HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r460:c1b7acf3f56f

Renamed SplinePresenter to SplineChartItem

Marek Rosa -

r460:c1b7acf3f56f

parent child

Context file:

r460:c1b7acf3f56f

Collapse all files

example/splinechart/splinewidget.cpp +2 -8

             #include "splinewidget.h"
             #include "qchartview.h"
             #include "qlineseries.h"
             #include <QGridLayout>
             #include <QPushButton>
             #include "qchartaxis.h"
             #include <qmath.h>
             QTCOMMERCIALCHART_USE_NAMESPACE
             SplineWidget::SplineWidget(QWidget *parent)
                 : QWidget(parent)
             {
             //    qsrand(time(NULL));
                 //! [1]
                 //create QSplineSeries
                 series = new QSplineSeries;
                 //! [1]
                 //! [2]
                 // customize the series presentation settings
                 QPen seriesPen(Qt::blue);
                 seriesPen.setWidth(3);
                 series->setPen(seriesPen);
                 //! [2]
                 //! [add points to series]
                 //add data points to the series
                 series->add(QPointF(150, 100));
                 series->add(QPointF(200, 130));
                 series->add(QPointF(250, 120));
                 series->add(QPointF(300, 140));
                 series->add(QPointF(350, 160));
                 //! [add points to series]
             //    series->add(QPointF(400, 120));
             //    series->add(QPointF(450, 150));
             //    series->add(QPointF(500, 145));
             //    series->add(QPointF(550, 170));
             //    series->add(QPointF(600, 190));
             //    series->add(QPointF(650, 210));
             //    series->add(QPointF(700, 190));
             //    series->add(QPointF(750, 180));
             //    series->add(QPointF(800, 170));
                 //! [3]
                 // create chart view
                 QChartView* chart = new QChartView;
                 chart->addSeries(series);
                 chart->setChartTitle("Spline chart example");
-            //    chart->setMinimumSize(800,600);
-            //    chart->axisX()->setRange(0, 1500);
-            //    chart->axisX()->setMax(1500);
-            //    chart->axisY()->setRange(0, 400);
                 chart->axisX()->setMax(1500);
-            //        chart->
+                chart->axisY()->setMax(500);
                 chart->setMinimumSize(800,600);
                 //! [3]
                 //! [4]
                 //add new data point button
                 QPushButton* addButton = new QPushButton("Add new point");
                 connect(addButton, SIGNAL(clicked()), this, SLOT(addNewPoint()));
                 // remove the last data point in the series
                 QPushButton* removeButton = new QPushButton("Remove point");
                 connect(removeButton, SIGNAL(clicked()), this, SLOT(removePoint()));
                 //! [4]
                 //! [5]
                 //butttons layout
                 QVBoxLayout* buttonsLayout = new QVBoxLayout;
                 buttonsLayout->addWidget(addButton);
                 buttonsLayout->addWidget(removeButton);
                 buttonsLayout->addStretch();
                 QGridLayout* mainLayout = new QGridLayout;
                 mainLayout->addWidget(chart, 1, 0);
                 mainLayout->addLayout(buttonsLayout, 1, 1);
                 setLayout(mainLayout);
                 //! [5]
             }
             //! [add point]
             void SplineWidget::addNewPoint()
             {
                 if (series->count() > 0)
-                    series->add(QPointF(series->x(series->count() - 1) + 20 + qrand()%40, qAbs(series->y(series->count() - 1) - 50 + qrand()%100)));
+                    series->add(QPointF(series->x(series->count() - 1) + 40 + qrand()%40, qAbs(series->y(series->count() - 1) - 50 + qrand()%100)));
                 else
                     series->add(QPointF(50, 50 + qrand()%50));
             }
             //! [add point]
             //! [remove point]
             void SplineWidget::removePoint()
             {
                 if (series->count() > 0)
                     series->remove(QPointF(series->x(series->count() - 1), series->y(series->count() - 1)));
             }
             //! [remove point]
             SplineWidget::~SplineWidget()
             {
             }

src/chartpresenter.cpp +2 -2

             #include "qchart.h"
             #include "qchartaxis.h"
             #include "chartpresenter_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_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 "axisanimationitem_p.h"
             #include "areachartitem_p.h"
             #include "barpresenter_p.h"
             #include "stackedbarpresenter_p.h"
             #include "percentbarpresenter_p.h"
             #include "linechartitem_p.h"
             #include "linechartanimationitem_p.h"
             #include "piepresenter_p.h"
             #include "scatterpresenter_p.h"
-            #include "splinepresenter_p.h"
+            #include "splinechartitem_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartPresenter::ChartPresenter(QChart* chart,ChartDataSet* dataset):QObject(chart),
                 m_chart(chart),
                 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()
             {
             }
             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 ;
                 if(!m_options.testFlag(QChart::GridAxisAnimations))
                 {
                     item = new AxisItem(axis,axis==m_dataset->axisX()?AxisItem::X_AXIS : AxisItem::Y_AXIS,m_chart);
                 }else{
                     item = new AxisAnimationItem(axis,axis==m_dataset->axisX()?AxisItem::X_AXIS : AxisItem::Y_AXIS,m_chart);
                 }
                 if(axis==m_dataset->axisX()){
                     QObject::connect(domain,SIGNAL(rangeXChanged(qreal,qreal)),item,SLOT(handleRangeChanged(qreal,qreal)));
                     //initialize
                     item->handleRangeChanged(domain->minX(),domain->maxX());
                     item->handleTicksCountChanged(4);
                 }
                 else{
                     QObject::connect(domain,SIGNAL(rangeYChanged(qreal,qreal)),item,SLOT(handleRangeChanged(qreal,qreal)));
                     //initialize
                     item->handleRangeChanged(domain->minY(),domain->maxY());
                     item->handleTicksCountChanged(4);
                 }
                 QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&)));
                 //initialize
                 item->handleGeometryChanged(m_rect);
                 m_chartTheme->decorate(axis,item);
                 m_axisItems.insert(axis,item);
             }
             void ChartPresenter::handleAxisRemoved(QChartAxis* axis)
             {
                 AxisItem* item = m_axisItems.take(axis);
                 Q_ASSERT(item);
                 delete item;
             }
             void ChartPresenter::handleSeriesAdded(QSeries* series,Domain* domain)
             {
                 switch(series->type())
                 {
                 case QSeries::SeriesTypeLine: {
                     QLineSeries* lineSeries = static_cast<QLineSeries*>(series);
                     LineChartItem* item;
                     if(m_options.testFlag(QChart::SeriesAnimations)){
                         item = new LineChartAnimationItem(lineSeries,m_chart);
                     }else{
                         item = new LineChartItem(lineSeries,m_chart);
                     }
                     QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&)));
                     QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),item,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
                     //initialize
                     item->handleDomainChanged(domain->minX(),domain->maxX(),domain->minY(),domain->maxY());
                     if(m_rect.isValid()) item->handleGeometryChanged(m_rect);
                     //decorate
                     m_chartTheme->decorate(item,lineSeries,m_chartItems.count());
                     m_chartItems.insert(series,item);
                     break;
                 }
                 case QSeries::SeriesTypeArea: {
                     QAreaSeries* areaSeries = static_cast<QAreaSeries*>(series);
                     AreaChartItem* item;
                     if(m_options.testFlag(QChart::SeriesAnimations)) {
                         item = new AreaChartItem(areaSeries,m_chart);
                     }
                     else {
                         item = new AreaChartItem(areaSeries,m_chart);
                     }
                     QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&)));
                     QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),item,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
                     //initialize
                      item->handleDomainChanged(domain->minX(),domain->maxX(),domain->minY(),domain->maxY());
                      if(m_rect.isValid()) item->handleGeometryChanged(m_rect);
                      //decorate
                     m_chartTheme->decorate(item,areaSeries,m_chartItems.count());
                     m_chartItems.insert(series,item);
                     break;
                 }
                 case QSeries::SeriesTypeBar: {
                     QBarSeries* barSeries = static_cast<QBarSeries*>(series);
                     BarPresenter* item = new BarPresenter(barSeries,m_chart);
                     m_chartTheme->decorate(item,barSeries,m_chartItems.count());
                     QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&)));
                     //            QObject::connect(barSeries,SIGNAL(changed(int)),item,SLOT(handleModelChanged(int)));
                     m_chartItems.insert(series,item);
                     // m_axisXItem->setVisible(false);
                     if(m_rect.isValid()) item->handleGeometryChanged(m_rect);
                     break;
                 }
                 case QSeries::SeriesTypeStackedBar: {
                     QStackedBarSeries* stackedBarSeries = static_cast<QStackedBarSeries*>(series);
                     StackedBarPresenter* item = new StackedBarPresenter(stackedBarSeries,m_chart);
                     m_chartTheme->decorate(item,stackedBarSeries,m_chartItems.count());
                     QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&)));
                     //            QObject::connect(stackedBarSeries,SIGNAL(changed(int)),item,SLOT(handleModelChanged(int)));
                     m_chartItems.insert(series,item);
                     if(m_rect.isValid()) item->handleGeometryChanged(m_rect);
                     break;
                 }
                 case QSeries::SeriesTypePercentBar: {
                     QPercentBarSeries* percentBarSeries = static_cast<QPercentBarSeries*>(series);
                     PercentBarPresenter* item = new PercentBarPresenter(percentBarSeries,m_chart);
                     m_chartTheme->decorate(item,percentBarSeries ,m_chartItems.count());
                     QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&)));
                     //            QObject::connect(percentBarSeries,SIGNAL(changed(int)),item,SLOT(handleModelChanged(int)));
                     m_chartItems.insert(series,item);
                     if(m_rect.isValid()) item->handleGeometryChanged(m_rect);
                     break;
                 }
                 case QSeries::SeriesTypeScatter: {
                     QScatterSeries *scatterSeries = qobject_cast<QScatterSeries *>(series);
                     ScatterPresenter *scatterPresenter = new ScatterPresenter(scatterSeries, m_chart);
                     QObject::connect(scatterPresenter, SIGNAL(clicked(QPointF)),
                                      scatterSeries, SIGNAL(clicked(QPointF)));
                     QObject::connect(this, SIGNAL(geometryChanged(const QRectF&)),
                                      scatterPresenter, SLOT(handleGeometryChanged(const QRectF&)));
                     QObject::connect(domain, SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),
                                      scatterPresenter, SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
                     m_chartTheme->decorate(scatterPresenter, scatterSeries, m_chartItems.count());
                     m_chartItems.insert(scatterSeries, scatterPresenter);
                     if (m_rect.isValid())
                         scatterPresenter->handleGeometryChanged(m_rect);
                     scatterPresenter->handleDomainChanged(domain->minX(), domain->maxX(), domain->minY(), domain->maxY());
                     break;
                 }
                 case QSeries::SeriesTypePie: {
                     QPieSeries *s = qobject_cast<QPieSeries *>(series);
                     PiePresenter* pie = new PiePresenter(m_chart, s);
                     m_chartTheme->decorate(pie, s, m_chartItems.count());
                     QObject::connect(this, SIGNAL(geometryChanged(const QRectF&)), pie, SLOT(handleGeometryChanged(const QRectF&)));
                     // 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()->setAxisVisible(false);
                         m_chart->axisY()->setAxisVisible(false);
                         m_chart->axisX()->setGridVisible(false);
                         m_chart->axisY()->setGridVisible(false);
                         m_chart->axisX()->setLabelsVisible(false);
                         m_chart->axisY()->setLabelsVisible(false);
                         m_chart->axisX()->setShadesVisible(false);
                         m_chart->axisY()->setShadesVisible(false);
                         m_chart->setChartBackgroundBrush(Qt::transparent);
                     }
                     m_chartItems.insert(series, pie);
                     pie->handleGeometryChanged(m_rect);
                     break;
                 }
                 case QSeries::SeriesTypeSpline: {
                     QSplineSeries* splineSeries = qobject_cast<QSplineSeries*>(series);
-                    SplinePresenter* splinePresenter = new SplinePresenter(splineSeries, m_chart);
+                    SplineChartItem* splinePresenter = new SplineChartItem(splineSeries, m_chart);
                     QObject::connect(this, SIGNAL(geometryChanged(const QRectF&)), splinePresenter, SLOT(handleGeometryChanged(const QRectF&)));
                     QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),splinePresenter,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
                     //initialize
                     splinePresenter->handleDomainChanged(domain->minX(),domain->maxX(),domain->minY(),domain->maxY());
                     m_chartTheme->decorate(splinePresenter, splineSeries, m_chartItems.count());
                     m_chartItems.insert(splineSeries, splinePresenter);
                     break;
                 }
                 default: {
                     qDebug()<< "Series type" << series->type() << "not implemented.";
                     break;
                 }
                 }
                 zoomReset();
             }
             void ChartPresenter::handleSeriesRemoved(QSeries* series)
             {
                 ChartItem* item = m_chartItems.take(series);
                 delete item;
             }
             void ChartPresenter::setChartTheme(QChart::ChartTheme theme)
             {
                 delete m_chartTheme;
                 m_chartTheme = ChartTheme::createTheme(theme);
                 m_chartTheme->decorate(m_chart);
                 QMapIterator<QSeries*,ChartItem*> i(m_chartItems);
                 int index=0;
                 while (i.hasNext()) {
                     i.next();
                     m_chartTheme->decorate(i.value(),i.key(),index);
                     index++;
                 }
                 QMapIterator<QChartAxis*,AxisItem*> j(m_axisItems);
                 while (j.hasNext()) {
                     j.next();
                     m_chartTheme->decorate(j.key(),j.value());
                 }
             }
             QChart::ChartTheme ChartPresenter::chartTheme()
             {
                 return m_chartTheme->id();
             }
             void ChartPresenter::setAnimationOptions(QChart::AnimationOptions options)
             {
                 if(m_options!=options) {
                     m_options=options;
                     //recreate elements
                     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);
             	m_dataset->zoomInDomain(r,geometry().size());
             	m_zoomStack<<r;
             	m_zoomIndex++;
             }
             void ChartPresenter::zoomOut()
             {
             	if(m_zoomIndex==0) return;
             	m_dataset->zoomOutDomain(m_zoomStack[m_zoomIndex-1],geometry().size());
             	m_zoomIndex--;
             	m_zoomStack.resize(m_zoomIndex);
             }
             void ChartPresenter::zoomReset()
             {
                 m_zoomIndex=0;
                 m_zoomStack.resize(m_zoomIndex);
             }
             QChart::AnimationOptions ChartPresenter::animationOptions() const
             {
                 return m_options;
             }
             #include "moc_chartpresenter_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/charttheme.cpp +5 -5

             #include "charttheme_p.h"
             #include "qchart.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 "scatterpresenter_p.h"
             #include "piepresenter_p.h"
-            #include "splinepresenter_p.h"
+            #include "splinechartitem_p.h"
             //themes
             #include "chartthemevanilla_p.h"
             #include "chartthemeicy_p.h"
             #include "chartthemegrayscale_p.h"
             #include "chartthemescientific_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /* TODO
                 case QChart::ChartThemeUnnamed1:
                     m_seriesThemes.append(SeriesTheme(QColor(QRgb(0xff3fa9f5)), 2));
                     m_seriesThemes.append(SeriesTheme(QColor(QRgb(0xff7AC943)), 2));
                     m_seriesThemes.append(SeriesTheme(QColor(QRgb(0xffFF931E)), 2));
                     m_seriesThemes.append(SeriesTheme(QColor(QRgb(0xffFF1D25)), 2));
                     m_seriesThemes.append(SeriesTheme(QColor(QRgb(0xffFF7BAC)), 2));
                     m_gradientStartColor = QColor(QRgb(0xfff3dc9e));
                     m_gradientEndColor = QColor(QRgb(0xffafafaf));
             */
             ChartTheme::ChartTheme(QChart::ChartTheme id)
             {
                 m_id = id;
                 m_seriesColor.append(QRgb(0xff000000));
                 m_seriesColor.append(QRgb(0xff707070));
                 m_gradientStartColor = QColor(QRgb(0xffffffff));
                 m_gradientEndColor = QColor(QRgb(0xffafafaf));
                 qsrand(QTime(0,0,0).secsTo(QTime::currentTime()));
             }
             ChartTheme* ChartTheme::createTheme(QChart::ChartTheme theme)
             {
                 switch(theme) {
                     case QChart::ChartThemeDefault:
                         return new ChartTheme();
                     case QChart::ChartThemeVanilla:
                         return new ChartThemeVanilla();
                     case QChart::ChartThemeIcy:
                         return new ChartThemeIcy();
                     case QChart::ChartThemeGrayscale:
                         return new ChartThemeGrayscale();
                     case QChart::ChartThemeScientific:
                         return new ChartThemeScientific();
                 }
             }
             void ChartTheme::decorate(QChart* chart)
             {
                 QLinearGradient backgroundGradient;
                 backgroundGradient.setColorAt(0.0, m_gradientStartColor);
                 backgroundGradient.setColorAt(1.0, m_gradientEndColor);
                 backgroundGradient.setCoordinateMode(QGradient::ObjectBoundingMode);
                 chart->setChartBackgroundBrush(backgroundGradient);
             }
             //TODO helper to by removed later
             void ChartTheme::decorate(ChartItem* item, QSeries* series,int count)
             {
                 switch(series->type())
                 {
                     case QSeries::SeriesTypeLine: {
                         QLineSeries* s = static_cast<QLineSeries*>(series);
                         LineChartItem* i = static_cast<LineChartItem*>(item);
                         decorate(i,s,count);
                         break;
                     }
                     case QSeries::SeriesTypeArea: {
                                QAreaSeries* s = static_cast<QAreaSeries*>(series);
                                AreaChartItem* i = static_cast<AreaChartItem*>(item);
                                decorate(i,s,count);
                                break;
                     }
                     case QSeries::SeriesTypeBar: {
                         QBarSeries* b = static_cast<QBarSeries*>(series);
                         BarPresenter* i = static_cast<BarPresenter*>(item);
                         decorate(i,b,count);
                         break;
                     }
                     case QSeries::SeriesTypeStackedBar: {
                         QStackedBarSeries* s = static_cast<QStackedBarSeries*>(series);
                         StackedBarPresenter* i = static_cast<StackedBarPresenter*>(item);
                         decorate(i,s,count);
                         break;
                     }
                     case QSeries::SeriesTypePercentBar: {
                         QPercentBarSeries* s = static_cast<QPercentBarSeries*>(series);
                         PercentBarPresenter* i = static_cast<PercentBarPresenter*>(item);
                         decorate(i,s,count);
                         break;
                     }
                     case QSeries::SeriesTypeScatter: {
                         QScatterSeries* s = qobject_cast<QScatterSeries*>(series);
                         Q_ASSERT(s);
                         ScatterPresenter* i = static_cast<ScatterPresenter*>(item);
                         Q_ASSERT(i);
                         decorate(i, s, count);
                         break;
                     }
                     case QSeries::SeriesTypePie: {
                         QPieSeries* s = static_cast<QPieSeries*>(series);
                         PiePresenter* i = static_cast<PiePresenter*>(item);
                         decorate(i,s,count);
                         break;
                     }
                     default:
                     qDebug()<<"Wrong item to be decorated by theme";
                     break;
                 }
             }
             void ChartTheme::decorate(AreaChartItem* item, QAreaSeries* series,int count)
             {
                 QPen pen;
                 QBrush brush;
                 if(pen != series->pen()){
                    item->setPen(series->pen());
                 }else{
                     pen.setColor(m_seriesColor.at(count%m_seriesColor.size()));
                     pen.setWidthF(2);
                     item->setPen(pen);
                 }
                 if(brush != series->brush()){
                    item->setBrush(series->brush());
                 }else{
                    QBrush brush(m_seriesColor.at(count%m_seriesColor.size()));
                    item->setBrush(brush);
                 }
             }
             void ChartTheme::decorate(LineChartItem* item, QLineSeries* series,int count)
             {
                 QPen pen;
                 if(pen != series->pen()){
                     item->setPen(series->pen());
                     return;
                 }
                 pen.setColor(m_seriesColor.at(count%m_seriesColor.size()));
                 pen.setWidthF(2);
                 item->setPen(pen);
             }
             void ChartTheme::decorate(BarPresenter* item, QBarSeries* series,int count)
             {
                 QList<QBarSet*> sets = series->barSets();
                 for (int i=0; i<series->barsetCount(); i++) {
                     sets.at(i)->setBrush(QBrush(m_seriesColor.at(i%m_seriesColor.count())));
                 }
             }
             void ChartTheme::decorate(StackedBarPresenter* item, QStackedBarSeries* series,int count)
             {
                 QList<QBarSet*> sets = series->barSets();
                 for (int i=0; i<series->barsetCount(); i++) {
                     sets.at(i)->setBrush(QBrush(m_seriesColor.at(i%m_seriesColor.count())));
                 }
             }
             void ChartTheme::decorate(PercentBarPresenter* item, QPercentBarSeries* series,int count)
             {
                 QList<QBarSet*> sets = series->barSets();
                 for (int i=0; i<series->barsetCount(); i++) {
                     sets.at(i)->setBrush(QBrush(m_seriesColor.at(i%m_seriesColor.count())));
                 }
             }
             void ChartTheme::decorate(ScatterPresenter* presenter, QScatterSeries* series, int count)
             {
                 Q_ASSERT(presenter);
                 Q_ASSERT(series);
                 QColor color = m_seriesColor.at(count % m_seriesColor.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(PiePresenter* item, QPieSeries* series, int /*count*/)
             {
                 // create a list of slice colors based on current theme
                 int i = 0;
                 QList<QColor> colors;
                 while (colors.count() < series->count()) {
                     // get base color
                     QColor c = m_seriesColor[i++];
                     i = i % m_seriesColor.count();
                     // dont use black colors... looks bad
                     if (c == Qt::black)
                         continue;
                     // by default use the "raw" theme color
                     if (!colors.contains(c)) {
                         colors << c;
                         continue;
                     }
                     // ...ok we need to generate something that looks like the same color
                     // but different lightness
                     int tryCount = 0;
                     while (tryCount++ < 100) {
                         // find maximum value we can raise the lightness
                         int lMax = 255;
                         if (lMax > 255 - c.red())
                             lMax = 255 - c.red();
                         if (lMax > 255 - c.green())
                             lMax = 255 - c.green();
                         if (lMax > 255 - c.blue())
                             lMax = 255 - c.blue();
                         // find maximum value we can make it darker
                         int dMax = 255;
                         if (dMax > c.red())
                             dMax = c.red();
                         if (dMax > c.green())
                             dMax = c.green();
                         if (dMax > c.blue())
                             dMax = c.blue();
                         int max = dMax + lMax;
                         if (max == 0) {
                             // no room to make color lighter or darker...
                             qDebug() << "cannot generate a color for pie!";
                             break;
                         }
                         // generate random color
                         int r = c.red() - dMax;
                         int g = c.green() - dMax;
                         int b = c.blue() - dMax;
                         int d = qrand() % max;
                         c.setRgb(r+d, g+d, b+d);
                         // found a unique color?
                         if (!colors.contains(c))
                             break;
                     }
                     qDebug() << "generated a color for pie" << c;
                     colors << c;
                 }
                 // finally update colors
                 foreach (QPieSlice* s, series->slices()) {
                     QColor c = colors.takeFirst();
                     s->setPen(c);
                     s->setBrush(c);
                 }
             }
             void ChartTheme::decorate(QChartAxis* axis,AxisItem* item)
             {
                 //TODO: dummy defults for now
                 axis->setLabelsBrush(Qt::black);
                 axis->setLabelsPen(Qt::NoPen);
                 axis->setShadesPen(Qt::NoPen);
                 axis->setShadesOpacity(0.5);
             }
-            void ChartTheme::decorate(SplinePresenter* presenter, QSplineSeries* series, int count)
+            void ChartTheme::decorate(SplineChartItem* item, QSplineSeries* series, int count)
             {
-                Q_ASSERT(presenter);
+                Q_ASSERT(item);
                 Q_ASSERT(series);
                 QPen pen;
                 if(pen != series->pen()){
-                    presenter->setPen(series->pen());
+                    item->setPen(series->pen());
                     return;
                 }
                 pen.setColor(m_seriesColor.at(count%m_seriesColor.size()));
                 pen.setWidthF(series->pen().widthF());
-                presenter->setPen(pen);
+                item->setPen(pen);
             //    QColor color = m_seriesColor.at(count % m_seriesColor.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;
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/charttheme_p.h +2 -2

             #ifndef CHARTTHEME_H
             #define CHARTTHEME_H
             #include "qchartglobal.h"
             #include "qchart.h"
             #include <QColor>
             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 ScatterPresenter;
             class PiePresenter;
             class QPieSeries;
-            class SplinePresenter;
+            class SplineChartItem;
             class QSplineSeries;
             class AreaChartItem;
             class QAreaSeries;
             class ChartTheme
             {
             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(ChartItem* item, QSeries* series,int count);
                 void decorate(BarPresenter* item, QBarSeries* series,int count);
                 void decorate(StackedBarPresenter* item, QStackedBarSeries* series,int count);
                 void decorate(PercentBarPresenter* item, QPercentBarSeries* series,int count);
                 void decorate(LineChartItem* item, QLineSeries* series,int count);
                 void decorate(AreaChartItem* item, QAreaSeries* series,int count);
                 void decorate(ScatterPresenter* presenter, QScatterSeries* series, int count);
                 void decorate(PiePresenter* item, QPieSeries* series, int count);
                 void decorate(QChartAxis* axis,AxisItem* item);
-                void decorate(SplinePresenter* presenter, QSplineSeries* series, int count);
+                void decorate(SplineChartItem* presenter, QSplineSeries* series, int count);
             protected:
                 QChart::ChartTheme m_id;
                 QColor m_gradientStartColor;
                 QColor m_gradientEndColor;
                 QList<QColor> m_seriesColor;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // CHARTTHEME_H

src/splinechart/splinechart.pri +2 -2

             INCLUDEPATH += $$PWD
             DEPENDPATH += $$PWD
             SOURCES += \
                 $$PWD/qsplineseries.cpp \
-                $$PWD/splinepresenter.cpp
+                $$PWD/splinechartitem.cpp
             PRIVATE_HEADERS += \
-                $$PWD/splinepresenter_p.h
+                $$PWD/splinechartitem_p.h
             PUBLIC_HEADERS += \
                 $$PWD/qsplineseries.h

src/splinechart/splinechartitem.cpp ~~src/splinechart/splinepresenter.cpp~~ renamed +6 -6

-            #include "splinepresenter_p.h"
+            #include "splinechartitem_p.h"
             #include <QPainter>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            SplinePresenter::SplinePresenter(QSplineSeries* series, QGraphicsObject *parent) :
+            SplineChartItem::SplineChartItem(QSplineSeries* series, QGraphicsObject *parent) :
                 LineChartItem(series, parent)//,m_boundingRect()
             {
                 //
             }
-            QPointF SplinePresenter::calculateGeometryControlPoint(int index) const
+            QPointF SplineChartItem::calculateGeometryControlPoint(int index) const
             {
                 QSplineSeries* splineSeries = qobject_cast<QSplineSeries*>(m_series);
                 const qreal deltaX = m_size.width()/(m_maxX-m_minX);
                 const qreal deltaY = m_size.height()/(m_maxY-m_minY);
                 qreal x = (splineSeries->controlPoint(index).x() - m_minX)* deltaX;
                 qreal y = (splineSeries->controlPoint(index).y() - m_minY)*-deltaY + m_size.height();
                 return QPointF(x,y);
             }
-            void SplinePresenter::applyGeometry(QVector<QPointF>& points)
+            void SplineChartItem::applyGeometry(QVector<QPointF>& points)
             {
                 if(points.size()==0) return;
                 QPainterPath splinePath;
                 const QPointF& point = points.at(0);
                 splinePath.moveTo(point);
             //    QSplineSeries* splineSeries = qobject_cast<QSplineSeries*>(m_series);
                 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();
             }
-            void SplinePresenter::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
+            void SplineChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(widget);
                 Q_UNUSED(option);
                 painter->save();
                 painter->setPen(m_pen);
                 painter->setClipRect(m_clipRect);
                 painter->drawPath(m_path);
                 QSplineSeries* splineSeries = qobject_cast<QSplineSeries*>(m_series);
                 for (int i = 0; i < m_points.size() - 1; i++)
                 {
                     painter->setPen(Qt::red);
                     painter->drawEllipse(m_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 (m_points.count() > 0)
                 {
                     painter->setPen(Qt::red);
                     painter->drawEllipse(m_points[m_points.count() - 1], 2, 2);
                 }
                 painter->restore();
             }
-            #include "moc_splinepresenter_p.cpp"
+            #include "moc_splinechartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/splinechart/splinechartitem_p.h ~~src/splinechart/splinepresenter_p.h~~ renamed +5 -5

-            #ifndef SPLINEPRESENTER_P_H
+            #ifndef SPLINECHARTITEM_P_H
-            #define SPLINEPRESENTER_P_H
+            #define SPLINECHARTITEM_P_H
             #include "chartitem_p.h"
             #include <QObject>
             #include "qsplineseries.h"
             #include "linechartitem_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            class SplinePresenter : public LineChartItem
+            class SplineChartItem : public LineChartItem
             {
                 Q_OBJECT
             public:
-                SplinePresenter(QSplineSeries* series, QGraphicsObject *parent = 0);
+                SplineChartItem(QSplineSeries* series, QGraphicsObject *parent = 0);
                 void updateGeometry();
                 void applyGeometry(QVector<QPointF>& points);
                 QPointF calculateGeometryControlPoint(int index) const;
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
             };
             QTCOMMERCIALCHART_END_NAMESPACE
-            #endif // SPLINEPRESENTER_P_H
+            #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