HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r762:aec68d24dd4f

minor code review fixes

sauimone -

r762:aec68d24dd4f

parent child

Context file:

r762:aec68d24dd4f

Collapse all files

src/barchart/bar.cpp +3 -3

             #include "bar_p.h"
             #include <QDebug>
             #include <QPainter>
             #include <QGraphicsSceneEvent>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             Bar::Bar(QString category, QGraphicsItem *parent)
                 : QGraphicsRectItem(parent),
-                mCategory(category)
+                m_Category(category)
             {
                 setAcceptedMouseButtons(Qt::LeftButton | Qt::RightButton);
                 setAcceptHoverEvents(true);
             }
             void Bar::mousePressEvent(QGraphicsSceneMouseEvent *event)
             {
                 if (event->button() == Qt::LeftButton) {
-                    emit clicked(mCategory);
+                    emit clicked(m_Category);
                 } else if (event->button() == Qt::RightButton) {
-                    emit rightClicked(mCategory);
+                    emit rightClicked(m_Category);
                 }
             }
             void Bar::hoverEnterEvent(QGraphicsSceneHoverEvent *event)
             {
                 emit hoverEntered(event->lastScreenPos());
             }
             void Bar::hoverLeaveEvent(QGraphicsSceneHoverEvent *event)
             {
                 Q_UNUSED(event)
                 emit hoverLeaved();
             }
             #include "moc_bar_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/bar_p.h +1 -1

             #ifndef BAR_H
             #define BAR_H
             #include "qchartglobal.h"
             #include <QGraphicsRectItem>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             // Single visual bar item of chart
             class Bar : public QObject, public QGraphicsRectItem
             {
                 Q_OBJECT
             public:
                 Bar(QString category, QGraphicsItem *parent = 0);
             public:
                 void mousePressEvent(QGraphicsSceneMouseEvent *event);
                 void hoverEnterEvent(QGraphicsSceneHoverEvent *event);
                 void hoverLeaveEvent(QGraphicsSceneHoverEvent *event);
             Q_SIGNALS:
                 void clicked(QString category);
                 void rightClicked(QString category);
                 void hoverEntered(QPoint pos);
                 void hoverLeaved();
             private:
-                QString mCategory;
+                QString m_Category;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // BAR_H

src/barchart/barchartitem.cpp +42 -42

             #include "barchartitem_p.h"
             #include "bar_p.h"
             #include "barvalue_p.h"
             #include "qbarset.h"
             #include "qbarseries.h"
             #include "qchart.h"
             #include "qchartaxis.h"
             #include "qchartaxiscategories.h"
             #include "chartpresenter_p.h"
             #include "chartanimator_p.h"
             #include "chartdataset_p.h"
             #include <QDebug>
             #include <QToolTip>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             BarChartItem::BarChartItem(QBarSeries *series, ChartPresenter *presenter) :
                 ChartItem(presenter),
-                mLayoutSet(false),
+                m_LayoutSet(false),
-                mSeries(series)
+                m_Series(series)
             {
                 connect(series, SIGNAL(showToolTip(QPoint,QString)), this, SLOT(showToolTip(QPoint,QString)));
                 connect(series, SIGNAL(updatedBars()), this, SLOT(handleLayoutChanged()));
             //TODO:  connect(series,SIGNAL("position or size has changed"), this, SLOT(handleLayoutChanged()));
                 connect(series, SIGNAL(restructuredBar(int)), this, SLOT(handleModelChanged(int)));
                 setZValue(ChartPresenter::BarSeriesZValue);
                 dataChanged();
             }
             BarChartItem::~BarChartItem()
             {
                 disconnect(this,SLOT(showToolTip(QPoint,QString)));
             }
             void BarChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
-                if (!mLayoutSet) {
+                if (!m_LayoutSet) {
-                    qDebug() << "BarChartItem::paint called without layout set. Aborting.";
+                    qWarning() << "BarChartItem::paint called without layout set. Aborting.";
                     return;
                 }
                 foreach(QGraphicsItem* i, childItems())
                     i->paint(painter,option,widget);
             }
             QRectF BarChartItem::boundingRect() const
             {
                 return m_rect;
             }
             void BarChartItem::dataChanged()
             {
                 // TODO: performance optimizations. Do we really need to delete and create items every time data is changed or can we reuse them?
                 // Delete old bars
                 foreach (QGraphicsItem *item, childItems())
                     delete item;
-                mBars.clear();
+                m_Bars.clear();
-                mFloatingValues.clear();
+                m_FloatingValues.clear();
-                mLayout.clear();
+                m_Layout.clear();
                 // Create new graphic items for bars
-                for (int c = 0; c < mSeries->categoryCount(); c++) {
+                for (int c = 0; c < m_Series->categoryCount(); c++) {
-                    QString category = mSeries->categoryName(c);
+                    QString category = m_Series->categoryName(c);
-                    for (int s = 0; s < mSeries->barsetCount(); s++) {
+                    for (int s = 0; s < m_Series->barsetCount(); s++) {
-                        QBarSet *set = mSeries->barsetAt(s);
+                        QBarSet *set = m_Series->barsetAt(s);
                         Bar *bar = new Bar(category,this);
                         childItems().append(bar);
-                        mBars.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()));
-                        mLayout.append(QRectF(0, 0, 0, 0));
+                        m_Layout.append(QRectF(0, 0, 0, 0));
                     }
                 }
                 // Create floating values
-                for (int category = 0; category < mSeries->categoryCount(); category++) {
+                for (int category = 0; category < m_Series->categoryCount(); category++) {
-                    for (int s = 0; s < mSeries->barsetCount(); s++) {
+                    for (int s = 0; s < m_Series->barsetCount(); s++) {
-                        QBarSet *set = mSeries->barsetAt(s);
+                        QBarSet *set = m_Series->barsetAt(s);
                         BarValue *value = new BarValue(*set, this);
                         childItems().append(value);
-                        mFloatingValues.append(value);
+                        m_FloatingValues.append(value);
                         connect(set, SIGNAL(toggleFloatingValues()), value, SLOT(toggleVisible()));
                     }
                 }
             }
             QVector<QRectF> BarChartItem::calculateLayout()
             {
                 QVector<QRectF> layout;
                 // Use temporary qreals for accurancy (we might get some compiler warnings... :)
-                qreal categoryCount = mSeries->categoryCount();
+                qreal categoryCount = m_Series->categoryCount();
-                qreal setCount = mSeries->barsetCount();
+                qreal setCount = m_Series->barsetCount();
                 qreal width = geometry().width();
                 qreal height = geometry().height();
-                qreal max = mSeries->max();
+                qreal max = m_Series->max();
                 // Domain:
-                if (mDomainMaxY > max) {
+                if (m_DomainMaxY > max) {
-                    max = mDomainMaxY;
+                    max = m_DomainMaxY;
                 }
                 qreal scale = (height / max);
                 qreal categoryWidth = width / categoryCount;
                 qreal barWidth = categoryWidth / (setCount+1);
                 int itemIndex(0);
                 for (int category = 0; category < categoryCount; category++) {
                     qreal xPos = categoryWidth * category + barWidth / 2;
                     qreal yPos = height;
                     for (int set = 0; set < setCount; set++) {
-                        qreal barHeight = mSeries->valueAt(set, category) * scale;
+                        qreal barHeight = m_Series->valueAt(set, category) * scale;
-                        Bar* bar = mBars.at(itemIndex);
+                        Bar* bar = m_Bars.at(itemIndex);
                         QRectF rect(xPos, yPos - barHeight, barWidth, barHeight);
                         layout.append(rect);
-                        bar->setPen(mSeries->barsetAt(set)->pen());
+                        bar->setPen(m_Series->barsetAt(set)->pen());
-                        bar->setBrush(mSeries->barsetAt(set)->brush());
+                        bar->setBrush(m_Series->barsetAt(set)->brush());
                         itemIndex++;
                         xPos += barWidth;
                     }
                 }
                 // Position floating values
                 itemIndex = 0;
-                for (int category = 0; category < mSeries->categoryCount(); category++) {
+                for (int category = 0; category < m_Series->categoryCount(); category++) {
                     qreal xPos = categoryWidth * category  + barWidth;
                     qreal yPos = height;
-                    for (int set=0; set < mSeries->barsetCount(); set++) {
+                    for (int set=0; set < m_Series->barsetCount(); set++) {
-                        qreal barHeight = mSeries->valueAt(set, category) * scale;
+                        qreal barHeight = m_Series->valueAt(set, category) * scale;
-                        BarValue* value = mFloatingValues.at(itemIndex);
+                        BarValue* value = m_FloatingValues.at(itemIndex);
-                        QBarSet* barSet = mSeries->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 (mSeries->valueAt(set,category) != 0) {
+                        if (m_Series->valueAt(set,category) != 0) {
-                            value->setValueString(QString::number(mSeries->valueAt(set, category)));
+                            value->setValueString(QString::number(m_Series->valueAt(set, category)));
                         } else {
                             value->setValueString(QString(""));
                         }
                         itemIndex++;
                         xPos += barWidth;
                     }
                 }
                 return layout;
             }
             void BarChartItem::applyLayout(const QVector<QRectF> &layout)
             {
                 if (animator())
-                    animator()->updateLayout(this, mLayout, layout);
+                    animator()->updateLayout(this, m_Layout, layout);
                 else
                     setLayout(layout);
             }
             void BarChartItem::setLayout(const QVector<QRectF> &layout)
             {
-                mLayout = layout;
+                m_Layout = layout;
-                for (int i=0; i < mBars.count(); i++)
+                for (int i=0; i < m_Bars.count(); i++)
-                    mBars.at(i)->setRect(layout.at(i));
+                    m_Bars.at(i)->setRect(layout.at(i));
                 update();
             }
             //handlers
             void BarChartItem::handleModelChanged(int index)
             {
                 Q_UNUSED(index)
                 dataChanged();
             }
             void BarChartItem::handleDomainChanged(qreal minX, qreal maxX, qreal minY, qreal maxY)
             {
-                mDomainMinX = minX;
+                m_DomainMinX = minX;
-                mDomainMaxX = maxX;
+                m_DomainMaxX = maxX;
-                mDomainMinY = minY;
+                m_DomainMinY = minY;
-                mDomainMaxY = maxY;
+                m_DomainMaxY = maxY;
                 handleLayoutChanged();
             }
             void BarChartItem::handleGeometryChanged(const QRectF &rect)
             {
                 m_rect = rect;
                 handleLayoutChanged();
-                mLayoutSet = true;
+                m_LayoutSet = true;
                 setPos(rect.topLeft());
             }
             void BarChartItem::handleLayoutChanged()
             {
                 QVector<QRectF> layout = calculateLayout();
                 applyLayout(layout);
                 update();
             }
             void BarChartItem::showToolTip(QPoint pos, QString tip)
             {
                 // TODO: cool tooltip instead of default
                 QToolTip::showText(pos, tip);
             }
             #include "moc_barchartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/barchartitem_p.h +9 -9

             #ifndef BARCHARTITEM_H
             #define BARCHARTITEM_H
             #include "chartitem_p.h"
             #include "qbarseries.h"
             #include <QPen>
             #include <QBrush>
             #include <QGraphicsItem>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class Bar;
             class BarValue;
             class QChartAxisCategories;
             class QChart;
             //typedef QVector<QRectF> BarLayout;
             class BarChartItem : public ChartItem
             {
                 Q_OBJECT
             public:
                 BarChartItem(QBarSeries *series, ChartPresenter *presenter);
                 virtual ~BarChartItem();
             // Common implemantation of different presenters. Not to be instantiated.
             // TODO: combine this with BarPresenter and derive other presenters from it?
             public:
                 // From QGraphicsItem
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
                 QRectF boundingRect() const;
                 // TODO: Consider the domain for layoutChanged. May be use case, may not be. If it is, then the derived classes need to implement it
                 virtual void dataChanged();     // data of series has changed -> need to recalculate bar sizes
             private slots:
             public:
                 virtual QVector<QRectF> calculateLayout();
                 void applyLayout(const QVector<QRectF> &layout);
                 void setLayout(const QVector<QRectF> &layout);
                 void updateLayout(const QVector<QRectF> &layout);
                 QRectF geometry() const { return m_rect;}
             public slots:
                 void handleModelChanged(int index);
                 void handleDomainChanged(qreal minX, qreal maxX, qreal minY, qreal maxY);
                 void handleGeometryChanged(const QRectF &size);
                 void handleLayoutChanged();
                 // Internal slots
                 void showToolTip(QPoint pos, QString tip);      // shows tooltip (if enabled)
             protected:
                 // TODO: consider these.
-                qreal mDomainMinX;
+                qreal m_DomainMinX;
-                qreal mDomainMaxX;
+                qreal m_DomainMaxX;
-                qreal mDomainMinY;
+                qreal m_DomainMinY;
-                qreal mDomainMaxY;
+                qreal m_DomainMaxY;
                 QRectF m_rect;
-                bool mLayoutSet;    // True, if component has been laid out.
+                bool m_LayoutSet;    // True, if component has been laid out.
-                QVector<QRectF> mLayout;
+                QVector<QRectF> m_Layout;
                 // Not owned.
-                QBarSeries *mSeries;
+                QBarSeries *m_Series;
-                QList<Bar *> mBars;
+                QList<Bar *> m_Bars;
-                QList<BarValue *> mFloatingValues;
+                QList<BarValue *> m_FloatingValues;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // BARCHARTITEM_H

src/barchart/barchartmodel.cpp +31 -32

             #include <limits.h>
             #include <QVector>
             #include <QDebug>
             #include "barchartmodel_p.h"
             #include "qbarset.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            BarChartModel::BarChartModel(QStringList categories, QObject *parent) :
+            BarChartModel::BarChartModel(QStringList categories, QObject *parent) : QObject(parent),
-                QObject(parent)
+                m_Category(categories)
-                ,mCategory(categories)
             {
             }
             QStringList BarChartModel::category()
             {
-                return mCategory;
+                return m_Category;
             }
             void BarChartModel::addBarSet(QBarSet *set)
             {
-                mDataModel.append(set);
+                m_DataModel.append(set);
             }
             void BarChartModel::removeBarSet(QBarSet *set)
             {
-                if (mDataModel.contains(set)) {
+                if (m_DataModel.contains(set)) {
-                    mDataModel.removeOne(set);
+                    m_DataModel.removeOne(set);
                 }
             }
             void BarChartModel::insertBarSet(int i, QBarSet *set)
             {
-                mDataModel.insert(i, set);
+                m_DataModel.insert(i, set);
             }
             void BarChartModel::insertCategory(int i, QString category)
             {
-                mCategory.insert(i, category);
+                m_Category.insert(i, category);
             }
             void BarChartModel::removeCategory(int i)
             {
-                mCategory.removeAt(i);
+                m_Category.removeAt(i);
             }
             QBarSet* BarChartModel::setAt(int index)
             {
-                return mDataModel.at(index);
+                return m_DataModel.at(index);
             }
             QList<QBarSet*> BarChartModel::barSets()
             {
-                return mDataModel;
+                return m_DataModel;
             }
             int BarChartModel::barsetCount()
             {
-                return mDataModel.count();
+                return m_DataModel.count();
             }
             int BarChartModel::categoryCount()
             {
-                return mCategory.count();
+                return m_Category.count();
             }
             qreal BarChartModel::min()
             {
-                Q_ASSERT(mDataModel.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 < mDataModel.count(); i++) {
+                for (int i = 0; i < m_DataModel.count(); i++) {
-                    int itemCount = mDataModel.at(i)->count();
+                    int itemCount = m_DataModel.at(i)->count();
                     for (int j = 0; j < itemCount; j++) {
-                        qreal temp = mDataModel.at(i)->valueAt(j);
+                        qreal temp = m_DataModel.at(i)->valueAt(j);
                         if (temp < min)
                             min = temp;
                     }
                 }
                 return min;
             }
             qreal BarChartModel::max()
             {
-                Q_ASSERT(mDataModel.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 < mDataModel.count(); i++) {
+                for (int i = 0; i < m_DataModel.count(); i++) {
-                    int itemCount = mDataModel.at(i)->count();
+                    int itemCount = m_DataModel.at(i)->count();
                     for (int j = 0; j < itemCount; j++) {
-                        qreal temp = mDataModel.at(i)->valueAt(j);
+                        qreal temp = m_DataModel.at(i)->valueAt(j);
                         if (temp > max)
                             max = temp;
                     }
                 }
                 return max;
             }
             qreal BarChartModel::valueAt(int set, int category)
             {
-                if ((set < 0) || (set >= mDataModel.count())) {
+                if ((set < 0) || (set >= m_DataModel.count())) {
                     // No set, no value.
                     return 0;
-                } else if ((category < 0) || (category >= mDataModel.at(set)->count())) {
+                } else if ((category < 0) || (category >= m_DataModel.at(set)->count())) {
                     // No category, no value.
                     return 0;
                 }
-                return mDataModel.at(set)->valueAt(category);
+                return m_DataModel.at(set)->valueAt(category);
             }
             qreal BarChartModel::percentageAt(int set, int category)
             {
-                if ((set < 0) || (set >= mDataModel.count())) {
+                if ((set < 0) || (set >= m_DataModel.count())) {
                     // No set, no value.
                     return 0;
-                } else if ((category < 0) || (category >= mDataModel.at(set)->count())) {
+                } else if ((category < 0) || (category >= m_DataModel.at(set)->count())) {
                     // No category, no value.
                     return 0;
                 }
-                qreal value = mDataModel.at(set)->valueAt(category);
+                qreal value = m_DataModel.at(set)->valueAt(category);
                 qreal total = categorySum(category);
                 if (0 == total)
                     return 100.0;
                 return value / total;
             }
             qreal BarChartModel::categorySum(int category)
             {
                 qreal sum(0);
-                int count = mDataModel.count(); // Count sets
+                int count = m_DataModel.count(); // Count sets
                 for (int set = 0; set < count; set++) {
-                    if (category < mDataModel.at(set)->count())
+                    if (category < m_DataModel.at(set)->count())
-                        sum += mDataModel.at(set)->valueAt(category);
+                        sum += m_DataModel.at(set)->valueAt(category);
                 }
                 return sum;
             }
             qreal BarChartModel::maxCategorySum()
             {
                 qreal max = INT_MIN;
                 int count = categoryCount();
                 for (int col = 0; col < count; col++) {
                     qreal sum = categorySum(col);
                     if (sum > max)
                         max = sum;
                 }
                 return max;
             }
             QString BarChartModel::categoryName(int category)
             {
-                return mCategory.at(category);
+                return m_Category.at(category);
             }
             #include "moc_barchartmodel_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/barchartmodel_p.h +2 -3

             #ifndef BARCHARTMODEL_H
             #define BARCHARTMODEL_H
             #include <QObject>
             #include <QStringList>
             #include "qchartglobal.h"
             #include <qseries.h>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             // Model for bar chart. Internal class.
             // TODO: Implement as QAbstractItemModel?
             class QBarSet;
             class BarChartModel : public QObject //, public QAbstractItemModel
             {
                 Q_OBJECT
             public:
                 explicit BarChartModel(QStringList categories, QObject *parent = 0);
                 QStringList category();
                 void addBarSet(QBarSet *set);
                 void removeBarSet(QBarSet *set);
                 void insertBarSet(int i, QBarSet *set);
                 void insertCategory(int i, QString category);
                 void removeCategory(int i);
                 QBarSet *setAt(int index);
                 QList<QBarSet *> barSets();
                 int barsetCount();          // Number of sets in model
                 int categoryCount();        // Number of categories
                 qreal max();                // Maximum value of all sets
                 qreal min();                // Minimum value of all sets
                 qreal valueAt(int set, int category);
                 qreal percentageAt(int set, int category);
                 qreal categorySum(int category);
                 qreal maxCategorySum();     // returns maximum sum of sets in all categories.
                 QString categoryName(int category);
             signals:
                 void modelUpdated();
             public slots:
             private:
-                QList<QBarSet *> mDataModel;
+                QList<QBarSet *> m_DataModel;
-                QStringList mCategory;
+                QStringList m_Category;
-                int mCurrentSet;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // BARCHARTMODEL_H

src/barchart/barvalue.cpp +16 -16

             #include "barvalue_p.h"
             #include <QPainter>
             #include <QPen>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             BarValue::BarValue(QBarSet &set, QGraphicsItem *parent)
                 : QGraphicsObject(parent),
-                mBarSet(set),
+                m_BarSet(set),
-                mXpos(0),
+                m_Xpos(0),
-                mYpos(0),
+                m_Ypos(0),
-                mWidth(0),
+                m_Width(0),
-                mHeight(0)
+                m_Height(0)
             {
                 setVisible(false);
             }
             void BarValue::setValueString(QString str)
             {
-                mValueString = str;
+                m_ValueString = str;
             }
             QString BarValue::valueString()
             {
-                return mValueString;
+                return m_ValueString;
             }
             void BarValue::setPen(const QPen pen)
             {
-                mPen = pen;
+                m_Pen = pen;
             }
             QPen BarValue::pen() const
             {
-                return mPen;
+                return m_Pen;
             }
             void BarValue::resize(qreal w, qreal h)
             {
-                mWidth = w;
+                m_Width = w;
-                mHeight = h;
+                m_Height = h;
             }
             void BarValue::setPos(qreal x, qreal y)
             {
-                mXpos = x;
+                m_Xpos = x;
-                mYpos = y;
+                m_Ypos = y;
             }
             void BarValue::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(option)
                 Q_UNUSED(widget)
                 if (isVisible()) {
-                    painter->setPen(mPen);
+                    painter->setPen(m_Pen);
-                    painter->drawText(boundingRect(), mValueString);
+                    painter->drawText(boundingRect(), m_ValueString);
                 }
             }
             QRectF BarValue::boundingRect() const
             {
-                QRectF r(mXpos, mYpos, mWidth, mHeight);
+                QRectF r(m_Xpos, m_Ypos, m_Width, m_Height);
                 return r;
             }
             void BarValue::toggleVisible()
             {
                 setVisible(!isVisible());
             }
             #include "moc_barvalue_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/barvalue_p.h +8 -8

             #ifndef BARVALUE_P_H
             #define BARVALUE_P_H
             #include "qchartglobal.h"
             #include <QGraphicsObject>
             #include <QPen>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QBarSet;
             // Visual class for floating bar values
             // By default these are not visible.
             class BarValue : public QGraphicsObject
             {
                 Q_OBJECT
             public:
                 BarValue(QBarSet &set, QGraphicsItem *parent = 0);
                 void setValueString(QString str);
                 QString valueString();
                 void setPen(const QPen pen);
                 QPen pen() const;
                 void resize(qreal w, qreal h);
                 void setPos(qreal x, qreal y);
                 // From QGraphicsItem
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
                 QRectF boundingRect() const;
             public Q_SLOTS:
                 void toggleVisible();
             private:
-                QBarSet &mBarSet;
+                QBarSet &m_BarSet;
-                QPen mPen;
+                QPen m_Pen;
-                QString mValueString;
+                QString m_ValueString;
-                qreal mXpos;
+                qreal m_Xpos;
-                qreal mYpos;
+                qreal m_Ypos;
-                qreal mWidth;
+                qreal m_Width;
-                qreal mHeight;
+                qreal m_Height;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // BARVALUE_P_H

src/barchart/percentbarchartitem.cpp +16 -16

             #include "percentbarchartitem_p.h"
             #include "bar_p.h"
             #include "barvalue_p.h"
             #include "qbarset.h"
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             PercentBarChartItem::PercentBarChartItem(QBarSeries *series, ChartPresenter *presenter) :
                 BarChartItem(series, presenter)
             {
             }
             QVector<QRectF> PercentBarChartItem::calculateLayout()
             {
                 QVector<QRectF> layout;
                 // Use temporary qreals for accurancy (we might get some compiler warnings... :)
                 qreal width = geometry().width();
                 qreal height = geometry().height();
-                qreal categoryCount = mSeries->categoryCount();
+                qreal categoryCount = m_Series->categoryCount();
-                qreal barWidth = width / (mSeries->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 = mSeries->categorySum(category);
+                    qreal colSum = m_Series->categorySum(category);
                     qreal scale = (height / colSum);
                     qreal yPos = height;
-                    for (int set=0; set < mSeries->barsetCount(); set++) {
+                    for (int set=0; set < m_Series->barsetCount(); set++) {
-                        qreal barHeight = mSeries->valueAt(set, category) * scale;
+                        qreal barHeight = m_Series->valueAt(set, category) * scale;
-                        Bar* bar = mBars.at(itemIndex);
+                        Bar* bar = m_Bars.at(itemIndex);
-                        bar->setPen(mSeries->barsetAt(set)->pen());
+                        bar->setPen(m_Series->barsetAt(set)->pen());
-                        bar->setBrush(mSeries->barsetAt(set)->brush());
+                        bar->setBrush(m_Series->barsetAt(set)->brush());
                         QRectF rect(xPos, yPos-barHeight, barWidth, barHeight);
                         layout.append(rect);
                         itemIndex++;
                         yPos -= barHeight;
                     }
                     xPos += xStep;
                 }
                 // Position floating values
                 itemIndex = 0;
                 xPos = (width/categoryCount);
-                for (int category=0; category < mSeries->categoryCount(); category++) {
+                for (int category=0; category < m_Series->categoryCount(); category++) {
                     qreal yPos = height;
-                    qreal colSum = mSeries->categorySum(category);
+                    qreal colSum = m_Series->categorySum(category);
                     qreal scale = (height / colSum);
-                    for (int set=0; set < mSeries->barsetCount(); set++) {
+                    for (int set=0; set < m_Series->barsetCount(); set++) {
-                        qreal barHeight = mSeries->valueAt(set,category) * scale;
+                        qreal barHeight = m_Series->valueAt(set,category) * scale;
-                        BarValue* value = mFloatingValues.at(itemIndex);
+                        BarValue* value = m_FloatingValues.at(itemIndex);
-                        QBarSet* barSet = mSeries->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 (mSeries->valueAt(set,category) != 0) {
+                        if (m_Series->valueAt(set,category) != 0) {
-                            int p = mSeries->percentageAt(set,category) * 100;
+                            int p = m_Series->percentageAt(set,category) * 100;
                             QString vString(QString::number(p));
                             vString.truncate(3);
                             vString.append("%");
                             value->setValueString(vString);
                         } else {
                             value->setValueString(QString(""));
                         }
                         itemIndex++;
                         yPos -= barHeight;
                     }
                     xPos += xStep;
                 }
                 return layout;
             }
             #include "moc_percentbarchartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/qbarseries.cpp +28 -29

             #include <QDebug>
             #include "qbarseries.h"
             #include "qbarset.h"
             #include "barchartmodel_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QBarSeries
                 \brief part of QtCommercial chart API.
                 QBarSeries represents a series of data shown as bars. One QBarSeries can contain multible
                 QBarSet data sets. QBarSeries groups the data from sets to categories, which are defined
                 by QStringList.
                 \mainclass
                 \sa QBarSet, QStackedBarSeries, QPercentBarSeries
             */
             /*!
                 \fn virtual QSeriesType QBarSeries::type() const
                 \brief Returns type of series.
                 \sa QSeries, QSeriesType
             */
             /*!
                 \fn void QBarSeries::showToolTip(QPoint pos, QString tip)
                 \brief \internal \a pos \a tip
             */
             /*!
                 Constructs empty QBarSeries. Parameter \a categories defines the categories for chart.
                 QBarSeries is QObject which is a child of a \a parent.
             */
-            QBarSeries::QBarSeries(QBarCategories categories, QObject *parent)
+            QBarSeries::QBarSeries(QBarCategories categories, QObject *parent) : QSeries(parent),
-                : QSeries(parent)
+                m_Model(new BarChartModel(categories, this))
-                ,mModel(new BarChartModel(categories, this))
             {
                 m_model = NULL;
                 m_mapCategories = -1;
                 m_mapBarBottom = -1;
                 m_mapBarTop = -1;
                 m_mapFirst = 0;
                 m_mapCount = 0;
                 m_mapOrientation = Qt::Vertical;
             }
             /*!
                 Adds a set of bars to series. Takes ownership of \a set.
                 Connects the clicked(QString) and rightClicked(QString) signals
                 of \a set to this series
             */
             void QBarSeries::addBarSet(QBarSet *set)
             {
-                mModel->addBarSet(set);
+                m_Model->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()));
                 emit updatedBars();
             }
             /*!
                 Removes a set of bars from series. Releases ownership of \a set. Doesnt delete \a set.
                 Disconnects the clicked(QString) and rightClicked(QString) signals
                 of \a set from this series
             */
             void QBarSeries::removeBarSet(QBarSet *set)
             {
                 disconnect(set, SIGNAL(clicked(QString)), this, SLOT(barsetClicked(QString)));
                 disconnect(set, SIGNAL(rightClicked(QString)), this, SLOT(barsetRightClicked(QString)));
-                mModel->removeBarSet(set);
+                m_Model->removeBarSet(set);
                 emit updatedBars();
             }
             void QBarSeries::insertBarSet(int i, QBarSet *set)
             {
-                mModel->insertBarSet(i, set);
+                m_Model->insertBarSet(i, set);
                 //    emit barsetChanged();
             }
             void QBarSeries::insertCategory(int i, QString category)
             {
-                mModel->insertCategory(i, category);
+                m_Model->insertCategory(i, category);
             }
             void QBarSeries::removeCategory(int i)
             {
-                mModel->removeCategory(i);
+                m_Model->removeCategory(i);
             }
             /*!
                 Returns number of sets in series.
             */
             int QBarSeries::barsetCount()
             {
                 //    if(m_model)
                 //        return m_mapBarTop - m_mapBarBottom;
                 //    else
-                return mModel->barsetCount();
+                return m_Model->barsetCount();
             }
             /*!
                 Returns number of categories in series
             */
             int QBarSeries::categoryCount()
             {
-                return mModel->categoryCount();
+                return m_Model->categoryCount();
             }
             /*!
                 Returns a list of sets in series. Keeps ownership of sets.
              */
             QList<QBarSet*> QBarSeries::barSets()
             {
-                return mModel->barSets();
+                return m_Model->barSets();
             }
             /*!
                 \internal \a index
             */
             QBarSet* QBarSeries::barsetAt(int index)
             {
-                return mModel->setAt(index);
+                return m_Model->setAt(index);
             }
             /*!
                 \internal \a category
             */
             QString QBarSeries::categoryName(int category)
             {
-                return mModel->categoryName(category);
+                return m_Model->categoryName(category);
             }
             /*!
                 Enables or disables tooltip depending on parameter \a enabled.
                 Tooltip shows the name of set, when mouse is hovering on top of bar.
                 Calling without parameter \a enabled, enables the tooltip
             */
             void QBarSeries::setToolTipEnabled(bool enabled)
             {
                 // 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<mModel->barsetCount(); i++) {
+                    for (int i=0; i<m_Model->barsetCount(); i++) {
-                        QBarSet *set = mModel->setAt(i);
+                        QBarSet *set = m_Model->setAt(i);
                         connect(set, SIGNAL(showToolTip(QPoint,QString)), this, SIGNAL(showToolTip(QPoint,QString)));
                     }
                 } else {
-                    for (int i=0; i<mModel->barsetCount(); i++) {
+                    for (int i=0; i<m_Model->barsetCount(); i++) {
-                        QBarSet *set = mModel->setAt(i);
+                        QBarSet *set = m_Model->setAt(i);
                         disconnect(set, SIGNAL(showToolTip(QPoint,QString)), this, SIGNAL(showToolTip(QPoint,QString)));
                     }
                 }
             }
             /*!
                 \internal \a category
             */
             void QBarSeries::barsetClicked(QString category)
             {
                 emit clicked(qobject_cast<QBarSet*>(sender()), category);
             }
             /*!
                 \internal \a category
             */
             void QBarSeries::barsetRightClicked(QString category)
             {
                 emit rightClicked(qobject_cast<QBarSet*>(sender()), category);
             }
             /*!
                 \internal
             */
             qreal QBarSeries::min()
             {
-                return mModel->min();
+                return m_Model->min();
             }
             /*!
                 \internal
             */
             qreal QBarSeries::max()
             {
-                return mModel->max();
+                return m_Model->max();
             }
             /*!
                 \internal \a set \a category
             */
             qreal QBarSeries::valueAt(int set, int category)
             {
-                return mModel->valueAt(set, category);
+                return m_Model->valueAt(set, category);
             }
             /*!
                 \internal \a set \a category
             */
             qreal QBarSeries::percentageAt(int set, int category)
             {
-                return mModel->percentageAt(set, category);
+                return m_Model->percentageAt(set, category);
             }
             /*!
                 \internal \a category
             */
             qreal QBarSeries::categorySum(int category)
             {
-                return mModel->categorySum(category);
+                return m_Model->categorySum(category);
             }
             /*!
                 \internal
             */
             qreal QBarSeries::maxCategorySum()
             {
-                return mModel->maxCategorySum();
+                return m_Model->maxCategorySum();
             }
             /*!
                 \internal
             */
             BarChartModel& QBarSeries::model()
             {
-                return *mModel;
+                return *m_Model;
             }
             bool QBarSeries::setModel(QAbstractItemModel *model)
             {
                 // disconnect signals from old model
                 if(m_model)
                 {
                     disconnect(m_model, 0, this, 0);
                     m_mapCategories = -1;
                     m_mapBarBottom = -1;
                     m_mapBarTop = -1;
                     m_mapFirst = 0;
                     m_mapCount = 0;
                     m_mapOrientation = Qt::Vertical;
                 }
                 // set new model
                 if(model)
                 {
                     m_model = model;
                     return true;
                 }
                 else
                 {
                     m_model = NULL;
                     return false;
                 }
             }
             // TODO
             void QBarSeries::setModelMapping(int categories, int bottomBoundry, int topBoundry, Qt::Orientation orientation)
             {
                 if (m_model == NULL)
                     return;
                 m_mapCategories = categories;
                 m_mapBarBottom = bottomBoundry;
                 m_mapBarTop = topBoundry;
             //    m_mapFirst = 1;
                 m_mapOrientation = orientation;
                 // connect the signals
                 if (m_mapOrientation == Qt::Vertical) {
                     m_mapCount = m_model->rowCount() - m_mapFirst;
                     connect(m_model,SIGNAL(dataChanged(QModelIndex,QModelIndex)),
                             this, SLOT(modelUpdated(QModelIndex, QModelIndex)));
                     connect(m_model,SIGNAL(rowsInserted(QModelIndex, int, int)),
                             this, SLOT(modelDataAdded(QModelIndex,int,int)));
                     connect(m_model, SIGNAL(rowsRemoved(QModelIndex, int, int)),
                             this, SLOT(modelDataRemoved(QModelIndex,int,int)));
                 } else {
                     m_mapCount = m_model->columnCount() - m_mapFirst;
                     connect(m_model,SIGNAL(dataChanged(QModelIndex,QModelIndex)),
                             this, SLOT(modelUpdated(QModelIndex, QModelIndex)));
                     connect(m_model,SIGNAL(columnsInserted(QModelIndex, int, int)),
                             this, SLOT(modelDataAdded(QModelIndex,int,int)));
                     connect(m_model, SIGNAL(columnsRemoved(QModelIndex, int, int)),
                             this, SLOT(modelDataRemoved(QModelIndex,int,int)));
                 }
                 // create the initial bars
-                delete mModel;
+                delete m_Model;
                 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();
-                    mModel = new BarChartModel(categories, this);
+                    m_Model = new BarChartModel(categories, this);
                     for (int i = m_mapBarBottom; i <= m_mapBarTop; i++) {
                         QBarSet* barSet = new QBarSet(QString("Column: %1").arg(i + 1));
                         for(int m = m_mapFirst; m < m_mapFirst + m_mapCount; m++)
                             *barSet << m_model->data(m_model->index(m, i), Qt::DisplayRole).toDouble();
                         addBarSet(barSet);
                     }
                 } else {
                     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();
-                    mModel = new BarChartModel(categories, this);
+                    m_Model = new BarChartModel(categories, this);
                     for (int i = m_mapBarBottom; i <= m_mapBarTop; i++) {
                         QBarSet* barSet = new QBarSet(QString("Row: %1").arg(i + 1));
                         for(int m = m_mapFirst; m < m_mapFirst + m_mapCount; m++)
                             *barSet << m_model->data(m_model->index(i, m), Qt::DisplayRole).toDouble();
                         addBarSet(barSet);
                     }
                 }
             }
             void QBarSeries::setModelMappingShift(int first, int count)
             {
                 m_mapFirst = first;
                 m_mapCount = count;
             }
             void QBarSeries::modelUpdated(QModelIndex topLeft, QModelIndex bottomRight)
             {
                 Q_UNUSED(bottomRight)
                 if (m_mapOrientation == Qt::Vertical)
                 {
                     // model update is relevant to BarSeries if the change was made to the part of the model that was mapped to BarSeries
                     if (topLeft.column() >= m_mapBarBottom && topLeft.column() <= m_mapBarTop && topLeft.row() >= m_mapFirst && topLeft.row() < m_mapFirst + m_mapCount)
                         barsetAt(topLeft.column() - m_mapBarBottom)->setValue(topLeft.row() - m_mapFirst, m_model->data(topLeft, Qt::DisplayRole).toDouble());
                 }
                 else
                 {
                     // model update is relevant to BarSeries if the change was made to the part of the model that was mapped to BarSeries
                     if (topLeft.row() >= m_mapBarBottom && topLeft.row() <= m_mapBarTop && topLeft.column() >= m_mapFirst && topLeft.column() < m_mapFirst + m_mapCount)
                         barsetAt(topLeft.row() - m_mapBarBottom)->setValue(topLeft.column() - m_mapFirst, m_model->data(topLeft, Qt::DisplayRole).toDouble());
                 }
             }
             void QBarSeries::modelDataAdded(QModelIndex /*parent*/, int start, int /*end*/)
             {
                 if (m_mapOrientation == Qt::Vertical) {
                     insertCategory(start - m_mapFirst, QString("Row: %1").arg(start + 1));
                     for (int i = 0; i <= m_mapBarTop - m_mapBarBottom; i++) {
                         barsetAt(i)->insertValue(start - m_mapFirst, m_model->data(m_model->index(start, i), Qt::DisplayRole).toDouble());
                     }
                 } else {
                     insertCategory(start - m_mapFirst, QString("Column: %1").arg(start + 1));
                     for (int i = 0; i <= m_mapBarTop - m_mapBarBottom; i++) {
                         barsetAt(i)->insertValue(start - m_mapFirst, m_model->data(m_model->index(i, start), Qt::DisplayRole).toDouble());
                     }
                 }
                 emit restructuredBar(1);
             }
             void QBarSeries::modelDataRemoved(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent)
                 Q_UNUSED(end)
                 removeCategory(start - m_mapFirst);
                 for (int i = 0; i <= m_mapBarTop - m_mapBarBottom; i++)
                 {
                     barsetAt(i)->removeValue(start - m_mapFirst);
                 }
                 emit restructuredBar(1);
             }
             void QBarSeries::barsetChanged()
             {
                 emit updatedBars();
             }
             QBarCategories QBarSeries::categories() const
             {
                 QBarCategories categories;
-                int count = mModel->categoryCount();
+                int count = m_Model->categoryCount();
                 for (int i=1; i <= count; i++) {
-                      categories.insert(i, mModel->categoryName(i - 1));
+                      categories.insert(i, m_Model->categoryName(i - 1));
                 }
                 return categories;
             }
             #include "moc_qbarseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/qbarseries.h +1 -1

             #ifndef BARSERIES_H
             #define BARSERIES_H
             #include <qseries.h>
             #include <QStringList>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             typedef QStringList QBarCategories;
             class QBarSet;
             class BarChartModel;
             class BarCategory;
             // Container for series
             class QTCOMMERCIALCHART_EXPORT QBarSeries : public QSeries
             {
                 Q_OBJECT
             public:
                 QBarSeries(QStringList categories, QObject *parent = 0);
                 virtual QSeriesType type() const { return QSeries::SeriesTypeBar; }
                 void addBarSet(QBarSet *set);               // Takes ownership of set
                 void removeBarSet(QBarSet *set);            // Releases ownership, doesn't delete set
                 void insertBarSet(int i, QBarSet *set);
                 void insertCategory(int i, QString category);
                 void removeCategory(int i);
                 int barsetCount();
                 int categoryCount();
                 QList<QBarSet*> barSets();
                 QBarCategories categories() const;
                 bool setModel(QAbstractItemModel *model);
                 QAbstractItemModel *modelExt() { return m_model; }
                 void setModelMapping(int categories, int bottomBoundry, int topBoundry, Qt::Orientation orientation = Qt::Vertical);
                 void setModelMappingShift(int first, int count);
             public:
                 // TODO: Functions below this are not part of api and will be moved
                 // to private implementation, when we start using it
                 // TODO: TO PIMPL --->
                 QBarSet* barsetAt(int index);
                 QString categoryName(int category);
                 qreal min();
                 qreal max();
                 qreal valueAt(int set, int category);
                 qreal percentageAt(int set, int category);
                 qreal categorySum(int category);
                 qreal maxCategorySum();
                 BarChartModel& model();
                 // <--- TO PIMPL
             signals:
                 //void changed(int index);
                 void clicked(QBarSet *barset, QString category);        // Up to user of api, what to do with these signals
                 void rightClicked(QBarSet *barset, QString category);
                 //
                 void updatedBars();
                 void restructuredBar(int);
                 // TODO: internal signals, these to private implementation.
                 // TODO: TO PIMPL --->
                 void showToolTip(QPoint pos, QString tip);
                 // <--- TO PIMPL
             public Q_SLOTS:
                 void setToolTipEnabled(bool enabled = true);           // enables tooltips
                 // TODO: TO PIMPL --->
                 void barsetClicked(QString category);
                 void barsetRightClicked(QString category);
                 // <--- TO PIMPL
             private Q_SLOTS:
                 // slots for updating bars when data in model changes
                 void modelUpdated(QModelIndex topLeft, QModelIndex bottomRight);
                 void modelDataAdded(QModelIndex parent, int start, int end);
                 void modelDataRemoved(QModelIndex parent, int start, int end);
                 void barsetChanged();
             protected:
-                BarChartModel *mModel;
+                BarChartModel *m_Model;
             //    QAbstractItemModel* m_model;
                 int m_mapCategories;
                 int m_mapBarBottom;
                 int m_mapBarTop;
                 int m_mapFirst;
                 int m_mapCount;
                 Qt::Orientation m_mapOrientation;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // BARSERIES_H

src/barchart/qbarset.cpp +18 -18

             #include "qbarset.h"
             #include <QDebug>
             #include <QToolTip>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QBarSet
                 \brief part of QtCommercial chart API.
                 QBarSet represents one set of bars. Set of bars contains one data value for each category.
                 First value of set is assumed to belong to first category, second to second category and so on.
                 If set has fewer values than there are categories, then the missing values are assumed to be
                 at the end of set. For missing values in middle of a set, numerical value of zero is used.
                 \mainclass
                 \sa QBarSeries, QStackedBarSeries, QPercentBarSeries
             */
             /*!
                 \fn void QBarSet::clicked(QString category)
                 \brief signals that set has been clicked
                 Parameter \a category describes on which category was clicked
             */
             /*!
                 \fn void QBarSet::rightClicked(QString category)
                 \brief signals that set has been clicked with right mouse button
                 Parameter \a category describes on which category was clicked
             */
             /*!
                 \fn void QBarSet::hoverEnter(QPoint pos)
                 \brief signals that mouse has entered over the set at position \a pos.
             */
             /*!
                 \fn void QBarSet::hoverLeave()
                 \brief signals that mouse has left from the set.
             */
             /*!
                 \fn void QBarSet::toggleFloatingValues()
                 \brief \internal
             */
             /*!
                 \fn void QBarSet::showToolTip(QPoint pos, QString tip)
                 \brief \internal \a pos \a tip
             */
             /*!
                 Constructs QBarSet with a name of \a name and with parent of \a parent
             */
             QBarSet::QBarSet(QString name, QObject *parent)
                 : QObject(parent)
-                ,mName(name)
+                ,m_Name(name)
             {
             }
             /*!
                 Sets new \a name for set.
             */
             void QBarSet::setName(QString name)
             {
-                mName = name;
+                m_Name = name;
             }
             /*!
                 Returns name of the set.
             */
             QString QBarSet::name()
             {
-                return mName;
+                return m_Name;
             }
             /*!
                 Appends new value \a value to the end of set.
             */
             QBarSet& QBarSet::operator << (const qreal &value)
             {
-                mValues.append(value);
+                m_Values.append(value);
                 emit structureChanged();
                 return *this;
             }
             void QBarSet::insertValue(int i, qreal value)
             {
-                mValues.insert(i, value);
+                m_Values.insert(i, value);
             }
             void QBarSet::removeValue(int i)
             {
-                mValues.removeAt(i);
+                m_Values.removeAt(i);
             }
             /*!
                 Returns count of values in set.
             */
             int QBarSet::count()
             {
-                return mValues.count();
+                return m_Values.count();
             }
             /*!
                 Returns value of set indexed by \a index
             */
             qreal QBarSet::valueAt(int index)
             {
-                return mValues.at(index);
+                return m_Values.at(index);
             }
             /*!
                 Sets a new value \a value to set, indexed by \a index
             */
             void QBarSet::setValue(int index, qreal value)
             {
-                mValues.replace(index,value);
+                m_Values.replace(index,value);
                 emit valueChanged();
             }
             /*!
                 Returns total sum of all values in barset.
             */
             qreal QBarSet::total()
             {
                 qreal total(0);
-                for (int i=0; i < mValues.count(); i++) {
+                for (int i=0; i < m_Values.count(); i++) {
-                    total += mValues.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)
             {
-                mPen = pen;
+                m_Pen = pen;
                 emit valueChanged();
             }
             /*!
                 Returns pen of the set.
             */
             QPen QBarSet::pen() const
             {
-                return mPen;
+                return m_Pen;
             }
             /*!
                 Sets brush for the set. Bars of this set are drawn using \a brush
             */
             void QBarSet::setBrush(const QBrush brush)
             {
-                mBrush = brush;
+                m_Brush = brush;
                 emit valueChanged();
             }
             /*!
                 Returns brush of the set.
             */
             QBrush QBarSet::brush() const
             {
-                return mBrush;
+                return m_Brush;
             }
             /*!
                 Sets the pen for floating values that are drawn on top of this set
             */
             void QBarSet::setFloatingValuePen(const QPen pen)
             {
-                mFloatingValuePen = pen;
+                m_FloatingValuePen = pen;
             }
             /*!
                 Returns the pen for floating values that are drawn on top of this set
             */
             QPen QBarSet::floatingValuePen() const
             {
-                return mFloatingValuePen;
+                return m_FloatingValuePen;
             }
             /*!
                 \internal \a pos
             */
             void QBarSet::barHoverEnterEvent(QPoint pos)
             {
-                emit showToolTip(pos, mName);
+                emit showToolTip(pos, m_Name);
                 emit hoverEnter(pos);
             }
             /*!
                 \internal
             */
             void QBarSet::barHoverLeaveEvent()
             {
                 // Emit signal to user of charts
                 emit hoverLeave();
             }
             #include "moc_qbarset.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/qbarset.h +6 -6

             #ifndef QBARSET_H
             #define QBARSET_H
             #include <qchartglobal.h>
             #include <QPen>
             #include <QBrush>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QTCOMMERCIALCHART_EXPORT QBarSet : public QObject
             {
                 Q_OBJECT
             public:
                 QBarSet(QString name, QObject *parent = 0);
                 void setName(QString name);
                 QString name();
                 QBarSet& operator << (const qreal &value);  // appends new value to set
                 void insertValue(int i, qreal value);
                 void removeValue(int i);
                 // TODO: remove indices eventually. Use as internal?
                 int count();                                // count of values in set
                 qreal valueAt(int index);                   // for modifying individual values
                 void setValue(int index, qreal value);      // setter for individual value
                 qreal total();                              // total values in the set
                 // TODO:
                 //qreal value(QString category);
                 //void setValue(QString category, qreal value);
                 void setPen(const QPen pen);
                 QPen pen() const;
                 void setBrush(const QBrush brush);
                 QBrush brush() const;
                 void setFloatingValuePen(const QPen pen);
                 QPen floatingValuePen() const;
             Q_SIGNALS:
                 void clicked(QString category);                         // Clicked and hover signals exposed to user
                 void rightClicked(QString category);
                 void toggleFloatingValues();
                 // TODO: Expose this to user or not?
                 // TODO: TO PIMPL --->
                 void structureChanged();
                 void valueChanged();
                 void hoverEnter(QPoint pos);
                 void hoverLeave();
                 void showToolTip(QPoint pos, QString tip);  // Private signal
                 // <--- TO PIMPL
             public Q_SLOTS:
                 // These are for internal communication
                 // TODO: TO PIMPL --->
                 void barHoverEnterEvent(QPoint pos);
                 void barHoverLeaveEvent();
                 // <--- TO PIMPL
             private:
-                QString mName;
+                QString m_Name;
-                QList<qreal> mValues;   // TODO: replace with map (category, value)
+                QList<qreal> m_Values;   // TODO: replace with map (category, value)
-                QMap<QString, qreal> mMappedValues;
+                QMap<QString, qreal> m_MappedValues;
-                QPen mPen;
+                QPen m_Pen;
-                QBrush mBrush;
+                QBrush m_Brush;
-                QPen mFloatingValuePen;
+                QPen m_FloatingValuePen;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QBARSET_H

src/barchart/stackedbarchartitem.cpp +17 -17

             #include "stackedbarchartitem_p.h"
             #include "bar_p.h"
             #include "barvalue_p.h"
             #include "qbarset.h"
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             StackedBarChartItem::StackedBarChartItem(QBarSeries *series, ChartPresenter *presenter) :
                 BarChartItem(series, presenter)
             {
             }
             StackedBarChartItem::~StackedBarChartItem()
             {
             }
             QVector<QRectF> StackedBarChartItem::calculateLayout()
             {
                 QVector<QRectF> layout;
                 // Use temporary qreals for accurancy (we might get some compiler warnings... :)
-                qreal maxSum = mSeries->maxCategorySum();
+                qreal maxSum = m_Series->maxCategorySum();
                 // Domain:
-                if (mDomainMaxY > maxSum) {
+                if (m_DomainMaxY > maxSum) {
-                    maxSum = mDomainMaxY;
+                    maxSum = m_DomainMaxY;
                 }
                 qreal height = geometry().height();
                 qreal width = geometry().width();
-                qreal scale = (height /  mSeries->maxCategorySum());
+                qreal scale = (height /  m_Series->maxCategorySum());
-                qreal categotyCount = mSeries->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 < mSeries->barsetCount(); set++) {
+                    for (int set=0; set < m_Series->barsetCount(); set++) {
-                        qreal barHeight = mSeries->valueAt(set, category) * scale;
+                        qreal barHeight = m_Series->valueAt(set, category) * scale;
-                        Bar* bar = mBars.at(itemIndex);
+                        Bar* bar = m_Bars.at(itemIndex);
-                        bar->setPen(mSeries->barsetAt(set)->pen());
+                        bar->setPen(m_Series->barsetAt(set)->pen());
-                        bar->setBrush(mSeries->barsetAt(set)->brush());
+                        bar->setBrush(m_Series->barsetAt(set)->brush());
                         QRectF rect(xPos, yPos-barHeight, barWidth, barHeight);
                         layout.append(rect);
                         itemIndex++;
                         yPos -= barHeight;
                     }
                     xPos += xStep;
                 }
                 // Position floating values
                 itemIndex = 0;
                 xPos = (width/categotyCount);
-                for (int category=0; category < mSeries->categoryCount(); category++) {
+                for (int category=0; category < m_Series->categoryCount(); category++) {
                     qreal yPos = height;
-                    for (int set=0; set < mSeries->barsetCount(); set++) {
+                    for (int set=0; set < m_Series->barsetCount(); set++) {
-                        qreal barHeight = mSeries->valueAt(set, category) * scale;
+                        qreal barHeight = m_Series->valueAt(set, category) * scale;
-                        BarValue* value = mFloatingValues.at(itemIndex);
+                        BarValue* value = m_FloatingValues.at(itemIndex);
-                        QBarSet* barSet = mSeries->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 (mSeries->valueAt(set, category) != 0) {
+                        if (m_Series->valueAt(set, category) != 0) {
-                            value->setValueString(QString::number(mSeries->valueAt(set,category)));
+                            value->setValueString(QString::number(m_Series->valueAt(set,category)));
                         } else {
                             value->setValueString(QString(""));
                         }
                         itemIndex++;
                         yPos -= barHeight;
                     }
                     xPos += xStep;
                 }
                 return layout;
             }
             #include "moc_stackedbarchartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/qlegend.cpp +99 -104

             #include "qchartglobal.h"
             #include "qlegend.h"
             #include "qseries.h"
             #include "legendmarker_p.h"
             #include "legendscrollbutton_p.h"
             #include "qxyseries.h"
             #include "qlineseries.h"
             #include "qareaseries.h"
             #include "qscatterseries.h"
             #include "qsplineseries.h"
             #include "qbarseries.h"
             #include "qstackedbarseries.h"
             #include "qpercentbarseries.h"
             #include "qbarset.h"
             #include "qpieseries.h"
             #include "qpieslice.h"
             #include "chartpresenter_p.h"
             #include <QPainter>
             #include <QPen>
             #include <QGraphicsSceneEvent>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QLegend
                 \brief part of QtCommercial chart API.
                 QLegend is a graphical object, whics displays legend of the chart. Legend state is updated by QChart, when
                 series have been changed. By default, legend is drawn by QChart, but user can set a new parent to legend and
                 handle the drawing manually.
                 User isn't supposed to create or delete legend objects, but can reference it via QChart class.
                 \mainclass
                 \sa QChart, QSeries
             */
             /*!
                 \enum QLegend::PreferredLayout
                 This enum describes the possible position for legend inside chart.
                 \value PreferredLayoutTop
                 \value PreferredLayoutBottom
                 \value PreferredLayoutLeft
                 \value PreferredLayoutRight
             */
             /*!
                 \fn void QLegend::clicked(QSeries* series, Qt::MouseButton button)
                 \brief Notifies when series has been clicked on legend \a series \a button
             */
             /*!
                 \fn void QLegend::clicked(QBarSet* barset, Qt::MouseButton button)
                 \brief Notifies when barset has been clicked on legend \a barset \a button
             */
             /*!
                 \fn void QLegend::clicked(QPieSlice* slice, Qt::MouseButton button)
                 \brief Notifies when pie slice has been clicked on legend \a slice \a button
             */
             /*!
                 Constructs the legend object and sets the parent to \a parent
             */
-            QLegend::QLegend(QGraphicsItem *parent)
+            QLegend::QLegend(QGraphicsItem *parent) : QGraphicsObject(parent),
-                : QGraphicsObject(parent)
+                m_Pos(0,0),
-                ,mPos(0,0)
+                m_Size(0,0),
-                ,mSize(0,0)
+                m_MinimumSize(50,20),                // TODO: magic numbers
-                ,mMinimumSize(50,20)                // TODO: magic numbers
+                m_MaximumSize(150,100),
-                ,mMaximumSize(150,100)
+                m_brush(Qt::darkGray),       // TODO: from theme?
-                ,m_brush(Qt::darkGray)       // TODO: from theme?
+                m_PreferredLayout(QLegend::PreferredLayoutTop),
-                ,mPreferredLayout(QLegend::PreferredLayoutTop)
+                mFirstMarker(0),
-                ,mFirstMarker(0)
+                m_Margin(5)
-                ,mMargin(5)
+                m_ScrollButtonLeft = new LegendScrollButton(LegendScrollButton::ScrollButtonIdLeft, this);
-            //    setVisible(false);
+                m_ScrollButtonRight = new LegendScrollButton(LegendScrollButton::ScrollButtonIdRight, this);
+                m_ScrollButtonUp = new LegendScrollButton(LegendScrollButton::ScrollButtonIdUp, this);
-                mScrollButtonLeft = new LegendScrollButton(LegendScrollButton::ScrollButtonIdLeft, this);
+                m_ScrollButtonDown = new LegendScrollButton(LegendScrollButton::ScrollButtonIdDown, this);
-                mScrollButtonRight = new LegendScrollButton(LegendScrollButton::ScrollButtonIdRight, this);
-                mScrollButtonUp = new LegendScrollButton(LegendScrollButton::ScrollButtonIdUp, this);
+                connect(m_ScrollButtonLeft, SIGNAL(clicked(QGraphicsSceneMouseEvent*)),
-                mScrollButtonDown = new LegendScrollButton(LegendScrollButton::ScrollButtonIdDown, this);
-                connect(mScrollButtonLeft, SIGNAL(clicked(QGraphicsSceneMouseEvent*)),
                         this, SLOT(handleScrollButtonClicked(QGraphicsSceneMouseEvent*)));
-                connect(mScrollButtonRight, SIGNAL(clicked(QGraphicsSceneMouseEvent*)),
+                connect(m_ScrollButtonRight, SIGNAL(clicked(QGraphicsSceneMouseEvent*)),
                         this, SLOT(handleScrollButtonClicked(QGraphicsSceneMouseEvent*)));
-                connect(mScrollButtonUp, SIGNAL(clicked(QGraphicsSceneMouseEvent*)),
+                connect(m_ScrollButtonUp, SIGNAL(clicked(QGraphicsSceneMouseEvent*)),
                         this, SLOT(handleScrollButtonClicked(QGraphicsSceneMouseEvent*)));
-                connect(mScrollButtonDown, SIGNAL(clicked(QGraphicsSceneMouseEvent*)),
+                connect(m_ScrollButtonDown, SIGNAL(clicked(QGraphicsSceneMouseEvent*)),
                         this, SLOT(handleScrollButtonClicked(QGraphicsSceneMouseEvent*)));
                 setZValue(ChartPresenter::LegendZValue);
             }
             /*!
                 Paints the legend to given \a painter. Paremeters \a option and \a widget arent used.
             */
             void QLegend::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(option)
                 Q_UNUSED(widget)
                 painter->setOpacity(opacity());
                 painter->setPen(m_pen);
                 painter->setBrush(m_brush);
                 painter->drawRect(boundingRect());
             }
             /*!
                 Bounding rect of legend.
             */
             QRectF QLegend::boundingRect() const
             {
-                return QRectF(mPos,mSize);
+                return QRectF(m_Pos,m_Size);
             }
             /*!
                 Sets the \a brush of legend. Brush affects the background of legend.
             */
             void QLegend::setBrush(const QBrush &brush)
             {
                 if (m_brush != brush) {
                     m_brush = brush;
                     update();
                 }
             }
             /*!
                 Returns the brush used by legend.
             */
             QBrush QLegend::brush() const
             {
                 return m_brush;
             }
             /*!
                 Sets the \a pen of legend. Pen affects the legend borders.
             */
             void QLegend::setPen(const QPen &pen)
             {
                 if (m_pen != pen) {
                     m_pen = pen;
                     update();
                 }
             }
             /*!
                 Returns the pen used by legend
             */
             QPen QLegend::pen() const
             {
                 return m_pen;
             }
             /*!
                 Sets the \a preferred layout for legend. Legend tries to paint itself on the defined position in chart.
                 \sa QLegend::PreferredLayout
             */
             void QLegend::setPreferredLayout(QLegend::PreferredLayout preferred)
             {
-                mPreferredLayout = preferred;
+                m_PreferredLayout = preferred;
                 updateLayout();
             }
             /*!
                 Returns the preferred layout for legend
             */
             QLegend::PreferredLayout QLegend::preferredLayout() const
             {
-                return mPreferredLayout;
+                return m_PreferredLayout;
             }
             /*!
                 Returns the maximum size of legend.
             */
             QSizeF QLegend::maximumSize() const
             {
-                return mMaximumSize;
+                return m_MaximumSize;
             }
             /*!
                 Sets the maximum \a size for legend. The legend can't grow bigger than this size. If there are
                 more series than legend can fit to this size, scroll buttons are displayed.
             */
             void QLegend::setMaximumSize(const QSizeF size)
             {
-                mMaximumSize = size;
+                m_MaximumSize = size;
                 updateLayout();
             }
             /*!
                 Returns the current size of legend.
             */
             QSizeF QLegend::size() const
             {
-                return mSize;
+                return m_Size;
             }
             /*!
                 Sets the \a size of legend. If size is bigger than maximum size of legend, the legend is resized to the maximum size.
                 \sa setMmaximumSize()
             */
             void QLegend::setSize(const QSizeF size)
             {
-                mSize = size;
+                m_Size = size;
-                if (mSize.width() > mMaximumSize.width()) {
+                if (m_Size.width() > m_MaximumSize.width()) {
-                    mSize.setWidth(mMaximumSize.width());
+                    m_Size.setWidth(m_MaximumSize.width());
                 }
-                if (mSize.height() > mMaximumSize.height()) {
+                if (m_Size.height() > m_MaximumSize.height()) {
-                    mSize.setHeight(mMaximumSize.height());
+                    m_Size.setHeight(m_MaximumSize.height());
                 }
             }
             /*!
                 Sets position of legend to \a pos
             */
             void QLegend::setPos(const QPointF &pos)
             {
-                mPos = pos;
+                m_Pos = pos;
                 updateLayout();
             }
             /*!
                 \internal \a series \a domain Should be called when series is added to chart.
             */
             void QLegend::handleSeriesAdded(QSeries *series, Domain *domain)
             {
                 Q_UNUSED(domain)
                 createMarkers(series);
                 connectSeries(series);
                 updateLayout();
             }
             /*!
                 \internal \a series Should be called when series is removed from chart.
             */
             void QLegend::handleSeriesRemoved(QSeries *series)
             {
                 disconnectSeries(series);
                 if (series->type() == QSeries::SeriesTypeArea)
                 {
                     // This is special case. Area series has upper and lower series, which each have markers
                     QAreaSeries* s = static_cast<QAreaSeries *> (series);
                     deleteMarkers(s->upperSeries());
                     deleteMarkers(s->lowerSeries());
                 } else {
                     deleteMarkers(series);
                 }
                 updateLayout();
             }
             /*!
                 \internal \a slices Should be called when slices are added to pie chart.
             */
             void QLegend::handleAdded(QList<QPieSlice *> slices)
             {
                 QPieSeries* series = static_cast<QPieSeries *> (sender());
                 foreach(QPieSlice* s, slices) {
                     LegendMarker* marker = new LegendMarker(series, s, this);
                     marker->setName(s->label());
                     marker->setBrush(s->brush());
                     connect(marker, SIGNAL(clicked(QPieSlice*,Qt::MouseButton)),
                             this, SIGNAL(clicked(QPieSlice*,Qt::MouseButton)));
                     connect(s, SIGNAL(changed()), marker, SLOT(changed()));
                     connect(s, SIGNAL(destroyed()), marker, SLOT(deleteLater()));
                     connect(marker, SIGNAL(destroyed()), this, SLOT(handleMarkerDestroyed()));
-                    mMarkers.append(marker);
+                    m_Markers.append(marker);
                     childItems().append(marker);
                 }
                 updateLayout();
             }
             /*!
                 \internal \a slices Should be called when slices are removed from pie chart. Currently unused,
                 because removed slices are also deleted and we listen destroyed signal
             */
             void QLegend::handleRemoved(QList<QPieSlice *> slices)
             {
                 Q_UNUSED(slices)
-                // Propably no need to listen for this, since removed slices are deleted and we listen destroyed signal
-            //    qDebug() << "QLegend::handleRemoved(QList<QPieSlice*> slices) count:" << slices.count();
             }
             /*!
                 \internal Notifies legend that some marker has been removed. Sent by legend markers when destroyed
             */
             void QLegend::handleMarkerDestroyed()
             {
                 // TODO: what if more than one markers are destroyed and we update layout after first one?
                 LegendMarker* m = static_cast<LegendMarker *> (sender());
-                mMarkers.removeOne(m);
+                m_Markers.removeOne(m);
                 updateLayout();
             }
             /*!
                 \internal \a event Handles clicked signals from scroll buttons
             */
             void QLegend::handleScrollButtonClicked(QGraphicsSceneMouseEvent *event)
             {
                 Q_UNUSED(event);    // Maybe later something happens with right click...
                 LegendScrollButton* scrollButton = static_cast<LegendScrollButton *> (sender());
                 Q_ASSERT(scrollButton);
                 switch (scrollButton->id()) {
                 case LegendScrollButton::ScrollButtonIdLeft:
                 case LegendScrollButton::ScrollButtonIdUp: {
                     // Lower limit is same in these cases
                     mFirstMarker--;
                     checkFirstMarkerBounds();
                     break;
                 }
                 case LegendScrollButton::ScrollButtonIdRight:
                 case LegendScrollButton::ScrollButtonIdDown: {
                     mFirstMarker++;
                     checkFirstMarkerBounds();
                     break;
                 }
                 default: {
                     break;
                 }
                 }
                 updateLayout();
             }
             /*!
                 \internal Connects the \a series to legend. Legend listens changes in series, for example pie slices added / removed.
                 Not all series notify about events
             */
             void QLegend::connectSeries(QSeries *series)
             {
                 // Connect relevant signals from series
                 switch (series->type())
                 {
                 case QSeries::SeriesTypeLine: {
             //        QLineSeries* lineSeries = static_cast<QLineSeries*>(series);
                     break;
                 }
                 case QSeries::SeriesTypeArea: {
             //        QAreaSeries* areaSeries = static_cast<QAreaSeries*>(series);
                     break;
                 }
                 case QSeries::SeriesTypeBar: {
             //        QBarSeries* barSeries = static_cast<QBarSeries*>(series);
                     break;
                 }
                 case QSeries::SeriesTypeStackedBar: {
             //        QStackedBarSeries* stackedBarSeries = static_cast<QStackedBarSeries*>(series);
                     break;
                 }
                 case QSeries::SeriesTypePercentBar: {
             //        QPercentBarSeries* percentBarSeries = static_cast<QPercentBarSeries*>(series);
                     break;
                 }
                 case QSeries::SeriesTypeScatter: {
             //        QScatterSeries *scatterSeries = static_cast<QScatterSeries *>(series);
                     break;
                 }
                 case QSeries::SeriesTypePie: {
                     QPieSeries *pieSeries = static_cast<QPieSeries *>(series);
                     connect(pieSeries,SIGNAL(added(QList<QPieSlice*>)),this,SLOT(handleAdded(QList<QPieSlice*>)));
             //        connect(pieSeries,SIGNAL(removed(QList<QPieSlice*>)),this,SLOT(handleRemoved(QList<QPieSlice*>)));
                     break;
                 }
                 case QSeries::SeriesTypeSpline: {
             //        QSplineSeries* splineSeries = static_cast<QSplineSeries*>(series);
                     break;
                 }
                 default: {
-                    qDebug()<< "QLegend::connectSeries" << series->type() << "not implemented.";
+                    qWarning() << "QLegend::connectSeries" << series->type() << "not implemented.";
                     break;
                 }
                 }
             }
             /*!
                 \internal Disconnects \a series from legend. No more status updates from series to legend.
             */
             void QLegend::disconnectSeries(QSeries *series)
             {
                 // Connect relevant signals from series
                 switch (series->type())
                 {
                 case QSeries::SeriesTypeLine: {
             //        QLineSeries* lineSeries = static_cast<QLineSeries*>(series);
                     break;
                 }
                 case QSeries::SeriesTypeArea: {
             //        QAreaSeries* areaSeries = static_cast<QAreaSeries*>(series);
                     break;
                 }
                 case QSeries::SeriesTypeBar: {
             //        QBarSeries* barSeries = static_cast<QBarSeries*>(series);
                     break;
                 }
                 case QSeries::SeriesTypeStackedBar: {
             //        QStackedBarSeries* stackedBarSeries = static_cast<QStackedBarSeries*>(series);
                     break;
                 }
                 case QSeries::SeriesTypePercentBar: {
             //        QPercentBarSeries* percentBarSeries = static_cast<QPercentBarSeries*>(series);
                     break;
                 }
                 case QSeries::SeriesTypeScatter: {
             //        QScatterSeries *scatterSeries = static_cast<QScatterSeries *>(series);
                     break;
                 }
                 case QSeries::SeriesTypePie: {
                     QPieSeries *pieSeries = static_cast<QPieSeries *>(series);
                     disconnect(pieSeries, SIGNAL(added(QList<QPieSlice *>)), this, SLOT(handleAdded(QList<QPieSlice *>)));
             //        disconnect(pieSeries,SIGNAL(removed(QList<QPieSlice*>)),this,SLOT(handleRemoved(QList<QPieSlice*>)));
                     break;
                 }
                 case QSeries::SeriesTypeSpline: {
             //        QSplineSeries* splineSeries = static_cast<QSplineSeries*>(series);
                     break;
                 }
                 default: {
-                    qDebug()<< "QLegend::disconnectSeries" << series->type() << "not implemented.";
+                    qWarning()<< "QLegend::disconnectSeries" << series->type() << "not implemented.";
                     break;
                 }
                 }
             }
             /*!
                 \internal Creates new markers for \a series. Marker contains the colored rectangle and series name.
                 With pie chart, created markers depend on pie slices.
                 With bar chart, created markers depend on bar sets.
             */
             void QLegend::createMarkers(QSeries *series)
             {
                 switch (series->type())
                 {
                 case QSeries::SeriesTypeLine: {
                     QLineSeries *lineSeries = static_cast<QLineSeries *>(series);
                     appendMarkers(lineSeries);
                     break;
                 }
                 case QSeries::SeriesTypeArea: {
                     QAreaSeries *areaSeries = static_cast<QAreaSeries *>(series);
                     appendMarkers(areaSeries->upperSeries());
                     if(areaSeries->lowerSeries())
                         appendMarkers(areaSeries->lowerSeries());
                     break;
                 }
                 case QSeries::SeriesTypeBar: {
                     QBarSeries *barSeries = static_cast<QBarSeries *>(series);
                     appendMarkers(barSeries);
                     break;
                 }
                 case QSeries::SeriesTypeStackedBar: {
                     QStackedBarSeries *stackedBarSeries = static_cast<QStackedBarSeries *>(series);
                     appendMarkers(stackedBarSeries);
                     break;
                 }
                 case QSeries::SeriesTypePercentBar: {
                     QPercentBarSeries *percentBarSeries = static_cast<QPercentBarSeries *>(series);
                     appendMarkers(percentBarSeries);
                     break;
                 }
                 case QSeries::SeriesTypeScatter: {
                     QScatterSeries *scatterSeries = static_cast<QScatterSeries *>(series);
                     appendMarkers(scatterSeries);
                     break;
                 }
                 case QSeries::SeriesTypePie: {
                     QPieSeries *pieSeries = static_cast<QPieSeries *>(series);
                     appendMarkers(pieSeries);
                     break;
                 }
                 case QSeries::SeriesTypeSpline: {
                     QSplineSeries *splineSeries = static_cast<QSplineSeries *>(series);
                     appendMarkers(splineSeries);
                     break;
                 }
                 default: {
-                    qDebug()<< "QLegend::createMarkers" << series->type() << "not implemented.";
+                    qWarning()<< "QLegend::createMarkers" << series->type() << "not implemented.";
                     break;
                 }
                 }
             }
             /*!
                 \internal Helper function. Appends markers from \a series to legend.
             */
             void QLegend::appendMarkers(QXYSeries* series)
             {
                 LegendMarker* marker = new LegendMarker(series,this);
                 marker->setName(series->name());
                 marker->setPen(series->pen());
                 marker->setBrush(series->brush());
                 connect(marker, SIGNAL(clicked(QSeries *, Qt::MouseButton)), this, SIGNAL(clicked(QSeries *, Qt::MouseButton)));
                 connect(marker, SIGNAL(destroyed()), this, SLOT(handleMarkerDestroyed()));
-                mMarkers.append(marker);
+                m_Markers.append(marker);
                 childItems().append(marker);
             }
             /*!
                 \internal Helper function. Appends markers from  \a series to legend.
             */
             void QLegend::appendMarkers(QBarSeries *series)
             {
                 foreach(QBarSet* s, series->barSets()) {
                     LegendMarker* marker = new LegendMarker(series, s, this);
                     marker->setName(s->name());
                     marker->setPen(s->pen());
                     marker->setBrush(s->brush());
                     connect(marker, SIGNAL(clicked(QBarSet *, Qt::MouseButton)),
                             this, SIGNAL(clicked(QBarSet *, Qt::MouseButton)));
                     connect(s, SIGNAL(valueChanged()), marker, SLOT(changed()));
                     connect(marker, SIGNAL(destroyed()), this, SLOT(handleMarkerDestroyed()));
-                    mMarkers.append(marker);
+                    m_Markers.append(marker);
                     childItems().append(marker);
                 }
             }
             /*!
                 \internal Helper function. Appends markers from  \a series to legend.
             */
             void QLegend::appendMarkers(QPieSeries *series)
             {
                 foreach(QPieSlice* s, series->slices()) {
                     LegendMarker* marker = new LegendMarker(series, s, this);
                     marker->setName(s->label());
                     marker->setPen(s->pen());
                     marker->setBrush(s->brush());
                     connect(marker, SIGNAL(clicked(QPieSlice *, Qt::MouseButton)),
                             this, SIGNAL(clicked(QPieSlice *, Qt::MouseButton)));
                     connect(s, SIGNAL(changed()), marker, SLOT(changed()));
                     connect(s, SIGNAL(destroyed()), marker, SLOT(deleteLater()));
                     connect(marker, SIGNAL(destroyed()), this, SLOT(handleMarkerDestroyed()));
-                    mMarkers.append(marker);
+                    m_Markers.append(marker);
                     childItems().append(marker);
                 }
             }
             /*!
                 \internal Deletes all markers that are created from \a series
             */
             void QLegend::deleteMarkers(QSeries *series)
             {
                 // Search all markers that belong to given series and delete them.
-                foreach (LegendMarker *m, mMarkers) {
+                foreach (LegendMarker *m, m_Markers) {
                     if (m->series() == series) {
-                        mMarkers.removeOne(m);
+                        m_Markers.removeOne(m);
                         delete m;
                     }
                 }
             }
             /*!
                 \internal Updates layout of legend. Tries to fit as many markers as possible up to the maximum size of legend.
                 If items don't fit, sets the visibility of scroll buttons accordingly.
                 Causes legend to be resized.
             */
             void QLegend::updateLayout()
             {
                 // Calculate layout for markers and text
-                if (mMarkers.count() <= 0) {
+                if (m_Markers.count() <= 0) {
                     // Nothing to do
                     return;
                 }
                 // Find out widest item.
                 QSizeF markerMaxSize = maximumMarkerSize();
                 checkFirstMarkerBounds();
                 // Use max height as scroll button size
                 rescaleScrollButtons(QSize(markerMaxSize.height() ,markerMaxSize.height()));
                 qreal totalWidth = 0;
                 qreal totalHeight = 0;
-                switch (mPreferredLayout)
+                switch (m_PreferredLayout)
                 {
                 // Both cases organise items horizontally
                 case QLegend::PreferredLayoutBottom:
                 case QLegend::PreferredLayoutTop: {
                     qreal xStep = markerMaxSize.width();
-                    qreal x = mPos.x() + mMargin;
+                    qreal x = m_Pos.x() + m_Margin;
-                    qreal y = mPos.y() + mMargin;
+                    qreal y = m_Pos.y() + m_Margin;
                     int column = 0;
                     int maxColumns = 1;
                     qreal scrollButtonWidth = 0;
                     // Set correct visibility for scroll scrollbuttons
                     if (scrollButtonsVisible()) {
-                        mScrollButtonLeft->setVisible(true);
+                        m_ScrollButtonLeft->setVisible(true);
-                        mScrollButtonRight->setVisible(true);
+                        m_ScrollButtonRight->setVisible(true);
                         // scrollbuttons visible, so add their width to total width
-                        totalWidth += (mScrollButtonLeft->boundingRect().width() + mMargin) * 2;
+                        totalWidth += (m_ScrollButtonLeft->boundingRect().width() + m_Margin) * 2;
-                        scrollButtonWidth = mScrollButtonLeft->boundingRect().width() + mMargin;
+                        scrollButtonWidth = m_ScrollButtonLeft->boundingRect().width() + m_Margin;
                         // start position changes by scrollbutton width
                         x += scrollButtonWidth;
                     } else {
-                        mScrollButtonLeft->setVisible(false);
+                        m_ScrollButtonLeft->setVisible(false);
-                        mScrollButtonRight->setVisible(false);
+                        m_ScrollButtonRight->setVisible(false);
                     }
-                    mScrollButtonUp->setVisible(false);
+                    m_ScrollButtonUp->setVisible(false);
-                    mScrollButtonDown->setVisible(false);
+                    m_ScrollButtonDown->setVisible(false);
-                    for (int i=0; i < mMarkers.count(); i++) {
+                    for (int i=0; i < m_Markers.count(); i++) {
-                        LegendMarker *m = mMarkers.at(i);
+                        LegendMarker *m = m_Markers.at(i);
                         if (i < mFirstMarker) {
                             // Markers before first are not visible.
                             m->setVisible(false);
                         } else {
-                            if ((x + xStep + scrollButtonWidth + mMargin) > (mPos.x() + mMaximumSize.width())) {
+                            if ((x + xStep + scrollButtonWidth + m_Margin) > (m_Pos.x() + m_MaximumSize.width())) {
                                 // This marker would go outside legend rect.
                                 m->setVisible(false);
                             } else {
                                 // This marker is ok
                                 m->setVisible(true);
                                 m->setPos(x, y);
                                 x += xStep;
                                 column++;
                             }
                         }
                         maxColumns = column;
                     }
-                    mScrollButtonLeft->setPos(mPos.x() + mMargin, y);
+                    m_ScrollButtonLeft->setPos(m_Pos.x() + m_Margin, y);
-                    mScrollButtonRight->setPos(x + mMargin, y);
+                    m_ScrollButtonRight->setPos(x + m_Margin, y);
-                    totalWidth += maxColumns * markerMaxSize.width() + mMargin * 2;
+                    totalWidth += maxColumns * markerMaxSize.width() + m_Margin * 2;
-                    totalHeight = markerMaxSize.height() + mMargin * 2;
+                    totalHeight = markerMaxSize.height() + m_Margin * 2;
                     break;
                 }
                 // Both cases organize items vertically
                 case QLegend::PreferredLayoutLeft:
                 case QLegend::PreferredLayoutRight: {
                     qreal yStep = markerMaxSize.height();
-                    qreal x = mPos.x() + mMargin;
+                    qreal x = m_Pos.x() + m_Margin;
-                    qreal y = mPos.y() + mMargin;
+                    qreal y = m_Pos.y() + m_Margin;
                     int row = 1;
                     int maxRows = 1;
                     qreal scrollButtonHeight = 0;
                     // Set correct visibility for scroll scrollbuttons
                     if (scrollButtonsVisible()) {
-                        mScrollButtonUp->setVisible(true);
+                        m_ScrollButtonUp->setVisible(true);
-                        mScrollButtonDown->setVisible(true);
+                        m_ScrollButtonDown->setVisible(true);
-                        totalHeight += (mScrollButtonUp->boundingRect().height() + mMargin) * 2;   // scrollbuttons visible, so add their height to total height
+                        totalHeight += (m_ScrollButtonUp->boundingRect().height() + m_Margin) * 2;   // scrollbuttons visible, so add their height to total height
-                        scrollButtonHeight = mScrollButtonUp->boundingRect().height();
+                        scrollButtonHeight = m_ScrollButtonUp->boundingRect().height();
-                        y += scrollButtonHeight + mMargin;                                         // start position changes by scrollbutton height
+                        y += scrollButtonHeight + m_Margin;                                         // start position changes by scrollbutton height
                     } else {
-                        mScrollButtonUp->setVisible(false);
+                        m_ScrollButtonUp->setVisible(false);
-                        mScrollButtonDown->setVisible(false);
+                        m_ScrollButtonDown->setVisible(false);
                     }
-                    mScrollButtonLeft->setVisible(false);
+                    m_ScrollButtonLeft->setVisible(false);
-                    mScrollButtonRight->setVisible(false);
+                    m_ScrollButtonRight->setVisible(false);
-                    for (int i=0; i < mMarkers.count(); i++) {
+                    for (int i=0; i < m_Markers.count(); i++) {
-                        LegendMarker* m = mMarkers.at(i);
+                        LegendMarker* m = m_Markers.at(i);
                         if (i < mFirstMarker) {
                             // Markers before first are not visible.
                             m->setVisible(false);
                         } else {
-                            if ((y + yStep + scrollButtonHeight) > (mPos.y() + mMaximumSize.height())) {
+                            if ((y + yStep + scrollButtonHeight) > (m_Pos.y() + m_MaximumSize.height())) {
                                 // This marker would go outside legend rect.
                                 m->setVisible(false);
                             } else {
                                 // This marker is ok
                                 m->setVisible(true);
                                 m->setPos(x, y);
                                 y += yStep;
                                 row++;
                             }
                         }
                         maxRows = row;
                     }
-                    mScrollButtonUp->setPos(mPos.x() + mMargin, mPos.y() + mMargin);
+                    m_ScrollButtonUp->setPos(m_Pos.x() + m_Margin, m_Pos.y() + m_Margin);
-                    mScrollButtonDown->setPos(mPos.x() + mMargin, y + mMargin);
+                    m_ScrollButtonDown->setPos(m_Pos.x() + m_Margin, y + m_Margin);
-                    totalWidth += markerMaxSize.width() + mMargin * 2;
+                    totalWidth += markerMaxSize.width() + m_Margin * 2;
-                    totalHeight = maxRows * markerMaxSize.height() + mMargin * 4 + scrollButtonHeight; // TODO: check this
+                    totalHeight = maxRows * markerMaxSize.height() + m_Margin * 4 + scrollButtonHeight; // TODO: check this
                     break;
                 }
                 default: {
                     break;
                 }
                 }
-                mSize.setWidth(totalWidth);
+                m_Size.setWidth(totalWidth);
-                mSize.setHeight(totalHeight);
+                m_Size.setHeight(totalHeight);
                 update();
             }
             /*!
                 \internal Sets the size of scroll buttons to \a size
             */
             void QLegend::rescaleScrollButtons(const QSize &size)
             {
                 QPolygonF left;
                 left << QPointF(size.width(), 0) << QPointF(0, size.height() / 2) << QPointF(size.width(), size.height());
                 QPolygonF right;
                 right << QPointF(0, 0) << QPointF(size.width(), size.height() / 2) << QPointF(0, size.height());
                 QPolygonF up;
                 up << QPointF(0, size.height()) << QPointF(size.width() / 2,0) << QPointF(size.width(), size.height());
                 QPolygonF down;
                 down << QPointF(0, 0) << QPointF(size.width() / 2, size.height()) << QPointF(size.width(), 0);
-                mScrollButtonLeft->setPolygon(left);
+                m_ScrollButtonLeft->setPolygon(left);
-                mScrollButtonRight->setPolygon(right);
+                m_ScrollButtonRight->setPolygon(right);
-                mScrollButtonUp->setPolygon(up);
+                m_ScrollButtonUp->setPolygon(up);
-                mScrollButtonDown->setPolygon(down);
+                m_ScrollButtonDown->setPolygon(down);
             }
             /*!
                 \internal Finds out maximum size of single marker. Marker sizes depend on series names.
             */
             QSizeF QLegend::maximumMarkerSize()
             {
                 QSizeF max(0,0);
-                foreach (LegendMarker* m, mMarkers) {
+                foreach (LegendMarker* m, m_Markers) {
                     if (m->boundingRect().width() > max.width())
                         max.setWidth(m->boundingRect().width());
                     if (m->boundingRect().height() > max.height())
                         max.setHeight(m->boundingRect().height());
                 }
                 return max;
             }
             /*!
                 \internal Checks that first marker is in acceptable bounds. Bounds range from 0 to (maximum number of markers - visible markers)
                 If scrollbuttons are visible, they affect the number of visible markers.
             */
             void QLegend::checkFirstMarkerBounds()
             {
-                if ((mPreferredLayout == QLegend::PreferredLayoutLeft) || (mPreferredLayout == QLegend::PreferredLayoutRight)) {
+                if ((m_PreferredLayout == QLegend::PreferredLayoutLeft) || (m_PreferredLayout == QLegend::PreferredLayoutRight)) {
                     // Bounds limited by height.
                     int max;
                     if (scrollButtonsVisible()) {
-                        max = (mMaximumSize.height() - mScrollButtonLeft->boundingRect().height() * 2 - mMargin * 4) / maximumMarkerSize().height();
+                        max = (m_MaximumSize.height() - m_ScrollButtonLeft->boundingRect().height() * 2 - m_Margin * 4) / maximumMarkerSize().height();
                     } else {
-                        max = mMaximumSize.height() / maximumMarkerSize().height();
+                        max = m_MaximumSize.height() / maximumMarkerSize().height();
                     }
-                    if (mFirstMarker > mMarkers.count() - max)
+                    if (mFirstMarker > m_Markers.count() - max)
-                        mFirstMarker = mMarkers.count() - max;
+                        mFirstMarker = m_Markers.count() - max;
                 } else {
                     // Bounds limited by width
                     int max;
                     if (scrollButtonsVisible()) {
-                        max = (mMaximumSize.width() - mScrollButtonLeft->boundingRect().width() * 2 - mMargin*4) / maximumMarkerSize().width();
+                        max = (m_MaximumSize.width() - m_ScrollButtonLeft->boundingRect().width() * 2 - m_Margin*4) / maximumMarkerSize().width();
                     } else {
-                        max = mMaximumSize.width() / maximumMarkerSize().width();
+                        max = m_MaximumSize.width() / maximumMarkerSize().width();
                     }
-                    if (mFirstMarker > mMarkers.count() - max)
+                    if (mFirstMarker > m_Markers.count() - max)
-                        mFirstMarker = mMarkers.count() - max;
+                        mFirstMarker = m_Markers.count() - max;
                 }
                 if (mFirstMarker < 0)
                     mFirstMarker = 0;
             }
             /*!
                 \internal Helper function. Visibility of scroll buttons isn't quite obvious, so helper function clarifies the logic.
             */
             bool QLegend::scrollButtonsVisible()
             {
                 // Just a helper to clarify, what the magic below means :)
-                if ((mPreferredLayout == QLegend::PreferredLayoutTop) || (mPreferredLayout == QLegend::PreferredLayoutBottom)) {
+                if ((m_PreferredLayout == QLegend::PreferredLayoutTop) || (m_PreferredLayout == QLegend::PreferredLayoutBottom)) {
-                    return (maximumMarkerSize().width() * mMarkers.count() + mMargin * 2 > mMaximumSize.width());
+                    return (maximumMarkerSize().width() * m_Markers.count() + m_Margin * 2 > m_MaximumSize.width());
-                } else if ((mPreferredLayout == QLegend::PreferredLayoutLeft) || (mPreferredLayout == QLegend::PreferredLayoutRight)) {
+                } else if ((m_PreferredLayout == QLegend::PreferredLayoutLeft) || (m_PreferredLayout == QLegend::PreferredLayoutRight)) {
-                    return (maximumMarkerSize().height() * mMarkers.count() + mMargin * 2 > mMaximumSize.height());
+                    return (maximumMarkerSize().height() * m_Markers.count() + m_Margin * 2 > m_MaximumSize.height());
                 }
-                return (maximumMarkerSize().height() * mMarkers.count() + mMargin * 2 > mMaximumSize.height());
+                return (maximumMarkerSize().height() * m_Markers.count() + m_Margin * 2 > m_MaximumSize.height());
             }
             #include "moc_qlegend.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/qlegend.h +14 -12

             #ifndef QLEGEND_H
             #define QLEGEND_H
             #include <qchartglobal.h>
-            #include <qseries.h>
             #include <QGraphicsObject>
+            #include <QPen>
+            #include <QBrush>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class Domain;
             class LegendMarker;
             class QPieSlice;
             class QXYSeries;
             class QBarSet;
             class QBarSeries;
             class QPieSeries;
             class LegendScrollButton;
+            class QSeries;
             class QTCOMMERCIALCHART_EXPORT QLegend : public QGraphicsObject
             {
                 Q_OBJECT
             public:
                 enum PreferredLayout {
                     PreferredLayoutTop,
                     PreferredLayoutBottom,
                     PreferredLayoutLeft,
                     PreferredLayoutRight
                 };
                 explicit QLegend(QGraphicsItem *parent = 0);
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = 0);
                 QRectF boundingRect() const;
                 void setBrush(const QBrush &brush);
                 QBrush brush() const;
                 void setPen(const QPen &pen);
                 QPen pen() const;
                 void setPreferredLayout(QLegend::PreferredLayout preferred);
                 QLegend::PreferredLayout preferredLayout() const;
                 QSizeF maximumSize() const;
                 void setMaximumSize(const QSizeF size);
                 QSizeF size() const;
                 void setSize(const QSizeF size);
                 void setPos(const QPointF &pos);
             signals:
                 // for interactions.
                 void clicked(QSeries *series, Qt::MouseButton button);
                 void clicked(QBarSet *barset, Qt::MouseButton button);
                 void clicked(QPieSlice *slice, Qt::MouseButton button);
             public slots:
                 // PIMPL --->
                 void handleSeriesAdded(QSeries *series, Domain *domain);
                 void handleSeriesRemoved(QSeries *series);
                 void handleAdded(QList<QPieSlice *> slices);
                 void handleRemoved(QList<QPieSlice *> slices);
                 void handleMarkerDestroyed();
                 void handleScrollButtonClicked(QGraphicsSceneMouseEvent *event);
                 // PIMPL <---
             private:
                 // PIMPL --->
                 void connectSeries(QSeries *series);
                 void disconnectSeries(QSeries *series);
                 void createMarkers(QSeries *series);
                 void appendMarkers(QXYSeries *series);      // All line series are derived from QXYSeries, so this works for now
                 void appendMarkers(QBarSeries *series);
                 void appendMarkers(QPieSeries *series);
                 void deleteMarkers(QSeries *series);
                 void updateLayout();
                 void rescaleScrollButtons(const QSize &size);
                 QSizeF maximumMarkerSize();
                 void checkFirstMarkerBounds();
                 bool scrollButtonsVisible();
-                QPointF mPos;
+                QPointF m_Pos;
-                QSizeF mSize;
+                QSizeF m_Size;
-                QSizeF mMinimumSize;
+                QSizeF m_MinimumSize;
-                QSizeF mMaximumSize;
+                QSizeF m_MaximumSize;
-                QList<LegendMarker *> mMarkers;
+                QList<LegendMarker *> m_Markers;
                 QBrush m_brush;
                 QPen m_pen;
-                QLegend::PreferredLayout mPreferredLayout;
+                QLegend::PreferredLayout m_PreferredLayout;
                 int mFirstMarker;
-                LegendScrollButton *mScrollButtonLeft;
+                LegendScrollButton *m_ScrollButtonLeft;
-                LegendScrollButton *mScrollButtonRight;
+                LegendScrollButton *m_ScrollButtonRight;
-                LegendScrollButton *mScrollButtonUp;
+                LegendScrollButton *m_ScrollButtonUp;
-                LegendScrollButton *mScrollButtonDown;
+                LegendScrollButton *m_ScrollButtonDown;
-                qreal mMargin;
+                qreal m_Margin;
                 // <--- PIMPL
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QLEGEND_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