HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r153:04be7b528347

Adds missing ids to theme classes

Michal Klocek -

r153:04be7b528347

parent child

Context file:

r153:04be7b528347

Collapse all files

src/chartpresenter.cpp +14 -4

             #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 "qlinechartseries.h"
             #include "qpieseries.h"
             //items
             #include "axisitem_p.h"
             #include "bargroup.h"
             #include "stackedbargroup.h"
             #include "linechartitem_p.h"
             #include "percentbargroup.h"
             #include "linechartanimationitem_p.h"
             #include "piepresenter.h"
             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);
+                setChartTheme(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);
                 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::handleSeriesAdded(QChartSeries* series)
             {
                 switch(series->type())
                 {
                     case QChartSeries::SeriesTypeLine: {
                         QLineChartSeries* lineSeries = static_cast<QLineChartSeries*>(series);
                         LineChartItem* item = new LineChartAnimationItem(this,lineSeries,m_chart);
                         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());
                         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());
                         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());
                         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);
                         PiePresenter* pie = new PiePresenter(m_chart, pieSeries);
                         pieSeries->m_piePresenter = pie; // TODO: remove this pointer passing use signals&slots
                         QObject::connect(this, SIGNAL(geometryChanged(const QRectF&)), pie, SLOT(handleGeometryChanged(const QRectF&)));
                         QObject::connect(m_dataset, SIGNAL(domainChanged(const Domain&)), pie, SLOT(handleDomainChanged(const Domain&)));
                         m_chartItems.insert(series, pie);
                         break;
                     }
                     default: {
                         qDebug()<< "Series type" << series->type() << "not implemented.";
                         break;
                     }
                 }
                 if(m_rect.isValid()) emit geometryChanged(m_rect);
             }
             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(r,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)
+            void ChartPresenter::setChartTheme(QChart::ChartTheme 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()
+            QChart::ChartTheme ChartPresenter::chartTheme()
             {
-                return (QChart::ChartThemeId) 0;
+                return m_chartTheme->id();
+            }
+            void ChartPresenter::setAxisX(QChartAxis* axis)
+            {
+            }
+            void ChartPresenter::addAxisY(QChartAxis* axis)
+            {
             }
             /*
              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 +4 -9

             #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 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);
+                void setChartTheme(QChart::ChartTheme theme);
-                QChart::ChartThemeId theme();
+                QChart::ChartTheme chartTheme();
+                void setAxisX(QChartAxis* axis);
+                void addAxisY(QChartAxis* axis);
             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 +3 -2

             #include "charttheme_p.h"
             #include "qchart.h"
             //series
             #include "barchartseries.h"
             #include "stackedbarchartseries.h"
             #include "percentbarchartseries.h"
             #include "qlinechartseries.h"
             //items
             #include "axisitem_p.h"
             #include "bargroup.h"
             #include "stackedbargroup.h"
             #include "linechartitem_p.h"
             #include "percentbargroup.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()
+            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));
             }
-            ChartTheme* ChartTheme::createTheme(QChart::ChartThemeId theme)
+            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, QChartSeries* series,int count)
             {
                 switch(series->type())
                 {
                     case QChartSeries::SeriesTypeLine: {
                         QLineChartSeries* s = static_cast<QLineChartSeries*>(series);
                         LineChartItem* i = static_cast<LineChartItem*>(item);
                         decorate(i,s,count);
                         break;
                     }
                     case QChartSeries::SeriesTypeBar: {
                         BarChartSeries* b = static_cast<BarChartSeries*>(series);
                         BarGroup* i = static_cast<BarGroup*>(item);
                         decorate(i,b,count);
                         break;
                     }
                     case QChartSeries::SeriesTypeStackedBar: {
                         StackedBarChartSeries* s = static_cast<StackedBarChartSeries*>(series);
                         StackedBarGroup* i = static_cast<StackedBarGroup*>(item);
                         decorate(i,s,count);
                         break;
                     }
                     case QChartSeries::SeriesTypePercentBar: {
                         PercentBarChartSeries* s = static_cast<PercentBarChartSeries*>(series);
                         PercentBarGroup* i = static_cast<PercentBarGroup*>(item);
                         decorate(i,s,count);
                         break;
                     }
                     default:
                     qDebug()<<"Wrong item to be decorated by theme";
                     break;
                 }
             }
             void ChartTheme::decorate(LineChartItem* item, QLineChartSeries* 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(BarGroup* item, BarChartSeries* series,int count)
             {
                 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));
             }
             void ChartTheme::decorate(StackedBarGroup* item, StackedBarChartSeries* series,int 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));
             }
             void ChartTheme::decorate(PercentBarGroup* item, PercentBarChartSeries* series,int 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));
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/charttheme_p.h +4 -2

             #ifndef CHARTTHEME_H
             #define CHARTTHEME_H
             #include "qchartglobal.h"
             #include "qchart.h"
             #include <QColor>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartItem;
             class QChartSeries;
             class LineChartItem;
             class QLineChartSeries;
             class BarGroup;
             class BarChartSeries;
             class StackedBarGroup;
             class StackedBarChartSeries;
             class PercentBarChartSeries;
             class PercentBarGroup;
             class ChartTheme
             {
             protected:
-                explicit ChartTheme();
+                explicit ChartTheme(QChart::ChartTheme id =  QChart::ChartThemeDefault);
             public:
-                static ChartTheme* createTheme(QChart::ChartThemeId theme);
+                static ChartTheme* createTheme(QChart::ChartTheme theme);
+                QChart::ChartTheme id() const {return m_id;}
                 void decorate(QChart* chart);
                 void decorate(ChartItem* item, QChartSeries* series,int count);
                 void decorate(LineChartItem* item, QLineChartSeries*, int count);
                 void decorate(BarGroup* item, BarChartSeries* series,int count);
                 void decorate(StackedBarGroup* item, StackedBarChartSeries* series,int count);
                 void decorate(PercentBarGroup* item, PercentBarChartSeries* 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/qchart.cpp +8 -18

             #include "qchart.h"
             #include "qscatterseries.h"
             #include "qscatterseries_p.h"
             #include "qpieseries.h"
             #include "qchartaxis.h"
             #include "chartpresenter_p.h"
             #include "chartdataset_p.h"
             //series
             #include "barchartseries.h"
             #include "stackedbarchartseries.h"
             #include "percentbarchartseries.h"
             #include "qlinechartseries.h"
             #include <QGraphicsScene>
             #include <QGraphicsSceneResizeEvent>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             QChart::QChart(QGraphicsItem *parent, Qt::WindowFlags wFlags) : QGraphicsWidget(parent,wFlags),
             m_backgroundItem(0),
             m_titleItem(0),
             m_dataset(new ChartDataSet(this)),
             m_presenter(new ChartPresenter(this,m_dataset))
             {
             }
             QChart::~QChart() {}
             void QChart::addSeries(QChartSeries* 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: {
                         series = QLineChartSeries::create();
                         break;
                     }
                     case QChartSeries::SeriesTypeBar: {
                         series = new BarChartSeries(this);
                         break;
                     }
                     case QChartSeries::SeriesTypeStackedBar: {
                         series = new StackedBarChartSeries(this);
                         break;
                     }
                     case QChartSeries::SeriesTypePercentBar: {
                         series = new PercentBarChartSeries(this);
                         break;
                     }
                     case QChartSeries::SeriesTypeScatter: {
                         series = new QScatterSeries(this);
                         break;
                     }
                     case QChartSeries::SeriesTypePie: {
                         series = new QPieSeries(this);
                         break;
                     }
                     default:
                     Q_ASSERT(false);
                     break;
                 }
                 addSeries(series);
                 return series;
             }
             void QChart::setChartBackgroundBrush(const QBrush& brush)
             {
                 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) {
                     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);
             }
-            void QChart::setTheme(QChart::ChartThemeId theme)
+            void QChart::setChartTheme(QChart::ChartTheme theme)
             {
-                m_presenter->setTheme(theme);
+                m_presenter->setChartTheme(theme);
             }
-            QChart::ChartThemeId QChart::theme()
+            QChart::ChartTheme QChart::chartTheme() const
             {
-                return m_presenter->theme();
+                return m_presenter->chartTheme();
             }
             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)
+            void QChart::setAxisX(QChartAxis* axis)
             {
+                m_presenter->setAxisX(axis);
             }
-            void QChart::setAxisY(const QChartAxis& axis)
+            void QChart::addAxisY(QChartAxis* axis)
-            void QChart::setAxisY(const QList<QChartAxis>& axis)
             {
-                //TODO not implemented
+                m_presenter->addAxisY(axis);
-            void QChart::setAxis(AxisItem *item, const QChartAxis& axis)
             }
             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 +5 -7

             #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 {
+                enum ChartTheme {
-                    ChartThemeInvalid = -1,
                     /*! The default theme follows the GUI style of the Operating System */
                     ChartThemeDefault,
                     ChartThemeVanilla,
                     ChartThemeIcy,
                     ChartThemeGrayscale,
                     ChartThemeScientific,
                     //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);
+                void setChartTheme(QChart::ChartTheme theme);
-                QChart::ChartThemeId theme();
+                QChart::ChartTheme chartTheme() const;
                 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 setAxisX(QChartAxis* axis);
-                void setAxisY(const QChartAxis& axis);
+                void addAxisY(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;
                 QRectF m_rect;
                 ChartDataSet *m_dataset;
                 ChartPresenter *m_presenter;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/qchartview.cpp +6 -2

             #include "qchartview.h"
             #include "qchart.h"
             #include <QGraphicsView>
             #include <QGraphicsScene>
             #include <QRubberBand>
             #include <QResizeEvent>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             QChartView::QChartView(QWidget *parent) :
                 QGraphicsView(parent),
                 m_scene(new QGraphicsScene()),
                 m_chart(new QChart()),
                 m_rubberBand(0),
                 m_verticalRubberBand(false),
                 m_horizonalRubberBand(false)
             {
             	setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
                 setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
                 setScene(m_scene);
                 m_chart->setMargin(50);
                 m_scene->addItem(m_chart);
                 setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
             }
             QChartView::~QChartView()
             {
             }
             void QChartView::resizeEvent(QResizeEvent *event)
             {
                 m_scene->setSceneRect(0,0,size().width(),size().height());
                 m_chart->resize(size());
                 QWidget::resizeEvent(event);
             }
             void QChartView::addSeries(QChartSeries* series)
             {
                 m_chart->addSeries(series);
             }
             QChartSeries* QChartView::createSeries(QChartSeries::QChartSeriesType type)
             {
                 return m_chart->createSeries(type);
             }
             void QChartView::zoomInToRect(const QRect& rectangle)
             {
                 m_chart->zoomInToRect(rectangle);
             }
             void QChartView::zoomIn()
             {
                 m_chart->zoomIn();
             }
             void QChartView::zoomOut()
             {
                 m_chart->zoomOut();
             }
             int QChartView::margin() const
             {
                 return m_chart->margin();
             }
             void QChartView::setTitle(const QString& title)
             {
                 m_chart->setTitle(title);
             }
             void QChartView::setChartBackgroundBrush(const QBrush& brush)
             {
             	 m_chart->setChartBackgroundBrush(brush);
             }
             void QChartView::setChartBackgroundPen(const QPen& pen)
             {
             	 m_chart->setChartBackgroundPen(pen);
             }
             void QChartView::setRubberBandPolicy(const RubberBandPolicy policy)
             {
                 switch(policy){
                     case VerticalRubberBand:
                         m_verticalRubberBand = true;
                         m_horizonalRubberBand = false;
                         break;
                     case HorizonalRubberBand:
                         m_verticalRubberBand = false;
                         m_horizonalRubberBand = true;
                         break;
                     case RectangleRubberBand:
                         m_verticalRubberBand = true;
                         m_horizonalRubberBand = true;
                         break;
                     case NoRubberBand:
                     default:
                         delete m_rubberBand;
                         m_rubberBand=0;
                         m_horizonalRubberBand = false;
                         m_verticalRubberBand = false;
                         return;
                 }
                 if(!m_rubberBand){
                 m_rubberBand = new QRubberBand(QRubberBand::Rectangle, this);
                 m_rubberBand->setEnabled(true);
                 }
             }
             QChartView::RubberBandPolicy QChartView::rubberBandPolicy() const
             {
                 if(m_horizonalRubberBand && m_verticalRubberBand) return RectangleRubberBand;
                 if(m_horizonalRubberBand) return HorizonalRubberBand;
                 if(m_verticalRubberBand) return VerticalRubberBand;
                 return NoRubberBand;
             }
             void QChartView::mousePressEvent(QMouseEvent *event)
             {
                 if(m_rubberBand && m_rubberBand->isEnabled() && event->button() == Qt::LeftButton) {
                     int margin = m_chart->margin();
                     QRect rect(margin, margin, width() - 2 * margin, height() - 2 * margin);
                     if (rect.contains(event->pos())) {
                         m_rubberBandOrigin = event->pos();
                         m_rubberBand->setGeometry(QRect(m_rubberBandOrigin, QSize()));
                         m_rubberBand->show();
                         event->accept();
                     }
                 }
             }
             void QChartView::mouseMoveEvent(QMouseEvent *event)
             {
                 if(m_rubberBand && m_rubberBand->isVisible()){
                     int margin = m_chart->margin();
                     QRect rect(margin, margin, width() - 2 * margin, height() - 2 * margin);
                     int width = event->pos().x() - m_rubberBandOrigin.x();
                     int height = event->pos().y() - m_rubberBandOrigin.y();
                     if(!m_verticalRubberBand) {
                         m_rubberBandOrigin.setY(rect.top());
                         height = rect.height();
                     }
                     if(!m_horizonalRubberBand) {
                         m_rubberBandOrigin.setX(rect.left());
                         width= rect.width();
                     }
                     m_rubberBand->setGeometry(QRect(m_rubberBandOrigin.x(),m_rubberBandOrigin.y(), width,height).normalized());
                 } else {
                     QGraphicsView::mouseMoveEvent(event);
                 }
             }
             void QChartView::mouseReleaseEvent(QMouseEvent *event)
             {
                 if(m_rubberBand){
                 if (event->button() == Qt::LeftButton && m_rubberBand->isVisible()) {
                     m_rubberBand->hide();
                     QRect rect = m_rubberBand->geometry();
                     m_chart->zoomInToRect(rect);
                     event->accept();
                 }
                 if(event->button()==Qt::RightButton)
                     m_chart->zoomReset();
                 }else{
                     QGraphicsView::mouseReleaseEvent(event);
                 }
             }
             void QChartView::keyPressEvent(QKeyEvent *event)
             {
                 switch (event->key()) {
                 case Qt::Key_Plus:
                     zoomIn();
                     break;
                 case Qt::Key_Minus:
                     zoomOut();
                     break;
                 default:
                     QGraphicsView::keyPressEvent(event);
                     break;
                 }
             }
-            void QChartView::setTheme(QChart::ChartThemeId theme)
+            void QChartView::setChartTheme(QChart::ChartTheme theme)
             {
-                m_chart->setTheme(theme);
+                m_chart->setChartTheme(theme);
             }
+            QChart::ChartTheme QChartView::chartTheme() const
+            {
+                return m_chart->chartTheme();
+            }
             QTCOMMERCIALCHART_END_NAMESPACE

src/qchartview.h +2 -1

             #ifndef QCHARTWIDGET_H
             #define QCHARTWIDGET_H
             #include "qchartglobal.h"
             #include "qchartseries.h"
             #include "qchart.h"
             #include <QGraphicsView>
             class QGraphicsScene;
             class QRubberBand;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QChart;
             class QTCOMMERCIALCHART_EXPORT QChartView : public QGraphicsView
             {
             public:
                 enum  RubberBandPolicy { NoRubberBand, VerticalRubberBand, HorizonalRubberBand, RectangleRubberBand };
                 explicit QChartView(QWidget *parent = 0);
                 ~QChartView();
                 //implement from QWidget
                 void resizeEvent(QResizeEvent *event);
                 void addSeries(QChartSeries* series);
                 // Convenience function
                 QChartSeries* createSeries(QChartSeries::QChartSeriesType type);
                 int margin() const;
                 void setTitle(const QString& title);
                 void setChartBackgroundBrush(const QBrush& brush);
                 void setChartBackgroundPen(const QPen& pen);
                 void zoomInToRect(const QRect& rectangle);
                 void zoomIn();
                 void zoomOut();
                 void setRubberBandPolicy(const RubberBandPolicy );
                 RubberBandPolicy rubberBandPolicy() const;
-                void setTheme(QChart::ChartThemeId theme);
+                void setChartTheme(QChart::ChartTheme theme);
+                QChart::ChartTheme chartTheme() const;
             protected:
                 void mousePressEvent(QMouseEvent *event);
                 void mouseMoveEvent(QMouseEvent *event);
                 void mouseReleaseEvent(QMouseEvent *event);
                 void keyPressEvent(QKeyEvent *event);
             private:
                 QGraphicsScene *m_scene;
                 QChart* m_chart;
                 QPoint m_rubberBandOrigin;
                 QRubberBand* m_rubberBand;
                 bool m_verticalRubberBand;
                 bool m_horizonalRubberBand;
                 Q_DISABLE_COPY(QChartView)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QCHARTWIDGET_H

src/themes/chartthemegrayscale_p.h +1 -1

             #include "charttheme_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartThemeGrayscale: public ChartTheme
             {
             public:
-                ChartThemeGrayscale()
+                ChartThemeGrayscale():ChartTheme(QChart::ChartThemeGrayscale)
                 {
                     m_seriesColor.append(QRgb(0xFF869299));
                     m_seriesColor.append(QRgb(0xFFA5BDCC));
                     m_seriesColor.append(QRgb(0xFFE8FFFC));
                     m_seriesColor.append(QRgb(0xFFCCC2C2));
                     m_gradientStartColor = QColor(QRgb(0xffffffff));
                     m_gradientEndColor = QColor(QRgb(0xffafafaf));
                 }
             };
             QTCOMMERCIALCHART_END_NAMESPACE

src/themes/chartthemeicy_p.h +1 -1

             #include "charttheme_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartThemeIcy: public ChartTheme
             {
             public:
-                ChartThemeIcy()
+                ChartThemeIcy():ChartTheme(QChart::ChartThemeIcy)
                 {
                     m_seriesColor.append(QRgb(0xFF0D2673));
                     m_seriesColor.append(QRgb(0xFF2685BF));
                     m_seriesColor.append(QRgb(0xFF3DADD9));
                     m_seriesColor.append(QRgb(0xFF62C3D9));
                     m_gradientStartColor = QColor(QRgb(0xffBDE3F2));
                     m_gradientEndColor = QColor(QRgb(0xffafafaf));
                 }
             };
             QTCOMMERCIALCHART_END_NAMESPACE

src/themes/chartthemescientific_p.h +1 -1

             #include "charttheme_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartThemeScientific: public ChartTheme
             {
             public:
-                ChartThemeScientific()
+                ChartThemeScientific():ChartTheme(QChart::ChartThemeScientific)
                 {
                     m_seriesColor.append(QRgb(0xFF000000));
                     m_seriesColor.append(QRgb(0xFFFFAD00));
                     m_seriesColor.append(QRgb(0xFF596A75));
                     m_seriesColor.append(QRgb(0xFF474747));
                     m_gradientStartColor = QColor(QRgb(0xffafafaf));
                     m_gradientEndColor = QColor(QRgb(0xffafafaf));
                 }
             };
             QTCOMMERCIALCHART_END_NAMESPACE

src/themes/chartthemevanilla_p.h +1 -1

             #include "charttheme_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartThemeVanilla: public ChartTheme
             {
             public:
-                ChartThemeVanilla()
+                ChartThemeVanilla():ChartTheme(QChart::ChartThemeVanilla)
                 {
                     m_seriesColor.append(QColor(217, 197, 116));
                     m_seriesColor.append(QColor(214, 168, 150));
                     m_seriesColor.append(QColor(160, 160, 113));
                     m_seriesColor.append(QColor(210, 210, 52));
                     m_seriesColor.append(QColor(136, 114, 58));
                     m_gradientStartColor = QColor(QRgb(0xff9d844d));
                     m_gradientEndColor = QColor(QRgb(0xffafafaf));
                 }
             };
             QTCOMMERCIALCHART_END_NAMESPACE

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