HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r745:477bbc361e58

more minor code review fixes

sauimone -

r745:477bbc361e58

parent child

Context file:

r745:477bbc361e58

Collapse all files

src/axis/axisitem.cpp +47 -53

             #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) :
+            Axis::Axis(QChartAxis* axis,ChartPresenter* presenter,AxisType type) : Chart(presenter),
-            Chart(presenter),
+                m_chartAxis(axis),
-            m_chartAxis(axis),
+                m_type(type),
-            m_type(type),
+                m_labelsAngle(0),
-            m_labelsAngle(0),
+                m_grid(presenter->rootItem()),
-            m_grid(presenter->rootItem()),
+                m_shades(presenter->rootItem()),
-            m_shades(presenter->rootItem()),
+                m_labels(presenter->rootItem()),
-            m_labels(presenter->rootItem()),
+                m_axis(presenter->rootItem()),
-            m_axis(presenter->rootItem()),
+                m_min(0),
-            m_min(0),
+                m_max(0),
-            m_max(0),
+                m_ticksCount(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);
-                QObject::connect(m_chartAxis,SIGNAL(updated()),this,SLOT(handleAxisUpdated()));
+                connect(m_chartAxis,SIGNAL(updated()),this,SLOT(handleAxisUpdated()));
-                QObject::connect(m_chartAxis->categories(),SIGNAL(updated()),this,SLOT(handleAxisCategoriesUpdated()));
+                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));
+                    m_axis.addToGroup(new AxisItem(this));
                 for (int i = 0; i < count; ++i) {
-                       m_grid.addToGroup(new QGraphicsLineItem());
+                    m_grid.addToGroup(new QGraphicsLineItem());
-                       m_labels.addToGroup(new QGraphicsSimpleTextItem());
+                    m_labels.addToGroup(new QGraphicsSimpleTextItem());
-                       m_axis.addToGroup(new QGraphicsLineItem());
+                    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());
+                    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)
             {
-                if(animator()){
+                if (animator()) {
-                   animator()->updateLayout(this,layout);
+                    animator()->updateLayout(this,layout);
+                } else {
+                    setLayout(layout);
                 }
-                else setLayout(layout);
             }
             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) {
+                if (!category) {
                     int n = qMax(int(-floor(log10((max-min)/(ticks-1)))),0);
                     for(int i=0; i< ticks; i++) {
                         qreal value = min + (i * (max - min)/ (ticks-1));
                         labels << QString::number(value,'f',n);
                     }
+                } else {
-                else {
                     QList<qreal> values = categories->values();
-                    for(int i=0; i< ticks; i++) {
+                    for (int i=0; i< ticks; i++) {
                         qreal value = (min + (i * (max - min)/ (ticks-1)));
                         int j=0;
-                        for(; j<values.count(); j++){
+                        for (; j<values.count(); j++) {
                             if (values.at(j) > value) break;
                         }
-                        if(j!=0) value=values.at(j-1);
+                        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)
+            void Axis::setLabelsPen(const QPen &pen)
             {
                 foreach(QGraphicsItem* item , m_labels.childItems()) {
                     static_cast<QGraphicsSimpleTextItem*>(item)->setPen(pen);
                 }
             }
-            void Axis::setLabelsBrush(const QBrush& brush)
+            void Axis::setLabelsBrush(const QBrush &brush)
             {
                 foreach(QGraphicsItem* item , m_labels.childItems()) {
                     static_cast<QGraphicsSimpleTextItem*>(item)->setBrush(brush);
                 }
             }
-            void Axis::setLabelsFont(const QFont& font)
+            void Axis::setLabelsFont(const QFont &font)
             {
                 foreach(QGraphicsItem* item , m_labels.childItems()) {
                     static_cast<QGraphicsSimpleTextItem*>(item)->setFont(font);
                 }
             }
-            void Axis::setShadesBrush(const QBrush& brush)
+            void Axis::setShadesBrush(const QBrush &brush)
             {
                 foreach(QGraphicsItem* item , m_shades.childItems()) {
                     static_cast<QGraphicsRectItem*>(item)->setBrush(brush);
                 }
             }
-            void Axis::setShadesPen(const QPen& pen)
+            void Axis::setShadesPen(const QPen &pen)
             {
                 foreach(QGraphicsItem* item , m_shades.childItems()) {
                     static_cast<QGraphicsRectItem*>(item)->setPen(pen);
                 }
             }
-            void Axis::setAxisPen(const QPen& 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)
+            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)
             {
             	int diff = m_layoutVector.size() - layout.size();
-            	if(diff>0) {
+                if (diff>0) {
             		deleteItems(diff);
             	}
             	else if(diff<0) {
             		createItems(-diff);
             	}
             	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){
             				    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){
             				    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) {
             					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){
             				    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){
             				    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) {
             					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";
             		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;
             	updateLayout(m_layoutVector);
             }
             void Axis::handleAxisUpdated()
             {
-                if(isEmpty()) return;
+                if (isEmpty()) return;
-                if(m_chartAxis->isAxisVisible()) {
+                if (m_chartAxis->isAxisVisible()) {
                     setAxisOpacity(100);
+                } else {
-                else {
                     setAxisOpacity(0);
                 }
                 if(m_chartAxis->isGridLineVisible()) {
                     setGridOpacity(100);
+                } else {
-                else {
                     setGridOpacity(0);
                 }
-                if(m_chartAxis->labelsVisible())
+                if(m_chartAxis->labelsVisible()) {
                     setLabelsOpacity(100);
+                } else {
-                else {
                     setLabelsOpacity(0);
                 }
-                if(m_chartAxis->shadesVisible()) {
+                if (m_chartAxis->shadesVisible()) {
                     setShadesOpacity(m_chartAxis->shadesOpacity());
+                } else {
-                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;
                 m_min = min;
                 m_max = max;
                 m_ticksCount= tickCount;
-                if(isEmpty()) return;
+                if (isEmpty()) return;
                 QVector<qreal> layout = calculateLayout();
                 updateLayout(layout);
             }
             void Axis::handleGeometryChanged(const QRectF& rect)
             {
                 m_rect = rect;
-                if(isEmpty()) return;
+                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/axisitem_p.h +13 -13

             #ifndef AXISITEM_H_
             #define AXISITEM_H_
             #include "chart_p.h"
             #include <QGraphicsItem>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QChartAxis;
             class ChartPresenter;
             class Axis : public Chart
             {
                 Q_OBJECT
             public:
                 enum AxisType{X_AXIS,Y_AXIS};
-                Axis(QChartAxis* axis,ChartPresenter* presenter,AxisType type = X_AXIS);
+                Axis(QChartAxis *axis, ChartPresenter *presenter, AxisType type = X_AXIS);
                 ~Axis();
                 AxisType axisType() const {return m_type;};
                 void setAxisOpacity(qreal opacity);
                 qreal axisOpacity() const;
                 void setGridOpacity(qreal opacity);
                 qreal gridOpacity() const;
                 void setLabelsOpacity(qreal opacity);
                 qreal labelsOpacity() const;
                 void setShadesOpacity(qreal opacity);
                 qreal shadesOpacity() const;
                 void setLabelsAngle(int angle);
                 int labelsAngle()const { return m_labelsAngle; }
-                void setShadesBrush(const QBrush& brush);
+                void setShadesBrush(const QBrush &brush);
-                void setShadesPen(const QPen& pen);
+                void setShadesPen(const QPen &pen);
-                void setAxisPen(const QPen& pen);
+                void setAxisPen(const QPen &pen);
-                void setGridPen(const QPen& pen);
+                void setGridPen(const QPen &pen);
-                void setLabelsPen(const QPen& pen);
+                void setLabelsPen(const QPen &pen);
-                void setLabelsBrush(const QBrush& brush);
+                void setLabelsBrush(const QBrush &brush);
-                void setLabelsFont(const QFont& font);
+                void setLabelsFont(const QFont &font);
                 inline QRectF geometry() const { return m_rect; }
                 inline QVector<qreal> layout() { return m_layoutVector;};
             public slots:
                 void handleAxisUpdated();
                 void handleAxisCategoriesUpdated();
                 void handleRangeChanged(qreal min , qreal max,int tickCount);
-                void handleGeometryChanged(const QRectF& size);
+                void handleGeometryChanged(const QRectF &size);
             private:
                 inline bool isEmpty();
                 void createItems(int count);
                 void deleteItems(int count);
                 QVector<qreal> calculateLayout() const;
-                void updateLayout(QVector<qreal>& layout);
+                void updateLayout(QVector<qreal> &layout);
-                void setLayout(QVector<qreal>& layout);
+                void setLayout(QVector<qreal> &layout);
-                bool createLabels(QStringList& labels,qreal min, qreal max,int ticks) const;
+                bool createLabels(QStringList &labels,qreal min, qreal max,int ticks) const;
                 void axisSelected();
             private:
                 QChartAxis* m_chartAxis;
                 AxisType m_type;
                 QRectF m_rect;
                 int m_labelsAngle;
                 QGraphicsItemGroup m_grid;
                 QGraphicsItemGroup m_shades;
                 QGraphicsItemGroup m_labels;
                 QGraphicsItemGroup m_axis;
                 QVector<qreal> m_layoutVector;
                 qreal m_min;
                 qreal m_max;
                 int m_ticksCount;
                 qreal m_zoomFactor;
                 friend class AxisAnimation;
                 friend class AxisItem;
             };
             class AxisItem: public QGraphicsLineItem
             {
             public:
-                AxisItem(Axis* axis,QGraphicsItem* parent=0):QGraphicsLineItem(parent),m_axis(axis){};
+                AxisItem(Axis *axis, QGraphicsItem *parent=0) : QGraphicsLineItem(parent), m_axis(axis) {};
             protected:
                void mousePressEvent(QGraphicsSceneMouseEvent *event)
                {
                    Q_UNUSED(event)
                    m_axis->axisSelected();
                }
                QRectF boundingRect() const
                {
                   return shape().boundingRect();
                }
                QPainterPath shape() const
                {
                    QPainterPath path = QGraphicsLineItem::shape();
                    QRectF rect = path.boundingRect();
                    path.addRect(rect.adjusted(0,0,m_axis->axisType()!=Axis::X_AXIS?8:0,m_axis->axisType()!=Axis::Y_AXIS?8:0));
                    return path;
                }
             private:
                Axis* m_axis;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif /* AXISITEM_H_ */

src/axis/qchartaxis.h +8 -8

             #ifndef QCHARTAXIS_H_
             #define QCHARTAXIS_H_
             #include <qchartglobal.h>
             #include <qchartaxiscategories.h>
             #include <QPen>
             #include <QFont>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QTCOMMERCIALCHART_EXPORT QChartAxis : public QObject
             {
             	Q_OBJECT
             public:
-                QChartAxis(QObject* parent =0);
+                QChartAxis(QObject *parent =0);
                 ~QChartAxis();
                 //axis handling
                 bool isAxisVisible() const { return m_axisVisible;};
                 void setAxisVisible(bool visible);
-                void setAxisPen(const QPen& pen);
+                void setAxisPen(const QPen &pen);
                 QPen axisPen() const { return m_axisPen;};
                 //grid handling
                 bool isGridLineVisible() const { return m_gridLineVisible;};
                 void setGridLineVisible(bool visible);
-                void setGridLinePen(const QPen& pen);
+                void setGridLinePen(const QPen &pen);
                 QPen gridLinePen() const {return m_gridLinePen;}
                 //labels handling
                 bool labelsVisible() const { return m_labelsVisible;};
                 void setLabelsVisible(bool visible);
-                void setLabelsPen(const QPen& pen);
+                void setLabelsPen(const QPen &pen);
                 QPen labelsPen() const { return m_labelsPen;}
-                void setLabelsBrush(const QBrush& brush);
+                void setLabelsBrush(const QBrush &brush);
                 QBrush labelsBrush() const { return m_labelsBrush;}
-                void setLabelsFont(const QFont& font);
+                void setLabelsFont(const QFont &font);
                 QFont labelsFont() const { return m_labelsFont;}
                 void setLabelsAngle(int angle);
                 int labelsAngle() const { return m_labelsAngle;};
                 //shades handling
                 bool shadesVisible() const { return m_shadesVisible;};
                 void setShadesVisible(bool visible);
-                void setShadesPen(const QPen& pen);
+                void setShadesPen(const QPen &pen);
                 QPen shadesPen() const { return m_shadesPen;}
-                void setShadesBrush(const QBrush& brush);
+                void setShadesBrush(const QBrush &brush);
                 QBrush shadesBrush() const { return m_shadesBrush;}
                 void setShadesOpacity(qreal opacity);
                 qreal shadesOpacity() const { return m_shadesOpacity;}
                 //range handling
                 void setMin(qreal min);
                 qreal min() const { return m_min;};
                 void setMax(qreal max);
                 qreal max() const { return m_max;};
                 void setRange(qreal min, qreal max);
                 //ticks handling
                 void setTicksCount(int count);
                 int ticksCount() const { return m_ticksCount;}
                 void setNiceNumbers(bool enabled);
                 bool niceNumbers() const { return m_niceNumbers;}
                 QChartAxisCategories* categories() { return &m_category; }
                 void show();
                 void hide();
             signals:
             	void minChanged(qreal min);
             	void maxChanged(qreal max);
             	void rangeChanged(qreal min, qreal max);
             	void ticksCountChanged(int count);
             //interal signal
             	void updated();
             	void changed(qreal min, qreal max, int tickCount,bool niceNumbers);
             //internal slot
             public slots:
             	void handleAxisRangeChanged(qreal min, qreal max,int count);
             private:
                 bool m_axisVisible;
                 QPen m_axisPen;
                 QBrush m_axisBrush;
                 bool m_gridLineVisible;
                 QPen m_gridLinePen;
                 bool m_labelsVisible;
                 QPen m_labelsPen;
                 QBrush m_labelsBrush;
                 QFont m_labelsFont;
                 int m_labelsAngle;
                 bool m_shadesVisible;
                 QPen m_shadesPen;
                 QBrush m_shadesBrush;
                 qreal m_shadesOpacity;
                 qreal m_min;
                 qreal m_max;
                 int m_ticksCount;
                 QChartAxisCategories m_category;
                 bool m_niceNumbers;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif /* QCHARTAXIS_H_ */

src/axis/qchartaxiscategories.h +1 -1

             #ifndef QCHARTAXISCATEGORIES_H_
             #define QCHARTAXISCATEGORIES_H_
             #include <qchartglobal.h>
             #include <qbarseries.h>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QTCOMMERCIALCHART_EXPORT QChartAxisCategories : public QObject
             {
                 Q_OBJECT
             private:
                 QChartAxisCategories();
             public:
                 ~QChartAxisCategories();
-                void insert(const QBarCategories& category);
+                void insert(const QBarCategories &category);
                 void insert(qreal value,QString label);
                 void remove(qreal value);
                 QList<qreal> values() const;
                 QString label(qreal value) const;
                 void clear();
                 int count();
             //internal signal
             signals:
                 void updated();
             private:
                 QMap<qreal,QString> m_map;
             friend class QChartAxis;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif /* QCHARTAXISCATEGORIES_H_ */

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