HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r524:280ce33a2f47

framework for legend

sauimone -

r524:280ce33a2f47

parent child

Context file:

r524:280ce33a2f47

Collapse all files

src/qlegend.cpp created 644 +44 0

@@ -0,0 +1,44
	1	#include "qchartglobal.h"
	2	#include "qlegend.h"
	3	#include "qseries.h"
	4
	5	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	6	QLegend::QLegend(QGraphicsItem *parent)
	7	: QGraphicsObject(parent)
	8	,mBoundingRect(0,0,0,0)
	9	{
	10	}
	11
	12
	13	void QLegend::paint(QPainter painter, const QStyleOptionGraphicsItem option, QWidget *widget)
	14	{
	15	// TODO:
	16	qDebug() << "QLegend::paint";
	17	foreach(QSeries* s, mSeriesList) {
	18	for (int i=0; i<s->legendEntries().count(); i++) {
	19	// Paint it...
	20	//qDebug() << s->legendEntries().at(i).mName;
	21	}
	22	}
	23	}
	24
	25	QRectF QLegend::boundingRect() const
	26	{
	27	return mBoundingRect;
	28	}
	29
	30	void QLegend::handleSeriesAdded(QSeries* series,Domain* domain)
	31	{
	32	// TODO: append entries
	33	mSeriesList.append(series);
	34	}
	35
	36	void QLegend::handleSeriesRemoved(QSeries* series)
	37	{
	38	// TODO: remove entries
	39	mSeriesList.removeOne(series);
	40	}
	41
	42
	43	#include "moc_qlegend.cpp"
	44	QTCOMMERCIALCHART_END_NAMESPACE

src/qlegend.h created 644 +36 0

@@ -0,0 +1,36
	1	#ifndef QLEGEND_H
	2	#define QLEGEND_H
	3
	4	#include "qchartglobal.h"
	5	#include "qseries.h"
	6	#include <QGraphicsObject>
	7
	8	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	9
	10	class Domain;
	11
	12	class QLegend : public QGraphicsObject
	13	{
	14	Q_OBJECT
	15	public:
	16
	17	explicit QLegend(QGraphicsItem *parent = 0);
	18
	19	void paint(QPainter painter, const QStyleOptionGraphicsItem option, QWidget *widget = 0);
	20	QRectF boundingRect() const;
	21
	22	signals:
	23
	24	public slots:
	25	void handleSeriesAdded(QSeries* series,Domain* domain);
	26	void handleSeriesRemoved(QSeries* series);
	27
	28	private:
	29
	30	QRectF mBoundingRect;
	31	QList<QSeries*> mSeriesList;
	32	};
	33
	34	QTCOMMERCIALCHART_END_NAMESPACE
	35
	36	#endif // QLEGEND_H

src/barchart/barchartmodel.cpp +3 -3

             #include <limits.h>
             #include <QVector>
             #include <QDebug>
             #include "barchartmodel_p.h"
             #include "qbarset.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             BarChartModel::BarChartModel(QStringList categories, QObject *parent) :
                 QObject(parent)
                 ,mCategory(categories)
             {
             }
             QStringList BarChartModel::category()
             {
                 return mCategory;
             }
             void BarChartModel::addBarSet(QBarSet *set)
             {
                 mDataModel.append(set);
             }
             void BarChartModel::removeBarSet(QBarSet *set)
             {
                 if (mDataModel.contains(set)) {
                     mDataModel.removeOne(set);
                 }
             }
             QBarSet* BarChartModel::setAt(int index)
             {
                 return mDataModel.at(index);
             }
             QList<QBarSet*> BarChartModel::barSets()
             {
                 return mDataModel;
             }
-            QList<QSeries::Legend> BarChartModel::legend()
+            QList<QSeries::LegendEntry> BarChartModel::legendEntries()
             {
-                QList<QSeries::Legend> legend;
+                QList<QSeries::LegendEntry> legend;
                 for (int i=0; i<mDataModel.count(); i++) {
-                    QSeries::Legend l;
+                    QSeries::LegendEntry l;
                     l.mName = mDataModel.at(i)->name();
                     l.mPen = mDataModel.at(i)->pen();
                     legend.append(l);
                 }
                 return legend;
             }
             int BarChartModel::barsetCount()
             {
                 return mDataModel.count();
             }
             int BarChartModel::categoryCount()
             {
                 return mCategory.count();
             }
             qreal BarChartModel::min()
             {
                 Q_ASSERT(mDataModel.count() > 0);
                 // TODO: make min and max members and update them when data changes.
                 // This is slower since they are checked every time, even if data is same since previous call.
                 qreal min = INT_MAX;
                 for (int i=0; i <mDataModel.count(); i++) {
                     int itemCount = mDataModel.at(i)->count();
                     for (int j=0; j<itemCount; j++) {
                         qreal temp = mDataModel.at(i)->valueAt(j);
                         if (temp < min) {
                             min = temp;
                         }
                     }
                 }
                 return min;
             }
             qreal BarChartModel::max()
             {
                 Q_ASSERT(mDataModel.count() > 0);
                 // TODO: make min and max members and update them when data changes.
                 // This is slower since they are checked every time, even if data is same since previous call.
                 qreal max = INT_MIN;
                 for (int i=0; i <mDataModel.count(); i++) {
                     int itemCount = mDataModel.at(i)->count();
                     for (int j=0; j<itemCount; j++) {
                         qreal temp = mDataModel.at(i)->valueAt(j);
                         if (temp > max) {
                             max = temp;
                         }
                     }
                 }
                 return max;
             }
             qreal BarChartModel::valueAt(int set, int category)
             {
                 if ((set < 0) || (set >= mDataModel.count())) {
                     // No set, no value.
                     return 0;
                 } else if ((category < 0) || (category >= mDataModel.at(set)->count())) {
                     // No category, no value.
                     return 0;
                 }
                 return mDataModel.at(set)->valueAt(category);
             }
             qreal BarChartModel::percentageAt(int set, int category)
             {
                 if ((set < 0) || (set >= mDataModel.count())) {
                     // No set, no value.
                     return 0;
                 } else if ((category < 0) || (category >= mDataModel.at(set)->count())) {
                     // No category, no value.
                     return 0;
                 }
                 qreal value = mDataModel.at(set)->valueAt(category);
                 qreal total = categorySum(category);
                 if (0 == total) {
                     return 100.0;
                 }
                 return value / total;
             }
             qreal BarChartModel::categorySum(int category)
             {
                 qreal sum(0);
                 int count = mDataModel.count(); // Count sets
                 for (int set = 0; set < count; set++) {
                     if (category < mDataModel.at(set)->count()) {
                         sum += mDataModel.at(set)->valueAt(category);
                     }
                 }
                 return sum;
             }
             qreal BarChartModel::maxCategorySum()
             {
                 qreal max = INT_MIN;
                 int count = categoryCount();
                 for (int col=0; col<count; col++) {
                     qreal sum = categorySum(col);
                     if (sum > max) {
                         max = sum;
                     }
                 }
                 return max;
             }
             QString BarChartModel::categoryName(int category)
             {
                 return mCategory.at(category);
             }
             #include "moc_barchartmodel_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/barchartmodel_p.h +1 -1

             #ifndef BARCHARTMODEL_H
             #define BARCHARTMODEL_H
             #include <QObject>
             #include <QStringList>
             #include "qchartglobal.h"
             #include <qseries.h>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             // Model for bar chart. Internal class.
             // TODO: Implement as QAbstractItemModel?
             class QBarSet;
             class BarChartModel : public QObject //, public QAbstractItemModel
             {
                 Q_OBJECT
             public:
                 explicit BarChartModel(QStringList categories, QObject *parent = 0);
                 QStringList category();
                 void addBarSet(QBarSet *set);
                 void removeBarSet(QBarSet *set);
                 QBarSet *setAt(int index);
                 QList<QBarSet*> barSets();
-                QList<QSeries::Legend> legend();
+                QList<QSeries::LegendEntry> legendEntries();
                 int barsetCount();          // Number of sets in model
                 int categoryCount();        // Number of categories
                 qreal max();                // Maximum value of all sets
                 qreal min();                // Minimum value of all sets
                 qreal valueAt(int set, int category);
                 qreal percentageAt(int set, int category);
                 qreal categorySum(int category);
                 qreal maxCategorySum();     // returns maximum sum of sets in all categories.
                 QString categoryName(int category);
             signals:
                 void modelUpdated();
             public slots:
             private:
                 QList<QBarSet*> mDataModel;
                 QStringList mCategory;
                 int mCurrentSet;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // BARCHARTMODEL_H

src/barchart/qbarseries.cpp +2 -2

             #include <QDebug>
             #include "qbarseries.h"
             #include "qbarset.h"
             #include "barchartmodel_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QBarSeries
                 \brief part of QtCommercial chart API.
                 QBarSeries represents a series of data shown as bars. One QBarSeries can contain multible
                 QBarSet data sets. QBarSeries groups the data from sets to categories, which are defined
                 by QStringList.
                 \mainclass
                 \sa QBarSet, QStackedBarSeries, QPercentBarSeries
             */
             /*!
                 \fn virtual QSeriesType QBarSeries::type() const
                 \brief Returns type of series.
                 \sa QSeries, QSeriesType
             */
             /*!
                 \fn void QBarSeries::showToolTip(QPoint pos, QString tip)
                 \brief \internal \a pos \a tip
             */
             /*!
                 Constructs empty QBarSeries. Parameter \a categories defines the categories for chart.
                 QBarSeries is QObject which is a child of a \a parent.
             */
             QBarSeries::QBarSeries(QStringList categories, QObject *parent)
                 : QSeries(parent)
                 ,mModel(new BarChartModel(categories, this))
             {
             }
             /*!
                 Adds a set of bars to series. Takes ownership of \a set.
                 Connects the clicked(QString) and rightClicked(QString) signals
                 of \a set to this series
             */
             void QBarSeries::addBarSet(QBarSet *set)
             {
                 mModel->addBarSet(set);
                 connect(set,SIGNAL(clicked(QString)),this,SLOT(barsetClicked(QString)));
                 connect(set,SIGNAL(rightClicked(QString)),this,SLOT(barsetRightClicked(QString)));
             }
             /*!
                 Removes a set of bars from series. Releases ownership of \a set. Doesnt delete \a set.
                 Disconnects the clicked(QString) and rightClicked(QString) signals
                 of \a set from this series
             */
             void QBarSeries::removeBarSet(QBarSet *set)
             {
                 disconnect(set,SIGNAL(clicked(QString)),this,SLOT(barsetClicked(QString)));
                 disconnect(set,SIGNAL(rightClicked(QString)),this,SLOT(barsetRightClicked(QString)));
                 mModel->removeBarSet(set);
             }
             /*!
                 Returns number of sets in series.
             */
             int QBarSeries::barsetCount()
             {
                 return mModel->barsetCount();
             }
             /*!
                 Returns number of categories in series
             */
             int QBarSeries::categoryCount()
             {
                 return mModel->categoryCount();
             }
             /*!
                 Returns a list of sets in series. Keeps ownership of sets.
              */
             QList<QBarSet*> QBarSeries::barSets()
             {
                 return mModel->barSets();
             }
             /*!
                 \internal \a index
             */
             QBarSet* QBarSeries::barsetAt(int index)
             {
                 return mModel->setAt(index);
             }
             /*!
                 Returns legend of series.
             */
-            QList<QSeries::Legend> QBarSeries::legend()
+            QList<QSeries::LegendEntry> QBarSeries::legendEntries()
             {
-                return mModel->legend();
+                return mModel->legendEntries();
             }
             /*!
                 \internal \a category
             */
             QString QBarSeries::categoryName(int category)
             {
                 return mModel->categoryName(category);
             }
             /*!
                 Enables or disables tooltip depending on parameter \a enabled.
                 Tooltip shows the name of set, when mouse is hovering on top of bar.
                 Calling without parameter \a enabled, enables the tooltip
             */
             void QBarSeries::setToolTipEnabled(bool enabled)
             {
                 // TODO: what if we add sets after call to this function? Those sets won't have tooltip enabled.
                 if (enabled) {
                     for (int i=0; i<mModel->barsetCount(); i++) {
                         QBarSet *set = mModel->setAt(i);
                         connect(set,SIGNAL(showToolTip(QPoint,QString)),this,SIGNAL(showToolTip(QPoint,QString)));
                     }
                 } else {
                     for (int i=0; i<mModel->barsetCount(); i++) {
                         QBarSet *set = mModel->setAt(i);
                         disconnect(set,SIGNAL(showToolTip(QPoint,QString)),this,SIGNAL(showToolTip(QPoint,QString)));
                     }
                 }
             }
             /*!
                 Enables or disables separators depending on parameter \a enabled.
                 Separators are visual elements that are drawn between categories.
                 Calling without parameter \a enabled, enables the separators
             */
             void QBarSeries::setSeparatorsVisible(bool visible)
             {
                 mSeparatorsVisible = visible;
                 emit enableSeparators(visible);
             }
             /*!
                 \internal \a category
             */
             void QBarSeries::barsetClicked(QString category)
             {
                 emit clicked(qobject_cast<QBarSet*>(sender()), category);
             }
             /*!
                 \internal \a category
             */
             void QBarSeries::barsetRightClicked(QString category)
             {
                 emit rightClicked(qobject_cast<QBarSet*>(sender()), category);
             }
             /*!
                 \internal
             */
             qreal QBarSeries::min()
             {
                 return mModel->min();
             }
             /*!
                 \internal
             */
             qreal QBarSeries::max()
             {
                 return mModel->max();
             }
             /*!
                 \internal \a set \a category
             */
             qreal QBarSeries::valueAt(int set, int category)
             {
                 return mModel->valueAt(set,category);
             }
             /*!
                 \internal \a set \a category
             */
             qreal QBarSeries::percentageAt(int set, int category)
             {
                 return mModel->percentageAt(set,category);
             }
             /*!
                 \internal \a category
             */
             qreal QBarSeries::categorySum(int category)
             {
                 return mModel->categorySum(category);
             }
             /*!
                 \internal
             */
             qreal QBarSeries::maxCategorySum()
             {
                 return mModel->maxCategorySum();
             }
             /*!
                 \internal
             */
             BarChartModel& QBarSeries::model()
             {
                 return *mModel;
             }
             bool QBarSeries::separatorsVisible()
             {
                 return mSeparatorsVisible;
             }
             #include "moc_qbarseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/qbarseries.h +1 -1

             #ifndef BARSERIES_H
             #define BARSERIES_H
             #include "qseries.h"
             #include <QStringList>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QBarSet;
             class BarChartModel;
             class BarCategory;
             // Container for series
             class QTCOMMERCIALCHART_EXPORT QBarSeries : public QSeries
             {
                 Q_OBJECT
             public:
                 QBarSeries(QStringList categories, QObject* parent=0);
                 virtual QSeriesType type() const { return QSeries::SeriesTypeBar; }
                 void addBarSet(QBarSet *set);               // Takes ownership of set
                 void removeBarSet(QBarSet *set);            // Releases ownership, doesn't delete set
                 int barsetCount();
                 int categoryCount();
                 QList<QBarSet*> barSets();
-                QList<QSeries::Legend> legend();
+                QList<QSeries::LegendEntry> legendEntries();
             public:
                 // TODO: Functions below this are not part of api and will be moved
                 // to private implementation, when we start using it
                 // TODO: TO PIMPL --->
                 QBarSet* barsetAt(int index);
                 QString categoryName(int category);
                 qreal min();
                 qreal max();
                 qreal valueAt(int set, int category);
                 qreal percentageAt(int set, int category);
                 qreal categorySum(int category);
                 qreal maxCategorySum();
                 BarChartModel& model();
                 bool separatorsVisible();
                 // <--- TO PIMPL
             signals:
                 //void changed(int index);
                 void clicked(QBarSet* barset, QString category);        // Up to user of api, what to do with these signals
                 void rightClicked(QBarSet* barset, QString category);
                 // TODO: internal signals, these to private implementation.
                 // TODO: TO PIMPL --->
                 void enableSeparators(bool enable);
                 void showToolTip(QPoint pos, QString tip);
                 // <--- TO PIMPL
             public Q_SLOTS:
                 void setToolTipEnabled(bool enabled=true);           // enables tooltips
                 void setSeparatorsVisible(bool visible=true);        // enables separators between categories
                 // TODO: TO PIMPL --->
                 void barsetClicked(QString category);
                 void barsetRightClicked(QString category);
                 // <--- TO PIMPL
             protected:
                 BarChartModel* mModel;
                 bool mSeparatorsVisible;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // BARSERIES_H

src/qchart.cpp +16 -1

             #include "qchart.h"
             #include "qchartaxis.h"
+            #include "qlegend.h"
             #include "chartpresenter_p.h"
             #include "chartdataset_p.h"
             #include <QGraphicsScene>
             #include <QGraphicsSceneResizeEvent>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \enum QChart::ChartTheme
                 This enum describes the theme used by the chart.
                 \value ChartThemeDefault
                 \value ChartThemeVanilla
                 \value ChartThemeIcy
                 \value ChartThemeGrayscale
                 \value ChartThemeScientific
             */
             /*!
                 \enum QChart::AnimationOption
                 For enabling/disabling animations. Defaults to NoAnimation.
                 \value NoAnimation
                 \value GridAxisAnimations
                 \value SeriesAnimations
                 \value AllAnimations
             */
             /*!
                 \class QChart
                 \brief QtCommercial chart API.
                 QChart is a QGraphicsWidget that you can show in a QGraphicsScene. It manages the graphical
                 representation of different types of QChartSeries and other chart related objects like
                 QChartAxis and QChartLegend. If you simply want to show a chart in a layout, you can use the
                 convenience class QChartView instead of QChart.
                 \sa QChartView
             */
             /*!
                 Constructs a chart object which is a child of a\a parent. Parameter \a wFlags is passed to the QGraphicsWidget constructor.
             */
             QChart::QChart(QGraphicsItem *parent, Qt::WindowFlags wFlags) : QGraphicsWidget(parent,wFlags),
                 m_backgroundItem(0),
                 m_titleItem(0),
                 m_dataset(new ChartDataSet(this)),
-                m_presenter(new ChartPresenter(this,m_dataset))
+                m_presenter(new ChartPresenter(this,m_dataset)),
+                m_legend(new QLegend(this)) // TODO: is this the parent we want the legend to have?
             {
+                connect(m_dataset,SIGNAL(seriesAdded(QSeries*,Domain*)),m_legend,SLOT(handleSeriesAdded(QSeries*,Domain*)));
+                connect(m_dataset,SIGNAL(seriesRemoved(QSeries*)),m_legend,SLOT(handleSeriesRemoved(QSeries*)));
             }
             /*!
                 Destroys the object and it's children, like QChartSeries and QChartAxis object added to it.
             */
             QChart::~QChart()
             {
+                disconnect(m_dataset,SIGNAL(seriesAdded(QSeries*,Domain*)),m_legend,SLOT(handleSeriesAdded(QSeries*,Domain*)));
+                disconnect(m_dataset,SIGNAL(seriesRemoved(QSeries*)),m_legend,SLOT(handleSeriesRemoved(QSeries*)));
             }
             /*!
                 Adds the \a series and optional \a axisY onto the chart and takes the ownership of the objects.
                 If auto scaling is enabled, re-scales the axes the series is bound to (both the x axis and
                 the y axis).
             */
             void QChart::addSeries(QSeries* series, QChartAxis* axisY)
             {
                 m_dataset->addSeries(series, axisY);
             }
             /*!
                 Removes the \a series specified in a perameter from the QChartView.
                 It releses its ownership of the specified QChartSeries object.
                 It does not delete the pointed QChartSeries data object
                 \sa addSeries(), removeAllSeries()
             */
             void QChart::removeSeries(QSeries* series)
             {
                 m_dataset->removeSeries(series);
             }
             /*!
                 Removes all the QChartSeries that have been added to the QChartView
                 It also deletes the pointed QChartSeries data objects
                 \sa addSeries(), removeSeries()
             */
             void QChart::removeAllSeries()
             {
                 m_dataset->removeAllSeries();
             }
             /*!
                 Sets the \a brush that is used for painting the background of the chart area.
             */
             void QChart::setChartBackgroundBrush(const QBrush& brush)
             {
                 createChartBackgroundItem();
                 m_backgroundItem->setBrush(brush);
                 m_backgroundItem->update();
             }
             /*!
                 Sets the \a pen that is used for painting the background of the chart area.
             */
             void QChart::setChartBackgroundPen(const QPen& pen)
             {
                 createChartBackgroundItem();
                 m_backgroundItem->setPen(pen);
                 m_backgroundItem->update();
             }
             /*!
                 Sets the chart \a title. The description text that is drawn above the chart.
             */
             void QChart::setChartTitle(const QString& title)
             {
                 createChartTitleItem();
                 m_titleItem->setText(title);
             }
             /*!
                 Returns the chart title. The description text that is drawn above the chart.
             */
             QString QChart::chartTitle() const
             {
                 if(m_titleItem)
                 return m_titleItem->text();
                 else
                 return QString();
             }
             /*!
                 Sets the \a font that is used for rendering the description text that is rendered above the chart.
             */
             void QChart::setChartTitleFont(const QFont& font)
             {
                 createChartTitleItem();
                 m_titleItem->setFont(font);
             }
             /*!
                 Sets the \a brush used for rendering the title text.
             */
             void QChart::setChartTitleBrush(const QBrush &brush)
             {
                 createChartTitleItem();
                 m_titleItem->setBrush(brush);
             }
             /*!
                 Returns the brush used for rendering the title text.
             */
             QBrush QChart::chartTitleBrush()
             {
                 createChartTitleItem();
                 return m_titleItem->brush();
             }
             void QChart::createChartBackgroundItem()
             {
                 if(!m_backgroundItem) {
                     m_backgroundItem = new QGraphicsRectItem(this);
                     m_backgroundItem->setPen(Qt::NoPen);
                     m_backgroundItem->setZValue(ChartPresenter::BackgroundZValue);
                 }
             }
             void QChart::createChartTitleItem()
             {
                 if(!m_titleItem) {
                     m_titleItem = new QGraphicsSimpleTextItem(this);
                     m_titleItem->setZValue(ChartPresenter::BackgroundZValue);
                 }
             }
             /*!
                 Returns the chart margin, which is the distance between the widget edge and the part of the chart where the actual data can be displayed.
                 \sa setMargin()
             */
             int QChart::margin() const
             {
                 return m_presenter->margin();
             }
             /*!
                 Sets the chart \a margin, which is the distance between the widget edge and the part of the chart where the actual data can be displayed.
                 \sa margin()
             */
             void QChart::setMargin(int margin)
             {
                 m_presenter->setMargin(margin);
             }
             /*!
                 Sets the \a theme used by the chart for rendering the graphical representation of the data
                 \sa ChartTheme, chartTheme()
             */
             void QChart::setChartTheme(QChart::ChartTheme theme)
             {
                 m_presenter->setChartTheme(theme);
             }
             /*!
                 Returns the theme enum used by the chart.
                 \sa ChartTheme, setChartTheme()
             */
             QChart::ChartTheme QChart::chartTheme() const
             {
                 return m_presenter->chartTheme();
             }
             /*!
                 Zooms in the view by a factor of 2
             */
             void QChart::zoomIn()
             {
                 m_presenter->zoomIn();
             }
             /*!
                 Zooms in the view to a maximum level at which \a rect is still fully visible.
             */
             void QChart::zoomIn(const QRectF& rect)
             {
                 if(!rect.isValid()) return;
                 m_presenter->zoomIn(rect);
             }
             /*!
                 Restores the view zoom level to the previous one.
             */
             void QChart::zoomOut()
             {
                 m_presenter->zoomOut();
             }
             /*!
                 Resets to the default view.
             */
             void QChart::zoomReset()
             {
                 m_presenter->zoomReset();
             }
             /*!
                 Returns the pointer to the x axis object of the chart
             */
             QChartAxis* QChart::axisX() const
             {
                 return m_dataset->axisX();
             }
             /*!
                 Returns the pointer to the y axis object of the chart
             */
             QChartAxis* QChart::axisY() const
             {
                 return m_dataset->axisY();
             }
             /*!
+                Returns the legend object of the chart
+            */
+            QLegend* QChart::legend() const
+            {
+                return m_legend;
+            }
+            /*!
                 Resizes and updates the chart area using the \a event data
             */
             void QChart::resizeEvent(QGraphicsSceneResizeEvent *event)
             {
                 m_rect = QRectF(QPoint(0,0),event->newSize());
                 QRectF rect = m_rect.adjusted(margin(),margin(), -margin(), -margin());
                 // recalculate title position
                 if (m_titleItem) {
                     QPointF center = m_rect.center() -m_titleItem->boundingRect().center();
                     m_titleItem->setPos(center.x(),m_rect.top()/2 + margin()/2);
                 }
                 //recalculate background gradient
                 if (m_backgroundItem) {
                     m_backgroundItem->setRect(rect);
                 }
                 QGraphicsWidget::resizeEvent(event);
                 update();
             }
             /*!
                 Sets animation \a options for the chart
             */
             void QChart::setAnimationOptions(AnimationOptions options)
             {
                 m_presenter->setAnimationOptions(options);
             }
             /*!
                 Returns animation options for the chart
             */
             QChart::AnimationOptions QChart::animationOptions() const
             {
                 return m_presenter->animationOptions();
             }
             #include "moc_qchart.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/qchart.h +4 0

             #ifndef QCHART_H
             #define QCHART_H
             #include <qchartglobal.h>
             #include <qseries.h>
             #include <QGraphicsWidget>
             #include <QLinearGradient>
             #include <QFont>
             class QGraphicsSceneResizeEvent;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class AxisItem;
             class QSeries;
             class PlotDomain;
             class BarPresenter;
             class QChartAxis;
             class ChartTheme;
             class ChartItem;
             class ChartDataSet;
             class ChartPresenter;
+            class QLegend;
             class QTCOMMERCIALCHART_EXPORT QChart : public QGraphicsWidget
             {
                 Q_OBJECT
             public:
                 enum ChartTheme {
                     ChartThemeDefault,
                     ChartThemeVanilla,
                     ChartThemeIcy,
                     ChartThemeGrayscale,
                     ChartThemeScientific
                     //ChartThemeUnnamed1
                     /*! The default theme follows the GUI style of the Operating System */
                 };
                 enum  AnimationOption {
                     NoAnimation = 0x0,
                     GridAxisAnimations = 0x1,
                     SeriesAnimations =0x2,
                     AllAnimations = 0x3
                     };
                     Q_DECLARE_FLAGS(AnimationOptions, AnimationOption)
             public:
                 QChart(QGraphicsItem *parent = 0, Qt::WindowFlags wFlags = 0);
                 ~QChart();
                 void addSeries(QSeries* series, QChartAxis* axisY = 0);
                 void removeSeries(QSeries* series); //returns ownership , deletes axis if no series attached
                 void removeAllSeries(); // deletes series and axis
                 void setMargin(int margin);
                 int margin() const;
                 void setChartTheme(QChart::ChartTheme theme);
                 QChart::ChartTheme chartTheme() const;
                 void setChartTitle(const QString& title);
                 QString chartTitle() const;
                 void setChartTitleFont(const QFont& font);
                 void setChartTitleBrush(const QBrush &brush);
                 QBrush chartTitleBrush();
                 void setChartBackgroundBrush(const QBrush& brush);
                 void setChartBackgroundPen(const QPen& pen);
                 void setAnimationOptions(AnimationOptions options);
                 AnimationOptions animationOptions() const;
                 void zoomIn();
                 void zoomIn(const QRectF& rect);
                 void zoomOut();
                 void zoomReset();
                 QChartAxis* axisX() const;
                 QChartAxis* axisY() const;
+                QLegend* legend() const;
             protected:
                 void resizeEvent(QGraphicsSceneResizeEvent *event);
             private:
                 inline void createChartBackgroundItem();
                 inline void createChartTitleItem();
             private:
                 Q_DISABLE_COPY(QChart)
                 QGraphicsRectItem* m_backgroundItem;
                 QGraphicsSimpleTextItem* m_titleItem;
                 QRectF m_rect;
                 ChartDataSet *m_dataset;
                 ChartPresenter *m_presenter;
+                QLegend* m_legend;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             Q_DECLARE_OPERATORS_FOR_FLAGS(QTCOMMERCIALCHART_NAMESPACE::QChart::AnimationOptions)
             #endif

src/qseries.h +3 -4

             #ifndef QSERIES_H
             #define QSERIES_H
             #include "qchartglobal.h"
             #include <QObject>
             #include <QAbstractItemModel>
             #include <QPen>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QTCOMMERCIALCHART_EXPORT QSeries : public QObject
             {
                 Q_OBJECT
             public:
                 enum QSeriesType {
                     SeriesTypeLine,
                     SeriesTypeArea,
                     SeriesTypeBar,
                     SeriesTypeStackedBar,
                     SeriesTypePercentBar,
                     SeriesTypePie,
                     SeriesTypeScatter,
                     SeriesTypeSpline
                 };
                 // Helper class to contain legend and color for it
                 // TODO: This as private class? Or should we expose this to user of API
-                class Legend {
+                class LegendEntry {
-                public:
+                    public:
                     QString mName;
                     QPen mPen;
                 };
             protected:
                 QSeries(QObject *parent = 0) : QObject(parent) {}
             public:
                 virtual ~QSeries() {}
                 virtual QSeriesType type() const = 0;
                 // TODO
                 virtual bool setModel(QAbstractItemModel* /*model*/) { return false; }
-                // TODO: should this be internal?
+                virtual QList<QSeries::LegendEntry> legendEntries() { QList<QSeries::LegendEntry> l; return l; }
-                virtual QList<QSeries::Legend> legend() { QList<QSeries::Legend> l; return l; }
                 void setTitle(QString title) { m_title = title; }
                 QString title() { return m_title; }
             private:
                 QString m_title;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

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
+                qseries.cpp \
+                qlegend.cpp
             PRIVATE_HEADERS += \
                 chartdataset_p.h \
                 chartitem_p.h \
                 chartpresenter_p.h \
                 charttheme_p.h \
                 domain_p.h
             PUBLIC_HEADERS += \
                 qchart.h \
                 qchartglobal.h \
                 qseries.h \
-                qchartview.h
+                qchartview.h \
+                qlegend.h
             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