HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r562:f23c0d74d416

Fix theme decoration calls on all xyseries

Michal Klocek -

r562:f23c0d74d416

parent child

Context file:

r562:f23c0d74d416

Collapse all files

src/chartpresenter.cpp +7 -5

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

src/charttheme.cpp +10 -31

             #include "charttheme_p.h"
             #include "qchart.h"
             #include "qlegend.h"
             #include "qchartaxis.h"
             #include <QTime>
             //series
             #include "qbarset.h"
             #include "qbarseries.h"
             #include "qstackedbarseries.h"
             #include "qpercentbarseries.h"
             #include "qlineseries.h"
             #include "qareaseries.h"
             #include "qscatterseries.h"
             #include "qpieseries.h"
             #include "qpieslice.h"
             #include "qsplineseries.h"
             //items
             #include "axisitem_p.h"
             #include "barpresenter_p.h"
             #include "stackedbarpresenter_p.h"
             #include "percentbarpresenter_p.h"
             #include "linechartitem_p.h"
             #include "areachartitem_p.h"
             #include "scatterchartitem_p.h"
             #include "piepresenter_p.h"
             #include "splinechartitem_p.h"
             //themes
             #include "chartthemedefault_p.h"
             #include "chartthemevanilla_p.h"
             #include "chartthemeicy_p.h"
             #include "chartthemegrayscale_p.h"
             #include "chartthemescientific_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartTheme::ChartTheme(QChart::ChartTheme id)
             {
                 m_id = id;
                 qsrand(QTime(0,0,0).secsTo(QTime::currentTime()));
             }
             ChartTheme* ChartTheme::createTheme(QChart::ChartTheme theme)
             {
                 switch(theme) {
                     case QChart::ChartThemeVanilla:
                         return new ChartThemeVanilla();
                     case QChart::ChartThemeIcy:
                         return new ChartThemeIcy();
                     case QChart::ChartThemeGrayscale:
                         return new ChartThemeGrayscale();
                     case QChart::ChartThemeScientific:
                         return new ChartThemeScientific();
                     default:
                         return new ChartThemeDefault();
                 }
             }
             void ChartTheme::decorate(QChart* chart)
             {
                 chart->setChartBackgroundBrush(m_backgroundGradient);
                 chart->setChartTitleFont(m_masterFont);
             }
             void ChartTheme::decorate(QLegend* legend)
             {
                 legend->setBackgroundBrush(m_backgroundGradient);
             }
-            void ChartTheme::decorate(AreaChartItem* item, QAreaSeries* series, int index)
+            void ChartTheme::decorate(QAreaSeries* series, int index)
             {
                 QPen pen;
                 QBrush brush;
                 if (pen == series->pen()){
                     pen.setColor(colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 1.0));
                     pen.setWidthF(2);
                     series->setPen(pen);
                 }
                 if (brush == series->brush()) {
                    QBrush brush(m_seriesColors.at(index % m_seriesColors.size()));
                    series->setBrush(brush);
                 }
             }
-            void ChartTheme::decorate(LineChartItem* item, QLineSeries* series,int index)
+            void ChartTheme::decorate(QLineSeries* series,int index)
             {
                 QPen pen;
                 if(pen == series->pen()){
                     pen.setColor(m_seriesColors.at(index%m_seriesColors.size()));
                     pen.setWidthF(2);
                     series->setPen(pen);
                 }
             }
             void ChartTheme::decorate(BarPresenter* item, QBarSeries* series,int index)
             {
                 QList<QBarSet*> sets = series->barSets();
                 for (int i=0; i<sets.count(); i++) {
                     qreal pos = 0.5;
                     if (sets.count() > 1)
                         pos = (qreal) i / (qreal) (sets.count() - 1);
                     QColor c = colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), pos);
                     sets.at(i)->setBrush(QBrush(c));
                     // Pick label color as far as possible from bar color (within gradient).
                     // 0.3 is magic number that was picked as value that gave enough contrast with icy theme gradient :)
                     // TODO: better picking of label color?
                     if (pos < 0.3) {
                         c = colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 1);
                     } else {
                         c = colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 0);
                     }
                     sets.at(i)->setFloatingValuePen(QPen(c));
                 }
             }
             void ChartTheme::decorate(StackedBarPresenter* item, QStackedBarSeries* series,int index)
             {
                 QList<QBarSet*> sets = series->barSets();
                 for (int i=0; i<sets.count(); i++) {
                     qreal pos = 0.5;
                     if (sets.count() > 1)
                         pos = (qreal) i / (qreal) (sets.count() - 1);
                     QColor c = colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), pos);
                     sets.at(i)->setBrush(QBrush(c));
                     if (pos < 0.3) {
                         c = colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 1);
                     } else {
                         c = colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 0);
                     }
                     sets.at(i)->setFloatingValuePen(QPen(c));
                 }
             }
             void ChartTheme::decorate(PercentBarPresenter* item, QPercentBarSeries* series,int index)
             {
                 QList<QBarSet*> sets = series->barSets();
                 for (int i=0; i<sets.count(); i++) {
                     qreal pos = 0.5;
                     if (sets.count() > 1)
                         pos = (qreal) i / (qreal) (sets.count() - 1);
                     QColor c = colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), pos);
                     sets.at(i)->setBrush(QBrush(c));
                     if (pos < 0.3) {
                         c = colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 1);
                     } else {
                         c = colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 0);
                     }
                     sets.at(i)->setFloatingValuePen(QPen(c));
                 }
             }
-            void ChartTheme::decorate(ScatterChartItem* item, QScatterSeries* series, int index)
+            void ChartTheme::decorate(QScatterSeries* series, int index)
             {
-                Q_ASSERT(item);
-                Q_ASSERT(series);
                 QPen pen;
                 QBrush brush;
                 if (pen == series->pen()) {
                     pen.setColor(colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 1.0));
                     pen.setWidthF(2);
                     series->setPen(pen);
                 }
                 if (brush == series->brush()) {
                     QBrush brush(m_seriesColors.at(index % m_seriesColors.size()));
                     series->setBrush(brush);
                 }
             }
             void ChartTheme::decorate(PiePresenter* item, QPieSeries* series, int index)
             {
                 // Get color for a slice from a gradient linearly, beginning from the start of the gradient
                 for (int i(0); i < series->slices().count(); i++) {
                     qreal pos = (qreal) i / (qreal) series->count();
                     QColor penColor = colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 0.1);
                     series->slices().at(i)->setSlicePen(penColor);
                     QColor brushColor = colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), pos);
                     series->slices().at(i)->setSliceBrush(brushColor);
                 }
             }
-            void ChartTheme::decorate(SplineChartItem* item, QSplineSeries* series, int index)
+            void ChartTheme::decorate(QSplineSeries* series, int index)
             {
-                Q_ASSERT(item);
-                Q_ASSERT(series);
                 QPen pen;
-                if(pen != series->pen()){
+                if(pen == series->pen()){
-                    item->setLinePen(series->pen());
-                }else{
                     pen.setColor(m_seriesColors.at(index%m_seriesColors.size()));
-                    pen.setWidthF(series->pen().widthF());
+                    pen.setWidthF(2);
-                    item->setLinePen(series->pen());
+                    series->setPen(pen);
                 }
-            //    QColor color = m_seriesColors.at(index % m_seriesColors.size());
-                // TODO: define alpha in the theme? or in the series?
-                //color.setAlpha(120);
-            //    QBrush brush(color, Qt::SolidPattern);
-            //    presenter->m_markerBrush = brush;
-            //    QPen pen(brush, 3);
-            //    pen.setColor(color);
-            //    presenter->m_markerPen = pen;
             }
-            void ChartTheme::decorate(QChartAxis* axis, QChart* parent)
+            void ChartTheme::decorate(QChartAxis* axis,bool axisX)
             {
-                Q_ASSERT(axis);
-                Q_ASSERT(parent);
                 if (axis->isAxisVisible()) {
                     axis->setLabelsBrush(m_axisLabelBrush);
                     axis->setLabelsPen(m_axisLabelPen);
                     // TODO: check the axis type (x or y) should define whether to show the shades or not
                     if (m_backgroundShades == BackgroundShadesBoth
-                            || (m_backgroundShades == BackgroundShadesVertical && parent->axisX() == axis)
+                            || (m_backgroundShades == BackgroundShadesVertical && axisX)
-                            || (m_backgroundShades == BackgroundShadesHorizontal && parent->axisY() == axis)) {
+                            || (m_backgroundShades == BackgroundShadesHorizontal && !axisX)) {
                         axis->setShadesPen(m_backgroundShadesPen);
                         axis->setShadesBrush(m_backgroundShadesBrush);
                     } else {
                         // The shades not supposed to be shown for this axis, clear possible brush and pen
                         axis->setShadesPen(Qt::NoPen);
                         axis->setShadesBrush(Qt::NoBrush);
                     }
                     axis->setAxisPen(m_axisLinePen);
                     axis->setGridLinePen(m_gridLinePen);
                     axis->setLabelsFont(m_masterFont);
                 }
             }
             void ChartTheme::generateSeriesGradients()
             {
                 // Generate gradients in HSV color space
                 foreach (QColor color, m_seriesColors) {
                     QLinearGradient g;
                     qreal h = color.hsvHueF();
                     qreal s = color.hsvSaturationF();
                     // TODO: tune the algorithm to give nice results with most base colors defined in
                     // most themes. The rest of the gradients we can define manually in theme specific
                     // implementation.
                     QColor start = color;
                     start.setHsvF(h, 0.05, 0.95);
                     g.setColorAt(0.0, start);
                     g.setColorAt(0.5, color);
                     QColor end = color;
                     end.setHsvF(h, s, 0.25);
                     g.setColorAt(1.0, end);
                     m_seriesGradients << g;
                 }
             }
             QColor ChartTheme::colorAt(const QColor &start, const QColor &end, qreal pos)
             {
                 Q_ASSERT(pos >=0.0 && pos <= 1.0);
                 qreal r = start.redF() + ((end.redF() - start.redF()) * pos);
                 qreal g = start.greenF() + ((end.greenF() - start.greenF()) * pos);
                 qreal b = start.blueF() + ((end.blueF() - start.blueF()) * pos);
                 QColor c;
                 c.setRgbF(r, g, b);
                 return c;
             }
             QColor ChartTheme::colorAt(const QGradient &gradient, qreal pos)
             {
                 Q_ASSERT(pos >=0 && pos <= 1.0);
                 // another possibility:
                 // http://stackoverflow.com/questions/3306786/get-intermediate-color-from-a-gradient
                 QGradientStops stops = gradient.stops();
                 int count = stops.count();
                 // find previous stop relative to position
                 QGradientStop prev = stops.first();
                 for (int i=0; i<count; i++) {
                     QGradientStop stop = stops.at(i);
                     if (pos > stop.first)
                         prev = stop;
                     // given position is actually a stop position?
                     if (pos == stop.first) {
                         //qDebug() << "stop color" << pos;
                         return stop.second;
                     }
                 }
                 // find next stop relative to position
                 QGradientStop next = stops.last();
                 for (int i=count-1; i>=0; i--) {
                     QGradientStop stop = stops.at(i);
                     if (pos < stop.first)
                         next = stop;
                 }
                 //qDebug() << "prev" << prev.first << "pos" << pos << "next" << next.first;
                 qreal range = next.first - prev.first;
                 qreal posDelta = pos - prev.first;
                 qreal relativePos = posDelta / range;
                 //qDebug() << "range" << range << "posDelta" << posDelta << "relativePos" << relativePos;
                 return colorAt(prev.second, next.second, relativePos);
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/charttheme_p.h +5 -5

             #ifndef CHARTTHEME_H
             #define CHARTTHEME_H
             #include "qchartglobal.h"
             #include "qchart.h"
             #include <QColor>
             #include <QGradientStops>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartItem;
             class QSeries;
             class LineChartItem;
             class QLineSeries;
             class BarPresenter;
             class QBarSeries;
             class StackedBarPresenter;
             class QStackedBarSeries;
             class QPercentBarSeries;
             class PercentBarPresenter;
             class QScatterSeries;
             class ScatterChartItem;
             class PiePresenter;
             class QPieSeries;
             class SplineChartItem;
             class QSplineSeries;
             class AreaChartItem;
             class QAreaSeries;
             class ChartTheme
             {
             public:
                 enum BackgroundShadesMode {
                     BackgroundShadesNone = 0,
                     BackgroundShadesVertical,
                     BackgroundShadesHorizontal,
                     BackgroundShadesBoth
                 };
             protected:
                 explicit ChartTheme(QChart::ChartTheme id =  QChart::ChartThemeDefault);
             public:
                 static ChartTheme* createTheme(QChart::ChartTheme theme);
                 QChart::ChartTheme id() const {return m_id;}
                 void decorate(QChart* chart);
                 void decorate(QLegend* legend);
                 //void decorate(ChartItem* item, QSeries* series,int index);
                 void decorate(BarPresenter* item, QBarSeries* series, int index);
                 void decorate(StackedBarPresenter* item, QStackedBarSeries* series, int index);
                 void decorate(PercentBarPresenter* item, QPercentBarSeries* series, int index);
-                void decorate(LineChartItem* item, QLineSeries* series, int index);
+                void decorate(QLineSeries* series, int index);
-                void decorate(AreaChartItem* item, QAreaSeries* series, int index);
+                void decorate(QAreaSeries* series, int index);
-                void decorate(ScatterChartItem* presenter, QScatterSeries* series, int index);
+                void decorate(QScatterSeries* series, int index);
                 void decorate(PiePresenter* item, QPieSeries* series, int index);
-                void decorate(SplineChartItem* presenter, QSplineSeries* series, int index);
+                void decorate(QSplineSeries* series, int index);
-                void decorate(QChartAxis* axis, QChart* parent);
+                void decorate(QChartAxis* axis, bool axisX);
             public: // utils
                 void generateSeriesGradients();
                 static QColor colorAt(const QColor &start, const QColor &end, qreal pos);
                 static QColor colorAt(const QGradient &gradient, qreal pos);
             protected:
                 QChart::ChartTheme m_id;
                 QList<QColor> m_seriesColors;
                 QList<QGradient> m_seriesGradients;
                 QLinearGradient m_backgroundGradient;
                 QFont m_masterFont;
                 QPen m_axisLinePen;
                 QBrush m_axisLabelBrush;
                 QPen m_axisLabelPen;
                 QPen m_backgroundShadesPen;
                 QBrush m_backgroundShadesBrush;
                 BackgroundShadesMode m_backgroundShades;
                 QPen m_gridLinePen;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // CHARTTHEME_H

src/splinechart/splinechartitem.cpp +1 -6

             #include "splinechartitem_p.h"
             #include "chartpresenter_p.h"
             #include <QPainter>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             SplineChartItem::SplineChartItem(QSplineSeries* series, QGraphicsItem *parent) :
             XYChartItem(series, parent),
             m_series(series)
             {
                 setZValue(ChartPresenter::LineChartZValue);
                 QObject::connect(series,SIGNAL(updated()),this,SLOT(handleUpdated()));
                 handleUpdated();
             }
             QRectF SplineChartItem::boundingRect() const
             {
                 return m_rect;
             }
             QPainterPath SplineChartItem::shape() const
             {
                 return m_path;
             }
             QPointF SplineChartItem::calculateGeometryControlPoint(int index) const
             {
                 return XYChartItem::calculateGeometryPoint(m_series->controlPoint(index));
             }
             void SplineChartItem::setLayout(QVector<QPointF>& points)
             {
                 if(points.size()==0)
                 {
                     XYChartItem::setLayout(points);
                     return;
                 }
                 QPainterPath splinePath;
                 const QPointF& point = points.at(0);
                 splinePath.moveTo(point);
                 for (int i = 0; i < points.size() - 1; i++)
                 {
                     const QPointF& point = points.at(i + 1);
                     splinePath.cubicTo(calculateGeometryControlPoint(2 * i), calculateGeometryControlPoint(2 * i + 1), point);
                 }
                 prepareGeometryChange();
                 m_path = splinePath;
                 m_rect = splinePath.boundingRect();
                 XYChartItem::setLayout(points);
             }
-            void SplineChartItem::setLinePen(const QPen& pen)
-                m_pen = pen;
             //handlers
             void SplineChartItem::handleUpdated()
             {
                 //m_items.setVisible(m_series->pointsVisible());
-                setLinePen(m_series->pen());
+                m_pen = m_series->pen();
                 update();
             }
             //painter
             void SplineChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(widget);
                 Q_UNUSED(option);
                 painter->save();
                 painter->setClipRect(clipRect());
                 painter->setPen(m_pen);
                 painter->drawPath(m_path);
                 const QVector<QPointF> points =  XYChartItem::points();
                 for (int i = 0; i < points.size() - 1; i++)
                 {
                     painter->setPen(Qt::red);
                     painter->drawEllipse(points[i], 2, 2);
                     painter->setPen(Qt::blue);
                     //        painter->drawLine(m_series->at(i), m_series->controlPoint(2 * i));
                     //        painter->drawLine(m_series->at(i + 1), m_series->controlPoint(2 * i + 1));
                     //        painter->drawEllipse(calculateGeometryControlPoint(2 * i), 4, 4);
                     //        painter->drawEllipse(calculateGeometryControlPoint(2 * i + 1), 4, 4);
                 }
                 if (points.count() > 0)
                 {
                     painter->setPen(Qt::red);
                     painter->drawEllipse(points[points.count() - 1], 2, 2);
                 }
                 painter->restore();
             }
             #include "moc_splinechartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/splinechart/splinechartitem_p.h 0 -1

             #ifndef SPLINECHARTITEM_P_H
             #define SPLINECHARTITEM_P_H
             #include "qsplineseries.h"
             #include "xychartitem_p.h"
             #include <QGraphicsItem>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class SplineChartItem : public XYChartItem
             {
                 Q_OBJECT
             public:
                 SplineChartItem(QSplineSeries* series, QGraphicsItem *parent = 0);
                 //from QGraphicsItem
                 QRectF boundingRect() const;
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
                 QPainterPath shape() const;
-                void setLinePen(const QPen& pen);
                 void setPointsVisible(bool visible);
             public slots:
                 void handleUpdated();
             protected:
                 void setLayout(QVector<QPointF>& points);
             private:
                 QPointF calculateGeometryControlPoint(int index) const;
             private:
                 QSplineSeries* m_series;
                 QPainterPath m_path;
                 QRectF m_rect;
                 QPen m_pen;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // SPLINECHARTITEM_P_H

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