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

src/animations/xyanimation.cpp +1 -1

             {
                 if(state()!=QAbstractAnimation::Stopped){ //workaround
                     QVector<QPointF> vector = qVariantValue<QVector<QPointF> >(value);
-                    m_item->setGeometry(vector);
+                    m_item->setLayout(vector);
                 }
             }

src/areachart/areachartitem.cpp +2 -12

                 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;
             void AreaChartItem::handleUpdated()
             {
-                setPen(m_series->pen());
+                m_pen = m_series->pen();
-                setBrush(m_series->brush());
+                m_brush = m_series->brush();
                 update();
             }

src/areachart/areachartitem_p.h +2 -4

                 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:
                 ~AreaBoundItem(){};
-                void setGeometry(QVector<QPointF>& points){
+                void setLayout(QVector<QPointF>& points){
-                    LineChartItem::setGeometry(points);
+                    LineChartItem::setLayout(points);
                     m_item->updatePath();
                 }

src/charttheme.cpp +2 -6

                 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);
                 }
             }

src/linechart/linechartitem.cpp +3 -3

                 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;
                 }
                 m_path = linePath;
                 m_rect = linePath.boundingRect();
-                XYChartItem::setGeometry(points);
+                XYChartItem::setLayout(points);
             }
             void LineChartItem::handleUpdated()

src/linechart/linechartitem_p.h +1 -1

                 void clicked(const QPointF& point);
             protected:
-                virtual void setGeometry(QVector<QPointF>& points);
+                void setLayout(QVector<QPointF>& points);
                 void mousePressEvent( QGraphicsSceneMouseEvent * event );
             private:

src/scatterseries/scatterchartitem.cpp +3 -3

                 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;
                 }
                 prepareGeometryChange();
                 m_rect = clipRect();
-                XYChartItem::setGeometry(points);
+                XYChartItem::setLayout(points);
             }

src/scatterseries/scatterchartitem_p.h +1 -1

                 void deletePoints(int count);
             protected:
-                virtual void setGeometry(QVector<QPointF>& points);
+                void setLayout(QVector<QPointF>& points);
             private:
                 QScatterSeries *m_series;

src/splinechart/splinechartitem.cpp +3 -3

                 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;
                 }
                 prepareGeometryChange();
                 m_path = splinePath;
                 m_rect = splinePath.boundingRect();
-                XYChartItem::setGeometry(points);
+                XYChartItem::setLayout(points);
             }
             void SplineChartItem::setLinePen(const QPen& pen)

src/splinechart/splinechartitem_p.h +1 -1

                 void handleUpdated();
             protected:
-                void setGeometry(QVector<QPointF>& points);
+                void setLayout(QVector<QPointF>& points);
             private:
                 QPointF calculateGeometryControlPoint(int index) const;

src/xychart/xychartitem.cpp +10 -10

                 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;
             }
                 QPointF point = calculateGeometryPoint(index);
                 QVector<QPointF> points = m_points;
                 points.insert(index,point);
-                updatePoints(points);
+                updateLayout(points);
                 update();
             }
             void XYChartItem::handlePointRemoved(int index)
             //    QPointF point = calculateGeometryPoint(index);
                 QVector<QPointF> points = m_points;
                 points.remove(index);
-                updatePoints(points);
+                updateLayout(points);
                 update();
             }
                 QPointF point = calculateGeometryPoint(index);
                 QVector<QPointF> points = m_points;
                 points.replace(index,point);
-                updatePoint(points);
+                updateLayout(points);
                 update();
             }
                 if(isEmpty()) return;
                 QVector<QPointF> points = calculateGeometryPoints();
-                updatePoints(points);
+                applyLayout(points);
                 update();
             }
                 if(isEmpty()) return;
             	QVector<QPointF> points = calculateGeometryPoints();
-            	updatePoints(points);
+            	applyLayout(points);
             	update();
             }

src/xychart/xychartitem_p.h +3 -3

                 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:

	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