HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r2104:f8a933676fbd

more coding style fixes for src-folder...

Jani Honkonen -

r2104:f8a933676fbd

parent child

Context file:

r2104:f8a933676fbd

Expand all files

src/animations/axisanimation.cpp +1 -1

                 m_type = type;
             }
-            void AxisAnimation::setAnimationPoint(const QPointF& point)
+            void AxisAnimation::setAnimationPoint(const QPointF &point)
             {
                 if (state() != QAbstractAnimation::Stopped)
                     stop();

src/animations/axisanimation_p.h +1 -1

                 AxisAnimation(ChartAxis *axis);
                 ~AxisAnimation();
                 void setAnimationType(Animation type);
-                void setAnimationPoint(const QPointF& point);
+                void setAnimationPoint(const QPointF &point);
                 void setValues(QVector<qreal> &oldLayout, QVector<qreal> &newLayout);
             protected:
                 QVariant interpolated(const QVariant &from, const QVariant &to, qreal progress) const;

src/animations/pieanimation.cpp +3 -3

             {
             }
-            ChartAnimation* PieAnimation::updateValue(PieSliceItem *sliceItem, const PieSliceData &sliceData)
+            ChartAnimation *PieAnimation::updateValue(PieSliceItem *sliceItem, const PieSliceData &sliceData)
             {
                 PieSliceAnimation *animation = m_animations.value(sliceItem);
                 Q_ASSERT(animation);
                 return animation;
             }
-            ChartAnimation* PieAnimation::addSlice(PieSliceItem *sliceItem, const PieSliceData &sliceData, bool startupAnimation)
+            ChartAnimation *PieAnimation::addSlice(PieSliceItem *sliceItem, const PieSliceData &sliceData, bool startupAnimation)
             {
                 PieSliceAnimation *animation = new PieSliceAnimation(sliceItem);
                 m_animations.insert(sliceItem, animation);
                 return animation;
             }
-            ChartAnimation* PieAnimation::removeSlice(PieSliceItem *sliceItem)
+            ChartAnimation *PieAnimation::removeSlice(PieSliceItem *sliceItem)
             {
                 PieSliceAnimation *animation = m_animations.value(sliceItem);
                 Q_ASSERT(animation);

src/animations/pieanimation_p.h +3 -3

             public:
                 PieAnimation(PieChartItem *item);
                 ~PieAnimation();
-                ChartAnimation* updateValue(PieSliceItem *sliceItem, const PieSliceData &newValue);
+                ChartAnimation *updateValue(PieSliceItem *sliceItem, const PieSliceData &newValue);
-                ChartAnimation* addSlice(PieSliceItem *sliceItem, const PieSliceData &endValue, bool startupAnimation);
+                ChartAnimation *addSlice(PieSliceItem *sliceItem, const PieSliceData &endValue, bool startupAnimation);
-                ChartAnimation* removeSlice(PieSliceItem *sliceItem);
+                ChartAnimation *removeSlice(PieSliceItem *sliceItem);
             public: // from QVariantAnimation
                 void updateCurrentValue(const QVariant &value);

src/animations/splineanimation.cpp +4 -3

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            SplineAnimation::SplineAnimation(SplineChartItem* item): XYAnimation(item),
+            SplineAnimation::SplineAnimation(SplineChartItem *item)
-                m_item(item),
+                : XYAnimation(item),
-                m_valid(false)
+                  m_item(item),
+                  m_valid(false)
             {
             }

src/areachart/areachartitem_p.h +9 -8

                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
                 QPainterPath shape() const;
-                LineChartItem* upperLineItem() const { return m_upper; }
+                LineChartItem *upperLineItem() const { return m_upper; }
-                LineChartItem* lowerLineItem() const { return m_lower; }
+                LineChartItem *lowerLineItem() const { return m_lower; }
                 void updatePath();
                 void handleGeometryChanged(const QRectF &size);
             private:
-                QAreaSeries* m_series;
+                QAreaSeries *m_series;
-                LineChartItem* m_upper;
+                LineChartItem *m_upper;
-                LineChartItem* m_lower;
+                LineChartItem *m_lower;
                 QPainterPath m_path;
                 QRectF m_rect;
                 QRectF m_clipRect;
             class AreaBoundItem : public LineChartItem
             {
             public:
-                AreaBoundItem(AreaChartItem *item, QLineSeries *lineSeries, ChartPresenter* presenter)
+                AreaBoundItem(AreaChartItem *item, QLineSeries *lineSeries, ChartPresenter *presenter)
                     : LineChartItem(lineSeries, 0), m_item(item)
                 {
                     setPresenter(presenter);
                 }
                 ~AreaBoundItem() {}
-                void updateGeometry() {
+                void updateGeometry()
+                {
                     LineChartItem::updateGeometry();
                     m_item->updatePath();
                 }
             private:
-                AreaChartItem* m_item;
+                AreaChartItem *m_item;
             };
             QTCOMMERCIALCHART_END_NAMESPACE

src/areachart/qareaseries.cpp +13 -13

             /*!
                 Sets the \a series that is to be used as the area chart upper series.
             */
-            void QAreaSeries::setUpperSeries(QLineSeries* series)
+            void QAreaSeries::setUpperSeries(QLineSeries *series)
             {
                 Q_D(QAreaSeries);
                 d->m_upperSeries = series;
             }
-            QLineSeries* QAreaSeries::upperSeries() const
+            QLineSeries *QAreaSeries::upperSeries() const
             {
                 Q_D(const QAreaSeries);
                 return d->m_upperSeries;
             /*!
                 Sets the \a series that is to be used as the area chart lower series.
             */
-            void QAreaSeries::setLowerSeries(QLineSeries* series)
+            void QAreaSeries::setLowerSeries(QLineSeries *series)
             {
                 Q_D(QAreaSeries);
                 d->m_lowerSeries = series;
             }
-            QLineSeries* QAreaSeries::lowerSeries() const
+            QLineSeries *QAreaSeries::lowerSeries() const
             {
                 Q_D(const QAreaSeries);
                 return d->m_lowerSeries;
             ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-            QAreaSeriesPrivate::QAreaSeriesPrivate(QLineSeries *upperSeries, QLineSeries *lowerSeries, QAreaSeries* q)
+            QAreaSeriesPrivate::QAreaSeriesPrivate(QLineSeries *upperSeries, QLineSeries *lowerSeries, QAreaSeries *q)
                 : QAbstractSeriesPrivate(q),
                   m_upperSeries(upperSeries),
                   m_lowerSeries(lowerSeries),
             {
             }
-            void QAreaSeriesPrivate::scaleDomain(Domain& domain)
+            void QAreaSeriesPrivate::scaleDomain(Domain &domain)
             {
                 Q_Q(QAreaSeries);
                 qreal maxX(domain.maxX());
                 qreal maxY(domain.maxY());
-                QLineSeries* upperSeries = q->upperSeries();
+                QLineSeries *upperSeries = q->upperSeries();
-                QLineSeries* lowerSeries = q->lowerSeries();
+                QLineSeries *lowerSeries = q->lowerSeries();
                 const QList<QPointF>& points = upperSeries->points();
                 domain.setRange(minX, maxX, minY, maxY);
             }
-            ChartElement* QAreaSeriesPrivate::createGraphics(ChartPresenter* presenter)
+            ChartElement *QAreaSeriesPrivate::createGraphics(ChartPresenter *presenter)
             {
                 Q_Q(QAreaSeries);
-                AreaChartItem* area = new AreaChartItem(q, presenter);
+                AreaChartItem *area = new AreaChartItem(q, presenter);
                 if (presenter->animationOptions().testFlag(QChart::SeriesAnimations)) {
                     area->upperLineItem()->setAnimation(new XYAnimation(area->upperLineItem()));
                     if (q->lowerSeries())
                 return area;
             }
-            QList<LegendMarker*> QAreaSeriesPrivate::createLegendMarker(QLegend* legend)
+            QList<LegendMarker *> QAreaSeriesPrivate::createLegendMarker(QLegend *legend)
             {
                 Q_Q(QAreaSeries);
-                QList<LegendMarker*> list;
+                QList<LegendMarker *> list;
                 return list << new AreaLegendMarker(q, legend);
             }
-            void QAreaSeriesPrivate::initializeAxis(QAbstractAxis* axis)
+            void QAreaSeriesPrivate::initializeAxis(QAbstractAxis *axis)
             {
                 Q_UNUSED(axis);
             }

src/areachart/qareaseries.h +4 -4

             public:
                 QAbstractSeries::SeriesType type() const;
-                void setUpperSeries(QLineSeries* series);
+                void setUpperSeries(QLineSeries *series);
-                QLineSeries* upperSeries() const;
+                QLineSeries *upperSeries() const;
-                void setLowerSeries(QLineSeries* series);
+                void setLowerSeries(QLineSeries *series);
-                QLineSeries* lowerSeries() const;
+                QLineSeries *lowerSeries() const;
                 void setPen(const QPen &pen);
                 QPen pen() const;

src/areachart/qareaseries_p.h +7 -7

                 Q_OBJECT
             public:
-                QAreaSeriesPrivate(QLineSeries *upperSeries, QLineSeries *lowerSeries, QAreaSeries* q);
+                QAreaSeriesPrivate(QLineSeries *upperSeries, QLineSeries *lowerSeries, QAreaSeries *q);
-                void scaleDomain(Domain& domain);
+                void scaleDomain(Domain &domain);
-                ChartElement* createGraphics(ChartPresenter* presenter);
+                ChartElement *createGraphics(ChartPresenter *presenter);
-                QList<LegendMarker*> createLegendMarker(QLegend* legend);
+                QList<LegendMarker *> createLegendMarker(QLegend *legend);
-                void initializeAxis(QAbstractAxis* axis);
+                void initializeAxis(QAbstractAxis *axis);
                 QAbstractAxis::AxisType defaultAxisType(Qt::Orientation orientation) const;
             Q_SIGNALS:
             protected:
                 QBrush m_brush;
                 QPen m_pen;
-                QLineSeries* m_upperSeries;
+                QLineSeries *m_upperSeries;
-                QLineSeries* m_lowerSeries;
+                QLineSeries *m_lowerSeries;
                 bool m_pointsVisible;
             private:
                 Q_DECLARE_PUBLIC(QAreaSeries);

src/axis/barcategoryaxis/chartbarcategoryaxisx.cpp +7 -7

                 const qreal delta =  chartRect.width() / (m_categoriesAxis->d_ptr->count());
-                QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(axis.at(0));
+                QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem *>(axis.at(0));
                 lineItem->setLine(chartRect.left(),  chartRect.bottom(),  chartRect.right(),  chartRect.bottom());
                 qreal width =  chartRect.left();
                 for (int i = 0; i < layout.size(); ++i) {
-                    QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(lines.at(i));
+                    QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem *>(lines.at(i));
                     lineItem->setLine(layout[i],  chartRect.top(), layout[i],  chartRect.bottom());
-                    QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem*>(labels.at(i));
+                    QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem *>(labels.at(i));
                     labelItem->setText(ticksList.at(i));
-                    const QRectF& rect = labelItem->boundingRect();
+                    const QRectF &rect = labelItem->boundingRect();
                     QPointF center = rect.center();
                     labelItem->setTransformOriginPoint(center.x(), center.y());
                     }
                     if ((i + 1) % 2 && i > 1) {
-                        QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem*>(shades.at(i / 2 - 1));
+                        QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem *>(shades.at(i / 2 - 1));
                         rectItem->setRect(layout[i - 1], chartRect.top(), layout[i] - layout[i - 1], chartRect.height());
                     }
-                    lineItem = static_cast<QGraphicsLineItem*>(axis.at(i + 1));
+                    lineItem = static_cast<QGraphicsLineItem *>(axis.at(i + 1));
                     lineItem->setLine(layout[i], chartRect.bottom(), layout[i], chartRect.bottom() + 5);
                 }
             }
                 ChartAxis::handleAxisUpdated();
             }
-            QSizeF ChartBarCategoryAxisX::sizeHint(Qt::SizeHint which, const QSizeF& constraint) const
+            QSizeF ChartBarCategoryAxisX::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
             {
                 Q_UNUSED(constraint)

src/axis/barcategoryaxis/chartbarcategoryaxisx_p.h +1 -1

                 ~ChartBarCategoryAxisX();
                 AxisType axisType() const { return X_AXIS;}
-                QSizeF sizeHint(Qt::SizeHint which, const QSizeF& constraint) const;
+                QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint) const;
             protected:
                 QVector<qreal> calculateLayout() const;
                 void updateGeometry();

src/axis/barcategoryaxis/chartbarcategoryaxisy.cpp +7 -7

                 const qreal delta = chartRect.height() / (m_categoriesAxis->d_ptr->count());
-                QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(axis.at(0));
+                QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem *>(axis.at(0));
                 lineItem->setLine(chartRect.left() , chartRect.top(), chartRect.left(), chartRect.bottom());
                 qreal height = chartRect.bottom();
                 for (int i = 0; i < layout.size(); ++i) {
-                    QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(lines.at(i));
+                    QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem *>(lines.at(i));
                     lineItem->setLine(chartRect.left() , layout[i], chartRect.right(), layout[i]);
-                    QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem*>(labels.at(i));
+                    QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem *>(labels.at(i));
                     labelItem->setText(ticksList.at(i));
-                    const QRectF& rect = labelItem->boundingRect();
+                    const QRectF &rect = labelItem->boundingRect();
                     QPointF center = rect.center();
                     labelItem->setTransformOriginPoint(center.x(), center.y());
                     }
                     if ((i + 1) % 2 && i > 1) {
-                        QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem*>(shades.at(i / 2 - 1));
+                        QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem *>(shades.at(i / 2 - 1));
                         rectItem->setRect(chartRect.left(), layout[i], chartRect.width(), layout[i - 1] - layout[i]);
                     }
-                    lineItem = static_cast<QGraphicsLineItem*>(axis.at(i + 1));
+                    lineItem = static_cast<QGraphicsLineItem *>(axis.at(i + 1));
                     lineItem->setLine(chartRect.left() - 5, layout[i], chartRect.left(), layout[i]);
                 }
             }
                 ChartAxis::handleAxisUpdated();
             }
-            QSizeF ChartBarCategoryAxisY::sizeHint(Qt::SizeHint which, const QSizeF& constraint) const
+            QSizeF ChartBarCategoryAxisY::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
             {
                 Q_UNUSED(constraint)

src/axis/barcategoryaxis/chartbarcategoryaxisy_p.h +1 -1

                 ~ChartBarCategoryAxisY();
                 AxisType axisType() const { return Y_AXIS;}
-                QSizeF sizeHint(Qt::SizeHint which, const QSizeF& constraint) const;
+                QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint) const;
             protected:
                 QVector<qreal> calculateLayout() const;
                 void updateGeometry();

src/axis/barcategoryaxis/qbarcategoryaxis.cpp +11 -11

             /*!
                 Sets minimum category to \a min.
             */
-            void QBarCategoryAxis::setMin(const QString& min)
+            void QBarCategoryAxis::setMin(const QString &min)
             {
                 Q_D(QBarCategoryAxis);
                 setRange(min, d->m_maxCategory);
             /*!
                 Sets maximum category to \a max.
             */
-            void QBarCategoryAxis::setMax(const QString& max)
+            void QBarCategoryAxis::setMax(const QString &max)
             {
                 Q_D(QBarCategoryAxis);
                 setRange(d->m_minCategory, max);
             /*!
                 Sets range from \a minCategory to \a maxCategory
             */
-            void QBarCategoryAxis::setRange(const QString& minCategory, const QString& maxCategory)
+            void QBarCategoryAxis::setRange(const QString &minCategory, const QString &maxCategory)
             {
                 Q_D(QBarCategoryAxis);
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-            QBarCategoryAxisPrivate::QBarCategoryAxisPrivate(QBarCategoryAxis* q):
+            QBarCategoryAxisPrivate::QBarCategoryAxisPrivate(QBarCategoryAxis *q)
-                QAbstractAxisPrivate(q),
+                : QAbstractAxisPrivate(q),
-                m_min(0.0),
+                  m_min(0.0),
-                m_max(0.0),
+                  m_max(0.0),
-                m_count(0)
+                  m_count(0)
             {
             }
             void QBarCategoryAxisPrivate::handleDomainUpdated()
             {
                 Q_Q(QBarCategoryAxis);
-                Domain* domain = qobject_cast<Domain*>(sender());
+                Domain *domain = qobject_cast<Domain *>(sender());
                 if (m_orientation == Qt::Horizontal) {
                     m_min = domain->minX();
                     emit q->rangeChanged(m_minCategory, m_maxCategory);
             }
-            ChartAxis* QBarCategoryAxisPrivate::createGraphics(ChartPresenter* presenter)
+            ChartAxis *QBarCategoryAxisPrivate::createGraphics(ChartPresenter *presenter)
             {
                 Q_Q(QBarCategoryAxis);
                 if (m_orientation == Qt::Vertical)
                 return new ChartBarCategoryAxisX(q, presenter);
             }
-            void QBarCategoryAxisPrivate::intializeDomain(Domain* domain)
+            void QBarCategoryAxisPrivate::intializeDomain(Domain *domain)
             {
                 Q_Q(QBarCategoryAxis);

src/axis/barcategoryaxis/qbarcategoryaxis.h +3 -3

                 QString at(int index) const;
                 //range handling
-                void setMin(const QString& minCategory);
+                void setMin(const QString &minCategory);
                 QString min() const;
-                void setMax(const QString& maxCategory);
+                void setMax(const QString &maxCategory);
                 QString max() const;
-                void setRange(const QString& minCategory, const QString& maxCategory);
+                void setRange(const QString &minCategory, const QString &maxCategory);
             Q_SIGNALS:
                 void categoriesChanged();

src/axis/barcategoryaxis/qbarcategoryaxis_p.h +2 -2

                 ~QBarCategoryAxisPrivate();
             public:
-                ChartAxis* createGraphics(ChartPresenter* presenter);
+                ChartAxis *createGraphics(ChartPresenter *presenter);
-                void intializeDomain(Domain* domain);
+                void intializeDomain(Domain *domain);
                 void handleDomainUpdated();
                 qreal min() { return m_min; }
                 qreal max() { return m_max; }

src/axis/categoryaxis/chartcategoryaxisx.cpp +7 -7

                 QRectF chartRect = presenter()->chartsGeometry();
                 // axis base line
-                QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(axis.at(0));
+                QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem *>(axis.at(0));
                 lineItem->setLine(chartRect.left(), chartRect.bottom(), chartRect.right(), chartRect.bottom());
                 for (int i = 0; i < layout.size(); ++i) {
-                    QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem*>(labels.at(i));
+                    QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem *>(labels.at(i));
                     if (i < ticksList.count())
                         labelItem->setText(ticksList.at(i));
-                    const QRectF& rect = labelItem->boundingRect();
+                    const QRectF &rect = labelItem->boundingRect();
                     QPointF center = rect.center();
                     labelItem->setTransformOriginPoint(center.x(), center.y());
                         labelItem->setVisible(true);
                     if ((i + 1) % 2 && i > 1) {
-                        QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem*>(shades.at(i / 2 - 1));
+                        QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem *>(shades.at(i / 2 - 1));
                         rectItem->setRect(layout[i - 1], chartRect.top(), layout[i] - layout[i - 1], chartRect.height());
                     }
                     // grid lines and axis line ticks
-                    QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(lines.at(i));
+                    QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem *>(lines.at(i));
                     lineItem->setPos(layout[i], chartRect.top());
                     lineItem->setLine(0, 0, 0, chartRect.height());
-                    QGraphicsLineItem *tickLineItem = static_cast<QGraphicsLineItem*>(axis.at(i + 1));
+                    QGraphicsLineItem *tickLineItem = static_cast<QGraphicsLineItem *>(axis.at(i + 1));
                     tickLineItem->setPos(layout[i], chartRect.bottom());
                     tickLineItem->setLine(0, 0, 0, 5);
                 ChartAxis::handleAxisUpdated();
             }
-            QSizeF ChartCategoryAxisX::sizeHint(Qt::SizeHint which, const QSizeF& constraint) const
+            QSizeF ChartCategoryAxisX::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
             {
                 Q_UNUSED(constraint)

src/axis/categoryaxis/chartcategoryaxisx_p.h +1 -1

                 ~ChartCategoryAxisX();
                 AxisType axisType() const { return X_AXIS; }
-                QSizeF sizeHint(Qt::SizeHint which, const QSizeF& constraint) const;
+                QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint) const;
             protected:
                 QVector<qreal> calculateLayout() const;
                 void updateGeometry();

src/axis/categoryaxis/chartcategoryaxisy.cpp +7 -7

                 QRectF chartRect = presenter()->chartsGeometry();
                 // axis base line
-                QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(axis.at(0));
+                QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem *>(axis.at(0));
                 lineItem->setLine(chartRect.left() , chartRect.top(), chartRect.left(), chartRect.bottom());
                 for (int i = 0; i < layout.size(); ++i) {
                     // label items
-                    QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem*>(labels.at(i));
+                    QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem *>(labels.at(i));
                     if (i < ticksList.count()) {
                         labelItem->setText(ticksList.at(i));
                     }
-                    const QRectF& rect = labelItem->boundingRect();
+                    const QRectF &rect = labelItem->boundingRect();
                     QPointF center = rect.center();
                     labelItem->setTransformOriginPoint(center.x(), center.y());
                         labelItem->setVisible(true);
                     if ((i + 1) % 2 && i > 1) {
-                        QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem*>(shades.at(i / 2 - 1));
+                        QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem *>(shades.at(i / 2 - 1));
                         rectItem->setRect(chartRect.left(), layout[i], chartRect.width(), layout[i - 1] - layout[i]);
                     }
                     // grid lines and axis line ticks
-                    QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(lines.at(i));
+                    QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem *>(lines.at(i));
                     lineItem->setPos(chartRect.left(), layout[i]);
                     lineItem->setLine(0, 0, chartRect.width(), 0);
-                    QGraphicsLineItem *tickLineItem = static_cast<QGraphicsLineItem*>(axis.at(i + 1));
+                    QGraphicsLineItem *tickLineItem = static_cast<QGraphicsLineItem *>(axis.at(i + 1));
                     tickLineItem->setPos(chartRect.left(), layout[i]);
                     tickLineItem->setLine(-5, 0, 0, 0);
                 ChartAxis::handleAxisUpdated();
             }
-            QSizeF ChartCategoryAxisY::sizeHint(Qt::SizeHint which, const QSizeF& constraint) const
+            QSizeF ChartCategoryAxisY::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
             {
                 Q_UNUSED(constraint)

src/axis/categoryaxis/chartcategoryaxisy_p.h +1 -1

                 ~ChartCategoryAxisY();
                 AxisType axisType() const { return Y_AXIS; }
-                QSizeF sizeHint(Qt::SizeHint which, const QSizeF& constraint) const;
+                QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint) const;
             protected:
                 QVector<qreal> calculateLayout() const;
                 void updateGeometry();

src/axis/categoryaxis/qcategoryaxis.cpp +8 -8

                 It has to be greater than the high end limit of the previous category.
                 Otherwise the method returns without adding a new category.
             */
-            void QCategoryAxis::append(const QString& categoryLabel, qreal categoryEndValue)
+            void QCategoryAxis::append(const QString &categoryLabel, qreal categoryEndValue)
             {
                 Q_D(QCategoryAxis);
             /*!
                 Returns the low end limit of the category specified by an \a categoryLabel
             */
-            qreal QCategoryAxis::startValue(const QString& categoryLabel) const
+            qreal QCategoryAxis::startValue(const QString &categoryLabel) const
             {
                 Q_D(const QCategoryAxis);
                 if (categoryLabel.isEmpty())
             /*!
                 Returns the high end limit of the interval specified by an \a categoryLabel
             */
-            qreal QCategoryAxis::endValue(const QString& categoryLabel) const
+            qreal QCategoryAxis::endValue(const QString &categoryLabel) const
             {
                 Q_D(const QCategoryAxis);
                 return d->m_categoriesMap.value(categoryLabel).second;
               Replaces \a oldLabel of an existing category with a \a newLabel
               If the old label does not exist the method returns without making any changes.
              */
-            void QCategoryAxis::replaceLabel(const QString& oldLabel, const QString& newLabel)
+            void QCategoryAxis::replaceLabel(const QString &oldLabel, const QString &newLabel)
             {
                 Q_D(QCategoryAxis);
                 int labelIndex = d->m_categories.indexOf(oldLabel);
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-            QCategoryAxisPrivate::QCategoryAxisPrivate(QCategoryAxis* q):
+            QCategoryAxisPrivate::QCategoryAxisPrivate(QCategoryAxis *q)
-                QValueAxisPrivate(q),
+                : QValueAxisPrivate(q),
-                m_categoryMinimum(0)
+                  m_categoryMinimum(0)
             {
             }
                 Q_UNUSED(max);
             }
-            ChartAxis* QCategoryAxisPrivate::createGraphics(ChartPresenter* presenter)
+            ChartAxis *QCategoryAxisPrivate::createGraphics(ChartPresenter *presenter)
             {
                 Q_Q(QCategoryAxis);
                 if (m_orientation == Qt::Vertical)

src/axis/categoryaxis/qcategoryaxis.h +5 -5

             public:
                 AxisType type() const;
-                void append(const QString& label, qreal categoryEndValue);
+                void append(const QString &label, qreal categoryEndValue);
-                void remove(const QString& label);
+                void remove(const QString &label);
-                void replaceLabel(const QString& oldLabel, const QString& newLabel);
+                void replaceLabel(const QString &oldLabel, const QString &newLabel);
-                qreal startValue(const QString& categoryLabel = QString()) const;
+                qreal startValue(const QString &categoryLabel = QString()) const;
                 void setStartValue(qreal min);
-                qreal endValue(const QString& categoryLabel) const;
+                qreal endValue(const QString &categoryLabel) const;
                 QStringList categoriesLabels();
                 int count() const;

src/axis/categoryaxis/qcategoryaxis_p.h +1 -1

                 QCategoryAxisPrivate(QCategoryAxis *q);
                 ~QCategoryAxisPrivate();
-                ChartAxis* createGraphics(ChartPresenter* presenter);
+                ChartAxis *createGraphics(ChartPresenter *presenter);
                 int ticksCount() const;
             Q_SIGNALS:

src/axis/chartaxis.cpp +4 -5

             {
             }
-            void ChartAxis::setAnimation(AxisAnimation* animation)
+            void ChartAxis::setAnimation(AxisAnimation *animation)
             {
                 m_animation = animation;
             }
             void ChartAxis::handleDomainUpdated()
             {
-                Domain* domain = qobject_cast<Domain*>(sender());
+                Domain *domain = qobject_cast<Domain *>(sender());
                 qreal min(0);
                 qreal max(0);
                 setTitleText(m_chartAxis->title());
             }
-            void ChartAxis::setTitleText(const QString& title)
+            void ChartAxis::setTitleText(const QString &title)
             {
                 if (m_titleText != title) {
                     m_titleText = title;
                 return m_chartAxis->isVisible();
             }
-            QSizeF ChartAxis::sizeHint(Qt::SizeHint which, const QSizeF& constraint) const
+            QSizeF ChartAxis::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
             {
                 Q_UNUSED(constraint);
                 QFontMetrics fn(m_title->font());
                 QSizeF sh;

src/axis/chartaxis_p.h +7 -7

                 void setTitlePen(const QPen &pen);
                 void setTitleBrush(const QBrush &brush);
                 void setTitleFont(const QFont &font);
-                void setTitleText(const QString& title);
+                void setTitleText(const QString &title);
                 void setLayout(QVector<qreal> &layout);
                 QVector<qreal> layout() const { return m_layoutVector; }
-                void setAnimation(AxisAnimation* animation);
+                void setAnimation(AxisAnimation *animation);
-                ChartAnimation* animation() const { return m_animation; };
+                ChartAnimation *animation() const { return m_animation; };
                 Qt::Orientation orientation() const;
                 bool alternativePlacement() const;
                 void setInternalRect(const QRectF &size);
-                virtual QSizeF sizeHint(Qt::SizeHint which, const QSizeF& constraint = QSizeF()) const;
+                virtual QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint = QSizeF()) const;
             protected:
                 virtual void updateGeometry() = 0;
                 void axisSelected();
             protected:
-                QAbstractAxis* m_chartAxis;
+                QAbstractAxis *m_chartAxis;
                 int m_labelsAngle;
                 //TODO: to be removed
                 QRectF m_rect;
                 QScopedPointer<QGraphicsItemGroup> m_shades;
                 QScopedPointer<QGraphicsItemGroup> m_labels;
                 QScopedPointer<QGraphicsItemGroup> m_arrow;
-                QGraphicsSimpleTextItem* m_title;
+                QGraphicsSimpleTextItem *m_title;
                 QVector<qreal> m_layoutVector;
                 qreal m_min;
                 qreal m_max;
                 }
             private:
-                ChartAxis* m_axis;
+                ChartAxis *m_axis;
             };
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/datetimeaxis/chartdatetimeaxisx.cpp +9 -9

                 QRectF chartRect = presenter()->chartsGeometry();
-                QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(axis.at(0));
+                QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem *>(axis.at(0));
                 lineItem->setLine(chartRect.left(), chartRect.bottom(), chartRect.right(), chartRect.bottom());
                 qreal width = 0;
                 for (int i = 0; i < layout.size(); ++i) {
-                    QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(lines.at(i));
+                    QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem *>(lines.at(i));
                     lineItem->setLine(layout[i], chartRect.top(), layout[i], chartRect.bottom());
-                    QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem*>(labels.at(i));
+                    QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem *>(labels.at(i));
                     labelItem->setText(ticksList.at(i));
-                    const QRectF& rect = labelItem->boundingRect();
+                    const QRectF &rect = labelItem->boundingRect();
                     QPointF center = rect.center();
                     labelItem->setTransformOriginPoint(center.x(), center.y());
                     labelItem->setPos(layout[i] - center.x(), chartRect.bottom() + label_padding);
                     }
                     if ((i + 1) % 2 && i > 1) {
-                        QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem*>(shades.at(i / 2 - 1));
+                        QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem *>(shades.at(i / 2 - 1));
                         rectItem->setRect(layout[i - 1], chartRect.top(), layout[i] - layout[i - 1], chartRect.height());
                     }
-                    lineItem = static_cast<QGraphicsLineItem*>(axis.at(i + 1));
+                    lineItem = static_cast<QGraphicsLineItem *>(axis.at(i + 1));
                     lineItem->setLine(layout[i], chartRect.bottom(), layout[i], chartRect.bottom() + 5);
                 }
             }
             void ChartDateTimeAxisX::handleAxisUpdated()
             {
                 //TODO:: fix this
-                QDateTimeAxis* axis = qobject_cast<QDateTimeAxis*>(m_chartAxis);
+                QDateTimeAxis *axis = qobject_cast<QDateTimeAxis *>(m_chartAxis);
                 m_tickCount = axis->tickCount();
                 ChartAxis::handleAxisUpdated();
             }
-            QSizeF ChartDateTimeAxisX::sizeHint(Qt::SizeHint which, const QSizeF& constraint) const
+            QSizeF ChartDateTimeAxisX::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
             {
                 Q_UNUSED(constraint)
                     }
                     sh = QSizeF(width, height);
                     break;
+                }
                 default:
                     break;
                 }

src/axis/datetimeaxis/chartdatetimeaxisx_p.h +1 -1

                 ~ChartDateTimeAxisX();
                 AxisType axisType() const { return X_AXIS;}
-                QSizeF sizeHint(Qt::SizeHint which, const QSizeF& constraint) const;
+                QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint) const;
             protected:
                 void createLabels(QStringList &labels, qreal min, qreal max, int ticks);
                 void handleAxisUpdated();

src/axis/datetimeaxis/chartdatetimeaxisy.cpp +8 -8

                 qreal height =  chartRect.bottom();
-                QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(axis.at(0));
+                QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem *>(axis.at(0));
                 lineItem->setLine(chartRect.left() , chartRect.top(), chartRect.left(), chartRect.bottom());
                 for (int i = 0; i < layout.size(); ++i) {
-                    QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(lines.at(i));
+                    QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem *>(lines.at(i));
                     lineItem->setLine(chartRect.left() , layout[i], chartRect.right(), layout[i]);
-                    QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem*>(labels.at(i));
+                    QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem *>(labels.at(i));
                     labelItem->setText(ticksList.at(i));
-                    const QRectF& rect = labelItem->boundingRect();
+                    const QRectF &rect = labelItem->boundingRect();
                     QPointF center = rect.center();
                     labelItem->setTransformOriginPoint(center.x(), center.y());
                     }
                     if ((i + 1) % 2 && i > 1) {
-                        QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem*>(shades.at(i / 2 - 1));
+                        QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem *>(shades.at(i / 2 - 1));
                         rectItem->setRect(chartRect.left(), layout[i], chartRect.width(), layout[i - 1] - layout[i]);
                     }
-                    lineItem = static_cast<QGraphicsLineItem*>(axis.at(i + 1));
+                    lineItem = static_cast<QGraphicsLineItem *>(axis.at(i + 1));
                     lineItem->setLine(chartRect.left() - 5, layout[i], chartRect.left(), layout[i]);
                 }
             }
             void ChartDateTimeAxisY::handleAxisUpdated()
             {
                 //TODO:: fix this
-                QDateTimeAxis* axis = qobject_cast<QDateTimeAxis*>(m_chartAxis);
+                QDateTimeAxis *axis = qobject_cast<QDateTimeAxis *>(m_chartAxis);
                 m_tickCount = axis->tickCount();
                 ChartAxis::handleAxisUpdated();
             }
-            QSizeF ChartDateTimeAxisY::sizeHint(Qt::SizeHint which, const QSizeF& constraint) const
+            QSizeF ChartDateTimeAxisY::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
             {
                 Q_UNUSED(constraint)

src/axis/datetimeaxis/chartdatetimeaxisy_p.h +1 -1

                 ~ChartDateTimeAxisY();
                 AxisType axisType() const { return Y_AXIS;}
-                QSizeF sizeHint(Qt::SizeHint which, const QSizeF& constraint) const;
+                QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint) const;
             protected:
                 void createLabels(QStringList &labels, qreal min, qreal max, int ticks);
                 QVector<qreal> calculateLayout() const;

src/axis/datetimeaxis/qdatetimeaxis.cpp +8 -8

             /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-            QDateTimeAxisPrivate::QDateTimeAxisPrivate(QDateTimeAxis* q):
+            QDateTimeAxisPrivate::QDateTimeAxisPrivate(QDateTimeAxis *q)
-                QAbstractAxisPrivate(q),
+                : QAbstractAxisPrivate(q),
-                m_min(QDateTime::fromMSecsSinceEpoch(0)),
+                  m_min(QDateTime::fromMSecsSinceEpoch(0)),
-                m_max(QDateTime::fromMSecsSinceEpoch(0)),
+                  m_max(QDateTime::fromMSecsSinceEpoch(0)),
-                m_tickCount(5)
+                  m_tickCount(5)
             {
                 m_format = "dd-MM-yyyy\nh:mm";
             }
             void QDateTimeAxisPrivate::handleDomainUpdated()
             {
                 Q_Q(QDateTimeAxis);
-                Domain* domain = qobject_cast<Domain*>(sender());
+                Domain *domain = qobject_cast<Domain *>(sender());
                 Q_ASSERT(domain);
                 if (orientation() == Qt::Horizontal)
                     q->setRange(min.toDateTime(), max.toDateTime());
             }
-            ChartAxis* QDateTimeAxisPrivate::createGraphics(ChartPresenter* presenter)
+            ChartAxis *QDateTimeAxisPrivate::createGraphics(ChartPresenter *presenter)
             {
                 Q_Q(QDateTimeAxis);
                 if (m_orientation == Qt::Vertical)
                 return new ChartDateTimeAxisX(q, presenter);
             }
-            void QDateTimeAxisPrivate::intializeDomain(Domain* domain)
+            void QDateTimeAxisPrivate::intializeDomain(Domain *domain)
             {
                 Q_Q(QDateTimeAxis);
                 if (m_max == m_min) {

src/axis/datetimeaxis/qdatetimeaxis_p.h +4 -4

                 ~QDateTimeAxisPrivate();
             public:
-                ChartAxis* createGraphics(ChartPresenter* presenter);
+                ChartAxis *createGraphics(ChartPresenter *presenter);
-                void intializeDomain(Domain* domain);
+                void intializeDomain(Domain *domain);
                 void handleDomainUpdated();
-                qreal min(){ return m_min.toMSecsSinceEpoch(); }
+                qreal min() { return m_min.toMSecsSinceEpoch(); }
-                qreal max(){ return m_max.toMSecsSinceEpoch(); }
+                qreal max() { return m_max.toMSecsSinceEpoch(); }
                 int count() const { /*TODO:*/ return 0;}
             protected:

src/axis/qabstractaxis.cpp +15 -15

                 return d_ptr->m_titleFont;
             }
-            void QAbstractAxis::setTitle(const QString& title)
+            void QAbstractAxis::setTitle(const QString &title)
             {
                 if (d_ptr->m_title != title) {
                     d_ptr->m_title = title;
             /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-            QAbstractAxisPrivate::QAbstractAxisPrivate(QAbstractAxis* q):
+            QAbstractAxisPrivate::QAbstractAxisPrivate(QAbstractAxis *q)
-                q_ptr(q),
+                : q_ptr(q),
-                m_orientation(Qt::Orientation(0)),
+                  m_orientation(Qt::Orientation(0)),
-                m_dataset(0),
+                  m_dataset(0),
-                m_visible(true),
+                  m_visible(true),
-                m_arrowVisible(true),
+                  m_arrowVisible(true),
-                m_gridLineVisible(true),
+                  m_gridLineVisible(true),
-                m_labelsVisible(true),
+                  m_labelsVisible(true),
-                m_labelsAngle(0),
+                  m_labelsAngle(0),
-                m_shadesVisible(false),
+                  m_shadesVisible(false),
-                m_shadesBrush(Qt::SolidPattern),
+                  m_shadesBrush(Qt::SolidPattern),
-                m_shadesOpacity(1.0),
+                  m_shadesOpacity(1.0),
-                m_dirty(false),
+                  m_dirty(false),
-                m_alternativePlacement(false)
+                  m_alternativePlacement(false)
             {
             }

src/axis/qabstractaxis.h +1 -1

                 QBrush titleBrush() const;
                 void setTitleFont(const QFont &font);
                 QFont titleFont() const;
-                void setTitle(const QString& title);
+                void setTitle(const QString &title);
                 QString title() const;

src/axis/qabstractaxis_p.h +3 -4

                 ~QAbstractAxisPrivate();
             public:
+                virtual ChartAxis *createGraphics(ChartPresenter *presenter) = 0;
-                virtual ChartAxis* createGraphics(ChartPresenter* presenter) = 0;
+                virtual void intializeDomain(Domain *domain) = 0;
-                virtual void intializeDomain(Domain* domain) = 0;
                 void emitUpdated();
                 void setDirty(bool dirty);
-                bool isDirty(){ return m_dirty; }
+                bool isDirty() { return m_dirty; }
                 void setOrientation(Qt::Orientation orientation);
                 Qt::Orientation orientation() const { return m_orientation; }

src/axis/valueaxis/chartvalueaxisx.cpp +9 -9

                 QRectF chartRrect = presenter()->chartsGeometry();
-                QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(axis.at(0));
+                QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem *>(axis.at(0));
                 //    lineItem->setLine(chartRrect.left(), chartRrect.bottom(), chartRrect.right(), chartRrect.bottom());
                 if (m_chartAxis->alternativePlacement())
                     lineItem->setLine(chartRrect.left(), m_internalRect.top(), chartRrect.right(), m_internalRect.top());
                 qreal width = 0;
                 for (int i = 0; i < layout.size(); ++i) {
-                    QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(lines.at(i));
+                    QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem *>(lines.at(i));
                     lineItem->setLine(layout[i], chartRrect.top(), layout[i], chartRrect.bottom());
-                    QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem*>(labels.at(i));
+                    QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem *>(labels.at(i));
                     labelItem->setText(ticksList.at(i));
-                    const QRectF& rect = labelItem->boundingRect();
+                    const QRectF &rect = labelItem->boundingRect();
                     QPointF center = rect.center();
                     labelItem->setTransformOriginPoint(center.x(), center.y());
                     //            labelItem->setPos(layout[i] - center.x(), chartRrect.bottom() + label_padding);
                         labelItem->setPos(layout[i] - center.x(), m_internalRect.bottom() + label_padding);
                     if (labelItem->pos().x() <= width ||
                         labelItem->pos().x() < m_rect.left() ||
-                        labelItem->pos().x() + rect.width() > m_rect.right()){
+                        labelItem->pos().x() + rect.width() > m_rect.right()) {
                         labelItem->setVisible(false);
                         lineItem->setVisible(false);
                     } else {
                     }
                     if ((i + 1) % 2 && i > 1) {
-                        QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem*>(shades.at(i / 2 - 1));
+                        QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem *>(shades.at(i / 2 - 1));
                         rectItem->setRect(layout[i - 1], chartRrect.top(), layout[i] - layout[i - 1], chartRrect.height());
                     }
-                    lineItem = static_cast<QGraphicsLineItem*>(axis.at(i + 1));
+                    lineItem = static_cast<QGraphicsLineItem *>(axis.at(i + 1));
                     //        lineItem->setLine(layout[i],chartRrect.bottom(),layout[i],chartRrect.bottom()+5);
                     if (m_chartAxis->alternativePlacement())
                         lineItem->setLine(layout[i], m_internalRect.top(), layout[i], m_internalRect.top() - 5);
             void ChartValueAxisX::handleAxisUpdated()
             {
                 //TODO:: fix this
-                QValueAxis* axis = qobject_cast<QValueAxis*>(m_chartAxis);
+                QValueAxis *axis = qobject_cast<QValueAxis *>(m_chartAxis);
                 if (m_tickCount != axis->tickCount()) {
                     m_tickCount = axis->tickCount();
                     presenter()->layout()->invalidate();
                 ChartAxis::handleAxisUpdated();
             }
-            QSizeF ChartValueAxisX::sizeHint(Qt::SizeHint which, const QSizeF& constraint) const
+            QSizeF ChartValueAxisX::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
             {
                 Q_UNUSED(constraint)

src/axis/valueaxis/chartvalueaxisx_p.h +2 -1

                 ~ChartValueAxisX();
                 AxisType axisType() const { return X_AXIS;}
-                QSizeF sizeHint(Qt::SizeHint which, const QSizeF& constraint) const;
+                QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint) const;
             protected:
                 void handleAxisUpdated();
                 QVector<qreal> calculateLayout() const;

src/axis/valueaxis/chartvalueaxisy.cpp +8 -8

                 qreal height = m_rect.bottom();
-                QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(axis.at(0));
+                QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem *>(axis.at(0));
                 //    lineItem->setLine( chartRect.left() ,  chartRect.top(),  chartRect.left(),  chartRect.bottom());
                 if (m_chartAxis->alternativePlacement())
                     lineItem->setLine(m_internalRect.right(), chartRect.top(), m_internalRect.right(), chartRect.bottom());
                 QFontMetrics fn(m_font);
                 for (int i = 0; i < layout.size(); ++i) {
-                    QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(lines.at(i));
+                    QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem *>(lines.at(i));
                     lineItem->setLine(chartRect.left(), layout[i], chartRect.right(), layout[i]);
-                    QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem*>(labels.at(i));
+                    QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem *>(labels.at(i));
                     QString text = ticksList.at(i);
                         labelItem->setText(text);
                     }
-                    const QRectF& rect = labelItem->boundingRect();
+                    const QRectF &rect = labelItem->boundingRect();
                     QPointF center = rect.center();
                     labelItem->setTransformOriginPoint(center.x(), center.y());
                     }
                     if ((i + 1) % 2 && i > 1) {
-                        QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem*>(shades.at(i / 2 - 1));
+                        QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem *>(shades.at(i / 2 - 1));
                         rectItem->setRect(chartRect.left(), layout[i], chartRect.width(), layout[i - 1] - layout[i]);
                     }
-                    lineItem = static_cast<QGraphicsLineItem*>(axis.at(i + 1));
+                    lineItem = static_cast<QGraphicsLineItem *>(axis.at(i + 1));
                     //        lineItem->setLine( chartRect.left()-5,layout[i], chartRect.left(),layout[i]);
                     if (m_chartAxis->alternativePlacement())
                         lineItem->setLine(m_internalRect.right() + 5, layout[i], m_internalRect.right(), layout[i]);
             void ChartValueAxisY::handleAxisUpdated()
             {
                 //TODO:: fix this
-                QValueAxis* axis = qobject_cast<QValueAxis*>(m_chartAxis);
+                QValueAxis *axis = qobject_cast<QValueAxis *>(m_chartAxis);
                 if (m_tickCount != axis->tickCount()) {
                     m_tickCount = axis->tickCount();
                     presenter()->layout()->invalidate();
                 ChartAxis::handleAxisUpdated();
             }
-            QSizeF ChartValueAxisY::sizeHint(Qt::SizeHint which, const QSizeF& constraint) const
+            QSizeF ChartValueAxisY::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
             {
                 Q_UNUSED(constraint)

src/axis/valueaxis/chartvalueaxisy_p.h +1 -1

                 ~ChartValueAxisY();
                 AxisType axisType() const { return Y_AXIS;}
-                QSizeF sizeHint(Qt::SizeHint which, const QSizeF& constraint) const;
+                QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint) const;
             protected:
                 QVector<qreal> calculateLayout() const;
                 void updateGeometry();

src/axis/valueaxis/qvalueaxis.cpp +10 -10

             /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-            QValueAxisPrivate::QValueAxisPrivate(QValueAxis* q):
+            QValueAxisPrivate::QValueAxisPrivate(QValueAxis *q)
-                QAbstractAxisPrivate(q),
+                : QAbstractAxisPrivate(q),
-                m_min(0),
+                  m_min(0),
-                m_max(0),
+                  m_max(0),
-                m_tickCount(5),
+                  m_tickCount(5),
-                m_niceNumbers(false),
+                  m_niceNumbers(false),
-                m_format(QString::null)
+                  m_format(QString::null)
             {
             }
             void QValueAxisPrivate::handleDomainUpdated()
             {
                 Q_Q(QValueAxis);
-                Domain* domain = qobject_cast<Domain*>(sender());
+                Domain *domain = qobject_cast<Domain *>(sender());
                 Q_ASSERT(domain);
                 if (orientation() == Qt::Horizontal)
                     q->setRange(value1, value2);
             }
-            ChartAxis* QValueAxisPrivate::createGraphics(ChartPresenter* presenter)
+            ChartAxis *QValueAxisPrivate::createGraphics(ChartPresenter *presenter)
             {
                 Q_Q(QValueAxis);
                 if (m_orientation == Qt::Vertical)
                 return new ChartValueAxisX(q, presenter);
             }
-            void QValueAxisPrivate::intializeDomain(Domain* domain)
+            void QValueAxisPrivate::intializeDomain(Domain *domain)
             {
                 Q_Q(QValueAxis);
                 if (qFuzzyCompare(m_max, m_min)) {

src/axis/valueaxis/qvalueaxis_p.h +4 -4

                 ~QValueAxisPrivate();
             public:
-                ChartAxis* createGraphics(ChartPresenter* presenter);
+                ChartAxis *createGraphics(ChartPresenter *presenter);
-                void intializeDomain(Domain* domain);
+                void intializeDomain(Domain *domain);
                 void handleDomainUpdated();
-                qreal min(){ return m_min; };
+                qreal min() { return m_min; };
-                qreal max(){ return m_max; };
+                qreal max() { return m_max; };
                 int count() const { return m_tickCount; }
             protected:

src/barchart/abstractbarchartitem.cpp +3 -3

                 for (int category = 0; category < categoryCount; category++) {
                     for (int set = 0; set < setCount; set++) {
-                        QBarSetPrivate* barSet = m_series->d_func()->barsetAt(set)->d_ptr.data();
+                        QBarSetPrivate *barSet = m_series->d_func()->barsetAt(set)->d_ptr.data();
-                        Bar* bar = m_bars.at(itemIndex);
+                        Bar *bar = m_bars.at(itemIndex);
                         bar->setPen(barSet->m_pen);
                         bar->setBrush(barSet->m_brush);
                         bar->update();
-                        QGraphicsSimpleTextItem* label = m_labels.at(itemIndex);
+                        QGraphicsSimpleTextItem *label = m_labels.at(itemIndex);
                         label->setFont(barSet->m_labelFont);
                         label->setBrush(barSet->m_labelBrush);
                         label->update();

src/barchart/abstractbarchartitem_p.h +1 -1

                 virtual QVector<QRectF> calculateLayout() = 0;
                 virtual void applyLayout(const QVector<QRectF> &layout);
-                virtual void setAnimation(AbstractBarAnimation* animation);
+                virtual void setAnimation(AbstractBarAnimation *animation);
                 void setLayout(const QVector<QRectF> &layout);
                 void updateLayout(const QVector<QRectF> &layout);
                 QRectF geometry() const { return m_rect;}

src/barchart/horizontal/bar/horizontalbarchartitem.cpp +3 -3

                 for (int category = 0; category < categoryCount; category++) {
                     qreal xPos = -scaleX * m_domainMinX + geometry().left();
                     for (int set = 0; set < setCount; set++) {
-                        QBarSetPrivate* barSet = m_series->d_func()->barsetAt(set)->d_ptr.data();
+                        QBarSetPrivate *barSet = m_series->d_func()->barsetAt(set)->d_ptr.data();
                         qreal yPos = geometry().bottom() + (m_domainMinY - barSet->pos(category)) * scaleY;
                         yPos += setCount * rectHeight / 2;
                         yPos -= set * rectHeight;
                         qreal rectWidth = barSet->value(category) * scaleX;
-                        Bar* bar = m_bars.at(itemIndex);
+                        Bar *bar = m_bars.at(itemIndex);
                         QRectF rect(xPos, yPos - rectHeight, rectWidth, rectHeight);
                         layout.append(rect);
                         else
                             bar->setVisible(barsVisible);
-                        QGraphicsSimpleTextItem* label = m_labels.at(itemIndex);
+                        QGraphicsSimpleTextItem *label = m_labels.at(itemIndex);
                         if (!qFuzzyIsNull(barSet->value(category)))
                             label->setText(QString::number(barSet->value(category)));

src/barchart/horizontal/bar/qhorizontalbarseries.cpp +7 -6

                 Constructs empty QHorizontalBarSeries.
                 QHorizontalBarSeries is QObject which is a child of a \a parent.
             */
-            QHorizontalBarSeries::QHorizontalBarSeries(QObject *parent) :
+            QHorizontalBarSeries::QHorizontalBarSeries(QObject *parent)
-                QAbstractBarSeries(*new QHorizontalBarSeriesPrivate(this), parent)
+                : QAbstractBarSeries(*new QHorizontalBarSeriesPrivate(this), parent)
             {
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-            QHorizontalBarSeriesPrivate::QHorizontalBarSeriesPrivate(QHorizontalBarSeries *q) : QAbstractBarSeriesPrivate(q)
+            QHorizontalBarSeriesPrivate::QHorizontalBarSeriesPrivate(QHorizontalBarSeries *q)
+                : QAbstractBarSeriesPrivate(q)
             {
             }
-            void QHorizontalBarSeriesPrivate::scaleDomain(Domain& domain)
+            void QHorizontalBarSeriesPrivate::scaleDomain(Domain &domain)
             {
                 qreal minX(domain.minX());
                 qreal minY(domain.minY());
                 domain.setRange(minX, maxX, minY, maxY);
             }
-            ChartElement* QHorizontalBarSeriesPrivate::createGraphics(ChartPresenter* presenter)
+            ChartElement *QHorizontalBarSeriesPrivate::createGraphics(ChartPresenter *presenter)
             {
                 Q_Q(QHorizontalBarSeries);
-                HorizontalBarChartItem* bar = new HorizontalBarChartItem(q, presenter);
+                HorizontalBarChartItem *bar = new HorizontalBarChartItem(q, presenter);
                 if (presenter->animationOptions().testFlag(QChart::SeriesAnimations))
                     bar->setAnimation(new HorizontalBarAnimation(bar));
                 presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));

src/barchart/horizontal/bar/qhorizontalbarseries_p.h +3 -3

             class QHorizontalBarSeriesPrivate: public QAbstractBarSeriesPrivate
             {
             public:
-                QHorizontalBarSeriesPrivate(QHorizontalBarSeries* q);
+                QHorizontalBarSeriesPrivate(QHorizontalBarSeries *q);
-                ChartElement* createGraphics(ChartPresenter* presenter);
+                ChartElement *createGraphics(ChartPresenter *presenter);
-                void scaleDomain(Domain& domain);
+                void scaleDomain(Domain &domain);
             private:
                 Q_DECLARE_PUBLIC(QHorizontalBarSeries)
             };

src/barchart/horizontal/percent/horizontalpercentbarchartitem.cpp +5 -5

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            HorizontalPercentBarChartItem::HorizontalPercentBarChartItem(QAbstractBarSeries *series, ChartPresenter *presenter) :
+            HorizontalPercentBarChartItem::HorizontalPercentBarChartItem(QAbstractBarSeries *series, ChartPresenter *presenter)
-                AbstractBarChartItem(series, presenter)
+                : AbstractBarChartItem(series, presenter)
             {
             }
                     qreal percentage = (100 / colSum);
                     qreal xPos = -scaleX * m_domainMinX + geometry().left();
                     for (int set = 0; set < setCount; set++) {
-                        QBarSetPrivate* barSet = m_series->d_func()->barsetAt(set)->d_ptr.data();
+                        QBarSetPrivate *barSet = m_series->d_func()->barsetAt(set)->d_ptr.data();
                         qreal yPos = (m_domainMinY + 0.5 - barSet->pos(category)) * scaleY + geometry().bottom() - rectHeight / 2;
                         qreal rectWidth = barSet->value(category) * percentage * scaleX;
-                        Bar* bar = m_bars.at(itemIndex);
+                        Bar *bar = m_bars.at(itemIndex);
                         QRectF rect(xPos, yPos - rectHeight, rectWidth, rectHeight);
                         layout.append(rect);
                         else
                             bar->setVisible(barsVisible);
-                        QGraphicsSimpleTextItem* label = m_labels.at(itemIndex);
+                        QGraphicsSimpleTextItem *label = m_labels.at(itemIndex);
                         if (!qFuzzyIsNull(m_series->d_func()->valueAt(set, category))) {
                             int p = m_series->d_func()->percentageAt(set, category) * 100;

src/barchart/horizontal/percent/qhorizontalpercentbarseries.cpp +3 -3

             }
-            void QHorizontalPercentBarSeriesPrivate::scaleDomain(Domain& domain)
+            void QHorizontalPercentBarSeriesPrivate::scaleDomain(Domain &domain)
             {
                 qreal minX(domain.minX());
                 qreal minY(domain.minY());
                 domain.setRange(minX, maxX, minY, maxY);
             }
-            ChartElement* QHorizontalPercentBarSeriesPrivate::createGraphics(ChartPresenter* presenter)
+            ChartElement *QHorizontalPercentBarSeriesPrivate::createGraphics(ChartPresenter *presenter)
             {
                 Q_Q(QHorizontalPercentBarSeries);
-                HorizontalPercentBarChartItem* bar = new HorizontalPercentBarChartItem(q, presenter);
+                HorizontalPercentBarChartItem *bar = new HorizontalPercentBarChartItem(q, presenter);
                 if (presenter->animationOptions().testFlag(QChart::SeriesAnimations))
                     bar->setAnimation(new HorizontalPercentBarAnimation(bar));
                 presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));

src/barchart/horizontal/percent/qhorizontalpercentbarseries_p.h +3 -3

             class QHorizontalPercentBarSeriesPrivate: public QAbstractBarSeriesPrivate
             {
             public:
-                QHorizontalPercentBarSeriesPrivate(QHorizontalPercentBarSeries* q);
+                QHorizontalPercentBarSeriesPrivate(QHorizontalPercentBarSeries *q);
-                ChartElement* createGraphics(ChartPresenter* presenter);
+                ChartElement *createGraphics(ChartPresenter *presenter);
-                void scaleDomain(Domain& domain);
+                void scaleDomain(Domain &domain);
             private:
                 Q_DECLARE_PUBLIC(QHorizontalPercentBarSeries)
             };

src/barchart/horizontal/stacked/horizontalstackedbarchartitem.cpp +5 -5

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            HorizontalStackedBarChartItem::HorizontalStackedBarChartItem(QAbstractBarSeries *series, ChartPresenter *presenter) :
+            HorizontalStackedBarChartItem::HorizontalStackedBarChartItem(QAbstractBarSeries *series, ChartPresenter *presenter)
-                AbstractBarChartItem(series, presenter)
+                : AbstractBarChartItem(series, presenter)
             {
             }
                     qreal xMax = -scaleX * m_domainMinX + geometry().left();
                     qreal xMin = -scaleX * m_domainMinX + geometry().left();
                     for (int set = 0; set < setCount; set++) {
-                        QBarSetPrivate* barSet = m_series->d_func()->barsetAt(set)->d_ptr.data();
+                        QBarSetPrivate *barSet = m_series->d_func()->barsetAt(set)->d_ptr.data();
                         qreal yPos = (m_domainMinY + 0.5 - barSet->pos(category)) * scaleY + geometry().bottom() - rectHeight / 2;
                         qreal rectWidth = barSet->value(category) * scaleX;
-                        Bar* bar = m_bars.at(itemIndex);
+                        Bar *bar = m_bars.at(itemIndex);
                         bar->setPen(barSet->m_pen);
                         bar->setBrush(barSet->m_brush);
                         else
                             bar->setVisible(barsVisible);
-                        QGraphicsSimpleTextItem* label = m_labels.at(itemIndex);
+                        QGraphicsSimpleTextItem *label = m_labels.at(itemIndex);
                         if (!qFuzzyIsNull(barSet->value(category)))
                             label->setText(QString::number(barSet->value(category)));

src/barchart/horizontal/stacked/qhorizontalstackedbarseries.cpp +5 -5

                 Constructs empty QHorizontalStackedBarSeries.
                 QHorizontalStackedBarSeries is QObject which is a child of a \a parent.
             */
-            QHorizontalStackedBarSeries::QHorizontalStackedBarSeries(QObject *parent) :
+            QHorizontalStackedBarSeries::QHorizontalStackedBarSeries(QObject *parent)
-                QAbstractBarSeries(*new QHorizontalStackedBarSeriesPrivate(this), parent)
+                : QAbstractBarSeries(*new QHorizontalStackedBarSeriesPrivate(this), parent)
             {
             }
             }
-            void QHorizontalStackedBarSeriesPrivate::scaleDomain(Domain& domain)
+            void QHorizontalStackedBarSeriesPrivate::scaleDomain(Domain &domain)
             {
                 qreal minX(domain.minX());
                 qreal minY(domain.minY());
                 domain.setRange(minX, maxX, minY, maxY);
             }
-            ChartElement* QHorizontalStackedBarSeriesPrivate::createGraphics(ChartPresenter* presenter)
+            ChartElement *QHorizontalStackedBarSeriesPrivate::createGraphics(ChartPresenter *presenter)
             {
                 Q_Q(QHorizontalStackedBarSeries);
-                HorizontalStackedBarChartItem* bar = new HorizontalStackedBarChartItem(q, presenter);
+                HorizontalStackedBarChartItem *bar = new HorizontalStackedBarChartItem(q, presenter);
                 if (presenter->animationOptions().testFlag(QChart::SeriesAnimations))
                     bar->setAnimation(new HorizontalStackedBarAnimation(bar));
                 presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));

src/barchart/horizontal/stacked/qhorizontalstackedbarseries_p.h +3 -3

             class QHorizontalStackedBarSeriesPrivate: public QAbstractBarSeriesPrivate
             {
             public:
-                QHorizontalStackedBarSeriesPrivate(QHorizontalStackedBarSeries* q);
+                QHorizontalStackedBarSeriesPrivate(QHorizontalStackedBarSeries *q);
-                ChartElement* createGraphics(ChartPresenter* presenter);
+                ChartElement *createGraphics(ChartPresenter *presenter);
-                void scaleDomain(Domain& domain);
+                void scaleDomain(Domain &domain);
             private:
                 Q_DECLARE_PUBLIC(QHorizontalStackedBarSeries)
             };

src/barchart/qabstractbarseries.cpp +17 -17

                 Q_D(QAbstractBarSeries);
                 bool success = d->append(set);
                 if (success) {
-                    QList<QBarSet*> sets;
+                    QList<QBarSet *> sets;
                     sets.append(set);
                     set->setParent(this);
                     emit barsetsAdded(sets);
                 Q_D(QAbstractBarSeries);
                 bool success = d->remove(set);
                 if (success) {
-                    QList<QBarSet*> sets;
+                    QList<QBarSet *> sets;
                     sets.append(set);
                     set->setParent(0);
                     emit barsetsRemoved(sets);
                 Q_D(QAbstractBarSeries);
                 bool success = d->remove(set);
                 if (success) {
-                    QList<QBarSet*> sets;
+                    QList<QBarSet *> sets;
                     sets.append(set);
                     emit barsetsRemoved(sets);
                     emit countChanged();
                 nothing is appended and function returns false. If any of the sets is in list more than once, nothing is appended
                 and function returns false.
             */
-            bool QAbstractBarSeries::append(QList<QBarSet* > sets)
+            bool QAbstractBarSeries::append(QList<QBarSet *> sets)
             {
                 Q_D(QAbstractBarSeries);
                 bool success = d->append(sets);
                 Q_D(QAbstractBarSeries);
                 bool success = d->insert(index, set);
                 if (success) {
-                    QList<QBarSet*> sets;
+                    QList<QBarSet *> sets;
                     sets.append(set);
                     emit barsetsAdded(sets);
                     emit countChanged();
             /*!
                 Returns a list of sets in series. Keeps ownership of sets.
              */
-            QList<QBarSet*> QAbstractBarSeries::barSets() const
+            QList<QBarSet *> QAbstractBarSeries::barSets() const
             {
                 Q_D(const QAbstractBarSeries);
                 return d->m_barSets;
                 return m_barWidth;
             }
-            QBarSet* QAbstractBarSeriesPrivate::barsetAt(int index)
+            QBarSet *QAbstractBarSeriesPrivate::barsetAt(int index)
             {
                 return m_barSets.at(index);
             }
             }
-            void QAbstractBarSeriesPrivate::scaleDomain(Domain& domain)
+            void QAbstractBarSeriesPrivate::scaleDomain(Domain &domain)
             {
                 qreal minX(domain.minX());
                 qreal minY(domain.minY());
                 domain.setRange(minX, maxX, minY, maxY);
             }
-            ChartElement* QAbstractBarSeriesPrivate::createGraphics(ChartPresenter* presenter)
+            ChartElement *QAbstractBarSeriesPrivate::createGraphics(ChartPresenter *presenter)
             {
                 Q_UNUSED(presenter);
                 qWarning() << "QAbstractBarSeriesPrivate::createGraphics called";
                 return 0;
             }
-            QList<LegendMarker*> QAbstractBarSeriesPrivate::createLegendMarker(QLegend* legend)
+            QList<LegendMarker *> QAbstractBarSeriesPrivate::createLegendMarker(QLegend *legend)
             {
                 Q_Q(QAbstractBarSeries);
-                QList<LegendMarker*> markers;
+                QList<LegendMarker *> markers;
                 foreach (QBarSet *set, q->barSets()) {
                     BarLegendMarker* marker = new BarLegendMarker(q, set, legend);
                     markers << marker;
                 return true;
             }
-            bool QAbstractBarSeriesPrivate::append(QList<QBarSet* > sets)
+            bool QAbstractBarSeriesPrivate::append(QList<QBarSet * > sets)
             {
                 foreach (QBarSet *set, sets) {
                     if ((set == 0) || (m_barSets.contains(set)))
                 return true;
             }
-            bool QAbstractBarSeriesPrivate::remove(QList<QBarSet* > sets)
+            bool QAbstractBarSeriesPrivate::remove(QList<QBarSet * > sets)
             {
                 if (sets.count() == 0)
                     return false;
                 return true;
             }
-            void QAbstractBarSeriesPrivate::initializeAxis(QAbstractAxis* axis)
+            void QAbstractBarSeriesPrivate::initializeAxis(QAbstractAxis *axis)
             {
                 Q_Q(QAbstractBarSeries);
                     case QAbstractSeries::SeriesTypeHorizontalPercentBar:
                     case QAbstractSeries::SeriesTypeHorizontalStackedBar:
                         if (axis->orientation() == Qt::Vertical)
-                            populateCategories(qobject_cast<QBarCategoryAxis*>(axis));
+                            populateCategories(qobject_cast<QBarCategoryAxis *>(axis));
                         break;
                     case QAbstractSeries::SeriesTypeBar:
                     case QAbstractSeries::SeriesTypePercentBar:
                     case QAbstractSeries::SeriesTypeStackedBar:
                         if (axis->orientation() == Qt::Horizontal)
-                            populateCategories(qobject_cast<QBarCategoryAxis*>(axis));
+                            populateCategories(qobject_cast<QBarCategoryAxis *>(axis));
                         break;
                     default:
                         qWarning() << "Unexpected series type";
             }
-            void QAbstractBarSeriesPrivate::populateCategories(QBarCategoryAxis* axis)
+            void QAbstractBarSeriesPrivate::populateCategories(QBarCategoryAxis *axis)
             {
                 QStringList categories;
                 if (axis->categories().isEmpty()) {

src/barchart/qabstractbarseries.h +4 -4

                 bool append(QBarSet *set);
                 bool remove(QBarSet *set);
                 bool take(QBarSet *set);
-                bool append(QList<QBarSet* > sets);
+                bool append(QList<QBarSet *> sets);
                 bool insert(int index, QBarSet *set);
                 int count() const;
-                QList<QBarSet*> barSets() const;
+                QList<QBarSet *> barSets() const;
                 void clear();
                 void setLabelsVisible(bool visible = true);
                 void countChanged();
                 void labelsVisibleChanged();
-                void barsetsAdded(QList<QBarSet*> sets);
+                void barsetsAdded(QList<QBarSet *> sets);
-                void barsetsRemoved(QList<QBarSet*> sets);
+                void barsetsRemoved(QList<QBarSet *> sets);
             protected:
                 Q_DECLARE_PRIVATE(QAbstractBarSeries)

src/barchart/qabstractbarseries_p.h +8 -8

                 void setVisible(bool visible);
                 void setLabelsVisible(bool visible);
-                void scaleDomain(Domain& domain);
+                void scaleDomain(Domain &domain);
-                ChartElement* createGraphics(ChartPresenter* presenter);
+                ChartElement *createGraphics(ChartPresenter *presenter);
-                QList<LegendMarker*> createLegendMarker(QLegend* legend);
+                QList<LegendMarker *> createLegendMarker(QLegend *legend);
-                void initializeAxis(QAbstractAxis* axis);
+                void initializeAxis(QAbstractAxis *axis);
                 virtual QAbstractAxis::AxisType defaultAxisType(Qt::Orientation orientation) const;
                 bool append(QBarSet *set);
                 bool remove(QBarSet *set);
-                bool append(QList<QBarSet* > sets);
+                bool append(QList<QBarSet *> sets);
-                bool remove(QList<QBarSet* > sets);
+                bool remove(QList<QBarSet *> sets);
                 bool insert(int index, QBarSet *set);
-                QBarSet* barsetAt(int index);
+                QBarSet *barsetAt(int index);
                 qreal min();
                 qreal max();
                 qreal valueAt(int set, int category);
                 void visibleChanged();
             private:
-                void populateCategories(QBarCategoryAxis* axis);
+                void populateCategories(QBarCategoryAxis *axis);
             protected:
                 QList<QBarSet *> m_barSets;

src/barchart/qbarmodelmapper.cpp +7 -7

             {
             }
-            QAbstractItemModel* QBarModelMapper::model() const
+            QAbstractItemModel *QBarModelMapper::model() const
             {
                 Q_D(const QBarModelMapper);
                 return d->m_model;
                 connect(d->m_model, SIGNAL(destroyed()), d, SLOT(handleModelDestroyed()));
             }
-            QAbstractBarSeries* QBarModelMapper::series() const
+            QAbstractBarSeries *QBarModelMapper::series() const
             {
                 Q_D(const QBarModelMapper);
                 return d->m_series;
                 m_seriesSignalsBlock = block;
             }
-            QBarSet* QBarModelMapperPrivate::barSet(QModelIndex index)
+            QBarSet *QBarModelMapperPrivate::barSet(QModelIndex index)
             {
                 if (!index.isValid())
                     return 0;
                 for (int row = topLeft.row(); row <= bottomRight.row(); row++) {
                     for (int column = topLeft.column(); column <= bottomRight.column(); column++) {
                         index = topLeft.sibling(row, column);
-                        QBarSet* bar = barSet(index);
+                        QBarSet *bar = barSet(index);
                         if (bar) {
                             if (m_orientation == Qt::Vertical)
                                 bar->replace(row - m_first, m_model->data(index).toReal());
                 if (orientation != m_orientation) {
                     for (int section = first; section <= last; section++) {
                         if (section >= m_firstBarSetSection && section <= m_lastBarSetSection) {
-                            QBarSet* bar = m_series->barSets().at(section - m_firstBarSetSection);
+                            QBarSet *bar = m_series->barSets().at(section - m_firstBarSetSection);
                             if (bar)
                                 bar->setLabel(m_model->headerData(section, orientation).toString());
                         }
                 // To be implemented
             }
-            void QBarModelMapperPrivate::barSetsAdded(QList<QBarSet*> sets)
+            void QBarModelMapperPrivate::barSetsAdded(QList<QBarSet *> sets)
             {
                 if (m_seriesSignalsBlock)
                     return;
                 initializeBarFromModel();
             }
-            void QBarModelMapperPrivate::barSetsRemoved(QList<QBarSet*> sets)
+            void QBarModelMapperPrivate::barSetsRemoved(QList<QBarSet *> sets)
             {
                 if (m_seriesSignalsBlock)
                     return;

src/barchart/qbarmodelmapper.h +2 -2

             protected:
                 explicit QBarModelMapper(QObject *parent = 0);
-                QAbstractItemModel* model() const;
+                QAbstractItemModel *model() const;
                 void setModel(QAbstractItemModel *model);
-                QAbstractBarSeries* series() const;
+                QAbstractBarSeries *series() const;
                 void setSeries(QAbstractBarSeries *series);
                 int first() const;

src/barchart/qbarmodelmapper_p.h +4 -4

                 void handleModelDestroyed();
                 // for the series
-                void barSetsAdded(QList<QBarSet*> sets);
+                void barSetsAdded(QList<QBarSet *> sets);
-                void barSetsRemoved(QList<QBarSet*> sets);
+                void barSetsRemoved(QList<QBarSet *> sets);
                 void valuesAdded(int index, int count);
                 void valuesRemoved(int index, int count);
                 void barLabelChanged();
                 void initializeBarFromModel();
             private:
-                QBarSet* barSet(QModelIndex index);
+                QBarSet *barSet(QModelIndex index);
                 QModelIndex barModelIndex(int barSection, int posInBar);
                 void insertData(int start, int end);
                 void removeData(int start, int end);
             private:
                 QAbstractBarSeries *m_series;
-                QList<QBarSet*> m_barSets;
+                QList<QBarSet *> m_barSets;
                 QAbstractItemModel *m_model;
                 int m_first;
                 int m_count;

src/barchart/qbarset.cpp +1 -1

                 Convenience operator. Same as append, with real \a value.
                 \sa append()
             */
-            QBarSet& QBarSet::operator << (const qreal &value)
+            QBarSet &QBarSet::operator << (const qreal &value)
             {
                 append(value);
                 return *this;

src/barchart/qbarset.h +1 -1

                 void append(const qreal value);
                 void append(const QList<qreal> &values);
-                QBarSet& operator << (const qreal &value);
+                QBarSet &operator << (const qreal &value);
                 void insert(const int index, const qreal value);
                 void remove(const int index, const int count = 1);

src/barchart/qhbarmodelmapper.cpp +2 -2

                 QBarModelMapper::setOrientation(Qt::Horizontal);
             }
-            QAbstractItemModel* QHBarModelMapper::model() const
+            QAbstractItemModel *QHBarModelMapper::model() const
             {
                 return QBarModelMapper::model();
             }
                 }
             }
-            QAbstractBarSeries* QHBarModelMapper::series() const
+            QAbstractBarSeries *QHBarModelMapper::series() const
             {
                 return QBarModelMapper::series();
             }

src/barchart/qhbarmodelmapper.h +2 -2

             public:
                 explicit QHBarModelMapper(QObject *parent = 0);
-                QAbstractItemModel* model() const;
+                QAbstractItemModel *model() const;
                 void setModel(QAbstractItemModel *model);
-                QAbstractBarSeries* series() const;
+                QAbstractBarSeries *series() const;
                 void setSeries(QAbstractBarSeries *series);
                 int firstBarSetRow() const;

src/barchart/qvbarmodelmapper.cpp +2 -2

                 QBarModelMapper::setOrientation(Qt::Vertical);
             }
-            QAbstractItemModel* QVBarModelMapper::model() const
+            QAbstractItemModel *QVBarModelMapper::model() const
             {
                 return QBarModelMapper::model();
             }
                 }
             }
-            QAbstractBarSeries* QVBarModelMapper::series() const
+            QAbstractBarSeries *QVBarModelMapper::series() const
             {
                 return QBarModelMapper::series();
             }

src/barchart/qvbarmodelmapper.h +2 -2

             public:
                 explicit QVBarModelMapper(QObject *parent = 0);
-                QAbstractItemModel* model() const;
+                QAbstractItemModel *model() const;
                 void setModel(QAbstractItemModel *model);
-                QAbstractBarSeries* series() const;
+                QAbstractBarSeries *series() const;
                 void setSeries(QAbstractBarSeries *series);
                 int firstBarSetColumn() const;

src/barchart/vertical/bar/barchartitem.cpp +3 -3

                 for (int category = 0; category < categoryCount; category++) {
                     qreal yPos = height + scaleY * m_domainMinY + geometry().top();
                     for (int set = 0; set < setCount; set++) {
-                        QBarSetPrivate* barSet = m_series->d_func()->barsetAt(set)->d_ptr.data();
+                        QBarSetPrivate *barSet = m_series->d_func()->barsetAt(set)->d_ptr.data();
                         qreal xPos = (barSet->pos(category) - m_domainMinX) * scaleX + geometry().left();
                         xPos -= setCount * rectWidth / 2;
                         xPos += set * rectWidth;
                         qreal rectHeight = barSet->value(category) * scaleY;
-                        Bar* bar = m_bars.at(itemIndex);
+                        Bar *bar = m_bars.at(itemIndex);
                         QRectF rect(xPos, yPos - rectHeight, rectWidth, rectHeight);
                         layout.append(rect);
                         else
                             bar->setVisible(barsVisible);
-                        QGraphicsSimpleTextItem* label = m_labels.at(itemIndex);
+                        QGraphicsSimpleTextItem *label = m_labels.at(itemIndex);
                         if (!qFuzzyIsNull(barSet->value(category)))
                             label->setText(QString::number(barSet->value(category)));

src/barchart/vertical/bar/qbarseries.cpp +3 -3

             }
-            void QBarSeriesPrivate::scaleDomain(Domain& domain)
+            void QBarSeriesPrivate::scaleDomain(Domain &domain)
             {
                 qreal minX(domain.minX());
                 qreal minY(domain.minY());
             }
-            ChartElement* QBarSeriesPrivate::createGraphics(ChartPresenter* presenter)
+            ChartElement *QBarSeriesPrivate::createGraphics(ChartPresenter *presenter)
             {
                 Q_Q(QBarSeries);
-                BarChartItem* bar = new BarChartItem(q, presenter);
+                BarChartItem *bar = new BarChartItem(q, presenter);
                 if (presenter->animationOptions().testFlag(QChart::SeriesAnimations))
                     bar->setAnimation(new BarAnimation(bar));
                 presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));

src/barchart/vertical/bar/qbarseries_p.h +3 -3

             class QBarSeriesPrivate: public QAbstractBarSeriesPrivate
             {
             public:
-                QBarSeriesPrivate(QBarSeries* q);
+                QBarSeriesPrivate(QBarSeries *q);
-                ChartElement* createGraphics(ChartPresenter* presenter);
+                ChartElement *createGraphics(ChartPresenter *presenter);
-                void scaleDomain(Domain& domain);
+                void scaleDomain(Domain &domain);
             private:
                 Q_DECLARE_PUBLIC(QBarSeries)
             };

src/barchart/vertical/percent/percentbarchartitem.cpp +3 -3

                     qreal percentage = (100 / colSum);
                     qreal yPos = height + scaleY * m_domainMinY + geometry().top();
                     for (int set = 0; set < setCount; set++) {
-                        QBarSetPrivate* barSet = m_series->d_func()->barsetAt(set)->d_ptr.data();
+                        QBarSetPrivate *barSet = m_series->d_func()->barsetAt(set)->d_ptr.data();
                         qreal xPos = (barSet->pos(category) - m_domainMinX) * scaleX + geometry().left() - rectWidth / 2;
                         qreal rectHeight = barSet->value(category) * percentage * scaleY;
-                        Bar* bar = m_bars.at(itemIndex);
+                        Bar *bar = m_bars.at(itemIndex);
                         bar->setPen(barSet->m_pen);
                         bar->setBrush(barSet->m_brush);
                         if (qFuzzyIsNull(rectHeight))
                         QRectF rect(xPos, yPos - rectHeight, rectWidth, rectHeight);
                         layout.append(rect);
-                        QGraphicsSimpleTextItem* label = m_labels.at(itemIndex);
+                        QGraphicsSimpleTextItem *label = m_labels.at(itemIndex);
                         if (!qFuzzyIsNull(m_series->d_func()->valueAt(set, category))) {
                             int p = m_series->d_func()->percentageAt(set, category) * 100;

src/barchart/vertical/percent/qpercentbarseries.cpp +3 -3

             }
-            void QPercentBarSeriesPrivate::scaleDomain(Domain& domain)
+            void QPercentBarSeriesPrivate::scaleDomain(Domain &domain)
             {
                 qreal minX(domain.minX());
                 qreal minY(domain.minY());
             }
-            ChartElement* QPercentBarSeriesPrivate::createGraphics(ChartPresenter* presenter)
+            ChartElement *QPercentBarSeriesPrivate::createGraphics(ChartPresenter *presenter)
             {
                 Q_Q(QPercentBarSeries);
-                PercentBarChartItem* bar = new PercentBarChartItem(q, presenter);
+                PercentBarChartItem *bar = new PercentBarChartItem(q, presenter);
                 if (presenter->animationOptions().testFlag(QChart::SeriesAnimations))
                     bar->setAnimation(new PercentBarAnimation(bar));
                 presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));

src/barchart/vertical/percent/qpercentbarseries_p.h +3 -3

             class QPercentBarSeriesPrivate: public QAbstractBarSeriesPrivate
             {
             public:
-                QPercentBarSeriesPrivate(QPercentBarSeries* q);
+                QPercentBarSeriesPrivate(QPercentBarSeries *q);
-                void scaleDomain(Domain& domain);
+                void scaleDomain(Domain &domain);
-                ChartElement* createGraphics(ChartPresenter* presenter);
+                ChartElement *createGraphics(ChartPresenter *presenter);
             private:
                 Q_DECLARE_PUBLIC(QPercentBarSeries)
             };

src/barchart/vertical/stacked/qstackedbarseries.cpp +3 -3

             }
-            void QStackedBarSeriesPrivate::scaleDomain(Domain& domain)
+            void QStackedBarSeriesPrivate::scaleDomain(Domain &domain)
             {
                 qreal minX(domain.minX());
                 qreal minY(domain.minY());
                 domain.setRange(minX, maxX, minY, maxY);
             }
-            ChartElement* QStackedBarSeriesPrivate::createGraphics(ChartPresenter* presenter)
+            ChartElement *QStackedBarSeriesPrivate::createGraphics(ChartPresenter *presenter)
             {
                 Q_Q(QStackedBarSeries);
-                StackedBarChartItem* bar = new StackedBarChartItem(q, presenter);
+                StackedBarChartItem *bar = new StackedBarChartItem(q, presenter);
                 if (presenter->animationOptions().testFlag(QChart::SeriesAnimations))
                     bar->setAnimation(new StackedBarAnimation(bar));
                 presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));

src/barchart/vertical/stacked/qstackedbarseries_p.h +3 -3

             class QStackedBarSeriesPrivate: public QAbstractBarSeriesPrivate
             {
             public:
-                QStackedBarSeriesPrivate(QStackedBarSeries* q);
+                QStackedBarSeriesPrivate(QStackedBarSeries *q);
-                ChartElement* createGraphics(ChartPresenter* presenter);
+                ChartElement *createGraphics(ChartPresenter *presenter);
-                void scaleDomain(Domain& domain);
+                void scaleDomain(Domain &domain);
             private:
                 Q_DECLARE_PUBLIC(QStackedBarSeries)
             };

src/barchart/vertical/stacked/stackedbarchartitem.cpp +3 -3

                     qreal yMax = height + scaleY * m_domainMinY + geometry().top();
                     qreal yMin = height + scaleY * m_domainMinY + geometry().top();
                     for (int set = 0; set < setCount; set++) {
-                        QBarSetPrivate* barSet = m_series->d_func()->barsetAt(set)->d_ptr.data();
+                        QBarSetPrivate *barSet = m_series->d_func()->barsetAt(set)->d_ptr.data();
                         qreal xPos = (barSet->pos(category) - m_domainMinX) * scaleX + geometry().left() - rectWidth / 2;
                         qreal rectHeight = barSet->value(category) * scaleY;
-                        Bar* bar = m_bars.at(itemIndex);
+                        Bar *bar = m_bars.at(itemIndex);
                         bar->setPen(barSet->m_pen);
                         bar->setBrush(barSet->m_brush);
                         if (qFuzzyIsNull(rectHeight))
                         else
                             bar->setVisible(barsVisible);
-                        QGraphicsSimpleTextItem* label = m_labels.at(itemIndex);
+                        QGraphicsSimpleTextItem *label = m_labels.at(itemIndex);
                         if (!qFuzzyIsNull(barSet->value(category)))
                             label->setText(QString::number(barSet->value(category)));

src/chartbackground.cpp +4 -4

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            ChartBackground::ChartBackground(QGraphicsItem* parent) :
+            ChartBackground::ChartBackground(QGraphicsItem *parent)
-                QGraphicsRectItem(parent),
+                : QGraphicsRectItem(parent),
-                m_diameter(15),
+                  m_diameter(15),
-                m_dropShadow(0)
+                  m_dropShadow(0)
             {
             }

src/chartconfig_p.h +3 -3

                     m_instance = this;
                 }
             public:
-                static ChartConfig* instance() {
+                static ChartConfig *instance() {
                     if (!m_instance) {
                         m_instance = new ChartConfig();
                     }
                 }
             private:
-                static ChartConfig* m_instance;
+                static ChartConfig *m_instance;
             };
-            ChartConfig* ChartConfig::m_instance = 0;
+            ChartConfig *ChartConfig::m_instance = 0;
             QTCOMMERCIALCHART_END_NAMESPACE

src/chartdataset.cpp +48 -47

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            ChartDataSet::ChartDataSet(QChart *parent): QObject(parent)
+            ChartDataSet::ChartDataSet(QChart *parent)
+                : QObject(parent)
             {
             }
                 removeAllSeries();
             }
-            void ChartDataSet::addSeries(QAbstractSeries* series)
+            void ChartDataSet::addSeries(QAbstractSeries *series)
             {
-                Domain* domain = m_seriesDomainMap.value(series);
+                Domain *domain = m_seriesDomainMap.value(series);
                 if (domain) {
                     qWarning() << "Can not add series. Series already on the chart";
                 createSeriesIndex(series);
                 series->setParent(this); // take ownership
-                series->d_ptr->m_chart = qobject_cast<QChart*>(parent());
+                series->d_ptr->m_chart = qobject_cast<QChart *>(parent());
                 series->d_ptr->m_dataset = this;
                 emit seriesAdded(series, domain);
             }
-            void ChartDataSet::removeSeries(QAbstractSeries* series)
+            void ChartDataSet::removeSeries(QAbstractSeries *series)
             {
                 if (!m_seriesDomainMap.contains(series)) {
                 emit seriesRemoved(series);
-                Domain* domain = m_seriesDomainMap.take(series);
+                Domain *domain = m_seriesDomainMap.take(series);
                 delete domain;
                 domain = 0;
-            void ChartDataSet::createSeriesIndex(QAbstractSeries* series)
+            void ChartDataSet::createSeriesIndex(QAbstractSeries *series)
             {
-                QMapIterator<int, QAbstractSeries*> i(m_indexSeriesMap);
+                QMapIterator<int, QAbstractSeries *> i(m_indexSeriesMap);
                 int key = 0;
                 while (i.hasNext()) {
                 m_indexSeriesMap.insert(key, series);
             }
-            void ChartDataSet::removeSeriesIndex(QAbstractSeries* series)
+            void ChartDataSet::removeSeriesIndex(QAbstractSeries *series)
             {
                 int key = seriesIndex(series);
                 Q_ASSERT(key != -1);
                 QAbstractAxis::AxisTypes typeY(0);
                 // Remove possibly existing axes
-                QMapIterator<QAbstractSeries*, Domain*> i(m_seriesDomainMap);
+                QMapIterator<QAbstractSeries *, Domain *> i(m_seriesDomainMap);
                 while (i.hasNext()) {
                     i.next();
                     removeAxes(i.key());
                 // Select the required axis x and axis y types based on the types of the current series
                 while (i.hasNext()) {
                     i.next();
-                    QAbstractAxis* axisX = m_seriesAxisXMap.value(i.key());
+                    QAbstractAxis *axisX = m_seriesAxisXMap.value(i.key());
-                    QAbstractAxis* axisY = m_seriesAxisYMap.value(i.key());
+                    QAbstractAxis *axisY = m_seriesAxisYMap.value(i.key());
                     if (axisX)
                         typeX &= axisX->type();
                     else
             void ChartDataSet::createAxes(QAbstractAxis::AxisTypes type, Qt::Orientation orientation)
             {
-                QMapIterator<QAbstractSeries*, Domain*> i(m_seriesDomainMap);
+                QMapIterator<QAbstractSeries *, Domain *> i(m_seriesDomainMap);
                 // TODO: Add a descriptive comment of what happens here
                 if (type.testFlag(QAbstractAxis::AxisTypeValue) && type.testFlag(QAbstractAxis::AxisTypeBarCategory)) {
                     while (i.hasNext()) {
                         i.next();
-                        QAbstractAxis* axis = createAxis(i.key()->d_ptr->defaultAxisType(orientation), orientation);
+                        QAbstractAxis *axis = createAxis(i.key()->d_ptr->defaultAxisType(orientation), orientation);
                         if (axis) {
                             initializeAxis(axis, i.key());
                             emit axisAdded(axis, i.value());
                         }
                     }
                 } else if (!type.testFlag(QAbstractAxis::AxisTypeNoAxis)) {
-                    QAbstractAxis* axis = createAxis(QAbstractAxis::AxisType(int(type)), orientation);
+                    QAbstractAxis *axis = createAxis(QAbstractAxis::AxisType(int(type)), orientation);
                     i.toFront();
                     while (i.hasNext()) {
                         i.next();
                 }
             }
-            QAbstractAxis* ChartDataSet::createAxis(QAbstractAxis::AxisType type, Qt::Orientation orientation)
+            QAbstractAxis *ChartDataSet::createAxis(QAbstractAxis::AxisType type, Qt::Orientation orientation)
             {
-                QAbstractAxis* axis = 0;
+                QAbstractAxis *axis = 0;
                 switch (type) {
                 case QAbstractAxis::AxisTypeValue:
                 return axis;
             }
-            void ChartDataSet::initializeAxis(QAbstractAxis* axis, QAbstractSeries* series)
+            void ChartDataSet::initializeAxis(QAbstractAxis *axis, QAbstractSeries *series)
             {
-                Domain* domain = m_seriesDomainMap.value(series);
+                Domain *domain = m_seriesDomainMap.value(series);
                 axis->d_ptr->m_dataset = this;
                 series->d_ptr->initializeAxis(axis);
                 axis->d_ptr->intializeDomain(domain);
                 axis->d_ptr->emitUpdated();
             }
-            void ChartDataSet::removeAxes(QAbstractSeries* series)
+            void ChartDataSet::removeAxes(QAbstractSeries *series)
             {
-                QAbstractAxis* axisX = m_seriesAxisXMap.take(series);
+                QAbstractAxis *axisX = m_seriesAxisXMap.take(series);
                 if (axisX) {
-                    QList<QAbstractAxis*> axesX = m_seriesAxisXMap.values();
+                    QList<QAbstractAxis *> axesX = m_seriesAxisXMap.values();
                     int x = axesX.indexOf(axisX);
                     if (x == -1) {
                     }
                 }
-                QAbstractAxis* axisY = m_seriesAxisYMap.take(series);
+                QAbstractAxis *axisY = m_seriesAxisYMap.take(series);
                 if (axisY) {
-                    QList<QAbstractAxis*> axesY = m_seriesAxisYMap.values();
+                    QList<QAbstractAxis *> axesY = m_seriesAxisYMap.values();
                     int y = axesY.indexOf(axisY);
                 }
             }
-            void ChartDataSet::removeAxis(QAbstractAxis* axis)
+            void ChartDataSet::removeAxis(QAbstractAxis *axis)
             {
                 if (!axis->d_ptr->m_dataset) {
                     qWarning() << "UnBound axis found !";
                     return;
                 }
-                QMap<QAbstractSeries*, QAbstractAxis*> *seriesAxisMap;
+                QMap<QAbstractSeries *, QAbstractAxis *> *seriesAxisMap;
                 if (axis->orientation() == Qt::Vertical)
                     seriesAxisMap = &m_seriesAxisYMap;
                 else
                     seriesAxisMap = &m_seriesAxisXMap;
-                QMapIterator<QAbstractSeries*, QAbstractAxis*> i(*seriesAxisMap);
+                QMapIterator<QAbstractSeries *, QAbstractAxis *> i(*seriesAxisMap);
                 while (i.hasNext()) {
                     i.next();
                 qDeleteAll(series);
             }
-            void ChartDataSet::zoomInDomain(const QRectF& rect, const QSizeF& size)
+            void ChartDataSet::zoomInDomain(const QRectF &rect, const QSizeF &size)
             {
                 //for performance reasons block, signals and scale "full" domain one by one. Gives twice less screen updates
                 blockAxisSignals(true);
-                QMapIterator<QAbstractSeries*, Domain*> i(m_seriesDomainMap);
+                QMapIterator<QAbstractSeries *, Domain *> i(m_seriesDomainMap);
                 while (i.hasNext()) {
                     i.next();
             }
-            void ChartDataSet::zoomOutDomain(const QRectF& rect, const QSizeF& size)
+            void ChartDataSet::zoomOutDomain(const QRectF &rect, const QSizeF &size)
             {
                 //for performance reasons block, signals and scale "full" domain one by one. Gives twice less screen updates
                 blockAxisSignals(true);
-                QMapIterator<QAbstractSeries*, Domain*> i(m_seriesDomainMap);
+                QMapIterator<QAbstractSeries *, Domain *> i(m_seriesDomainMap);
                 while (i.hasNext()) {
                     i.next();
             void ChartDataSet::blockAxisSignals(bool enabled)
             {
-                QMapIterator<QAbstractSeries*, Domain*> i(m_seriesDomainMap);
+                QMapIterator<QAbstractSeries *, Domain *> i(m_seriesDomainMap);
                 while (i.hasNext()) {
                     i.next();
-                    QAbstractAxis* axisX = m_seriesAxisXMap.value(i.key());
+                    QAbstractAxis *axisX = m_seriesAxisXMap.value(i.key());
-                    QAbstractAxis* axisY = m_seriesAxisYMap.value(i.key());
+                    QAbstractAxis *axisY = m_seriesAxisYMap.value(i.key());
                     if (axisX) {
                         axisX->d_ptr->blockSignals(enabled);
                         if (!enabled) {
             int ChartDataSet::seriesCount(QAbstractSeries::SeriesType type)
             {
                 int count = 0;
-                QMapIterator<QAbstractSeries*, Domain*> i(m_seriesDomainMap);
+                QMapIterator<QAbstractSeries *, Domain *> i(m_seriesDomainMap);
                 while (i.hasNext()) {
                     i.next();
                     if (i.key()->type() == type)
             int ChartDataSet::seriesIndex(QAbstractSeries *series)
             {
-                QMapIterator<int, QAbstractSeries*> i(m_indexSeriesMap);
+                QMapIterator<int, QAbstractSeries *> i(m_indexSeriesMap);
                 while (i.hasNext()) {
                     i.next();
                     if (i.value() == series)
                 return -1;
             }
-            QAbstractAxis* ChartDataSet::axisX(QAbstractSeries *series) const
+            QAbstractAxis *ChartDataSet::axisX(QAbstractSeries *series) const
             {
                 if (series == 0) {
-                    QMapIterator<QAbstractSeries*, QAbstractAxis *> i(m_seriesAxisXMap);
+                    QMapIterator<QAbstractSeries *, QAbstractAxis *> i(m_seriesAxisXMap);
                     while (i.hasNext()) {
                         i.next();
                 return m_seriesAxisXMap.value(series);
             }
-            QAbstractAxis* ChartDataSet::axisY(QAbstractSeries *series) const
+            QAbstractAxis *ChartDataSet::axisY(QAbstractSeries *series) const
             {
                 if (series == 0) {
-                    QMapIterator<QAbstractSeries*, QAbstractAxis *> i(m_seriesAxisYMap);
+                    QMapIterator<QAbstractSeries *, QAbstractAxis *> i(m_seriesAxisYMap);
                     while (i.hasNext()) {
                         i.next();
                     return;
                 }
-                Domain* domain = m_seriesDomainMap.value(series);
+                Domain *domain = m_seriesDomainMap.value(series);
                 if (!domain) {
                     qWarning() << "Series not found on the chart.";
                 axis->d_ptr->setOrientation(orientation);
-                QMap<QAbstractSeries*, QAbstractAxis*> *seriesAxisMap;
+                QMap<QAbstractSeries *, QAbstractAxis *> *seriesAxisMap;
                 if (orientation == Qt::Vertical)
                     seriesAxisMap = &m_seriesAxisYMap;
                 }
                 QAbstractAxis *oldAxis = seriesAxisMap->take(series);
-                QList<QAbstractAxis*> axes = seriesAxisMap->values();
+                QList<QAbstractAxis *> axes = seriesAxisMap->values();
                 if (oldAxis) {
                     if (axes.indexOf(oldAxis) == -1) {
                         emit axisRemoved(oldAxis);
                 }
             }
-            Domain* ChartDataSet::domain(QAbstractSeries *series) const
+            Domain *ChartDataSet::domain(QAbstractSeries *series) const
             {
                 return m_seriesDomainMap.value(series);
             }
-            void ChartDataSet::scrollDomain(qreal dx, qreal dy, const QSizeF& size)
+            void ChartDataSet::scrollDomain(qreal dx, qreal dy, const QSizeF &size)
             {
                 blockAxisSignals(true);
-                QMapIterator<QAbstractSeries*, Domain*> i(m_seriesDomainMap);
+                QMapIterator<QAbstractSeries *, Domain *> i(m_seriesDomainMap);
                 while (i.hasNext()) {
                     i.next();
                     i.value()->move(dx, dy, size);
                 blockAxisSignals(false);
             }
-            QList<QAbstractSeries*> ChartDataSet::series() const
+            QList<QAbstractSeries *> ChartDataSet::series() const
             {
                 return m_seriesDomainMap.keys();
             }

src/chartdataset_p.h +25 -25

             {
                 Q_OBJECT
             public:
-                ChartDataSet(QChart* parent = 0);
+                ChartDataSet(QChart *parent = 0);
                 virtual ~ChartDataSet();
-                void addSeries(QAbstractSeries* series);
+                void addSeries(QAbstractSeries *series);
-                void removeSeries(QAbstractSeries* series);
+                void removeSeries(QAbstractSeries *series);
                 void removeAllSeries();
             //    void updateSeries(QAbstractSeries* series);
-                void zoomInDomain(const QRectF& rect, const QSizeF& size);
+                void zoomInDomain(const QRectF &rect, const QSizeF &size);
-                void zoomOutDomain(const QRectF& rect, const QSizeF& size);
+                void zoomOutDomain(const QRectF &rect, const QSizeF &size);
-                void scrollDomain(qreal dx, qreal dy, const QSizeF& size);
+                void scrollDomain(qreal dx, qreal dy, const QSizeF &size);
                 int seriesCount(QAbstractSeries::SeriesType type);
                 int seriesIndex(QAbstractSeries *series);
-                QAbstractAxis* axisX(QAbstractSeries *series) const;
+                QAbstractAxis *axisX(QAbstractSeries *series) const;
-                QAbstractAxis* axisY(QAbstractSeries *series) const;
+                QAbstractAxis *axisY(QAbstractSeries *series) const;
                 void setAxis(QAbstractSeries *series, QAbstractAxis *axis, Qt::Orientation orientation);
-                QList<QAbstractSeries*> series() const;
+                QList<QAbstractSeries *> series() const;
-                Domain* domain(QAbstractSeries *series) const;
+                Domain *domain(QAbstractSeries *series) const;
-                void removeAxis(QAbstractAxis* axis);
+                void removeAxis(QAbstractAxis *axis);
                 void createDefaultAxes();
             Q_SIGNALS:
-                void seriesAdded(QAbstractSeries* series, Domain* domain);
+                void seriesAdded(QAbstractSeries *series, Domain *domain);
-                void seriesRemoved(QAbstractSeries* series);
+                void seriesRemoved(QAbstractSeries *series);
             //    void seriesUpdated(QAbstractSeries* series);
-                void axisAdded(QAbstractAxis* axis, Domain* domain);
+                void axisAdded(QAbstractAxis *axis, Domain *domain);
-                void axisRemoved(QAbstractAxis* axis);
+                void axisRemoved(QAbstractAxis *axis);
             private:
-                void calculateDomain(QAbstractSeries* series, Domain* domain);
+                void calculateDomain(QAbstractSeries *series, Domain *domain);
                 void createAxes(QAbstractAxis::AxisTypes type, Qt::Orientation orientation);
-                QAbstractAxis* createAxis(QAbstractAxis::AxisType type, Qt::Orientation orientation);
+                QAbstractAxis *createAxis(QAbstractAxis::AxisType type, Qt::Orientation orientation);
-                void initializeAxis(QAbstractAxis* axis, QAbstractSeries* series);
+                void initializeAxis(QAbstractAxis *axis, QAbstractSeries *series);
-                void removeAxes(QAbstractSeries* series);
+                void removeAxes(QAbstractSeries *series);
                 void blockAxisSignals(bool enabled);
-                void createSeriesIndex(QAbstractSeries* series);
+                void createSeriesIndex(QAbstractSeries *series);
-                void removeSeriesIndex(QAbstractSeries* series);
+                void removeSeriesIndex(QAbstractSeries *series);
             private:
-                QMap<QAbstractSeries*, QAbstractAxis*> m_seriesAxisXMap;
+                QMap<QAbstractSeries *, QAbstractAxis *> m_seriesAxisXMap;
-                QMap<QAbstractSeries*, QAbstractAxis*> m_seriesAxisYMap;
+                QMap<QAbstractSeries *, QAbstractAxis *> m_seriesAxisYMap;
-                QMap<QAbstractSeries*, Domain*> m_seriesDomainMap;
+                QMap<QAbstractSeries *, Domain *> m_seriesDomainMap;
-                QMap<int, QAbstractSeries*> m_indexSeriesMap;
+                QMap<int, QAbstractSeries *> m_indexSeriesMap;
             };
             QTCOMMERCIALCHART_END_NAMESPACE

src/chartelement.cpp +3 -3

                 m_presenter = presenter;
             }
-            ChartPresenter* ChartElement::presenter() const
+            ChartPresenter *ChartElement::presenter() const
             {
                 return m_presenter;
             }
                 m_domain = domain;
             }
-            Domain* ChartElement::domain() const
+            Domain *ChartElement::domain() const
             {
                 return m_domain;
             }
-            void ChartElement::handleGeometryChanged(const QRectF& rect)
+            void ChartElement::handleGeometryChanged(const QRectF &rect)
             {
                 Q_UNUSED(rect);
                 qWarning() << "Slot not implemented";

src/chartelement_p.h +6 -7

                 explicit ChartElement(ChartPresenter *presenter);
             public Q_SLOTS:
-                virtual void handleGeometryChanged(const QRectF& rect);
+                virtual void handleGeometryChanged(const QRectF &rect);
                 virtual void handleDomainChanged(qreal minX, qreal maxX, qreal minY, qreal maxY);
                 virtual void handleDomainUpdated();
-                virtual ChartAnimation* animation() const { return 0; };
+                virtual ChartAnimation *animation() const { return 0; }
                 void setPresenter(ChartPresenter *presenter);
-                ChartPresenter* presenter() const;
+                ChartPresenter *presenter() const;
                 void setDomain(Domain *domain);
-                Domain* domain() const;
+                Domain *domain() const;
             private:
-                ChartPresenter* m_presenter;
+                ChartPresenter *m_presenter;
-                Domain* m_domain;
+                Domain *m_domain;
             };
             QTCOMMERCIALCHART_END_NAMESPACE

src/chartlayout.cpp +25 -25

             static const qreal golden_ratio = 0.25;
-            ChartLayout::ChartLayout(ChartPresenter* presenter)
+            ChartLayout::ChartLayout(ChartPresenter *presenter)
                 : m_presenter(presenter),
                   m_margins(20, 20, 20, 20),
                   m_minChartRect(0, 0, 200, 200)
             }
-            void ChartLayout::setGeometry(const QRectF& rect)
+            void ChartLayout::setGeometry(const QRectF &rect)
             {
                 if (!rect.isValid())
                     return;
-                QList<ChartAxis*> axes = m_presenter->axisItems();
+                QList<ChartAxis *> axes = m_presenter->axisItems();
-                ChartTitle* title = m_presenter->titleElement();
+                ChartTitle *title = m_presenter->titleElement();
-                QLegend* legend = m_presenter->legend();
+                QLegend *legend = m_presenter->legend();
-                ChartBackground* background = m_presenter->backgroundElement();
+                ChartBackground *background = m_presenter->backgroundElement();
                 QRectF contentGeometry = calculateBackgroundGeometry(rect, background);
                 //TODO remove me
             #ifdef SHOW_LAYOUT
-                LayoutDebuger* debuger = LayoutDebuger::instance();
+                LayoutDebuger *debuger = LayoutDebuger::instance();
                 debuger->reset();
                 debuger->setPen(QPen(Qt::red));
                 debuger->add(backgroundGeometry, m_presenter->rootItem());
                 debuger->add(legendGeometry , m_presenter->rootItem());
                 debuger->add(axisGeometry , m_presenter->rootItem());
                 debuger->add(geometry, m_presenter->rootItem());
-                foreach (LegendMarker *marker, legend->d_ptr->markers())
+                foreach(LegendMarker * marker, legend->d_ptr->markers())
-                    debuger->add(marker->mapRectToScene(marker->boundingRect()), m_presenter->rootItem());
+                debuger->add(marker->mapRectToScene(marker->boundingRect()), m_presenter->rootItem());
             #endif
                 QGraphicsLayout::setGeometry(rect);
             }
-            QRectF ChartLayout::calculateContentGeometry(const QRectF& geometry) const
+            QRectF ChartLayout::calculateContentGeometry(const QRectF &geometry) const
             {
                 return geometry.adjusted(m_margins.left(), m_margins.top(), -m_margins.right(), -m_margins.bottom());
             }
-            QRectF ChartLayout::calculateContentMinimum(const QRectF& minimum) const
+            QRectF ChartLayout::calculateContentMinimum(const QRectF &minimum) const
             {
                 return  minimum.adjusted(0, 0, m_margins.left() + m_margins.right(), m_margins.top() + m_margins.bottom());
             }
-            QRectF ChartLayout::calculateBackgroundGeometry(const QRectF& geometry, ChartBackground* background) const
+            QRectF ChartLayout::calculateBackgroundGeometry(const QRectF &geometry, ChartBackground *background) const
             {
                 qreal left, top, right, bottom;
                 getContentsMargins(&left, &top, &right, &bottom);
                 return backgroundGeometry;
             }
-            QRectF ChartLayout::calculateBackgroundMinimum(const QRectF& minimum) const
+            QRectF ChartLayout::calculateBackgroundMinimum(const QRectF &minimum) const
             {
                 qreal left, top, right, bottom;
                 getContentsMargins(&left, &top, &right, &bottom);
                 return minimum.adjusted(0, 0, left + right, top + bottom);
             }
-            QRectF ChartLayout::calculateChartGeometry(const QRectF& geometry, const QList<ChartAxis*>& axes) const
+            QRectF ChartLayout::calculateChartGeometry(const QRectF &geometry, const QList<ChartAxis *>& axes) const
             {
                 QSizeF vertical(0, 0);
                 int rightAxisCount = 0;
                 // check axis size
-                foreach (ChartAxis* axis , axes) {
+                foreach (ChartAxis *axis , axes) {
                     if (axis->orientation() == Qt::Vertical && axis->isVisible()) {
             //            vertical = vertical.expandedTo(axis->effectiveSizeHint(Qt::MinimumSize));
                         if (axis->alternativePlacement())
                 return rect;
             }
-            QRectF ChartLayout::calculateAxisMinimum(const QRectF& minimum, const QList<ChartAxis*>& axes) const
+            QRectF ChartLayout::calculateAxisMinimum(const QRectF &minimum, const QList<ChartAxis *>& axes) const
             {
                 QSizeF vertical(0, 0);
                 QSizeF horizontal(0, 0);
                 return minimum.adjusted(0, 0, horizontal.width() + vertical.width(), horizontal.height() + vertical.height());
             }
-            QRectF ChartLayout::calculateLegendGeometry(const QRectF& geometry, QLegend* legend) const
+            QRectF ChartLayout::calculateLegendGeometry(const QRectF &geometry, QLegend *legend) const
             {
                 QSizeF size = legend->effectiveSizeHint(Qt::PreferredSize, QSizeF(-1, -1));
                 QRectF legendRect;
                 return result;
             }
-            QRectF ChartLayout::calculateLegendMinimum(const QRectF& geometry, QLegend* legend) const
+            QRectF ChartLayout::calculateLegendMinimum(const QRectF &geometry, QLegend *legend) const
             {
                 QSizeF minSize = legend->effectiveSizeHint(Qt::MinimumSize, QSizeF(-1, -1));
                 return geometry.adjusted(0, 0, minSize.width(), minSize.height());
             }
-            QRectF ChartLayout::calculateTitleGeometry(const QRectF& geometry, ChartTitle* title) const
+            QRectF ChartLayout::calculateTitleGeometry(const QRectF &geometry, ChartTitle *title) const
             {
                 title->setGeometry(geometry);
                 QPointF center = geometry.center() - title->boundingRect().center();
                 return geometry.adjusted(0, title->boundingRect().height(), 0, 0);
             }
-            QRectF ChartLayout::calculateTitleMinimum(const QRectF& minimum, ChartTitle* title) const
+            QRectF ChartLayout::calculateTitleMinimum(const QRectF &minimum, ChartTitle *title) const
             {
                 QSizeF min = title->sizeHint(Qt::MinimumSize);
                 return minimum.adjusted(0, 0, min.width(), min.height());
             }
-            QSizeF ChartLayout::sizeHint(Qt::SizeHint which, const QSizeF & constraint) const
+            QSizeF ChartLayout::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
             {
                 Q_UNUSED(constraint);
                 if (which == Qt::MinimumSize) {
-                    QList<ChartAxis*> axes = m_presenter->axisItems();
+                    QList<ChartAxis *> axes = m_presenter->axisItems();
-                    ChartTitle* title = m_presenter->titleElement();
+                    ChartTitle *title = m_presenter->titleElement();
-                    QLegend* legend = m_presenter->legend();
+                    QLegend *legend = m_presenter->legend();
                     QRectF minimumRect(0, 0, 0, 0);
                     minimumRect = calculateBackgroundMinimum(minimumRect);
                     minimumRect = calculateContentMinimum(minimumRect);
                 return QSize(-1, -1);
             }
-            void ChartLayout::setMargins(const QMargins& margins)
+            void ChartLayout::setMargins(const QMargins &margins)
             {
                 if (m_margins != margins) {
                     m_margins = margins;

src/chartlayout_p.h +17 -17

             {
             public:
-                ChartLayout(ChartPresenter* presenter);
+                ChartLayout(ChartPresenter *presenter);
                 virtual ~ChartLayout();
-                void setMargins(const QMargins& margins);
+                void setMargins(const QMargins &margins);
                 QMargins margins() const;
-                void setGeometry(const QRectF& rect);
+                void setGeometry(const QRectF &rect);
                 void adjustChartGeometry();
             protected:
-                QSizeF sizeHint ( Qt::SizeHint which, const QSizeF &constraint = QSizeF()) const;
+                QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint = QSizeF()) const;
                 int count() const { return 0; }
-                QGraphicsLayoutItem* itemAt(int) const { return 0; };
+                QGraphicsLayoutItem *itemAt(int) const { return 0; };
-                void removeAt(int){};
+                void removeAt(int) {};
             private:
-                QRectF calculateBackgroundGeometry(const QRectF& geometry, ChartBackground* background) const;
+                QRectF calculateBackgroundGeometry(const QRectF &geometry, ChartBackground *background) const;
-                QRectF calculateContentGeometry(const QRectF& geometry) const;
+                QRectF calculateContentGeometry(const QRectF &geometry) const;
-                QRectF calculateTitleGeometry(const QRectF& geometry, ChartTitle* title) const;
+                QRectF calculateTitleGeometry(const QRectF &geometry, ChartTitle *title) const;
-                QRectF calculateChartGeometry(const QRectF& geometry, const QList<ChartAxis*>& axes) const;
+                QRectF calculateChartGeometry(const QRectF &geometry, const QList<ChartAxis *>& axes) const;
-                QRectF calculateLegendGeometry(const QRectF& geometry, QLegend* legend) const;
+                QRectF calculateLegendGeometry(const QRectF &geometry, QLegend *legend) const;
-                QRectF calculateBackgroundMinimum(const QRectF& minimum) const;
+                QRectF calculateBackgroundMinimum(const QRectF &minimum) const;
-                QRectF calculateContentMinimum(const QRectF& minimum) const;
+                QRectF calculateContentMinimum(const QRectF &minimum) const;
-                QRectF calculateTitleMinimum(const QRectF& minimum, ChartTitle* title) const;
+                QRectF calculateTitleMinimum(const QRectF &minimum, ChartTitle *title) const;
-                QRectF calculateAxisMinimum(const QRectF& minimum, const QList<ChartAxis*>& axes) const;
+                QRectF calculateAxisMinimum(const QRectF &minimum, const QList<ChartAxis *>& axes) const;
-                QRectF calculateLegendMinimum(const QRectF& minimum, QLegend* legend) const;
+                QRectF calculateLegendMinimum(const QRectF &minimum, QLegend *legend) const;
             private:
-                ChartPresenter* m_presenter;
+                ChartPresenter *m_presenter;
                 QMargins m_margins;
                 QRectF m_minChartRect;
                 QRectF m_minAxisRect;

src/chartpresenter.cpp +31 -31

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            ChartPresenter::ChartPresenter(QChart* chart, ChartDataSet* dataset)
+            ChartPresenter::ChartPresenter(QChart *chart, ChartDataSet *dataset)
                 : QObject(chart),
                   m_chart(chart),
                   m_dataset(dataset),
                 delete m_chartTheme;
             }
-            void ChartPresenter::setChartsGeometry(const QRectF& rect)
+            void ChartPresenter::setChartsGeometry(const QRectF &rect)
             {
                 Q_ASSERT(rect.isValid());
                 return m_chartsRect;
             }
-            void ChartPresenter::handleAxisAdded(QAbstractAxis* axis, Domain* domain)
+            void ChartPresenter::handleAxisAdded(QAbstractAxis *axis, Domain *domain)
             {
-                ChartAxis* item = axis->d_ptr->createGraphics(this);
+                ChartAxis *item = axis->d_ptr->createGraphics(this);
                 item->setDomain(domain);
                 if (m_options.testFlag(QChart::GridAxisAnimations))
                 selectVisibleAxis();
             }
-            void ChartPresenter::handleAxisRemoved(QAbstractAxis* axis)
+            void ChartPresenter::handleAxisRemoved(QAbstractAxis *axis)
             {
-                ChartAxis* item = m_axisItems.take(axis);
+                ChartAxis *item = m_axisItems.take(axis);
                 Q_ASSERT(item);
                 selectVisibleAxis();
                 item->hide();
             }
-            void ChartPresenter::handleSeriesAdded(QAbstractSeries* series, Domain* domain)
+            void ChartPresenter::handleSeriesAdded(QAbstractSeries *series, Domain *domain)
             {
                 ChartElement *item = series->d_ptr->createGraphics(this);
                 Q_ASSERT(item);
                 m_chartItems.insert(series, item);
             }
-            void ChartPresenter::handleSeriesRemoved(QAbstractSeries* series)
+            void ChartPresenter::handleSeriesRemoved(QAbstractSeries *series)
             {
-                ChartElement* item = m_chartItems.take(series);
+                ChartElement *item = m_chartItems.take(series);
                 Q_ASSERT(item);
                 item->deleteLater();
             }
             void ChartPresenter::selectVisibleAxis()
             {
-                QMapIterator<QAbstractAxis*, ChartAxis*> i(m_axisItems);
+                QMapIterator<QAbstractAxis *, ChartAxis *> i(m_axisItems);
                 while (i.hasNext()) {
                     i.next();
             void ChartPresenter::handleAxisVisibleChanged(bool visible)
             {
-                QAbstractAxis* axis = static_cast<QAbstractAxis*>(sender());
+                QAbstractAxis *axis = static_cast<QAbstractAxis *>(sender());
                 Q_ASSERT(axis);
                 if (visible) {
-                    QMapIterator<QAbstractAxis*, ChartAxis*> i(m_axisItems);
+                    QMapIterator<QAbstractAxis *, ChartAxis *> i(m_axisItems);
                     while (i.hasNext()) {
                         i.next();
             void ChartPresenter::resetAllElements()
             {
-                QMapIterator<QAbstractAxis*, ChartAxis*> i(m_axisItems);
+                QMapIterator<QAbstractAxis *, ChartAxis *> i(m_axisItems);
                 while (i.hasNext()) {
                     i.next();
-                    Domain* domain = i.value()->domain();
+                    Domain *domain = i.value()->domain();
-                    QAbstractAxis* axis = i.key();
+                    QAbstractAxis *axis = i.key();
                     handleAxisRemoved(axis);
                     handleAxisAdded(axis, domain);
                 }
-                QMapIterator<QAbstractSeries*, ChartElement*> j(m_chartItems);
+                QMapIterator<QAbstractSeries *, ChartElement *> j(m_chartItems);
                 while (j.hasNext()) {
                     j.next();
-                    Domain* domain = j.value()->domain();
+                    Domain *domain = j.value()->domain();
-                    QAbstractSeries* series = j.key();
+                    QAbstractSeries *series = j.key();
                     handleSeriesRemoved(series);
                     handleSeriesAdded(series, domain);
                 }
                 zoomIn(rect);
             }
-            void ChartPresenter::zoomIn(const QRectF& rect)
+            void ChartPresenter::zoomIn(const QRectF &rect)
             {
                 QRectF r = rect.normalized();
                 r.translate(-chartsGeometry().topLeft());
             void ChartPresenter::handleAnimationFinished()
             {
-                m_animations.removeAll(qobject_cast<ChartAnimation*>(sender()));
+                m_animations.removeAll(qobject_cast<ChartAnimation *>(sender()));
                 if (m_animations.empty())
                     emit animationsFinished();
             }
-            void ChartPresenter::startAnimation(ChartAnimation* animation)
+            void ChartPresenter::startAnimation(ChartAnimation *animation)
             {
                 if (animation->state() != QAbstractAnimation::Stopped)
                     animation->stop();
                 QTimer::singleShot(0, animation, SLOT(start()));
             }
-            void ChartPresenter::setBackgroundBrush(const QBrush& brush)
+            void ChartPresenter::setBackgroundBrush(const QBrush &brush)
             {
                 createBackgroundItem();
                 m_background->setBrush(brush);
                 return m_background->brush();
             }
-            void ChartPresenter::setBackgroundPen(const QPen& pen)
+            void ChartPresenter::setBackgroundPen(const QPen &pen)
             {
                 createBackgroundItem();
                 m_background->setPen(pen);
                 return m_background->pen();
             }
-            void ChartPresenter::setTitle(const QString& title)
+            void ChartPresenter::setTitle(const QString &title)
             {
                 createTitleItem();
                 m_title->setText(title);
                 return m_title->text();
             }
-            void ChartPresenter::setTitleFont(const QFont& font)
+            void ChartPresenter::setTitleFont(const QFont &font)
             {
                 createTitleItem();
                 m_title->setFont(font);
             }
-            QGraphicsLayout* ChartPresenter::layout()
+            QGraphicsLayout *ChartPresenter::layout()
             {
                 return m_layout;
             }
-            void ChartPresenter::setMargins(const QMargins& margins)
+            void ChartPresenter::setMargins(const QMargins &margins)
             {
                 m_layout->setMargins(margins);
             }
                 return m_layout->margins();
             }
-            QLegend* ChartPresenter::legend()
+            QLegend *ChartPresenter::legend()
             {
                 return m_chart->legend();
             }
                 m_chart->setVisible(visible);
             }
-            ChartBackground* ChartPresenter::backgroundElement()
+            ChartBackground *ChartPresenter::backgroundElement()
             {
                 return m_background;
             }
-            QList<ChartAxis*>  ChartPresenter::axisItems() const
+            QList<ChartAxis *>  ChartPresenter::axisItems() const
             {
                 return m_axisItems.values();
             }
-            ChartTitle* ChartPresenter::titleElement()
+            ChartTitle *ChartPresenter::titleElement()
             {
                 return m_title;
             }

src/chartpresenter_p.h +28 -28

                     ZoomOutState
                 };
-                ChartPresenter(QChart* chart, ChartDataSet *dataset);
+                ChartPresenter(QChart *chart, ChartDataSet *dataset);
                 virtual ~ChartPresenter();
                 ChartTheme *chartTheme() const { return m_chartTheme; }
                 ChartDataSet *dataSet() const { return m_dataset; }
-                QGraphicsItem* rootItem() const { return m_chart; }
+                QGraphicsItem *rootItem() const { return m_chart; }
-                ChartBackground* backgroundElement();
+                ChartBackground *backgroundElement();
-                ChartTitle* titleElement();
+                ChartTitle *titleElement();
-                QList<ChartAxis*> axisItems() const;
+                QList<ChartAxis *> axisItems() const;
-                QLegend* legend();
+                QLegend *legend();
-                void setBackgroundBrush(const QBrush& brush);
+                void setBackgroundBrush(const QBrush &brush);
                 QBrush backgroundBrush() const;
-                void setBackgroundPen(const QPen& pen);
+                void setBackgroundPen(const QPen &pen);
                 QPen backgroundPen() const;
-                void setTitle(const QString& title);
+                void setTitle(const QString &title);
                 QString title() const;
-                void setTitleFont(const QFont& font);
+                void setTitleFont(const QFont &font);
                 QFont titleFont() const;
                 void setTitleBrush(const QBrush &brush);
                 QChart::AnimationOptions animationOptions() const;
                 void zoomIn(qreal factor);
-                void zoomIn(const QRectF& rect);
+                void zoomIn(const QRectF &rect);
                 void zoomOut(qreal factor);
                 void scroll(qreal dx, qreal dy);
-                void setChartsGeometry(const QRectF& rect);
+                void setChartsGeometry(const QRectF &rect);
                 QRectF chartsGeometry() const;
-                void startAnimation(ChartAnimation* animation);
+                void startAnimation(ChartAnimation *animation);
                 State state() const { return m_state; }
                 QPointF statePoint() const { return m_statePoint; }
                 void resetAllElements();
-                void setMargins(const QMargins& margins);
+                void setMargins(const QMargins &margins);
                 QMargins margins() const;
-                QGraphicsLayout* layout();
+                QGraphicsLayout *layout();
             private:
                 void createBackgroundItem();
                 void selectVisibleAxis();
             public Q_SLOTS:
-                void handleSeriesAdded(QAbstractSeries* series, Domain* domain);
+                void handleSeriesAdded(QAbstractSeries *series, Domain *domain);
-                void handleSeriesRemoved(QAbstractSeries* series);
+                void handleSeriesRemoved(QAbstractSeries *series);
-                void handleAxisAdded(QAbstractAxis* axis, Domain* domain);
+                void handleAxisAdded(QAbstractAxis *axis, Domain *domain);
-                void handleAxisRemoved(QAbstractAxis* axis);
+                void handleAxisRemoved(QAbstractAxis *axis);
                 void handleAxisVisibleChanged(bool visible);
             private Q_SLOTS:
                 void handleAnimationFinished();
             Q_SIGNALS:
-                void geometryChanged(const QRectF& rect);
+                void geometryChanged(const QRectF &rect);
                 void animationsFinished();
                 void marginsChanged(QRectF margins);
             private:
-                QChart* m_chart;
+                QChart *m_chart;
-                ChartDataSet* m_dataset;
+                ChartDataSet *m_dataset;
                 ChartTheme *m_chartTheme;
-                QMap<QAbstractSeries*, ChartElement*> m_chartItems;
+                QMap<QAbstractSeries *, ChartElement *> m_chartItems;
-                QMap<QAbstractAxis*, ChartAxis*> m_axisItems;
+                QMap<QAbstractAxis *, ChartAxis *> m_axisItems;
                 QRectF m_chartsRect;
                 QChart::AnimationOptions m_options;
                 State m_state;
                 QPointF m_statePoint;
-                QList<ChartAnimation*> m_animations;
+                QList<ChartAnimation *> m_animations;
-                ChartLayout* m_layout;
+                ChartLayout *m_layout;
-                ChartBackground* m_background;
+                ChartBackground *m_background;
-                ChartTitle* m_title;
+                ChartTitle *m_title;
             };
             QTCOMMERCIALCHART_END_NAMESPACE

src/charttheme.cpp +1 -1

             }
-            ChartTheme* ChartTheme::createTheme(QChart::ChartTheme theme)
+            ChartTheme *ChartTheme::createTheme(QChart::ChartTheme theme)
             {
                 switch (theme) {
                 case QChart::ChartThemeLight:

src/charttitle.cpp +1 -1

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            ChartTitle::ChartTitle(QGraphicsItem* parent)
+            ChartTitle::ChartTitle(QGraphicsItem *parent)
                 : QGraphicsSimpleTextItem(parent)
             {

src/charttitle_p.h +1 -1

             class ChartTitle : public QGraphicsSimpleTextItem
             {
             public:
-                ChartTitle(QGraphicsItem* parent = 0);
+                ChartTitle(QGraphicsItem *parent = 0);
                 ~ChartTitle();
                 QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint = QSizeF()) const;
                 void setText(const QString &text);

src/domain.cpp +5 -5

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            Domain::Domain(QObject* parent)
+            Domain::Domain(QObject *parent)
                 : QObject(parent),
                   m_minX(0),
                   m_maxX(0),
                 return qFuzzyIsNull(spanX()) || qFuzzyIsNull(spanY());
             }
-            void Domain::zoomIn(const QRectF& rect, const QSizeF& size)
+            void Domain::zoomIn(const QRectF &rect, const QSizeF &size)
             {
                 qreal dx = spanX() / size.width();
                 qreal dy = spanY() / size.height();
                 setRange(minX, maxX, minY, maxY);
             }
-            void Domain::zoomOut(const QRectF& rect, const QSizeF& size)
+            void Domain::zoomOut(const QRectF &rect, const QSizeF &size)
             {
                 qreal dx = spanX() / rect.width();
                 qreal dy = spanY() / rect.height();
                 setRange(minX, maxX, minY, maxY);
             }
-            void Domain::move(qreal dx, qreal dy, const QSizeF& size)
+            void Domain::move(qreal dx, qreal dy, const QSizeF &size)
             {
                 qreal x = spanX() / size.width();
                 qreal y = spanY() / size.height();
             void Domain::handleAxisUpdated()
             {
-                QAbstractAxisPrivate* axis = qobject_cast<QAbstractAxisPrivate*>(sender());
+                QAbstractAxisPrivate *axis = qobject_cast<QAbstractAxisPrivate *>(sender());
                 Q_ASSERT(axis);
                 axis->setDirty(false);
                 if (axis->orientation() == Qt::Horizontal)

src/domain_p.h +4 -4

             {
                 Q_OBJECT
             public:
-                explicit Domain(QObject* object = 0);
+                explicit Domain(QObject *object = 0);
                 virtual ~Domain();
                 void setRange(qreal minX, qreal maxX, qreal minY, qreal maxY);
                 friend bool QTCOMMERCIALCHART_AUTOTEST_EXPORT operator!= (const Domain &domain1, const Domain &domain2);
                 friend QDebug QTCOMMERCIALCHART_AUTOTEST_EXPORT operator<<(QDebug dbg, const Domain &domain);
-                void zoomIn(const QRectF& rect, const QSizeF& size);
+                void zoomIn(const QRectF &rect, const QSizeF &size);
-                void zoomOut(const QRectF& rect, const QSizeF& size);
+                void zoomOut(const QRectF &rect, const QSizeF &size);
-                void move(qreal dx, qreal dy, const QSizeF& size);
+                void move(qreal dx, qreal dy, const QSizeF &size);
                 void emitUpdated();
             Q_SIGNALS:

src/legend/legendlayout.cpp +9 -9

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            LegendLayout::LegendLayout(QLegend* legend)
+            LegendLayout::LegendLayout(QLegend *legend)
                 : m_legend(legend)
             {
                     m_legend->d_ptr->m_presenter->layout()->invalidate();
             }
-            void LegendLayout::setGeometry(const QRectF& rect)
+            void LegendLayout::setGeometry(const QRectF &rect)
             {
                 m_legend->d_ptr->items()->setVisible(m_legend->isVisible());
                     setDettachedGeometry(rect);
             }
-            void LegendLayout::setAttachedGeometry(const QRectF& rect)
+            void LegendLayout::setAttachedGeometry(const QRectF &rect)
             {
                 if (!rect.isValid())
                     return;
                         if (marker->isVisible()) {
                             marker->setGeometry(geometry);
                             marker->setPos(point);
-                            const QRectF& rect = marker->boundingRect();
+                            const QRectF &rect = marker->boundingRect();
                             qreal h = rect.height();
                             size = size.expandedTo(rect.size());
                             m_height += h;
                 m_maxOffsetY = m_height - geometry.height() - bottom;
             }
-            void LegendLayout::setDettachedGeometry(const QRectF& rect)
+            void LegendLayout::setDettachedGeometry(const QRectF &rect)
             {
                 if (!rect.isValid())
                     return;
                             if (marker->isVisible()) {
                                 marker->setGeometry(geometry);
                                 marker->setPos(point.x(), point.y());
-                                const QRectF& boundingRect = marker->boundingRect();
+                                const QRectF &boundingRect = marker->boundingRect();
                                 qreal w = boundingRect.width();
                                 qreal h = boundingRect.height();
                                 m_width = qMax(m_width, w);
                             LegendMarker *marker = markers.at(i);
                             if (marker->isVisible()) {
                                 marker->setGeometry(geometry);
-                                const QRectF& boundingRect = marker->boundingRect();
+                                const QRectF &boundingRect = marker->boundingRect();
                                 qreal w = boundingRect.width();
                                 qreal h = boundingRect.height();
                                 m_height = qMax(m_height, h);
                             LegendMarker *marker = markers.at(i);
                             if (marker->isVisible()) {
                                 marker->setGeometry(geometry);
-                                const QRectF& boundingRect = marker->boundingRect();
+                                const QRectF &boundingRect = marker->boundingRect();
                                 qreal w = boundingRect.width();
                                 qreal h = boundingRect.height();
                                 m_height = qMax(m_height, h);
             }
-            QSizeF LegendLayout::sizeHint(Qt::SizeHint which, const QSizeF & constraint) const
+            QSizeF LegendLayout::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
             {
                 QSizeF size(0, 0);
                 qreal left, top, right, bottom;

src/legend/legendlayout_p.h +8 -8

             {
             public:
-                LegendLayout(QLegend* legend);
+                LegendLayout(QLegend *legend);
                 virtual ~LegendLayout();
-                void setGeometry(const QRectF& rect);
+                void setGeometry(const QRectF &rect);
                 void setOffset(qreal x, qreal y);
                 QPointF offset() const;
                 void invalidate();
             protected:
-                QSizeF sizeHint ( Qt::SizeHint which, const QSizeF & constraint = QSizeF()) const;
+                QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint = QSizeF()) const;
                 int count() const { return 0; }
-                QGraphicsLayoutItem* itemAt(int) const { return 0; };
+                QGraphicsLayoutItem *itemAt(int) const { return 0; };
-                void removeAt(int){};
+                void removeAt(int) {};
             private:
-                void setAttachedGeometry(const QRectF& rect);
+                void setAttachedGeometry(const QRectF &rect);
-                void setDettachedGeometry(const QRectF& rect);
+                void setDettachedGeometry(const QRectF &rect);
             private:
-                QLegend* m_legend;
+                QLegend *m_legend;
                 qreal m_offsetX;
                 qreal m_offsetY;
                 qreal m_minOffsetX;

src/legend/legendmarker.cpp +4 -4

             }
-            void LegendMarker::setGeometry(const QRectF& rect)
+            void LegendMarker::setGeometry(const QRectF &rect)
             {
                 QFontMetrics fn(font());
                     m_textItem->setText(m_text);
                 }
-                const QRectF& textRect = m_textItem->boundingRect();
+                const QRectF &textRect = m_textItem->boundingRect();
                 m_textItem->setPos(x - m_margin, y / 2 - textRect.height() / 2);
                 m_rectItem->setRect(m_markerRect);
                 m_rectItem->setPos(m_margin, y / 2  - m_markerRect.height() / 2);
                 Q_UNUSED(painter)
             }
-            QSizeF LegendMarker::sizeHint(Qt::SizeHint which, const QSizeF& constraint) const
+            QSizeF LegendMarker::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
             {
                 Q_UNUSED(constraint)
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-            PieLegendMarker::PieLegendMarker(QPieSeries* series, QPieSlice *pieslice, QLegend *legend)
+            PieLegendMarker::PieLegendMarker(QPieSeries *series, QPieSlice *pieslice, QLegend *legend)
                 : LegendMarker(series, legend),
                   m_pieslice(pieslice)
             {

src/legend/legendmarker_p.h +3 -3

                 QAbstractSeries *series() const { return m_series;}
-                void setGeometry(const QRectF& rect);
+                void setGeometry(const QRectF &rect);
                 QRectF boundingRect() const;
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = 0);
-                QSizeF sizeHint(Qt::SizeHint which, const QSizeF& constraint) const;
+                QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint) const;
             protected:
                 // From QGraphicsObject
                 QAbstractSeries *m_series;
                 QRectF m_markerRect;
                 QRectF m_boundingRect;
-                QLegend* m_legend;
+                QLegend *m_legend;
                 QGraphicsSimpleTextItem *m_textItem;
                 QGraphicsRectItem *m_rectItem;
                 qreal m_margin;

src/legend/legendscroller_p.h +4 -4

             public:
                 LegendScroller(QChart *chart): QLegend(chart) { }
-                void setOffset(const QPointF& point) { d_ptr->setOffset(point.x(), point.y()); }
+                void setOffset(const QPointF &point) { d_ptr->setOffset(point.x(), point.y()); }
                 QPointF offset() const { return d_ptr->offset(); }
-                void mousePressEvent(QGraphicsSceneMouseEvent* event) { Scroller::mousePressEvent(event); }
+                void mousePressEvent(QGraphicsSceneMouseEvent *event) { Scroller::mousePressEvent(event); }
-                void mouseMoveEvent(QGraphicsSceneMouseEvent* event) { Scroller::mouseMoveEvent(event); }
+                void mouseMoveEvent(QGraphicsSceneMouseEvent *event) { Scroller::mouseMoveEvent(event); }
-                void mouseReleaseEvent(QGraphicsSceneMouseEvent* event) { Scroller::mouseReleaseEvent(event); }
+                void mouseReleaseEvent(QGraphicsSceneMouseEvent *event) { Scroller::mouseReleaseEvent(event); }
             };
             QTCOMMERCIALCHART_END_NAMESPACE

src/legend/qlegend.cpp +4 -4

             ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-            QLegendPrivate::QLegendPrivate(ChartPresenter* presenter, QChart *chart, QLegend *q)
+            QLegendPrivate::QLegendPrivate(ChartPresenter *presenter, QChart *chart, QLegend *q)
                 : q_ptr(q),
                   m_presenter(presenter),
                   m_layout(new LegendLayout(q)),
             {
                 Q_UNUSED(domain)
-                QList<LegendMarker*> markers = series->d_ptr->createLegendMarker(q_ptr);
+                QList<LegendMarker *> markers = series->d_ptr->createLegendMarker(q_ptr);
                 foreach (LegendMarker *marker, markers) {
                     marker->setFont(m_font);
             void QLegendPrivate::handleSeriesVisibleChanged()
             {
-                QAbstractSeries* series = qobject_cast<QAbstractSeries *> (sender());
+                QAbstractSeries *series = qobject_cast<QAbstractSeries *> (sender());
                 Q_ASSERT(series);
                 foreach (LegendMarker *marker, m_markers) {
             void QLegendPrivate::handleCountChanged()
             {
-                QAbstractSeriesPrivate* series = qobject_cast<QAbstractSeriesPrivate *> (sender());
+                QAbstractSeriesPrivate *series = qobject_cast<QAbstractSeriesPrivate *> (sender());
                 Q_ASSERT(series);
                 handleSeriesRemoved(series->q_ptr);
                 handleSeriesAdded(series->q_ptr, 0);

src/legend/qlegend_p.h +5 -5

                 QPointF offset() const;
                 int roundness(qreal size);
-                QList<LegendMarker*> markers() { return m_markers; }
+                QList<LegendMarker *> markers() { return m_markers; }
-                QGraphicsItemGroup* items() { return m_items; }
+                QGraphicsItemGroup *items() { return m_items; }
             public Q_SLOTS:
                 void handleSeriesAdded(QAbstractSeries *series, Domain *domain);
                 QLegend *q_ptr;
                 ChartPresenter *m_presenter;
                 LegendLayout *m_layout;
-                QChart* m_chart;
+                QChart *m_chart;
-                QGraphicsItemGroup* m_items;
+                QGraphicsItemGroup *m_items;
-                QList<LegendMarker*> m_markers;
+                QList<LegendMarker *> m_markers;
                 Qt::Alignment m_alignment;
                 QBrush m_brush;
                 QPen m_pen;

src/linechart/linechartitem.cpp +1 -1

             const qreal mouseEventMinWidth(12);
-            LineChartItem::LineChartItem(QLineSeries* series, ChartPresenter *presenter)
+            LineChartItem::LineChartItem(QLineSeries *series, ChartPresenter *presenter)
                 : XYChart(series, presenter),
                   QGraphicsItem(presenter ? presenter->rootItem() : 0),
                   m_series(series),

src/linechart/linechartitem_p.h +1 -1

                 void mousePressEvent(QGraphicsSceneMouseEvent *event);
             private:
-                QLineSeries* m_series;
+                QLineSeries *m_series;
                 QPainterPath m_path;
                 QPainterPath m_linePath;
                 QVector<QPointF> m_points;

src/linechart/qlineseries.cpp +4 -3

             ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-            QLineSeriesPrivate::QLineSeriesPrivate(QLineSeries* q): QXYSeriesPrivate(q)
+            QLineSeriesPrivate::QLineSeriesPrivate(QLineSeries *q)
+                : QXYSeriesPrivate(q)
             {
             };
-            ChartElement* QLineSeriesPrivate::createGraphics(ChartPresenter* presenter)
+            ChartElement *QLineSeriesPrivate::createGraphics(ChartPresenter *presenter)
             {
                 Q_Q(QLineSeries);
-                LineChartItem* line = new LineChartItem(q, presenter);
+                LineChartItem *line = new LineChartItem(q, presenter);
                 if (presenter->animationOptions().testFlag(QChart::SeriesAnimations))
                     line->setAnimation(new XYAnimation(line));
                 presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));

src/linechart/qlineseries_p.h +2 -3

             class QLineSeriesPrivate: public QXYSeriesPrivate
             {
             public:
-                QLineSeriesPrivate(QLineSeries* q);
+                QLineSeriesPrivate(QLineSeries *q);
-                ChartElement* createGraphics(ChartPresenter* presenter);
+                ChartElement *createGraphics(ChartPresenter *presenter);
             private:
                 Q_DECLARE_PUBLIC(QLineSeries);
             };
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/piechartitem.cpp +10 -10

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            PieChartItem::PieChartItem(QPieSeries *series, ChartPresenter* presenter)
+            PieChartItem::PieChartItem(QPieSeries *series, ChartPresenter *presenter)
                 : ChartItem(presenter),
                   m_series(series),
                   m_animation(0)
                 // slices deleted automatically through QGraphicsItem
             }
-            void PieChartItem::setAnimation(PieAnimation* animation)
+            void PieChartItem::setAnimation(PieAnimation *animation)
             {
                 m_animation = animation;
             }
-            ChartAnimation* PieChartItem::animation() const
+            ChartAnimation *PieChartItem::animation() const
             {
                 return m_animation;
             }
-            void PieChartItem::handleGeometryChanged(const QRectF& rect)
+            void PieChartItem::handleGeometryChanged(const QRectF &rect)
             {
                 prepareGeometryChange();
                 m_rect = rect;
                 update();
             }
-            void PieChartItem::handleSlicesAdded(QList<QPieSlice*> slices)
+            void PieChartItem::handleSlicesAdded(QList<QPieSlice *> slices)
             {
                 // delay creating slice items until there is a proper rectangle
                 if (!m_rect.isValid() && m_sliceItems.isEmpty())
                 bool startupAnimation = m_sliceItems.isEmpty();
-                foreach (QPieSlice *slice, slices) {
+                foreach(QPieSlice * slice, slices) {
-                    PieSliceItem* sliceItem = new PieSliceItem(this);
+                    PieSliceItem *sliceItem = new PieSliceItem(this);
                     m_sliceItems.insert(slice, sliceItem);
                     // Note: no need to connect to slice valueChanged() etc.
                 }
             }
-            void PieChartItem::handleSlicesRemoved(QList<QPieSlice*> slices)
+            void PieChartItem::handleSlicesRemoved(QList<QPieSlice *> slices)
             {
                 presenter()->chartTheme()->decorate(m_series, presenter()->dataSet()->seriesIndex(m_series));
             void PieChartItem::handleSliceChanged()
             {
-                QPieSlice* slice = qobject_cast<QPieSlice *>(sender());
+                QPieSlice *slice = qobject_cast<QPieSlice *>(sender());
                 if (!slice) {
-                    QPieSlicePrivate* slicep = qobject_cast<QPieSlicePrivate *>(sender());
+                    QPieSlicePrivate *slicep = qobject_cast<QPieSlicePrivate *>(sender());
                     slice = slicep->q_ptr;
                 }
                 Q_ASSERT(m_sliceItems.contains(slice));

src/piechart/piechartitem_p.h +6 -6

                 virtual void rangeYChanged(qreal min, qreal max, int tickYCount);
                 void updateLayout();
-                void handleSlicesAdded(QList<QPieSlice*> slices);
+                void handleSlicesAdded(QList<QPieSlice *> slices);
-                void handleSlicesRemoved(QList<QPieSlice*> slices);
+                void handleSlicesRemoved(QList<QPieSlice *> slices);
                 void handleSliceChanged();
                 void handleSeriesVisibleChanged();
                 void handleOpacityChanged();
-                void setAnimation(PieAnimation* animation);
+                void setAnimation(PieAnimation *animation);
-                ChartAnimation* animation() const;
+                ChartAnimation *animation() const;
             private:
                 PieSliceData updateSliceGeometry(QPieSlice *slice);
             private:
-                QHash<QPieSlice*, PieSliceItem*> m_sliceItems;
+                QHash<QPieSlice *, PieSliceItem *> m_sliceItems;
                 QPieSeries *m_series;
                 QRectF m_rect;
                 QPointF m_pieCenter;
                 qreal m_pieRadius;
                 qreal m_holeSize;
-                PieAnimation* m_animation;
+                PieAnimation *m_animation;
             };

src/piechart/pieslicedata_p.h +2 -3

             class Themed : public T
             {
             public:
-                Themed():m_isThemed(true) {}
+                Themed(): m_isThemed(true) {}
                 inline T &operator=(const T &other) { return T::operator =(other); }
                 {
                 }
-                bool operator!=(const PieSliceData &other) const
+                bool operator!=(const PieSliceData &other) const {
                     if (!qFuzzyIsNull(m_value - other.m_value))
                         return true;

src/piechart/piesliceitem.cpp +5 -5

                 return QPointF(dx, -dy);
             }
-            PieSliceItem::PieSliceItem(QGraphicsItem* parent)
+            PieSliceItem::PieSliceItem(QGraphicsItem *parent)
                 : QGraphicsObject(parent),
                   m_hovered(false)
             {
                 return m_slicePath;
             }
-            void PieSliceItem::paint(QPainter* painter, const QStyleOptionGraphicsItem* /*option*/, QWidget* /*widget*/)
+            void PieSliceItem::paint(QPainter *painter, const QStyleOptionGraphicsItem * /*option*/, QWidget * /*widget*/)
             {
                 painter->save();
                 painter->setClipRect(parentItem()->boundingRect());
                 }
             }
-            void PieSliceItem::hoverEnterEvent(QGraphicsSceneHoverEvent* /*event*/)
+            void PieSliceItem::hoverEnterEvent(QGraphicsSceneHoverEvent * /*event*/)
             {
                 m_hovered = true;
                 emit hovered(true);
             }
-            void PieSliceItem::hoverLeaveEvent(QGraphicsSceneHoverEvent* /*event*/)
+            void PieSliceItem::hoverLeaveEvent(QGraphicsSceneHoverEvent * /*event*/)
             {
                 m_hovered = false;
                 emit hovered(false);
                 return point;
             }
-            QPainterPath PieSliceItem::slicePath(QPointF center, qreal radius, qreal startAngle, qreal angleSpan, qreal *centerAngle, QPointF* armStart)
+            QPainterPath PieSliceItem::slicePath(QPointF center, qreal radius, qreal startAngle, qreal angleSpan, qreal *centerAngle, QPointF *armStart)
             {
                 // calculate center angle
                 *centerAngle = startAngle + (angleSpan / 2);

src/piechart/piesliceitem_p.h +1 -1

                 Q_OBJECT
             public:
-                PieSliceItem(QGraphicsItem* parent = 0);
+                PieSliceItem(QGraphicsItem *parent = 0);
                 ~PieSliceItem();
                 // from QGraphicsItem

src/piechart/qhpiemodelmapper.cpp +2 -2

                 setOrientation(Qt::Horizontal);
             }
-            QAbstractItemModel* QHPieModelMapper::model() const
+            QAbstractItemModel *QHPieModelMapper::model() const
             {
                 return QPieModelMapper::model();
             }
                 }
             }
-            QPieSeries* QHPieModelMapper::series() const
+            QPieSeries *QHPieModelMapper::series() const
             {
                 return QPieModelMapper::series();
             }

src/piechart/qhpiemodelmapper.h +2 -2

             public:
                 explicit QHPieModelMapper(QObject *parent = 0);
-                QAbstractItemModel* model() const;
+                QAbstractItemModel *model() const;
                 void setModel(QAbstractItemModel *model);
-                QPieSeries* series() const;
+                QPieSeries *series() const;
                 void setSeries(QPieSeries *series);
                 int valuesRow() const;

src/piechart/qpiemodelmapper.cpp +5 -5

             {
             }
-            QAbstractItemModel* QPieModelMapper::model() const
+            QAbstractItemModel *QPieModelMapper::model() const
             {
                 Q_D(const QPieModelMapper);
                 return d->m_model;
                 connect(d->m_model, SIGNAL(destroyed()), d, SLOT(handleModelDestroyed()));
             }
-            QPieSeries* QPieModelMapper::series() const
+            QPieSeries *QPieModelMapper::series() const
             {
                 Q_D(const QPieModelMapper);
                 return d->m_series;
             }
-            QPieSlice* QPieModelMapperPrivate::pieSlice(QModelIndex index) const
+            QPieSlice *QPieModelMapperPrivate::pieSlice(QModelIndex index) const
             {
                 if (!index.isValid())
                     return 0; // index is invalid
                 return false;
             }
-            void QPieModelMapperPrivate::slicesAdded(QList<QPieSlice*> slices)
+            void QPieModelMapperPrivate::slicesAdded(QList<QPieSlice *> slices)
             {
                 if (m_seriesSignalsBlock)
                     return;
                 blockModelSignals(false);
             }
-            void QPieModelMapperPrivate::slicesRemoved(QList<QPieSlice*> slices)
+            void QPieModelMapperPrivate::slicesRemoved(QList<QPieSlice *> slices)
             {
                 if (m_seriesSignalsBlock)
                     return;

src/piechart/qpiemodelmapper.h +2 -2

             protected:
                 explicit QPieModelMapper(QObject *parent = 0);
-                QAbstractItemModel* model() const;
+                QAbstractItemModel *model() const;
                 void setModel(QAbstractItemModel *model);
-                QPieSeries* series() const;
+                QPieSeries *series() const;
                 void setSeries(QPieSeries *series);
                 int first() const;

src/piechart/qpiemodelmapper_p.h +4 -4

                 void handleModelDestroyed();
                 // for the series
-                void slicesAdded(QList<QPieSlice*> slices);
+                void slicesAdded(QList<QPieSlice *> slices);
-                void slicesRemoved(QList<QPieSlice*> slices);
+                void slicesRemoved(QList<QPieSlice *> slices);
                 void sliceLabelChanged();
                 void sliceValueChanged();
                 void handleSeriesDestroyed();
                 void initializePieFromModel();
             private:
-                QPieSlice* pieSlice(QModelIndex index) const;
+                QPieSlice *pieSlice(QModelIndex index) const;
                 bool isLabelIndex(QModelIndex index) const;
                 bool isValueIndex(QModelIndex index) const;
                 QModelIndex valueModelIndex(int slicePos);
             private:
                 QPieSeries *m_series;
-                QList<QPieSlice*> m_slices;
+                QList<QPieSlice *> m_slices;
                 QAbstractItemModel *m_model;
                 int m_first;
                 int m_count;

src/piechart/qpieseries.cpp +24 -24

                 Returns true if append was succesfull.
             */
-            bool QPieSeries::append(QPieSlice* slice)
+            bool QPieSeries::append(QPieSlice *slice)
             {
-                return append(QList<QPieSlice*>() << slice);
+                return append(QList<QPieSlice *>() << slice);
             }
             /*!
                 Returns true if append was successful.
             */
-            bool QPieSeries::append(QList<QPieSlice*> slices)
+            bool QPieSeries::append(QList<QPieSlice *> slices)
             {
                 Q_D(QPieSeries);
                 Appends a single \a slice to the series and returns a reference to the series.
                 Slice ownership is passed to the series.
             */
-            QPieSeries& QPieSeries::operator << (QPieSlice* slice)
+            QPieSeries &QPieSeries::operator << (QPieSlice *slice)
             {
                 append(slice);
                 return *this;
                 Appends a single slice to the series with give \a value and \a label.
                 Slice ownership is passed to the series.
             */
-            QPieSlice* QPieSeries::append(QString label, qreal value)
+            QPieSlice *QPieSeries::append(QString label, qreal value)
             {
-                QPieSlice* slice = new QPieSlice(label, value);
+                QPieSlice *slice = new QPieSlice(label, value);
                 append(slice);
                 return slice;
             }
                 Returns true if insert was successful.
             */
-            bool QPieSeries::insert(int index, QPieSlice* slice)
+            bool QPieSeries::insert(int index, QPieSlice *slice)
             {
                 Q_D(QPieSeries);
                 connect(slice, SIGNAL(hovered(bool)), d, SLOT(sliceHovered(bool)));
-                emit added(QList<QPieSlice*>() << slice);
+                emit added(QList<QPieSlice *>() << slice);
                 emit countChanged();
                 return true;
                 Returns true if remove was successful.
             */
-            bool QPieSeries::remove(QPieSlice* slice)
+            bool QPieSeries::remove(QPieSlice *slice)
             {
                 Q_D(QPieSeries);
                 d->updateDerivativeData();
-                emit removed(QList<QPieSlice*>() << slice);
+                emit removed(QList<QPieSlice *>() << slice);
                 emit countChanged();
                 delete slice;
                 Returns true if take was successful.
             */
-            bool QPieSeries::take(QPieSlice* slice)
+            bool QPieSeries::take(QPieSlice *slice)
             {
                 Q_D(QPieSeries);
                 d->updateDerivativeData();
-                emit removed(QList<QPieSlice*>() << slice);
+                emit removed(QList<QPieSlice *>() << slice);
                 emit countChanged();
                 return true;
                 if (d->m_slices.count() == 0)
                     return;
-                QList<QPieSlice*> slices = d->m_slices;
+                QList<QPieSlice *> slices = d->m_slices;
                 foreach (QPieSlice *s, d->m_slices)
                     d->m_slices.removeOne(s);
             /*!
                 Returns a list of slices that belong to this series.
             */
-            QList<QPieSlice*> QPieSeries::slices() const
+            QList<QPieSlice *> QPieSeries::slices() const
             {
                 Q_D(const QPieSeries);
                 return d->m_slices;
                 // update slice attributes
                 qreal sliceAngle = m_pieStartAngle;
                 qreal pieSpan = m_pieEndAngle - m_pieStartAngle;
-                QVector<QPieSlice*> changed;
+                QVector<QPieSlice *> changed;
                 foreach (QPieSlice *s, m_slices) {
                     QPieSlicePrivate *d = QPieSlicePrivate::fromSlice(s);
                     d->setPercentage(s->value() / m_sum);
                     emit pieSizeChanged();
             }
-            QPieSeriesPrivate* QPieSeriesPrivate::fromSeries(QPieSeries *series)
+            QPieSeriesPrivate *QPieSeriesPrivate::fromSeries(QPieSeries *series)
             {
                 return series->d_func();
             }
             void QPieSeriesPrivate::sliceClicked()
             {
-                QPieSlice* slice = qobject_cast<QPieSlice *>(sender());
+                QPieSlice *slice = qobject_cast<QPieSlice *>(sender());
                 Q_ASSERT(m_slices.contains(slice));
                 Q_Q(QPieSeries);
                 emit q->clicked(slice);
             void QPieSeriesPrivate::sliceHovered(bool state)
             {
-                QPieSlice* slice = qobject_cast<QPieSlice *>(sender());
+                QPieSlice *slice = qobject_cast<QPieSlice *>(sender());
                 Q_ASSERT(m_slices.contains(slice));
                 Q_Q(QPieSeries);
                 emit q->hovered(slice, state);
             }
-            void QPieSeriesPrivate::scaleDomain(Domain& domain)
+            void QPieSeriesPrivate::scaleDomain(Domain &domain)
             {
                 Q_UNUSED(domain);
                 // does not apply to pie
             }
-            ChartElement* QPieSeriesPrivate::createGraphics(ChartPresenter* presenter)
+            ChartElement *QPieSeriesPrivate::createGraphics(ChartPresenter *presenter)
             {
                 Q_Q(QPieSeries);
-                PieChartItem* pie = new PieChartItem(q, presenter);
+                PieChartItem *pie = new PieChartItem(q, presenter);
                 if (presenter->animationOptions().testFlag(QChart::SeriesAnimations))
                     pie->setAnimation(new PieAnimation(pie));
                 presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
                 return pie;
             }
-            QList<LegendMarker*> QPieSeriesPrivate::createLegendMarker(QLegend* legend)
+            QList<LegendMarker *> QPieSeriesPrivate::createLegendMarker(QLegend *legend)
             {
                 Q_Q(QPieSeries);
-                QList<LegendMarker*> markers;
+                QList<LegendMarker *> markers;
                 foreach (QPieSlice *slice, q->slices()) {
                     PieLegendMarker* marker = new PieLegendMarker(q, slice, legend);
                     markers << marker;
                 return markers;
             }
-            void QPieSeriesPrivate::initializeAxis(QAbstractAxis* axis)
+            void QPieSeriesPrivate::initializeAxis(QAbstractAxis *axis)
             {
                 Q_UNUSED(axis);
             }

src/piechart/qpieseries.h +12 -12

                 QAbstractSeries::SeriesType type() const;
-                bool append(QPieSlice* slice);
+                bool append(QPieSlice *slice);
-                bool append(QList<QPieSlice*> slices);
+                bool append(QList<QPieSlice *> slices);
-                QPieSeries& operator << (QPieSlice* slice);
+                QPieSeries &operator << (QPieSlice *slice);
-                QPieSlice* append(QString label, qreal value);
+                QPieSlice *append(QString label, qreal value);
-                bool insert(int index, QPieSlice* slice);
+                bool insert(int index, QPieSlice *slice);
-                bool remove(QPieSlice* slice);
+                bool remove(QPieSlice *slice);
-                bool take(QPieSlice* slice);
+                bool take(QPieSlice *slice);
                 void clear();
-                QList<QPieSlice*> slices() const;
+                QList<QPieSlice *> slices() const;
                 int count() const;
                 bool isEmpty() const;
                 void setLabelsPosition(QPieSlice::LabelPosition position);
             Q_SIGNALS:
-                void added(QList<QPieSlice*> slices);
+                void added(QList<QPieSlice *> slices);
-                void removed(QList<QPieSlice*> slices);
+                void removed(QList<QPieSlice *> slices);
-                void clicked(QPieSlice* slice);
+                void clicked(QPieSlice *slice);
-                void hovered(QPieSlice* slice, bool state);
+                void hovered(QPieSlice *slice, bool state);
                 void countChanged();
                 void sumChanged();

src/piechart/qpieseries_p.h +6 -6

                 QPieSeriesPrivate(QPieSeries *parent);
                 ~QPieSeriesPrivate();
-                void scaleDomain(Domain& domain);
+                void scaleDomain(Domain &domain);
-                ChartElement* createGraphics(ChartPresenter *presenter);
+                ChartElement *createGraphics(ChartPresenter *presenter);
-                QList<LegendMarker*> createLegendMarker(QLegend *legend);
+                QList<LegendMarker *> createLegendMarker(QLegend *legend);
-                void initializeAxis(QAbstractAxis* axis);
+                void initializeAxis(QAbstractAxis *axis);
                 QAbstractAxis::AxisType defaultAxisType(Qt::Orientation orientation) const;
                 void updateDerivativeData();
                 void setSizes(qreal innerSize, qreal outerSize);
-                static QPieSeriesPrivate* fromSeries(QPieSeries *series);
+                static QPieSeriesPrivate *fromSeries(QPieSeries *series);
             signals:
                 void calculatedDataChanged();
                 void sliceHovered(bool state);
             private:
-                QList<QPieSlice*> m_slices;
+                QList<QPieSlice *> m_slices;
                 qreal m_pieRelativeHorPos;
                 qreal m_pieRelativeVerPos;
                 qreal m_pieRelativeSize;

src/piechart/qpieslice_p.h +1 -1

                 QPieSlicePrivate(QPieSlice *parent);
                 ~QPieSlicePrivate();
-                static QPieSlicePrivate* fromSlice(QPieSlice *slice);
+                static QPieSlicePrivate *fromSlice(QPieSlice *slice);
                 void setPen(const QPen &pen, bool themed);
                 void setBrush(const QBrush &brush, bool themed);

src/piechart/qvpiemodelmapper.cpp +2 -2

                 QPieModelMapper::setOrientation(Qt::Vertical);
             }
-            QAbstractItemModel* QVPieModelMapper::model() const
+            QAbstractItemModel *QVPieModelMapper::model() const
             {
                 return QPieModelMapper::model();
             }
                 }
             }
-            QPieSeries* QVPieModelMapper::series() const
+            QPieSeries *QVPieModelMapper::series() const
             {
                 return QPieModelMapper::series();
             }

src/piechart/qvpiemodelmapper.h +2 -2

             public:
                 explicit QVPieModelMapper(QObject *parent = 0);
-                QAbstractItemModel* model() const;
+                QAbstractItemModel *model() const;
                 void setModel(QAbstractItemModel *model);
-                QPieSeries* series() const;
+                QPieSeries *series() const;
                 void setSeries(QPieSeries *series);
                 int valuesColumn() const;

src/qabstractseries.cpp +3 -3

                     qFatal("Still binded series detected !");
             }
-            void QAbstractSeries::setName(const QString& name)
+            void QAbstractSeries::setName(const QString &name)
             {
                 if (name != d_ptr->m_name) {
                     d_ptr->m_name = name;
                 Set automatically when the series is added to the chart
                 and unset when the series is removed from the chart.
             */
-            QChart* QAbstractSeries::chart() const
+            QChart *QAbstractSeries::chart() const
             {
                 return d_ptr->m_chart;
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////
-            QAbstractSeriesPrivate::QAbstractSeriesPrivate(QAbstractSeries* q)
+            QAbstractSeriesPrivate::QAbstractSeriesPrivate(QAbstractSeries *q)
                 : q_ptr(q),
                   m_chart(0),
                   m_dataset(0),

src/qabstractseries.h +2 -2

                 ~QAbstractSeries();
                 virtual SeriesType type() const = 0;
-                void setName(const QString& name);
+                void setName(const QString &name);
                 QString name() const;
                 void setVisible(bool visible = true);
                 bool isVisible() const;
                 qreal opacity() const;
                 void setOpacity(qreal opacity);
-                QChart* chart() const;
+                QChart *chart() const;
                 void show();
                 void hide();

src/qabstractseries_p.h +4 -4

                 QAbstractSeriesPrivate(QAbstractSeries *q);
                 ~QAbstractSeriesPrivate();
-                virtual void scaleDomain(Domain& domain) = 0;
+                virtual void scaleDomain(Domain &domain) = 0;
-                virtual ChartElement* createGraphics(ChartPresenter* presenter) = 0;
+                virtual ChartElement *createGraphics(ChartPresenter *presenter) = 0;
-                virtual QList<LegendMarker*> createLegendMarker(QLegend* legend) = 0;
+                virtual QList<LegendMarker *> createLegendMarker(QLegend *legend) = 0;
-                virtual void initializeAxis(QAbstractAxis* axis) = 0;
+                virtual void initializeAxis(QAbstractAxis *axis) = 0;
                 virtual QAbstractAxis::AxisType defaultAxisType(Qt::Orientation) const = 0;
             Q_SIGNALS:

src/qchart.cpp +13 -12

             /*!
              Sets the \a brush that is used for painting the background of the chart area.
              */
-            void QChart::setBackgroundBrush(const QBrush& brush)
+            void QChart::setBackgroundBrush(const QBrush &brush)
             {
                 d_ptr->m_presenter->setBackgroundBrush(brush);
             }
             /*!
              Sets the \a pen that is used for painting the background of the chart area.
              */
-            void QChart::setBackgroundPen(const QPen& pen)
+            void QChart::setBackgroundPen(const QPen &pen)
             {
                 d_ptr->m_presenter->setBackgroundPen(pen);
             }
             /*!
              Sets the chart \a title. The description text that is drawn above the chart.
              */
-            void QChart::setTitle(const QString& title)
+            void QChart::setTitle(const QString &title)
             {
                 d_ptr->m_presenter->setTitle(title);
             }
             /*!
              Sets the \a font that is used for drawing the chart description text that is rendered above the chart.
              */
-            void QChart::setTitleFont(const QFont& font)
+            void QChart::setTitleFont(const QFont &font)
             {
                 d_ptr->m_presenter->setTitleFont(font);
             }
             /*!
              Zooms in the view to a maximum level at which \a rect is still fully visible.
              */
-            void QChart::zoomIn(const QRectF& rect)
+            void QChart::zoomIn(const QRectF &rect)
             {
-                if (!rect.isValid()) return;
+                if (!rect.isValid())
+                    return;
                 d_ptr->m_presenter->zoomIn(rect);
             }
              Returns the pointer to the x axis object of the chart asociated with the specified \a series
              If no series is provided then pointer to currently visible axis is provided
              */
-            QAbstractAxis* QChart::axisX(QAbstractSeries* series) const
+            QAbstractAxis *QChart::axisX(QAbstractSeries *series) const
             {
                 return d_ptr->m_dataset->axisX(series);
             }
              Returns the pointer to the y axis object of the chart asociated with the specified \a series
              If no series is provided then pointer to currently visible axis is provided
              */
-            QAbstractAxis* QChart::axisY(QAbstractSeries *series) const
+            QAbstractAxis *QChart::axisY(QAbstractSeries *series) const
             {
                 return d_ptr->m_dataset->axisY(series);
             }
             /*!
              Returns the legend object of the chart. Ownership stays in chart.
              */
-            QLegend* QChart::legend() const
+            QLegend *QChart::legend() const
             {
                 return d_ptr->m_legend;
             }
             /*!
               Sets the minimum \a margins between the plot area (axes) and the edge of the chart widget.
             */
-            void QChart::setMargins(const QMargins& margins)
+            void QChart::setMargins(const QMargins &margins)
             {
                 d_ptr->m_presenter->setMargins(margins);
             }
               \sa addSeries(), removeSeries(), removeAllSeries()
             */
-            QList<QAbstractSeries*> QChart::series() const
+            QList<QAbstractSeries *> QChart::series() const
             {
                 return d_ptr->m_dataset->series();
             }
                \sa axisX(), axisY(), setAxisY(), createDefaultAxes()
             */
-            void QChart::setAxisX(QAbstractAxis* axis , QAbstractSeries *series)
+            void QChart::setAxisX(QAbstractAxis *axis , QAbstractSeries *series)
             {
                 d_ptr->m_dataset->setAxis(series, axis, Qt::Horizontal);
             }

src/qchart.h +9 -9

                 void addSeries(QAbstractSeries *series);
                 void removeSeries(QAbstractSeries *series);
                 void removeAllSeries();
-                QList<QAbstractSeries*> series() const;
+                QList<QAbstractSeries *> series() const;
-                void setAxisX(QAbstractAxis* axis, QAbstractSeries *series = 0);
+                void setAxisX(QAbstractAxis *axis, QAbstractSeries *series = 0);
-                void setAxisY(QAbstractAxis* axis, QAbstractSeries *series = 0);
+                void setAxisY(QAbstractAxis *axis, QAbstractSeries *series = 0);
-                QAbstractAxis* axisX(QAbstractSeries* series = 0) const;
+                QAbstractAxis *axisX(QAbstractSeries *series = 0) const;
-                QAbstractAxis* axisY(QAbstractSeries* series = 0) const;
+                QAbstractAxis *axisY(QAbstractSeries *series = 0) const;
                 void createDefaultAxes();
                 void setTheme(QChart::ChartTheme theme);
                 QChart::ChartTheme theme() const;
-                void setTitle(const QString& title);
+                void setTitle(const QString &title);
                 QString title() const;
-                void setTitleFont(const QFont& font);
+                void setTitleFont(const QFont &font);
                 QFont titleFont() const;
                 void setTitleBrush(const QBrush &brush);
                 QBrush titleBrush() const;
                 void zoom(qreal factor);
                 void scroll(qreal dx, qreal dy);
-                QLegend* legend() const;
+                QLegend *legend() const;
-                void setMargins(const QMargins& margins);
+                void setMargins(const QMargins &margins);
                 QMargins margins() const;
                 QRectF plotArea() const;

src/qchart_p.h +1 -1

             {
                 QChartPrivate();
                 ~QChartPrivate();
-                QLegend* m_legend;
+                QLegend *m_legend;
                 ChartDataSet *m_dataset;
                 ChartPresenter *m_presenter;

src/qchartglobal.h +2 -2

                 va_start(valist, numargs);
                 //for( int i = 0 ; i < numargs; i++ )
                 int line = va_arg(valist, int);
-                char* file = va_arg(valist, char*);
+                char *file = va_arg(valist, char *);
-                char* function = va_arg(valist, char*);
+                char *function = va_arg(valist, char *);
                 va_end(valist);
                 return qDebug() << QString().append(function).append("(").append(file).append(":%1)").arg(line);
             }

src/qchartview.cpp +3 -3

             /*!
                 Returns the pointer to the associated chart
             */
-            QChart* QChartView::chart() const
+            QChart *QChartView::chart() const
             {
                 return d_ptr->m_chart;
             }
             /*!
                 Sets the RubberBandPlicy to \a rubberBand. Selected policy determines the way zooming is performed.
             */
-            void QChartView::setRubberBand(const RubberBands& rubberBand)
+            void QChartView::setRubberBand(const RubberBands &rubberBand)
             {
                 d_ptr->m_rubberBandFlags = rubberBand;
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-            QChartViewPrivate::QChartViewPrivate(QChartView *q, QChart* chart)
+            QChartViewPrivate::QChartViewPrivate(QChartView *q, QChart *chart)
                 : q_ptr(q),
                   m_scene(new QGraphicsScene(q)),
                   m_chart(chart),

src/qchartview.h +74 -74

@@ -1,74 +1,74
1	/****************************************************************************	1	/****************************************************************************
2	**	2	**
3	** Copyright (C) 2012 Digia Plc	3	** Copyright (C) 2012 Digia Plc
4	** All rights reserved.	4	** All rights reserved.
5	** For any questions to Digia, please use contact form at http://qt.digia.com	5	** For any questions to Digia, please use contact form at http://qt.digia.com
6	**	6	**
7	** This file is part of the Qt Commercial Charts Add-on.	7	** This file is part of the Qt Commercial Charts Add-on.
8	**	8	**
9	** $QT_BEGIN_LICENSE$	9	** $QT_BEGIN_LICENSE$
10	** Licensees holding valid Qt Commercial licenses may use this file in	10	** Licensees holding valid Qt Commercial licenses may use this file in
11	** accordance with the Qt Commercial License Agreement provided with the	11	** accordance with the Qt Commercial License Agreement provided with the
12	** Software or, alternatively, in accordance with the terms contained in	12	** Software or, alternatively, in accordance with the terms contained in
13	** a written agreement between you and Digia.	13	** a written agreement between you and Digia.
14	**	14	**
15	** If you have questions regarding the use of this file, please use	15	** If you have questions regarding the use of this file, please use
16	** contact form at http://qt.digia.com	16	** contact form at http://qt.digia.com
17	** $QT_END_LICENSE$	17	** $QT_END_LICENSE$
18	**	18	**
19	****************************************************************************/	19	****************************************************************************/
20		20
21	#ifndef QCHARTVIEW_H	21	#ifndef QCHARTVIEW_H
22	#define QCHARTVIEW_H	22	#define QCHARTVIEW_H
23		23
24	#include <QAbstractAxis>	24	#include <QAbstractAxis>
25	#include <QAbstractSeries>	25	#include <QAbstractSeries>
26	#include <QChart>	26	#include <QChart>
27	#include <QGraphicsView>	27	#include <QGraphicsView>
28		28
29	class QGraphicsScene;	29	class QGraphicsScene;
30	class QRubberBand;	30	class QRubberBand;
31		31
32	QTCOMMERCIALCHART_BEGIN_NAMESPACE	32	QTCOMMERCIALCHART_BEGIN_NAMESPACE
33		33
34	class QChartViewPrivate;	34	class QChartViewPrivate;
35		35
36	class QTCOMMERCIALCHART_EXPORT QChartView : public QGraphicsView	36	class QTCOMMERCIALCHART_EXPORT QChartView : public QGraphicsView
37	{	37	{
38	Q_OBJECT	38	Q_OBJECT
39	Q_ENUMS(RubberBand)	39	Q_ENUMS(RubberBand)
40	public:	40	public:
41		41
42	enum RubberBand {	42	enum RubberBand {
43	NoRubberBand = 0x0,	43	NoRubberBand = 0x0,
44	VerticalRubberBand = 0x1,	44	VerticalRubberBand = 0x1,
45	HorizonalRubberBand = 0x2,	45	HorizonalRubberBand = 0x2,
46	RectangleRubberBand = 0x3	46	RectangleRubberBand = 0x3
47	};	47	};
48		48
49	Q_DECLARE_FLAGS(RubberBands, RubberBand)	49	Q_DECLARE_FLAGS(RubberBands, RubberBand)
50		50
51	explicit QChartView(QWidget *parent = 0);	51	explicit QChartView(QWidget *parent = 0);
52	explicit QChartView(QChart chart, QWidget parent = 0);	52	explicit QChartView(QChart chart, QWidget parent = 0);
53	~QChartView();	53	~QChartView();
54		54
55	void setRubberBand(const RubberBands& rubberBands);	55	void setRubberBand(const RubberBands &rubberBands);
56	RubberBands rubberBand() const;	56	RubberBands rubberBand() const;
57		57
58	QChart* chart() const;	58	QChart *chart() const;
59	void setChart(QChart *chart);	59	void setChart(QChart *chart);
60		60
61	protected:	61	protected:
62	void resizeEvent(QResizeEvent *event);	62	void resizeEvent(QResizeEvent *event);
63	void mousePressEvent(QMouseEvent *event);	63	void mousePressEvent(QMouseEvent *event);
64	void mouseMoveEvent(QMouseEvent *event);	64	void mouseMoveEvent(QMouseEvent *event);
65	void mouseReleaseEvent(QMouseEvent *event);	65	void mouseReleaseEvent(QMouseEvent *event);
66		66
67	protected:	67	protected:
68	QScopedPointer<QChartViewPrivate> d_ptr;	68	QScopedPointer<QChartViewPrivate> d_ptr;
69	Q_DISABLE_COPY(QChartView)	69	Q_DISABLE_COPY(QChartView)
70	};	70	};
71		71
72	QTCOMMERCIALCHART_END_NAMESPACE	72	QTCOMMERCIALCHART_END_NAMESPACE
73		73
74	#endif // QCHARTVIEW_H	74	#endif // QCHARTVIEW_H

src/scatterchart/qscatterseries.cpp +5 -5

             ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-            QScatterSeriesPrivate::QScatterSeriesPrivate(QScatterSeries* q) :
+            QScatterSeriesPrivate::QScatterSeriesPrivate(QScatterSeries *q)
-                QXYSeriesPrivate(q),
+                : QXYSeriesPrivate(q),
-                m_shape(QScatterSeries::MarkerShapeCircle),
+                  m_shape(QScatterSeries::MarkerShapeCircle),
-                m_size(15.0)
+                  m_size(15.0)
             {
             }
-            ChartElement* QScatterSeriesPrivate::createGraphics(ChartPresenter* presenter)
+            ChartElement *QScatterSeriesPrivate::createGraphics(ChartPresenter *presenter)
             {
                 Q_Q(QScatterSeries);
                 ScatterChartItem *scatter = new ScatterChartItem(q, presenter);

src/scatterchart/qscatterseries_p.h +2 -2

             class QScatterSeriesPrivate: public QXYSeriesPrivate
             {
             public:
-                QScatterSeriesPrivate(QScatterSeries* q);
+                QScatterSeriesPrivate(QScatterSeries *q);
-                ChartElement* createGraphics(ChartPresenter* presenter);
+                ChartElement *createGraphics(ChartPresenter *presenter);
             private:
                 QScatterSeries::MarkerShape m_shape;

src/scatterchart/scatterchartitem.cpp +9 -10

                     switch (m_shape) {
                     case QScatterSeries::MarkerShapeCircle: {
                         item = new CircleMarker(0, 0, m_size, m_size, this);
-                        const QRectF& rect = item->boundingRect();
+                        const QRectF &rect = item->boundingRect();
                         item->setPos(-rect.width() / 2, -rect.height() / 2);
                         break;
                         }
-                    case QScatterSeries::MarkerShapeRectangle: {
+                    case QScatterSeries::MarkerShapeRectangle:
                         item = new RectangleMarker(0, 0, m_size, m_size, this);
                         item->setPos(-m_size / 2, -m_size / 2);
                         break;
                     default:
                         qWarning() << "Unsupported marker type";
                         break;
                 QList<QGraphicsItem *> items = m_items.childItems();
                 for (int i = 0; i < count; ++i) {
-                    QGraphicsItem * item = items.takeLast();
+                    QGraphicsItem *item = items.takeLast();
                     m_markerMap.remove(item);
                     delete(item);
                 }
                 if (diff != 0)
                     handleUpdated();
-                QList<QGraphicsItem*> items = m_items.childItems();
+                QList<QGraphicsItem *> items = m_items.childItems();
                 for (int i = 0; i < points.size(); i++) {
-                    QGraphicsItem* item = items.at(i);
+                    QGraphicsItem *item = items.at(i);
-                    const QPointF& point = points.at(i);
+                    const QPointF &point = points.at(i);
-                    const QRectF& rect = item->boundingRect();
+                    const QRectF &rect = item->boundingRect();
                     m_markerMap[item] = point;
                     item->setPos(point.x() - rect.width() / 2, point.y() - rect.height() / 2);
                     if (!m_visible || !clipRect().contains(point))
                 Q_UNUSED(widget)
             }
-            void ScatterChartItem::setPen(const QPen& pen)
+            void ScatterChartItem::setPen(const QPen &pen)
             {
                 foreach (QGraphicsItem *item , m_items.childItems())
                     static_cast<QAbstractGraphicsShapeItem*>(item)->setPen(pen);
             }
-            void ScatterChartItem::setBrush(const QBrush& brush)
+            void ScatterChartItem::setBrush(const QBrush &brush)
             {
                 foreach (QGraphicsItem *item , m_items.childItems())
                     static_cast<QAbstractGraphicsShapeItem*>(item)->setBrush(brush);

src/scatterchart/scatterchartitem_p.h +7 -7

             {
             public:
-               CircleMarker(qreal x, qreal y, qreal w, qreal h, ScatterChartItem *parent)
+                CircleMarker(qreal x, qreal y, qreal w, qreal h, ScatterChartItem *parent)
-                : QGraphicsEllipseItem(x, y, w, h, parent),
+                    : QGraphicsEllipseItem(x, y, w, h, parent),
-                  m_parent(parent)
+                      m_parent(parent)
+                {
+                }
             protected:
                 void mousePressEvent(QGraphicsSceneMouseEvent *event)
                 }
             private:
-                ScatterChartItem* m_parent;
+                ScatterChartItem *m_parent;
             };
             class RectangleMarker: public QGraphicsRectItem
                 }
             private:
-                ScatterChartItem* m_parent;
+                ScatterChartItem *m_parent;
             };
             QTCOMMERCIALCHART_END_NAMESPACE

src/scroller.cpp +6 -6

             {
             }
-            void Scroller::mousePressEvent(QGraphicsSceneMouseEvent* event)
+            void Scroller::mousePressEvent(QGraphicsSceneMouseEvent *event)
             {
                 if (event->button() == Qt::LeftButton) {
                     switch (m_state) {
                 }
             }
-            void Scroller::mouseMoveEvent(QGraphicsSceneMouseEvent* event)
+            void Scroller::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
             {
                 QPointF delta = event->pos() - m_press;
                 }
             }
-            void Scroller::mouseReleaseEvent(QGraphicsSceneMouseEvent* event)
+            void Scroller::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
             {
                 if (event->button() == Qt::LeftButton) {
                 }
             }
-            void Scroller::lowerSpeed(QPointF& speed, qreal maxSpeed)
+            void Scroller::lowerSpeed(QPointF &speed, qreal maxSpeed)
             {
                 qreal x = qBound(-maxSpeed, speed.x(), maxSpeed);
                 qreal y = qBound(-maxSpeed, speed.y(), maxSpeed);
                 speed.setY(y);
             }
-            void Scroller::calculateSpeed(const QPointF& position)
+            void Scroller::calculateSpeed(const QPointF &position)
             {
                 if (m_timeStamp.elapsed() > m_timeTreshold) {
             /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-            ScrollTicker::ScrollTicker(Scroller *scroller, QObject* parent)
+            ScrollTicker::ScrollTicker(Scroller *scroller, QObject *parent)
                 : QObject(parent),
                   m_scroller(scroller)
             {

src/scroller_p.h +6 -6

                 Scroller();
                 virtual ~Scroller();
-                virtual void setOffset(const QPointF& point) = 0;
+                virtual void setOffset(const QPointF &point) = 0;
                 virtual QPointF offset() const = 0;
             public:
                 void scrollTick();
             public:
-                void mousePressEvent(QGraphicsSceneMouseEvent* event);
+                void mousePressEvent(QGraphicsSceneMouseEvent *event);
-                void mouseMoveEvent(QGraphicsSceneMouseEvent* event);
+                void mouseMoveEvent(QGraphicsSceneMouseEvent *event);
-                void mouseReleaseEvent(QGraphicsSceneMouseEvent* event);
+                void mouseReleaseEvent(QGraphicsSceneMouseEvent *event);
             private:
-                void calculateSpeed(const QPointF& position);
+                void calculateSpeed(const QPointF &position);
-                void lowerSpeed(QPointF& speed, qreal maxSpeed = 100);
+                void lowerSpeed(QPointF &speed, qreal maxSpeed = 100);
             private:
                 ScrollTicker m_ticker;

src/splinechart/qsplineseries.cpp +2 -2

             ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-            QSplineSeriesPrivate::QSplineSeriesPrivate(QSplineSeries* q)
+            QSplineSeriesPrivate::QSplineSeriesPrivate(QSplineSeries *q)
                 : QLineSeriesPrivate(q)
             {
             }
                 }
             }
-            ChartElement* QSplineSeriesPrivate::createGraphics(ChartPresenter* presenter)
+            ChartElement *QSplineSeriesPrivate::createGraphics(ChartPresenter *presenter)
             {
                 Q_Q(QSplineSeries);
                 SplineChartItem *spline = new SplineChartItem(q, presenter);

src/splinechart/qsplineseries_p.h +2 -2

             {
                 Q_OBJECT
             public:
-                ChartElement* createGraphics(ChartPresenter* presenter);
+                ChartElement *createGraphics(ChartPresenter *presenter);
-                QSplineSeriesPrivate(QSplineSeries* q);
+                QSplineSeriesPrivate(QSplineSeries *q);
                 QPointF controlPoint(int index) const;

src/splinechart/splinechartitem.cpp +3 -3

                 return m_path;
             }
-            void SplineChartItem::setAnimation(SplineAnimation* animation)
+            void SplineChartItem::setAnimation(SplineAnimation *animation)
             {
                 m_animation = animation;
                 XYChart::setAnimation(animation);
             }
-            ChartAnimation* SplineChartItem::animation() const
+            ChartAnimation *SplineChartItem::animation() const
             {
                 return m_animation;
             }
                 QPainterPath splinePath(points.at(0));
                 for (int i = 0; i < points.size() - 1; i++) {
-                    const QPointF& point = points.at(i + 1);
+                    const QPointF &point = points.at(i + 1);
                     splinePath.cubicTo(controlPoints[2 * i], controlPoints[2 * i + 1], point);
                 }

src/splinechart/splinechartitem_p.h +3 -3

                 void setControlGeometryPoints(QVector<QPointF>& points);
                 QVector<QPointF> controlGeometryPoints() const;
-                void setAnimation(SplineAnimation* animation);
+                void setAnimation(SplineAnimation *animation);
-                ChartAnimation* animation() const;
+                ChartAnimation *animation() const;
             public Q_SLOTS:
                 void handleUpdated();
                 QPen m_pointPen;
                 bool m_pointsVisible;
                 QVector<QPointF> m_controlPoints;
-                SplineAnimation* m_animation;
+                SplineAnimation *m_animation;
                 friend class SplineAnimation;
             };

src/xychart/qhxymodelmapper.cpp +2 -2

                 QXYModelMapper::setOrientation(Qt::Horizontal);
             }
-            QAbstractItemModel* QHXYModelMapper::model() const
+            QAbstractItemModel *QHXYModelMapper::model() const
             {
                 return QXYModelMapper::model();
             }
                 }
             }
-            QXYSeries* QHXYModelMapper::series() const
+            QXYSeries *QHXYModelMapper::series() const
             {
                 return QXYModelMapper::series();
             }

src/xychart/qhxymodelmapper.h +2 -2

             public:
                 explicit QHXYModelMapper(QObject *parent = 0);
-                QAbstractItemModel* model() const;
+                QAbstractItemModel *model() const;
                 void setModel(QAbstractItemModel *model);
-                QXYSeries* series() const;
+                QXYSeries *series() const;
                 void setSeries(QXYSeries *series);
                 int xRow() const;

src/xychart/qvxymodelmapper.cpp +2 -2

                 QXYModelMapper::setOrientation(Qt::Vertical);
             }
-            QAbstractItemModel* QVXYModelMapper::model() const
+            QAbstractItemModel *QVXYModelMapper::model() const
             {
                 return QXYModelMapper::model();
             }
                 }
             }
-            QXYSeries* QVXYModelMapper::series() const
+            QXYSeries *QVXYModelMapper::series() const
             {
                 return QXYModelMapper::series();
             }

src/xychart/qvxymodelmapper.h +2 -2

             public:
                 explicit QVXYModelMapper(QObject *parent = 0);
-                QAbstractItemModel* model() const;
+                QAbstractItemModel *model() const;
                 void setModel(QAbstractItemModel *model);
-                QXYSeries* series() const;
+                QXYSeries *series() const;
                 void setSeries(QXYSeries *series);
                 int xColumn() const;

src/xychart/qxymodelmapper.cpp +2 -2

             /*!
                 \internal
             */
-            QAbstractItemModel* QXYModelMapper::model() const
+            QAbstractItemModel *QXYModelMapper::model() const
             {
                 Q_D(const QXYModelMapper);
                 return d->m_model;
             /*!
                 \internal
             */
-            QXYSeries* QXYModelMapper::series() const
+            QXYSeries *QXYModelMapper::series() const
             {
                 Q_D(const QXYModelMapper);
                 return d->m_series;

src/xychart/qxymodelmapper.h +3 -3

             protected:
                 explicit QXYModelMapper(QObject *parent = 0);
-                QAbstractItemModel* model() const;
+                QAbstractItemModel *model() const;
                 void setModel(QAbstractItemModel *model);
-                QXYSeries* series() const;
+                QXYSeries *series() const;
                 void setSeries(QXYSeries *series);
                 int first() const;
                 void setYSection(int ySection);
             protected:
-                QXYModelMapperPrivate * const d_ptr;
+                QXYModelMapperPrivate *const d_ptr;
                 Q_DECLARE_PRIVATE(QXYModelMapper)
             };

src/xychart/qxyseries.cpp +9 -9

                 Stream operator for adding a data \a point to the series.
                 \sa append()
             */
-            QXYSeries& QXYSeries::operator<< (const QPointF &point)
+            QXYSeries &QXYSeries::operator<< (const QPointF &point)
             {
                 append(point);
                 return *this;
                 \sa append()
             */
-            QXYSeries& QXYSeries::operator<< (const QList<QPointF>& points)
+            QXYSeries &QXYSeries::operator<< (const QList<QPointF>& points)
             {
                 append(points);
                 return *this;
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-            QXYSeriesPrivate::QXYSeriesPrivate(QXYSeries *q) :
+            QXYSeriesPrivate::QXYSeriesPrivate(QXYSeries *q)
-                QAbstractSeriesPrivate(q),
+                : QAbstractSeriesPrivate(q),
-                m_pointsVisible(false)
+                  m_pointsVisible(false)
             {
             }
-            void QXYSeriesPrivate::scaleDomain(Domain& domain)
+            void QXYSeriesPrivate::scaleDomain(Domain &domain)
             {
                 qreal minX(0);
                 qreal minY(0);
                 domain.setRange(minX, maxX, minY, maxY);
             }
-            QList<LegendMarker*> QXYSeriesPrivate::createLegendMarker(QLegend* legend)
+            QList<LegendMarker *> QXYSeriesPrivate::createLegendMarker(QLegend *legend)
             {
                 Q_Q(QXYSeries);
-                QList<LegendMarker*> list;
+                QList<LegendMarker *> list;
                 return list << new XYLegendMarker(q, legend);
             }
-            void QXYSeriesPrivate::initializeAxis(QAbstractAxis* axis)
+            void QXYSeriesPrivate::initializeAxis(QAbstractAxis *axis)
             {
                 Q_UNUSED(axis);
             }

src/xychart/qxyseries.h +2 -2

                 int count() const;
                 QList<QPointF> points() const;
-                QXYSeries& operator << (const QPointF &point);
+                QXYSeries &operator << (const QPointF &point);
-                QXYSeries& operator << (const QList<QPointF> &points);
+                QXYSeries &operator << (const QList<QPointF> &points);
                 virtual void setPen(const QPen &pen);
                 QPen pen() const;

src/xychart/qxyseries_p.h +4 -4

                 Q_OBJECT
             public:
-                QXYSeriesPrivate(QXYSeries* q);
+                QXYSeriesPrivate(QXYSeries *q);
-                void scaleDomain(Domain& domain);
+                void scaleDomain(Domain &domain);
-                QList<LegendMarker*> createLegendMarker(QLegend* legend);
+                QList<LegendMarker *> createLegendMarker(QLegend *legend);
-                void initializeAxis(QAbstractAxis* axis);
+                void initializeAxis(QAbstractAxis *axis);
                 QAbstractAxis::AxisType defaultAxisType(Qt::Orientation orientation) const;
             Q_SIGNALS:

src/xychart/xychart.cpp +1 -1

                 m_clipRect = rect;
             }
-            void XYChart::setAnimation(XYAnimation* animation)
+            void XYChart::setAnimation(XYAnimation *animation)
             {
                 m_animation = animation;
             }

src/xychart/xychart_p.h +5 -5

                 QSizeF size() const { return m_size; }
                 QPointF origin() const { return m_origin; }
-                void setAnimation(XYAnimation* animation);
+                void setAnimation(XYAnimation *animation);
-                ChartAnimation* animation() const { return m_animation; }
+                ChartAnimation *animation() const { return m_animation; }
                 virtual void updateGeometry() = 0;
                 bool isDirty() const { return m_dirty; }
                 void handleGeometryChanged(const QRectF &size);
             Q_SIGNALS:
-                void clicked(const QPointF& point);
+                void clicked(const QPointF &point);
             protected:
                 virtual void updateChart(QVector<QPointF> &oldPoints, QVector<QPointF> &newPoints, int index = -1);
                 qreal m_maxX;
                 qreal m_minY;
                 qreal m_maxY;
-                QXYSeries* m_series;
+                QXYSeries *m_series;
                 QSizeF m_size;
                 QPointF m_origin;
                 QRectF m_clipRect;
                 QVector<QPointF> m_points;
-                XYAnimation* m_animation;
+                XYAnimation *m_animation;
                 bool m_dirty;
                 friend class AreaChartItem;

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