HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r2193:7e0a20ef8117

optional series parameter to markers function. code style fixes

sauimone -

r2193:7e0a20ef8117

parent child

Context file:

r2193:7e0a20ef8117

Expand all files

src/legend/legendlayout.cpp +14 -14

             /****************************************************************************
             **
             ** 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 "legendlayout_p.h"
             #include "chartpresenter_p.h"
             #include "qlegend_p.h"
             #include "chartlayout_p.h"
             #include "qlegendmarker_p.h"
             #include "legendmarkeritem_p.h"
             #include "qlegendmarker.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             LegendLayout::LegendLayout(QLegend *legend)
                 : m_legend(legend)
             {
             }
             LegendLayout::~LegendLayout()
             {
             }
             void LegendLayout::setOffset(qreal x, qreal y)
             {
                 bool scrollHorizontal = true;
                 switch (m_legend->alignment()) {
                 case Qt::AlignTop:
                 case Qt::AlignBottom:
                     scrollHorizontal = true;
                     break;
                 case Qt::AlignLeft:
                 case Qt::AlignRight:
                     scrollHorizontal = false;
                     break;
                 }
                 // If detached, the scrolling direction is vertical instead of horizontal and vice versa.
                 if (!m_legend->isAttachedToChart())
                     scrollHorizontal = !scrollHorizontal;
                 QRectF boundingRect = geometry();
                 qreal left, top, right, bottom;
                 getContentsMargins(&left, &top, &right, &bottom);
                 boundingRect.adjust(left, top, -right, -bottom);
                 // Limit offset between m_minOffset and m_maxOffset
                 if (scrollHorizontal) {
                     if (m_width <= boundingRect.width())
                         return;
                     if (x != m_offsetX) {
                         m_offsetX = qBound(m_minOffsetX, x, m_maxOffsetX);
                         m_legend->d_ptr->items()->setPos(-m_offsetX, boundingRect.top());
                     }
                 } else {
                     if (m_height <= boundingRect.height())
                         return;
                     if (y != m_offsetY) {
                         m_offsetY = qBound(m_minOffsetY, y, m_maxOffsetY);
                         m_legend->d_ptr->items()->setPos(boundingRect.left(), -m_offsetY);
                     }
                 }
             }
             QPointF LegendLayout::offset() const
             {
                 return QPointF(m_offsetX, m_offsetY);
             }
             void LegendLayout::invalidate()
             {
                 QGraphicsLayout::invalidate();
                 if (m_legend->isAttachedToChart())
                     m_legend->d_ptr->m_presenter->layout()->invalidate();
             }
             void LegendLayout::setGeometry(const QRectF &rect)
             {
                 m_legend->d_ptr->items()->setVisible(m_legend->isVisible());
                 QGraphicsLayout::setGeometry(rect);
                 if (m_legend->isAttachedToChart())
                     setAttachedGeometry(rect);
                 else
                     setDettachedGeometry(rect);
             }
             void LegendLayout::setAttachedGeometry(const QRectF &rect)
             {
                 if (!rect.isValid())
                     return;
                 m_offsetX = 0;
                 m_offsetY = 0;
                 QSizeF size(0, 0);
                 if (m_legend->d_ptr->markers().isEmpty()) {
                     return;
                 }
                 m_width = 0;
                 m_height = 0;
                 qreal left, top, right, bottom;
                 getContentsMargins(&left, &top, &right, &bottom);
                 QRectF geometry = rect.adjusted(left, top, -right, -bottom);
                 switch(m_legend->alignment()) {
                 case Qt::AlignTop:
                 case Qt::AlignBottom: {
                         QPointF point(0,0);
-                        foreach (QLegendMarker* marker, m_legend->d_ptr->markers()) {
+                        foreach (QLegendMarker *marker, m_legend->d_ptr->markers()) {
-                            LegendMarkerItem* item = marker->d_ptr->item();
+                            LegendMarkerItem *item = marker->d_ptr->item();
                             if (item->isVisible()) {
                                 item->setGeometry(geometry);
                                 item->setPos(point.x(),geometry.height()/2 - item->boundingRect().height()/2);
-                                const QRectF& rect = item->boundingRect();
+                                const QRectF &rect = item->boundingRect();
                                 size = size.expandedTo(rect.size());
                                 qreal w = rect.width();
                                 m_width+=w;
                                 point.setX(point.x() + w);
                             }
                         }
                         if (m_width < geometry.width())
                             m_legend->d_ptr->items()->setPos(geometry.width() / 2 - m_width / 2, geometry.top());
                         else
                             m_legend->d_ptr->items()->setPos(geometry.topLeft());
                         m_height = size.height();
                     }
                     break;
                 case Qt::AlignLeft:
                 case Qt::AlignRight: {
                         QPointF point(0,0);
-                        foreach (QLegendMarker* marker, m_legend->d_ptr->markers()) {
+                        foreach (QLegendMarker *marker, m_legend->d_ptr->markers()) {
-                            LegendMarkerItem* item = marker->d_ptr->item();
+                            LegendMarkerItem *item = marker->d_ptr->item();
                             if (item->isVisible()) {
                                 item->setGeometry(geometry);
                                 item->setPos(point);
-                                const QRectF& rect = item->boundingRect();
+                                const QRectF &rect = item->boundingRect();
                                 qreal h = rect.height();
                                 size = size.expandedTo(rect.size());
                                 m_height+=h;
                                 point.setY(point.y() + h);
                             }
                         }
                         if (m_height < geometry.height())
                             m_legend->d_ptr->items()->setPos(geometry.left(), geometry.height() / 2 - m_height / 2);
                         else
                             m_legend->d_ptr->items()->setPos(geometry.topLeft());
                         m_width = size.width();
                         break;
                         }
                     }
                 m_minOffsetX = -left;
                 m_minOffsetY = - top;
                 m_maxOffsetX = m_width - geometry.width() - right;
                 m_maxOffsetY = m_height - geometry.height() - bottom;
             }
             void LegendLayout::setDettachedGeometry(const QRectF &rect)
             {
                 if (!rect.isValid())
                     return;
                 // Detached layout is different.
                 // In detached mode legend may have multiple rows and columns, so layout calculations
                 // differ a log from attached mode.
                 // Also the scrolling logic is bit different.
                 m_offsetX = 0;
                 m_offsetY = 0;
                 qreal left, top, right, bottom;
                 getContentsMargins(&left, &top, &right, &bottom);
                 QRectF geometry = rect.adjusted(left, top, -right, -bottom);
                 QSizeF size(0, 0);
                 QList<QLegendMarker *> markers = m_legend->d_ptr->markers();
                 if (markers.isEmpty())
                     return;
                 switch (m_legend->alignment()) {
                 case Qt::AlignTop: {
                     QPointF point(0, 0);
                     m_width = 0;
                     m_height = 0;
                     for (int i = 0; i < markers.count(); i++) {
                         LegendMarkerItem *item = markers.at(i)->d_ptr->item();
                         if (item->isVisible()) {
                             item->setGeometry(geometry);
                             item->setPos(point.x(),point.y());
-                            const QRectF& boundingRect = item->boundingRect();
+                            const QRectF &boundingRect = item->boundingRect();
                             qreal w = boundingRect.width();
                             qreal h = boundingRect.height();
                             m_width = qMax(m_width,w);
                             m_height = qMax(m_height,h);
                             point.setX(point.x() + w);
                             if (point.x() + w > geometry.left() + geometry.width() - right) {
                                 // Next item would go off rect.
                                 point.setX(0);
                                 point.setY(point.y() + h);
                                 if (i+1 < markers.count()) {
                                     m_height += h;
                                 }
                             }
                         }
                     }
                     m_legend->d_ptr->items()->setPos(geometry.topLeft());
                     m_minOffsetX = -left;
                     m_minOffsetY = -top;
                     m_maxOffsetX = m_width - geometry.width() - right;
                     m_maxOffsetY = m_height - geometry.height() - bottom;
                 }
                 break;
                 case Qt::AlignBottom: {
                     QPointF point(0, geometry.height());
                     m_width = 0;
                     m_height = 0;
                     for (int i = 0; i < markers.count(); i++) {
                         LegendMarkerItem *item = markers.at(i)->d_ptr->item();
                         if (item->isVisible()) {
                             item->setGeometry(geometry);
-                            const QRectF& boundingRect = item->boundingRect();
+                            const QRectF &boundingRect = item->boundingRect();
                             qreal w = boundingRect.width();
                             qreal h = boundingRect.height();
                             m_width = qMax(m_width,w);
                             m_height = qMax(m_height,h);
                             item->setPos(point.x(),point.y() - h);
                             point.setX(point.x() + w);
                             if (point.x() + w > geometry.left() + geometry.width() - right) {
                                 // Next item would go off rect.
                                 point.setX(0);
                                 point.setY(point.y() - h);
                                 if (i+1 < markers.count()) {
                                     m_height += h;
                                 }
                             }
                         }
                     }
                     m_legend->d_ptr->items()->setPos(geometry.topLeft());
                     m_minOffsetX = -left;
                     m_minOffsetY = -m_height + geometry.height() - top;
                     m_maxOffsetX = m_width - geometry.width() - right;
                     m_maxOffsetY = -bottom;
                 }
                 break;
                 case Qt::AlignLeft: {
                     QPointF point(0, 0);
                     m_width = 0;
                     m_height = 0;
                     qreal maxWidth = 0;
                     for (int i = 0; i < markers.count(); i++) {
                         LegendMarkerItem *item = markers.at(i)->d_ptr->item();
                         if (item->isVisible()) {
                             item->setGeometry(geometry);
-                            const QRectF& boundingRect = item->boundingRect();
+                            const QRectF &boundingRect = item->boundingRect();
                             qreal w = boundingRect.width();
                             qreal h = boundingRect.height();
                             m_height = qMax(m_height,h);
                             maxWidth = qMax(maxWidth,w);
                             item->setPos(point.x(),point.y());
                             point.setY(point.y() + h);
                             if (point.y() + h > geometry.bottom() - bottom) {
                                 // Next item would go off rect.
                                 point.setX(point.x() + maxWidth);
                                 point.setY(0);
                                 if (i+1 < markers.count()) {
                                     m_width += maxWidth;
                                     maxWidth = 0;
                                 }
                             }
                         }
                     }
                     m_width += maxWidth;
                     m_legend->d_ptr->items()->setPos(geometry.topLeft());
                     m_minOffsetX = -left;
                     m_minOffsetY = -top;
                     m_maxOffsetX = m_width - geometry.width() - right;
                     m_maxOffsetY = m_height - geometry.height() - bottom;
                 }
                 break;
                 case Qt::AlignRight: {
                     QPointF point(geometry.width(), 0);
                     m_width = 0;
                     m_height = 0;
                     qreal maxWidth = 0;
                     for (int i = 0; i < markers.count(); i++) {
                         LegendMarkerItem *item = markers.at(i)->d_ptr->item();
                         if (item->isVisible()) {
                             item->setGeometry(geometry);
-                            const QRectF& boundingRect = item->boundingRect();
+                            const QRectF &boundingRect = item->boundingRect();
                             qreal w = boundingRect.width();
                             qreal h = boundingRect.height();
                             m_height = qMax(m_height,h);
                             maxWidth = qMax(maxWidth,w);
                             item->setPos(point.x() - w,point.y());
                             point.setY(point.y() + h);
                             if (point.y() + h > geometry.bottom()-bottom) {
                                 // Next item would go off rect.
                                 point.setX(point.x() - maxWidth);
                                 point.setY(0);
                                 if (i+1 < markers.count()) {
                                     m_width += maxWidth;
                                     maxWidth = 0;
                                 }
                             }
                         }
                     }
                     m_width += maxWidth;
                     m_legend->d_ptr->items()->setPos(geometry.topLeft());
                     m_minOffsetX = - m_width + geometry.width() - left;
                     m_minOffsetY = -top;
                     m_maxOffsetX = - right;
                     m_maxOffsetY = m_height - geometry.height() - bottom;
                 }
                 break;
                 default:
                     break;
                 }
             }
             QSizeF LegendLayout::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
             {
                 QSizeF size(0, 0);
                 qreal left, top, right, bottom;
                 getContentsMargins(&left, &top, &right, &bottom);
                 if(constraint.isValid()) {
-                    foreach(QLegendMarker* marker, m_legend->d_ptr->markers()) {
+                    foreach(QLegendMarker *marker, m_legend->d_ptr->markers()) {
                         LegendMarkerItem *item = marker->d_ptr->item();
                         size = size.expandedTo(item->effectiveSizeHint(which));
                     }
                     size = size.boundedTo(constraint);
                 }
                 else if (constraint.width() >= 0) {
                     qreal width = 0;
                     qreal height = 0;
-                    foreach(QLegendMarker* marker, m_legend->d_ptr->markers()) {
+                    foreach(QLegendMarker *marker, m_legend->d_ptr->markers()) {
                         LegendMarkerItem *item = marker->d_ptr->item();
                         width+=item->effectiveSizeHint(which).width();
                         height=qMax(height,item->effectiveSizeHint(which).height());
                     }
                     size = QSizeF(qMin(constraint.width(),width), height);
                 }
                 else if (constraint.height() >= 0) {
                     qreal width = 0;
                     qreal height = 0;
-                    foreach(QLegendMarker* marker, m_legend->d_ptr->markers()) {
+                    foreach(QLegendMarker *marker, m_legend->d_ptr->markers()) {
                         LegendMarkerItem *item = marker->d_ptr->item();
                         width=qMax(width,item->effectiveSizeHint(which).width());
                         height+=height,item->effectiveSizeHint(which).height();
                     }
                     size = QSizeF(width,qMin(constraint.height(),height));
                 }
                 else {
-                    foreach(QLegendMarker* marker, m_legend->d_ptr->markers()) {
+                    foreach(QLegendMarker *marker, m_legend->d_ptr->markers()) {
                         LegendMarkerItem *item = marker->d_ptr->item();
                         size = size.expandedTo(item->effectiveSizeHint(which));
                     }
                 }
                 size += QSize(left + right, top + bottom);
                 return size;
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/legend/legendmarkeritem.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 <QPainter>
             #include <QGraphicsSceneEvent>
             #include <QGraphicsSimpleTextItem>
             #include "qlegend.h"
             #include "qlegend_p.h"
             #include "qlegendmarker.h"
             #include "qlegendmarker_p.h"
             #include "legendmarkeritem_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             LegendMarkerItem::LegendMarkerItem(QLegendMarkerPrivate *marker, QGraphicsObject *parent) :
                 QGraphicsObject(parent),
                 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),
                 m_pressPos(0, 0)
             {
                 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_label = label;
                 updateGeometry();
             }
             QString LegendMarkerItem::label() const
             {
                 return m_label;
             }
             void LegendMarkerItem::setLabelBrush(const QBrush &brush)
             {
                 m_textItem->setBrush(brush);
             }
             QBrush LegendMarkerItem::labelBrush() const
             {
                 return m_textItem->brush();
             }
-            void LegendMarkerItem::setGeometry(const QRectF& rect)
+            void LegendMarkerItem::setGeometry(const QRectF &rect)
             {
                 QFontMetrics fn (m_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_label).width() + x > width)
                 {
                     QString string = m_label + "...";
                     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_label);
-                const QRectF& textRect = m_textItem->boundingRect();
+                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);
             }
             QRectF LegendMarkerItem::boundingRect() const
             {
                 return m_boundingRect;
             }
             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_label).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)
             {
                 MouseEventHandler::handleMousePressEvent(event);
                 m_pressPos = event->screenPos();
             }
             void LegendMarkerItem::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
             {
                 MouseEventHandler::handleMouseMoveEvent(event);
             }
             void LegendMarkerItem::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
             {
                 MouseEventHandler::handleMouseReleaseEvent(event);
             }
             void LegendMarkerItem::mouseClicked()
             {
                 emit m_marker->q_func()->clicked();
             }
             void LegendMarkerItem::mouseMoved(const QPointF &delta)
             {
                 m_marker->m_legend->d_ptr->move(delta);
             }
             void LegendMarkerItem::mouseReleased(const QPointF &pos)
             {
                 m_marker->m_legend->d_ptr->release(pos - m_pressPos);
             }
             #include "moc_legendmarkeritem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/legend/legendmarkeritem_p.h +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$
             **
             ****************************************************************************/
             //  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 <QFont>
             #include <QBrush>
             #include <QPen>
             #include <QGraphicsSimpleTextItem>
             #include <QGraphicsLayoutItem>
             #include "mouseeventhandler_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QLegendMarkerPrivate;
             class LegendMarkerItem : public QGraphicsObject, public QGraphicsLayoutItem, public MouseEventHandler
             {
                 Q_OBJECT
                 Q_INTERFACES(QGraphicsLayoutItem)
             public:
                 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;
-                void setGeometry(const QRectF& rect);
+                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;
+                QSizeF sizeHint (Qt::SizeHint which, const QSizeF &constraint) const;
                 // Event handlers, logic delegated to MouseEventHandler
                 void mousePressEvent(QGraphicsSceneMouseEvent *event);
                 void mouseMoveEvent(QGraphicsSceneMouseEvent *event);
                 void mouseReleaseEvent(QGraphicsSceneMouseEvent *event);
                 // Filtered callbacks from MouseEventHandler
                 void mouseClicked();
                 void mouseMoved(const QPointF &delta);
                 void mouseReleased(const QPointF &pos);
             protected:
                 QLegendMarkerPrivate *m_marker; // Knows
                 QRectF m_markerRect;
                 QRectF m_boundingRect;
                 QGraphicsSimpleTextItem *m_textItem;
                 QGraphicsRectItem *m_rectItem;
                 qreal m_margin;
                 qreal m_space;
                 QString m_label;
                 QBrush m_labelBrush;
                 QFont m_font;
                 QPen m_pen;
                 QBrush m_brush;
                 bool m_visible;
                 QPointF m_pressPos;
                 friend class QLegendMarker;
                 friend class QLegendMarkerPrivate;
                 friend class LegendMarkerItem;
                 friend class LegendLayout;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // LEGENDMARKERITEM_P_H

src/legend/mouseeventhandler.cpp +3 -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 "mouseeventhandler_p.h"
             #include <QGraphicsSceneMouseEvent>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             MouseEventHandler::MouseEventHandler() :
                 m_lastPos(0, 0),
                 m_state(Idle),
                 m_treshold(10)
             {
             }
             MouseEventHandler::~MouseEventHandler()
             {
             }
             void MouseEventHandler::setMoveTreshold(qreal treshold)
             {
                 m_treshold = treshold;
             }
-            void MouseEventHandler::handleMousePressEvent(QGraphicsSceneMouseEvent* event)
+            void MouseEventHandler::handleMousePressEvent(QGraphicsSceneMouseEvent *event)
             {
                 m_lastPos = event->screenPos();
                 m_state = Pressed;
                 event->accept();
             }
-            void MouseEventHandler::handleMouseMoveEvent(QGraphicsSceneMouseEvent* event)
+            void MouseEventHandler::handleMouseMoveEvent(QGraphicsSceneMouseEvent *event)
             {
                 QPointF delta = event->screenPos() - m_lastPos;
                 switch (m_state) {
                 case Pressed: {
                     // calculate treshold. If enough, change to move state and send out move deltas.
                     if (qAbs(delta.x()) > m_treshold || qAbs(delta.y()) > m_treshold) {
                         m_state = Moved;
                         m_lastPos = event->screenPos();
                         mouseMoved(delta);
                     }
                     event->accept();
                     break;
                 }
                 case Moved: {
                     m_lastPos = event->screenPos();
                     mouseMoved(delta);
                     event->accept();
                     break;
                 }
                 case Idle:
                 default: {
                     event->ignore();
                     break;
                 }
                 }
             }
-            void MouseEventHandler::handleMouseReleaseEvent(QGraphicsSceneMouseEvent* event)
+            void MouseEventHandler::handleMouseReleaseEvent(QGraphicsSceneMouseEvent *event)
             {
                 m_lastPos = event->screenPos();
                 switch (m_state) {
                 case Pressed:
                 {
                     m_state = Idle;
                     mouseClicked();
                     event->accept();
                     break;
                 }
                 case Moved:
                 {
                     m_state = Idle;
                     mouseReleased(m_lastPos);
                     event->accept();
                     break;
                 }
                 default:
                 {
                     m_state = Idle;
                     event->ignore();
                     break;
                 }
                 }
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/legend/mouseeventhandler_p.h +3 -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.
             /*
                 Purpose of this class is to resolve what happens during MousePress - MouseMove - MouseRelease event chain.
                 Threre can be many MouseMove events and if they all are below our treshold, the result is clicked call.
                 If any move event goes over treshold, result will be many moved(QPointF delta) calls,
                 where delta is calculated from original position.
                 Reason for this is, that legend marker don't know when it should emit clicked and when it should
                 allow legend to scroll. We only get this information when some move goes beyond treshold, but
                 then it will be too late to let the scroller handle events, because marker is already handling.
                 By handling clicked calls in markers and moved calls in scroller, the problem is solved.
                 Derived class descides, should the virtual method be implemented as signal or not.
                 This could be implemented in LegendMarkerItem, but this way the code is reusable and in one place only.
             */
             #ifndef MOUSEEVENTHANDLER_H
             #define MOUSEEVENTHANDLER_H
             #include "qchartglobal.h"
             #include <QBasicTimer>
             #include <QTime>
             #include <QPointF>
             class QGraphicsSceneMouseEvent;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class MouseEventHandler
             {
             public:
                 enum State {
                     Idle,
                     Pressed,
                     Moved,
                     Released
                 };
                 MouseEventHandler();
                 virtual ~MouseEventHandler();
                 void setMoveTreshold(qreal treshold);
                 virtual void mouseClicked() = 0;
                 virtual void mouseMoved(const QPointF &delta) = 0;
                 virtual void mouseReleased(const QPointF &pos) = 0;
-                void handleMousePressEvent(QGraphicsSceneMouseEvent* event);
+                void handleMousePressEvent(QGraphicsSceneMouseEvent *event);
-                void handleMouseMoveEvent(QGraphicsSceneMouseEvent* event);
+                void handleMouseMoveEvent(QGraphicsSceneMouseEvent *event);
-                void handleMouseReleaseEvent(QGraphicsSceneMouseEvent* event);
+                void handleMouseReleaseEvent(QGraphicsSceneMouseEvent *event);
             private:
                 QPointF m_lastPos;
                 State m_state;
                 qreal m_treshold;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // MOUSEEVENTHANDLER_H

src/legend/qarealegendmarker.cpp +1 -1

             /****************************************************************************
             **
             ** 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 "qarealegendmarker.h"
             #include "qarealegendmarker_p.h"
             #include "qareaseries_p.h"
             #include <QAreaSeries>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            QAreaLegendMarker::QAreaLegendMarker(QAreaSeries* series, QLegend *legend, QObject *parent) :
+            QAreaLegendMarker::QAreaLegendMarker(QAreaSeries *series, QLegend *legend, QObject *parent) :
                 QLegendMarker(*new QAreaLegendMarkerPrivate(this,series,legend), parent)
             {
             }
             QAreaLegendMarker::~QAreaLegendMarker()
             {
             }
             /*!
                 \internal
             */
             QAreaLegendMarker::QAreaLegendMarker(QAreaLegendMarkerPrivate &d, QObject *parent) :
                 QLegendMarker(d, parent)
             {
             }
             QAreaSeries* QAreaLegendMarker::series()
             {
                 Q_D(QAreaLegendMarker);
                 return d->m_series;
             }
             ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QAreaLegendMarkerPrivate::QAreaLegendMarkerPrivate(QAreaLegendMarker *q, QAreaSeries *series, QLegend *legend) :
                 QLegendMarkerPrivate(q,legend),
                 m_series(series)
             {
                 QObject::connect(m_series->d_func(),SIGNAL(updated()), this, SLOT(updated()));
                 QObject::connect(m_series, SIGNAL(nameChanged()), this, SLOT(updated()));
                 updated();
             }
             QAreaLegendMarkerPrivate::~QAreaLegendMarkerPrivate()
             {
             }
             QAreaSeries* QAreaLegendMarkerPrivate::series()
             {
                 return m_series;
             }
             QObject* QAreaLegendMarkerPrivate::relatedObject()
             {
                 return m_series;
             }
             void QAreaLegendMarkerPrivate::updated()
             {
                 m_item->setBrush(m_series->brush());
                 m_item->setLabel(m_series->name());
             }
             #include "moc_qarealegendmarker.cpp"
             #include "moc_qarealegendmarker_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/legend/qarealegendmarker.h +1 -1

             /****************************************************************************
             **
             ** 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 QAREALEGENDMARKER_H
             #define QAREALEGENDMARKER_H
             #include <QChartGlobal>
             #include <QLegendMarker>
             #include <QAreaSeries>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QAreaLegendMarkerPrivate;
             class QTCOMMERCIALCHART_EXPORT QAreaLegendMarker : public QLegendMarker
             {
                 Q_OBJECT
             public:
-                explicit QAreaLegendMarker(QAreaSeries* series, QLegend *legend, QObject *parent = 0);
+                explicit QAreaLegendMarker(QAreaSeries *series, QLegend *legend, QObject *parent = 0);
                 virtual ~QAreaLegendMarker();
                 virtual LegendMarkerType type() { return LegendMarkerTypeArea; }
                 // Related series
                 virtual QAreaSeries* series();
             protected:
                 QAreaLegendMarker(QAreaLegendMarkerPrivate &d, QObject *parent = 0);
             private:
                 Q_DECLARE_PRIVATE(QAreaLegendMarker)
                 Q_DISABLE_COPY(QAreaLegendMarker)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QAREALEGENDMARKER_H

src/legend/qarealegendmarker_p.h +1 -1

             /****************************************************************************
             **
             ** 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 QAREALEGENDMARKER_P_H
             #define QAREALEGENDMARKER_P_H
             #include "qchartglobal.h"
             #include "qlegendmarker_p.h"
             #include "legendmarkeritem_p.h"
             #include <QAreaSeries>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QAreaLegendMarker;
             class QAreaLegendMarkerPrivate : public QLegendMarkerPrivate
             {
                 Q_OBJECT
             public:
                 explicit QAreaLegendMarkerPrivate(QAreaLegendMarker *q, QAreaSeries *series, QLegend *legend);
                 virtual ~QAreaLegendMarkerPrivate();
                 virtual QAreaSeries* series();
                 virtual QObject* relatedObject();
             public Q_SLOTS:
                 virtual void updated();
             private:
                 QAreaLegendMarker *q_ptr;
-                QAreaSeries* m_series;
+                QAreaSeries *m_series;
                 Q_DECLARE_PUBLIC(QAreaLegendMarker)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QAREALEGENDMARKER_P_H

src/legend/qbarlegendmarker.cpp +1 -1

             /****************************************************************************
             **
             ** 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 "qbarlegendmarker.h"
             #include "qbarlegendmarker_p.h"
             #include <QAbstractBarSeries>
             #include <QBarSet>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            QBarLegendMarker::QBarLegendMarker(QAbstractBarSeries* series, QBarSet* barset, QLegend *legend, QObject *parent) :
+            QBarLegendMarker::QBarLegendMarker(QAbstractBarSeries *series, QBarSet *barset, QLegend *legend, QObject *parent) :
                 QLegendMarker(*new QBarLegendMarkerPrivate(this,series,barset,legend), parent)
             {
             }
             QBarLegendMarker::~QBarLegendMarker()
             {
             }
             /*!
                 \internal
             */
             QBarLegendMarker::QBarLegendMarker(QBarLegendMarkerPrivate &d, QObject *parent) :
                 QLegendMarker(d, parent)
             {
             }
             QAbstractBarSeries *QBarLegendMarker::series()
             {
                 Q_D(QBarLegendMarker);
                 return d->m_series;
             }
             QBarSet* QBarLegendMarker::barset()
             {
                 Q_D(QBarLegendMarker);
                 return d->m_barset;
             }
             ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QBarLegendMarkerPrivate::QBarLegendMarkerPrivate(QBarLegendMarker *q, QAbstractBarSeries *series, QBarSet *barset, QLegend *legend) :
                 QLegendMarkerPrivate(q,legend),
                 m_series(series),
                 m_barset(barset)
             {
                 QObject::connect(m_barset, SIGNAL(penChanged()), this, SLOT(updated()));
                 QObject::connect(m_barset, SIGNAL(labelChanged()), this, SLOT(updated()));
                 QObject::connect(m_barset, SIGNAL(brushChanged()), this, SLOT(updated()));
                 updated();
             }
             QBarLegendMarkerPrivate::~QBarLegendMarkerPrivate()
             {
             }
             QAbstractBarSeries* QBarLegendMarkerPrivate::series()
             {
                 return m_series;
             }
             QObject* QBarLegendMarkerPrivate::relatedObject()
             {
                 return m_barset;
             }
             void QBarLegendMarkerPrivate::updated()
             {
                 m_item->setPen(m_barset->pen());
                 m_item->setBrush(m_barset->brush());
                 m_item->setLabel(m_barset->label());
             }
             #include "moc_qbarlegendmarker.cpp"
             #include "moc_qbarlegendmarker_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/legend/qbarlegendmarker.h +1 -1

             /****************************************************************************
             **
             ** 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 QBARLEGENDMARKER_H
             #define QBARLEGENDMARKER_H
             #include <QChartGlobal>
             #include <QLegendMarker>
             #include <QAbstractBarSeries>
             #include <QBarSet>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QLegend;
             class QBarLegendMarkerPrivate;
             class QTCOMMERCIALCHART_EXPORT QBarLegendMarker : public QLegendMarker
             {
                 Q_OBJECT
             public:
-                explicit QBarLegendMarker(QAbstractBarSeries* series, QBarSet* barset, QLegend *legend, QObject *parent = 0);
+                explicit QBarLegendMarker(QAbstractBarSeries *series, QBarSet *barset, QLegend *legend, QObject *parent = 0);
                 virtual ~QBarLegendMarker();
                 virtual LegendMarkerType type() { return LegendMarkerTypeBar; }
                 // Related series and barset
                 virtual QAbstractBarSeries* series();
                 QBarSet* barset();
             protected:
                 QBarLegendMarker(QBarLegendMarkerPrivate &d, QObject *parent = 0);
             private:
                 Q_DECLARE_PRIVATE(QBarLegendMarker)
                 Q_DISABLE_COPY(QBarLegendMarker)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QBARLEGENDMARKER_H

src/legend/qbarlegendmarker_p.h +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$
             **
             ****************************************************************************/
             //  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 QBARLEGENDMARKER_P_H
             #define QBARLEGENDMARKER_P_H
             #include "qchartglobal.h"
             #include "qlegendmarker_p.h"
             #include "legendmarkeritem_p.h"
             #include <QAbstractBarSeries>
             #include <QBarSet>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QBarLegendMarker;
             class QBarLegendMarkerPrivate : public QLegendMarkerPrivate
             {
                 Q_OBJECT
             public:
                 explicit QBarLegendMarkerPrivate(QBarLegendMarker *q, QAbstractBarSeries *series, QBarSet *barset, QLegend *legend);
                 virtual ~QBarLegendMarkerPrivate();
                 virtual QAbstractBarSeries* series();
                 virtual QObject* relatedObject();
             public Q_SLOTS:
                 virtual void updated();
             private:
                 QBarLegendMarker *q_ptr;
-                QAbstractBarSeries* m_series;
+                QAbstractBarSeries *m_series;
-                QBarSet* m_barset;
+                QBarSet *m_barset;
                 Q_DECLARE_PUBLIC(QBarLegendMarker)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QBARLEGENDMARKER_P_H

src/legend/qlegend.cpp +29 -27

             /****************************************************************************
              **
              ** 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 "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 <QGraphicsItemGroup>
             #include "qlegendmarker.h"
             #include "qlegendmarker_p.h"
             #include "legendmarkeritem_p.h"
+            #include <QPainter>
+            #include <QPen>
+            #include <QGraphicsItemGroup>
             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*)));
                 QObject::connect(chart->d_ptr->m_dataset, SIGNAL(seriesRemoved(QAbstractSeries*)), d_ptr.data(), SLOT(handleSeriesRemoved(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 (QLegendMarker *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 (QLegendMarker *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
+            QList<QLegendMarker*> QLegend::markers(QAbstractSeries *series) const
             {
-                return d_ptr->markers();
+                return d_ptr->markers(series);
             }
-            void QLegend::addSeries(QAbstractSeries* series)
+            void QLegend::addSeries(QAbstractSeries *series)
             {
                 d_ptr->addSeries(series);
             }
-            void QLegend::removeSeries(QAbstractSeries* 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)
             {
                 m_items->setHandlesChildEvents(false);
             }
             QLegendPrivate::~QLegendPrivate()
             {
             }
             void QLegendPrivate::setOffset(const QPointF &offset)
             {
                 m_layout->setOffset(offset.x(), offset.y());
             }
             QPointF QLegendPrivate::offset() const
             {
                 return m_layout->offset();
             }
             int QLegendPrivate::roundness(qreal size)
             {
                 return 100 * m_diameter / int(size);
             }
-            void QLegendPrivate::addSeries(QAbstractSeries* series)
+            QList<QLegendMarker*> QLegendPrivate::markers(QAbstractSeries *series)
+            {
+                // Return all markers
+                if (!series) {
+                    return m_markers;
+                }
+                // Create filtered list
+                QList<QLegendMarker *> markers;
+                foreach (QLegendMarker *marker, m_markers) {
+                    if (marker->series() == series) {
+                        markers.append(marker);
+                    }
+                }
+                return markers;
+            }
+            void QLegendPrivate::addSeries(QAbstractSeries *series)
             {
                 // Only allow one instance of series
                 if (m_series.contains(series)) {
                     return;
                 }
                 QList<QLegendMarker*> newMarkers = series->d_ptr->createLegendMarkers(q_ptr);
                 decorateMarkers(newMarkers);
                 addMarkers(newMarkers);
                 QObject::connect(series->d_ptr.data(), SIGNAL(countChanged()), this, SLOT(handleCountChanged()));
                 QObject::connect(series, SIGNAL(visibleChanged()), this, SLOT(handleSeriesVisibleChanged()));
                 m_series.append(series);
                 m_items->setVisible(false);
                 m_layout->invalidate();
             }
-            void QLegendPrivate::removeSeries(QAbstractSeries* series)
+            void QLegendPrivate::removeSeries(QAbstractSeries *series)
             {
                 if (m_series.contains(series)) {
                     m_series.removeOne(series);
                 }
                 // Find out, which markers to remove
                 QList<QLegendMarker *> removed;
                 foreach (QLegendMarker *m, m_markers) {
                     if (m->series() == series) {
                         removed << m;
                     }
                 }
                 removeMarkers(removed);
                 QObject::disconnect(series->d_ptr.data(), SIGNAL(countChanged()), this, SLOT(handleCountChanged()));
                 QObject::disconnect(series, SIGNAL(visibleChanged()), this, SLOT(handleSeriesVisibleChanged()));
                 m_layout->invalidate();
             }
             void QLegendPrivate::handleSeriesAdded(QAbstractSeries *series)
             {
                 // Moved to appendSeries
                 // This slot is just to make old code work for now.
                 addSeries(series);
             }
             void QLegendPrivate::handleSeriesRemoved(QAbstractSeries *series)
             {
                 // Moved to removeSeries
                 // This slot is just to make old code work for now.
                 removeSeries(series);
             }
             void QLegendPrivate::handleSeriesVisibleChanged()
             {
                 QAbstractSeries *series = qobject_cast<QAbstractSeries *> (sender());
                 Q_ASSERT(series);
-                foreach (QLegendMarker* marker, m_markers) {
+                foreach (QLegendMarker *marker, m_markers) {
                     if (marker->series() == series) {
                         marker->setVisible(series->isVisible());
                     }
                 }
                 m_layout->invalidate();
             }
             void QLegendPrivate::handleCountChanged()
             {
                 // Here we handle the changes in marker count.
                 // Can happen for example when pieslice(s) have been added to or removed from pieseries.
                 QAbstractSeriesPrivate *series = qobject_cast<QAbstractSeriesPrivate *> (sender());
                 QList<QLegendMarker *> createdMarkers = series->createLegendMarkers(q_ptr);
                 // Find out removed markers and created markers
                 QList<QLegendMarker *> removedMarkers;
                 foreach (QLegendMarker *oldMarker, m_markers) {
                     // we have marker, which is related to sender.
                     if (oldMarker->series() == series->q_ptr) {
                         bool found = false;
                         foreach(QLegendMarker *newMarker, createdMarkers) {
                             // New marker considered existing if:
                             // - d_ptr->relatedObject() is same for both markers.
                             if (newMarker->d_ptr->relatedObject() == oldMarker->d_ptr->relatedObject()) {
                                 // Delete the new marker, since we already have existing marker, that might be connected on user side.
                                 found = true;
                                 createdMarkers.removeOne(newMarker);
                                 delete newMarker;
                             }
                         }
                         if (!found) {
                             // No related object found for marker, add to removedMarkers list
                             removedMarkers << oldMarker;
                         }
                     }
                 }
                 removeMarkers(removedMarkers);
                 decorateMarkers(createdMarkers);
                 addMarkers(createdMarkers);
                 q_ptr->layout()->invalidate();
             }
             void QLegendPrivate::addMarkers(QList<QLegendMarker *> markers)
             {
-                foreach (QLegendMarker* marker, markers) {
+                foreach (QLegendMarker *marker, markers) {
                     m_items->addToGroup(marker->d_ptr.data()->item());
                     m_markers << marker;
                 }
             }
             void QLegendPrivate::removeMarkers(QList<QLegendMarker *> markers)
             {
                 foreach (QLegendMarker *marker, markers) {
                     marker->d_ptr->item()->setVisible(false);
                     m_items->removeFromGroup(marker->d_ptr->item());
                     delete marker;
                     m_markers.removeOne(marker);
                 }
             }
             void QLegendPrivate::decorateMarkers(QList<QLegendMarker *> markers)
             {
-                foreach (QLegendMarker* marker, markers) {
+                foreach (QLegendMarker *marker, markers) {
                     marker->setFont(m_font);
                     marker->setLabelBrush(m_labelBrush);
                 }
             }
             #include "moc_qlegend.cpp"
             #include "moc_qlegend_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/legend/qlegend.h +3 -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$
             **
             ****************************************************************************/
             #ifndef QLEGEND_H
             #define QLEGEND_H
             #include <qchartglobal.h>
             #include <QGraphicsWidget>
             #include <QPen>
             #include <QBrush>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             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;
+                QList <QLegendMarker*> markers(QAbstractSeries *series = 0) const;
-                void addSeries(QAbstractSeries* series);
+                void addSeries(QAbstractSeries *series);
-                void removeSeries(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;
                 friend class LegendMarkerItem;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QLEGEND_H

src/legend/qlegend_p.h +8 -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$
             **
             ****************************************************************************/
             //  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"
             #include "scroller_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QChart;
             class ChartPresenter;
             class QAbstractSeries;
             class LegendLayout;
             class Domain;
             class QLegendMarker;
             class QLegendPrivate : public QObject, public Scroller
             {
                 Q_OBJECT
             public:
                 QLegendPrivate(ChartPresenter *presenter, QChart *chart, QLegend *q);
                 ~QLegendPrivate();
                 void setOffset(const QPointF &offset);
                 QPointF offset() const;
                 int roundness(qreal size);
                 QGraphicsItemGroup* items() { return m_items; }
-                // New stuff:
+                QList<QLegendMarker*> markers(QAbstractSeries *series = 0);
-                QList<QLegendMarker*> markers() { return m_markers; }
+                void addSeries(QAbstractSeries *series);
-                void addSeries(QAbstractSeries* series);
+                void removeSeries(QAbstractSeries *series);
-                void removeSeries(QAbstractSeries* series);
             public Q_SLOTS:
                 void handleSeriesAdded(QAbstractSeries *series);
                 void handleSeriesRemoved(QAbstractSeries *series);
                 void handleSeriesVisibleChanged();
                 void handleCountChanged();
             private:
                 // Internal helpers
                 void addMarkers(QList<QLegendMarker *> markers);
                 void removeMarkers(QList<QLegendMarker *> markers);
                 void decorateMarkers(QList<QLegendMarker *> markers);
             private:
                 QLegend *q_ptr;
                 ChartPresenter *m_presenter;
                 LegendLayout *m_layout;
-                QChart* m_chart;
+                QChart *m_chart;
-                QGraphicsItemGroup* m_items;
+                QGraphicsItemGroup *m_items;
                 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;
+                QList<QLegendMarker *> m_markers;
-                friend class LegendLayout;
+                QList<QAbstractSeries *> m_series;
-                QList<QLegendMarker*> m_markers;
-                QList<QAbstractSeries*> m_series;
                 friend class QLegend;
                 friend class LegendMarkerItem;
+                friend class LegendLayout;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/legend/qlegendmarker_p.h +1 -1

             /****************************************************************************
             **
             ** 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>
             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(QLegendMarker *q, QLegend *legend);
                 virtual ~QLegendMarkerPrivate();
                 // Helper for now. (or declare LegendLayout as friend)
                 LegendMarkerItem* item() const { return m_item; }
                 virtual QAbstractSeries* series() = 0;
                 virtual QObject* relatedObject() = 0;
             public Q_SLOTS:
                 virtual void updated() {};
             protected:
                 LegendMarkerItem *m_item;
-                QLegend* m_legend;
+                QLegend *m_legend;
             private:
                 QLegendMarker *q_ptr;
                 friend class QLegendPrivate;
                 friend class LegendMarkerItem;
                 Q_DECLARE_PUBLIC(QLegendMarker)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QLEGENDMARKERPRIVATE_H

src/legend/qpielegendmarker.cpp +1 -1

             /****************************************************************************
             **
             ** 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 <QPieSlice>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            QPieLegendMarker::QPieLegendMarker(QPieSeries* series, QPieSlice* slice, QLegend *legend, QObject *parent) :
+            QPieLegendMarker::QPieLegendMarker(QPieSeries *series, QPieSlice *slice, QLegend *legend, QObject *parent) :
                 QLegendMarker(*new QPieLegendMarkerPrivate(this,series,slice,legend), parent)
             {
             }
             QPieLegendMarker::~QPieLegendMarker()
             {
             }
             /*!
                 \internal
             */
             QPieLegendMarker::QPieLegendMarker(QPieLegendMarkerPrivate &d, QObject *parent) :
                 QLegendMarker(d, parent)
             {
             }
             QPieSeries* QPieLegendMarker::series()
             {
                 Q_D(QPieLegendMarker);
                 return d->m_series;
             }
             QPieSlice* QPieLegendMarker::slice()
             {
                 Q_D(QPieLegendMarker);
                 return d->m_slice;
             }
             ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QPieLegendMarkerPrivate::QPieLegendMarkerPrivate(QPieLegendMarker *q, QPieSeries *series, QPieSlice *slice, QLegend *legend) :
                 QLegendMarkerPrivate(q,legend),
                 m_series(series),
                 m_slice(slice)
             {
                 QObject::connect(m_slice, SIGNAL(labelChanged()), this, SLOT(updated()));
                 QObject::connect(m_slice, SIGNAL(brushChanged()), this, SLOT(updated()));
                 QObject::connect(m_slice, SIGNAL(penChanged()), this, SLOT(updated()));
                 updated();
             }
             QPieLegendMarkerPrivate::~QPieLegendMarkerPrivate()
             {
             }
             QPieSeries* QPieLegendMarkerPrivate::series()
             {
                 return m_series;
             }
             QObject* QPieLegendMarkerPrivate::relatedObject()
             {
                 return m_slice;
             }
             void QPieLegendMarkerPrivate::updated()
             {
                 m_item->setPen(m_slice->pen());
                 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 +1 -1

             /****************************************************************************
             **
             ** 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 <QPieSeries>
             #include <QPieSlice>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QPieLegendMarkerPrivate;
             class QTCOMMERCIALCHART_EXPORT QPieLegendMarker : public QLegendMarker
             {
                 Q_OBJECT
             public:
-                explicit QPieLegendMarker(QPieSeries* series, QPieSlice* slice, QLegend *legend, QObject *parent = 0);
+                explicit QPieLegendMarker(QPieSeries *series, QPieSlice *slice, QLegend *legend, QObject *parent = 0);
                 virtual ~QPieLegendMarker();
                 virtual LegendMarkerType type() { return LegendMarkerTypePie; }
                 // Related series and slice
                 virtual QPieSeries* series();
                 QPieSlice* slice();
             protected:
                 QPieLegendMarker(QPieLegendMarkerPrivate &d, QObject *parent = 0);
             private:
                 Q_DECLARE_PRIVATE(QPieLegendMarker)
                 Q_DISABLE_COPY(QPieLegendMarker)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QPIELEGENDMARKER_H

src/legend/qpielegendmarker_p.h +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$
             **
             ****************************************************************************/
             //  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>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QPieLegendMarker;
             class QPieLegendMarkerPrivate : public QLegendMarkerPrivate
             {
                 Q_OBJECT
             public:
                 explicit QPieLegendMarkerPrivate(QPieLegendMarker *q, QPieSeries *series, QPieSlice *slice, QLegend *legend);
                 virtual ~QPieLegendMarkerPrivate();
                 // internal
                 virtual QPieSeries* series();
                 virtual QObject* relatedObject();
             public Q_SLOTS:
                 virtual void updated();
             private:
                 QPieLegendMarker *q_ptr;
-                QPieSeries* m_series;
+                QPieSeries *m_series;
-                QPieSlice* m_slice;
+                QPieSlice *m_slice;
                 Q_DECLARE_PUBLIC(QPieLegendMarker)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QPIELEGENDMARKER_P_H

src/legend/qxylegendmarker.cpp +1 -1

             /****************************************************************************
             **
             ** 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 "qxylegendmarker.h"
             #include "qxylegendmarker_p.h"
             #include "qxyseries_p.h"
             #include <QXYSeries>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            QXYLegendMarker::QXYLegendMarker(QXYSeries* series, QLegend *legend, QObject *parent) :
+            QXYLegendMarker::QXYLegendMarker(QXYSeries *series, QLegend *legend, QObject *parent) :
                 QLegendMarker(*new QXYLegendMarkerPrivate(this,series,legend), parent)
             {
             }
             QXYLegendMarker::~QXYLegendMarker()
             {
             }
             /*!
                 \internal
             */
             QXYLegendMarker::QXYLegendMarker(QXYLegendMarkerPrivate &d, QObject *parent) :
                 QLegendMarker(d, parent)
             {
             }
             QXYSeries* QXYLegendMarker::series()
             {
                 Q_D(QXYLegendMarker);
                 return d->m_series;
             }
             ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QXYLegendMarkerPrivate::QXYLegendMarkerPrivate(QXYLegendMarker *q, QXYSeries *series, QLegend *legend) :
                 QLegendMarkerPrivate(q,legend),
                 m_series(series)
             {
                 QObject::connect(m_series, SIGNAL(nameChanged()), this, SLOT(updated()));
                 QObject::connect(m_series->d_func(), SIGNAL(updated()), this, SLOT(updated()));
                 updated();
             }
             QXYLegendMarkerPrivate::~QXYLegendMarkerPrivate()
             {
             }
             QAbstractSeries* QXYLegendMarkerPrivate::series()
             {
                 return m_series;
             }
             QObject* QXYLegendMarkerPrivate::relatedObject()
             {
                 return m_series;
             }
             void QXYLegendMarkerPrivate::updated()
             {
                 m_item->setLabel(m_series->name());
                 if (m_series->type()== QAbstractSeries::SeriesTypeScatter)  {
                     m_item->setBrush(m_series->brush());
                 } else {
                     m_item->setBrush(QBrush(m_series->pen().color()));
                 }
             }
             #include "moc_qxylegendmarker.cpp"
             #include "moc_qxylegendmarker_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/legend/qxylegendmarker.h +1 -1

             /****************************************************************************
             **
             ** 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 QXYLEGENDMARKER_H
             #define QXYLEGENDMARKER_H
             #include <QChartGlobal>
             #include <QLegendMarker>
             #include <QXYSeries>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QXYLegendMarkerPrivate;
             class QTCOMMERCIALCHART_EXPORT QXYLegendMarker : public QLegendMarker
             {
                 Q_OBJECT
             public:
-                explicit QXYLegendMarker(QXYSeries* series, QLegend *legend, QObject *parent = 0);
+                explicit QXYLegendMarker(QXYSeries *series, QLegend *legend, QObject *parent = 0);
                 virtual ~QXYLegendMarker();
                 virtual LegendMarkerType type() { return LegendMarkerTypeXY; }
                 // Related series
                 virtual QXYSeries* series();
             protected:
                 QXYLegendMarker(QXYLegendMarkerPrivate &d, QObject *parent = 0);
             private:
                 Q_DECLARE_PRIVATE(QXYLegendMarker)
                 Q_DISABLE_COPY(QXYLegendMarker)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QXYLEGENDMARKER_H

src/legend/qxylegendmarker_p.h +1 -1

             /****************************************************************************
             **
             ** 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 QXYLEGENDMARKER_P_H
             #define QXYLEGENDMARKER_P_H
             #include "qchartglobal.h"
             #include "qlegendmarker_p.h"
             #include "legendmarkeritem_p.h"
             #include <QXYSeries>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QXYLegendMarker;
             class QXYLegendMarkerPrivate : public QLegendMarkerPrivate
             {
                 Q_OBJECT
             public:
                 explicit QXYLegendMarkerPrivate(QXYLegendMarker *q, QXYSeries *series, QLegend *legend);
                 virtual ~QXYLegendMarkerPrivate();
                 virtual QAbstractSeries* series();
                 virtual QObject* relatedObject();
             public Q_SLOTS:
                 virtual void updated();
             private:
                 QXYLegendMarker *q_ptr;
-                QXYSeries* m_series;
+                QXYSeries *m_series;
                 Q_DECLARE_PUBLIC(QXYLegendMarker)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QXYLEGENDMARKER_P_H

General Comments 0

Write
Preview

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

No TODOs yet

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

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