HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r2531:baa389f1ece6

Documentation and fix for box specific pen color...

Mika Salmela -

r2531:baa389f1ece6

parent child

Context file:

r2531:baa389f1ece6

Collapse all files

examples/boxplotchart/main.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include <QApplication>
             #include <QMainWindow>
             #include <QChartView>
             #include <QBoxPlotSeries>
             #include <QBoxSet>
             #include <QLegend>
             #include <QBarCategoryAxis>
             #include "boxdatareader.h"
             QTCOMMERCIALCHART_USE_NAMESPACE
             int main(int argc, char *argv[])
             {
                 QApplication a(argc, argv);
             //![1]
             //![2]
                 QBoxPlotSeries *series = new QBoxPlotSeries();
                 series->setName("Cargotec");
             //![2]
                 QFile stockData(":stock");
                 if (!stockData.open(QIODevice::ReadOnly | QIODevice::Text)) {
                     return 1;
                 }
                 BoxDataReader dataReader(&stockData);
                 while (!dataReader.atEnd()) {
                     QBoxSet *set = dataReader.readBox();
                     if (set)
                         series->append(set);
                 }
             //![3]
                 QChart *chart = new QChart();
                 chart->addSeries(series);
-                chart->setTitle("Cargotec's share deviation 2012")
+                chart->setTitle("Cargotec's share deviation in 2012");
                 chart->setAnimationOptions(QChart::SeriesAnimations);
             //![3]
             //![4]
                 chart->createDefaultAxes();
                 chart->axisY()->setMin(15.0);
             //![4]
             //![5]
                 chart->legend()->setVisible(true);
                 chart->legend()->setAlignment(Qt::AlignBottom);
             //![5]
             //![6]
                 QChartView *chartView = new QChartView(chart);
                 chartView->setRenderHint(QPainter::Antialiasing);
             //![6]
             //![7]
                 QMainWindow window;
                 window.setCentralWidget(chartView);
                 window.resize(600, 400);
                 window.show();
             //![7]
                 return a.exec();
             }

examples/qmlboxplot/qml/qmlboxplot/box.qml +6 0

             /****************************************************************************
             **
             ** Copyright (C) 2013 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             import QtQuick 1.1
             import QtCommercial.Chart 1.1
             BoxSet {
                 id: myNewBox
                 label: "Foo"
                 values: [5, 6, 7, 8, 9]
+                onPenChanged: {
+                    console.log("onPenChanged")
+                }
+                onColorChanged: {
+                    console.log("onColorChanged")
+                }
                 Component.onCompleted: {
                     console.log("BoxSet completed")
                 }
             }

examples/qmlboxplot/qml/qmlboxplot/main.qml +16 -3

             /****************************************************************************
             **
             ** Copyright (C) 2013 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             //![1]
             import QtQuick 1.0
             import QtCommercial.Chart 1.1
             ChartView {
                 title: "Box Plot series"
                 width: 400
                 height: 300
                 theme: ChartView.ChartThemeBrownSand
                 legend.alignment: Qt.AlignBottom
             //![1]
             //![2]
                 BoxPlotSeries {
                     id: plotSeries
                     name: "Income"
                     //axisX: BarCategoryAxis { categories: ["Jan", "Feb", "Mar", "Apr", "May"] }
                     BoxSet { values: [3, 4, 4.4, 6, 7] }
                     BoxSet { label: "Tok"; values: [5, 6, 7.5, 8, 12] }
                     BoxSet { label: "Kol"; values: [2, 5, 5.7, 8, 9] }
-                    BoxSet { label: "Nel"; values: [5, 6, 6.8, 7, 8] }
+                    BoxSet { id: nelBox
-                    BoxSet { label: "Vii"; values: [4, 5, 5.2, 6, 7] }
+                             label: "Nel"
+                             values: [5, 6, 6.8, 7, 8];
+                             onColorChanged: {
+                                console.log("onColorChanged")
+                             }
+                    }
+                    BoxSet { label: "Vii"; values: [4, 5, 5.2, 6, 7]; color: "#aa0000" }
+                    //onClicked: console.log("series onClicked " + boxset.median)
+                    //onHovered: console.log("series onHovered " + status + "median = " + boxset.median)
+                    onCountChanged: console.log("onCountChanged")
                 }
             //![2]
                 Rectangle {
                     id: moreButton
                     width: 50
                     height: 50
                     color: "gray"
                     MouseArea {
                         anchors.fill: parent
                         onClicked: {
+                            nelBox.color = "#0000aa"
                             var com = Qt.createComponent("box.qml")
                             if (com.status == Component.Ready) {
                                 var obj = com.createObject(moreButton)
                                 obj.lowerExtreme = 1.2
                                 console.log("lowerExtreme = " + obj.lowerExtreme)
                                 obj.lowerQuartile = 2.2
                                 console.log("lowerQuartile = " + obj.lowerQuartile)
                                 obj.median = 3.2
                                 console.log("median = " + obj.median)
                                 obj.upperQuartile = 4.2
                                 console.log("upperQuartile = " + obj.upperQuartile)
                                 obj.upperExtreme = 5.2
                                 console.log("upperExtreme = " + obj.upperExtreme)
                                 obj.label = "mik"
                                 console.log("label = " + obj.label)
                                 plotSeries.append(obj)
+                                obj.color = "#aa0000"
+                                console.log("color = " + obj.color)
+                                obj.borderColor = "#00aa00"
                             } else {
                                 console.log(com.errorString())
+                            }
                         }
                     }
                 }
             //![3]
             }
             //![3]

plugins/declarative/declarativeboxplotseries.cpp +12 -2

             /****************************************************************************
             **
             ** Copyright (C) 2013 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "declarativebarseries.h"
             #include "declarativeboxplotseries.h"
             #include "qboxset.h"
             #include "qvboxplotmodelmapper.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             DeclarativeBoxSet::DeclarativeBoxSet(const QString label, QObject *parent)
                 : QBoxSet(label, parent)
             {
                 connect(this, SIGNAL(valuesAdded(int,int)), this, SLOT(handleCountChanged(int,int)));
                 //connect(this, SIGNAL(valuesRemoved(int,int)), this, SLOT(handleCountChanged(int,int)));
             }
             void DeclarativeBoxSet::handleCountChanged(int index, int count)
             {
                 Q_UNUSED(index)
                 Q_UNUSED(count)
                 emit countChanged(QBoxSet::count());
             }
             QVariantList DeclarativeBoxSet::values()
             {
                 QVariantList values;
                 for (int i(0); i < count(); i++)
                     values.append(QVariant(QBoxSet::at(i)));
                 return values;
             }
             void DeclarativeBoxSet::setValues(QVariantList values)
             {
                 for (int i(0); i < values.count(); i++) {
                     if (values.at(i).canConvert(QVariant::Double))
                         QBoxSet::append(values[i].toDouble());
                 }
             }
-            // Declarative box&whiskers series =====================================================
+            // =====================================================
             DeclarativeBoxPlotSeries::DeclarativeBoxPlotSeries(QDeclarativeItem *parent) :
                 QBoxPlotSeries(parent),
                 m_axes(new DeclarativeAxes(this))
             {
                 connect(m_axes, SIGNAL(axisXChanged(QAbstractAxis*)), this, SIGNAL(axisXChanged(QAbstractAxis*)));
                 connect(m_axes, SIGNAL(axisYChanged(QAbstractAxis*)), this, SIGNAL(axisYChanged(QAbstractAxis*)));
                 connect(m_axes, SIGNAL(axisXTopChanged(QAbstractAxis*)), this, SIGNAL(axisXTopChanged(QAbstractAxis*)));
                 connect(m_axes, SIGNAL(axisYRightChanged(QAbstractAxis*)), this, SIGNAL(axisYRightChanged(QAbstractAxis*)));
+                connect(this, SIGNAL(hovered(bool, QBoxSet*)), this, SLOT(onHovered(bool, QBoxSet*)));
+                connect(this, SIGNAL(clicked(QBoxSet*)), this, SLOT(onClicked(QBoxSet*)));
             }
             void DeclarativeBoxPlotSeries::classBegin()
             {
             }
             void DeclarativeBoxPlotSeries::componentComplete()
             {
                 foreach (QObject *child, children()) {
                     if (qobject_cast<DeclarativeBoxSet *>(child)) {
                         QBoxPlotSeries::append(qobject_cast<DeclarativeBoxSet *>(child));
                     } else if (qobject_cast<QVBoxPlotModelMapper *>(child)) {
                         QVBoxPlotModelMapper *mapper = qobject_cast<QVBoxPlotModelMapper *>(child);
                         mapper->setSeries(this);
                     }// else if (qobject_cast<QHBarModelMapper *>(child)) { // TODO: Horisontal
                         //QHBarModelMapper *mapper = qobject_cast<QHBarModelMapper *>(child); //TODO
                         //mapper->setSeries(this);
                     //}
                 }
             }
             QDeclarativeListProperty<QObject> DeclarativeBoxPlotSeries::seriesChildren()
             {
                 return QDeclarativeListProperty<QObject>(this, 0, &DeclarativeBoxPlotSeries::appendSeriesChildren);
             }
             void DeclarativeBoxPlotSeries::appendSeriesChildren(QDeclarativeListProperty<QObject> * list, QObject *element)
             {
                 // Empty implementation; the children are parsed in componentComplete instead
                 Q_UNUSED(list);
                 Q_UNUSED(element);
             }
             DeclarativeBoxSet *DeclarativeBoxPlotSeries::at(int index)
             {
-                qDebug() << "DeclarativeBoxPlotSeries::at";
                 QList<QBoxSet *> setList = boxSets();
                 if (index >= 0 && index < setList.count())
                     return qobject_cast<DeclarativeBoxSet *>(setList[index]);
                 return 0;
             }
             DeclarativeBoxSet *DeclarativeBoxPlotSeries::insert(int index, const QString label, QVariantList values)
             {
                 DeclarativeBoxSet *barset = new DeclarativeBoxSet(label, this);
                 barset->setValues(values);
                 if (QBoxPlotSeries::insert(index, barset))
                     return barset;
                 delete barset;
                 return 0;
             }
+            void DeclarativeBoxPlotSeries::onHovered(bool status, QBoxSet *boxset)
+            {
+                emit hovered(status, qobject_cast<DeclarativeBoxSet *>(boxset));
+            }
+            void DeclarativeBoxPlotSeries::onClicked(QBoxSet *boxset)
+            {
+                emit clicked(qobject_cast<DeclarativeBoxSet *>(boxset));
+            }
             #include "moc_declarativeboxplotseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

plugins/declarative/declarativeboxplotseries.h +4 0

             /****************************************************************************
             **
             ** Copyright (C) 2013 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef DECLARATIVEBOXPLOT_H
             #define DECLARATIVEBOXPLOT_H
             #include "qboxset.h"
             #include "declarativeaxes.h"
             #include "qboxplotseries.h"
             #include <QtDeclarative/QDeclarativeItem>
             #include <QtDeclarative/QDeclarativeParserStatus>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class DeclarativeBoxSet : public QBoxSet
             {
                 Q_OBJECT
                 Q_PROPERTY(QVariantList values READ values WRITE setValues)
                 Q_PROPERTY(QString label READ label WRITE setLabel)
                 Q_PROPERTY(int count READ count NOTIFY countChanged)
                 Q_PROPERTY(qreal lowerExtreme READ lowerExtreme WRITE setLowerExtreme)
                 Q_PROPERTY(qreal lowerQuartile READ lowerQuartile WRITE setLowerQuartile)
                 Q_PROPERTY(qreal median READ median WRITE setMedian)
                 Q_PROPERTY(qreal upperQuartile READ upperQuartile WRITE setUpperQuartile)
                 Q_PROPERTY(qreal upperExtreme READ upperExtreme WRITE setUpperExtreme)
             public:
                 explicit DeclarativeBoxSet(const QString label = "", QObject *parent = 0);
                 QVariantList values();
                 void setValues(QVariantList values);
             public: // From QBoxSet
                 Q_INVOKABLE void append(qreal value) { QBoxSet::append(value); }
                 Q_INVOKABLE void replace(int index, qreal value) { QBoxSet::replace(index, value); }
                 Q_INVOKABLE qreal at(int index) { return QBoxSet::at(index); }
             Q_SIGNALS:
                 void countChanged(int count);
             private Q_SLOTS:
                 void handleCountChanged(int index, int count);
             };
             class DeclarativeBoxPlotSeries : public QBoxPlotSeries, public QDeclarativeParserStatus
             {
                 Q_OBJECT
                 Q_INTERFACES(QDeclarativeParserStatus)
                 Q_PROPERTY(QAbstractAxis *axisX READ axisX WRITE setAxisX NOTIFY axisXChanged REVISION 1)
                 Q_PROPERTY(QAbstractAxis *axisY READ axisY WRITE setAxisY NOTIFY axisYChanged REVISION 1)
                 Q_PROPERTY(QAbstractAxis *axisXTop READ axisXTop WRITE setAxisXTop NOTIFY axisXTopChanged REVISION 2)
                 Q_PROPERTY(QAbstractAxis *axisYRight READ axisYRight WRITE setAxisYRight NOTIFY axisYRightChanged REVISION 2)
                 Q_PROPERTY(QDeclarativeListProperty<QObject> seriesChildren READ seriesChildren)
                 Q_CLASSINFO("DefaultProperty", "seriesChildren")
             public:
                 explicit DeclarativeBoxPlotSeries(QDeclarativeItem *parent = 0);
                 QAbstractAxis *axisX() { return m_axes->axisX(); }
                 void setAxisX(QAbstractAxis *axis) { m_axes->setAxisX(axis); }
                 QAbstractAxis *axisY() { return m_axes->axisY(); }
                 void setAxisY(QAbstractAxis *axis) { m_axes->setAxisY(axis); }
                 Q_REVISION(2) QAbstractAxis *axisXTop() { return m_axes->axisXTop(); }
                 Q_REVISION(2) void setAxisXTop(QAbstractAxis *axis) { m_axes->setAxisXTop(axis); }
                 Q_REVISION(2) QAbstractAxis *axisYRight() { return m_axes->axisYRight(); }
                 Q_REVISION(2) void setAxisYRight(QAbstractAxis *axis) { m_axes->setAxisYRight(axis); }
                 QDeclarativeListProperty<QObject> seriesChildren();
             public:
                 Q_INVOKABLE DeclarativeBoxSet *at(int index);
                 Q_INVOKABLE DeclarativeBoxSet *append(const QString label, QVariantList values) { return insert(count(), label, values); }
                 Q_INVOKABLE void append(DeclarativeBoxSet *box) { QBoxPlotSeries::append(box); }
                 Q_INVOKABLE DeclarativeBoxSet *insert(int index, const QString label, QVariantList values);
                 Q_INVOKABLE bool remove(QBoxSet *boxset) { return QBoxPlotSeries::remove(boxset); }
                 Q_INVOKABLE void clear() { return QBoxPlotSeries::clear(); }
             public: // from QDeclarativeParserStatus
                 void classBegin();
                 void componentComplete();
             Q_SIGNALS:
                 Q_REVISION(1) void axisXChanged(QAbstractAxis *axis);
                 Q_REVISION(1) void axisYChanged(QAbstractAxis *axis);
                 Q_REVISION(2) void axisXTopChanged(QAbstractAxis *axis);
                 Q_REVISION(2) void axisYRightChanged(QAbstractAxis *axis);
+                void clicked(DeclarativeBoxSet *boxset);
+                void hovered(bool status, DeclarativeBoxSet *boxset);
             public Q_SLOTS:
                 static void appendSeriesChildren(QDeclarativeListProperty<QObject> *list, QObject *element);
+                void onHovered(bool status, QBoxSet *boxset);
+                void onClicked(QBoxSet *boxset);
             public:
                 DeclarativeAxes *m_axes;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // DECLARATIVEBOXPLOT_H

src/boxplotchart/boxplotchartitem.cpp 0 -2

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "boxplotchartitem_p.h"
             #include "qboxplotseries_p.h"
             #include "bar_p.h"
             #include "qboxset_p.h"
             #include "qabstractbarseries_p.h"
             #include "qboxset.h"
             #include "boxwhiskers_p.h"
             #include <QPainter>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             BoxPlotChartItem::BoxPlotChartItem(QBoxPlotSeries *series, QGraphicsItem* item) :
                 ChartItem(series->d_func(), item),
                 m_series(series),
                 m_animation(0),
                 m_animate(0),
                 m_domainMaxY(0.0),
                 m_domainMinY(0.0)
             {
                 connect(series, SIGNAL(boxsetsRemoved(QList<QBoxSet*>)), this, SLOT(handleBoxsetRemove(QList<QBoxSet*>)));
                 connect(series->d_func(), SIGNAL(restructuredBoxes()), this, SLOT(handleDataStructureChanged()));
                 connect(series->d_func(), SIGNAL(updatedLayout()), this, SLOT(handleLayoutChanged()));
                 connect(series->d_func(), SIGNAL(updatedBoxes()), this, SLOT(handleUpdatedBars()));
                 connect(series->d_func(), SIGNAL(updated()), this, SLOT(handleUpdatedBars()));
                 // QBoxPlotSeriesPrivate calls handleDataStructureChanged(), don't do it here
                 setZValue(ChartPresenter::BoxPlotSeriesZValue);
             }
             BoxPlotChartItem::~BoxPlotChartItem()
             {
                 qDebug() << "BoxPlotChartItem::~BoxPlotChartItem() " << m_seriesIndex;
             }
             void BoxPlotChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(painter);
                 Q_UNUSED(option);
                 Q_UNUSED(widget);
                 //painter->setClipRect(QRectF(QPointF(0,0),domain()->size()));
                 //qDebug() << "ALERT EMPTY: BoxPlotChartItem::paint";
             }
             void BoxPlotChartItem::setAnimation(BoxPlotAnimation *animation)
             {
                 //qDebug() << "BoxPlotChartItem::setAnimation :" << animation;
                 m_animation = animation;
                 if (m_animation) {
                     foreach (BoxWhiskers *item, m_boxTable.values()) {
                         m_animation->addBox(item);
                     }
                     handleDomainUpdated();
                 }
             }
             void BoxPlotChartItem::handleDataStructureChanged()
             {
                 qDebug() << "BoxPlotChartItem::handleDataStructureChanged()";
                 int setCount = m_series->count();
                 for (int s = 0; s < setCount; s++) {
                     QBoxSet *set = m_series->d_func()->boxsetAt(s);
                     BoxWhiskers *box = m_boxTable.value(set);
                     if (!box) {
                         // Item is not yet created, make a box and add it to hash table
                         box = new BoxWhiskers(set, domain(), this);
                         m_boxTable.insert(set, box);
                         connect(box, SIGNAL(clicked(QBoxSet *)), m_series, SIGNAL(clicked(QBoxSet*)));
                         connect(box, SIGNAL(hovered(bool,QBoxSet*)), m_series, SIGNAL(hovered(bool,QBoxSet*)));
                         connect(box, SIGNAL(clicked(QBoxSet*)), set, SIGNAL(clicked()));
                         connect(box, SIGNAL(hovered(bool,QBoxSet*)), set, SIGNAL(hovered(bool)));
                         // Set the decorative issues for the newly created box
                         box->setBrush(m_series->brush());
                         box->setPen(m_series->pen());
                     }
                     updateBoxGeometry(box, s);
                     box->updateGeometry();
                     if (m_animation)
                         m_animation->addBox(box);
                 }
                 //
                 handleDomainUpdated();
             }
             void BoxPlotChartItem::handleUpdatedBars()
             {
-                qDebug() << "BoxPlotChartItem::handleUpdatedBars()";
                 foreach (BoxWhiskers *item, m_boxTable.values()) {
                     item->setBrush(m_series->brush());
                     item->setPen(m_series->pen());
                 }
                 // Override with QBoxSet specific settings
                 foreach (QBoxSet *set, m_boxTable.keys()) {
                     if (set->brush().style() != Qt::NoBrush)
                         m_boxTable.value(set)->setBrush(set->brush());
                     if (set->pen().style() != Qt::NoPen)
                         m_boxTable.value(set)->setPen(set->pen());
                 }
             }
             void BoxPlotChartItem::handleBoxsetRemove(QList<QBoxSet*> barSets)
             {
                 //qDebug() << "BoxPlotChartItem::handleBarsetRemove";
                 foreach (QBoxSet *set, barSets) {
                     BoxWhiskers *boxItem = m_boxTable.value(set);
                     m_boxTable.remove(set);
                     delete boxItem;
                 }
                 // We trust that series emits the restructuredBars, which handles restructuring
             }
             void BoxPlotChartItem::handleDomainUpdated()
             {
                 //qDebug() << "BoxPlotChartItem::handleDomainUpdated() domain()->size() = " << domain()->size();
                 if ((domain()->size().width() <= 0) || (domain()->size().height() <= 0))
                     return;
                 // Set my bounding rect to same as domain size
                 m_boundingRect.setRect(0.0, 0.0, domain()->size().width(), domain()->size().height());
                 foreach (BoxWhiskers *item, m_boxTable.values()) {
                     // Update the domain size for each BoxWhisker item
                     item->setDomainSize(domain()->size());
                     if (domain()->minY() != m_domainMinY || domain()->maxY() != m_domainMaxY) {
                         item->updateGeometry();
                         m_domainMinY = domain()->minY();
                         m_domainMaxY = domain()->maxY();
                         qDebug() << "Updating";
                     }
                     // If the animation is set, start the animation for each BoxWhisker item
                     if (m_animation) {
                         presenter()->startAnimation(m_animation->boxAnimation(item));
                     }
                 }
             }
             void BoxPlotChartItem::handleLayoutChanged()
             {
                 qDebug() << "BoxPlotChartItem::handleLayoutChanged";
                 foreach (BoxWhiskers *item, m_boxTable.values()) {
                     if (m_animation)
                         m_animation->setAnimationStart(item);
                     bool dirty = updateBoxGeometry(item, item->m_data.m_index);
                     if (dirty && m_animation)
                         presenter()->startAnimation(m_animation->boxChangeAnimation(item));
                     else
                         item->updateGeometry();
                 }
             }
             QRectF BoxPlotChartItem::boundingRect() const
             {
                 return m_boundingRect;
             }
             void BoxPlotChartItem::initializeLayout()
             {
                 qDebug() << "ALERT EMPTY: BoxPlotChartItem::initializeLayout";
             }
             QVector<QRectF> BoxPlotChartItem::calculateLayout()
             {
                 qDebug() << "ALERT EMPTY: BoxPlotChartItem::calculateLayout()";
                 return QVector<QRectF>();
             }
             bool BoxPlotChartItem::updateBoxGeometry(BoxWhiskers *box, int index)
             {
                 bool changed = false;
                 QBoxSet *set = m_series->d_func()->boxsetAt(index);
                 BoxWhiskersData &data = box->m_data;
                 if ((data.m_lowerExtreme != set->at(0)) || (data.m_lowerQuartile != set->at(1)) ||
                     (data.m_median != set->at(2)) || (data.m_upperQuartile != set->at(3)) || (data.m_upperExtreme != set->at(4)))
                     changed = true;
                 data.m_lowerExtreme = set->at(0);
                 data.m_lowerQuartile = set->at(1);
                 data.m_median = set->at(2);
                 data.m_upperQuartile = set->at(3);
                 data.m_upperExtreme = set->at(4);
                 data.m_index = index;
                 data.m_boxItems = m_series->count();
                 data.m_maxX = domain()->maxX();
                 data.m_minX = domain()->minX();
                 data.m_maxY = domain()->maxY();
                 data.m_minY = domain()->minY();
                 data.m_seriesIndex = m_seriesIndex;
                 data.m_seriesCount = m_seriesCount;
                 return changed;
             }
             #include "moc_boxplotchartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/boxplotchart/qboxplotseries.cpp +47 -4

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "qboxplotseries.h"
             #include "qboxplotseries_p.h"
             #include "qboxplotlegendmarker.h"
             #include "qbarcategoryaxis.h"
             #include "boxplotchartitem_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             #include "qvalueaxis.h"
             #include "charttheme_p.h"
             #include "boxplotanimation_p.h"
             #include "qchart_p.h"
             #include "qboxset.h"
             #include "qboxset_p.h"
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QBoxPlotSeries
                 \brief Series for creating box-and-whiskers chart
                 \mainclass
                 QBoxPlotSeries represents a series of data shown as box-and-whisker bars. The purpose of this class is to act as
-                a container for single box-and-whisker items. Each item is drawn to own slot. If chart includes multiple QBoxPlotSeries
+                a container for single box-and-whisker items. Each item is drawn to own slot. If chart includes multiple instances of
-                items with the same index are drawn to same slot.
+                QBoxPlotSeries then box-and-whiskers items with the same index are drawn to same slot.
                 See the \l {Box and Whiskers Example} {box-and-whiskers chart example} to learn how to create a box-and-whiskers chart.
                 \image examples_boxplotchart.png
                 \sa QBoxSet
             */
             /*!
                 \qmlclass BoxPlotSeries QBoxPlotSeries
-                \inherits AbstractBarSeries
+                \inherits QAbstractSeries
+                BoxPlotSeries represents a series of data shown as box-and-whisker bars. The purpose of this class is to act as
+                a container for single box-and-whisker items. Each item is drawn to own slot. If chart includes multiple instances of
+                BoxPlotSeries then box-and-whiskers items with the same index are drawn to same slot.
                 The following QML shows how to create a simple box-and-whiskers chart:
                 \snippet ../examples/qmlboxplot/qml/qmlboxplot/main.qml 1
                 \beginfloatleft
-                \image demos_qmlchart7.png
+                \image TODO_CREATE_IMAGE.png
                 \endfloat
                 \clearfloat
             */
             /*!
                 \fn QBoxPlotSeries::boxsetsAdded(QList<QBoxSet *> sets)
                 \brief Signal is emitted when a new \a sets of box-and-whiskers data is added to the series.
             */
             /*!
                 \fn QBoxPlotSeries::boxsetsRemoved(QList<QBoxSet *> sets)
                 \brief Signal is emitted when \a sets of box-and-whiskers data is removed from the series.
             */
             /*!
                 \fn QBoxPlotSeries::clicked(QBoxSet *boxset)
                 \brief Signal is emitted when the user clicks the \a boxset on the chart.
             */
             /*!
                 \fn QBoxPlotSeries::hovered(bool status, QBoxSet *boxset)
                 \brief Signal is emitted when there is change in hover \a status over \a boxset.
             */
             /*!
                 \fn QBoxPlotSeries::countChanged()
                 \brief Signal is emitted when there is change in count of box-and-whiskers items in the series.
             */
+            /*!
+                \qmlmethod BoxPlotSeries::append(const QString label, QVariantList values)
+                Appends a new box-and-whiskers set with \a label and \a values to the series.
+             */
+            /*!
+                \qmlmethod BoxPlotSeries::append(BoxSet *box)
+                Appends the \a box to the series.
+            */
+            /*!
+                \qmlmethod BoxPlotSeries::insert(int index, const QString label, QVariantList values)
+                Inserts a new box-and-whiskers set with \a label and \a values at the \a index position.
+            */
+            /*!
+                \qmlmethod BoxPlotSeries::remove(QBoxSet *boxset)
+                Removes the \a boxset from the series.
+            */
+            /*!
+                \qmlmethod BoxPlotSeries::clear()
+                Removes all boxsets from the series. Deletes removed sets.
+            */
+            /*!
+                \qmlsignal BoxPlotSeries::onClicked(BoxSet boxset);
+                Signal is emitted when the user clicks the \a boxset on the chart.
+            */
+            /*!
+                \qmlsignal BoxPlotSeries::onHovered(bool status, BoxSet boxset);
+                Signal is emitted when there is change in hover \a status over \a boxset.
+            */
+            /*!
+                \qmlsignal BoxPlotSeries::onCountChanged();
+                Signal is emitted when there is change in count of box-and-whiskers items in the series.
+            */
+            /*
+                void boxsetsAdded(QList<QBoxSet *> sets);
+            */
+            /*
+                void boxsetsRemoved(QList<QBoxSet *> sets);
+            */
             /*!
                 Constructs empty QBoxPlotSeries.
                 QBoxPlotSeries is QObject which is a child of a \a parent.
             */
             QBoxPlotSeries::QBoxPlotSeries(QObject *parent)
                 : QAbstractSeries(*new QBoxPlotSeriesPrivate(this), parent)
             {
             }
             /*!
                 Destructor. Removes series from chart.
             */
             QBoxPlotSeries::~QBoxPlotSeries()
             {
                 qDebug() << "QBoxPlotSeries::~QBoxPlotSeries";
                 Q_D(QBoxPlotSeries);
                 if (d->m_chart)
                     d->m_chart->removeSeries(this);
             }
             /*!
                 Adds a single box and whiskers set to series. Takes ownership of the \a set. If the set is null or is already in series, it won't be appended.
                 Returns true, if appending succeeded.
             */
             bool QBoxPlotSeries::append(QBoxSet *set)
             {
                 Q_D(QBoxPlotSeries);
                 bool success = d->append(set);
                 if (success) {
                     QList<QBoxSet *> sets;
                     sets.append(set);
                     set->setParent(this);
                     emit boxsetsAdded(sets);
                     emit countChanged();
                 }
                 return success;
             }
             /*!
                 Removes boxset from the series. Releases ownership of the \a set. Deletes the set, if remove
                 was successful.
                 Returns true, if the set was removed.
             */
             bool QBoxPlotSeries::remove(QBoxSet *set)
             {
                 Q_D(QBoxPlotSeries);
                 bool success = d->remove(set);
                 if (success) {
                     QList<QBoxSet *> sets;
                     sets.append(set);
                     set->setParent(0);
                     emit boxsetsRemoved(sets);
                     emit countChanged();
                     delete set;
                     set = 0;
                 }
                 return success;
             }
             /*!
                 Takes a single \a set from the series. Does not delete the boxset object.
                 NOTE: The series remains as the boxset's parent object. You must set the
                 parent object to take full ownership.
                 Returns true if take was successful.
             */
             bool QBoxPlotSeries::take(QBoxSet *set)
             {
                 Q_D(QBoxPlotSeries);
                 bool success = d->remove(set);
                 if (success) {
                     QList<QBoxSet *> sets;
                     sets.append(set);
                     emit boxsetsRemoved(sets);
                     emit countChanged();
                 }
                 return success;
             }
             /*!
                 Adds a list of boxsets to series. Takes ownership of the \a sets.
                 Returns true, if all sets were appended successfully. If any of the sets is null or is already appended to series,
                 nothing is appended and function returns false. If any of the sets is in list more than once, nothing is appended
                 and function returns false.
             */
             bool QBoxPlotSeries::append(QList<QBoxSet *> sets)
             {
                 Q_D(QBoxPlotSeries);
                 bool success = d->append(sets);
                 if (success) {
                     emit boxsetsAdded(sets);
                     emit countChanged();
                 }
                 return success;
             }
             /*!
                 Insert a set of bars to series at \a index postion. Takes ownership of \a set. If the set is null or is already in series, it won't be appended.
                 Returns true, if inserting succeeded.
             */
             bool QBoxPlotSeries::insert(int index, QBoxSet *set)
             {
                 Q_D(QBoxPlotSeries);
                 bool success = d->insert(index, set);
                 if (success) {
                     QList<QBoxSet *> sets;
                     sets.append(set);
                     emit boxsetsAdded(sets);
                     emit countChanged();
                 }
                 return success;
             }
             /*!
                 Removes all boxsets from the series. Deletes removed sets.
             */
             void QBoxPlotSeries::clear()
             {
                 Q_D(QBoxPlotSeries);
                 QList<QBoxSet *> sets = boxSets();
                 bool success = d->remove(sets);
                 if (success) {
                     emit boxsetsRemoved(sets);
                     emit countChanged();
                     foreach (QBoxSet *set, sets)
                         delete set;
                 }
             }
             /*!
                 Returns number of sets in series.
             */
             int QBoxPlotSeries::count() const
             {
                 Q_D(const QBoxPlotSeries);
                 return d->m_boxSets.count();
             }
             /*!
                 Returns a list of sets in series. Keeps ownership of sets.
              */
             QList<QBoxSet *> QBoxPlotSeries::boxSets() const
             {
                 Q_D(const QBoxPlotSeries);
                 return d->m_boxSets;
             }
             /*!
                 Returns QChartSeries::SeriesTypeBoxPlot.
             */
             QAbstractSeries::SeriesType QBoxPlotSeries::type() const
             {
                 return QAbstractSeries::SeriesTypeBoxPlot;
             }
             /*!
                 Sets brush for the series. Box-and-whiskers items are drawn using \a brush
             */
             void QBoxPlotSeries::setBrush(const QBrush &brush)
             {
                 Q_D(QBoxPlotSeries);
                 if (d->m_brush != brush) {
                     d->m_brush = brush;
                     emit d->updated();
                 }
             }
             /*!
                 Returns brush of the series.
             */
             QBrush QBoxPlotSeries::brush() const
             {
                 Q_D(const QBoxPlotSeries);
                 return d->m_brush;
             }
             /*!
                 Sets pen for the series. Box-and-whiskers items are drawn using \a pen
             */
             void QBoxPlotSeries::setPen(const QPen &pen)
             {
                 Q_D(QBoxPlotSeries);
                 if (d->m_pen != pen) {
                     d->m_pen = pen;
                     emit d->updated();
                 }
             }
             /*!
                 Returns the pen of this series.
             */
             QPen QBoxPlotSeries::pen() const
             {
                 Q_D(const QBoxPlotSeries);
                 return d->m_pen;
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QBoxPlotSeriesPrivate::QBoxPlotSeriesPrivate(QBoxPlotSeries *q)
                 : QAbstractSeriesPrivate(q),
                   m_pen(QPen(Qt::NoPen)),
                   m_brush(QBrush(Qt::NoBrush))
             {
             }
             QBoxPlotSeriesPrivate::~QBoxPlotSeriesPrivate()
             {
                 qDebug() << "QBoxPlotSeriesPrivate::~QBoxPlotSeriesPrivate()";
                 disconnect(this, 0, 0, 0);
             }
             void QBoxPlotSeriesPrivate::initializeDomain()
             {
                 qreal minX(domain()->minX());
                 qreal minY(domain()->minY());
                 qreal maxX(domain()->maxX());
                 qreal maxY(domain()->maxY());
                 qreal x = m_boxSets.count();
                 minX = qMin(minX, - (qreal)0.5);
                 minY = qMin(minY, bottom());
                 maxX = qMax(maxX, x - (qreal)0.5);
                 maxY = qMax(maxY, max());
                 domain()->setRange(minX, maxX, minY, maxY);
             }
             void QBoxPlotSeriesPrivate::initializeAxes()
             {
                 foreach (QAbstractAxis* axis, m_axes) {
                     if (axis->type() == QAbstractAxis::AxisTypeBarCategory) {
                         if (axis->orientation() == Qt::Horizontal)
                             populateCategories(qobject_cast<QBarCategoryAxis *>(axis));
                         else
                             qDebug() << "ALERT: QBoxPlotSeriesPrivate::initializeAxes implement #1";
                     }
                 }
             }
             QAbstractAxis::AxisType QBoxPlotSeriesPrivate::defaultAxisType(Qt::Orientation orientation) const
             {
                 if (orientation == Qt::Horizontal)
                     return QAbstractAxis::AxisTypeBarCategory;
                 return QAbstractAxis::AxisTypeValue;
             }
             QAbstractAxis* QBoxPlotSeriesPrivate::createDefaultAxis(Qt::Orientation orientation) const
             {
                 Q_UNUSED(orientation);
                 // This is not implemented even in barseries, keep in touch if something needs this
                 qDebug() << "ALERT: QBoxPlotSeriesPrivate::createDefaultAxis implement";
                 return 0;
             }
             void QBoxPlotSeriesPrivate::populateCategories(QBarCategoryAxis *axis)
             {
                 QStringList categories;
                 if (axis->categories().isEmpty()) {
                     for (int i(1); i < m_boxSets.count() + 1; i++) {
                         QBoxSet *set = m_boxSets.at(i - 1);
                         if (set->label().isEmpty())
                             categories << QString::number(i);
                         else
                             categories << set->label();
                     }
                     axis->append(categories);
                 }
             }
             void QBoxPlotSeriesPrivate::initializeGraphics(QGraphicsItem* parent)
             {
                 Q_Q(QBoxPlotSeries);
                 BoxPlotChartItem *boxPlot = new BoxPlotChartItem(q,parent);
                 m_item.reset(boxPlot);
                 QAbstractSeriesPrivate::initializeGraphics(parent);
                 if (m_chart) {
                     connect(m_chart->d_ptr->m_dataset, SIGNAL(seriesAdded(QAbstractSeries*)), this, SLOT(handleSeriesChange(QAbstractSeries*)) );
                     connect(m_chart->d_ptr->m_dataset, SIGNAL(seriesRemoved(QAbstractSeries*)), this, SLOT(handleSeriesRemove(QAbstractSeries*)) );
                     QList<QAbstractSeries *> serieses = m_chart->series();
                     // Tries to find this series from the Chart's list of serieses and deduce the index
                     int index = 0;
                     foreach (QAbstractSeries *s, serieses) {
                         if (s->type() == QAbstractSeries::SeriesTypeBoxPlot) {
                             if (q == static_cast<QBoxPlotSeries *>(s)) {
                                 boxPlot->m_seriesIndex = index;
                                 m_index = index;
                             }
                             index++;
                         }
                     }
                     boxPlot->m_seriesCount = index;
                 }
                 // Make BoxPlotChartItem to instantiate box & whisker items
                 boxPlot->handleDataStructureChanged();
             }
             void QBoxPlotSeriesPrivate::initializeTheme(int index, ChartTheme* theme, bool forced)
             {
                 Q_Q(QBoxPlotSeries);
                 qDebug() << "QBoxPlotSeriesPrivate::initializeTheme";
                 const QList<QGradient> gradients = theme->seriesGradients();
                 if (forced || m_brush == QBrush(Qt::NoBrush)) {
                     QColor brushColor = ChartThemeManager::colorAt(gradients.at(index % gradients.size()), 0.5);
                     q->setBrush(brushColor);
                 }
                 if (forced || m_pen == QPen(Qt::NoPen)) {
                     QPen pen = theme->outlinePen();
                     pen.setCosmetic(true);
                     q->setPen(pen);
                 }
             }
             void QBoxPlotSeriesPrivate::initializeAnimations(QtCommercialChart::QChart::AnimationOptions options)
             {
                 BoxPlotChartItem *item = static_cast<BoxPlotChartItem *>(m_item.data());
                 Q_ASSERT(item);
                 if (options.testFlag(QChart::SeriesAnimations)) {
                     item->setAnimation(new BoxPlotAnimation(item));
                 }else{
                     item->setAnimation((BoxPlotAnimation *)0);
                 }
                 QAbstractSeriesPrivate::initializeAnimations(options);
             }
             QList<QLegendMarker*> QBoxPlotSeriesPrivate::createLegendMarkers(QLegend *legend)
             {
                 Q_Q(QBoxPlotSeries);
                 QList<QLegendMarker*> list;
                 return list << new QBoxPlotLegendMarker(q, legend);
             }
             void QBoxPlotSeriesPrivate::handleSeriesRemove(QAbstractSeries *series)
             {
                 qDebug() << "QBoxPlotSeriesPrivate::handleSeriesRemove";
                 Q_Q(QBoxPlotSeries);
                 QBoxPlotSeries *removedSeries = static_cast<QBoxPlotSeries *>(series);
                 QObject::disconnect(m_chart->d_ptr->m_dataset, 0, removedSeries->d_func(), 0);
                 // Test if series removed is me, then don't do anything
                 if (q != removedSeries) {
                     BoxPlotChartItem *item = static_cast<BoxPlotChartItem *>(m_item.data());
                     if (item) {
                         item->m_seriesCount = item->m_seriesCount - 1;
                         if (removedSeries->d_func()->m_index < m_index) {
                             m_index--;
                             item->m_seriesIndex = m_index;
                         }
                         item->handleDataStructureChanged();
                     }
                 }
             }
             void QBoxPlotSeriesPrivate::handleSeriesChange(QAbstractSeries *series)
             {
                 Q_UNUSED(series);
                 Q_Q(QBoxPlotSeries);
                 BoxPlotChartItem *boxPlot = static_cast<BoxPlotChartItem *>(m_item.data());
                 if (m_chart) {
                     QList<QAbstractSeries *> serieses = m_chart->series();
                     // Tries to find this series from the Chart's list of serieses and deduce the index
                     int index = 0;
                     foreach (QAbstractSeries *s, serieses) {
                         if (s->type() == QAbstractSeries::SeriesTypeBoxPlot) {
                             if (q == static_cast<QBoxPlotSeries *>(s)) {
                                 boxPlot->m_seriesIndex = index;
                                 m_index = index;
                             }
                             index++;
                         }
                     }
                     boxPlot->m_seriesCount = index;
                 }
                 boxPlot->handleDataStructureChanged();
             }
             bool QBoxPlotSeriesPrivate::append(QBoxSet *set)
             {
                 if ((m_boxSets.contains(set)) || (set == 0))
                     return false; // Fail if set is already in list or set is null.
                 m_boxSets.append(set);
                 QObject::connect(set->d_ptr.data(), SIGNAL(updatedLayout()), this, SIGNAL(updatedLayout()));
                 QObject::connect(set->d_ptr.data(), SIGNAL(updatedBox()), this, SIGNAL(updatedBoxes()));
                 QObject::connect(set->d_ptr.data(), SIGNAL(restructuredBox()), this, SIGNAL(restructuredBoxes()));
                 emit restructuredBoxes(); // this notifies boxplotchartitem
                 return true;
             }
             bool QBoxPlotSeriesPrivate::remove(QBoxSet *set)
             {
                 if (!m_boxSets.contains(set))
                     return false; // Fail if set is not in list
                 m_boxSets.removeOne(set);
                 QObject::disconnect(set->d_ptr.data(), SIGNAL(updatedLayout()), this, SIGNAL(updatedLayout()));
                 QObject::disconnect(set->d_ptr.data(), SIGNAL(updatedBox()), this, SIGNAL(updatedBoxes()));
                 QObject::disconnect(set->d_ptr.data(), SIGNAL(restructuredBox()), this, SIGNAL(restructuredBoxes()));
                 emit restructuredBoxes(); // this notifies boxplotchartitem
                 return true;
             }
             bool QBoxPlotSeriesPrivate::append(QList<QBoxSet * > sets)
             {
                 foreach (QBoxSet *set, sets) {
                     if ((set == 0) || (m_boxSets.contains(set)))
                         return false; // Fail if any of the sets is null or is already appended.
                     if (sets.count(set) != 1)
                         return false; // Also fail if same set is more than once in given list.
                 }
                 foreach (QBoxSet *set, sets) {
                     m_boxSets.append(set);
                     QObject::connect(set->d_ptr.data(), SIGNAL(updatedLayout()), this, SIGNAL(updatedLayout()));
                     QObject::connect(set->d_ptr.data(), SIGNAL(updatedBox()), this, SIGNAL(updatedBoxes()));
                     QObject::connect(set->d_ptr.data(), SIGNAL(restructuredBox()), this, SIGNAL(restructuredBoxes()));
                 }
                 emit restructuredBoxes(); // this notifies boxplotchartitem
                 return true;
             }
             bool QBoxPlotSeriesPrivate::remove(QList<QBoxSet * > sets)
             {
                 if (sets.count() == 0)
                     return false;
                 foreach (QBoxSet *set, sets) {
                     if ((set == 0) || (!m_boxSets.contains(set)))
                         return false; // Fail if any of the sets is null or is not in series
                     if (sets.count(set) != 1)
                         return false; // Also fail if same set is more than once in given list.
                 }
                 foreach (QBoxSet *set, sets) {
                     m_boxSets.removeOne(set);
                     QObject::disconnect(set->d_ptr.data(), SIGNAL(updatedLayout()), this, SIGNAL(updatedLayout()));
                     QObject::disconnect(set->d_ptr.data(), SIGNAL(updatedBox()), this, SIGNAL(updatedBoxes()));
                     QObject::disconnect(set->d_ptr.data(), SIGNAL(restructuredBox()), this, SIGNAL(restructuredBoxes()));
                 }
                 emit restructuredBoxes();        // this notifies boxplotchartitem
                 return true;
             }
             bool QBoxPlotSeriesPrivate::insert(int index, QBoxSet *set)
             {
                 if ((m_boxSets.contains(set)) || (set == 0))
                     return false; // Fail if set is already in list or set is null.
                 m_boxSets.insert(index, set);
                 QObject::connect(set->d_ptr.data(), SIGNAL(updatedLayout()), this, SIGNAL(updatedLayout()));
                 QObject::connect(set->d_ptr.data(), SIGNAL(updatedBox()), this, SIGNAL(updatedBoxes()));
                 QObject::connect(set->d_ptr.data(), SIGNAL(restructuredBox()), this, SIGNAL(restructuredBoxes()));
                 emit restructuredBoxes();      // this notifies boxplotchartitem
                 return true;
             }
             QBoxSet *QBoxPlotSeriesPrivate::boxsetAt(int index)
             {
                 return m_boxSets.at(index);
             }
             qreal QBoxPlotSeriesPrivate::bottom()
             {
                 // Returns bottom of all boxes
                 qreal bottom(0);
                 foreach (QBoxSet *set, m_boxSets) {
                     for (int i = 0; i < set->count(); i++) {
                         if (set->at(i) < bottom)
                             bottom = set->at(i);
                     }
                 }
                 return bottom;
             }
             qreal QBoxPlotSeriesPrivate::max()
             {
                 if (m_boxSets.count() <= 0)
                     return 0;
                 qreal max = INT_MIN;
                 foreach (QBoxSet *set, m_boxSets) {
                     for (int i = 0; i < set->count(); i++) {
                         if (set->at(i) > max)
                             max = set->at(i);
                     }
                 }
                 return max;
             }
             #include "moc_qboxplotseries.cpp"
             #include "moc_qboxplotseries_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/boxplotchart/qboxset.cpp +84 -8

             /****************************************************************************
             **
             ** Copyright (C) 2013 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "qboxset.h"
             #include "qboxset_p.h"
             #include "charthelpers_p.h"
             #include <QDebug> //TODO: remove on release
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QBoxSet
                 \brief Building block for box-and-whiskers chart
                 QBoxSet represents one box-and-whiskers item. It takes fives values to create a graphical representation
                 of range and three medians. There's two type of methods to give the values. The first one is with constructor
-                or append type of methods (append and operator <<). In these the values have to be given in order lower extreme,
+                or append type of methods (append and operator <<). The values have to be given in order lower extreme,
                 lower quartile, median, upper quartile and upper extre. Second method is to create an empty QBoxSet instance and
-                give the values using own methods.
+                give the values using value specific methods.
                 \mainclass
                 \sa QBoxPlotSeries
             */
             /*!
                 \qmlclass BoxSet QBoxSet
                 BoxSet represents one box-and-whiskers item. It takes fives values to create a graphical representation
                 of range and three medians. There's two type of methods to give the values. The first one is with constructor
-                or append type of methods (append and operator <<). In these the values have to be given in order lower extreme,
+                or with append method. In these the values have to be given in order lower extreme, lower quartile, median,
-                lower quartile, median, upper quartile and upper extre. Second method is to create an empty BoxSet instance and
+                upper quartile and upper extre. Second method is to create an empty QBoxSet instance and
-                give the values using own methods.
+                give the values using value specific methods.
                 \sa BoxPlotSeries
             */
+            /*!
+                \qmlproperty string BoxSet::label
+                Defines the label of the boxSet.
+            */
+            /*!
+                \qmlproperty int BoxSet::count
+                The count of values on the box-and-whiskers set
+            */
             /*!
                 \property QBoxSet::pen
                 \brief Defines the pen used by the box-and-whiskers set.
             */
             /*!
                 \property QBoxSet::brush
                 \brief Defines the brush used by the box-and-whiskers set.
             */
             /*!
                 \property QBoxSet::color
                 The fill (brush) color of the box-and-whiskers set.
             */
+            /*!
+                \qmlproperty color BoxSet::color
+                Defines the fill (brush) color of the box-and-whiskers set.
+            */
             /*!
                 \property QBoxSet::borderColor
                 The line (pen) color of the box-and-whiskers set.
             */
+            /*!
+                \qmlproperty color BoxSet::borderColor
+                Defines the outline color of the box-and-whiskers set.
+            */
+            /*!
+                \qmlproperty qreal BoxSet::lowerExtreme
+                The lower extreme value of the box-and-whiskers set
+            */
+            /*!
+                \qmlproperty qreal BoxSet::lowerQuartile
+                The lower quartile value of the box-and-whiskers set
+            */
+            /*!
+                \qmlproperty qreal BoxSet::median
+                The median value of the box-and-whiskers set
+            */
+            /*!
+                \qmlproperty qreal BoxSet::upperQuartile
+                The upper quartile value of the box-and-whiskers set
+            */
+            /*!
+                \qmlproperty qreal BoxSet::upperExtreme
+                The upper extreme value of the box-and-whiskers set
+            */
             /*!
                 \fn void QBoxSet::clicked()
                 The signal is emitted if the user clicks with a mouse on top of box-and-whisker item.
             */
+            /*!
+                \qmlsignal BoxSet::onClicked()
+                This signal is emitted when the user clicks with a mouse on top of box-and-whisker item.
+            */
             /*!
                 \fn void QBoxSet::hovered(bool status)
                 The signal is emitted if mouse is hovered on top of box-and-whisker item.
                 Parameter \a status is true, if mouse entered on top of item, false if mouse left from top of item.
             */
+            /*!
+                \qmlsignal BoxSet::onHovered(bool status)
+                The signal is emitted if mouse is hovered on top of box-and-whisker item.
+                Parameter \a status is true, if mouse entered on top of item, false if mouse left from top of item.
+            */
             /*!
                 \fn void QBoxSet::penChanged()
                 This signal is emitted when the pen of the box-and-whisker item has changed.
                 \sa pen
             */
+            /*!
+                \qmlsignal BoxSet::onPenChanged()
+                This signal is emitted when the pen of the box-and-whisker item has changed.
+            */
             /*!
                 \fn void QBoxSet::brushChanged()
                 This signal is emitted when the brush of the box-and-whisker item has changed.
                 \sa brush
             */
+            /*!
+                \qmlsignal BoxSet::onBrushChanged()
+                This signal is emitted when the brush of the box-and-whisker item has changed.
+            */
             /*!
                 \fn void QBoxSet::colorChanged(QColor)
                 This signal is emitted when the fill (brush) color of the box-and-whisker item has changed to \a color.
             */
+            /*!
+                \qmlsignal BoxSet::onColorChanged(QColor color)
+                This signal is emitted when the fill (brush) color of the box-and-whisker item has changed to \a color.
+            */
             /*!
                 \fn void QBoxSet::valuesAdded(int index, int count)
                 This signal is emitted when new values have been added to the box-and-whisker item.
                 Parameter \a index indicates the position of the first inserted value.
                 Parameter \a count is the number of inserted values.
                 \sa append(), insert()
             */
+            /*!
+                \qmlsignal BoxSet::onValuesAdded(int index, int count)
+                This signal is emitted when new values have been added to the box-and-whisker item.
+                Parameter \a index indicates the position of the first inserted value.
+                Parameter \a count is the number of inserted values.
+            */
             /*!
                 \fn void QBoxSet::valueChanged(int index)
                 This signal is emitted values the value in the box-and-whisker item has been modified.
                 Parameter \a index indicates the position of the modified value.
                 \sa at()
             */
+            /*!
+                \qmlsignal BoxSet::onValueChanged(int index)
+                This signal is emitted values the value in the box-and-whisker item has been modified.
+                Parameter \a index indicates the position of the modified value.
+            */
             /*!
                 \fn void QBoxSet::borderColorChanged(QColor)
                 This signal is emitted when the line (pen) color of the box-and-whisker item has changed to \a color.
             */
+            /*!
+                \qmlsignal BoxSet::onBorderColorChanged(QColor color)
+                This signal is emitted when the line (pen) color of the box-and-whisker item has changed to \a color.
+            */
             /*!
                 Constructs QBoxSet with optional \a label and parent of \a parent
             */
             QBoxSet::QBoxSet(const QString label, QObject *parent)
                 : QObject(parent),
                   d_ptr(new QBoxSetPrivate(label, this))
             {
             }
             /*!
                 Constructs QBoxSet with given ordered values. \a le for lower extreme, \a lq for lower quartile, \a m for median,
                 \a uq for upper quartile and \a ue for upper quartile. \a label and \a parent are optional.
              */
             QBoxSet::QBoxSet(const qreal le, const qreal lq, const qreal m, const qreal uq, const qreal ue, const QString label, QObject *parent)
                 : QObject(parent),
                   d_ptr(new QBoxSetPrivate(label, this))
             {
                 d_ptr->append(le);
                 d_ptr->append(lq);
                 d_ptr->append(m);
                 d_ptr->append(uq);
                 d_ptr->append(ue);
             }
             /*!
                 Destroys the boxset
             */
             QBoxSet::~QBoxSet()
             {
                 // NOTE: d_ptr destroyed by QObject
             }
             /*!
                 Appends new value \a value to the end of set.
             */
             void QBoxSet::append(const qreal value)
             {
                 //int index = d_ptr->m_values.count();
                 d_ptr->append(value);
                 emit valuesAdded(d_ptr->m_valuesCount, 1);
             }
             /*!
                 Appends a list of reals to set. Works like append with single real value. The \a values in list
                 are appended to end of boxset
                 \sa append()
             */
             void QBoxSet::append(const QList<qreal> &values)
             {
                 //int index = d_ptr->m_values.count();
                 d_ptr->append(values);
                 emit valuesAdded(d_ptr->m_valuesCount, values.count());
             }
             /*!
                 Sets new value \a value as the lower extreme for the set.
             */
             void QBoxSet::setLowerExtreme(const qreal value)
             {
                 d_ptr->replace(QBoxSetPrivate::PosLowerExtreme, value);
                 emit d_ptr->restructuredBox();
                 emit valueChanged(QBoxSetPrivate::PosLowerExtreme);
             }
             /*!
                 Returns the lower extreme value of the set.
             */
             qreal QBoxSet::lowerExtreme()
             {
                 return d_ptr->m_values[QBoxSetPrivate::PosLowerExtreme];
             }
             /*!
                 Sets new value \a value as the lower quartile for the set.
             */
             void QBoxSet::setLowerQuartile(const qreal value)
             {
                 d_ptr->replace(QBoxSetPrivate::PosLowerQuartile, value);
                 emit d_ptr->restructuredBox();
                 emit valueChanged(QBoxSetPrivate::PosLowerQuartile);
             }
             /*!
                 Returns the lower quartile value of the set.
             */
             qreal QBoxSet::lowerQuartile()
             {
                 return d_ptr->m_values[QBoxSetPrivate::PosLowerQuartile];
             }
             /*!
                 Sets new value \a value as the median for the set.
             */
             void QBoxSet::setMedian(const qreal value)
             {
                 d_ptr->replace(QBoxSetPrivate::PosMedian, value);
                 emit d_ptr->restructuredBox();
                 emit valueChanged(QBoxSetPrivate::PosMedian);
             }
             /*!
                 Returns the median value of the set.
             */
             qreal QBoxSet::median()
             {
                 return d_ptr->m_values[QBoxSetPrivate::PosMedian];
             }
             /*!
                 Sets new value \a value as the upper quartile for the set.
             */
             void QBoxSet::setUpperQuartile(const qreal value)
             {
                 d_ptr->replace(QBoxSetPrivate::PosUpperQuartile, value);
                 emit d_ptr->restructuredBox();
                 emit valueChanged(QBoxSetPrivate::PosUpperQuartile);
             }
             /*!
                 Returns the upper quartile value of the set.
             */
             qreal QBoxSet::upperQuartile()
             {
                 return d_ptr->m_values[QBoxSetPrivate::PosUpperQuartile];
             }
             /*!
                 Sets new value \a value as the upper extreme for the set.
             */
             void QBoxSet::setUpperExtreme(const qreal value)
             {
                 d_ptr->replace(QBoxSetPrivate::PosUpperExtreme, value);
                 emit d_ptr->restructuredBox();
                 emit valueChanged(QBoxSetPrivate::PosUpperExtreme);
             }
             /*!
                 Returns the upper extreme value of the set.
             */
             qreal QBoxSet::upperExtreme()
             {
                 return d_ptr->m_values[QBoxSetPrivate::PosUpperExtreme];
             }
             /*!
                 Sets new \a label for set.
             */
             void QBoxSet::setLabel(const QString label)
             {
                 d_ptr->m_label = label;
             }
             /*!
                 Returns label of the set.
             */
             QString QBoxSet::label() const
             {
                 return d_ptr->m_label;
             }
             /*!
                 Convenience operator. Same as append, with real \a value.
                 \sa append()
             */
             QBoxSet &QBoxSet::operator << (const qreal &value)
             {
                 append(value);
                 return *this;
             }
             /*!
                 Inserts new \a value on the \a index position.
                 The value that is currently at this postion is moved to postion index + 1
             */
             void QBoxSet::insert(const int index, const qreal value)
             {
                 d_ptr->insert(index, value);
                 emit valuesAdded(index, 1);
             }
             /*!
                 Sets a new value \a value to set, indexed by \a index
             */
             void QBoxSet::replace(const int index, const qreal value)
             {
                 if (index >= 0 && index < 5) {
                     d_ptr->replace(index, value);
                     emit valueChanged(index);
                 }
             }
             /*!
                 Returns value of set indexed by \a index.
                 If the index is out of bounds 0.0 is returned.
             */
             qreal QBoxSet::at(const int index) const
             {
                 if (index < 0 || index >= 5)
                     return 0;
                 return d_ptr->m_values[index];
             }
             /*!
                 Returns value of set indexed by \a index.
                 If the index is out of bounds 0.0 is returned.
             */
             qreal QBoxSet::operator [](const int index) const
             {
                 return at(index);
             }
             /*!
                 Returns count of values in set.
             */
             int QBoxSet::count() const
             {
                 return d_ptr->m_valuesCount;
             }
             /*!
                 Sets pen for set. Boxes of this set are drawn using \a pen
             */
             void QBoxSet::setPen(const QPen &pen)
             {
                 if (d_ptr->m_pen != pen) {
                     d_ptr->m_pen = pen;
                     emit d_ptr->updatedBox();
                     emit penChanged();
                 }
             }
             /*!
                 Returns pen of the set.
             */
             QPen QBoxSet::pen() const
             {
                 return d_ptr->m_pen;
             }
             /*!
                 Sets brush for the set. Boxes of this set are drawn using \a brush
             */
             void QBoxSet::setBrush(const QBrush &brush)
             {
                 if (d_ptr->m_brush != brush) {
                     d_ptr->m_brush = brush;
                     emit d_ptr->updatedBox();
                     emit brushChanged();
                 }
             }
             /*!
                 Returns brush of the set.
             */
             QBrush QBoxSet::brush() const
             {
                 return d_ptr->m_brush;
             }
             /*!
                 Returns the color of the brush of boxset.
             */
             QColor QBoxSet::color()
             {
                 return brush().color();
             }
             /*!
                 Sets the \a color of brush for this boxset
             */
             void QBoxSet::setColor(QColor color)
             {
                 QBrush b = brush();
                 if ((b.color() != color) || (b.style() == Qt::NoBrush)) {
                     b.setColor(color);
                     if (b.style() == Qt::NoBrush) {
                         // Set tyle to Qt::SolidPattern. (Default is Qt::NoBrush)
                         // This prevents theme to override color defined in QML side:
                         // BoxSet { label: "Bob"; color:"red"; values: [1,2,3] }
                         // The color must be obeyed, since user wanted it.
                         b.setStyle(Qt::SolidPattern);
                     }
                     setBrush(b);
                     emit colorChanged(color);
                 }
             }
             /*!
                 Returns the color of pen of this boxset
             */
             QColor QBoxSet::borderColor()
             {
                 return pen().color();
             }
             /*!
                 Sets the color of pen for this boxset
             */
             void QBoxSet::setBorderColor(QColor color)
             {
                 QPen p = pen();
                 if (p.color() != color) {
                     p.setColor(color);
+                    p.setStyle(Qt::SolidLine);
                     setPen(p);
                     emit borderColorChanged(color);
                 }
             }
             ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QBoxSetPrivate::QBoxSetPrivate(const QString label, QBoxSet *parent) : QObject(parent),
                 q_ptr(parent),
                 m_label(label),
                 m_valuesCount(5),
                 m_appendCount(0),
                 m_pen(QPen(Qt::NoPen)),
                 m_brush(QBrush(Qt::NoBrush))
             {
                 m_values = new qreal[m_valuesCount];
             }
             QBoxSetPrivate::~QBoxSetPrivate()
             {
             }
             void QBoxSetPrivate::append(qreal value)
             {
                 if (isValidValue(value) && m_appendCount < m_valuesCount) {
                     m_values[m_appendCount++] = value;
                     emit restructuredBox();
                 }
             }
             void QBoxSetPrivate::append(QList<qreal> values)
             {
                 for (int i = 0; i < values.count(); i++) {
                     if (isValidValue(values.at(i)) && m_appendCount < m_valuesCount)
                         m_values[m_appendCount++] = values.at(i);
                 }
                 emit restructuredBox();
             }
             void QBoxSetPrivate::insert(const int index, const qreal value)
             {
                 if (isValidValue(value)) {
                     for (int i = 4; i > index; i--)
                         m_values[i] = m_values[i - 1];
                     m_values[index] = value;
                     emit restructuredBox();
                 }
             }
             void QBoxSetPrivate::replace(const int index, const qreal value)
             {
                 m_values[index] = value;
                 emit updatedLayout();
             }
             qreal QBoxSetPrivate::value(const int index)
             {
                 if (index < 0 || index >= m_valuesCount)
                     return 0;
                 return m_values[index];
             }
             #include "moc_qboxset.cpp"
             #include "moc_qboxset_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

General Comments 0

Write
Preview

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

No TODOs yet

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

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