HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r557:6b65c67e3745

Unify naming setGeometry -> setLayout

Michal Klocek -

r557:6b65c67e3745

parent child

Context file:

r557:6b65c67e3745

Collapse all files

src/animations/xyanimation.cpp +1 -1

             #include "xyanimation_p.h"
             #include "xychartitem_p.h"
             Q_DECLARE_METATYPE(QVector<QPointF>)
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             XYAnimation::XYAnimation(XYChartItem *item):ChartAnimation(item),
                 m_item(item),
                 m_type(MoveDownAnimation),
                 m_dirty(false)
             {
             }
             XYAnimation::~XYAnimation()
             {
             }
             void XYAnimation::setAnimationType(Animation type)
             {
                 m_type=type;
             }
             void XYAnimation::setValues(QVector<QPointF>& oldPoints,QVector<QPointF>& newPoints)
             {
                 setKeyValueAt(0.0, qVariantFromValue(oldPoints));
                 setKeyValueAt(1.0, qVariantFromValue(newPoints));
                 m_points = newPoints;
                 m_dirty=false;
             }
             void XYAnimation::updateValues(QVector<QPointF>& newPoints)
             {
                 if(state()!=QAbstractAnimation::Stopped) {
                     stop();
                     m_dirty=true;
                 }
                 if(m_dirty) {
                     m_points=newPoints;
                     m_dirty=false;
                 }
                 setKeyValueAt(0.0, qVariantFromValue(m_points));
                 setKeyValueAt(1.0, qVariantFromValue(newPoints));
             }
             QVariant XYAnimation::interpolated(const QVariant &start, const QVariant & end, qreal progress ) const
             {
                 QVector<QPointF> startVector = qVariantValue<QVector<QPointF> >(start);
                 QVector<QPointF> endVector = qVariantValue<QVector<QPointF> >(end);
                 QVector<QPointF> result;
                 switch(m_type) {
                     case MoveDownAnimation: {
                         Q_ASSERT(startVector.count() == endVector.count());
                         for(int i =0;i< startVector.count();i++) {
                             qreal x = startVector[i].x() + ((endVector[i].x()- startVector[i].x()) * progress);
                             qreal y = startVector[i].y() + ((endVector[i].y()- startVector[i].y()) * progress);
                             result << QPointF(x,y);
                         }
                     }
                         break;
                     case LineDrawAnimation:{
                         for(int i =0;i< endVector.count()* qBound(0.0, progress, 1.0);i++) {
                             result << endVector[i];
                         }
                     }
                         break;
                     default:
                         qWarning()<<"Unknow type of animation";
                         break;
                 }
                 return qVariantFromValue(result);
             }
             void XYAnimation::updateCurrentValue (const QVariant & value )
             {
                 if(state()!=QAbstractAnimation::Stopped){ //workaround
                     QVector<QPointF> vector = qVariantValue<QVector<QPointF> >(value);
-                    m_item->setGeometry(vector);
+                    m_item->setLayout(vector);
                 }
             }
             void XYAnimation::updateState(QAbstractAnimation::State newState, QAbstractAnimation::State oldState)
             {
                 Q_UNUSED(oldState)
                 if (newState==QAbstractAnimation::Running)  m_dirty=true;
                 QVariantAnimation::updateState(newState,oldState);
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/areachart/areachartitem.cpp +2 -12

             #include "areachartitem_p.h"
             #include "qareaseries.h"
             #include "qlineseries.h"
             #include <QPainter>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             //TODO: optimize : remove points which are not visible
             AreaChartItem::AreaChartItem(QAreaSeries* areaSeries,QGraphicsItem *parent):ChartItem(parent),
             m_series(areaSeries),
             m_upper(0),
             m_lower(0)
             {
                 //m_items.setZValue(ChartPresenter::LineChartZValue);
                 m_upper = new AreaBoundItem(this,m_series->upperSeries());
                 if(m_series->lowerSeries()){
                 m_lower = new AreaBoundItem(this,m_series->lowerSeries());
                 }
                 QObject::connect(areaSeries,SIGNAL(updated()),this,SLOT(handleUpdated()));
                 handleUpdated();
             }
             AreaChartItem::~AreaChartItem()
             {
                 delete m_upper;
                 delete m_lower;
             };
             QRectF AreaChartItem::boundingRect() const
             {
                 return m_rect;
             }
             QPainterPath AreaChartItem::shape() const
             {
                 return m_path;
             }
-            void AreaChartItem::setPen(const QPen& pen)
-                m_pen = pen;
-            void AreaChartItem::setBrush(const QBrush& brush)
-                m_brush = brush;
             void AreaChartItem::updatePath()
             {
                 QPainterPath path;
                 path.connectPath(m_upper->shape());
                 if(m_lower){
                 path.connectPath(m_lower->shape().toReversed());
                 }
                 else{
                     QPointF first = path.pointAtPercent(0);
                     QPointF last =  path.pointAtPercent(1);
                     path.lineTo(last.x(),m_clipRect.bottom());
                     path.lineTo(first.x(),m_clipRect.bottom());
                 }
                 path.closeSubpath();
                 prepareGeometryChange();
                 m_path=path;
                 m_rect=path.boundingRect();
                 update();
             }
             void AreaChartItem::handleUpdated()
             {
-                setPen(m_series->pen());
+                m_pen = m_series->pen();
-                setBrush(m_series->brush());
+                m_brush = m_series->brush();
                 update();
             }
             void AreaChartItem::handleDomainChanged(qreal minX, qreal maxX, qreal minY, qreal maxY)
             {
                 m_upper->handleDomainChanged(minX,maxX,minY,maxY);
                 if(m_lower)
                 m_lower->handleDomainChanged(minX,maxX,minY,maxY);
             }
             void AreaChartItem::handleGeometryChanged(const QRectF& rect)
             {
                 m_clipRect=rect.translated(-rect.topLeft());
                 setPos(rect.topLeft());
                 m_upper->handleGeometryChanged(rect);
                 if(m_lower)
                 m_lower->handleGeometryChanged(rect);
             }
             //painter
             void AreaChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(widget);
                 Q_UNUSED(option);
                 painter->save();
                 painter->setPen(m_pen);
                 painter->setBrush(m_brush);
                 painter->setClipRect(m_clipRect);
                 painter->drawPath(m_path);
                 painter->restore();
             }
             #include "moc_areachartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/areachart/areachartitem_p.h +2 -4

             #ifndef AREACHARTITEM_H
             #define AREACHARTITEM_H
             #include "qchartglobal.h"
             #include "linechartitem_p.h"
             #include <QPen>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QAreaSeries;
             class AreaChartItem;
             class AreaChartItem :  public QObject ,public ChartItem
             {
                 Q_OBJECT
             public:
                 AreaChartItem(QAreaSeries* areaSeries, QGraphicsItem *parent = 0);
                 ~ AreaChartItem();
                 //from QGraphicsItem
                 QRectF boundingRect() const;
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
                 QPainterPath shape() const;
-                void setPen(const QPen& pen);
-                void setBrush(const QBrush& brush);
                 void setPointsVisible(bool visible);
                 void updatePath();
             public slots:
                 void handleUpdated();
                 void handleDomainChanged(qreal minX, qreal maxX, qreal minY, qreal maxY);
                 void handleGeometryChanged(const QRectF& size);
             private:
                 QAreaSeries* m_series;
                 LineChartItem* m_upper;
                 LineChartItem* m_lower;
                 QPainterPath m_path;
                 QRectF m_rect;
                 QRectF m_clipRect;
                 QPen m_pen;
                 QBrush m_brush;
             };
             class AreaBoundItem : public LineChartItem
             {
             public:
                 AreaBoundItem(AreaChartItem* item,QLineSeries* lineSeries):LineChartItem(lineSeries),
                 m_item(item){};
                 ~AreaBoundItem(){};
-                void setGeometry(QVector<QPointF>& points){
+                void setLayout(QVector<QPointF>& points){
-                    LineChartItem::setGeometry(points);
+                    LineChartItem::setLayout(points);
                     m_item->updatePath();
                 }
             private:
                 AreaChartItem* m_item;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/charttheme.cpp +2 -6

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

src/linechart/linechartitem.cpp +3 -3

             #include "linechartitem_p.h"
             #include "qlineseries.h"
             #include "chartpresenter_p.h"
             #include <QPainter>
             #include <QGraphicsSceneMouseEvent>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             //TODO: optimize : remove points which are not visible
             LineChartItem::LineChartItem(QLineSeries* series,QGraphicsItem *parent):XYChartItem(series,parent),
             m_series(series),
             m_pointsVisible(false)
             {
                 setZValue(ChartPresenter::LineChartZValue);
                 QObject::connect(series,SIGNAL(updated()),this,SLOT(handleUpdated()));
                 QObject::connect(this,SIGNAL(clicked(const QPointF&)),series,SIGNAL(clicked(const QPointF&)));
                 handleUpdated();
             }
             QRectF LineChartItem::boundingRect() const
             {
             	return m_rect;
             }
             QPainterPath LineChartItem::shape() const
             {
                 return m_path;
             }
-            void LineChartItem::setGeometry(QVector<QPointF>& points)
+            void LineChartItem::setLayout(QVector<QPointF>& points)
             {
                 if(points.size()==0)
                 {
-                    XYChartItem::setGeometry(points);
+                    XYChartItem::setLayout(points);
                     return;
                 }
                 QList<QGraphicsItem*> items = m_items.childItems();
                 QPainterPath linePath(points.at(0));
                 for(int i=1; i< points.size();i++) {
                     linePath.lineTo(points.at(i));
                 }
                 prepareGeometryChange();
                 m_path = linePath;
                 m_rect = linePath.boundingRect();
-                XYChartItem::setGeometry(points);
+                XYChartItem::setLayout(points);
             }
             void LineChartItem::handleUpdated()
             {
                 m_pointsVisible = m_series->pointsVisible();
                 m_linePen = m_series->pen();
                 m_pointPen = m_series->pen();
                 m_pointPen.setWidthF(2*m_pointPen.width());
                 update();
             }
             //painter
             void LineChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(widget);
                 Q_UNUSED(option);
                 painter->save();
                 painter->setPen(m_linePen);
                 painter->setClipRect(clipRect());
                 painter->drawPath(m_path);
                 if(m_pointsVisible){
                 	painter->setPen(m_pointPen);
                 	painter->drawPoints(points());
                 }
                 painter->restore();
             }
             void LineChartItem::mousePressEvent( QGraphicsSceneMouseEvent * event )
             {
                 emit clicked(calculateDomainPoint(event->pos()));
             }
             #include "moc_linechartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/linechart/linechartitem_p.h +1 -1

             #ifndef LINECHARTITEM_H
             #define LINECHARTITEM_H
             #include "qchartglobal.h"
             #include "xychartitem_p.h"
             #include <QPen>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QLineSeries;
             class LineChartItem :  public XYChartItem
             {
                  Q_OBJECT
             public:
                  explicit LineChartItem(QLineSeries* series,QGraphicsItem *parent = 0);
                 ~ LineChartItem(){};
                 //from QGraphicsItem
                 QRectF boundingRect() const;
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
                 QPainterPath shape() const;
             public slots:
                 void handleUpdated();
             signals:
                 void clicked(const QPointF& point);
             protected:
-                virtual void setGeometry(QVector<QPointF>& points);
+                void setLayout(QVector<QPointF>& points);
                 void mousePressEvent( QGraphicsSceneMouseEvent * event );
             private:
                 QLineSeries* m_series;
                 QGraphicsItemGroup m_items;
                 QPainterPath m_path;
                 QRectF m_rect;
                 QPen m_linePen;
                 QPen m_pointPen;
                 bool m_pointsVisible;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/scatterseries/scatterchartitem.cpp +3 -3

             #include "scatterchartitem_p.h"
             #include "qscatterseries.h"
             #include "chartpresenter_p.h"
             #include <QPainter>
             #include <QGraphicsScene>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ScatterChartItem::ScatterChartItem(QScatterSeries *series, QGraphicsItem *parent) :
                 XYChartItem(series,parent),
                 m_series(series),
                 m_items(this),
                 m_shape(QScatterSeries::MarkerShapeRectangle),
                 m_size(10)
             {
                 Q_ASSERT(parent);
                 Q_ASSERT(series);
                 QObject::connect(m_series,SIGNAL(updated()), this, SLOT(handleUpdated()));
                 QObject::connect(this,SIGNAL(clicked(const QPointF&)), m_series, SIGNAL(clicked(const QPointF&)));
                 setZValue(ChartPresenter::ScatterSeriesZValue);
                 setFlags(QGraphicsItem::ItemHasNoContents);
                 setFlags(QGraphicsItem::ItemClipsChildrenToShape);
                 handleUpdated();
                 m_items.setHandlesChildEvents(false);
                 // TODO: how to draw a drop shadow?
             //    QGraphicsDropShadowEffect *dropShadow = new QGraphicsDropShadowEffect();
             //    dropShadow->setOffset(2.0);
             //    dropShadow->setBlurRadius(2.0);
             //    setGraphicsEffect(dropShadow);
             }
             QRectF ScatterChartItem::boundingRect() const
             {
                 return m_rect;
             }
             void ScatterChartItem::createPoints(int count)
             {
                 for (int i = 0; i < count; ++i) {
                     QGraphicsItem *item;
                     switch (m_shape) {
                                case QScatterSeries::MarkerShapeCircle:{
                                    QGraphicsEllipseItem* i = new QGraphicsEllipseItem(0,0,m_size,m_size);
                                    const QRectF& rect = i->boundingRect();
                                    i->setPos(-rect.width()/2,-rect.height()/2);
                                    item = new Marker(i,this);
                                    break;
                                }
                                case QScatterSeries::MarkerShapeRectangle:{
                                    QGraphicsRectItem* i = new QGraphicsRectItem(0,0,m_size,m_size);
                                    i->setPos(-m_size/2,-m_size/2);
                                    item = new Marker(i,this);
                                    break;
                                }
                                default:
                                    qWarning()<<"Unsupported marker type";
                                    break;
                     }
                     m_items.addToGroup(item);
                 }
             }
             void ScatterChartItem::deletePoints(int count)
             {
                 QList<QGraphicsItem *> items = m_items.childItems();
                 for (int i = 0; i < count; ++i) {
                     delete(items.takeLast());
                 }
             }
             void ScatterChartItem::markerSelected(Marker* marker)
             {
                 emit clicked(QPointF(m_series->x(marker->index()), m_series->y(marker->index())));
             }
-            void ScatterChartItem::setGeometry(QVector<QPointF>& points)
+            void ScatterChartItem::setLayout(QVector<QPointF>& points)
             {
                 if(points.size()==0)
                 {
-                    XYChartItem::setGeometry(points);
+                    XYChartItem::setLayout(points);
                     return;
                 }
                 int diff = XYChartItem::points().size() - points.size();
                 if(diff>0) {
                     deletePoints(diff);
                 }
                 else if(diff<0) {
                     createPoints(-diff);
                 }
                 if(diff!=0) handleUpdated();
                 QList<QGraphicsItem*> items = m_items.childItems();
                 for(int i=0; i< points.size();i++) {
                     Marker* item = static_cast<Marker*>(items.at(i));
                     const QPointF& point = points.at(i);
                     const QRectF& rect = item->boundingRect();
                     item->setIndex(i);
                     item->setPos(point.x()-rect.width()/2,point.y()-rect.height()/2);
                     if(!clipRect().contains(point)) {
                         item->setVisible(false);
                     }
                     else {
                         item->setVisible(true);
                     }
                 }
                 prepareGeometryChange();
                 m_rect = clipRect();
-                XYChartItem::setGeometry(points);
+                XYChartItem::setLayout(points);
             }
             void ScatterChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(painter);
                 Q_UNUSED(option);
                 Q_UNUSED(widget);
             }
             void ScatterChartItem::setPen(const QPen& pen)
             {
                 foreach(QGraphicsItem* item , m_items.childItems()) {
                        static_cast<Marker*>(item)->setPen(pen);
                 }
             }
             void ScatterChartItem::setBrush(const QBrush& brush)
             {
                 foreach(QGraphicsItem* item , m_items.childItems()) {
                         static_cast<Marker*>(item)->setBrush(brush);
                  }
             }
             void ScatterChartItem::handleUpdated()
             {
                 int count = m_items.childItems().count();
                 if(count==0) return;
                 bool recreate = m_size != m_series->size() || m_shape != m_series->shape();
                 //TODO: only rewrite on size change
                 m_size = m_series->size();
                 m_shape = m_series->shape();
                 if(recreate){
                     deletePoints(count);
                     createPoints(count);
                 }
                 setPen(m_series->pen());
                 setBrush(m_series->brush());
             }
             #include "moc_scatterchartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/scatterseries/scatterchartitem_p.h +1 -1

             #ifndef SCATTERPRESENTER_H
             #define SCATTERPRESENTER_H
             #include "qchartglobal.h"
             #include "xychartitem_p.h"
             #include <QGraphicsEllipseItem>
             #include <QPen>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QScatterSeries;
             class Marker;
             class ScatterChartItem : public XYChartItem
             {
                 Q_OBJECT
             public:
                 explicit ScatterChartItem(QScatterSeries *series, QGraphicsItem *parent = 0);
             public:
                 //from QGraphicsItem
                 QRectF boundingRect() const;
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
                 void setPen(const QPen& pen);
                 void setBrush(const QBrush& brush);
                 void markerSelected(Marker* item);
             signals:
                 void clicked(const QPointF& point);
             public slots:
                 void handleUpdated();
             private:
                 void createPoints(int count);
                 void deletePoints(int count);
             protected:
-                virtual void setGeometry(QVector<QPointF>& points);
+                void setLayout(QVector<QPointF>& points);
             private:
                 QScatterSeries *m_series;
                 QGraphicsItemGroup m_items;
                 int m_shape;
                 int m_size;
                 QRectF m_rect;
             };
             class Marker: public QAbstractGraphicsShapeItem
             {
             public:
                Marker(QAbstractGraphicsShapeItem* item , ScatterChartItem* parent):QAbstractGraphicsShapeItem(0),m_item(item),m_parent(parent)
                {
                };
                ~Marker()
                {
                    delete m_item;
                }
                void setIndex(int index)
                {
                    m_index=index;
                }
                int index() const
                {
                    return m_index;
                }
                QPainterPath shape() const
                {
                    return m_item->shape();
                }
                QRectF boundingRect() const
                {
                    return m_item->boundingRect();
                }
                bool contains(const QPointF &point) const
                {
                    return m_item->contains(point);
                }
                void setPen(const QPen& pen)
                {
                    m_item->setPen(pen);
                }
                void setBrush(const QBrush& brush)
                {
                    m_item->setBrush(brush);
                }
                void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
                {
                    m_item->paint(painter,option,widget);
                }
             protected:
                void mousePressEvent( QGraphicsSceneMouseEvent * event )
                {
                    m_parent->markerSelected(this);
                }
             private:
                QAbstractGraphicsShapeItem* m_item;
                ScatterChartItem* m_parent;
                int m_index;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // SCATTERPRESENTER_H

src/splinechart/splinechartitem.cpp +3 -3

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

src/splinechart/splinechartitem_p.h +1 -1

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

src/xychart/xychartitem.cpp +10 -10

             #include "xychartitem_p.h"
             #include "qxyseries.h"
             #include "chartpresenter_p.h"
             #include "chartanimator_p.h"
             #include <QPainter>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             //TODO: optimize : remove points which are not visible
             XYChartItem::XYChartItem(QXYSeries* series, QGraphicsItem *parent):ChartItem(parent),
             m_minX(0),
             m_maxX(0),
             m_minY(0),
             m_maxY(0),
             m_series(series)
             {
                 QObject::connect(series,SIGNAL(pointReplaced(int)),this,SLOT(handlePointReplaced(int)));
                 QObject::connect(series,SIGNAL(pointAdded(int)),this,SLOT(handlePointAdded(int)));
                 QObject::connect(series,SIGNAL(pointRemoved(int)),this,SLOT(handlePointRemoved(int)));
             }
             QPointF XYChartItem::calculateGeometryPoint(const QPointF& point) const
             {
                 const qreal deltaX = m_size.width()/(m_maxX-m_minX);
                 const qreal deltaY = m_size.height()/(m_maxY-m_minY);
                 qreal x = (point.x() - m_minX)* deltaX;
                 qreal y = (point.y() - m_minY)*-deltaY + m_size.height();
                 return QPointF(x,y);
             }
             QPointF XYChartItem::calculateGeometryPoint(int index) const
             {
                 const qreal deltaX = m_size.width()/(m_maxX-m_minX);
                 const qreal deltaY = m_size.height()/(m_maxY-m_minY);
                 qreal x = (m_series->x(index) - m_minX)* deltaX;
                 qreal y = (m_series->y(index) - m_minY)*-deltaY + m_size.height();
                 return QPointF(x,y);
             }
             QVector<QPointF> XYChartItem::calculateGeometryPoints() const
             {
                 const qreal deltaX = m_size.width()/(m_maxX-m_minX);
                 const qreal deltaY = m_size.height()/(m_maxY-m_minY);
                 QVector<QPointF> points;
                 points.reserve(m_series->count());
                 for (int i = 0; i < m_series->count(); ++i) {
                   qreal x = (m_series->x(i) - m_minX)* deltaX;
                   qreal y = (m_series->y(i) - m_minY)*-deltaY + m_size.height();
                   points << QPointF(x,y);
                 }
                 return points;
             }
             QPointF XYChartItem::calculateDomainPoint(const QPointF& point) const
             {
                 const qreal deltaX = m_size.width()/(m_maxX-m_minX);
                 const qreal deltaY = m_size.height()/(m_maxY-m_minY);
                 qreal x = point.x()/deltaX +m_minX;
                 qreal y = (point.y()-m_size.height())/(-deltaY)+ m_minY;
                 return QPointF(x,y);
             }
-            void XYChartItem::updatePoints(QVector<QPointF>& points)
+            void XYChartItem::applyLayout(QVector<QPointF>& points)
             {
                 if(m_animator){
                    m_animator->applyLayout(this,points);
                 }
-                   else  setGeometry(points);
+                   else setLayout(points);
             }
-            void XYChartItem::updatePoint(QVector<QPointF>& points)
+            void XYChartItem::updateLayout(QVector<QPointF>& points)
             {
-                setGeometry(points);
+                setLayout(points);
             }
-            void XYChartItem::setGeometry(QVector<QPointF>& points)
+            void XYChartItem::setLayout(QVector<QPointF>& points)
             {
                 m_points = points;
             }
             //handlers
             void XYChartItem::handlePointAdded(int index)
             {
                 Q_ASSERT(index<m_series->count());
                 Q_ASSERT(index>=0);
                 QPointF point = calculateGeometryPoint(index);
                 QVector<QPointF> points = m_points;
                 points.insert(index,point);
-                updatePoints(points);
+                updateLayout(points);
                 update();
             }
             void XYChartItem::handlePointRemoved(int index)
             {
                 Q_ASSERT(index<m_series->count() + 1);
                 Q_ASSERT(index>=0);
             //    QPointF point = calculateGeometryPoint(index);
                 QVector<QPointF> points = m_points;
                 points.remove(index);
-                updatePoints(points);
+                updateLayout(points);
                 update();
             }
             void XYChartItem::handlePointReplaced(int index)
             {
                 Q_ASSERT(index<m_series->count());
                 Q_ASSERT(index>=0);
                 QPointF point = calculateGeometryPoint(index);
                 QVector<QPointF> points = m_points;
                 points.replace(index,point);
-                updatePoint(points);
+                updateLayout(points);
                 update();
             }
             void XYChartItem::handleDomainChanged(qreal minX, qreal maxX, qreal minY, qreal maxY)
             {
                 m_minX=minX;
                 m_maxX=maxX;
                 m_minY=minY;
                 m_maxY=maxY;
                 if(isEmpty()) return;
                 QVector<QPointF> points = calculateGeometryPoints();
-                updatePoints(points);
+                applyLayout(points);
                 update();
             }
             void XYChartItem::handleGeometryChanged(const QRectF& rect)
             {
             	Q_ASSERT(rect.isValid());
             	m_size=rect.size();
             	m_clipRect=rect.translated(-rect.topLeft());
             	setPos(rect.topLeft());
                 if(isEmpty()) return;
             	QVector<QPointF> points = calculateGeometryPoints();
-            	updatePoints(points);
+            	applyLayout(points);
             	update();
             }
             bool XYChartItem::isEmpty()
             {
                return !m_clipRect.isValid() ||  m_maxX - m_minX == 0 || m_maxY - m_minY ==0 ;
             }
             #include "moc_xychartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/xychart/xychartitem_p.h +3 -3

             #ifndef XYCHARTITEM_H
             #define XYCHARTITEM_H
             #include "qchartglobal.h"
             #include "chartitem_p.h"
             #include <QPen>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartPresenter;
             class QXYSeries;
             class XYChartItem :  public QObject , public ChartItem
             {
                  Q_OBJECT
             public:
                  explicit XYChartItem(QXYSeries* series, QGraphicsItem *parent = 0);
                 ~ XYChartItem(){};
                 QVector<QPointF> points() const {return m_points;}
                 QRectF clipRect() const { return m_clipRect;}
             public slots:
                 void handlePointAdded(int index);
                 void handlePointRemoved(int index);
                 void handlePointReplaced(int index);
                 void handleDomainChanged(qreal minX, qreal maxX, qreal minY, qreal maxY);
                 void handleGeometryChanged(const QRectF& size);
             protected:
-                virtual void setGeometry(QVector<QPointF>& points);
+                virtual void setLayout(QVector<QPointF>& points);
                 QPointF calculateGeometryPoint(const QPointF& point) const;
                 QPointF calculateGeometryPoint(int index) const;
                 QPointF calculateDomainPoint(const QPointF& point) const;
                 QVector<QPointF> calculateGeometryPoints() const;
             private:
-                void updatePoints(QVector<QPointF>& points);
+                void applyLayout(QVector<QPointF>& points);
-                void updatePoint(QVector<QPointF>& points);
+                void updateLayout(QVector<QPointF>& points);
                 inline bool isEmpty();
             private:
                 qreal m_minX;
                 qreal m_maxX;
                 qreal m_minY;
                 qreal m_maxY;
                 QXYSeries* m_series;
                 QSizeF m_size;
                 QRectF m_clipRect;
                 QVector<QPointF> m_points;
                 friend class XYAnimation;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

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