HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r275:e59660aaa64a

Merge branch 'master' of https://git.it.local/repos/QtCommercialDevel-13049/charts

Marek Rosa -

r275:e59660aaa64a

parent child

Context file:

r275:e59660aaa64a

Collapse all files

example/stackedbarchart/main.cpp +6 -6

             #include <QApplication>
             #include <QMainWindow>
             #include <QStandardItemModel>
             #include <qstackedbarchartseries.h>
             #include "chartwidget.h"
             #include <qbarset.h>
             #include <qbarcategory.h>
             QTCOMMERCIALCHART_USE_NAMESPACE
             int main(int argc, char *argv[])
             {
                 QApplication a(argc, argv);
                 QMainWindow window;
                 QBarCategory *category = new QBarCategory;
                 *category << "Jan" << "Feb" << "Mar" << "Apr" << "May" << "June" << "Jul" << "Aug" << "Sep" << "Oct" << "Nov" << "Dec";
                 QStackedBarChartSeries* series0 = new QStackedBarChartSeries(category);
                 QBarSet *set0 = new QBarSet;
                 QBarSet *set1 = new QBarSet;
                 QBarSet *set2 = new QBarSet;
                 QBarSet *set3 = new QBarSet;
                 QBarSet *set4 = new QBarSet;
                 // Create some test data to chart
                 *set0 << 1 << 2 << 3 << 4 << 5 << 6 << 7 << 8 << 9 << 10 << 11 << 12;
-                *set1 << 5 << 0 << 0 << 4 << 0 << 7 << 8 << 9 << 9 << 0 << 4 << 2;
+            //    *set1 << 5 << 0 << 0 << 4 << 0 << 7 << 8 << 9 << 9 << 0 << 4 << 2;
-                *set2 << 3 << 5 << 8 << 13 << 8 << 5 << 3 << 2 << 1 << 1 << 3 << 5;
+            //    *set2 << 3 << 5 << 8 << 13 << 8 << 5 << 3 << 2 << 1 << 1 << 3 << 5;
-                *set3 << 5 << 6 << 7 << 3 << 4 << 5 << 8 << 9 << 10 << 5 << 2 << 7;
+            //    *set3 << 5 << 6 << 7 << 3 << 4 << 5 << 8 << 9 << 10 << 5 << 2 << 7;
                 *set4 << 9 << 7 << 5 << 3 << 1 << 2 << 4 << 6 << 8 << 10 << 1 << 6;
                 series0->addBarSet(set0);
-                series0->addBarSet(set1);
+            //    series0->addBarSet(set1);
-                series0->addBarSet(set2);
+            //    series0->addBarSet(set2);
-                series0->addBarSet(set3);
+            //    series0->addBarSet(set3);
                 series0->addBarSet(set4);
                 ChartWidget* chartWidget =  new ChartWidget(&window);
                 chartWidget->addSeries(series0);
                 window.setCentralWidget(chartWidget);
                 window.resize(400, 300);
                 window.show();
                 return a.exec();
             }

src/axisitem.cpp +24 -7

             #include "axisitem_p.h"
             #include "qchartaxis.h"
             #include "chartpresenter_p.h"
             #include <QPainter>
             #include <QDebug>
             static int label_padding = 5;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             AxisItem::AxisItem(AxisType type,QGraphicsItem* parent) :
             ChartItem(parent),
             m_type(type),
             m_labelsAngle(0),
             m_shadesEnabled(true),
             m_grid(parent),
             m_shades(parent),
             m_labels(parent),
-            m_origin(0,0)
+            m_axis(parent)
             {
                 //initial initialization
+                m_axis.setZValue(ChartPresenter::AxisZValue);
                 m_shades.setZValue(ChartPresenter::ShadesZValue);
                 m_grid.setZValue(ChartPresenter::GridZValue);
+                setFlags(QGraphicsItem::ItemHasNoContents);
             }
             AxisItem::~AxisItem()
             {
             }
             QRectF AxisItem::boundingRect() const
             {
                 return m_rect;
             }
             void AxisItem::createItems(int count)
             {
+                m_axis.addToGroup(new QGraphicsLineItem(this));
                 for (int i = 0; i < count; ++i) {
                        m_grid.addToGroup(new QGraphicsLineItem(this));
                        m_labels.addToGroup(new QGraphicsSimpleTextItem(this));
                        if(i%2) m_shades.addToGroup(new QGraphicsRectItem(this));
+                       m_axis.addToGroup(new QGraphicsLineItem(this));
                    }
             }
             void AxisItem::clear()
             {
                 foreach(QGraphicsItem* item , m_shades.childItems()) {
                     delete item;
                 }
                 foreach(QGraphicsItem* item , m_grid.childItems()) {
                     delete item;
                 }
                 foreach(QGraphicsItem* item , m_labels.childItems()) {
                     delete item;
                 }
+                foreach(QGraphicsItem* item , m_axis.childItems()) {
+                        delete item;
+                }
                 m_thicksList.clear();
             }
             void AxisItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
             }
             void AxisItem::updateItem(int count)
             {
+                if(count ==0) return;
                 QList<QGraphicsItem *> lines = m_grid.childItems();
                 QList<QGraphicsItem *> labels = m_labels.childItems();
                 QList<QGraphicsItem *> shades = m_shades.childItems();
+                QList<QGraphicsItem *> axis = m_axis.childItems();
                 switch (m_type)
                   {
                       case X_AXIS:
                       {
                           const qreal deltaX = m_rect.width() / (count-1);
-                          m_axis.setLine(m_rect.left(), m_rect.bottom(), m_rect.right(), m_rect.bottom());
+                          QGraphicsLineItem *lineItem =  static_cast<QGraphicsLineItem*>(axis.at(0));
+                          lineItem->setLine(m_rect.left(), m_rect.bottom(), m_rect.right(), m_rect.bottom());
                           for (int i = 0; i < count; ++i) {
                               int x = i * deltaX + m_rect.left();
                               QGraphicsLineItem *lineItem =  static_cast<QGraphicsLineItem*>(lines.at(i));
                               lineItem->setLine(x, m_rect.top(), x, m_rect.bottom());
                               QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem*>(labels.at(i));
                               labelItem->setText(m_thicksList.at(i));
                               QPointF center = labelItem->boundingRect().center();
                               labelItem->setTransformOriginPoint(center.x(), center.y());
                               labelItem->setPos(x - center.x(), m_rect.bottom() + label_padding);
                               if(i%2){
                                   QGraphicsRectItem *rectItem =  static_cast<QGraphicsRectItem*>(shades.at(i/2));
                                   rectItem->setRect(x,m_rect.top(),deltaX,m_rect.height());
                               }
+                              lineItem =  static_cast<QGraphicsLineItem*>(axis.at(i+1));
+                              lineItem->setLine(x,m_rect.bottom(),x,m_rect.bottom()+5);
                           }
                       }
                       break;
                       case Y_AXIS:
                       {
                           const qreal deltaY = m_rect.height()/ (count-1);
-                          m_axis.setLine(m_rect.left() , m_rect.top(), m_rect.left(), m_rect.bottom());
+                          QGraphicsLineItem *lineItem =  static_cast<QGraphicsLineItem*>(axis.at(0));
+                          lineItem->setLine(m_rect.left() , m_rect.top(), m_rect.left(), m_rect.bottom());
                           for (int i = 0; i < count; ++i) {
                               int y = i * -deltaY + m_rect.bottom();
                               QGraphicsLineItem *lineItem =  static_cast<QGraphicsLineItem*>(lines.at(i));
                               lineItem->setLine(m_rect.left() , y, m_rect.right(), y);
                               QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem*>(labels.at(i));
                               labelItem->setText(m_thicksList.at(i));
                               QPointF center = labelItem->boundingRect().center();
                               labelItem->setTransformOriginPoint(center.x(), center.y());
                               labelItem->setPos(m_rect.left() -  labelItem->boundingRect().width() - label_padding , y-center.y());
                               if(i%2){
                                   QGraphicsRectItem *rectItem =  static_cast<QGraphicsRectItem*>(shades.at(i/2));
                                   rectItem->setRect(m_rect.left(),y,m_rect.width(),deltaY);
                               }
+                              lineItem =  static_cast<QGraphicsLineItem*>(axis.at(i+1));
+                              lineItem->setLine(m_rect.left()-5,y,m_rect.left(),y);
                           }
                       }
                       break;
                       default:
                       qDebug()<<"Unknown axis type";
                       break;
                   }
             }
             void AxisItem::handleAxisUpdate(QChartAxis* axis)
             {
                 if(axis->isAxisVisible()) {
                     setAxisOpacity(100);
                 }
                 else {
                     setAxisOpacity(0);
                 }
                 if(axis->isGridVisible()) {
                     setGridOpacity(100);
                 }
                 else {
                     setGridOpacity(0);
                 }
                 if(axis->isLabelsVisible())
                 {
                     setLabelsOpacity(100);
                 }
                 else {
                     setLabelsOpacity(0);
                 }
                 if(axis->isShadesVisible()) {
                     setShadesOpacity(axis->shadesOpacity());
                 }
                 else {
                     setShadesOpacity(0);
                 }
                 setLabelsAngle(axis->labelsAngle());
                 setAxisPen(axis->axisPen());
                 setLabelsPen(axis->labelsPen());
                 setLabelsBrush(axis->labelsBrush());
                 setLabelsFont(axis->labelFont());
                 setGridPen(axis->gridPen());
                 setShadesPen(axis->shadesPen());
                 setShadesBrush(axis->shadesBrush());
             }
             void AxisItem::handleLabelsChanged(QChartAxis* axis,const QStringList& labels)
             {
                 m_thicksList=labels;
                 QList<QGraphicsItem*> items = m_labels.childItems();
-                if(items.size()!=m_thicksList.size()){
+                //if(items.size()!=m_thicksList.size()){
                    clear();
                    m_thicksList=labels;
                    createItems(m_thicksList.size());
                    updateItem(m_thicksList.size());
                    items = m_labels.childItems();
                    handleAxisUpdate(axis);
+                // }
                 Q_ASSERT(items.size()==m_thicksList.size());
                 int i=0;
                 foreach(QGraphicsItem* item, items){
                     static_cast<QGraphicsSimpleTextItem*>(item)->setText(m_thicksList.at(i));
                     i++;
                 }
                 update();
             }
             void AxisItem::handleGeometryChanged(const QRectF& rect)
             {
                 m_rect = rect;
                 updateItem(m_thicksList.size());
                 update();
             }
             void AxisItem::setAxisOpacity(qreal opacity)
             {
                 m_axis.setOpacity(opacity);
             }
             qreal AxisItem::axisOpacity() const
             {
                 return m_axis.opacity();
             }
             void AxisItem::setGridOpacity(qreal opacity)
             {
                 m_grid.setOpacity(opacity);
             }
             qreal AxisItem::gridOpacity() const
             {
                 return m_grid.opacity();
             }
             void AxisItem::setLabelsOpacity(qreal opacity)
             {
                 m_labels.setOpacity(opacity);
             }
             qreal AxisItem::labelsOpacity() const
             {
                 return m_labels.opacity();
             }
             void AxisItem::setShadesOpacity(qreal opacity)
             {
                 m_shades.setOpacity(opacity);
             }
             qreal AxisItem::shadesOpacity() const
             {
                 return m_shades.opacity();
             }
             void AxisItem::setLabelsAngle(int angle)
             {
                 foreach(QGraphicsItem* item , m_labels.childItems()) {
                       QPointF center = item->boundingRect().center();
                       item->setRotation(angle);
                 }
                 m_labelsAngle=angle;
             }
             void AxisItem::setLabelsPen(const QPen& pen)
             {
                 foreach(QGraphicsItem* item , m_labels.childItems()) {
                     static_cast<QGraphicsSimpleTextItem*>(item)->setPen(pen);
                 }
             }
             void AxisItem::setLabelsBrush(const QBrush& brush)
             {
                 foreach(QGraphicsItem* item , m_labels.childItems()) {
                     static_cast<QGraphicsSimpleTextItem*>(item)->setBrush(brush);
                 }
             }
             void AxisItem::setLabelsFont(const QFont& font)
             {
                 foreach(QGraphicsItem* item , m_labels.childItems()) {
                     static_cast<QGraphicsSimpleTextItem*>(item)->setFont(font);
                 }
             }
             void AxisItem::setShadesBrush(const QBrush& brush)
             {
                 foreach(QGraphicsItem* item , m_shades.childItems()) {
                     static_cast<QGraphicsRectItem*>(item)->setBrush(brush);
                 }
             }
             void AxisItem::setShadesPen(const QPen& pen)
             {
                 foreach(QGraphicsItem* item , m_shades.childItems()) {
                     static_cast<QGraphicsRectItem*>(item)->setPen(pen);
                 }
             }
             void AxisItem::setAxisPen(const QPen& pen)
             {
-                m_axis.setPen(pen);
+                foreach(QGraphicsItem* item , m_axis.childItems()) {
+                       static_cast<QGraphicsLineItem*>(item)->setPen(pen);
+                }
             }
             void AxisItem::setGridPen(const QPen& pen)
             {
                 foreach(QGraphicsItem* item , m_grid.childItems()) {
                     static_cast<QGraphicsLineItem*>(item)->setPen(pen);
                 }
             }
             //TODO "nice numbers algorithm"
             #include "moc_axisitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axisitem_p.h +1 -2

             #ifndef AXISITEM_H_
             #define AXISITEM_H_
             #include "domain_p.h"
             #include "chartitem_p.h"
             #include <QGraphicsItem>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QChartAxis;
             class AxisItem : public QObject, public ChartItem
             {
                 Q_OBJECT
             public:
                 enum AxisType{X_AXIS,Y_AXIS};
                 AxisItem(AxisType type = X_AXIS,QGraphicsItem* parent = 0);
                 ~AxisItem();
                 //from QGraphicsItem
                 QRectF boundingRect() const;
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
                 AxisType axisType() const {return m_type;};
                 void setAxisOpacity(qreal opacity);
                 qreal axisOpacity() const;
                 void setGridOpacity(qreal opacity);
                 qreal gridOpacity() const;
                 void setLabelsOpacity(qreal opacity);
                 qreal labelsOpacity() const;
                 void setShadesOpacity(qreal opacity);
                 qreal shadesOpacity() const;
                 void setLabelsAngle(int angle);
                 int labelsAngle()const { return m_labelsAngle; }
                 void setShadesBrush(const QBrush& brush);
                 void setShadesPen(const QPen& pen);
                 void setAxisPen(const QPen& pen);
                 void setGridPen(const QPen& pen);
                 void setLabelsPen(const QPen& pen);
                 void setLabelsBrush(const QBrush& brush);
                 void setLabelsFont(const QFont& font);
             public slots:
                 void handleAxisUpdate(QChartAxis* axis); //look and feel
                 void handleLabelsChanged(QChartAxis* axis,const QStringList& labels); //labels from dataset
                 void handleGeometryChanged(const QRectF& size); // geometry from presenter
             protected:
                 void updateItem(int count);
             private:
                 void clear();
                 void createItems(int count);
             private:
                 AxisType m_type;
                 QRectF m_rect;
                 int m_labelsAngle;
                 bool m_shadesEnabled;
                 QGraphicsItemGroup m_grid;
                 QGraphicsItemGroup m_shades;
                 QGraphicsItemGroup m_labels;
-                QGraphicsLineItem m_axis;
+                QGraphicsItemGroup m_axis;
                 QStringList m_thicksList;
-                QPointF m_origin;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif /* AXISITEM_H_ */

src/barchart/bar.cpp +1 -1

             #include "bar_p.h"
             #include <QDebug>
             #include <QPainter>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             Bar::Bar(QGraphicsItem *parent)
                 : QGraphicsObject(parent)
             {
                 setAcceptedMouseButtons(Qt::LeftButton);
             }
             void Bar::setSize(const QSizeF& size)
             {
                 mWidth = size.width();
                 mHeight = size.height();
             }
             void Bar::resize( qreal w, qreal h )
             {
                 mWidth = w;
                 mHeight = h;
             }
             void Bar::setColor( QColor col )
             {
                 mColor = col;
             }
             void Bar::setPos(qreal x, qreal y)
             {
                 mXpos = x;
                 mYpos = y;
             }
             void Bar::setPen(QPen pen)
             {
                 mPen = pen;
             }
             void Bar::setBrush(QBrush brush)
             {
                 mBrush = brush;
             }
             void Bar::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 if (0 == mHeight) {
                     return;
                 }
                 painter->setBrush(mBrush);
                 // This compensates for rounding errors. drawRect takes ints and cumulative error of pos + size may be over 1.
                 int x0 = mXpos;
                 int x1 = (mXpos + mWidth);
                 int w = x1-x0;
                 int y0 = mYpos;
                 int y1 = (mYpos + mHeight);
                 int h = y1-y0;
                 painter->drawRect(x0, y0 ,w ,h);
             }
             QRectF Bar::boundingRect() const
             {
-                QRectF r(mXpos, mYpos, mXpos + mWidth, mYpos + mHeight);
+                QRectF r(mXpos, mYpos, mWidth, mHeight);
                 return r;
             }
             void Bar::mousePressEvent(QGraphicsSceneMouseEvent* /*event*/)
             {
                 emit clicked();
             }
             #include "moc_bar_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/barchartmodel.cpp +2 -3

             #include <limits.h>
             #include <QVector>
             #include <QDebug>
             #include "barchartmodel_p.h"
             #include "qbarcategory.h"
             #include "qbarset.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             BarChartModel::BarChartModel(QBarCategory *category, QObject *parent) :
                 QObject(parent)
                 ,mCategory(category)
             {
             }
             BarChartModel::~BarChartModel()
             {
                 delete mCategory;
             }
             QBarCategory& BarChartModel::category()
             {
                 return *mCategory;
             }
             void BarChartModel::addBarSet(QBarSet *set)
             {
                 mDataModel.append(set);
             }
             void BarChartModel::removeBarSet(QBarSet *set)
             {
                 if (mDataModel.contains(set)) {
                     mDataModel.removeOne(set);
                 }
             }
             QBarSet* BarChartModel::nextSet(bool getFirst)
             {
                 if (getFirst) {
                     mCurrentSet = 0;
                 }
                 if ((mDataModel.count() <= 0) || (mDataModel.count() <= mCurrentSet)) {
                     return 0;
                 }
                 QBarSet* set = mDataModel.at(mCurrentSet);
                 mCurrentSet++;
                 return set;
             }
+            QBarSet* BarChartModel::setAt(int index)
-            QBarSet& BarChartModel::setAt(int index)
             {
-                return *mDataModel.at(index);
+                return mDataModel.at(index);
             }
             int BarChartModel::countSets()
             {
                 return mDataModel.count();
             }
             int BarChartModel::countCategories()
             {
                 int count(0);
                 for (int i=0; i<mDataModel.count(); i++){
                     // TODO: can we assume that all series have same number of values? If not. then which values are empty?
                     int temp = mDataModel.at(i)->count();
                     if (temp > count) {
                         count = temp;
                     }
                 }
                 return count;
             }
             int BarChartModel::countTotalItems()
             {
                 int total = mDataModel.count() * countCategories();
                 return total;
             }
             qreal BarChartModel::min()
             {
                 Q_ASSERT(mDataModel.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++) {
                     int itemCount = mDataModel.at(i)->count();
                     for (int j=0; j<itemCount; j++) {
                         qreal temp = mDataModel.at(i)->valueAt(j);
                         if (temp < min) {
                             min = temp;
                         }
                     }
                 }
                 return min;
             }
             qreal BarChartModel::max()
             {
                 Q_ASSERT(mDataModel.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++) {
                     int itemCount = mDataModel.at(i)->count();
                     for (int j=0; j<itemCount; j++) {
                         qreal temp = mDataModel.at(i)->valueAt(j);
                         if (temp > max) {
                             max = temp;
                         }
                     }
                 }
                 return max;
             }
             qreal BarChartModel::valueAt(int set, int category)
             {
                 if ((set < 0) || (set >= mDataModel.count())) {
                     // No set, no value.
                     return 0;
                 } else if ((category < 0) || (category >= mDataModel.at(set)->count())) {
                     // No category, no value.
                     return 0;
                 }
                 return mDataModel.at(set)->valueAt(category);
             }
             qreal BarChartModel::percentageAt(int set, int category)
             {
                 if ((set < 0) || (set >= mDataModel.count())) {
                     // No set, no value.
                     return 0;
                 } else if ((category < 0) || (category >= mDataModel.at(set)->count())) {
                     // No category, no value.
                     return 0;
                 }
                 qreal value = mDataModel.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
                 for (int set = 0; set < count; set++) {
                     if (category < mDataModel.at(set)->count()) {
                         sum += mDataModel.at(set)->valueAt(category);
                     }
                 }
                 return sum;
             }
             qreal BarChartModel::maxCategorySum()
             {
                 qreal max = INT_MIN;
                 int count = countCategories();
                 for (int col=0; col<count; col++) {
                     qreal sum = categorySum(col);
                     if (sum > max) {
                         max = sum;
                     }
                 }
                 return max;
             }
             QString BarChartModel::label(int category)
             {
                 return mCategory->label(category);
             }
             #include "moc_barchartmodel_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/barchartmodel_p.h +1 -2

             #ifndef BARCHARTMODEL_H
             #define BARCHARTMODEL_H
             #include <QObject>
             #include "qchartglobal.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             // Model for bar chart. Internal class.
             // TODO: Implement as QAbstractItemModel?
             class QBarSet;
             class QBarCategory;
             class BarChartModel : public QObject //, public QAbstractItemModel
             {
                 Q_OBJECT
             public:
                 explicit BarChartModel(QBarCategory *category, QObject *parent = 0);
                 ~BarChartModel();
                 QBarCategory& category();
                 void addBarSet(QBarSet *set);
                 void removeBarSet(QBarSet *set);
                 QBarSet* nextSet(bool getFirst);
+                QBarSet *setAt(int index);
-                QBarSet& setAt(int index);  // Internal
                 int countSets();            // Number of sets in model
                 int countCategories();      // Number of categories
                 int countTotalItems();      // Total items in all sets. Includes empty items.
                 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 label(int category);
             signals:
                 void modelUpdated();
             public slots:
             private:
                 QList<QBarSet*> mDataModel;
                 QBarCategory* mCategory;    // Owned
                 int mCurrentSet;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // BARCHARTMODEL_H

src/barchart/barlabel.cpp +1 -1

             #include "barlabel_p.h"
             #include <QPainter>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             BarLabel::BarLabel(QGraphicsItem* parent) : ChartItem(parent)
             {
             }
             void BarLabel::set(QString label)
             {
                 mLabel = label;
             }
             void BarLabel::setPos(qreal x, qreal y)
             {
                 mXpos = x;
                 mYpos = y;
             }
             void BarLabel::setSize(const QSizeF &size)
             {
                 mSize = size;
             }
             void BarLabel::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 painter->drawText(boundingRect(),mLabel);
             }
             QRectF BarLabel::boundingRect() const
             {
-                QRectF r(mXpos, mYpos, mXpos + mSize.width(), mYpos + mSize.height());
+                QRectF r(mXpos, mYpos, mSize.width(), mSize.height());
                 return r;
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/barpresenter.cpp +1 -1

             #include "barpresenter.h"
             #include "bar_p.h"
             #include "barlabel_p.h"
             #include "barvalue_p.h"
             #include "qbarset.h"
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             BarPresenter::BarPresenter(BarChartModel& model, QGraphicsItem *parent) :
                 BarPresenterBase(model,parent)
             {
                 mBarDefaultWidth = 15;
             }
             void BarPresenter::layoutChanged()
             {
                 // Scale bars to new layout
                 // Layout for bars:
                 if (mModel.countSets() <= 0) {
                     qDebug() << "No sets in model!";
                     return;
                 }
                 if (childItems().count() == 0) {
                     qDebug() << "WARNING: BarPresenter::layoutChanged called before graphics items are created!";
                     return;
                 }
                 // TODO: better way to auto-layout?
                 // Use reals for accurancy (we might get some compiler warnings... :)
                 int categoryCount = mModel.countCategories();
                 int setCount = mModel.countSets();
                 qreal tW = mWidth;
                 qreal tH = mHeight;
                 qreal tM = mModel.max();
                 qreal scale = (tH/tM);
                 qreal tC = categoryCount+1;
                 qreal xStepPerSet = (tW/tC);
                 // Scaling.
                 int itemIndex(0);
                 int labelIndex(0);
                 for (int category=0; category < categoryCount; category++) {
                     qreal xPos = xStepPerSet * category + ((tW + mBarDefaultWidth*setCount)/(categoryCount*2));
                     qreal yPos = mHeight;
                     for (int set = 0; set < setCount; set++) {
                         qreal barHeight = mModel.valueAt(set, category) * scale;
                         Bar* bar = mBars.at(itemIndex);
                         // TODO: width settable per bar?
                         bar->resize(mBarDefaultWidth, barHeight);
-                        bar->setBrush(mModel.setAt(set).brush());
+                        bar->setBrush(mModel.setAt(set)->brush());
                         bar->setPos(xPos, yPos-barHeight); // item*posStep+startPos + set * mBarDefaultWidth, mHeight);
                         itemIndex++;
                         xPos += mBarDefaultWidth;
                     }
                     // TODO: Layout for labels, remove magic number
                     xPos = xStepPerSet * category + ((tW + mBarDefaultWidth*setCount)/(categoryCount*2));
                     BarLabel* label = mLabels.at(labelIndex);
                     label->setPos(xPos, mHeight + 20);
                     labelIndex++;
                 }
                 // Position floating values
                 itemIndex = 0;
                 for (int category=0; category < mModel.countCategories(); category++) {
                     qreal xPos = xStepPerSet * category + ((tW + mBarDefaultWidth*setCount)/(categoryCount*2));
                     qreal yPos = mHeight;
                     for (int set=0; set < mModel.countSets(); set++) {
                         qreal barHeight = mModel.valueAt(set,category) * scale;
                         BarValue* value = mFloatingValues.at(itemIndex);
                         // TODO: remove hard coding, apply layout
                         value->resize(100,50);
                         value->setPos(xPos + mBarDefaultWidth/2, yPos-barHeight/2);
                         value->setPen(QPen(QColor(255,255,255,255)));
                         QString vString(QString::number(mModel.valueAt(set,category)));
                         value->setValueString(vString);
                         itemIndex++;
                         xPos += mBarDefaultWidth;
                     }
                 }
                 mLayoutDirty = true;
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/barpresenterbase.cpp +8 -19

             #include "barpresenterbase.h"
             #include "bar_p.h"
             #include "barvalue_p.h"
             #include "barlabel_p.h"
             #include "separator_p.h"
             #include "qbarset.h"
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             BarPresenterBase::BarPresenterBase(BarChartModel& model, QGraphicsItem *parent)
                 : ChartItem(parent)
                 ,mBarDefaultWidth(20) // TODO: remove hard coding, when we have layout code ready
                 ,mLayoutSet(false)
                 ,mLayoutDirty(true)
                 ,mSeparatorsVisible(false)
                 ,mModel(model)
             {
                 dataChanged();
             }
             void BarPresenterBase::setSeparatorsVisible(bool visible)
             {
                 mSeparatorsVisible = visible;
             }
             void BarPresenterBase::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 if (!mLayoutSet) {
                     qDebug() << "BarPresenterBase::paint called without layout set. Aborting.";
                     return;
                 }
             //    if (mLayoutDirty) {
                     // Layout or data has changed. Need to redraw.
                     foreach(QGraphicsItem* i, childItems()) {
                         i->paint(painter,option,widget);
                     }
             //    }
             }
             QRectF BarPresenterBase::boundingRect() const
             {
                 return QRectF(0,0,mWidth,mHeight);
             }
             void BarPresenterBase::setBarWidth( int w )
             {
                 mBarDefaultWidth = w;
             }
             void BarPresenterBase::dataChanged()
             {
                 // TODO: performance optimizations. Do we really need to delete and create items every time data is changed or can we reuse them?
                 qDebug() << "datachanged";
                 // Delete old bars
                 foreach (QGraphicsItem* item, childItems()) {
                     delete item;
                 }
                 mBars.clear();
                 mLabels.clear();
                 mSeparators.clear();
                 mFloatingValues.clear();
                 // Create new graphic items for bars
-                for (int s=0; s<mModel.countSets(); s++) {
+                for (int c=0; c<mModel.countCategories(); c++) {
-                    QBarSet *set = mModel.nextSet(0==s);
+                    for (int s=0; s<mModel.countSets(); s++) {
-                    for (int c=0; c<mModel.countCategories(); c++) {
+                        QBarSet *set = mModel.setAt(s);
                         Bar *bar = new Bar(this);
                         childItems().append(bar);
                         mBars.append(bar);
-                        connect(bar,SIGNAL(clicked()),set,SLOT(toggleFloatingValuesVisible()));
+                        connect(bar,SIGNAL(clicked()),set,SLOT(barClicked()));
                     }
                 }
                 // Create labels
                 int count = mModel.countCategories();
                 for (int i=0; i<count; i++) {
                     BarLabel* label = new BarLabel(this);
                     label->set(mModel.label(i));
                     childItems().append(label);
                     mLabels.append(label);
                 }
                 // Create separators
                 count = mModel.countCategories() - 1;   // There is one less separator than columns
                 for (int i=0; i<count; i++) {
                     Separator* sep = new Separator(this);
                     sep->setColor(QColor(255,0,0,255));     // TODO: color for separations from theme
                     childItems().append(sep);
                     mSeparators.append(sep);
                 }
                 // Create floating values
-                for (int s=0; s<mModel.countSets(); s++) {
+                for (int category=0; category<mModel.countCategories(); category++) {
-                    QBarSet *set = mModel.nextSet(0==s);
+                    for (int s=0; s<mModel.countSets(); s++) {
-                    for (int category=0; category<mModel.countCategories(); category++) {
+                        QBarSet *set = mModel.setAt(s);
                         BarValue *value = new BarValue(*set, this);
                         childItems().append(value);
                         mFloatingValues.append(value);
+                        connect(set,SIGNAL(clicked()),value,SLOT(toggleVisible()));
                     }
-                    connect(set,SIGNAL(setFloatingValuesVisible(QBarSet*)),this,SLOT(setFloatingValues(QBarSet*)));
                 }
                 // TODO: if (autolayout) { layoutChanged() } or something
                 mLayoutDirty = true;
             }
-            void BarPresenterBase::setFloatingValues(QBarSet *set)
-                qDebug() << "BarPresenterBase::setFloatingValues";
-                // TODO: better way to map set to BarValues?
-                for (int i=0; i<mFloatingValues.count(); i++) {
-                    if (mFloatingValues.at(i)->belongsToSet(set)) {
-                        mFloatingValues.at(i)->setVisible(set->isFloatingValuesVisible());
             //handlers
             void BarPresenterBase::handleModelChanged(int index)
             {
             //    qDebug() << "BarPresenterBase::handleModelChanged" << index;
                 dataChanged();
             }
             void BarPresenterBase::handleDomainChanged(const Domain& domain)
             {
             //    qDebug() << "BarPresenterBase::handleDomainChanged";
                 // TODO: Figure out the use case for this.
                 // Affects the size of visible item, so layout is changed.
             //    layoutChanged();
             }
             void BarPresenterBase::handleGeometryChanged(const QRectF& rect)
             {
                 mWidth = rect.width();
                 mHeight = rect.height();
                 layoutChanged();
                 mLayoutSet = true;
                 setPos(rect.topLeft());
             }
             #include "moc_barpresenterbase.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/barpresenterbase.h 0 -3

             #ifndef BARPRESENTERBASE_H
             #define BARPRESENTERBASE_H
             #include "chartitem_p.h"
             #include "barchartmodel_p.h"
             #include <QPen>
             #include <QBrush>
             #include <QGraphicsItem>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class Bar;
             class BarLabel;
             class Separator;
             class BarValue;
             // Common implemantation of different presenters. Not to be instantiated.
             class BarPresenterBase : public QObject, public ChartItem
             {
                 Q_OBJECT
             public:
                 BarPresenterBase(BarChartModel& model, QGraphicsItem *parent = 0);
                 void setSeparatorsVisible(bool visible = true);
             public:
                 // From QGraphicsItem
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
                 QRectF boundingRect() const;
                 // TODO: these may change with layout awarness.
                 void setBarWidth( int w );
                 void setPen(QPen pen);
                 QPen pen();
                 void setBrush(QBrush brush);
                 QBrush brush();
                 // 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
                 virtual void layoutChanged() = 0;   // layout has changed -> need to recalculate bar sizes
-            public Q_SLOTS:
-                void setFloatingValues(QBarSet *set);
             protected slots:
                 void handleModelChanged(int index);
                 void handleDomainChanged(const Domain& domain);
                 void handleGeometryChanged(const QRectF& size);
             protected:
                 // TODO: consider these.
                 int mHeight;        // Layout spesific
                 int mWidth;
                 int mBarDefaultWidth;
                 bool mLayoutSet;    // True, if component has been laid out.
                 bool mLayoutDirty;
                 bool mSeparatorsVisible;
                 BarChartModel& mModel;
                 // Not owned.
                 QList<Bar*> mBars;
                 QList<BarLabel*> mLabels;
                 QList<Separator*> mSeparators;
                 QList<BarValue*> mFloatingValues;
                 QPen mPen;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // BARPRESENTERBASE_H

src/barchart/barvalue.cpp +8 -3

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

src/barchart/barvalue_p.h +6 -2

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

src/barchart/percentbarpresenter.cpp +1 -1

             #include "percentbarpresenter.h"
             #include "bar_p.h"
             #include "barlabel_p.h"
             #include "barvalue_p.h"
             #include "separator_p.h"
             #include "qbarset.h"
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             PercentBarPresenter::PercentBarPresenter(BarChartModel& model, QGraphicsItem *parent) :
                 BarPresenterBase(model, parent)
             {
             }
             void PercentBarPresenter::layoutChanged()
             {
                 // Scale bars to new layout
                 // Layout for bars:
                 if (mModel.countSets() <= 0) {
                     qDebug() << "No sets in model!";
                     // Nothing to do.
                     return;
                 }
                 if (childItems().count() == 0) {
                     qDebug() << "WARNING: PercentBarPresenter::layoutChanged called before graphics items are created!";
                     return;
                 }
                 // TODO: better way to auto-layout
                 // Use reals for accurancy (we might get some compiler warnings... :)
                 int count = mModel.countCategories();
                 int itemIndex(0);
                 int labelIndex(0);
                 qreal tW = mWidth;
                 qreal tC = count+1;
                 qreal xStep = (tW/tC);
                 qreal xPos = ((tW/tC) - mBarDefaultWidth / 2);
                 qreal h = mHeight;
                 for (int category = 0; category < mModel.countCategories(); category++) {
                     qreal colSum = mModel.categorySum(category);
                     qreal scale = (h / colSum);
                     qreal yPos = h;
                     for (int set=0; set < mModel.countSets(); set++) {
                         qreal barHeight = mModel.valueAt(set, category) * scale;
                         Bar* bar = mBars.at(itemIndex);
                         // TODO: width settable per bar?
                         bar->resize(mBarDefaultWidth, barHeight);
-                        bar->setBrush(mModel.setAt(set).brush());
+                        bar->setBrush(mModel.setAt(set)->brush());
                         bar->setPos(xPos, yPos-barHeight);
                         itemIndex++;
                         yPos -= barHeight;
                     }
                     // TODO: Layout for labels, remove magic number
                     BarLabel* label = mLabels.at(labelIndex);
                     label->setPos(xPos, mHeight + 20);
                     labelIndex++;
                     xPos += xStep;
                 }
                 // Position separators
                 xPos = xStep + xStep/2;
                 for (int s=0; s < mModel.countCategories() - 1; s++) {
                     Separator* sep = mSeparators.at(s);
                     sep->setPos(xPos,0);
                     sep->setSize(QSizeF(1,mHeight));
                     xPos += xStep;
                 }
                 // Position floating values
                 itemIndex = 0;
                 xPos = ((tW/tC) - mBarDefaultWidth / 2);
                 for (int category=0; category < mModel.countCategories(); category++) {
                     qreal yPos = h;
                     qreal colSum = mModel.categorySum(category);
                     qreal scale = (h / colSum);
                     for (int set=0; set < mModel.countSets(); set++) {
                         qreal barHeight = mModel.valueAt(set,category) * scale;
                         BarValue* value = mFloatingValues.at(itemIndex);
                         // TODO: remove hard coding, apply layout
                         value->setPos(xPos + mBarDefaultWidth/2, yPos-barHeight/2);
                         value->setPen(QPen(QColor(255,255,255,255)));
                         QString vString(QString::number(mModel.percentageAt(set,category) * 100));
                         vString.append("%");
                         value->setValueString(vString);
                         itemIndex++;
                         yPos -= barHeight;
                     }
                     xPos += xStep;
                 }
                 mLayoutDirty = true;
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/qbarset.cpp +1 -14

             #include "qbarset.h"
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             QBarSet::QBarSet()
             {
                 mFloatingValuesVisible = false;
             }
             void QBarSet::setName(QString name)
             {
                 mName = name;
             }
             QString QBarSet::name()
             {
                 return mName;
             }
             QBarSet& QBarSet::operator << (const qreal &value)
             {
                 mValues.append(value);
                 return *this;
             }
             int QBarSet::count()
             {
                 return mValues.count();
             }
             qreal QBarSet::valueAt(int index)
             {
                 return mValues.at(index);
             }
             void QBarSet::setValue(int index, qreal value)
             {
                 mValues.replace(index,value);
             }
             void QBarSet::setPen(const QPen& pen)
             {
                 mPen = pen;
             }
             const QPen& QBarSet::pen() const
             {
                 return mPen;
             }
             void QBarSet::setBrush(const QBrush& brush)
             {
                 mBrush = brush;
             }
             const QBrush& QBarSet::brush() const
             {
                 return mBrush;
             }
             bool QBarSet::isFloatingValuesVisible()
             {
                 return mFloatingValuesVisible;
             }
             void QBarSet::barClicked()
             {
-                qDebug() << "QBarset::barClicked";
+                qDebug() << "QBarset::barClicked" << this;
                 // Some bar of this set has been clicked
                 // TODO: What happens then?
                 emit clicked();     // Notify that set has been clicked
             }
-            void QBarSet::toggleFloatingValuesVisible()
-                qDebug() << "QBarset::toggleFloatingValuesVisible";
-                // TODO: toggle vs explicit set?
-                if (mFloatingValuesVisible) {
-                    mFloatingValuesVisible=false;
-                } else {
-                    mFloatingValuesVisible=true;
-                emit setFloatingValuesVisible(this);
             #include "moc_qbarset.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/qbarset.h 0 -2

             #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();
                 void setName(QString name);
                 QString name();
                 QBarSet& operator << (const qreal &value);  // appends new value to set
                 int count();                                // count of values in set
                 qreal valueAt(int index);                   // for modifying individual values
                 void setValue(int index, qreal value);      //
                 void setPen(const QPen& pen);
                 const QPen& pen() const;
                 void setBrush(const QBrush& brush);
                 const QBrush& brush() const;
                 bool isFloatingValuesVisible();
             Q_SIGNALS:
                 void clicked();
-                void setFloatingValuesVisible(QBarSet* set);
             /*
                 void hoverEnter();
                 void hoverLeave();
             */
             public Q_SLOTS:
                 void barClicked();
-                void toggleFloatingValuesVisible();
             private:
                 QString mName;
                 QList<qreal> mValues;
                 QPen mPen;
                 QBrush mBrush;
                 bool mFloatingValuesVisible;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QBARSET_H

src/barchart/stackedbarpresenter.cpp +1 -1

             #include "stackedbarpresenter.h"
             #include "bar_p.h"
             #include "barlabel_p.h"
             #include "barvalue_p.h"
             #include "separator_p.h"
             #include "qbarset.h"
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             StackedBarPresenter::StackedBarPresenter(BarChartModel& model, QGraphicsItem *parent) :
                 BarPresenterBase(model,parent)
             {
             }
             void StackedBarPresenter::layoutChanged()
             {
                 // Scale bars to new layout
                 // Layout for bars:
                 if (mModel.countSets() <= 0) {
                     qDebug() << "No sets in model!";
                     // Nothing to do.
                     return;
                 }
                 if (mModel.countCategories() == 0) {
                     qDebug() << "No categories in model!";
                     // Nothing to do
                     return;
                 }
                 if (childItems().count() == 0) {
                     qDebug() << "WARNING: StackedBarPresenter::layoutChanged called before graphics items are created!";
                     return;
                 }
                 // TODO: better way to auto-layout
                 // Use reals for accurancy (we might get some compiler warnings... :)
                 // TODO: use temp variable for category count...
                 qreal maxSum = mModel.maxCategorySum();
                 qreal h = mHeight;
                 qreal scale = (h / maxSum);
                 int itemIndex(0);
                 int labelIndex(0);
                 qreal tW = mWidth;
                 qreal tC = mModel.countCategories() + 1;
                 qreal xStep = (tW/tC);
                 qreal xPos = ((tW/tC) - mBarDefaultWidth / 2);
                 for (int category = 0; category < mModel.countCategories(); category++) {
                     qreal yPos = h;
                     for (int set=0; set < mModel.countSets(); set++) {
                         qreal barHeight = mModel.valueAt(set, category) * scale;
                         Bar* bar = mBars.at(itemIndex);
                         bar->resize(mBarDefaultWidth, barHeight);
-                        bar->setBrush(mModel.setAt(set).brush());
+                        bar->setBrush(mModel.setAt(set)->brush());
                         bar->setPos(xPos, yPos-barHeight);
                         itemIndex++;
                         yPos -= barHeight;
                     }
                     // TODO: Layout for labels, remove magic number
                     BarLabel* label = mLabels.at(labelIndex);
                     label->setPos(xPos, mHeight + 20);
                     labelIndex++;
                     xPos += xStep;
                 }
                 // Position separators
                 xPos = xStep + xStep/2;
                 for (int s=0; s < mModel.countCategories() - 1; s++) {
                     Separator* sep = mSeparators.at(s);
                     sep->setPos(xPos,0);
                     sep->setSize(QSizeF(1,mHeight));
                     xPos += xStep;
                 }
                 // Position floating values
                 itemIndex = 0;
                 xPos = ((tW/tC) - mBarDefaultWidth / 2);
                 for (int category=0; category < mModel.countCategories(); category++) {
                     qreal yPos = h;
                     for (int set=0; set < mModel.countSets(); set++) {
                         qreal barHeight = mModel.valueAt(set,category) * scale;
                         BarValue* value = mFloatingValues.at(itemIndex);
                         // TODO: remove hard coding, apply layout
                         value->resize(100,50);
                         value->setPos(xPos + mBarDefaultWidth/2, yPos-barHeight/2);
                         value->setPen(QPen(QColor(255,255,255,255)));
                         QString vString(QString::number(mModel.valueAt(set,category)));
                         value->setValueString(vString);
                         itemIndex++;
                         yPos -= barHeight;
                     }
                     xPos += xStep;
                 }
                 mLayoutDirty = true;
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/qchart.cpp +1 0

             #include "qchart.h"
             #include "qchartaxis.h"
             #include "chartpresenter_p.h"
             #include "chartdataset_p.h"
             #include <QGraphicsScene>
             #include <QGraphicsSceneResizeEvent>
             #include <QDebug>
             /*!
                 \class QChart
                 \brief QtCommercial chart API.
                 QChart is a QGraphicsWidget that you can show in a QGraphicsScene. It manages the graphical
                 representation of different types of QChartSeries and other chart related objects like
                 QChartAxis and QChartLegend. If you simply want to show a chart in a layout, you can use the
                 convenience class QChartView instead of QChart.
                 \sa QChartView
             */
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 Constructs a chart object which is a child of parent.
             */
             QChart::QChart(QGraphicsItem *parent, Qt::WindowFlags wFlags) : QGraphicsWidget(parent,wFlags),
                 m_backgroundItem(0),
                 m_titleItem(0),
                 m_dataset(new ChartDataSet(this)),
                 m_presenter(new ChartPresenter(this,m_dataset))
             {
             }
             /*!
                 Destroys the object and it's children, like QChartSeries and QChartAxis object added to it.
             */
             QChart::~QChart()
             {
             }
             /*!
                 Adds the series and optional y axis onto the chart and takes the ownership of the objects.
                 If auto scaling is enabled, re-scales the axes the series is bound to (both the x axis and
                 the y axis).
             */
             void QChart::addSeries(QChartSeries* series, QChartAxis* axisY)
             {
                 m_dataset->addSeries(series, axisY);
             }
             /*!
                 Removes the QChartSeries specified in a perameter from the QChartView.
                 It releses its ownership of the specified QChartSeries object.
                 It does not delete the pointed QChartSeries data object
                 \sa removeSeries(), removeAllSeries()
             */
             void QChart::removeSeries(QChartSeries* series)
             {
                 m_dataset->removeSeries(series);
             }
             /*!
                 Removes all the QChartSeries that have been added to the QChartView
                 It also deletes the pointed QChartSeries data objects
                 \sa addSeries(), removeSeries()
             */
             void QChart::removeAllSeries()
             {
                 m_dataset->removeAllSeries();
             }
             void QChart::setChartBackgroundBrush(const QBrush& brush)
             {
                 createChartBackgroundItem();
                 m_backgroundItem->setBrush(brush);
                 m_backgroundItem->update();
             }
             void QChart::setChartBackgroundPen(const QPen& pen)
             {
                 createChartBackgroundItem();
                 m_backgroundItem->setPen(pen);
                 m_backgroundItem->update();
             }
             /*!
                 Sets the title description text that is rendered above the chart.
             */
             void QChart::setChartTitle(const QString& title)
             {
                 createChartTitleItem();
                 m_titleItem->setPlainText(title);
             }
             /*!
                 Sets the font that is used for rendering the description text that is rendered above the chart.
             */
             void QChart::setChartTitleFont(const QFont& font)
             {
                 createChartTitleItem();
                 m_titleItem->setFont(font);
             }
             void QChart::createChartBackgroundItem()
             {
                 if(!m_backgroundItem) {
                     m_backgroundItem = new QGraphicsRectItem(this);
+                    m_backgroundItem->setPen(Qt::NoPen);
                     m_backgroundItem->setZValue(ChartPresenter::BackgroundZValue);
                 }
             }
             void QChart::createChartTitleItem()
             {
                 if(!m_titleItem) {
                     m_titleItem = new QGraphicsTextItem(this);
                     m_titleItem->setZValue(ChartPresenter::BackgroundZValue);
                 }
             }
             int QChart::margin() const
             {
                 return m_presenter->margin();
             }
             void QChart::setMargin(int margin)
             {
                 m_presenter->setMargin(margin);
             }
             void QChart::setChartTheme(QChart::ChartTheme theme)
             {
                 m_presenter->setChartTheme(theme);
             }
             QChart::ChartTheme QChart::chartTheme() const
             {
                 return m_presenter->chartTheme();
             }
             void QChart::zoomIn()
             {
                 if (!m_dataset->nextDomain()) {
                     QRectF rect = m_presenter->geometry();
                     rect.setWidth(rect.width()/2);
                     rect.setHeight(rect.height()/2);
                     rect.moveCenter(m_presenter->geometry().center());
                     zoomIn(rect);
                 }
             }
             void QChart::zoomIn(const QRectF& rect)
             {
                 if(!rect.isValid()) return;
                    QRectF r = rect.normalized();
                    int margin = m_presenter->margin();
                    r.translate(-margin, -margin);
                    m_dataset->addDomain(r,m_presenter->geometry());
             }
             void QChart::zoomOut()
             {
                 m_dataset->previousDomain();
             }
             void QChart::zoomReset()
             {
                 m_dataset->clearDomains();
             }
             QChartAxis* QChart::axisX() const
             {
                 return m_dataset->axisX();
             }
             QChartAxis* QChart::axisY() const
             {
                 return m_dataset->axisY();
             }
             void QChart::resizeEvent(QGraphicsSceneResizeEvent *event)
             {
                 m_rect = QRectF(QPoint(0,0),event->newSize());
                 QRectF rect = m_rect.adjusted(margin(),margin(), -margin(), -margin());
                 // recalculate title position
                 if (m_titleItem) {
                     QPointF center = m_rect.center() -m_titleItem->boundingRect().center();
                     m_titleItem->setPos(center.x(),m_rect.top()/2 + margin()/2);
                 }
                 //recalculate background gradient
                 if (m_backgroundItem) {
                     m_backgroundItem->setRect(rect);
                 }
                 QGraphicsWidget::resizeEvent(event);
                 update();
             }
             #include "moc_qchart.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages