HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r487:03622a1338c4

Labels for barchart to axis

sauimone -

r487:03622a1338c4

parent child

Context file:

r487:03622a1338c4

Collapse all files

examples/stackedbarchartdrilldown/main.cpp +2 -2

             #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) {}
                 void mapDrilldownSeries(QString category, DrilldownBarSeries* drilldownSeries)
                 {
                     mDrilldownSeries[category] = drilldownSeries;
                 }
                 DrilldownBarSeries* drilldownSeries(QString category)
                 {
                     return mDrilldownSeries[category];
                 }
             public Q_SLOTS:
             private:
                 QMap<QString, DrilldownBarSeries*> mDrilldownSeries;
             };
             //! [1]
             //! [2]
             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;
                     DrilldownBarSeries* series = static_cast<DrilldownBarSeries*> (sender());
                     changeSeries(series->drilldownSeries(category));
                 }
             private:
                 QSeries* m_currentSeries;
             };
             //! [2]
             int main(int argc, char *argv[])
             {
                 QApplication a(argc, argv);
                 QMainWindow window;
                 DrilldownChart* drilldownChart =  new DrilldownChart(&window);
                 drilldownChart->setChartTheme(QChart::ChartThemeIcy);
                 //! [3]
                 // Define categories
                 QStringList months;
                 months << "May" << "Jun" << "Jul" << "Aug" << "Sep";
                 QStringList weeks;
                 weeks << "week 1" << "week 2" << "week 3" << "week 4";
                 QStringList plants;
                 plants << "Habanero" << "Lemon Drop" << "Starfish" << "Aji Amarillo";
                 //! [3]
                 //! [4]
                 // Create drilldown structure
                 DrilldownBarSeries* seasonSeries = new DrilldownBarSeries(months, drilldownChart);
                 seasonSeries->setTitle("Crop by month - Season");
                 // Each month in season series has drilldown series for weekly data
                 foreach (QString month, months) {
                     // Create drilldown series for every week
                     DrilldownBarSeries* weeklySeries = new DrilldownBarSeries(weeks, drilldownChart);
                     seasonSeries->mapDrilldownSeries(month, weeklySeries);
                     // Drilling down from weekly data brings us back to season data.
                     foreach (QString week, weeks) {
                         weeklySeries->mapDrilldownSeries(week, seasonSeries);
                         weeklySeries->setTitle(QString("Crop by week - " + month));
                     }
                     // Use right click signal to implement drilldown
                     QObject::connect(weeklySeries,SIGNAL(rightClicked(QBarSet*,QString)),drilldownChart,SLOT(handleRightClick(QBarSet*,QString)));
                 }
                 // Enable drilldown from season series using right click.
                 QObject::connect(seasonSeries,SIGNAL(rightClicked(QBarSet*,QString)),drilldownChart,SLOT(handleRightClick(QBarSet*,QString)));
                 //! [4]
                 //! [5]
                 // Fill monthly and weekly series with data
                 foreach (QString plant, plants) {
                     QBarSet* monthlyCrop = new QBarSet(plant);
                     foreach (QString month, months) {
                         QBarSet* weeklyCrop = new QBarSet(plant);
                         foreach (QString week, weeks ) {
                             *weeklyCrop << (qrand() % 20);
                         }
                         // Get the drilldown series from season series and add crop to it.
                         seasonSeries->drilldownSeries(month)->addBarSet(weeklyCrop);
                         seasonSeries->drilldownSeries(month)->setToolTipEnabled(true);
                         *monthlyCrop << weeklyCrop->total();
                         QObject::connect(weeklyCrop,SIGNAL(clicked(QString)),weeklyCrop,SIGNAL(toggleFloatingValues()));
                     }
                     seasonSeries->addBarSet(monthlyCrop);
                     QObject::connect(monthlyCrop,SIGNAL(clicked(QString)),monthlyCrop,SIGNAL(toggleFloatingValues()));
                 }
                 //! [5]
                 seasonSeries->setToolTipEnabled(true);
                 //! [6]
                 // Show season series in initial view
                 drilldownChart->changeSeries(seasonSeries);
                 drilldownChart->setChartTitle(seasonSeries->title());
                 //! [6]
                 // Disable axis, since they don't really apply to bar chart
-                drilldownChart->axisX()->setAxisVisible(false);
+            //    drilldownChart->axisX()->setAxisVisible(false);
                 drilldownChart->axisX()->setGridVisible(false);
-                drilldownChart->axisX()->setLabelsVisible(false);
+            //    drilldownChart->axisX()->setLabelsVisible(false);
                 window.setCentralWidget(drilldownChart);
                 window.resize(400, 300);
                 window.show();
                 return a.exec();
             }
             #include "main.moc"

src/barchart/barpresenter.cpp +1 -2

             #include "barpresenter_p.h"
             #include "bar_p.h"
             #include "barlabel_p.h"
             #include "barvalue_p.h"
             #include "qbarset.h"
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            BarPresenter::BarPresenter(QBarSeries *series, QGraphicsItem *parent) :
+            BarPresenter::BarPresenter(QBarSeries *series, QChart *parent) :
                 BarPresenterBase(series, parent)
             {
-                mBarWidth = 5;
             }
             void BarPresenter::layoutChanged()
             {
                 // Scale bars to new layout
                 // Layout for bars:
                 if (mSeries->barsetCount() <= 0) {
                     qDebug() << "No sets in model!";
                     return;
                 }
                 if (childItems().count() == 0) {
                     qDebug() << "WARNING: BarPresenter::layoutChanged called before graphics items are created!";
                     return;
                 }
                 // Use temporary qreals for accurancy (we might get some compiler warnings... :)
                 int categoryCount = mSeries->categoryCount();
                 int setCount = mSeries->barsetCount();
                 qreal tW = mWidth;
                 qreal tH = mHeight;
                 qreal tM = mSeries->max();
                 qreal scale = (tH/tM);
                 qreal tC = categoryCount + 1;
                 mBarWidth = tW / ((categoryCount * setCount) + tC);
                 qreal xStepPerCategory = (tW/tC) + mBarWidth;
                 int itemIndex(0);
                 int labelIndex(0);
                 for (int category=0; category < categoryCount; category++) {
                     qreal xPos = xStepPerCategory * category;
                     qreal yPos = mHeight;
                     for (int set = 0; set < setCount; set++) {
                         qreal barHeight = mSeries->valueAt(set,category) * scale;
                         Bar* bar = mBars.at(itemIndex);
                         // TODO: width settable per bar?
                         bar->resize(mBarWidth, barHeight);
                         bar->setBrush(mSeries->barsetAt(set)->brush());
                         bar->setPos(xPos, yPos-barHeight);
                         itemIndex++;
                         xPos += mBarWidth;
                     }
                     // TODO: Layout for labels, remove magic number
                     xPos = xStepPerCategory * category + mBarWidth/2;
                     BarLabel* label = mLabels.at(labelIndex);
                     label->setPos(xPos, mHeight - 20);
                     labelIndex++;
                 }
                 // Position floating values
                 itemIndex = 0;
                 for (int category=0; category < mSeries->categoryCount(); category++) {
                     qreal xPos = xStepPerCategory * category + mBarWidth/2;
                     qreal yPos = mHeight;
                     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++;
                         xPos += mBarWidth;
                     }
                 }
             }
             #include "moc_barpresenter_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/barpresenter_p.h +1 -1

             #ifndef BARPRESENTER_H
             #define BARPRESENTER_H
             #include "qchartglobal.h"
             #include "barpresenterbase_p.h"
             #include <QGraphicsItem>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QBarSeries;
             // Presenter for parallel bars. Grouping of bars is done on category basis.
             class BarPresenter : public BarPresenterBase
             {
                 Q_OBJECT
             public:
-                explicit BarPresenter(QBarSeries *series, QGraphicsItem *parent = 0);
+                explicit BarPresenter(QBarSeries *series, QChart *parent = 0);
             private:
                 // From BarPresenterBase
                 void layoutChanged();   // layout has changed -> need to recalculate bar sizes
             private:
                 // Data
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // BARPRESENTER_H

src/barchart/barpresenterbase.cpp +52 -12

             #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 "qchart.h"
+            #include "qchartaxis.h"
+            #include "qchartaxiscategories.h"
             #include <QDebug>
             #include <QToolTip>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            BarPresenterBase::BarPresenterBase(QBarSeries *series, QGraphicsItem *parent)
+            BarPresenterBase::BarPresenterBase(QBarSeries *series, QChart *parent)
                 : ChartItem(parent)
-                ,mBarWidth(20) // TODO: remove hard coding, when we have layout code ready
                 ,mLayoutSet(false)
                 ,mSeparatorsEnabled(false)
                 ,mSeries(series)
+                ,mChart(parent)
             {
                 connect(series,SIGNAL(showToolTip(QPoint,QString)),this,SLOT(showToolTip(QPoint,QString)));
+                initAxisLabels();
                 dataChanged();
             }
             BarPresenterBase::~BarPresenterBase()
             {
                 disconnect(this,SLOT(showToolTip(QPoint,QString)));
             }
             void BarPresenterBase::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 if (!mLayoutSet) {
                     qDebug() << "BarPresenterBase::paint called without layout set. Aborting.";
                     return;
                 }
                 foreach(QGraphicsItem* i, childItems()) {
                     i->paint(painter,option,widget);
                 }
             }
             QRectF BarPresenterBase::boundingRect() const
             {
                 return QRectF(0,0,mWidth,mHeight);
             }
-            void BarPresenterBase::setBarWidth( int w )
-                mBarWidth = 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?
                 // 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
+                int 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()));
                     }
                 }
             }
+            void BarPresenterBase::initAxisLabels()
+            {
+                int count = mSeries->categoryCount();
+                if (0 == count) {
+                    return;
+                }
+                mChart->axisX()->setTicksCount(count);
+                qreal min = 0;
+                qreal max = mSeries->categoryCount();
+                mChart->axisX()->setMin(min);
+                mChart->axisX()->setMax(max);
+                qreal step = (max-min)/count;
+                QChartAxisCategories& categories = mChart->axisX()->categories();
+                categories.clear();
+                for (int i=0; i<count; i++) {
+                    qDebug() << "initAxisLabels" << min << mSeries->categoryName(i);
+                    categories.insert(min,mSeries->categoryName(i));
+                    min += step;
+                }
+                mChart->axisX()->setLabelsVisible(true);
+            }
             //handlers
             void BarPresenterBase::handleModelChanged(int index)
             {
             //    qDebug() << "BarPresenterBase::handleModelChanged" << index;
                 dataChanged();
             }
             void BarPresenterBase::handleDomainChanged(const Domain& domain)
             {
-            //    qDebug() << "BarPresenterBase::handleDomainChanged";
+                qDebug() << "BarPresenterBase::handleDomainChanged";
-                // TODO: Figure out the use case for this.
+                /*
-                // Affects the size of visible item, so layout is changed.
+                int count = mSeries->categoryCount();
-            //    layoutChanged();
+                if (0 == count) {
+                    return;
+                }
+                // Position labels to domain
+                qreal min = domain.minX();
+                qreal max = domain.maxX();
+                qreal step = (max-min)/count;
+                QChartAxisCategories& categories = mChart->axisX()->categories();
+                categories.clear();
+                for (int i=0; i<count; i++) {
+                    categories.insert(min,mSeries->categoryName(i));
+                    min += step;
+                }
+                */
             }
             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 +7 -5

             #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;
+            class QChartAxisCategories;
+            class QChart;
             // 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(QBarSeries *series, QChart *parent = 0);
                 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
+            protected:
+                void initAxisLabels();
             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;
                 qreal mBarWidth;
                 bool mLayoutSet;    // True, if component has been laid out.
                 bool mSeparatorsEnabled;
                 // Not owned.
                 QBarSeries* mSeries;
                 QList<Bar*> mBars;
                 QList<BarLabel*> mLabels;
                 QList<Separator*> mSeparators;
                 QList<BarValue*> mFloatingValues;
+                QChart* mChart;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // BARPRESENTERBASE_H

src/barchart/percentbarpresenter.cpp +1 -1

             #include "percentbarpresenter_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
-            PercentBarPresenter::PercentBarPresenter(QBarSeries *series, QGraphicsItem *parent) :
+            PercentBarPresenter::PercentBarPresenter(QBarSeries *series, QChart *parent) :
                 BarPresenterBase(series, parent)
             {
             }
             void PercentBarPresenter::layoutChanged()
             {
                 // Scale bars to new layout
                 // Layout for bars:
                 if (mSeries->barsetCount() <= 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;
                 }
                 // Use temporary qreals for accurancy (we might get some compiler warnings... :)
                 qreal tW = mWidth;
                 qreal tC = mSeries->categoryCount() + 1;
                 qreal cC = mSeries->categoryCount() * 2 + 1;
                 mBarWidth = tW / cC;
                 qreal xStep = (tW/tC);
                 qreal xPos = ((tW/tC) - mBarWidth / 2);
                 qreal h = mHeight;
                 int itemIndex(0);
                 int labelIndex(0);
                 for (int category = 0; category < mSeries->categoryCount(); category++) {
                     qreal colSum = mSeries->categorySum(category);
                     qreal scale = (h / colSum);
                     qreal yPos = h;
                     for (int set=0; set < mSeries->barsetCount(); set++) {
                         qreal barHeight = mSeries->valueAt(set, category) * scale;
                         Bar* bar = mBars.at(itemIndex);
                         // TODO: width settable per bar?
                         bar->resize(mBarWidth, 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);
                 for (int category=0; category < mSeries->categoryCount(); category++) {
                     qreal yPos = h;
                     qreal colSum = mSeries->categorySum(category);
                     qreal scale = (h / colSum);
                     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) {
                             int p = mSeries->percentageAt(set,category) * 100;
                             QString vString(QString::number(p));
                             vString.truncate(3);
                             vString.append("%");
                             value->setValueString(vString);
                         } else {
                             value->setValueString(QString(""));
                         }
                         itemIndex++;
                         yPos -= barHeight;
                     }
                     xPos += xStep;
                 }
             }
             #include "moc_percentbarpresenter_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/percentbarpresenter_p.h +1 -1

             #ifndef PERCENTBARPRESENTER_H
             #define PERCENTBARPRESENTER_H
             #include "chartitem_p.h"
             #include "bar_p.h"
             #include "qpercentbarseries.h"
             #include "barpresenterbase_p.h"
             #include <QGraphicsItem>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class PercentBarPresenter : public BarPresenterBase
             {
                 Q_OBJECT
             public:
-                PercentBarPresenter(QBarSeries *series, QGraphicsItem *parent = 0);
+                PercentBarPresenter(QBarSeries *series, QChart *parent = 0);
             private:
                 void layoutChanged();   // layout has changed -> need to recalculate bar sizes
             private:
                 // Data
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // PERCENTBARPRESENTER_H

src/barchart/qbarseries.cpp +1 0

             #include <QDebug>
             #include "qbarseries.h"
             #include "qbarset.h"
             #include "barchartmodel_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QBarSeries
                 \brief part of QtCommercial chart API.
                 QBarSeries represents a series of data shown as bars. One QBarSeries can contain multible
                 QBarSet data sets. QBarSeries groups the data from sets to categories, which are defined
                 by QStringList.
                 \mainclass
                 \sa QBarSet, QStackedBarSeries, QPercentBarSeries
             */
             /*!
                 \fn virtual QSeriesType QBarSeries::type() const
                 \brief Returns type of series.
                 \sa QSeries, QSeriesType
             */
             /*!
                 \fn void QBarSeries::showToolTip(QPoint pos, QString tip)
                 \brief \internal \a pos \a tip
             */
             /*!
                 Constructs empty QBarSeries. Parameter \a categories defines the categories for chart.
                 QBarSeries is QObject which is a child of a \a parent.
             */
             QBarSeries::QBarSeries(QStringList categories, QObject *parent)
                 : QSeries(parent)
                 ,mModel(new BarChartModel(categories, this))
             {
             }
             /*!
                 Adds a set of bars to series. Takes ownership of \a set.
                 Connects the clicked(QString) and rightClicked(QString) signals
                 of \a set to this series
             */
             void QBarSeries::addBarSet(QBarSet *set)
             {
                 mModel->addBarSet(set);
                 connect(set,SIGNAL(clicked(QString)),this,SLOT(barsetClicked(QString)));
                 connect(set,SIGNAL(rightClicked(QString)),this,SLOT(barsetRightClicked(QString)));
             }
             /*!
                 Removes a set of bars from series. Releases ownership of \a set. Doesnt delete \a set.
                 Disconnects the clicked(QString) and rightClicked(QString) signals
                 of \a set from this series
             */
             void QBarSeries::removeBarSet(QBarSet *set)
             {
                 disconnect(set,SIGNAL(clicked(QString)),this,SLOT(barsetClicked(QString)));
                 disconnect(set,SIGNAL(rightClicked(QString)),this,SLOT(barsetRightClicked(QString)));
                 mModel->removeBarSet(set);
             }
             /*!
                 Returns number of sets in series.
             */
             int QBarSeries::barsetCount()
             {
                 return mModel->barsetCount();
             }
             /*!
                 Returns number of categories in series
             */
             int QBarSeries::categoryCount()
             {
                 return mModel->categoryCount();
             }
             /*!
                 Returns a list of sets in series. Keeps ownership of sets.
              */
             QList<QBarSet*> QBarSeries::barSets()
             {
                 return mModel->barSets();
             }
             /*!
                 \internal \a index
             */
             QBarSet* QBarSeries::barsetAt(int index)
             {
                 return mModel->setAt(index);
             }
             /*!
                 Returns legend of series.
             */
             QList<QSeries::Legend> QBarSeries::legend()
             {
                 return mModel->legend();
             }
             /*!
                 \internal \a category
             */
             QString QBarSeries::categoryName(int category)
             {
                 return mModel->categoryName(category);
             }
             /*!
                 Enables or disables tooltip depending on parameter \a enabled.
                 Tooltip shows the name of set, when mouse is hovering on top of bar.
                 Calling without parameter \a enabled, enables the tooltip
             */
             void QBarSeries::setToolTipEnabled(bool enabled)
             {
+                // TODO: what if we add sets after call to this function? Those sets won't have tooltip enabled.
                 if (enabled) {
                     for (int i=0; i<mModel->barsetCount(); i++) {
                         QBarSet *set = mModel->setAt(i);
                         connect(set,SIGNAL(showToolTip(QPoint,QString)),this,SIGNAL(showToolTip(QPoint,QString)));
                     }
                 } else {
                     for (int i=0; i<mModel->barsetCount(); i++) {
                         QBarSet *set = mModel->setAt(i);
                         disconnect(set,SIGNAL(showToolTip(QPoint,QString)),this,SIGNAL(showToolTip(QPoint,QString)));
                     }
                 }
             }
             /*!
                 Enables or disables separators depending on parameter \a enabled.
                 Separators are visual elements that are drawn between categories.
                 Calling without parameter \a enabled, enables the separators
             */
             void QBarSeries::setSeparatorsEnabled(bool enabled)
             {
                 // TODO: toggle
             //    emit separatorsEnabled(enabled);
             }
             /*!
                 \internal \a category
             */
             void QBarSeries::barsetClicked(QString category)
             {
                 emit clicked(qobject_cast<QBarSet*>(sender()), category);
             }
             /*!
                 \internal \a category
             */
             void QBarSeries::barsetRightClicked(QString category)
             {
                 emit rightClicked(qobject_cast<QBarSet*>(sender()), category);
             }
             /*!
                 \internal
             */
             qreal QBarSeries::min()
             {
                 return mModel->min();
             }
             /*!
                 \internal
             */
             qreal QBarSeries::max()
             {
                 return mModel->max();
             }
             /*!
                 \internal \a set \a category
             */
             qreal QBarSeries::valueAt(int set, int category)
             {
                 return mModel->valueAt(set,category);
             }
             /*!
                 \internal \a set \a category
             */
             qreal QBarSeries::percentageAt(int set, int category)
             {
                 return mModel->percentageAt(set,category);
             }
             /*!
                 \internal \a category
             */
             qreal QBarSeries::categorySum(int category)
             {
                 return mModel->categorySum(category);
             }
             /*!
                 \internal
             */
             qreal QBarSeries::maxCategorySum()
             {
                 return mModel->maxCategorySum();
             }
             /*!
                 \internal
             */
             BarChartModel& QBarSeries::model()
             {
                 return *mModel;
             }
             #include "moc_qbarseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/stackedbarpresenter.cpp +3 -3

             #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) :
+            StackedBarPresenter::StackedBarPresenter(QBarSeries *series, QChart *parent) :
                 BarPresenterBase(series,parent)
             {
             }
             StackedBarPresenter::~StackedBarPresenter()
             {
             }
             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;
                 }
                 // Use temporary qreals for accurancy (we might get some compiler warnings... :)
                 qreal maxSum = mSeries->maxCategorySum();
                 qreal h = mHeight;
                 qreal scale = (h / maxSum);
                 qreal tW = mWidth;
                 qreal tC = mSeries->categoryCount() + 1;
                 qreal cC = mSeries->categoryCount() * 2 + 1;
                 mBarWidth = tW / cC;
                 qreal xStep = (tW/tC);
                 qreal xPos = ((tW/tC) - mBarWidth / 2);
                 int itemIndex(0);
                 int labelIndex(0);
                 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(mBarWidth, 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);
+            //        BarLabel* label = mLabels.at(labelIndex);
-                    label->setPos(xPos, mHeight + 20);
+            //        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);
                 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;
                 }
             }
             #include "moc_stackedbarpresenter_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/stackedbarpresenter_p.h +1 -1

             #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(QBarSeries *series, QChart *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