HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r1331:c415cc6dbfb2

Added placeholders for mappers documentation

Marek Rosa -

r1331:c415cc6dbfb2

parent child

Context file:

r1331:c415cc6dbfb2

Collapse all files

doc/src/classes.qdoc +7 -1

             /*!
                 \page classes.html
                 \title QtCommercial Charts API
                 \keyword All Classes
                 \image class_diagram.png
                 Charts API is build on top of Qt Graphics View Framework. Charts can be displayed as QGraphicsWidget using QChart class. However
                 there is also convenience class QChartView which is QWidget based. These lets quickly use QCharts as normal Qt widget.
                 The API supports following chart types:
                  \list
                  \o area
                  \o line
                  \o bar
                  \o percent bar
                  \o pie
                  \o scatter
                  \o spline
                  \o stacked bar
                  \endlist
                 Each chart type is represented by QSeries derived class. To create given chart type users have to use instace of releted sereis class and add it to QChart/QChartView instance.
                 \code
                 QLineSeries* series = new QLineSeries();
                 series->add(0, 6);
                 series->add(2, 4);
                 ...
                 chartView->addSeries(series);
                 \endcode
                 \raw HTML
                     <table cellpadding="2" cellspacing="1" border="0" width="100%" class="indextable">
                     <tr>
                     <th class="titleheader" width="33%">
                     List of classes
                     </th>
                     </tr>
                     <tr>
                     <td valign="top">
                     <ul>
                         <li><a href="qareaseries.html">QAreaSeries</a></li>
                         <li><a href="qbarseries.html">QBarSeries</a></li>
                         <li><a href="qbarset.html">QBarSet</a></li>
                         <li><a href="qchart.html">QChart</a></li>
                         <li><a href="qaxis.html">QAxis</a></li>
                         <li><a href="qchartview.html">QChartView</a></li>
                         <li><a href="qlineseries.html">QLineSeries</a></li>
                         <li><a href="qpercentbarseries.html">QPercentBarSeries</a></li>
                         <li><a href="qpieseries.html">QPieSeries</a></li>
                         <li><a href="qpieslice.html">QPieSlice</a></li>
                         <li><a href="qscatterseries.html">QScatterSeries</a></li>
                         <li><a href="qabstractseries.html">QAbstractSeries</a></li>
                         <li><a href="qsplineseries.html">QSplineSeries</a></li>
                         <li><a href="qstackedbarseries.html">QStackedBarSeries</a></li>
                         <li><a href="qxyseries.html">QXYSeries</a></li>
-            			<li><a href="qlegend.html">QLegend</a></li>
+                        <li><a href="qlegend.html">QLegend</a></li>
+            	    <li><a href="qhpiemodelmapper.html">QHPieModelMapper</a></li>
+            	    <li><a href="qvpiemodelmapper.html">QVPieModelMapper</a></li>
+            	    <li><a href="qhbarmodelmapper.html">QHBarModelMapper</a></li>
+            	    <li><a href="qvbarmodelmapper.html">QVBarModelMapper</a></li>
+            	    <li><a href="qhxymodelmapper.html">QHXYModelMapper</a></li>
+            	    <li><a href="qvxymodelmapper.html">QVXYModelMapper</a></li>
                     </ul>
                     </td>
                     </tr>
                     </table>
                     <table cellpadding="2" cellspacing="1" border="0" width="100%" class="indextable">
                     <tr>
                     <th class="titleheader" width="33%">
                     Other files:
                     </th>
                     </tr>
                     <tr>
                     <td valign="top">
                     <ul>
                         <li><a href="qchartglobal.html">QChartGlobal</a></li>
                     </ul>
                     </td>
                     </tr>
                     </table>
                 \endraw
             */

src/barchart/qbarmodelmapper.cpp +11 -6

             #include "qbarmodelmapper.h"
             #include "qbarmodelmapper_p.h"
             #include "qbarseries.h"
             #include "qbarset.h"
+            #include "qchart.h"
+            #include "qaxis.h"
             #include <QAbstractItemModel>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             QBarModelMapper::QBarModelMapper(QObject *parent) :
                 QObject(parent),
                 d_ptr(new QBarModelMapperPrivate(this))
             {
             }
             QAbstractItemModel* QBarModelMapper::model() const
             {
                 Q_D(const QBarModelMapper);
                 return d->m_model;
             }
             void QBarModelMapper::setModel(QAbstractItemModel *model)
             {
                 if (model == 0)
                     return;
                 Q_D(QBarModelMapper);
                 if (d->m_model) {
                     disconnect(d->m_model, 0, d, 0);
                 }
                 d->m_model = model;
                 d->initializeBarFromModel();
                 //    connect signals from the model
                 connect(d->m_model, SIGNAL(dataChanged(QModelIndex,QModelIndex)), d, SLOT(modelUpdated(QModelIndex,QModelIndex)));
                 connect(d->m_model, SIGNAL(rowsInserted(QModelIndex,int,int)), d, SLOT(modelRowsAdded(QModelIndex,int,int)));
                 connect(d->m_model, SIGNAL(rowsRemoved(QModelIndex,int,int)), d, SLOT(modelRowsRemoved(QModelIndex,int,int)));
                 connect(d->m_model, SIGNAL(columnsInserted(QModelIndex,int,int)), d, SLOT(modelColumnsAdded(QModelIndex,int,int)));
                 connect(d->m_model, SIGNAL(columnsRemoved(QModelIndex,int,int)), d, SLOT(modelColumnsRemoved(QModelIndex,int,int)));
             }
             QBarSeries* QBarModelMapper::series() const
             {
                 Q_D(const QBarModelMapper);
                 return d->m_series;
             }
             void QBarModelMapper::setSeries(QBarSeries *series)
             {
                 Q_D(QBarModelMapper);
                 if (d->m_series) {
                     disconnect(d->m_series, 0, d, 0);
                 }
                 if (series == 0)
                     return;
                 d->m_series = series;
                 d->initializeBarFromModel();
                 // connect the signals from the series
                 //    connect(d->m_series, SIGNAL(pointAdded(int)), d, SLOT(handlePointAdded(int)));
                 //    connect(d->m_series, SIGNAL(pointRemoved(int)), d, SLOT(handlePointRemoved(int)));
                 //    connect(d->m_series, SIGNAL(pointReplaced(int)), d, SLOT(handlePointReplaced(int)));
             }
             int QBarModelMapper::first() const
             {
                 Q_D(const QBarModelMapper);
                 return d->m_first;
             }
             void QBarModelMapper::setFirst(int first)
             {
                 Q_D(QBarModelMapper);
                 d->m_first = qMax(first, 0);
                 d->initializeBarFromModel();
             }
             int QBarModelMapper::count() const
             {
                 Q_D(const QBarModelMapper);
                 return d->m_count;
             }
             void QBarModelMapper::setCount(int count)
             {
                 Q_D(QBarModelMapper);
                 d->m_count = qMax(count, -1);
                 d->initializeBarFromModel();
             }
             Qt::Orientation QBarModelMapper::orientation() const
             {
                 Q_D(const QBarModelMapper);
                 return d->m_orientation;
             }
             void QBarModelMapper::setOrientation(Qt::Orientation orientation)
             {
                 Q_D(QBarModelMapper);
                 d->m_orientation = orientation;
                 d->initializeBarFromModel();
             }
             int QBarModelMapper::firstBarSetSection() const
             {
                 Q_D(const QBarModelMapper);
                 return d->m_firstBarSetSection;
             }
             void QBarModelMapper::setFirstBarSetSection(int firstBarSetSection)
             {
                 Q_D(QBarModelMapper);
                 d->m_firstBarSetSection = firstBarSetSection;
                 d->initializeBarFromModel();
             }
             int QBarModelMapper::lastBarSetSection() const
             {
                 Q_D(const QBarModelMapper);
                 return d->m_lastBarSetSection;
             }
             void QBarModelMapper::setLastBarSetSection(int lastBarSetSection)
             {
                 Q_D(QBarModelMapper);
                 d->m_lastBarSetSection = lastBarSetSection;
                 d->initializeBarFromModel();
             }
             int QBarModelMapper::categoriesSection() const
             {
                 Q_D(const QBarModelMapper);
                 return d->m_categoriesSection;
             }
             void QBarModelMapper::setCategoriesSection(int categoriesSection)
             {
                 Q_D(QBarModelMapper);
                 d->m_categoriesSection = categoriesSection;
                 d->initializeBarFromModel();
             }
             void QBarModelMapper::reset()
             {
                 Q_D(QBarModelMapper);
                 d->m_first = 0;
                 d->m_count = -1;
-                d->m_orientation = Qt::Vertical;
                 d->m_firstBarSetSection = -1;
                 d->m_lastBarSetSection = -1;
                 d->m_categoriesSection = -1;
                 d->initializeBarFromModel();
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QBarModelMapperPrivate::QBarModelMapperPrivate(QBarModelMapper *q) :
                 m_series(0),
                 m_model(0),
                 m_first(0),
                 m_count(-1),
                 m_orientation(Qt::Vertical),
                 m_firstBarSetSection(-1),
                 m_lastBarSetSection(-1),
                 m_categoriesSection(-1),
                 m_seriesSignalsBlock(false),
                 m_modelSignalsBlock(false),
                 q_ptr(q)
             {
             }
             void QBarModelMapperPrivate::blockModelSignals(bool block)
             {
                 m_modelSignalsBlock = block;
             }
             void QBarModelMapperPrivate::blockSeriesSignals(bool block)
             {
                 m_seriesSignalsBlock = block;
             }
             QBarSet* QBarModelMapperPrivate::barSet(QModelIndex index)
             {
                 if (!index.isValid())
                     return 0;
                 if (m_orientation == Qt::Vertical && index.column() >= m_firstBarSetSection && index.column() <= m_lastBarSetSection) {
-                    if (index.row() >= m_first && (m_count == - 1 || index.row() < m_first + m_count))
+                    if (index.row() >= m_first && (m_count == - 1 || index.row() < m_first + m_count)) {
-                        return m_series->barSets().at(index.column() - m_firstBarSetSection);
+            //            if (m_model->index(index.row(), m_valuesSection).isValid() && m_model->index(index.row(), m_labelsSection).isValid())
+                            return m_series->barSets().at(index.column() - m_firstBarSetSection);
+            //            else
+            //                return 0;
+                    }
                 } else if (m_orientation == Qt::Horizontal && index.row() >= m_firstBarSetSection && index.row() <= m_lastBarSetSection) {
                     if (index.column() >= m_first && (m_count == - 1 || index.column() < m_first + m_count))
                         return m_series->barSets().at(index.row() - m_firstBarSetSection);
                 }
                 return 0; // This part of model has not been mapped to any slice
             }
             QModelIndex QBarModelMapperPrivate::barModelIndex(int barSection, int posInBar)
             {
                 if (m_count != -1 && posInBar >= m_count)
                     return QModelIndex(); // invalid
                 if (barSection < m_firstBarSetSection || barSection > m_lastBarSetSection)
                     return QModelIndex(); // invalid
                 if (m_orientation == Qt::Vertical)
                     return m_model->index(posInBar + m_first, barSection);
                 else
                     return m_model->index(barSection, posInBar + m_first);
             }
             QModelIndex QBarModelMapperPrivate::categoriesModelIndex(int posInCategories)
             {
                 if (m_count != -1 && posInCategories >= m_count)
                     return QModelIndex(); // invalid
                 if (m_orientation == Qt::Vertical)
                     return m_model->index(posInCategories + m_first, m_categoriesSection);
                 else
                     return m_model->index(m_categoriesSection, posInCategories + m_first);
             }
             void QBarModelMapperPrivate::modelUpdated(QModelIndex topLeft, QModelIndex bottomRight)
             {
                 Q_UNUSED(topLeft)
                 Q_UNUSED(bottomRight)
                 if (m_model == 0 || m_series == 0)
                     return;
                 if (m_modelSignalsBlock)
                     return;
                 blockSeriesSignals();
                 QModelIndex index;
                 //    QPointF oldPoint;
                 //    QPointF newPoint;
                 for (int row = topLeft.row(); row <= bottomRight.row(); row++) {
                     for (int column = topLeft.column(); column <= bottomRight.column(); column++) {
                         index = topLeft.sibling(row, column);
                         QBarSet* bar = barSet(index);
                         if (bar) {
                             if (m_orientation == Qt::Vertical)
                                 bar->replace(row - m_first, m_model->data(index).toReal());
                             else
                                 bar->replace(column - m_first, m_model->data(index).toReal());
                         }
                     }
                 }
                 blockSeriesSignals(false);
             }
             void QBarModelMapperPrivate::modelRowsAdded(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent);
                 Q_UNUSED(end)
                 if (m_modelSignalsBlock)
                     return;
                 blockSeriesSignals();
                 if (m_orientation == Qt::Vertical)
                     //        insertData(start, end);
                     initializeBarFromModel();
                 else if (start <= m_firstBarSetSection || start <= m_lastBarSetSection || start <= m_categoriesSection) // if the changes affect the map - reinitialize
                     initializeBarFromModel();
                 blockSeriesSignals(false);
             }
             void QBarModelMapperPrivate::modelRowsRemoved(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent);
                 Q_UNUSED(end)
                 if (m_modelSignalsBlock)
                     return;
                 blockSeriesSignals();
                 if (m_orientation == Qt::Vertical)
                     //        removeData(start, end);
                     initializeBarFromModel();
                 else if (start <= m_firstBarSetSection || start <= m_lastBarSetSection || start <= m_categoriesSection) // if the changes affect the map - reinitialize
                     initializeBarFromModel();
                 blockSeriesSignals(false);
             }
             void QBarModelMapperPrivate::modelColumnsAdded(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent);
                 Q_UNUSED(end)
                 if (m_modelSignalsBlock)
                     return;
                 blockSeriesSignals();
                 if (m_orientation == Qt::Horizontal)
                     //        insertData(start, end);
                     initializeBarFromModel();
                 else if (start <= m_firstBarSetSection || start <= m_lastBarSetSection || start <= m_categoriesSection) // if the changes affect the map - reinitialize
                     initializeBarFromModel();
                 blockSeriesSignals(false);
             }
             void QBarModelMapperPrivate::modelColumnsRemoved(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent);
                 Q_UNUSED(end)
                 if (m_modelSignalsBlock)
                     return;
                 blockSeriesSignals();
                 if (m_orientation == Qt::Horizontal)
                     //        removeData(start, end);
                     initializeBarFromModel();
                 else if (start <= m_firstBarSetSection || start <= m_lastBarSetSection || start <= m_categoriesSection) // if the changes affect the map - reinitialize
                     initializeBarFromModel();
                 blockSeriesSignals(false);
             }
             void QBarModelMapperPrivate::insertData(int start, int end)
             {
                 Q_UNUSED(end)
                 if (m_model == 0 || m_series == 0)
                     return;
                 if (m_count != -1 && start >= m_first + m_count) {
                     return;
                 } /*else {
                     int addedCount = end - start + 1;
                     if (m_count != -1 && addedCount > m_count)
                         addedCount = m_count;
                     int first = qMax(start, m_first);
                     int last = qMin(first + addedCount - 1, m_orientation == Qt::Vertical ? m_model->rowCount() - 1 : m_model->columnCount() - 1);
                     for (int k = 0; k < m_series->barSets().count(); k++) {
                         for (int i = first; i <= last; i++) {
                             QBar point;
                             point.setX(m_model->data(xModelIndex(i - m_first), Qt::DisplayRole).toDouble());
                             point.setY(m_model->data(yModelIndex(i - m_first), Qt::DisplayRole).toDouble());
                             m_series->insert(i - m_first, point);
                         }
+            >>>>>>> Stashed changes
                     }
                     // remove excess of slices (abouve m_count)
                     if (m_count != -1 && m_series->points().size() > m_count)
                         for (int i = m_series->points().size() - 1; i >= m_count; i--) {
                             m_series->remove(m_series->points().at(i));
                         }
                 }*/
             }
             void QBarModelMapperPrivate::removeData(int start, int end)
             {
                 Q_UNUSED(end)
                 if (m_model == 0 || m_series == 0)
                     return;
                 //    int removedCount = end - start + 1;
                 if (m_count != -1 && start >= m_first + m_count) {
                     return;
                 } /*else {
                     int toRemove = qMin(m_series->count(), removedCount);     // first find how many items can actually be removed
                     int first = qMax(start, m_first);    // get the index of the first item that will be removed.
                     int last = qMin(first + toRemove - 1, m_series->count() + m_first - 1);    // get the index of the last item that will be removed.
                     for (int i = last; i >= first; i--) {
                         m_series->remove(m_series->points().at(i - m_first));
                     }
                     if (m_count != -1) {
                         int itemsAvailable;     // check how many are available to be added
                         if (m_orientation == Qt::Vertical)
                             itemsAvailable = m_model->rowCount() - m_first - m_series->count();
                         else
                             itemsAvailable = m_model->columnCount() - m_first - m_series->count();
                         int toBeAdded = qMin(itemsAvailable, m_count - m_series->count());     // add not more items than there is space left to be filled.
                         int currentSize = m_series->count();
                         if (toBeAdded > 0)
                             for (int i = m_series->count(); i < currentSize + toBeAdded; i++) {
                                 QPointF point;
                                 point.setX(m_model->data(xModelIndex(i), Qt::DisplayRole).toDouble());
                                 point.setY(m_model->data(yModelIndex(i), Qt::DisplayRole).toDouble());
                                 m_series->insert(i, point);
                             }
                     }
                 }*/
             }
             void QBarModelMapperPrivate::initializeBarFromModel()
             {
                 if (m_model == 0 || m_series == 0)
                     return;
                 blockSeriesSignals();
                 // clear current content
                 m_series->clear();
                 // create the initial bar sets
                 for (int i = m_firstBarSetSection; i <= m_lastBarSetSection; i++) {
                     int posInBar = 0;
                     QModelIndex barIndex = barModelIndex(i, posInBar);
                     QBarSet *barSet = new QBarSet(m_model->headerData(i, Qt::Horizontal).toString());
                     //    QModelIndex yIndex = yModelIndex(pointPos);
                     while (barIndex.isValid()) {
                         barSet->append(m_model->data(barIndex, Qt::DisplayRole).toDouble());
                         posInBar++;
                         barIndex = barModelIndex(i, posInBar);
                     }
                     m_series->append(barSet);
                 }
-                if (m_categoriesSection != -1) {
+                if (m_series->chart() && m_categoriesSection != -1) {
                     int posInCategories = 0;
                     QStringList categories;
                     QModelIndex categoriesIndex = categoriesModelIndex(posInCategories);
                     while (categoriesIndex.isValid()) {
                         categories.append(m_model->data(categoriesIndex, Qt::DisplayRole).toString());
                         posInCategories++;
                         categoriesIndex = categoriesModelIndex(posInCategories);
                     }
-                    // TODO: set the categories to axis
+                    m_series->chart()->axisX()->categories()->insert(categories);
-            //        m_series->setCategories(categories);
                 }
                 blockSeriesSignals(false);
             }
             #include "moc_qbarmodelmapper.cpp"
             #include "moc_qbarmodelmapper_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/qbarmodelmapper.h +5 -4

             #ifndef QBARMODELMAPPER_H
             #define QBARMODELMAPPER_H
             #include "qchartglobal.h"
             #include <QObject>
             class QAbstractItemModel;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QBarModelMapperPrivate;
             class QBarSeries;
+            class QChart;
             class QTCOMMERCIALCHART_EXPORT QBarModelMapper : public QObject
             {
                 Q_OBJECT
                 Q_PROPERTY(QBarSeries *series READ series WRITE setSeries)
                 Q_PROPERTY(QAbstractItemModel *model READ model WRITE setModel)
                 Q_PROPERTY(int first READ first WRITE setFirst)
                 Q_PROPERTY(int count READ count WRITE setCount)
                 Q_ENUMS(Qt::Orientation)
             protected:
                 explicit QBarModelMapper(QObject *parent = 0);
             public:
                 QAbstractItemModel* model() const;
                 void setModel(QAbstractItemModel *model);
                 QBarSeries* series() const;
                 void setSeries(QBarSeries *series);
                 int first() const;
                 void setFirst(int first);
                 int count() const;
                 void setCount(int count);
+                void reset();
+            protected:
                 int firstBarSetSection() const;
                 void setFirstBarSetSection(int firstBarSetSection);
                 int lastBarSetSection() const;
                 void setLastBarSetSection(int lastBarSetSection);
                 int categoriesSection() const;
                 void setCategoriesSection(int categoriesSection);
-            protected:
                 Qt::Orientation orientation() const;
                 void setOrientation(Qt::Orientation orientation);
-                void reset();
             Q_SIGNALS:
                 void updated();
             protected:
                 QBarModelMapperPrivate * const d_ptr;
                 Q_DECLARE_PRIVATE(QBarModelMapper)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QBARMODELMAPPER_H

src/barchart/qhbarmodelmapper.cpp +8 0

             #include "qhbarmodelmapper.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
+            /*!
+                \class QHBarModelMapper
+                \brief part of QtCommercial chart API.
+                \mainclass
+                Nothing here yet
+            */
             QHBarModelMapper::QHBarModelMapper(QObject *parent) :
                 QBarModelMapper(parent)
             {
                 QBarModelMapper::setOrientation(Qt::Horizontal);
             }
             int QHBarModelMapper::firstBarSetRow() const
             {
                 return QBarModelMapper::firstBarSetSection();
             }
             void QHBarModelMapper::setFirstBarSetRow(int firstBarSetRow)
             {
                 return QBarModelMapper::setFirstBarSetSection(firstBarSetRow);
             }
             int QHBarModelMapper::lastBarSetRow() const
             {
                 return QBarModelMapper::lastBarSetSection();
             }
             void QHBarModelMapper::setLastBarSetRow(int lastBarSetRow)
             {
                 return QBarModelMapper::setLastBarSetSection(lastBarSetRow);
             }
             int QHBarModelMapper::categoriesRow() const
             {
                 return QBarModelMapper::categoriesSection();
             }
             void QHBarModelMapper::setCategoriesRow(int categoriesRow)
             {
                 return QBarModelMapper::setCategoriesSection(categoriesRow);
             }
             #include "moc_qhbarmodelmapper.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/qvbarmodelmapper.cpp +8 0

             #include "qvbarmodelmapper.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
+            /*!
+                \class QVBarModelMapper
+                \brief part of QtCommercial chart API.
+                \mainclass
+                Nothing here yet
+            */
             QVBarModelMapper::QVBarModelMapper(QObject *parent) :
                 QBarModelMapper(parent)
             {
                 QBarModelMapper::setOrientation(Qt::Vertical);
             }
             int QVBarModelMapper::firstBarSetColumn() const
             {
                 return QBarModelMapper::firstBarSetSection();
             }
             void QVBarModelMapper::setFirstBarSetColumn(int firstBarSetColumn)
             {
                 return QBarModelMapper::setFirstBarSetSection(firstBarSetColumn);
             }
             int QVBarModelMapper::lastBarSetColumn() const
             {
                 return QBarModelMapper::lastBarSetSection();
             }
             void QVBarModelMapper::setLastBarSetColumn(int lastBarSetColumn)
             {
                 return QBarModelMapper::setLastBarSetSection(lastBarSetColumn);
             }
             int QVBarModelMapper::categoriesColumn() const
             {
                 return QBarModelMapper::categoriesSection();
             }
             void QVBarModelMapper::setCategoriesColumn(int categoriesColumn)
             {
                 return QBarModelMapper::setCategoriesSection(categoriesColumn);
             }
             #include "moc_qvbarmodelmapper.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/qhpiemodelmapper.cpp +8 0

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "qhpiemodelmapper.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
+            /*!
+                \class QHPieModelMapper
+                \brief part of QtCommercial chart API.
+                \mainclass
+                Nothing here yet
+            */
             QHPieModelMapper::QHPieModelMapper(QObject *parent) :
                 QPieModelMapper(parent)
             {
                 QPieModelMapper::setOrientation(Qt::Horizontal);
             }
             int QHPieModelMapper::valuesRow() const
             {
                 return QPieModelMapper::valuesSection();
             }
             void QHPieModelMapper::setValuesRow(int valuesRow)
             {
                 QPieModelMapper::setValuesSection(valuesRow);
             }
             int QHPieModelMapper::labelsRow() const
             {
                 return QPieModelMapper::labelsSection();
             }
             void QHPieModelMapper::setLabelsRow(int labelsRow)
             {
                 QPieModelMapper::setLabelsSection(labelsRow);
             }
             #include "moc_qhpiemodelmapper.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/qvpiemodelmapper.cpp +8 0

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "qpiemodelmapper_p.h"
             #include "qvpiemodelmapper.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
+            /*!
+                \class QVPieModelMapper
+                \brief part of QtCommercial chart API.
+                \mainclass
+                Nothing here yet
+            */
             QVPieModelMapper::QVPieModelMapper(QObject *parent) :
                 QPieModelMapper(parent)
             {
                 QPieModelMapper::setOrientation(Qt::Vertical);
             }
             int QVPieModelMapper::valuesColumn() const
             {
                 return QPieModelMapper::valuesSection();
             }
             void QVPieModelMapper::setValuesColumn(int valuesColumn)
             {
                 QPieModelMapper::setValuesSection(valuesColumn);
             }
             int QVPieModelMapper::labelsColumn() const
             {
                 return QPieModelMapper::labelsSection();
             }
             void QVPieModelMapper::setLabelsColumn(int labelsColumn)
             {
                 QPieModelMapper::setLabelsSection(labelsColumn);
             }
             #include "moc_qvpiemodelmapper.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/xychart/qhxymodelmapper.cpp +8 0

             #include "qhxymodelmapper.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
+            /*!
+                \class QHXYModelMapper
+                \brief part of QtCommercial chart API.
+                \mainclass
+                Nothing here yet
+            */
             QHXYModelMapper::QHXYModelMapper(QObject *parent) :
                 QXYModelMapper(parent)
             {
                 QXYModelMapper::setOrientation(Qt::Horizontal);
             }
             int QHXYModelMapper::xRow() const
             {
                 return QXYModelMapper::xSection();
             }
             void QHXYModelMapper::setXRow(int xRow)
             {
                 return QXYModelMapper::setXSection(xRow);
             }
             int QHXYModelMapper::yRow() const
             {
                 return QXYModelMapper::ySection();
             }
             void QHXYModelMapper::setYRow(int yRow)
             {
                 return QXYModelMapper::setYSection(yRow);
             }
             #include "moc_qhxymodelmapper.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/xychart/qvxymodelmapper.cpp +8 0

             #include "qvxymodelmapper.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
+            /*!
+                \class QVXYModelMapper
+                \brief part of QtCommercial chart API.
+                \mainclass
+                Nothing here yet
+            */
             QVXYModelMapper::QVXYModelMapper(QObject *parent) :
                 QXYModelMapper(parent)
             {
                 QXYModelMapper::setOrientation(Qt::Vertical);
             }
             int QVXYModelMapper::xColumn() const
             {
                 return QXYModelMapper::xSection();
             }
             void QVXYModelMapper::setXColumn(int xColumn)
             {
                 return QXYModelMapper::setXSection(xColumn);
             }
             int QVXYModelMapper::yColumn() const
             {
                 return QXYModelMapper::ySection();
             }
             void QVXYModelMapper::setYColumn(int yColumn)
             {
                 return QXYModelMapper::setYSection(yColumn);
             }
             #include "moc_qvxymodelmapper.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

tests/tablemodelchart/tablewidget.cpp +10 -6

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "tablewidget.h"
             #include <QGridLayout>
             #include <QTableView>
             #include <QChart>
             #include <QStyledItemDelegate>
             #include <QLineSeries>
             #include <QSplineSeries>
             #include <QScatterSeries>
             #include <QVXYModelMapper>
             #include <QHXYModelMapper>
             #include "customtablemodel.h"
             #include <QPieSeries>
             #include <QVPieModelMapper>
             #include <QPieSlice>
             #include <QAreaSeries>
             #include <QBarSeries>
             #include <QGroupedBarSeries>
             #include <QBarSet>
             #include <QVBarModelMapper>
             #include <QPushButton>
             #include <QRadioButton>
             #include <QLabel>
             #include <QSpinBox>
             #include <QTime>
             #include <QHeaderView>
             TableWidget::TableWidget(QWidget *parent)
                 : QWidget(parent),
                   m_series(0),
                   m_mapper(0),
                   m_model(0),
                   m_pieMapper(0),
                   m_pieMapper2(0)
                 //      specialPie(0)
             {
                 setGeometry(1900, 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;
                 m_tableView = new QTableView;
                 m_tableView->setModel(m_model);
                 //    m_tableView->setMinimumHeight(300);
                 m_tableView->horizontalHeader()->setResizeMode(QHeaderView::Stretch);
                 m_tableView->verticalHeader()->setResizeMode(QHeaderView::Stretch);
                 m_chart = new QChart;
                 m_chart->legend()->setVisible(true);
                 m_chart->setAnimationOptions(QChart::SeriesAnimations);
                 m_chartView = new QChartView(m_chart);
                 m_chartView->setRenderHint(QPainter::Antialiasing);
                 m_chartView->setMinimumSize(640, 480);
                 // 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()));
                 QPushButton* addColumnRightButton = new QPushButton("Add column to the right");
                 connect(addColumnRightButton, SIGNAL(clicked()), this, SLOT(addColumnRight()));
                 QPushButton* removeColumnButton = new QPushButton("Remove column");
                 connect(removeColumnButton, SIGNAL(clicked()), this, SLOT(removeColumn()));
                 QPushButton* specialPieButton = new QPushButton("Add slices using series API");
                 connect(specialPieButton, SIGNAL(clicked()), this, SLOT(testPie()));
                 QPushButton* specialPieButton2 = new QPushButton("Remove slices using series API");
                 connect(specialPieButton2, SIGNAL(clicked()), this, SLOT(testPie2()));
                 QPushButton* specialPieButton3 = new QPushButton("Modify slices using series API");
                 connect(specialPieButton3, SIGNAL(clicked()), this, SLOT(testPie3()));
                 QPushButton* xyTestButton = new QPushButton("Append XY point");
                 connect(xyTestButton, SIGNAL(clicked()), this, SLOT(testXY()));
                 QLabel *spinBoxLabel = new QLabel("Rows affected:");
                 // spin box for setting number of affected items (add, remove)
                 m_linesCountSpinBox = new QSpinBox;
                 m_linesCountSpinBox->setRange(1, 10);
                 m_linesCountSpinBox->setValue(1);
                 // buttons layout
                 QVBoxLayout* buttonsLayout = new QVBoxLayout;
                 buttonsLayout->addWidget(spinBoxLabel);
                 buttonsLayout->addWidget(m_linesCountSpinBox);
                 //    buttonsLayout->addWidget(addRowAboveButton);
                 buttonsLayout->addWidget(addRowBelowButton);
                 buttonsLayout->addWidget(removeRowButton);
                 //    buttonsLayout->addWidget(addColumnRightButton);
                 //    buttonsLayout->addWidget(removeColumnButton);
                 buttonsLayout->addWidget(specialPieButton);
                 buttonsLayout->addWidget(specialPieButton2);
                 buttonsLayout->addWidget(specialPieButton3);
                 buttonsLayout->addWidget(xyTestButton);
                 buttonsLayout->addStretch();
                 // chart type radio buttons
                 m_lineRadioButton = new QRadioButton("Line");
                 m_splineRadioButton = new QRadioButton("Spline");
                 m_scatterRadioButton = new QRadioButton("Scatter");
                 m_pieRadioButton = new QRadioButton("Pie");
                 m_areaRadioButton = new QRadioButton("Area");
                 m_barRadioButton = new QRadioButton("Bar");
                 connect(m_lineRadioButton, SIGNAL(toggled(bool)), this, SLOT(updateChartType(bool)));
                 connect(m_splineRadioButton, SIGNAL(toggled(bool)), this, SLOT(updateChartType(bool)));
                 connect(m_scatterRadioButton, SIGNAL(toggled(bool)), this, SLOT(updateChartType(bool)));
                 connect(m_pieRadioButton, SIGNAL(toggled(bool)), this, SLOT(updateChartType(bool)));
                 connect(m_areaRadioButton, SIGNAL(toggled(bool)), this, SLOT(updateChartType(bool)));
                 connect(m_barRadioButton, SIGNAL(toggled(bool)), this, SLOT(updateChartType(bool)));
-                m_lineRadioButton->setChecked(true);
+                m_barRadioButton->setChecked(true);
                 // radio buttons layout
                 QVBoxLayout* radioLayout = new QVBoxLayout;
                 radioLayout->addWidget(m_lineRadioButton);
                 radioLayout->addWidget(m_splineRadioButton);
                 radioLayout->addWidget(m_scatterRadioButton);
                 radioLayout->addWidget(m_pieRadioButton);
                 //    radioLayout->addWidget(m_areaRadioButton);
                 radioLayout->addWidget(m_barRadioButton);
                 radioLayout->addStretch();
                 // create main layout
                 QGridLayout* mainLayout = new QGridLayout;
                 mainLayout->addLayout(buttonsLayout, 2, 0);
                 mainLayout->addLayout(radioLayout, 3, 0);
                 mainLayout->addWidget(m_tableView, 1, 0);
                 mainLayout->addWidget(m_chartView, 1, 1, 2, 1);
                 setLayout(mainLayout);
                 m_lineRadioButton->setFocus();
             }
             void TableWidget::addRowAbove()
             {
                 m_model->insertRows(m_tableView->currentIndex().row(), m_linesCountSpinBox->value());
             }
             void TableWidget::addRowBelow()
             {
                 m_model->insertRows(m_tableView->currentIndex().row() + 1, m_linesCountSpinBox->value());
             }
             void TableWidget::removeRow()
             {
                 m_model->removeRows(m_tableView->currentIndex().row(), qMin(m_model->rowCount() - m_tableView->currentIndex().row(), m_linesCountSpinBox->value()));
             }
             void TableWidget::addColumnRight()
             {
                 m_model->insertColumns(m_tableView->currentIndex().column() + 1, m_linesCountSpinBox->value());
             }
             void TableWidget::removeColumn()
             {
                 m_model->removeColumns(m_tableView->currentIndex().column(), qMin(m_model->columnCount() - m_tableView->currentIndex().column(), m_linesCountSpinBox->value()));
             }
             void TableWidget::updateChartType(bool toggle)
             {
                 // this if is needed, so that the function is only called once.
                 // For the radioButton that was enabled.
                 if (toggle) {
                     //        specialPie = 0;
                     m_chart->removeAllSeries();
                     m_series = 0;
                     //        m_chart->axisX()->setNiceNumbersEnabled(false);
                     //        m_chart->axisY()->setNiceNumbersEnabled(false);
                     if (m_mapper) {
                         m_mapper->deleteLater();
                         m_mapper = 0;
                     }
                     if (m_pieMapper) {
                         m_pieMapper->deleteLater();
                         m_pieMapper = 0;
                     }
                     if (m_pieMapper2) {
                         m_pieMapper2->deleteLater();
                         m_pieMapper2 = 0;
                     }
                     //        if (m_series) {
                     //            delete m_series;
                     //            m_series = 0;
                     //        }
                     // renable axes of the chart (pie hides them)
                     // x axis
                     QAxis *axis = m_chart->axisX();
                     axis->setAxisVisible(true);
                     axis->setGridLineVisible(true);
                     axis->setLabelsVisible(true);
                     // y axis
                     axis = m_chart->axisY();
                     axis->setAxisVisible(true);
                     axis->setGridLineVisible(true);
                     axis->setLabelsVisible(true);
                     m_model->clearMapping();
                     QString seriesColorHex = "#000000";
                     //        QPen pen;
                     //        pen.setWidth(2);
                     if (m_lineRadioButton->isChecked())
                     {
             //            m_chart->setAnimationOptions(QChart::NoAnimation);
                         // series 1
                         m_series = new QLineSeries;
             //            m_mapper = new QHXYModelMapper;
             //            m_mapper->setModel(m_model);
             //            m_mapper->setSeries(m_series);
             //            m_mapper->setXRow(0);
             //            m_mapper->setYRow(1);
             //            m_mapper->setFirst(3);
             //            m_mapper->setCount(4);
                         m_mapper = new QVXYModelMapper;
                         m_mapper->setModel(m_model);
                         m_mapper->setSeries(m_series);
                         m_mapper->setXColumn(0);
                         m_mapper->setYColumn(1);
                         m_mapper->setFirst(3);
             //            m_mapper->setCount(4);
                         //            m_series->setModelMapping(0,1, Qt::Vertical);
                         //            m_series->setModelMappingRange(3, 4);
                         m_chart->addSeries(m_series);
                         seriesColorHex = "#" + QString::number(m_series->pen().color().rgb(), 16).right(6).toUpper();
                         m_model->addMapping(seriesColorHex, QRect(0, 3, 2, 4));
                         //            // series 2
                         //            m_series = new QLineSeries;
                         //            m_series->setModel(m_model);
                         //            mapper = new QXYModelMapper;
                         //            mapper->setMapX(3);
                         //            mapper->setMapY(4);
                         //            //            mapper->setFirst(3);
                         //            //            mapper->setCount(4);
                         //            m_series->setModelMapper(mapper);
                         //            //            m_series->setModelMapping(2,3, Qt::Vertical);
                         //            m_chart->addSeries(m_series);
                         //            seriesColorHex = "#" + QString::number(m_series->pen().color().rgb(), 16).right(6).toUpper();
                         //            m_model->addMapping(seriesColorHex, QRect(3, 0, 2, 1000));
                         //            // series 3
                         //            m_series = new QLineSeries;
                         //            m_series->setModel(m_model);
                         //            mapper = new QXYModelMapper;
                         //            mapper->setMapX(5);
                         //            mapper->setMapY(6);
                         //            mapper->setFirst(2);
                         //            mapper->setCount(-1);
                         //            m_series->setModelMapper(mapper);
                         //            //            m_series->setModelMapping(4,5, Qt::Vertical);
                         //            //            m_series->setModelMappingRange(2, -1);
                         //            m_chart->addSeries(m_series);
                         //            seriesColorHex = "#" + QString::number(m_series->pen().color().rgb(), 16).right(6).toUpper();
                         //            m_model->addMapping(seriesColorHex, QRect(5, 2, 2, 1000));
                     }
                     else if (m_splineRadioButton->isChecked())
                     {
                         m_chart->setAnimationOptions(QChart::NoAnimation);
                         // series 1
                         m_series = new QSplineSeries;
                         //            m_series->setModel(m_model);
             //            m_mapper = new QVXYModelMapper;
             //            m_mapper->setSeries(m_series);
             //            m_mapper->setModel(m_model);
             //            m_mapper->setXColumn(0);
             //            m_mapper->setYColumn(1);
             //            m_mapper->setFirst(0);
             //            m_mapper->setCount(-1);
                         //            m_series->setModelMapper(mapper);
                         m_chart->addSeries(m_series);
                         seriesColorHex = "#" + QString::number(m_series->pen().color().rgb(), 16).right(6).toUpper();
                         m_model->addMapping(seriesColorHex, QRect(0, 0, 2, 1000));
                         //            // series 2
                         //            m_series = new QSplineSeries;
                         //            m_series->setModel(m_model);
                         //            mapper = new QXYModelMapper;
                         //            mapper->setMapX(2);
                         //            mapper->setMapY(3);
                         //            mapper->setFirst(2);
                         //            mapper->setCount(4);
                         //            m_series->setModelMapper(mapper);
                         //            m_chart->addSeries(m_series);
                         //            seriesColorHex = "#" + QString::number(m_series->pen().color().rgb(), 16).right(6).toUpper();
                         //            m_model->addMapping(seriesColorHex, QRect(2, 2, 2, 4));
                         //            // series 3
                         //            m_series = new QSplineSeries;
                         //            m_series->setModel(m_model);
                         //            mapper = new QXYModelMapper;
                         //            mapper->setMapX(4);
                         //            mapper->setMapY(5);
                         //            mapper->setFirst(2);
                         //            mapper->setCount(-1);
                         //            m_series->setModelMapper(mapper);
                         //            m_chart->addSeries(m_series);
                         //            seriesColorHex = "#" + QString::number(m_series->pen().color().rgb(), 16).right(6).toUpper();
                         //            m_model->addMapping(seriesColorHex, QRect(4, 2, 2, 1000));
                     }        else if (m_scatterRadioButton->isChecked())
                     {
                         m_chart->setAnimationOptions(QChart::NoAnimation);
                         // series 1
                         m_series = new QScatterSeries;
             //            m_mapper = new QVXYModelMapper;
             //            m_mapper->setSeries(m_series);
             //            m_mapper->setModel(m_model);
             //            m_mapper->setXColumn(0);
             //            m_mapper->setYColumn(1);
             //            m_mapper->setFirst(0);
             //            m_mapper->setCount(-1);
                         m_chart->addSeries(m_series);
                         seriesColorHex = "#" + QString::number(m_series->brush().color().rgb(), 16).right(6).toUpper();
                         m_model->addMapping(seriesColorHex, QRect(0, 2, 2, 1000));
                         //            // series 2
                         //            m_series = new QScatterSeries;
                         //            m_series->setModel(m_model);
                         //            m_series->setModelMapping(2,3, Qt::Vertical);
                         //            //            m_series->setModelMappingRange(1, 6);
                         //            //        series->setModelMapping(2,3, Qt::Horizontal);
                         //            m_chart->addSeries(m_series);
                         //            seriesColorHex = "#" + QString::number(m_series->brush().color().rgb(), 16).right(6).toUpper();
                         //            m_model->addMapping(seriesColorHex, QRect(2, 1, 2, 6));
                         //            // series 3
                         //            m_series = new QScatterSeries;
                         //            m_series->setModel(m_model);
                         //            m_series->setModelMapping(4,5, Qt::Vertical);
                         //            //        series->setModelMapping(4,5, Qt::Horizontal);
                         //            m_chart->addSeries(m_series);
                         //            seriesColorHex = "#" + QString::number(m_series->brush().color().rgb(), 16).right(6).toUpper();
                         //            m_model->addMapping(seriesColorHex, QRect(4, 0, 2, 1000));
                     } else if (m_pieRadioButton->isChecked()) {
                         m_chart->setAnimationOptions(QChart::SeriesAnimations);
                         // pie 1
                         m_pieSeries = new QPieSeries;
                         m_pieMapper = new QVPieModelMapper;
                         m_pieMapper->setValuesColumn(1);
                         m_pieMapper->setLabelsColumn(7);
                         m_pieMapper->setSeries(m_pieSeries);
                         m_pieMapper->setModel(m_model);
                         m_pieMapper->setFirst(2);
                         //                        m_pieMapper->setCount(5);
                         //                    pieSeries->setModelMapper(mapper);
                         m_pieSeries->setLabelsVisible(true);
                         m_pieSeries->setPieSize(0.35);
                         m_pieSeries->setHorizontalPosition(0.25);
                         m_pieSeries->setVerticalPosition(0.35);
                         m_chart->addSeries(m_pieSeries);
                         seriesColorHex = "#" + QString::number(m_pieSeries->slices().at(m_pieSeries->slices().count()/2)->brush().color().rgb(), 16).right(6).toUpper();
                         m_model->addMapping(seriesColorHex, QRect(1, 2, 1, 50));
                         //                            pieSeries->slices().at(0)->setValue(400);
                         //                            pieSeries->slices().at(0)->setLabel(QString("36"));
                         // pie 2
                         m_pieSeries2 = new QPieSeries;
                         m_pieMapper2 = new QVPieModelMapper;
                         m_pieMapper2->setValuesColumn(0);
                         m_pieMapper2->setLabelsColumn(7);
                         m_pieMapper2->setModel(m_model);
                         m_pieMapper2->setSeries(m_pieSeries2);
                         m_pieMapper2->setFirst(2);
                         m_pieSeries2->setLabelsVisible(true);
                         m_pieSeries2->setPieSize(0.35);
                         m_pieSeries2->setHorizontalPosition(0.75);
                         m_pieSeries2->setVerticalPosition(0.65);
                         m_chart->addSeries(m_pieSeries2);
                         seriesColorHex = "#" + QString::number(m_pieSeries2->slices().at(m_pieSeries2->slices().count()/2)->brush().color().rgb(), 16).right(6).toUpper();
                         m_model->addMapping(seriesColorHex, QRect(0, 2, 1, 1000));
                         //            // pie 3
                         //            pieSeries = new QPieSeries;
                         //            pieSeries->setModel(m_model);
                         //            pieSeries->setModelMapping(2,2, Qt::Vertical);
                         //            pieSeries->setLabelsVisible(true);
                         //            pieSeries->setPieSize(0.35);
                         //            pieSeries->setHorizontalPosition(0.5);
                         //            pieSeries->setVerticalPosition(0.75);
                         //            m_chart->addSeries(pieSeries);
                         //            seriesColorHex = "#" + QString::number(pieSeries->slices().at(pieSeries->slices().count()/2)->brush().color().rgb(), 16).right(6).toUpper();
                         //            m_model->addMapping(seriesColorHex, QRect(2, 0, 1, 1000));
                         //            // special pie
                         //            specialPie = new QPieSeries;
                         //            specialPie->append(17, "1");
                         //            specialPie->append(45, "2");
                         //            specialPie->append(77, "3");
                         //            specialPie->append(37, "4");
                         //            specialPie->append(27, "5");
                         //            specialPie->append(47, "6");
                         //            specialPie->setPieSize(0.35);
                         //            specialPie->setHorizontalPosition(0.8);
                         //            specialPie->setVerticalPosition(0.75);
                         //            specialPie->setLabelsVisible(true);
                         //            m_chart->addSeries(specialPie);
                     }
                     //        else if (m_areaRadioButton->isChecked())
                     //        {
                     //            m_chart->setAnimationOptions(QChart::NoAnimation);
                     //            QLineSeries* upperLineSeries = new QLineSeries;
                     //            upperLineSeries->setModel(m_model);
                     //            upperLineSeries->setModelMapping(0, 1, Qt::Vertical);
                     //            //            upperLineSeries->setModelMappingRange(1, 5);
                     //            QLineSeries* lowerLineSeries = new QLineSeries;
                     //            lowerLineSeries->setModel(m_model);
                     //            lowerLineSeries->setModelMapping(2, 3, Qt::Vertical);
                     //            QAreaSeries* areaSeries = new QAreaSeries(upperLineSeries, lowerLineSeries);
                     //            m_chart->addSeries(areaSeries);
                     //            seriesColorHex = "#" + QString::number(areaSeries->brush().color().rgb(), 16).right(6).toUpper();
                     //            m_model->addMapping(seriesColorHex, QRect(0, 1, 2, 5));
                     //            m_model->addMapping(seriesColorHex, QRect(2, 0, 2, 1000));
                     //        }
                     else if (m_barRadioButton->isChecked())
                     {
                         m_chart->setAnimationOptions(QChart::SeriesAnimations);
                         QGroupedBarSeries* barSeries = new QGroupedBarSeries();
             //            barSeries->setCategories(QStringList());
             //            barSeries->setModel(m_model);
                         //            barSeries->setModelMappingRange(2, 5);
                         //                    barSeries->setModelMapping(5, 2, 4, Qt::Vertical);
                         int first = 3;
-            //            int count = 4;
+                        int count = 6;
                         QVBarModelMapper *mapper = new QVBarModelMapper;
-                        mapper->setCategoriesSection(5);
+                        mapper->setCategoriesColumn(5);
-                        mapper->setFirstBarSetSection(2);
+                        mapper->setFirstBarSetColumn(2);
-                        mapper->setLastBarSetSection(4);
+                        mapper->setLastBarSetColumn(4);
                         mapper->setFirst(first);
-            //            mapper->setCount(count);
+                        mapper->setCount(count);
                         mapper->setSeries(barSeries);
                         mapper->setModel(m_model);
             //            barSeries->setModelMapper(mapper);
                         m_chart->addSeries(barSeries);
                         QList<QBarSet*> barsets = barSeries->barSets();
                         for (int i = 0; i < barsets.count(); i++) {
                             seriesColorHex = "#" + QString::number(barsets.at(i)->brush().color().rgb(), 16).right(6).toUpper();
                             m_model->addMapping(seriesColorHex, QRect(2 + i, first, 1, barsets.at(i)->count()));
                         }
                     }
                     if (!m_barRadioButton->isChecked()) {
             //            m_chart->axisX()->setRange(0, 500);
             //            m_chart->axisY()->setRange(0, 220);
                     }
                     m_chart->legend()->setVisible(true);
                     // repaint table view colors
                     m_tableView->repaint();
                     m_tableView->setFocus();
                 }
             }
             void TableWidget::testPie()
             {
                 //    m_pieMapper->setCount(-1);
                 QPieSlice *slice = new QPieSlice("Hehe", 145);
                 slice->setLabelVisible();
                 m_pieSeries->append(slice);
                 slice = new QPieSlice("Hoho", 34);
                 slice->setLabelVisible();
                 m_pieSeries->append(slice);
                 //    m_series->modelMapper()->setMapX(4);
                 //    m_tableView->setColumnWidth(10, 250);
                 //    if (specialPie) {
                 //        specialPie->remove(specialPie->slices().at(2));
                 //        //    specialPie->insert(4, new QPieSlice(45, "Hello"));//specialPie->slices.at(2));
                 //        specialPie->append(4, "heloo");
                 //    }
             }
             void TableWidget::testPie2()
             {
                 QPieSlice *slice;
                 if (m_pieSeries->count() > 0) {
                     slice = m_pieSeries->slices().last();
                     m_pieSeries->remove(slice);
                 }
                 if (m_pieSeries->count() > 0) {
                     slice = m_pieSeries->slices().first();
                     m_pieSeries->remove(slice);
                 }
             }
             void TableWidget::testPie3()
             {
                 QPieSlice *slice;
                 if (m_pieSeries->count() > 0) {
                     slice = m_pieSeries->slices().last();
                     slice->setLabel("Dalej");
                     slice->setValue(222);
                 }
                 if (m_pieSeries->count() > 0) {
                     slice = m_pieSeries->slices().first();
                     slice->setLabel("Prawie");
                     slice->setValue(111);
                 }
             }
             void TableWidget::testXY()
             {
                 //    if (m_series->type() != QAbstractSeries::SeriesTypeLine) {
                 //        m_series->append(QPointF(150, 75));
                 //    }
                 if (m_series->count() > 0) {
                     m_series->remove(m_series->points().last());
                 }
             }
             TableWidget::~TableWidget()
             {
             }

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