HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r194:c7a6b069859c

Moved scatter impl into a subfolder

Tero Ahola -

r194:c7a6b069859c

parent child

Context file:

r194:c7a6b069859c

Collapse all files

src/scatterseries/scatter.pri created 644 +13 0

@@ -0,0 +1,13
	1	INCLUDEPATH += $$PWD
	2	DEPENDPATH += $$PWD
	3
	4	SOURCES += \
	5	$$PWD/qscatterseries.cpp \
	6	$$PWD/scatterpresenter.cpp
	7
	8	PRIVATE_HEADERS += \
	9	$$PWD/scatterpresenter_p.h \
	10	$$PWD/scatterseries_p.h
	11
	12	PUBLIC_HEADERS += \
	13	$$PWD/qscatterseries.h

src/chartpresenter.cpp +1 -1

             #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"
             #include "qscatterseries.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"
-            #include "scatterpresenter.h"
+            #include "scatterpresenter_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartPresenter::ChartPresenter(QChart* chart,ChartDataSet* dataset):QObject(chart),
             m_chart(chart),
             m_dataset(dataset),
             m_chartTheme(0),
             m_axisXItem(new AxisItem(AxisItem::X_AXIS,m_chart)),
             m_axisYItem(new AxisItem(AxisItem::Y_AXIS,m_chart)),
             m_domainIndex(0),
             m_marginSize(0),
             m_rect(QRectF(QPoint(0,0),m_chart->size()))
             {
                 setChartTheme(QChart::ChartThemeDefault);
                 createConnections();
             }
             ChartPresenter::~ChartPresenter()
             {
             }
             void ChartPresenter::createConnections()
             {
                 QObject::connect(m_chart,SIGNAL(geometryChanged()),this,SLOT(handleGeometryChanged()));
                 QObject::connect(m_dataset,SIGNAL(seriesAdded(QChartSeries*)),this,SLOT(handleSeriesAdded(QChartSeries*)));
                 QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),m_axisXItem,SLOT(handleGeometryChanged(const QRectF&)));
                 QObject::connect(m_dataset,SIGNAL(domainChanged(const Domain&)),m_axisXItem,SLOT(handleDomainChanged(const Domain&)));
                 QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),m_axisYItem,SLOT(handleGeometryChanged(const QRectF&)));
                 QObject::connect(m_dataset,SIGNAL(domainChanged(const Domain&)),m_axisYItem,SLOT(handleDomainChanged(const Domain&)));
             }
             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)
             {
                 qDebug() << " ChartPresenter::handleSeriesAdded";
                 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->model(),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->model(),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->model(),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);
                         ScatterPresenter *scatterPresenter = new ScatterPresenter(scatterSeries, m_chart);
                         QObject::connect(this, SIGNAL(geometryChanged(const QRectF&)),
                                          scatterPresenter, SLOT(handleGeometryChanged(const QRectF&)));
                         QObject::connect(m_dataset, SIGNAL(domainChanged(const Domain&)),
                                          scatterPresenter, SLOT(handleDomainChanged(const Domain&)));
                         m_chartTheme->decorate(scatterPresenter, scatterSeries, m_chartItems.count());
             //            scatterSeries->d->m_theme = m_chartTheme->themeForSeries();
             //            scatterSeries->d->setParentItem(this);
             //            scatterSeries->d->m_boundingRect = m_rect.adjusted(margin(),margin(), -margin(), -margin());
                         m_chartItems.insert(scatterSeries, scatterPresenter);
                         break;
                     }
                     case QChartSeries::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&)));
                         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::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);
                 }
                 m_chartTheme->decorate(m_axisX, m_axisXItem);
                 m_chartTheme->decorate(m_axisY, m_axisYItem);
             }
             QChart::ChartTheme ChartPresenter::chartTheme()
             {
                 return m_chartTheme->id();
             }
             void ChartPresenter::setDefaultAxisX(const QChartAxis& axis)
             {
                 //if(m_axisX != axis) {
                     m_axisX = axis;
                     m_axisXItem->handleAxisChanged(m_axisX);
                 //}
             }
             void ChartPresenter::setDefaultAxisY(const QChartAxis& axis)
             {
                 // if(m_axisY != axis) {
                     m_axisY = axis;
                     m_axisYItem->handleAxisChanged(m_axisY);
                 //}
             }
             QChartAxis ChartPresenter::defaultAxisX() const
             {
                 return m_axisX;
             }
             QChartAxis ChartPresenter::defaultAxisY() const
             {
                 return m_axisY;
             }
             QChartAxis ChartPresenter::axisY(int id) const
             {
                 return m_axis.value(id);
             }
             int ChartPresenter::addAxisY(const QChartAxis& axis)
             {
                 int key =0 ;
                 while(m_axis.contains(key)){
                     key++;
                     //TODO overflow
                 }
                 m_axis.insert(key,axis);
                 m_axisItems.insert(key,new AxisItem(AxisItem::Y_AXIS,m_chart));
                 return key;
             }
             void ChartPresenter::removeAxisY(int id)
             {
                 m_axis.remove(id);
                 delete m_axisItems.take(id);
             }
             #include "moc_chartpresenter_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/charttheme.cpp +1 -1

             #include "charttheme_p.h"
             #include "qchart.h"
             #include "qchartaxis.h"
             //series
             #include "barchartseries.h"
             #include "stackedbarchartseries.h"
             #include "percentbarchartseries.h"
             #include "qlinechartseries.h"
             #include "qscatterseries.h"
             #include "qpieseries.h"
             //items
             #include "axisitem_p.h"
             #include "bargroup.h"
             #include "stackedbargroup.h"
             #include "linechartitem_p.h"
             #include "percentbargroup.h"
-            #include "scatterpresenter.h"
+            #include "scatterpresenter_p.h"
             #include "piepresenter.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));
             }
             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;
                     }
                     case QChartSeries::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(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)
             {
                 // TODO: better way to descide series color and remove hard coded colors.
                 item->resetBrushes();
                 for (int i=0; i<m_seriesColor.count(); i++) {
                     QBrush brush(m_seriesColor.at(i));
                     item->addBrush(brush);
                 }
                 item->addBrush(QBrush(QColor(255,0,0,128)));
                 item->addBrush(QBrush(QColor(255,255,0,128)));
                 item->addBrush(QBrush(QColor(0,255,0,128)));
                 item->addBrush(QBrush(QColor(0,0,255,128)));
                 item->addBrush(QBrush(QColor(255,128,0,128)));
             }
             void ChartTheme::decorate(StackedBarGroup* item, StackedBarChartSeries* series,int count)
             {
                 // TODO: better way to descide series color and remove hard coded colors.
                 item->resetBrushes();
                 for (int i=0; i<m_seriesColor.count(); i++) {
                     QBrush brush(m_seriesColor.at(i));
                     item->addBrush(brush);
                 }
                 item->addBrush(QBrush(QColor(255,0,0,128)));
                 item->addBrush(QBrush(QColor(255,255,0,128)));
                 item->addBrush(QBrush(QColor(0,255,0,128)));
                 item->addBrush(QBrush(QColor(0,0,255,128)));
                 item->addBrush(QBrush(QColor(255,128,0,128)));
             }
             void ChartTheme::decorate(PercentBarGroup* item, PercentBarChartSeries* series,int count)
             {
                 // TODO: better way to descide series color and remove hard coded colors.
                 item->resetBrushes();
                 for (int i=0; i<m_seriesColor.count(); i++) {
                     QBrush brush(m_seriesColor.at(i));
                     item->addBrush(brush);
                 }
                 item->addBrush(QBrush(QColor(255,0,0,128)));
                 item->addBrush(QBrush(QColor(255,255,0,128)));
                 item->addBrush(QBrush(QColor(0,255,0,128)));
                 item->addBrush(QBrush(QColor(0,0,255,128)));
                 item->addBrush(QBrush(QColor(255,128,0,128)));
             }
             void ChartTheme::decorate(ScatterPresenter* presenter, QScatterSeries* series, int count)
             {
                 Q_ASSERT(presenter);
                 Q_ASSERT(series);
                 presenter->m_markerPen.setColor(m_seriesColor.at(count % m_seriesColor.size()));
             //    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(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();
                     // -1 means achromatic color -> cannot manipulate lightness
                     // TODO: find a better way to randomize lightness
                     if (c.toHsv().hue() == -1)
                         qWarning() << "ChartTheme::decorate() warning: achromatic theme color";
                     // randomize lightness
                     qreal f = 50 + (qrand() % 100); // 50 is 50% darker, 100 is the same, 150 is 50% lighter
                     c = c.lighter(f);
                     // find duplicates
                     bool isUnique = true;
                     foreach (QColor color, colors) {
                         if (c == color)
                             isUnique = false;
                     }
                     // add to array if unique
                     //if (isUnique)
                         colors << c;
                 }
                 // finally update colors
                 foreach (QPieSliceId id, series->ids()) {
                     QPieSlice s = series->slice(id);
                     s.setPen(QPen(Qt::black)); // TODO: get from theme
                     s.setBrush(colors.takeFirst());
                     series->update(s);
                 }
             }
             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);
                 item->handleAxisChanged(axis);
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/qchart.cpp +3 -3

             #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 "qscatterseries.h"
+            //#include "scatterseries_p.h"
+            #include "qpieseries.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)
             {
                 QChartSeries *series(0);
                 switch (type) {
                     case QChartSeries::SeriesTypeLine: {
                         series = new QLineChartSeries(this);
                         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::setChartTitle(const QString& title)
             {
                 if(!m_titleItem) m_titleItem = new QGraphicsTextItem(this);
                 m_titleItem->setPlainText(title);
             }
             void QChart::setChartTitleFont(const QFont& font)
             {
                 if(!m_titleItem) m_titleItem = new QGraphicsTextItem(this);
                 m_titleItem->setFont(font);
             }
             int QChart::margin() const
             {
                 return m_presenter->margin();
             }
             void QChart::setMargin(int margin)
             {
                 m_presenter->setMargin(margin);
             }
             void QChart::setChartTheme(QChart::ChartTheme theme)
             {
                 m_presenter->setChartTheme(theme);
             }
             QChart::ChartTheme QChart::chartTheme() const
             {
                 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::setDefaultAxisX(const QChartAxis& axis)
             {
                 m_presenter->setDefaultAxisX(axis);
             }
             void QChart::setDefaultAxisY(const QChartAxis& axis)
             {
                 m_presenter->setDefaultAxisY(axis);
             }
             QChartAxis QChart::defaultAxisX() const
             {
                 return m_presenter->defaultAxisX();
             }
             QChartAxis QChart::defaultAxisY() const
             {
                 return m_presenter->defaultAxisY();
             }
             int QChart::addAxisY(const QChartAxis& axis)
             {
                 return m_presenter->addAxisY(axis);
             }
             QChartAxis QChart::axisY(int id) const
             {
                 return m_presenter->axisY(id);
             }
             void QChart::removeAxisY(int id)
             {
                 m_presenter->removeAxisY(id);
             }
             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/scatterseries/qscatterseries.cpp ~~src/qscatterseries.cpp~~ renamed +1 -1

             #include "qscatterseries.h"
-            #include "qscatterseries_p.h"
+            #include "scatterseries_p.h"
             #include "qchart.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             QScatterSeriesPrivate::QScatterSeriesPrivate() :
                 m_data(QList<QPointF>())
             {
             }
             QScatterSeries::QScatterSeries(QObject *parent) :
                 QChartSeries(parent),
                 d(new QScatterSeriesPrivate())
             {
             }
             QScatterSeries::~QScatterSeries()
             {
                 delete d;
             }
             void QScatterSeries::addData(QPointF value)
             {
                 d->m_data.append(value);
                 emit changed();
             }
             QScatterSeries& QScatterSeries::operator << (const QPointF &value)
             {
                 d->m_data.append(value);
                 emit changed();
                 return *this;
             }
             void QScatterSeries::setData(QList<QPointF> data)
             {
                 d->m_data = data;
                 emit changed();
             }
             QList<QPointF> QScatterSeries::data()
             {
                 return d->m_data;
             }
             void QScatterSeries::setMarkerPen(QPen pen)
             {
                 d->m_markerPen = pen;
             }
             QPen QScatterSeries::markerPen()
             {
                 return d->m_markerPen;
             }
             #include "moc_qscatterseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/scatterseries/qscatterseries.h ~~src/qscatterseries.h~~ renamed 0 0

NO CONTENT: file renamed from src/qscatterseries.h to src/scatterseries/qscatterseries.h

src/scatterseries/scatterpresenter.cpp ~~src/scatterpresenter.cpp~~ renamed +2 -2

-            #include "scatterpresenter.h"
+            #include "scatterpresenter_p.h"
             #include "qscatterseries.h"
             #include <QPen>
             #include <QPainter>
             #include <QGraphicsScene>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ScatterPresenter::ScatterPresenter(QScatterSeries *series, QGraphicsObject *parent) :
                 ChartItem(parent),
                 m_series(series),
                 m_boundingRect(),
                 //m_markerColor(QColor()),
             //    m_markerColor(QColor(255, 0, 0)),
                 m_visibleChartArea()
             {
                 if (parent)
                     m_boundingRect = parent->boundingRect();
                 if (series) {
                     connect(series, SIGNAL(changed()), this, SLOT(handleModelChanged()));
                 }
             }
             void ScatterPresenter::handleDomainChanged(const Domain& domain)
             {
                 m_visibleChartArea = domain;
                 changeGeometry();
             }
             void ScatterPresenter::handleGeometryChanged(const QRectF& rect)
             {
                 m_boundingRect = rect;
                 changeGeometry();
             }
             void ScatterPresenter::handleModelChanged()
             {
                 // TODO: more fine grained modelChanged signaling
                 changeGeometry();
             }
             void ScatterPresenter::paint(QPainter *painter, const QStyleOptionGraphicsItem */*option*/, QWidget */*widget*/)
             {
                 // TODO: The opacity should be user definable?
                 //brush.setColor(QColor(255, 82, 0, 100));
                 //if (m_series->markerPen().isValid()) {
                 if (false) {
                     QPen pen = painter->pen();
                     QBrush brush = pen.brush();
                     brush.setColor(m_series->markerPen().color());
                     pen.setBrush(brush);
                     pen.setWidth(4);
                     painter->setPen(pen);
                 }
                 else {
                     // TODO: fix this
                     QPen pen = painter->pen();
                     QBrush brush = pen.brush();
                     brush.setColor(m_markerPen.color());
                     pen.setBrush(brush);
                     pen.setWidth(4);
                     painter->setPen(pen);
                 }
                 for (int i(0); i < m_scenex.count() && i < m_sceney.count(); i++) {
                     if (scene()->width() > m_scenex.at(i) && scene()->height() > m_sceney.at(i))
                         //painter->drawArc(m_scenex.at(i), m_sceney.at(i), 2, 2, 0, 5760);
                         painter->drawPoint(m_scenex.at(i), m_sceney.at(i));
                 }
             }
             void ScatterPresenter::changeGeometry()
             {
                 if (m_boundingRect.isValid()) {
                     prepareGeometryChange();
                     qreal scalex = m_boundingRect.width() / m_visibleChartArea.spanX();
                     qreal scaley = m_boundingRect.height() / m_visibleChartArea.spanY();
                     m_scenex.clear();
                     m_sceney.clear();
                     // Convert relative coordinates to absolute pixel coordinates that can be used for drawing
                     foreach (QPointF point, m_series->data()) {
                         m_scenex.append(m_boundingRect.left() + point.x() * scalex - m_visibleChartArea.m_minX * scalex);
                         m_sceney.append(m_boundingRect.bottom() - point.y() * scaley + m_visibleChartArea.m_minY * scaley);
                     }
                 }
             }
-            #include "moc_scatterpresenter.cpp"
+            #include "moc_scatterpresenter_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/scatterseries/scatterpresenter_p.h ~~src/scatterpresenter.h~~ renamed 0 0

NO CONTENT: file renamed from src/scatterpresenter.h to src/scatterseries/scatterpresenter_p.h

src/scatterseries/scatterseries_p.h ~~src/qscatterseries_p.h~~ renamed 0 0

NO CONTENT: file renamed from src/qscatterseries_p.h to src/scatterseries/scatterseries_p.h

src/src.pro +4 -9

             !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 \
                 barchart/barchartmodel.cpp \
                 barchart/separator.cpp \
                 barchart/bargroupbase.cpp \
                 barchart/qbarset.cpp \
                 barchart/qbarcategory.cpp \
                 linechart/linechartanimationitem.cpp \
                 linechart/linechartitem.cpp \
                 linechart/qlinechartseries.cpp \
-                qscatterseries.cpp \
-                #scatterpresentation.cpp \
                 qchart.cpp \
                 axisitem.cpp \
                 qchartview.cpp \
                 qchartseries.cpp \
                 qchartaxis.cpp \
                 charttheme.cpp \
                 chartdataset.cpp \
                 chartpresenter.cpp \
-                domain.cpp \
+                domain.cpp
-                scatterpresenter.cpp
             PRIVATE_HEADERS += linechart/linechartitem_p.h \
                 linechart/linechartanimationitem_p.h \
                 barchart/barlabel_p.h \
                 barchart/bar_p.h \
                 barchart/separator_p.h \
                 barchart/barchartmodel_p.h \
-                qscatterseries_p.h \
-                #scatterpresentation.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/bargroupbase.h \
                 barchart/qbarset.h \
                 barchart/qbarcategory.h \
                 qchartseries.h \
-                qscatterseries.h \
                 qchart.h \
                 qchartglobal.h \
                 qchartview.h \
                 qchartaxis.h
             include(piechart/piechart.pri)
+            include(scatterseries/scatter.pri)
             THEMES += themes/chartthemeicy_p.h \
                 themes/chartthemegrayscale_p.h \
                 themes/chartthemescientific_p.h \
                 themes/chartthemevanilla_p.h
-            HEADERS += $$PUBLIC_HEADERS \
+            HEADERS += $$PUBLIC_HEADERS
-                scatterpresenter.h
             HEADERS += $$PRIVATE_HEADERS
             HEADERS += $$THEMES
             INCLUDEPATH += linechart \
                 barchart \
                 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_public_headers.name = bild_public_headers
             install_build_public_headers.output = $$CHART_BUILD_PUBLIC_HEADER_DIR/${QMAKE_FILE_BASE}.h
             install_build_public_headers.input = PUBLIC_HEADERS
             install_build_public_headers.commands = $$QMAKE_COPY \
                 ${QMAKE_FILE_NAME} \
                 $$CHART_BUILD_PUBLIC_HEADER_DIR
             install_build_public_headers.CONFIG += target_predeps \
                 no_link
             install_build_private_headers.name = bild_private_headers
             install_build_private_headers.output = $$CHART_BUILD_PRIVATE_HEADER_DIR/${QMAKE_FILE_BASE}.h
             install_build_private_headers.input = PRIVATE_HEADERS
             install_build_private_headers.commands = $$QMAKE_COPY \
                 ${QMAKE_FILE_NAME} \
                 $$CHART_BUILD_PRIVATE_HEADER_DIR
             install_build_private_headers.CONFIG += target_predeps \
                 no_link
             QMAKE_EXTRA_COMPILERS += install_build_public_headers install_build_private_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