HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r1671:86eb2ea7496a

Added QDonutGroup class

Marek Rosa -

r1671:86eb2ea7496a

parent child

Context file:

r1671:86eb2ea7496a

Collapse all files

src/piechart/qdonutgroup.cpp created 644 +39 0

@@ -0,0 +1,39
	1	#include "qdonutgroup.h"
	2	#include "qdonutgroup_p.h"
	3
	4	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	5
	6	QDonutGroup::QDonutGroup(QObject *parent) :
	7	QObject(parent),
	8	d_ptr(new QDonutGroupPrivate(this))
	9	{
	10	}
	11
	12	void QDonutGroup::append(QPieSeries *donut)
	13	{
	14	if (donut == 0)
	15	return;
	16
	17	donut->setDonut();
	18	Q_D(QDonutGroup);
	19	d->m_donuts.append(donut);
	20	qreal donutFraction = 1.0 / (d->m_donuts.count() + 1);
	21	for(int i = 0; i < d->m_donuts.count(); i++) {
	22	d->m_donuts[i]->setPieSize( (i + 2) * donutFraction);
	23	d->m_donuts[i]->setDonutInnerSize( (i + 1) * donutFraction);
	24	}
	25	}
	26
	27	///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	28
	29	QDonutGroupPrivate::QDonutGroupPrivate(QDonutGroup *q):
	30	QObject(q),
	31	q_ptr(q)
	32	{
	33	//
	34	}
	35
	36	#include "moc_qdonutgroup.cpp"
	37	#include "moc_qdonutgroup_p.cpp"
	38
	39	QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/qdonutgroup.h created 644 +27 0

@@ -0,0 +1,27
	1	#ifndef QDONUTGROUP_H
	2	#define QDONUTGROUP_H
	3
	4	#include <QObject>
	5	#include <QPieSeries>
	6
	7	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	8
	9	//class QPieSeries;
	10	class QDonutGroupPrivate;
	11
	12	class QTCOMMERCIALCHART_EXPORT QDonutGroup : public QObject
	13	{
	14	Q_OBJECT
	15	public:
	16	explicit QDonutGroup(QObject *parent = 0);
	17
	18	void append(QPieSeries *donut);
	19
	20	protected:
	21	QDonutGroupPrivate * const d_ptr;
	22	Q_DECLARE_PRIVATE(QDonutGroup)
	23	};
	24
	25	QTCOMMERCIALCHART_END_NAMESPACE
	26
	27	#endif // QDONUTGROUP_H

src/piechart/qdonutgroup_p.h created 644 +29 0

@@ -0,0 +1,29
	1	#ifndef QDONUTGROUP_P_H
	2	#define QDONUTGROUP_P_H
	3
	4	#include <QObject>
	5	#include <qdonutgroup.h>
	6
	7	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	8
	9	class QPieSeries;
	10
	11	class QDonutGroupPrivate : public QObject
	12	{
	13	Q_OBJECT
	14	public:
	15	explicit QDonutGroupPrivate(QDonutGroup *q);
	16
	17	void append(QPieSeries *donut);
	18
	19	private:
	20	QList<QPieSeries *> m_donuts;
	21
	22	private:
	23	QDonutGroup *q_ptr;
	24	Q_DECLARE_PUBLIC(QDonutGroup)
	25	};
	26
	27	QTCOMMERCIALCHART_END_NAMESPACE
	28
	29	#endif // QDONUTGROUP_P_H

src/barchart/qbarmodelmapper.cpp +1 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 "qbarmodelmapper.h"
             #include "qbarmodelmapper_p.h"
             #include "qabstractbarseries.h"
             #include "qbarset.h"
             #include "qchart.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(headerDataChanged(Qt::Orientation,int,int)), d, SLOT(modelHeaderDataUpdated(Qt::Orientation,int,int)));
                 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)));
                 connect(d->m_model, SIGNAL(destroyed()), d, SLOT(handleModelDestroyed()));
             }
             QAbstractBarSeries* QBarModelMapper::series() const
             {
                 Q_D(const QBarModelMapper);
                 return d->m_series;
             }
             void QBarModelMapper::setSeries(QAbstractBarSeries *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(barsetsAdded(QList<QBarSet*>)), d, SLOT(barSetsAdded(QList<QBarSet*>)));
                 connect(d->m_series, SIGNAL(barsetsRemoved(QList<QBarSet*>)), d, SLOT(barSetsRemoved(QList<QBarSet*>)));
                 connect(d->m_series, SIGNAL(destroyed()), d, SLOT(handleSeriesDestroyed()));
             }
             /*!
                 Returns which row/column of the model contains the first values of the QBarSets in the series.
                 The default value is 0.
             */
             int QBarModelMapper::first() const
             {
                 Q_D(const QBarModelMapper);
                 return d->m_first;
             }
             /*!
                 Sets which row of the model contains the \a first values of the QBarSets in the series.
                 The default value is 0.
             */
             void QBarModelMapper::setFirst(int first)
             {
                 Q_D(QBarModelMapper);
                 d->m_first = qMax(first, 0);
                 d->initializeBarFromModel();
             }
             /*!
                 Returns the number of rows/columns of the model that are mapped as the data for QAbstractBarSeries
                 Minimal and default value is: -1 (count limited by the number of rows/columns in the model)
             */
             int QBarModelMapper::count() const
             {
                 Q_D(const QBarModelMapper);
                 return d->m_count;
             }
             /*!
                 Sets the \a count of rows/columns of the model that are mapped as the data for QAbstractBarSeries
                 Minimal and default value is: -1 (count limited by the number of rows/columns in the model)
             */
             void QBarModelMapper::setCount(int count)
             {
                 Q_D(QBarModelMapper);
                 d->m_count = qMax(count, -1);
                 d->initializeBarFromModel();
             }
             /*!
                 Returns the orientation that is used when QBarModelMapper accesses the model.
                 This mean whether the consecutive values of the bar set are read from row (Qt::Horizontal)
                 or from columns (Qt::Vertical)
             */
             Qt::Orientation QBarModelMapper::orientation() const
             {
                 Q_D(const QBarModelMapper);
                 return d->m_orientation;
             }
             /*!
                 Returns the \a orientation that is used when QBarModelMapper accesses the model.
                 This mean whether the consecutive values of the pie are read from row (Qt::Horizontal)
                 or from columns (Qt::Vertical)
             */
             void QBarModelMapper::setOrientation(Qt::Orientation orientation)
             {
                 Q_D(QBarModelMapper);
                 d->m_orientation = orientation;
                 d->initializeBarFromModel();
             }
             /*!
                 Returns which section of the model is used as the data source for the first bar set
             */
             int QBarModelMapper::firstBarSetSection() const
             {
                 Q_D(const QBarModelMapper);
                 return d->m_firstBarSetSection;
             }
             /*!
                 Sets the model section that is used as the data source for the first bar set
                 Parameter \a firstBarSetSection specifies the section of the model.
             */
             void QBarModelMapper::setFirstBarSetSection(int firstBarSetSection)
             {
                 Q_D(QBarModelMapper);
                 d->m_firstBarSetSection = qMax(-1, firstBarSetSection);
                 d->initializeBarFromModel();
             }
             /*!
                 Returns which section of the model is used as the data source for the last bar set
             */
             int QBarModelMapper::lastBarSetSection() const
             {
                 Q_D(const QBarModelMapper);
                 return d->m_lastBarSetSection;
             }
             /*!
                 Sets the model section that is used as the data source for the last bar set
                 Parameter \a lastBarSetSection specifies the section of the model.
             */
             void QBarModelMapper::setLastBarSetSection(int lastBarSetSection)
             {
                 Q_D(QBarModelMapper);
                 d->m_lastBarSetSection = qMax(-1, lastBarSetSection);
                 d->initializeBarFromModel();
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QBarModelMapperPrivate::QBarModelMapperPrivate(QBarModelMapper *q) :
+                QObject(q),
                 m_series(0),
                 m_model(0),
                 m_first(0),
                 m_count(-1),
                 m_orientation(Qt::Vertical),
                 m_firstBarSetSection(-1),
                 m_lastBarSetSection(-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 (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);
             }
             void QBarModelMapperPrivate::handleSeriesDestroyed()
             {
                 m_series = 0;
             }
             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;
                 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::modelHeaderDataUpdated(Qt::Orientation orientation, int first, int last)
             {
                 if (m_model == 0 || m_series == 0)
                     return;
                 if (m_modelSignalsBlock)
                     return;
                 blockSeriesSignals();
                 if (orientation != m_orientation) {
                     for (int section = first; section <= last; section++) {
                         if (section >= m_firstBarSetSection && section <= m_lastBarSetSection) {
                             QBarSet* bar = m_series->barSets().at(section - m_firstBarSetSection);
                             if (bar)
                                 bar->setLabel(m_model->headerData(section, orientation).toString());
                         }
                     }
                 }
                 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) // 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) // 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) // 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) // if the changes affect the map - reinitialize
                     initializeBarFromModel();
                 blockSeriesSignals(false);
             }
             void QBarModelMapperPrivate::handleModelDestroyed()
             {
                 m_model = 0;
             }
             void QBarModelMapperPrivate::insertData(int start, int end)
             {
                 Q_UNUSED(end)
                 Q_UNUSED(start)
                 Q_UNUSED(end)
                 // To be implemented
             }
             void QBarModelMapperPrivate::removeData(int start, int end)
             {
                 Q_UNUSED(end)
                 Q_UNUSED(start)
                 Q_UNUSED(end)
                 // To be implemented
             }
             void QBarModelMapperPrivate::barSetsAdded(QList<QBarSet*> sets)
             {
                 if (m_seriesSignalsBlock)
                     return;
                 if (sets.count() == 0)
                     return;
                 int firstIndex = m_series->barSets().indexOf(sets.at(0));
                 if (firstIndex == -1)
                     return;
                 int maxCount = 0;
                 for(int i = 0; i < sets.count(); i++)
                     if (sets.at(i)->count() > m_count)
                         maxCount = sets.at(i)->count();
                 if (m_count != -1 && m_count < maxCount)
                     m_count = maxCount;
                 m_lastBarSetSection += sets.count();
                 blockModelSignals();
                 int modelCapacity = m_orientation == Qt::Vertical ? m_model->rowCount() - m_first : m_model->columnCount() - m_first;
                 if (maxCount > modelCapacity) {
                     if (m_orientation == Qt::Vertical)
                         m_model->insertRows(m_model->rowCount(), maxCount - modelCapacity);
                     else
                         m_model->insertColumns(m_model->columnCount(), maxCount - modelCapacity);
                 }
                 if (m_orientation == Qt::Vertical)
                     m_model->insertColumns(firstIndex + m_firstBarSetSection, sets.count());
                 else
                     m_model->insertRows(firstIndex + m_firstBarSetSection, sets.count());
                 for(int i = firstIndex + m_firstBarSetSection; i < firstIndex + m_firstBarSetSection + sets.count(); i++) {
                     m_model->setHeaderData(i, m_orientation == Qt::Vertical ? Qt::Horizontal : Qt::Vertical, sets.at(i - firstIndex - m_firstBarSetSection)->label());
                     for (int j = 0; j < sets.at(i - firstIndex - m_firstBarSetSection)->count(); j++)
                         m_model->setData(barModelIndex(i, j), sets.at(i - firstIndex - m_firstBarSetSection)->at(j));
                 }
                 blockModelSignals(false);
                 initializeBarFromModel();
             }
             void QBarModelMapperPrivate::barSetsRemoved(QList<QBarSet*> sets)
             {
                 if (m_seriesSignalsBlock)
                     return;
                 if (sets.count() == 0)
                     return;
                 int firstIndex = m_barSets.indexOf(sets.at(0));
                 if (firstIndex == -1)
                     return;
                 m_lastBarSetSection -= sets.count();
                 for (int i = firstIndex + sets.count() - 1; i >= firstIndex; i--)
                     m_barSets.removeAt(i);
                 blockModelSignals();
                 if (m_orientation == Qt::Vertical)
                     m_model->removeColumns(firstIndex + m_firstBarSetSection, sets.count());
                 else
                     m_model->removeRows(firstIndex + m_firstBarSetSection, sets.count());
                 blockModelSignals(false);
                 initializeBarFromModel();
             }
             void QBarModelMapperPrivate::valuesAdded(int index, int count)
             {
                 if (m_seriesSignalsBlock)
                     return;
                 if (m_count != -1)
                     m_count += count;
                 int barSetIndex = m_barSets.indexOf(qobject_cast<QBarSet *>(QObject::sender()));
                 blockModelSignals();
                 if (m_orientation == Qt::Vertical)
                     m_model->insertRows(index + m_first, count);
                 else
                     m_model->insertColumns(index + m_first, count);
                 for (int j = index; j < index + count; j++)
                     m_model->setData(barModelIndex(barSetIndex + m_firstBarSetSection, j), m_barSets.at(barSetIndex)->at(j));
                 blockModelSignals(false);
                 initializeBarFromModel();
             }
             void QBarModelMapperPrivate::valuesRemoved(int index, int count)
             {
                 if (m_seriesSignalsBlock)
                     return;
                 if (m_count != -1)
                     m_count -= count;
                 blockModelSignals();
                 if (m_orientation == Qt::Vertical)
                     m_model->removeRows(index + m_first, count);
                 else
                     m_model->removeColumns(index + m_first, count);
                 blockModelSignals(false);
                 initializeBarFromModel();
             }
             void QBarModelMapperPrivate::barLabelChanged()
             {
                 if (m_seriesSignalsBlock)
                     return;
                 int barSetIndex = m_barSets.indexOf(qobject_cast<QBarSet *>(QObject::sender()));
                 blockModelSignals();
                 m_model->setHeaderData(barSetIndex + m_firstBarSetSection, m_orientation == Qt::Vertical ? Qt::Horizontal : Qt::Vertical, m_barSets.at(barSetIndex)->label());
                 blockModelSignals(false);
                 initializeBarFromModel();
             }
             void QBarModelMapperPrivate::barValueChanged(int index)
             {
                 if (m_seriesSignalsBlock)
                     return;
                 int barSetIndex = m_barSets.indexOf(qobject_cast<QBarSet *>(QObject::sender()));
                 blockModelSignals();
                 m_model->setData(barModelIndex(barSetIndex + m_firstBarSetSection, index), m_barSets.at(barSetIndex)->at(index));
                 blockModelSignals(false);
                 initializeBarFromModel();
             }
             void QBarModelMapperPrivate::initializeBarFromModel()
             {
                 if (m_model == 0 || m_series == 0)
                     return;
                 blockSeriesSignals();
                 // clear current content
                 m_series->clear();
                 m_barSets.clear();
                 // create the initial bar sets
                 for (int i = m_firstBarSetSection; i <= m_lastBarSetSection; i++) {
                     int posInBar = 0;
                     QModelIndex barIndex = barModelIndex(i, posInBar);
                     // check if there is such model index
                     if (barIndex.isValid()) {
                         QBarSet *barSet = new QBarSet(m_model->headerData(i, m_orientation == Qt::Vertical ? Qt::Horizontal : Qt::Vertical).toString());
                         while (barIndex.isValid()) {
                             barSet->append(m_model->data(barIndex, Qt::DisplayRole).toDouble());
                             posInBar++;
                             barIndex = barModelIndex(i, posInBar);
                         }
                         connect(barSet, SIGNAL(valuesAdded(int, int)), this, SLOT(valuesAdded(int, int)));
                         connect(barSet, SIGNAL(valuesRemoved(int, int)), this, SLOT(valuesRemoved(int, int)));
                         connect(barSet, SIGNAL(valueChanged(int)), this, SLOT(barValueChanged(int)));
                         connect(barSet, SIGNAL(labelChanged()), this, SLOT(barLabelChanged()));
                         m_series->append(barSet);
                         m_barSets.append(barSet);
                     } else {
                         break;
                     }
                 }
                 blockSeriesSignals(false);
             }
             #include "moc_qbarmodelmapper.cpp"
             #include "moc_qbarmodelmapper_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/piechart.pri +6 -4

             INCLUDEPATH += $$PWD
             DEPENDPATH += $$PWD
             SOURCES += \
                 $$PWD/qpieseries.cpp \
                 $$PWD/piesliceitem.cpp \
                 $$PWD/piechartitem.cpp \
                 $$PWD/qpieslice.cpp \
                 $$PWD/qpiemodelmapper.cpp \
                 $$PWD/qvpiemodelmapper.cpp \
-                $$PWD/qhpiemodelmapper.cpp
+                $$PWD/qhpiemodelmapper.cpp \
+                piechart/qdonutgroup.cpp
             PRIVATE_HEADERS += \
                 $$PWD/pieslicedata_p.h \
                 $$PWD/piechartitem_p.h \
                 $$PWD/piesliceitem_p.h \
                 $$PWD/qpieslice_p.h \
                 $$PWD/qpieseries_p.h \
-                $$PWD/qpiemodelmapper_p.h
+                $$PWD/qpiemodelmapper_p.h \
+                $$PWD/qdonutgroup_p.h
             PUBLIC_HEADERS += \
                 $$PWD/qpieseries.h \
                 $$PWD/qpieslice.h \
                 $$PWD/qpiemodelmapper.h \
                 $$PWD/qvpiemodelmapper.h \
-                $$PWD/qhpiemodelmapper.h
+                $$PWD/qhpiemodelmapper.h \
+                $$PWD/qdonutgroup.h

src/piechart/piechartitem.cpp +3 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 "piechartitem_p.h"
             #include "piesliceitem_p.h"
             #include "qpieslice.h"
             #include "qpieslice_p.h"
             #include "qpieseries.h"
             #include "qpieseries_p.h"
             #include "chartpresenter_p.h"
             #include "chartdataset_p.h"
             #include "chartanimator_p.h"
             #include <QPainter>
             #include <QTimer>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             PieChartItem::PieChartItem(QPieSeries *series, ChartPresenter* presenter)
                 :ChartItem(presenter),
                 m_series(series)
             {
                 Q_ASSERT(series);
                 QPieSeriesPrivate *p = QPieSeriesPrivate::fromSeries(series);
                 connect(series, SIGNAL(visibleChanged()), this, SLOT(handleSeriesVisibleChanged()));
                 connect(series, SIGNAL(added(QList<QPieSlice*>)), this, SLOT(handleSlicesAdded(QList<QPieSlice*>)));
                 connect(series, SIGNAL(removed(QList<QPieSlice*>)), this, SLOT(handleSlicesRemoved(QList<QPieSlice*>)));
                 connect(p, SIGNAL(horizontalPositionChanged()), this, SLOT(updateLayout()));
                 connect(p, SIGNAL(verticalPositionChanged()), this, SLOT(updateLayout()));
                 connect(p, SIGNAL(pieSizeChanged()), this, SLOT(updateLayout()));
                 connect(p, SIGNAL(calculatedDataChanged()), this, SLOT(updateLayout()));
                 // Note: the following does not affect as long as the item does not have anything to paint
                 setZValue(ChartPresenter::PieSeriesZValue);
                 // Note: will not create slice items until we have a proper rectangle to draw on.
             }
             PieChartItem::~PieChartItem()
             {
                 // slices deleted automatically through QGraphicsItem
             }
             void PieChartItem::handleGeometryChanged(const QRectF& rect)
             {
                 prepareGeometryChange();
                 m_rect = rect;
                 updateLayout();
                 // This is for delayed initialization of the slice items during startup.
                 // It ensures that startup animation originates from the correct position.
                 if (m_sliceItems.isEmpty())
                     handleSlicesAdded(m_series->slices());
             }
             void PieChartItem::handleDomainChanged(qreal minX, qreal maxX, qreal minY, qreal maxY)
             {
                 Q_UNUSED(minX);
                 Q_UNUSED(maxX);
                 Q_UNUSED(minY);
                 Q_UNUSED(maxY);
                 // does not apply to pie
             }
             void PieChartItem::rangeXChanged(qreal min, qreal max, int tickXCount)
             {
                 Q_UNUSED(min);
                 Q_UNUSED(max);
                 Q_UNUSED(tickXCount);
                 // does not apply to pie
             }
             void PieChartItem::rangeYChanged(qreal min, qreal max, int tickYCount)
             {
                 Q_UNUSED(min);
                 Q_UNUSED(max);
                 Q_UNUSED(tickYCount);
                 // does not apply to pie
             }
             void PieChartItem::updateLayout()
             {
                 // find pie center coordinates
                 m_pieCenter.setX(m_rect.left() + (m_rect.width() * m_series->horizontalPosition()));
                 m_pieCenter.setY(m_rect.top() + (m_rect.height() * m_series->verticalPosition()));
                 // find maximum radius for pie
                 m_pieRadius = m_rect.height() / 2;
                 if (m_rect.width() < m_rect.height())
                     m_pieRadius = m_rect.width() / 2;
+                m_donutInnerRadius = m_pieRadius;
                 // apply size factor
                 m_pieRadius *= m_series->pieSize();
+                m_donutInnerRadius *= m_series->donutInnerSize();
                 // set layouts for existing slice items
                 foreach (QPieSlice* slice, m_series->slices()) {
                     PieSliceItem *sliceItem = m_sliceItems.value(slice);
                     if (sliceItem) {
                         PieSliceData sliceData = updateSliceGeometry(slice);
                         if (animator())
                             animator()->updateAnimation(this, sliceItem, sliceData);
                         else
                             sliceItem->setLayout(sliceData);
                     }
                 }
                 update();
             }
             void PieChartItem::handleSlicesAdded(QList<QPieSlice*> slices)
             {
                 // delay creating slice items until there is a proper rectangle
                 if (!m_rect.isValid() && m_sliceItems.isEmpty())
                     return;
                 presenter()->chartTheme()->decorate(m_series, presenter()->dataSet()->seriesIndex(m_series));
                 bool startupAnimation = m_sliceItems.isEmpty();
                 foreach (QPieSlice *slice, slices) {
                     PieSliceItem* sliceItem = new PieSliceItem(this);
                     m_sliceItems.insert(slice, sliceItem);
                     // Note: no need to connect to slice valueChanged() etc.
                     // This is handled through calculatedDataChanged signal.
                     connect(slice, SIGNAL(labelChanged()), this, SLOT(handleSliceChanged()));
                     connect(slice, SIGNAL(labelVisibleChanged()), this, SLOT(handleSliceChanged()));
                     connect(slice, SIGNAL(penChanged()), this, SLOT(handleSliceChanged()));
                     connect(slice, SIGNAL(brushChanged()), this, SLOT(handleSliceChanged()));
                     connect(slice, SIGNAL(labelBrushChanged()), this, SLOT(handleSliceChanged()));
                     connect(slice, SIGNAL(labelFontChanged()), this, SLOT(handleSliceChanged()));
                     QPieSlicePrivate *p = QPieSlicePrivate::fromSlice(slice);
                     connect(p, SIGNAL(labelPositionChanged()), this, SLOT(handleSliceChanged()));
                     connect(p, SIGNAL(explodedChanged()), this, SLOT(handleSliceChanged()));
                     connect(p, SIGNAL(labelArmLengthFactorChanged()), this, SLOT(handleSliceChanged()));
                     connect(p, SIGNAL(explodeDistanceFactorChanged()), this, SLOT(handleSliceChanged()));
                     connect(sliceItem, SIGNAL(clicked(Qt::MouseButtons)), slice, SIGNAL(clicked()));
                     connect(sliceItem, SIGNAL(hovered(bool)), slice, SIGNAL(hovered(bool)));
                     PieSliceData sliceData = updateSliceGeometry(slice);
                     if (animator())
                         animator()->addAnimation(this, sliceItem, sliceData, startupAnimation);
                     else
                         sliceItem->setLayout(sliceData);
                 }
             }
             void PieChartItem::handleSlicesRemoved(QList<QPieSlice*> slices)
             {
                 presenter()->chartTheme()->decorate(m_series, presenter()->dataSet()->seriesIndex(m_series));
                 foreach (QPieSlice *slice, slices) {
                     PieSliceItem *sliceItem = m_sliceItems.value(slice);
                     // this can happen if you call append() & remove() in a row so that PieSliceItem is not even created
                     if (!sliceItem)
                         continue;
                     m_sliceItems.remove(slice);
                     if (animator())
                         animator()->removeAnimation(this, sliceItem); // animator deletes the PieSliceItem
                     else
                         delete sliceItem;
                 }
             }
             void PieChartItem::handleSliceChanged()
             {
                 QPieSlice* slice = qobject_cast<QPieSlice *>(sender());
                 if (!slice) {
                     QPieSlicePrivate* slicep = qobject_cast<QPieSlicePrivate *>(sender());
                     slice = slicep->q_ptr;
                 }
                 Q_ASSERT(m_sliceItems.contains(slice));
                 PieSliceItem *sliceItem = m_sliceItems.value(slice);
                 PieSliceData sliceData = updateSliceGeometry(slice);
                 if (animator())
                     animator()->updateAnimation(this, sliceItem, sliceData);
                 else
                     sliceItem->setLayout(sliceData);
                 update();
             }
             void PieChartItem::handleSeriesVisibleChanged()
             {
                 setVisible(m_series->isVisible());
             }
             PieSliceData PieChartItem::updateSliceGeometry(QPieSlice *slice)
             {
                 PieSliceData &sliceData = QPieSlicePrivate::fromSlice(slice)->m_data;
                 sliceData.m_center = PieSliceItem::sliceCenter(m_pieCenter, m_pieRadius, slice);
                 sliceData.m_radius = m_pieRadius;
                 sliceData.m_donut = m_series->donut();
+                sliceData.m_innerRadius = m_donutInnerRadius;
                 return sliceData;
             }
             #include "moc_piechartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/piechartitem_p.h +1 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$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef PIECHARTITEM_H
             #define PIECHARTITEM_H
             #include "qpieseries.h"
             #include "chartitem_p.h"
             #include "piesliceitem_p.h"
             class QGraphicsItem;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QPieSlice;
             class ChartPresenter;
             class PieChartItem : public ChartItem
             {
                 Q_OBJECT
             public:
                 explicit PieChartItem(QPieSeries *series, ChartPresenter *presenter);
                 ~PieChartItem();
                 // from QGraphicsItem
                 QRectF boundingRect() const { return m_rect; }
                 void paint(QPainter *, const QStyleOptionGraphicsItem *, QWidget *) {}
             public Q_SLOTS:
                 // from Chart
                 virtual void handleGeometryChanged(const QRectF &rect);
                 virtual void handleDomainChanged(qreal minX, qreal maxX, qreal minY, qreal maxY);
                 virtual void rangeXChanged(qreal min, qreal max, int tickXCount);
                 virtual void rangeYChanged(qreal min, qreal max, int tickYCount);
                 void updateLayout();
                 void handleSlicesAdded(QList<QPieSlice*> slices);
                 void handleSlicesRemoved(QList<QPieSlice*> slices);
                 void handleSliceChanged();
                 void handleSeriesVisibleChanged();
             private:
                 PieSliceData updateSliceGeometry(QPieSlice *slice);
             private:
                 QHash<QPieSlice*, PieSliceItem*> m_sliceItems;
                 QPieSeries *m_series;
                 QRectF m_rect;
                 QPointF m_pieCenter;
                 qreal m_pieRadius;
+                qreal m_donutInnerRadius;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // PIECHARTITEM_H

src/piechart/pieslicedata_p.h +4 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$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef PIESLICEDATA_P_H
             #define PIESLICEDATA_P_H
             #include "qchartglobal.h"
             #include "qpieslice.h"
             #include <QPen>
             #include <QBrush>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             template <class T>
             class Themed : public T
             {
             public:
                 Themed():m_isThemed(true) {}
                 inline T &operator=(const T &other) { return T::operator =(other); }
                 inline bool operator!=(const T &other) const { return T::operator !=(other); }
                 inline bool operator!=(const Themed &other) const
                 {
                     if (T::operator !=(other))
                         return true;
                     if (m_isThemed != other.m_isThemed)
                         return true;
                     return false;
                 }
                 inline void setThemed(bool state) { m_isThemed = state; }
                 inline bool isThemed() const { return m_isThemed; }
             private:
                 bool m_isThemed;
             };
             class PieSliceData
             {
             public:
                 PieSliceData()
                 {
                     m_value = 0;
                     m_isExploded = false;
                     m_explodeDistanceFactor = 0.15;
                     m_isLabelVisible = false;
                     m_labelPosition = QPieSlice::LabelOutside;
                     m_labelArmLengthFactor = 0.15;
                     m_percentage = 0;
                     m_radius = 0;
                     m_startAngle = 0;
                     m_angleSpan = 0;
                     m_donut = false;
+                    m_innerRadius = 0;
                 }
                 bool operator!=(const PieSliceData &other) const
                 {
                     if (!qFuzzyIsNull(m_value - other.m_value))
                         return true;
                     if (m_slicePen != other.m_slicePen ||
                         m_sliceBrush != other.m_sliceBrush)
                         return true;
                     if (m_isExploded != other.m_isExploded ||
                         !qFuzzyIsNull(m_explodeDistanceFactor - other.m_explodeDistanceFactor))
                         return true;
                     if (m_isLabelVisible != other.m_isLabelVisible ||
                         m_labelText != other.m_labelText ||
                         m_labelFont != other.m_labelFont ||
                         m_labelPosition != other.m_labelPosition ||
                         !qFuzzyIsNull(m_labelArmLengthFactor - other.m_labelArmLengthFactor) ||
                         m_labelBrush != other.m_labelBrush)
                         return true;
                     if (!qFuzzyIsNull(m_percentage - other.m_percentage) ||
                         m_center != other.m_center ||
                         !qFuzzyIsNull(m_radius - other.m_radius) ||
                         !qFuzzyIsNull(m_startAngle - other.m_startAngle) ||
                         !qFuzzyIsNull(m_angleSpan - other.m_angleSpan))
                         return true;
                     return false;
                 }
                 qreal m_value;
                 Themed<QPen> m_slicePen;
                 Themed<QBrush> m_sliceBrush;
                 bool m_isExploded;
                 qreal m_explodeDistanceFactor;
                 bool m_isLabelVisible;
                 QString m_labelText;
                 Themed<QFont> m_labelFont;
                 QPieSlice::LabelPosition m_labelPosition;
                 qreal m_labelArmLengthFactor;
                 Themed<QBrush> m_labelBrush;
                 qreal m_percentage;
                 QPointF m_center;
                 qreal m_radius;
                 qreal m_startAngle;
                 qreal m_angleSpan;
                 bool m_donut;
+                qreal m_innerRadius;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // PIESLICEDATA_P_H

src/piechart/piesliceitem.cpp +1 -2

             /****************************************************************************
             **
             ** 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 "piesliceitem_p.h"
             #include "piechartitem_p.h"
             #include "qpieseries.h"
             #include "qpieslice.h"
             #include "chartpresenter_p.h"
             #include <QPainter>
             #include <qmath.h>
             #include <QGraphicsSceneEvent>
             #include <QTime>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             QPointF offset(qreal angle, qreal length)
             {
                 qreal dx = qSin(angle*(M_PI/180)) * length;
                 qreal dy = qCos(angle*(M_PI/180)) * length;
                 return QPointF(dx, -dy);
             }
             PieSliceItem::PieSliceItem(QGraphicsItem* parent)
                 :QGraphicsObject(parent),
                   m_hovered(false)
             {
                 setAcceptHoverEvents(true);
                 setAcceptedMouseButtons(Qt::MouseButtonMask);
                 setZValue(ChartPresenter::PieSeriesZValue);
             }
             PieSliceItem::~PieSliceItem()
             {
                 // If user is hovering over the slice and it gets destroyed we do
                 // not get a hover leave event. So we must emit the signal here.
                 if (m_hovered)
                     emit hovered(false);
             }
             QRectF PieSliceItem::boundingRect() const
             {
                 return m_boundingRect;
             }
             QPainterPath PieSliceItem::shape() const
             {
                 // Don't include the label and label arm.
                 // This is used to detect a mouse clicks. We do not want clicks from label.
                 return m_slicePath;
             }
             void PieSliceItem::paint(QPainter* painter, const QStyleOptionGraphicsItem* /*option*/, QWidget* /*widget*/)
             {
                 painter->save();
                 painter->setClipRect(parentItem()->boundingRect());
                 painter->setPen(m_data.m_slicePen);
                 painter->setBrush(m_data.m_sliceBrush);
                 painter->drawPath(m_slicePath);
                 painter->restore();
                 if (m_data.m_isLabelVisible) {
                     painter->save();
                     // Pen for label arm not defined in the QPieSeries api, let's use brush's color instead
                     // Also, the drawText actually uses the pen color for the text color (unlike QGraphicsSimpleTextItem)
                     painter->setPen(m_data.m_labelBrush.color());
                     painter->setBrush(m_data.m_labelBrush);
                     painter->setFont(m_data.m_labelFont);
                     if (m_data.m_labelPosition == QPieSlice::LabelOutside) {
                         painter->setClipRect(parentItem()->boundingRect());
                         painter->strokePath(m_labelArmPath, m_data.m_labelBrush.color());
                     } else { // QPieSlice::LabelInside
                         painter->setClipPath(m_slicePath);
                     }
                     painter->drawText(m_labelTextRect, Qt::AlignCenter, m_data.m_labelText);
                     painter->restore();
                 }
             }
             void PieSliceItem::hoverEnterEvent(QGraphicsSceneHoverEvent* /*event*/)
             {
                 m_hovered = true;
                 emit hovered(true);
             }
             void PieSliceItem::hoverLeaveEvent(QGraphicsSceneHoverEvent* /*event*/)
             {
                 m_hovered = false;
                 emit hovered(false);
             }
             void PieSliceItem::mousePressEvent(QGraphicsSceneMouseEvent *event)
             {
                 emit clicked(event->buttons());
             }
             void PieSliceItem::setLayout(const PieSliceData &sliceData)
             {
                 m_data = sliceData;
                 updateGeometry();
                 update();
             }
             void PieSliceItem::updateGeometry()
             {
                 if (m_data.m_radius <= 0)
                     return;
                 prepareGeometryChange();
                 // slice path
                 qreal centerAngle;
                 QPointF armStart;
                 m_slicePath = slicePath(m_data.m_center, m_data.m_radius, m_data.m_startAngle, m_data.m_angleSpan, &centerAngle, &armStart);
                 // text rect
                 QFontMetricsF fm(m_data.m_labelFont);
                 m_labelTextRect = QRectF(0, 0, fm.width(m_data.m_labelText), fm.height());
                 // label arm path
                 QPointF labelTextStart;
                 m_labelArmPath = labelArmPath(armStart, centerAngle, m_data.m_radius * m_data.m_labelArmLengthFactor, m_labelTextRect.width(), &labelTextStart);
                 // text position
                 if (m_data.m_labelPosition == QPieSlice::LabelOutside)
                     m_labelTextRect.moveBottomLeft(labelTextStart);
                 else {// QPieSlice::LabelInside
                     QPointF sliceCenter = m_data.m_center + offset(centerAngle, m_data.m_radius / 2);
                     m_labelTextRect.moveCenter(sliceCenter);
                 }
                 //  bounding rect
                 if (m_data.m_isLabelVisible)
                     m_boundingRect = m_slicePath.boundingRect().united(m_labelArmPath.boundingRect()).united(m_labelTextRect);
                 else
                     m_boundingRect = m_slicePath.boundingRect();
             }
             QPointF PieSliceItem::sliceCenter(QPointF point, qreal radius, QPieSlice *slice)
             {
                 if (slice->isExploded()) {
                     qreal centerAngle = slice->startAngle() + (slice->angleSpan()/2);
                     qreal len = radius * slice->explodeDistanceFactor();
                     point += offset(centerAngle, len);
                 }
                 return point;
             }
             QPainterPath PieSliceItem::slicePath(QPointF center, qreal radius, qreal startAngle, qreal angleSpan, qreal *centerAngle, QPointF* armStart)
             {
                 // calculate center angle
                 *centerAngle = startAngle + (angleSpan/2);
                 // calculate slice rectangle
                 QRectF rect(center.x()-radius, center.y()-radius, radius*2, radius*2);
                 // slice path
                 QPainterPath path;
                 if (m_data.m_donut) {
-                    qreal donutFraction = 5.0;
+                    QRectF insideRect(center.x() - m_data.m_innerRadius, center.y()-m_data.m_innerRadius, m_data.m_innerRadius*2, m_data.m_innerRadius*2);
-                    QRectF insideRect = rect.adjusted(rect.width() / donutFraction, rect.height() / donutFraction, -rect.width() / donutFraction, -rect.height() / donutFraction);
                     path.arcMoveTo(rect, -startAngle + 90);
                     path.arcTo(rect, -startAngle + 90, -angleSpan);
                     path.arcTo(insideRect, -startAngle + 90 - angleSpan, angleSpan);
                     path.closeSubpath();
                 } else {
                     path.moveTo(rect.center());
                     path.arcTo(rect, -startAngle + 90, -angleSpan);
                     path.closeSubpath();
                 }
                 // calculate label arm start point
                 *armStart = center;
                 *armStart += offset(*centerAngle, radius + PIESLICE_LABEL_GAP);
                 return path;
             }
             QPainterPath PieSliceItem::labelArmPath(QPointF start, qreal angle, qreal length, qreal textWidth, QPointF *textStart)
             {
                 // Normalize the angle to 0-360 range
                 // NOTE: We are using int here on purpose. Depenging on platform and hardware
                 // qreal can be a double, float or something the user gives to the Qt configure
                 // (QT_COORD_TYPE). Compilers do not seem to support modulo for double or float
                 // but there are fmod() and fmodf() functions for that. So instead of some #ifdef
                 // that might break we just use int. Precision for this is just fine for our needs.
                 int normalized = angle * 10.0;
                 normalized = normalized % 3600;
                 if (normalized < 0)
                     normalized += 3600;
                 angle = (qreal) normalized / 10.0;
                 // prevent label arm pointing straight down because it will look bad
                 if (angle < 180 && angle > 170)
                     angle = 170;
                 if (angle > 180 && angle < 190)
                     angle = 190;
                 // line from slice to label
                 QPointF parm1 = start + offset(angle, length);
                 // line to underline the label
                 QPointF parm2 = parm1;
                 if (angle < 180) { // arm swings the other way on the left side
                     parm2 += QPointF(textWidth, 0);
                     *textStart = parm1;
                 }
                 else {
                     parm2 += QPointF(-textWidth,0);
                     *textStart = parm2;
                 }
                 QPainterPath path;
                 path.moveTo(start);
                 path.lineTo(parm1);
                 path.lineTo(parm2);
                 return path;
             }
             #include "moc_piesliceitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/qpiemodelmapper.cpp +1 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 "qpiemodelmapper.h"
             #include "qpieseries.h"
             #include "qpieslice.h"
             #include <QAbstractItemModel>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             QPieModelMapper::QPieModelMapper(QObject *parent) :
                 QObject(parent),
                 d_ptr(new QPieModelMapperPrivate(this))
             {
             }
             QAbstractItemModel* QPieModelMapper::model() const
             {
                 Q_D(const QPieModelMapper);
                 return d->m_model;
             }
             void QPieModelMapper::setModel(QAbstractItemModel *model)
             {
                 if (model == 0)
                     return;
                 Q_D(QPieModelMapper);
                 if (d->m_model) {
                     disconnect(d->m_model, 0, d, 0);
                 }
                 d->m_model = model;
                 d->initializePieFromModel();
                 //    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)));
                 connect(d->m_model, SIGNAL(destroyed()), d, SLOT(handleModelDestroyed()));
             }
             QPieSeries* QPieModelMapper::series() const
             {
                 Q_D(const QPieModelMapper);
                 return d->m_series;
             }
             void QPieModelMapper::setSeries(QPieSeries *series)
             {
                 Q_D(QPieModelMapper);
                 if (d->m_series) {
                     disconnect(d->m_series, 0, d, 0);
                 }
                 if (series == 0)
                     return;
                 d->m_series = series;
                 d->initializePieFromModel();
                 // connect the signals from the series
                 connect(d->m_series, SIGNAL(added(QList<QPieSlice*>)), d, SLOT(slicesAdded(QList<QPieSlice*>)));
                 connect(d->m_series, SIGNAL(removed(QList<QPieSlice*>)), d, SLOT(slicesRemoved(QList<QPieSlice*>)));
                 connect(d->m_series, SIGNAL(destroyed()), d, SLOT(handleSeriesDestroyed()));
             }
             /*!
                 Defines which row/column of the model contains the first slice value.
                 Minimal and default value is: 0
             */
             int QPieModelMapper::first() const
             {
                 Q_D(const QPieModelMapper);
                 return d->m_first;
             }
             /*!
                 Sets which row/column of the model contains the \a first slice value.
                 Minimal and default value is: 0
             */
             void QPieModelMapper::setFirst(int first)
             {
                 Q_D(QPieModelMapper);
                 d->m_first = qMax(first, 0);
                 d->initializePieFromModel();
             }
             /*!
                 Defines the number of rows/columns of the model that are mapped as the data for QPieSeries
                 Minimal and default value is: -1 (count limited by the number of rows/columns in the model)
             */
             int QPieModelMapper::count() const
             {
                 Q_D(const QPieModelMapper);
                 return d->m_count;
             }
             /*!
                 Defines the \a count of rows/columns of the model that are mapped as the data for QPieSeries
                 Minimal and default value is: -1 (count limited by the number of rows/columns in the model)
             */
             void QPieModelMapper::setCount(int count)
             {
                 Q_D(QPieModelMapper);
                 d->m_count = qMax(count, -1);
                 d->initializePieFromModel();
             }
             /*!
                 Returns the orientation that is used when QPieModelMapper accesses the model.
                 This mean whether the consecutive values/labels of the pie are read from row (Qt::Horizontal)
                 or from columns (Qt::Vertical)
             */
             Qt::Orientation QPieModelMapper::orientation() const
             {
                 Q_D(const QPieModelMapper);
                 return d->m_orientation;
             }
             /*!
                 Returns the \a orientation that is used when QPieModelMapper accesses the model.
                 This mean whether the consecutive values/labels of the pie are read from row (Qt::Horizontal)
                 or from columns (Qt::Vertical)
             */
             void QPieModelMapper::setOrientation(Qt::Orientation orientation)
             {
                 Q_D(QPieModelMapper);
                 d->m_orientation = orientation;
                 d->initializePieFromModel();
             }
             /*!
                 Returns which section of the model is kept in sync with the values of the pie's slices
             */
             int QPieModelMapper::valuesSection() const
             {
                 Q_D(const QPieModelMapper);
                 return d->m_valuesSection;
             }
             /*!
                 Sets the model section that is kept in sync with the pie slices values.
                 Parameter \a valuesSection specifies the section of the model.
             */
             void QPieModelMapper::setValuesSection(int valuesSection)
             {
                 Q_D(QPieModelMapper);
                 d->m_valuesSection = qMax(-1, valuesSection);
                 d->initializePieFromModel();
             }
             /*!
                 Returns which section of the model is kept in sync with the labels of the pie's slices
             */
             int QPieModelMapper::labelsSection() const
             {
                 Q_D(const QPieModelMapper);
                 return d->m_labelsSection;
             }
             /*!
                 Sets the model section that is kept in sync with the pie slices labels.
                 Parameter \a labelsSection specifies the section of the model.
             */
             void QPieModelMapper::setLabelsSection(int labelsSection)
             {
                 Q_D(QPieModelMapper);
                 d->m_labelsSection = qMax(-1, labelsSection);
                 d->initializePieFromModel();
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QPieModelMapperPrivate::QPieModelMapperPrivate(QPieModelMapper *q) :
+                QObject(q),
                 m_series(0),
                 m_model(0),
                 m_first(0),
                 m_count(-1),
                 m_orientation(Qt::Vertical),
                 m_valuesSection(-1),
                 m_labelsSection(-1),
                 m_seriesSignalsBlock(false),
                 m_modelSignalsBlock(false),
                 q_ptr(q)
             {
             }
             void QPieModelMapperPrivate::blockModelSignals(bool block)
             {
                 m_modelSignalsBlock = block;
             }
             void QPieModelMapperPrivate::blockSeriesSignals(bool block)
             {
                 m_seriesSignalsBlock = block;
             }
             QPieSlice* QPieModelMapperPrivate::pieSlice(QModelIndex index) const
             {
                 if (!index.isValid())
                     return 0; // index is invalid
                 if (m_orientation == Qt::Vertical && (index.column() == m_valuesSection || index.column() == m_labelsSection)) {
                     if (index.row() >= m_first && (m_count == - 1 || index.row() < m_first + m_count)) {
                         if (m_model->index(index.row(), m_valuesSection).isValid() && m_model->index(index.row(), m_labelsSection).isValid())
                             return m_series->slices().at(index.row() - m_first);
                         else
                             return 0;
                     }
                 } else if (m_orientation == Qt::Horizontal && (index.row() == m_valuesSection || index.row() == m_labelsSection)) {
                     if (index.column() >= m_first && (m_count == - 1 || index.column() < m_first + m_count)) {
                         if (m_model->index(m_valuesSection, index.column()).isValid() && m_model->index(m_labelsSection, index.column()).isValid())
                             return m_series->slices().at(index.column() - m_first);
                         else
                             return 0;
                     }
                 }
                 return 0; // This part of model has not been mapped to any slice
             }
             QModelIndex QPieModelMapperPrivate::valueModelIndex(int slicePos)
             {
                 if (m_count != -1 && slicePos >= m_count)
                     return QModelIndex(); // invalid
                 if (m_orientation == Qt::Vertical)
                     return m_model->index(slicePos + m_first, m_valuesSection);
                 else
                     return m_model->index(m_valuesSection, slicePos + m_first);
             }
             QModelIndex QPieModelMapperPrivate::labelModelIndex(int slicePos)
             {
                 if (m_count != -1 && slicePos >= m_count)
                     return QModelIndex(); // invalid
                 if (m_orientation == Qt::Vertical)
                     return m_model->index(slicePos + m_first, m_labelsSection);
                 else
                     return m_model->index(m_labelsSection, slicePos + m_first);
             }
             bool QPieModelMapperPrivate::isLabelIndex(QModelIndex index) const
             {
                 if (m_orientation == Qt::Vertical && index.column() == m_labelsSection)
                     return true;
                 else if (m_orientation == Qt::Horizontal && index.row() == m_labelsSection)
                     return true;
                 return false;
             }
             bool QPieModelMapperPrivate::isValueIndex(QModelIndex index) const
             {
                 if (m_orientation == Qt::Vertical && index.column() == m_valuesSection)
                     return true;
                 else if (m_orientation == Qt::Horizontal && index.row() == m_valuesSection)
                     return true;
                 return false;
             }
             void QPieModelMapperPrivate::slicesAdded(QList<QPieSlice*> slices)
             {
                 if (m_seriesSignalsBlock)
                     return;
                 if (slices.count() == 0)
                     return;
                 int firstIndex = m_series->slices().indexOf(slices.at(0));
                 if (firstIndex == -1)
                     return;
                 if (m_count != -1)
                     m_count += slices.count();
                 for (int i = firstIndex; i < firstIndex + slices.count(); i++) {
                     m_slices.insert(i, slices.at(i - firstIndex));
                     connect(slices.at(i - firstIndex), SIGNAL(labelChanged()), this, SLOT(sliceLabelChanged()));
                     connect(slices.at(i - firstIndex), SIGNAL(valueChanged()), this, SLOT(sliceValueChanged()));
                 }
                 blockModelSignals();
                 if (m_orientation == Qt::Vertical)
                     m_model->insertRows(firstIndex + m_first, slices.count());
                 else
                     m_model->insertColumns(firstIndex + m_first, slices.count());
                 for(int i = firstIndex; i < firstIndex + slices.count(); i++) {
                     m_model->setData(valueModelIndex(i), slices.at(i - firstIndex)->value());
                     m_model->setData(labelModelIndex(i), slices.at(i - firstIndex)->label());
                 }
                 blockModelSignals(false);
             }
             void QPieModelMapperPrivate::slicesRemoved(QList<QPieSlice*> slices)
             {
                 if (m_seriesSignalsBlock)
                     return;
                 if (slices.count() == 0)
                     return;
                 int firstIndex = m_slices.indexOf(slices.at(0));
                 if (firstIndex == -1)
                     return;
                 if (m_count != -1)
                     m_count -= slices.count();
                 for (int i = firstIndex + slices.count() - 1; i >= firstIndex; i--)
                     m_slices.removeAt(i);
                 blockModelSignals();
                 if (m_orientation == Qt::Vertical)
                     m_model->removeRows(firstIndex + m_first, slices.count());
                 else
                     m_model->removeColumns(firstIndex + m_first, slices.count());
                 blockModelSignals(false);
             }
             void QPieModelMapperPrivate::sliceLabelChanged()
             {
                 if (m_seriesSignalsBlock)
                     return;
                 blockModelSignals();
                 QPieSlice *slice = qobject_cast<QPieSlice *>(QObject::sender());
                 m_model->setData(labelModelIndex(m_series->slices().indexOf(slice)), slice->label());
                 blockModelSignals(false);
             }
             void QPieModelMapperPrivate::sliceValueChanged()
             {
                 if (m_seriesSignalsBlock)
                     return;
                 blockModelSignals();
                 QPieSlice *slice = qobject_cast<QPieSlice *>(QObject::sender());
                 m_model->setData(valueModelIndex(m_series->slices().indexOf(slice)), slice->value());
                 blockModelSignals(false);
             }
             void QPieModelMapperPrivate::handleSeriesDestroyed()
             {
                 m_series = 0;
             }
             void QPieModelMapperPrivate::modelUpdated(QModelIndex topLeft, QModelIndex bottomRight)
             {
                 if (m_model == 0 || m_series == 0)
                     return;
                 if (m_modelSignalsBlock)
                     return;
                 blockSeriesSignals();
                 QModelIndex index;
                 QPieSlice *slice;
                 for (int row = topLeft.row(); row <= bottomRight.row(); row++) {
                     for (int column = topLeft.column(); column <= bottomRight.column(); column++) {
                         index = topLeft.sibling(row, column);
                         slice = pieSlice(index);
                         if (slice) {
                             if (isValueIndex(index))
                                 slice->setValue(m_model->data(index, Qt::DisplayRole).toReal());
                             if (isLabelIndex(index))
                                 slice->setLabel(m_model->data(index, Qt::DisplayRole).toString());
                         }
                     }
                 }
                 blockSeriesSignals(false);
             }
             void QPieModelMapperPrivate::modelRowsAdded(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent);
                 if (m_modelSignalsBlock)
                     return;
                 blockSeriesSignals();
                 if (m_orientation == Qt::Vertical)
                     insertData(start, end);
                 else if (start <= m_valuesSection || start <= m_labelsSection) // if the changes affect the map - reinitialize the pie
                     initializePieFromModel();
                 blockSeriesSignals(false);
             }
             void QPieModelMapperPrivate::modelRowsRemoved(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent);
                 if (m_modelSignalsBlock)
                     return;
                 blockSeriesSignals();
                 if (m_orientation == Qt::Vertical)
                     removeData(start, end);
                 else if (start <= m_valuesSection || start <= m_labelsSection) // if the changes affect the map - reinitialize the pie
                     initializePieFromModel();
                 blockSeriesSignals(false);
             }
             void QPieModelMapperPrivate::modelColumnsAdded(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent);
                 if (m_modelSignalsBlock)
                     return;
                 blockSeriesSignals();
                 if (m_orientation == Qt::Horizontal)
                     insertData(start, end);
                 else if (start <= m_valuesSection || start <= m_labelsSection) // if the changes affect the map - reinitialize the pie
                     initializePieFromModel();
                 blockSeriesSignals(false);
             }
             void QPieModelMapperPrivate::modelColumnsRemoved(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent);
                 if (m_modelSignalsBlock)
                     return;
                 blockSeriesSignals();
                 if (m_orientation == Qt::Horizontal)
                     removeData(start, end);
                 else if (start <= m_valuesSection || start <= m_labelsSection) // if the changes affect the map - reinitialize the pie
                     initializePieFromModel();
                 blockSeriesSignals(false);
             }
             void QPieModelMapperPrivate::handleModelDestroyed()
             {
                 m_model = 0;
             }
             void QPieModelMapperPrivate::insertData(int start, int 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 i = first; i <= last; i++) {
                         QModelIndex valueIndex = valueModelIndex(i - m_first);
                         QModelIndex labelIndex = labelModelIndex(i - m_first);
                         if (valueIndex.isValid() && labelIndex.isValid()) {
                             QPieSlice *slice = new QPieSlice;
                             slice->setValue(m_model->data(valueIndex, Qt::DisplayRole).toDouble());
                             slice->setLabel(m_model->data(labelIndex, Qt::DisplayRole).toString());
                             connect(slice, SIGNAL(labelChanged()), this, SLOT(sliceLabelChanged()));
                             connect(slice, SIGNAL(valueChanged()), this, SLOT(sliceValueChanged()));
                             m_series->insert(i - m_first, slice);
                             m_slices.insert(i - m_first, slice);
                         }
                     }
                     // remove excess of slices (abouve m_count)
                     if (m_count != -1 && m_series->slices().size() > m_count)
                         for (int i = m_series->slices().size() - 1; i >= m_count; i--) {
                             m_series->remove(m_series->slices().at(i));
                             m_slices.removeAt(i);
                         }
                 }
             }
             void QPieModelMapperPrivate::removeData(int start, int 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->slices().size(), 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->slices().size() + 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->slices().at(i - m_first));
                         m_slices.removeAt(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->slices().size();
                         else
                             itemsAvailable = m_model->columnCount() - m_first - m_series->slices().size();
                         int toBeAdded = qMin(itemsAvailable, m_count - m_series->slices().size());     // add not more items than there is space left to be filled.
                         int currentSize = m_series->slices().size();
                         if (toBeAdded > 0)
                             for (int i = m_series->slices().size(); i < currentSize + toBeAdded; i++) {
                                 QModelIndex valueIndex = valueModelIndex(i - m_first);
                                 QModelIndex labelIndex = labelModelIndex(i - m_first);
                                 if (valueIndex.isValid() && labelIndex.isValid()) {
                                     QPieSlice *slice = new QPieSlice;
                                     slice->setValue(m_model->data(valueIndex, Qt::DisplayRole).toDouble());
                                     slice->setLabel(m_model->data(labelIndex, Qt::DisplayRole).toString());
                                     m_series->insert(i, slice);
                                     m_slices.insert(i, slice);
                                 }
                             }
                     }
                 }
             }
             void QPieModelMapperPrivate::initializePieFromModel()
             {
                 if (m_model == 0 || m_series == 0)
                     return;
                 blockSeriesSignals();
                 // clear current content
                 m_series->clear();
                 m_slices.clear();
                 // create the initial slices set
                 int slicePos = 0;
                 QModelIndex valueIndex = valueModelIndex(slicePos);
                 QModelIndex labelIndex = labelModelIndex(slicePos);
                 while (valueIndex.isValid() && labelIndex.isValid()) {
                     QPieSlice *slice = new QPieSlice;
                     slice->setLabel(m_model->data(labelIndex, Qt::DisplayRole).toString());
                     slice->setValue(m_model->data(valueIndex, Qt::DisplayRole).toDouble());
                     connect(slice, SIGNAL(labelChanged()), this, SLOT(sliceLabelChanged()));
                     connect(slice, SIGNAL(valueChanged()), this, SLOT(sliceValueChanged()));
                     m_series->append(slice);
                     m_slices.append(slice);
                     slicePos++;
                     valueIndex = valueModelIndex(slicePos);
                     labelIndex = labelModelIndex(slicePos);
                 }
                 blockSeriesSignals(false);
             }
             #include "moc_qpiemodelmapper_p.cpp"
             #include "moc_qpiemodelmapper.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/qpieseries.cpp +22 -2

             /****************************************************************************
             **
             ** 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 "qpieseries.h"
             #include "qpieseries_p.h"
             #include "qpieslice.h"
             #include "qpieslice_p.h"
             #include "pieslicedata_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             #include "chartanimator_p.h"
             #include "legendmarker_p.h"
             #include "qabstractaxis.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QPieSeries
                 \brief Pie series API for QtCommercial Charts
                 The pie series defines a pie chart which consists of pie slices which are defined as QPieSlice objects.
                 The slices can have any values as the QPieSeries will calculate its relative value to the sum of all slices.
                 The actual slice size is determined by that relative value.
                 Pie size and position on the chart is controlled by using relative values which range from 0.0 to 1.0
                 These relate to the actual chart rectangle.
                 By default the pie is defined as a full pie but it can also be a partial pie.
                 This can be done by setting a starting angle and angle span to the series.
                 Full pie is 360 degrees where 0 is at 12 a'clock.
                 See the \l {PieChart Example} {pie chart example} to learn how to create a simple pie chart.
                 \image examples_piechart.png
             */
             /*!
                 \qmlclass PieSeries QPieSeries
                 \inherits AbstractSeries
                 The following QML shows how to create a simple pie chart.
                 \snippet ../demos/qmlchart/qml/qmlchart/View1.qml 1
                 \beginfloatleft
                 \image demos_qmlchart1.png
                 \endfloat
                 \clearfloat
             */
             /*!
                 \property QPieSeries::horizontalPosition
                 \brief Defines the horizontal position of the pie.
                 The value is a relative value to the chart rectangle where:
                 \list
                 \o 0.0 is the absolute left.
                 \o 1.0 is the absolute right.
                 \endlist
                 Default value is 0.5 (center).
                 \sa verticalPosition
             */
             /*!
                 \qmlproperty real PieSeries::horizontalPosition
                 Defines the horizontal position of the pie.
                 The value is a relative value to the chart rectangle where:
                 \list
                 \o 0.0 is the absolute left.
                 \o 1.0 is the absolute right.
                 \endlist
                 Default value is 0.5 (center).
                 \sa verticalPosition
             */
             /*!
                 \property QPieSeries::verticalPosition
                 \brief Defines the vertical position of the pie.
                 The value is a relative value to the chart rectangle where:
                 \list
                 \o 0.0 is the absolute top.
                 \o 1.0 is the absolute bottom.
                 \endlist
                 Default value is 0.5 (center).
                 \sa horizontalPosition
             */
             /*!
                 \qmlproperty real PieSeries::verticalPosition
                 Defines the vertical position of the pie.
                 The value is a relative value to the chart rectangle where:
                 \list
                 \o 0.0 is the absolute top.
                 \o 1.0 is the absolute bottom.
                 \endlist
                 Default value is 0.5 (center).
                 \sa horizontalPosition
             */
             /*!
                 \property QPieSeries::size
                 \brief Defines the pie size.
                 The value is a relative value to the chart rectangle where:
                 \list
                 \o 0.0 is the minimum size (pie not drawn).
                 \o 1.0 is the maximum size that can fit the chart.
                 \endlist
                 Default value is 0.7.
             */
             /*!
                 \qmlproperty real PieSeries::size
                 Defines the pie size.
                 The value is a relative value to the chart rectangle where:
                 \list
                 \o 0.0 is the minimum size (pie not drawn).
                 \o 1.0 is the maximum size that can fit the chart.
                 \endlist
                 Default value is 0.7.
             */
             /*!
                 \property QPieSeries::startAngle
                 \brief Defines the starting angle of the pie.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                 Default is value is 0.
             */
             /*!
                 \qmlproperty real PieSeries::startAngle
                 Defines the starting angle of the pie.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                 Default is value is 0.
             */
             /*!
                 \property QPieSeries::endAngle
                 \brief Defines the ending angle of the pie.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                 Default is value is 360.
             */
             /*!
                 \qmlproperty real PieSeries::endAngle
                 Defines the ending angle of the pie.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                 Default is value is 360.
             */
             /*!
                 \property QPieSeries::count
                 Number of slices in the series.
             */
             /*!
                 \qmlproperty int PieSeries::count
                 Number of slices in the series.
             */
             /*!
                 \fn void QPieSeries::countChanged()
                 Emitted when the slice count has changed.
                 \sa count
             */
             /*!
                 \qmlsignal PieSeries::onCountChanged()
                 Emitted when the slice count has changed.
             */
             /*!
                 \property QPieSeries::sum
                 Sum of all slices.
                 The series keeps track of the sum of all slices it holds.
             */
             /*!
                 \qmlproperty real PieSeries::sum
                 Sum of all slices.
                 The series keeps track of the sum of all slices it holds.
             */
             /*!
                 \fn void QPieSeries::sumChanged()
                 Emitted when the sum of all slices has changed.
                 \sa sum
             */
             /*!
                 \qmlsignal PieSeries::onSumChanged()
                 Emitted when the sum of all slices has changed. This may happen for example if you add or remove slices, or if you
                 change value of a slice.
             */
             /*!
                 \fn void QPieSeries::added(QList<QPieSlice*> slices)
                 This signal is emitted when \a slices have been added to the series.
                 \sa append(), insert()
             */
             /*!
                 \qmlsignal PieSeries::onAdded(PieSlice slice)
                 Emitted when \a slice has been added to the series.
             */
             /*!
                 \fn void QPieSeries::removed(QList<QPieSlice*> slices)
                 This signal is emitted when \a slices have been removed from the series.
                 \sa remove()
             */
             /*!
                 \qmlsignal PieSeries::onRemoved(PieSlice slice)
                 Emitted when \a slice has been removed from the series.
             */
             /*!
                 \fn void QPieSeries::clicked(QPieSlice* slice)
                 This signal is emitted when a \a slice has been clicked.
                 \sa QPieSlice::clicked()
             */
             /*!
               \qmlsignal PieSeries::onClicked(PieSlice slice)
               This signal is emitted when a \a slice has been clicked.
             */
             /*!
                 \fn void QPieSeries::hovered(QPieSlice* slice, bool state)
                 This signal is emitted when user has hovered over or away from the \a slice.
                 \a state is true when user has hovered over the slice and false when hover has moved away from the slice.
                 \sa QPieSlice::hovered()
             */
             /*!
                 \qmlsignal PieSeries::onHovered(PieSlice slice, bool state)
                 This signal is emitted when user has hovered over or away from the \a slice. \a state is true when user has hovered
                 over the slice and false when hover has moved away from the slice.
             */
             /*!
                 \qmlmethod PieSlice PieSeries::at(int index)
                 Returns slice at \a index. Returns null if the index is not valid.
             */
             /*!
                 \qmlmethod PieSlice PieSeries::find(string label)
                 Returns the first slice with \a label. Returns null if the index is not valid.
             */
             /*!
                 \qmlmethod PieSlice PieSeries::append(string label, real value)
                 Adds a new slice with \a label and \a value to the pie.
             */
             /*!
                 \qmlmethod bool PieSeries::remove(PieSlice slice)
                 Removes the \a slice from the pie. Returns true if the removal was successfull, false otherwise.
             */
             /*!
                 \qmlmethod PieSeries::clear()
                 Removes all slices from the pie.
             */
             /*!
                 Constructs a series object which is a child of \a parent.
             */
             QPieSeries::QPieSeries(QObject *parent) :
                 QAbstractSeries(*new QPieSeriesPrivate(this),parent)
             {
             }
             /*!
                 Destroys the series and its slices.
             */
             QPieSeries::~QPieSeries()
             {
                 // NOTE: d_prt destroyed by QObject
             }
             /*!
                 Returns QChartSeries::SeriesTypePie.
             */
             QAbstractSeries::SeriesType QPieSeries::type() const
             {
                 return QAbstractSeries::SeriesTypePie;
             }
             /*!
                 Appends a single \a slice to the series.
                 Slice ownership is passed to the series.
                 Returns true if append was succesfull.
             */
             bool QPieSeries::append(QPieSlice* slice)
             {
                 return append(QList<QPieSlice*>() << slice);
             }
             /*!
                 Appends an array of \a slices to the series.
                 Slice ownership is passed to the series.
                 Returns true if append was successfull.
             */
             bool QPieSeries::append(QList<QPieSlice*> slices)
             {
                 Q_D(QPieSeries);
                 if (slices.count() == 0)
                     return false;
                 foreach (QPieSlice* s, slices) {
                     if (!s || d->m_slices.contains(s))
                         return false;
                     if (s->series()) // already added to some series
                         return false;
                 }
                 foreach (QPieSlice* s, slices) {
                     s->setParent(this);
                     QPieSlicePrivate::fromSlice(s)->m_series = this;
                     d->m_slices << s;
                 }
                 d->updateDerivativeData();
                 foreach (QPieSlice* s, slices) {
                     connect(s, SIGNAL(valueChanged()), d, SLOT(sliceValueChanged()));
                     connect(s, SIGNAL(clicked()), d, SLOT(sliceClicked()));
                     connect(s, SIGNAL(hovered(bool)), d, SLOT(sliceHovered(bool)));
                 }
                 emit added(slices);
                 emit countChanged();
                 return true;
             }
             /*!
                 Appends a single \a slice to the series and returns a reference to the series.
                 Slice ownership is passed to the series.
             */
             QPieSeries& QPieSeries::operator << (QPieSlice* slice)
             {
                 append(slice);
                 return *this;
             }
             /*!
                 Appends a single slice to the series with give \a value and \a label.
                 Slice ownership is passed to the series.
             */
             QPieSlice* QPieSeries::append(QString label, qreal value)
             {
                 QPieSlice* slice = new QPieSlice(label, value);
                 append(slice);
                 return slice;
             }
             /*!
                 Inserts a single \a slice to the series before the slice at \a index position.
                 Slice ownership is passed to the series.
                 Returns true if insert was successfull.
             */
             bool QPieSeries::insert(int index, QPieSlice* slice)
             {
                 Q_D(QPieSeries);
                 if (index < 0 || index > d->m_slices.count())
                     return false;
                 if (!slice || d->m_slices.contains(slice))
                     return false;
                 if (slice->series()) // already added to some series
                     return false;
                 slice->setParent(this);
                 QPieSlicePrivate::fromSlice(slice)->m_series = this;
                 d->m_slices.insert(index, slice);
                 d->updateDerivativeData();
                 connect(slice, SIGNAL(valueChanged()), d, SLOT(sliceValueChanged()));
                 connect(slice, SIGNAL(clicked()), d, SLOT(sliceClicked()));
                 connect(slice, SIGNAL(hovered(bool)), d, SLOT(sliceHovered(bool)));
                 emit added(QList<QPieSlice*>() << slice);
                 emit countChanged();
                 return true;
             }
             /*!
                 Removes a single \a slice from the series and deletes the slice.
                 Do not reference the pointer after this call.
                 Returns true if remove was successfull.
             */
             bool QPieSeries::remove(QPieSlice* slice)
             {
                 Q_D(QPieSeries);
                 if (!d->m_slices.removeOne(slice))
                     return false;
                 d->updateDerivativeData();
                 emit removed(QList<QPieSlice*>() << slice);
                 emit countChanged();
                 delete slice;
                 slice = 0;
                 return true;
             }
             /*!
                 Clears all slices from the series.
             */
             void QPieSeries::clear()
             {
                 Q_D(QPieSeries);
                 if (d->m_slices.count() == 0)
                     return;
                 QList<QPieSlice*> slices = d->m_slices;
                 foreach (QPieSlice* s, d->m_slices) {
                     d->m_slices.removeOne(s);
                     delete s;
                 }
                 d->updateDerivativeData();
                 emit removed(slices);
                 emit countChanged();
             }
             /*!
                 Returns a list of slices that belong to this series.
             */
             QList<QPieSlice*> QPieSeries::slices() const
             {
                 Q_D(const QPieSeries);
                 return d->m_slices;
             }
             /*!
                 returns the number of the slices in this series.
             */
             int QPieSeries::count() const
             {
                 Q_D(const QPieSeries);
                 return d->m_slices.count();
             }
             /*!
                 Returns true is the series is empty.
             */
             bool QPieSeries::isEmpty() const
             {
                 Q_D(const QPieSeries);
                 return d->m_slices.isEmpty();
             }
             /*!
                 Returns the sum of all slice values in this series.
                 \sa QPieSlice::value(), QPieSlice::setValue(), QPieSlice::percentage()
             */
             qreal QPieSeries::sum() const
             {
                 Q_D(const QPieSeries);
                 return d->m_sum;
             }
             void QPieSeries::setDonut(bool donut)
             {
                 Q_D(QPieSeries);
                 d->m_donutChart = donut;
                 d->updateDerivativeData();
             }
             bool QPieSeries::donut() const
             {
                 Q_D(const QPieSeries);
                 return d->m_donutChart;
             }
+            void QPieSeries::setDonutInnerSize(qreal innerSize)
+            {
+                Q_D(QPieSeries);
+                if (innerSize < 0.0)
+                    innerSize = 0.0;
+                if (innerSize > 1.0)
+                    innerSize = 1.0;
+                d->m_donutRelativeInnerSize = innerSize;
+                d->updateDerivativeData();
+                emit d->pieSizeChanged();
+            }
+            qreal QPieSeries::donutInnerSize() const
+            {
+                Q_D(const QPieSeries);
+                return d->m_donutRelativeInnerSize;
+            }
             void QPieSeries::setHorizontalPosition(qreal relativePosition)
             {
                 Q_D(QPieSeries);
                 if (relativePosition < 0.0)
                     relativePosition = 0.0;
                 if (relativePosition > 1.0)
                     relativePosition = 1.0;
                 if (!qFuzzyIsNull(d->m_pieRelativeHorPos - relativePosition)) {
                     d->m_pieRelativeHorPos = relativePosition;
                     emit d->horizontalPositionChanged();
                 }
             }
             qreal QPieSeries::horizontalPosition() const
             {
                 Q_D(const QPieSeries);
                 return d->m_pieRelativeHorPos;
             }
             void QPieSeries::setVerticalPosition(qreal relativePosition)
             {
                 Q_D(QPieSeries);
                 if (relativePosition < 0.0)
                     relativePosition = 0.0;
                 if (relativePosition > 1.0)
                     relativePosition = 1.0;
                 if (!qFuzzyIsNull(d->m_pieRelativeVerPos - relativePosition)) {
                     d->m_pieRelativeVerPos = relativePosition;
                     emit d->verticalPositionChanged();
                 }
             }
             qreal QPieSeries::verticalPosition() const
             {
                 Q_D(const QPieSeries);
                 return d->m_pieRelativeVerPos;
             }
             void QPieSeries::setPieSize(qreal relativeSize)
             {
                 Q_D(QPieSeries);
                 if (relativeSize < 0.0)
                     relativeSize = 0.0;
                 if (relativeSize > 1.0)
                     relativeSize = 1.0;
                 if (!qFuzzyIsNull(d->m_pieRelativeSize - relativeSize)) {
                     d->m_pieRelativeSize = relativeSize;
                     emit d->pieSizeChanged();
                 }
             }
             qreal QPieSeries::pieSize() const
             {
                 Q_D(const QPieSeries);
                 return d->m_pieRelativeSize;
             }
             void QPieSeries::setPieStartAngle(qreal angle)
             {
                 Q_D(QPieSeries);
                 if (qFuzzyIsNull(d->m_pieStartAngle - angle))
                     return;
                 d->m_pieStartAngle = angle;
                 d->updateDerivativeData();
                 emit d->pieStartAngleChanged();
             }
             qreal QPieSeries::pieStartAngle() const
             {
                 Q_D(const QPieSeries);
                 return d->m_pieStartAngle;
             }
             /*!
                 Sets the end angle of the pie.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                 \a angle must be greater than start angle.
                 \sa pieEndAngle(), pieStartAngle(), setPieStartAngle()
             */
             void QPieSeries::setPieEndAngle(qreal angle)
             {
                 Q_D(QPieSeries);
                 if (qFuzzyIsNull(d->m_pieEndAngle - angle))
                     return;
                 d->m_pieEndAngle = angle;
                 d->updateDerivativeData();
                 emit d->pieEndAngleChanged();
             }
             /*!
                 Returns the end angle of the pie.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                 \sa setPieEndAngle(), pieStartAngle(), setPieStartAngle()
             */
             qreal QPieSeries::pieEndAngle() const
             {
                 Q_D(const QPieSeries);
                 return d->m_pieEndAngle;
             }
             /*!
                 Sets the all the slice labels \a visible or invisible.
                 Note that this affects only the current slices in the series.
                 If user adds a new slice the default label visibility is false.
                 \sa QPieSlice::isLabelVisible(), QPieSlice::setLabelVisible()
             */
             void QPieSeries::setLabelsVisible(bool visible)
             {
                 Q_D(QPieSeries);
                 foreach (QPieSlice* s, d->m_slices)
                     s->setLabelVisible(visible);
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QPieSeriesPrivate::QPieSeriesPrivate(QPieSeries *parent) :
                 QAbstractSeriesPrivate(parent),
                 m_pieRelativeHorPos(0.5),
                 m_pieRelativeVerPos(0.5),
                 m_pieRelativeSize(0.7),
                 m_pieStartAngle(0),
                 m_pieEndAngle(360),
                 m_sum(0),
-                m_donutChart(false)
+                m_donutChart(false),
+                m_donutRelativeInnerSize(0.5)
             {
             }
             QPieSeriesPrivate::~QPieSeriesPrivate()
             {
             }
             void QPieSeriesPrivate::updateDerivativeData()
             {
                 // calculate sum of all slices
                 qreal sum = 0;
                 foreach (QPieSlice* s, m_slices)
                     sum += s->value();
                 if (!qFuzzyIsNull(m_sum - sum)) {
                     m_sum = sum;
                     emit q_func()->sumChanged();
                 }
                 // nothing to show..
                 if (qFuzzyIsNull(m_sum))
                     return;
                 // update slice attributes
                 qreal sliceAngle = m_pieStartAngle;
                 qreal pieSpan = m_pieEndAngle - m_pieStartAngle;
                 QVector<QPieSlice*> changed;
                 foreach (QPieSlice* s, m_slices) {
                     QPieSlicePrivate *d = QPieSlicePrivate::fromSlice(s);
                     d->setPercentage(s->value() / m_sum);
                     d->setStartAngle(sliceAngle);
                     d->setAngleSpan(pieSpan * s->percentage());
-                    d->m_data.m_donut = m_donutChart;
                     sliceAngle += s->angleSpan();
                 }
                 emit calculatedDataChanged();
             }
             QPieSeriesPrivate* QPieSeriesPrivate::fromSeries(QPieSeries *series)
             {
                 return series->d_func();
             }
             void QPieSeriesPrivate::sliceValueChanged()
             {
                 Q_ASSERT(m_slices.contains(qobject_cast<QPieSlice *>(sender())));
                 updateDerivativeData();
             }
             void QPieSeriesPrivate::sliceClicked()
             {
                 QPieSlice* slice = qobject_cast<QPieSlice *>(sender());
                 Q_ASSERT(m_slices.contains(slice));
                 Q_Q(QPieSeries);
                 emit q->clicked(slice);
             }
             void QPieSeriesPrivate::sliceHovered(bool state)
             {
                 QPieSlice* slice = qobject_cast<QPieSlice *>(sender());
                 Q_ASSERT(m_slices.contains(slice));
                 Q_Q(QPieSeries);
                 emit q->hovered(slice, state);
             }
             void QPieSeriesPrivate::scaleDomain(Domain& domain)
             {
                 Q_UNUSED(domain);
                 // does not apply to pie
             }
             Chart* QPieSeriesPrivate::createGraphics(ChartPresenter* presenter)
             {
                 Q_Q(QPieSeries);
                 PieChartItem* pie = new PieChartItem(q,presenter);
                 if(presenter->animationOptions().testFlag(QChart::SeriesAnimations)) {
                     presenter->animator()->addAnimation(pie);
                 }
                 presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
                 return pie;
             }
             QList<LegendMarker*> QPieSeriesPrivate::createLegendMarker(QLegend* legend)
             {
                 Q_Q(QPieSeries);
                 QList<LegendMarker*> markers;
                 foreach(QPieSlice* slice, q->slices()) {
                     PieLegendMarker* marker = new PieLegendMarker(q,slice,legend);
                     markers << marker;
                 }
                 return markers;
             }
             void QPieSeriesPrivate::initializeAxisX(QAbstractAxis* axis)
             {
                 Q_UNUSED(axis);
             }
             void QPieSeriesPrivate::initializeAxisY(QAbstractAxis* axis)
             {
                 Q_UNUSED(axis);
             }
             QAbstractAxis::AxisType QPieSeriesPrivate::defaultAxisXType() const
             {
                 return QAbstractAxis::AxisTypeNoAxis;
             }
             QAbstractAxis::AxisType QPieSeriesPrivate::defaultAxisYType() const
             {
                 return QAbstractAxis::AxisTypeNoAxis;
             }
             #include "moc_qpieseries.cpp"
             #include "moc_qpieseries_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/qpieseries.h +3 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$
             **
             ****************************************************************************/
             #ifndef PIESERIES_H
             #define PIESERIES_H
             #include <qabstractseries.h>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QPieSeriesPrivate;
             class QPieSlice;
             class QTCOMMERCIALCHART_EXPORT QPieSeries : public QAbstractSeries
             {
                 Q_OBJECT
                 Q_PROPERTY(qreal horizontalPosition READ horizontalPosition WRITE setHorizontalPosition)
                 Q_PROPERTY(qreal verticalPosition READ verticalPosition WRITE setVerticalPosition)
                 Q_PROPERTY(qreal size READ pieSize WRITE setPieSize)
                 Q_PROPERTY(qreal startAngle READ pieStartAngle WRITE setPieStartAngle)
                 Q_PROPERTY(qreal endAngle READ pieEndAngle WRITE setPieEndAngle)
                 Q_PROPERTY(int count READ count NOTIFY countChanged)
                 Q_PROPERTY(qreal sum READ sum NOTIFY sumChanged)
             public:
                 explicit QPieSeries(QObject *parent = 0);
                 virtual ~QPieSeries();
                 QAbstractSeries::SeriesType type() const;
                 bool append(QPieSlice* slice);
                 bool append(QList<QPieSlice*> slices);
                 QPieSeries& operator << (QPieSlice* slice);
                 QPieSlice* append(QString label, qreal value);
                 bool insert(int index, QPieSlice* slice);
                 bool remove(QPieSlice* slice);
                 void clear();
                 QList<QPieSlice*> slices() const;
                 int count() const;
                 bool isEmpty() const;
                 qreal sum() const;
                 void setDonut(bool donut = true);
                 bool donut() const;
+                void setDonutInnerSize(qreal innerSize);
+                qreal donutInnerSize() const;
                 void setHorizontalPosition(qreal relativePosition);
                 qreal horizontalPosition() const;
                 void setVerticalPosition(qreal relativePosition);
                 qreal verticalPosition() const;
                 void setPieSize(qreal relativeSize);
                 qreal pieSize() const;
                 void setPieStartAngle(qreal startAngle);
                 qreal pieStartAngle() const;
                 void setPieEndAngle(qreal endAngle);
                 qreal pieEndAngle() const;
                 void setLabelsVisible(bool visible = true);
             Q_SIGNALS:
                 void added(QList<QPieSlice*> slices);
                 void removed(QList<QPieSlice*> slices);
                 void clicked(QPieSlice* slice);
                 void hovered(QPieSlice* slice, bool state);
                 void countChanged();
                 void sumChanged();
             private:
                 Q_DECLARE_PRIVATE(QPieSeries)
                 Q_DISABLE_COPY(QPieSeries)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // PIESERIES_H

src/piechart/qpieseries_p.h +1 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$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef QPIESERIES_P_H
             #define QPIESERIES_P_H
             #include "qpieseries.h"
             #include "qabstractseries_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QLegendPrivate;
             class QPieSeriesPrivate : public QAbstractSeriesPrivate
             {
                 Q_OBJECT
             public:
                 QPieSeriesPrivate(QPieSeries *parent);
                 ~QPieSeriesPrivate();
                 void scaleDomain(Domain& domain);
                 Chart* createGraphics(ChartPresenter *presenter);
                 QList<LegendMarker*> createLegendMarker(QLegend *legend);
                 void initializeAxisX(QAbstractAxis* axis);
                 void initializeAxisY(QAbstractAxis* axis);
                 QAbstractAxis::AxisType defaultAxisXType() const;
                 QAbstractAxis::AxisType defaultAxisYType() const;
                 void updateDerivativeData();
                 static QPieSeriesPrivate* fromSeries(QPieSeries *series);
             signals:
                 void calculatedDataChanged();
                 void pieSizeChanged();
                 void pieStartAngleChanged();
                 void pieEndAngleChanged();
                 void horizontalPositionChanged();
                 void verticalPositionChanged();
             public Q_SLOTS:
                 void sliceValueChanged();
                 void sliceClicked();
                 void sliceHovered(bool state);
             private:
                 QList<QPieSlice*> m_slices;
                 qreal m_pieRelativeHorPos;
                 qreal m_pieRelativeVerPos;
                 qreal m_pieRelativeSize;
                 qreal m_pieStartAngle;
                 qreal m_pieEndAngle;
                 qreal m_sum;
                 bool m_donutChart;
+                qreal m_donutRelativeInnerSize;
             private:
                 friend class QLegendPrivate;
                 Q_DECLARE_PUBLIC(QPieSeries)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QPIESERIES_P_H

src/xychart/qxymodelmapper.cpp +1 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 "qxymodelmapper.h"
             #include "qxymodelmapper_p.h"
             #include "qxyseries.h"
             #include <QAbstractItemModel>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 Constructs a mapper object which is a child of \a parent.
             */
             QXYModelMapper::QXYModelMapper(QObject *parent):
                 QObject(parent),
                 d_ptr(new QXYModelMapperPrivate(this))
             {
             }
             /*!
                 \internal
             */
             QAbstractItemModel* QXYModelMapper::model() const
             {
                 Q_D(const QXYModelMapper);
                 return d->m_model;
             }
             /*!
                 \internal
             */
             void QXYModelMapper::setModel(QAbstractItemModel *model)
             {
                 if (model == 0)
                     return;
                 Q_D(QXYModelMapper);
                 if (d->m_model) {
                     disconnect(d->m_model, 0, d, 0);
                 }
                 d->m_model = model;
                 d->initializeXYFromModel();
                 //    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)));
                 connect(d->m_model, SIGNAL(destroyed()), d, SLOT(handleModelDestroyed()));
             }
             /*!
                 \internal
             */
             QXYSeries* QXYModelMapper::series() const
             {
                 Q_D(const QXYModelMapper);
                 return d->m_series;
             }
             /*!
                 \internal
             */
             void QXYModelMapper::setSeries(QXYSeries *series)
             {
                 Q_D(QXYModelMapper);
                 if (d->m_series) {
                     disconnect(d->m_series, 0, d, 0);
                 }
                 if (series == 0)
                     return;
                 d->m_series = series;
                 d->initializeXYFromModel();
                 // 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)));
                 connect(d->m_series, SIGNAL(destroyed()), d, SLOT(handleSeriesDestroyed()));
             }
             /*!
                 \internal
             */
             int QXYModelMapper::first() const
             {
                 Q_D(const QXYModelMapper);
                 return d->m_first;
             }
             /*!
                 \internal
             */
             void QXYModelMapper::setFirst(int first)
             {
                 Q_D(QXYModelMapper);
                 d->m_first = qMax(first, 0);
                 d->initializeXYFromModel();
             }
             /*!
                 \internal
             */
             int QXYModelMapper::count() const
             {
                 Q_D(const QXYModelMapper);
                 return d->m_count;
             }
             /*!
                 \internal
             */
             void QXYModelMapper::setCount(int count)
             {
                 Q_D(QXYModelMapper);
                 d->m_count = qMax(count, -1);
                 d->initializeXYFromModel();
             }
             /*!
                 Returns the orientation that is used when QXYModelMapper accesses the model.
                 This mean whether the consecutive x/y values of the QXYSeries are read from rows (Qt::Horizontal)
                 or from columns (Qt::Vertical)
             */
             Qt::Orientation QXYModelMapper::orientation() const
             {
                 Q_D(const QXYModelMapper);
                 return d->m_orientation;
             }
             /*!
                 Returns the \a orientation that is used when QXYModelMapper accesses the model.
                 This mean whether the consecutive x/y values of the QXYSeries are read from rows (Qt::Horizontal)
                 or from columns (Qt::Vertical)
             */
             void QXYModelMapper::setOrientation(Qt::Orientation orientation)
             {
                 Q_D(QXYModelMapper);
                 d->m_orientation = orientation;
                 d->initializeXYFromModel();
             }
             /*!
                 Returns which section of the model is kept in sync with the x values of the QXYSeries
             */
             int QXYModelMapper::xSection() const
             {
                 Q_D(const QXYModelMapper);
                 return d->m_xSection;
             }
             /*!
                 Sets the model section that is kept in sync with the x values of the QXYSeries.
                 Parameter \a xSection specifies the section of the model.
             */
             void QXYModelMapper::setXSection(int xSection)
             {
                 Q_D(QXYModelMapper);
                 d->m_xSection = qMax(-1, xSection);
                 d->initializeXYFromModel();
             }
             /*!
                 Returns which section of the model is kept in sync with the y values of the QXYSeries
             */
             int QXYModelMapper::ySection() const
             {
                 Q_D(const QXYModelMapper);
                 return d->m_ySection;
             }
             /*!
                 Sets the model section that is kept in sync with the y values of the QXYSeries.
                 Parameter \a ySection specifies the section of the model.
             */
             void QXYModelMapper::setYSection(int ySection)
             {
                 Q_D(QXYModelMapper);
                 d->m_ySection = qMax(-1, ySection);
                 d->initializeXYFromModel();
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QXYModelMapperPrivate::QXYModelMapperPrivate(QXYModelMapper *q) :
+                QObject(q),
                 m_series(0),
                 m_model(0),
                 m_first(0),
                 m_count(-1),
                 m_orientation(Qt::Vertical),
                 m_xSection(-1),
                 m_ySection(-1),
                 m_seriesSignalsBlock(false),
                 m_modelSignalsBlock(false),
                 q_ptr(q)
             {
             }
             void QXYModelMapperPrivate::blockModelSignals(bool block)
             {
                 m_modelSignalsBlock = block;
             }
             void QXYModelMapperPrivate::blockSeriesSignals(bool block)
             {
                 m_seriesSignalsBlock = block;
             }
             QModelIndex QXYModelMapperPrivate::xModelIndex(int xPos)
             {
                 if (m_count != -1 && xPos >= m_count)
                     return QModelIndex(); // invalid
                 if (m_orientation == Qt::Vertical)
                     return m_model->index(xPos + m_first, m_xSection);
                 else
                     return m_model->index(m_xSection, xPos + m_first);
             }
             QModelIndex QXYModelMapperPrivate::yModelIndex(int yPos)
             {
                 if (m_count != -1 && yPos >= m_count)
                     return QModelIndex(); // invalid
                 if (m_orientation == Qt::Vertical)
                     return m_model->index(yPos + m_first, m_ySection);
                 else
                     return m_model->index(m_ySection, yPos + m_first);
             }
             void QXYModelMapperPrivate::handlePointAdded(int pointPos)
             {
                 if (m_seriesSignalsBlock)
                     return;
                 if (m_count != -1)
                     m_count += 1;
                 blockModelSignals();
                 if (m_orientation == Qt::Vertical)
                     m_model->insertRows(pointPos + m_first, 1);
                 else
                     m_model->insertColumns(pointPos + m_first, 1);
                 m_model->setData(xModelIndex(pointPos), m_series->points().at(pointPos).x());
                 m_model->setData(yModelIndex(pointPos), m_series->points().at(pointPos).y());
                 blockModelSignals(false);
             }
             void QXYModelMapperPrivate::handlePointRemoved(int pointPos)
             {
                 if (m_seriesSignalsBlock)
                     return;
                 if (m_count != -1)
                     m_count -= 1;
                 blockModelSignals();
                 if (m_orientation == Qt::Vertical)
                     m_model->removeRow(pointPos + m_first);
                 else
                     m_model->removeColumn(pointPos + m_first);
                 blockModelSignals(false);
             }
             void QXYModelMapperPrivate::handlePointReplaced(int pointPos)
             {
                 if (m_seriesSignalsBlock)
                     return;
                 blockModelSignals();
                 m_model->setData(xModelIndex(pointPos), m_series->points().at(pointPos).x());
                 m_model->setData(yModelIndex(pointPos), m_series->points().at(pointPos).y());
                 blockModelSignals(false);
             }
             void QXYModelMapperPrivate::handleSeriesDestroyed()
             {
                 m_series = 0;
             }
             void QXYModelMapperPrivate::modelUpdated(QModelIndex topLeft, QModelIndex 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);
                         if (m_orientation == Qt::Vertical && (index.column() == m_xSection || index.column() == m_ySection)) {
                             if (index.row() >= m_first && (m_count == - 1 || index.row() < m_first + m_count)) {
                                 QModelIndex xIndex = xModelIndex(index.row() - m_first);
                                 QModelIndex yIndex = yModelIndex(index.row() - m_first);
                                 if (xIndex.isValid() && yIndex.isValid()) {
                                     oldPoint = m_series->points().at(index.row() - m_first);
                                     newPoint.setX(m_model->data(xIndex).toReal());
                                     newPoint.setY(m_model->data(yIndex).toReal());
                                 }
                             }
                         } else if (m_orientation == Qt::Horizontal && (index.row() == m_xSection || index.row() == m_ySection)) {
                             if (index.column() >= m_first && (m_count == - 1 || index.column() < m_first + m_count)) {
                                 QModelIndex xIndex = xModelIndex(index.column() - m_first);
                                 QModelIndex yIndex = yModelIndex(index.column() - m_first);
                                 if (xIndex.isValid() && yIndex.isValid()) {
                                     oldPoint = m_series->points().at(index.column() - m_first);
                                     newPoint.setX(m_model->data(xIndex).toReal());
                                     newPoint.setY(m_model->data(yIndex).toReal());
                                 }
                             }
                         } else {
                             continue;
                         }
                         m_series->replace(oldPoint, newPoint);
                     }
                 }
                 blockSeriesSignals(false);
             }
             void QXYModelMapperPrivate::modelRowsAdded(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent);
                 if (m_modelSignalsBlock)
                     return;
                 blockSeriesSignals();
                 if (m_orientation == Qt::Vertical)
                     insertData(start, end);
                 else if (start <= m_xSection || start <= m_ySection) // if the changes affect the map - reinitialize the xy
                     initializeXYFromModel();
                 blockSeriesSignals(false);
             }
             void QXYModelMapperPrivate::modelRowsRemoved(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent);
                 if (m_modelSignalsBlock)
                     return;
                 blockSeriesSignals();
                 if (m_orientation == Qt::Vertical)
                     removeData(start, end);
                 else if (start <= m_xSection || start <= m_ySection) // if the changes affect the map - reinitialize the xy
                     initializeXYFromModel();
                 blockSeriesSignals(false);
             }
             void QXYModelMapperPrivate::modelColumnsAdded(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent);
                 if (m_modelSignalsBlock)
                     return;
                 blockSeriesSignals();
                 if (m_orientation == Qt::Horizontal)
                     insertData(start, end);
                 else if (start <= m_xSection || start <= m_ySection) // if the changes affect the map - reinitialize the xy
                     initializeXYFromModel();
                 blockSeriesSignals(false);
             }
             void QXYModelMapperPrivate::modelColumnsRemoved(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent);
                 if (m_modelSignalsBlock)
                     return;
                 blockSeriesSignals();
                 if (m_orientation == Qt::Horizontal)
                     removeData(start, end);
                 else if (start <= m_xSection || start <= m_ySection) // if the changes affect the map - reinitialize the xy
                     initializeXYFromModel();
                 blockSeriesSignals(false);
             }
             void QXYModelMapperPrivate::handleModelDestroyed()
             {
                 m_model = 0;
             }
             void QXYModelMapperPrivate::insertData(int start, int 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 i = first; i <= last; i++) {
                         QPointF point;
                         QModelIndex xIndex = xModelIndex(i - m_first);
                         QModelIndex yIndex = yModelIndex(i - m_first);
                         if (xIndex.isValid() && yIndex.isValid()) {
                             point.setX(m_model->data(xIndex, Qt::DisplayRole).toDouble());
                             point.setY(m_model->data(yIndex, Qt::DisplayRole).toDouble());
                             m_series->insert(i - m_first, point);
                         }
                     }
                     // 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 QXYModelMapperPrivate::removeData(int start, int 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;
                                 QModelIndex xIndex = xModelIndex(i);
                                 QModelIndex yIndex = yModelIndex(i);
                                 if (xIndex.isValid() && yIndex.isValid()) {
                                     point.setX(m_model->data(xIndex, Qt::DisplayRole).toDouble());
                                     point.setY(m_model->data(yIndex, Qt::DisplayRole).toDouble());
                                     m_series->insert(i, point);
                                 }
                             }
                     }
                 }
             }
             void QXYModelMapperPrivate::initializeXYFromModel()
             {
                 if (m_model == 0 || m_series == 0)
                     return;
                 blockSeriesSignals();
                 // clear current content
                 m_series->clear();
                 // create the initial slices set
                 int pointPos = 0;
                 QModelIndex xIndex = xModelIndex(pointPos);
                 QModelIndex yIndex = yModelIndex(pointPos);
                 while (xIndex.isValid() && yIndex.isValid()) {
                     QPointF point;
                     point.setX(m_model->data(xIndex, Qt::DisplayRole).toDouble());
                     point.setY(m_model->data(yIndex, Qt::DisplayRole).toDouble());
                     m_series->append(point);
                     pointPos++;
                     xIndex = xModelIndex(pointPos);
                     yIndex = yModelIndex(pointPos);
                 }
                 blockSeriesSignals(false);
             }
             #include "moc_qxymodelmapper.cpp"
             #include "moc_qxymodelmapper_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages