HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r547:2c194d26bbea

Separated legend marker to private header. Added signals for left and right mouse click

sauimone -

r547:2c194d26bbea

parent child

Context file:

r547:2c194d26bbea

Collapse all files

src/legendmarker.cpp created 644 +63 0

@@ -0,0 +1,63
	1	#include "qchartglobal.h"
	2	#include "legendmarker_p.h"
	3	#include <QPainter>
	4	#include <QGraphicsSceneEvent>
	5
	6	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	7
	8	LegendMarker::LegendMarker(QSeries* series, QGraphicsItem *parent)
	9	: QGraphicsObject(parent)
	10	,mSeries(series)
	11	,mBoundingRect(0,0,1,1)
	12	{
	13	setAcceptedMouseButtons(Qt::LeftButton\|Qt::RightButton);
	14	}
	15
	16	void LegendMarker::setBoundingRect(const QRectF rect)
	17	{
	18	mBoundingRect = rect;
	19	}
	20
	21	void LegendMarker::setBrush(const QBrush brush)
	22	{
	23	mBrush = brush;
	24	}
	25
	26	void LegendMarker::setName(const QString name)
	27	{
	28	mName = name;
	29	}
	30
	31	QString LegendMarker::name() const
	32	{
	33	return mName;
	34	}
	35
	36	QColor LegendMarker::color() const
	37	{
	38	return mBrush.color();
	39	}
	40
	41	void LegendMarker::paint(QPainter painter, const QStyleOptionGraphicsItem option, QWidget *widget)
	42	{
	43	painter->setBrush(mBrush);
	44	painter->drawRect(mBoundingRect);
	45	}
	46
	47	QRectF LegendMarker::boundingRect() const
	48	{
	49	return mBoundingRect;
	50	}
	51
	52	void LegendMarker::mousePressEvent(QGraphicsSceneMouseEvent *event)
	53	{
	54	if (event->button() == Qt::LeftButton) {
	55	emit clicked(mSeries, mName);
	56	} else if (event->button() == Qt::RightButton) {
	57	emit rightClicked(mSeries, mName);
	58	}
	59	}
	60
	61	#include "moc_legendmarker_p.cpp"
	62
	63	QTCOMMERCIALCHART_END_NAMESPACE

src/legendmarker_p.h created 644 +44 0

@@ -0,0 +1,44
	1	#ifndef LEGENDMARKER_P_H
	2	#define LEGENDMARKER_P_H
	3
	4	#include "qchartglobal.h"
	5	#include <QGraphicsObject>
	6	#include <QBrush>
	7
	8	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	9
	10	class QSeries;
	11
	12
	13	class LegendMarker : public QGraphicsObject
	14	{
	15	Q_OBJECT
	16	public:
	17	LegendMarker(QSeries* series, QGraphicsItem *parent = 0);
	18	void setBoundingRect(const QRectF rect);
	19	void setBrush(const QBrush brush);
	20	void setName(const QString name);
	21	QString name() const;
	22	QColor color() const;
	23
	24	void paint(QPainter painter, const QStyleOptionGraphicsItem option, QWidget *widget = 0);
	25
	26	QRectF boundingRect() const;
	27
	28	public:
	29	// From QGraphicsObject
	30	void mousePressEvent(QGraphicsSceneMouseEvent *event);
	31
	32	Q_SIGNALS:
	33	void clicked(QSeries* series, QString name);
	34	void rightClicked(QSeries* series, QString name);
	35
	36	private:
	37	QRectF mBoundingRect;
	38	QBrush mBrush;
	39	QString mName;
	40	QSeries* mSeries;
	41	};
	42
	43	QTCOMMERCIALCHART_END_NAMESPACE
	44	#endif // LEGENDMARKER_P_H

src/chartpresenter.cpp +1 -1

             #include "qchart.h"
             #include "qchartaxis.h"
             #include "chartpresenter_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             #include "chartanimator_p.h"
             //series
             #include "qbarseries.h"
             #include "qstackedbarseries.h"
             #include "qpercentbarseries.h"
             #include "qlineseries.h"
             #include "qareaseries.h"
             #include "qpieseries.h"
             #include "qscatterseries.h"
             #include "qsplineseries.h"
             //items
             #include "axisitem_p.h"
             #include "areachartitem_p.h"
             #include "barpresenter_p.h"
             #include "stackedbarpresenter_p.h"
             #include "percentbarpresenter_p.h"
             #include "linechartitem_p.h"
             #include "piepresenter_p.h"
             #include "scatterchartitem_p.h"
             #include "splinechartitem_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartPresenter::ChartPresenter(QChart* chart,ChartDataSet* dataset):QObject(chart),
                 m_chart(chart),
                 m_animator(0),
                 m_dataset(dataset),
                 m_chartTheme(0),
                 m_zoomIndex(0),
                 m_marginSize(0),
                 m_rect(QRectF(QPoint(0,0),m_chart->size())),
                 m_options(QChart::NoAnimation)
             {
                 createConnections();
                 setChartTheme(QChart::ChartThemeDefault);
             }
             ChartPresenter::~ChartPresenter()
             {
             	delete m_chartTheme;
             }
             void ChartPresenter::createConnections()
             {
                 QObject::connect(m_chart,SIGNAL(geometryChanged()),this,SLOT(handleGeometryChanged()));
                 QObject::connect(m_dataset,SIGNAL(seriesAdded(QSeries*,Domain*)),this,SLOT(handleSeriesAdded(QSeries*,Domain*)));
                 QObject::connect(m_dataset,SIGNAL(seriesRemoved(QSeries*)),this,SLOT(handleSeriesRemoved(QSeries*)));
                 QObject::connect(m_dataset,SIGNAL(axisAdded(QChartAxis*,Domain*)),this,SLOT(handleAxisAdded(QChartAxis*,Domain*)));
                 QObject::connect(m_dataset,SIGNAL(axisRemoved(QChartAxis*)),this,SLOT(handleAxisRemoved(QChartAxis*)));
             }
             QRectF ChartPresenter::geometry() const
             {
                 return m_rect;
             }
             void ChartPresenter::handleGeometryChanged()
             {
                 QRectF rect(QPoint(0,0),m_chart->size());
                 rect.adjust(m_marginSize,m_marginSize, -m_marginSize, -m_marginSize);
                 //rewrite zoom stack
                 for(int i=0;i<m_zoomStack.count();i++){
                     QRectF r = m_zoomStack[i];
                     qreal w = rect.width()/m_rect.width();
                     qreal h = rect.height()/m_rect.height();
                     QPointF tl = r.topLeft();
                     tl.setX(tl.x()*w);
                     tl.setY(tl.y()*h);
                     QPointF br = r.bottomRight();
                     br.setX(br.x()*w);
                     br.setY(br.y()*h);
                     r.setTopLeft(tl);
                     r.setBottomRight(br);
                     m_zoomStack[i]=r;
                 }
                 m_rect = rect;
                 Q_ASSERT(m_rect.isValid());
                 emit geometryChanged(m_rect);
             }
             int ChartPresenter::margin() const
             {
                 return m_marginSize;
             }
             void ChartPresenter::setMargin(int margin)
             {
                 m_marginSize = margin;
             }
             void ChartPresenter::handleAxisAdded(QChartAxis* axis,Domain* domain)
             {
                 AxisItem* item = new AxisItem(axis,this,axis==m_dataset->axisX()?AxisItem::X_AXIS : AxisItem::Y_AXIS,m_chart);
                 if(m_options.testFlag(QChart::GridAxisAnimations)){
                     m_animator->addAnimation(item);
                 }
                 if(axis==m_dataset->axisX()){
                     QObject::connect(domain,SIGNAL(rangeXChanged(qreal,qreal,int)),item,SLOT(handleRangeChanged(qreal,qreal,int)));
                     //initialize
                     item->handleRangeChanged(domain->minX(),domain->maxX(),domain->tickXCount());
                 }
                 else{
                     QObject::connect(domain,SIGNAL(rangeYChanged(qreal,qreal,int)),item,SLOT(handleRangeChanged(qreal,qreal,int)));
                     //initialize
                     item->handleRangeChanged(domain->minY(),domain->maxY(),domain->tickYCount());
                 }
                 QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&)));
                 //initialize
                 item->handleGeometryChanged(m_rect);
                 m_chartTheme->decorate(axis,item);
                 m_axisItems.insert(axis,item);
             }
             void ChartPresenter::handleAxisRemoved(QChartAxis* axis)
             {
                 AxisItem* item = m_axisItems.take(axis);
                 Q_ASSERT(item);
                 if(m_animator) m_animator->removeAnimation(item);
                 delete item;
             }
             void ChartPresenter::handleSeriesAdded(QSeries* series,Domain* domain)
             {
             	ChartItem *item = 0 ;
                 switch(series->type())
                 {
                 case QSeries::SeriesTypeLine: {
                     QLineSeries* lineSeries = static_cast<QLineSeries*>(series);
                     LineChartItem* line = new LineChartItem(lineSeries,m_chart);
                     if(m_options.testFlag(QChart::SeriesAnimations)) {
                     	m_animator->addAnimation(line);
                     }
                     m_chartTheme->decorate(line, lineSeries, m_dataset->seriesIndex(series));
                     QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),line,SLOT(handleGeometryChanged(const QRectF&)));
                     QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),line,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
                     item = line;
                     break;
                 }
                 case QSeries::SeriesTypeArea: {
                     QAreaSeries* areaSeries = static_cast<QAreaSeries*>(series);
                     AreaChartItem* area = new AreaChartItem(areaSeries,m_chart);
                     if(m_options.testFlag(QChart::SeriesAnimations)) {
                       //  m_animator->addAnimation(area);
                     }
                     m_chartTheme->decorate(area, areaSeries, m_dataset->seriesIndex(series));
                     QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),area,SLOT(handleGeometryChanged(const QRectF&)));
                     QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),area,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
                     item=area;
                     break;
                 }
                 case QSeries::SeriesTypeBar: {
                     QBarSeries* barSeries = static_cast<QBarSeries*>(series);
                     BarPresenter* bar = new BarPresenter(barSeries,m_chart);
                     if(m_options.testFlag(QChart::SeriesAnimations)) {
                      //  m_animator->addAnimation(bar);
                     }
                     m_chartTheme->decorate(bar, barSeries, m_dataset->seriesIndex(barSeries));
                     QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),bar,SLOT(handleGeometryChanged(const QRectF&)));
                     QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),bar,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
                     item=bar;
                     break;
                 }
                 case QSeries::SeriesTypeStackedBar: {
                     QStackedBarSeries* stackedBarSeries = static_cast<QStackedBarSeries*>(series);
                     StackedBarPresenter* bar = new StackedBarPresenter(stackedBarSeries,m_chart);
                     if(m_options.testFlag(QChart::SeriesAnimations)) {
                      //  m_animator->addAnimation(bar);
                     }
                     m_chartTheme->decorate(bar, stackedBarSeries, m_dataset->seriesIndex(stackedBarSeries));
                     QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),bar,SLOT(handleGeometryChanged(const QRectF&)));
                     QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),bar,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
                     item=bar;
                     break;
                 }
                 case QSeries::SeriesTypePercentBar: {
                     QPercentBarSeries* percentBarSeries = static_cast<QPercentBarSeries*>(series);
                     PercentBarPresenter* bar = new PercentBarPresenter(percentBarSeries,m_chart);
                     if(m_options.testFlag(QChart::SeriesAnimations)) {
                      //  m_animator->addAnimation(bar);
                     }
                     m_chartTheme->decorate(bar, percentBarSeries, m_dataset->seriesIndex(percentBarSeries));
                     QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),bar,SLOT(handleGeometryChanged(const QRectF&)));
                     QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),bar,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
                     item=bar;
                     break;
                 }
                 case QSeries::SeriesTypeScatter: {
                 	QScatterSeries *scatterSeries = static_cast<QScatterSeries *>(series);
                         ScatterChartItem *scatter = new ScatterChartItem(scatterSeries, m_chart);
                         if(m_options.testFlag(QChart::SeriesAnimations)) {
                             m_animator->addAnimation(scatter);
                         }
                         m_chartTheme->decorate(scatter, scatterSeries, m_dataset->seriesIndex(series));
                         QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),scatter,SLOT(handleGeometryChanged(const QRectF&)));
                         QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),scatter,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
                         item = scatter;
                         break;
             	}
                 case QSeries::SeriesTypePie: {
                     QPieSeries *pieSeries = static_cast<QPieSeries *>(series);
                     PiePresenter* pie = new PiePresenter(m_chart, pieSeries);
                     if(m_options.testFlag(QChart::SeriesAnimations)) {
                        // m_animator->addAnimation(pie);
                     }
                     m_chartTheme->decorate(pie, pieSeries, m_dataset->seriesIndex(series));
                     QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),pie,SLOT(handleGeometryChanged(const QRectF&)));
                     QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),pie,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
                     // Hide all from background when there is only piechart
                     // TODO: refactor this ugly code... should be one setting for this
                     if (m_chartItems.count() == 0) {
                         m_chart->axisX()->hide();
                         m_chart->axisY()->hide();
                         m_chart->setChartBackgroundBrush(Qt::transparent);
                     }
                     item=pie;
                     break;
                 }
                 case QSeries::SeriesTypeSpline: {
                     QSplineSeries* splineSeries = static_cast<QSplineSeries*>(series);
                     SplineChartItem* spline  = new SplineChartItem(splineSeries, m_chart);
                     if(m_options.testFlag(QChart::SeriesAnimations)) {
                         m_animator->addAnimation(spline);
                     }
                     m_chartTheme->decorate(spline, splineSeries, m_dataset->seriesIndex(series));
                     QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),spline,SLOT(handleGeometryChanged(const QRectF&)));
                     QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),spline,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
                     item=spline;
                     break;
                 }
                 default: {
                     qDebug()<< "Series type" << series->type() << "not implemented.";
                     break;
                 }
                 }
                 //initialize
                 item->handleDomainChanged(domain->minX(),domain->maxX(),domain->minY(),domain->maxY());
                 if(m_rect.isValid()) item->handleGeometryChanged(m_rect);
                 m_chartItems.insert(series,item);
                 zoomReset();
             }
             void ChartPresenter::handleSeriesRemoved(QSeries* series)
             {
                 ChartItem* item = m_chartItems.take(series);
                 Q_ASSERT(item);
                 if(m_animator) m_animator->removeAnimation(item);
                 delete item;
             }
             void ChartPresenter::setChartTheme(QChart::ChartTheme theme)
             {
             	if(m_chartTheme && m_chartTheme->id() == theme) return;
                 delete m_chartTheme;
                 m_chartTheme = ChartTheme::createTheme(theme);
                 m_chartTheme->decorate(m_chart);
                 m_chartTheme->decorate(m_chart->legend());
                 resetAllElements();
             }
             QChart::ChartTheme ChartPresenter::chartTheme()
             {
                 return m_chartTheme->id();
             }
             void ChartPresenter::setAnimationOptions(QChart::AnimationOptions options)
             {
                 if(m_options!=options) {
                     m_options=options;
                     if(m_options!=QChart::NoAnimation && !m_animator) {
                         m_animator= new ChartAnimator(this);
                     }
                     resetAllElements();
                 }
             }
             void ChartPresenter::resetAllElements()
             {
                  QList<QChartAxis*> axisList = m_axisItems.uniqueKeys();
                  QList<QSeries*> seriesList = m_chartItems.uniqueKeys();
                  foreach(QChartAxis* axis, axisList) {
                      handleAxisRemoved(axis);
                      handleAxisAdded(axis,m_dataset->domain(axis));
                  }
                  foreach(QSeries* series, seriesList) {
                      handleSeriesRemoved(series);
                      handleSeriesAdded(series,m_dataset->domain(series));
                  }
             }
             void ChartPresenter::zoomIn()
             {
             	QRectF rect = geometry();
             	rect.setWidth(rect.width()/2);
             	rect.setHeight(rect.height()/2);
             	rect.moveCenter(geometry().center());
             	zoomIn(rect);
             }
             void ChartPresenter::zoomIn(const QRectF& rect)
             {
             	QRectF r = rect.normalized();
             	r.translate(-m_marginSize, -m_marginSize);
             	if(m_animator) {
             		QPointF point(r.center().x()/geometry().width(),r.center().y()/geometry().height());
             		m_animator->setState(ChartAnimator::ZoomInState,point);
             	}
             	m_dataset->zoomInDomain(r,geometry().size());
             	m_zoomStack<<r;
             	m_zoomIndex++;
             	if(m_animator) {
             		m_animator->setState(ChartAnimator::ShowState);
             	}
             }
             void ChartPresenter::zoomOut()
             {
             	if(m_zoomIndex==0) return;
             	if(m_animator)
             	{
             		m_animator->setState(ChartAnimator::ZoomOutState);
             	}
             	m_dataset->zoomOutDomain(m_zoomStack[m_zoomIndex-1],geometry().size());
             	m_zoomIndex--;
             	m_zoomStack.resize(m_zoomIndex);
             	if(m_animator){
             			m_animator->setState(ChartAnimator::ShowState);
             	}
             }
             void ChartPresenter::zoomReset()
             {
                 m_zoomIndex=0;
                 m_zoomStack.resize(m_zoomIndex);
             }
             void ChartPresenter::scroll(int dx,int dy)
             {
             	if(m_animator){
             		if(dx<0) m_animator->setState(ChartAnimator::ScrollLeftState,QPointF());
             		if(dx>0) m_animator->setState(ChartAnimator::ScrollRightState,QPointF());
             		if(dy<0) m_animator->setState(ChartAnimator::ScrollUpState,QPointF());
             		if(dy>0) m_animator->setState(ChartAnimator::ScrollDownState,QPointF());
             	}
             	m_dataset->scrollDomain(dx,dy,geometry().size());
-            	if(m_animator){
+                if(m_animator){
             		m_animator->setState(ChartAnimator::ShowState);
             	}
             }
             QChart::AnimationOptions ChartPresenter::animationOptions() const
             {
                 return m_options;
             }
             #include "moc_chartpresenter_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/qlegend.cpp +12 -33

             #include "qchartglobal.h"
             #include "qlegend.h"
             #include "qseries.h"
+            #include "legendmarker_p.h"
             #include <QPainter>
             #include <QPen>
-            QTCOMMERCIALCHART_BEGIN_NAMESPACE
+            #include <QGraphicsSceneEvent>
-            // TODO: this to legendmarker_p.h header
-            class LegendMarker : public QGraphicsItem
-            public:
-                LegendMarker(QGraphicsItem *parent = 0) : QGraphicsItem(parent)
-                  ,mBoundingRect(0,0,1,1)
-                {}
-                void setBoundingRect(const QRectF rect) { mBoundingRect = rect; }
-                void setBrush(const QBrush brush) { mBrush = brush; }
-                void setName(const QString name) { mName = name; }
-                QString name() const { return mName; }
-                QColor color() const { return mBrush.color(); }
-                void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = 0)
-                    painter->setBrush(mBrush);
-                    painter->drawRect(mBoundingRect);
-                QRectF boundingRect() const { return mBoundingRect; }
-            private:
+            QTCOMMERCIALCHART_BEGIN_NAMESPACE
-                QRectF mBoundingRect;
-                QBrush mBrush;
-                QString mName;
-            };
             QLegend::QLegend(QGraphicsItem *parent)
                 : QGraphicsObject(parent)
                 ,mBoundingRect(0,0,1,1)
                 ,mBackgroundBrush(Qt::darkGray)     // TODO: from theme?
             {
             }
             void QLegend::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 painter->setBrush(mBackgroundBrush);
                 painter->drawRect(mBoundingRect);
                 foreach(LegendMarker* m, mMarkers) {
                     QRectF r = m->boundingRect();
                     painter->setPen(m->color());
-                    painter->drawText(r.x() + 20, r.y() + r.height(), m->name());
+                    painter->drawText(r.x() + r.width()*2, r.y() + r.height(), m->name());
                 }
             }
             QRectF QLegend::boundingRect() const
             {
                 return mBoundingRect;
             }
             void QLegend::setBackgroundBrush(const QBrush& brush)
             {
                 mBackgroundBrush = brush;
             }
             QBrush QLegend::backgroundBrush() const
             {
                 return mBackgroundBrush;
             }
             void QLegend::handleSeriesAdded(QSeries* series,Domain* domain)
             {
                 mSeriesList.append(series);
                 dataChanged();
                 layoutChanged();
             }
             void QLegend::handleSeriesRemoved(QSeries* series)
             {
                 mSeriesList.removeOne(series);
                 dataChanged();
                 layoutChanged();
             }
             void QLegend::handleGeometryChanged(const QRectF& size)
             {
                 mBoundingRect = size;
                 layoutChanged();
             }
             void QLegend::dataChanged()
             {
-                foreach (QGraphicsItem* i, childItems()) {
+                foreach (LegendMarker* marker, mMarkers) {
-                    delete i;
+                    disconnect(marker,SIGNAL(clicked(QSeries*,QString)),this,SIGNAL(clicked(QSeries*,QString)));
+                    disconnect(marker,SIGNAL(rightClicked(QSeries*,QString)),this,SIGNAL(rightClicked(QSeries*,QString)));
+                    delete marker;
                 }
                 mMarkers.clear();
                 foreach (QSeries* s, mSeriesList) {
                     for (int i=0; i<s->legendEntries().count(); i++) {
-                        LegendMarker *marker = new LegendMarker(this);
+                        LegendMarker *marker = new LegendMarker(s, this);
                         marker->setBrush(s->legendEntries().at(i).mBrush);
                         marker->setName(s->legendEntries().at(i).mName);
                         mMarkers.append(marker);
-            //            childItems().append(marker);
+                        childItems().append(marker);
+                        connect(marker,SIGNAL(clicked(QSeries*,QString)),this,SIGNAL(clicked(QSeries*,QString)));
+                        connect(marker,SIGNAL(rightClicked(QSeries*,QString)),this,SIGNAL(rightClicked(QSeries*,QString)));
                     }
                 }
             }
             void QLegend::layoutChanged()
             {
                 // Calculate layout for markers and text
                 if (mMarkers.count() <= 0) {
                     // Nothing to do
                     return;
                 }
                 // TODO: marker defined by series.
                 QSizeF markerSize(10,10);
                 // TODO: better layout, this is just concept.
                 // Leave some space around markers like this: | x x x x |
                 qreal steps = mMarkers.count();
                 qreal xStep = mBoundingRect.width() / steps;
                 qreal yStep = mBoundingRect.height() / steps;
                 qreal x = mBoundingRect.x() + 5;
                 qreal y = mBoundingRect.y() + (mBoundingRect.height() - markerSize.height())/2;
                 foreach (LegendMarker* m, mMarkers) {
                     qDebug() << "marker x:" << x;
                     qDebug() << "marker y:" << y;
                     m->setBoundingRect(QRectF(x,y,markerSize.width(),markerSize.height()));
                     x += xStep;
                 }
             }
             #include "moc_qlegend.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/qlegend.h +4 -1

             #ifndef QLEGEND_H
             #define QLEGEND_H
             #include "qchartglobal.h"
             #include "qseries.h"
             #include <QGraphicsObject>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class Domain;
             class LegendMarker;
             class QTCOMMERCIALCHART_EXPORT QLegend : public QGraphicsObject
             {
                 Q_OBJECT
             public:
                 explicit QLegend(QGraphicsItem *parent = 0);
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = 0);
                 QRectF boundingRect() const;
                 void setBackgroundBrush(const QBrush& brush);
                 QBrush backgroundBrush() const;
             signals:
+                // for interactions.
+                void clicked(QSeries* series, QString name);
+                void rightClicked(QSeries* series, QString name);
             public slots:
                 void handleSeriesAdded(QSeries* series,Domain* domain);
                 void handleSeriesRemoved(QSeries* series);
                 void handleGeometryChanged(const QRectF& size);
             private:
                 void dataChanged();
                 void layoutChanged();
                 QRectF mBoundingRect;
                 QList<QSeries*> mSeriesList;
                 QList<LegendMarker*> mMarkers;
                 QBrush mBackgroundBrush;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QLEGEND_H

src/src.pro +5 -3

             !include( ../common.pri ):error( Couldn't find the common.pri file! )
             TARGET = QtCommercialChart
             DESTDIR = $$CHART_BUILD_LIB_DIR
             TEMPLATE = lib
             QT += core \
                 gui
             CONFIG += debug_and_release
             CONFIG(debug, debug|release):TARGET = QtCommercialChartd
             SOURCES += \
                 chartdataset.cpp \
                 chartpresenter.cpp \
                 charttheme.cpp \
                 domain.cpp \
                 qchart.cpp \
                 qchartview.cpp \
                 qseries.cpp \
-                qlegend.cpp
+                qlegend.cpp \
+                legendmarker.cpp
             PRIVATE_HEADERS += \
                 chartdataset_p.h \
                 chartitem_p.h \
                 chartpresenter_p.h \
                 charttheme_p.h \
-                domain_p.h
+                domain_p.h \
-            PUBLIC_HEADERS += \
+                legendmarker_p.h
+            PUBLIC_HEADERS += \
                 qchart.h \
                 qchartglobal.h \
                 qseries.h \
                 qchartview.h \
                 qlegend.h
             include(animations/animations.pri)
             include(axis/axis.pri)
             include(xychart/xychart.pri)
             include(linechart/linechart.pri)
             include(areachart/areachart.pri)
             include(barchart/barchart.pri)
             include(piechart/piechart.pri)
             include(scatterseries/scatter.pri)
             include(splinechart/splinechart.pri)
             THEMES += themes/chartthemedefault_p.h \
                 themes/chartthemeicy_p.h \
                 themes/chartthemegrayscale_p.h \
                 themes/chartthemescientific_p.h \
                 themes/chartthemevanilla_p.h
             HEADERS += $$PUBLIC_HEADERS
             HEADERS += $$PRIVATE_HEADERS
             HEADERS += $$THEMES
             INCLUDEPATH += linechart \
                 barchart \
                 themes \
                 .
             OBJECTS_DIR = $$CHART_BUILD_DIR/lib
             MOC_DIR = $$CHART_BUILD_DIR/lib
             UI_DIR = $$CHART_BUILD_DIR/lib
             RCC_DIR = $$CHART_BUILD_DIR/lib
             DEFINES += QTCOMMERCIALCHART_LIBRARY
             public_headers.path = $$[QT_INSTALL_HEADERS]/QtCommercialChart
             public_headers.files = $$PUBLIC_HEADERS
             target.path = $$[QT_INSTALL_LIBS]
             INSTALLS += target \
                 public_headers
             install_build_public_headers.name = bild_public_headers
             install_build_public_headers.output = $$CHART_BUILD_PUBLIC_HEADER_DIR/${QMAKE_FILE_BASE}.h
             install_build_public_headers.input = PUBLIC_HEADERS
             install_build_public_headers.commands = $$QMAKE_COPY \
                 ${QMAKE_FILE_NAME} \
                 $$CHART_BUILD_PUBLIC_HEADER_DIR
             install_build_public_headers.CONFIG += target_predeps \
                 no_link
             install_build_private_headers.name = bild_private_headers
             install_build_private_headers.output = $$CHART_BUILD_PRIVATE_HEADER_DIR/${QMAKE_FILE_BASE}.h
             install_build_private_headers.input = PRIVATE_HEADERS
             install_build_private_headers.commands = $$QMAKE_COPY \
                 ${QMAKE_FILE_NAME} \
                 $$CHART_BUILD_PRIVATE_HEADER_DIR
             install_build_private_headers.CONFIG += target_predeps \
                 no_link
             QMAKE_EXTRA_COMPILERS += install_build_public_headers \
                 install_build_private_headers
             chartversion.target = qchartversion_p.h
             chartversion.commands = @echo \
                 "build_time" \
                 > \
                 $$chartversion.target;
             chartversion.depends = $$HEADERS \
                 $$SOURCES
             PRE_TARGETDEPS += qchartversion_p.h
             QMAKE_CLEAN += qchartversion_p.h
             QMAKE_EXTRA_TARGETS += chartversion
             unix:QMAKE_DISTCLEAN += -r \
                 $$CHART_BUILD_HEADER_DIR \
                 $$CHART_BUILD_LIB_DIR
             win32:QMAKE_DISTCLEAN += /Q \
                 $$CHART_BUILD_HEADER_DIR \
                 $$CHART_BUILD_LIB_DIR

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