HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r2097:db3c1ea5786f

astyle and manual coding style fixes for src-folder

Jani Honkonen -

r2097:db3c1ea5786f

parent child

Context file:

r2097:db3c1ea5786f

Expand all files

src/animations/abstractbaranimation.cpp 0 0

NO CONTENT: modified file

src/animations/axisanimation.cpp +11 -7

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            AxisAnimation::AxisAnimation(ChartAxis *axis): ChartAnimation(axis),
+            AxisAnimation::AxisAnimation(ChartAxis *axis)
+                : ChartAnimation(axis),
                   m_axis(axis),
                   m_type(DefaultAnimation)
             {
             void AxisAnimation::setAnimationType(Animation type)
             {
-                if (state() != QAbstractAnimation::Stopped) stop();
+                if (state() != QAbstractAnimation::Stopped)
+                    stop();
                 m_type = type;
             }
             void AxisAnimation::setAnimationPoint(const QPointF& point)
             {
-                if (state() != QAbstractAnimation::Stopped) stop();
+                if (state() != QAbstractAnimation::Stopped)
+                    stop();
                 m_point = point;
             }
             void AxisAnimation::setValues(QVector<qreal> &oldLayout, QVector<qreal> &newLayout)
             {
-                  if (state() != QAbstractAnimation::Stopped) stop();
+                if (state() != QAbstractAnimation::Stopped)
+                    stop();
                 if (newLayout.count() == 0)
                     return;
                     }
                     break;
                 case ZoomInAnimation: {
-                      int index = qMin(oldLayout.count() * (m_axis->axisType() == ChartAxis::X_AXIS ? m_point.x() : (1 - m_point.y())), newLayout.count() - (qreal)1.0);
+                        int index = qMin(oldLayout.count() * (m_axis->axisType() == ChartAxis::X_AXIS ? m_point.x() : (1 - m_point.y())),
+                                         newLayout.count() - (qreal)1.0);
                         oldLayout.resize(newLayout.count());
                         for (int i = 0; i < oldLayout.count(); i++)
             void AxisAnimation::updateCurrentValue(const QVariant &value)
             {
-                if (state() != QAbstractAnimation::Stopped)//workaround
+                if (state() != QAbstractAnimation::Stopped) { //workaround
                     QVector<qreal> vector = qVariantValue<QVector<qreal> >(value);
                     Q_ASSERT(vector.count() != 0);
                     m_axis->setLayout(vector);

src/animations/axisanimation_p.h 0 0

NO CONTENT: modified file

src/animations/baranimation.cpp 0 0

NO CONTENT: modified file

src/animations/chartanimation_p.h 0 0

NO CONTENT: modified file

src/animations/horizontalbaranimation.cpp +2 -2

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            HorizontalBarAnimation::HorizontalBarAnimation(AbstractBarChartItem *item) :
+            HorizontalBarAnimation::HorizontalBarAnimation(AbstractBarChartItem *item)
-                AbstractBarAnimation(item)
+                : AbstractBarAnimation(item)
             {
             }

src/animations/horizontalpercentbaranimation.cpp 0 0

NO CONTENT: modified file

src/animations/horizontalstackedbaranimation.cpp 0 0

NO CONTENT: modified file

src/animations/percentbaranimation.cpp 0 0

NO CONTENT: modified file

src/animations/pieanimation.cpp 0 0

NO CONTENT: modified file

src/animations/piesliceanimation.cpp 0 0

NO CONTENT: modified file

src/animations/splineanimation.cpp +6 -15

                 x = m_oldSpline.first.count();
                 y = m_newSpline.first.count();
-                if(x != y)
+                if (x != y) {
                     m_type = NewAnimation;
+                } else if (m_type == NewAnimation) {
-                else if(m_type == NewAnimation)
                     m_type = ReplacePointAnimation;
                 }
                 SplineVector result;
                 switch (animationType()) {
                 case RemovePointAnimation:
                 case AddPointAnimation:
-                    case ReplacePointAnimation:
+                case ReplacePointAnimation: {
                         if (startPair.first.count() != endPair.first.count())
                             break;
                         Q_ASSERT(startPair.first.count() * 2 - 2 == startPair.second.count());
                             y = startPair.second[i * 2 + 1].y() + ((endPair.second[i * 2 + 1].y() - startPair.second[i * 2 + 1].y()) * progress);
                             result.second << QPointF(x, y);
                         }
                     }
                     break;
                 case NewAnimation: {
             {
                 XYAnimation::updateState(newState, oldState);
-                if(oldState == QAbstractAnimation::Running && newState == QAbstractAnimation::Stopped)
+                if (oldState == QAbstractAnimation::Running && newState == QAbstractAnimation::Stopped) {
                     if (m_item->isDirty() && m_type == RemovePointAnimation) {
                         if (!m_newSpline.first.isEmpty()) {
                             m_newSpline.first.remove(m_index);
                     }
                 }
-                if(oldState == QAbstractAnimation::Stopped && newState == QAbstractAnimation::Running)
+                if (oldState == QAbstractAnimation::Stopped && newState == QAbstractAnimation::Running) {
+                    if (!m_valid)
-                    if(!m_valid) {
                         stop();
                 }
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/animations/stackedbaranimation.cpp 0 0

NO CONTENT: modified file

src/animations/xyanimation.cpp +7 -12

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            XYAnimation::XYAnimation(XYChart *item):ChartAnimation(item),
+            XYAnimation::XYAnimation(XYChart *item)
+                : ChartAnimation(item),
                   m_type(NewAnimation),
                   m_dirty(false),
                   m_index(-1),
                 y = m_newPoints.count();
                 if (x != y)
                     m_type = NewAnimation;
                 else if (m_type == NewAnimation)
                     m_type = ReplacePointAnimation;
                 setKeyValueAt(0.0, qVariantFromValue(m_oldPoints));
                 setKeyValueAt(1.0, qVariantFromValue(m_newPoints));
                 case ReplacePointAnimation:
                 case AddPointAnimation:
-                case RemovePointAnimation:
+                case RemovePointAnimation: {
+                    if (startVector.count() != endVector.count())
-                    if (startVector.count() != endVector.count()){
                         break;
                     for (int i = 0; i < startVector.count(); i++) {
                         qreal x = startVector[i].x() + ((endVector[i].x() - startVector[i].x()) * progress);
             void XYAnimation::updateState(QAbstractAnimation::State newState, QAbstractAnimation::State oldState)
             {
-            	if(oldState == QAbstractAnimation::Running && newState == QAbstractAnimation::Stopped)
+                if (oldState == QAbstractAnimation::Running && newState == QAbstractAnimation::Stopped) {
                     if (m_item->isDirty() && m_type == RemovePointAnimation) {
-            		    if(!m_newPoints.isEmpty()) m_newPoints.remove(m_index);
+                        if (!m_newPoints.isEmpty())
+                            m_newPoints.remove(m_index);
                         m_item->setGeometryPoints(m_newPoints);
                     }
                 }

src/animations/xyanimation_p.h 0 0

NO CONTENT: modified file

src/areachart/areachartitem.cpp +1 -2

             {
                 setZValue(ChartPresenter::LineChartZValue);
                 m_upper = new AreaBoundItem(this, m_series->upperSeries(), presenter);
-                if (m_series->lowerSeries()){
+                if (m_series->lowerSeries())
                     m_lower = new AreaBoundItem(this, m_series->lowerSeries(), presenter);
                 QObject::connect(m_series->d_func(), SIGNAL(updated()), this, SLOT(handleUpdated()));
                 QObject::connect(m_series, SIGNAL(visibleChanged()), this, SLOT(handleUpdated()));

src/areachart/areachartitem_p.h +3 -1

             class AreaBoundItem : public LineChartItem
             {
             public:
-                AreaBoundItem(AreaChartItem *item,QLineSeries *lineSeries,ChartPresenter* presenter) : LineChartItem(lineSeries, 0), m_item(item) {
+                AreaBoundItem(AreaChartItem *item, QLineSeries *lineSeries, ChartPresenter* presenter)
+                    : LineChartItem(lineSeries, 0), m_item(item)
+                {
                     setPresenter(presenter);
                 }
                 ~AreaBoundItem() {}

src/areachart/qareaseries.cpp +8 -11

             QAreaSeries::~QAreaSeries()
             {
                 Q_D(QAreaSeries);
-                if(d->m_dataset){
+                if (d->m_dataset)
                     d->m_dataset->removeSeries(this);
             }
             /*!
                 Returns QChartSeries::SeriesTypeArea.
             ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-            QAreaSeriesPrivate::QAreaSeriesPrivate(QLineSeries *upperSeries, QLineSeries *lowerSeries,QAreaSeries* q) :
+            QAreaSeriesPrivate::QAreaSeriesPrivate(QLineSeries *upperSeries, QLineSeries *lowerSeries, QAreaSeries* q)
-                QAbstractSeriesPrivate(q),
+                : QAbstractSeriesPrivate(q),
                   m_upperSeries(upperSeries),
                   m_lowerSeries(lowerSeries),
                   m_pointsVisible(false)
                 const QList<QPointF>& points = upperSeries->points();
-                for (int i = 0; i < points.count(); i++)
+                for (int i = 0; i < points.count(); i++) {
                     qreal x = points[i].x();
                     qreal y = points[i].y();
                     minX = qMin(minX, x);
                     const QList<QPointF>& points = lowerSeries->points();
-                    for (int i = 0; i < points.count(); i++)
+                    for (int i = 0; i < points.count(); i++) {
                         qreal x = points[i].x();
                         qreal y = points[i].y();
                         minX = qMin(minX, x);
                         minY = qMin(minY, y);
                         maxX = qMax(maxX, x);
                         maxY = qMax(maxY, y);
-                    }}
+                }
                 domain.setRange(minX, maxX, minY, maxY);
             }
                 AreaChartItem* area = new AreaChartItem(q, presenter);
                 if (presenter->animationOptions().testFlag(QChart::SeriesAnimations)) {
                     area->upperLineItem()->setAnimation(new XYAnimation(area->upperLineItem()));
-                    if(q->lowerSeries())  {
+                    if (q->lowerSeries())
                         area->lowerLineItem()->setAnimation(new XYAnimation(area->lowerLineItem()));
                 }
                 presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
                 return area;
             }

src/areachart/qareaseries_p.h 0 0

NO CONTENT: modified file

src/axis/barcategoryaxis/chartbarcategoryaxisx.cpp +15 -24

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            ChartBarCategoryAxisX::ChartBarCategoryAxisX(QBarCategoryAxis *axis,ChartPresenter *presenter) : ChartAxis(axis,presenter),
+            ChartBarCategoryAxisX::ChartBarCategoryAxisX(QBarCategoryAxis *axis, ChartPresenter *presenter)
+                : ChartAxis(axis, presenter),
                   m_categoriesAxis(axis)
             {
                 if (delta < 1) return points;
-                if(offset<=0) {
+                if (offset <= 0)
                     offset = int(offset * rect.width() / (m_max - m_min)) % int(delta) + delta;
+                else
-                else {
                     offset = int(offset * rect.width() / (m_max - m_min)) % int(delta);
                 points[0] = rect.left();
                 points[count + 1] = rect.right();
                 qreal d = (m_max - m_min) / rect.width();
                 for (int i = 0; i < layout.count() - 1; ++i) {
                     qreal x = qFloor((((layout[i + 1] + layout[i]) / 2 - rect.left()) * d + m_min + 0.5));
-                    if ((x < m_categoriesAxis->categories().count()) && (x >= 0)) {
+                    if ((x < m_categoriesAxis->categories().count()) && (x >= 0))
                         result << m_categoriesAxis->categories().at(x);
+                    else
-                    else {
+                        result << ""; // No label for x coordinate
-                        // No label for x coordinate
-                        result << "";
                 }
                 result << "";
                 return result;
             {
                 const QVector<qreal>& layout = ChartAxis::layout();
-                if(layout.isEmpty()) return;
+                if (layout.isEmpty())
+                    return;
                 QStringList ticksList = createCategoryLabels(layout);
                     QPointF center = rect.center();
                     labelItem->setTransformOriginPoint(center.x(), center.y());
-                    if(i==0){
+                    if (i == 0)
                         labelItem->setPos(layout[i + 1] - (delta) / 2 - center.x(),  chartRect.bottom() + label_padding);
-                    }else{
+                    else
                         labelItem->setPos(layout[i] + (delta) / 2 - center.x(),  chartRect.bottom() + label_padding);
                     if (labelItem->pos().x() <= width || labelItem->pos().x() + rect.width() > chartRect.right()) {
                         labelItem->setVisible(false);
+                    } else {
-                    else {
                         labelItem->setVisible(true);
                         width = rect.width() + labelItem->pos().x();
                     }
             void ChartBarCategoryAxisX::handleAxisUpdated()
             {
-                if(m_categoriesAxis->categories()!=m_categories)
+                if (m_categoriesAxis->categories() != m_categories) {
                     m_categories = m_categoriesAxis->categories();
                     if (ChartAxis::layout().count() == m_categoriesAxis->d_ptr->count() + 2) updateGeometry();
                 }
                     height += base.height();
                     sh = QSizeF(width, height);
                     break;
-                    case Qt::PreferredSize:{
+                case Qt::PreferredSize:
+                    for (int i = 0; i < ticksList.size(); ++i) {
-                        for (int i = 0; i < ticksList.size(); ++i)
                         QRectF rect = fn.boundingRect(ticksList.at(i));
                         width += rect.width();
                         height = qMax(rect.height() + label_padding, height);
                     height += base.height();
                     sh = QSizeF(width, height);
                     break;
                 default:
                     break;
                 }

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

                 void updateGeometry();
             private:
                 QStringList createCategoryLabels(const QVector<qreal>& layout) const;
-            Q_SLOTS
+            public Q_SLOTS:
                 void handleAxisUpdated();
             private:

src/axis/barcategoryaxis/chartbarcategoryaxisy.cpp +16 -27

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            ChartBarCategoryAxisY::ChartBarCategoryAxisY(QBarCategoryAxis *axis,ChartPresenter *presenter) : ChartAxis(axis,presenter),
+            ChartBarCategoryAxisY::ChartBarCategoryAxisY(QBarCategoryAxis *axis, ChartPresenter *presenter)
+                : ChartAxis(axis, presenter),
                   m_categoriesAxis(axis)
             {
             }
                 if (delta < 1) return points;
-                if(offset<=0) {
+                if (offset <= 0)
                     offset = int(offset * rect.height() / (m_max - m_min)) % int(delta) + delta;
+                else
-                else {
                     offset = int(offset * rect.height() / (m_max - m_min)) % int(delta);
                 points[0] = rect.bottom();
                 points[count + 1] = rect.top();
                 qreal d = (m_max - m_min) / rect.height();
                 for (int i = 0; i < layout.count() - 1; ++i) {
                     qreal x = qFloor(((rect.height() - (layout[i + 1] + layout[i]) / 2 + rect.top()) * d + m_min + 0.5));
-                    if ((x < m_categoriesAxis->categories().count()) && (x >= 0)) {
+                    if ((x < m_categoriesAxis->categories().count()) && (x >= 0))
                         result << m_categoriesAxis->categories().at(x);
+                    else
-                    else {
+                        result << ""; // No label for x coordinate
-                        // No label for x coordinate
-                        result << "";
                 }
                 result << "";
                 return result;
             {
                 const QVector<qreal>& layout = ChartAxis::layout();
-                if(layout.isEmpty()) return;
+                if (layout.isEmpty())
+                    return;
                 QStringList ticksList = createCategoryLabels(layout);
                     QPointF center = rect.center();
                     labelItem->setTransformOriginPoint(center.x(), center.y());
-                    if(i==0) {
+                    if (i == 0)
                         labelItem->setPos(chartRect.left() - rect.width() - label_padding , layout[i + 1] + (delta) / 2 - center.y());
+                    else
-                    else {
                         labelItem->setPos(chartRect.left() - rect.width() - label_padding , layout[i] - (delta) / 2 - center.y());
                     if (labelItem->pos().y() + rect.height() >= height || labelItem->pos().y() < chartRect.top()) {
                         labelItem->setVisible(false);
+                    } else {
-                    else {
                         labelItem->setVisible(true);
                         height = labelItem->pos().y();
                     }
             void ChartBarCategoryAxisY::handleAxisUpdated()
             {
-                if(m_categoriesAxis->categories()!=m_categories)
+                if (m_categoriesAxis->categories() != m_categories) {
                     m_categories = m_categoriesAxis->categories();
-                    if(ChartAxis::layout().count()==m_categoriesAxis->d_ptr->count()+2) {
+                    if (ChartAxis::layout().count() == m_categoriesAxis->d_ptr->count() + 2)
                         updateGeometry();
                 }
                 ChartAxis::handleAxisUpdated();
             }
                     height = qMax(height, base.height());
                     sh = QSizeF(width, height);
                     break;
-                    case Qt::PreferredSize:{
+                case Qt::PreferredSize:
+                    for (int i = 0; i < ticksList.size(); ++i) {
-                        for (int i = 0; i < ticksList.size(); ++i)
                         QRectF rect = fn.boundingRect(ticksList.at(i));
                         height += rect.height();
                         width = qMax(rect.width() + label_padding, width);
                     width += base.width();
                     sh = QSizeF(width, height);
                     break;
                 default:
                     break;
                 }

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

                 void updateGeometry();
             private:
                 QStringList createCategoryLabels(const QVector<qreal>& layout) const;
-            Q_SLOTS
+            public Q_SLOTS:
                 void handleAxisUpdated();
             private:
                 QStringList m_categories;

src/axis/barcategoryaxis/qbarcategoryaxis.cpp +14 -20

             QBarCategoryAxis::~QBarCategoryAxis()
             {
                 Q_D(QBarCategoryAxis);
-                if(d->m_dataset){
+                if (d->m_dataset)
                     d->m_dataset->removeAxis(this);
             }
             /*!
                 \internal
             */
-            QBarCategoryAxis::QBarCategoryAxis(QBarCategoryAxisPrivate &d,QObject *parent):QAbstractAxis(d,parent)
+            QBarCategoryAxis::QBarCategoryAxis(QBarCategoryAxisPrivate &d, QObject *parent)
+                : QAbstractAxis(d, parent)
             {
             }
             */
             void QBarCategoryAxis::append(const QStringList &categories)
             {
-                if(categories.isEmpty()) return;
+                if (categories.isEmpty())
+                    return;
                 Q_D(QBarCategoryAxis);
                 if (d->m_categories.isEmpty()) {
                     d->emitUpdated();
                 }
-                if(d->m_categories.indexOf(d->m_maxCategory)<d->m_categories.indexOf(d->m_minCategory)) return;
+                if (d->m_categories.indexOf(d->m_maxCategory) < d->m_categories.indexOf(d->m_minCategory))
+                    return;
                 if (!minCategory.isEmpty() && d->m_minCategory != minCategory && d->m_categories.contains(minCategory)) {
                     d->m_minCategory = minCategory;
                 if (m_orientation == Qt::Horizontal) {
                     m_min = domain->minX();
                     m_max = domain->maxX();
+                } else if (m_orientation == Qt::Vertical) {
-                else if(m_orientation==Qt::Vertical) {
                     m_min = domain->minY();
                     m_max = domain->maxY();
                 }
                     }
                 }
-                if (changed) {
+                if (changed)
                     emit q->rangeChanged(m_minCategory, m_maxCategory);
             }
             ChartAxis* QBarCategoryAxisPrivate::createGraphics(ChartPresenter* presenter)
             {
                 Q_Q(QBarCategoryAxis);
-                if(m_orientation == Qt::Vertical){
+                if (m_orientation == Qt::Vertical)
                     return new ChartBarCategoryAxisY(q, presenter);
-                }else{
                 return new ChartBarCategoryAxisX(q, presenter);
             }
             void QBarCategoryAxisPrivate::intializeDomain(Domain* domain)
             {
                     if (m_orientation == Qt::Vertical) {
                         min = domain->minY() + 0.5;
                         max = domain->maxY() - 0.5;
+                    } else {
-                    else {
                         min = domain->minX() + 0.5;
                         max = domain->maxX() - 0.5;
                     }
                     if (min > 0 && min < m_categories.count() && max > 0 && max < m_categories.count())
                         q->setRange(m_categories.at(min), m_categories.at(max));
+                } else {
-                else {
+                    if (m_orientation == Qt::Vertical)
-                    if(m_orientation==Qt::Vertical) {
                         domain->setRangeY(m_min, m_max);
+                    else
-                    else {
                         domain->setRangeX(m_min, m_max);
                 }
             }
             #include "moc_qbarcategoryaxis.cpp"
             #include "moc_qbarcategoryaxis_p.cpp"

src/axis/barcategoryaxis/qbarcategoryaxis.h 0 0

NO CONTENT: modified file

src/axis/barcategoryaxis/qbarcategoryaxis_p.h 0 0

NO CONTENT: modified file

src/axis/categoryaxis/chartcategoryaxisx.cpp +10 -16

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            ChartCategoryAxisX::ChartCategoryAxisX(QAbstractAxis *axis,ChartPresenter *presenter) : ChartAxis(axis,presenter)
+            ChartCategoryAxisX::ChartCategoryAxisX(QAbstractAxis *axis, ChartPresenter *presenter)
+                : ChartAxis(axis, presenter)
             {
             }
             {
                 const QVector<qreal>& layout = ChartAxis::layout();
-                if(layout.isEmpty()) return;
+                if (layout.isEmpty())
+                    return;
                 QCategoryAxis *categoryAxis = qobject_cast<QCategoryAxis *>(m_chartAxis);
                 QStringList ticksList = categoryAxis->categoriesLabels();
                 QList<QGraphicsItem *> axis = m_arrow->childItems();
-                for (int i = 0; i < labels.count(); i++) {
+                for (int i = 0; i < labels.count(); i++)
                     labels.at(i)->setVisible(false);
                 QRectF chartRect = presenter()->chartsGeometry();
                 // axis base line
                 for (int i = 0; i < layout.size(); ++i) {
                     QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem*>(labels.at(i));
-                    if (i < ticksList.count()) {
+                    if (i < ticksList.count())
                         labelItem->setText(ticksList.at(i));
                     const QRectF& rect = labelItem->boundingRect();
                     QPointF center = rect.center();
                     labelItem->setTransformOriginPoint(center.x(), center.y());
-                    if (i < layout.size() - 1) {
+                    if (i < layout.size() - 1)
                         labelItem->setPos(layout[i] + (layout[i + 1] - layout[i]) / 2 - center.x(), chartRect.bottom() + label_padding);
-                    } else {
+                    else
                         labelItem->setPos(layout[i] - center.x(), chartRect.bottom() + label_padding);
                     // check if the label should be shown
                     if (labelItem->pos().x() + center.x() < chartRect.left() || labelItem->pos().x() + center.x() > chartRect.right())
                         lineItem->setVisible(true);
                         tickLineItem->setVisible(true);
                     }
                 }
             }
             void ChartCategoryAxisX::handleAxisUpdated()
                     height += base.height();
                     sh = QSizeF(width, height);
                     break;
-                    case Qt::PreferredSize: {
+                case Qt::PreferredSize:
+                    for (int i = 0; i < ticksList.size(); ++i) {
-                        for (int i = 0; i < ticksList.size(); ++i)
                         QRectF rect = fn.boundingRect(ticksList.at(i));
                         width += rect.width();
                         height = qMax(rect.height() + label_padding, height);
                     height += base.height();
                     sh = QSizeF(width, height);
                     break;
                 default:
                     break;
                 }

src/axis/categoryaxis/chartcategoryaxisx_p.h 0 0

NO CONTENT: modified file

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

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            ChartCategoryAxisY::ChartCategoryAxisY(QAbstractAxis *axis,ChartPresenter *presenter) : ChartAxis(axis,presenter)
+            ChartCategoryAxisY::ChartCategoryAxisY(QAbstractAxis *axis, ChartPresenter *presenter)
+                : ChartAxis(axis, presenter)
             {
             }
                 if (range > 0) {
                     points.resize(tickCount);
                     qreal scale = rect.height() / range;
-                    for (int i = 0; i < tickCount; ++i)
+                    for (int i = 0; i < tickCount; ++i) {
                         if (i < tickCount - 1) {
                             int y = -(axis->startValue(axis->categoriesLabels().at(i)) - axis->min()) * scale + rect.bottom();
                             points[i] = y;
                             points[i] = y;
                         }
                     }
+                }
                 return points;
             }
             {
                 const QVector<qreal> &layout = ChartAxis::layout();
-                if(layout.isEmpty()) {
+                if (layout.isEmpty())
                     return;
                 QCategoryAxis *categoryAxis = qobject_cast<QCategoryAxis *>(m_chartAxis);
                 QStringList ticksList = categoryAxis->categoriesLabels();
                         lineItem->setVisible(true);
                         tickLineItem->setVisible(true);
                     }
                 }
             }
             void ChartCategoryAxisY::handleAxisUpdated()
                     height += base.height();
                     sh = QSizeF(width, height);
                     break;
-                    case Qt::PreferredSize:{
+                case Qt::PreferredSize:
+                    for (int i = 0; i < ticksList.size(); ++i) {
-                        for (int i = 0; i < ticksList.size(); ++i)
                         QRectF rect = fn.boundingRect(ticksList.at(i));
                         height += rect.height();
                         width = qMax(rect.width() + label_padding, width);
                     width += base.width();
                     sh = QSizeF(width, height);
                     break;
                 default:
                     break;
                 }

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

                 QVector<qreal> calculateLayout() const;
                 void updateGeometry();
-            Q_SLOTS
+            public Q_SLOTS:
                 void handleAxisUpdated();
             };

src/axis/categoryaxis/qcategoryaxis.cpp +2 -7

             {
                 Q_D(QCategoryAxis);
-                if (!d->m_categories.contains(categoryLabel))
+                if (!d->m_categories.contains(categoryLabel)) {
                     if (d->m_categories.isEmpty()) {
                         Range range(d->m_categoryMinimum, categoryEndValue);
                         d->m_categoriesMap.insert(categoryLabel, range);
                 Q_D(const QCategoryAxis);
                 if (categoryLabel.isEmpty())
                     return d->m_categoryMinimum;
-                else
                 return d->m_categoriesMap.value(categoryLabel).first;
             }
                     d->m_categoriesMap.insert(newLabel, range);
                     d->emitUpdated();
                 }
             }
             /*!
             ChartAxis* QCategoryAxisPrivate::createGraphics(ChartPresenter* presenter)
             {
                 Q_Q(QCategoryAxis);
-                if(m_orientation == Qt::Vertical){
+                if (m_orientation == Qt::Vertical)
                     return new ChartCategoryAxisY(q, presenter);
-                }else{
                 return new ChartCategoryAxisX(q, presenter);
             }
             #include "moc_qcategoryaxis.cpp"
             #include "moc_qcategoryaxis_p.cpp"

src/axis/categoryaxis/qcategoryaxis.h 0 0

NO CONTENT: modified file

src/axis/categoryaxis/qcategoryaxis_p.h 0 0

NO CONTENT: modified file

src/axis/chartaxis.cpp +42 -59

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            ChartAxis::ChartAxis(QAbstractAxis *axis,ChartPresenter *presenter) : ChartElement(presenter),
+            ChartAxis::ChartAxis(QAbstractAxis *axis, ChartPresenter *presenter)
+                : ChartElement(presenter),
                   m_chartAxis(axis),
                   m_labelsAngle(0),
                   m_grid(new QGraphicsItemGroup(presenter->rootItem())),
             {
                 if (m_arrow->children().size() == 0)
                     m_arrow->addToGroup(new AxisItem(this, presenter()->rootItem()));
                 for (int i = 0; i < count; ++i) {
                     m_grid->addToGroup(new QGraphicsLineItem(presenter()->rootItem()));
                     m_labels->addToGroup(new QGraphicsSimpleTextItem(presenter()->rootItem()));
                     m_arrow->addToGroup(new QGraphicsLineItem(presenter()->rootItem()));
-                    if ((m_grid->childItems().size())%2 && m_grid->childItems().size()>2) m_shades->addToGroup(new QGraphicsRectItem(presenter()->rootItem()));
+                    if ((m_grid->childItems().size()) % 2 && m_grid->childItems().size() > 2)
+                        m_shades->addToGroup(new QGraphicsRectItem(presenter()->rootItem()));
                 }
             }
                 QList<QGraphicsItem *> axis = m_arrow->childItems();
                 for (int i = 0; i < count; ++i) {
-                    if (lines.size()%2 && lines.size() > 1) delete(shades.takeLast());
+                    if (lines.size() % 2 && lines.size() > 1)
+                        delete(shades.takeLast());
                     delete(lines.takeLast());
                     delete(labels.takeLast());
                     delete(axis.takeLast());
             {
                 int diff = m_layoutVector.size() - layout.size();
-                if (diff>0) {
+                if (diff > 0)
                     deleteItems(diff);
+                else if (diff < 0)
-                else if (diff<0) {
                     createItems(-diff);
-                if(diff<0) handleAxisUpdated();
+                if (diff < 0)
+                    handleAxisUpdated();
                 if (m_animation) {
                     switch (presenter()->state()) {
                     }
                     m_animation->setValues(m_layoutVector, layout);
                     presenter()->startAnimation(m_animation);
+                } else {
-                else {
                     setLayout(layout);
                     updateGeometry();
                 }
             void ChartAxis::setLabelsAngle(int angle)
             {
-                foreach(QGraphicsItem* item , m_labels->childItems()) {
+                foreach (QGraphicsItem *item , m_labels->childItems())
                     item->setRotation(angle);
                 m_labelsAngle = angle;
             }
             void ChartAxis::setLabelsPen(const QPen &pen)
             {
-                foreach(QGraphicsItem* item , m_labels->childItems()) {
+                foreach (QGraphicsItem *item , m_labels->childItems())
                     static_cast<QGraphicsSimpleTextItem*>(item)->setPen(pen);
             }
             void ChartAxis::setLabelsBrush(const QBrush &brush)
             {
-                foreach(QGraphicsItem* item , m_labels->childItems()) {
+                foreach (QGraphicsItem *item , m_labels->childItems())
                     static_cast<QGraphicsSimpleTextItem*>(item)->setBrush(brush);
             }
             void ChartAxis::setLabelsFont(const QFont &font)
             {
-                foreach(QGraphicsItem* item , m_labels->childItems()) {
+                foreach (QGraphicsItem *item , m_labels->childItems())
                     static_cast<QGraphicsSimpleTextItem*>(item)->setFont(font);
                 if (m_font != font) {
                     m_font = font;
-                    foreach(QGraphicsItem* item , m_labels->childItems()) {
+                    foreach (QGraphicsItem *item , m_labels->childItems())
                         static_cast<QGraphicsSimpleTextItem*>(item)->setFont(font);
                     QGraphicsLayoutItem::updateGeometry();
                     presenter()->layout()->invalidate();
                 }
             }
             void ChartAxis::setShadesBrush(const QBrush &brush)
             {
-                foreach(QGraphicsItem* item , m_shades->childItems()) {
+                foreach (QGraphicsItem *item , m_shades->childItems())
                     static_cast<QGraphicsRectItem*>(item)->setBrush(brush);
             }
             void ChartAxis::setShadesPen(const QPen &pen)
             {
-                foreach(QGraphicsItem* item , m_shades->childItems()) {
+                foreach (QGraphicsItem *item , m_shades->childItems())
                     static_cast<QGraphicsRectItem*>(item)->setPen(pen);
             }
             void ChartAxis::setArrowPen(const QPen &pen)
             {
-                foreach(QGraphicsItem* item , m_arrow->childItems()) {
+                foreach (QGraphicsItem *item , m_arrow->childItems())
                     static_cast<QGraphicsLineItem*>(item)->setPen(pen);
             }
             void ChartAxis::setGridPen(const QPen &pen)
             {
-                foreach(QGraphicsItem* item , m_grid->childItems()) {
+                foreach (QGraphicsItem *item , m_grid->childItems())
                     static_cast<QGraphicsLineItem*>(item)->setPen(pen);
             }
             bool ChartAxis::isEmpty()
             {
-                return !m_rect.isValid() || presenter()->chartsGeometry().isEmpty() || qFuzzyIsNull(m_min - m_max);
+                return !m_rect.isValid() ||
+                       presenter()->chartsGeometry().isEmpty() ||
+                       qFuzzyIsNull(m_min - m_max);
             }
             void ChartAxis::handleDomainUpdated()
                 if (m_chartAxis->orientation() == Qt::Horizontal) {
                     min = domain->minX();
                     max = domain->maxX();
+                } else if (m_chartAxis->orientation() == Qt::Vertical) {
-                else if (m_chartAxis->orientation()==Qt::Vertical)
                     min = domain->minY();
                     max = domain->maxY();
                 }
-                if (!qFuzzyIsNull(m_min - min) || !qFuzzyIsNull(m_max - max))
+                if (!qFuzzyIsNull(m_min - min) || !qFuzzyIsNull(m_max - max)) {
                     m_min = min;
                     m_max = max;
             void ChartAxis::handleAxisUpdated()
             {
-                if(isEmpty()) return;
+                if (isEmpty())
+                    return;
                 bool visible = m_chartAxis->isVisible();
             void ChartAxis::setGeometry(const QRectF &rect)
             {
                 m_rect = rect;
-                    if (isEmpty()) return;
+                if (isEmpty())
+                    return;
                 if (!m_titleText.isNull()) {
                     QFontMetrics fn(m_title->font());
                     else if (orientation() == Qt::Vertical)
                         size = chartRect.height();
-                        if (fn.boundingRect(m_titleText).width() > size)
+                    if (fn.boundingRect(m_titleText).width() > size) {
                         QString string = m_titleText + "...";
                         while (fn.boundingRect(string).width() > size && string.length() > 3)
                             string.remove(string.length() - 4, 1);
                         m_title->setText(string);
+                    } else {
-                        else
                         m_title->setText(m_titleText);
+                    }
                     QPointF center = chartRect.center() - m_title->boundingRect().center();
                     if (orientation() == Qt::Horizontal) {
                         m_title->setPos(center.x(), m_rect.bottom() - m_title->boundingRect().height());
+                    } else if (orientation() == Qt::Vertical) {
-                        else if(orientation()==Qt::Vertical) {
                         m_title->setTransformOriginPoint(m_title->boundingRect().center());
                         m_title->setRotation(270);
                         m_title->setPos(m_rect.left() - m_title->boundingRect().width() / 2 + m_title->boundingRect().height() / 2, center.y());
                 QVector<qreal> layout = calculateLayout();
                 updateLayout(layout);
             }
             void ChartAxis::setInternalRect(const QRectF &size)
                         qreal value = min + (i * (max - min) / (ticks - 1));
                         labels << QString::number(value, 'f', n);
                     }
+                } else {
-                else {
                     QByteArray array = format.toAscii();
                     for (int i = 0; i < ticks; i++) {
                         qreal value = min + (i * (max - min) / (ticks - 1));
                 QFontMetrics fn(m_title->font());
                 QSizeF sh;
-                if(m_titleText.isNull()) return sh;
+                if (m_titleText.isNull())
+                    return sh;
                 switch (which) {
                 case Qt::MinimumSize:
-                    if(orientation()==Qt::Horizontal) {
+                    if (orientation() == Qt::Horizontal)
                         sh = QSizeF(fn.boundingRect("...").width(), fn.height());
+                    else if (orientation() == Qt::Vertical)
-                    else if(orientation()==Qt::Vertical) {
                         sh = QSizeF(fn.height(), fn.boundingRect("...").width());
                     break;
                 case Qt::MaximumSize:
                 case Qt::PreferredSize:
-                    if(orientation()==Qt::Horizontal) {
+                    if (orientation() == Qt::Horizontal)
                         sh = QSizeF(fn.boundingRect(m_chartAxis->title()).width(), fn.height());
+                    else if (orientation() == Qt::Vertical)
-                    else if(orientation()==Qt::Vertical) {
                         sh = QSizeF(fn.height(), fn.boundingRect(m_chartAxis->title()).width());
                     break;
                 default:
                     break;

src/axis/chartaxis_p.h +3 -7

                 explicit AxisItem(ChartAxis *axis, QGraphicsItem *parent = 0) : QGraphicsLineItem(parent), m_axis(axis) {}
             protected:
-               void mousePressEvent(QGraphicsSceneMouseEvent *event)
+                void mousePressEvent(QGraphicsSceneMouseEvent *event) {
                     Q_UNUSED(event)
                     m_axis->axisSelected();
                 }
-               QRectF boundingRect() const
+                QRectF boundingRect() const {
                     return shape().boundingRect();
                 }
-               QPainterPath shape() const
+                QPainterPath shape() const {
                     QPainterPath path = QGraphicsLineItem::shape();
                     QRectF rect = path.boundingRect();
                     path.addRect(rect.adjusted(0, 0, m_axis->axisType() != ChartAxis::X_AXIS ? 8 : 0, m_axis->axisType() != ChartAxis::Y_AXIS ? 8 : 0));
             private:
                 ChartAxis* m_axis;
             };
             QTCOMMERCIALCHART_END_NAMESPACE

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

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            ChartDateTimeAxisX::ChartDateTimeAxisX(QAbstractAxis *axis,ChartPresenter *presenter) : ChartAxis(axis,presenter),
+            ChartDateTimeAxisX::ChartDateTimeAxisX(QAbstractAxis *axis, ChartPresenter *presenter)
+                : ChartAxis(axis, presenter),
                   m_tickCount(0)
             {
             }
             {
                 const QVector<qreal>& layout = ChartAxis::layout();
-                if(layout.isEmpty()) return;
+                if (layout.isEmpty())
+                    return;
                 QStringList ticksList;
                     sh = QSizeF(fn.boundingRect("...").width(), fn.height());
                     break;
                 case Qt::PreferredSize: {
                     const QVector<qreal>& layout = ChartAxis::layout();
-                        if(layout.isEmpty()) break;
+                    if (layout.isEmpty())
+                        break;
                     QStringList ticksList;
                     qreal width = 0;
                     qreal height = 0;
+                    for (int i = 0; i < ticksList.size(); ++i) {
-                        for (int i = 0; i < ticksList.size(); ++i)
                         QRectF rect = fn.boundingRect(ticksList.at(i));
                         width += rect.width();
                         height += qMax(rect.height() + label_padding, height);

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

             private:
                 int m_tickCount;
             };
             QTCOMMERCIALCHART_END_NAMESPACE

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

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            ChartDateTimeAxisY::ChartDateTimeAxisY(QAbstractAxis *axis,ChartPresenter *presenter) : ChartAxis(axis,presenter),
+            ChartDateTimeAxisY::ChartDateTimeAxisY(QAbstractAxis *axis, ChartPresenter *presenter)
+                : ChartAxis(axis, presenter),
                   m_tickCount(0)
             {
             }
             {
                 const QVector<qreal> &layout = ChartAxis::layout();
-                if(layout.isEmpty()) return;
+                if (layout.isEmpty())
+                    return;
                 QStringList ticksList;
                     if (labelItem->pos().y() + rect.height() > height) {
                         labelItem->setVisible(false);
                         lineItem->setVisible(false);
+                    } else {
-                        else {
                         labelItem->setVisible(true);
                         lineItem->setVisible(true);
                         height = labelItem->pos().y();
                     sh = QSizeF(fn.boundingRect("...").width(), fn.height());
                     break;
                 case Qt::PreferredSize: {
                     const QVector<qreal>& layout = ChartAxis::layout();
-                        if(layout.isEmpty()) break;
+                    if (layout.isEmpty())
+                        break;
                     QStringList ticksList;
                     qreal width = 0;
                     qreal height = 0;
+                    for (int i = 0; i < ticksList.size(); ++i) {
-                        for (int i = 0; i < ticksList.size(); ++i)
                         QRectF rect = fn.boundingRect(ticksList.at(i));
                         width += rect.width();
                         height += qMax(rect.height() + label_padding, height);

src/axis/datetimeaxis/chartdatetimeaxisy_p.h 0 0

NO CONTENT: modified file

src/axis/datetimeaxis/qdatetimeaxis.cpp +7 -13

                 Domain* domain = qobject_cast<Domain*>(sender());
                 Q_ASSERT(domain);
-                if(orientation()==Qt::Horizontal){
+                if (orientation() == Qt::Horizontal)
                     q->setRange(QDateTime::fromMSecsSinceEpoch(domain->minX()), QDateTime::fromMSecsSinceEpoch(domain->maxX()));
-                }else if(orientation()==Qt::Vertical){
+                else if (orientation() == Qt::Vertical)
                     q->setRange(QDateTime::fromMSecsSinceEpoch(domain->minY()), QDateTime::fromMSecsSinceEpoch(domain->maxY()));
             }
             void QDateTimeAxisPrivate::setMin(const QVariant &min)
             ChartAxis* QDateTimeAxisPrivate::createGraphics(ChartPresenter* presenter)
             {
                 Q_Q(QDateTimeAxis);
-                if(m_orientation == Qt::Vertical){
+                if (m_orientation == Qt::Vertical)
                     return new ChartDateTimeAxisY(q, presenter);
-                }else{
                 return new ChartDateTimeAxisX(q, presenter);
             }
             void QDateTimeAxisPrivate::intializeDomain(Domain* domain)
             {
                 Q_Q(QDateTimeAxis);
                 if (m_max == m_min) {
-                    if(m_orientation==Qt::Vertical){
+                    if (m_orientation == Qt::Vertical)
                         q->setRange(QDateTime::fromMSecsSinceEpoch(domain->minY()), QDateTime::fromMSecsSinceEpoch(domain->maxY()));
-                    }else{
+                    else
                         q->setRange(QDateTime::fromMSecsSinceEpoch(domain->minX()), QDateTime::fromMSecsSinceEpoch(domain->maxX()));
                 } else {
-                    if(m_orientation==Qt::Vertical){
+                    if (m_orientation == Qt::Vertical)
                         domain->setRangeY(m_min.toMSecsSinceEpoch(), m_max.toMSecsSinceEpoch());
-                    }else{
+                    else
                         domain->setRangeX(m_min.toMSecsSinceEpoch(), m_max.toMSecsSinceEpoch());
                 }
             }
             #include "moc_qdatetimeaxis.cpp"
             #include "moc_qdatetimeaxis_p.cpp"

src/axis/datetimeaxis/qdatetimeaxis.h 0 0

NO CONTENT: modified file

src/axis/datetimeaxis/qdatetimeaxis_p.h 0 0

NO CONTENT: modified file

src/axis/qabstractaxis.cpp +4 -3

               QChart when axis added.
             */
-            QAbstractAxis::QAbstractAxis(QAbstractAxisPrivate &d, QObject *parent) :
+            QAbstractAxis::QAbstractAxis(QAbstractAxisPrivate &d, QObject *parent)
-            QObject(parent),
+                : QObject(parent),
                   d_ptr(&d)
             {
             }
             QAbstractAxis::~QAbstractAxis()
             {
-                if(d_ptr->m_dataset) qFatal("Still binded axis detected !");
+                if (d_ptr->m_dataset)
+                    qFatal("Still binded axis detected !");
             }
             /*!

src/axis/qabstractaxis.h 0 0

NO CONTENT: modified file

src/axis/valueaxis/chartvalueaxisx.cpp +5 -7

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            ChartValueAxisX::ChartValueAxisX(QAbstractAxis *axis,ChartPresenter *presenter) : ChartAxis(axis,presenter),
+            ChartValueAxisX::ChartValueAxisX(QAbstractAxis *axis, ChartPresenter *presenter)
+                : ChartAxis(axis, presenter),
                   m_tickCount(0)
             {
             }
             {
                 const QVector<qreal>& layout = ChartAxis::layout();
-                if(layout.isEmpty()) return;
+                if (layout.isEmpty())
+                    return;
                 QStringList ticksList = createNumberLabels(m_min, m_max, layout.size());
                     sh = QSizeF(width, height);
                     break;
                     }
-                case Qt::PreferredSize:{
+                case Qt::PreferredSize:
                     for (int i = 0; i < ticksList.size(); ++i)
                         width += fn.averageCharWidth() * ticksList.at(i).count();
                     height = fn.height() + label_padding;
                     width = qMax(width, base.width());
                     height += base.height();
                     sh = QSizeF(width, height);
                     break;
                 default:
                     break;
                 }

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

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            ChartValueAxisY::ChartValueAxisY(QAbstractAxis *axis,ChartPresenter *presenter) : ChartAxis(axis,presenter),
+            ChartValueAxisY::ChartValueAxisY(QAbstractAxis *axis, ChartPresenter *presenter)
+                : ChartAxis(axis, presenter),
                   m_tickCount(0)
             {
             }
             {
                 const QVector<qreal> &layout = ChartAxis::layout();
-                if(layout.isEmpty()) return;
+                if (layout.isEmpty())
+                    return;
                 QStringList ticksList = createNumberLabels(m_min, m_max, layout.size());
                     QString text = ticksList.at(i);
-                    if (fn.boundingRect(text).width() > chartRect.left() - m_rect.left() - label_padding )
+                    if (fn.boundingRect(text).width() > chartRect.left() - m_rect.left() - label_padding) {
                         QString label = text + "...";
                         while (fn.boundingRect(label).width() > chartRect.left() - m_rect.left() - label_padding && label.length() > 3)
                             label.remove(label.length() - 4, 1);
                     break;
                     }
                 case Qt::PreferredSize:
+                    for (int i = 0; i < ticksList.size(); ++i) {
-                    for (int i = 0; i < ticksList.size(); ++i)
                         width = qMax(qreal(fn.averageCharWidth() * ticksList.at(i).count()) + label_padding, width);
                         height += fn.height();
                     }
                     width += base.width();
                     sh = QSizeF(width, height);
                     break;
                 default:
                     break;
                 }

src/axis/valueaxis/qvalueaxis.cpp +22 -25

             /*!
                 \internal
             */
-            QValueAxis::QValueAxis(QValueAxisPrivate &d,QObject *parent) : QAbstractAxis(d,parent)
+            QValueAxis::QValueAxis(QValueAxisPrivate &d, QObject *parent)
+                : QAbstractAxis(d, parent)
             {
             }
             QValueAxis::~QValueAxis()
             {
                 Q_D(QValueAxis);
-                if(d->m_dataset) {
+                if (d->m_dataset)
                     d->m_dataset->removeAxis(this);
             }
             void QValueAxis::setMin(qreal min)
             {
                 Q_D(QValueAxis);
                 bool changed = false;
-                if (min > max) return;
+                if (min > max)
+                    return;
                 if (d->m_niceNumbers) {
                     int ticks = d->m_tickCount;
                     d->looseNiceNumbers(min, max, ticks);
-                    if(ticks!=d->m_tickCount) setTickCount(ticks);
+                    if (ticks != d->m_tickCount)
+                        setTickCount(ticks);
                 }
                 if (!qFuzzyIsNull(d->m_min - min)) {
                 Q_D(QValueAxis);
                 if (d->m_niceNumbers != enable) {
                     d->m_niceNumbers = enable;
-                    if(enable && !qFuzzyIsNull(d->m_max - d->m_min)) {
+                    if (enable && !qFuzzyIsNull(d->m_max - d->m_min))
                         setRange(d->m_min, d->m_max);
                 }
             }
             bool  QValueAxis::niceNumbersEnabled() const
             {
                 Domain* domain = qobject_cast<Domain*>(sender());
                 Q_ASSERT(domain);
-               if(orientation()==Qt::Horizontal){
+                if (orientation() == Qt::Horizontal)
                     q->setRange(domain->minX(), domain->maxX());
-               }else if(orientation()==Qt::Vertical){
+                else if (orientation() == Qt::Vertical)
                     q->setRange(domain->minY(), domain->maxY());
             }
             void QValueAxisPrivate::setMin(const QVariant &min)
                 Q_Q(QValueAxis);
                 bool ok;
                 qreal value = min.toReal(&ok);
-                if(ok) q->setMin(value);
+                if (ok)
+                    q->setMin(value);
             }
             void QValueAxisPrivate::setMax(const QVariant &max)
                 Q_Q(QValueAxis);
                 bool ok;
                 qreal value = max.toReal(&ok);
-                if(ok) q->setMax(value);
+                if (ok)
+                    q->setMax(value);
             }
             void QValueAxisPrivate::setRange(const QVariant &min, const QVariant &max)
                 bool ok2;
                 qreal value1 = min.toReal(&ok1);
                 qreal value2 = max.toReal(&ok2);
-                if(ok1&&ok2) q->setRange(value1,value2);
+                if (ok1 && ok2)
+                    q->setRange(value1, value2);
             }
             ChartAxis* QValueAxisPrivate::createGraphics(ChartPresenter* presenter)
             {
                 Q_Q(QValueAxis);
-                if(m_orientation == Qt::Vertical){
+                if (m_orientation == Qt::Vertical)
                     return new ChartValueAxisY(q, presenter);
-                }else{
                 return new ChartValueAxisX(q, presenter);
             }
             void QValueAxisPrivate::intializeDomain(Domain* domain)
             {
                 Q_Q(QValueAxis);
                 if (qFuzzyCompare(m_max, m_min)) {
-                    if(m_orientation==Qt::Vertical){
+                    if (m_orientation == Qt::Vertical)
                         q->setRange(domain->minY(), domain->maxY());
-                    }else{
+                    else
                         q->setRange(domain->minX(), domain->maxX());
                 } else {
-                    if(m_orientation==Qt::Vertical){
+                    if (m_orientation == Qt::Vertical)
                         domain->setRangeY(m_min, m_max);
-                    }else{
+                    else
                         domain->setRangeX(m_min, m_max);
                 }
             }
             //algorithm defined by Paul S.Heckbert GraphicalGems I
                     else if (q <= 2.0) q = 2;
                     else if (q <= 5.0) q = 5;
                     else q = 10;
+                } else {
-                else {
                     if (q < 1.5) q = 1;
                     else if (q < 3.0) q = 2;
                     else if (q < 7.0) q = 5;

src/axis/valueaxis/qvalueaxis.h 0 0

NO CONTENT: modified file

src/axis/valueaxis/qvalueaxis_p.h 0 0

NO CONTENT: modified file

src/barchart/abstractbarchartitem.cpp +5 -11

                 if (m_animation) {
                     m_animation->setup(m_layout, layout);
                     presenter()->startAnimation(m_animation);
                 } else {
                     setLayout(layout);
                     update();
                 m_layout = layout;
-                for (int i=0; i < m_bars.count(); i++) {
+                for (int i = 0; i < m_bars.count(); i++)
                     m_bars.at(i)->setRect(layout.at(i));
             }
             //handlers
             void AbstractBarChartItem::handleDomainUpdated()
             void AbstractBarChartItem::handleLayoutChanged()
             {
-                if ((m_rect.width() <= 0) || (m_rect.height() <= 0)) {
+                if ((m_rect.width() <= 0) || (m_rect.height() <= 0))
-                    // rect size zero.
+                    return; // rect size zero.
-                    return;
                 QVector<QRectF> layout = calculateLayout();
                 applyLayout(layout);
             }
             void AbstractBarChartItem::handleLabelsVisibleChanged(bool visible)
             {
-                foreach (QGraphicsSimpleTextItem* label, m_labels) {
+                foreach (QGraphicsSimpleTextItem *label, m_labels)
                     label->setVisible(visible);
                 update();
             }
             void AbstractBarChartItem::handleDataStructureChanged()
             {
-                foreach(QGraphicsItem *item, childItems()) {
+                foreach (QGraphicsItem *item, childItems())
                     delete item;
                 m_bars.clear();
                 m_labels.clear();

src/barchart/horizontal/bar/horizontalbarchartitem.cpp +8 -10

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            HorizontalBarChartItem::HorizontalBarChartItem(QAbstractBarSeries *series, ChartPresenter *presenter) :
+            HorizontalBarChartItem::HorizontalBarChartItem(QAbstractBarSeries *series, ChartPresenter *presenter)
-                AbstractBarChartItem(series, presenter)
+                : AbstractBarChartItem(series, presenter)
             {
             }
                         layout.append(rect);
                         bar->setPen(barSet->m_pen);
                         bar->setBrush(barSet->m_brush);
-                        if (qFuzzyIsNull(rectHeight)) {
+                        if (qFuzzyIsNull(rectHeight))
                             bar->setVisible(false);
-                        } else {
+                        else
                             bar->setVisible(barsVisible);
                         QGraphicsSimpleTextItem* label = m_labels.at(itemIndex);
-                        if (!qFuzzyIsNull(barSet->value(category))) {
+                        if (!qFuzzyIsNull(barSet->value(category)))
                             label->setText(QString::number(barSet->value(category)));
-                        } else {
+                        else
                             label->setText(QString(""));
-                        label->setPos(xPos + (rect.width()/2 - label->boundingRect().width()/2)
+                        label->setPos(xPos + (rect.width() / 2 - label->boundingRect().width() / 2),
-                                      ,yPos - rectHeight/2 - label->boundingRect().height()/2);
+                                      yPos - rectHeight / 2 - label->boundingRect().height() / 2);
                         label->setFont(barSet->m_labelFont);
                         label->setBrush(barSet->m_labelBrush);

src/barchart/horizontal/bar/qhorizontalbarseries.cpp +2 -4

             QHorizontalBarSeries::~QHorizontalBarSeries()
             {
                 Q_D(QHorizontalBarSeries);
-                if(d->m_dataset) {
+                if (d->m_dataset)
                     d->m_dataset->removeSeries(this);
             }
             /*!
                 Returns QChartSeries::SeriesTypeHorizontalBar.
                 Q_Q(QHorizontalBarSeries);
                 HorizontalBarChartItem* bar = new HorizontalBarChartItem(q, presenter);
-                if(presenter->animationOptions().testFlag(QChart::SeriesAnimations)) {
+                if (presenter->animationOptions().testFlag(QChart::SeriesAnimations))
                     bar->setAnimation(new HorizontalBarAnimation(bar));
                 presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
                 return bar;
             }

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

                         layout.append(rect);
                         bar->setPen(barSet->m_pen);
                         bar->setBrush(barSet->m_brush);
-                        if (qFuzzyIsNull(rectHeight)) {
+                        if (qFuzzyIsNull(rectHeight))
                             bar->setVisible(false);
-                        } else {
+                        else
                             bar->setVisible(barsVisible);
                         QGraphicsSimpleTextItem* label = m_labels.at(itemIndex);
                             label->setText(QString(""));
                         }
-                        label->setPos(xPos + (rect.width()/2 - label->boundingRect().width()/2)
+                        label->setPos(xPos + (rect.width() / 2 - label->boundingRect().width() / 2),
-                                      ,yPos - rectHeight/2 - label->boundingRect().height()/2);
+                                      yPos - rectHeight / 2 - label->boundingRect().height() / 2);
                         label->setFont(barSet->m_labelFont);
                         label->setBrush(barSet->m_labelBrush);

src/barchart/horizontal/percent/qhorizontalpercentbarseries.cpp +2 -4

             QHorizontalPercentBarSeries::~QHorizontalPercentBarSeries()
             {
                 Q_D(QHorizontalPercentBarSeries);
-                if(d->m_dataset) {
+                if (d->m_dataset)
                     d->m_dataset->removeSeries(this);
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                 Q_Q(QHorizontalPercentBarSeries);
                 HorizontalPercentBarChartItem* bar = new HorizontalPercentBarChartItem(q, presenter);
-                if(presenter->animationOptions().testFlag(QChart::SeriesAnimations)) {
+                if (presenter->animationOptions().testFlag(QChart::SeriesAnimations))
                     bar->setAnimation(new HorizontalPercentBarAnimation(bar));
                 presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
                 return bar;
             }

src/barchart/horizontal/stacked/horizontalstackedbarchartitem.cpp +8 -10

                         bar->setPen(barSet->m_pen);
                         bar->setBrush(barSet->m_brush);
-                        if (qFuzzyIsNull(rectHeight)) {
+                        if (qFuzzyIsNull(rectHeight))
                             bar->setVisible(false);
-                        } else {
+                        else
                             bar->setVisible(barsVisible);
                         QGraphicsSimpleTextItem* label = m_labels.at(itemIndex);
-                        if (!qFuzzyIsNull(barSet->value(category))) {
+                        if (!qFuzzyIsNull(barSet->value(category)))
                             label->setText(QString::number(barSet->value(category)));
-                        } else {
+                        else
                             label->setText(QString(""));
                         label->setFont(barSet->m_labelFont);
                         label->setBrush(barSet->m_labelBrush);
                         if (rectWidth > 0) {
                             QRectF rect(xMax, yPos - rectHeight, rectWidth, rectHeight);
                             layout.append(rect);
-                            label->setPos(xMax + (rect.width()/2 - label->boundingRect().width()/2)
+                            label->setPos(xMax + (rect.width() / 2 - label->boundingRect().width() / 2),
-                                          ,yPos - rectHeight/2 - label->boundingRect().height()/2);
+                                          yPos - rectHeight / 2 - label->boundingRect().height() / 2);
                             xMax += rectWidth;
                         } else {
                             QRectF rect(xMin, yPos - rectHeight, rectWidth, rectHeight);
                             layout.append(rect);
-                            label->setPos(xMin + (rect.width()/2 - label->boundingRect().width()/2)
+                            label->setPos(xMin + (rect.width() / 2 - label->boundingRect().width() / 2),
-                                          ,yPos - rectHeight/2 - label->boundingRect().height()/2);
+                                          yPos - rectHeight / 2 - label->boundingRect().height() / 2);
                             xMin += rectWidth;
                         }
                         itemIndex++;

src/barchart/horizontal/stacked/qhorizontalstackedbarseries.cpp +2 -4

             QHorizontalStackedBarSeries::~QHorizontalStackedBarSeries()
             {
                 Q_D(QHorizontalStackedBarSeries);
-                if(d->m_dataset) {
+                if (d->m_dataset)
                     d->m_dataset->removeSeries(this);
             }
             /*!
                 Returns QChartSeries::SeriesTypeHorizontalStackedBar.
                 Q_Q(QHorizontalStackedBarSeries);
                 HorizontalStackedBarChartItem* bar = new HorizontalStackedBarChartItem(q, presenter);
-                if(presenter->animationOptions().testFlag(QChart::SeriesAnimations)) {
+                if (presenter->animationOptions().testFlag(QChart::SeriesAnimations))
                     bar->setAnimation(new HorizontalStackedBarAnimation(bar));
                 presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
                 return bar;
             }

src/barchart/qabstractbarseries.cpp +44 -92

             /*!
                 \internal
             */
-            QAbstractBarSeries::QAbstractBarSeries(QAbstractBarSeriesPrivate &o, QObject *parent) :
+            QAbstractBarSeries::QAbstractBarSeries(QAbstractBarSeriesPrivate &o, QObject *parent)
-                QAbstractSeries(o,parent)
+                : QAbstractSeries(o, parent)
             {
                 Q_D(QAbstractSeries);
                 QObject::connect(this, SIGNAL(countChanged()), d, SIGNAL(countChanged()));
                 if (success) {
                     emit barsetsRemoved(sets);
                     emit countChanged();
-                    foreach (QBarSet* set, sets) {
+                    foreach (QBarSet *set, sets)
                         delete set;
                 }
             }
             /*!
                 Returns number of sets in series.
                 // No categories defined. return count of longest set.
                 int count = 0;
                 for (int i = 0; i < m_barSets.count(); i++) {
-                    if (m_barSets.at(i)->count() > count) {
+                    if (m_barSets.at(i)->count() > count)
                         count = m_barSets.at(i)->count();
                 }
                 return count;
             }
             void QAbstractBarSeriesPrivate::setBarWidth(qreal width)
             {
-                if (width < 0.0) {
+                if (width < 0.0)
                     width = 0.0;
                 m_barWidth = width;
                 emit updatedLayout();
             }
             qreal QAbstractBarSeriesPrivate::min()
             {
-                if (m_barSets.count() <= 0) {
+                if (m_barSets.count() <= 0)
                     return 0;
                 qreal min = INT_MAX;
                 for (int i = 0; i < m_barSets.count(); i++) {
             qreal QAbstractBarSeriesPrivate::max()
             {
-                if (m_barSets.count() <= 0) {
+                if (m_barSets.count() <= 0)
                     return 0;
                 qreal max = INT_MIN;
                 for (int i = 0; i < m_barSets.count(); i++) {
             qreal QAbstractBarSeriesPrivate::valueAt(int set, int category)
             {
-                if ((set < 0) || (set >= m_barSets.count())) {
+                if ((set < 0) || (set >= m_barSets.count()))
-                    // No set, no value.
+                    return 0; // No set, no value.
-                    return 0;
+                else if ((category < 0) || (category >= m_barSets.at(set)->count()))
-                } else if ((category < 0) || (category >= m_barSets.at(set)->count())) {
+                    return 0; // No category, no value.
-                    // No category, no value.
-                    return 0;
                 return m_barSets.at(set)->at(category);
             }
             qreal QAbstractBarSeriesPrivate::percentageAt(int set, int category)
             {
-                if ((set < 0) || (set >= m_barSets.count())) {
+                if ((set < 0) || (set >= m_barSets.count()))
-                    // No set, no value.
+                    return 0; // No set, no value.
-                    return 0;
+                else if ((category < 0) || (category >= m_barSets.at(set)->count()))
-                } else if ((category < 0) || (category >= m_barSets.at(set)->count())) {
+                    return 0; // No category, no value.
-                    // No category, no value.
-                    return 0;
                 qreal value = m_barSets.at(set)->at(category);
                 qreal sum = categorySum(category);
-                if ( qFuzzyIsNull(sum) ) {
+                if (qFuzzyIsNull(sum))
                     return 0;
                 return value / sum;
             }
             qreal QAbstractBarSeriesPrivate::minX()
             {
-                if (m_barSets.count() <= 0) {
+                if (m_barSets.count() <= 0)
                     return 0;
                 qreal min = INT_MAX;
                 for (int i = 0; i < m_barSets.count(); i++) {
             qreal QAbstractBarSeriesPrivate::maxX()
             {
-                if (m_barSets.count() <= 0) {
+                if (m_barSets.count() <= 0)
                     return 0;
                 qreal max = INT_MIN;
                 for (int i = 0; i < m_barSets.count(); i++) {
                 int count = categoryCount();
                 for (int i = 0; i < count; i++) {
                     qreal temp = categoryTop(i);
-                    if (temp > top) {
+                    if (temp > top)
                         top = temp;
                 }
                 return top;
             }
                 int count = categoryCount();
                 for (int i = 0; i < count; i++) {
                     qreal temp = categoryBottom(i);
-                    if (temp < bottom) {
+                    if (temp < bottom)
                         bottom = temp;
                 }
                 return bottom;
             }
             bool QAbstractBarSeriesPrivate::append(QBarSet *set)
             {
-                if ((m_barSets.contains(set)) || (set == 0)) {
+                if ((m_barSets.contains(set)) || (set == 0))
-                    // Fail if set is already in list or set is null.
+                    return false; // Fail if set is already in list or set is null.
-                    return false;
                 m_barSets.append(set);
                 QObject::connect(set->d_ptr.data(), SIGNAL(updatedLayout()), this, SIGNAL(updatedLayout()));
             bool QAbstractBarSeriesPrivate::remove(QBarSet *set)
             {
-                if (!m_barSets.contains(set)) {
+                if (!m_barSets.contains(set))
-                    // Fail if set is not in list
+                    return false; // Fail if set is not in list
-                    return false;
                 m_barSets.removeOne(set);
                 QObject::disconnect(set->d_ptr.data(), SIGNAL(updatedLayout()), this, SIGNAL(updatedLayout()));
             bool QAbstractBarSeriesPrivate::append(QList<QBarSet* > sets)
             {
                 foreach (QBarSet *set, sets) {
-                    if ((set == 0) || (m_barSets.contains(set))) {
+                    if ((set == 0) || (m_barSets.contains(set)))
-                        // Fail if any of the sets is null or is already appended.
+                        return false; // Fail if any of the sets is null or is already appended.
-                        return false;
+                    if (sets.count(set) != 1)
+                        return false; // Also fail if same set is more than once in given list.
-                    if (sets.count(set) != 1) {
-                        // Also fail if same set is more than once in given list.
-                        return false;
                 }
                 foreach (QBarSet *set, sets) {
             bool QAbstractBarSeriesPrivate::remove(QList<QBarSet* > sets)
             {
-                if (sets.count() == 0) {
+                if (sets.count() == 0)
                     return false;
                 foreach (QBarSet *set, sets) {
-                    if ((set == 0) || (!m_barSets.contains(set))) {
+                    if ((set == 0) || (!m_barSets.contains(set)))
-                        // Fail if any of the sets is null or is not in series
+                        return false; // Fail if any of the sets is null or is not in series
-                        return false;
+                    if (sets.count(set) != 1)
+                        return false; // Also fail if same set is more than once in given list.
-                    if (sets.count(set) != 1) {
-                        // Also fail if same set is more than once in given list.
-                        return false;
                 }
                 foreach (QBarSet *set, sets) {
             bool QAbstractBarSeriesPrivate::insert(int index, QBarSet *set)
             {
-                if ((m_barSets.contains(set)) || (set == 0)) {
+                if ((m_barSets.contains(set)) || (set == 0))
-                    // Fail if set is already in list or set is null.
+                    return false; // Fail if set is already in list or set is null.
-                    return false;
                 m_barSets.insert(index, set);
                 QObject::connect(set->d_ptr.data(), SIGNAL(updatedLayout()), this, SIGNAL(updatedLayout()));
                 Q_Q(QAbstractBarSeries);
                 if (axis->type() == QAbstractAxis::AxisTypeBarCategory) {
                     switch (q->type()) {
                     case QAbstractSeries::SeriesTypeHorizontalBar:
                     case QAbstractSeries::SeriesTypeHorizontalPercentBar:
-                        case QAbstractSeries::SeriesTypeHorizontalStackedBar: {
+                    case QAbstractSeries::SeriesTypeHorizontalStackedBar:
                         if (axis->orientation() == Qt::Vertical)
                             populateCategories(qobject_cast<QBarCategoryAxis*>(axis));
                         break;
                     case QAbstractSeries::SeriesTypeBar:
                     case QAbstractSeries::SeriesTypePercentBar:
-                        case QAbstractSeries::SeriesTypeStackedBar: {
+                    case QAbstractSeries::SeriesTypeStackedBar:
                         if (axis->orientation() == Qt::Horizontal)
                             populateCategories(qobject_cast<QBarCategoryAxis*>(axis));
                         break;
                     default:
                         qWarning() << "Unexpected series type";
                         break;
                     }
                 }
             }
                 Q_Q(const QAbstractBarSeries);
                 switch (q->type()) {
                 case QAbstractSeries::SeriesTypeHorizontalBar:
                 case QAbstractSeries::SeriesTypeHorizontalPercentBar:
-                    case QAbstractSeries::SeriesTypeHorizontalStackedBar: {
+                case QAbstractSeries::SeriesTypeHorizontalStackedBar:
                     if (orientation == Qt::Vertical)
                         return QAbstractAxis::AxisTypeBarCategory;
                     break;
                 case QAbstractSeries::SeriesTypeBar:
                 case QAbstractSeries::SeriesTypePercentBar:
-                    case QAbstractSeries::SeriesTypeStackedBar: {
+                case QAbstractSeries::SeriesTypeStackedBar:
                     if (orientation == Qt::Horizontal)
                         return QAbstractAxis::AxisTypeBarCategory;
                     break;
                 default:
                     qWarning() << "Unexpected series type";
                     break;
                 }
                 return QAbstractAxis::AxisTypeValue;
             #include "moc_qabstractbarseries.cpp"
             #include "moc_qabstractbarseries_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/qabstractbarseries.h 0 0

NO CONTENT: modified file

src/barchart/qbarmodelmapper.cpp +4 -5

                     return;
                 Q_D(QBarModelMapper);
-                if (d->m_model) {
+                if (d->m_model)
                     disconnect(d->m_model, 0, d, 0);
                 d->m_model = model;
                 d->initializeBarFromModel();
             void QBarModelMapper::setSeries(QAbstractBarSeries *series)
             {
                 Q_D(QBarModelMapper);
-                if (d->m_series) {
+                if (d->m_series)
                     disconnect(d->m_series, 0, d, 0);
                 if (series == 0)
                     return;
                     return;
                 int maxCount = 0;
-                for(int i = 0; i < sets.count(); i++)
+                for (int i = 0; i < sets.count(); i++) {
                     if (sets.at(i)->count() > m_count)
                         maxCount = sets.at(i)->count();
+                }
                 if (m_count != -1 && m_count < maxCount)
                     m_count = maxCount;

src/barchart/qbarmodelmapper.h 0 0

NO CONTENT: modified file

src/barchart/qbarmodelmapper_p.h 0 0

NO CONTENT: modified file

src/barchart/qbarset.cpp +12 -24

                 Constructs QBarSet with a label of \a label and with parent of \a parent
             */
             QBarSet::QBarSet(const QString label, QObject *parent)
-                : QObject(parent)
+                : QObject(parent),
-                ,d_ptr(new QBarSetPrivate(label,this))
+                  d_ptr(new QBarSetPrivate(label, this))
             {
             }
             void QBarSet::remove(const int index, const int count)
             {
                 int removedCount = d_ptr->remove(index, count);
-                if (removedCount > 0) {
+                if (removedCount > 0)
                     emit valuesRemoved(index, removedCount);
                 return;
             }
             */
             qreal QBarSet::at(const int index) const
             {
-                if (index < 0 || index >= d_ptr->m_values.count()) {
+                if (index < 0 || index >= d_ptr->m_values.count())
                     return 0;
                 return d_ptr->m_values.at(index).y();
             }
             qreal QBarSet::sum() const
             {
                 qreal total(0);
-                for (int i=0; i < d_ptr->m_values.count(); i++) {
+                for (int i = 0; i < d_ptr->m_values.count(); i++)
                     total += d_ptr->m_values.at(i).y();
                 return total;
             }
             void QBarSetPrivate::append(QList<QPointF> values)
             {
-                for (int i=0; i<values.count(); i++) {
+                for (int i = 0; i < values.count(); i++)
                     m_values.append(values.at(i));
                 emit restructuredBars();
             }
             {
                 int removeCount = count;
-                if ((index <0) || (m_values.count() == 0)) {
+                if ((index < 0) || (m_values.count() == 0))
-                    // Invalid index or not values in list, remove nothing.
+                    return 0; // Invalid index or not values in list, remove nothing.
-                    return 0;
+                else if ((index + count) > m_values.count())
-                } else if ((index + count) > m_values.count()) {
+                    removeCount = m_values.count() - index; // Trying to remove more items than list has. Limit amount to be removed.
-                    // Trying to remove more items than list has. Limit amount to be removed.
-                    removeCount = m_values.count() - index;
                 int c = 0;
                 while (c < removeCount) {
             qreal QBarSetPrivate::pos(const int index)
             {
-                if (index < 0 || index >= m_values.count()) {
+                if (index < 0 || index >= m_values.count())
                     return 0;
                 return m_values.at(index).x();
             }
             qreal QBarSetPrivate::value(const int index)
             {
-                if (index < 0 || index >= m_values.count()) {
+                if (index < 0 || index >= m_values.count())
                     return 0;
                 return m_values.at(index).y();
             }

src/barchart/qbarset.h 0 0

NO CONTENT: modified file

src/barchart/vertical/bar/barchartitem.cpp +6 -8

                         layout.append(rect);
                         bar->setPen(barSet->m_pen);
                         bar->setBrush(barSet->m_brush);
-                        if (qFuzzyIsNull(rectHeight)) {
+                        if (qFuzzyIsNull(rectHeight))
                             bar->setVisible(false);
-                        } else {
+                        else
                             bar->setVisible(barsVisible);
                         QGraphicsSimpleTextItem* label = m_labels.at(itemIndex);
-                        if (!qFuzzyIsNull(barSet->value(category))) {
+                        if (!qFuzzyIsNull(barSet->value(category)))
                             label->setText(QString::number(barSet->value(category)));
-                        } else {
+                        else
                             label->setText(QString(""));
-                        label->setPos(xPos + (rect.width()/2 - label->boundingRect().width()/2)
+                        label->setPos(xPos + (rect.width() / 2 - label->boundingRect().width() / 2),
-                                      ,yPos - rectHeight/2 - label->boundingRect().height()/2);
+                                      yPos - rectHeight / 2 - label->boundingRect().height() / 2);
                         label->setFont(barSet->m_labelFont);
                         label->setBrush(barSet->m_labelBrush);

src/barchart/vertical/bar/qbarseries.cpp +2 -4

             QBarSeries::~QBarSeries()
             {
                 Q_D(QBarSeries);
-                if(d->m_dataset) {
+                if (d->m_dataset)
                     d->m_dataset->removeSeries(this);
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QBarSeriesPrivate::QBarSeriesPrivate(QBarSeries *q) : QAbstractBarSeriesPrivate(q)
                 Q_Q(QBarSeries);
                 BarChartItem* bar = new BarChartItem(q, presenter);
-                if(presenter->animationOptions().testFlag(QChart::SeriesAnimations)) {
+                if (presenter->animationOptions().testFlag(QChart::SeriesAnimations))
                     bar->setAnimation(new BarAnimation(bar));
                 presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
                 return bar;
             }

src/barchart/vertical/percent/percentbarchartitem.cpp +4 -5

                         Bar* bar = m_bars.at(itemIndex);
                         bar->setPen(barSet->m_pen);
                         bar->setBrush(barSet->m_brush);
-                        if (qFuzzyIsNull(rectHeight)) {
+                        if (qFuzzyIsNull(rectHeight))
                             bar->setVisible(false);
-                        } else {
+                        else
                             bar->setVisible(barsVisible);
                         QRectF rect(xPos, yPos - rectHeight, rectWidth, rectHeight);
                         layout.append(rect);
                             label->setText(QString(""));
                         }
-                        label->setPos(xPos + (rect.width()/2 - label->boundingRect().width()/2)
+                        label->setPos(xPos + (rect.width() / 2 - label->boundingRect().width() / 2),
-                                      ,yPos - rectHeight/2 - label->boundingRect().height()/2);
+                                      yPos - rectHeight / 2 - label->boundingRect().height() / 2);
                         label->setFont(barSet->m_labelFont);
                         label->setBrush(barSet->m_labelBrush);

src/barchart/vertical/percent/qpercentbarseries.cpp +2 -4

             QPercentBarSeries::~QPercentBarSeries()
             {
                 Q_D(QPercentBarSeries);
-                if(d->m_dataset) {
+                if (d->m_dataset)
                     d->m_dataset->removeSeries(this);
             }
             /*!
                 Returns QChartSeries::SeriesTypePercentBar.
                 Q_Q(QPercentBarSeries);
                 PercentBarChartItem* bar = new PercentBarChartItem(q, presenter);
-                if(presenter->animationOptions().testFlag(QChart::SeriesAnimations)) {
+                if (presenter->animationOptions().testFlag(QChart::SeriesAnimations))
                     bar->setAnimation(new PercentBarAnimation(bar));
                 presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
                 return bar;
             }

src/barchart/vertical/stacked/qstackedbarseries.cpp +2 -4

             QStackedBarSeries::~QStackedBarSeries()
             {
                 Q_D(QStackedBarSeries);
-                if(d->m_dataset) {
+                if (d->m_dataset)
                     d->m_dataset->removeSeries(this);
             }
             /*!
                 Returns QChartSeries::SeriesTypeStackedBar.
             */
                 Q_Q(QStackedBarSeries);
                 StackedBarChartItem* bar = new StackedBarChartItem(q, presenter);
-                if(presenter->animationOptions().testFlag(QChart::SeriesAnimations)) {
+                if (presenter->animationOptions().testFlag(QChart::SeriesAnimations))
                     bar->setAnimation(new StackedBarAnimation(bar));
                 presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
                 return bar;
             }

src/barchart/vertical/stacked/stackedbarchartitem.cpp +9 -10

                         Bar* bar = m_bars.at(itemIndex);
                         bar->setPen(barSet->m_pen);
                         bar->setBrush(barSet->m_brush);
-                        if (qFuzzyIsNull(rectHeight)) {
+                        if (qFuzzyIsNull(rectHeight))
                             bar->setVisible(false);
-                        } else {
+                        else
                             bar->setVisible(barsVisible);
                         QGraphicsSimpleTextItem* label = m_labels.at(itemIndex);
-                        if (!qFuzzyIsNull(barSet->value(category))) {
+                        if (!qFuzzyIsNull(barSet->value(category)))
                             label->setText(QString::number(barSet->value(category)));
-                        } else {
+                        else
                             label->setText(QString(""));
                         label->setFont(barSet->m_labelFont);
                         label->setBrush(barSet->m_labelBrush);
                         if (rectHeight < 0) {
                             QRectF rect(xPos, yMax - rectHeight, rectWidth, rectHeight);
                             layout.append(rect);
-                            label->setPos(xPos + (rect.width()/2 - label->boundingRect().width()/2)
+                            label->setPos(xPos + (rect.width() / 2 - label->boundingRect().width() / 2),
-                                          ,yMax - rectHeight/2 - label->boundingRect().height()/2);
+                                          yMax - rectHeight / 2 - label->boundingRect().height() / 2);
                             yMax -= rectHeight;
                         } else {
                             QRectF rect(xPos, yMin - rectHeight, rectWidth, rectHeight);
                             layout.append(rect);
-                            label->setPos(xPos + (rect.width()/2 - label->boundingRect().width()/2)
+                            label->setPos(xPos + (rect.width() / 2 - label->boundingRect().width() / 2),
-                                          ,yMin - rectHeight/2 - label->boundingRect().height()/2);
+                                          yMin - rectHeight / 2 - label->boundingRect().height() / 2);
                             yMin -= rectHeight;
                         }

src/chartbackground.cpp +4 -3

             int ChartBackground::roundness(qreal size) const
             {
-                if(qFuzzyIsNull(size)) return 0;
+                if (qFuzzyIsNull(size))
+                    return 0;
                 return 100 * m_diameter / int(size);
             }
                 return m_diameter;
             }
-            void ChartBackground::setDimeter(int dimater)
+            void ChartBackground::setDiameter(int diameter)
             {
-                m_diameter=dimater;
+                m_diameter = diameter;
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/chartbackground_p.h +1 -1

                 ChartBackground(QGraphicsItem *parent = 0);
                 ~ChartBackground();
-                void setDimeter(int dimater);
+                void setDiameter(int diameter);
                 int diameter() const;
                 void setDropShadowEnabled(bool enabled);
                 bool isDropShadowEnabled() { return m_dropShadow != 0; }

src/chartconfig_p.h +2 -2

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            class ChartConfig {
+            class ChartConfig
+            {
             private:
                 ChartConfig() {
             #if defined(DEVELOPMENT_BUILD) && !defined(QT_NO_DEBUG)

src/chartdataset.cpp +20 -22

                 int key = 0;
                 while (i.hasNext()) {
                     i.next();
-                    if(i.key()!=key) {
+                    if (i.key() != key)
                         break;
                     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* axisY = m_seriesAxisYMap.value(i.key());
-                    if(axisX) typeX&=axisX->type();
+                    if (axisX)
-                    else typeX|=i.key()->d_ptr->defaultAxisType(Qt::Horizontal);
+                        typeX &= axisX->type();
-                    if(axisY) typeY&=axisY->type();
+                    else
-                    else typeY|=i.key()->d_ptr->defaultAxisType(Qt::Vertical);
+                        typeX |= i.key()->d_ptr->defaultAxisType(Qt::Horizontal);
+                    if (axisY)
+                        typeY &= axisY->type();
+                    else
+                        typeY |= i.key()->d_ptr->defaultAxisType(Qt::Vertical);
                 }
                 // Create the axes of the types selected
                     QObject::connect(axis->d_ptr.data(), SIGNAL(updated()), domain, SLOT(handleAxisUpdated()));
                     QObject::connect(domain, SIGNAL(updated()), axis->d_ptr.data(), SLOT(handleDomainUpdated()));
                     m_seriesAxisXMap.insert(series, axis);
+                } else {
-                else {
                     QObject::connect(axis->d_ptr.data(), SIGNAL(updated()), domain, SLOT(handleAxisUpdated()));
                     QObject::connect(domain, SIGNAL(updated()), axis->d_ptr.data(), SLOT(handleDomainUpdated()));
                     m_seriesAxisYMap.insert(series, axis);
                 QMap<QAbstractSeries*, QAbstractAxis*> *seriesAxisMap;
-                if(axis->orientation()==Qt::Vertical) {
+                if (axis->orientation() == Qt::Vertical)
                     seriesAxisMap = &m_seriesAxisYMap;
+                else
-                else {
                     seriesAxisMap = &m_seriesAxisXMap;
                 QMapIterator<QAbstractSeries*, QAbstractAxis*> i(*seriesAxisMap);
                 while (i.hasNext()) {
                     i.next();
-                    if(i.value()==axis) {
+                    if (i.value() == axis)
                         removeSeries(i.key());
                 }
             }
             void ChartDataSet::removeAllSeries()
             {
                 QList<QAbstractSeries*> series =   m_seriesDomainMap.keys();
-                foreach(QAbstractSeries *s , series) {
+                foreach (QAbstractSeries *s , series)
                     removeSeries(s);
                 Q_ASSERT(m_seriesAxisXMap.count() == 0);
                 Q_ASSERT(m_seriesAxisXMap.count() == 0);
                 QMapIterator<QAbstractSeries*, Domain*> i(m_seriesDomainMap);
                 while (i.hasNext()) {
                     i.next();
-                    if(i.key()->type()==type) count++;
+                    if (i.key()->type() == type)
+                        count++;
                 }
                 return count;
             }
                     while (i.hasNext()) {
                         i.next();
-                        if(i.value()->isVisible()) return i.value();
+                        if (i.value()->isVisible())
+                            return i.value();
                     }
                     return 0;
                 }
                 QMap<QAbstractSeries*, QAbstractAxis*> *seriesAxisMap;
-                if(orientation==Qt::Vertical) {
+                if (orientation == Qt::Vertical)
                     seriesAxisMap = &m_seriesAxisYMap;
-                }else{
+                else
                     seriesAxisMap = &m_seriesAxisXMap;
                 if (seriesAxisMap->value(series) == axis) {
                     qWarning() << "The axis already set for the series";

src/chartdataset_p.h 0 0

NO CONTENT: modified file

src/chartelement.cpp +2 -1

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            ChartElement::ChartElement(ChartPresenter *presenter):QObject(presenter),
+            ChartElement::ChartElement(ChartPresenter *presenter)
+                : QObject(presenter),
                   m_presenter(presenter),
                   m_domain(0)
             {

src/chartelement_p.h 0 0

NO CONTENT: modified file

src/chartitem_p.h 0 0

NO CONTENT: modified file

src/chartlayout.cpp +15 -25

             static const qreal golden_ratio = 0.25;
-            ChartLayout::ChartLayout(ChartPresenter* presenter):
+            ChartLayout::ChartLayout(ChartPresenter* presenter)
-                m_presenter(presenter),
+                : m_presenter(presenter),
                   m_margins(20, 20, 20, 20),
                   m_minChartRect(0, 0, 200, 200)
             {
                 contentGeometry = calculateContentGeometry(contentGeometry);
-                if (title && title->isVisible()) {
+                if (title && title->isVisible())
                     contentGeometry = calculateTitleGeometry(contentGeometry, title);
-                if (legend->isAttachedToChart() && legend->isVisible()) {
+                if (legend->isAttachedToChart() && legend->isVisible())
                     contentGeometry = calculateLegendGeometry(contentGeometry, legend);
                 calculateChartGeometry(contentGeometry, axes);
                 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());
             #endif
                 QGraphicsLayout::setGeometry(rect);
                 qreal left, top, right, bottom;
                 getContentsMargins(&left, &top, &right, &bottom);
                 QRectF backgroundGeometry = geometry.adjusted(left, top, -right, -bottom);
-                if(background) background->setRect(backgroundGeometry);
+                if (background)
+                    background->setRect(backgroundGeometry);
                 return backgroundGeometry;
             }
                             rightAxisCount++;
                         else
                             leftAxisCount++;
+                    } else if (axis->orientation() == Qt::Horizontal && axis->isVisible()) {
-                    else if(axis->orientation()==Qt::Horizontal && axis->isVisible()) {
             //            horizontal = horizontal.expandedTo(axis->effectiveSizeHint(Qt::MinimumSize));
                         if (axis->alternativePlacement())
                             topAxisCount++;
                         else
                             bottomAxisCount++;
                     }
                 }
                 qreal width = qMin(vertical.width(), geometry.width() * golden_ratio);
                             rightAxisCount++;
                         else
                             leftAxisCount++;
+                    } else if (axis->orientation() == Qt::Horizontal) {
-                    else if(axis->orientation()==Qt::Horizontal) {
                         axis->setInternalRect(rect.adjusted(0, -topAxisCount * axisWidth, 0, bottomAxisCount * axisWidth));
                         axis->setGeometry(rect.adjusted(0, -(topAxisCount + 1) * axisWidth, 0, (bottomAxisCount + 1) * axisWidth));
                         if (axis->alternativePlacement())
                 // check axis size
                 foreach (ChartAxis *axis , axes) {
-                    if(axis->orientation()==Qt::Vertical && axis->isVisible()){
+                    if (axis->orientation() == Qt::Vertical && axis->isVisible())
                         vertical = vertical.expandedTo(axis->effectiveSizeHint(Qt::MinimumSize));
-                    }else if(axis->orientation()==Qt::Horizontal && axis->isVisible()) {
+                    else if (axis->orientation() == Qt::Horizontal && axis->isVisible())
                         horizontal = horizontal.expandedTo(axis->effectiveSizeHint(Qt::MinimumSize));
                 }
                 return minimum.adjusted(0, 0, horizontal.width() + vertical.width(), horizontal.height() + vertical.height());
             }
                 QRectF result;
                 switch (legend->alignment()) {
-                case Qt::AlignTop: {
+                case Qt::AlignTop:
                     legendRect = QRectF(geometry.topLeft(), QSizeF(geometry.width(), size.height()));
                     result = geometry.adjusted(0, legendRect.height(), 0, 0);
                     break;
+                case Qt::AlignBottom:
-                case Qt::AlignBottom: {
                     legendRect = QRectF(QPointF(geometry.left(), geometry.bottom() - size.height()), QSizeF(geometry.width(), size.height()));
                     result = geometry.adjusted(0, 0, 0, -legendRect.height());
                     break;
                 case Qt::AlignLeft: {
                     qreal width = qMin(size.width(), geometry.width() * golden_ratio);
                     legendRect = QRectF(geometry.topLeft(), QSizeF(width, geometry.height()));
                     result = geometry.adjusted(0, 0, -width, 0);
                     break;
                 }
-                default: {
+                default:
                     legendRect = QRectF(0, 0, 0, 0);
                     result = geometry;
                     break;
                 }
                 legend->setGeometry(legendRect);
                     minimumRect = calculateLegendMinimum(minimumRect, legend);
                     minimumRect = calculateAxisMinimum(minimumRect, axes);
                     return minimumRect.united(m_minChartRect).size().toSize();
-                }else
                 return QSize(-1, -1);
             }
             void ChartLayout::setMargins(const QMargins& margins)
             {
                 if (m_margins != margins) {
                     m_margins = margins;
                     updateGeometry();

src/chartlayout_p.h 0 0

NO CONTENT: modified file

src/chartpresenter.cpp +30 -23

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            ChartPresenter::ChartPresenter(QChart* chart,ChartDataSet* dataset):QObject(chart),
+            ChartPresenter::ChartPresenter(QChart* chart, ChartDataSet* dataset)
+                : QObject(chart),
                   m_chart(chart),
                   m_dataset(dataset),
                   m_chartTheme(0),
                 if (m_chartsRect != rect) {
                     m_chartsRect = rect;
                     foreach (ChartElement *chart, m_chartItems)
                         chart->handleGeometryChanged(rect);
                 }
             }
             QRectF ChartPresenter::chartsGeometry() const
             {
                 ChartAxis* item = axis->d_ptr->createGraphics(this);
                 item->setDomain(domain);
-                if(m_options.testFlag(QChart::GridAxisAnimations)){
+                if (m_options.testFlag(QChart::GridAxisAnimations))
                     item->setAnimation(new AxisAnimation(item));
                 QObject::connect(this, SIGNAL(geometryChanged(QRectF)), item, SLOT(handleGeometryChanged(QRectF)));
                 QObject::connect(domain, SIGNAL(updated()), item, SLOT(handleDomainUpdated()));
                 m_chartTheme->decorate(axis);
                 axis->d_ptr->setDirty(false);
                 axis->d_ptr->emitUpdated();
-                if(m_chartsRect.isValid()) item->handleGeometryChanged(m_chartsRect);
+                if (m_chartsRect.isValid())
+                    item->handleGeometryChanged(m_chartsRect);
                 m_axisItems.insert(axis, item);
                 selectVisibleAxis();
                 //initialize
                 item->handleDomainUpdated();
-                if(m_chartsRect.isValid()) item->handleGeometryChanged(m_chartsRect);
+                if (m_chartsRect.isValid())
+                    item->handleGeometryChanged(m_chartsRect);
                 m_chartItems.insert(series, item);
             }
                     while (i.hasNext()) {
                         i.next();
-                    if(i.key()==axis) {
+                        if (i.key() == axis)
                             continue;
+                        if (i.key()->orientation() == axis->orientation())
-                    if(i.key()->orientation()==axis->orientation()) {
                             i.key()->setVisible(false);
                     }
                 }
             }
             void ChartPresenter::setTheme(QChart::ChartTheme theme, bool force)
             {
-                if(m_chartTheme && m_chartTheme->id() == theme) return;
+                if (m_chartTheme && m_chartTheme->id() == theme)
+                    return;
                 delete m_chartTheme;
                 m_chartTheme = ChartTheme::createTheme(theme);
                 m_chartTheme->setForced(force);
             void ChartPresenter::handleAnimationFinished()
             {
                 m_animations.removeAll(qobject_cast<ChartAnimation*>(sender()));
-               if(m_animations.empty()) emit animationsFinished();
+                if (m_animations.empty())
+                    emit animationsFinished();
             }
             void ChartPresenter::startAnimation(ChartAnimation* animation)
             {
-                if (animation->state() != QAbstractAnimation::Stopped) animation->stop();
+                if (animation->state() != QAbstractAnimation::Stopped)
+                    animation->stop();
                 QObject::connect(animation, SIGNAL(finished()), this, SLOT(handleAnimationFinished()), Qt::UniqueConnection);
-                if(!m_animations.isEmpty()){
+                if (!m_animations.isEmpty())
                     m_animations.append(animation);
                 QTimer::singleShot(0, animation, SLOT(start()));
             }
             QBrush ChartPresenter::backgroundBrush() const
             {
-                if (!m_background) return QBrush();
+                if (!m_background)
+                    return QBrush();
                 return m_background->brush();
             }
             QPen ChartPresenter::backgroundPen() const
             {
-                if (!m_background) return QPen();
+                if (!m_background)
+                    return QPen();
                 return m_background->pen();
             }
             QString ChartPresenter::title() const
             {
-                if (!m_title) return QString();
+                if (!m_title)
+                    return QString();
                 return m_title->text();
             }
             QFont ChartPresenter::titleFont() const
             {
-                if (!m_title)  return QFont();
+                if (!m_title)
+                    return QFont();
                 return m_title->font();
             }
             QBrush ChartPresenter::titleBrush() const
             {
-                if (!m_title) return QBrush();
+                if (!m_title)
+                    return QBrush();
                 return m_title->brush();
             }
             bool ChartPresenter::isBackgroundVisible() const
             {
-                if (!m_background) return false;
+                if (!m_background)
+                    return false;
                 return m_background->isVisible();
             }
             bool ChartPresenter::isBackgroundDropShadowEnabled() const
             {
-                if (!m_background) return false;
+                if (!m_background)
+                    return false;
                 return m_background->isDropShadowEnabled();
             }

src/chartpresenter_p.h 0 0

NO CONTENT: modified file

src/charttheme.cpp +8 -16

                 if (axis->isLineVisible()) {
-                    if(m_force || brush == axis->labelsBrush()){
+                    if (m_force || brush == axis->labelsBrush())
                         axis->setLabelsBrush(m_labelBrush);
-                    if(m_force || pen == axis->labelsPen()){
-                        axis->setLabelsPen(Qt::NoPen); // NoPen for performance reasons
+                    if (m_force || pen == axis->labelsPen())
+                        axis->setLabelsPen(Qt::NoPen); // NoPen for performance reasons
                     if (m_force || axis->shadesVisible()) {
-                        if(m_force || brush == axis->shadesBrush()){
+                        if (m_force || brush == axis->shadesBrush())
                             axis->setShadesBrush(m_backgroundShadesBrush);
-                        if(m_force || pen == axis->shadesPen()){
+                        if (m_force || pen == axis->shadesPen())
                             axis->setShadesPen(m_backgroundShadesPen);
                         if (m_force && (m_backgroundShades == BackgroundShadesBoth
                                         || (m_backgroundShades == BackgroundShadesVertical && axisX)
                                         || (m_backgroundShades == BackgroundShadesHorizontal && !axisX))) {
                             axis->setShadesVisible(true);
                         }
                     }
-                    if(m_force || pen == axis->linePen()){
+                    if (m_force || pen == axis->linePen())
                         axis->setLinePen(m_axisLinePen);
-                    if(m_force || pen == axis->gridLinePen()){
+                    if (m_force || pen == axis->gridLinePen())
                         axis->setGridLinePen(m_gridLinePen);
-                    if(m_force || font == axis->labelsFont()){
+                    if (m_force || font == axis->labelsFont())
                         axis->setLabelsFont(m_labelFont);
                 }
             }
             void ChartTheme::generateSeriesGradients()
             {

src/charttheme_p.h 0 0

NO CONTENT: modified file

src/charttitle.cpp +5 -5

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            ChartTitle::ChartTitle(QGraphicsItem* parent):QGraphicsSimpleTextItem(parent)
+            ChartTitle::ChartTitle(QGraphicsItem* parent)
+                : QGraphicsSimpleTextItem(parent)
             {
             }
                 int width = rect.width();
-              if (fn.boundingRect(m_text).width() > width)
+                if (fn.boundingRect(m_text).width() > width) {
                     QString string = m_text + "...";
                     while (fn.boundingRect(string).width() > width && string.length() > 3)
                         string.remove(string.length() - 4, 1);
                     QGraphicsSimpleTextItem::setText(string);
+                } else {
-              else
                     QGraphicsSimpleTextItem::setText(m_text);
+                }
                 setPos(rect.topLeft());
             }

src/domain.cpp +5 -6

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            Domain::Domain(QObject* parent) : QObject(parent),
+            Domain::Domain(QObject* parent)
+                : QObject(parent),
                   m_minX(0),
                   m_maxX(0),
                   m_minY(0),
                     emit rangeYChanged(m_minY, m_maxY);
                 }
-                if(axisXChanged || axisYChanged) {
+                if (axisXChanged || axisYChanged)
                     emit updated();
             }
             void Domain::setRangeX(qreal min, qreal max)
             {
                 QAbstractAxisPrivate* axis = qobject_cast<QAbstractAxisPrivate*>(sender());
                 Q_ASSERT(axis);
                 axis->setDirty(false);
-                if(axis->orientation()==Qt::Horizontal){
+                if (axis->orientation() == Qt::Horizontal)
                     setRangeX(axis->min(), axis->max());
-                }else if(axis->orientation()==Qt::Vertical){
+                else if (axis->orientation() == Qt::Vertical)
                     setRangeY(axis->min(), axis->max());
             }
             bool QTCOMMERCIALCHART_AUTOTEST_EXPORT operator== (const Domain &domain1, const Domain &domain2)
             {

src/domain_p.h +2 -1

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            class QTCOMMERCIALCHART_AUTOTEST_EXPORT Domain: public QObject {
+            class QTCOMMERCIALCHART_AUTOTEST_EXPORT Domain: public QObject
+            {
                 Q_OBJECT
             public:
                 explicit Domain(QObject* object = 0);

src/legend/legendlayout.cpp +33 -44

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            LegendLayout::LegendLayout(QLegend* legend):
+            LegendLayout::LegendLayout(QLegend* legend)
-            m_legend(legend)
+                : m_legend(legend)
             {
             }
                 bool scrollHorizontal = true;
                 switch (m_legend->alignment()) {
                 case Qt::AlignTop:
-                    case Qt::AlignBottom: {
+                case Qt::AlignBottom:
                     scrollHorizontal = true;
                     break;
                 case Qt::AlignLeft:
-                    case Qt::AlignRight: {
+                case Qt::AlignRight:
                     scrollHorizontal = false;
                     break;
                 }
                 // If detached, the scrolling direction is vertical instead of horizontal and vice versa.
-                if (!m_legend->isAttachedToChart()) {
+                if (!m_legend->isAttachedToChart())
                     scrollHorizontal = !scrollHorizontal;
                 QRectF boundingRect = geometry();
                 qreal left, top, right, bottom;
                 // Limit offset between m_minOffset and m_maxOffset
                 if (scrollHorizontal) {
-                    if(m_width<=boundingRect.width()) return;
+                    if (m_width <= boundingRect.width())
+                        return;
                     if (x != m_offsetX) {
                         m_offsetX = qBound(m_minOffsetX, x, m_maxOffsetX);
                         m_legend->d_ptr->items()->setPos(-m_offsetX, boundingRect.top());
                     }
+                } else {
-                else {
+                    if (m_height <= boundingRect.height())
-                    if(m_height<=boundingRect.height()) return;
+                        return;
                     if (y != m_offsetY) {
                         m_offsetY = qBound(m_minOffsetY, y, m_maxOffsetY);
             void LegendLayout::invalidate()
             {
                 QGraphicsLayout::invalidate();
-                if(m_legend->isAttachedToChart()){
+                if (m_legend->isAttachedToChart())
                     m_legend->d_ptr->m_presenter->layout()->invalidate();
             }
             void LegendLayout::setGeometry(const QRectF& rect)
             {
                 QGraphicsLayout::setGeometry(rect);
-                if(m_legend->isAttachedToChart()) {
+                if (m_legend->isAttachedToChart())
                     setAttachedGeometry(rect);
-                } else {
+                else
                     setDettachedGeometry(rect);
             }
             void LegendLayout::setAttachedGeometry(const QRectF& rect)
             {
-                if (!rect.isValid()) return;
+                if (!rect.isValid())
+                    return;
                 m_offsetX = 0;
                 m_offsetY = 0;
                 QSizeF size(0, 0);
-                if( m_legend->d_ptr->markers().isEmpty()) return;
+                if (m_legend->d_ptr->markers().isEmpty())
+                    return;
                 m_width = 0;
                 m_height = 0;
                 QRectF geometry = rect.adjusted(left, top, -right, -bottom);
                 switch (m_legend->alignment()) {
                 case Qt::AlignTop:
                 case Qt::AlignBottom: {
                         QPointF point(0, 0);
                                 point.setX(point.x() + w);
                             }
                         }
-                        if(m_width<geometry.width()) {
+                        if (m_width < geometry.width())
                             m_legend->d_ptr->items()->setPos(geometry.width() / 2 - m_width / 2, geometry.top());
+                        else
-                        else {
                             m_legend->d_ptr->items()->setPos(geometry.topLeft());
                         m_height = size.height();
                     }
                     break;
                             point.setY(point.y() + h);
                         }
                     }
-                        if(m_height<geometry.height()) {
+                    if (m_height < geometry.height())
                         m_legend->d_ptr->items()->setPos(geometry.left(), geometry.height() / 2 - m_height / 2);
+                    else
-                        else {
                         m_legend->d_ptr->items()->setPos(geometry.topLeft());
                     m_width = size.width();
                     break;
                     }
+                }
                 m_minOffsetX = -left;
                 m_minOffsetY = - top;
             void LegendLayout::setDettachedGeometry(const QRectF& rect)
             {
-                if (!rect.isValid()) return;
+                if (!rect.isValid())
+                    return;
                 // Detached layout is different.
                 // In detached mode legend may have multiple rows and columns, so layout calculations
                 QList<LegendMarker *> markers = m_legend->d_ptr->markers();
-                if(markers.isEmpty()) return;
+                if (markers.isEmpty())
+                    return;
                 switch (m_legend->alignment()) {
                 case Qt::AlignTop: {
                 getContentsMargins(&left, &top, &right, &bottom);
                 if (constraint.isValid()) {
-                    foreach(LegendMarker* marker, m_legend->d_ptr->markers()) {
+                    foreach (LegendMarker *marker, m_legend->d_ptr->markers())
                         size = size.expandedTo(marker->effectiveSizeHint(which));
                     size = size.boundedTo(constraint);
+                } else if (constraint.width() >= 0) {
-                else if (constraint.width() >= 0) {
                     qreal width = 0;
                     qreal height = 0;
                     foreach (LegendMarker *marker, m_legend->d_ptr->markers()) {
                     }
                     size = QSizeF(qMin(constraint.width(), width), height);
+                } else if (constraint.height() >= 0) {
-                else if (constraint.height() >= 0) {
                     qreal width = 0;
                     qreal height = 0;
                     foreach (LegendMarker *marker, m_legend->d_ptr->markers()) {
                         height += height, marker->effectiveSizeHint(which).height();
                     }
                     size = QSizeF(width, qMin(constraint.height(), height));
+                } else {
-                else {
+                    foreach (LegendMarker *marker, m_legend->d_ptr->markers())
-                    foreach(LegendMarker* marker, m_legend->d_ptr->markers()) {
                         size = size.expandedTo(marker->effectiveSizeHint(which));
                 }
                 size += QSize(left + right, top + bottom);
                 return size;
             }

src/legend/legendlayout_p.h 0 -1

                 qreal m_maxOffsetY;
                 qreal m_width;
                 qreal m_height;
             };
             QTCOMMERCIALCHART_END_NAMESPACE

src/legend/legendmarker.cpp +12 -15

                 qreal x = m_margin + m_markerRect.width() +  m_space + m_margin;
                 qreal y = qMax(m_markerRect.height() + 2 * m_margin, fn.height() + 2 * m_margin);
-                if (fn.boundingRect(m_text).width() + x > width)
+                if (fn.boundingRect(m_text).width() + x > width) {
                     QString string = m_text + "...";
                     while (fn.boundingRect(string).width() + x > width && string.length() > 3)
                         string.remove(string.length() - 4, 1);
                     m_textItem->setText(string);
+                } else {
-                else
                     m_textItem->setText(m_text);
+                }
                 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);
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-            AreaLegendMarker::AreaLegendMarker(QAreaSeries *series,QLegend *legend) : LegendMarker(series,legend),
+            AreaLegendMarker::AreaLegendMarker(QAreaSeries *series, QLegend *legend)
+                : LegendMarker(series, legend),
                   m_series(series)
             {
                 //QObject::connect(this, SIGNAL(selected()), series, SIGNAL(selected()));
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-            BarLegendMarker::BarLegendMarker(QAbstractBarSeries *barseries,QBarSet *barset, QLegend *legend) : LegendMarker(barseries,legend),
+            BarLegendMarker::BarLegendMarker(QAbstractBarSeries *barseries, QBarSet *barset, QLegend *legend)
+                : LegendMarker(barseries, legend),
                   m_barset(barset)
             {
                 //QObject::connect(this, SIGNAL(selected()),barset->d_ptr.data(), SIGNAL(selected()));
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-            PieLegendMarker::PieLegendMarker(QPieSeries* series,QPieSlice *pieslice, QLegend *legend) : LegendMarker(series,legend),
+            PieLegendMarker::PieLegendMarker(QPieSeries* series, QPieSlice *pieslice, QLegend *legend)
+                : LegendMarker(series, legend),
                   m_pieslice(pieslice)
             {
                 QObject::connect(pieslice, SIGNAL(labelChanged()), this, SLOT(updated()));
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-            XYLegendMarker::XYLegendMarker(QXYSeries *series, QLegend *legend) : LegendMarker(series,legend),
+            XYLegendMarker::XYLegendMarker(QXYSeries *series, QLegend *legend)
+                : LegendMarker(series, legend),
                   m_series(series)
             {
                 //QObject::connect(this, SIGNAL(selected()), series, SIGNAL(selected()));
                 setLabel(m_series->name());
                 if (m_series->type() == QAbstractSeries::SeriesTypeScatter)
                     setBrush(m_series->brush());
+                else
-                else {
                     setBrush(QBrush(m_series->pen().color()));
             }
             #include "moc_legendmarker_p.cpp"

src/legend/legendmarker_p.h 0 0

NO CONTENT: modified file

src/legend/legendscroller_p.h +9 -20

@@ -41,28 +41,17 class LegendScroller: public QLegend, public Scroller
41	{	41	{
42		42
43	public:	43	public:
44	LegendScroller(QChart *chart):QLegend(chart)	44	LegendScroller(QChart *chart): QLegend(chart) { }
45	{
46	}
47		45
48	void setOffset(const QPointF& point)	46	void setOffset(const QPointF& point) { d_ptr->setOffset(point.x(), point.y()); }
49	{	47
50	d_ptr->setOffset(point.x(), point.y());	48	QPointF offset() const { return d_ptr->offset(); }
51	}	49
52	QPointF offset() const	50	void mousePressEvent(QGraphicsSceneMouseEvent* event) { Scroller::mousePressEvent(event); }
53	{	51
54	return d_ptr->offset();	52	void mouseMoveEvent(QGraphicsSceneMouseEvent* event) { Scroller::mouseMoveEvent(event); }
55	}
56		53
57	void mouse~~Press~~Event(QGraphicsSceneMouseEvent* event){	54	void mouseReleaseEvent(QGraphicsSceneMouseEvent* event) { Scroller::mouseReleaseEvent(event); }
58	Scroller::mousePressEvent(event);
59	}
60	void mouseMoveEvent(QGraphicsSceneMouseEvent* event){
61	Scroller::mouseMoveEvent(event);
62	}
63	void mouseReleaseEvent(QGraphicsSceneMouseEvent* event){
64	Scroller::mouseReleaseEvent(event);
65	}
66	};	55	};
67		56
68	QTCOMMERCIALCHART_END_NAMESPACE	57	QTCOMMERCIALCHART_END_NAMESPACE

src/legend/qlegend.cpp +8 -10

                 Q_UNUSED(option)
                 Q_UNUSED(widget)
-                if(!d_ptr->m_backgroundVisible) return;
+                if (!d_ptr->m_backgroundVisible)
+                    return;
                 painter->setOpacity(opacity());
                 painter->setPen(d_ptr->m_pen);
                 painter->setBrush(d_ptr->m_brush);
                 painter->drawRoundRect(rect(), d_ptr->roundness(rect().width()), d_ptr->roundness(rect().height()));
             }
             {
                 if (d_ptr->m_font != font) {
                     d_ptr->m_font = font;
+                    foreach (LegendMarker *marker, d_ptr->markers())
-                    foreach (LegendMarker *marker, d_ptr->markers()) {
                         marker->setFont(d_ptr->m_font);
                     layout()->invalidate();
                     emit fontChanged(font);
                 }
              */
             void QLegend::hideEvent(QHideEvent *event)
             {
-               if(isAttachedToChart()) d_ptr->m_presenter->layout()->invalidate();
+                if (isAttachedToChart())
+                    d_ptr->m_presenter->layout()->invalidate();
                 QGraphicsWidget::hideEvent(event);
             }
             /*!
             ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-            QLegendPrivate::QLegendPrivate(ChartPresenter* presenter, QChart *chart, QLegend *q):
+            QLegendPrivate::QLegendPrivate(ChartPresenter* presenter, QChart *chart, QLegend *q)
-                q_ptr(q),
+                : q_ptr(q),
                   m_presenter(presenter),
                   m_layout(new LegendLayout(q)),
                   m_chart(chart),
                 Q_ASSERT(series);
                 foreach (LegendMarker *marker, m_markers) {
-                    if (marker->series() == series) {
+                    if (marker->series() == series)
                         marker->setVisible(series->isVisible());
                 }
                 m_layout->invalidate();
             }

src/legend/qlegend_p.h 0 -1

                 friend class QLegend;
                 friend class LegendLayout;
             };
             QTCOMMERCIALCHART_END_NAMESPACE

src/linechart/linechartitem.cpp +5 -9

             const qreal mouseEventMinWidth(12);
-            LineChartItem::LineChartItem(QLineSeries* series,ChartPresenter *presenter):
+            LineChartItem::LineChartItem(QLineSeries* series, ChartPresenter *presenter)
-                XYChart(series, presenter),
+                : XYChart(series, presenter),
                   QGraphicsItem(presenter ? presenter->rootItem() : 0),
                   m_series(series),
                   m_pointsVisible(false)
             {
                 m_points = geometryPoints();
-                if(m_points.size()==0)
+                if (m_points.size() == 0) {
                     prepareGeometryChange();
                     m_path = QPainterPath();
                     m_rect = QRect();
                     }
                 } else {
+                    for (int i = 1; i < m_points.size(); i++)
-                    for(int i=1; i< m_points.size();i++) {
                         linePath.lineTo(m_points.at(i));
                 }
                 m_linePath = linePath;
                 if (m_pointsVisible) {
                     painter->drawPath(m_linePath);
+                } else {
-                else {
                     for (int i(1); i < m_points.size(); i++)
                         painter->drawLine(m_points.at(i - 1), m_points.at(i));
                 }

src/linechart/linechartitem_p.h 0 0

NO CONTENT: modified file

src/linechart/qlineseries.cpp +6 -6

                 Constructs empty series object which is a child of \a parent.
                 When series object is added to QChartView or QChart instance ownerships is transferred.
             */
-            QLineSeries::QLineSeries(QObject *parent) : QXYSeries(*new QLineSeriesPrivate(this),parent)
+            QLineSeries::QLineSeries(QObject *parent)
+                : QXYSeries(*new QLineSeriesPrivate(this), parent)
             {
             }
             /*!
                 \internal
             */
-            QLineSeries::QLineSeries(QLineSeriesPrivate &d,QObject *parent) : QXYSeries (d,parent)
+            QLineSeries::QLineSeries(QLineSeriesPrivate &d, QObject *parent)
+                : QXYSeries(d, parent)
             {
             }
             QLineSeries::~QLineSeries()
             {
                 Q_D(QLineSeries);
-                if(d->m_dataset){
+                if (d->m_dataset)
                     d->m_dataset->removeSeries(this);
             }
             QAbstractSeries::SeriesType QLineSeries::type() const
             {
             {
                 Q_Q(QLineSeries);
                 LineChartItem* line = new LineChartItem(q, presenter);
-                if(presenter->animationOptions().testFlag(QChart::SeriesAnimations)) {
+                if (presenter->animationOptions().testFlag(QChart::SeriesAnimations))
                     line->setAnimation(new XYAnimation(line));
                 presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
                 return line;
             }

src/linechart/qlineseries.h 0 0

NO CONTENT: modified file

src/piechart/piechartitem.cpp +1 -2

                     PieSliceItem *sliceItem = m_sliceItems.value(slice);
                     if (sliceItem) {
                         PieSliceData sliceData = updateSliceGeometry(slice);
-                        if (m_animation){
+                        if (m_animation)
                             presenter()->startAnimation(m_animation->updateValue(sliceItem, sliceData));
                         else
                             sliceItem->setLayout(sliceData);
                     }

src/piechart/piesliceitem.cpp +3 -6

                     painter->setBrush(m_data.m_labelBrush);
                     painter->setFont(m_data.m_labelFont);
-                    switch (m_data.m_labelPosition)
+                    switch (m_data.m_labelPosition) {
                     case QPieSlice::LabelOutside:
                         painter->setClipRect(parentItem()->boundingRect());
                         painter->strokePath(m_labelArmPath, m_data.m_labelBrush.color());
                 m_labelArmPath = labelArmPath(armStart, centerAngle, m_data.m_radius * m_data.m_labelArmLengthFactor, m_labelTextRect.width(), &labelTextStart);
                 // text position
-                switch (m_data.m_labelPosition)
+                switch (m_data.m_labelPosition) {
                 case QPieSlice::LabelOutside:
                     m_labelTextRect.moveBottomLeft(labelTextStart);
                     break;
                 if (angle < 180) { // arm swings the other way on the left side
                     parm2 += QPointF(textWidth, 0);
                     *textStart = parm1;
+                } else {
-                else {
                     parm2 += QPointF(-textWidth, 0);
                     *textStart = parm2;
                 }

src/piechart/qpiemodelmapper.cpp 0 0

NO CONTENT: modified file

src/piechart/qpieseries.cpp +3 -4

             /*!
                 Constructs a series object which is a child of \a parent.
             */
-            QPieSeries::QPieSeries(QObject *parent) :
+            QPieSeries::QPieSeries(QObject *parent)
-                QAbstractSeries(*new QPieSeriesPrivate(this),parent)
+                : QAbstractSeries(*new QPieSeriesPrivate(this), parent)
             {
                 Q_D(QPieSeries);
                 QObject::connect(this, SIGNAL(countChanged()), d, SIGNAL(countChanged()));
             {
                 Q_Q(QPieSeries);
                 PieChartItem* pie = new PieChartItem(q, presenter);
-                if(presenter->animationOptions().testFlag(QChart::SeriesAnimations)) {
+                if (presenter->animationOptions().testFlag(QChart::SeriesAnimations))
                     pie->setAnimation(new PieAnimation(pie));
                 presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
                 return pie;
             }

src/piechart/qpieslice.cpp 0 0

NO CONTENT: modified file

src/qabstractseries.cpp +4 -3

             */
             QAbstractSeries::~QAbstractSeries()
             {
-                if(d_ptr->m_dataset) qFatal("Still binded series detected !");
+                if (d_ptr->m_dataset)
+                    qFatal("Still binded series detected !");
             }
             void QAbstractSeries::setName(const QString& name)
             ///////////////////////////////////////////////////////////////////////////////////////////////////
-            QAbstractSeriesPrivate::QAbstractSeriesPrivate(QAbstractSeries* q):
+            QAbstractSeriesPrivate::QAbstractSeriesPrivate(QAbstractSeries* q)
-                q_ptr(q),
+                : q_ptr(q),
                   m_chart(0),
                   m_dataset(0),
                   m_visible(true),

src/qchart.cpp +2 -1

             /*!
              Constructs a chart object which is a child of a\a parent. Parameter \a wFlags is passed to the QGraphicsWidget constructor.
              */
-            QChart::QChart(QGraphicsItem *parent, Qt::WindowFlags wFlags) : QGraphicsWidget(parent,wFlags),
+            QChart::QChart(QGraphicsItem *parent, Qt::WindowFlags wFlags)
+                : QGraphicsWidget(parent, wFlags),
                   d_ptr(new QChartPrivate())
             {
                 d_ptr->m_dataset = new ChartDataSet(this);

src/qchart.h 0 0

NO CONTENT: modified file

src/qchart_p.h 0 -1

                 ChartPresenter *m_presenter;
                 void createConnections();
             };
             QTCOMMERCIALCHART_END_NAMESPACE

src/qchartglobal.h 0 0

NO CONTENT: modified file

src/qchartview.cpp +11 -13

                 Constructs a chartView object with parent \a parent.
             */
-            QChartView::QChartView(QWidget *parent) :
+            QChartView::QChartView(QWidget *parent)
-                QGraphicsView(parent),
+                : QGraphicsView(parent),
                   d_ptr(new QChartViewPrivate(this))
             {
                 Constructs a chartView object with parent \a parent to display a \a chart.
             */
-            QChartView::QChartView(QChart *chart,QWidget *parent) :
+            QChartView::QChartView(QChart *chart, QWidget *parent)
-                QGraphicsView(parent),
+                : QGraphicsView(parent),
                   d_ptr(new QChartViewPrivate(this, chart))
             {
                         d_ptr->m_rubberBand->show();
                         event->accept();
                     }
+                } else {
-                else {
                     QGraphicsView::mousePressEvent(event);
                 }
             }
                         width = rect.width();
                     }
                     d_ptr->m_rubberBand->setGeometry(QRect(d_ptr->m_rubberBandOrigin.x(), d_ptr->m_rubberBandOrigin.y(), width, height).normalized());
+                } else {
-                else {
                     QGraphicsView::mouseMoveEvent(event);
                 }
             }
                         d_ptr->m_chart->zoomOut();
                         event->accept();
                     }
+                } else {
-                else {
                     QGraphicsView::mouseReleaseEvent(event);
                 }
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-            QChartViewPrivate::QChartViewPrivate(QChartView *q,QChart* chart):
+            QChartViewPrivate::QChartViewPrivate(QChartView *q, QChart* chart)
-            q_ptr(q),
+                : q_ptr(q),
                   m_scene(new QGraphicsScene(q)),
                   m_chart(chart),
                   m_rubberBand(0),
                 q_ptr->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
                 q_ptr->setScene(m_scene);
                 q_ptr->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
-                if(!m_chart) m_chart = new QChart();
+                if (!m_chart)
+                    m_chart = new QChart();
                 m_scene->addItem(m_chart);
             }

src/qchartview.h 0 0

NO CONTENT: modified file

src/qchartview_p.h +2 -2

             class QChart;
             class QChartView;
-            class QChartViewPrivate {
+            class QChartViewPrivate
+            {
             public:
                 explicit QChartViewPrivate(QChartView *q, QChart *chart = 0);
                 ~QChartViewPrivate();

src/scatterchart/qscatterseries.cpp +4 -5

             /*!
                 Constructs a series object which is a child of \a parent.
             */
-            QScatterSeries::QScatterSeries(QObject *parent) : QXYSeries(*new QScatterSeriesPrivate(this),parent)
+            QScatterSeries::QScatterSeries(QObject *parent)
+                : QXYSeries(*new QScatterSeriesPrivate(this), parent)
             {
             }
             QScatterSeries::~QScatterSeries()
             {
                 Q_D(QScatterSeries);
-                if(d->m_dataset) {
+                if (d->m_dataset)
                     d->m_dataset->removeSeries(this);
             }
             QAbstractSeries::SeriesType QScatterSeries::type() const
             {
             {
                 Q_Q(QScatterSeries);
                 ScatterChartItem *scatter = new ScatterChartItem(q, presenter);
-                if(presenter->animationOptions().testFlag(QChart::SeriesAnimations)) {
+                if (presenter->animationOptions().testFlag(QChart::SeriesAnimations))
                     scatter->setAnimation(new XYAnimation(scatter));
                 presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
                 return scatter;
             }

src/scatterchart/scatterchartitem.cpp +13 -19

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            ScatterChartItem::ScatterChartItem(QScatterSeries *series, ChartPresenter *presenter) :
+            ScatterChartItem::ScatterChartItem(QScatterSeries *series, ChartPresenter *presenter)
-                XYChart(series,presenter),
+                : XYChart(series, presenter),
                   QGraphicsItem(presenter ? presenter->rootItem() : 0),
                   m_series(series),
                   m_items(this),
                     default:
                         qWarning() << "Unsupported marker type";
                         break;
                     }
                     m_items.addToGroup(item);
                 }
                 const QVector<QPointF>& points = geometryPoints();
-                if(points.size()==0)
+                if (points.size() == 0) {
                     deletePoints(m_items.childItems().count());
                     return;
                 }
                 int diff = m_items.childItems().size() - points.size();
-                if(diff>0) {
+                if (diff > 0)
                     deletePoints(diff);
+                else if (diff < 0)
-                else if(diff<0) {
                     createPoints(-diff);
-                if(diff!=0) handleUpdated();
+                if (diff != 0)
+                    handleUpdated();
                 QList<QGraphicsItem*> items = m_items.childItems();
                     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)) {
+                    if (!m_visible || !clipRect().contains(point))
                         item->setVisible(false);
+                    else
-                    else {
                         item->setVisible(true);
                 }
                 prepareGeometryChange();
                 m_rect = clipRect();
             void ScatterChartItem::setPen(const QPen& pen)
             {
-                foreach(QGraphicsItem* item , m_items.childItems()) {
+                foreach (QGraphicsItem *item , m_items.childItems())
                     static_cast<QAbstractGraphicsShapeItem*>(item)->setPen(pen);
             }
             void ScatterChartItem::setBrush(const QBrush& brush)
             {
-                foreach(QGraphicsItem* item , m_items.childItems()) {
+                foreach (QGraphicsItem *item , m_items.childItems())
                     static_cast<QAbstractGraphicsShapeItem*>(item)->setBrush(brush);
             }
             void ScatterChartItem::handleUpdated()
             {
                 int count = m_items.childItems().count();
-                if(count==0) return;
+                if (count == 0)
+                    return;
                 bool recreate = m_visible != m_series->isVisible()
                                 || m_size != m_series->markerSize()

src/scatterchart/scatterchartitem_p.h +4 -2

             {
             public:
-               CircleMarker(qreal x, qreal y, qreal w, qreal h, ScatterChartItem *parent) : QGraphicsEllipseItem(x,y,w,h,parent),
+               CircleMarker(qreal x, qreal y, qreal w, qreal h, ScatterChartItem *parent)
+                : QGraphicsEllipseItem(x, y, w, h, parent),
                   m_parent(parent)
                {
                }
             {
             public:
-               RectangleMarker(qreal x, qreal y, qreal w, qreal h, ScatterChartItem *parent) : QGraphicsRectItem(x,y,w,h,parent),
+                RectangleMarker(qreal x, qreal y, qreal w, qreal h, ScatterChartItem *parent)
+                    : QGraphicsRectItem(x, y, w, h, parent),
                       m_parent(parent)
                 {
                 }

src/scroller.cpp +9 -31

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            Scroller::Scroller():
+            Scroller::Scroller()
-            m_ticker(this),
+                : m_ticker(this),
                   m_state(Idle),
                   m_moveThreshold(10),
                   m_timeTreshold(50)
             void Scroller::mousePressEvent(QGraphicsSceneMouseEvent* event)
             {
                 if (event->button() == Qt::LeftButton) {
                     switch (m_state) {
                     case Idle:
                         m_state = Pressed;
                         m_offset = offset();
                         m_press = event->pos();
                         m_timeStamp = QTime::currentTime();
                         event->accept();
                         break;
                     case Scroll:
                         m_state = Stop;
                         m_speed = QPointF(0, 0);
                         m_offset = offset();
                         m_press = event->pos();
                         event->accept();
                         break;
                     case Pressed:
                     case Move:
                     case Stop:
                 switch (m_state) {
                 case Pressed:
                 case Stop:
                     if (qAbs(delta.x()) > m_moveThreshold || qAbs(delta.y()) > m_moveThreshold) {
                         m_state = Move;
                         m_timeStamp = QTime::currentTime();
                         m_distance = QPointF(0, 0);
                         m_press = event->pos();
                         event->accept();
-                        break;
+                    } else {
-                    else {
                         event->ignore();
-                        break;
                     }
+                    break;
                 case Move:
                     setOffset(m_offset - delta);
                     calculateSpeed(event->pos());
                     event->accept();
                     break;
                 case Idle:
                 case Scroll:
                     qWarning() << __FUNCTION__ << "Scroller unexpected state" << m_state;
                     event->ignore();
                     break;
                 }
             }
             void Scroller::mouseReleaseEvent(QGraphicsSceneMouseEvent* event)
                         event->accept();
                         break;
                     case Pressed:
                         m_state = Idle;
                         //if (m_timeStamp.elapsed() < m_clickedPressDelay) {
                         //}
                         event->accept();
                         break;
                     case Move:
                         calculateSpeed(event->pos());
                         m_offset = offset();
                         m_press = event->pos();
                         if (m_speed == QPointF(0, 0)) {
                             m_state = Idle;
+                        } else {
-                        else {
                             m_speed /= 3.75;
                             m_state = Scroll;
                             m_ticker.start(25);
                         }
                         event->accept();
                         break;
                     case Stop:
                     case Idle:
                         qWarning() << __FUNCTION__ << "Scroller unexpected state" << m_state;
                         event->ignore();
                         break;
                     }
                 }
             }
             {
                 switch (m_state) {
                 case Scroll:
                     lowerSpeed(m_speed);
                     setOffset(m_offset - m_speed);
                     m_offset = offset();
                         m_ticker.stop();
                     }
                     break;
                 case Stop:
                     m_ticker.stop();
                     break;
                     if (fraction != 0) {
                         m_fraction.setX(qAbs(m_speed.x() / fraction));
                         m_fraction.setY(qAbs(m_speed.y() / fraction));
+                    } else {
-                    else {
                         m_fraction.setX(1);
                         m_fraction.setY(1);
                     }
             /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-            ScrollTicker::ScrollTicker(Scroller *scroller,QObject* parent):QObject(parent),
+            ScrollTicker::ScrollTicker(Scroller *scroller, QObject* parent)
+                : QObject(parent),
                   m_scroller(scroller)
             {
             void ScrollTicker::start(int interval)
             {
-                if (!m_timer.isActive()){
+                if (!m_timer.isActive())
                     m_timer.start(interval, this);
             }
             void ScrollTicker::stop()
             {

src/scroller_p.h 0 -3

             public:
                 void scrollTick();
             public:
                 void mousePressEvent(QGraphicsSceneMouseEvent* event);
                 void mouseMoveEvent(QGraphicsSceneMouseEvent* event);
                 QPointF m_fraction;
                 int m_moveThreshold;
                 int m_timeTreshold;
             };
             QTCOMMERCIALCHART_END_NAMESPACE

src/splinechart/qsplineseries.cpp +10 -14

                 When series object is added to QChartView or QChart instance then the ownerships is transferred.
               */
-            QSplineSeries::QSplineSeries(QObject *parent) :
+            QSplineSeries::QSplineSeries(QObject *parent)
-                QLineSeries(*new QSplineSeriesPrivate(this),parent)
+                : QLineSeries(*new QSplineSeriesPrivate(this), parent)
             {
                 Q_D(QSplineSeries);
                 QObject::connect(this, SIGNAL(pointAdded(int)), d, SLOT(updateControlPoints()));
             QSplineSeries::~QSplineSeries()
             {
                 Q_D(QSplineSeries);
-                if(d->m_dataset){
+                if (d->m_dataset)
                     d->m_dataset->removeSeries(this);
             }
             QAbstractSeries::SeriesType QSplineSeries::type() const
             {
             ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-            QSplineSeriesPrivate::QSplineSeriesPrivate(QSplineSeries* q):QLineSeriesPrivate(q)
+            QSplineSeriesPrivate::QSplineSeriesPrivate(QSplineSeries* q)
+                : QLineSeriesPrivate(q)
             {
             }
                 int n = points.count() - 1;
-                if (n == 1)
+                if (n == 1) {
                     //for n==1
                     m_controlPoints[0].setX((2 * points[0].x() + points[1].x()) / 3);
                     m_controlPoints[0].setY((2 * points[0].y() + points[1].y()) / 3);
                 vector[0] = points[0].x() + 2 * points[1].x();
-                for (int i = 1; i < n - 1; ++i){
+                for (int i = 1; i < n - 1; ++i)
                     vector[i] = 4 * points[i].x() + 2 * points[i + 1].x();
                 vector[n - 1] = (8 * points[n - 1].x() + points[n].x()) / 2.0;
                 vector[0] = points[0].y() + 2 * points[1].y();
-                for (int i = 1; i < n - 1; ++i) {
+                for (int i = 1; i < n - 1; ++i)
                     vector[i] = 4 * points[i].y() + 2 * points[i + 1].y();
                 vector[n - 1] = (8 * points[n - 1].y() + points[n].y()) / 2.0;
                     b = (i < count - 1 ? 4.0 : 3.5) - temp[i];
                     result[i] = (vector[i] - result[i - 1]) / b;
                 }
                 for (int i = 1; i < count; i++)
                     result[count - i - 1] -= temp[count - i] * result[count - i];
             {
                 Q_Q(QSplineSeries);
                 SplineChartItem *spline = new SplineChartItem(q, presenter);
-                if(presenter->animationOptions().testFlag(QChart::SeriesAnimations)) {
+                if (presenter->animationOptions().testFlag(QChart::SeriesAnimations))
                     spline->setAnimation(new SplineAnimation(spline));
                 presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
                 return spline;
             }

src/splinechart/splinechartitem.cpp +5 -7

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            SplineChartItem::SplineChartItem(QSplineSeries *series, ChartPresenter *presenter) :
+            SplineChartItem::SplineChartItem(QSplineSeries *series, ChartPresenter *presenter)
-                XYChart(series, presenter),
+                : XYChart(series, presenter),
                   QGraphicsItem(presenter ? presenter->rootItem() : 0),
                   m_series(series),
                   m_pointsVisible(false),
             {
                 QVector<QPointF> controlPoints;
-                if(newPoints.count()>=2) {
+                if (newPoints.count() >= 2)
                     controlPoints.resize(newPoints.count() * 2 - 2);
                 for (int i = 0; i < newPoints.size() - 1; i++) {
                     controlPoints[2 * i] = calculateGeometryControlPoint(2 * i);
                 m_controlPoints = controlPoints;
                 setDirty(false);
-                if (m_animation) {
+                if (m_animation)
                     presenter()->startAnimation(m_animation);
-                } else {
+                else
                     updateGeometry();
             }
             QPointF SplineChartItem::calculateGeometryControlPoint(int index) const
             {

src/splinechart/splinechartitem_p.h 0 0

NO CONTENT: modified file

src/themes/chartthemebluecerulean_p.h +1 -2

             class ChartThemeBlueCerulean: public ChartTheme
             {
             public:
-                ChartThemeBlueCerulean() : ChartTheme(QChart::ChartThemeBlueCerulean)
+                ChartThemeBlueCerulean() : ChartTheme(QChart::ChartThemeBlueCerulean) {
                     // Series colors
                     m_seriesColors << QRgb(0xc7e85b);
                     m_seriesColors << QRgb(0x1cb54f);

src/themes/chartthemesystem_p.h 0 0

NO CONTENT: modified file

src/xychart/qhxymodelmapper.h 0 0

NO CONTENT: modified file

src/xychart/qvxymodelmapper.h 0 0

NO CONTENT: modified file

src/xychart/qxymodelmapper.cpp +2 -4

                     return;
                 Q_D(QXYModelMapper);
-                if (d->m_model) {
+                if (d->m_model)
                     disconnect(d->m_model, 0, d, 0);
                 d->m_model = model;
                 d->initializeXYFromModel();
             void QXYModelMapper::setSeries(QXYSeries *series)
             {
                 Q_D(QXYModelMapper);
-                if (d->m_series) {
+                if (d->m_series)
                     disconnect(d->m_series, 0, d, 0);
                 if (series == 0)
                     return;

src/xychart/qxyseries.cpp +7 -5

                 Constructs empty series object which is a child of \a parent.
                 When series object is added to QChartView or QChart instance ownerships is transferred.
             */
-            QXYSeries::QXYSeries(QXYSeriesPrivate &d,QObject *parent) : QAbstractSeries(d, parent)
+            QXYSeries::QXYSeries(QXYSeriesPrivate &d, QObject *parent)
+                : QAbstractSeries(d, parent)
             {
             }
              */
             void QXYSeries::append(const QList<QPointF> &points)
             {
-                foreach(const QPointF& point , points) {
+                foreach (const QPointF &point , points)
                     append(point);
             }
             /*!
               Replaces data point \a oldX \a oldY with data point \a newX \a newY.
             {
                 Q_D(QXYSeries);
                 int index = d->m_points.indexOf(oldPoint);
-                if(index==-1) return;
+                if (index == -1)
+                    return;
                 d->m_points[index] = newPoint;
                 emit pointReplaced(index);
             }
             {
                 Q_D(QXYSeries);
                 int index = d->m_points.indexOf(point);
-                if(index==-1) return;
+                if (index == -1)
+                    return;
                 d->m_points.remove(index);
                 emit pointRemoved(index);
             }

src/xychart/qxyseries.h 0 0

NO CONTENT: modified file

src/xychart/xychart.cpp +3 -3

             //TODO: optimize : remove points which are not visible
-            XYChart::XYChart(QXYSeries *series, ChartPresenter *presenter):ChartElement(presenter),
+            XYChart::XYChart(QXYSeries *series, ChartPresenter *presenter)
+                : ChartElement(presenter),
                   m_minX(0),
                   m_maxX(0),
                   m_minY(0),
                     m_points = newPoints;
                     setDirty(false);
                     presenter()->startAnimation(m_animation);
+                } else {
-                else {
                     m_points = newPoints;
                     updateGeometry();
                 }

src/xychart/xychart_p.h 0 -1

                 bool m_dirty;
                 friend class AreaChartItem;
             };
             QTCOMMERCIALCHART_END_NAMESPACE

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