HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r288:5f68000bea7a

moved tooltip to presenter

sauimone -

r288:5f68000bea7a

parent child

Context file:

r288:5f68000bea7a

Collapse all files

src/barchart/barpresenter.cpp +16 -14

             #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) :
+            BarPresenter::BarPresenter(QBarChartSeries *series, QGraphicsItem *parent) :
-                BarPresenterBase(model,parent)
+                BarPresenterBase(series, parent)
             {
                 mBarDefaultWidth = 15;
             }
             void BarPresenter::layoutChanged()
             {
                 // Scale bars to new layout
                 // Layout for bars:
-                if (mModel.countSets() <= 0) {
+                if (mSeries->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 categoryCount = mSeries->countCategories();
-                int setCount = mModel.countSets();
+                int setCount = mSeries->countSets();
                 qreal tW = mWidth;
                 qreal tH = mHeight;
-                qreal tM = mModel.max();
+                qreal tM = mSeries->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;
+                        qreal barHeight = mSeries->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(mSeries->setAt(set)->brush());
-                        bar->setPos(xPos, yPos-barHeight); // item*posStep+startPos + set * mBarDefaultWidth, mHeight);
+                        bar->setPos(xPos, yPos-barHeight);
                         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++) {
+                for (int category=0; category < mSeries->countCategories(); category++) {
                     qreal xPos = xStepPerSet * category + ((tW + mBarDefaultWidth*setCount)/(categoryCount*2));
                     qreal yPos = mHeight;
-                    for (int set=0; set < mModel.countSets(); set++) {
+                    for (int set=0; set < mSeries->countSets(); set++) {
-                        qreal barHeight = mModel.valueAt(set,category) * scale;
+                        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 (mModel.valueAt(set,category) != 0) {
+                        if (mSeries->valueAt(set,category) != 0) {
-                            value->setValueString(QString::number(mModel.valueAt(set,category)));
+                            value->setValueString(QString::number(mSeries->valueAt(set,category)));
                         } else {
                             value->setValueString(QString(""));
                         }
                         itemIndex++;
                         xPos += mBarDefaultWidth;
                     }
                 }
                 mLayoutDirty = true;
             }
+            #include "moc_barpresenter.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/barpresenter.h +5 -2

             #ifndef BARPRESENTER_H
             #define BARPRESENTER_H
+            #include "qchartglobal.h"
             #include "barpresenterbase.h"
-            #include "qbarchartseries.h"
             #include <QGraphicsItem>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
+            class QBarChartSeries;
             // Presenter for parallel bars. Grouping of bars is done on category basis.
             class BarPresenter : public BarPresenterBase
             {
+                Q_OBJECT
             public:
-                explicit BarPresenter(BarChartModel& model, QGraphicsItem *parent = 0);
+                explicit BarPresenter(QBarChartSeries *series, QGraphicsItem *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 +39 -18

             #include "barpresenterbase.h"
             #include "bar_p.h"
             #include "barvalue_p.h"
             #include "barlabel_p.h"
             #include "separator_p.h"
             #include "qbarset.h"
+            #include "qbarchartseries.h"
             #include <QDebug>
+            #include <QToolTip>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            BarPresenterBase::BarPresenterBase(BarChartModel& model, QGraphicsItem *parent)
+            BarPresenterBase::BarPresenterBase(QBarChartSeries *series, QGraphicsItem *parent)
                 : ChartItem(parent)
                 ,mBarDefaultWidth(20) // TODO: remove hard coding, when we have layout code ready
                 ,mLayoutSet(false)
                 ,mLayoutDirty(true)
-                ,mSeparatorsVisible(false)
+                ,mSeries(series)
-                ,mModel(model)
             {
+                connect(series,SIGNAL(floatingValuesEnabled(bool)),this,SLOT(enableFloatingValues(bool)));
+                connect(series,SIGNAL(toolTipEnabled(bool)),this,SLOT(enableToolTip(bool)));
+                connect(series,SIGNAL(separatorsEnabled(bool)),this,SLOT(enableSeparators(bool)));
+                connect(series,SIGNAL(showToolTip(QPoint,QString)),this,SLOT(showToolTip(QPoint,QString)));
                 dataChanged();
             }
-            void BarPresenterBase::setSeparatorsVisible(bool visible)
+            BarPresenterBase::~BarPresenterBase()
             {
-                mSeparatorsVisible = visible;
+                disconnect(this,SLOT(enableFloatingValues(bool)));
+                disconnect(this,SLOT(enableToolTip(bool)));
+                disconnect(this,SLOT(enableSeparators(bool)));
+                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<mModel.countCategories(); c++) {
+                for (int c=0; c<mSeries->countCategories(); c++) {
-                    for (int s=0; s<mModel.countSets(); s++) {
+                    for (int s=0; s<mSeries->countSets(); s++) {
-                        QBarSet *set = mModel.setAt(s);
+                        QBarSet *set = mSeries->setAt(s);
                         Bar *bar = new Bar(this);
                         childItems().append(bar);
                         mBars.append(bar);
                         connect(bar,SIGNAL(clicked()),set,SLOT(barClicked()));
                         // TODO: should the event be passed to set or not?
                         connect(bar,SIGNAL(hoverEntered(QPoint)),set,SLOT(barHoverEntered(QPoint)));
                         connect(bar,SIGNAL(hoverLeaved()),set,SLOT(barHoverLeaved()));
                     }
                 }
                 // Create labels
-                int count = mModel.countCategories();
+                int count = mSeries->countCategories();
                 for (int i=0; i<count; i++) {
                     BarLabel* label = new BarLabel(this);
-                    label->set(mModel.label(i));
+                    label->set(mSeries->label(i));
                     childItems().append(label);
                     mLabels.append(label);
                 }
                 // Create separators
-                count = mModel.countCategories() - 1;   // There is one less separator than columns
+                count = mSeries->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 category=0; category<mModel.countCategories(); category++) {
+                for (int category=0; category<mSeries->countCategories(); category++) {
-                    for (int s=0; s<mModel.countSets(); s++) {
+                    for (int s=0; s<mSeries->countSets(); s++) {
-                        QBarSet *set = mModel.setAt(s);
+                        QBarSet *set = mSeries->setAt(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::enableFloatingValues(bool enabled)
+            {
+                mFloatingValuesEnabled = enabled;
+            }
+            void BarPresenterBase::enableToolTip(bool enabled)
+            {
+                mToolTipEnabled = enabled;
+            }
-            void BarPresenterBase::barHoverEntered(QGraphicsSceneHoverEvent *event)
+            void BarPresenterBase::enableSeparators(bool enabled)
             {
-                //TODO: show tooltip (name of series, where bar belongs...)
+                mSeparatorsEnabled = enabled;
             }
-            void BarPresenterBase::barHoverLeaved(QGraphicsSceneHoverEvent *event)
+            void BarPresenterBase::showToolTip(QPoint pos, QString tip)
             {
-                //TODO: hide tooltip (name of series, where bar belongs...)
+                if (mToolTipEnabled) {
+                    // TODO: cool tooltip instead of default
+                    QToolTip::showText(pos,tip);
+                }
             }
             #include "moc_barpresenterbase.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/barpresenterbase.h +15 -8

             #ifndef BARPRESENTERBASE_H
             #define BARPRESENTERBASE_H
             #include "chartitem_p.h"
-            #include "barchartmodel_p.h"
+            #include "qbarchartseries.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(BarChartModel& model, QGraphicsItem *parent = 0);
+                BarPresenterBase(QBarChartSeries *series, QGraphicsItem *parent = 0);
-                void setSeparatorsVisible(bool visible = true);
+                ~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 slots:
                 void handleModelChanged(int index);
                 void handleDomainChanged(const Domain& domain);
                 void handleGeometryChanged(const QRectF& size);
-                void barHoverEntered(QGraphicsSceneHoverEvent *event);  // Internal.
+                // Internal slots
-                void barHoverLeaved(QGraphicsSceneHoverEvent *event);
+                void enableFloatingValues(bool enabled=true);   // enables floating values on top of bars
+                void enableToolTip(bool enabled=true);          // enables tooltips
+                void enableSeparators(bool enabled=true);       // enables separators between categories
+                void showToolTip(QPoint pos, QString tip);      // shows tooltip (if 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 mSeparatorsVisible;
+                bool mFloatingValuesEnabled;
-                BarChartModel& mModel;
+                bool mToolTipEnabled;
+                bool mSeparatorsEnabled;
+                // Owned
+                QBarChartSeries* mSeries;
                 // Not owned.
                 QList<Bar*> mBars;
                 QList<BarLabel*> mLabels;
                 QList<Separator*> mSeparators;
                 QList<BarValue*> mFloatingValues;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // BARPRESENTERBASE_H

src/barchart/percentbarpresenter.cpp +18 -16

             #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) :
+            PercentBarPresenter::PercentBarPresenter(QBarChartSeries *series, QGraphicsItem *parent) :
-                BarPresenterBase(model, parent)
+                BarPresenterBase(series, parent)
             {
             }
             void PercentBarPresenter::layoutChanged()
             {
                 // Scale bars to new layout
                 // Layout for bars:
-                if (mModel.countSets() <= 0) {
+                if (mSeries->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 count = mSeries->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++) {
+                for (int category = 0; category < mSeries->countCategories(); category++) {
-                    qreal colSum = mModel.categorySum(category);
+                    qreal colSum = mSeries->categorySum(category);
                     qreal scale = (h / colSum);
                     qreal yPos = h;
-                    for (int set=0; set < mModel.countSets(); set++) {
+                    for (int set=0; set < mSeries->countSets(); set++) {
-                        qreal barHeight = mModel.valueAt(set, category) * scale;
+                        qreal barHeight = mSeries->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(mSeries->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++) {
+                for (int s=0; s < mSeries->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++) {
+                for (int category=0; category < mSeries->countCategories(); category++) {
                     qreal yPos = h;
-                    qreal colSum = mModel.categorySum(category);
+                    qreal colSum = mSeries->categorySum(category);
                     qreal scale = (h / colSum);
-                    for (int set=0; set < mModel.countSets(); set++) {
+                    for (int set=0; set < mSeries->countSets(); set++) {
-                        qreal barHeight = mModel.valueAt(set,category) * scale;
+                        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 (mModel.valueAt(set,category) != 0) {
+                        if (mSeries->valueAt(set,category) != 0) {
-                            int p = mModel.percentageAt(set,category) * 100;
+                            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;
                 }
                 mLayoutDirty = true;
             }
+            #include "moc_percentbarpresenter.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/percentbarpresenter.h +2 -1

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

src/barchart/qbarchartseries.cpp +34 -6

             #include <QDebug>
             #include "qbarchartseries.h"
             #include "qbarcategory.h"
             #include "qbarset.h"
             #include "barchartmodel_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             QBarChartSeries::QBarChartSeries(QBarCategory *category, QObject *parent)
                 : QChartSeries(parent)
                 ,mModel(new BarChartModel(category, this))
             {
             }
             void QBarChartSeries::addBarSet(QBarSet *set)
             {
-            //    connect(this,SIGNAL(floatingValuesEnabled(bool)),set,SLOT(enableFloatingValues(bool)));
+                connect(this,SIGNAL(floatingValuesEnabled(bool)),set,SLOT(enableFloatingValues(bool)));
-            //    connect(this,SIGNAL(hoverNamesEnabled(bool)),set,SLOT(enableHoverNames(bool)));
+                connect(this,SIGNAL(separatorsEnabled(bool)),set,SLOT(enableSeparators(bool)));
+                connect(this,SIGNAL(toolTipEnabled(bool)),set,SLOT(enableToolTip(bool)));
+                connect(set,SIGNAL(showToolTip(QPoint,QString)),this,SIGNAL(showToolTip(QPoint,QString)));
                 mModel->addBarSet(set);
             }
             void QBarChartSeries::removeBarSet(QBarSet *set)
             {
-            //    disconnect(set,SLOT(enableFloatingValues(bool)));
+                disconnect(set,SLOT(enableFloatingValues(bool)));
-            //    disconnect(set,SLOT(enableHoverNames(bool)));
+                disconnect(set,SLOT(enableSeparators(bool)));
+                disconnect(set,SLOT(enableToolTip(bool)));
                 mModel->removeBarSet(set);
             }
             int QBarChartSeries::countSets()
             {
                 return mModel->countSets();
             }
             QBarSet* QBarChartSeries::nextSet(bool getFirst)
             {
                 return mModel->nextSet(getFirst);
             }
+            QBarSet* QBarChartSeries::setAt(int index)
+            {
+                return mModel->setAt(index);
+            }
             QList<QString> QBarChartSeries::legend()
             {
                 return mModel->legend();
             }
+            QString QBarChartSeries::label(int category)
+            {
+                return mModel->label(category);
+            }
             void QBarChartSeries::enableFloatingValues(bool enabled)
             {
                 emit floatingValuesEnabled(enabled);
             }
-            void QBarChartSeries::enableHoverNames(bool enabled)
+            void QBarChartSeries::enableToolTip(bool enabled)
             {
-                emit hoverNamesEnabled(enabled);
+                emit toolTipEnabled(enabled);
+            }
+            void QBarChartSeries::enableSeparators(bool enabled)
+            {
+                emit separatorsEnabled(enabled);
             }
             int QBarChartSeries::countCategories()
             {
                 return mModel->countCategories();
             }
             qreal QBarChartSeries::min()
             {
                 return mModel->min();
             }
             qreal QBarChartSeries::max()
             {
                 return mModel->max();
             }
             qreal QBarChartSeries::valueAt(int set, int category)
             {
                 return mModel->valueAt(set,category);
             }
+            qreal QBarChartSeries::percentageAt(int set, int category)
+            {
+                return mModel->percentageAt(set,category);
+            }
+            qreal QBarChartSeries::categorySum(int category)
+            {
+                return mModel->categorySum(category);
+            }
             qreal QBarChartSeries::maxCategorySum()
             {
                 return mModel->maxCategorySum();
             }
             BarChartModel& QBarChartSeries::model()
             {
                 return *mModel;
             }
             #include "moc_qbarchartseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/qbarchartseries.h +15 -8

             #ifndef BARCHARTSERIES_H
             #define BARCHARTSERIES_H
             #include "qchartseries.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QBarCategory;
             class QBarSet;
             class BarChartModel;
             // Container for series
             class QTCOMMERCIALCHART_EXPORT QBarChartSeries : public QChartSeries
             {
                 Q_OBJECT
             public:
                 QBarChartSeries(QBarCategory *category, QObject* parent=0);
                 virtual QChartSeriesType type() const { return QChartSeries::SeriesTypeBar; }
                 void addBarSet(QBarSet *set);               // Takes ownership of set
                 void removeBarSet(QBarSet *set);            // Releases ownership, doesn't delete set
                 int countSets();
                 QBarSet* nextSet(bool getFirst=false);     // Returns first set, if called with true
+                QBarSet *setAt(int index);
-                QList<QString> legend();  // Returns legend of series (ie. names of all sets in series)
+                QList<QString> legend();                    // Returns legend of series (ie. names of all sets in series)
+                QString label(int category);
+            public Q_SLOTS:
                 // Disabled by default. Call these to change behavior.
-                void enableFloatingValues(bool enabled=true);
+                void enableFloatingValues(bool enabled=true);    // enables floating values on top of bars
-                void enableHoverNames(bool enabled=true);
+                void enableToolTip(bool enabled=true);           // enables tooltips
+                void enableSeparators(bool enabled=true);        // enables separators between categories
+            public:
                 // TODO: Functions below this are not part of api and will be moved
                 // to private implementation, when we start using it (not part of api)
                 int countCategories();
                 qreal min();
                 qreal max();
                 qreal valueAt(int set, int category);
+                qreal percentageAt(int set, int category);
+                qreal categorySum(int category);
                 qreal maxCategorySum();
                 BarChartModel& model();
             signals:
                 void changed(int index);
-                // TODO: these to private implementation.
+                // TODO: internal signals, these to private implementation.
                 void floatingValuesEnabled(bool enabled);
-                void hoverNamesEnabled(bool enabled);
+                void toolTipEnabled(bool enabled);
+                void separatorsEnabled(bool enabled);
+                void showToolTip(QPoint pos, QString tip);
-            //public Q_SLOTS:
             protected:
                 BarChartModel* mModel;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // BARCHARTSERIES_H

src/barchart/qbarset.cpp +21 -13

             #include "qbarset.h"
             #include <QDebug>
             #include <QToolTip>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             QBarSet::QBarSet(QString name, QObject *parent)
                 : QObject(parent)
                 ,mName(name)
-                ,mHoverNamesEnabled(true)       // TODO: these 2 as false by default, when implementation is ready
+                ,mToolTipEnabled(true)       // TODO: these 2 as false by default, when implementation is ready
                 ,mFloatingValuesEnabled(true)
             {
             }
             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;
             }
             void QBarSet::enableFloatingValues(bool enabled)
             {
-                qDebug() << "QBarSet::enableFloatingValues" << enabled;
+                qDebug() << "QBarSet::enableFloatingValues";
                 mFloatingValuesEnabled = enabled;
             }
             void QBarSet::enableToolTip(bool enabled)
             {
-                qDebug() << "QBarSet::enableHoverNames" << enabled;
+                qDebug() << "QBarSet::enableToolTip";
-                mHoverNamesEnabled = enabled;
+                mToolTipEnabled = enabled;
+            }
+            void QBarSet::enableSeparators(bool enabled)
+            {
+                qDebug() << "QBarSet::enableSeparators";
+                mSeparatorsEnabled = enabled;
             }
             void QBarSet::barClicked()
             {
-                qDebug() << "QBarset::barClicked" << this;
+            //    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::barHoverEntered(QPoint pos)
             {
-                qDebug() << "QBarset::barHoverEntered" << this << pos;
+                if (mToolTipEnabled) {
-                if (mHoverNamesEnabled) {
+                    emit showToolTip(pos, mName);
-                    QToolTip::showText(pos, mName);
-            //        emit hoverEnter();
                 }
+                // Emit signal to user of charts
+                emit hoverEnter(pos);
             }
             void QBarSet::barHoverLeaved()
             {
-                qDebug() << "QBarset::barHoverLeaved" << this;
+            //    qDebug() << "QBarset::barHoverLeaved" << this;
-                if (mHoverNamesEnabled) {
+            //    if (mToolTipEnabled) {
-            //        emit hoverLeave();
+                    // TODO: do what?
+            //    }
+                // Emit signal to user of charts
+                emit hoverLeave();
             }
             #include "moc_qbarset.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/qbarset.h +6 -4

             #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
                 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
                 void setPen(const QPen& pen);
                 const QPen& pen() const;
                 void setBrush(const QBrush& brush);
                 const QBrush& brush() const;
             Q_SIGNALS:
                 void clicked();                 // Clicked and hover signals exposed to user
-                void hoverEnter();
+                void hoverEnter(QPoint pos);
                 void hoverLeave();
-                void toggleFloatingValues();    // Private signal, TODO: move to private impl
+                void toggleFloatingValues();                // Private signal, TODO: move to private impl
+                void showToolTip(QPoint pos, QString tip);  // Private signal, TODO: move to private impl
             public Q_SLOTS:
-                // TODO: should these be in series instead?
                 void enableFloatingValues(bool enabled);    // enables floating values on top of bars
                 void enableToolTip(bool enabled);           // enables tooltips
+                void enableSeparators(bool enabled);        // enables separators between categories
                 // TODO: these slots belong to private implementation.
                 // These are for single bars to notify set about internal events
                 void barClicked();
                 void barHoverEntered(QPoint pos);
                 void barHoverLeaved();
             private:
                 QString mName;
                 QList<qreal> mValues;
                 QPen mPen;
                 QBrush mBrush;
                 // TODO: to pimpl
                 bool mFloatingValuesEnabled;
-                bool mHoverNamesEnabled;
+                bool mToolTipEnabled;
+                bool mSeparatorsEnabled;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QBARSET_H

src/barchart/stackedbarpresenter.cpp +18 -16

             #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) :
+            StackedBarPresenter::StackedBarPresenter(QBarChartSeries *series, QGraphicsItem *parent) :
-                BarPresenterBase(model,parent)
+                BarPresenterBase(series,parent)
             {
             }
             void StackedBarPresenter::layoutChanged()
             {
                 // Scale bars to new layout
                 // Layout for bars:
-                if (mModel.countSets() <= 0) {
+                if (mSeries->countSets() <= 0) {
                     qDebug() << "No sets in model!";
                     // Nothing to do.
                     return;
                 }
-                if (mModel.countCategories() == 0) {
+                if (mSeries->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 maxSum = mSeries->maxCategorySum();
                 qreal h = mHeight;
                 qreal scale = (h / maxSum);
                 int itemIndex(0);
                 int labelIndex(0);
                 qreal tW = mWidth;
-                qreal tC = mModel.countCategories() + 1;
+                qreal tC = mSeries->countCategories() + 1;
                 qreal xStep = (tW/tC);
                 qreal xPos = ((tW/tC) - mBarDefaultWidth / 2);
-                for (int category = 0; category < mModel.countCategories(); category++) {
+                for (int category = 0; category < mSeries->countCategories(); category++) {
                     qreal yPos = h;
-                    for (int set=0; set < mModel.countSets(); set++) {
+                    for (int set=0; set < mSeries->countSets(); set++) {
-                        qreal barHeight = mModel.valueAt(set, category) * scale;
+                        qreal barHeight = mSeries->valueAt(set, category) * scale;
                         Bar* bar = mBars.at(itemIndex);
                         bar->resize(mBarDefaultWidth, barHeight);
-                        bar->setBrush(mModel.setAt(set)->brush());
+                        bar->setBrush(mSeries->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++) {
+                for (int s=0; s < mSeries->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++) {
+                for (int category=0; category < mSeries->countCategories(); category++) {
                     qreal yPos = h;
-                    for (int set=0; set < mModel.countSets(); set++) {
+                    for (int set=0; set < mSeries->countSets(); set++) {
-                        qreal barHeight = mModel.valueAt(set,category) * scale;
+                        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 (mModel.valueAt(set,category) != 0) {
+                        if (mSeries->valueAt(set,category) != 0) {
-                            value->setValueString(QString::number(mModel.valueAt(set,category)));
+                            value->setValueString(QString::number(mSeries->valueAt(set,category)));
                         } else {
                             value->setValueString(QString(""));
                         }
                         itemIndex++;
                         yPos -= barHeight;
                     }
                     xPos += xStep;
                 }
                 mLayoutDirty = true;
             }
+            #include "moc_stackedbarpresenter.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/stackedbarpresenter.h +2 -1

             #ifndef STACKEDBARPRESENTER_H
             #define STACKEDBARPRESENTER_H
             #include "barpresenterbase.h"
             #include "qstackedbarchartseries.h"
             #include <QGraphicsItem>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class StackedBarPresenter : public BarPresenterBase
             {
+                Q_OBJECT
             public:
-                StackedBarPresenter(BarChartModel& model, QGraphicsItem *parent = 0);
+                StackedBarPresenter(QBarChartSeries *series, QGraphicsItem *parent = 0);
             private:
                 // From BarPresenterBase
                 void layoutChanged();   // layout has changed -> need to recalculate bar sizes
             private:
                 // Data
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // STACKEDBARPRESENTER_H

src/chartpresenter.cpp +3 -3

             #include "qchart.h"
             #include "qchartaxis.h"
             #include "chartpresenter_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             //series
             #include "qbarchartseries.h"
             #include "qstackedbarchartseries.h"
             #include "qpercentbarchartseries.h"
             #include "qlinechartseries.h"
             #include "qpieseries.h"
             #include "qscatterseries.h"
             //items
             #include "axisitem_p.h"
             #include "barpresenter.h"
             #include "stackedbarpresenter.h"
             #include "linechartitem_p.h"
             #include "percentbarpresenter.h"
             #include "linechartanimationitem_p.h"
             #include "piepresenter.h"
             #include "scatterpresenter_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartPresenter::ChartPresenter(QChart* chart,ChartDataSet* dataset):QObject(chart),
             m_chart(chart),
             m_dataset(dataset),
             m_chartTheme(0),
             m_marginSize(0),
             m_rect(QRectF(QPoint(0,0),m_chart->size()))
             {
             	createConnections();
                 setChartTheme(QChart::ChartThemeDefault);
             }
             ChartPresenter::~ChartPresenter()
             {
             }
             void ChartPresenter::createConnections()
             {
                 QObject::connect(m_chart,SIGNAL(geometryChanged()),this,SLOT(handleGeometryChanged()));
                 QObject::connect(m_dataset,SIGNAL(seriesAdded(QChartSeries*)),this,SLOT(handleSeriesAdded(QChartSeries*)));
                 QObject::connect(m_dataset,SIGNAL(seriesRemoved(QChartSeries*)),this,SLOT(handleSeriesRemoved(QChartSeries*)));
                 QObject::connect(m_dataset,SIGNAL(axisAdded(QChartAxis*)),this,SLOT(handleAxisAdded(QChartAxis*)));
                 QObject::connect(m_dataset,SIGNAL(axisRemoved(QChartAxis*)),this,SLOT(handleAxisRemoved(QChartAxis*)));
                 QObject::connect(m_dataset,SIGNAL(seriesDomainChanged(QChartSeries*,const Domain&)),this,SLOT(handleSeriesDomainChanged(QChartSeries*,const Domain&)));
                 QObject::connect(m_dataset,SIGNAL(axisLabelsChanged(QChartAxis*,const QStringList&)),this,SLOT(handleAxisLabelsChanged(QChartAxis*,const QStringList&)));
             }
             QRectF ChartPresenter::geometry() const
             {
                 return m_rect;
             }
             void ChartPresenter::handleGeometryChanged()
             {
                 m_rect = QRectF(QPoint(0,0),m_chart->size());
                 m_rect.adjust(m_marginSize,m_marginSize, -m_marginSize, -m_marginSize);
                 Q_ASSERT(m_rect.isValid());
                 emit geometryChanged(m_rect);
             }
             int ChartPresenter::margin() const
             {
                 return m_marginSize;
             }
             void ChartPresenter::setMargin(int margin)
             {
                 m_marginSize = margin;
             }
             void ChartPresenter::handleAxisAdded(QChartAxis* axis)
             {
                 AxisItem* item ;
                 if(axis==m_dataset->axisX()){
                 item = new AxisItem(AxisItem::X_AXIS,m_chart);
                 }else{
                 item = new AxisItem(AxisItem::Y_AXIS,m_chart);
                 }
                 QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&)));
                 QObject::connect(axis,SIGNAL(update(QChartAxis*)),item,SLOT(handleAxisUpdate(QChartAxis*)));
                 item->handleAxisUpdate(axis);
                 item->handleGeometryChanged(m_rect);
                 m_chartTheme->decorate(axis,item);
                 m_axisItems.insert(axis,item);
             }
             void ChartPresenter::handleAxisRemoved(QChartAxis* axis)
             {
                 AxisItem* item = m_axisItems.take(axis);
                 Q_ASSERT(item);
                 delete item;
             }
             void ChartPresenter::handleSeriesAdded(QChartSeries* series)
             {
                 switch(series->type())
                 {
                     case QChartSeries::SeriesTypeLine: {
                         QLineChartSeries* lineSeries = static_cast<QLineChartSeries*>(series);
                         LineChartItem* item = new LineChartAnimationItem(this,lineSeries,m_chart);
                         m_chartTheme->decorate(item,lineSeries,m_chartItems.count());
                         QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&)));
                         QObject::connect(lineSeries,SIGNAL(changed(int)),item,SLOT(handleModelChanged(int)));
                         m_chartItems.insert(series,item);
                         break;
                     }
                     case QChartSeries::SeriesTypeBar: {
                         QBarChartSeries* barSeries = static_cast<QBarChartSeries*>(series);
-                        BarPresenter* item = new BarPresenter(barSeries->model(),m_chart);
+                        BarPresenter* item = new BarPresenter(barSeries,m_chart);
                         m_chartTheme->decorate(item,barSeries,m_chartItems.count());
                         QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&)));
                         QObject::connect(barSeries,SIGNAL(changed(int)),item,SLOT(handleModelChanged(int)));
                         m_chartItems.insert(series,item);
                         // m_axisXItem->setVisible(false);
                         break;
                     }
                     case QChartSeries::SeriesTypeStackedBar: {
                         QStackedBarChartSeries* stackedBarSeries = static_cast<QStackedBarChartSeries*>(series);
-                        StackedBarPresenter* item = new StackedBarPresenter(stackedBarSeries->model(),m_chart);
+                        StackedBarPresenter* item = new StackedBarPresenter(stackedBarSeries,m_chart);
                         m_chartTheme->decorate(item,stackedBarSeries,m_chartItems.count());
                         QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&)));
                         QObject::connect(stackedBarSeries,SIGNAL(changed(int)),item,SLOT(handleModelChanged(int)));
                         m_chartItems.insert(series,item);
                         break;
                     }
                     case QChartSeries::SeriesTypePercentBar: {
                         QPercentBarChartSeries* percentBarSeries = static_cast<QPercentBarChartSeries*>(series);
-                        PercentBarPresenter* item = new PercentBarPresenter(percentBarSeries->model(),m_chart);
+                        PercentBarPresenter* item = new PercentBarPresenter(percentBarSeries,m_chart);
                         m_chartTheme->decorate(item,percentBarSeries ,m_chartItems.count());
                         QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&)));
                         QObject::connect(percentBarSeries,SIGNAL(changed(int)),item,SLOT(handleModelChanged(int)));
                         m_chartItems.insert(series,item);
                         break;
                     }
                     case QChartSeries::SeriesTypeScatter: {
                         QScatterSeries *scatterSeries = qobject_cast<QScatterSeries *>(series);
                         ScatterPresenter *scatterPresenter = new ScatterPresenter(scatterSeries, m_chart);
                         QObject::connect(this, SIGNAL(geometryChanged(const QRectF&)),
                                          scatterPresenter, SLOT(handleGeometryChanged(const QRectF&)));
                         m_chartTheme->decorate(scatterPresenter, scatterSeries, m_chartItems.count());
                         m_chartItems.insert(scatterSeries, scatterPresenter);
                         break;
                     }
                     case QChartSeries::SeriesTypePie: {
                         QPieSeries *s = qobject_cast<QPieSeries *>(series);
                         PiePresenter* pie = new PiePresenter(m_chart, s);
                         m_chartTheme->decorate(pie, s, m_chartItems.count());
                         QObject::connect(this, SIGNAL(geometryChanged(const QRectF&)), pie, SLOT(handleGeometryChanged(const QRectF&)));
                         m_chartItems.insert(series, pie);
                         break;
                     }
                     default: {
                         qDebug()<< "Series type" << series->type() << "not implemented.";
                         break;
                     }
                 }
                 if(m_rect.isValid()) emit geometryChanged(m_rect);
             }
             void ChartPresenter::handleSeriesRemoved(QChartSeries* series)
             {
             	ChartItem* item = m_chartItems.take(series);
             	delete item;
             }
             void ChartPresenter::handleSeriesChanged(QChartSeries* series)
             {
                 //TODO:
             }
             void ChartPresenter::handleSeriesDomainChanged(QChartSeries* series, const Domain& domain)
             {
                 m_chartItems.value(series)->handleDomainChanged(domain);
             }
             void ChartPresenter::handleAxisLabelsChanged(QChartAxis* axis,const QStringList& labels)
             {
                 m_axisItems.value(axis)->handleLabelsChanged(axis,labels);
             }
             void ChartPresenter::setChartTheme(QChart::ChartTheme theme)
             {
                 delete m_chartTheme;
                 m_chartTheme = ChartTheme::createTheme(theme);
                 m_chartTheme->decorate(m_chart);
                 QMapIterator<QChartSeries*,ChartItem*> i(m_chartItems);
                 int index=0;
                 while (i.hasNext()) {
                     i.next();
                     index++;
                     m_chartTheme->decorate(i.value(),i.key(),index);
                 }
                 QMapIterator<QChartAxis*,AxisItem*> j(m_axisItems);
                 while (j.hasNext()) {
                         j.next();
                         m_chartTheme->decorate(j.key(),j.value());
                 }
             }
             QChart::ChartTheme ChartPresenter::chartTheme()
             {
                 return m_chartTheme->id();
             }
             #include "moc_chartpresenter_p.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