HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r655:7ed6749a4b0d

Barchart updates on BarSet->SetValue now

Marek Rosa -

r655:7ed6749a4b0d

parent child

Context file:

r655:7ed6749a4b0d

Collapse all files

examples/tablemodelchart/tablewidget.cpp +3 -3

             #include "tablewidget.h"
             #include <QGridLayout>
             #include <QTableView>
             #include <QStyledItemDelegate>
             #include "qlineseries.h"
             #include "qsplineseries.h"
             #include "qscatterseries.h"
             #include "customtablemodel.h"
             #include "qpieseries.h"
             #include "qareaseries.h"
             #include "qbarseries.h"
             #include <QPushButton>
             #include <QRadioButton>
             #include <QTime>
             TableWidget::TableWidget(QWidget *parent)
                 : QWidget(parent)
             {
                 setGeometry(100, 100, 1000, 600);
                 qsrand(QTime(0,0,0).secsTo(QTime::currentTime()));
                 // create simple model for storing data
                 // user's table data model
                 m_model = new CustomTableModel;
                 tableView = new QTableView;
                 tableView->setModel(m_model);
                 tableView->setMinimumHeight(240);
             //    tableView->setMinimumSize(340, 480);
             //    tableView->setItemDelegate(new QStyledItemDelegate);
                 chartView = new QChartView(this);
                 chartView->setRenderHint(QPainter::Antialiasing);
                 chartView->setMinimumSize(640, 480);
                 // create
             //    QLineSeries* series = new QLineSeries;
             //    QSplineSeries* series = new QSplineSeries;
             //    QScatterSeries* series = new QScatterSeries;
             //    series->setModel(m_model);
             //    series->setModelMapping(0,1, Qt::Vertical);
             //    QPieSeries* pieSeries = new QPieSeries;
             //    pieSeries->setModel(model);
             //    pieSeries
             //    chartView->addSeries(series);
                 // add, remove data buttons
                 QPushButton* addRowAboveButton = new QPushButton("Add row above");
                 connect(addRowAboveButton, SIGNAL(clicked()), this, SLOT(addRowAbove()));
                 QPushButton* addRowBelowButton = new QPushButton("Add row below");
                 connect(addRowBelowButton, SIGNAL(clicked()), this, SLOT(addRowBelow()));
                 QPushButton* removeRowButton = new QPushButton("Remove row");
                 connect(removeRowButton, SIGNAL(clicked()), this, SLOT(removeRow()));
                 // buttons layout
                 QVBoxLayout* buttonsLayout = new QVBoxLayout;
                 buttonsLayout->addWidget(addRowAboveButton);
                 buttonsLayout->addWidget(addRowBelowButton);
                 buttonsLayout->addWidget(removeRowButton);
                 buttonsLayout->addStretch();
                 // chart type radio buttons
                 lineRadioButton = new QRadioButton("Line");
                 splineRadioButton = new QRadioButton("Spline");
                 scatterRadioButton = new QRadioButton("Scatter");
                 pieRadioButton = new QRadioButton("Pie");
                 areaRadioButton = new QRadioButton("Area");
                 barRadioButton = new QRadioButton("Bar");
                 connect(lineRadioButton, SIGNAL(toggled(bool)), this, SLOT(updateChartType()));
                 connect(splineRadioButton, SIGNAL(toggled(bool)), this, SLOT(updateChartType()));
                 connect(scatterRadioButton, SIGNAL(toggled(bool)), this, SLOT(updateChartType()));
                 connect(pieRadioButton, SIGNAL(toggled(bool)), this, SLOT(updateChartType()));
                 connect(areaRadioButton, SIGNAL(toggled(bool)), this, SLOT(updateChartType()));
                 connect(barRadioButton, SIGNAL(toggled(bool)), this, SLOT(updateChartType()));
                 lineRadioButton->setChecked(true);
                 // radio buttons layout
                 QVBoxLayout* radioLayout = new QVBoxLayout;
                 radioLayout->addWidget(lineRadioButton);
                 radioLayout->addWidget(splineRadioButton);
                 radioLayout->addWidget(scatterRadioButton);
                 radioLayout->addWidget(pieRadioButton);
                 radioLayout->addWidget(areaRadioButton);
                 radioLayout->addWidget(barRadioButton);
                 radioLayout->addStretch();
                 // create main layout
                 QGridLayout* mainLayout = new QGridLayout;
                 mainLayout->addLayout(buttonsLayout, 1, 0);
                 mainLayout->addLayout(radioLayout, 2, 0);
                 mainLayout->addWidget(tableView, 1, 1);
                 mainLayout->addWidget(chartView, 2, 1);
                 setLayout(mainLayout);
                 lineRadioButton->setFocus();
             }
             void TableWidget::addRowAbove()
             {
             //    m_model->insertRow(m_model->rowCount());
                 m_model->insertRow(tableView->currentIndex().row());
             }
             void TableWidget::addRowBelow()
             {
             //    m_model->insertRow(m_model->rowCount());
                 m_model->insertRow(tableView->currentIndex().row() + 1);
             }
             void TableWidget::removeRow()
             {
             //    m_model->removeRow(m_model->rowCount() - 1);
                 m_model->removeRow(tableView->currentIndex().row());
             }
             void TableWidget::updateChartType()
             {
                 chartView->removeAllSeries();
                 if (lineRadioButton->isChecked())
                 {
                     // series 1
                     series = new QLineSeries;
                     series->setModel(m_model);
                     series->setModelMapping(0,1, Qt::Vertical);
             //        series->setModelMapping(0,1, Qt::Horizontal);
                     chartView->addSeries(series);
                     // series 2
                     series = new QLineSeries;
                     series->setModel(m_model);
                     series->setModelMapping(2,3, Qt::Vertical);
             //        series->setModelMapping(2,3, Qt::Horizontal);
                     chartView->addSeries(series);
                     // series 3
                     series = new QLineSeries;
                     series->setModel(m_model);
                     series->setModelMapping(4,5, Qt::Vertical);
             //        series->setModelMapping(4,5, Qt::Horizontal);
                     chartView->addSeries(series);
                 }
                 else if (splineRadioButton->isChecked())
                 {
                     // series 1
                     series = new QSplineSeries;
                     series->setModel(m_model);
                     series->setModelMapping(0,1, Qt::Vertical);
             //        series->setModelMapping(0,1, Qt::Horizontal);
                     chartView->addSeries(series);
                     // series 2
                     series = new QSplineSeries;
                     series->setModel(m_model);
                     series->setModelMapping(2,3, Qt::Vertical);
             //        series->setModelMapping(2,3, Qt::Horizontal);
                     chartView->addSeries(series);
                     // series 3
                     series = new QSplineSeries;
                     series->setModel(m_model);
                     series->setModelMapping(4,5, Qt::Vertical);
             //        series->setModelMapping(4,5, Qt::Horizontal);
                     chartView->addSeries(series);
                 }
                 else if (scatterRadioButton->isChecked())
                 {
                     // series 1
                     series = new QScatterSeries;
                     series->setModel(m_model);
                     series->setModelMapping(0,1, Qt::Vertical);
             //        series->setModelMapping(0,1, Qt::Horizontal);
                     chartView->addSeries(series);
                     // series 2
                     series = new QScatterSeries;
                     series->setModel(m_model);
                     series->setModelMapping(2,3, Qt::Vertical);
             //        series->setModelMapping(2,3, Qt::Horizontal);
                     chartView->addSeries(series);
                     // series 3
                     series = new QScatterSeries;
                     series->setModel(m_model);
                     series->setModelMapping(4,5, Qt::Vertical);
             //        series->setModelMapping(4,5, Qt::Horizontal);
                     chartView->addSeries(series);
                 }
                 else if (pieRadioButton->isChecked())
                 {
                     // pie 1
                     QPieSeries* pieSeries = new QPieSeries;
                     pieSeries->setModel(m_model);
-                    pieSeries->setModelMapping(0,0, Qt::Horizontal);
+                    pieSeries->setModelMapping(0,0, Qt::Vertical);
                     pieSeries->setLabelsVisible(true);
                     pieSeries->setPieSize(0.4);
                     pieSeries->setPiePosition(0.2, 0.35);
                     chartView->addSeries(pieSeries);
                     // pie 2
                     pieSeries = new QPieSeries;
                     pieSeries->setModel(m_model);
-                    pieSeries->setModelMapping(1,1, Qt::Horizontal);
+                    pieSeries->setModelMapping(1,1, Qt::Vertical);
                     pieSeries->setLabelsVisible(true);
                     pieSeries->setPieSize(0.4);
                     pieSeries->setPiePosition(0.8, 0.35);
                     chartView->addSeries(pieSeries);
                     // pie 3
                     pieSeries = new QPieSeries;
                     pieSeries->setModel(m_model);
-                    pieSeries->setModelMapping(2,2, Qt::Horizontal);
+                    pieSeries->setModelMapping(2,2, Qt::Vertical);
                     pieSeries->setLabelsVisible(true);
                     pieSeries->setPieSize(0.4);
                     pieSeries->setPiePosition(0.5, 0.65);
                     chartView->addSeries(pieSeries);
                 }
                 else if (areaRadioButton->isChecked())
                 {
                     QLineSeries* upperLineSeries = new QLineSeries;
                     upperLineSeries->setModel(m_model);
                     upperLineSeries->setModelMapping(0, 1, Qt::Vertical);
                     QLineSeries* lowerLineSeries = new QLineSeries;
                     lowerLineSeries->setModel(m_model);
                     lowerLineSeries->setModelMapping(2, 3, Qt::Vertical);
                     QAreaSeries* areaSeries = new QAreaSeries(upperLineSeries, lowerLineSeries);
                     chartView->addSeries(areaSeries);
                 }
                 else if (barRadioButton->isChecked())
                 {
                     QBarSeries* barSeries = new QBarSeries(QStringList());
                     barSeries->setModel(m_model);
                     barSeries->setModelMapping(5, 2, 4, Qt::Vertical);
                     barSeries->setToolTipEnabled(true);
                     chartView->addSeries(barSeries);
                 }
             //    series->setModel(m_model);
             //    series->setModelMapping(0,1, Qt::Vertical);
             //    chartView->addSeries(series);
             }
             TableWidget::~TableWidget()
             {
             }

src/barchart/barpresenter.cpp +2 0

             #include "barpresenter_p.h"
             #include "bar_p.h"
             #include "barvalue_p.h"
             #include "qbarset.h"
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             BarPresenter::BarPresenter(QBarSeries *series, QChart *parent) :
                 BarPresenterBase(series, parent)
             {
+                connect(series, SIGNAL(updatedBars()), this, SLOT(layoutChanged()));
             }
             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;
                 qreal categoryWidth = tW/tC;
                 mBarWidth = categoryWidth / (setCount+1);
                 int itemIndex(0);
                 for (int category=0; category < categoryCount; category++) {
                     qreal xPos = categoryWidth * category + categoryWidth /2 + mBarWidth/2;
                     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;
                     }
                 }
                 // Position floating values
                 itemIndex = 0;
                 for (int category=0; category < mSeries->categoryCount(); category++) {
                     qreal xPos = categoryWidth * category + categoryWidth/2 + mBarWidth;
                     qreal yPos = mHeight;
                     for (int set=0; set < mSeries->barsetCount(); set++) {
                         qreal barHeight = mSeries->valueAt(set,category) * scale;
                         BarValue* value = mFloatingValues.at(itemIndex);
                         QBarSet* barSet = mSeries->barsetAt(set);
                         value->resize(100,50);  // TODO: proper layout for this.
                         value->setPos(xPos, yPos-barHeight/2);
                         value->setPen(barSet->floatingValuePen());
                         if (mSeries->valueAt(set,category) != 0) {
                             value->setValueString(QString::number(mSeries->valueAt(set,category)));
                         } else {
                             value->setValueString(QString(""));
                         }
                         itemIndex++;
                         xPos += mBarWidth;
                     }
                 }
+                update();
             }
             #include "moc_barpresenter_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/barpresenterbase_p.h +1 0

             #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 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, QChart *parent = 0);
                 virtual ~BarPresenterBase();
             public:
                 // From QGraphicsItem
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
                 QRectF boundingRect() const;
                 // TODO: Consider the domain for layoutChanged. May be use case, may not be. If it is, then the derived classes need to implement it
                 virtual void dataChanged();     // data of series has changed -> need to recalculate bar sizes
+            private slots:
                 virtual void layoutChanged() = 0;   // layout has changed -> need to recalculate bar sizes
             protected:
                 void initAxisLabels();
             public slots:
                 void handleModelChanged(int index);
                 void handleDomainChanged(qreal minX, qreal maxX, qreal minY, qreal maxY);
                 void handleGeometryChanged(const QRectF& size);
                 // Internal slots
                 void showToolTip(QPoint pos, QString tip);      // shows tooltip (if enabled)
             protected:
                 // TODO: consider these.
                 int mHeight;        // Layout spesific
                 int mWidth;
                 qreal mBarWidth;
                 bool mLayoutSet;    // True, if component has been laid out.
                 // Not owned.
                 QBarSeries* mSeries;
                 QList<Bar*> mBars;
                 QList<BarValue*> mFloatingValues;
                 QChart* mChart;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // BARPRESENTERBASE_H

src/barchart/qbarseries.cpp +2 -2

             #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))
             {
                 m_model = NULL;
                 m_mapCategories = -1;
                 m_mapBarBottom = -1;
                 m_mapBarTop = -1;
                 m_mapOrientation = Qt::Vertical;
             }
             /*!
                 Adds a set of bars to series. Takes ownership of \a set.
                 Connects the clicked(QString) and rightClicked(QString) signals
                 of \a set to this series
             */
             void QBarSeries::addBarSet(QBarSet *set)
             {
                 mModel->addBarSet(set);
                 connect(set,SIGNAL(clicked(QString)),this,SLOT(barsetClicked(QString)));
                 connect(set,SIGNAL(rightClicked(QString)),this,SLOT(barsetRightClicked(QString)));
-                connect(set, SIGNAL(changed()), this, SLOT(barsetChanged()));
+                connect(set, SIGNAL(valueChanged()), this, SLOT(barsetChanged()));
             }
             /*!
                 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()
             {
             //    if(m_model)
             //        return m_mapBarTop - m_mapBarBottom;
             //    else
                     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);
             }
             /*!
                 \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)));
                     }
                 }
             }
             /*!
                 \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;
             }
             bool QBarSeries::setModel(QAbstractItemModel* model)
             {
                 // disconnect signals from old model
                 if(m_model)
                 {
                     disconnect(m_model, 0, this, 0);
                     m_mapCategories = -1;
                     m_mapBarBottom = -1;
                     m_mapBarTop = -1;
                     m_mapOrientation = Qt::Vertical;
                 }
                 // set new model
                 if(model)
                 {
                     m_model = model;
                     return true;
                 }
                 else
                 {
                     m_model = NULL;
                     return false;
                 }
             }
             // TODO
             void QBarSeries::setModelMapping(int categories, int bottomBoundry, int topBoundry, Qt::Orientation orientation)
             {
                 if (m_model == NULL)
                     return;
                 m_mapCategories = categories;
                 m_mapBarBottom = bottomBoundry;
                 m_mapBarTop = topBoundry;
                 m_mapOrientation = orientation;
                 // connect the signals
                 if (m_mapOrientation == Qt::Vertical)
                 {
                     connect(m_model,SIGNAL(dataChanged(QModelIndex,QModelIndex)), this, SLOT(modelUpdated(QModelIndex, QModelIndex)));
                     connect(m_model,SIGNAL(rowsInserted(QModelIndex, int, int)), this, SLOT(modelDataAdded(QModelIndex,int,int)));
                     connect(m_model, SIGNAL(rowsRemoved(QModelIndex, int, int)), this, SLOT(modelDataRemoved(QModelIndex,int,int)));
                 }
                 else
                 {
                     connect(m_model,SIGNAL(dataChanged(QModelIndex,QModelIndex)), this, SLOT(modelUpdated(QModelIndex, QModelIndex)));
                     connect(m_model,SIGNAL(columnsInserted(QModelIndex, int, int)), this, SLOT(modelDataAdded(QModelIndex,int,int)));
                     connect(m_model, SIGNAL(columnsRemoved(QModelIndex, int, int)), this, SLOT(modelDataRemoved(QModelIndex,int,int)));
                 }
                 // create the initial bars
                 delete mModel;
                 if (m_mapOrientation == Qt::Vertical)
                 {
                     QStringList categories;
                     for (int k = 0; k < m_model->rowCount(); k++)
                         categories << m_model->data(m_model->index(k, m_mapCategories), Qt::DisplayRole).toString();
                     mModel = new BarChartModel(categories, this);
                     for (int i = m_mapBarBottom; i <= m_mapBarTop; i++)
                     {
                         QBarSet* barSet = new QBarSet(QString("Column: %1").arg(i + 1));
                         for(int m = 0; m < m_model->rowCount(); m++)
                             *barSet << m_model->data(m_model->index(m, i), Qt::DisplayRole).toDouble();
                         addBarSet(barSet);
                     }
                 }
                 else
                 {
                     QStringList categories;
                     for (int k = 0; k < m_model->columnCount(); k++)
                         categories << m_model->data(m_model->index(m_mapCategories, k), Qt::DisplayRole).toString();
                     mModel = new BarChartModel(categories, this);
                     for (int i = m_mapBarBottom; i <= m_mapBarTop; i++)
                     {
                         QBarSet* barSet = new QBarSet(QString("Row: %1").arg(i + 1));
                         for(int m = 0; m < m_model->columnCount(); m++)
                             *barSet << m_model->data(m_model->index(i, m), Qt::DisplayRole).toDouble();
                         addBarSet(barSet);
                     }
                 }
             }
             void QBarSeries::modelUpdated(QModelIndex topLeft, QModelIndex bottomRight)
             {
                 Q_UNUSED(bottomRight)
                 if (m_mapOrientation == Qt::Vertical)
                 {
                     if (topLeft.column() >= m_mapBarBottom && topLeft.column() <= m_mapBarTop)
                         barsetAt(topLeft.column() - m_mapBarBottom)->setValue(topLeft.row(), m_model->data(topLeft, Qt::DisplayRole).toDouble());
             //        else if (topLeft.column() == m_mapCategories)
             //            slices().at(topLeft.row())->setLabel(m_model->data(topLeft, Qt::DisplayRole).toString());
                 }
                 else
                 {
                     if (topLeft.row() >= m_mapBarBottom && topLeft.row() <= m_mapBarTop)
                         barsetAt(topLeft.row() - m_mapBarBottom)->setValue(topLeft.column(), m_model->data(topLeft, Qt::DisplayRole).toDouble());
             //        else if (topLeft.row() == m_mapCategories)
             //            slices().at(topLeft.column())->setLabel(m_model->data(topLeft, Qt::DisplayRole).toString());
                 }
             }
             void QBarSeries::modelDataAdded(QModelIndex /*parent*/, int /*start*/, int /*end*/)
             {
                 //
             }
             void QBarSeries::modelDataRemoved(QModelIndex /*parent*/, int /*start*/, int /*end*/)
             {
                 //
             }
             void QBarSeries::barsetChanged()
             {
-            //    mModel->
+                emit updatedBars();
             }
             #include "moc_qbarseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/qbarseries.h +4 -1

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

src/barchart/qbarset.cpp +4 -3

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

src/barchart/qbarset.h +2 -1

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