HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r143:a0c24bcedc00

Refactor themes...

Michal Klocek -

r143:a0c24bcedc00

parent child

Context file:

r143:a0c24bcedc00

Collapse all files

src/themes/chartthemegrayscale_p.h created 644 +20 0

@@ -0,0 +1,20
	1	#include "charttheme_p.h"
	2
	3	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	4
	5	class ChartThemeGrayscale: public ChartTheme
	6	{
	7	public:
	8	ChartThemeGrayscale()
	9	{
	10	m_seriesColor.append(QRgb(0xFF869299));
	11	m_seriesColor.append(QRgb(0xFFA5BDCC));
	12	m_seriesColor.append(QRgb(0xFFE8FFFC));
	13	m_seriesColor.append(QRgb(0xFFCCC2C2));
	14
	15	m_gradientStartColor = QColor(QRgb(0xffffffff));
	16	m_gradientEndColor = QColor(QRgb(0xffafafaf));
	17	}
	18	};
	19
	20	QTCOMMERCIALCHART_END_NAMESPACE

src/themes/chartthemeicy_p.h created 644 +20 0

@@ -0,0 +1,20
	1	#include "charttheme_p.h"
	2
	3	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	4
	5	class ChartThemeIcy: public ChartTheme
	6	{
	7	public:
	8	ChartThemeIcy()
	9	{
	10	m_seriesColor.append(QRgb(0xFF0D2673));
	11	m_seriesColor.append(QRgb(0xFF2685BF));
	12	m_seriesColor.append(QRgb(0xFF3DADD9));
	13	m_seriesColor.append(QRgb(0xFF62C3D9));
	14
	15	m_gradientStartColor = QColor(QRgb(0xffBDE3F2));
	16	m_gradientEndColor = QColor(QRgb(0xffafafaf));
	17	}
	18	};
	19
	20	QTCOMMERCIALCHART_END_NAMESPACE

src/themes/chartthemescientific_p.h created 644 +20 0

@@ -0,0 +1,20
	1	#include "charttheme_p.h"
	2
	3	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	4
	5	class ChartThemeScientific: public ChartTheme
	6	{
	7	public:
	8	ChartThemeScientific()
	9	{
	10	m_seriesColor.append(QRgb(0xFF000000));
	11	m_seriesColor.append(QRgb(0xFFFFAD00));
	12	m_seriesColor.append(QRgb(0xFF596A75));
	13	m_seriesColor.append(QRgb(0xFF474747));
	14
	15	m_gradientStartColor = QColor(QRgb(0xffafafaf));
	16	m_gradientEndColor = QColor(QRgb(0xffafafaf));
	17	}
	18	};
	19
	20	QTCOMMERCIALCHART_END_NAMESPACE

src/themes/chartthemevanilla_p.h created 644 +21 0

@@ -0,0 +1,21
	1	#include "charttheme_p.h"
	2
	3	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	4
	5	class ChartThemeVanilla: public ChartTheme
	6	{
	7	public:
	8	ChartThemeVanilla()
	9	{
	10	m_seriesColor.append(QColor(217, 197, 116));
	11	m_seriesColor.append(QColor(214, 168, 150));
	12	m_seriesColor.append(QColor(160, 160, 113));
	13	m_seriesColor.append(QColor(210, 210, 52));
	14	m_seriesColor.append(QColor(136, 114, 58));
	15
	16	m_gradientStartColor = QColor(QRgb(0xff9d844d));
	17	m_gradientEndColor = QColor(QRgb(0xffafafaf));
	18	}
	19	};
	20
	21	QTCOMMERCIALCHART_END_NAMESPACE

src/chartpresenter.cpp +30 -23

             #include "qchart.h"
             #include "qchartaxis.h"
             #include "chartpresenter_p.h"
             #include "chartdataset_p.h"
+            #include "charttheme_p.h"
             //series
             #include "barchartseries.h"
             #include "stackedbarchartseries.h"
             #include "percentbarchartseries.h"
             #include "qxychartseries.h"
             #include "qpieseries.h"
             //items
             #include "axisitem_p.h"
             #include "bargroup.h"
             #include "stackedbargroup.h"
             #include "xylinechartitem_p.h"
             #include "percentbargroup.h"
             #include "linechartanimationitem_p.h"
             #include "piepresentation.h"
             #include <QAbstractAnimation>
             #include <QPropertyAnimation>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartPresenter::ChartPresenter(QChart* chart,ChartDataSet* dataset):QObject(chart),
             m_chart(chart),
             m_dataset(dataset),
+            m_chartTheme(0),
             m_domainIndex(0),
             m_marginSize(0),
             m_rect(QRectF(QPoint(0,0),m_chart->size()))
             {
+                setTheme(QChart::ChartThemeDefault);
                 createConnections();
                 createDeafultAxis();
             }
             ChartPresenter::~ChartPresenter()
             {
             }
             void ChartPresenter::createDeafultAxis()
             {
                 //default axis
                 QChartAxis* axisX = new QChartAxis(this);
                 QChartAxis* axisY = new QChartAxis(this);
                 m_axis << new AxisItem(axisX,AxisItem::X_AXIS,m_chart);
                 m_axis << new AxisItem(axisY,AxisItem::Y_AXIS,m_chart);
                 foreach(AxisItem* item, m_axis) {
                     QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&)));
                     QObject::connect(m_dataset,SIGNAL(domainChanged(const Domain&)),item,SLOT(handleDomainChanged(const Domain&)));
                 }
             }
             void ChartPresenter::createConnections()
             {
                 QObject::connect(m_chart,SIGNAL(geometryChanged()),this,SLOT(handleGeometryChanged()));
                 QObject::connect(m_dataset,SIGNAL(seriesAdded(QChartSeries*)),this,SLOT(handleSeriesAdded(QChartSeries*)));
             }
             void ChartPresenter::handleGeometryChanged()
             {
                 m_rect = QRectF(QPoint(0,0),m_chart->size());
                 m_rect.adjust(m_marginSize,m_marginSize, -m_marginSize, -m_marginSize);
                 emit geometryChanged(m_rect);
             }
             int ChartPresenter::margin() const
             {
                 return m_marginSize;
             }
             void ChartPresenter::setMargin(int margin)
             {
                 m_marginSize = margin;
             }
             void ChartPresenter::handleSeriesAdded(QChartSeries* series)
             {
                 switch(series->type())
                 {
                     case QChartSeries::SeriesTypeLine: {
                         QXYChartSeries* lineSeries = static_cast<QXYChartSeries*>(series);
                         XYLineChartItem* item = new LineChartAnimationItem(this,lineSeries,m_chart);
-                        item->setPen(lineSeries->pen());
+                        m_chartTheme->decorate(item,lineSeries,m_chartItems.count());
                         QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&)));
                         QObject::connect(m_dataset,SIGNAL(domainChanged(const Domain&)),item,SLOT(handleDomainChanged(const Domain&)));
                         QObject::connect(lineSeries,SIGNAL(changed(int)),item,SLOT(handleModelChanged(int)));
                         m_chartItems.insert(series,item);
                         break;
                     }
                     case QChartSeries::SeriesTypeBar: {
                         BarChartSeries* barSeries = static_cast<BarChartSeries*>(series);
                         BarGroup* item = new BarGroup(*barSeries,m_chart);
+                        m_chartTheme->decorate(item,barSeries,m_chartItems.count());
-                        // Add some fugly colors for 5 fist series...
-                        item->addColor(QColor(255,0,0,128));
-                        item->addColor(QColor(255,255,0,128));
-                        item->addColor(QColor(0,255,0,128));
-                        item->addColor(QColor(0,0,255,128));
-                        item->addColor(QColor(255,128,0,128));
                         QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&)));
                         QObject::connect(m_dataset,SIGNAL(domainChanged(const Domain&)),item,SLOT(handleDomainChanged(const Domain&)));
                         QObject::connect(barSeries,SIGNAL(changed(int)),item,SLOT(handleModelChanged(int)));
                         m_chartItems.insert(series,item);
                         // m_axisXItem->setVisible(false);
                         break;
                     }
                     case QChartSeries::SeriesTypeStackedBar: {
                         StackedBarChartSeries* stackedBarSeries = static_cast<StackedBarChartSeries*>(series);
                         StackedBarGroup* item = new StackedBarGroup(*stackedBarSeries,m_chart);
+                        m_chartTheme->decorate(item,stackedBarSeries,m_chartItems.count());
-                        // Add some fugly colors for 5 fist series...
-                        item->addColor(QColor(255,0,0,128));
-                        item->addColor(QColor(255,255,0,128));
-                        item->addColor(QColor(0,255,0,128));
-                        item->addColor(QColor(0,0,255,128));
-                        item->addColor(QColor(255,128,0,128));
                         QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&)));
                         QObject::connect(m_dataset,SIGNAL(domainChanged(const Domain&)),item,SLOT(handleDomainChanged(const Domain&)));
                         QObject::connect(stackedBarSeries,SIGNAL(changed(int)),item,SLOT(handleModelChanged(int)));
                         m_chartItems.insert(series,item);
                         break;
                     }
                     case QChartSeries::SeriesTypePercentBar: {
                         PercentBarChartSeries* percentBarSeries = static_cast<PercentBarChartSeries*>(series);
                         PercentBarGroup* item = new PercentBarGroup(*percentBarSeries,m_chart);
+                        m_chartTheme->decorate(item,percentBarSeries ,m_chartItems.count());
-                        // Add some fugly colors for 5 fist series...
-                        item->addColor(QColor(255,0,0,128));
-                        item->addColor(QColor(255,255,0,128));
-                        item->addColor(QColor(0,255,0,128));
-                        item->addColor(QColor(0,0,255,128));
-                        item->addColor(QColor(255,128,0,128));
                         QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&)));
                         QObject::connect(m_dataset,SIGNAL(domainChanged(const Domain&)),item,SLOT(handleDomainChanged(const Domain&)));
                         QObject::connect(percentBarSeries,SIGNAL(changed(int)),item,SLOT(handleModelChanged(int)));
                         m_chartItems.insert(series,item);
                         break;
                     }
                     /*
                      case QChartSeries::SeriesTypeScatter: {
                      QScatterSeries *scatterSeries = qobject_cast<QScatterSeries *>(series);
                      scatterSeries->d->m_theme = m_chartTheme->themeForSeries();
                      scatterSeries->d->setParentItem(this);
                      scatterSeries->d->m_boundingRect = m_rect.adjusted(margin(),margin(), -margin(), -margin());
                      m_chartItems << scatterSeries->d;
                      m_chartTheme->addObserver(scatterSeries->d);
                      foreach (qreal x, scatterSeries->d->m_x) {
                      domain.m_minX = qMin(domain.m_minX, x);
                      domain.m_maxX = qMax(domain.m_maxX, x);
                      }
                      foreach (qreal y, scatterSeries->d->m_y) {
                      domain.m_minY = qMin(domain.m_minY, y);
                      domain.m_maxY = qMax(domain.m_maxY, y);
                      }
                      break;
                      }
                      */
                     case QChartSeries::SeriesTypePie: {
                         QPieSeries *pieSeries = qobject_cast<QPieSeries *>(series);
                         PiePresentation* pieChart = new PiePresentation(m_chart, pieSeries);
                         pieSeries->m_piePresentation = pieChart; // TODO: remove this pointer passing use signals&slots
                         QObject::connect(this, SIGNAL(geometryChanged(const QRectF&)), pieChart, SLOT(handleGeometryChanged(const QRectF&)));
                         QObject::connect(m_dataset, SIGNAL(domainChanged(const Domain&)), pieChart, SLOT(handleDomainChanged(const Domain&)));
                         m_chartItems.insert(series, pieChart);
                         break;
                     }
                     default: {
                         qDebug()<< "Series type" << series->type() << "not implemented.";
                         break;
                     }
                 }
             }
             void ChartPresenter::handleSeriesChanged(QChartSeries* series)
             {
                 //TODO:
             }
             void ChartPresenter::zoomInToRect(const QRectF& rect)
             {
                 if(!rect.isValid()) return;
                 QRectF r = rect.normalized();
                 r.translate(-m_marginSize, -m_marginSize);
                 Domain domain (m_dataset->domain().subDomain(rect,m_rect.width(),m_rect.height()));
                 m_dataset->addDomain(domain);
             }
             void ChartPresenter::zoomIn()
             {
                 if (!m_dataset->nextDomain()) {
                     QRectF rect = m_rect;
                     rect.setWidth(rect.width()/2);
                     rect.setHeight(rect.height()/2);
                     rect.moveCenter(m_rect.center());
                     Domain domain (m_dataset->domain().subDomain(rect,m_rect.width(),m_rect.height()));
                     m_dataset->addDomain(domain);
                 }
             }
             void ChartPresenter::zoomOut()
             {
                 m_dataset->previousDomain();
             }
             void ChartPresenter::zoomReset()
             {
                 m_dataset->clearDomains();
             }
+            void ChartPresenter::setTheme(QChart::ChartThemeId theme)
+            {
+                delete m_chartTheme;
+                m_chartTheme = ChartTheme::createTheme(theme);
+                m_chartTheme->decorate(m_chart);
+                QMapIterator<QChartSeries*,ChartItem*> i(m_chartItems);
+                int index=0;
+                while (i.hasNext()) {
+                    i.next();
+                    index++;
+                    m_chartTheme->decorate(i.value(),i.key(),index);
+                  }
+                }
+            QChart::ChartThemeId ChartPresenter::theme()
+            {
+                return (QChart::ChartThemeId) 0;
+            }
             /*
              void ChartPresenter::setAxisX(const QChartAxis& axis)
              {
              setAxis(m_axisXItem,axis);
              }
              void ChartPresenter::setAxisY(const QChartAxis& axis)
              {
              setAxis(m_axisYItem.at(0),axis);
              }
              void ChartPresenter::setAxisY(const QList<QChartAxis>& axis)
              {
              //TODO not implemented
              }
              void ChartPresenter::setAxis(AxisItem *item, const QChartAxis& axis)
              {
              item->setVisible(axis.isAxisVisible());
              }
              */
             #include "moc_chartpresenter_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/chartpresenter_p.h +8 -1

             #ifndef CHARTPRESENTER_H_
             #define CHARTPRESENTER_H_
             #include "qchartglobal.h"
+            #include "qchart.h" //becouse of QChart::ChartThemeId //TODO
             #include <QRectF>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartItem;
             class QChartSeries;
             class ChartDataSet;
-            class QChart;
+            //class QChart;
             class Domain;
             class AxisItem;
+            class ChartTheme;
             class ChartPresenter: public QObject
             {
                 Q_OBJECT
             public:
                 ChartPresenter(QChart* chart,ChartDataSet *dataset);
                 virtual ~ChartPresenter();
             /*
                 void setAxisX(const QChartAxis& axis);
                 void setAxisY(const QChartAxis& axis);
                 void setAxisY(const QList<QChartAxis>& axis);
             */
                 void setMargin(int margin);
                 int margin() const;
                 void zoomInToRect(const QRectF& rectangle);
                 void zoomIn();
                 void zoomOut();
                 void zoomReset();
+                void setTheme(QChart::ChartThemeId theme);
+                QChart::ChartThemeId theme();
             private:
                 void createConnections();
                 void createDeafultAxis();
             public slots:
                 void handleSeriesAdded(QChartSeries* series);
                 void handleSeriesRemoved(QChartSeries* series){};
                 void handleSeriesChanged(QChartSeries* series);
                 //void handleDomainChanged(Domain oldDomain,Domain newDomain);
                 void handleGeometryChanged();
             signals:
                 void geometryChanged(const QRectF& rect);
             private:
                 QMap<QChartSeries*,ChartItem*> m_chartItems;
                 QChart* m_chart;
                 ChartDataSet* m_dataset;
                 QVector<Domain> m_domains;
                 QList<AxisItem*> m_axis;
+                ChartTheme *m_chartTheme;
                 int m_domainIndex;
                 int m_marginSize;
                 QRectF m_rect;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif /* CHARTPRESENTER_H_ */

src/charttheme.cpp +110 -80

@@ -1,112 +1,142
1	#include "charttheme_p.h"	1	#include "charttheme_p.h"
2	#include "qchart.h"	2	#include "qchart.h"
3		3
4	QTCOMMERCIALCHART_BEGIN_NAMESPACE
5		4
6	void ChartThemeData::setTheme(int theme)	5	//series
7	{	6	#include "barchartseries.h"
8	m_seriesThemes.clear();	7	#include "stackedbarchartseries.h"
9	m_seriesIndex = 0;	8	#include "percentbarchartseries.h"
10	m_currentTheme = theme;	9	#include "qxychartseries.h"
11		10	//items
12	switch (theme) {	11	#include "axisitem_p.h"
13	case QChart::ChartThemeDefault:	12	#include "bargroup.h"
14	// line: solid, dashed, dotted	13	#include "stackedbargroup.h"
15	// line width: 1	14	#include "xylinechartitem_p.h"
16	// line color (and opacity)	15	#include "percentbargroup.h"
17	// line shadow (on/off)
18	// marker shape: "x", "o", "."
19	// TODO: define the default theme based on the OS
20	m_seriesThemes.append(SeriesTheme(QRgb(0xff000000), 2));
21	m_seriesThemes.append(SeriesTheme(QRgb(0xff707070), 2));
22	m_gradientStartColor = QColor(QRgb(0xffffffff));
23	m_gradientEndColor = QColor(QRgb(0xffafafaf));
24	break;
25	case QChart::ChartThemeVanilla:
26	m_seriesThemes.append(SeriesTheme(QColor(217, 197, 116), 6));
27	m_seriesThemes.append(SeriesTheme(QColor(214, 168, 150), 4));
28	m_seriesThemes.append(SeriesTheme(QColor(160, 160, 113), 6));
29	m_seriesThemes.append(SeriesTheme(QColor(210, 210, 52), 4));
30	m_seriesThemes.append(SeriesTheme(QColor(136, 114, 58), 6));
31
32	m_gradientStartColor = QColor(QRgb(0xff9d844d));
33	m_gradientEndColor = QColor(QRgb(0xffafafaf));
34	break;
35	case QChart::ChartThemeIcy:
36	m_seriesThemes.append(SeriesTheme(QRgb(0xFF0D2673), 2));
37	m_seriesThemes.append(SeriesTheme(QRgb(0xFF2685BF), 2));
38	m_seriesThemes.append(SeriesTheme(QRgb(0xFF3DADD9), 3));
39	m_seriesThemes.append(SeriesTheme(QRgb(0xFF62C3D9), 2));
40		16
41	m_gradientStartColor = QColor(QRgb(0xffBDE3F2));	17	//themes
42	m_gradientEndColor = QColor(QRgb(0xffafafaf));	18	#include "chartthemevanilla_p.h"
43	break;	19	#include "chartthemeicy_p.h"
44	case QChart::ChartThemeGrayscale:	20	#include "chartthemegrayscale_p.h"
45	m_seriesThemes.append(SeriesTheme(QRgb(0xFF869299), 2));	21	#include "chartthemescientific_p.h"
46	m_seriesThemes.append(SeriesTheme(QRgb(0xFFA5BDCC), 2));
47	m_seriesThemes.append(SeriesTheme(QRgb(0xFFE8FFFC), 3));
48	m_seriesThemes.append(SeriesTheme(QRgb(0xFFCCC2C2), 2));
49		22
50	m_gradientStartColor = QColor(QRgb(0xffffffff));
51	m_gradientEndColor = QColor(QRgb(0xffafafaf));
52	break;
53	case QChart::ChartThemeScientific:
54	m_seriesThemes.append(SeriesTheme(QRgb(0xFF000000), 3));
55	m_seriesThemes.append(SeriesTheme(QRgb(0xFFFFAD00), 2));
56	m_seriesThemes.append(SeriesTheme(QRgb(0xFF596A75), 2));
57	m_seriesThemes.append(SeriesTheme(QRgb(0xFF474747), 2));
58		23
59	m_gradientStartColor = QColor(QRgb(0xffafafaf));	24	QTCOMMERCIALCHART_BEGIN_NAMESPACE
60	m_gradientEndColor = QColor(QRgb(0xffafafaf));	25
61	break;	26	/* TODO
62	case QChart::ChartThemeUnnamed1:	27	case QChart::ChartThemeUnnamed1:
63	m_seriesThemes.append(SeriesTheme(QColor(QRgb(0xff3fa9f5)), 2));	28	m_seriesThemes.append(SeriesTheme(QColor(QRgb(0xff3fa9f5)), 2));
64	m_seriesThemes.append(SeriesTheme(QColor(QRgb(0xff7AC943)), 2));	29	m_seriesThemes.append(SeriesTheme(QColor(QRgb(0xff7AC943)), 2));
65	m_seriesThemes.append(SeriesTheme(QColor(QRgb(0xffFF931E)), 2));	30	m_seriesThemes.append(SeriesTheme(QColor(QRgb(0xffFF931E)), 2));
66	m_seriesThemes.append(SeriesTheme(QColor(QRgb(0xffFF1D25)), 2));	31	m_seriesThemes.append(SeriesTheme(QColor(QRgb(0xffFF1D25)), 2));
67	m_seriesThemes.append(SeriesTheme(QColor(QRgb(0xffFF7BAC)), 2));	32	m_seriesThemes.append(SeriesTheme(QColor(QRgb(0xffFF7BAC)), 2));
68		33
69	m_gradientStartColor = QColor(QRgb(0xfff3dc9e));	34	m_gradientStartColor = QColor(QRgb(0xfff3dc9e));
70	m_gradientEndColor = QColor(QRgb(0xffafafaf));	35	m_gradientEndColor = QColor(QRgb(0xffafafaf));
71	break;	36	*/
72	default:	37
73	Q_ASSERT(false);	38	ChartTheme::ChartTheme()
		39	{
		40	m_seriesColor.append(QRgb(0xff000000));
		41	m_seriesColor.append(QRgb(0xff707070));
		42	m_gradientStartColor = QColor(QRgb(0xffffffff));
		43	m_gradientEndColor = QColor(QRgb(0xffafafaf));
		44	}
		45
		46
		47	ChartTheme* ChartTheme::createTheme(QChart::ChartThemeId theme)
		48	{
		49	switch(theme) {
		50	case QChart::ChartThemeDefault:
		51	return new ChartTheme();
		52	case QChart::ChartThemeVanilla:
		53	return new ChartThemeVanilla();
		54	case QChart::ChartThemeIcy:
		55	return new ChartThemeIcy();
		56	case QChart::ChartThemeGrayscale:
		57	return new ChartThemeGrayscale();
		58	case QChart::ChartThemeScientific:
		59	return new ChartThemeScientific();
		60	}
		61	}
		62
		63	void ChartTheme::decorate(QChart* chart)
		64	{
		65	QLinearGradient backgroundGradient;
		66	backgroundGradient.setColorAt(0.0, m_gradientStartColor);
		67	backgroundGradient.setColorAt(1.0, m_gradientEndColor);
		68	backgroundGradient.setCoordinateMode(QGradient::ObjectBoundingMode);
		69	chart->setChartBackgroundBrush(backgroundGradient);
		70	}
		71	//TODO helper to by removed later
		72	void ChartTheme::decorate(ChartItem* item, QChartSeries* series,int count)
		73	{
		74	switch(series->type())
		75	{
		76	case QChartSeries::SeriesTypeLine: {
		77	QXYChartSeries* s = static_cast<QXYChartSeries*>(series);
		78	XYLineChartItem* i = static_cast<XYLineChartItem*>(item);
		79	decorate(i,s,count);
		80	break;
		81	}
		82	case QChartSeries::SeriesTypeBar: {
		83	BarChartSeries* b = static_cast<BarChartSeries*>(series);
		84	BarGroup* i = static_cast<BarGroup*>(item);
		85	decorate(i,b,count);
		86	break;
		87	}
		88	case QChartSeries::SeriesTypeStackedBar: {
		89	StackedBarChartSeries* s = static_cast<StackedBarChartSeries*>(series);
		90	StackedBarGroup* i = static_cast<StackedBarGroup*>(item);
		91	decorate(i,s,count);
		92	break;
		93	}
		94	case QChartSeries::SeriesTypePercentBar: {
		95	PercentBarChartSeries* s = static_cast<PercentBarChartSeries*>(series);
		96	PercentBarGroup* i = static_cast<PercentBarGroup*>(item);
		97	decorate(i,s,count);
		98	break;
		99	}
		100	default:
		101	qDebug()<<"Wrong item to be decorated by theme";
74	break;	102	break;
75	}	103	}
		104
76	}	105	}
77		106
78	ChartTheme::ChartTheme(QObject *parent) :	107	void ChartTheme::decorate(XYLineChartItem* item, QXYChartSeries* series,int count)
79	QObject(parent),
80	d(new ChartThemeData())
81	{	108	{
82	d->m_currentTheme = QChart::ChartThemeInvalid;	109	item->setPen(series->pen());
83	d->m_seriesIndex = 0;
84	}	110	}
85		111
86	void ChartTheme::setTheme(int theme)	112	void ChartTheme::decorate(BarGroup* item, BarChartSeries* series,int count)
87	{	113	{
88	if (theme != d->m_currentTheme) {	114	item->addColor(QColor(255,0,0,128));
89	d->setTheme(theme);	115	item->addColor(QColor(255,255,0,128));
90	foreach (ChartThemeObserver *o, d->m_observers)	116	item->addColor(QColor(0,255,0,128));
91	o->themeChanged(this);	117	item->addColor(QColor(0,0,255,128));
92	}	118	item->addColor(QColor(255,128,0,128));
93	}	119	}
94		120
95	SeriesTheme ChartTheme::themeForSeries()	121	void ChartTheme::decorate(StackedBarGroup* item, StackedBarChartSeries* series,int count)
96	{	122	{
97	if (d->m_seriesThemes.count() == 0) {	123	// Add some fugly colors for 5 fist series...
98	return SeriesTheme();	124	item->addColor(QColor(255,0,0,128));
99	} else {	125	item->addColor(QColor(255,255,0,128));
100	// Get the next available theme for the series; if no more themes available start over	126	item->addColor(QColor(0,255,0,128));
101	// beginning from the first theme in the list	127	item->addColor(QColor(0,0,255,128));
102	SeriesTheme nextTheme =	128	item->addColor(QColor(255,128,0,128));
103	d->m_seriesThemes[d->m_seriesIndex % d->m_seriesThemes.count()];
104	d->m_seriesIndex++;
105	return nextTheme;
106	}
107	}	129	}
108		130
		131	void ChartTheme::decorate(PercentBarGroup* item, PercentBarChartSeries* series,int count)
		132	{
		133	// Add some fugly colors for 5 fist series...
		134	item->addColor(QColor(255,0,0,128));
		135	item->addColor(QColor(255,255,0,128));
		136	item->addColor(QColor(0,255,0,128));
		137	item->addColor(QColor(0,0,255,128));
		138	item->addColor(QColor(255,128,0,128));
		139	}
109		140
110	#include "moc_charttheme_p.cpp"
111		141
112	QTCOMMERCIALCHART_END_NAMESPACE	142	QTCOMMERCIALCHART_END_NAMESPACE

src/charttheme_p.h +25 -66

@@ -1,84 +1,43
1	#ifndef CHARTTHEME_H	1	#ifndef CHARTTHEME_H
2	#define CHARTTHEME_H	2	#define CHARTTHEME_H
3		3
4	#include "qchartglobal.h"	4	#include "qchartglobal.h"
5	#include <QObject>	5	#include "qchart.h"
6	#include <QSharedData>
7	#include <QColor>	6	#include <QColor>
8	#include <QLinearGradient>
9	#include <QPen>
10		7
11	QTCOMMERCIALCHART_BEGIN_NAMESPACE	8	QTCOMMERCIALCHART_BEGIN_NAMESPACE
12		9
13	class Chart~~Theme~~;	10	class ChartItem;
14		11	class QChartSeries;
15	class ChartThemeObserver	12	class XYLineChartItem;
16	{	13	class QXYChartSeries;
17	public:	14	class BarGroup;
18	virtual void themeChanged(ChartTheme *theme) = 0;	15	class BarChartSeries;
19	};	16	class StackedBarGroup;
20		17	class StackedBarChartSeries;
21	/*!	18	class PercentBarChartSeries;
22	* The theme specific settings for the appearance of a series. TODO: These can be overridden by setting	19	class PercentBarGroup;
23	* custom settings to a QChartSeries object.	20
24	*/	21	class ChartTheme
25	struct SeriesTheme {
26	public:
27	SeriesTheme() :
28	linePen(QPen()),
29	markerPen(QPen()) {}
30	SeriesTheme(QColor lineColor, qreal lineWidth/, QPen marker/) :
31	linePen(QPen(QBrush(lineColor), lineWidth)),
32	markerPen(linePen) {}
33
34	//const QBrush & brush, qreal width, Qt::PenStyle style = Qt::SolidLine, Qt::PenCapStyle cap = Qt::SquareCap, Qt::PenJoinStyle join = Qt::BevelJo
35	// TODO:
36	//QColor lineColor;
37	QPen linePen;
38	//QBrush lineBrush;
39	QPen markerPen;
40	//QBrush markerBrush;
41	};
42
43	/*!
44	* Explicitly shared data class for the themes.
45	*/
46	class ChartThemeData : public QSharedData
47	{	22	{
		23	protected:
		24	explicit ChartTheme();
48	public:	25	public:
49	ChartThemeData() : m_currentTheme(0) {}	26	static ChartTheme* createTheme(QChart::ChartThemeId theme);
50	~ChartThemeData() {}	27	void decorate(QChart* chart);
51		28	void decorate(ChartItem* item, QChartSeries* series,int count);
52	public:	29	void decorate(XYLineChartItem* item, QXYChartSeries*, int count);
53	void setTheme(int theme);	30	void decorate(BarGroup* item, BarChartSeries* series,int count);
54		31	void decorate(StackedBarGroup* item, StackedBarChartSeries* series,int count);
55	public:	32	void decorate(PercentBarGroup* item, PercentBarChartSeries* series,int count);
56	int m_currentTheme;	33
57	QList<ChartThemeObserver *> m_observers;	34	protected:
58	QColor m_gradientStartColor;	35	QColor m_gradientStartColor;
59	QColor m_gradientEndColor;	36	QColor m_gradientEndColor;
60	QList<~~SeriesTheme~~> m_series~~Themes~~;	37	QList<QColor> m_seriesColor;
61	int m_seriesIndex;
62	};
63		38
64	class ChartTheme : public QObject
65	{
66	Q_OBJECT
67	public:
68	explicit ChartTheme(QObject *parent = 0);
69	explicit ChartTheme(const ChartTheme &other, QObject *parent = 0) : QObject(parent), d(other.d) {}
70	void operator =(const ChartTheme &other) { d = other.d; }
71
72	void setTheme(int theme);
73	SeriesTheme themeForSeries();
74	void addObserver(ChartThemeObserver *o) { d->m_observers << o; }
75
76	public:
77	// All the graphical elements of a QChart share the same theme settings
78	// so let's use explicitly shared data
79	QExplicitlySharedDataPointer<ChartThemeData> d;
80	};	39	};
81		40
82	QTCOMMERCIALCHART_END_NAMESPACE	41	QTCOMMERCIALCHART_END_NAMESPACE
83		42
84	#endif // CHARTTHEME_H	43	#endif // CHARTTHEME_H

src/piechart/pieslice.cpp +1 0

             #include "pieslice.h"
             #include "piepresentation.h"
             #include <QPainter>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             PieSlice::PieSlice(PiePresentation *piePresentation, int seriesIndex, qreal startAngle, qreal span)
                 :QGraphicsItem(piePresentation),
                 m_seriesIndex(seriesIndex),
                 m_startAngle(startAngle),
                 m_span(span)
             {
                 Q_ASSERT(piePresentation);
                 setAcceptHoverEvents(true);
                 setAcceptedMouseButtons(Qt::LeftButton);
             }
             PieSlice::~PieSlice()
             {
             }
             QRectF PieSlice::boundingRect() const
             {
                 return shape().boundingRect();
             }
             QPainterPath PieSlice::shape() const
             {
                 QRectF rect = (static_cast<PiePresentation*>(parentItem()))->pieRect();
                 qreal angle = (-m_startAngle) + (90);
                 qreal span = -m_span;
                 QPainterPath path;
                 path.moveTo(rect.center());
                 path.arcTo(rect, angle, span);
                 // TODO: draw the shape so that it might have a hole in the center
                 // - Sin & Cos will be needed to find inner/outer arc endpoints
                 // dx, dy are offsets from the center
                 //qreal l = boundingRect().height();
                 //qreal dx = qSin(angle*(M_PI/180)) * l;
                 //qreal dy = qCos(angle*(M_PI/180)) * l;
                 // TODO: exploded slice?
                 return path;
             }
             void PieSlice::paint(QPainter* painter, const QStyleOptionGraphicsItem* /*option*/, QWidget* /*widget*/)
             {
                 painter->setRenderHint(QPainter::Antialiasing);
                 // TODO: how to map theme settings to a pie slice? Now we
                 //painter->setPen(m_theme.linePen);
                 // TODO:
                 QPieSlice data = (static_cast<PiePresentation*>(parentItem()))->m_pieSeries->slice(m_seriesIndex);
                 painter->setBrush(data.m_color);
                 //painter->setBrush(m_theme.linePen.color());
                 // From Qt docs:
                 // The startAngle and spanAngle must be specified in 1/16th of a degree, i.e. a full circle equals 5760 (16 * 360).
                 // Positive values for the angles mean counter-clockwise while negative values mean the clockwise direction.
                 // Zero degrees is at the 3 o'clock position.
                 //
                 // For sake of simplicity convert this so that zero degrees is at 12 o'clock and full circle is 360.
                 //qreal angle = (-m_startAngle*16) + (90*16);
                 //qreal span = -m_span*16;
                 //painter->drawPie(boundingRect(), angle, span);
                 painter->drawPath(shape());
                 // Draw the label
                 // TODO: do this better
                 painter->drawText(boundingRect().center(), data.m_label);
             }
             void PieSlice::hoverEnterEvent(QGraphicsSceneHoverEvent * event)
             {
                 QGraphicsItem::hoverEnterEvent(event);
                 qDebug() << "hover" << m_seriesIndex << m_startAngle << m_span;
             }
             void PieSlice::mousePressEvent(QGraphicsSceneMouseEvent *event)
             {
                 QGraphicsItem::mousePressEvent(event);
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/pieslice.h +1 0

             #ifndef PIESLICE_H
             #define PIESLICE_H
             #include "qchartglobal.h"
             #include "charttheme_p.h"
             #include <QGraphicsItem>
             #include <QRectF>
             #include <QColor>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class PiePresentation;
             class PieSlice : public QGraphicsItem
             {
             public:
                 PieSlice(PiePresentation *piePresentation, int seriesIndex, qreal startAngle, qreal span);
                 ~PieSlice();
             public: // from QGraphicsItem
                 QRectF boundingRect() const;
                 QPainterPath shape() const;
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
                 void hoverEnterEvent(QGraphicsSceneHoverEvent *event);
                 void mousePressEvent(QGraphicsSceneMouseEvent *event);
             private:
                 int m_seriesIndex;
                 qreal m_startAngle;
                 qreal m_span;
+                QRectF m_rect;
                 //SeriesTheme m_theme;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // PIESLICE_H

src/qchart.cpp +40 -70

             #include "qchart.h"
             #include "qchartseries.h"
             #include "qscatterseries.h"
             #include "qscatterseries_p.h"
             #include "qpieseries.h"
             #include "qchartaxis.h"
             #include "charttheme_p.h"
             #include "chartitem_p.h"
             #include "plotdomain_p.h"
             #include "axisitem_p.h"
             #include "chartpresenter_p.h"
             #include "chartdataset_p.h"
             //series
             #include "barchartseries.h"
             #include "stackedbarchartseries.h"
             #include "percentbarchartseries.h"
             #include "qxychartseries.h"
             #include <QGraphicsScene>
             #include <QGraphicsSceneResizeEvent>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             QChart::QChart(QGraphicsItem *parent, Qt::WindowFlags wFlags) : QGraphicsWidget(parent,wFlags),
-                m_backgroundItem(0),
+            m_backgroundItem(0),
-                m_titleItem(0),
+            m_titleItem(0),
-                m_axisXItem(0),
+            m_dataset(new ChartDataSet(this)),
-                m_chartTheme(new ChartTheme(this)),
+            m_presenter(new ChartPresenter(this,m_dataset))
-                //m_dataset(0),
-                m_dataset(new ChartDataSet(this)),
-                //m_presenter(0)
-                m_presenter(new ChartPresenter(this,m_dataset))
             {
-                // TODO: the default theme?
-                setTheme(QChart::ChartThemeDefault);
-                //m_chartItems << m_axisXItem;
-                //m_chartItems << m_axisYItem.at(0);
             }
-            QChart::~QChart(){}
+            QChart::~QChart() {}
             void QChart::addSeries(QChartSeries* series)
             {
-               m_dataset->addSeries(series);
+                m_dataset->addSeries(series);
             }
+            //TODO on review, is it really needed ??
             QChartSeries* QChart::createSeries(QChartSeries::QChartSeriesType type)
             {
                 // TODO: support also other types; not only scatter and pie
                 QChartSeries *series(0);
                 switch (type) {
-                case QChartSeries::SeriesTypeLine: {
+                    case QChartSeries::SeriesTypeLine: {
-                    series = QXYChartSeries::create();
+                        series = QXYChartSeries::create();
-                    break;
+                        break;
+                    }
-                case QChartSeries::SeriesTypeBar: {
+                    case QChartSeries::SeriesTypeBar: {
-                    series = new BarChartSeries(this);
+                        series = new BarChartSeries(this);
-                    break;
+                        break;
+                    }
-                case QChartSeries::SeriesTypeStackedBar: {
+                    case QChartSeries::SeriesTypeStackedBar: {
-                    series = new StackedBarChartSeries(this);
+                        series = new StackedBarChartSeries(this);
-                    break;
+                        break;
+                    }
-                case QChartSeries::SeriesTypePercentBar: {
+                    case QChartSeries::SeriesTypePercentBar: {
-                    series = new PercentBarChartSeries(this);
+                        series = new PercentBarChartSeries(this);
-                    break;
+                        break;
+                    }
-                case QChartSeries::SeriesTypeScatter: {
+                    case QChartSeries::SeriesTypeScatter: {
-                    series = new QScatterSeries(this);
+                        series = new QScatterSeries(this);
-                    break;
+                        break;
+                    }
-                case QChartSeries::SeriesTypePie: {
+                    case QChartSeries::SeriesTypePie: {
-                    series = new QPieSeries(this);
+                        series = new QPieSeries(this);
-                    break;
+                        break;
+                    }
-                default:
+                    default:
                     Q_ASSERT(false);
                     break;
                 }
                 addSeries(series);
                 return series;
             }
             void QChart::setChartBackgroundBrush(const QBrush& brush)
             {
-                if(!m_backgroundItem){
+                if(!m_backgroundItem) {
                     m_backgroundItem = new QGraphicsRectItem(this);
                     m_backgroundItem->setZValue(-1);
                 }
                 m_backgroundItem->setBrush(brush);
                 m_backgroundItem->update();
             }
             void QChart::setChartBackgroundPen(const QPen& pen)
             {
-                if(!m_backgroundItem){
+                if(!m_backgroundItem) {
                     m_backgroundItem = new QGraphicsRectItem(this);
                     m_backgroundItem->setZValue(-1);
                 }
                 m_backgroundItem->setPen(pen);
                 m_backgroundItem->update();
             }
             void QChart::setTitle(const QString& title,const QFont& font)
             {
                 if(!m_titleItem) m_titleItem = new QGraphicsTextItem(this);
                 m_titleItem->setPlainText(title);
                 m_titleItem->setFont(font);
             }
             int QChart::margin() const
             {
                 return m_presenter->margin();
             }
             void QChart::setMargin(int margin)
             {
-               m_presenter->setMargin(margin);
+                m_presenter->setMargin(margin);
             }
             void QChart::setTheme(QChart::ChartThemeId theme)
             {
-                m_chartTheme->setTheme(theme);
+                m_presenter->setTheme(theme);
-                QLinearGradient backgroundGradient;
-                backgroundGradient.setColorAt(0.0, m_chartTheme->d->m_gradientStartColor);
-                backgroundGradient.setColorAt(1.0, m_chartTheme->d->m_gradientEndColor);
-                backgroundGradient.setCoordinateMode(QGradient::ObjectBoundingMode);
-                setChartBackgroundBrush(backgroundGradient);
-                // TODO: Move the controlling of the series presentations into private implementation of the
-                // series instead of QChart controlling themes for each
-                // In other words, the following should be used when creating xy series:
-                // m_chartTheme->addObserver(xyseries)
-                foreach (QChartSeries *series, m_chartSeries) {
-                    if (series->type() == QChartSeries::SeriesTypeLine) {
-                        QXYChartSeries *xyseries = static_cast<QXYChartSeries *>(series);
-                        SeriesTheme seriesTheme = m_chartTheme->themeForSeries();
-                        xyseries->setPen(seriesTheme.linePen);
-                update();
             }
             QChart::ChartThemeId QChart::theme()
             {
-                return (QChart::ChartThemeId) m_chartTheme->d->m_currentTheme;
+                return (QChart::ChartThemeId) m_presenter->theme();
             }
             void QChart::zoomInToRect(const QRectF& rectangle)
             {
                 m_presenter->zoomInToRect(rectangle);
             }
             void QChart::zoomIn()
             {
                 m_presenter->zoomIn();
             }
             void QChart::zoomOut()
             {
                 m_presenter->zoomOut();
             }
             void QChart::zoomReset()
             {
                 m_presenter->zoomReset();
             }
             void QChart::setAxisX(const QChartAxis& axis)
             {
-                setAxis(m_axisXItem,axis);
             }
             void QChart::setAxisY(const QChartAxis& axis)
             {
-                setAxis(m_axisYItem.at(0),axis);
             }
             void QChart::setAxisY(const QList<QChartAxis>& axis)
             {
                 //TODO not implemented
             }
             void QChart::setAxis(AxisItem *item, const QChartAxis& axis)
             {
-                item->setVisible(axis.isAxisVisible());
             }
             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();
             }
             #include "moc_qchart.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/qchart.h +1 -8

             #ifndef CHART_H
             #define CHART_H
             #include <qchartglobal.h>
             #include <qchartseries.h>
             #include <QGraphicsWidget>
             #include <QLinearGradient>
             #include <QFont>
             class QGraphicsSceneResizeEvent;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class AxisItem;
             class QChartSeries;
             class PlotDomain;
             class BarGroup;
             class QChartAxis;
             class ChartTheme;
             class ChartItem;
             class ChartDataSet;
             class ChartPresenter;
             // TODO: We don't need to have QChart tied to QGraphicsItem:
             //class QTCOMMERCIALCHART_EXPORT QChart
             //class QTCOMMERCIALCHART_EXPORT QChartGraphicsItem : public QGraphicsItem {
             // public: QChartGraphicsItem(QChart &chart);
             /*!
              * TODO: define the responsibilities
              */
             class QTCOMMERCIALCHART_EXPORT QChart : public QGraphicsWidget
             {
                 Q_OBJECT
             public:
                 enum ChartThemeId {
                     ChartThemeInvalid = -1,
                     /*! The default theme follows the GUI style of the Operating System */
                     ChartThemeDefault,
                     ChartThemeVanilla,
                     ChartThemeIcy,
                     ChartThemeGrayscale,
                     ChartThemeScientific,
-                    ChartThemeUnnamed1
+                    //ChartThemeUnnamed1
                 };
             public:
                 QChart(QGraphicsItem *parent = 0, Qt::WindowFlags wFlags = 0);
                 ~QChart();
                 void addSeries(QChartSeries* series);
                 //TODO: QChartSeries* createSeries(QSeriesData *data, QChartSeries::QChartSeriesType type);
                 // TODO: who owns the series now? maybe owned by chart and returned a reference instead...
                 QChartSeries* createSeries(QChartSeries::QChartSeriesType type);
                 void setMargin(int margin);
                 int margin() const;
                 void setTheme(QChart::ChartThemeId theme);
                 QChart::ChartThemeId theme();
                 void setTitle(const QString& title,const QFont& font = QFont());
                 void setChartBackgroundBrush(const QBrush& brush);
                 void setChartBackgroundPen(const QPen& pen);
                 void zoomInToRect(const QRectF& rectangle);
                 void zoomIn();
                 void zoomOut();
                 void zoomReset();
                 void setAxisX(const QChartAxis& axis);
                 void setAxisY(const QChartAxis& axis);
                 void setAxisY(const QList<QChartAxis>& axis);
             protected:
                 void resizeEvent(QGraphicsSceneResizeEvent *event);
             private:
                 void setAxis(AxisItem *item, const QChartAxis& axis);
             private:
                 Q_DISABLE_COPY(QChart)
                 QGraphicsRectItem* m_backgroundItem;
                 QGraphicsTextItem* m_titleItem;
-                AxisItem* m_axisXItem;
-                QList<AxisItem*> m_axisYItem;
                 QRectF m_rect;
-                QList<QChartSeries *> m_chartSeries;
-                QList<ChartItem *> m_chartItems;
-                ChartTheme *m_chartTheme;
                 ChartDataSet *m_dataset;
                 ChartPresenter *m_presenter;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/qscatterseries.cpp +2 -2

             #include "qscatterseries.h"
             #include "qscatterseries_p.h"
             #include "qchart.h"
             #include <QPainter>
             #include <QGraphicsScene>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             //#define QSeriesData QList<qreal>
             QScatterSeriesPrivate::QScatterSeriesPrivate(QGraphicsItem *parent) :
                 ChartItem(parent),
                 m_boundingRect(),
                 m_markerColor(QColor()),
                 m_visibleChartArea()
             {
                 if (parent)
                     m_boundingRect = parent->boundingRect();
             }
             void QScatterSeriesPrivate::changeGeometry()
             {
                 if (m_boundingRect.isValid()) {
                     prepareGeometryChange();
                     qreal scalex = m_boundingRect.width() / m_visibleChartArea.spanX();
                     qreal scaley = m_boundingRect.height() / m_visibleChartArea.spanY();
                     m_scenex.clear();
                     m_sceney.clear();
                     // Convert relative coordinates to absolute pixel coordinates that can be used for drawing
                     foreach(qreal x, m_x)
                         m_scenex.append(m_boundingRect.left() + x * scalex - m_visibleChartArea.m_minX * scalex);
                     foreach(qreal y, m_y)
                         m_sceney.append(m_boundingRect.bottom() - y * scaley + m_visibleChartArea.m_minY * scaley);
                 }
             }
             void QScatterSeriesPrivate::setSize(const QSizeF &size)
             {
             //    m_boundingRect = QRectF(pos().x(), pos().y(), size.width(), size.height());
                 m_boundingRect = QRectF(0, 0, size.width(), size.height());
                 changeGeometry();
             }
             void QScatterSeriesPrivate::themeChanged(ChartTheme *theme)
             {
-                m_theme = theme->themeForSeries();
+                //m_theme = theme->themeForSeries();
             }
             void QScatterSeriesPrivate::setPlotDomain(const PlotDomain& plotDomain)
             {
                 m_visibleChartArea = plotDomain;
                 changeGeometry();
             }
             QRectF QScatterSeriesPrivate::boundingRect() const
             {
                 return m_boundingRect;
             }
             void QScatterSeriesPrivate::paint(QPainter *painter, const QStyleOptionGraphicsItem */*option*/, QWidget */*widget*/)
             {
                 // TODO: The opacity should be user definable?
                 //brush.setColor(QColor(255, 82, 0, 100));
                 if (m_markerColor.isValid()) {
                     QPen pen = painter->pen();
                     QBrush brush = pen.brush();
                     brush.setColor(m_markerColor);
                     pen.setBrush(brush);
                     pen.setWidth(4);
                     painter->setPen(pen);
                 }
                 else
-                    painter->setPen(m_theme.markerPen);
+                    //painter->setPen(m_theme.markerPen);
             //        brush.setColor(m_theme..lineColor);
                 // TODO: m_scenex and m_sceny are left empty during construction -> we would need a resize
                 // event right after construction or maybe given a size during initialization
                 for (int i(0); i < m_scenex.count() && i < m_sceney.count(); i++) {
                     if (scene()->width() > m_scenex.at(i) && scene()->height() > m_sceney.at(i))
                         //painter->drawArc(m_scenex.at(i), m_sceney.at(i), 2, 2, 0, 5760);
                         painter->drawPoint(m_scenex.at(i), m_sceney.at(i));
                 }
             }
             QScatterSeries::QScatterSeries(QObject *parent) :
                 QChartSeries(parent),
                 d(new QScatterSeriesPrivate(qobject_cast<QGraphicsItem *> (parent)))
             {
             }
             bool QScatterSeries::setData(QList<qreal> xlist, QList<qreal> ylist)
             {
                 // TODO: validate data
                 d->m_x = xlist;
                 d->m_y = ylist;
                 // TODO: the following updates the visible chart area setting of the series, we would instead
                 // need to update the _chart's_ visible area... this would require a callback or
                 // similar to the parenting QChart object...
                 foreach (qreal x, d->m_x) {
                     d->m_visibleChartArea.m_minX = qMin(d->m_visibleChartArea.m_minX, x);
                     d->m_visibleChartArea.m_maxX = qMax(d->m_visibleChartArea.m_maxX, x);
                 }
                 foreach (qreal y, d->m_y) {
                     d->m_visibleChartArea.m_minY = qMin(d->m_visibleChartArea.m_minY, y);
                     d->m_visibleChartArea.m_maxY = qMax(d->m_visibleChartArea.m_maxY, y);
                 }
                 d->changeGeometry();
                 return true;
             }
             void QScatterSeries::setMarkerColor(QColor color)
             {
                 d->m_markerColor = color;
             }
             QColor QScatterSeries::markerColor()
             {
                 return d->m_markerColor;
             }
             // TODO:
             //void QScatterSeries::chartScaleChanged(qreal xscale, qreal yscale)
             //{
             //    d->rescale(xscale, yscale);
             //}
             QScatterSeries::~QScatterSeries()
             {
                 delete d;
             }
             #include "moc_qscatterseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/qscatterseries_p.h +2 -2

             #ifndef QSCATTERSERIESPRIVATE_H
             #define QSCATTERSERIESPRIVATE_H
             #include "qchartseries.h"
             #include "charttheme_p.h"
             #include "chartitem_p.h"
             #include "plotdomain_p.h"
             #include <QGraphicsItem>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
              * The PIMPL class of QScatterSeries.
              */
-            class QScatterSeriesPrivate : public ChartItem, public ChartThemeObserver
+            class QScatterSeriesPrivate : public ChartItem
             {
             public:
                 QScatterSeriesPrivate(QGraphicsItem *parent);
             public: // from ChartObjectInterface
                 void setSize(const QSizeF &size);
                 void setPlotDomain(const PlotDomain& data);
             public: // from ChartThemeObserver
                 void themeChanged(ChartTheme *theme);
             public: // from QGraphicsItem
                 QRectF boundingRect() const;
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
             public:
                 void changeGeometry();
                 QRectF m_boundingRect;
                 // TODO: use the chart data class instead of list of x and y values?
                 QList<qreal> m_x;
                 QList<qreal> m_y;
                 QList<qreal> m_scenex;
                 QList<qreal> m_sceney;
                 QColor m_markerColor;
-                SeriesTheme m_theme;
+                //SeriesTheme m_theme;
                 PlotDomain m_visibleChartArea;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QSCATTERSERIESPRIVATE_H

src/src.pro +10 -1

             !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 += \
                 barchart/barchartseries.cpp \
                 barchart/bargroup.cpp \
                 barchart/bar.cpp \
                 barchart/stackedbarchartseries.cpp \
                 barchart/stackedbargroup.cpp \
                 barchart/percentbarchartseries.cpp \
                 barchart/percentbargroup.cpp \
                 barchart/barlabel.cpp \
                 xylinechart/qxychartseries.cpp \
                 xylinechart/xylinechartitem.cpp \
                 xylinechart/linechartanimationitem.cpp \
                 piechart/qpieseries.cpp \
                 piechart/pieslice.cpp \
                 piechart/piepresentation.cpp \
                 plotdomain.cpp \
                 qscatterseries.cpp \
                 qchart.cpp \
                 axisitem.cpp \
                 qchartview.cpp \
                 qchartseries.cpp \
                 qchartaxis.cpp \
                 charttheme.cpp \
                 barchart/separator.cpp \
                 barchart/bargroupbase.cpp \
                 barchart/barchartseriesbase.cpp \
                 chartdataset.cpp \
                 chartpresenter.cpp \
                 domain.cpp
             PRIVATE_HEADERS += \
                 xylinechart/xylinechartitem_p.h \
                 xylinechart/linechartanimationitem_p.h \
                 barchart/barlabel_p.h \
                 barchart/bar_p.h \
                 barchart/separator_p.h \
                 piechart/piepresentation.h \
                 piechart/pieslice.h \
                 plotdomain_p.h \
                 qscatterseries_p.h \
                 axisitem_p.h \
                 chartitem_p.h \
                 charttheme_p.h \
                 chartdataset_p.h \
                 chartpresenter_p.h \
                 domain_p.h
             PUBLIC_HEADERS += \
                 qchartseries.h \
                 qscatterseries.h \
                 qchart.h \
                 qchartglobal.h \
                 xylinechart/qxychartseries.h \
                 barchart/barchartseries.h \
                 barchart/bargroup.h \
                 barchart/stackedbarchartseries.h \
                 barchart/stackedbargroup.h \
                 barchart/percentbarchartseries.h \
                 barchart/percentbargroup.h \
                 barchart/barchartseriesbase.h \
                 barchart/bargroupbase.h \
                 piechart/qpieseries.h \
                 qchartview.h \
                 qchartaxis.h
+            THEMES += \
+                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 += xylinechart \
                            barchart \
                            piechart \
+                           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_headers.name = bild_headers
             install_build_headers.output = $$CHART_BUILD_HEADER_DIR/${QMAKE_FILE_BASE}.h
             install_build_headers.input = PUBLIC_HEADERS
             install_build_headers.commands = $$QMAKE_COPY ${QMAKE_FILE_NAME} $$CHART_BUILD_HEADER_DIR
             install_build_headers.CONFIG += target_predeps no_link
             QMAKE_EXTRA_COMPILERS += install_build_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