HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r707:0529e02041c3

Add mousebuttons to pie clicked signals

Jani Honkonen -

r707:0529e02041c3

parent child

Context file:

r707:0529e02041c3

Collapse all files

demos/piechartcustomization/main.cpp +4 -2

             #include <QtGui/QApplication>
             #include <QMainWindow>
             #include <qchartglobal.h>
             #include <qchartview.h>
             #include <qpieseries.h>
             #include <qpieslice.h>
             #include <QGridLayout>
             #include <QFormLayout>
             #include <QComboBox>
             #include <QSpinBox>
             #include <QCheckBox>
             #include <QGroupBox>
             #include <QLabel>
             #include <QPushButton>
             #include <QColorDialog>
             #include <QFontDialog>
             QTCOMMERCIALCHART_USE_NAMESPACE
             class PenTool : public QWidget
             {
                 Q_OBJECT
             public:
                 explicit PenTool(QString title, QWidget *parent = 0)
                     :QWidget(parent)
                 {
                     setWindowTitle(title);
                     setWindowFlags(Qt::Tool);
                     m_colorButton = new QPushButton();
                     m_widthSpinBox = new QDoubleSpinBox();
                     m_styleCombo = new QComboBox();
                     m_styleCombo->addItem("NoPen");
                     m_styleCombo->addItem("SolidLine");
                     m_styleCombo->addItem("DashLine");
                     m_styleCombo->addItem("DotLine");
                     m_styleCombo->addItem("DashDotLine");
                     m_styleCombo->addItem("DashDotDotLine");
                     m_capStyleCombo = new QComboBox();
                     m_capStyleCombo->addItem("FlatCap", Qt::FlatCap);
                     m_capStyleCombo->addItem("SquareCap", Qt::SquareCap);
                     m_capStyleCombo->addItem("RoundCap", Qt::RoundCap);
                     m_joinStyleCombo = new QComboBox();
                     m_joinStyleCombo->addItem("MiterJoin", Qt::MiterJoin);
                     m_joinStyleCombo->addItem("BevelJoin", Qt::BevelJoin);
                     m_joinStyleCombo->addItem("RoundJoin", Qt::RoundJoin);
                     m_joinStyleCombo->addItem("SvgMiterJoin", Qt::SvgMiterJoin);
                     QFormLayout *layout = new QFormLayout();
                     layout->addRow("Color", m_colorButton);
                     layout->addRow("Width", m_widthSpinBox);
                     layout->addRow("Style", m_styleCombo);
                     layout->addRow("Cap style", m_capStyleCombo);
                     layout->addRow("Join style", m_joinStyleCombo);
                     setLayout(layout);
                     connect(m_colorButton, SIGNAL(clicked()), this, SLOT(showColorDialog()));
                     connect(m_widthSpinBox, SIGNAL(valueChanged(double)), this, SLOT(updateWidth(double)));
                     connect(m_styleCombo, SIGNAL(currentIndexChanged(int)), this, SLOT(updateStyle(int)));
                     connect(m_capStyleCombo, SIGNAL(currentIndexChanged(int)), this, SLOT(updateCapStyle(int)));
                     connect(m_joinStyleCombo, SIGNAL(currentIndexChanged(int)), this, SLOT(updateJoinStyle(int)));
                 }
                 void setPen(QPen pen)
                 {
                     m_pen = pen;
                     m_colorButton->setText(m_pen.color().name());
                     m_widthSpinBox->setValue(m_pen.widthF());
                     m_styleCombo->setCurrentIndex(m_pen.style()); // index matches the enum
                     m_capStyleCombo->setCurrentIndex(m_capStyleCombo->findData(m_pen.capStyle()));
                     m_joinStyleCombo->setCurrentIndex(m_joinStyleCombo->findData(m_pen.joinStyle()));
                 }
                 QPen pen() const
                 {
                     return m_pen;
                 }
                 QString name()
                 {
                     return name(m_pen);
                 }
                 static QString name(const QPen &pen)
                 {
                     return pen.color().name() + ":" + QString::number(pen.widthF());
                 }
             Q_SIGNALS:
                 void changed();
             public Q_SLOTS:
                 void showColorDialog()
                 {
                     QColorDialog dialog(m_pen.color());
                     dialog.show();
                     dialog.exec();
                     m_pen.setColor(dialog.selectedColor());
                     m_colorButton->setText(m_pen.color().name());
                     emit changed();
                 }
                 void updateWidth(double width)
                 {
                     if (width != m_pen.widthF()) {
                         m_pen.setWidthF(width);
                         emit changed();
                     }
                 }
                 void updateStyle(int style)
                 {
                     if (m_pen.style() != style) {
                         m_pen.setStyle((Qt::PenStyle) style);
                         emit changed();
                     }
                 }
                 void updateCapStyle(int index)
                 {
                     Qt::PenCapStyle capStyle = (Qt::PenCapStyle) m_capStyleCombo->itemData(index).toInt();
                     if (m_pen.capStyle() != capStyle) {
                         m_pen.setCapStyle(capStyle);
                         emit changed();
                     }
                 }
                 void updateJoinStyle(int index)
                 {
                     Qt::PenJoinStyle joinStyle = (Qt::PenJoinStyle) m_joinStyleCombo->itemData(index).toInt();
                     if (m_pen.joinStyle() != joinStyle) {
                         m_pen.setJoinStyle(joinStyle);
                         emit changed();
                     }
                 }
             private:
                 QPen m_pen;
                 QPushButton *m_colorButton;
                 QDoubleSpinBox *m_widthSpinBox;
                 QComboBox *m_styleCombo;
                 QComboBox *m_capStyleCombo;
                 QComboBox *m_joinStyleCombo;
             };
             class BrushTool : public QWidget
             {
                 Q_OBJECT
             public:
                 explicit BrushTool(QString title, QWidget *parent = 0)
                     :QWidget(parent)
                 {
                     setWindowTitle(title);
                     setWindowFlags(Qt::Tool);
                     m_colorButton = new QPushButton();
                     m_styleCombo = new QComboBox();
                     m_styleCombo->addItem("Nobrush", Qt::NoBrush);
                     m_styleCombo->addItem("Solidpattern", Qt::SolidPattern);
                     m_styleCombo->addItem("Dense1pattern", Qt::Dense1Pattern);
                     m_styleCombo->addItem("Dense2attern", Qt::Dense2Pattern);
                     m_styleCombo->addItem("Dense3Pattern", Qt::Dense3Pattern);
                     m_styleCombo->addItem("Dense4Pattern", Qt::Dense4Pattern);
                     m_styleCombo->addItem("Dense5Pattern", Qt::Dense5Pattern);
                     m_styleCombo->addItem("Dense6Pattern", Qt::Dense6Pattern);
                     m_styleCombo->addItem("Dense7Pattern", Qt::Dense7Pattern);
                     m_styleCombo->addItem("HorPattern", Qt::HorPattern);
                     m_styleCombo->addItem("VerPattern", Qt::VerPattern);
                     m_styleCombo->addItem("CrossPattern", Qt::CrossPattern);
                     m_styleCombo->addItem("BDiagPattern", Qt::BDiagPattern);
                     m_styleCombo->addItem("FDiagPattern", Qt::FDiagPattern);
                     m_styleCombo->addItem("DiagCrossPattern", Qt::DiagCrossPattern);
                     QFormLayout *layout = new QFormLayout();
                     layout->addRow("Color", m_colorButton);
                     layout->addRow("Style", m_styleCombo);
                     setLayout(layout);
                     connect(m_colorButton, SIGNAL(clicked()), this, SLOT(showColorDialog()));
                     connect(m_styleCombo, SIGNAL(currentIndexChanged(int)), this, SLOT(updateStyle()));
                 }
                 void setBrush(QBrush brush)
                 {
                     m_brush = brush;
                     m_colorButton->setText(m_brush.color().name());
                     m_styleCombo->setCurrentIndex(m_brush.style()); // index matches the enum
                 }
                 QBrush brush() const
                 {
                     return m_brush;
                 }
                 QString name()
                 {
                     return name(m_brush);
                 }
                 static QString name(const QBrush &brush)
                 {
                     return brush.color().name();
                 }
             Q_SIGNALS:
                 void changed();
             public Q_SLOTS:
                 void showColorDialog()
                 {
                     QColorDialog dialog(m_brush.color());
                     dialog.show();
                     dialog.exec();
                     m_brush.setColor(dialog.selectedColor());
                     m_colorButton->setText(m_brush.color().name());
                     emit changed();
                 }
                 void updateStyle()
                 {
                     Qt::BrushStyle style = (Qt::BrushStyle) m_styleCombo->itemData(m_styleCombo->currentIndex()).toInt();
                     if (m_brush.style() != style) {
                         m_brush.setStyle(style);
                         emit changed();
                     }
                 }
             private:
                 QBrush m_brush;
                 QPushButton *m_colorButton;
                 QComboBox *m_styleCombo;
             };
             class CustomSlice : public QPieSlice
             {
                 Q_OBJECT
             public:
                 CustomSlice(qreal value, QString label)
                     :QPieSlice(value, label)
                 {
                     connect(this, SIGNAL(hoverEnter()), this, SLOT(handleHoverEnter()));
                     connect(this, SIGNAL(hoverLeave()), this, SLOT(handleHoverLeave()));
                 }
             public:
                 QBrush originalBrush()
                 {
                     return m_originalBrush;
                 }
             public Q_SLOTS:
                 void handleHoverEnter()
                 {
                     QBrush brush = this->sliceBrush();
                     m_originalBrush = brush;
                     brush.setColor(brush.color().lighter());
                     setSliceBrush(brush);
                 }
                 void handleHoverLeave()
                 {
                     setSliceBrush(m_originalBrush);
                 }
             private:
                 QBrush m_originalBrush;
             };
             class MainWidget : public QWidget
             {
                 Q_OBJECT
             public:
                 explicit MainWidget(QWidget* parent = 0)
                     :QWidget(parent),
                     m_slice(0)
                 {
                     // create chart
                     m_chartView =  new QChartView();
                     m_chartView->setChartTitle("Piechart customization");
                     m_chartView->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_chartView->addSeries(m_series);
-                    connect(m_series, SIGNAL(clicked(QPieSlice*)), this, SLOT(handleSliceClicked(QPieSlice*)));
+                    connect(m_series, SIGNAL(clicked(QPieSlice*, Qt::MouseButtons)), this, SLOT(handleSliceClicked(QPieSlice*, Qt::MouseButtons)));
                     // chart settings
                     m_themeComboBox = new QComboBox();
                     m_themeComboBox->addItem("Default", QChart::ChartThemeDefault);
                     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("Icy", QChart::ChartThemeIcy);
                     m_themeComboBox->addItem("Scientific", QChart::ChartThemeScientific);
                     m_aaCheckBox = new QCheckBox();
                     m_animationsCheckBox = new QCheckBox();
                     m_animationsCheckBox->setCheckState(Qt::Checked);
                     QFormLayout* chartSettingsLayout = new QFormLayout();
                     chartSettingsLayout->addRow("Theme", m_themeComboBox);
                     chartSettingsLayout->addRow("Antialiasing", m_aaCheckBox);
                     chartSettingsLayout->addRow("Animations", m_animationsCheckBox);
                     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()));
                     // 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->pieHorizontalPosition());
                     m_vPosition = new QDoubleSpinBox();
                     m_vPosition->setMinimum(0.0);
                     m_vPosition->setMaximum(1.0);
                     m_vPosition->setSingleStep(0.1);
                     m_vPosition->setValue(m_series->pieVerticalPosition());
                     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 *addSlice = new QPushButton("Add 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(addSlice);
                     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(addSlice, SIGNAL(clicked()), this, SLOT(addSlice()));
                     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_labelArmPen = new QPushButton();
                     m_labelArmPenTool = new PenTool("Label arm 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 arm pen", m_labelArmPen);
                     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_labelArmPen, SIGNAL(clicked()), m_labelArmPenTool, SLOT(show()));
                     connect(m_labelArmPenTool, 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 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();
                 }
             public Q_SLOTS:
                 void updateChartSettings()
                 {
                     QChart::ChartTheme theme = (QChart::ChartTheme) m_themeComboBox->itemData(m_themeComboBox->currentIndex()).toInt();
                     m_chartView->setChartTheme(theme);
                     m_chartView->setRenderHint(QPainter::Antialiasing, m_aaCheckBox->isChecked());
                     if (m_animationsCheckBox->checkState() == Qt::Checked)
                         m_chartView->setAnimationOptions(QChart::AllAnimations);
                     else
                         m_chartView->setAnimationOptions(QChart::NoAnimation);
                 }
                 void updateSerieSettings()
                 {
                     m_series->setPiePosition(m_hPosition->value(), m_vPosition->value());
                     m_series->setPieSize(m_sizeFactor->value());
                     m_series->setPieStartAngle(m_startAngle->value());
                     m_series->setPieEndAngle(m_endAngle->value());
                 }
                 void updateSliceSettings()
                 {
                     if (!m_slice)
                         return;
                     m_slice->setValue(m_sliceValue->value());
                     m_slice->setSlicePen(m_penTool->pen());
                     m_slice->setSliceBrush(m_brushTool->brush());
                     m_slice->setLabelArmPen(m_labelArmPenTool->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 handleSliceClicked(QPieSlice* slice)
+                void handleSliceClicked(QPieSlice* slice, Qt::MouseButtons buttons)
                 {
+                    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->slicePen()));
                     m_penTool->setPen(m_slice->slicePen());
                     // brush
                     m_brush->setText(m_slice->originalBrush().color().name());
                     m_brushTool->setBrush(m_slice->originalBrush());
                     // label
                     m_labelArmPen->setText(PenTool::name(m_slice->labelArmPen()));
                     m_labelArmPenTool->setPen(m_slice->labelArmPen());
                     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 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 addSlice()
                 {
                     *m_series << new CustomSlice(10.0, "Slice " + QString::number(m_series->count()+1));
                 }
                 void 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 removeSlice()
                 {
                     if (!m_slice)
                         return;
                     m_series->remove(m_slice);
                     m_slice = 0;
                 }
             private:
                 QComboBox *m_themeComboBox;
                 QCheckBox *m_aaCheckBox;
                 QCheckBox *m_animationsCheckBox;
                 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_labelArmPen;
                 PenTool *m_labelArmPenTool;
             };
             int main(int argc, char *argv[])
             {
                 QApplication a(argc, argv);
                 QMainWindow window;
                 MainWidget* widget = new MainWidget();
                 window.setCentralWidget(widget);
                 window.resize(900, 600);
                 window.show();
                 return a.exec();
             }
             #include "main.moc"

examples/piechartdrilldown/main.cpp +2 -2

             #include <QtGui/QApplication>
             #include <QMainWindow>
             #include <qchartglobal.h>
             #include <qchartview.h>
             #include <qpieseries.h>
             #include <qpieslice.h>
             #include <QTime>
             QTCOMMERCIALCHART_USE_NAMESPACE
             class DrilldownSlice : public QPieSlice
             {
                 Q_OBJECT
             public:
                 DrilldownSlice(qreal value, QString prefix, QSeries* drilldownSeries)
                     :m_drilldownSeries(drilldownSeries),
                     m_prefix(prefix)
                 {
                     setValue(value);
                     setLabelVisible(true);
                     updateLabel();
                     connect(this, SIGNAL(changed()), this, SLOT(updateLabel()));
                 }
                 QSeries* drilldownSeries() const { return m_drilldownSeries; }
             public Q_SLOTS:
                 void updateLabel()
                 {
                     QString label = m_prefix;
                     label += " " + QString::number(this->value())+ "e (";
                     label += QString::number(this->percentage()*100, 'f', 1) + "%)";
                     setLabel(label);
                 }
             private:
                 QSeries* m_drilldownSeries;
                 QString m_prefix;
             };
             class DrilldownChart : public QChartView
             {
                 Q_OBJECT
             public:
                 explicit DrilldownChart(QWidget *parent = 0):QChartView(parent), m_currentSeries(0) {}
                 void changeSeries(QSeries* series)
                 {
                     // NOTE: if the series is owned by the chart it will be deleted
                     // here the "window" owns the series...
                     if (m_currentSeries)
                         removeSeries(m_currentSeries);
                     m_currentSeries = series;
                     addSeries(series);
                     setChartTitle(series->title());
                 }
             public Q_SLOTS:
                 void handleSliceClicked(QPieSlice* slice)
                 {
                     DrilldownSlice* drilldownSlice = static_cast<DrilldownSlice*>(slice);
                     changeSeries(drilldownSlice->drilldownSeries());
                 }
             private:
                 QSeries* m_currentSeries;
             };
             int main(int argc, char *argv[])
             {
                 QApplication a(argc, argv);
                 qsrand(QTime(0,0,0).secsTo(QTime::currentTime()));
                 QMainWindow window;
                 DrilldownChart* drilldownChart =  new DrilldownChart(&window);
                 drilldownChart->setRenderHint(QPainter::Antialiasing);
                 drilldownChart->setChartTheme(QChart::ChartThemeLight);
                 drilldownChart->setAnimationOptions(QChart::AllAnimations);
                 QPieSeries* yearSeries = new QPieSeries(&window);
                 yearSeries->setTitle("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" << "Samantha" << "Bob";
                 foreach (QString name, names) {
                     QPieSeries* series = new QPieSeries(&window);
                     series->setTitle("Sales by month - " + name);
                     foreach (QString month, months)
                         *series << new DrilldownSlice(qrand() % 1000, month, yearSeries);
-                    QObject::connect(series, SIGNAL(clicked(QPieSlice*)), drilldownChart, SLOT(handleSliceClicked(QPieSlice*)));
+                    QObject::connect(series, SIGNAL(clicked(QPieSlice*, Qt::MouseButtons)), drilldownChart, SLOT(handleSliceClicked(QPieSlice*)));
                     *yearSeries << new DrilldownSlice(series->total(), name, series);
                 }
-                QObject::connect(yearSeries, SIGNAL(clicked(QPieSlice*)), drilldownChart, SLOT(handleSliceClicked(QPieSlice*)));
+                QObject::connect(yearSeries, SIGNAL(clicked(QPieSlice*, Qt::MouseButtons)), drilldownChart, SLOT(handleSliceClicked(QPieSlice*)));
                 drilldownChart->changeSeries(yearSeries);
                 window.setCentralWidget(drilldownChart);
                 window.resize(800, 600);
                 window.show();
                 return a.exec();
             }
             #include "main.moc"

src/piechart/piechartitem.cpp +1 -1

             #include "piechartitem_p.h"
             #include "piesliceitem_p.h"
             #include "qpieslice.h"
             #include "qpiesliceprivate_p.h"
             #include "qpieseries.h"
             #include "chartpresenter_p.h"
             #include "chartdataset_p.h"
             #include "chartanimator_p.h"
             #include <QDebug>
             #include <QPainter>
             #include <QTimer>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             PieChartItem::PieChartItem(QPieSeries *series, ChartPresenter* presenter)
                 :ChartItem(presenter),
                 m_series(series)
             {
                 Q_ASSERT(series);
                 connect(series, SIGNAL(added(QList<QPieSlice*>)), this, SLOT(handleSlicesAdded(QList<QPieSlice*>)));
                 connect(series, SIGNAL(removed(QList<QPieSlice*>)), this, SLOT(handleSlicesRemoved(QList<QPieSlice*>)));
                 connect(series, SIGNAL(piePositionChanged()), this, SLOT(handlePieLayoutChanged()));
                 connect(series, SIGNAL(pieSizeChanged()), this, SLOT(handlePieLayoutChanged()));
                 QTimer::singleShot(0, this, SLOT(initialize()));
                 // 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()->theme()->decorate(m_series, presenter()->dataSet()->seriesIndex(m_series), false);
                 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()), s, SIGNAL(clicked()));
+                    connect(item, SIGNAL(clicked(Qt::MouseButtons)), s, SIGNAL(clicked(Qt::MouseButtons)));
                     connect(item, SIGNAL(hoverEnter()), s, SIGNAL(hoverEnter()));
                     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()->theme()->decorate(m_series, presenter()->dataSet()->seriesIndex(m_series), false);
                 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->pieHorizontalPosition()));
                 m_pieCenter.setY(m_rect.top() + (m_rect.height() * m_series->pieVerticalPosition()));
                 // 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)
             {
                 PieSliceData sliceData = slice->data_ptr()->m_data;
                 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 +3 -3

             #include "piesliceitem_p.h"
             #include "piechartitem_p.h"
             #include "qpieseries.h"
             #include "qpieslice.h"
             #include "chartpresenter_p.h"
             #include <QPainter>
             #include <QDebug>
             #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::LeftButton);
+                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->setClipRect(parentItem()->boundingRect());
                 painter->save();
                 painter->setPen(m_data.m_slicePen);
                 painter->setBrush(m_data.m_sliceBrush);
                 painter->drawPath(m_slicePath);
                 painter->restore();
                 if (m_data.m_isLabelVisible) {
                     painter->save();
                     painter->setPen(m_data.m_labelArmPen);
                     painter->drawPath(m_labelArmPath);
                     painter->restore();
                     painter->setFont(m_data.m_labelFont);
                     painter->drawText(m_labelTextRect.bottomLeft(), m_data.m_labelText);
                 }
             }
             void PieSliceItem::hoverEnterEvent(QGraphicsSceneHoverEvent* /*event*/)
             {
                 emit hoverEnter();
             }
             void PieSliceItem::hoverLeaveEvent(QGraphicsSceneHoverEvent* /*event*/)
             {
                 emit hoverLeave();
             }
-            void PieSliceItem::mousePressEvent(QGraphicsSceneMouseEvent* /*event*/)
+            void PieSliceItem::mousePressEvent(QGraphicsSceneMouseEvent *event)
             {
-                emit clicked();
+                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
                 m_boundingRect = m_slicePath.boundingRect().united(m_labelArmPath.boundingRect()).united(m_labelTextRect);
             }
             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)
             {
                 qreal dx = qSin(angle*(PI/180)) * length;
                 qreal dy = -qCos(angle*(PI/180)) * length;
                 QPointF parm1 = start + QPointF(dx, dy);
                 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, -5);
                 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 -1

             #ifndef PIESLICEITEM_H
             #define PIESLICEITEM_H
             #include "qchartglobal.h"
             #include "charttheme_p.h"
             #include "qpieseries.h"
             #include "qpiesliceprivate_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();
+                void clicked(Qt::MouseButtons buttons);
                 void hoverEnter();
                 void hoverLeave();
             public:
                 void setSliceData(PieSliceData sliceData);
                 void updateGeometry();
                 static QPointF sliceCenter(QPointF point, qreal radius, QPieSlice *slice);
                 static QPainterPath slicePath(QPointF center, qreal radius, qreal startAngle, qreal angleSpan, qreal* centerAngle, QPointF* armStart);
                 static QPainterPath labelArmPath(QPointF start, qreal angle, qreal length, qreal textWidth, QPointF* textStart);
                 static 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 +3 -3

             #include "qpieseries.h"
             #include "qpiesliceprivate_p.h"
             #include "qpieseriesprivate_p.h"
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             QPieSeriesPrivate::QPieSeriesPrivate(QPieSeries *parent)
                 :QObject(parent),
                 q_ptr(parent),
                 m_pieRelativeHorPos(0.5),
                 m_pieRelativeVerPos(0.5),
                 m_pieRelativeSize(0.7),
                 m_pieStartAngle(0),
                 m_pieEndAngle(360),
                 m_total(0)
             {
             }
             QPieSeriesPrivate::~QPieSeriesPrivate()
             {
             }
             void QPieSeriesPrivate::updateDerivativeData()
             {
                 m_total = 0;
                 // nothing to do?
                 if (m_slices.count() == 0)
                     return;
                 // calculate total
                 foreach (QPieSlice* s, m_slices)
                     m_total += s->value();
                 // nothing to show..
                 if (m_total == 0)
                     return;
                 // update slice attributes
                 qreal sliceAngle = m_pieStartAngle;
                 qreal pieSpan = m_pieEndAngle - m_pieStartAngle;
                 QVector<QPieSlice*> changed;
                 foreach (QPieSlice* s, m_slices) {
                     bool isChanged = false;
                     qreal percentage = s->value() / m_total;
                     if (s->data_ptr()->m_data.m_percentage != percentage) {
                         s->data_ptr()->m_data.m_percentage = percentage;
                         isChanged = true;
                     }
                     qreal sliceSpan = pieSpan * percentage;
                     if (s->data_ptr()->m_data.m_angleSpan != sliceSpan) {
                         s->data_ptr()->m_data.m_angleSpan = sliceSpan;
                         isChanged = true;
                     }
                     if (s->data_ptr()->m_data.m_startAngle != sliceAngle) {
                         s->data_ptr()->m_data.m_startAngle = sliceAngle;
                         isChanged = true;
                     }
                     sliceAngle += sliceSpan;
                     if (isChanged)
                         changed << s;
                 }
                 // emit signals
                 foreach (QPieSlice* s, changed)
                     emit s->data_ptr()->changed();
             }
             void QPieSeriesPrivate::sliceChanged()
             {
                 Q_ASSERT(m_slices.contains(qobject_cast<QPieSlice *>(sender())));
                 updateDerivativeData();
             }
-            void QPieSeriesPrivate::sliceClicked()
+            void QPieSeriesPrivate::sliceClicked(Qt::MouseButtons buttons)
             {
                 QPieSlice* slice = qobject_cast<QPieSlice *>(sender());
                 Q_ASSERT(m_slices.contains(slice));
                 Q_Q(QPieSeries);
-                emit q->clicked(slice);
+                emit q->clicked(slice, buttons);
             }
             void QPieSeriesPrivate::sliceHoverEnter()
             {
                 QPieSlice* slice = qobject_cast<QPieSlice *>(sender());
                 Q_ASSERT(m_slices.contains(slice));
                 Q_Q(QPieSeries);
                 emit q->hoverEnter(slice);
             }
             void QPieSeriesPrivate::sliceHoverLeave()
             {
                 QPieSlice* slice = qobject_cast<QPieSlice *>(sender());
                 Q_ASSERT(m_slices.contains(slice));
                 Q_Q(QPieSeries);
                 emit q->hoverLeave(slice);
             }
             void QPieSeriesPrivate::modelUpdated(QModelIndex topLeft, QModelIndex bottomRight)
             {
                 Q_UNUSED(bottomRight)
                 Q_Q(QPieSeries);
                 if (m_mapOrientation == Qt::Vertical)
                 {
                     //        slices().at(topLeft.row())->setValue(m_model->data(m_model->index(topLeft.row(), topLeft.column()), Qt::DisplayRole).toDouble());
                     if (topLeft.column() == m_mapValues)
                         if (m_mapValues == m_mapLabels)
                         {
                             m_slices.at(topLeft.row())->setValue(q->m_model->data(topLeft, Qt::DisplayRole).toDouble());
                             m_slices.at(topLeft.row())->setLabel(q->m_model->data(topLeft, Qt::DisplayRole).toString());
                         }
                         else
                         {
                             m_slices.at(topLeft.row())->setValue(q->m_model->data(topLeft, Qt::DisplayRole).toDouble());
                         }
                     else if (topLeft.column() == m_mapLabels)
                         m_slices.at(topLeft.row())->setLabel(q->m_model->data(topLeft, Qt::DisplayRole).toString());
                 }
                 else
                 {
                     //        slices().at(topLeft.column())->setValue(m_model->data(m_model->index(topLeft.row(), topLeft.column()), Qt::DisplayRole).toDouble());
                     if (topLeft.row() == m_mapValues)
                         if (m_mapValues == m_mapLabels)
                         {
                             m_slices.at(topLeft.column())->setValue(q->m_model->data(topLeft, Qt::DisplayRole).toDouble());
                             m_slices.at(topLeft.column())->setLabel(q->m_model->data(topLeft, Qt::DisplayRole).toString());
                         }
                         else
                         {
                             m_slices.at(topLeft.column())->setValue(q->m_model->data(topLeft, Qt::DisplayRole).toDouble());
                         }
                     else if (topLeft.row() == m_mapLabels)
                         m_slices.at(topLeft.column())->setLabel(q->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(q->m_model->data(q->m_model->index(start, m_mapValues), Qt::DisplayRole).toDouble());
                     newSlice->setLabel(q->m_model->data(q->m_model->index(start, m_mapLabels), Qt::DisplayRole).toString());
                 }
                 else
                 {
                     newSlice->setValue(q->m_model->data(q->m_model->index(m_mapValues, start), Qt::DisplayRole).toDouble());
                     newSlice->setLabel(q->m_model->data(q->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));
             }
             /*!
                 \class QPieSeries
                 \brief Pie series API for QtCommercial Charts
                 The pie series defines a pie chart which consists of pie slices which are 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.
                 By default the pie is defined as a full pie but it can be a partial pie.
                 This can be done by setting a starting angle and angle span to the series.
             */
             /*!
                 Constructs a series object which is a child of \a parent.
             */
             QPieSeries::QPieSeries(QObject *parent) :
                 QSeries(parent),
                 d_ptr(new QPieSeriesPrivate(this))
             {
             }
             /*!
                 Destroys the object. Note that adding series to QChart transfers the ownership to the chart.
             */
             QPieSeries::~QPieSeries()
             {
                 // NOTE: d_prt destroyed by QObject
             }
             /*!
                 Returns QChartSeries::SeriesTypePie.
             */
             QSeries::QSeriesType QPieSeries::type() const
             {
                 return QSeries::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();
                 add(slices);
             }
             /*!
                 Adds an array of \a slices to the series.
                 Slice ownership is passed to the series.
             */
             void QPieSeries::add(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()), d, SLOT(sliceClicked()));
+                    connect(s, SIGNAL(clicked(Qt::MouseButtons)), d, SLOT(sliceClicked(Qt::MouseButtons)));
                     connect(s, SIGNAL(hoverEnter()), d, SLOT(sliceHoverEnter()));
                     connect(s, SIGNAL(hoverLeave()), d, SLOT(sliceHoverLeave()));
                 }
                 emit added(slices);
             }
             /*!
                 Adds a single \a slice to the series.
                 Slice ownership is passed to the series.
             */
             void QPieSeries::add(QPieSlice* slice)
             {
                 add(QList<QPieSlice*>() << slice);
             }
             /*!
                 Adds 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)
             {
                 add(slice);
                 return *this;
             }
             /*!
                 Adds a single slice to the series with give \a value and \a name.
                 Slice ownership is passed to the series.
             */
             QPieSlice* QPieSeries::add(qreal value, QString name)
             {
                 QPieSlice* slice = new QPieSlice(value, name);
                 add(slice);
                 return slice;
             }
             void QPieSeries::insert(int i, QPieSlice* slice)
             {
                 Q_D(QPieSeries);
                 Q_ASSERT(i <= d->m_slices.count());
                 slice->setParent(this);
                 d->m_slices.insert(i, slice);
                 d->updateDerivativeData();
                 connect(slice, SIGNAL(changed()), d, SLOT(sliceChanged()));
                 connect(slice, SIGNAL(clicked()), d, SLOT(sliceClicked()));
                 connect(slice, SIGNAL(hoverEnter()), d, SLOT(sliceHoverEnter()));
                 connect(slice, SIGNAL(hoverLeave()), d, SLOT(sliceHoverLeave()));
                 emit added(QList<QPieSlice*>() << slice);
             }
             /*!
                 Removes a single \a slice from the series and deletes the slice.
                 Do not reference this 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);
                 delete slice;
                 slice = NULL;
             }
             /*!
                 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);
             }
             /*!
                 Counts 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;
             }
             /*!
                 Sets the center position of the pie by \a relativeHorizontalPosition and \a relativeVerticalPosition.
                 The factors are relative to the chart rectangle where:
                 \a relativeHorizontalPosition 0.0 means the absolute left.
                 \a relativeHorizontalPosition 1.0 means the absolute right.
                 \a relativeVerticalPosition 0.0 means the absolute top.
                 \a relativeVerticalPosition 1.0 means the absolute bottom.
                 By default both values are 0.5 which puts the pie in the middle of the chart rectangle.
                 \sa pieHorizontalPosition(), pieVerticalPosition(), setPieSize()
             */
             void QPieSeries::setPiePosition(qreal relativeHorizontalPosition, qreal relativeVerticalPosition)
             {
                 Q_D(QPieSeries);
                 if (relativeHorizontalPosition < 0.0 || relativeHorizontalPosition > 1.0 ||
                         relativeVerticalPosition < 0.0 || relativeVerticalPosition > 1.0)
                     return;
                 if (d->m_pieRelativeHorPos != relativeHorizontalPosition || d->m_pieRelativeVerPos != relativeVerticalPosition) {
                     d->m_pieRelativeHorPos = relativeHorizontalPosition;
                     d->m_pieRelativeVerPos = relativeVerticalPosition;
                     emit piePositionChanged();
                 }
             }
             /*!
                 Gets the horizontal position of the pie.
                 The returned value is relative to the chart rectangle where:
 .0 means the absolute left.
 .0 means the absolute right.
                 By default it is 0.5 which puts the pie in the horizontal middle of the chart rectangle.
                 \sa setPiePosition(), pieVerticalPosition(), setPieSize()
             */
             qreal QPieSeries::pieHorizontalPosition() const
             {
                 Q_D(const QPieSeries);
                 return d->m_pieRelativeHorPos;
             }
             /*!
                 Gets the vertical position position of the pie.
                 The returned value is relative to the chart rectangle where:
 .0 means the absolute top.
 .0 means the absolute bottom.
                 By default it is 0.5 which puts the pie in the vertical middle of the chart rectangle.
                 \sa setPiePosition(), pieHorizontalPosition(), setPieSize()
             */
             qreal QPieSeries::pieVerticalPosition() const
             {
                 Q_D(const QPieSeries);
                 return d->m_pieRelativeVerPos;
             }
             /*!
                 Sets the relative size of the pie.
                 The \a relativeSize is defined so that the 1.0 is the maximum that can fit the given chart rectangle.
                 Default value is 0.7.
                 \sa pieSize(), setPiePosition(), pieVerticalPosition(), pieHorizontalPosition()
             */
             void QPieSeries::setPieSize(qreal relativeSize)
             {
                 Q_D(QPieSeries);
                 if (relativeSize < 0.0 || relativeSize > 1.0)
                     return;
                 if (d->m_pieRelativeSize != relativeSize) {
                     d->m_pieRelativeSize = relativeSize;
                     emit pieSizeChanged();
                 }
             }
             /*!
                 Gets the relative size of the pie.
                 The size is defined so that the 1.0 is the maximum that can fit the given chart rectangle.
                 Default value is 0.7.
                 \sa setPieSize(), setPiePosition(), pieVerticalPosition(), pieHorizontalPosition()
             */
             qreal QPieSeries::pieSize() const
             {
                 Q_D(const QPieSeries);
                 return d->m_pieRelativeSize;
             }
             /*!
                 Sets the end angle of the pie.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                 \a angle must be less than pie end angle. Default value is 0.
                 \sa pieStartAngle(), pieEndAngle(), setPieEndAngle()
             */
             void QPieSeries::setPieStartAngle(qreal angle)
             {
                 Q_D(QPieSeries);
                 if (angle >= 0 && angle <= 360 && angle != d->m_pieStartAngle && angle <= d->m_pieEndAngle) {
                     d->m_pieStartAngle = angle;
                     d->updateDerivativeData();
                 }
             }
             /*!
                 Gets the start angle of the pie.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock. Default value is 360.
                 \sa setPieStartAngle(), pieEndAngle(), setPieEndAngle()
             */
             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 (angle >= 0 && angle <= 360 && angle != d->m_pieEndAngle && angle >= d->m_pieStartAngle) {
                     d->m_pieEndAngle = angle;
                     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()
             */
             qreal QPieSeries::total() const
             {
                 Q_D(const QPieSeries);
                 return d->m_total;
             }
             /*!
                 \fn void QPieSeries::clicked(QPieSlice* slice)
                 This signal is emitted when a \a slice has been clicked.
                 \sa QPieSlice::clicked()
             */
             /*!
                 \fn void QPieSeries::hoverEnter(QPieSlice* slice)
                 This signal is emitted when user has hovered over a \a slice.
                 \sa QPieSlice::hoverEnter()
             */
             /*!
                 \fn void QPieSeries::hoverLeave(QPieSlice* slice)
                 This signal is emitted when user has hovered away from a \a slice.
                 \sa QPieSlice::hoverLeave()
             */
             bool QPieSeries::setModel(QAbstractItemModel* model)
             {
                 Q_D(QPieSeries);
                 // disconnect signals from old model
                 if(m_model)
                 {
                     disconnect(m_model, 0, this, 0);
                     d->m_mapValues = -1;
                     d->m_mapLabels = -1;
                     d->m_mapOrientation = Qt::Vertical;
                 }
                 // set new model
                 if(model)
                 {
                     m_model = model;
                     return true;
                 }
                 else
                 {
                     m_model = NULL;
                     return false;
                 }
             }
             void QPieSeries::setModelMapping(int modelValuesLine, int modelLabelsLine, Qt::Orientation orientation)
             {
                 Q_D(QPieSeries);
                 if (m_model == NULL)
                     return;
                 d->m_mapValues = modelValuesLine;
                 d->m_mapLabels = modelLabelsLine;
                 d->m_mapOrientation = orientation;
                 // connect the signals
                 if (d->m_mapOrientation == Qt::Vertical) {
                     connect(m_model, SIGNAL(dataChanged(QModelIndex,QModelIndex)), d, SLOT(modelUpdated(QModelIndex, QModelIndex)));
                     connect(m_model, SIGNAL(rowsInserted(QModelIndex, int, int)), d, SLOT(modelDataAdded(QModelIndex,int,int)));
                     connect(m_model, SIGNAL(rowsRemoved(QModelIndex, int, int)), d, SLOT(modelDataRemoved(QModelIndex,int,int)));
                 } else {
                     connect(m_model, SIGNAL(dataChanged(QModelIndex,QModelIndex)), d, SLOT(modelUpdated(QModelIndex, QModelIndex)));
                     connect(m_model, SIGNAL(columnsInserted(QModelIndex, int, int)), d, SLOT(modelDataAdded(QModelIndex,int,int)));
                     connect(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 < m_model->rowCount(); i++)
                         add(m_model->data(m_model->index(i, d->m_mapValues), Qt::DisplayRole).toDouble(), m_model->data(m_model->index(i, d->m_mapLabels), Qt::DisplayRole).toString());
                 } else {
                     for (int i = 0; i < m_model->columnCount(); i++)
                         add(m_model->data(m_model->index(d->m_mapValues, i), Qt::DisplayRole).toDouble(), m_model->data(m_model->index(d->m_mapLabels, i), Qt::DisplayRole).toString());
                 }
             }
             #include "moc_qpieseries.cpp"
             #include "moc_qpieseriesprivate_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/qpieseries.h +1 -1

             #ifndef PIESERIES_H
             #define PIESERIES_H
             #include <qseries.h>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QPieSeriesPrivate;
             class QPieSlice;
             class QTCOMMERCIALCHART_EXPORT QPieSeries : public QSeries
             {
                 Q_OBJECT
             public:
                 QPieSeries(QObject *parent = 0);
                 virtual ~QPieSeries();
             public: // from QChartSeries
                 QSeriesType type() const;
             public:
                 // slice setters
                 void add(QPieSlice* slice);
                 void add(QList<QPieSlice*> slices);
                 void insert(int i, 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 total() const;
                 // pie customization
                 void setPiePosition(qreal relativeHorizontalPosition, qreal relativeVerticalPosition);
                 qreal pieHorizontalPosition() const;
                 qreal pieVerticalPosition() 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* add(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);
+                void clicked(QPieSlice* slice, Qt::MouseButtons buttons);
                 void hoverEnter(QPieSlice* slice);
                 void hoverLeave(QPieSlice* slice);
                 void added(QList<QPieSlice*> slices);
                 void removed(QList<QPieSlice*> slices);
                 void piePositionChanged();
                 void pieSizeChanged();
             private:
                 QPieSeriesPrivate * const d_ptr;
                 Q_DECLARE_PRIVATE(QPieSeries)
                 Q_DISABLE_COPY(QPieSeries)
             public:
                 typedef QPieSeriesPrivate * const DataPtr;
                 inline DataPtr &data_ptr() { return d_ptr; }
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // PIESERIES_H

src/piechart/qpieseriesprivate_p.h +2 -2

             #ifndef QPIESERIESPRIVATE_P_H
             #define QPIESERIESPRIVATE_P_H
             #include "qpieseries.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QPieSeriesPrivate : public QObject
             {
                 Q_OBJECT
                 Q_DECLARE_PUBLIC(QPieSeries)
             public:
                 QPieSeriesPrivate(QPieSeries *parent);
                 ~QPieSeriesPrivate();
                 void updateDerivativeData();
-            public Q_SLOTS: // TODO: should be private and not visible in the interface at all
+            public Q_SLOTS:
                 void sliceChanged();
-                void sliceClicked();
+                void sliceClicked(Qt::MouseButtons buttons);
                 void sliceHoverEnter();
                 void sliceHoverLeave();
                 void modelUpdated(QModelIndex topLeft, QModelIndex bottomRight);
                 void modelDataAdded(QModelIndex parent, int start, int end);
                 void modelDataRemoved(QModelIndex parent, int start, int end);
             public:
                 QPieSeries * const q_ptr;
                 QList<QPieSlice*> m_slices;
                 qreal m_pieRelativeHorPos;
                 qreal m_pieRelativeVerPos;
                 qreal m_pieRelativeSize;
                 qreal m_pieStartAngle;
                 qreal m_pieEndAngle;
                 qreal m_total;
                 // model map
                 int m_mapValues;
                 int m_mapLabels;
                 Qt::Orientation m_mapOrientation;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QPIESERIESPRIVATE_P_H

src/piechart/qpieslice.h +1 -1

             #ifndef QPIESLICE_H
             #define QPIESLICE_H
             #include <qchartglobal.h>
             #include <QObject>
             #include <QPen>
             #include <QBrush>
             #include <QFont>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QPieSlicePrivate;
             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:
                 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 setSlicePen(const QPen &pen);
                 QPen slicePen() const;
                 void setSliceBrush(const QBrush &brush);
                 QBrush sliceBrush() const;
                 void setLabelArmPen(const QPen &pen);
                 QPen labelArmPen() const;
                 void setLabelFont(const QFont &font);
                 QFont labelFont() const;
                 void setLabelArmLengthFactor(qreal factor);
                 qreal labelArmLengthFactor() const;
                 void setExplodeDistanceFactor(qreal factor);
                 qreal explodeDistanceFactor() const;
             Q_SIGNALS:
-                void clicked();
+                void clicked(Qt::MouseButtons buttons);
                 void hoverEnter();
                 void hoverLeave();
                 void changed();
             private:
                 QPieSlicePrivate * const d_ptr;
                 Q_DECLARE_PRIVATE(QPieSlice)
                 Q_DISABLE_COPY(QPieSlice)
             public:
                 typedef QPieSlicePrivate * const DataPtr;
                 inline DataPtr &data_ptr() { return d_ptr; }
             };
             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