HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r1450:7bf1a442df6a

pie: add label position to slice

Jani Honkonen -

r1450:7bf1a442df6a

parent child

Context file:

r1450:7bf1a442df6a

Collapse all files

demos/piechartcustomization/mainwidget.cpp +10 -1

             /****************************************************************************
             **
             ** 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 "mainwidget.h"
             #include "customslice.h"
             #include "pentool.h"
             #include "brushtool.h"
             #include <QPushButton>
             #include <QComboBox>
             #include <QCheckBox>
             #include <QLabel>
             #include <QGroupBox>
             #include <QDoubleSpinBox>
             #include <QFormLayout>
             #include <QFontDialog>
             #include <QChartView>
             #include <QPieSeries>
             QTCOMMERCIALCHART_USE_NAMESPACE
             MainWidget::MainWidget(QWidget* parent)
                 :QWidget(parent),
                 m_slice(0)
             {
                 // create chart
                 QChart *chart = new QChart;
                 chart->setTitle("Piechart customization");
                 chart->setAnimationOptions(QChart::AllAnimations);
                 // create series
                 m_series = new QPieSeries();
                 *m_series << new CustomSlice("Slice 1", 10.0);
                 *m_series << new CustomSlice("Slice 2", 20.0);
                 *m_series << new CustomSlice("Slice 3", 30.0);
                 *m_series << new CustomSlice("Slice 4", 40.0);
                 *m_series << new CustomSlice("Slice 5", 50.0);
                 m_series->setLabelsVisible();
                 chart->addSeries(m_series);
                 connect(m_series, SIGNAL(clicked(QPieSlice*)), this, SLOT(handleSliceClicked(QPieSlice*)));
                 // chart settings
                 m_themeComboBox = new QComboBox();
                 m_themeComboBox->addItem("Light", QChart::ChartThemeLight);
                 m_themeComboBox->addItem("BlueCerulean", QChart::ChartThemeBlueCerulean);
                 m_themeComboBox->addItem("Dark", QChart::ChartThemeDark);
                 m_themeComboBox->addItem("BrownSand", QChart::ChartThemeBrownSand);
                 m_themeComboBox->addItem("BlueNcs", QChart::ChartThemeBlueNcs);
                 m_themeComboBox->addItem("High Contrast", QChart::ChartThemeHighContrast);
                 m_themeComboBox->addItem("Blue Icy", QChart::ChartThemeBlueIcy);
                 m_aaCheckBox = new QCheckBox();
                 m_animationsCheckBox = new QCheckBox();
                 m_animationsCheckBox->setCheckState(Qt::Checked);
                 m_legendCheckBox = new QCheckBox();
                 QFormLayout* chartSettingsLayout = new QFormLayout();
                 chartSettingsLayout->addRow("Theme", m_themeComboBox);
                 chartSettingsLayout->addRow("Antialiasing", m_aaCheckBox);
                 chartSettingsLayout->addRow("Animations", m_animationsCheckBox);
                 chartSettingsLayout->addRow("Legend", m_legendCheckBox);
                 QGroupBox* chartSettings = new QGroupBox("Chart");
                 chartSettings->setLayout(chartSettingsLayout);
                 connect(m_themeComboBox, SIGNAL(currentIndexChanged(int)), this ,SLOT(updateChartSettings()));
                 connect(m_aaCheckBox, SIGNAL(toggled(bool)), this ,SLOT(updateChartSettings()));
                 connect(m_animationsCheckBox, SIGNAL(toggled(bool)), this ,SLOT(updateChartSettings()));
                 connect(m_legendCheckBox, SIGNAL(toggled(bool)), this ,SLOT(updateChartSettings()));
                 // series settings
                 m_hPosition = new QDoubleSpinBox();
                 m_hPosition->setMinimum(0.0);
                 m_hPosition->setMaximum(1.0);
                 m_hPosition->setSingleStep(0.1);
                 m_hPosition->setValue(m_series->horizontalPosition());
                 m_vPosition = new QDoubleSpinBox();
                 m_vPosition->setMinimum(0.0);
                 m_vPosition->setMaximum(1.0);
                 m_vPosition->setSingleStep(0.1);
                 m_vPosition->setValue(m_series->verticalPosition());
                 m_sizeFactor = new QDoubleSpinBox();
                 m_sizeFactor->setMinimum(0.0);
                 m_sizeFactor->setMaximum(1.0);
                 m_sizeFactor->setSingleStep(0.1);
                 m_sizeFactor->setValue(m_series->pieSize());
                 m_startAngle = new QDoubleSpinBox();
                 m_startAngle->setMinimum(-720);
                 m_startAngle->setMaximum(720);
                 m_startAngle->setValue(m_series->pieStartAngle());
                 m_startAngle->setSingleStep(1);
                 m_endAngle = new QDoubleSpinBox();
                 m_endAngle->setMinimum(-720);
                 m_endAngle->setMaximum(720);
                 m_endAngle->setValue(m_series->pieEndAngle());
                 m_endAngle->setSingleStep(1);
                 QPushButton *appendSlice = new QPushButton("Append slice");
                 QPushButton *insertSlice = new QPushButton("Insert slice");
                 QFormLayout* seriesSettingsLayout = new QFormLayout();
                 seriesSettingsLayout->addRow("Horizontal position", m_hPosition);
                 seriesSettingsLayout->addRow("Vertical position", m_vPosition);
                 seriesSettingsLayout->addRow("Size factor", m_sizeFactor);
                 seriesSettingsLayout->addRow("Start angle", m_startAngle);
                 seriesSettingsLayout->addRow("End angle", m_endAngle);
                 seriesSettingsLayout->addRow(appendSlice);
                 seriesSettingsLayout->addRow(insertSlice);
                 QGroupBox* seriesSettings = new QGroupBox("Series");
                 seriesSettings->setLayout(seriesSettingsLayout);
                 connect(m_vPosition, SIGNAL(valueChanged(double)), this, SLOT(updateSerieSettings()));
                 connect(m_hPosition, SIGNAL(valueChanged(double)), this, SLOT(updateSerieSettings()));
                 connect(m_sizeFactor, SIGNAL(valueChanged(double)), this, SLOT(updateSerieSettings()));
                 connect(m_startAngle, SIGNAL(valueChanged(double)), this, SLOT(updateSerieSettings()));
                 connect(m_endAngle, SIGNAL(valueChanged(double)), this, SLOT(updateSerieSettings()));
                 connect(appendSlice, SIGNAL(clicked()), this, SLOT(appendSlice()));
                 connect(insertSlice, SIGNAL(clicked()), this, SLOT(insertSlice()));
                 // slice settings
                 m_sliceName = new QLabel("<click a slice>");
                 m_sliceValue = new QDoubleSpinBox();
                 m_sliceValue->setMaximum(1000);
                 m_sliceLabelVisible = new QCheckBox();
                 m_sliceLabelArmFactor = new QDoubleSpinBox();
                 m_sliceLabelArmFactor->setSingleStep(0.01);
                 m_sliceExploded = new QCheckBox();
                 m_sliceExplodedFactor = new QDoubleSpinBox();
                 m_sliceExplodedFactor->setSingleStep(0.01);
                 m_pen = new QPushButton();
                 m_penTool = new PenTool("Slice pen", this);
                 m_brush = new QPushButton();
                 m_brushTool = new BrushTool("Slice brush", this);
                 m_font = new QPushButton();
                 m_labelBrush = new QPushButton();
                 m_labelBrushTool = new BrushTool("Label brush", this);
+                m_labelPosition = new QComboBox(this);
+                m_labelPosition->addItem("Outside", QPieSlice::LabelOutside);
+                m_labelPosition->addItem("Inside", QPieSlice::LabelInside);
                 QPushButton *removeSlice = new QPushButton("Remove slice");
                 QFormLayout* sliceSettingsLayout = new QFormLayout();
                 sliceSettingsLayout->addRow("Selected", m_sliceName);
                 sliceSettingsLayout->addRow("Value", m_sliceValue);
                 sliceSettingsLayout->addRow("Pen", m_pen);
                 sliceSettingsLayout->addRow("Brush", m_brush);
                 sliceSettingsLayout->addRow("Label visible", m_sliceLabelVisible);
                 sliceSettingsLayout->addRow("Label font", m_font);
-                sliceSettingsLayout->addRow("Label pen", m_labelBrush);
+                sliceSettingsLayout->addRow("Label brush", m_labelBrush);
+                sliceSettingsLayout->addRow("Label position", m_labelPosition);
                 sliceSettingsLayout->addRow("Label arm length", m_sliceLabelArmFactor);
                 sliceSettingsLayout->addRow("Exploded", m_sliceExploded);
                 sliceSettingsLayout->addRow("Explode distance", m_sliceExplodedFactor);
                 sliceSettingsLayout->addRow(removeSlice);
                 QGroupBox* sliceSettings = new QGroupBox("Slice");
                 sliceSettings->setLayout(sliceSettingsLayout);
                 connect(m_sliceValue, SIGNAL(valueChanged(double)), this, SLOT(updateSliceSettings()));
                 connect(m_pen, SIGNAL(clicked()), m_penTool, SLOT(show()));
                 connect(m_penTool, SIGNAL(changed()), this, SLOT(updateSliceSettings()));
                 connect(m_brush, SIGNAL(clicked()), m_brushTool, SLOT(show()));
                 connect(m_brushTool, SIGNAL(changed()), this, SLOT(updateSliceSettings()));
                 connect(m_font, SIGNAL(clicked()), this, SLOT(showFontDialog()));
                 connect(m_labelBrush, SIGNAL(clicked()), m_labelBrushTool, SLOT(show()));
                 connect(m_labelBrushTool, SIGNAL(changed()), this, SLOT(updateSliceSettings()));
                 connect(m_sliceLabelVisible, SIGNAL(toggled(bool)), this, SLOT(updateSliceSettings()));
                 connect(m_sliceLabelVisible, SIGNAL(toggled(bool)), this, SLOT(updateSliceSettings()));
                 connect(m_sliceLabelArmFactor, SIGNAL(valueChanged(double)), this, SLOT(updateSliceSettings()));
                 connect(m_sliceExploded, SIGNAL(toggled(bool)), this, SLOT(updateSliceSettings()));
                 connect(m_sliceExplodedFactor, SIGNAL(valueChanged(double)), this, SLOT(updateSliceSettings()));
+                connect(m_labelPosition, SIGNAL(currentIndexChanged(int)), this, SLOT(updateSliceSettings()));
                 connect(removeSlice, SIGNAL(clicked()), this, SLOT(removeSlice()));
                 // create chart view
                 m_chartView = new QChartView(chart);
                 // create main layout
                 QVBoxLayout *settingsLayout = new QVBoxLayout();
                 settingsLayout->addWidget(chartSettings);
                 settingsLayout->addWidget(seriesSettings);
                 settingsLayout->addWidget(sliceSettings);
                 settingsLayout->addStretch();
                 QGridLayout* baseLayout = new QGridLayout();
                 baseLayout->addLayout(settingsLayout, 0, 0);
                 baseLayout->addWidget(m_chartView, 0, 1);
                 setLayout(baseLayout);
                 updateSerieSettings();
             }
             void MainWidget::updateChartSettings()
             {
                 QChart::ChartTheme theme = (QChart::ChartTheme) m_themeComboBox->itemData(m_themeComboBox->currentIndex()).toInt();
                 m_chartView->chart()->setTheme(theme);
                 m_chartView->setRenderHint(QPainter::Antialiasing, m_aaCheckBox->isChecked());
                 if (m_animationsCheckBox->checkState() == Qt::Checked)
                     m_chartView->chart()->setAnimationOptions(QChart::AllAnimations);
                 else
                     m_chartView->chart()->setAnimationOptions(QChart::NoAnimation);
                 if (m_legendCheckBox->checkState() == Qt::Checked)
                     m_chartView->chart()->legend()->show();
                 else
                     m_chartView->chart()->legend()->hide();
             }
             void MainWidget::updateSerieSettings()
             {
                 m_series->setHorizontalPosition(m_hPosition->value());
                 m_series->setVerticalPosition(m_vPosition->value());
                 m_series->setPieSize(m_sizeFactor->value());
                 m_series->setPieStartAngle(m_startAngle->value());
                 m_series->setPieEndAngle(m_endAngle->value());
             }
             void MainWidget::updateSliceSettings()
             {
                 if (!m_slice)
                     return;
                 m_slice->setValue(m_sliceValue->value());
                 m_slice->setPen(m_penTool->pen());
                 m_slice->setBrush(m_brushTool->brush());
                 m_slice->setLabelBrush(m_labelBrushTool->brush());
                 m_slice->setLabelVisible(m_sliceLabelVisible->isChecked());
                 m_slice->setLabelArmLengthFactor(m_sliceLabelArmFactor->value());
+                m_slice->setLabelPosition((QPieSlice::LabelPosition)m_labelPosition->currentIndex()); // assumes that index is in sync with the enum
                 m_slice->setExploded(m_sliceExploded->isChecked());
                 m_slice->setExplodeDistanceFactor(m_sliceExplodedFactor->value());
             }
             void MainWidget::handleSliceClicked(QPieSlice* slice)
             {
                 m_slice = static_cast<CustomSlice*>(slice);
                 // name
                 m_sliceName->setText(slice->label());
                 // value
                 m_sliceValue->blockSignals(true);
                 m_sliceValue->setValue(slice->value());
                 m_sliceValue->blockSignals(false);
                 // pen
                 m_pen->setText(PenTool::name(m_slice->pen()));
                 m_penTool->setPen(m_slice->pen());
                 // brush
                 m_brush->setText(m_slice->originalBrush().color().name());
                 m_brushTool->setBrush(m_slice->originalBrush());
                 // label
                 m_labelBrush->setText(BrushTool::name(m_slice->labelBrush()));
                 m_labelBrushTool->setBrush(m_slice->labelBrush());
                 m_font->setText(slice->labelFont().toString());
                 m_sliceLabelVisible->blockSignals(true);
                 m_sliceLabelVisible->setChecked(slice->isLabelVisible());
                 m_sliceLabelVisible->blockSignals(false);
                 m_sliceLabelArmFactor->blockSignals(true);
                 m_sliceLabelArmFactor->setValue(slice->labelArmLengthFactor());
                 m_sliceLabelArmFactor->blockSignals(false);
+                m_labelPosition->blockSignals(true);
+                m_labelPosition->setCurrentIndex(slice->labelPosition()); // assumes that index is in sync with the enum
+                m_labelPosition->blockSignals(false);
                 // exploded
                 m_sliceExploded->blockSignals(true);
                 m_sliceExploded->setChecked(slice->isExploded());
                 m_sliceExploded->blockSignals(false);
                 m_sliceExplodedFactor->blockSignals(true);
                 m_sliceExplodedFactor->setValue(slice->explodeDistanceFactor());
                 m_sliceExplodedFactor->blockSignals(false);
             }
             void MainWidget::showFontDialog()
             {
                 if (!m_slice)
                     return;
                 QFontDialog dialog(m_slice->labelFont());
                 dialog.show();
                 dialog.exec();
                 m_slice->setLabelFont(dialog.currentFont());
                 m_font->setText(dialog.currentFont().toString());
             }
             void MainWidget::appendSlice()
             {
                 *m_series << new CustomSlice("Slice " + QString::number(m_series->count()+1), 10.0);
             }
             void MainWidget::insertSlice()
             {
                 if (!m_slice)
                     return;
                 int i = m_series->slices().indexOf(m_slice);
                 m_series->insert(i, new CustomSlice("Slice " + QString::number(m_series->count()+1), 10.0));
             }
             void MainWidget::removeSlice()
             {
                 if (!m_slice)
                     return;
                 m_sliceName->setText("<click a slice>");
                 m_series->remove(m_slice);
                 m_slice = 0;
             }
             #include "moc_mainwidget.cpp"

demos/piechartcustomization/mainwidget.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$
             **
             ****************************************************************************/
             #ifndef MAINWIDGET_H
             #define MAINWIDGET_H
             #include <QWidget>
             #include <QChartGlobal>
             class QLabel;
             class QPushButton;
             class QCheckBox;
             class QComboBox;
             class QDoubleSpinBox;
             class PenTool;
             class BrushTool;
             class CustomSlice;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QChartView;
             class QPieSeries;
             class QPieSlice;
             QTCOMMERCIALCHART_END_NAMESPACE
             QTCOMMERCIALCHART_USE_NAMESPACE
             class MainWidget : public QWidget
             {
                 Q_OBJECT
             public:
                 explicit MainWidget(QWidget* parent = 0);
             public Q_SLOTS:
                 void updateChartSettings();
                 void updateSerieSettings();
                 void updateSliceSettings();
                 void handleSliceClicked(QPieSlice* slice);
                 void showFontDialog();
                 void appendSlice();
                 void insertSlice();
                 void removeSlice();
             private:
                 QComboBox *m_themeComboBox;
                 QCheckBox *m_aaCheckBox;
                 QCheckBox *m_animationsCheckBox;
                 QCheckBox *m_legendCheckBox;
                 QChartView* m_chartView;
                 QPieSeries* m_series;
                 CustomSlice* m_slice;
                 QDoubleSpinBox* m_hPosition;
                 QDoubleSpinBox* m_vPosition;
                 QDoubleSpinBox* m_sizeFactor;
                 QDoubleSpinBox* m_startAngle;
                 QDoubleSpinBox* m_endAngle;
                 QLabel* m_sliceName;
                 QDoubleSpinBox* m_sliceValue;
                 QCheckBox* m_sliceLabelVisible;
                 QDoubleSpinBox* m_sliceLabelArmFactor;
                 QCheckBox* m_sliceExploded;
                 QDoubleSpinBox* m_sliceExplodedFactor;
                 QPushButton *m_brush;
                 BrushTool *m_brushTool;
                 QPushButton *m_pen;
                 PenTool *m_penTool;
                 QPushButton *m_font;
                 QPushButton *m_labelBrush;
+                QComboBox *m_labelPosition;
                 BrushTool *m_labelBrushTool;
             };
             #endif // MAINWIDGET_H

src/piechart/piechartitem.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 "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);
                 connect(series, SIGNAL(added(QList<QPieSlice*>)), this, SLOT(handleSlicesAdded(QList<QPieSlice*>)));
                 connect(series, SIGNAL(removed(QList<QPieSlice*>)), this, SLOT(handleSlicesRemoved(QList<QPieSlice*>)));
                 connect(series, SIGNAL(horizontalPositionChanged()), this, SLOT(updateLayout()));
                 connect(series, SIGNAL(verticalPositionChanged()), this, SLOT(updateLayout()));
                 connect(series, SIGNAL(pieSizeChanged()), this, SLOT(updateLayout()));
                 connect(QPieSeriesPrivate::fromSeries(series), 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;
                 // apply size factor
                 m_pieRadius *= m_series->pieSize();
                 // 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: do 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(explodedChanged()), 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()));
+                    connect(slice, SIGNAL(labelPositionChanged()), this, SLOT(handleSliceChanged()));
                     connect(slice, SIGNAL(labelArmLengthFactorChanged()), this, SLOT(handleSliceChanged()));
                     connect(slice, 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());
                 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();
             }
             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;
                 return sliceData;
             }
             #include "moc_piechartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/pieslicedata_p.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$
             **
             ****************************************************************************/
             //  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;
                 }
                 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;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // PIESLICEDATA_P_H

src/piechart/piesliceitem.cpp +23 -19

             /****************************************************************************
             **
             ** 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();
-                    painter->setClipRect(parentItem()->boundingRect());
                     // 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->drawPath(m_labelArmPath);
+                    painter->setBrush(m_data.m_labelBrush);
                     painter->setFont(m_data.m_labelFont);
-                    painter->drawText(m_labelTextRect.bottomLeft(), m_data.m_labelText);
+                    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();
-                // update slice path
+                // 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);
-                // update text rect
+                // text rect
-                m_labelTextRect = labelTextRect(m_data.m_labelFont, m_data.m_labelText);
+                QFontMetricsF fm(m_data.m_labelFont);
+                m_labelTextRect = QRectF(0, 0, fm.width(m_data.m_labelText), fm.height());
-                // update label arm path
+                // label arm path
                 QPointF labelTextStart;
                 m_labelArmPath = labelArmPath(armStart, centerAngle, m_data.m_radius * m_data.m_labelArmLengthFactor, m_labelTextRect.width(), &labelTextStart);
-                // update text position
+                // text position
-                m_labelTextRect.moveBottomLeft(labelTextStart);
+                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);
+                }
-                // update bounding rect
+                //  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
                 // TODO: draw the shape so that it might have a hole in the center
                 QPainterPath path;
                 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;
                 }
-                // elevate the text position a bit so that it does not hit the line
-                *textStart += QPointF(0, -3);
                 QPainterPath path;
                 path.moveTo(start);
                 path.lineTo(parm1);
                 path.lineTo(parm2);
                 return path;
             }
-            QRectF PieSliceItem::labelTextRect(QFont font, QString text)
-                QFontMetricsF fm(font);
-                return fm.boundingRect(text);
             #include "moc_piesliceitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/piesliceitem_p.h 0 -1

             /****************************************************************************
             **
             ** 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 PIESLICEITEM_H
             #define PIESLICEITEM_H
             #include "qchartglobal.h"
             #include "charttheme_p.h"
             #include "qpieseries.h"
             #include "pieslicedata_p.h"
             #include <QGraphicsItem>
             #include <QRectF>
             #include <QColor>
             #include <QPen>
             #define PIESLICE_LABEL_GAP 5
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class PieChartItem;
             class PieSliceLabel;
             class QPieSlice;
             class PieSliceItem : public QGraphicsObject
             {
                 Q_OBJECT
             public:
                 PieSliceItem(QGraphicsItem* parent = 0);
                 ~PieSliceItem();
                 // from QGraphicsItem
                 QRectF boundingRect() const;
                 QPainterPath shape() const;
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
                 void hoverEnterEvent(QGraphicsSceneHoverEvent *event);
                 void hoverLeaveEvent(QGraphicsSceneHoverEvent *event);
                 void mousePressEvent(QGraphicsSceneMouseEvent *event);
                 void setLayout(const PieSliceData &sliceData);
                 static QPointF sliceCenter(QPointF point, qreal radius, QPieSlice *slice);
             Q_SIGNALS:
                 void clicked(Qt::MouseButtons buttons);
                 void hovered(bool state);
             private:
                 void updateGeometry();
                 QPainterPath slicePath(QPointF center, qreal radius, qreal startAngle, qreal angleSpan, qreal *centerAngle, QPointF *armStart);
                 QPainterPath labelArmPath(QPointF start, qreal angle, qreal length, qreal textWidth, QPointF *textStart);
-                QRectF labelTextRect(QFont font, QString text);
             private:
                 PieSliceData m_data;
                 QRectF m_boundingRect;
                 QPainterPath m_slicePath;
                 QPainterPath m_labelArmPath;
                 QRectF m_labelTextRect;
                 bool m_hovered;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // PIESLICEITEM_H

src/piechart/qpieslice.cpp +39 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 "qpieslice.h"
             #include "qpieslice_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QPieSlice
                 \brief Defines a slice in pie series.
                 This object defines the properties of a single slice in a QPieSeries.
                 In addition to the obvious value and label properties the user can also control
                 the visual appearance of a slice. By modifying the visual appearance also means that
                 the user is overriding the default appearance set by the theme.
                 Note that if the user has customized slices and theme is changed all customizations will be lost.
                 To enable user interaction with the pie some basic signals are provided about clicking and hovering.
             */
             /*!
+             \enum QPieSlice::LabelPosition
+             This enum describes the position of the slice label.
+             \value LabelOutside Label is outside the slice with an arm.
+             \value LabelInside Label is centered inside the slice.
+             */
+            /*!
                 \property QPieSlice::label
                 Label of the slice.
                 \sa labelVisible, labelBrush, labelFont, labelArmLengthFactor
             */
             /*!
                 \fn void QPieSlice::labelChanged()
                 This signal emitted when the slice label has been changed.
                 \sa label
             */
             /*!
                 \property QPieSlice::value
                 Value of the slice.
                 Note that if users sets a negative value it is converted to a positive value.
                 \sa percentage(), QPieSeries::sum()
             */
             /*!
                 \fn void QPieSlice::valueChanged()
                 This signal is emitted when the slice value changes.
                 \sa value
             */
             /*!
                 \property QPieSlice::labelVisible
                 Defienes the visibility of the slice label.
                 Default is not visible.
                 \sa label, labelBrush, labelFont, labelArmLengthFactor
             */
             /*!
                 \fn void QPieSlice::labelVisibleChanged()
                 This signal emitted when visibility of the slice label has changed.
                 \sa labelVisible
             */
             /*!
                 \property QPieSlice::exploded
                 Defines if the slice is exploded from the pie.
                 \sa explodeDistanceFactor
             */
             /*!
                 \fn void QPieSlice::explodedChanged()
                 This signal is emitted the the slice has been exploded from the pie or is returned back to the pie.
                 \sa exploded
             */
             /*!
                 \property QPieSlice::pen
                 Pen used to draw the slice border.
             */
             /*!
                 \fn void QPieSlice::penChanged()
                 This signal is emitted when the pen of the slice has changed.
                 \sa pen
             */
             /*!
                 \property QPieSlice::borderColor
                 Color used to draw the slice border.
                 This is a convenience property for modifying the slice pen.
                 \sa pen, borderWidth
             */
             /*!
                 \fn void QPieSlice::borderColorChanged()
                 This signal is emitted when slice border color changes.
                 \sa pen, borderColor
             */
             /*!
                 \property QPieSlice::borderWidth
                 Width of the slice border.
                 This is a convenience property for modifying the slice pen.
                 \sa pen, borderColor
             */
             /*!
                 \fn void QPieSlice::borderWidthChanged()
                 This signal is emitted when slice border width changes.
                 \sa pen, borderWidth
             */
             /*!
                 \property QPieSlice::brush
                 Brush used to draw the slice.
             */
             /*!
                 \fn void QPieSlice::brushChanged()
                 This signal is emitted when the brush of the slice has changed.
                 \sa brush
             */
             /*!
                 \property QPieSlice::color
                 Color used to draw the slice.
                 This is a convenience property for modifying the slice brush.
                 \sa brush
             */
             /*!
                 \fn void QPieSlice::colorChanged()
                 This signal is emitted when slice color changes.
                 \sa brush
             */
             /*!
                 \property QPieSlice::labelBrush
                 Pen used to draw label and label arm of the slice.
                 \sa label, labelVisible, labelFont, labelArmLengthFactor
             */
             /*!
                 \fn void QPieSlice::labelBrushChanged()
                 This signal is emitted when the label pen of the slice has changed.
                 \sa labelBrush
             */
             /*!
                 \property QPieSlice::labelColor
                 Color used to draw the slice label.
                 This is a convenience property for modifying the slice label brush.
                 \sa labelBrush
             */
             /*!
                 \fn void QPieSlice::labelColorChanged()
                 This signal is emitted when slice label color changes.
                 \sa labelColor
             */
             /*!
                 \property QPieSlice::labelFont
                 Font used for drawing label text.
                 \sa label, labelVisible, labelArmLengthFactor
             */
             /*!
                 \fn void QPieSlice::labelFontChanged()
                 This signal is emitted when the label font of the slice has changed.
                 \sa labelFont
             */
             /*!
+                \property QPieSlice::labelPosition
+                Position of the slice label.
+                \sa label, labelVisible
+            */
+            /*!
+                \fn void QPieSlice::labelPositionChanged()
+                This signal is emitted when the label position of the slice has changed.
+                \sa labelPosition
+            */
+            /*!
                 \property QPieSlice::labelArmLengthFactor
                 Defines the length of the label arm.
                 The factor is relative to pie radius. For example:
 .0 means the length is the same as the radius.
 .5 means the length is half of the radius.
                 Default value is 0.15
                 \sa label, labelVisible, labelBrush, labelFont
             */
             /*!
                 \fn void QPieSlice::labelArmLengthFactorChanged()
                 This signal is emitted when the label arm factor of the slice has changed.
                 \sa labelArmLengthFactor
             */
             /*!
                 \property QPieSlice::explodeDistanceFactor
                 When the slice is exploded this factor defines how far the slice is exploded away from the pie.
                 The factor is relative to pie radius. For example:
 .0 means the distance is the same as the radius.
 .5 means the distance is half of the radius.
                 Default value is 0.15
                 \sa exploded
             */
             /*!
                 \fn void QPieSlice::explodeDistanceFactorChanged()
                 This signal is emitted when the explode distance factor of the slice has changed.
                 \sa explodeDistanceFactor
             */
             /*!
                 \property QPieSlice::percentage
                 Percentage of the slice compared to the sum of all slices in the series.
                 The actual value ranges from 0.0 to 1.0.
                 Updated automatically once the slice is added to the series.
                 \sa value, QPieSeries::sum
             */
             /*!
                 \fn void QPieSlice::percentageChanged()
                 This signal is emitted when the percentage of the slice has changed.
                 \sa percentage
             */
             /*!
                 \property QPieSlice::startAngle
                 Defines the starting angle of this slice in the series it belongs to.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                 Updated automatically once the slice is added to the series.
             */
             /*!
                 \fn void QPieSlice::startAngleChanged()
                 This signal is emitted when the starting angle f the slice has changed.
                 \sa startAngle
             */
             /*!
                 \property QPieSlice::angleSpan
                 Span of the slice in degrees.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                 Updated automatically once the slice is added to the series.
             */
             /*!
                 \fn void QPieSlice::angleSpanChanged()
                 This signal is emitted when the angle span of the slice has changed.
                 \sa angleSpan
             */
             /*!
                 \fn void QPieSlice::clicked()
                 This signal is emitted when user has clicked the slice.
                 \sa QPieSeries::clicked()
             */
             /*!
                 \fn void QPieSlice::hovered(bool state)
                 This signal is emitted when user has hovered over or away from the slice.
                 \a state is true when user has hovered over the slice and false when hover has moved away from the slice.
                 \sa QPieSeries::hovered()
             */
             /*!
                 Constructs an empty slice with a \a parent.
                 \sa QPieSeries::append(), QPieSeries::insert()
             */
             QPieSlice::QPieSlice(QObject *parent)
                 :QObject(parent),
                 d_ptr(new QPieSlicePrivate(this))
             {
             }
             /*!
                 Constructs an empty slice with given \a value, \a label and a \a parent.
                 \sa QPieSeries::append(), QPieSeries::insert()
             */
             QPieSlice::QPieSlice(QString label, qreal value, QObject *parent)
                 :QObject(parent),
                 d_ptr(new QPieSlicePrivate(this))
             {
                 setValue(value);
                 setLabel(label);
             }
             /*!
                 Destroys the slice.
                 User should not delete the slice if it has been added to the series.
             */
             QPieSlice::~QPieSlice()
             {
             }
             void QPieSlice::setLabel(QString label)
             {
                 if (d_ptr->m_data.m_labelText != label) {
                     d_ptr->m_data.m_labelText = label;
                     emit labelChanged();
                 }
             }
             QString QPieSlice::label() const
             {
                 return d_ptr->m_data.m_labelText;
             }
             void QPieSlice::setValue(qreal value)
             {
                 value = qAbs(value); // negative values not allowed
                 if (!qFuzzyIsNull(d_ptr->m_data.m_value - value)) {
                     d_ptr->m_data.m_value = value;
                     emit valueChanged();
                 }
             }
             qreal QPieSlice::value() const
             {
                 return d_ptr->m_data.m_value;
             }
             void QPieSlice::setLabelVisible(bool visible)
             {
                 if (d_ptr->m_data.m_isLabelVisible != visible) {
                     d_ptr->m_data.m_isLabelVisible = visible;
                     emit labelVisibleChanged();
                 }
             }
             bool QPieSlice::isLabelVisible() const
             {
                 return d_ptr->m_data.m_isLabelVisible;
             }
             void QPieSlice::setExploded(bool exploded)
             {
                 if (d_ptr->m_data.m_isExploded != exploded) {
                     d_ptr->m_data.m_isExploded = exploded;
                     emit explodedChanged();
                 }
             }
+            QPieSlice::LabelPosition QPieSlice::labelPosition()
+            {
+                return d_ptr->m_data.m_labelPosition;
+            }
+            void QPieSlice::setLabelPosition(LabelPosition position)
+            {
+                if (d_ptr->m_data.m_labelPosition != position) {
+                    d_ptr->m_data.m_labelPosition = position;
+                    emit labelPositionChanged();
+                }
+            }
             bool QPieSlice::isExploded() const
             {
                 return d_ptr->m_data.m_isExploded;
             }
             void QPieSlice::setPen(const QPen &pen)
             {
                 d_ptr->setPen(pen, false);
             }
             QPen QPieSlice::pen() const
             {
                 return d_ptr->m_data.m_slicePen;
             }
             QColor QPieSlice::borderColor()
             {
                 return pen().color();
             }
             void QPieSlice::setBorderColor(QColor color)
             {
                 QPen p = pen();
                 if (color != p.color()) {
                     p.setColor(color);
                     setPen(p);
                 }
             }
             int QPieSlice::borderWidth()
             {
                 return pen().width();
             }
             void QPieSlice::setBorderWidth(int width)
             {
                 QPen p = pen();
                 if (width != p.width()) {
                     p.setWidth(width);
                     setPen(p);
                 }
             }
             void QPieSlice::setBrush(const QBrush &brush)
             {
                 d_ptr->setBrush(brush, false);
             }
             QBrush QPieSlice::brush() const
             {
                 return d_ptr->m_data.m_sliceBrush;
             }
             QColor QPieSlice::color()
             {
                 return brush().color();
             }
             void QPieSlice::setColor(QColor color)
             {
                 QBrush b = brush();
                 if (color != b.color()) {
                     b.setColor(color);
                     setBrush(b);
                 }
             }
             void QPieSlice::setLabelBrush(const QBrush &brush)
             {
                 d_ptr->setLabelBrush(brush, false);
             }
             QBrush QPieSlice::labelBrush() const
             {
                 return d_ptr->m_data.m_labelBrush;
             }
             QColor QPieSlice::labelColor()
             {
                 return labelBrush().color();
             }
             void QPieSlice::setLabelColor(QColor color)
             {
                 QBrush b = labelBrush();
                 if (color != b.color()) {
                     b.setColor(color);
                     setLabelBrush(b);
                 }
             }
             void QPieSlice::setLabelFont(const QFont &font)
             {
                 d_ptr->setLabelFont(font, false);
             }
             QFont QPieSlice::labelFont() const
             {
                 return d_ptr->m_data.m_labelFont;
             }
             void QPieSlice::setLabelArmLengthFactor(qreal factor)
             {
                 if (!qFuzzyIsNull(d_ptr->m_data.m_labelArmLengthFactor - factor)) {
                     d_ptr->m_data.m_labelArmLengthFactor = factor;
                     emit labelArmLengthFactorChanged();
                 }
             }
             qreal QPieSlice::labelArmLengthFactor() const
             {
                 return d_ptr->m_data.m_labelArmLengthFactor;
             }
             void QPieSlice::setExplodeDistanceFactor(qreal factor)
             {
                 if (!qFuzzyIsNull(d_ptr->m_data.m_explodeDistanceFactor - factor)) {
                     d_ptr->m_data.m_explodeDistanceFactor = factor;
                     emit explodeDistanceFactorChanged();
                 }
             }
             qreal QPieSlice::explodeDistanceFactor() const
             {
                 return d_ptr->m_data.m_explodeDistanceFactor;
             }
             qreal QPieSlice::percentage() const
             {
                 return d_ptr->m_data.m_percentage;
             }
             qreal QPieSlice::startAngle() const
             {
                 return d_ptr->m_data.m_startAngle;
             }
             qreal QPieSlice::angleSpan() const
             {
                 return d_ptr->m_data.m_angleSpan;
             }
             /*!
               Returns the series that this slice belongs to.
               \sa QPieSeries::append()
             */
             QPieSeries *QPieSlice::series() const
             {
                 return d_ptr->m_series;
             }
             QPieSlicePrivate::QPieSlicePrivate(QPieSlice *parent)
                 :QObject(parent),
                 q_ptr(parent),
                 m_series(0)
             {
             }
             QPieSlicePrivate::~QPieSlicePrivate()
             {
             }
             QPieSlicePrivate *QPieSlicePrivate::fromSlice(QPieSlice *slice)
             {
                 return slice->d_func();
             }
             void QPieSlicePrivate::setPen(const QPen &pen, bool themed)
             {
                 if (m_data.m_slicePen != pen) {
                     QPen oldPen = m_data.m_slicePen;
                     m_data.m_slicePen = pen;
                     m_data.m_slicePen.setThemed(themed);
                     emit q_ptr->penChanged();
                     if (oldPen.color() != pen.color())
                         emit q_ptr->borderColorChanged();
                     if (oldPen.width() != pen.width())
                         emit q_ptr->borderWidthChanged();
                 }
             }
             void QPieSlicePrivate::setBrush(const QBrush &brush, bool themed)
             {
                 if (m_data.m_sliceBrush != brush) {
                     QBrush oldBrush = m_data.m_sliceBrush;
                     m_data.m_sliceBrush = brush;
                     m_data.m_sliceBrush.setThemed(themed);
                     emit q_ptr->brushChanged();
                     if (oldBrush.color() != brush.color())
                         emit q_ptr->colorChanged();
                 }
             }
             void QPieSlicePrivate::setLabelBrush(const QBrush &brush, bool themed)
             {
                 if (m_data.m_labelBrush != brush) {
                     QBrush oldBrush = m_data.m_labelBrush;
                     m_data.m_labelBrush = brush;
                     m_data.m_labelBrush.setThemed(themed);
                     emit q_ptr->labelBrushChanged();
                     if (oldBrush.color() != brush.color())
                         emit q_ptr->labelColorChanged();
                 }
             }
             void QPieSlicePrivate::setLabelFont(const QFont &font, bool themed)
             {
                 if (m_data.m_labelFont != font) {
                     m_data.m_labelFont = font;
                     m_data.m_labelFont.setThemed(themed);
                     emit q_ptr->labelFontChanged();
                 }
             }
             void QPieSlicePrivate::setPercentage(qreal percentage)
             {
                 if (!qFuzzyIsNull(m_data.m_percentage - percentage)) {
                     m_data.m_percentage = percentage;
                     emit q_ptr->percentageChanged();
                 }
             }
             void QPieSlicePrivate::setStartAngle(qreal angle)
             {
                 if (!qFuzzyIsNull(m_data.m_startAngle - angle)) {
                     m_data.m_startAngle = angle;
                     emit q_ptr->startAngleChanged();
                 }
             }
             void QPieSlicePrivate::setAngleSpan(qreal span)
             {
                 if (!qFuzzyIsNull(m_data.m_angleSpan - span)) {
                     m_data.m_angleSpan = span;
                     emit q_ptr->angleSpanChanged();
                 }
             }
             QTCOMMERCIALCHART_END_NAMESPACE
             QTCOMMERCIALCHART_USE_NAMESPACE
             #include "moc_qpieslice.cpp"
             #include "moc_qpieslice_p.cpp"

src/piechart/qpieslice.h +12 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 QPIESLICE_H
             #define QPIESLICE_H
             #include <qchartglobal.h>
             #include <QObject>
             #include <QPen>
             #include <QBrush>
             #include <QFont>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QPieSlicePrivate;
             class QPieSeries;
             class QTCOMMERCIALCHART_EXPORT QPieSlice : public QObject
             {
                 Q_OBJECT
+                Q_ENUMS(LabelPosition)
                 Q_PROPERTY(QString label READ label WRITE setLabel NOTIFY labelChanged)
                 Q_PROPERTY(qreal value READ value WRITE setValue NOTIFY valueChanged)
                 Q_PROPERTY(bool labelVisible READ isLabelVisible WRITE setLabelVisible NOTIFY labelVisibleChanged)
+                Q_PROPERTY(LabelPosition labelPosition READ labelPosition WRITE setLabelPosition NOTIFY labelPositionChanged)
                 Q_PROPERTY(bool exploded READ isExploded WRITE setExploded NOTIFY explodedChanged)
                 Q_PROPERTY(QPen pen READ pen WRITE setPen NOTIFY penChanged)
                 Q_PROPERTY(QColor borderColor READ borderColor WRITE setBorderColor NOTIFY borderColorChanged)
                 Q_PROPERTY(int borderWidth READ borderWidth WRITE setBorderWidth NOTIFY borderWidthChanged)
                 Q_PROPERTY(QBrush brush READ brush WRITE setBrush NOTIFY brushChanged)
                 Q_PROPERTY(QColor color READ color WRITE setColor NOTIFY colorChanged)
                 Q_PROPERTY(QBrush labelBrush READ labelBrush WRITE setLabelBrush NOTIFY labelBrushChanged)
                 Q_PROPERTY(QColor labelColor READ labelColor WRITE setLabelColor NOTIFY labelColorChanged)
                 Q_PROPERTY(QFont labelFont READ labelFont WRITE setLabelFont NOTIFY labelFontChanged)
                 Q_PROPERTY(qreal labelArmLengthFactor READ labelArmLengthFactor WRITE setLabelArmLengthFactor)
                 Q_PROPERTY(qreal explodeDistanceFactor READ explodeDistanceFactor WRITE setExplodeDistanceFactor)
                 Q_PROPERTY(qreal percentage READ percentage NOTIFY percentageChanged)
                 Q_PROPERTY(qreal startAngle READ startAngle NOTIFY startAngleChanged)
                 Q_PROPERTY(qreal angleSpan READ angleSpan NOTIFY angleSpanChanged)
             public:
+                enum LabelPosition {
+                    LabelOutside,
+                    LabelInside
+                };
+            public:
                 explicit QPieSlice(QObject *parent = 0);
                 QPieSlice(QString label, qreal value, QObject *parent = 0);
                 virtual ~QPieSlice();
                 void setLabel(QString label);
                 QString label() const;
                 void setValue(qreal value);
                 qreal value() const;
                 void setLabelVisible(bool visible = true);
                 bool isLabelVisible() const;
+                LabelPosition labelPosition();
+                void setLabelPosition(LabelPosition position);
                 void setExploded(bool exploded = true);
                 bool isExploded() const;
                 void setPen(const QPen &pen);
                 QPen pen() const;
                 QColor borderColor();
                 void setBorderColor(QColor color);
                 int borderWidth();
                 void setBorderWidth(int width);
                 void setBrush(const QBrush &brush);
                 QBrush brush() const;
                 QColor color();
                 void setColor(QColor color);
                 void setLabelBrush(const QBrush &brush);
                 QBrush labelBrush() const;
                 QColor labelColor();
                 void setLabelColor(QColor color);
                 void setLabelFont(const QFont &font);
                 QFont labelFont() const;
                 void setLabelArmLengthFactor(qreal factor);
                 qreal labelArmLengthFactor() const;
                 void setExplodeDistanceFactor(qreal factor);
                 qreal explodeDistanceFactor() const;
                 qreal percentage() const;
                 qreal startAngle() const;
                 qreal angleSpan() const;
                 QPieSeries *series() const;
             Q_SIGNALS:
                 void labelChanged();
                 void valueChanged();
                 void labelVisibleChanged();
+                void labelPositionChanged();
                 void explodedChanged();
                 void penChanged();
                 void brushChanged();
                 void labelBrushChanged();
                 void labelFontChanged();
                 void labelArmLengthFactorChanged();
                 void explodeDistanceFactorChanged();
                 void percentageChanged();
                 void startAngleChanged();
                 void angleSpanChanged();
                 void colorChanged();
                 void borderColorChanged();
                 void borderWidthChanged();
                 void labelColorChanged();
                 void clicked();
                 void hovered(bool state);
             private:
                 QPieSlicePrivate * const d_ptr;
                 Q_DECLARE_PRIVATE(QPieSlice)
                 Q_DISABLE_COPY(QPieSlice)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QPIESLICE_H

tests/auto/qpieslice/tst_qpieslice.cpp +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$
             **
             ****************************************************************************/
             #include <QtTest/QtTest>
             #include <tst_definitions.h>
             #include <qchartview.h>
             #include <qchart.h>
             #include <qpieslice.h>
             #include <qpieseries.h>
             QTCOMMERCIALCHART_USE_NAMESPACE
             class tst_qpieslice : public QObject
             {
                 Q_OBJECT
             public slots:
                 void initTestCase();
                 void cleanupTestCase();
                 void init();
                 void cleanup();
             private slots:
                 void construction();
                 void changedSignals();
                 void customize();
                 void mouseClick();
                 void mouseHover();
             private:
             private:
             };
             void tst_qpieslice::initTestCase()
             {
             }
             void tst_qpieslice::cleanupTestCase()
             {
             }
             void tst_qpieslice::init()
             {
             }
             void tst_qpieslice::cleanup()
             {
             }
             void tst_qpieslice::construction()
             {
                 // no params
                 QPieSlice slice1;
                 QCOMPARE(slice1.value(), 0.0);
                 QVERIFY(slice1.label().isEmpty());
                 QVERIFY(!slice1.isLabelVisible());
                 QVERIFY(!slice1.isExploded());
                 QCOMPARE(slice1.pen(), QPen());
                 QCOMPARE(slice1.brush(), QBrush());
                 QCOMPARE(slice1.labelBrush(), QBrush());
                 QCOMPARE(slice1.labelFont(), QFont());
                 QCOMPARE(slice1.labelArmLengthFactor(), 0.15); // default value
                 QCOMPARE(slice1.explodeDistanceFactor(), 0.15); // default value
                 QCOMPARE(slice1.percentage(), 0.0);
                 QCOMPARE(slice1.startAngle(), 0.0);
                 QCOMPARE(slice1.angleSpan(), 0.0);
                 // value and label params
                 QPieSlice slice2("foobar", 1.0);
                 QCOMPARE(slice2.value(), 1.0);
                 QCOMPARE(slice2.label(), QString("foobar"));
                 QVERIFY(!slice2.isLabelVisible());
                 QVERIFY(!slice2.isExploded());
                 QCOMPARE(slice2.pen(), QPen());
                 QCOMPARE(slice2.brush(), QBrush());
                 QCOMPARE(slice2.labelBrush(), QBrush());
                 QCOMPARE(slice2.labelFont(), QFont());
                 QCOMPARE(slice2.labelArmLengthFactor(), 0.15); // default value
                 QCOMPARE(slice2.explodeDistanceFactor(), 0.15); // default value
                 QCOMPARE(slice2.percentage(), 0.0);
                 QCOMPARE(slice2.startAngle(), 0.0);
                 QCOMPARE(slice2.angleSpan(), 0.0);
             }
             void tst_qpieslice::changedSignals()
             {
                 QPieSlice slice;
                 QSignalSpy valueSpy(&slice, SIGNAL(valueChanged()));
                 QSignalSpy labelSpy(&slice, SIGNAL(labelChanged()));
                 QSignalSpy explodedSpy(&slice, SIGNAL(explodedChanged()));
                 QSignalSpy penSpy(&slice, SIGNAL(penChanged()));
                 QSignalSpy brushSpy(&slice, SIGNAL(brushChanged()));
                 QSignalSpy labelBrushSpy(&slice, SIGNAL(labelBrushChanged()));
                 QSignalSpy labelFontSpy(&slice, SIGNAL(labelFontChanged()));
+                QSignalSpy labelPositionSpy(&slice, SIGNAL(labelPositionChanged()));
                 QSignalSpy labelArmLengthFactorSpy(&slice, SIGNAL(labelArmLengthFactorChanged()));
                 QSignalSpy explodeDistanceFactorSpy(&slice, SIGNAL(explodeDistanceFactorChanged()));
                 QSignalSpy colorSpy(&slice, SIGNAL(colorChanged()));
                 QSignalSpy borderColorSpy(&slice, SIGNAL(borderColorChanged()));
                 QSignalSpy borderWidthSpy(&slice, SIGNAL(borderWidthChanged()));
                 QSignalSpy labelColorSpy(&slice, SIGNAL(labelColorChanged()));
                 // percentageChanged(), startAngleChanged() and angleSpanChanged() signals tested at tst_qpieseries::calculatedValues()
                 // set everything twice to see we do not get unnecessary signals
                 slice.setValue(1.0);
                 slice.setValue(-1.0);
                 QCOMPARE(slice.value(), 1.0);
                 slice.setLabel("foobar");
                 slice.setLabel("foobar");
                 slice.setLabelVisible();
                 slice.setLabelVisible();
                 slice.setExploded();
                 slice.setExploded();
                 slice.setPen(QPen(Qt::red));
                 slice.setPen(QPen(QBrush(Qt::red), 3));
                 slice.setBrush(QBrush(Qt::red));
                 slice.setBrush(QBrush(Qt::red));
                 slice.setLabelBrush(QBrush(Qt::green));
                 slice.setLabelBrush(QBrush(Qt::green));
                 slice.setLabelFont(QFont("Tahoma"));
                 slice.setLabelFont(QFont("Tahoma"));
+                slice.setLabelPosition(QPieSlice::LabelInside);
+                slice.setLabelPosition(QPieSlice::LabelInside);
                 slice.setLabelArmLengthFactor(0.1);
                 slice.setLabelArmLengthFactor(0.1);
                 slice.setExplodeDistanceFactor(0.1);
                 slice.setExplodeDistanceFactor(0.1);
                 TRY_COMPARE(valueSpy.count(), 1);
                 TRY_COMPARE(labelSpy.count(), 1);
                 TRY_COMPARE(explodedSpy.count(), 1);
                 TRY_COMPARE(penSpy.count(), 2);
                 TRY_COMPARE(brushSpy.count(), 1);
                 TRY_COMPARE(labelBrushSpy.count(), 1);
                 TRY_COMPARE(labelFontSpy.count(), 1);
+                TRY_COMPARE(labelPositionSpy.count(), 1);
                 TRY_COMPARE(labelArmLengthFactorSpy.count(), 1);
                 TRY_COMPARE(explodeDistanceFactorSpy.count(), 1);
                 TRY_COMPARE(colorSpy.count(), 1);
                 TRY_COMPARE(borderColorSpy.count(), 1);
                 TRY_COMPARE(borderWidthSpy.count(), 1);
                 TRY_COMPARE(labelColorSpy.count(), 1);
             }
             void tst_qpieslice::customize()
             {
                 // create a pie series
                 QPieSeries *series = new QPieSeries();
                 QPieSlice *s1 = series->append("slice 1", 1);
                 QPieSlice *s2 = series->append("slice 2", 2);
                 series->append("slice 3", 3);
                 // customize a slice
                 QPen p1(Qt::red);
                 s1->setPen(p1);
                 QBrush b1(Qt::red);
                 s1->setBrush(b1);
                 s1->setLabelBrush(b1);
                 QFont f1("Consolas");
                 s1->setLabelFont(f1);
                 // add series to the chart
                 QChartView view(new QChart());
                 view.resize(200, 200);
                 view.chart()->addSeries(series);
                 view.show();
                 QTest::qWaitForWindowShown(&view);
                 //QTest::qWait(1000);
                 // check that customizations persist
                 QCOMPARE(s1->pen(), p1);
                 QCOMPARE(s1->brush(), b1);
                 QCOMPARE(s1->labelBrush(), b1);
                 QCOMPARE(s1->labelFont(), f1);
                 // remove a slice
                 series->remove(s2);
                 QCOMPARE(s1->pen(), p1);
                 QCOMPARE(s1->brush(), b1);
                 QCOMPARE(s1->labelBrush(), b1);
                 QCOMPARE(s1->labelFont(), f1);
                 // add a slice
                 series->append("slice 4", 4);
                 QCOMPARE(s1->pen(), p1);
                 QCOMPARE(s1->brush(), b1);
                 QCOMPARE(s1->labelBrush(), b1);
                 QCOMPARE(s1->labelFont(), f1);
                 // insert a slice
                 series->insert(0, new QPieSlice("slice 5", 5));
                 QCOMPARE(s1->pen(), p1);
                 QCOMPARE(s1->brush(), b1);
                 QCOMPARE(s1->labelBrush(), b1);
                 QCOMPARE(s1->labelFont(), f1);
                 // change theme
                 // theme will overwrite customizations
                 view.chart()->setTheme(QChart::ChartThemeHighContrast);
                 QVERIFY(s1->pen() != p1);
                 QVERIFY(s1->brush() != b1);
                 QVERIFY(s1->labelBrush() != b1);
                 QVERIFY(s1->labelFont() != f1);
             }
             void tst_qpieslice::mouseClick()
             {
                 // create a pie series
                 QPieSeries *series = new QPieSeries();
                 series->setPieSize(1.0);
                 QPieSlice *s1 = series->append("slice 1", 1);
                 QPieSlice *s2 = series->append("slice 2", 2);
                 QPieSlice *s3 = series->append("slice 3", 3);
                 QSignalSpy clickSpy1(s1, SIGNAL(clicked()));
                 QSignalSpy clickSpy2(s2, SIGNAL(clicked()));
                 QSignalSpy clickSpy3(s3, SIGNAL(clicked()));
                 // add series to the chart
                 QChartView view(new QChart());
                 view.chart()->legend()->setVisible(false);
                 view.resize(200, 200);
                 view.chart()->addSeries(series);
                 view.show();
                 QTest::qWaitForWindowShown(&view);
                 // simulate clicks
                 // pie rectangle: QRectF(60,60 121x121)
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0,  QPoint(139, 85)); // inside slice 1
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0,  QPoint(146, 136)); // inside slice 2
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0,  QPoint(91, 119)); // inside slice 3
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0,  QPoint(70, 70)); // inside pie rectangle but not inside a slice
                 QTest::mouseClick(view.viewport(), Qt::LeftButton, 0,  QPoint(170, 170)); // inside pie rectangle but not inside a slice
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 QCOMPARE(clickSpy1.count(), 1);
                 QCOMPARE(clickSpy2.count(), 1);
                 QCOMPARE(clickSpy3.count(), 1);
             }
             void tst_qpieslice::mouseHover()
             {
                 // create a pie series
                 QPieSeries *series = new QPieSeries();
                 series->setPieSize(1.0);
                 QPieSlice *s1 = series->append("slice 1", 1);
                 series->append("slice 2", 2);
                 series->append("slice 3", 3);
                 // add series to the chart
                 QChartView view(new QChart());
                 view.chart()->legend()->setVisible(false);
                 view.resize(200, 200);
                 view.chart()->addSeries(series);
                 view.show();
                 QTest::qWaitForWindowShown(&view);
                 // first move to right top corner
                 QTest::mouseMove(view.viewport(), QPoint(200, 0));
                 QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
                 // move inside slice rectangle but NOT the actual slice
                 // pie rectangle: QRectF(60,60 121x121)
                 QSignalSpy hoverSpy(s1, SIGNAL(hovered(bool)));
                 QTest::mouseMove(view.viewport(), QPoint(170, 70));
                 TRY_COMPARE(hoverSpy.count(), 0);
                 // move inside the slice
                 QTest::mouseMove(view.viewport(), QPoint(139, 85));
                 TRY_COMPARE(hoverSpy.count(), 1);
                 QCOMPARE(qvariant_cast<bool>(hoverSpy.at(0).at(0)), true);
                 // move outside the slice
                 QTest::mouseMove(view.viewport(), QPoint(200, 0));
                 TRY_COMPARE(hoverSpy.count(), 2);
                 QCOMPARE(qvariant_cast<bool>(hoverSpy.at(1).at(0)), false);
             }
             QTEST_MAIN(tst_qpieslice)
             #include "tst_qpieslice.moc"

tests/qmlchartproperties/qml/qmlchartproperties/PieEditor.qml +9 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$
             **
             ****************************************************************************/
             import QtQuick 1.0
             import QtCommercial.Chart 1.0
             Flow {
                 id: flow
                 spacing: 5
                 flow: Flow.TopToBottom
                 property variant series
                 onSeriesChanged: {
                     seriesConnections.target = series;
                     sliceConnections.target = series.at(0);
                 }
                 Connections {
                     id: seriesConnections
                     ignoreUnknownSignals: true
                     onVisibleChanged:           console.log("series.onVisibleChanged: " + series.visible);
                     onHorizontalPositionChanged:console.log("series.onHorizontalPositionChanged: " + series.horizontalPosition);
                     onVerticalPositionChanged:  console.log("series.onVerticalPositionChanged: " + series.verticalPosition);
                     onSizeChanged:              console.log("series.onSizeChanged: " + series.size);
                     onStartAngleChanged:        console.log("series.onStartAngleChanged: " + series.startAngle);
                     onEndAngleChanged:          console.log("series.onEndAngleChanged: " + series.endAngle);
                     onCountChanged:             console.log("series.onCountChanged: " + series.count);
                     onSumChanged:               console.log("series.onSumChanged: " + series.sum);
                 }
                 Connections {
                     id: sliceConnections
                     ignoreUnknownSignals: true
                     onValueChanged:             console.log("slice.onValueChanged: " + series.at(0).value);
                     onLabelVisibleChanged:      console.log("slice.onLabelVisibleChanged: " + series.at(0).labelVisible);
+                    onLabelPositionChanged:     console.log("slice.onLabelPositionChanged: " + series.at(0).labelPosition);
                     onExplodedChanged:          console.log("slice.onExplodedChanged: " + series.at(0).exploded);
                     onPenChanged:               console.log("slice.onPenChanged: " + series.at(0).pen);
                     onBorderColorChanged:       console.log("slice.onBorderColorChanged: " + series.at(0).borderColor);
                     onBorderWidthChanged:       console.log("slice.onBorderWidthChanged: " + series.at(0).borderWidth);
                     onBrushChanged:             console.log("slice.onBrushChanged: " + series.at(0).brush);
                     onColorChanged:             console.log("slice.onColorChanged: " + series.at(0).color);
                     onLabelColorChanged:        console.log("slice.onLabelColorChanged: " + series.at(0).labelColor);
                     onLabelBrushChanged:        console.log("slice.onLabelBrushChanged: " + series.at(0).labelBrush);
                     onLabelFontChanged:         console.log("slice.onLabelFontChanged: " + series.at(0).labelFont);
                     onLabelArmLengthFactorChanged:  console.log("slice.onLabelArmLengthFactorChanged: " + series.at(0).labelArmLengthFactor);
                     onExplodeDistanceFactorChanged: console.log("slice.onExplodeDistanceFactorChanged: " + series.at(0).explodeDistanceFactor);
                     onPercentageChanged:        console.log("slice.onPercentageChanged: " + series.at(0).percentage);
                     onStartAngleChanged:        console.log("slice.onStartAngleChanged: " + series.at(0).startAngle);
                     onAngleSpanChanged:         console.log("slice.onAngleSpanChanged: " + series.at(0).angleSpan);
                 }
                 Button {
                     text: "visible"
                     onClicked: series.visible = !series.visible;
                 }
                 Button {
                     text: "series hpos +"
                     onClicked: series.horizontalPosition += 0.1;
                 }
                 Button {
                     text: "series hpos -"
                     onClicked: series.horizontalPosition -= 0.1;
                 }
                 Button {
                     text: "series vpos +"
                     onClicked: series.verticalPosition += 0.1;
                 }
                 Button {
                     text: "series vpos -"
                     onClicked: series.verticalPosition -= 0.1;
                 }
                 Button {
                     text: "series size +"
                     onClicked: series.size += 0.1;
                 }
                 Button {
                     text: "series size -"
                     onClicked: series.size -= 0.1;
                 }
                 Button {
                     text: "series start angle +"
                     onClicked: series.startAngle += 1.1;
                 }
                 Button {
                     text: "series start angle -"
                     onClicked: series.startAngle -= 1.1;
                 }
                 Button {
                     text: "series end angle +"
                     onClicked: series.endAngle += 1.1;
                 }
                 Button {
                     text: "series end angle -"
                     onClicked: series.endAngle -= 1.1;
                 }
                 Button {
                     text: "slice color"
                     onClicked: series.at(0).color = main.nextColor();
                 }
                 Button {
                     text: "slice border color"
                     onClicked: series.at(0).borderColor = main.nextColor();
                 }
                 Button {
                     text: "slice border width +"
                     onClicked: series.at(0).borderWidth++;
                 }
                 Button {
                     text: "slice border width -"
                     onClicked: series.at(0).borderWidth--;
                 }
                 Button {
                     text: "slice label visible"
                     onClicked: series.at(0).labelVisible = !series.at(0).labelVisible;
                 }
                 Button {
+                    text: "slice label position inside"
+                    onClicked: series.at(0).labelPosition = PieSlice.LabelInside;
+                }
+                Button {
+                    text: "slice label position outside"
+                    onClicked: series.at(0).labelPosition = PieSlice.LabelOutside;
+                }
+                Button {
                     text: "slice label arm len +"
                     onClicked: series.at(0).labelArmLengthFactor += 0.1;
                 }
                 Button {
                     text: "slice label arm len -"
                     onClicked: series.at(0).labelArmLengthFactor -= 0.1;
                 }
                 Button {
                     text: "slice label color"
                     onClicked: series.at(0).labelColor = main.nextColor();
                 }
                 Button {
                     text: "slice exploded"
                     onClicked: series.at(0).exploded = !series.at(0).exploded;
                 }
                 Button {
                     text: "slice explode dist +"
                     onClicked: series.at(0).explodeDistanceFactor += 0.1;
                 }
                 Button {
                     text: "slice explode dist -"
                     onClicked: series.at(0).explodeDistanceFactor -= 0.1;
                 }
             }

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