HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r438:c46e1ae6bddd

updating drilldown example. Needs some more thinking

sauimone -

r438:c46e1ae6bddd

parent child

Context file:

r438:c46e1ae6bddd

Collapse all files

example/stackedbarchartdrilldown/main.cpp +56 -25

             #include <QtGui/QApplication>
             #include <QMainWindow>
             #include <qchartglobal.h>
             #include <qchartview.h>
             #include <qstackedbarseries.h>
             #include <qbarset.h>
             #include <qchartaxis.h>
             #include <QStringList>
             #include <QDebug>
             QTCOMMERCIALCHART_USE_NAMESPACE
             //! [1]
             class DrilldownBarSeries : public QStackedBarSeries
             {
                 Q_OBJECT
             public:
                 DrilldownBarSeries(QStringList categories, QObject* parent = 0) : QStackedBarSeries(categories,parent) {}
-            /*
             public Q_SLOTS:
                 void handleRightClick(QBarSet *barset, QString category)
                 {
+                    qDebug() << "DrilldownBarSeries::handleRightClick" << barset->name() << category;
+            //        mChart->changeSeries(this);
                 }
-            */
             };
             //! [1]
             //! [2]
             class DrilldownBarSet : public QBarSet
             {
                 Q_OBJECT
             public:
-                DrilldownBarSet(QString name, DrilldownBarSeries *parent) : QBarSet(name, parent), mSeries(parent) {}
+                DrilldownBarSet(QString name, DrilldownBarSeries* drilldownSeries) : QBarSet(name) , mSeries(drilldownSeries) {}
-                DrilldownBarSeries* drilldownSeries() { return mSeries; }
+                DrilldownBarSeries* drilldownSeries(QString category)
+                    {
+                    return mSeries;
+                    }
             private:
                 DrilldownBarSeries* mSeries;
             };
             //! [2]
             //! [3]
             class DrilldownChart : public QChartView
             {
                 Q_OBJECT
             public:
                 explicit DrilldownChart(QWidget *parent = 0) : QChartView(parent), m_currentSeries(0) {}
                 void changeSeries(QSeries* series)
                 {
                     if (m_currentSeries)
                         removeSeries(m_currentSeries);
                     m_currentSeries = series;
                     addSeries(series);
                     setChartTitle(series->title());
                 }
             public Q_SLOTS:
                 void  handleRightClick(QBarSet *barset, QString category)
                 {
                     qDebug() << "DrilldownChart::handleRightClick" << barset->name() << category;
                     // TODO: continue from here
-            //        DrilldownBarSet* drilldownBarSet = static_cast<DrilldownBarSet*>(barset);
+                    DrilldownBarSet* drilldownBarSet = static_cast<DrilldownBarSet*>(barset);
-            //        changeSeries(drilldownBarSet->drilldownSeries());
+                    changeSeries(drilldownBarSet->drilldownSeries(category));
                 }
             private:
                 QSeries* m_currentSeries;
             };
             //! [3]
             int main(int argc, char *argv[])
             {
                 QApplication a(argc, argv);
                 QMainWindow window;
                 DrilldownChart* drilldownChart =  new DrilldownChart(&window);
                 drilldownChart->setChartTheme(QChart::ChartThemeIcy);
-                //! [1]
+                //! [4]
                 // Define categories
                 QStringList months;
-                months << "Jun" << "Jul" << "Aug" << "Oct";
+                months << "Jun" << "Jul" << "Aug" << "Sep";
                 QStringList weeks;
                 weeks << "week 1" << "week 2" << "week 3" << "week 4";
                 QStringList plants;
                 plants << "Habanero" << "Lemon Drop" << "Starfish" << "Aji Amarillo";
-                //! [1]
+                //! [4]
-                DrilldownBarSeries* seasonSeries = new DrilldownBarSeries(months, drilldownChart);
+                DrilldownBarSeries* monthlySeries = new DrilldownBarSeries(months, drilldownChart);
-                seasonSeries->setTitle("Crop by month - Season");
+                monthlySeries->setTitle("Crop by month - Season");
                 foreach (QString plant, plants) {
-                    DrilldownBarSet *seasonCrop = new DrilldownBarSet(plant, seasonSeries);
+                    DrilldownBarSeries* weeklySeries = new DrilldownBarSeries(weeks, drilldownChart);
+                    DrilldownBarSet* monthlyCrop = new DrilldownBarSet(plant,weeklySeries);
+                    weeklySeries->setTitle("Crop by week - Month");
                     foreach(QString month, months) {
-                        DrilldownBarSeries* monthSeries = new DrilldownBarSeries(weeks, drilldownChart);
+                        DrilldownBarSet* weeklyCrop = new DrilldownBarSet(plant,monthlySeries);
-                        DrilldownBarSet *monthCrop = new DrilldownBarSet(plant, monthSeries);
                         foreach (QString week, weeks ) {
-                            *monthCrop << (qrand() % 20);
+                            *weeklyCrop << (qrand() % 20);
-                        monthSeries->addBarSet(monthCrop);
-                        *seasonCrop << monthCrop->valueAt(plants.indexOf(plant));
                         }
-                    // We want floating values!
+                        weeklySeries->addBarSet(weeklyCrop);
-                    QObject::connect(seasonCrop,SIGNAL(clicked(QString)),seasonCrop,SIGNAL(toggleFloatingValues()));
+                        weeklySeries->setToolTipEnabled(true);
-                    seasonSeries->addBarSet(seasonCrop);
+                        *monthlyCrop << weeklyCrop->total();
+                        QObject::connect(weeklyCrop,SIGNAL(clicked(QString)),weeklyCrop,SIGNAL(toggleFloatingValues()));
+                        QObject::connect(weeklySeries,SIGNAL(rightClicked(QBarSet*,QString)),drilldownChart,SLOT(handleRightClick(QBarSet*,QString)));
                     }
-                QObject::connect(seasonSeries,SIGNAL(rightClicked(QBarSet*,QString)),drilldownChart,SLOT(handleRightClick(QBarSet*,QString)));
+                    QObject::connect(monthlyCrop,SIGNAL(clicked(QString)),monthlyCrop,SIGNAL(toggleFloatingValues()));
+                    monthlySeries->addBarSet(monthlyCrop);
+                }
-                seasonSeries->setToolTipEnabled(true);
+            /*
+                foreach (QString plant, plants) {
+                    DrilldownBarSeries* weeklySeries = new DrilldownBarSeries(weeks, drilldownChart);
+                    DrilldownBarSet* monthlyCrop = new DrilldownBarSet(plant,weeklySeries);
+                    weeklySeries->setTitle("Crop by week - Month");
+                    foreach(QString month, months) {
+                        DrilldownBarSet* weeklyCrop = new DrilldownBarSet(plant,monthlySeries);
+                        foreach (QString week, weeks ) {
+                            *weeklyCrop << (qrand() % 20);
+                        }
+                        weeklySeries->addBarSet(weeklyCrop);
+                        weeklySeries->setToolTipEnabled(true);
+                        *monthlyCrop << weeklyCrop->total();
+                        QObject::connect(weeklyCrop,SIGNAL(clicked(QString)),weeklyCrop,SIGNAL(toggleFloatingValues()));
+                        QObject::connect(weeklySeries,SIGNAL(rightClicked(QBarSet*,QString)),drilldownChart,SLOT(handleRightClick(QBarSet*,QString)));
+                    }
+                    QObject::connect(monthlyCrop,SIGNAL(clicked(QString)),monthlyCrop,SIGNAL(toggleFloatingValues()));
+                    monthlySeries->addBarSet(monthlyCrop);
+                }
+            */
+                QObject::connect(monthlySeries,SIGNAL(rightClicked(QBarSet*,QString)),drilldownChart,SLOT(handleRightClick(QBarSet*,QString)));
-                drilldownChart->addSeries(seasonSeries);
+                monthlySeries->setToolTipEnabled(true);
+                drilldownChart->changeSeries(monthlySeries);
+                drilldownChart->setChartTitle(monthlySeries->title());
                 drilldownChart->axisX()->setAxisVisible(false);
                 drilldownChart->axisX()->setGridVisible(false);
                 drilldownChart->axisX()->setLabelsVisible(false);
                 window.setCentralWidget(drilldownChart);
                 window.resize(400, 300);
                 window.show();
                 return a.exec();
             }
             #include "main.moc"

src/barchart/barpresenterbase.cpp 0 -1

             #include "barpresenterbase_p.h"
             #include "bar_p.h"
             #include "barvalue_p.h"
             #include "barlabel_p.h"
             #include "separator_p.h"
             #include "qbarset.h"
             #include "qbarseries.h"
             #include <QDebug>
             #include <QToolTip>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             BarPresenterBase::BarPresenterBase(QBarSeries *series, QGraphicsItem *parent)
                 : ChartItem(parent)
                 ,mBarDefaultWidth(20) // TODO: remove hard coding, when we have layout code ready
                 ,mLayoutSet(false)
                 ,mLayoutDirty(true)
                 ,mSeparatorsEnabled(false)
                 ,mSeries(series)
             {
                 connect(series,SIGNAL(showToolTip(QPoint,QString)),this,SLOT(showToolTip(QPoint,QString)));
             //    connect(series,SIGNAL(separatorsEnabled(bool)),this,SLOT(enableSeparators(bool)));
                 dataChanged();
             }
             BarPresenterBase::~BarPresenterBase()
             {
                 disconnect(this,SLOT(showToolTip(QPoint,QString)));
-                delete mSeries;
             }
             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 c=0; c<mSeries->categoryCount(); c++) {
                     QString category = mSeries->categoryName(c);
                     for (int s=0; s<mSeries->barsetCount(); s++) {
                         QBarSet *set = mSeries->barsetAt(s);
                         Bar *bar = new Bar(category,this);
                         childItems().append(bar);
                         mBars.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()));
                     }
                 }
                 // Create labels
                 int count = mSeries->categoryCount();
                 for (int i=0; i<count; i++) {
                     BarLabel* label = new BarLabel(this);
                     label->set(mSeries->categoryName(i));
                     childItems().append(label);
                     mLabels.append(label);
                 }
                 // Create separators
                 count = mSeries->categoryCount() - 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
                     sep->setVisible(mSeparatorsEnabled);
                     childItems().append(sep);
                     mSeparators.append(sep);
                 }
                 // Create floating values
                 for (int category=0; category<mSeries->categoryCount(); category++) {
                     for (int s=0; s<mSeries->barsetCount(); s++) {
                         QBarSet *set = mSeries->barsetAt(s);
                         BarValue *value = new BarValue(*set, this);
                         childItems().append(value);
                         mFloatingValues.append(value);
                         connect(set,SIGNAL(toggleFloatingValues()),value,SLOT(toggleVisible()));
                     }
                 }
                 // TODO: if (autolayout) { layoutChanged() } or something
                 mLayoutDirty = true;
             }
             //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());
             }
             void BarPresenterBase::showToolTip(QPoint pos, QString tip)
             {
                 // TODO: cool tooltip instead of default
                 QToolTip::showText(pos,tip);
             }
             void BarPresenterBase::enableSeparators(bool enabled)
             {
                 for (int i=0; i<mSeparators.count(); i++) {
                     mSeparators.at(i)->setVisible(enabled);
                 }
                 mSeparatorsEnabled = enabled;
             }
             #include "moc_barpresenterbase_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/barpresenterbase_p.h +1 -1

             #ifndef BARPRESENTERBASE_H
             #define BARPRESENTERBASE_H
             #include "chartitem_p.h"
             #include "qbarseries.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.
             // TODO: combine this with BarPresenter and derive other presenters from it?
             class BarPresenterBase : public QObject, public ChartItem
             {
                 Q_OBJECT
             public:
                 BarPresenterBase(QBarSeries *series, QGraphicsItem *parent = 0);
-                ~BarPresenterBase();
+                virtual ~BarPresenterBase();
             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 );
                 // 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 slots:
                 void handleModelChanged(int index);
                 void handleDomainChanged(const Domain& domain);
                 void handleGeometryChanged(const QRectF& size);
                 // Internal slots
                 void showToolTip(QPoint pos, QString tip);      // shows tooltip (if enabled)
                 void enableSeparators(bool enabled);
             protected:
                 // TODO: consider these.
                 int mHeight;        // Layout spesific
                 int mWidth;
                 int mBarDefaultWidth;
                 bool mLayoutSet;    // True, if component has been laid out.
                 bool mLayoutDirty;
                 bool mSeparatorsEnabled;
                 // Owned
                 QBarSeries* mSeries;
                 // Not owned.
                 QList<Bar*> mBars;
                 QList<BarLabel*> mLabels;
                 QList<Separator*> mSeparators;
                 QList<BarValue*> mFloatingValues;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // BARPRESENTERBASE_H

src/barchart/qbarset.cpp +10 0

             #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)
             {
             }
             /*!
                 Sets new \a name for set.
             */
             void QBarSet::setName(QString name)
             {
                 mName = name;
             }
             /*!
                 Returns name of the set.
             */
             QString QBarSet::name()
             {
                 return mName;
             }
             /*!
                 Appends new value \a value to the end of set.
             */
             QBarSet& QBarSet::operator << (const qreal &value)
             {
                 mValues.append(value);
                 return *this;
             }
             /*!
                 Returns count of values in set.
             */
             int QBarSet::count()
             {
                 return mValues.count();
             }
             /*!
                 Returns value of set indexed by \a index
             */
             qreal QBarSet::valueAt(int index)
             {
                 return mValues.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);
             }
+            qreal QBarSet::total()
+            {
+                qreal total(0);
+                for (int i=0; i<mValues.count(); i++) {
+                    total += mValues.at(i);
+                }
+                return total;
+            }
             /*!
                 Sets pen for set. Bars of this set are drawn using \a pen
             */
             void QBarSet::setPen(QPen pen)
             {
                 mPen = pen;
             }
             /*!
                 Returns pen of the set.
             */
             QPen QBarSet::pen()
             {
                 return mPen;
             }
             /*!
                 Sets brush for the set. Bars of this set are drawn using \a brush
             */
             void QBarSet::setBrush(QBrush brush)
             {
                 mBrush = brush;
             }
             /*!
                 Returns brush of the set.
             */
             QBrush QBarSet::brush()
             {
                 return mBrush;
             }
             /*!
                 \internal \a pos
             */
             void QBarSet::barHoverEnterEvent(QPoint pos)
             {
                 emit showToolTip(pos, mName);
                 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 +1 0

             #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
                 // 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(QPen pen);
                 QPen pen();
                 void setBrush(QBrush brush);
                 QBrush brush();
             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 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;
                 QList<qreal> mValues;   // TODO: replace with map (category, value)
                 QMap<QString,qreal> mMappedValues;
                 QPen mPen;
                 QBrush mBrush;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QBARSET_H

src/barchart/stackedbarpresenter.cpp +6 0

             #include "stackedbarpresenter_p.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(QBarSeries *series, QGraphicsItem *parent) :
                 BarPresenterBase(series,parent)
             {
             }
+            StackedBarPresenter::~StackedBarPresenter()
+            {
+                qDebug() << "StackedBarPresenter deleted";
+            }
             void StackedBarPresenter::layoutChanged()
             {
                 // Scale bars to new layout
                 // Layout for bars:
                 if (mSeries->barsetCount() <= 0) {
                     qDebug() << "No sets in model!";
                     // Nothing to do.
                     return;
                 }
                 if (mSeries->categoryCount() == 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 = mSeries->maxCategorySum();
                 qreal h = mHeight;
                 qreal scale = (h / maxSum);
                 int itemIndex(0);
                 int labelIndex(0);
                 qreal tW = mWidth;
                 qreal tC = mSeries->categoryCount() + 1;
                 qreal xStep = (tW/tC);
                 qreal xPos = ((tW/tC) - mBarDefaultWidth / 2);
                 for (int category = 0; category < mSeries->categoryCount(); category++) {
                     qreal yPos = h;
                     for (int set=0; set < mSeries->barsetCount(); set++) {
                         qreal barHeight = mSeries->valueAt(set, category) * scale;
                         Bar* bar = mBars.at(itemIndex);
                         bar->resize(mBarDefaultWidth, barHeight);
                         bar->setBrush(mSeries->barsetAt(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 < mSeries->categoryCount() - 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 < mSeries->categoryCount(); category++) {
                     qreal yPos = h;
                     for (int set=0; set < mSeries->barsetCount(); set++) {
                         qreal barHeight = mSeries->valueAt(set,category) * scale;
                         BarValue* value = mFloatingValues.at(itemIndex);
                         // TODO: remove hard coding, apply layout
                         value->resize(100,50);
                         value->setPos(xPos, yPos-barHeight/2);
                         value->setPen(QPen(QColor(255,255,255,255)));
                         if (mSeries->valueAt(set,category) != 0) {
                             value->setValueString(QString::number(mSeries->valueAt(set,category)));
                         } else {
                             value->setValueString(QString(""));
                         }
                         itemIndex++;
                         yPos -= barHeight;
                     }
                     xPos += xStep;
                 }
                 mLayoutDirty = true;
             }
             #include "moc_stackedbarpresenter_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/stackedbarpresenter_p.h +1 0

             #ifndef STACKEDBARPRESENTER_H
             #define STACKEDBARPRESENTER_H
             #include "barpresenterbase_p.h"
             #include "qstackedbarseries.h"
             #include <QGraphicsItem>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class StackedBarPresenter : public BarPresenterBase
             {
                 Q_OBJECT
             public:
                 StackedBarPresenter(QBarSeries *series, QGraphicsItem *parent = 0);
+                ~StackedBarPresenter();
             private:
                 // From BarPresenterBase
                 void layoutChanged();   // layout has changed -> need to recalculate bar sizes
             private:
                 // Data
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // STACKEDBARPRESENTER_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