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

                 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;
                 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;
                         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);
                         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);
                         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);
                         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);
                 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));
                     }
                 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());
                 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));
                     }

src/legend/legendmarkeritem.cpp +2 -2

                 return m_textItem->brush();
             }
-            void LegendMarkerItem::setGeometry(const QRectF& rect)
+            void LegendMarkerItem::setGeometry(const QRectF &rect)
             {
                 QFontMetrics fn (m_font);
                 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);

src/legend/legendmarkeritem_p.h +2 -2

                 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);

src/legend/mouseeventhandler.cpp +3 -3

                 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;
                 }
             }
-            void MouseEventHandler::handleMouseReleaseEvent(QGraphicsSceneMouseEvent* event)
+            void MouseEventHandler::handleMouseReleaseEvent(QGraphicsSceneMouseEvent *event)
             {
                 m_lastPos = event->screenPos();

src/legend/mouseeventhandler_p.h +3 -3

                 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;

src/legend/qarealegendmarker.cpp +1 -1

             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)
             {
             }

src/legend/qarealegendmarker.h +1 -1

                 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; }

src/legend/qarealegendmarker_p.h +1 -1

             private:
                 QAreaLegendMarker *q_ptr;
-                QAreaSeries* m_series;
+                QAreaSeries *m_series;
                 Q_DECLARE_PUBLIC(QAreaLegendMarker)
             };

src/legend/qbarlegendmarker.cpp +1 -1

             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)
             {
             }

src/legend/qbarlegendmarker.h +1 -1

             {
                 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; }

src/legend/qbarlegendmarker_p.h +2 -2

             private:
                 QBarLegendMarker *q_ptr;
-                QAbstractBarSeries* m_series;
+                QAbstractBarSeries *m_series;
-                QBarSet* m_barset;
+                QBarSet *m_barset;
                 Q_DECLARE_PUBLIC(QBarLegendMarker)
             };

src/legend/qlegend.cpp +29 -27

             #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
                 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);
             }
                 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)) {
                 m_layout->invalidate();
             }
-            void QLegendPrivate::removeSeries(QAbstractSeries* series)
+            void QLegendPrivate::removeSeries(QAbstractSeries *series)
             {
                 if (m_series.contains(series)) {
                     m_series.removeOne(series);
                 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());
                     }
             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::decorateMarkers(QList<QLegendMarker *> markers)
             {
-                foreach (QLegendMarker* marker, markers) {
+                foreach (QLegendMarker *marker, markers) {
                     marker->setFont(m_font);
                     marker->setLabelBrush(m_labelBrush);
                 }

src/legend/qlegend.h +3 -3

                 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);

src/legend/qlegend_p.h +8 -10

                 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);
                 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;
                 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

src/legend/qlegendmarker_p.h +1 -1

             protected:
                 LegendMarkerItem *m_item;
-                QLegend* m_legend;
+                QLegend *m_legend;
             private:
                 QLegendMarker *q_ptr;

src/legend/qpielegendmarker.cpp +1 -1

             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)
             {
             }

src/legend/qpielegendmarker.h +1 -1

                 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; }

src/legend/qpielegendmarker_p.h +2 -2

             private:
                 QPieLegendMarker *q_ptr;
-                QPieSeries* m_series;
+                QPieSeries *m_series;
-                QPieSlice* m_slice;
+                QPieSlice *m_slice;
                 Q_DECLARE_PUBLIC(QPieLegendMarker)
             };

src/legend/qxylegendmarker.cpp +1 -1

             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)
             {
             }

src/legend/qxylegendmarker.h +1 -1

             {
                 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; }

src/legend/qxylegendmarker_p.h +1 -1

             private:
                 QXYLegendMarker *q_ptr;
-                QXYSeries* m_series;
+                QXYSeries *m_series;
                 Q_DECLARE_PUBLIC(QXYLegendMarker)
             };

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