HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r2131:730996457e67

src folder: another massive victory for coding style police

Jani Honkonen -

r2131:730996457e67

parent child

Context file:

r2131:730996457e67

Expand all files

src/animations/axisanimation.cpp 0 0

NO CONTENT: modified file

src/animations/splineanimation.cpp 0 0

NO CONTENT: modified file

src/axis/barcategoryaxis/chartbarcategoryaxisx.cpp +13 -14

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            ChartBarCategoryAxisX::ChartBarCategoryAxisX(QBarCategoryAxis *axis,ChartPresenter *presenter) : HorizontalAxis(axis,presenter,true),
+            ChartBarCategoryAxisX::ChartBarCategoryAxisX(QBarCategoryAxis *axis, ChartPresenter *presenter)
+                : HorizontalAxis(axis, presenter, true),
                   m_categoriesAxis(axis)
             {
                 const qreal delta = gridRect.width() / (count);
                 qreal offset = -min() - 0.5;
-                if(delta<1) return points;
+                if (delta < 1)
+                    return points;
-                if(offset<0) {
+                if (offset < 0)
                     offset = int(offset * gridRect.width() / (max() - min())) % int(delta) + delta;
+                else
-                else {
                     offset = int(offset * gridRect.width() / (max() - min())) % int(delta);
                 for (int i = -1; i < count + 1; ++i) {
                     qreal x = offset + i * delta + gridRect.left();
                     qreal x = qFloor((((layout[i] + layout[i + 1]) / 2 - gridRect.left()) * d + min() + 0.5));
                     if ((x < m_categoriesAxis->categories().count()) && (x >= 0)) {
                         result << m_categoriesAxis->categories().at(x);
+                    } else {
-                    else {
                         // No label for x coordinate
                         result << "";
                     }
             void ChartBarCategoryAxisX::updateGeometry()
             {
                 const QVector<qreal>& layout = ChartAxis::layout();
-                if(layout.isEmpty()) return;
+                if (layout.isEmpty())
+                    return;
                 setLabels(createCategoryLabels(layout));
                 HorizontalAxis::updateGeometry();
             }
             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();
+                    if (ChartAxis::layout().count() == m_categoriesAxis->d_ptr->count() + 2)
+                        updateGeometry();
                 }
                 ChartAxis::handleAxisUpdated();
             }
                     break;
                 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() + labelPadding(), height);

src/axis/barcategoryaxis/chartbarcategoryaxisy.cpp +12 -15

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            ChartBarCategoryAxisY::ChartBarCategoryAxisY(QBarCategoryAxis *axis,ChartPresenter *presenter) : VerticalAxis(axis,presenter,true),
+            ChartBarCategoryAxisY::ChartBarCategoryAxisY(QBarCategoryAxis *axis, ChartPresenter *presenter)
+                : VerticalAxis(axis, presenter, true),
                   m_categoriesAxis(axis)
             {
             }
                 const qreal delta = gridRect.height() / (count);
                 qreal offset = - min() - 0.5;
-                if(delta<1) return points;
+                if (delta < 1)
+                    return points;
-                if(offset<0) {
+                if (offset < 0)
                     offset = int(offset * gridRect.height() / (max() - min())) % int(delta) + delta;
+                else
-                else {
                     offset = int(offset * gridRect.height() / (max() - min())) % int(delta);
                 for (int i = -1; i < count + 1; ++i) {
                     int y = gridRect.bottom() - i * delta - offset;
                     qreal x = qFloor(((gridRect.height() - (layout[i + 1] + layout[i]) / 2 + gridRect.top()) * d + min() + 0.5));
                     if ((x < m_categoriesAxis->categories().count()) && (x >= 0)) {
                         result << m_categoriesAxis->categories().at(x);
+                    } else {
-                    else {
                         // No label for x coordinate
                         result << "";
                     }
             void ChartBarCategoryAxisY::updateGeometry()
             {
                 const QVector<qreal>& layout = ChartAxis::layout();
-                if(layout.isEmpty()) return;
+                if (layout.isEmpty())
+                    return;
                 setLabels(createCategoryLabels(layout));
                 VerticalAxis::updateGeometry();
             }
             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();
             }
                     break;
                 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() + labelPadding(), width);

src/axis/barcategoryaxis/qbarcategoryaxis.cpp +17 -18

                 int count = d->m_categories.count();
-                foreach(QString category, categories)
+                foreach(QString category, categories) {
                     if (!d->m_categories.contains(category) && !category.isNull()) {
                         d->m_categories.append(category);
                     }
                 }
-                if(d->m_categories.count() == count) return;
+                if (d->m_categories.count() == count)
+                    return;
-                if (count == 0) {
+                if (count == 0)
                     setRange(d->m_categories.first(), d->m_categories.last());
-                } else {
+                else
                     setRange(d->m_minCategory, d->m_categories.last());
                 emit categoriesChanged();
             }
                 int count = d->m_categories.count();
-                if(!d->m_categories.contains(category) && !category.isNull()){
+                if (!d->m_categories.contains(category) && !category.isNull())
                     d->m_categories.append(category);
-                if(d->m_categories.count() == count) return;
+                if (d->m_categories.count() == count)
+                    return;
-                if (count == 0) {
+                if (count == 0)
                     setRange(d->m_categories.last(), d->m_categories.last());
-                } else {
+                else
                     setRange(d->m_minCategory, d->m_categories.last());
                 emit categoriesChanged();
             }
                             d->updateCategoryDomain();
                             d->emitUpdated();
                         }
-                    }else
+                    } else {
                         setRange(QString::null, QString::null);
+                    }
                     emit categoriesChanged();
                 }
             }
                 int count = d->m_categories.count();
-                if(!d->m_categories.contains(category) && !category.isNull()){
+                if (!d->m_categories.contains(category) && !category.isNull())
                     d->m_categories.insert(index, category);
-                if(d->m_categories.count() == count) return;
+                if (d->m_categories.count() == count)
+                    return;
                 if (count == 0) {
                     setRange(d->m_categories.first(), d->m_categories.first());
                     d->emitUpdated();
                 }
-                if (d->m_categories.indexOf(maxCategory) < d->m_categories.indexOf(minCategory)){
+                if (d->m_categories.indexOf(maxCategory) < d->m_categories.indexOf(minCategory))
                     return;
                 if (!minCategory.isEmpty() && d->m_minCategory != minCategory && d->m_categories.contains(minCategory)) {
                     d->m_minCategory = minCategory;
                     d->m_min = d->m_categories.indexOf(d->m_minCategory) - 0.5;

src/axis/categoryaxis/chartcategoryaxisx.cpp +5 -4

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            ChartCategoryAxisX::ChartCategoryAxisX(QCategoryAxis *axis,ChartPresenter *presenter) : HorizontalAxis(axis,presenter,true),
+            ChartCategoryAxisX::ChartCategoryAxisX(QCategoryAxis *axis, ChartPresenter *presenter)
+                : HorizontalAxis(axis, presenter, true),
                   m_axis(axis)
             {
             }
                 if (range > 0) {
                     points.resize(tickCount);
                     qreal scale = gridRect.width() / range;
-                    for (int i = 0; i < tickCount; ++i)
+                    for (int i = 0; i < tickCount; ++i) {
                         if (i < tickCount - 1) {
                             int x = (m_axis->startValue(m_axis->categoriesLabels().at(i)) - m_axis->min()) * scale + gridRect.left();
                             points[i] = x;
                             points[i] = x;
                         }
                     }
+                }
                 return points;
             }
                     break;
                 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() + labelPadding(), height);

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

                 ~ChartCategoryAxisX();
                 QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint) const;
             protected:
                 QVector<qreal> calculateLayout() const;
                 void updateGeometry();
-            Q_SLOTS
+            public Q_SLOTS:
                 void handleAxisUpdated();
             private:
                 QCategoryAxis *m_axis;
             };

src/axis/categoryaxis/chartcategoryaxisy.cpp +5 -4

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            ChartCategoryAxisY::ChartCategoryAxisY(QCategoryAxis *axis,ChartPresenter *presenter) : VerticalAxis(axis,presenter,true),
+            ChartCategoryAxisY::ChartCategoryAxisY(QCategoryAxis *axis, ChartPresenter *presenter)
+                : VerticalAxis(axis, presenter, true),
                   m_axis(axis)
             {
             }
                 if (range > 0) {
                     points.resize(tickCount);
                     qreal scale = gridRect.height() / range;
-                    for (int i = 0; i < tickCount; ++i)
+                    for (int i = 0; i < tickCount; ++i) {
                         if (i < tickCount - 1) {
                             int y = -(m_axis->startValue(m_axis->categoriesLabels().at(i)) - m_axis->min()) * scale + gridRect.bottom();
                             points[i] = y;
                             points[i] = y;
                         }
                     }
+                }
                 return points;
             }
                     break;
                 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() + labelPadding(), width);

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

                 ~ChartCategoryAxisY();
                 QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint) const;
             protected:
                 QVector<qreal> calculateLayout() const;
                 void updateGeometry();
-            Q_SLOTS
+            public Q_SLOTS:
                 void handleAxisUpdated();
             private:
                 QCategoryAxis *m_axis;
             };

src/axis/chartaxis.cpp +36 -55

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            ChartAxis::ChartAxis(QAbstractAxis *axis,ChartPresenter *presenter, bool intervalAxis) : ChartElement(presenter),
+            ChartAxis::ChartAxis(QAbstractAxis *axis, ChartPresenter *presenter, bool intervalAxis)
+                : 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()));
                 if (m_intervalAxis && m_grid->children().size() == 0) {
                     for (int i = 0 ; i < 2 ; i  ++)
                         m_grid->addToGroup(new QGraphicsLineItem(presenter()->rootItem()));
                 }
                 for (int i = 0; i < count; ++i) {
                     m_grid->addToGroup(new QGraphicsLineItem(presenter()->rootItem()));
                     m_labels->addToGroup(new QGraphicsSimpleTextItem(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();
                     }
                     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);
             }
             void ChartAxis::setLabelPadding(int padding)
             {
                 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();
                 m_gridRect = grid;
                 m_axisRect = axis;
-                    if (isEmpty()) return;
+                if (isEmpty())
+                    return;
                 if (!m_titleText.isNull()) {
                     QFontMetrics fn(m_title->font());
                     else if (orientation() == Qt::Vertical)
                         size = grid.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 = grid.center() - m_title->boundingRect().center();
                     if (orientation() == Qt::Horizontal) {
                         m_title->setPos(center.x(), m_axisRect.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_axisRect.left() - m_title->boundingRect().width() / 2 + m_title->boundingRect().height() / 2, center.y());
                 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;
                         qreal value = m_min + (i * (m_max - m_min) / (ticks - 1));
                         labels << QString::number(value, 'f', n);
                     }
+                } else {
-                else {
                     QByteArray array = format.toAscii();
                     for (int i = 0; i < ticks; i++) {
                         qreal value = m_min + (i * (m_max - m_min) / (ticks - 1));
                     qreal value = m_min + (i * (m_max - m_min) / (ticks - 1));
                     labels << QDateTime::fromMSecsSinceEpoch(value).toString(format);
                 }
                 return labels;
             }

src/axis/chartaxis_p.h 0 0

NO CONTENT: modified file

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

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            ChartDateTimeAxisX::ChartDateTimeAxisX(QDateTimeAxis *axis,ChartPresenter *presenter) : HorizontalAxis(axis,presenter),
+            ChartDateTimeAxisX::ChartDateTimeAxisX(QDateTimeAxis *axis, ChartPresenter *presenter)
-            m_tickCount(0),m_axis(axis)
+                : HorizontalAxis(axis, presenter),
+                  m_tickCount(0),
+                  m_axis(axis)
             {
             }
             void ChartDateTimeAxisX::updateGeometry()
             {
                 const QVector<qreal>& layout = ChartAxis::layout();
-                if(layout.isEmpty()) return;
+                if (layout.isEmpty())
+                    return;
                 setLabels(createDateTimeLabels(m_axis->format(), layout.size()));
                 HorizontalAxis::updateGeometry();
             }
                 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() + labelPadding(), height);

src/axis/datetimeaxis/chartdatetimeaxisy.cpp +7 -6

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            ChartDateTimeAxisY::ChartDateTimeAxisY(QDateTimeAxis *axis,ChartPresenter *presenter) : VerticalAxis(axis,presenter),
+            ChartDateTimeAxisY::ChartDateTimeAxisY(QDateTimeAxis *axis, ChartPresenter *presenter)
-            m_tickCount(0),m_axis(axis)
+                : VerticalAxis(axis, presenter),
+                  m_tickCount(0),
+                  m_axis(axis)
             {
             }
             void ChartDateTimeAxisY::updateGeometry()
             {
                 const QVector<qreal> &layout = ChartAxis::layout();
-                if(layout.isEmpty()) return;
+                if (layout.isEmpty())
+                    return;
                 setLabels(createDateTimeLabels(m_axis->format(), layout.size()));
                 VerticalAxis::updateGeometry();
             }
                     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() + labelPadding(), height);

src/axis/horizontalaxis.cpp +5 -4

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            HorizontalAxis::HorizontalAxis(QAbstractAxis *axis, ChartPresenter *presenter,bool intervalAxis):ChartAxis(axis,presenter,intervalAxis)
+            HorizontalAxis::HorizontalAxis(QAbstractAxis *axis, ChartPresenter *presenter, bool intervalAxis)
+                : ChartAxis(axis, presenter, intervalAxis)
             {
             }
             {
                 const QVector<qreal>& layout = ChartAxis::layout();
-                if(layout.isEmpty()) return;
+                if (layout.isEmpty())
+                    return;
                 QStringList ticksList = labels();
                         labelItem->setVisible(false);
                         gridItem->setVisible(false);
                         tickItem->setVisible(false);
+                    } else {
-                    else {
                         labelItem->setVisible(true);
                         gridItem->setVisible(true);
                         tickItem->setVisible(true);

src/axis/horizontalaxis_p.h 0 0

NO CONTENT: modified file

src/axis/qabstractaxis.cpp +6 -5

               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 !");
             }
             /*!
             /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-            QAbstractAxisPrivate::QAbstractAxisPrivate(QAbstractAxis* q):
+            QAbstractAxisPrivate::QAbstractAxisPrivate(QAbstractAxis *q)
-                q_ptr(q),
+                : q_ptr(q),
                   m_orientation(Qt::Orientation(0)),
                   m_alignment(0),
                   m_dataset(0),

src/axis/qabstractaxis.h 0 0

NO CONTENT: modified file

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

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            ChartValueAxisX::ChartValueAxisX(QValueAxis *axis,ChartPresenter *presenter) : HorizontalAxis(axis,presenter),
+            ChartValueAxisX::ChartValueAxisX(QValueAxis *axis, ChartPresenter *presenter)
+                : HorizontalAxis(axis, presenter),
                   m_tickCount(0), m_axis(axis)
             {
             }
             void ChartValueAxisX::updateGeometry()
             {
                 const QVector<qreal>& layout = ChartAxis::layout();
-                if(layout.isEmpty()) return;
+                if (layout.isEmpty())
+                    return;
                 setLabels(createValueLabels(layout.size()));
                 HorizontalAxis::updateGeometry();
             }
                     break;
                 }
                 case Qt::PreferredSize: {
-                    for (int i = 0; i < ticksList.size(); ++i)
+                    for (int i = 0; i < ticksList.size(); ++i) {
                         width += fn.averageCharWidth() * ticksList.at(i).count();
                     }
                     height = fn.height() + labelPadding();

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

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            ChartValueAxisY::ChartValueAxisY(QValueAxis *axis,ChartPresenter *presenter) : VerticalAxis(axis,presenter),
+            ChartValueAxisY::ChartValueAxisY(QValueAxis *axis, ChartPresenter *presenter)
-                m_tickCount(0),m_axis(axis)
+                : VerticalAxis(axis, presenter),
+                  m_tickCount(0),
+                  m_axis(axis)
             {
             }
             void ChartValueAxisY::updateGeometry()
             {
                 const QVector<qreal> &layout = ChartAxis::layout();
-                if(layout.isEmpty()) return;
+                if (layout.isEmpty())
+                    return;
                 setLabels(createValueLabels(layout.size()));
                 VerticalAxis::updateGeometry();
             }
                     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)
                         width = qMax(qreal(fn.averageCharWidth() * ticksList.at(i).count()) + labelPadding(), width);
                         height += fn.height();
                     }

src/axis/valueaxis/chartvalueaxisy_p.h 0 0

NO CONTENT: modified file

src/axis/verticalaxis.cpp +8 -10

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            VerticalAxis::VerticalAxis(QAbstractAxis *axis, ChartPresenter *presenter, bool intervalAxis):ChartAxis(axis,presenter,intervalAxis)
+            VerticalAxis::VerticalAxis(QAbstractAxis *axis, ChartPresenter *presenter, bool intervalAxis)
+                : ChartAxis(axis, presenter, intervalAxis)
             {
             }
             {
                 const QVector<qreal> &layout = ChartAxis::layout();
-                if(layout.isEmpty()) return;
+                if (layout.isEmpty())
+                    return;
                 QStringList labelList = labels();
                     //label text
                     QString text = labelList.at(i);
-                    if (fn.boundingRect(text).width() > axisRect.right() - axisRect.left() - labelPadding() )
+                    if (fn.boundingRect(text).width() > axisRect.right() - axisRect.left() - labelPadding()) {
                         QString label = text + "...";
                         while (fn.boundingRect(label).width() > axisRect.right() - axisRect.left() - labelPadding() && label.length() > 3)
                             label.remove(label.length() - 4, 1);
                         labelItem->setText(label);
+                    } else {
-                    else {
                         labelItem->setText(text);
                     }
                     const QRectF &rect = labelItem->boundingRect();
                     if (alignment() == Qt::AlignLeft) {
                         labelItem->setPos(axisRect.right() - rect.width() - labelPadding() , layout[i] - center.y());
                         tickItem->setLine(axisRect.right() - labelPadding(), layout[i], axisRect.right(), layout[i]);
+                    } else if (alignment() == Qt::AlignRight) {
-                    else if(alignment()==Qt::AlignRight) {
                         labelItem->setPos(axisRect.left() + labelPadding() , layout[i] - center.y());
                         tickItem->setLine(axisRect.left(), layout[i], axisRect.left() + labelPadding(), layout[i]);
                     }
                         labelItem->setVisible(false);
                         gridItem->setVisible(false);
                         tickItem->setVisible(false);
+                    } else {
-                    else {
                         labelItem->setVisible(true);
                         gridItem->setVisible(true);
                         height = labelItem->pos().y();

src/chartdataset.cpp 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file

NO CONTENT: modified file

src/chartlayout.cpp +13 -17

             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);
                 contentGeometry = calculateAxisGeometry(contentGeometry, axes);
                 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;
             }
             QRectF ChartLayout::calculateAxisGeometry(const QRectF &geometry, const QList<ChartAxis *>& axes) const
             {
                 QSizeF left;
                 QSizeF right;
                 QSizeF bottom;
                 foreach (ChartAxis *axis , axes) {
-                    if(!axis->isVisible()) continue;
+                    if (!axis->isVisible())
+                        continue;
                     QSizeF size = axis->effectiveSizeHint(Qt::MinimumSize);
                         bottom.setHeight(bottom.height() + size.height());
                         bottomCount++;
                         break;
                     }
                 }
                 foreach(ChartAxis * axis , axes) {
-                    if(!axis->isVisible()) continue;
+                    if (!axis->isVisible())
+                        continue;
                     QSizeF size = axis->effectiveSizeHint(Qt::MinimumSize);
                     QSizeF size = axis->effectiveSizeHint(Qt::MinimumSize);
-                    if(!axis->isVisible()) continue;
+                    if (!axis->isVisible())
+                        continue;
                     switch (axis->alignment()) {
                     case Qt::AlignLeft:
             QRectF ChartLayout::calculateChartsGeometry(const QRectF &geometry, const QList<ChartElement *>& charts) const
             {
                 Q_ASSERT(geometry.isValid());
                 foreach (ChartElement *chart, charts)
                     chart->handleGeometryChanged(geometry);
                 return geometry;
             }
                     minimumRect = calculateLegendMinimum(minimumRect, legend);
                     minimumRect = calculateAxisMinimum(minimumRect, axes);
                     return  minimumRect.united(m_minChartRect).size().toSize();
-                }else
                 return QSize(-1, -1);
             }

src/chartlayout_p.h 0 0

NO CONTENT: modified file

src/chartpresenter.cpp +24 -18

             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),
                 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(domain, SIGNAL(updated()), item, SLOT(handleDomainUpdated()));
                 QObject::connect(axis, SIGNAL(visibleChanged(bool)), this, SLOT(handleAxisVisibleChanged(bool)));
                     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();
                 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/legend/legendlayout.cpp 0 0

NO CONTENT: modified file

src/legend/qlegend.cpp 0 0

NO CONTENT: modified file

src/piechart/piesliceitem.cpp 0 0

NO CONTENT: modified file

src/piechart/qpiemodelmapper.cpp +2 -2

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            QPieModelMapper::QPieModelMapper(QObject *parent) :
+            QPieModelMapper::QPieModelMapper(QObject *parent)
-                QObject(parent),
+                : QObject(parent),
                   d_ptr(new QPieModelMapperPrivate(this))
             {
             }

src/piechart/qpieseries.cpp 0 0

NO CONTENT: modified file

src/qchart.cpp +8 -4

             /*!
              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);
              */
             void QChart::zoomIn(const QRectF &rect)
             {
-                if (!rect.isValid()) return;
+                if (!rect.isValid())
+                    return;
                 d_ptr->m_presenter->zoomIn(rect);
             }
             */
             void QChart::setAxisX(QAbstractAxis *axis , QAbstractSeries *series)
             {
-                if(axis->alignment()==Qt::AlignLeft || axis->alignment()==Qt::AlignRight) return;
+                if (axis->alignment() == Qt::AlignLeft || axis->alignment() == Qt::AlignRight)
+                    return;
                 d_ptr->m_dataset->setAxis(series, axis, Qt::Horizontal);
             }
             */
             void QChart::setAxisY(QAbstractAxis *axis , QAbstractSeries *series)
             {
-                if(axis->alignment()==Qt::AlignTop || axis->alignment()==Qt::AlignBottom) return;
+                if (axis->alignment() == Qt::AlignTop || axis->alignment() == Qt::AlignBottom)
+                    return;
                 d_ptr->m_dataset->setAxis(series, axis, Qt::Vertical);
             }

src/scatterchart/scatterchartitem.cpp 0 0

NO CONTENT: modified file

src/xychart/qxymodelmapper.cpp +2 -2

             /*!
                 Constructs a mapper object which is a child of \a parent.
             */
-            QXYModelMapper::QXYModelMapper(QObject *parent):
+            QXYModelMapper::QXYModelMapper(QObject *parent)
-                QObject(parent),
+                : QObject(parent),
                   d_ptr(new QXYModelMapperPrivate(this))
             {
             }

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