HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r146:6c3759bde1fd

Moved pie stuff to own .pri file and rename stuff

Jani Honkonen -

r146:6c3759bde1fd

parent child

Context file:

r146:6c3759bde1fd

Collapse all files

src/piechart/piechart.pri created 644 +14 0

@@ -0,0 +1,14
	1	INCLUDEPATH += $$PWD
	2	DEPENDPATH += $$PWD
	3
	4	SOURCES += \
	5	$$PWD/qpieseries.cpp \
	6	$$PWD/pieslice.cpp \
	7	$$PWD/piepresenter.cpp
	8
	9	PRIVATE_HEADERS += \
	10	$$PWD/piepresenter.h \
	11	$$PWD/pieslice.h
	12
	13	PUBLIC_HEADERS += \
	14	$$PWD/qpieseries.h

src/chartdataset.cpp +1 -2

             #include "chartdataset_p.h"
             //series
             #include "qlinechartseries.h"
             #include "barchartseries.h"
             #include "stackedbarchartseries.h"
             #include "percentbarchartseries.h"
-            #include "piechart/qpieseries.h"
+            #include "qpieseries.h"
-            #include "piechart/piepresentation.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartDataSet::ChartDataSet(QObject *parent):QObject(parent)
             {
                 Domain domain;
                 m_domains<<domain;
             }
             ChartDataSet::~ChartDataSet()
             {
                 // TODO Auto-generated destructor stub
             }
             const Domain& ChartDataSet::domain() const
             {
                 return m_domains[m_domainIndex];
             }
             void ChartDataSet::addSeries(QChartSeries* series)
             {
                 // TODO: we should check the series not already added
                 m_chartSeries << series;
                 m_domainIndex = 0;
                 m_domains.resize(1);
                 Domain& domain = m_domains[m_domainIndex];
                 switch(series->type())
                 {
                     case QChartSeries::SeriesTypeLine: {
                         QLineChartSeries* xyseries = static_cast<QLineChartSeries*>(series);
                         for (int i = 0; i < xyseries->count(); i++)
                         {
                             qreal x = xyseries->x(i);
                             qreal y = xyseries->y(i);
                             domain.m_minX = qMin(domain.m_minX,x);
                             domain.m_minY = qMin(domain.m_minY,y);
                             domain.m_maxX = qMax(domain.m_maxX,x);
                             domain.m_maxY = qMax(domain.m_maxY,y);
                         }
                         break;
                     }
                     case QChartSeries::SeriesTypeBar: {
                         BarChartSeries* barSeries = static_cast<BarChartSeries*>(series);
                         qreal x = barSeries->countColumns();
                         qreal y = barSeries->max();
                         domain.m_minX = qMin(domain.m_minX,x);
                         domain.m_minY = qMin(domain.m_minY,y);
                         domain.m_maxX = qMax(domain.m_maxX,x);
                         domain.m_maxY = qMax(domain.m_maxY,y);
                     }
                     break;
                     case QChartSeries::SeriesTypeStackedBar: {
                         StackedBarChartSeries* stackedBarSeries = static_cast<StackedBarChartSeries*>(series);
                         qreal x = stackedBarSeries->countColumns();
                         qreal y = stackedBarSeries->maxColumnSum();
                         domain.m_minX = qMin(domain.m_minX,x);
                         domain.m_minY = qMin(domain.m_minY,y);
                         domain.m_maxX = qMax(domain.m_maxX,x);
                         domain.m_maxY = qMax(domain.m_maxY,y);
                     }
                         break;
                     case QChartSeries::SeriesTypePercentBar: {
                         PercentBarChartSeries* percentBarSeries = static_cast<PercentBarChartSeries*>(series);
                         qreal x = percentBarSeries->countColumns();
                         domain.m_minX = qMin(domain.m_minX,x);
                         domain.m_minY = 0;
                         domain.m_maxX = qMax(domain.m_maxX,x);
                         domain.m_maxY = 100;
                     }
                         break;
                     case QChartSeries::SeriesTypePie: {
                         QPieSeries *pieSeries = static_cast<QPieSeries *>(series);
                         // TODO: domain stuff
                         break;
                     }
                     default: {
                         qDebug()<<__FUNCTION__<<"type" << series->type()<<"not supported";
                         return;
                         break;
                     }
                 }
                 emit seriesAdded(series);
                 emit domainChanged(domain);
             }
             bool ChartDataSet::nextDomain()
             {
                 if (m_domainIndex < m_domains.count() - 1) {
                     m_domainIndex++;
                     emit domainChanged(m_domains[m_domainIndex]);
                     return true;
                 }
                 else {
                     return false;
                 }
             }
             bool ChartDataSet::previousDomain()
             {
                 if (m_domainIndex > 0) {
                     m_domainIndex--;
                     emit domainChanged(m_domains[m_domainIndex]);
                     return true;
                 }
                 else {
                     return false;
                 }
             }
             void ChartDataSet::clearDomains()
             {
                 if (m_domainIndex > 0) {
                     m_domainIndex = 0;
                     emit domainChanged(m_domains[m_domainIndex]);
                 }
             }
             void ChartDataSet::addDomain(const Domain& domain)
             {
                 m_domains.resize(m_domainIndex + 1);
                 m_domains << domain;
                 m_domainIndex++;
                 emit domainChanged(domain);
             }
             #include "moc_chartdataset_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/chartpresenter.cpp +6 -6

             #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 "piepresentation.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);
                 createConnections();
                 createDeafultAxis();
             }
             ChartPresenter::~ChartPresenter()
             {
             }
             void ChartPresenter::createDeafultAxis()
             {
                 //default axis
                 QChartAxis* axisX = new QChartAxis(this);
                 QChartAxis* axisY = new QChartAxis(this);
                 m_axis << new AxisItem(axisX,AxisItem::X_AXIS,m_chart);
                 m_axis << new AxisItem(axisY,AxisItem::Y_AXIS,m_chart);
                 foreach(AxisItem* item, m_axis) {
                     QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&)));
                     QObject::connect(m_dataset,SIGNAL(domainChanged(const Domain&)),item,SLOT(handleDomainChanged(const Domain&)));
                 }
             }
             void ChartPresenter::createConnections()
             {
                 QObject::connect(m_chart,SIGNAL(geometryChanged()),this,SLOT(handleGeometryChanged()));
                 QObject::connect(m_dataset,SIGNAL(seriesAdded(QChartSeries*)),this,SLOT(handleSeriesAdded(QChartSeries*)));
             }
             void ChartPresenter::handleGeometryChanged()
             {
                 m_rect = QRectF(QPoint(0,0),m_chart->size());
                 m_rect.adjust(m_marginSize,m_marginSize, -m_marginSize, -m_marginSize);
                 emit geometryChanged(m_rect);
             }
             int ChartPresenter::margin() const
             {
                 return m_marginSize;
             }
             void ChartPresenter::setMargin(int margin)
             {
                 m_marginSize = margin;
             }
             void ChartPresenter::handleSeriesAdded(QChartSeries* series)
             {
                 switch(series->type())
                 {
                     case QChartSeries::SeriesTypeLine: {
                         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);
-                        PiePresentation* pieChart = new PiePresentation(m_chart, pieSeries);
+                        PiePresenter* pie = new PiePresenter(m_chart, pieSeries);
-                        pieSeries->m_piePresentation = pieChart; // TODO: remove this pointer passing use signals&slots
+                        pieSeries->m_piePresenter = pie; // TODO: remove this pointer passing use signals&slots
-                        QObject::connect(this, SIGNAL(geometryChanged(const QRectF&)), pieChart, SLOT(handleGeometryChanged(const QRectF&)));
+                        QObject::connect(this, SIGNAL(geometryChanged(const QRectF&)), pie, SLOT(handleGeometryChanged(const QRectF&)));
-                        QObject::connect(m_dataset, SIGNAL(domainChanged(const Domain&)), pieChart, SLOT(handleDomainChanged(const Domain&)));
+                        QObject::connect(m_dataset, SIGNAL(domainChanged(const Domain&)), pie, SLOT(handleDomainChanged(const Domain&)));
-                        m_chartItems.insert(series, pieChart);
+                        m_chartItems.insert(series, pie);
                         break;
                     }
                     default: {
                         qDebug()<< "Series type" << series->type() << "not implemented.";
                         break;
                     }
                 }
             }
             void ChartPresenter::handleSeriesChanged(QChartSeries* series)
             {
                 //TODO:
             }
             void ChartPresenter::zoomInToRect(const QRectF& rect)
             {
                 if(!rect.isValid()) return;
                 QRectF r = rect.normalized();
                 r.translate(-m_marginSize, -m_marginSize);
                 Domain domain (m_dataset->domain().subDomain(rect,m_rect.width(),m_rect.height()));
                 m_dataset->addDomain(domain);
             }
             void ChartPresenter::zoomIn()
             {
                 if (!m_dataset->nextDomain()) {
                     QRectF rect = m_rect;
                     rect.setWidth(rect.width()/2);
                     rect.setHeight(rect.height()/2);
                     rect.moveCenter(m_rect.center());
                     Domain domain (m_dataset->domain().subDomain(rect,m_rect.width(),m_rect.height()));
                     m_dataset->addDomain(domain);
                 }
             }
             void ChartPresenter::zoomOut()
             {
                 m_dataset->previousDomain();
             }
             void ChartPresenter::zoomReset()
             {
                 m_dataset->clearDomains();
             }
             void ChartPresenter::setTheme(QChart::ChartThemeId theme)
             {
                 delete m_chartTheme;
                 m_chartTheme = ChartTheme::createTheme(theme);
                 m_chartTheme->decorate(m_chart);
                 QMapIterator<QChartSeries*,ChartItem*> i(m_chartItems);
                 int index=0;
                 while (i.hasNext()) {
                     i.next();
                     index++;
                     m_chartTheme->decorate(i.value(),i.key(),index);
                   }
                 }
             QChart::ChartThemeId ChartPresenter::theme()
             {
                 return (QChart::ChartThemeId) 0;
             }
             /*
              void ChartPresenter::setAxisX(const QChartAxis& axis)
              {
              setAxis(m_axisXItem,axis);
              }
              void ChartPresenter::setAxisY(const QChartAxis& axis)
              {
              setAxis(m_axisYItem.at(0),axis);
              }
              void ChartPresenter::setAxisY(const QList<QChartAxis>& axis)
              {
              //TODO not implemented
              }
              void ChartPresenter::setAxis(AxisItem *item, const QChartAxis& axis)
              {
              item->setVisible(axis.isAxisVisible());
              }
              */
             #include "moc_chartpresenter_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/piepresenter.cpp ~~src/piechart/piepresentation.cpp~~ renamed +10 -10

-            #include "piepresentation.h"
+            #include "piepresenter.h"
             #include "pieslice.h"
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            PiePresentation::PiePresentation(QGraphicsItem *parent, QPieSeries *series) :
+            PiePresenter::PiePresenter(QGraphicsItem *parent, QPieSeries *series) :
                 ChartItem(parent),
                 m_pieSeries(series)
             {
                 Q_ASSERT(parent);
                 Q_ASSERT(series);
                 m_rect = parentItem()->boundingRect();
                 setAcceptHoverEvents(true);
             }
-            PiePresentation::~PiePresentation()
+            PiePresenter::~PiePresenter()
             {
                 while (m_slices.count())
                     delete m_slices.takeLast();
             }
-            void PiePresentation::seriesChanged()
+            void PiePresenter::seriesChanged()
             {
                 const qreal fullPie = 360;
                 qreal total = 0;
                 // calculate total
                 foreach (QPieSlice sliceData, m_pieSeries->slices())
                     total += sliceData.m_value;
                 // TODO: no need to create new slices in case size changed; we should re-use the existing ones
                 while (m_slices.count())
                     delete m_slices.takeLast();
                 // create slices
                 qreal angle = 0;
                 for (int i=0; i<m_pieSeries->count(); i++) {
                     QPieSlice sliceData = m_pieSeries->slice(i);
                     qreal span = sliceData.m_value / total * fullPie;
                     PieSlice *slice = new PieSlice(this, i, angle, span);
                     m_slices.append(slice);
                     angle += span;
                 }
                 resize();
             }
-            void PiePresentation::setSize(const QSizeF &size)
+            void PiePresenter::setSize(const QSizeF &size)
             {
                 // TODO: allow user setting the size?
                 // TODO: allow user defining the margins?
                 m_rect.setSize(size);
                 resize();
             }
-            void PiePresentation::setPlotDomain(const PlotDomain& plotDomain)
+            void PiePresenter::setPlotDomain(const PlotDomain& plotDomain)
             {
                 // TODO
             }
-            void PiePresentation::resize()
+            void PiePresenter::resize()
             {
                 m_pieRect = m_rect;
                 if (m_pieRect.width() < m_pieRect.height()) {
                     m_pieRect.setWidth(m_pieRect.width() * m_pieSeries->m_sizeFactor);
                     m_pieRect.setHeight(m_pieRect.width());
                     m_pieRect.moveCenter(m_rect.center());
                 } else {
                     m_pieRect.setHeight(m_pieRect.height() * m_pieSeries->m_sizeFactor);
                     m_pieRect.setWidth(m_pieRect.height());
                     m_pieRect.moveCenter(m_rect.center());
                 }
                 switch (m_pieSeries->m_position) {
                     case QPieSeries::PiePositionTopLeft: {
                         m_pieRect.setHeight(m_pieRect.height() / 2);
                         m_pieRect.setWidth(m_pieRect.height());
                         m_pieRect.moveCenter(QPointF(m_rect.center().x() / 2, m_rect.center().y() / 2));
                         break;
                     }
                     case QPieSeries::PiePositionTopRight: {
                         m_pieRect.setHeight(m_pieRect.height() / 2);
                         m_pieRect.setWidth(m_pieRect.height());
                         m_pieRect.moveCenter(QPointF((m_rect.center().x() / 2) * 3, m_rect.center().y() / 2));
                         break;
                     }
                     case QPieSeries::PiePositionBottomLeft: {
                         m_pieRect.setHeight(m_pieRect.height() / 2);
                         m_pieRect.setWidth(m_pieRect.height());
                         m_pieRect.moveCenter(QPointF(m_rect.center().x() / 2, (m_rect.center().y() / 2) * 3));
                         break;
                     }
                     case QPieSeries::PiePositionBottomRight: {
                         m_pieRect.setHeight(m_pieRect.height() / 2);
                         m_pieRect.setWidth(m_pieRect.height());
                         m_pieRect.moveCenter(QPointF((m_rect.center().x() / 2) * 3, (m_rect.center().y() / 2) * 3));
                         break;
                     }
                     default:
                         break;
                 }
                 qDebug() << "presentation rect:" << m_rect;
                 qDebug() << "pie rect:" << m_pieRect;
             }
-            void PiePresentation::handleDomainChanged(const Domain& domain)
+            void PiePresenter::handleDomainChanged(const Domain& domain)
             {
                 // TODO
             }
-            void PiePresentation::handleGeometryChanged(const QRectF& rect)
+            void PiePresenter::handleGeometryChanged(const QRectF& rect)
             {
                 setSize(rect.size());
             }
-            #include "moc_piepresentation.cpp"
+            #include "moc_piepresenter.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/piepresenter.h ~~src/piechart/piepresentation.h~~ renamed +6 -6

-            #ifndef PIEPRESENTATION_H
+            #ifndef PIEPRESENTER_H
-            #define PIEPRESENTATION_H
+            #define PIEPRESENTER_H
             #include "chartitem_p.h"
             #include "qpieseries.h"
             class QGraphicsItem;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class PieSlice;
-            class PiePresentation : public QObject, public ChartItem
+            class PiePresenter : public QObject, public ChartItem
             {
                 Q_OBJECT
             public:
                 // TODO: use a generic data class instead of x and y
-                PiePresentation(QGraphicsItem *parent, QPieSeries *series);
+                PiePresenter(QGraphicsItem *parent, QPieSeries *series);
-                ~PiePresentation();
+                ~PiePresenter();
             public: // from ChartItem
                 void setSize(const QSizeF &size);
                 void setPlotDomain(const PlotDomain& data);
                 QRectF boundingRect() const { return m_rect; }
                 void paint(QPainter *, const QStyleOptionGraphicsItem *, QWidget *) {}
             public:
                 void seriesChanged();
                 void resize();
                 QRectF pieRect() const { return m_pieRect; }
             public Q_SLOTS:
                 void handleDomainChanged(const Domain& domain);
                 void handleGeometryChanged(const QRectF& rect);
             private:
                 friend class PieSlice;
                 QList<PieSlice*> m_slices;
                 QPieSeries *m_pieSeries;
                 QRectF m_rect;
                 QRectF m_pieRect;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
-            #endif // PIEPRESENTATION_H
+            #endif // PIEPRESENTER_H

src/piechart/pieslice.cpp +4 -4

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

src/piechart/pieslice.h +2 -2

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

src/piechart/qpieseries.cpp +19 -19

             #include "qpieseries.h"
-            #include "piepresentation.h"
+            #include "piepresenter.h"
             #include "pieslice.h"
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             QPieSeries::QPieSeries(QObject *parent) :
                 QChartSeries(parent),
-                m_piePresentation(0),
+                m_piePresenter(0),
                 m_sizeFactor(1.0),
                 m_position(PiePositionMaximized)
             {
             }
             QPieSeries::~QPieSeries()
             {
             }
             void QPieSeries::set(QList<QPieSlice> slices)
             {
                 m_slices = slices;
-                if (m_piePresentation) {
+                if (m_piePresenter) {
-                    m_piePresentation->seriesChanged();
+                    m_piePresenter->seriesChanged();
-                    m_piePresentation->update();
+                    m_piePresenter->update();
                 }
             }
             void QPieSeries::add(QList<QPieSlice> slices)
             {
                 m_slices += slices;
-                if (m_piePresentation) {
+                if (m_piePresenter) {
-                    m_piePresentation->seriesChanged();
+                    m_piePresenter->seriesChanged();
-                    // TODO: m_piePresentation->seriesAppended()??
+                    // TODO: m_piePresenter->seriesAppended()??
-                    m_piePresentation->update();
+                    m_piePresenter->update();
                 }
             }
             void QPieSeries::add(QPieSlice slice)
             {
                 add(QList<QPieSlice>() << slice);
             }
             QPieSlice QPieSeries::slice(int index) const
             {
                 if ((index >= 0) && (index < m_slices.count()))
                     return m_slices.at(index);
                 return QPieSlice();
             }
             bool QPieSeries::update(int index, QPieSlice slice)
             {
                 if ((index >= 0) && (index < m_slices.count())) {
                     m_slices[index] = slice;
-                    if (m_piePresentation) {
+                    if (m_piePresenter) {
-                        m_piePresentation->seriesChanged();
+                        m_piePresenter->seriesChanged();
                         // TODO: for a nice animation we need something like
-                        // m_piePresentation->sliceChanged(index, oldslice, newslice)
+                        // m_piePresenter->sliceChanged(index, oldslice, newslice)
-                        m_piePresentation->update();
+                        m_piePresenter->update();
                     }
                     return true;
                 }
                 return false;
             }
             void QPieSeries::setSizeFactor(qreal factor)
             {
                 if (factor > 0.0)
                     m_sizeFactor = factor;
-                if (m_piePresentation) {
+                if (m_piePresenter) {
-                    m_piePresentation->resize();
+                    m_piePresenter->resize();
-                    m_piePresentation->update();
+                    m_piePresenter->update();
                     // TODO: do we have to update the parent item also?
                     //  - potential issue: what if this function is called from the parent context?
                 }
             }
             void QPieSeries::setPosition(PiePosition position)
             {
                 m_position = position;
-                if (m_piePresentation) {
+                if (m_piePresenter) {
-                    m_piePresentation->resize();
+                    m_piePresenter->resize();
-                    m_piePresentation->update();
+                    m_piePresenter->update();
                     // TODO: do we have to update the parent item also?
                     //  - potential issue: what if this function is called from the parent context?
                 }
             }
             #include "moc_qpieseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/qpieseries.h +3 -3

             #ifndef PIESERIES_H
             #define PIESERIES_H
             #include "qchartseries.h"
             #include <QObject>
             #include <QRectF>
             #include <QColor>
             class QGraphicsObject;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            class PiePresentation;
+            class PiePresenter;
             class PieSlice;
             class QPieSlice
             {
             public:
                 QPieSlice()
                     :m_value(0), m_label("<empty>"), m_color(Qt::white), m_isExploded(false) {}
                 QPieSlice(qreal value, QString label, QColor color, bool exploded = false)
                     :m_value(value), m_label(label), m_color(color), m_isExploded(exploded) {}
             public:
                 qreal m_value;
                 QString m_label;
                 QColor m_color;
                 bool m_isExploded;
             };
             class QTCOMMERCIALCHART_EXPORT QPieSeries : public QChartSeries
             {
                 Q_OBJECT
             public:
                 enum PiePosition {
                     PiePositionMaximized = 0,
                     PiePositionTopLeft,
                     PiePositionTopRight,
                     PiePositionBottomLeft,
                     PiePositionBottomRight
                 };
             public:
                 QPieSeries(QObject *parent = 0);
                 ~QPieSeries();
             public: // from QChartSeries
                 QChartSeriesType type() const { return QChartSeries::SeriesTypePie; }
             public:
                 void set(QList<QPieSlice> slices);
                 void add(QList<QPieSlice> slices);
                 void add(QPieSlice slice);
                 int count() const { return m_slices.count(); }
                 QList<QPieSlice> slices() const { return m_slices; }
                 QPieSlice slice(int index) const;
                 bool update(int index, QPieSlice slice);
                 // TODO: convenience functions
                 //void updateValue(int sliceIndex, qreal value);
                 //void updateLabel(int sliceIndex, QString label);
                 //void updateColor(int sliceIndex, QColor color);
                 //void updateExploded(int slizeIndex, bool exploded);
                 void setSizeFactor(qreal sizeFactor);
                 qreal sizeFactor() const { return m_sizeFactor; }
                 void setPosition(PiePosition position);
                 PiePosition position() const { return m_position; }
             private:
                 Q_DISABLE_COPY(QPieSeries)
                 // TODO: use PIML
                 friend class ChartPresenter;
                 friend class ChartDataSet;
-                friend class PiePresentation;
+                friend class PiePresenter;
-                PiePresentation *m_piePresentation;
+                PiePresenter *m_piePresenter;
                 QList<QPieSlice> m_slices;
                 qreal m_sizeFactor;
                 PiePosition m_position;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // PIESERIES_H

src/src.pro +3 -7

             !include( ../common.pri ):error( Couldn't find the common.pri file! )
             TARGET = QtCommercialChart
             DESTDIR = $$CHART_BUILD_LIB_DIR
             TEMPLATE = lib
             QT += core \
                 gui
             CONFIG += debug_and_release
             CONFIG(debug, debug|release):TARGET = QtCommercialChartd
             SOURCES += barchart/barchartseries.cpp \
                 barchart/bargroup.cpp \
                 barchart/bar.cpp \
                 barchart/stackedbarchartseries.cpp \
                 barchart/stackedbargroup.cpp \
                 barchart/percentbarchartseries.cpp \
                 barchart/percentbargroup.cpp \
                 barchart/barlabel.cpp \
                 linechart/linechartanimationitem.cpp \
                 linechart/linechartitem.cpp \
                 linechart/qlinechartseries.cpp \
-                piechart/qpieseries.cpp \
-                piechart/pieslice.cpp \
-                piechart/piepresentation.cpp \
                 barchart/separator.cpp \
                 barchart/bargroupbase.cpp \
                 barchart/barchartseriesbase.cpp \
                 plotdomain.cpp \
                 qscatterseries.cpp \
                 qchart.cpp \
                 axisitem.cpp \
                 qchartview.cpp \
                 qchartseries.cpp \
                 qchartaxis.cpp \
                 charttheme.cpp \
                 chartdataset.cpp \
                 chartpresenter.cpp \
                 domain.cpp
             PRIVATE_HEADERS += linechart/linechartitem_p.h \
                 linechart/linechartanimationitem_p.h \
                 barchart/barlabel_p.h \
                 barchart/bar_p.h \
                 barchart/separator_p.h \
-                piechart/piepresentation.h \
-                piechart/pieslice.h \
                 plotdomain_p.h \
                 qscatterseries_p.h \
                 axisitem_p.h \
                 chartitem_p.h \
                 charttheme_p.h \
                 chartdataset_p.h \
                 chartpresenter_p.h \
                 domain_p.h
             PUBLIC_HEADERS += linechart/qlinechartseries.h \
                 barchart/barchartseries.h \
                 barchart/bargroup.h \
                 barchart/stackedbarchartseries.h \
                 barchart/stackedbargroup.h \
                 barchart/percentbarchartseries.h \
                 barchart/percentbargroup.h \
                 barchart/barchartseriesbase.h \
                 barchart/bargroupbase.h \
-                piechart/qpieseries.h \
                 qchartseries.h \
                 qscatterseries.h \
                 qchart.h \
                 qchartglobal.h \
                 qchartview.h \
                 qchartaxis.h
+            include(piechart/piechart.pri)
             THEMES += themes/chartthemeicy_p.h \
                 themes/chartthemegrayscale_p.h \
                 themes/chartthemescientific_p.h \
                 themes/chartthemevanilla_p.h
             HEADERS += $$PUBLIC_HEADERS
             HEADERS += $$PRIVATE_HEADERS
             HEADERS += $$THEMES
             INCLUDEPATH += linechart \
                 barchart \
-                piechart \
                 themes \
                 .
             OBJECTS_DIR = $$CHART_BUILD_DIR/lib
             MOC_DIR = $$CHART_BUILD_DIR/lib
             UI_DIR = $$CHART_BUILD_DIR/lib
             RCC_DIR = $$CHART_BUILD_DIR/lib
             DEFINES += QTCOMMERCIALCHART_LIBRARY
             public_headers.path = $$[QT_INSTALL_HEADERS]/QtCommercialChart
             public_headers.files = $$PUBLIC_HEADERS
             target.path = $$[QT_INSTALL_LIBS]
             INSTALLS += target \
                 public_headers
             install_build_headers.name = bild_headers
             install_build_headers.output = $$CHART_BUILD_HEADER_DIR/${QMAKE_FILE_BASE}.h
             install_build_headers.input = PUBLIC_HEADERS
             install_build_headers.commands = $$QMAKE_COPY \
                 ${QMAKE_FILE_NAME} \
                 $$CHART_BUILD_HEADER_DIR
             install_build_headers.CONFIG += target_predeps \
                 no_link
             QMAKE_EXTRA_COMPILERS += install_build_headers
             chartversion.target = qchartversion_p.h
             chartversion.commands = @echo \
                 "build_time" \
                 > \
                 $$chartversion.target;
             chartversion.depends = $$HEADERS \
                 $$SOURCES
             PRE_TARGETDEPS += qchartversion_p.h
             QMAKE_CLEAN += qchartversion_p.h
             QMAKE_EXTRA_TARGETS += chartversion
             unix:QMAKE_DISTCLEAN += -r \
                 $$CHART_BUILD_HEADER_DIR \
                 $$CHART_BUILD_LIB_DIR
             win32:QMAKE_DISTCLEAN += /Q \
                 $$CHART_BUILD_HEADER_DIR \
                 $$CHART_BUILD_LIB_DIR

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages