HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r763:4467255a8e44

minor code review fixes, part n

sauimone -

r763:4467255a8e44

parent child

Context file:

r763:4467255a8e44

Collapse all files

src/barchart/bar.cpp +3 -3

             Bar::Bar(QString category, QGraphicsItem *parent)
                 : QGraphicsRectItem(parent),
-                m_Category(category)
+                m_category(category)
             {
                 setAcceptedMouseButtons(Qt::LeftButton | Qt::RightButton);
                 setAcceptHoverEvents(true);
             void Bar::mousePressEvent(QGraphicsSceneMouseEvent *event)
             {
                 if (event->button() == Qt::LeftButton) {
-                    emit clicked(m_Category);
+                    emit clicked(m_category);
                 } else if (event->button() == Qt::RightButton) {
-                    emit rightClicked(m_Category);
+                    emit rightClicked(m_category);
                 }
             }

src/barchart/bar_p.h +1 -1

                 void hoverLeaved();
             private:
-                QString m_Category;
+                QString m_category;
             };
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/barchartitem.cpp +41 -41

             BarChartItem::BarChartItem(QBarSeries *series, ChartPresenter *presenter) :
                 ChartItem(presenter),
-                m_LayoutSet(false),
+                m_layoutSet(false),
-                m_Series(series)
+                m_series(series)
             {
                 connect(series, SIGNAL(showToolTip(QPoint,QString)), this, SLOT(showToolTip(QPoint,QString)));
                 connect(series, SIGNAL(updatedBars()), this, SLOT(handleLayoutChanged()));
             void BarChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
-                if (!m_LayoutSet) {
+                if (!m_layoutSet) {
                     qWarning() << "BarChartItem::paint called without layout set. Aborting.";
                     return;
                 }
                 foreach (QGraphicsItem *item, childItems())
                     delete item;
-                m_Bars.clear();
+                m_bars.clear();
-                m_FloatingValues.clear();
+                m_floatingValues.clear();
-                m_Layout.clear();
+                m_layout.clear();
                 // Create new graphic items for bars
-                for (int c = 0; c < m_Series->categoryCount(); c++) {
+                for (int c = 0; c < m_series->categoryCount(); c++) {
-                    QString category = m_Series->categoryName(c);
+                    QString category = m_series->categoryName(c);
-                    for (int s = 0; s < m_Series->barsetCount(); s++) {
+                    for (int s = 0; s < m_series->barsetCount(); s++) {
-                        QBarSet *set = m_Series->barsetAt(s);
+                        QBarSet *set = m_series->barsetAt(s);
                         Bar *bar = new Bar(category,this);
                         childItems().append(bar);
-                        m_Bars.append(bar);
+                        m_bars.append(bar);
                         connect(bar, SIGNAL(clicked(QString)), set, SIGNAL(clicked(QString)));
                         connect(bar, SIGNAL(rightClicked(QString)), set, SIGNAL(rightClicked(QString)));
                         connect(bar, SIGNAL(hoverEntered(QPoint)), set, SLOT(barHoverEnterEvent(QPoint)));
                         connect(bar, SIGNAL(hoverLeaved()), set, SLOT(barHoverLeaveEvent()));
-                        m_Layout.append(QRectF(0, 0, 0, 0));
+                        m_layout.append(QRectF(0, 0, 0, 0));
                     }
                 }
                 // Create floating values
-                for (int category = 0; category < m_Series->categoryCount(); category++) {
+                for (int category = 0; category < m_series->categoryCount(); category++) {
-                    for (int s = 0; s < m_Series->barsetCount(); s++) {
+                    for (int s = 0; s < m_series->barsetCount(); s++) {
-                        QBarSet *set = m_Series->barsetAt(s);
+                        QBarSet *set = m_series->barsetAt(s);
                         BarValue *value = new BarValue(*set, this);
                         childItems().append(value);
-                        m_FloatingValues.append(value);
+                        m_floatingValues.append(value);
                         connect(set, SIGNAL(toggleFloatingValues()), value, SLOT(toggleVisible()));
                     }
                 }
                 QVector<QRectF> layout;
                 // Use temporary qreals for accurancy (we might get some compiler warnings... :)
-                qreal categoryCount = m_Series->categoryCount();
+                qreal categoryCount = m_series->categoryCount();
-                qreal setCount = m_Series->barsetCount();
+                qreal setCount = m_series->barsetCount();
                 qreal width = geometry().width();
                 qreal height = geometry().height();
-                qreal max = m_Series->max();
+                qreal max = m_series->max();
                 // Domain:
-                if (m_DomainMaxY > max) {
+                if (m_domainMaxY > max) {
-                    max = m_DomainMaxY;
+                    max = m_domainMaxY;
                 }
                 qreal scale = (height / max);
                     qreal xPos = categoryWidth * category + barWidth / 2;
                     qreal yPos = height;
                     for (int set = 0; set < setCount; set++) {
-                        qreal barHeight = m_Series->valueAt(set, category) * scale;
+                        qreal barHeight = m_series->valueAt(set, category) * scale;
-                        Bar* bar = m_Bars.at(itemIndex);
+                        Bar* bar = m_bars.at(itemIndex);
                         QRectF rect(xPos, yPos - barHeight, barWidth, barHeight);
                         layout.append(rect);
-                        bar->setPen(m_Series->barsetAt(set)->pen());
+                        bar->setPen(m_series->barsetAt(set)->pen());
-                        bar->setBrush(m_Series->barsetAt(set)->brush());
+                        bar->setBrush(m_series->barsetAt(set)->brush());
                         itemIndex++;
                         xPos += barWidth;
                     }
                 // Position floating values
                 itemIndex = 0;
-                for (int category = 0; category < m_Series->categoryCount(); category++) {
+                for (int category = 0; category < m_series->categoryCount(); category++) {
                     qreal xPos = categoryWidth * category  + barWidth;
                     qreal yPos = height;
-                    for (int set=0; set < m_Series->barsetCount(); set++) {
+                    for (int set=0; set < m_series->barsetCount(); set++) {
-                        qreal barHeight = m_Series->valueAt(set, category) * scale;
+                        qreal barHeight = m_series->valueAt(set, category) * scale;
-                        BarValue* value = m_FloatingValues.at(itemIndex);
+                        BarValue* value = m_floatingValues.at(itemIndex);
-                        QBarSet* barSet = m_Series->barsetAt(set);
+                        QBarSet* barSet = m_series->barsetAt(set);
                         value->resize(100, 50);  // TODO: proper layout for this.
                         value->setPos(xPos, yPos-barHeight / 2);
                         value->setPen(barSet->floatingValuePen());
-                        if (m_Series->valueAt(set,category) != 0) {
+                        if (m_series->valueAt(set,category) != 0) {
-                            value->setValueString(QString::number(m_Series->valueAt(set, category)));
+                            value->setValueString(QString::number(m_series->valueAt(set, category)));
                         } else {
                             value->setValueString(QString(""));
                         }
             void BarChartItem::applyLayout(const QVector<QRectF> &layout)
             {
                 if (animator())
-                    animator()->updateLayout(this, m_Layout, layout);
+                    animator()->updateLayout(this, m_layout, layout);
                 else
                     setLayout(layout);
             }
             void BarChartItem::setLayout(const QVector<QRectF> &layout)
             {
-                m_Layout = layout;
+                m_layout = layout;
-                for (int i=0; i < m_Bars.count(); i++)
+                for (int i=0; i < m_bars.count(); i++)
-                    m_Bars.at(i)->setRect(layout.at(i));
+                    m_bars.at(i)->setRect(layout.at(i));
                 update();
             }
             void BarChartItem::handleDomainChanged(qreal minX, qreal maxX, qreal minY, qreal maxY)
             {
-                m_DomainMinX = minX;
+                m_domainMinX = minX;
-                m_DomainMaxX = maxX;
+                m_domainMaxX = maxX;
-                m_DomainMinY = minY;
+                m_domainMinY = minY;
-                m_DomainMaxY = maxY;
+                m_domainMaxY = maxY;
                 handleLayoutChanged();
             }
             {
                 m_rect = rect;
                 handleLayoutChanged();
-                m_LayoutSet = true;
+                m_layoutSet = true;
                 setPos(rect.topLeft());
             }

src/barchart/barchartitem_p.h +9 -9

             protected:
                 // TODO: consider these.
-                qreal m_DomainMinX;
+                qreal m_domainMinX;
-                qreal m_DomainMaxX;
+                qreal m_domainMaxX;
-                qreal m_DomainMinY;
+                qreal m_domainMinY;
-                qreal m_DomainMaxY;
+                qreal m_domainMaxY;
                 QRectF m_rect;
-                bool m_LayoutSet;    // True, if component has been laid out.
+                bool m_layoutSet;    // True, if component has been laid out.
-                QVector<QRectF> m_Layout;
+                QVector<QRectF> m_layout;
                 // Not owned.
-                QBarSeries *m_Series;
+                QBarSeries *m_series;
-                QList<Bar *> m_Bars;
+                QList<Bar *> m_bars;
-                QList<BarValue *> m_FloatingValues;
+                QList<BarValue *> m_floatingValues;
             };
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/barchartmodel.cpp +30 -30

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             BarChartModel::BarChartModel(QStringList categories, QObject *parent) : QObject(parent),
-                m_Category(categories)
+                m_category(categories)
             {
             }
             QStringList BarChartModel::category()
             {
-                return m_Category;
+                return m_category;
             }
             void BarChartModel::addBarSet(QBarSet *set)
             {
-                m_DataModel.append(set);
+                m_dataModel.append(set);
             }
             void BarChartModel::removeBarSet(QBarSet *set)
             {
-                if (m_DataModel.contains(set)) {
+                if (m_dataModel.contains(set)) {
-                    m_DataModel.removeOne(set);
+                    m_dataModel.removeOne(set);
                 }
             }
             void BarChartModel::insertBarSet(int i, QBarSet *set)
             {
-                m_DataModel.insert(i, set);
+                m_dataModel.insert(i, set);
             }
             void BarChartModel::insertCategory(int i, QString category)
             {
-                m_Category.insert(i, category);
+                m_category.insert(i, category);
             }
             void BarChartModel::removeCategory(int i)
             {
-                m_Category.removeAt(i);
+                m_category.removeAt(i);
             }
             QBarSet* BarChartModel::setAt(int index)
             {
-                return m_DataModel.at(index);
+                return m_dataModel.at(index);
             }
             QList<QBarSet*> BarChartModel::barSets()
             {
-                return m_DataModel;
+                return m_dataModel;
             }
             int BarChartModel::barsetCount()
             {
-                return m_DataModel.count();
+                return m_dataModel.count();
             }
             int BarChartModel::categoryCount()
             {
-                return m_Category.count();
+                return m_category.count();
             }
             qreal BarChartModel::min()
             {
-                Q_ASSERT(m_DataModel.count() > 0);
+                Q_ASSERT(m_dataModel.count() > 0);
                 // TODO: make min and max members and update them when data changes.
                 // This is slower since they are checked every time, even if data is same since previous call.
                 qreal min = INT_MAX;
-                for (int i = 0; i < m_DataModel.count(); i++) {
+                for (int i = 0; i < m_dataModel.count(); i++) {
-                    int itemCount = m_DataModel.at(i)->count();
+                    int itemCount = m_dataModel.at(i)->count();
                     for (int j = 0; j < itemCount; j++) {
-                        qreal temp = m_DataModel.at(i)->valueAt(j);
+                        qreal temp = m_dataModel.at(i)->valueAt(j);
                         if (temp < min)
                             min = temp;
                     }
             qreal BarChartModel::max()
             {
-                Q_ASSERT(m_DataModel.count() > 0);
+                Q_ASSERT(m_dataModel.count() > 0);
                 // TODO: make min and max members and update them when data changes.
                 // This is slower since they are checked every time, even if data is same since previous call.
                 qreal max = INT_MIN;
-                for (int i = 0; i < m_DataModel.count(); i++) {
+                for (int i = 0; i < m_dataModel.count(); i++) {
-                    int itemCount = m_DataModel.at(i)->count();
+                    int itemCount = m_dataModel.at(i)->count();
                     for (int j = 0; j < itemCount; j++) {
-                        qreal temp = m_DataModel.at(i)->valueAt(j);
+                        qreal temp = m_dataModel.at(i)->valueAt(j);
                         if (temp > max)
                             max = temp;
                     }
             qreal BarChartModel::valueAt(int set, int category)
             {
-                if ((set < 0) || (set >= m_DataModel.count())) {
+                if ((set < 0) || (set >= m_dataModel.count())) {
                     // No set, no value.
                     return 0;
-                } else if ((category < 0) || (category >= m_DataModel.at(set)->count())) {
+                } else if ((category < 0) || (category >= m_dataModel.at(set)->count())) {
                     // No category, no value.
                     return 0;
                 }
-                return m_DataModel.at(set)->valueAt(category);
+                return m_dataModel.at(set)->valueAt(category);
             }
             qreal BarChartModel::percentageAt(int set, int category)
             {
-                if ((set < 0) || (set >= m_DataModel.count())) {
+                if ((set < 0) || (set >= m_dataModel.count())) {
                     // No set, no value.
                     return 0;
-                } else if ((category < 0) || (category >= m_DataModel.at(set)->count())) {
+                } else if ((category < 0) || (category >= m_dataModel.at(set)->count())) {
                     // No category, no value.
                     return 0;
                 }
-                qreal value = m_DataModel.at(set)->valueAt(category);
+                qreal value = m_dataModel.at(set)->valueAt(category);
                 qreal total = categorySum(category);
                 if (0 == total)
                     return 100.0;
             qreal BarChartModel::categorySum(int category)
             {
                 qreal sum(0);
-                int count = m_DataModel.count(); // Count sets
+                int count = m_dataModel.count(); // Count sets
                 for (int set = 0; set < count; set++) {
-                    if (category < m_DataModel.at(set)->count())
+                    if (category < m_dataModel.at(set)->count())
-                        sum += m_DataModel.at(set)->valueAt(category);
+                        sum += m_dataModel.at(set)->valueAt(category);
                 }
                 return sum;
             }
             QString BarChartModel::categoryName(int category)
             {
-                return m_Category.at(category);
+                return m_category.at(category);
             }
             #include "moc_barchartmodel_p.cpp"

src/barchart/barchartmodel_p.h +2 -2

             private:
-                QList<QBarSet *> m_DataModel;
+                QList<QBarSet *> m_dataModel;
-                QStringList m_Category;
+                QStringList m_category;
             };
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/barvalue.cpp +16 -16

             BarValue::BarValue(QBarSet &set, QGraphicsItem *parent)
                 : QGraphicsObject(parent),
-                m_BarSet(set),
+                m_barSet(set),
-                m_Xpos(0),
+                m_xPos(0),
-                m_Ypos(0),
+                m_yPos(0),
-                m_Width(0),
+                m_width(0),
-                m_Height(0)
+                m_height(0)
             {
                 setVisible(false);
             }
             void BarValue::setValueString(QString str)
             {
-                m_ValueString = str;
+                m_valueString = str;
             }
             QString BarValue::valueString()
             {
-                return m_ValueString;
+                return m_valueString;
             }
             void BarValue::setPen(const QPen pen)
             {
-                m_Pen = pen;
+                m_pen = pen;
             }
             QPen BarValue::pen() const
             {
-                return m_Pen;
+                return m_pen;
             }
             void BarValue::resize(qreal w, qreal h)
             {
-                m_Width = w;
+                m_width = w;
-                m_Height = h;
+                m_height = h;
             }
             void BarValue::setPos(qreal x, qreal y)
             {
-                m_Xpos = x;
+                m_xPos = x;
-                m_Ypos = y;
+                m_yPos = y;
             }
             void BarValue::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
                 Q_UNUSED(widget)
                 if (isVisible()) {
-                    painter->setPen(m_Pen);
+                    painter->setPen(m_pen);
-                    painter->drawText(boundingRect(), m_ValueString);
+                    painter->drawText(boundingRect(), m_valueString);
                 }
             }
             QRectF BarValue::boundingRect() const
             {
-                QRectF r(m_Xpos, m_Ypos, m_Width, m_Height);
+                QRectF r(m_xPos, m_yPos, m_width, m_height);
                 return r;
             }

src/barchart/barvalue_p.h +8 -8

             private:
-                QBarSet &m_BarSet;
+                QBarSet &m_barSet;
-                QPen m_Pen;
+                QPen m_pen;
-                QString m_ValueString;
+                QString m_valueString;
-                qreal m_Xpos;
+                qreal m_xPos;
-                qreal m_Ypos;
+                qreal m_yPos;
-                qreal m_Width;
+                qreal m_width;
-                qreal m_Height;
+                qreal m_height;
             };
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/percentbarchartitem.cpp +16 -16

                 qreal width = geometry().width();
                 qreal height = geometry().height();
-                qreal categoryCount = m_Series->categoryCount();
+                qreal categoryCount = m_series->categoryCount();
-                qreal barWidth = width / (m_Series->categoryCount() * 2);
+                qreal barWidth = width / (m_series->categoryCount() * 2);
                 qreal xStep = width / categoryCount;
                 qreal xPos =  xStep / 2 - barWidth / 2;
                 int itemIndex(0);
                 for (int category = 0; category < categoryCount; category++) {
-                    qreal colSum = m_Series->categorySum(category);
+                    qreal colSum = m_series->categorySum(category);
                     qreal scale = (height / colSum);
                     qreal yPos = height;
-                    for (int set=0; set < m_Series->barsetCount(); set++) {
+                    for (int set=0; set < m_series->barsetCount(); set++) {
-                        qreal barHeight = m_Series->valueAt(set, category) * scale;
+                        qreal barHeight = m_series->valueAt(set, category) * scale;
-                        Bar* bar = m_Bars.at(itemIndex);
+                        Bar* bar = m_bars.at(itemIndex);
-                        bar->setPen(m_Series->barsetAt(set)->pen());
+                        bar->setPen(m_series->barsetAt(set)->pen());
-                        bar->setBrush(m_Series->barsetAt(set)->brush());
+                        bar->setBrush(m_series->barsetAt(set)->brush());
                         QRectF rect(xPos, yPos-barHeight, barWidth, barHeight);
                         layout.append(rect);
                         itemIndex++;
                 // Position floating values
                 itemIndex = 0;
                 xPos = (width/categoryCount);
-                for (int category=0; category < m_Series->categoryCount(); category++) {
+                for (int category=0; category < m_series->categoryCount(); category++) {
                     qreal yPos = height;
-                    qreal colSum = m_Series->categorySum(category);
+                    qreal colSum = m_series->categorySum(category);
                     qreal scale = (height / colSum);
-                    for (int set=0; set < m_Series->barsetCount(); set++) {
+                    for (int set=0; set < m_series->barsetCount(); set++) {
-                        qreal barHeight = m_Series->valueAt(set,category) * scale;
+                        qreal barHeight = m_series->valueAt(set,category) * scale;
-                        BarValue* value = m_FloatingValues.at(itemIndex);
+                        BarValue* value = m_floatingValues.at(itemIndex);
-                        QBarSet* barSet = m_Series->barsetAt(set);
+                        QBarSet* barSet = m_series->barsetAt(set);
                         value->resize(100, 50);  // TODO: proper layout for this.
                         value->setPos(xPos, yPos-barHeight / 2);
                         value->setPen(barSet->floatingValuePen());
-                        if (m_Series->valueAt(set,category) != 0) {
+                        if (m_series->valueAt(set,category) != 0) {
-                            int p = m_Series->percentageAt(set,category) * 100;
+                            int p = m_series->percentageAt(set,category) * 100;
                             QString vString(QString::number(p));
                             vString.truncate(3);
                             vString.append("%");

src/barchart/qbarseries.cpp +27 -27

                 QBarSeries is QObject which is a child of a \a parent.
             */
             QBarSeries::QBarSeries(QBarCategories categories, QObject *parent) : QSeries(parent),
-                m_Model(new BarChartModel(categories, this))
+                m_internalModel(new BarChartModel(categories, this))
             {
                 m_model = NULL;
                 m_mapCategories = -1;
             */
             void QBarSeries::addBarSet(QBarSet *set)
             {
-                m_Model->addBarSet(set);
+                m_internalModel->addBarSet(set);
                 connect(set, SIGNAL(clicked(QString)), this, SLOT(barsetClicked(QString)));
                 connect(set, SIGNAL(rightClicked(QString)), this, SLOT(barsetRightClicked(QString)));
                 connect(set, SIGNAL(valueChanged()), this, SLOT(barsetChanged()));
             {
                 disconnect(set, SIGNAL(clicked(QString)), this, SLOT(barsetClicked(QString)));
                 disconnect(set, SIGNAL(rightClicked(QString)), this, SLOT(barsetRightClicked(QString)));
-                m_Model->removeBarSet(set);
+                m_internalModel->removeBarSet(set);
                 emit updatedBars();
             }
             void QBarSeries::insertBarSet(int i, QBarSet *set)
             {
-                m_Model->insertBarSet(i, set);
+                m_internalModel->insertBarSet(i, set);
                 //    emit barsetChanged();
             }
             void QBarSeries::insertCategory(int i, QString category)
             {
-                m_Model->insertCategory(i, category);
+                m_internalModel->insertCategory(i, category);
             }
             void QBarSeries::removeCategory(int i)
             {
-                m_Model->removeCategory(i);
+                m_internalModel->removeCategory(i);
             }
             /*!
                 //    if(m_model)
                 //        return m_mapBarTop - m_mapBarBottom;
                 //    else
-                return m_Model->barsetCount();
+                return m_internalModel->barsetCount();
             }
             /*!
             */
             int QBarSeries::categoryCount()
             {
-                return m_Model->categoryCount();
+                return m_internalModel->categoryCount();
             }
             /*!
              */
             QList<QBarSet*> QBarSeries::barSets()
             {
-                return m_Model->barSets();
+                return m_internalModel->barSets();
             }
             /*!
             */
             QBarSet* QBarSeries::barsetAt(int index)
             {
-                return m_Model->setAt(index);
+                return m_internalModel->setAt(index);
             }
             /*!
             */
             QString QBarSeries::categoryName(int category)
             {
-                return m_Model->categoryName(category);
+                return m_internalModel->categoryName(category);
             }
             /*!
             {
                 // TODO: what if we add sets after call to this function? Those sets won't have tooltip enabled.
                 if (enabled) {
-                    for (int i=0; i<m_Model->barsetCount(); i++) {
+                    for (int i=0; i<m_internalModel->barsetCount(); i++) {
-                        QBarSet *set = m_Model->setAt(i);
+                        QBarSet *set = m_internalModel->setAt(i);
                         connect(set, SIGNAL(showToolTip(QPoint,QString)), this, SIGNAL(showToolTip(QPoint,QString)));
                     }
                 } else {
-                    for (int i=0; i<m_Model->barsetCount(); i++) {
+                    for (int i=0; i<m_internalModel->barsetCount(); i++) {
-                        QBarSet *set = m_Model->setAt(i);
+                        QBarSet *set = m_internalModel->setAt(i);
                         disconnect(set, SIGNAL(showToolTip(QPoint,QString)), this, SIGNAL(showToolTip(QPoint,QString)));
                     }
                 }
             */
             qreal QBarSeries::min()
             {
-                return m_Model->min();
+                return m_internalModel->min();
             }
             /*!
             */
             qreal QBarSeries::max()
             {
-                return m_Model->max();
+                return m_internalModel->max();
             }
             /*!
             */
             qreal QBarSeries::valueAt(int set, int category)
             {
-                return m_Model->valueAt(set, category);
+                return m_internalModel->valueAt(set, category);
             }
             /*!
             */
             qreal QBarSeries::percentageAt(int set, int category)
             {
-                return m_Model->percentageAt(set, category);
+                return m_internalModel->percentageAt(set, category);
             }
             /*!
             */
             qreal QBarSeries::categorySum(int category)
             {
-                return m_Model->categorySum(category);
+                return m_internalModel->categorySum(category);
             }
             /*!
             */
             qreal QBarSeries::maxCategorySum()
             {
-                return m_Model->maxCategorySum();
+                return m_internalModel->maxCategorySum();
             }
             /*!
             */
             BarChartModel& QBarSeries::model()
             {
-                return *m_Model;
+                return *m_internalModel;
             }
             bool QBarSeries::setModel(QAbstractItemModel *model)
                 // create the initial bars
-                delete m_Model;
+                delete m_internalModel;
                 if (m_mapOrientation == Qt::Vertical) {
                     QStringList categories;
                     for (int k = m_mapFirst; k < m_mapFirst + m_mapCount; k++)
                         categories << m_model->data(m_model->index(k, m_mapCategories), Qt::DisplayRole).toString();
-                    m_Model = new BarChartModel(categories, this);
+                    m_internalModel = new BarChartModel(categories, this);
                     for (int i = m_mapBarBottom; i <= m_mapBarTop; i++) {
                         QBarSet* barSet = new QBarSet(QString("Column: %1").arg(i + 1));
                     QStringList categories;
                     for (int k = m_mapFirst; k < m_mapFirst + m_mapCount; k++)
                         categories << m_model->data(m_model->index(m_mapCategories, k), Qt::DisplayRole).toString();
-                    m_Model = new BarChartModel(categories, this);
+                    m_internalModel = new BarChartModel(categories, this);
                     for (int i = m_mapBarBottom; i <= m_mapBarTop; i++) {
                         QBarSet* barSet = new QBarSet(QString("Row: %1").arg(i + 1));
             QBarCategories QBarSeries::categories() const
             {
                 QBarCategories categories;
-                int count = m_Model->categoryCount();
+                int count = m_internalModel->categoryCount();
                 for (int i=1; i <= count; i++) {
-                      categories.insert(i, m_Model->categoryName(i - 1));
+                      categories.insert(i, m_internalModel->categoryName(i - 1));
                 }
                 return categories;
             }

src/barchart/qbarseries.h +2 -2

                 void barsetChanged();
             protected:
-                BarChartModel *m_Model;
+                BarChartModel *m_internalModel;
-            //    QAbstractItemModel* m_model;
+                QAbstractItemModel* m_model;
                 int m_mapCategories;
                 int m_mapBarBottom;
                 int m_mapBarTop;

src/barchart/qbarset.cpp +21 -21

             */
             QBarSet::QBarSet(QString name, QObject *parent)
                 : QObject(parent)
-                ,m_Name(name)
+                ,m_name(name)
             {
             }
             */
             void QBarSet::setName(QString name)
             {
-                m_Name = name;
+                m_name = name;
             }
             /*!
             */
             QString QBarSet::name()
             {
-                return m_Name;
+                return m_name;
             }
             /*!
             */
             QBarSet& QBarSet::operator << (const qreal &value)
             {
-                m_Values.append(value);
+                m_values.append(value);
                 emit structureChanged();
                 return *this;
             }
             void QBarSet::insertValue(int i, qreal value)
             {
-                m_Values.insert(i, value);
+                m_values.insert(i, value);
             }
             void QBarSet::removeValue(int i)
             {
-                m_Values.removeAt(i);
+                m_values.removeAt(i);
             }
             /*!
             */
             int QBarSet::count()
             {
-                return m_Values.count();
+                return m_values.count();
             }
             /*!
             */
             qreal QBarSet::valueAt(int index)
             {
-                return m_Values.at(index);
+                return m_values.at(index);
             }
             /*!
             */
             void QBarSet::setValue(int index, qreal value)
             {
-                m_Values.replace(index,value);
+                m_values.replace(index,value);
                 emit valueChanged();
             }
             qreal QBarSet::total()
             {
                 qreal total(0);
-                for (int i=0; i < m_Values.count(); i++) {
+                for (int i=0; i < m_values.count(); i++) {
-                    total += m_Values.at(i);
+                    total += m_values.at(i);
                 }
                 return total;
             }
             /*!
                 Sets pen for set. Bars of this set are drawn using \a pen
             */
-            void QBarSet::setPen(const QPen pen)
+            void QBarSet::setPen(const QPen &pen)
             {
-                m_Pen = pen;
+                m_pen = pen;
                 emit valueChanged();
             }
             */
             QPen QBarSet::pen() const
             {
-                return m_Pen;
+                return m_pen;
             }
             /*!
                 Sets brush for the set. Bars of this set are drawn using \a brush
             */
-            void QBarSet::setBrush(const QBrush brush)
+            void QBarSet::setBrush(const QBrush &brush)
             {
-                m_Brush = brush;
+                m_brush = brush;
                 emit valueChanged();
             }
             */
             QBrush QBarSet::brush() const
             {
-                return m_Brush;
+                return m_brush;
             }
             /*!
                 Sets the pen for floating values that are drawn on top of this set
             */
-            void QBarSet::setFloatingValuePen(const QPen pen)
+            void QBarSet::setFloatingValuePen(const QPen &pen)
             {
-                m_FloatingValuePen = pen;
+                m_floatingValuePen = pen;
             }
             /*!
             */
             QPen QBarSet::floatingValuePen() const
             {
-                return m_FloatingValuePen;
+                return m_floatingValuePen;
             }
             /*!
             */
             void QBarSet::barHoverEnterEvent(QPoint pos)
             {
-                emit showToolTip(pos, m_Name);
+                emit showToolTip(pos, m_name);
                 emit hoverEnter(pos);
             }

src/barchart/qbarset.h +9 -9

                 //qreal value(QString category);
                 //void setValue(QString category, qreal value);
-                void setPen(const QPen pen);
+                void setPen(const QPen &pen);
                 QPen pen() const;
-                void setBrush(const QBrush brush);
+                void setBrush(const QBrush &brush);
                 QBrush brush() const;
-                void setFloatingValuePen(const QPen pen);
+                void setFloatingValuePen(const QPen &pen);
                 QPen floatingValuePen() const;
             Q_SIGNALS:
             private:
-                QString m_Name;
+                QString m_name;
-                QList<qreal> m_Values;   // TODO: replace with map (category, value)
+                QList<qreal> m_values;   // TODO: replace with map (category, value)
-                QMap<QString, qreal> m_MappedValues;
+                QMap<QString, qreal> m_mappedValues;
-                QPen m_Pen;
+                QPen m_pen;
-                QBrush m_Brush;
+                QBrush m_brush;
-                QPen m_FloatingValuePen;
+                QPen m_floatingValuePen;
             };
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/stackedbarchartitem.cpp +17 -17

                 QVector<QRectF> layout;
                 // Use temporary qreals for accurancy (we might get some compiler warnings... :)
-                qreal maxSum = m_Series->maxCategorySum();
+                qreal maxSum = m_series->maxCategorySum();
                 // Domain:
-                if (m_DomainMaxY > maxSum) {
+                if (m_domainMaxY > maxSum) {
-                    maxSum = m_DomainMaxY;
+                    maxSum = m_domainMaxY;
                 }
                 qreal height = geometry().height();
                 qreal width = geometry().width();
-                qreal scale = (height /  m_Series->maxCategorySum());
+                qreal scale = (height /  m_series->maxCategorySum());
-                qreal categotyCount = m_Series->categoryCount();
+                qreal categotyCount = m_series->categoryCount();
                 qreal barWidth = width / (categotyCount * 2);
                 qreal xStep = width / categotyCount;
                 qreal xPos = xStep / 2 - barWidth / 2;
                 int itemIndex(0);
                 for (int category = 0; category < categotyCount; category++) {
                     qreal yPos = height;
-                    for (int set=0; set < m_Series->barsetCount(); set++) {
+                    for (int set=0; set < m_series->barsetCount(); set++) {
-                        qreal barHeight = m_Series->valueAt(set, category) * scale;
+                        qreal barHeight = m_series->valueAt(set, category) * scale;
-                        Bar* bar = m_Bars.at(itemIndex);
+                        Bar* bar = m_bars.at(itemIndex);
-                        bar->setPen(m_Series->barsetAt(set)->pen());
+                        bar->setPen(m_series->barsetAt(set)->pen());
-                        bar->setBrush(m_Series->barsetAt(set)->brush());
+                        bar->setBrush(m_series->barsetAt(set)->brush());
                         QRectF rect(xPos, yPos-barHeight, barWidth, barHeight);
                         layout.append(rect);
                         itemIndex++;
                 // Position floating values
                 itemIndex = 0;
                 xPos = (width/categotyCount);
-                for (int category=0; category < m_Series->categoryCount(); category++) {
+                for (int category=0; category < m_series->categoryCount(); category++) {
                     qreal yPos = height;
-                    for (int set=0; set < m_Series->barsetCount(); set++) {
+                    for (int set=0; set < m_series->barsetCount(); set++) {
-                        qreal barHeight = m_Series->valueAt(set, category) * scale;
+                        qreal barHeight = m_series->valueAt(set, category) * scale;
-                        BarValue* value = m_FloatingValues.at(itemIndex);
+                        BarValue* value = m_floatingValues.at(itemIndex);
-                        QBarSet* barSet = m_Series->barsetAt(set);
+                        QBarSet* barSet = m_series->barsetAt(set);
                         value->resize(100, 50);  // TODO: proper layout for this.
                         value->setPos(xPos, yPos-barHeight / 2);
                         value->setPen(barSet->floatingValuePen());
-                        if (m_Series->valueAt(set, category) != 0) {
+                        if (m_series->valueAt(set, category) != 0) {
-                            value->setValueString(QString::number(m_Series->valueAt(set,category)));
+                            value->setValueString(QString::number(m_series->valueAt(set,category)));
                         } else {
                             value->setValueString(QString(""));
                         }

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