HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r716:e7d88adcf7ee

Scrolling logic to legend

sauimone -

r716:e7d88adcf7ee

parent child

Context file:

r716:e7d88adcf7ee

Collapse all files

src/legendscrollbutton.cpp created 644 +26 0

			@@ -0,0 +1,26
		1	#include "legendscrollbutton_p.h"
		2	#include <QGraphicsSceneEvent>
		3
		4	QTCOMMERCIALCHART_BEGIN_NAMESPACE
		5
		6	LegendScrollButton::LegendScrollButton(ScrollButtonId id, QGraphicsItem *parent)
		7	: QGraphicsPolygonItem(parent)
		8	,mId(id)
		9	{
		10	setAcceptedMouseButtons(Qt::LeftButton);
		11	}
		12
		13	LegendScrollButton::ScrollButtonId LegendScrollButton::id()
		14	{
		15	return mId;
		16	}
		17
		18	void LegendScrollButton::mousePressEvent(QGraphicsSceneMouseEvent *event)
		19	{
		20	emit clicked(event);
		21	}
		22
		23	#include "moc_legendscrollbutton_p.cpp"
		24
		25	QTCOMMERCIALCHART_END_NAMESPACE
		26

src/legendscrollbutton_p.h created 644 +38 0

			@@ -0,0 +1,38
		1	#ifndef LEGENDSCROLLBUTTON_P_H
		2	#define LEGENDSCROLLBUTTON_P_H
		3
		4	#include <QObject>
		5	#include <qchartglobal.h>
		6	#include <QGraphicsPolygonItem>
		7
		8	QTCOMMERCIALCHART_BEGIN_NAMESPACE
		9
		10	class LegendScrollButton : public QObject, public QGraphicsPolygonItem
		11	{
		12	Q_OBJECT
		13	public:
		14	enum ScrollButtonId {
		15	ScrollButtonIdLeft,
		16	ScrollButtonIdRight,
		17	ScrollButtonIdUp,
		18	ScrollButtonIdDown
		19	};
		20
		21	explicit LegendScrollButton(ScrollButtonId id, QGraphicsItem *parent = 0);
		22	ScrollButtonId id();
		23
		24	virtual void mousePressEvent(QGraphicsSceneMouseEvent *event);
		25
		26	signals:
		27	void clicked(QGraphicsSceneMouseEvent* event);
		28
		29	public slots:
		30
		31	private:
		32
		33	ScrollButtonId mId;
		34	};
		35
		36	QTCOMMERCIALCHART_END_NAMESPACE
		37
		38	#endif // LEGENDSCROLLBUTTON_P_H

src/qchart.cpp +34 -2

                  // recalculate legend position
                  if (m_legend) {
                      if (m_legend->parentObject() == this) {
-                         m_legend->setMaximumSize(rect.size());
-                         m_legend->setPos(rect.topLeft());
+                         updateLegendLayout();
                      }
                  }
              }
+             void QChart::updateLegendLayout()
+             {
+                 QRectF plotRect = m_rect.adjusted(m_padding,m_padding, -m_padding, -m_padding);
+                 QRectF legendRect;
+                 switch (m_legend->preferredLayout())
+                 {
+                 case QLegend::PreferredLayoutTop:{
+                     legendRect = m_rect.adjusted(m_padding,0,-m_padding,-m_padding - plotRect.height());
+                     break;
+                 }
+                 case QLegend::PreferredLayoutBottom: {
+                     legendRect = m_rect.adjusted(m_padding,m_padding + plotRect.height(),-m_padding,0);
+                     break;
+                 }
+                 case QLegend::PreferredLayoutLeft: {
+                     legendRect = m_rect.adjusted(0,m_padding,-m_padding - plotRect.width(),-m_padding);
+                     break;
+                 }
+                 case QLegend::PreferredLayoutRight: {
+                     legendRect = m_rect.adjusted(m_padding + plotRect.width(),m_padding,0,-m_padding);
+                     break;
+                 }
+                 default: {
+                     legendRect = plotRect;
+                     break;
+                 }
+                 }
+                 m_legend->setMaximumSize(legendRect.size());
+                 m_legend->setPos(legendRect.topLeft());
+             }
              int QChart::padding() const
              {

src/qchart.h +1 0

                  void setBackgroundPadding(int padding);
                  void setBackgroundDiameter(int diameter);
                  void updateLayout();
+                 void updateLegendLayout();
              private:
                  Q_DISABLE_COPY(QChart)

src/qlegend.cpp +260 -90

              #include "qlegend.h"
              #include "qseries.h"
              #include "legendmarker_p.h"
+             #include "legendscrollbutton_p.h"
              #include "qxyseries.h"
              #include "qlineseries.h"
              #include "qareaseries.h"
                  ,mSize(0,0)
                  ,mMinimumSize(50,20)                // TODO: magic numbers
                  ,mMaximumSize(150,100)
-                 ,m_brush(Qt::darkGray)     // TODO: from theme?
-                 ,mPreferredLayout(QLegend::PreferredLayoutVertical)
+                 ,m_brush(Qt::darkGray)       // TODO: from theme?
+                 ,mPreferredLayout(QLegend::PreferredLayoutTop)
+                 ,mFirstMarker(0)
+                 ,mMargin(5)
              {
-                 setVisible(false);
+             //    setVisible(false);
+                 mScrollButtonLeft = new LegendScrollButton(LegendScrollButton::ScrollButtonIdLeft, this);
+                 mScrollButtonRight = new LegendScrollButton(LegendScrollButton::ScrollButtonIdRight, this);
+                 mScrollButtonUp = new LegendScrollButton(LegendScrollButton::ScrollButtonIdUp, this);
+                 mScrollButtonDown = new LegendScrollButton(LegendScrollButton::ScrollButtonIdDown, this);
+                 connect(mScrollButtonLeft,SIGNAL(clicked(QGraphicsSceneMouseEvent*)),this,SLOT(handleScrollButtonClicked(QGraphicsSceneMouseEvent*)));
+                 connect(mScrollButtonRight,SIGNAL(clicked(QGraphicsSceneMouseEvent*)),this,SLOT(handleScrollButtonClicked(QGraphicsSceneMouseEvent*)));
+                 connect(mScrollButtonUp,SIGNAL(clicked(QGraphicsSceneMouseEvent*)),this,SLOT(handleScrollButtonClicked(QGraphicsSceneMouseEvent*)));
+                 connect(mScrollButtonDown,SIGNAL(clicked(QGraphicsSceneMouseEvent*)),this,SLOT(handleScrollButtonClicked(QGraphicsSceneMouseEvent*)));
                  setZValue(ChartPresenter::LegendZValue);
              }
                  Q_UNUSED(option)
                  Q_UNUSED(widget)
-                 painter->setOpacity(0.5);
+                 painter->setOpacity(0.8);
                  painter->setPen(m_pen);
                  painter->setBrush(m_brush);
                  painter->drawRect(boundingRect());
              void QLegend::setPreferredLayout(QLegend::PreferredLayout preferred)
              {
                  mPreferredLayout = preferred;
-                 layoutChanged();
+                 updateLayout();
+             }
+             QLegend::PreferredLayout QLegend::preferredLayout() const
+             {
+                 return mPreferredLayout;
              }
              QSizeF QLegend::maximumSize() const
              void QLegend::setMaximumSize(const QSizeF size)
              {
                  mMaximumSize = size;
-                 layoutChanged();
+                 updateLayout();
              }
              void QLegend::setSize(const QSizeF size)
              void QLegend::setPos(const QPointF &pos)
              {
                  mPos = pos;
-                 layoutChanged();
+                 updateLayout();
              }
              void QLegend::handleSeriesAdded(QSeries* series, Domain* domain)
                  createMarkers(series);
                  connectSeries(series);
-                 layoutChanged();
+                 updateLayout();
              }
              void QLegend::handleSeriesRemoved(QSeries* series)
                      deleteMarkers(series);
                  }
-                 layoutChanged();
+                 updateLayout();
              }
              void QLegend::handleAdded(QList<QPieSlice*> slices)
                      mMarkers.append(marker);
                      childItems().append(marker);
                  }
-                 layoutChanged();
+                 updateLayout();
              }
              void QLegend::handleRemoved(QList<QPieSlice *> slices)
                  // TODO: what if more than one markers are destroyed and we update layout after first one?
                  LegendMarker* m = static_cast<LegendMarker*> (sender());
                  mMarkers.removeOne(m);
-                 layoutChanged();
+                 updateLayout();
+             }
+             void QLegend::handleScrollButtonClicked(QGraphicsSceneMouseEvent *event)
+             {
+                 Q_UNUSED(event);    // Maybe later somethin happens with right click...
+                 // TODO: detect sender object. scroll to appropiate direction.
+                 LegendScrollButton* scrollButton = static_cast<LegendScrollButton*> (sender());
+                 Q_ASSERT(scrollButton);
+                 switch (scrollButton->id()) {
+                 case LegendScrollButton::ScrollButtonIdLeft:
+                 case LegendScrollButton::ScrollButtonIdUp: {
+                     // Lower limit is same in these cases
+                     mFirstMarker--;
+                     checkMarkerBounds();
+                     break;
+                 }
+                 case LegendScrollButton::ScrollButtonIdRight:
+                 case LegendScrollButton::ScrollButtonIdDown: {
+                     mFirstMarker++;
+                     checkMarkerBounds();
+                     break;
+                 }
+                 default: {
+                     break;
+                 }
+                 }
+                 updateLayout();
              }
              void QLegend::connectSeries(QSeries *series)
                  }
              }
-             void QLegend::layoutChanged()
+             void QLegend::updateLayout()
              {
                  // Calculate layout for markers and text
                  if (mMarkers.count() <= 0) {
                      // Nothing to do
                      return;
                  }
+                 checkMarkerBounds();
                  // Find out widest item.
-                 qreal itemMaxWidth = 0;
-                 qreal itemMaxHeight = 0;
-                 foreach (LegendMarker* m, mMarkers) {
-                     if (m->boundingRect().width() > itemMaxWidth) {
-                         itemMaxWidth = m->boundingRect().width();
+                     }
-                     if (m->boundingRect().height() > itemMaxHeight) {
-                         itemMaxHeight = m->boundingRect().height();
+                     }
+                 }
+                 QSizeF markerMaxSize = maximumMarkerSize();
-                 int maxHorizontalItems = boundingRect().width() / itemMaxWidth;
-                 int maxVerticalItems = boundingRect().height() / itemMaxHeight;
+                 // Use max height as scroll button size
+                 rescaleScrollButtons(QSize(markerMaxSize.height() ,markerMaxSize.height()));
-                 if (mMarkers.count() > maxHorizontalItems * maxVerticalItems) {
-                     // TODO: overlapping layout
-                     //qDebug() << "Warning. Not enough space to layout all legend items properly.";
+                 }
-                 qreal margin = 5;
                  qreal totalWidth = 0;
                  qreal totalHeight = 0;
                  switch (mPreferredLayout)
                  {
-                 case QLegend::PreferredLayoutHorizontal: {
-                     /*
-                     qreal xStep = mMaximumSize.width() / (mMarkers.count()+1);
-                     if (xStep > itemMaxWidth) {
-                         xStep = itemMaxWidth;
+                     }
-                     qreal yStep = mMaximumSize.height() / (mMarkers.count()+1);
-                     if (yStep > itemMaxHeight) {
-                         yStep = itemMaxHeight;
-                     }*/
-                     qreal xStep = itemMaxWidth;
-                     qreal yStep = itemMaxHeight;
-                     qreal x = mPos.x() + margin;
-                     qreal y = mPos.y() + margin;
-                     int row = 1;
+                 // Both cases organise items horizontally
+                 case QLegend::PreferredLayoutBottom:
+                 case QLegend::PreferredLayoutTop: {
+                     qreal xStep = markerMaxSize.width();
+                     qreal x = mPos.x() + mMargin;
+                     qreal y = mPos.y() + mMargin;
                      int column = 0;
-                     int maxRows = 1;
                      int maxColumns = 1;
-                     foreach (LegendMarker* m, mMarkers) {
-                         maxRows = row;
-                         m->setPos(x,y);
-                         x += xStep;
-                         column++;
-                         if (column > maxColumns) {
-                             maxColumns = column;
+                         }
-                         if ((x + itemMaxWidth + margin*2) > (mPos.x() + mMaximumSize.width())) {
-                             x = mPos.x() + margin;
-                             y += yStep;
-                             row++;
-                             column = 0;
+                     qreal scrollButtonPadding = 0;
+                     // Set correct visibility for scroll scrollbuttons
+                     if (scrollButtonsVisible()) {
+                         mScrollButtonLeft->setVisible(true);
+                         mScrollButtonRight->setVisible(true);
+                         totalWidth += (mScrollButtonLeft->boundingRect().width() + mMargin) * 2;   // scrollbuttons visible, so add their width to total width
+                         x += mScrollButtonLeft->boundingRect().width() + mMargin;                  // start position changes by scrollbutton width
+                         scrollButtonPadding = mScrollButtonLeft->boundingRect().width();
+                     } else {
+                         mScrollButtonLeft->setVisible(false);
+                         mScrollButtonRight->setVisible(false);
+                     }
+                     mScrollButtonUp->setVisible(false);
+                     mScrollButtonDown->setVisible(false);
+                     for (int i=0; i<mMarkers.count(); i++) {
+                         LegendMarker* m = mMarkers.at(i);
+                         if (i<mFirstMarker) {
+                             // Markers before first are not visible.
+                             m->setVisible(false);
+                         } else {
+                             if ((x + xStep + scrollButtonPadding) > (mPos.x() + mMaximumSize.width())) {
+                                 // This marker would go outside legend rect.
+                                 m->setVisible(false);
+                             } else {
+                                 // This marker is ok
+                                 m->setVisible(true);
+                                 m->setPos(x,y);
+                                 x += xStep;
+                                 column++;
+                             }
                          }
+                         maxColumns = column;
                      }
-                     totalWidth = maxColumns * itemMaxWidth + margin * 2;
-                     totalHeight = maxRows * itemMaxHeight + margin * 2;
+                     mScrollButtonLeft->setPos(mPos.x() + mMargin, y);
+                     mScrollButtonRight->setPos(x+mMargin,y);
+                     totalWidth += maxColumns * markerMaxSize.width() + mMargin * 2;
+                     totalHeight = markerMaxSize.height() + mMargin * 2;
                      break;
                  }
-                 case QLegend::PreferredLayoutVertical: {
-                     /*
-                     qreal xStep = mMaximumSize.width() / (mMarkers.count()+1);
-                     if (xStep > itemMaxWidth) {
-                         xStep = itemMaxWidth;
+                 // Both cases organize items vertically
+                 case QLegend::PreferredLayoutLeft:
+                 case QLegend::PreferredLayoutRight: {
+                     qreal yStep = markerMaxSize.height();
+                     qreal x = mPos.x() + mMargin;
+                     qreal y = mPos.y() + mMargin;
+                     int row = 1;
+                     int maxRows = 1;
+                     qreal scrollButtonPadding = 0;
+                     // Set correct visibility for scroll scrollbuttons
+                     if (scrollButtonsVisible()) {
+                         mScrollButtonUp->setVisible(true);
+                         mScrollButtonDown->setVisible(true);
+                         totalHeight += (mScrollButtonUp->boundingRect().height() + mMargin) * 2;   // scrollbuttons visible, so add their height to total height
+                         y += mScrollButtonUp->boundingRect().height() + mMargin;                  // start position changes by scrollbutton height
+                         scrollButtonPadding = mScrollButtonUp->boundingRect().height();
+                     } else {
+                         mScrollButtonUp->setVisible(false);
+                         mScrollButtonDown->setVisible(false);
                      }
-                     qreal yStep = mMaximumSize.height() / (mMarkers.count()+1);
-                     if (yStep > itemMaxHeight) {
-                         yStep = itemMaxHeight;
-                     }*/
-                     qreal xStep = itemMaxWidth;
-                     qreal yStep = itemMaxHeight;
-                     qreal x = mPos.x() + margin;
-                     qreal y = mPos.y() + margin;
+                     mScrollButtonLeft->setVisible(false);
+                     mScrollButtonRight->setVisible(false);
+                     for (int i=0; i<mMarkers.count(); i++) {
+                         LegendMarker* m = mMarkers.at(i);
+                         if (i<mFirstMarker) {
+                             // Markers before first are not visible.
+                             m->setVisible(false);
+                         } else {
+                             if ((y + yStep + scrollButtonPadding) > (mPos.y() + mMaximumSize.height())) {
+                                 // This marker would go outside legend rect.
+                                 m->setVisible(false);
+                             } else {
+                                 // This marker is ok
+                                 m->setVisible(true);
+                                 m->setPos(x,y);
+                                 y += yStep;
+                                 row++;
+                             }
+                         }
+                         maxRows = row;
+                     }
+                     mScrollButtonUp->setPos(mPos.x() + mMargin, mPos.y() + mMargin);
+                     mScrollButtonDown->setPos(mPos.x() + mMargin, y + mMargin);
+                     totalWidth += markerMaxSize.width() + mMargin * 2;
+                     totalHeight = maxRows * markerMaxSize.height() + mMargin * 4 + scrollButtonPadding; // TODO: check this
+                     /*
+                     qreal yStep = markerMaxSize.height();
+                     qreal x = mPos.x() + mMargin;
+                     qreal y = mPos.y() + mMargin;
                      int row = 0;
-                     int column = 1;
                      int maxRows = 1;
                      int maxColumns = 1;
-                     foreach (LegendMarker* m, mMarkers) {
-                         maxColumns = column;
-                         m->setPos(x,y);
-                         y += yStep;
-                         row++;
-                         if (row > maxRows) {
-                             maxRows = row;
+                         }
-                         if ((y + itemMaxHeight + margin*2) > (mPos.y() + mMaximumSize.height())) {
-                             y = mPos.y() + margin;
-                             x += xStep;
-                             column++;
-                             row = 0;
+                     for (int i=0; i<mMarkers.count(); i++) {
+                         LegendMarker* m = mMarkers.at(i);
+                         if (i<mFirstMarker) {
+                             // Markers before first are not visible.
+                             m->setVisible(false);
+                         } else {
+                             if ((y + markerMaxSize.height() + mMargin*2) > (mPos.y() + mMaximumSize.height())) {
+                                 // This marker would go outside legend rect.
+                                 m->setVisible(false);
+                             } else {
+                                 // This marker is ok
+                                 m->setVisible(true);
+                                 maxRows = row;
+                                 m->setPos(x,y);
+                                 y += yStep;
+                                 row++;
+                             }
                          }
+                         maxRows = row;
                      }
-                     totalWidth = maxColumns * itemMaxWidth + margin * 2;
-                     totalHeight = maxRows * itemMaxHeight + margin * 2;
+                     totalWidth = maxColumns * markerMaxSize.width() + mMargin * 2;
+                     totalHeight = maxRows * markerMaxSize.height() + mMargin * 2;
+                     */
                      break;
                  }
                  default: {
                  mSize.setWidth(totalWidth);
                  mSize.setHeight(totalHeight);
+                 update();
+             }
+             void QLegend::rescaleScrollButtons(const QSize &size)
+             {
+                 QPolygonF left;
+                 left << QPointF(size.width(),0) << QPointF(0,size.height()/2) << QPointF(size.width(),size.height());
+                 QPolygonF right;
+                 right << QPointF(0,0) << QPointF(size.width(),size.height()/2) << QPointF(0,size.height());
+                 QPolygonF up;
+                 up << QPointF(0,size.height()) << QPointF(size.width()/2,0) << QPointF(size.width(),size.height());
+                 QPolygonF down;
+                 down << QPointF(0,0) << QPointF(size.width()/2,size.height()) << QPointF(size.width(),0);
+                 mScrollButtonLeft->setPolygon(left);
+                 mScrollButtonRight->setPolygon(right);
+                 mScrollButtonUp->setPolygon(up);
+                 mScrollButtonDown->setPolygon(down);
+             }
+             QSizeF QLegend::maximumMarkerSize()
+             {
+                 QSizeF max(0,0);
+                 foreach (LegendMarker* m, mMarkers) {
+                     if (m->boundingRect().width() > max.width()) {
+                         max.setWidth(m->boundingRect().width());
+                     }
+                     if (m->boundingRect().height() > max.height()) {
+                         max.setHeight(m->boundingRect().height());
+                     }
+                 }
+                 return max;
+             }
+             void QLegend::checkMarkerBounds()
+             {
+                 if ((mPreferredLayout == QLegend::PreferredLayoutLeft) || (mPreferredLayout == QLegend::PreferredLayoutRight)) {
+                     // Bounds limited by height
+                     int max;
+                     if (scrollButtonsVisible()) {
+                         max = (mMaximumSize.height() - mScrollButtonLeft->boundingRect().height() * 2 - mMargin*2) / maximumMarkerSize().height();
+                     } else {
+                         max = mMaximumSize.height() / maximumMarkerSize().height();
+                     }
+                     if (mFirstMarker > mMarkers.count() - max) {
+                         mFirstMarker = mMarkers.count() - max;
+                     }
+                 } else {
+                     // Bounds limited by width
+                     int max;
+                     if (scrollButtonsVisible()) {
+                         max = (mMaximumSize.width() - mScrollButtonLeft->boundingRect().width() * 2 - mMargin*2) / maximumMarkerSize().width();
+                     } else {
+                         max = mMaximumSize.width() / maximumMarkerSize().width();
+                     }
+                     if (mFirstMarker > mMarkers.count() - max) {
+                         mFirstMarker = mMarkers.count() - max;
+                     }
+                 }
+                 if (mFirstMarker < 0) {
+                     mFirstMarker = 0;
+                 }
+             }
+             bool QLegend::scrollButtonsVisible()
+             {
+                 // Just a helper to clarify, what the magic below means :)
+                 if ((mPreferredLayout == QLegend::PreferredLayoutTop) || (mPreferredLayout == QLegend::PreferredLayoutBottom)) {
+                     return (maximumMarkerSize().width() * mMarkers.count() + mMargin * 3 > mMaximumSize.width());
+                 }
+                 return (maximumMarkerSize().height() * mMarkers.count() + mMargin * 3 > mMaximumSize.height());
              }
              #include "moc_qlegend.cpp"

src/qlegend.h +24 -4

              class QBarSet;
              class QBarSeries;
              class QPieSeries;
+             class LegendScrollButton;
              class QTCOMMERCIALCHART_EXPORT QLegend : public QGraphicsObject
              {
              public:
                  enum PreferredLayout {
-                     PreferredLayoutHorizontal,
-                     PreferredLayoutVertical
+                     PreferredLayoutTop,
+                     PreferredLayoutBottom,
+                     PreferredLayoutLeft,
+                     PreferredLayoutRight,
                  };
                  explicit QLegend(QGraphicsItem *parent = 0);
                  QPen pen() const;
                  void setPreferredLayout(QLegend::PreferredLayout preferred);
+                 QLegend::PreferredLayout preferredLayout() const;
                  QSizeF maximumSize() const;
                  void setMaximumSize(const QSizeF size);
                  void handleAdded(QList<QPieSlice*> slices);
                  void handleRemoved(QList<QPieSlice*> slices);
                  void handleMarkerDestroyed();
+                 void handleScrollButtonClicked(QGraphicsSceneMouseEvent* event);
              private:
                  // PIMPL --->
                  void appendMarkers(QBarSeries* series);
                  void appendMarkers(QPieSeries* series);
                  void deleteMarkers(QSeries* series);
-                 void layoutChanged();
-                 // <--- PIMPL
+             //    void layoutChanged();   // This tries to fit all items to legend
+                 void updateLayout();    // New version of layout. Fits items only to row or column and adds scrollbars.
+                 void rescaleScrollButtons(const QSize& size);
+                 QSizeF maximumMarkerSize();
+                 void checkMarkerBounds();
+                 bool scrollButtonsVisible();
+             //    void updateScrollButtonsLayout();
                  QPointF mPos;
                  QSizeF mSize;
                  QBrush m_brush;
                  QPen m_pen;
                  QLegend::PreferredLayout mPreferredLayout;
+                 int mFirstMarker;
+                 LegendScrollButton* mScrollButtonLeft;
+                 LegendScrollButton* mScrollButtonRight;
+                 LegendScrollButton* mScrollButtonUp;
+                 LegendScrollButton* mScrollButtonDown;
+                 qreal mMargin;
+                 // <--- PIMPL
              };
              QTCOMMERCIALCHART_END_NAMESPACE

src/src.pro +2 0

                  $$PWD/qseries.cpp \
                  $$PWD/qlegend.cpp \
                  $$PWD/legendmarker.cpp \
+                 $$PWD/legendscrollbutton.cpp \
                  $$PWD/chartbackground.cpp \
                  $$PWD/chart.cpp
              PRIVATE_HEADERS += \
                  $$PWD/charttheme_p.h \
                  $$PWD/domain_p.h \
                  $$PWD/legendmarker_p.h \
+                 $$PWD/legendscrollbutton_p.h \
                  $$PWD/chartbackground_p.h \
                  $$PWD/chart_p.h
              PUBLIC_HEADERS += \

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