HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r759:ea8e9f62638e

minor code review fixes

sauimone -

r759:ea8e9f62638e

parent child

Context file:

r759:ea8e9f62638e

Collapse all files

src/axis/axisitem.cpp +21 -22

             #include "axisitem_p.h"
             #include "qchartaxis.h"
             #include "chartpresenter_p.h"
             #include "chartanimator_p.h"
             #include <QPainter>
             #include <QDebug>
             #include <cmath>
             static int label_padding = 5;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            Axis::Axis(QChartAxis* axis,ChartPresenter* presenter,AxisType type) : Chart(presenter),
+            Axis::Axis(QChartAxis *axis,ChartPresenter *presenter,AxisType type) : Chart(presenter),
                 m_chartAxis(axis),
                 m_type(type),
                 m_labelsAngle(0),
                 m_grid(presenter->rootItem()),
                 m_shades(presenter->rootItem()),
                 m_labels(presenter->rootItem()),
                 m_axis(presenter->rootItem()),
                 m_min(0),
                 m_max(0),
                 m_ticksCount(0)
             {
                 //initial initialization
                 m_axis.setZValue(ChartPresenter::AxisZValue);
                 m_axis.setHandlesChildEvents(false);
                 m_shades.setZValue(ChartPresenter::ShadesZValue);
                 m_grid.setZValue(ChartPresenter::GridZValue);
                 connect(m_chartAxis,SIGNAL(updated()),this,SLOT(handleAxisUpdated()));
                 connect(m_chartAxis->categories(),SIGNAL(updated()),this,SLOT(handleAxisCategoriesUpdated()));
                 handleAxisUpdated();
             }
             Axis::~Axis()
             {
             }
             void Axis::createItems(int count)
             {
-                if (m_axis.children().size()==0)
+                if (m_axis.children().size() == 0)
                     m_axis.addToGroup(new AxisItem(this));
                 for (int i = 0; i < count; ++i) {
                     m_grid.addToGroup(new QGraphicsLineItem());
                     m_labels.addToGroup(new QGraphicsSimpleTextItem());
                     m_axis.addToGroup(new QGraphicsLineItem());
-                    if((m_grid.childItems().size())%2 && m_grid.childItems().size()>2) m_shades.addToGroup(new QGraphicsRectItem());
+                    if ((m_grid.childItems().size())%2 && m_grid.childItems().size()>2) m_shades.addToGroup(new QGraphicsRectItem());
                    }
             }
             void Axis::deleteItems(int count)
             {
                 QList<QGraphicsItem *> lines = m_grid.childItems();
                 QList<QGraphicsItem *> labels = m_labels.childItems();
                 QList<QGraphicsItem *> shades = m_shades.childItems();
                 QList<QGraphicsItem *> axis = m_axis.childItems();
                 for (int i = 0; i < count; ++i) {
                     if (lines.size()%2 && lines.size() > 1) delete(shades.takeLast());
                     delete(lines.takeLast());
                     delete(labels.takeLast());
                     delete(axis.takeLast());
                 }
             }
-            void Axis::updateLayout(QVector<qreal>& layout)
+            void Axis::updateLayout(QVector<qreal> &layout)
             {
                 if (animator()) {
                     animator()->updateLayout(this,layout);
                 } else {
                     setLayout(layout);
                 }
             }
-            bool Axis::createLabels(QStringList& labels,qreal min, qreal max,int ticks) const
+            bool Axis::createLabels(QStringList &labels,qreal min, qreal max,int ticks) const
             {
                 Q_ASSERT(max>=min);
                 Q_ASSERT(ticks>1);
                 QChartAxisCategories* categories = m_chartAxis->categories();
                 bool category = categories->count()>0;
                 if (!category) {
                     int n = qMax(int(-floor(log10((max-min)/(ticks-1)))),0);
-                    for(int i=0; i< ticks; i++) {
+                    for (int i=0; i< ticks; i++) {
                         qreal value = min + (i * (max - min)/ (ticks-1));
                         labels << QString::number(value,'f',n);
                     }
                 } else {
                     QList<qreal> values = categories->values();
                     for (int i=0; i< ticks; i++) {
                         qreal value = (min + (i * (max - min)/ (ticks-1)));
                         int j=0;
                         for (; j<values.count(); j++) {
                             if (values.at(j) > value) break;
                         }
                         if (j!=0) value=values.at(j-1);
                         QString label = categories->label(value);
                         labels << label;
                     }
                 }
                 return category;
             }
             void Axis::setAxisOpacity(qreal opacity)
             {
                 m_axis.setOpacity(opacity);
             }
             qreal Axis::axisOpacity() const
             {
                 return m_axis.opacity();
             }
             void Axis::setGridOpacity(qreal opacity)
             {
                 m_grid.setOpacity(opacity);
             }
             qreal Axis::gridOpacity() const
             {
                 return m_grid.opacity();
             }
             void Axis::setLabelsOpacity(qreal opacity)
             {
                 m_labels.setOpacity(opacity);
             }
             qreal Axis::labelsOpacity() const
             {
                 return m_labels.opacity();
             }
             void Axis::setShadesOpacity(qreal opacity)
             {
                 m_shades.setOpacity(opacity);
             }
             qreal Axis::shadesOpacity() const
             {
                 return m_shades.opacity();
             }
             void Axis::setLabelsAngle(int angle)
             {
                 foreach(QGraphicsItem* item , m_labels.childItems()) {
                       QPointF center = item->boundingRect().center();
                       item->setRotation(angle);
                 }
                 m_labelsAngle=angle;
             }
             void Axis::setLabelsPen(const QPen &pen)
             {
                 foreach(QGraphicsItem* item , m_labels.childItems()) {
                     static_cast<QGraphicsSimpleTextItem*>(item)->setPen(pen);
                 }
             }
             void Axis::setLabelsBrush(const QBrush &brush)
             {
                 foreach(QGraphicsItem* item , m_labels.childItems()) {
                     static_cast<QGraphicsSimpleTextItem*>(item)->setBrush(brush);
                 }
             }
             void Axis::setLabelsFont(const QFont &font)
             {
                 foreach(QGraphicsItem* item , m_labels.childItems()) {
                     static_cast<QGraphicsSimpleTextItem*>(item)->setFont(font);
                 }
             }
             void Axis::setShadesBrush(const QBrush &brush)
             {
                 foreach(QGraphicsItem* item , m_shades.childItems()) {
                     static_cast<QGraphicsRectItem*>(item)->setBrush(brush);
                 }
             }
             void Axis::setShadesPen(const QPen &pen)
             {
                 foreach(QGraphicsItem* item , m_shades.childItems()) {
                     static_cast<QGraphicsRectItem*>(item)->setPen(pen);
                 }
             }
             void Axis::setAxisPen(const QPen &pen)
             {
                 foreach(QGraphicsItem* item , m_axis.childItems()) {
                        static_cast<QGraphicsLineItem*>(item)->setPen(pen);
                 }
             }
             void Axis::setGridPen(const QPen &pen)
             {
                 foreach(QGraphicsItem* item , m_grid.childItems()) {
                     static_cast<QGraphicsLineItem*>(item)->setPen(pen);
                 }
             }
             QVector<qreal> Axis::calculateLayout() const
             {
                 Q_ASSERT(m_ticksCount>=2);
                 QVector<qreal> points;
                 points.resize(m_ticksCount);
                 switch (m_type)
                 {
                     case X_AXIS:
                     {
                         const qreal deltaX = m_rect.width()/(m_ticksCount-1);
                         for (int i = 0; i < m_ticksCount; ++i) {
                              int x = i * deltaX + m_rect.left();
                              points[i] = x;
                         }
                     }
                     break;
                     case Y_AXIS:
                     {
                         const qreal deltaY = m_rect.height()/(m_ticksCount-1);
                         for (int i = 0; i < m_ticksCount; ++i) {
                              int y = i * -deltaY + m_rect.bottom();
                              points[i] = y;
                         }
                     }
                     break;
                 }
                 return points;
             }
-            void Axis::setLayout(QVector<qreal>& layout)
+            void Axis::setLayout(QVector<qreal> &layout)
             {
             	int diff = m_layoutVector.size() - layout.size();
                 if (diff>0) {
             		deleteItems(diff);
+                } else if (diff<0) {
-            	else if(diff<0) {
             		createItems(-diff);
             	}
-            	if(diff!=0) handleAxisUpdated();
+                if( diff!=0) handleAxisUpdated();
             	QStringList ticksList;
                 bool categories = createLabels(ticksList,m_min,m_max,layout.size());
             	QList<QGraphicsItem *> lines = m_grid.childItems();
             	QList<QGraphicsItem *> labels = m_labels.childItems();
             	QList<QGraphicsItem *> shades = m_shades.childItems();
             	QList<QGraphicsItem *> axis = m_axis.childItems();
             	Q_ASSERT(labels.size() == ticksList.size());
             	Q_ASSERT(layout.size() == ticksList.size());
             	switch (m_type)
             	{
             		case X_AXIS:
             		{
             			QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(axis.at(0));
             			lineItem->setLine(m_rect.left(), m_rect.bottom(), m_rect.right(), m_rect.bottom());
             			for (int i = 0; i < layout.size(); ++i) {
             				QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(lines.at(i));
             				lineItem->setLine(layout[i], m_rect.top(), layout[i], m_rect.bottom());
             				QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem*>(labels.at(i));
-            				if(!categories){
+                            if (!categories) {
             				    labelItem->setText(ticksList.at(i));
             				    QPointF center = labelItem->boundingRect().center();
             				    labelItem->setTransformOriginPoint(center.x(), center.y());
             				    labelItem->setPos(layout[i] - center.x(), m_rect.bottom() + label_padding);
-            				}else if(i>0){
+                            } else if(i>0) {
             				    labelItem->setText(ticksList.at(i));
             				    QPointF center = labelItem->boundingRect().center();
             				    labelItem->setTransformOriginPoint(center.x(), center.y());
             				    labelItem->setPos(layout[i] - (layout[i] - layout[i-1])/2 - center.x(), m_rect.bottom() + label_padding);
             				}
-            				if((i+1)%2 && i>1) {
+                            if ((i+1)%2 && i>1) {
             					QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem*>(shades.at(i/2-1));
             					rectItem->setRect(layout[i-1],m_rect.top(),layout[i]-layout[i-1],m_rect.height());
             				}
             				lineItem = static_cast<QGraphicsLineItem*>(axis.at(i+1));
             				lineItem->setLine(layout[i],m_rect.bottom(),layout[i],m_rect.bottom()+5);
             			}
             		}
             		break;
             		case Y_AXIS:
             		{
             			QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(axis.at(0));
             			lineItem->setLine(m_rect.left() , m_rect.top(), m_rect.left(), m_rect.bottom());
             			for (int i = 0; i < layout.size(); ++i) {
             				QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(lines.at(i));
             				lineItem->setLine(m_rect.left() , layout[i], m_rect.right(), layout[i]);
             				QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem*>(labels.at(i));
-            				if(!categories){
+                            if (!categories) {
             				    labelItem->setText(ticksList.at(i));
             				    QPointF center = labelItem->boundingRect().center();
             				    labelItem->setTransformOriginPoint(center.x(), center.y());
             				    labelItem->setPos(m_rect.left() - labelItem->boundingRect().width() - label_padding , layout[i]-center.y());
-            				} else if(i>0){
+                            } else if (i>0) {
             				    labelItem->setText(ticksList.at(i));
             				    QPointF center = labelItem->boundingRect().center();
             				    labelItem->setTransformOriginPoint(center.x(), center.y());
             				    labelItem->setPos(m_rect.left() - labelItem->boundingRect().width() - label_padding , layout[i] - (layout[i] - layout[i-1])/2 -center.y());
             				}
-            				if((i+1)%2 && i>1) {
+                            if ((i+1)%2 && i>1) {
             					QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem*>(shades.at(i/2-1));
             					rectItem->setRect(m_rect.left(),layout[i],m_rect.width(),layout[i-1]-layout[i]);
             				}
             				lineItem = static_cast<QGraphicsLineItem*>(axis.at(i+1));
             				lineItem->setLine(m_rect.left()-5,layout[i],m_rect.left(),layout[i]);
             			}
             		}
             		break;
             		default:
-            		qDebug()<<"Unknown axis type";
+                    qDebug()<<"Unknown axis type";
             		break;
             	}
             	m_layoutVector=layout;
             }
             bool Axis::isEmpty()
             {
                 return m_rect.isEmpty() || m_min==m_max || m_ticksCount==0;
             }
             //handlers
             void Axis::handleAxisCategoriesUpdated()
             {
-            	if(isEmpty()) return;
+                if (isEmpty()) return;
             	updateLayout(m_layoutVector);
             }
             void Axis::handleAxisUpdated()
             {
                 if (isEmpty()) return;
                 if (m_chartAxis->isAxisVisible()) {
                     setAxisOpacity(100);
                 } else {
                     setAxisOpacity(0);
                 }
-                if(m_chartAxis->isGridLineVisible()) {
+                if (m_chartAxis->isGridLineVisible()) {
                     setGridOpacity(100);
                 } else {
                     setGridOpacity(0);
                 }
-                if(m_chartAxis->labelsVisible()) {
+                if (m_chartAxis->labelsVisible()) {
                     setLabelsOpacity(100);
                 } else {
                     setLabelsOpacity(0);
                 }
                 if (m_chartAxis->shadesVisible()) {
                     setShadesOpacity(m_chartAxis->shadesOpacity());
                 } else {
                     setShadesOpacity(0);
                 }
                 setLabelsAngle(m_chartAxis->labelsAngle());
                 setAxisPen(m_chartAxis->axisPen());
                 setLabelsPen(m_chartAxis->labelsPen());
                 setLabelsBrush(m_chartAxis->labelsBrush());
                 setLabelsFont(m_chartAxis->labelsFont());
                 setGridPen(m_chartAxis->gridLinePen());
                 setShadesPen(m_chartAxis->shadesPen());
                 setShadesBrush(m_chartAxis->shadesBrush());
             }
             void Axis::handleRangeChanged(qreal min, qreal max,int tickCount)
             {
-                if(min==max || tickCount<2) return;
+                if (min==max || tickCount<2) return;
                 m_min = min;
                 m_max = max;
                 m_ticksCount= tickCount;
                 if (isEmpty()) return;
                 QVector<qreal> layout = calculateLayout();
                 updateLayout(layout);
             }
-            void Axis::handleGeometryChanged(const QRectF& rect)
+            void Axis::handleGeometryChanged(const QRectF &rect)
             {
                 m_rect = rect;
                 if (isEmpty()) return;
                 QVector<qreal> layout = calculateLayout();
                 updateLayout(layout);
             }
             void Axis::axisSelected()
             {
                 qDebug()<<"TODO axis clicked";
             }
             //TODO "nice numbers algorithm"
             #include "moc_axisitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/qchartaxis.cpp +69 -71

             #include "qchartaxis.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QChartAxis
                 \brief The QChartAxis class is used for manipulating chart's axis
                 and for adding optional axes to the chart.
                 \mainclass
                 There is only one x Axis, however there can be multiple y axes.
                 Each chart series can be bound to exactly one Y axis and the share common X axis.
                 Axis can be setup to show axis line with ticks, gird lines and shades.
             */
             /*!
                \fn bool QChartAxis::isAxisVisible() const
                \brief Returns if axis is visible
                \sa setAxisVisible()
             */
             /*!
                \fn QPen QChartAxis::axisPen() const
                \brief  Returns pen used to draw axis and ticks.
                 \sa setAxisPen()
             */
             /*!
                \fn bool QChartAxis::isGridLineVisible() const
                \brief Returns if grid is visible
                \sa setGridLineVisible()
             */
             /*!
                \fn QPen QChartAxis::gridLinePen() const
                \brief  Returns pen used to draw grid.
                 \sa setGridLinePen()
             */
             /*!
                \fn  bool QChartAxis::labelsVisible() const
                \brief Returns if grid is visible
                \sa setLabelsVisible()
             */
             /*!
                \fn QPen QChartAxis::labelsPen() const
                \brief Returns the pen used to labels.
                 \sa setLabelsPen()
             */
             /*!
                \fn QBrush QChartAxis::labelsBrush() const
                \brief Returns brush used to draw labels.
                 \sa setLabelsBrush()
             */
             /*!
                \fn QFont QChartAxis::labelsFont() const
                \brief Returns font used to draw labels.
                 \sa setLabelsFont()
             */
             /*!
                \fn QFont QChartAxis::labelsAngle() const
                \brief Returns angle used to draw labels.
                 \sa setLabelsAngle()
             */
             /*!
                \fn bool QChartAxis::shadesVisible() const
                \brief Returns if shades are visible.
                \sa setShadesVisible()
             */
             /*!
               \fn  qreal QChartAxis::shadesOpacity() const
               \brief Returns opacity of shades.
              */
             /*!
                \fn QPen QChartAxis::shadesPen() const
                \brief Returns pen used to draw shades.
                 \sa setShadesPen()
             */
             /*!
                \fn QBrush QChartAxis::shadesBrush() const
                \brief Returns brush used to draw shades.
                 \sa setShadesBrush()
             */
             /*!
                \fn qreal QChartAxis::min() const
                \brief Returns minimum value on the axis.
                \sa setMin()
             */
             /*!
                \fn qreal QChartAxis::max() const
                \brief Returns maximim value on the axis.
                \sa setMax()
             */
             /*!
                \fn void QChartAxis::minChanged(qreal min)
                \brief Axis emits signal when \a min of axis has changed.
             */
             /*!
                \fn void QChartAxis::maxChanged(qreal max)
                \brief Axis emits signal when \a max of axis has changed.
             */
             /*!
                \fn void QChartAxis::rangeChanged(qreal min, qreal max)
                \brief Axis emits signal when \a min or \a max of axis has changed.
             */
             /*!
                \fn int QChartAxis::ticksCount() const
                \brief Return number of ticks on the axis
                \sa setTicksCount()
             */
             /*!
                 \fn void QChartAxis::updated()
                 \brief \internal
             */
             /*!
                 \fn void QChartAxis::handleAxisRangeChanged(qreal min, qreal max)
                 \brief \internal \a min \a max
             */
             /*!
                 Constructs new axis object which is a child of \a parent. Ownership is taken by
                 QChatView or QChart when axis added.
             */
-            QChartAxis::QChartAxis(QObject* parent):QObject(parent),
+            QChartAxis::QChartAxis(QObject *parent) : QObject(parent),
-            m_axisVisible(true),
+                m_axisVisible(true),
-            m_gridLineVisible(true),
+                m_gridLineVisible(true),
-            m_labelsVisible(true),
+                m_labelsVisible(true),
-            m_labelsAngle(0),
+                m_labelsAngle(0),
-            m_shadesVisible(false),
+                m_shadesVisible(false),
-            m_shadesOpacity(1.0),
+                m_shadesOpacity(1.0),
-            m_min(0),
+                m_min(0),
-            m_max(0),
+                m_max(0),
-            m_ticksCount(5),
+                m_ticksCount(5),
-            m_niceNumbers(false)
+                m_niceNumbers(false)
             {
             }
             /*!
                 Destructor of the axis object. When axis is added to chart, chart object takes ownership.
             */
             QChartAxis::~QChartAxis()
             {
             }
             /*!
               Sets \a pen used to draw axis line and ticks.
              */
-            void QChartAxis::setAxisPen(const QPen& pen)
+            void QChartAxis::setAxisPen(const QPen &pen)
             {
             	if (pen != m_axisPen) {
-                m_axisPen=pen;
+                    m_axisPen = pen;
-                emit updated();
+                    emit updated();
             	}
             }
             /*!
               Sets if axis and ticks are \a visible.
              */
             void QChartAxis::setAxisVisible(bool visible)
             {
-            	if (m_axisVisible!=visible) {
+                if (m_axisVisible != visible) {
-                m_axisVisible=visible;
+                    m_axisVisible = visible;
-                emit updated();
+                    emit updated();
             	}
             }
             /*!
               Sets if grid line is \a visible.
              */
             void QChartAxis::setGridLineVisible(bool visible)
             {
-            	if (m_gridLineVisible!=visible) {
+                if (m_gridLineVisible != visible) {
-                m_gridLineVisible=visible;
+                    m_gridLineVisible = visible;
-                emit updated();
+                    emit updated();
             	}
             }
             /*!
               Sets \a pen used to draw grid line.
              */
-            void QChartAxis::setGridLinePen(const QPen& pen)
+            void QChartAxis::setGridLinePen(const QPen &pen)
             {
-            	if (m_gridLinePen!=pen) {
+                if (m_gridLinePen != pen) {
-                m_gridLinePen=pen;
+                    m_gridLinePen = pen;
-                emit updated();
+                    emit updated();
             	}
             }
             /*!
               Sets if axis' labels are \a visible.
              */
             void QChartAxis::setLabelsVisible(bool visible)
             {
-            	if(m_labelsVisible!=visible) {
+                if (m_labelsVisible != visible) {
-                m_labelsVisible=visible;
+                    m_labelsVisible = visible;
-                emit updated();
+                    emit updated();
             	}
             }
             /*!
               Sets \a pen used to draw labels.
              */
-            void QChartAxis::setLabelsPen(const QPen& pen)
+            void QChartAxis::setLabelsPen(const QPen &pen)
             {
-            	if(m_labelsPen!=pen) {
+                if (m_labelsPen != pen) {
-                m_labelsPen=pen;
+                    m_labelsPen = pen;
-                emit updated();
+                    emit updated();
             	}
             }
             /*!
               Sets \a brush used to draw labels.
              */
-            void QChartAxis::setLabelsBrush(const QBrush& brush)
+            void QChartAxis::setLabelsBrush(const QBrush &brush)
             {
-            	if(m_labelsBrush!=brush) {
+                if (m_labelsBrush != brush) {
-                m_labelsBrush=brush;
+                    m_labelsBrush = brush;
-                emit updated();
+                    emit updated();
             	}
             }
             /*!
               Sets \a font used to draw labels.
              */
-            void QChartAxis::setLabelsFont(const QFont& font)
+            void QChartAxis::setLabelsFont(const QFont &font)
             {
-            	if(m_labelsFont!=font) {
+                if (m_labelsFont != font) {
-                m_labelsFont=font;
+                    m_labelsFont = font;
-                emit updated();
+                    emit updated();
             	}
             }
             /*!
               Sets \a angle for all the labels on given axis.
              */
             void QChartAxis::setLabelsAngle(int angle)
             {
-            	if(m_labelsAngle!=angle) {
+                if (m_labelsAngle != angle) {
-            	m_labelsAngle=angle;
+                    m_labelsAngle = angle;
-            	emit updated();
+                    emit updated();
             	}
             }
             /*!
               Sets if shades are \a visible.
              */
             void QChartAxis::setShadesVisible(bool visible)
             {
-            	if(m_shadesVisible!=visible) {
+                if (m_shadesVisible != visible) {
-                m_shadesVisible=visible;
+                    m_shadesVisible = visible;
-                emit updated();
+                    emit updated();
             	}
             }
             /*!
               Sets \a pen used to draw shades.
              */
-            void QChartAxis::setShadesPen(const QPen& pen)
+            void QChartAxis::setShadesPen(const QPen &pen)
             {
-            	if(m_shadesPen!=pen) {
+                if (m_shadesPen != pen) {
-            	m_shadesPen=pen;
+                    m_shadesPen = pen;
-            	emit updated();
+                    emit updated();
             	}
             }
             /*!
               Sets \a brush used to draw shades.
              */
-            void QChartAxis::setShadesBrush(const QBrush& brush)
+            void QChartAxis::setShadesBrush(const QBrush &brush)
             {
-            	if(m_shadesBrush!=brush) {
+                if (m_shadesBrush != brush) {
-                m_shadesBrush=brush;
+                    m_shadesBrush = brush;
-                emit updated();
+                    emit updated();
             	}
             }
             /*!
               Sets \a opacity of the shades.
              */
             void QChartAxis::setShadesOpacity(qreal opacity)
             {
-            	if(m_shadesOpacity!=opacity) {
+                if (m_shadesOpacity != opacity) {
                 m_shadesOpacity=opacity;
                 emit updated();
             	}
             }
             /*!
              Sets \a min value on the axis.
              */
             void QChartAxis::setMin(qreal min)
             {
             	setRange(min,m_max);
             }
             /*!
              Sets \a max value on the axis.
              */
             void QChartAxis::setMax(qreal max)
             {
                 setRange(m_min,max);
             }
             /*!
               Sets range from \a min to \a max on the axis.
              */
             void QChartAxis::setRange(qreal min, qreal max)
             {
             	bool changed = false;
-                if(m_min!=min) {
+                if (m_min != min) {
-                    m_min=min;
+                    m_min = min;
-                    changed=true;
+                    changed = true;
                     emit minChanged(min);
                 }
-                if(m_max!=max) {
+                if (m_max != max) {
-                    m_max=max;
+                    m_max = max;
-                    changed=true;
+                    changed = true;
                     emit maxChanged(max);
                 }
-                if(changed) {
+                if (changed) {
                     emit rangeChanged(m_min,m_max);
                     emit this->changed(m_min, m_max, m_ticksCount, m_niceNumbers);
                 }
             }
             /*!
               Sets \a count for ticks on the axis.
              */
             void QChartAxis::setTicksCount(int count)
             {
-            	if(m_ticksCount!=count) {
+                if (m_ticksCount != count) {
-            		m_ticksCount=count;
+                    m_ticksCount = count;
             		emit ticksCountChanged(count);
             		emit changed(m_min, m_max, m_ticksCount, m_niceNumbers);
             	}
             }
             /*!
               Sets axis, shades, labels and grid lines to be visible.
              */
             void QChartAxis::show()
             {
                m_axisVisible=true;
                m_gridLineVisible=true;
                m_labelsVisible=true;
                m_shadesVisible=true;
                emit updated();
             }
             /*!
               Sets axis, shades, labels and grid lines to not be visible.
              */
             void QChartAxis::hide()
             {
-                m_axisVisible=false;
+                m_axisVisible = false;
-                m_gridLineVisible=false;
+                m_gridLineVisible = false;
-                m_labelsVisible=false;
+                m_labelsVisible = false;
-                m_shadesVisible=false;
+                m_shadesVisible = false;
                 emit updated();
             }
             void QChartAxis::handleAxisRangeChanged(qreal min, qreal max,int count)
             {
                setRange(min,max);
                setTicksCount(count);
             }
             void QChartAxis::setNiceNumbers(bool enabled)
             {
-                if(m_niceNumbers!=enabled){
+                if (m_niceNumbers != enabled){
-                    m_niceNumbers=enabled;
+                    m_niceNumbers = enabled;
                     emit changed(m_min, m_max, m_ticksCount, m_niceNumbers);
                 }
             }
             #include "moc_qchartaxis.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/qchartaxiscategories.cpp +2 -2

             #include "qchartaxiscategories.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             QChartAxisCategories::QChartAxisCategories()
             {
                 // TODO Auto-generated constructor stub
             }
             QChartAxisCategories::~QChartAxisCategories()
             {
                 // TODO Auto-generated destructor stub
             }
-            void QChartAxisCategories::insert(const QBarCategories& categories)
+            void QChartAxisCategories::insert(const QBarCategories &categories)
             {
                 int i=1;
-                foreach(QString string , categories){
+                foreach (QString string , categories) {
                     m_map.insert(i,string);
                     i++;
                 }
                 emit updated();
             }
             void QChartAxisCategories::insert(qreal value,QString label)
             {
                 m_map.insert(value,label);
                 emit updated();
             }
             void QChartAxisCategories::remove(qreal value)
             {
                 m_map.remove(value);
                 emit updated();
             }
             void QChartAxisCategories::clear()
             {
                 m_map.clear();
                 emit updated();
             }
             int QChartAxisCategories::count()
             {
                 return m_map.count();
                 emit updated();
             }
             QList<qreal> QChartAxisCategories::values() const
             {
                 return m_map.keys();
             }
             QString QChartAxisCategories::label(qreal value) const
             {
                 return m_map.value(value);
             }
             #include "moc_qchartaxiscategories.cpp"
             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