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()) {
-                             LegendMarkerItem* item = marker->d_ptr->item();
+                         foreach (QLegendMarker *marker, m_legend->d_ptr->markers()) {
+                             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()) {
-                             LegendMarkerItem* item = marker->d_ptr->item();
+                         foreach (QLegendMarker *marker, m_legend->d_ptr->markers()) {
+                             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 handleMouseMoveEvent(QGraphicsSceneMouseEvent* event);
-                 void handleMouseReleaseEvent(QGraphicsSceneMouseEvent* event);
+                 void handleMousePressEvent(QGraphicsSceneMouseEvent *event);
+                 void handleMouseMoveEvent(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;
-                 QBarSet* m_barset;
+                 QAbstractBarSeries *m_series;
+                 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;
-                 void addSeries(QAbstractSeries* series);
-                 void removeSeries(QAbstractSeries* series);
+                 QList <QLegendMarker*> markers(QAbstractSeries *series = 0) const;
+                 void addSeries(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() { return m_markers; }
-                 void addSeries(QAbstractSeries* series);
-                 void removeSeries(QAbstractSeries* series);
+                 QList<QLegendMarker*> markers(QAbstractSeries *series = 0);
+                 void addSeries(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;
-                 QGraphicsItemGroup* m_items;
+                 QChart *m_chart;
+                 QGraphicsItemGroup *m_items;
                  Qt::Alignment m_alignment;
                  QBrush m_brush;
                  QPen m_pen;
                  bool m_attachedToChart;
                  bool m_backgroundVisible;
-                 friend class QLegend;
-                 friend class LegendLayout;
-                 QList<QLegendMarker*> m_markers;
-                 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;
-                 QPieSlice* m_slice;
+                 QPieSeries *m_series;
+                 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