HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r60:0be2c26f8dc1

Added size factor property to pie

Tero Ahola -

r60:0be2c26f8dc1

parent child

Context file:

r60:0be2c26f8dc1

Collapse all files

charts.pro 0 0

NO CONTENT: modified file

integrated.pri +2 -2

             integrated_build:{
                 message('Internal build within charts core source tree')
                 INCLUDEPATH += $$CHART_BUILD_HEADER_DIR
                 LIBS += -L $$CHART_BUILD_LIB_DIR -Wl,-rpath,$$CHART_BUILD_LIB_DIR
                 DESTDIR = $$CHART_BUILD_BIN_DIR
                 CONFIG(debug, debug|release) {
                 LIBS += -lQtCommercialChartd
                 #this is ugly hack to work around missing rpath, it simply copies lib
                 win32:{
                     copylib.target = $$CHART_BUILD_BIN_DIR/QtCommercialChartd.dll
-                    copylib.commands = $$QMAKE_COPY $$CHART_BUILD_LIB_DIR\QtCommercialChartd.dll $$CHART_BUILD_BIN_DIR
+                    copylib.commands = $$QMAKE_COPY $$CHART_BUILD_LIB_DIR\\QtCommercialChartd.dll $$CHART_BUILD_BIN_DIR
                     copylib.depends = $$CHART_BUILD_LIB_DIR/QtCommercialChartd.dll
                     PRE_TARGETDEPS += $$CHART_BUILD_BIN_DIR/QtCommercialChartd.dll
                     QMAKE_EXTRA_TARGETS +=copylib
                 }
                 } else {
                     LIBS += -lQtCommercialChart
                     #this is ugly hack to work around missing rpath, it simply copies lib
                     win32: {
                         copylib.target = $$CHART_BUILD_BIN_DIR/QtCommercialChart
-                    copylib.commands = $$QMAKE_COPY $$CHART_BUILD_LIB_DIR\QtCommercialChart.dll $$CHART_BUILD_BIN_DIR
+                        copylib.commands = $$QMAKE_COPY $$CHART_BUILD_LIB_DIR\\QtCommercialChart.dll $$CHART_BUILD_BIN_DIR
                         copylib.depends = $$CHART_BUILD_LIB_DIR/QtCommercialChart.dll
                         PRE_TARGETDEPS += $$CHART_BUILD_BIN_DIR/QtCommercialChart
                         QMAKE_EXTRA_TARGETS +=copylib
                     }
                 }
             } else {
                 CONFIG+=qtcommercialchart
             }

src/pieslice.cpp +4 -3

             #include "pieslice.h"
             #include <QPainter>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            PieSlice::PieSlice(const QColor& color, qreal startAngle, qreal span)
+            PieSlice::PieSlice(const QColor& color, qreal startAngle, qreal span, QRectF rect)
                 : m_color(color),
                 m_startAngle(startAngle),
-                m_span(span)
+                m_span(span),
+                m_rect(rect)
             {
                 setAcceptHoverEvents(true);
             }
             PieSlice::~PieSlice()
             {
             }
             QRectF PieSlice::boundingRect() const
             {
-                return parentItem()->boundingRect();
+                return m_rect;
             }
             QPainterPath PieSlice::shape() const
             {
                 qreal angle = (-m_startAngle) + (90);
                 qreal span = -m_span;
                 QPainterPath path;
                 path.moveTo(boundingRect().center());
                 path.arcTo(boundingRect(), angle, span);
                 // TODO: draw the shape so that it might have a hole in the center
                 // - Sin & Cos will be needed to find inner/outer arc endpoints
                 // dx, dy are offsets from the center
                 //qreal l = boundingRect().height();
                 //qreal dx = qSin(angle*(M_PI/180)) * l;
                 //qreal dy = qCos(angle*(M_PI/180)) * l;
                 // TODO: exploded slice?
                 return path;
             }
             void PieSlice::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 // Setup painter
                 painter->setBrush(m_color);
                 QPen pen;
                 //pen.setColor(m_color.darker());
                 pen.setColor(Qt::gray);
                 pen.setWidth(1);
                 painter->setPen(pen);
                 // From Qt docs:
                 // The startAngle and spanAngle must be specified in 1/16th of a degree, i.e. a full circle equals 5760 (16 * 360).
                 // Positive values for the angles mean counter-clockwise while negative values mean the clockwise direction.
                 // Zero degrees is at the 3 o'clock position.
                 //
                 // For sake of simplicity convert this so that zero degrees is at 12 o'clock and full circle is 360.
                 //qreal angle = (-m_startAngle*16) + (90*16);
                 //qreal span = -m_span*16;
                 //painter->drawPie(boundingRect(), angle, span);
                 painter->drawPath(shape());
             }
             void PieSlice::hoverEnterEvent(QGraphicsSceneHoverEvent * event)
             {
                 QGraphicsItem::hoverEnterEvent(event);
                 qDebug() << "hover" << m_color << m_startAngle << m_span;
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/pieslice.h +3 -2

             #ifndef PIESLICE_H
             #define PIESLICE_H
             #include "qchartglobal.h"
             #include <QGraphicsItem>
             #include <QRectF>
             #include <QColor>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class PieSlice : public QGraphicsItem
             {
             public:
-                PieSlice(const QColor& color, qreal startAngle, qreal span);
+                PieSlice(const QColor& color, qreal startAngle, qreal span, QRectF rect);
                 ~PieSlice();
             public: // from QGraphicsItem
                 QRectF boundingRect() const;
                 QPainterPath shape() const;
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
                 void hoverEnterEvent(QGraphicsSceneHoverEvent * event);
-            private:
+            public:
                 QColor m_color;
                 qreal m_startAngle;
                 qreal m_span;
+                QRectF m_rect;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // PIESLICE_H

src/qpieseries.cpp +43 -6

             #include "qpieseries.h"
             #include "pieslice.h"
             #include <QGraphicsObject>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             QPieSeries::QPieSeries(QList<qreal> x, QGraphicsObject *parent) :
                 QChartSeries(parent),
-                m_x(x)
+                m_x(x),
+                m_sizeFactor(1.0)
             {
                 // Create slices
                 qreal fullPie = 360;
                 qreal total = 0;
                 foreach (qreal value, m_x)
                     total += value;
                 QGraphicsItem *parentItem = qobject_cast<QGraphicsItem *>(parent);
                 Q_ASSERT(parentItem);
+                m_chartSize = parentItem->boundingRect();
                 qreal angle = 0;
                 // TODO: no need to create new slices in case size changed; we should re-use the existing ones
                 foreach (qreal value, m_x) {
                     qreal span = value / total * fullPie;
-                    PieSlice *slice = new PieSlice(randomColor(), angle, span);
+                    PieSlice *slice = new PieSlice(randomColor(), angle, span, parentItem->boundingRect());
                     slice->setParentItem(parentItem);
                     m_slices.append(slice);
                     angle += span;
                 }
+                resizeSlices(m_chartSize);
             }
             QPieSeries::~QPieSeries()
             {
+                while (m_slices.count())
+                    delete m_slices.takeLast();
+            }
+            void QPieSeries::chartSizeChanged(QRectF chartRect)
+            {
+                // TODO: allow user setting the size?
+                // TODO: allow user defining the margins?
+                m_chartSize = chartRect;
+                resizeSlices(m_chartSize);
             }
-            void QPieSeries::chartSizeChanged(QRectF /*rect*/)
+            void QPieSeries::resizeSlices(QRectF rect)
             {
+                QRectF tempRect = rect;
+                if (tempRect.width() < tempRect.height()) {
+                    tempRect.setWidth(tempRect.width() * m_sizeFactor);
+                    tempRect.setHeight(tempRect.width());
+                    tempRect.moveCenter(rect.center());
+                } else {
+                    tempRect.setHeight(tempRect.height() * m_sizeFactor);
+                    tempRect.setWidth(tempRect.height());
+                    tempRect.moveCenter(rect.center());
+                }
+                foreach (PieSlice *slice, m_slices)
+                    slice->m_rect = tempRect;
+            }
+            void QPieSeries::setSizeFactor(qreal factor)
+            {
+                if (factor > 0.0)
+                    m_sizeFactor = factor;
+                resizeSlices(m_chartSize);
+                // Initiate update via the parent graphics item
+                // TODO: potential issue: what if this function is called from the parent context?
+                QGraphicsItem *parentItem = qobject_cast<QGraphicsItem *>(parent());
+                Q_ASSERT(parentItem);
+                parentItem->update();
             }
             QColor QPieSeries::randomColor()
             {
                 QColor c;
                 c.setRed(qrand() % 255);
                 c.setGreen(qrand() % 255);
                 c.setBlue(qrand() % 255);
                 return c;
             }
-            void QPieSeries::setData(QList<int> data)
             #include "moc_qpieseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/qpieseries.h +6 -2

             #ifndef PIESERIES_H
             #define PIESERIES_H
             #include "qchartseries.h"
             #include <QObject>
             #include <QRectF>
             #include <QColor>
             class QGraphicsObject;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class PieSlice;
             class QTCOMMERCIALCHART_EXPORT QPieSeries : public QChartSeries
             {
                 Q_OBJECT
             public:
                 // TODO: use a generic data class instead of x and y
                 QPieSeries(QList<qreal> x, QGraphicsObject *parent = 0);
                 ~QPieSeries();
                 QColor randomColor();
-                void setData(QList<int> data);
+                void setSizeFactor(qreal sizeFactor);
+                qreal sizeFactor() { return m_sizeFactor; }
             public: // from QChartSeries
                 QChartSeriesType type() const { return QChartSeries::SeriesTypePie; }
             public Q_SLOTS:
                 void chartSizeChanged(QRectF rect);
             private:
+                void resizeSlices(QRectF rect);
                 //Q_DECLARE_PRIVATE(QPieSeries)
                 Q_DISABLE_COPY(QPieSeries)
                 // TODO: move the followin to internal impl
                 QList<qreal> m_x;
                 QList<PieSlice*> m_slices;
-                QSizeF m_size;
+                QRectF m_chartSize;
+                qreal m_sizeFactor;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // PIESERIES_H

test/chartwidgettest/chartwidgettest.pro +6 -8

-            include( ../../common.pri )
+            !include( ../../common.pri ) {
-            include( ../../integrated.pri )
+                error( "Couldn't find the common.pri file!" )
+            }
+            !include( ../../integrated.pri ) {
+                error( "Couldn't find the integrated.pri file !")
+            }
             TARGET = chartwidgettest
             TEMPLATE = app
             QT += core gui
             contains(QT_MAJOR_VERSION, 5) {
                 QT += widgets
             }
             OBJECTS_DIR = tmp
             MOC_DIR = tmp
             SOURCES += main.cpp \
                 mainwidget.cpp \
-            #    qscatterseries.cpp \
-            #    qseriespointgraphicsitem.cpp \
                 dataseriedialog.cpp
             HEADERS += \
                 mainwidget.h \
-            #    qscatterseries.h \
-            #    qseriespointgraphicsitem.h \
                 dataseriedialog.h

test/chartwidgettest/mainwidget.cpp +55 -25

             #include "mainwidget.h"
             #include "dataseriedialog.h"
+            #include "qchartseries.h"
+            #include "qpieseries.h"
             #include <qxychartseries.h>
             #include <QPushButton>
             #include <QComboBox>
             #include <QSpinBox>
             #include <QCheckBox>
             #include <QGridLayout>
             #include <QHBoxLayout>
             #include <QLabel>
             #include <QSpacerItem>
             #include <QMessageBox>
             #include <cmath>
             #include <QDebug>
             QTCOMMERCIALCHART_USE_NAMESPACE
             MainWidget::MainWidget(QWidget *parent) :
                 QWidget(parent)
             {
                 QPushButton *addSeriesButton = new QPushButton("Add series");
                 connect(addSeriesButton, SIGNAL(clicked()), this, SLOT(addSeries()));
                 // Chart background
                 QComboBox *backgroundCombo = new QComboBox(this);
                 backgroundCombo->addItem("None");
                 backgroundCombo->addItem("TODO Grid");
                 backgroundCombo->addItem("TODO Image");
                 connect(backgroundCombo, SIGNAL(currentIndexChanged(int)),
                         this, SLOT(backgroundChanged(int)));
                 // Axis
                 // TODO: multiple axes?
                 m_autoScaleCheck = new QCheckBox("Automatic scaling");
                 connect(m_autoScaleCheck, SIGNAL(stateChanged(int)), this, SLOT(autoScaleChanged(int)));
                 // Allow setting also non-sense values (like -2147483648 and 2147483647)
                 m_xMinSpin = new QSpinBox();
                 m_xMinSpin->setMinimum(INT_MIN);
                 m_xMinSpin->setMaximum(INT_MAX);
                 m_xMinSpin->setValue(0);
                 connect(m_xMinSpin, SIGNAL(valueChanged(int)), this, SLOT(xMinChanged(int)));
                 m_xMaxSpin = new QSpinBox();
                 m_xMaxSpin->setMinimum(INT_MIN);
                 m_xMaxSpin->setMaximum(INT_MAX);
                 m_xMaxSpin->setValue(10);
                 connect(m_xMaxSpin, SIGNAL(valueChanged(int)), this, SLOT(xMaxChanged(int)));
                 m_yMinSpin = new QSpinBox();
                 m_yMinSpin->setMinimum(INT_MIN);
                 m_yMinSpin->setMaximum(INT_MAX);
                 m_yMinSpin->setValue(0);
                 connect(m_yMinSpin, SIGNAL(valueChanged(int)), this, SLOT(yMinChanged(int)));
                 m_yMaxSpin = new QSpinBox();
                 m_yMaxSpin->setMinimum(INT_MIN);
                 m_yMaxSpin->setMaximum(INT_MAX);
                 m_yMaxSpin->setValue(10);
                 connect(m_yMaxSpin, SIGNAL(valueChanged(int)), this, SLOT(yMaxChanged(int)));
                 QGridLayout *grid = new QGridLayout();
-                QHBoxLayout *hbox = new QHBoxLayout();
+                QGridLayout *mainLayout = new QGridLayout();
                 //grid->addWidget(new QLabel("Add series:"), 0, 0);
                 grid->addWidget(addSeriesButton, 0, 1);
                 grid->addWidget(new QLabel("Background:"), 2, 0);
                 grid->addWidget(backgroundCombo, 2, 1);
                 grid->addWidget(m_autoScaleCheck, 3, 0);
                 grid->addWidget(new QLabel("x min:"), 4, 0);
                 grid->addWidget(m_xMinSpin, 4, 1);
                 grid->addWidget(new QLabel("x max:"), 5, 0);
                 grid->addWidget(m_xMaxSpin, 5, 1);
                 grid->addWidget(new QLabel("y min:"), 6, 0);
                 grid->addWidget(m_yMinSpin, 6, 1);
                 grid->addWidget(new QLabel("y max:"), 7, 0);
                 grid->addWidget(m_yMaxSpin, 7, 1);
                 // add row with empty label to make all the other rows static
                 grid->addWidget(new QLabel(""), 8, 0);
                 grid->setRowStretch(8, 1);
-                hbox->addLayout(grid);
+                mainLayout->addLayout(grid, 0, 0);
+                // Scatter specific settings
+                m_scatterLayout = new QGridLayout();
+                m_scatterLayout->addWidget(new QLabel("scatter"), 0, 0);
+                m_scatterLayout->setEnabled(false);
+                // Pie specific settings
+                m_pieLayout = new QGridLayout();
+                m_pieLayout->addWidget(new QLabel("Pie size factor"), 0, 0);
+                QDoubleSpinBox *pieSizeSpin = new QDoubleSpinBox();
+                pieSizeSpin->setMinimum(LONG_MIN);
+                pieSizeSpin->setMaximum(LONG_MAX);
+                pieSizeSpin->setValue(1.0);
+                pieSizeSpin->setSingleStep(0.1);
+                connect(pieSizeSpin, SIGNAL(valueChanged(double)), this, SLOT(setPieSizeFactor(double)));
+                m_pieLayout->setEnabled(false);
+                m_pieLayout->addWidget(pieSizeSpin, 0, 1);
+                mainLayout->addLayout(m_scatterLayout, 1, 0);
+                mainLayout->addLayout(m_pieLayout, 2, 0);
                 m_chartWidget = new QChartWidget(this);
                 //m_chartWidget->setColor(Qt::red);
-                hbox->addWidget(m_chartWidget);
+                mainLayout->addWidget(m_chartWidget, 0, 1, 3, 1);
             //    hbox->setStretch(1, 1);
-                setLayout(hbox);
+                setLayout(mainLayout);
                 m_autoScaleCheck->setChecked(true);
-                chartTypeChanged(4);
                 testDataChanged(0);
             }
             void MainWidget::addSeries()
             {
-                DataSerieDialog dialog(m_defaultSeries, this);
+                DataSerieDialog dialog(m_defaultSeriesName, this);
                 connect(&dialog, SIGNAL(accepted(QString, QString)), this, SLOT(addSeries(QString, QString)));
                 dialog.exec();
             }
             void MainWidget::addSeries(QString series, QString data)
             {
                 qDebug() << "addSeries: " << series << " data: " << data;
-                m_defaultSeries = series;
+                m_defaultSeriesName = series;
+                QChartSeries *newSeries = QXYChartSeries::create();
-                QXYChartSeries* series0 = QXYChartSeries::create();
                 // TODO: a dedicated data class for storing x and y values
                 QList<qreal> x;
                 QList<qreal> y;
                 if (data == "linear") {
                     for (int i = 0; i < 20; i++) {
                         x.append(i);
                         y.append(i);
                     }
                     for (int i = 0; i < 20; i++)
-                        series0->add(i, i);
+                        ((QXYChartSeries *)newSeries)->add(i, i);
                 } else if (data == "linear, 1M") {
                     for (int i = 0; i < 10000; i++) {
                         x.append(i);
                         y.append(20);
                     }
                     for (int i = 0; i < 1000000; i++)
-                        series0->add(i, 10);
+                        ((QXYChartSeries *)newSeries)->add(i, 10);
                 } else if (data == "SIN") {
                     for (int i = 0; i < 100; i++) {
                         x.append(i);
                         y.append(abs(sin(3.14159265358979 / 50 * i) * 100));
                     }
                     for (int i = 0; i < 100; i++)
-                        series0->add(i, abs(sin(3.14159265358979 / 50 * i) * 100));
+                        ((QXYChartSeries *)newSeries)->add(i, abs(sin(3.14159265358979 / 50 * i) * 100));
                 } else if (data == "SIN + random") {
                     for (qreal i = 0; i < 100; i += 0.1) {
                         x.append(i + (rand() % 5));
                         y.append(abs(sin(3.14159265358979 / 50 * i) * 100) + (rand() % 5));
                     }
                     for (qreal i = 0; i < 100; i += 0.1)
-                        series0->add(i + (rand() % 5), abs(sin(3.14159265358979 / 50 * i) * 100) + (rand() % 5));
+                        ((QXYChartSeries *)newSeries)->add(i + (rand() % 5), abs(sin(3.14159265358979 / 50 * i) * 100) + (rand() % 5));
                 } else {
                     // TODO: check if data has a valid file name
                 }
                 // TODO: color of the series
                 if (series == "Scatter") {
-                    /*QChartSeries* scatterSeries = */
+                    newSeries = m_chartWidget->createSeries(x, y, QChartSeries::SeriesTypeScatter);
-                    m_chartWidget->createSeries(x, y, QChartSeries::SeriesTypeScatter);
                 } else if (series == "Pie") {
-                    m_chartWidget->createSeries(x, y, QChartSeries::SeriesTypePie);
+                    newSeries = m_chartWidget->createSeries(x, y, QChartSeries::SeriesTypePie);
                 } else if (series == "Line") {
-                    m_chartWidget->addSeries(series0);
+                    m_chartWidget->addSeries(newSeries);
                 } else {
                     // TODO
                 }
+                setCurrentSeries(newSeries);
             }
-            void MainWidget::chartTypeChanged(int itemIndex)
+            void MainWidget::setCurrentSeries(QChartSeries *series)
             {
-                // TODO: change chart type
+                m_currentSeries = series;
-                switch (itemIndex) {
+                switch (m_currentSeries->type()) {
-                case 4:
+                case QChartSeries::SeriesTypeLine:
-                    //m_chartWidget->setType(4);
                     break;
-                default: {
+                case QChartSeries::SeriesTypeScatter:
-                    //m_chartWidget->setType(0);
+                    break;
+                case QChartSeries::SeriesTypePie:
+                    break;
+                default:
+                    Q_ASSERT(false);
                     break;
                 }
             }
             void MainWidget::testDataChanged(int itemIndex)
             {
                 qDebug() << "testDataChanged: " << itemIndex;
             //    switch (itemIndex) {
             //    case 0: {
             //        QList<QChartDataPoint> data;
             //        for (int x = 0; x < 20; x++) {
             //            data.append(QChartDataPoint() << x << x / 2);
             //        }
             //        m_chartWidget->setData(data);
             //        break;
             //    }
             //    case 1: {
             //        QList<QChartDataPoint> data;
             //        for (int x = 0; x < 100; x++) {
             //            data.append(QChartDataPoint() << x - 200 << 2 * (uint(sin(3.14159/50*x)*80) % 100));
             //        }
             //        m_chartWidget->setData(data);
             //        break;
             //    }
             //    case 2: {
             //        QList<QChartDataPoint> data;
             //        for (int x = 0; x < 1000; x++) {
             //            data.append(QChartDataPoint() << x - 200 << 2 * (uint(sin(3.14159/50*x)*80) % 100) + (rand() % 100 * 0.2));
             //            data.append(QChartDataPoint() << x - 200 << 2 * (uint(sin(3.14159/50*x)*80) % 100) + (rand() % 100 * 0.2));
             //            data.append(QChartDataPoint() << x - 200 << 2 * (uint(sin(3.14159/50*x)*80) % 100) + (rand() % 100 * 0.2));
             //        }
             //        m_chartWidget->setData(data);
             //        break;
             //    }
             //    default:
             //        break;
             //    }
             }
             void MainWidget::backgroundChanged(int itemIndex)
             {
                 qDebug() << "backgroundChanged: " << itemIndex;
             }
             void MainWidget::autoScaleChanged(int value)
             {
                 if (value) {
                     // TODO: enable auto scaling
                 } else {
                     // TODO: set scaling manually (and disable auto scaling)
                 }
                 m_xMinSpin->setEnabled(!value);
                 m_xMaxSpin->setEnabled(!value);
                 m_yMinSpin->setEnabled(!value);
                 m_yMaxSpin->setEnabled(!value);
             }
             void MainWidget::xMinChanged(int value)
             {
                 qDebug() << "xMinChanged: " << value;
             }
             void MainWidget::xMaxChanged(int value)
             {
                 qDebug() << "xMaxChanged: " << value;
             }
             void MainWidget::yMinChanged(int value)
             {
                 qDebug() << "yMinChanged: " << value;
             }
             void MainWidget::yMaxChanged(int value)
             {
                 qDebug() << "yMaxChanged: " << value;
             }
+            void MainWidget::setPieSizeFactor(double size)
+            {
+                QPieSeries *pie = qobject_cast<QPieSeries *>(m_currentSeries);
+                Q_ASSERT(pie);
+                pie->setSizeFactor(qreal(size));
+            }

test/chartwidgettest/mainwidget.h +7 -2

             #ifndef MAINWIDGET_H
             #define MAINWIDGET_H
             #include <qchartglobal.h>
             #include <qchartwidget.h>
             #include <QWidget>
             class QSpinBox;
             class QCheckBox;
+            class QGridLayout;
             QTCOMMERCIALCHART_USE_NAMESPACE
             class MainWidget : public QWidget
             {
                 Q_OBJECT
             public:
                 explicit MainWidget(QWidget *parent = 0);
             signals:
             private slots:
-                void chartTypeChanged(int itemIndex);
                 void addSeries();
                 void addSeries(QString series, QString data);
                 void testDataChanged(int itemIndex);
                 void backgroundChanged(int itemIndex);
                 void autoScaleChanged(int value);
                 void xMinChanged(int value);
                 void xMaxChanged(int value);
                 void yMinChanged(int value);
                 void yMaxChanged(int value);
+                void setCurrentSeries(QChartSeries *series);
+                void setPieSizeFactor(double margin);
             private:
                 QChartWidget *m_chartWidget;
                 QCheckBox *m_autoScaleCheck;
                 QSpinBox *m_xMinSpin;
                 QSpinBox *m_xMaxSpin;
                 QSpinBox *m_yMinSpin;
                 QSpinBox *m_yMaxSpin;
-                QString m_defaultSeries;
+                QString m_defaultSeriesName;
+                QChartSeries *m_currentSeries;
+                QGridLayout *m_scatterLayout;
+                QGridLayout *m_pieLayout;
             };
             #endif // MAINWIDGET_H

src/pie/main.cpp removed 0 -168

NO CONTENT: file was removed

src/pie/pie.pro removed 0 -15

NO CONTENT: file was removed

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