HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r1009:983f422506c5

API review changes for pie

Jani Honkonen -

r1009:983f422506c5

parent child

Context file:

r1009:983f422506c5

Collapse all files

demos/piechartcustomization/customslice.cpp +10 -12

             /****************************************************************************
             **
             ** 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 "customslice.h"
             QTCOMMERCIALCHART_USE_NAMESPACE
             CustomSlice::CustomSlice(qreal value, QString label)
                 :QPieSlice(value, label)
             {
-                connect(this, SIGNAL(hoverEnter()), this, SLOT(handleHoverEnter()));
+                connect(this, SIGNAL(hovered(bool)), this, SLOT(showHighlight(bool)));
-                connect(this, SIGNAL(hoverLeave()), this, SLOT(handleHoverLeave()));
             }
             QBrush CustomSlice::originalBrush()
             {
                 return m_originalBrush;
             }
-            void CustomSlice::handleHoverEnter()
+            void CustomSlice::showHighlight(bool show)
             {
-                QBrush brush = this->brush();
+                if (show) {
-                m_originalBrush = brush;
+                    QBrush brush = this->brush();
-                brush.setColor(brush.color().lighter());
+                    m_originalBrush = brush;
-                setBrush(brush);
+                    brush.setColor(brush.color().lighter());
+                    setBrush(brush);
+                } else {
-            void CustomSlice::handleHoverLeave()
+                    setBrush(m_originalBrush);
+                }
-                setBrush(m_originalBrush);
             }
             #include "moc_customslice.cpp"

demos/piechartcustomization/customslice.h +1 -2

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef CUSTOMSLICE_H
             #define CUSTOMSLICE_H
             #include <QPieSlice>
             QTCOMMERCIALCHART_USE_NAMESPACE
             class CustomSlice : public QPieSlice
             {
                 Q_OBJECT
             public:
                 CustomSlice(qreal value, QString label);
             public:
                 QBrush originalBrush();
             public Q_SLOTS:
-                void handleHoverEnter();
+                void showHighlight(bool show);
-                void handleHoverLeave();
             private:
                 QBrush m_originalBrush;
             };
             #endif // CUSTOMSLICE_H

demos/piechartcustomization/mainwidget.cpp +11 -4

             /****************************************************************************
             **
             ** 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(10.0, "Slice 1");
                 *m_series << new CustomSlice(20.0, "Slice 2");
                 *m_series << new CustomSlice(30.0, "Slice 3");
                 *m_series << new CustomSlice(40.0, "Slice 4");
                 *m_series << new CustomSlice(50.0, "Slice 5");
                 m_series->setLabelsVisible();
                 chart->addSeries(m_series);
-                connect(m_series, SIGNAL(clicked(QPieSlice*,Qt::MouseButtons)), this, SLOT(handleSliceClicked(QPieSlice*,Qt::MouseButtons)));
+                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(0.0);
                 m_startAngle->setMaximum(360);
                 m_startAngle->setValue(m_series->pieStartAngle());
                 m_startAngle->setSingleStep(1);
                 m_endAngle = new QDoubleSpinBox();
                 m_endAngle->setMinimum(0.0);
                 m_endAngle->setMaximum(360);
                 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_labelPen = new QPushButton();
                 m_labelPenTool = new PenTool("Label pen", this);
                 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_labelPen);
                 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_labelPen, SIGNAL(clicked()), m_labelPenTool, SLOT(show()));
                 connect(m_labelPenTool, 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(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->setLabelPen(m_labelPenTool->pen());
                 m_slice->setLabelVisible(m_sliceLabelVisible->isChecked());
                 m_slice->setLabelArmLengthFactor(m_sliceLabelArmFactor->value());
                 m_slice->setExploded(m_sliceExploded->isChecked());
                 m_slice->setExplodeDistanceFactor(m_sliceExplodedFactor->value());
             }
-            void MainWidget::handleSliceClicked(QPieSlice* slice, Qt::MouseButtons buttons)
+            void MainWidget::handleSliceClicked(QPieSlice* slice)
             {
-                Q_UNUSED(buttons);
                 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_labelPen->setText(PenTool::name(m_slice->labelPen()));
                 m_labelPenTool->setPen(m_slice->labelPen());
                 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);
                 // 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(10.0, "Slice " + QString::number(m_series->count()+1));
             }
             void MainWidget::insertSlice()
             {
                 if (!m_slice)
                     return;
                 int i = m_series->slices().indexOf(m_slice);
                 m_series->insert(i, new CustomSlice(10.0, "Slice " + QString::number(m_series->count()+1)));
             }
             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 +2 -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$
             **
             ****************************************************************************/
             #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, Qt::MouseButtons buttons);
+                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_labelPen;
                 PenTool *m_labelPenTool;
             };
             #endif // MAINWIDGET_H

examples/piechartdrilldown/drilldownslice.cpp +4 -11

             /****************************************************************************
             **
             ** 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 "drilldownslice.h"
             QTCOMMERCIALCHART_USE_NAMESPACE
             DrilldownSlice::DrilldownSlice(qreal value, QString prefix, QAbstractSeries* drilldownSeries)
                 :m_drilldownSeries(drilldownSeries),
                 m_prefix(prefix)
             {
                 setValue(value);
                 updateLabel();
                 setLabelFont(QFont("Arial", 8));
                 connect(this, SIGNAL(changed()), this, SLOT(updateLabel()));
-                connect(this, SIGNAL(hoverEnter()), this, SLOT(showHighlight()));
+                connect(this, SIGNAL(hovered(bool)), this, SLOT(showHighlight(bool)));
-                connect(this, SIGNAL(hoverLeave()), this, SLOT(hideHighlight()));
             }
             DrilldownSlice::~DrilldownSlice()
             {
             }
             QAbstractSeries* DrilldownSlice::drilldownSeries() const
             {
                 return m_drilldownSeries;
             }
             void DrilldownSlice::updateLabel()
             {
                 QString label = m_prefix;
                 label += " $";
                 label += QString::number(this->value());
                 label += ", ";
                 label += QString::number(this->percentage()*100, 'f', 1);
                 label += "%";
                 setLabel(label);
             }
-            void DrilldownSlice::showHighlight()
+            void DrilldownSlice::showHighlight(bool show)
             {
-                setExploded();
+                setExploded(show);
-                setLabelVisible();
+                setLabelVisible(show);
-            void DrilldownSlice::hideHighlight()
-                setExploded(false);
-                setLabelVisible(false);
             }
             #include "moc_drilldownslice.cpp"

examples/piechartdrilldown/drilldownslice.h +1 -2

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef DRILLDOWNSLICE_H
             #define DRILLDOWNSLICE_H
             #include <QPieSlice>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QAbstractSeries;
             QTCOMMERCIALCHART_END_NAMESPACE
             QTCOMMERCIALCHART_USE_NAMESPACE
             class DrilldownSlice : public QPieSlice
             {
                 Q_OBJECT
             public:
                 DrilldownSlice(qreal value, QString prefix, QAbstractSeries* drilldownSeries);
                 virtual ~DrilldownSlice();
                 QAbstractSeries* drilldownSeries() const;
             public Q_SLOTS:
                 void updateLabel();
-                void showHighlight();
+                void showHighlight(bool show);
-                void hideHighlight();
             private:
                 QAbstractSeries* m_drilldownSeries;
                 QString m_prefix;
             };
             #endif // DRILLDOWNSLICE_H

examples/piechartdrilldown/main.cpp +2 -2

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "drilldownchart.h"
             #include "drilldownslice.h"
             #include <QtGui/QApplication>
             #include <QMainWindow>
             #include <QTime>
             #include <QChartView>
             #include <QLegend>
             #include <QPieSeries>
             QTCOMMERCIALCHART_USE_NAMESPACE
             int main(int argc, char *argv[])
             {
                 QApplication a(argc, argv);
                 qsrand(QTime(0,0,0).secsTo(QTime::currentTime()));
                 QMainWindow window;
                 DrilldownChart* chart = new DrilldownChart();
                 chart->setTheme(QChart::ChartThemeLight);
                 chart->setAnimationOptions(QChart::AllAnimations);
                 chart->legend()->setVisible(true);
                 chart->legend()->setAlignment(QLegend::AlignmentRight);
                 QPieSeries* yearSeries = new QPieSeries(&window);
                 yearSeries->setName("Sales by year - All");
                 QList<QString> months;
                 months << "Jan" << "Feb" << "Mar" << "Apr" << "May" << "Jun" << "Jul" << "Aug" << "Sep" << "Oct" << "Nov" << "Dec";
                 QList<QString> names;
                 names << "Jane" << "John" << "Axel" << "Mary" << "Susan" << "Bob";
                 foreach (QString name, names) {
                     QPieSeries* series = new QPieSeries(&window);
                     series->setName("Sales by month - " + name);
                     foreach (QString month, months)
                         *series << new DrilldownSlice(qrand() % 1000, month, yearSeries);
-                    QObject::connect(series, SIGNAL(clicked(QPieSlice*,Qt::MouseButtons)), chart, SLOT(handleSliceClicked(QPieSlice*)));
+                    QObject::connect(series, SIGNAL(clicked(QPieSlice*)), chart, SLOT(handleSliceClicked(QPieSlice*)));
                     *yearSeries << new DrilldownSlice(series->sum(), name, series);
                 }
-                QObject::connect(yearSeries, SIGNAL(clicked(QPieSlice*,Qt::MouseButtons)), chart, SLOT(handleSliceClicked(QPieSlice*)));
+                QObject::connect(yearSeries, SIGNAL(clicked(QPieSlice*)), chart, SLOT(handleSliceClicked(QPieSlice*)));
                 chart->changeSeries(yearSeries);
                 QChartView* chartView = new QChartView(chart);
                 chartView->setRenderHint(QPainter::Antialiasing);
                 window.setCentralWidget(chartView);
                 window.resize(800, 500);
                 window.show();
                 return a.exec();
             }

src/legend/legendmarker.cpp +1 -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 "legendmarker_p.h"
             #include "qxyseries.h"
             #include "qxyseries_p.h"
             #include "qlegend.h"
             #include "qbarseries.h"
             #include "qpieseries.h"
             #include "qpieslice.h"
             #include "qbarset.h"
             #include "qbarset_p.h"
             #include "qareaseries.h"
             #include "qareaseries_p.h"
             #include <QPainter>
             #include <QGraphicsSceneEvent>
             #include <QGraphicsSimpleTextItem>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             LegendMarker::LegendMarker(QAbstractSeries *series, QLegend *legend) : QGraphicsObject(legend),
             m_series(series),
             m_markerRect(0,0,10.0,10.0),
             m_boundingRect(0,0,0,0),
             m_legend(legend),
             m_textItem(new QGraphicsSimpleTextItem(this)),
             m_rectItem(new QGraphicsRectItem(this))
             {
                 //setAcceptedMouseButtons(Qt::LeftButton|Qt::RightButton);
                 m_rectItem->setRect(m_markerRect);
                 updateLayout();
             }
             void LegendMarker::setPen(const QPen &pen)
             {
                 m_textItem->setPen(pen);
                 updateLayout();
             }
             QPen LegendMarker::pen() const
             {
                 return m_textItem->pen();
             }
             void LegendMarker::setBrush(const QBrush &brush)
             {
                 m_rectItem->setBrush(brush);
             }
             QBrush LegendMarker::brush() const
             {
                 return m_rectItem->brush();
             }
             void LegendMarker::setLabel(const QString name)
             {
                 m_textItem->setText(name);
                 updateLayout();
             }
             void LegendMarker::setSize(const QSize& size)
             {
                 m_markerRect = QRectF(0,0,size.width(),size.height());
             }
             QString LegendMarker::label() const
             {
                 return m_textItem->text();
             }
             void LegendMarker::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(option)
                 Q_UNUSED(widget)
                 Q_UNUSED(painter)
             }
             QRectF LegendMarker::boundingRect() const
             {
                 return m_boundingRect;
             }
             void LegendMarker::updateLayout()
             {
                 static const qreal margin = 2;
                 static const qreal space = 4;
                 const QRectF& textRect = m_textItem->boundingRect();
                 prepareGeometryChange();
                 m_boundingRect = QRectF(0,0,m_markerRect.width() + 2*margin + space + textRect.width(),qMax(m_markerRect.height()+2*margin,textRect.height()+2*margin));
                 m_textItem->setPos(m_markerRect.width() + space + margin,m_boundingRect.height()/2 - textRect.height()/2);
                 m_rectItem->setPos(margin,m_boundingRect.height()/2 - m_markerRect.height()/2);
             }
             void LegendMarker::mousePressEvent(QGraphicsSceneMouseEvent *event)
             {
                 QGraphicsObject::mousePressEvent(event);
                 emit selected();
             }
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             AreaLegendMarker::AreaLegendMarker(QAreaSeries *series,QLegend *legend) : LegendMarker(series,legend),
             m_series(series)
             {
                 QObject::connect(this, SIGNAL(selected()), series, SIGNAL(selected()));
                 QObject::connect(series->d_func(),SIGNAL(updated()), this, SLOT(updated()));
                 updated();
             }
             void AreaLegendMarker::updated()
             {
                 setBrush(m_series->brush());
                 setLabel(m_series->name());
             }
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             BarLegendMarker::BarLegendMarker(QBarSeries *barseries,QBarSet *barset, QLegend *legend) : LegendMarker(barseries,legend),
             m_barset(barset)
             {
                 QObject::connect(this, SIGNAL(selected()),barseries, SIGNAL(selected()));
                 QObject::connect(barset->d_ptr.data(), SIGNAL(updatedBars()), this, SLOT(updated()));
                 updated();
             }
             void BarLegendMarker::updated()
             {
                 setBrush(m_barset->brush());
                 setLabel(m_barset->name());
             }
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             PieLegendMarker::PieLegendMarker(QPieSeries* series,QPieSlice *pieslice, QLegend *legend) : LegendMarker(series,legend),
             m_pieslice(pieslice)
             {
-                QObject::connect(this, SIGNAL(selected()),pieslice, SIGNAL(selected()));
+                QObject::connect(this, SIGNAL(selected()),pieslice, SIGNAL(clicked()));
                 QObject::connect(pieslice, SIGNAL(changed()), this, SLOT(updated()));
                 updated();
             }
             void PieLegendMarker::updated()
             {
                 setBrush(m_pieslice->brush());
                 setLabel(m_pieslice->label());
             }
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             XYLegendMarker::XYLegendMarker(QXYSeries *series, QLegend *legend) : LegendMarker(series,legend),
             m_series(series)
             {
                 QObject::connect(this, SIGNAL(selected()), series, SIGNAL(selected()));
                 QObject::connect(series->d_func(),SIGNAL(updated()), this, SLOT(updated()));
                 updated();
             }
             void XYLegendMarker::updated()
             {
                 setLabel(m_series->name());
                 if(m_series->type()== QAbstractSeries::SeriesTypeScatter)
                 {
                     setBrush(m_series->brush());
                 }
                 else {
                     setBrush(QBrush(m_series->pen().color()));
                 }
             }
             #include "moc_legendmarker_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/legend/qlegend.cpp +12 -9

             /****************************************************************************
              **
              ** 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 "qlegend.h"
             #include "qlegend_p.h"
             #include "qabstractseries.h"
             #include "qabstractseries_p.h"
             #include "qchart_p.h"
             #include "legendmarker_p.h"
             #include "qxyseries.h"
             #include "qlineseries.h"
             #include "qareaseries.h"
             #include "qscatterseries.h"
             #include "qsplineseries.h"
             #include "qbarseries.h"
             #include "qstackedbarseries.h"
             #include "qpercentbarseries.h"
             #include "qbarset.h"
             #include "qpieseries.h"
+            #include "qpieseries_p.h"
             #include "qpieslice.h"
             #include "chartpresenter_p.h"
             #include <QPainter>
             #include <QPen>
             #include <QTimer>
             #include <QGraphicsSceneEvent>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QLegend
                 \brief part of QtCommercial chart API.
                 \mainclass
                 QLegend is a graphical object, whics displays legend of the chart. Legend state is updated by QChart, when
                 series have been changed. By default, legend is drawn by QChart, but user can set a new parent to legend and
                 handle the drawing manually.
                 User isn't supposed to create or delete legend objects, but can reference it via QChart class.
                 \image examples_percentbarchart_legend.png
                 \sa QChart
             */
             /*!
              \enum QLegend::Alignment
              This enum describes the possible position for legend inside chart.
              \value AlignmentTop
              \value AlignmentBottom
              \value AlignmentLeft
              \value AlignmentRight
              */
             /*!
              \fn qreal QLegend::minWidth() const
              Returns minimum width of the legend
              */
             /*!
              \fn qreal QLegend::minHeight() const
              Returns minimum height of the legend
              */
             /*!
              Constructs the legend object and sets the parent to \a parent
              */
             QLegend::QLegend(QChart *chart):QGraphicsWidget(chart),
             d_ptr(new QLegendPrivate(chart->d_ptr->m_presenter,this))
             {
                 setZValue(ChartPresenter::LegendZValue);
                 setFlags(QGraphicsItem::ItemClipsChildrenToShape);
                 setEnabled(false); // By default legend is disabled
                 setVisible(false);
                 QObject::connect(chart->d_ptr->m_dataset,SIGNAL(seriesAdded(QAbstractSeries *, Domain *)),d_ptr.data(),SLOT(handleSeriesAdded(QAbstractSeries *,Domain*)));
                 QObject::connect(chart->d_ptr->m_dataset,SIGNAL(seriesRemoved(QAbstractSeries *)),d_ptr.data(),SLOT(handleSeriesRemoved(QAbstractSeries *)));
             }
             /*!
                 Destroys the legend object. Legend is always owned by a QChart, so an application should never call this.
             */
             QLegend::~QLegend()
             {
             }
             /*!
              Paints the legend to given \a painter. Paremeters \a option and \a widget arent used.
              */
             void QLegend::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(option)
                 Q_UNUSED(widget)
                 if(!d_ptr->m_backgroundVisible) return;
                 painter->setOpacity(opacity());
                 painter->setPen(d_ptr->m_pen);
                 painter->setBrush(d_ptr->m_brush);
                 painter->drawRect(boundingRect());
             }
             /*!
              Bounding rect of legend.
              */
             QRectF QLegend::boundingRect() const
             {
                 return d_ptr->m_rect;
             }
             /*!
              Sets the \a brush of legend. Brush affects the background of legend.
              */
             void QLegend::setBrush(const QBrush &brush)
             {
                 if (d_ptr->m_brush != brush) {
                     d_ptr->m_brush = brush;
                     update();
                 }
             }
             /*!
              Returns the brush used by legend.
              */
             QBrush QLegend::brush() const
             {
                 return d_ptr->m_brush;
             }
             /*!
              Sets the \a pen of legend. Pen affects the legend borders.
              */
             void QLegend::setPen(const QPen &pen)
             {
                 if (d_ptr->m_pen != pen) {
                     d_ptr->m_pen = pen;
                     update();
                 }
             }
             /*!
              Returns the pen used by legend
              */
             QPen QLegend::pen() const
             {
                 return d_ptr->m_pen;
             }
             /*!
              Sets the \a alignment for legend. Legend tries to paint itself on the defined position in chart.
              \sa QLegend::Alignment
              */
             void QLegend::setAlignment(QLegend::Alignments alignment)
             {
                 if(d_ptr->m_alignment!=alignment && d_ptr->m_attachedToChart) {
                     d_ptr->m_alignment = alignment;
                     d_ptr->updateLayout();
                 }
             }
             /*!
              Returns the preferred layout for legend
              */
             QLegend::Alignments QLegend::alignment() const
             {
                 return d_ptr->m_alignment;
             }
             /*!
              Detaches the legend from chart. Chart won't change layout of the legend.
              */
             void QLegend::detachFromChart()
             {
                 d_ptr->m_attachedToChart = false;
             }
             /*!
              Attaches the legend to chart. Chart may change layout of the legend.
              */
             void QLegend::attachToChart()
             {
                 d_ptr->m_attachedToChart = true;
             }
             /*!
              Returns true, if legend is attached to chart.
              */
             bool QLegend::isAttachedToChart()
             {
                 return d_ptr->m_attachedToChart;
             }
             /*!
                 Sets the legend's scrolling offset to value defined by \a point.
             */
             void QLegend::setOffset(const QPointF& point)
             {
                 d_ptr->setOffset(point.x(),point.y());
             }
             /*!
                 Returns the legend's scrolling offset.
             */
             QPointF QLegend::offset() const
             {
                 return QPointF(d_ptr->m_offsetX,d_ptr->m_offsetY);
             }
             /*!
              Sets the visibility of legend background to \a visible
              */
             void QLegend::setBackgroundVisible(bool visible)
             {
                 if(d_ptr->m_backgroundVisible!=visible)
                 {
                     d_ptr->m_backgroundVisible=visible;
                     update();
                 }
             }
             /*!
              Returns the visibility of legend background
              */
             bool QLegend::isBackgroundVisible() const
             {
                 return d_ptr->m_backgroundVisible;
             }
             /*!
              \internal \a event see QGraphicsWidget for details
              */
             void QLegend::resizeEvent(QGraphicsSceneResizeEvent *event)
             {
                 const QRectF& rect = QRectF(QPoint(0,0),event->newSize());
                 QGraphicsWidget::resizeEvent(event);
                 if(d_ptr->m_rect != rect) {
                     d_ptr->m_rect = rect;
                     d_ptr->updateLayout();
                 }
             }
             /*!
              \internal \a event see QGraphicsWidget for details
              */
             void QLegend::hideEvent(QHideEvent *event)
             {
                 QGraphicsWidget::hideEvent(event);
                 setEnabled(false);
                 d_ptr->updateLayout();
             }
             /*!
              \internal \a event see QGraphicsWidget for details
              */
             void QLegend::showEvent(QShowEvent *event)
             {
                 QGraphicsWidget::showEvent(event);
                 setEnabled(true);
                 d_ptr->updateLayout();
             }
             qreal QLegend::minWidth() const
             {
                 return d_ptr->m_minWidth;
             }
             qreal QLegend::minHeight() const
             {
                 return d_ptr->m_minHeight;
             }
             ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QLegendPrivate::QLegendPrivate(ChartPresenter* presenter,QLegend *q):
             q_ptr(q),
             m_presenter(presenter),
             m_markers(new QGraphicsItemGroup(q)),
             m_alignment(QLegend::AlignmentTop),
             m_offsetX(0),
             m_offsetY(0),
             m_minWidth(0),
             m_minHeight(0),
             m_width(0),
             m_height(0),
             m_attachedToChart(true),
             m_backgroundVisible(false)
             {
             }
             QLegendPrivate::~QLegendPrivate()
             {
             }
             void QLegendPrivate::setOffset(qreal x, qreal y)
             {
                 switch(m_alignment) {
                     case QLegend::AlignmentTop:
                     case QLegend::AlignmentBottom: {
                         if(m_width<=m_rect.width()) return;
                         if (x != m_offsetX) {
                             m_offsetX = qBound(qreal(0), x, m_width - m_rect.width());
                             m_markers->setPos(-m_offsetX,m_rect.top());
                         }
                         break;
                     }
                     case QLegend::AlignmentLeft:
                     case QLegend::AlignmentRight: {
                         if(m_height<=m_rect.height()) return;
                         if (y != m_offsetY) {
                             m_offsetY = qBound(qreal(0), y, m_height - m_rect.height());
                             m_markers->setPos(m_rect.left(),-m_offsetY);
                         }
                         break;
                     }
                 }
             }
             void QLegendPrivate::updateLayout()
             {
                 m_offsetX=0;
                 QList<QGraphicsItem *> items = m_markers->childItems();
                 if(items.isEmpty()) return;
                 m_minWidth=0;
                 m_minHeight=0;
                 switch(m_alignment) {
                     case QLegend::AlignmentTop:
                     case QLegend::AlignmentBottom: {
                         QPointF point = m_rect.topLeft();
                         m_width = 0;
                         foreach (QGraphicsItem *item, items) {
                             item->setPos(point.x(),m_rect.height()/2 -item->boundingRect().height()/2);
                             const QRectF& rect = item->boundingRect();
                             qreal w = rect.width();
                             m_minWidth=qMax(m_minWidth,w);
                             m_minHeight=qMax(m_minHeight,rect.height());
                             m_width+=w;
                             point.setX(point.x() + w);
                         }
                         if(m_width<m_rect.width()) {
                             m_markers->setPos(m_rect.width()/2-m_width/2,m_rect.top());
                         }
                         else {
                             m_markers->setPos(m_rect.topLeft());
                         }
                         m_height=m_minHeight;
                     }
                     break;
                     case QLegend::AlignmentLeft:
                     case QLegend::AlignmentRight: {
                         QPointF point = m_rect.topLeft();
                         m_height = 0;
                         foreach (QGraphicsItem *item, items) {
                             item->setPos(point);
                             const QRectF& rect = item->boundingRect();
                             qreal h = rect.height();
                             m_minWidth=qMax(m_minWidth,rect.width());
                             m_minHeight=qMax(m_minHeight,h);
                             m_height+=h;
                             point.setY(point.y() + h);
                         }
                         if(m_height<m_rect.height()) {
                             m_markers->setPos(m_rect.left(),m_rect.height()/2-m_height/2);
                         }
                         else {
                             m_markers->setPos(m_rect.topLeft());
                         }
                         m_width=m_minWidth;
                     }
                     break;
                 }
                 m_presenter->updateLayout();
             }
             void QLegendPrivate::handleSeriesAdded(QAbstractSeries *series, Domain *domain)
             {
                 Q_UNUSED(domain)
                 QList<LegendMarker*> markers = series->d_ptr->createLegendMarker(q_ptr);
                 foreach(LegendMarker* marker , markers)
                     m_markers->addToGroup(marker);
                 if(series->type() == QAbstractSeries::SeriesTypePie)
                 {
                     QPieSeries *pieSeries = static_cast<QPieSeries *>(series);
-                    QObject::connect(pieSeries,SIGNAL(added(QList<QPieSlice*>)),this,SLOT(handleUpdateSeries()));
+                    QPieSeriesPrivate *d = QPieSeriesPrivate::seriesData(*pieSeries);
-                    QObject::connect(pieSeries,SIGNAL(removed(QList<QPieSlice*>)),this,SLOT(handleUpdateSeries()));
+                    QObject::connect(d, SIGNAL(added(QList<QPieSlice*>)), this, SLOT(handleUpdatePieSeries()));
+                    QObject::connect(d, SIGNAL(removed(QList<QPieSlice*>)), this, SLOT(handleUpdatePieSeries()));
                 }
                 updateLayout();
             }
             void QLegendPrivate::handleSeriesRemoved(QAbstractSeries *series)
             {
                 QList<QGraphicsItem *> items = m_markers->childItems();
                 foreach (QGraphicsItem *markers, items) {
                     LegendMarker *marker = static_cast<LegendMarker*>(markers);
                     if (marker->series() == series) {
                         delete marker;
                     }
                 }
                 if(series->type() == QAbstractSeries::SeriesTypePie)
                 {
                     QPieSeries *pieSeries = static_cast<QPieSeries *>(series);
-                    QObject::disconnect(pieSeries,SIGNAL(added(QList<QPieSlice*>)),this,SLOT(handleUpdateSeries()));
+                    QPieSeriesPrivate *d = QPieSeriesPrivate::seriesData(*pieSeries);
-                    QObject::disconnect(pieSeries,SIGNAL(removed(QList<QPieSlice*>)),this,SLOT(handleUpdateSeries()));
+                    QObject::disconnect(d, SIGNAL(added(QList<QPieSlice*>)), this, SLOT(handleUpdatePieSeries()));
+                    QObject::disconnect(d, SIGNAL(removed(QList<QPieSlice*>)), this, SLOT(handleUpdatePieSeries()));
                 }
                 updateLayout();
             }
-            void QLegendPrivate::handleUpdateSeries()
+            void QLegendPrivate::handleUpdatePieSeries()
             {
                 //TODO: reimplement to be optimal
-                QAbstractSeries* series = qobject_cast<QAbstractSeries *> (sender());
+                QPieSeriesPrivate* d = qobject_cast<QPieSeriesPrivate *> (sender());
-                Q_ASSERT(series);
+                Q_ASSERT(d->q_func());
-                handleSeriesRemoved(series);
+                handleSeriesRemoved(d->q_func());
-                handleSeriesAdded(series,0);
+                handleSeriesAdded(d->q_func(), 0);
             }
             #include "moc_qlegend.cpp"
             #include "moc_qlegend_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/legend/qlegend_p.h +1 -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 QLEGEND_P_H
             #define QLEGEND_P_H
             #include "qlegend.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartPresenter;
             class QAbstractSeries;
             class QLegendPrivate : public QObject
             {
                 Q_OBJECT
             public:
                 QLegendPrivate(ChartPresenter *chart,QLegend *q);
                 ~QLegendPrivate();
                 void setOffset(qreal x, qreal y);
                 void updateLayout();
             public Q_SLOTS:
                 void handleSeriesAdded(QAbstractSeries *series, Domain *domain);
                 void handleSeriesRemoved(QAbstractSeries *series);
-                void handleUpdateSeries(); //TODO remove this function
+                void handleUpdatePieSeries(); //TODO remove this function
             private:
                 QLegend *q_ptr;
                 ChartPresenter *m_presenter;
                 QGraphicsItemGroup* m_markers;
                 QLegend::Alignments m_alignment;
                 QBrush m_brush;
                 QPen m_pen;
                 QRectF m_rect;
                 qreal m_offsetX;
                 qreal m_offsetY;
                 qreal m_minWidth;
                 qreal m_minHeight;
                 qreal m_width;
                 qreal m_height;
                 bool m_attachedToChart;
                 bool m_backgroundVisible;
             friend class QLegend;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/piechart/piechartitem.cpp +9 -7

             /****************************************************************************
             **
             ** 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 "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*>)));
+                QPieSeriesPrivate *d = QPieSeriesPrivate::seriesData(*series);
-                connect(series, SIGNAL(piePositionChanged()), this, SLOT(handlePieLayoutChanged()));
+                connect(d, SIGNAL(added(QList<QPieSlice*>)), this, SLOT(handleSlicesAdded(QList<QPieSlice*>)));
-                connect(series, SIGNAL(pieSizeChanged()), this, SLOT(handlePieLayoutChanged()));
+                connect(d, SIGNAL(removed(QList<QPieSlice*>)), this, SLOT(handleSlicesRemoved(QList<QPieSlice*>)));
+                connect(d, SIGNAL(piePositionChanged()), this, SLOT(handlePieLayoutChanged()));
+                connect(d, SIGNAL(pieSizeChanged()), this, SLOT(handlePieLayoutChanged()));
                 QTimer::singleShot(0, this, SLOT(initialize())); // TODO: get rid of this
                 // Note: the following does not affect as long as the item does not have anything to paint
                 setZValue(ChartPresenter::PieSeriesZValue);
             }
             PieChartItem::~PieChartItem()
             {
                 // slices deleted automatically through QGraphicsItem
             }
             void PieChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *, QWidget *)
             {
                 Q_UNUSED(painter)
                 // TODO: paint shadows for all components
                 // - get paths from items & merge & offset and draw with shadow color?
                 //painter->setBrush(QBrush(Qt::red));
                 //painter->drawRect(m_debugRect);
             }
             void PieChartItem::initialize()
             {
                 handleSlicesAdded(m_series->slices());
             }
             void PieChartItem::handleSlicesAdded(QList<QPieSlice*> slices)
             {
                 bool isEmpty = m_slices.isEmpty();
                 presenter()->chartTheme()->decorate(m_series, presenter()->dataSet()->seriesIndex(m_series));
                 foreach (QPieSlice *s, slices) {
                     PieSliceItem* item = new PieSliceItem(this);
                     m_slices.insert(s, item);
                     connect(s, SIGNAL(changed()), this, SLOT(handleSliceChanged()));
-                    connect(item, SIGNAL(clicked(Qt::MouseButtons)), s, SIGNAL(clicked(Qt::MouseButtons)));
+                    connect(item, SIGNAL(clicked(Qt::MouseButtons)), s, SIGNAL(clicked()));
-                    connect(item, SIGNAL(hoverEnter()), s, SIGNAL(hoverEnter()));
+                    connect(item, SIGNAL(hovered(bool)), s, SIGNAL(hovered(bool)));
-                    connect(item, SIGNAL(hoverLeave()), s, SIGNAL(hoverLeave()));
                     PieSliceData data = sliceData(s);
                     if (animator())
                         animator()->addAnimation(this, s, data, isEmpty);
                     else
                         setLayout(s, data);
                 }
             }
             void PieChartItem::handleSlicesRemoved(QList<QPieSlice*> slices)
             {
                 presenter()->chartTheme()->decorate(m_series, presenter()->dataSet()->seriesIndex(m_series));
                 foreach (QPieSlice *s, slices) {
                     if (animator())
                         animator()->removeAnimation(this, s);
                     else
                         destroySlice(s);
                 }
             }
             void PieChartItem::handlePieLayoutChanged()
             {
                 PieLayout layout = calculateLayout();
                 applyLayout(layout);
                 update();
             }
             void PieChartItem::handleSliceChanged()
             {
                 QPieSlice* slice = qobject_cast<QPieSlice *>(sender());
                 Q_ASSERT(m_slices.contains(slice));
                 PieSliceData data = sliceData(slice);
                 updateLayout(slice, data);
                 update();
             }
             void PieChartItem::handleDomainChanged(qreal, qreal, qreal, qreal)
             {
                 // TODO
             }
             void PieChartItem::handleGeometryChanged(const QRectF& rect)
             {
                 prepareGeometryChange();
                 m_rect = rect;
                 handlePieLayoutChanged();
             }
             void PieChartItem::calculatePieLayout()
             {
                 // 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();
             }
             PieSliceData PieChartItem::sliceData(QPieSlice *slice)
             {
             	// TODO: This function is kid of useless now. Refactor.
                 PieSliceData sliceData = PieSliceData::data(slice);
                 sliceData.m_center = PieSliceItem::sliceCenter(m_pieCenter, m_pieRadius, slice);
                 sliceData.m_radius = m_pieRadius;
                 return sliceData;
             }
             PieLayout PieChartItem::calculateLayout()
             {
                 calculatePieLayout();
                 PieLayout layout;
                 foreach (QPieSlice* s, m_series->slices()) {
                     if (m_slices.contains(s)) // calculate layout only for those slices that are already visible
                         layout.insert(s, sliceData(s));
                 }
                 return layout;
             }
             void PieChartItem::applyLayout(const PieLayout &layout)
             {
                 if (animator())
                     animator()->updateLayout(this, layout);
                 else
                     setLayout(layout);
             }
             void PieChartItem::updateLayout(QPieSlice *slice, const PieSliceData &sliceData)
             {
                 if (animator())
                     animator()->updateLayout(this, slice, sliceData);
                 else
                     setLayout(slice, sliceData);
             }
             void PieChartItem::setLayout(const PieLayout &layout)
             {
                 foreach (QPieSlice *slice, layout.keys()) {
                     PieSliceItem *item = m_slices.value(slice);
                     Q_ASSERT(item);
                     item->setSliceData(layout.value(slice));
                     item->updateGeometry();
                     item->update();
                 }
             }
             void PieChartItem::setLayout(QPieSlice *slice, const PieSliceData &sliceData)
             {
                 // find slice
                 PieSliceItem *item = m_slices.value(slice);
                 Q_ASSERT(item);
                 item->setSliceData(sliceData);
                 item->updateGeometry();
                 item->update();
             }
             void PieChartItem::destroySlice(QPieSlice *slice)
             {
                 delete m_slices.take(slice);
             }
             #include "moc_piechartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/piesliceitem.cpp +2 -2

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "piesliceitem_p.h"
             #include "piechartitem_p.h"
             #include "qpieseries.h"
             #include "qpieslice.h"
             #include "chartpresenter_p.h"
             #include <QPainter>
             #include <qmath.h>
             #include <QGraphicsSceneEvent>
             #include <QTime>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             #define PI 3.14159265 // TODO: is this defined in some header?
             QPointF offset(qreal angle, qreal length)
             {
                 qreal dx = qSin(angle*(PI/180)) * length;
                 qreal dy = qCos(angle*(PI/180)) * length;
                 return QPointF(dx, -dy);
             }
             PieSliceItem::PieSliceItem(QGraphicsItem* parent)
                 :QGraphicsObject(parent)
             {
                 setAcceptHoverEvents(true);
                 setAcceptedMouseButtons(Qt::MouseButtonMask);
                 setZValue(ChartPresenter::PieSeriesZValue);
             }
             PieSliceItem::~PieSliceItem()
             {
             }
             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->setClipRect(parentItem()->boundingRect());
                     painter->setPen(m_data.m_labelPen);
                     painter->drawPath(m_labelArmPath);
             		// the pen color will affect the font color as well
                     painter->setFont(m_data.m_labelFont);
                     painter->drawText(m_labelTextRect.bottomLeft(), m_data.m_labelText);
                 }
             }
             void PieSliceItem::hoverEnterEvent(QGraphicsSceneHoverEvent* /*event*/)
             {
-                emit hoverEnter(); // TODO: refactor emit hover(somebooleanvalue)
+                emit hovered(true);
             }
             void PieSliceItem::hoverLeaveEvent(QGraphicsSceneHoverEvent* /*event*/)
             {
-                emit hoverLeave(); // TODO: refactor emit hover(somebooleanvalue)
+                emit hovered(false);
             }
             void PieSliceItem::mousePressEvent(QGraphicsSceneMouseEvent *event)
             {
                 emit clicked(event->buttons());
             }
             void PieSliceItem::setSliceData(PieSliceData sliceData)
             {
                 m_data = sliceData;
             }
             void PieSliceItem::updateGeometry()
             {
                 if (m_data.m_radius <= 0)
                     return;
                 prepareGeometryChange();
                 // update 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
                 m_labelTextRect = labelTextRect(m_data.m_labelFont, m_data.m_labelText);
                 // update 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
                 m_labelTextRect.moveBottomLeft(labelTextStart);
                 // update 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->endAngle() - slice->startAngle())/2);
                     qreal len = radius * slice->explodeDistanceFactor();
                     qreal dx = qSin(centerAngle*(PI/180)) * len;
                     qreal dy = -qCos(centerAngle*(PI/180)) * len;
                     point += QPointF(dx, dy);
                 }
                 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)
             {
                 // 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
                 qreal dx = qSin(angle*(PI/180)) * length;
                 qreal dy = -qCos(angle*(PI/180)) * length;
                 QPointF parm1 = start + QPointF(dx, dy);
                 // 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 +1 -2

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #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();
             public: // 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);
             Q_SIGNALS:
                 void clicked(Qt::MouseButtons buttons);
-                void hoverEnter();
+                void hovered(bool state);
-                void hoverLeave();
             public:
                 void setSliceData(PieSliceData sliceData);
                 void updateGeometry();
                 static QPointF sliceCenter(QPointF point, qreal radius, QPieSlice *slice);
                 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;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // PIESLICEITEM_H

src/piechart/qpieseries.cpp +26 -69

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "qpieseries.h"
             #include "qpieseries_p.h"
             #include "qpieslice.h"
             #include "pieslicedata_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             #include "chartanimator_p.h"
             #include "legendmarker_p.h"
             #include <QAbstractItemModel>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QPieSeries
                 \brief Pie series API for QtCommercial Charts
                 The pie series defines a pie chart which consists of pie slices which are defined as QPieSlice objects.
                 The slices can have any values as the QPieSeries will calculate its relative value to the sum of all slices.
                 The actual slice size is determined by that relative value.
                 Pie size and position on the chart is controlled by using relative values which range from 0.0 to 1.0
                 These relate to the actual chart rectangle.
                 By default the pie is defined as a full pie but it can also be a partial pie.
                 This can be done by setting a starting angle and angle span to the series.
                 Full pie is 360 degrees where 0 is at 12 a'clock.
                 See the \l {PieChart Example} {pie chart example} to learn how to create a simple pie chart.
                 \image examples_piechart.png
             */
             /*!
                 \property QPieSeries::horizontalPosition
                 \brief Defines the horizontal position of the pie.
                 The value is a relative value to the chart rectangle where:
                 \list
                 \o 0.0 is the absolute left.
                 \o 1.0 is the absolute right.
                 \endlist
                 Default value is 0.5 (center).
             */
             /*!
                 \property QPieSeries::verticalPosition
                 \brief Defines the vertical position of the pie.
                 The value is a relative value to the chart rectangle where:
                 \list
                 \o 0.0 is the absolute top.
                 \o 1.0 is the absolute bottom.
                 \endlist
                 Default value is 0.5 (center).
             */
             /*!
                 \property QPieSeries::size
                 \brief Defines the pie size.
                 The value is a relative value to the chart rectangle where:
                 \list
                 \o 0.0 is the minimum size (pie not drawn).
                 \o 1.0 is the maximum size that can fit the chart.
                 \endlist
                 Default value is 0.7.
             */
             /*!
                 \property QPieSeries::startAngle
                 \brief Defines the starting angle of the pie.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                 Default is value is 0.
             */
             /*!
                 \property QPieSeries::endAngle
                 \brief Defines the ending angle of the pie.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                 Default is value is 360.
             */
             /*!
                 Constructs a series object which is a child of \a parent.
             */
             QPieSeries::QPieSeries(QObject *parent) :
                 QAbstractSeries(*new QPieSeriesPrivate(this),parent)
             {
             }
             /*!
                 Destroys the series and its slices.
             */
             QPieSeries::~QPieSeries()
             {
                 // NOTE: d_prt destroyed by QObject
             }
             /*!
                 Returns QChartSeries::SeriesTypePie.
             */
             QAbstractSeries::QSeriesType QPieSeries::type() const
             {
                 return QAbstractSeries::SeriesTypePie;
             }
             /*!
                 Sets an array of \a slices to the series replacing the existing slices.
                 Slice ownership is passed to the series.
             */
             void QPieSeries::replace(QList<QPieSlice*> slices)
             {
                 clear();
                 append(slices);
             }
             /*!
                 Appends an array of \a slices to the series.
                 Slice ownership is passed to the series.
             */
             void QPieSeries::append(QList<QPieSlice*> slices)
             {
                 Q_D(QPieSeries);
                 foreach (QPieSlice* s, slices) {
                     s->setParent(this);
                     d->m_slices << s;
                 }
                 d->updateDerivativeData();
                 foreach (QPieSlice* s, slices) {
                     connect(s, SIGNAL(changed()), d, SLOT(sliceChanged()));
-                    connect(s, SIGNAL(clicked(Qt::MouseButtons)), d, SLOT(sliceClicked(Qt::MouseButtons)));
+                    connect(s, SIGNAL(clicked()), d, SLOT(sliceClicked()));
-                    connect(s, SIGNAL(hoverEnter()), d, SLOT(sliceHoverEnter()));
+                    connect(s, SIGNAL(hovered(bool)), d, SLOT(sliceHovered(bool)));
-                    connect(s, SIGNAL(hoverLeave()), d, SLOT(sliceHoverLeave()));
                 }
-                emit added(slices);
+                emit d->added(slices);
             }
             /*!
                 Appends a single \a slice to the series.
                 Slice ownership is passed to the series.
             */
             void QPieSeries::append(QPieSlice* slice)
             {
                 append(QList<QPieSlice*>() << slice);
             }
             /*!
                 Appends a single \a slice to the series and returns a reference to the series.
                 Slice ownership is passed to the series.
             */
             QPieSeries& QPieSeries::operator << (QPieSlice* slice)
             {
                 append(slice);
                 return *this;
             }
             /*!
                 Appends a single slice to the series with give \a value and \a name.
                 Slice ownership is passed to the series.
             */
             QPieSlice* QPieSeries::append(qreal value, QString name)
             {
                 QPieSlice* slice = new QPieSlice(value, name);
                 append(slice);
                 return slice;
             }
             /*!
                 Inserts a single \a slice to the series before the slice at \a index position.
                 Slice ownership is passed to the series.
             */
             void QPieSeries::insert(int index, QPieSlice* slice)
             {
                 Q_D(QPieSeries);
                 Q_ASSERT(index <= d->m_slices.count());
                 slice->setParent(this);
                 d->m_slices.insert(index, slice);
                 d->updateDerivativeData();
                 connect(slice, SIGNAL(changed()), d, SLOT(sliceChanged()));
-                connect(slice, SIGNAL(clicked(Qt::MouseButtons)), d, SLOT(sliceClicked(Qt::MouseButtons)));
+                connect(slice, SIGNAL(clicked()), d, SLOT(sliceClicked()));
-                connect(slice, SIGNAL(hoverEnter()), d, SLOT(sliceHoverEnter()));
+                connect(slice, SIGNAL(hovered(bool)), d, SLOT(sliceHovered(bool)));
-                connect(slice, SIGNAL(hoverLeave()), d, SLOT(sliceHoverLeave()));
-                emit added(QList<QPieSlice*>() << slice);
+                emit d->added(QList<QPieSlice*>() << slice);
             }
             /*!
                 Removes a single \a slice from the series and deletes the slice.
                 Do not reference the pointer after this call.
             */
             void QPieSeries::remove(QPieSlice* slice)
             {
                 Q_D(QPieSeries);
                 if (!d->m_slices.removeOne(slice)) {
                     Q_ASSERT(0); // TODO: how should this be reported?
                     return;
                 }
                 d->updateDerivativeData();
-                emit removed(QList<QPieSlice*>() << slice);
+                emit d->removed(QList<QPieSlice*>() << slice);
                 delete slice;
                 slice = 0;
             }
             /*!
                 Clears all slices from the series.
             */
             void QPieSeries::clear()
             {
                 Q_D(QPieSeries);
                 if (d->m_slices.count() == 0)
                     return;
                 QList<QPieSlice*> slices = d->m_slices;
                 foreach (QPieSlice* s, d->m_slices) {
                     d->m_slices.removeOne(s);
                     delete s;
                 }
                 d->updateDerivativeData();
-                emit removed(slices);
+                emit d->removed(slices);
             }
             /*!
                 returns the number of the slices in this series.
             */
             int QPieSeries::count() const
             {
                 Q_D(const QPieSeries);
                 return d->m_slices.count();
             }
             /*!
                 Returns true is the series is empty.
             */
             bool QPieSeries::isEmpty() const
             {
                 Q_D(const QPieSeries);
                 return d->m_slices.isEmpty();
             }
             /*!
                 Returns a list of slices that belong to this series.
             */
             QList<QPieSlice*> QPieSeries::slices() const
             {
                 Q_D(const QPieSeries);
                 return d->m_slices;
             }
             void QPieSeries::setHorizontalPosition(qreal relativePosition)
             {
                 Q_D(QPieSeries);
                 if (d->setRealValue(d->m_pieRelativeHorPos, relativePosition, 1.0))
-                    emit piePositionChanged();
+                    emit d->piePositionChanged();
             }
             void QPieSeries::setVerticalPosition(qreal relativePosition)
             {
                 Q_D(QPieSeries);
                 if (d->setRealValue(d->m_pieRelativeVerPos, relativePosition, 1.0))
-                    emit piePositionChanged();
+                    emit d->piePositionChanged();
             }
             qreal QPieSeries::horizontalPosition() const
             {
                 Q_D(const QPieSeries);
                 return d->m_pieRelativeHorPos;
             }
             qreal QPieSeries::verticalPosition() const
             {
                 Q_D(const QPieSeries);
                 return d->m_pieRelativeVerPos;
             }
             void QPieSeries::setPieSize(qreal relativeSize)
             {
                 Q_D(QPieSeries);
                 if (d->setRealValue(d->m_pieRelativeSize, relativeSize, 1.0))
-                    emit pieSizeChanged();
+                    emit d->pieSizeChanged();
             }
             qreal QPieSeries::pieSize() const
             {
                 Q_D(const QPieSeries);
                 return d->m_pieRelativeSize;
             }
             void QPieSeries::setPieStartAngle(qreal angle)
             {
                 Q_D(QPieSeries);
                 if (d->setRealValue(d->m_pieStartAngle, angle, d->m_pieEndAngle))
                     d->updateDerivativeData();
             }
             qreal QPieSeries::pieStartAngle() const
             {
                 Q_D(const QPieSeries);
                 return d->m_pieStartAngle;
             }
             /*!
                 Sets the end angle of the pie.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                 \a angle must be greater than start angle.
                 \sa pieEndAngle(), pieStartAngle(), setPieStartAngle()
             */
             void QPieSeries::setPieEndAngle(qreal angle)
             {
                 Q_D(QPieSeries);
                 if (d->setRealValue(d->m_pieEndAngle, angle, 360.0, d->m_pieStartAngle))
                     d->updateDerivativeData();
             }
             /*!
                 Returns the end angle of the pie.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                 \sa setPieEndAngle(), pieStartAngle(), setPieStartAngle()
             */
             qreal QPieSeries::pieEndAngle() const
             {
                 Q_D(const QPieSeries);
                 return d->m_pieEndAngle;
             }
             /*!
                 Sets the all the slice labels \a visible or invisible.
                 \sa QPieSlice::isLabelVisible(), QPieSlice::setLabelVisible()
             */
             void QPieSeries::setLabelsVisible(bool visible)
             {
                 Q_D(QPieSeries);
                 foreach (QPieSlice* s, d->m_slices)
                     s->setLabelVisible(visible);
             }
             /*!
                 Returns the sum of all slice values in this series.
                 \sa QPieSlice::value(), QPieSlice::setValue(), QPieSlice::percentage()
             */
             qreal QPieSeries::sum() const
             {
                 Q_D(const QPieSeries);
                 return d->m_sum;
             }
             /*!
-                \fn void QPieSeries::clicked(QPieSlice* slice, Qt::MouseButtons buttons)
+                \fn void QPieSeries::clicked(QPieSlice* slice)
-                This signal is emitted when a \a slice has been clicked with mouse \a buttons.
+                This signal is emitted when a \a slice has been clicked.
                 \sa QPieSlice::clicked()
             */
             /*!
-                \fn void QPieSeries::hoverEnter(QPieSlice* slice)
+                \fn void QPieSeries::hovered(QPieSlice* slice, bool state)
-                This signal is emitted when user has hovered over a \a slice.
+                This signal is emitted when user has hovered over or away from the \a slice.
-                \sa QPieSlice::hoverEnter()
+                \a state is true when user has hovered over the slice and false when hover has moved away from the slice.
-            */
-            /*!
-                \fn void QPieSeries::hoverLeave(QPieSlice* slice)
-                This signal is emitted when user has hovered away from a \a slice.
-                \sa QPieSlice::hoverLeave()
-            */
-            /*!
-                \fn void QPieSeries::added(QList<QPieSlice*> slices)
-                This signal is emitted when \a slices has been added to the series.
-                \sa append(), insert()
+                \sa QPieSlice::hovered()
-            */
-            /*!
-                \fn void QPieSeries::removed(QList<QPieSlice*> slices)
-                This signal is emitted when \a slices has been removed from the series.
-                \sa remove(), clear()
-            */
-            /*!
-                \fn void QPieSeries::piePositionChanged()
-                This signal is emitted when pie position has changed.
-                \sa verticalPosition(), setVerticalPosition(), horizontalPosition(), setHorizontalPosition()
-            */
-            /*!
-                \fn void QPieSeries::pieSizeChanged()
-                This signal is emitted when pie size has changed.
-                \sa pieSize(), setPieSize()
             */
             /*!
                  \fn bool QPieSeries::setModel(QAbstractItemModel *model)
                  Sets the \a model to be used as a data source
              */
             bool QPieSeries::setModel(QAbstractItemModel* model)
             {
                 Q_D(QPieSeries);
                 // disconnect signals from old model
                 if(d->m_model)
                 {
                     disconnect(d->m_model, 0, this, 0);
                     d->m_mapValues = -1;
                     d->m_mapLabels = -1;
                     d->m_mapOrientation = Qt::Vertical;
                 }
                 // set new model
                 if(model)
                 {
                     d->m_model = model;
                     return true;
                 }
                 else
                 {
                     d->m_model = 0;
                     return false;
                 }
             }
             /*!
                  \fn bool QPieSeries::setModelMapping(int modelValuesLine, int modelLabelsLine, Qt::Orientation orientation)
                  Sets column/row specified by \a modelValuesLine to be used as a list of pie slice values for the pie.
                  Parameter \a modelValuesLine indicates the column/row where the values for the pie slices are located in the model.
                  Parameter \a modelLabelsLine indicates the column/row where the labels for the pie slices are located in the model.
                  The \a orientation parameter specifies whether the data is in columns or in rows.
              */
             void QPieSeries::setModelMapping(int modelValuesLine, int modelLabelsLine, Qt::Orientation orientation)
             {
                 Q_D(QPieSeries);
                 if (d->m_model == 0)
                     return;
                 d->m_mapValues = modelValuesLine;
                 d->m_mapLabels = modelLabelsLine;
                 d->m_mapOrientation = orientation;
                 // connect the signals
                 if (d->m_mapOrientation == Qt::Vertical) {
                     connect(d->m_model, SIGNAL(dataChanged(QModelIndex,QModelIndex)), d, SLOT(modelUpdated(QModelIndex,QModelIndex)));
                     connect(d->m_model, SIGNAL(rowsInserted(QModelIndex,int,int)), d, SLOT(modelDataAdded(QModelIndex,int,int)));
                     connect(d->m_model, SIGNAL(rowsRemoved(QModelIndex,int,int)), d, SLOT(modelDataRemoved(QModelIndex,int,int)));
                 } else {
                     connect(d->m_model, SIGNAL(dataChanged(QModelIndex,QModelIndex)), d, SLOT(modelUpdated(QModelIndex,QModelIndex)));
                     connect(d->m_model, SIGNAL(columnsInserted(QModelIndex,int,int)), d, SLOT(modelDataAdded(QModelIndex,int,int)));
                     connect(d->m_model, SIGNAL(columnsRemoved(QModelIndex,int,int)), d, SLOT(modelDataRemoved(QModelIndex,int,int)));
                 }
                 // create the initial slices set
                 if (d->m_mapOrientation == Qt::Vertical) {
                     for (int i = 0; i < d->m_model->rowCount(); i++)
                         append(d->m_model->data(d->m_model->index(i, d->m_mapValues), Qt::DisplayRole).toDouble(), d->m_model->data(d->m_model->index(i, d->m_mapLabels), Qt::DisplayRole).toString());
                 } else {
                     for (int i = 0; i < d->m_model->columnCount(); i++)
                         append(d->m_model->data(d->m_model->index(d->m_mapValues, i), Qt::DisplayRole).toDouble(), d->m_model->data(d->m_model->index(d->m_mapLabels, i), Qt::DisplayRole).toString());
                 }
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QPieSeriesPrivate::QPieSeriesPrivate(QPieSeries *parent) :
                 QAbstractSeriesPrivate(parent),
                 m_pieRelativeHorPos(0.5),
                 m_pieRelativeVerPos(0.5),
                 m_pieRelativeSize(0.7),
                 m_pieStartAngle(0),
                 m_pieEndAngle(360),
                 m_sum(0),
                 m_mapValues(0),
                 m_mapLabels(0),
                 m_mapOrientation(Qt::Horizontal)
             {
             }
             QPieSeriesPrivate::~QPieSeriesPrivate()
             {
             }
             void QPieSeriesPrivate::updateDerivativeData()
             {
                 m_sum = 0;
                 // nothing to do?
                 if (m_slices.count() == 0)
                     return;
                 // calculate sum of all slices
                 foreach (QPieSlice* s, m_slices)
                     m_sum += s->value();
                 // nothing to show..
                 if (qFuzzyIsNull(m_sum))
                     return;
                 // update slice attributes
                 qreal sliceAngle = m_pieStartAngle;
                 qreal pieSpan = m_pieEndAngle - m_pieStartAngle;
                 QVector<QPieSlice*> changed;
                 foreach (QPieSlice* s, m_slices) {
                     PieSliceData data = PieSliceData::data(s);
                     data.m_percentage = s->value() / m_sum;
                     data.m_angleSpan = pieSpan * data.m_percentage;
                     data.m_startAngle = sliceAngle;
                     sliceAngle += data.m_angleSpan;
                     if (PieSliceData::data(s) != data) {
                         PieSliceData::data(s) = data;
                         changed << s;
                     }
                 }
                 // emit signals
                 foreach (QPieSlice* s, changed)
                     PieSliceData::data(s).emitChangedSignal(s);
             }
-            void QPieSeriesPrivate::sliceChanged()
+            QPieSeriesPrivate* QPieSeriesPrivate::seriesData(QPieSeries &series)
             {
-                Q_ASSERT(m_slices.contains(qobject_cast<QPieSlice *>(sender())));
+                return series.d_func();
-                updateDerivativeData();
             }
-            void QPieSeriesPrivate::sliceClicked(Qt::MouseButtons buttons)
+            void QPieSeriesPrivate::sliceChanged()
             {
-                QPieSlice* slice = qobject_cast<QPieSlice *>(sender());
+                Q_ASSERT(m_slices.contains(qobject_cast<QPieSlice *>(sender())));
-                Q_ASSERT(m_slices.contains(slice));
+                updateDerivativeData();
-                Q_Q(QPieSeries);
-                emit q->clicked(slice, buttons);
             }
-            void QPieSeriesPrivate::sliceHoverEnter()
+            void QPieSeriesPrivate::sliceClicked()
             {
                 QPieSlice* slice = qobject_cast<QPieSlice *>(sender());
                 Q_ASSERT(m_slices.contains(slice));
                 Q_Q(QPieSeries);
-                emit q->hoverEnter(slice);
+                emit q->clicked(slice);
             }
-            void QPieSeriesPrivate::sliceHoverLeave()
+            void QPieSeriesPrivate::sliceHovered(bool state)
             {
                 QPieSlice* slice = qobject_cast<QPieSlice *>(sender());
                 Q_ASSERT(m_slices.contains(slice));
                 Q_Q(QPieSeries);
-                emit q->hoverLeave(slice);
+                emit q->hovered(slice, state);
             }
             void QPieSeriesPrivate::modelUpdated(QModelIndex topLeft, QModelIndex bottomRight)
             {
                 Q_UNUSED(bottomRight)
                 if (m_mapOrientation == Qt::Vertical)
                 {
                     if (topLeft.column() == m_mapValues)
                         if (m_mapValues == m_mapLabels)
                         {
                             m_slices.at(topLeft.row())->setValue(m_model->data(topLeft, Qt::DisplayRole).toDouble());
                             m_slices.at(topLeft.row())->setLabel(m_model->data(topLeft, Qt::DisplayRole).toString());
                         }
                         else
                         {
                             m_slices.at(topLeft.row())->setValue(m_model->data(topLeft, Qt::DisplayRole).toDouble());
                         }
                     else if (topLeft.column() == m_mapLabels)
                         m_slices.at(topLeft.row())->setLabel(m_model->data(topLeft, Qt::DisplayRole).toString());
                 }
                 else
                 {
                     if (topLeft.row() == m_mapValues)
                         if (m_mapValues == m_mapLabels)
                         {
                             m_slices.at(topLeft.column())->setValue(m_model->data(topLeft, Qt::DisplayRole).toDouble());
                             m_slices.at(topLeft.column())->setLabel(m_model->data(topLeft, Qt::DisplayRole).toString());
                         }
                         else
                         {
                             m_slices.at(topLeft.column())->setValue(m_model->data(topLeft, Qt::DisplayRole).toDouble());
                         }
                     else if (topLeft.row() == m_mapLabels)
                         m_slices.at(topLeft.column())->setLabel(m_model->data(topLeft, Qt::DisplayRole).toString());
                 }
             }
             void QPieSeriesPrivate::modelDataAdded(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent)
                 Q_UNUSED(end)
                 Q_Q(QPieSeries);
                 QPieSlice* newSlice = new QPieSlice;
                 newSlice->setLabelVisible(true);
                 if (m_mapOrientation == Qt::Vertical)
                 {
                     newSlice->setValue(m_model->data(m_model->index(start, m_mapValues), Qt::DisplayRole).toDouble());
                     newSlice->setLabel(m_model->data(m_model->index(start, m_mapLabels), Qt::DisplayRole).toString());
                 }
                 else
                 {
                     newSlice->setValue(m_model->data(m_model->index(m_mapValues, start), Qt::DisplayRole).toDouble());
                     newSlice->setLabel(m_model->data(m_model->index(m_mapLabels, start), Qt::DisplayRole).toString());
                 }
                 q->insert(start, newSlice);
             }
             void QPieSeriesPrivate::modelDataRemoved(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent)
                 Q_UNUSED(end)
                 Q_Q(QPieSeries);
                 q->remove(m_slices.at(start));
             }
             bool QPieSeriesPrivate::setRealValue(qreal &value, qreal newValue, qreal max, qreal min)
             {
                 // Remove rounding errors
                 qreal roundedValue = newValue;
                 if (qFuzzyIsNull(min) && qFuzzyIsNull(newValue))
                     roundedValue = 0.0;
                 else if (qFuzzyCompare(newValue, max))
                     roundedValue = max;
                 else if (qFuzzyCompare(newValue, min))
                     roundedValue = min;
                 // Check if the position is valid after removing the rounding errors
                 if (roundedValue < min || roundedValue > max) {
                     qWarning("QPieSeries: Illegal value");
                     return false;
                 }
                 if (!qFuzzyIsNull(value - roundedValue)) {
                     value = roundedValue;
                     return true;
                 }
                 // The change was so small it is considered a rounding error
                 return false;
             }
             void QPieSeriesPrivate::scaleDomain(Domain& domain)
             {
                 Q_UNUSED(domain);
             #ifndef QT_NO_DEBUG
                 qWarning() << __FILE__<<__FUNCTION__<<"not implemented";
             #endif
             }
             Chart* QPieSeriesPrivate::createGraphics(ChartPresenter* presenter)
             {
                 Q_Q(QPieSeries);
                 PieChartItem* pie = new PieChartItem(q,presenter);
                 if(presenter->animationOptions().testFlag(QChart::SeriesAnimations)) {
                     presenter->animator()->addAnimation(pie);
                 }
                 presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
                 return pie;
             }
             QList<LegendMarker*> QPieSeriesPrivate::createLegendMarker(QLegend* legend)
             {
                 Q_Q(QPieSeries);
                 QList<LegendMarker*> markers;
                 foreach(QPieSlice* slice, q->slices()) {
                     PieLegendMarker* marker = new PieLegendMarker(q,slice,legend);
                     markers << marker;
                 }
                 return markers;
             }
             #include "moc_qpieseries.cpp"
             #include "moc_qpieseries_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/qpieseries.h +7 -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$
             **
             ****************************************************************************/
             #ifndef PIESERIES_H
             #define PIESERIES_H
             #include <qabstractseries.h>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QPieSeriesPrivate;
             class QPieSlice;
             class QTCOMMERCIALCHART_EXPORT QPieSeries : public QAbstractSeries
             {
                 Q_OBJECT
                 Q_PROPERTY(qreal horizontalPosition READ horizontalPosition WRITE setHorizontalPosition)
                 Q_PROPERTY(qreal verticalPosition READ verticalPosition WRITE setVerticalPosition)
                 Q_PROPERTY(qreal size READ pieSize WRITE setPieSize)
                 Q_PROPERTY(qreal startAngle READ pieStartAngle WRITE setPieStartAngle)
                 Q_PROPERTY(qreal endAngle READ pieEndAngle WRITE setPieEndAngle)
             public:
                 explicit QPieSeries(QObject *parent = 0);
                 virtual ~QPieSeries();
-            public: // from QChartSeries
                 QSeriesType type() const;
-            public:
-                // slice setters
                 void append(QPieSlice* slice);
                 void append(QList<QPieSlice*> slices);
+                QPieSeries& operator << (QPieSlice* slice);
+                QPieSlice* append(qreal value, QString name);
                 void insert(int index, QPieSlice* slice);
                 void replace(QList<QPieSlice*> slices);
                 void remove(QPieSlice* slice);
                 void clear();
-                // slice getters
                 QList<QPieSlice*> slices() const;
-                // calculated data
                 int count() const;
                 bool isEmpty() const;
                 qreal sum() const;
-                // pie customization
                 void setHorizontalPosition(qreal relativePosition);
                 qreal horizontalPosition() const;
                 void setVerticalPosition(qreal relativePosition);
                 qreal verticalPosition() const;
                 void setPieSize(qreal relativeSize);
                 qreal pieSize() const;
                 void setPieStartAngle(qreal startAngle);
                 qreal pieStartAngle() const;
                 void setPieEndAngle(qreal endAngle);
                 qreal pieEndAngle() const;
-                // convenience function
-                QPieSeries& operator << (QPieSlice* slice);
-                QPieSlice* append(qreal value, QString name);
                 void setLabelsVisible(bool visible = true);
-                // data from model
                 bool setModel(QAbstractItemModel* model);
                 void setModelMapping(int modelValuesLine, int modelLabelsLine, Qt::Orientation orientation = Qt::Vertical);
             Q_SIGNALS:
-                void clicked(QPieSlice* slice, Qt::MouseButtons buttons);
+                void clicked(QPieSlice* slice);
-                void hoverEnter(QPieSlice* slice);
+                void hovered(QPieSlice* slice, bool state);
-                void hoverLeave(QPieSlice* slice);
-                void added(QList<QPieSlice*> slices);
-                void removed(QList<QPieSlice*> slices);
-                void piePositionChanged();
-                void pieSizeChanged();
             private:
                 Q_DECLARE_PRIVATE(QPieSeries)
                 Q_DISABLE_COPY(QPieSeries)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // PIESERIES_H

src/piechart/qpieseries_p.h +15 -5

             /****************************************************************************
             **
             ** 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 QPIESERIES_P_H
             #define QPIESERIES_P_H
             #include "qpieseries.h"
             #include "qabstractseries_p.h"
             class QModelIndex;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
+            class QLegendPrivate;
             class QPieSeriesPrivate : public QAbstractSeriesPrivate
             {
                 Q_OBJECT
             public:
                 QPieSeriesPrivate(QPieSeries *parent);
                 ~QPieSeriesPrivate();
                 void scaleDomain(Domain& domain);
-                Chart* createGraphics(ChartPresenter* presenter);
+                Chart* createGraphics(ChartPresenter *presenter);
-                QList<LegendMarker*> createLegendMarker(QLegend* legend);
+                QList<LegendMarker*> createLegendMarker(QLegend *legend);
                 void updateDerivativeData();
+                static QPieSeriesPrivate* seriesData(QPieSeries &series);
+            Q_SIGNALS:
+                void added(QList<QPieSlice*> slices);
+                void removed(QList<QPieSlice*> slices);
+                void piePositionChanged();
+                void pieSizeChanged();
             public Q_SLOTS:
                 void sliceChanged();
-                void sliceClicked(Qt::MouseButtons buttons);
+                void sliceClicked();
-                void sliceHoverEnter();
+                void sliceHovered(bool state);
-                void sliceHoverLeave();
                 void modelUpdated(QModelIndex topLeft, QModelIndex bottomRight);
                 void modelDataAdded(QModelIndex parent, int start, int end);
                 void modelDataRemoved(QModelIndex parent, int start, int end);
                 bool setRealValue(qreal &value, qreal newValue, qreal max, qreal min = 0.0);
             public:
                 QList<QPieSlice*> m_slices;
                 qreal m_pieRelativeHorPos;
                 qreal m_pieRelativeVerPos;
                 qreal m_pieRelativeSize;
                 qreal m_pieStartAngle;
                 qreal m_pieEndAngle;
                 qreal m_sum;
                 // model map
                 int m_mapValues;
                 int m_mapLabels;
                 Qt::Orientation m_mapOrientation;
             private:
+                friend class QLegendPrivate;
                 Q_DECLARE_PUBLIC(QPieSeries)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QPIESERIES_P_H

src/piechart/qpieslice.cpp +5 -18

             /****************************************************************************
             **
             ** 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 "pieslicedata_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. Even if the theme is
                 changed users settings will persist.
                 To enable user interaction customization with the slices some basic signals
                 are provided about clicking and hovering.
             */
             /*!
                 \property QPieSlice::label
                 Label of the slice.
             */
             /*!
                 \property QPieSlice::value
                 Value of the slice.
                 \sa percentage(), QPieSeries::sum()
             */
             /*!
                 Constructs an empty slice with a \a parent.
                 \sa QPieSeries::append(), QPieSeries::insert(), QPieSeries::replace()
             */
             QPieSlice::QPieSlice(QObject *parent)
                 :QObject(parent),
                 d(new PieSliceData())
             {
             }
             /*!
                 Constructs an empty slice with given \a value, \a label and a \a parent.
                 \sa QPieSeries::append(), QPieSeries::insert(), QPieSeries::replace()
             */
             QPieSlice::QPieSlice(qreal value, QString label, QObject *parent)
                 :QObject(parent),
                 d(new PieSliceData())
             {
                 d->m_value = value;
                 d->m_labelText = label;
             }
             /*!
                 Destroys the slice.
                 User should not delete the slice if it has been added to the series.
             */
             QPieSlice::~QPieSlice()
             {
                 delete d;
             }
             /*!
                 Gets the value of the slice.
                 Note that all values in the series
                 \sa setValue()
             */
             qreal QPieSlice::value() const
             {
                 return d->m_value;
             }
             /*!
                 Gets the label of the slice.
                 \sa setLabel()
             */
             QString QPieSlice::label() const
             {
                 return d->m_labelText;
             }
             /*!
                 Returns true if label is set as visible.
                 \sa setLabelVisible()
             */
             bool QPieSlice::isLabelVisible() const
             {
                 return d->m_isLabelVisible;
             }
             /*!
                 Returns true if slice is exloded from the pie.
                 \sa setExploded(), explodeDistanceFactor(), setExplodeDistanceFactor()
             */
             bool QPieSlice::isExploded() const
             {
                 return d->m_isExploded;
             }
             /*!
                 Returns the explode distance factor.
                 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 setExplodeDistanceFactor(), isExploded(), setExploded()
             */
             qreal QPieSlice::explodeDistanceFactor() const
             {
                 return d->m_explodeDistanceFactor;
             }
             /*!
                 Returns the percentage of this slice compared to the sum of all slices in the same series.
                 The returned value ranges from 0 to 1.0.
                 Updated internally after the slice is added to the series.
                 \sa QPieSeries::sum()
             */
             qreal QPieSlice::percentage() const
             {
                 return d->m_percentage;
             }
             /*!
                 Returns 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 internally after the slice is added to the series.
             */
             qreal QPieSlice::startAngle() const
             {
                 return d->m_startAngle;
             }
             /*!
                 Returns the end angle of this slice in the series it belongs to.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                 Updated internally after the slice is added to the series.
             */
             qreal QPieSlice::endAngle() const
             {
                 return d->m_startAngle + d->m_angleSpan;
             }
             /*!
                 Returns the pen used to draw this slice.
                 \sa setPen()
             */
             QPen QPieSlice::pen() const
             {
                 return d->m_slicePen;
             }
             /*!
                 Returns the brush used to draw this slice.
                 \sa setBrush()
             */
             QBrush QPieSlice::brush() const
             {
                 return d->m_sliceBrush;
             }
             /*!
                 Returns the pen used to draw the label in this slice.
                 \sa setLabelPen()
             */
             QPen QPieSlice::labelPen() const
             {
                 return d->m_labelPen;
             }
             /*!
                 Returns the font used to draw label in this slice.
                 \sa setLabelFont()
             */
             QFont QPieSlice::labelFont() const
             {
                 return d->m_labelFont;
             }
             /*!
                 Gets the label arm length factor.
                 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 setLabelArmLengthFactor()
             */
             qreal QPieSlice::labelArmLengthFactor() const
             {
                 return d->m_labelArmLengthFactor;
             }
             /*!
-                \fn void QPieSlice::clicked(Qt::MouseButtons buttons)
+                \fn void QPieSlice::clicked()
                 This signal is emitted when user has clicked the slice.
-                Parameter \a buttons hold the information about the clicked mouse buttons.
                 \sa QPieSeries::clicked()
             */
             /*!
-                \fn void QPieSlice::hoverEnter()
+                \fn void QPieSlice::hovered(bool state)
-                This signal is emitted when user has hovered over the slice.
+                This signal is emitted when user has hovered over or away from the slice.
-                \sa QPieSeries::hoverEnter()
+                \a state is true when user has hovered over the slice and false when hover has moved away from the slice.
-            */
-            /*!
-                \fn void QPieSlice::hoverLeave()
-                This signal is emitted when user has hovered away from the slice.
-                \sa QPieSeries::hoverLeave()
+                \sa QPieSeries::hovered()
             */
             /*!
                 \fn void QPieSlice::changed()
                 This signal emitted when something has changed in the slice.
             */
             /*!
-                \fn void QPieSlice::selected()
-                This signal emitted when this slice has been clicked in the legend.
-            */
-            /*!
                 Sets the \a value of this slice.
                 \sa value()
             */
             void QPieSlice::setValue(qreal value)
             {
                 if (!qFuzzyIsNull(d->m_value - value)) {
                     d->m_value = value;
                     emit changed();
                 }
             }
             /*!
                 Sets the \a label of the slice.
                 \sa label()
             */
             void QPieSlice::setLabel(QString label)
             {
                 if (d->m_labelText != label) {
                     d->m_labelText = label;
                     emit changed();
                 }
             }
             /*!
                 Sets the label \a visible in this slice.
                 \sa isLabelVisible(), QPieSeries::setLabelsVisible()
             */
             void QPieSlice::setLabelVisible(bool visible)
             {
                 if (d->m_isLabelVisible != visible) {
                     d->m_isLabelVisible = visible;
                     emit changed();
                 }
             }
             /*!
                 Sets this slices \a exploded state.
                 If the slice is exploded it is moved away from the pie center. The distance is defined by the explode distance factor.
                 \sa isExploded(), explodeDistanceFactor(), setExplodeDistanceFactor()
             */
             void QPieSlice::setExploded(bool exploded)
             {
                 if (d->m_isExploded != exploded) {
                     d->m_isExploded = exploded;
                     emit changed();
                 }
             }
             /*!
                 Sets the explode distance \a factor.
                 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 explodeDistanceFactor(), isExploded(), setExploded()
             */
             void QPieSlice::setExplodeDistanceFactor(qreal factor)
             {
                 if (!qFuzzyIsNull(d->m_explodeDistanceFactor - factor)) {
                     d->m_explodeDistanceFactor = factor;
                     emit changed();
                 }
             }
             /*!
                 Sets the \a pen used to draw this slice.
                 Overrides the pen set by the theme.
                 \sa pen()
             */
             void QPieSlice::setPen(const QPen &pen)
             {
                 if (d->m_slicePen != pen) {
                     d->m_slicePen = pen;
                     d->m_slicePen.setThemed(false);
                     emit changed();
                 }
             }
             /*!
                 Sets the \a brush used to draw this slice.
                 Overrides the brush set by the theme.
                 \sa brush()
             */
             void QPieSlice::setBrush(const QBrush &brush)
             {
                 if (d->m_sliceBrush != brush) {
                     d->m_sliceBrush = brush;
                     d->m_sliceBrush.setThemed(false);
                     emit changed();
                 }
             }
             /*!
                 Sets the \a pen used to draw the label in this slice.
                 Overrides the pen set by the theme.
                 \sa labelPen()
             */
             void QPieSlice::setLabelPen(const QPen &pen)
             {
                 if (d->m_labelPen != pen) {
                     d->m_labelPen = pen;
                     d->m_labelPen.setThemed(false);
                     emit changed();
                 }
             }
             /*!
                 Sets the \a font used to draw the label in this slice.
                 Overrides the font set by the theme.
                 \sa labelFont()
             */
             void QPieSlice::setLabelFont(const QFont &font)
             {
                 if (d->m_labelFont != font) {
                     d->m_labelFont = font;
                     d->m_labelFont.setThemed(false);
                     emit changed();
                 }
             }
             /*!
                 Sets the label arm length \a factor.
                 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 labelArmLengthFactor()
             */
             void QPieSlice::setLabelArmLengthFactor(qreal factor)
             {
                 if (!qFuzzyIsNull(d->m_labelArmLengthFactor - factor)) {
                     d->m_labelArmLengthFactor = factor;
                     emit changed();
                 }
             }
             QTCOMMERCIALCHART_END_NAMESPACE
             QTCOMMERCIALCHART_USE_NAMESPACE
             #include "moc_qpieslice.cpp"

src/piechart/qpieslice.h +7 -11

             /****************************************************************************
             **
             ** 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 PieSliceData;
             class QTCOMMERCIALCHART_EXPORT QPieSlice : public QObject
             {
                 Q_OBJECT
                 Q_PROPERTY(QString label READ label WRITE setLabel NOTIFY changed)
                 Q_PROPERTY(qreal value READ value WRITE setValue NOTIFY changed)
             public:
                 explicit QPieSlice(QObject *parent = 0);
                 QPieSlice(qreal value, QString label, QObject *parent = 0);
                 virtual ~QPieSlice();
-                // data
                 void setValue(qreal value);
                 qreal value() const;
                 void setLabel(QString label);
                 QString label() const;
                 void setLabelVisible(bool visible = true);
                 bool isLabelVisible() const;
                 void setExploded(bool exploded = true);
                 bool isExploded() const;
-                // generated data
-                qreal percentage() const;
-                qreal startAngle() const;
-                qreal endAngle() const;
-                // customization
                 void setPen(const QPen &pen);
                 QPen pen() const;
                 void setBrush(const QBrush &brush);
                 QBrush brush() const;
                 void setLabelPen(const QPen &pen);
                 QPen labelPen() const;
                 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 endAngle() const;
             Q_SIGNALS:
-                void clicked(Qt::MouseButtons buttons);
+                void clicked();
-                void hoverEnter();
+                void hovered(bool state);
-                void hoverLeave();
                 void changed();
-                void selected();
             private:
                 friend class PieSliceData;
                 PieSliceData * const d;
                 Q_DISABLE_COPY(QPieSlice)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QPIESLICE_H

General Comments 0

Write
Preview

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

No TODOs yet

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

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