HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r2517:26c3b5c0ed1d

Documentation...

Mika Salmela -

r2517:26c3b5c0ed1d

parent child

Context file:

r2517:26c3b5c0ed1d

Collapse all files

doc/src/examples-boxplotchart.qdoc created 644 +38 0

@@ -0,0 +1,38
	1	/*!
	2	\example examples/boxplotchart
	3	\title Box and Whiskers Example
	4	\subtitle
	5
	6	The example shows how to create a box-and-whiskers chart.
	7
	8	\image examples_barchart.png
	9
	10	Introduction here
	11
	12	\snippet ../examples/barchart/main.cpp 1
	13
	14	Ykk�skohta
	15
	16	\snippet ../examples/barchart/main.cpp 2
	17
	18	Kakkoskohta
	19
	20	\snippet ../examples/barchart/main.cpp 3
	21
	22	Kolmoskohta
	23
	24	\snippet ../examples/barchart/main.cpp 4
	25
	26	Neloskohta
	27
	28	\snippet ../examples/barchart/main.cpp 5
	29
	30	Tarkista numerointi. Finally we add the chart onto a view. We also turn on the antialiasing for the chartView.
	31
	32	\snippet ../examples/barchart/main.cpp 6
	33
	34	Tarkista numerointi. Chart is ready to be shown. We set the chart to be central widget of the window.
	35	We also set the size for the chart window and show it.
	36
	37	\snippet ../examples/barchart/main.cpp 7
	38	*/

src/barchart/qvbarmodelmapper.cpp +1 -1

             /****************************************************************************
             **
             ** 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 "qvbarmodelmapper.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QVBarModelMapper
                 \brief Vertical model mapper for bar series
                 \mainclass
                 Model mappers allow you to use QAbstractItemModel derived models as a data source for a chart series.
                 Vertical model mapper is used to create a connection between QAbstractBarSeries and QAbstractItemModel derived model object.
                 Model mapper maintains equal size of all the BarSets.
                 Adding/removing value from the BarSet causes the the same change in the rest of the BarSets added to the same series.
                 Note: used model has to support adding/removing rows/columns and modifying the data of the cells.
             */
             /*!
                 \qmlclass VBarModelMapper
                 \mainclass
                 VBarModelMapper allows you to use your own QAbstractItemModel derived model with data in columns as a data source
                 for any bar series. It is possible to use both QAbstractItemModel and bar series data API to manipulate data.
                 VBarModelMapper keeps the series and the model in sync.
                 The following QML example would create a bar series with three bar sets (assuming the
                 model has at least four columns). Each bar set would contain data starting from row 1. The name of a set would be
                 defined by the horizontal header (of the column).
                 \code
                     BarSeries {
                         VBarModelMapper {
                             model: myCustomModel // QAbstractItemModel derived implementation
                             firstBarSetColumn: 1
                             lastBarSetColumn: 3
                             firstRow: 1
                         }
                     }
                 \endcode
             */
             /*!
                 \property QVBarModelMapper::series
-                \brief Defines the QPieSeries object that is used by the mapper.
+                \brief Defines the QBarSeries object that is used by the mapper.
                 All the data in the series is discarded when it is set to the mapper.
                 When new series is specified the old series is disconnected (it preserves its data)
             */
             /*!
                 \qmlproperty AbstractBarSeries VBarModelMapper::series
                 Defines the AbstractBarSeries based object that is used by the mapper. All the data in the series is discarded when it is
                 set to the mapper. When new series is specified the old series is disconnected (it preserves its data).
             */
             /*!
                 \property QVBarModelMapper::model
                 \brief Defines the model that is used by the mapper.
             */
             /*!
                 \qmlproperty SomeModel VBarModelMapper::model
                 The QAbstractItemModel based model that is used by the mapper. You need to implement the model and expose it to
                 QML as shown in \l {QML Custom Model} demo application. Note: the model has to support adding/removing rows/columns
                 and modifying the data of the cells.
             */
             /*!
                 \property QVBarModelMapper::firstBarSetColumn
                 \brief Defines which column of the model is used as the data source for the first bar set
                 Default value is: -1 (invalid mapping)
             */
             /*!
                 \qmlproperty int VBarModelMapper::firstBarSetColumn
                 Defines which column of the model is used as the data source for the first bar set. Default value
                 is: -1 (invalid mapping).
             */
             /*!
                 \property QVBarModelMapper::lastBarSetColumn
                 \brief Defines which column of the model is used as the data source for the last bar set
                 Default value is: -1 (invalid mapping)
             */
             /*!
                 \qmlproperty int VBarModelMapper::lastBarSetColumn
                 Defines which column of the model is used as the data source for the last bar set. Default
                 value is: -1 (invalid mapping).
             */
             /*!
                 \property QVBarModelMapper::firstRow
                 \brief Defines which row of the model contains the first values of the QBarSets in the series.
                 Minimal and default value is: 0
             */
             /*!
                 \qmlproperty int VBarModelMapper::firstRow
                 Defines which row of the model contains the first values of the QBarSets in the series.
                 The default value is 0.
             */
             /*!
                 \property QVBarModelMapper::rowCount
                 \brief Defines the number of rows of the model that are mapped as the data for QAbstractBarSeries
                 Minimal and default value is: -1 (count limited by the number of rows in the model)
             */
             /*!
                 \qmlproperty int VBarModelMapper::rowCount
                 Defines the number of rows of the model that are mapped as the data for QAbstractBarSeries. The default value is
                 -1 (count limited by the number of rows in the model)
             */
             /*!
                 \fn void QVBarModelMapper::seriesReplaced()
                 Emitted when the series to which mapper is connected to has changed.
             */
             /*!
                 \fn void QVBarModelMapper::modelReplaced()
                 Emitted when the model to which mapper is connected to has changed.
             */
             /*!
                 \fn void QVBarModelMapper::firstBarSetColumnChanged()
                 Emitted when the firstBarSetColumn has changed.
             */
             /*!
                 \fn void QVBarModelMapper::lastBarSetColumnChanged()
                 Emitted when the lastBarSetColumn has changed.
             */
             /*!
                 \fn void QVBarModelMapper::firstRowChanged()
                 Emitted when the firstRow has changed.
             */
             /*!
                 \fn void QVBarModelMapper::rowCountChanged()
                 Emitted when the rowCount has changed.
             */
             /*!
                 Constructs a mapper object which is a child of \a parent.
             */
             QVBarModelMapper::QVBarModelMapper(QObject *parent) :
                 QBarModelMapper(parent)
             {
                 QBarModelMapper::setOrientation(Qt::Vertical);
             }
             QAbstractItemModel *QVBarModelMapper::model() const
             {
                 return QBarModelMapper::model();
             }
             void QVBarModelMapper::setModel(QAbstractItemModel *model)
             {
                 if (model != QBarModelMapper::model()) {
                     QBarModelMapper::setModel(model);
                     emit modelReplaced();
                 }
             }
             QAbstractBarSeries *QVBarModelMapper::series() const
             {
                 return QBarModelMapper::series();
             }
             void QVBarModelMapper::setSeries(QAbstractBarSeries *series)
             {
                 if (series != QBarModelMapper::series()) {
                     QBarModelMapper::setSeries(series);
                     emit seriesReplaced();
                 }
             }
             int QVBarModelMapper::firstBarSetColumn() const
             {
                 return QBarModelMapper::firstBarSetSection();
             }
             void QVBarModelMapper::setFirstBarSetColumn(int firstBarSetColumn)
             {
                 if (firstBarSetColumn != firstBarSetSection()) {
                     QBarModelMapper::setFirstBarSetSection(firstBarSetColumn);
                     emit firstBarSetColumnChanged();
                 }
             }
             int QVBarModelMapper::lastBarSetColumn() const
             {
                 return QBarModelMapper::lastBarSetSection();
             }
             void QVBarModelMapper::setLastBarSetColumn(int lastBarSetColumn)
             {
                 if (lastBarSetColumn != lastBarSetSection()) {
                     QBarModelMapper::setLastBarSetSection(lastBarSetColumn);
                     emit lastBarSetColumnChanged();
                 }
             }
             int QVBarModelMapper::firstRow() const
             {
                 return QBarModelMapper::first();
             }
             void QVBarModelMapper::setFirstRow(int firstRow)
             {
                 if (firstRow != first()) {
                     QBarModelMapper::setFirst(firstRow);
                     emit firstRowChanged();
                 }
             }
             int QVBarModelMapper::rowCount() const
             {
                 return QBarModelMapper::count();
             }
             void QVBarModelMapper::setRowCount(int rowCount)
             {
                 if (rowCount != count()) {
                     QBarModelMapper::setCount(rowCount);
                     emit rowCountChanged();
                 }
             }
             #include "moc_qvbarmodelmapper.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/boxplotchart/boxplotchartitem.cpp +13 -9

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "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)
             {
                 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 *boxWhiskersItem = m_boxTable.value(set);
+                    BoxWhiskers *box = m_boxTable.value(set);
-                    if (boxWhiskersItem == 0) {
+                    if (!box) {
                         // Item is not yet created, make a box and add it to hash table
-                        boxWhiskersItem = new BoxWhiskers(domain(), this);
+                        box = new BoxWhiskers(set, domain(), this);
-                        m_boxTable.insert(set, boxWhiskersItem);
+                        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
-                        boxWhiskersItem->setBrush(m_series->brush());
+                        box->setBrush(m_series->brush());
-                        boxWhiskersItem->setPen(m_series->pen());
+                        box->setPen(m_series->pen());
                     }
-                    updateBoxGeometry(boxWhiskersItem, s);
+                    updateBoxGeometry(box, s);
-                    boxWhiskersItem->updateGeometry();
+                    box->updateGeometry();
                     if (m_animation)
-                        m_animation->addBox(boxWhiskersItem);
+                        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 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/boxwhiskers.cpp +9 -10

             /****************************************************************************
              **
              ** 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 "boxwhiskers_p.h"
             #include <QPainter>
-            #include <QDebug>
             #include <QWidget>
+            #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            BoxWhiskers::BoxWhiskers(AbstractDomain *domain, QGraphicsObject *parent) :
+            BoxWhiskers::BoxWhiskers(QBoxSet *set, AbstractDomain *domain, QGraphicsObject *parent) :
                 QGraphicsObject(parent),
+                m_boxSet(set),
                 m_domain(domain)
             {
-                //qDebug() << "BoxWhiskers::BoxWhiskers()";
+                setAcceptHoverEvents(true);
+                setAcceptedMouseButtons(Qt::MouseButtonMask);
             }
             BoxWhiskers::~BoxWhiskers()
             {
-                //qDebug() << "BoxWhiskers::~BoxWhiskers()";
             }
             void BoxWhiskers::mousePressEvent(QGraphicsSceneMouseEvent *event)
             {
                 Q_UNUSED(event)
+                emit clicked(m_boxSet);
-                qDebug() << "BoxWhiskers::mousePressEvent";
             }
             void BoxWhiskers::hoverEnterEvent(QGraphicsSceneHoverEvent *event)
             {
                 Q_UNUSED(event)
+                emit hovered(true, m_boxSet);
-                qDebug() << "BoxWhiskers::hoverEnterEvent";
             }
             void BoxWhiskers::hoverLeaveEvent(QGraphicsSceneHoverEvent *event)
             {
                 Q_UNUSED(event)
+                emit hovered(false, m_boxSet);
-                qDebug() << "BoxWhiskers::hoverLeaveEvent";
             }
             void BoxWhiskers::setBrush(const QBrush &brush)
             {
                 m_brush = brush;
                 update();
             }
             void BoxWhiskers::setPen(const QPen &pen)
             {
                 m_pen = pen;
                 update();
             }
             void BoxWhiskers::setLayout(const BoxWhiskersData &data)
             {
                 m_data = data;
                 updateGeometry();
                 update();
             }
             QSizeF BoxWhiskers::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
             {
                 //Q_UNUSED(which)
                 Q_UNUSED(constraint)
                 qDebug() << "BoxWhiskers::sizeHint, which = " << which;
                 return QSizeF();
             }
             void BoxWhiskers::setGeometry(const QRectF &rect) // TODO: Unused?
             {
                 Q_UNUSED(rect)
                 qDebug() << "BoxWhiskers::setGeometry";
             }
             void BoxWhiskers::setDomainSize(const QSizeF &size)
             {
                 m_domainSize = size;
                 updateBoundingRect();
             }
             QRectF BoxWhiskers::boundingRect() const
             {
                 return m_boundingRect;
             }
             void BoxWhiskers::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(option)
                 Q_UNUSED(widget)
                 //Q_UNUSED(painter)
                 //painter->save();
                 //painter->setClipRect(parentItem()->boundingRect());
                 painter->setPen(m_pen);
                 painter->setBrush(m_brush);
                 qreal spanY = m_data.m_maxY - m_data.m_minY;
                 //painter->setClipRect(parentItem()->boundingRect());
                 painter->scale(m_domainSize.width() / m_data.m_boxItems, m_domainSize.height() / spanY);
                 painter->drawPath(m_boxPath);
                 //painter->restore();
             }
             void BoxWhiskers::updateGeometry()
             {
                 prepareGeometryChange();
                 QPainterPath path;
                 qreal columnWidth = 1.0 / m_data.m_seriesCount;
                 qreal left = 0.25 * columnWidth + columnWidth * m_data.m_seriesIndex;
                 qreal right = 0.75 * columnWidth + columnWidth * m_data.m_seriesIndex;
                 qreal middle = 0.5 * columnWidth + columnWidth * m_data.m_seriesIndex;
                 //whisker = 0.35 0.75
                 // Upper whisker
                 path.moveTo(left + m_data.m_index, m_data.m_maxY - m_data.m_upperExtreme);
                 path.lineTo(right + m_data.m_index, m_data.m_maxY - m_data.m_upperExtreme);
                 path.moveTo(middle + m_data.m_index, m_data.m_maxY - m_data.m_upperExtreme);
                 path.lineTo(middle + m_data.m_index, m_data.m_maxY - m_data.m_upperQuartile);
                 path.closeSubpath();
                 // Middle Box
                 path.addRect(left + m_data.m_index, m_data.m_maxY - m_data.m_upperQuartile,
 .5 * columnWidth, m_data.m_upperQuartile - m_data.m_lowerQuartile);
                 // Median/mean line
                 path.moveTo(left + m_data.m_index, m_data.m_maxY - m_data.m_median);
                 path.lineTo(right + m_data.m_index, m_data.m_maxY - m_data.m_median);
                 // Lower whisker
                 path.moveTo(left + m_data.m_index, m_data.m_maxY - m_data.m_lowerExtreme);
                 path.lineTo(right + m_data.m_index, m_data.m_maxY - m_data.m_lowerExtreme);
                 path.moveTo(middle + m_data.m_index, m_data.m_maxY - m_data.m_lowerExtreme);
                 path.lineTo(middle + m_data.m_index, m_data.m_maxY - m_data.m_lowerQuartile);
                 path.closeSubpath();
                 m_boxPath = path;
                 updateBoundingRect();
             //    qreal scaleY = m_domainSize.height() / (m_data.m_maxY - m_data.m_minY);
             //    qreal scaleX = m_domainSize.width() / m_data.m_boxItems;
             //    QRectF br = path.boundingRect();
             //    m_boundingRect = QRectF( br.x() * scaleX, br.y() * scaleY, br.width() * scaleX, br.height() * scaleY);
                 if (m_data.m_index == 5) {
                     //qDebug() << "myValue = " << myValue;
                     //qDebug() << "m_data.m_upperExtreme" << m_data.m_upperExtreme;
                     //qDebug() << "m_boundingRect = " << m_boundingRect;
             //        qDebug() << "x = " << m_boundingRect.x() << ", y = " << m_boundingRect.y() << ", width = "
             //                 << m_boundingRect.width() << ", height = " << m_boundingRect.height();
                 }
             }
             void BoxWhiskers::updateBoundingRect()
             {
                 qreal scaleY = m_domainSize.height() / (m_data.m_maxY - m_data.m_minY);
                 qreal scaleX = m_domainSize.width() / m_data.m_boxItems;
                 QRectF br = m_boxPath.boundingRect();
                 m_boundingRect = QRectF( br.x() * scaleX, br.y() * scaleY, br.width() * scaleX, br.height() * scaleY);
             }
             #include "moc_boxwhiskers_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/boxplotchart/boxwhiskers_p.h +5 -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$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef BOXWHISKERS_H
             #define BOXWHISKERS_H
             #include "boxwhiskersdata_p.h"
             #include "qchartglobal.h"
-            #include "qbarset.h"
             #include "abstractdomain_p.h"
+            #include <QBoxSet>
             #include <QGraphicsRectItem>
             #include <QGraphicsLineItem>
             #include <QGraphicsLayoutItem>
             #include <QPainterPath>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QBarSet;
             class BoxWhiskers : public QGraphicsObject/*, public QGraphicsLayoutItem*/
             {
                 Q_OBJECT
                 //Q_INTERFACES(QGraphicsLayoutItem)
             public:
-                BoxWhiskers(AbstractDomain *domain, QGraphicsObject *parent);
+                BoxWhiskers(QBoxSet *set, AbstractDomain *domain, QGraphicsObject *parent);
                 ~BoxWhiskers();
                 void setBrush(const QBrush &brush);
                 void setPen(const QPen &pen);
                 void setLayout(const BoxWhiskersData &data);
                 void setDomainSize(const QSizeF &size);
                 void mousePressEvent(QGraphicsSceneMouseEvent *event);
                 void hoverEnterEvent(QGraphicsSceneHoverEvent *event);
                 void hoverLeaveEvent(QGraphicsSceneHoverEvent *event);
                 QRectF boundingRect() const;
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = 0);
                 // From QGraphicsLayoutItem // TODO tarkista n�m� jollei ole QGraphicsLayoutItem
                 void updateGeometry();
             protected:
                 QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint) const;
                 void setGeometry(const QRectF &rect);
             private:
                 void updateBoundingRect();
             Q_SIGNALS:
-                void clicked(int index, QBarSet *barset);
+                void clicked(QBoxSet *boxset);
-                void hovered(bool status, QBarSet *barset);
+                void hovered(bool status, QBoxSet *boxset);
             private:
                 friend class BoxPlotChartItem;
                 friend class BoxPlotAnimation;
+                QBoxSet *m_boxSet;
                 AbstractDomain *m_domain;
                 QPainterPath    m_boxPath;
                 QRectF m_boundingRect;
                 bool m_hovering;
                 bool m_validData;
                 QBrush  m_brush;
                 QPen m_pen;
                 BoxWhiskersData m_data;
                 QSizeF m_domainSize;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // BOXWHISKERS_H

src/boxplotchart/qboxplotseries.cpp +46 -9

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "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 stacked bar chart
+                \brief Series for creating box-and-whiskers chart
                 \mainclass
-                QBoxPlotSeries represents a series of data shown as bars. The purpose of this class is to draw bars
+                QBoxPlotSeries represents a series of data shown as box-and-whisker bars. The purpose of this class is to act as
-                as stacks, where bars in same category are stacked on top of each other.
+                a container for single box-and-whisker items. Each item is drawn to own slot. If chart includes multiple QBoxPlotSeries
-                QBoxPlotSeries groups the data from sets to categories, which are defined by QStringList.
+                items with the same index are drawn to same slot.
-                See the \l {BoxPlotChart Example} {stacked bar chart example} to learn how to create a stacked bar chart.
+                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, QPercentBarSeries, QAbstractBarSeries
+                \sa QBoxSet
             */
             /*!
                 \qmlclass BoxPlotSeries QBoxPlotSeries
                 \inherits AbstractBarSeries
-                The following QML shows how to create a simple stacked bar chart:
+                The following QML shows how to create a simple box-and-whiskers chart:
-                \snippet ../demos/qmlchart/qml/qmlchart/View7.qml 1
+                \snippet ../examples/qmlboxplot/qml/qmlboxplot/main.qml 1
                 \beginfloatleft
                 \image demos_qmlchart7.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.
+            */
+            /*!
                 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 item to series. Takes ownership of \a the box. If the box is null or is already in series, it won't be appended.
+                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/qboxplotseries.h +1 -7

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef QBOXPLOTSERIES_H
             #define QBOXPLOTSERIES_H
             #include <qchartglobal.h>
             #include <qboxset.h>
-            //#include <qabstractbarseries.h>
             #include <qabstractseries.h>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QBoxPlotSeriesPrivate;
-            //class QBarSet;
             class QTCOMMERCIALCHART_EXPORT QBoxPlotSeries : public QAbstractSeries
             {
                 Q_OBJECT
             public:
                 explicit QBoxPlotSeries(QObject *parent = 0);
                 ~QBoxPlotSeries();
                 bool append(QBoxSet *box);
                 bool remove(QBoxSet *box);
                 bool take(QBoxSet *box);
                 bool append(QList<QBoxSet *> boxes);
                 bool insert(int index, QBoxSet *box);
                 int count() const;
                 QList<QBoxSet *> boxSets() const;
                 void clear();
-                void setLabelsVisible(bool visible = true);
-                bool isLabelsVisible() const;
                 QAbstractSeries::SeriesType type() const;
                 void setBrush(const QBrush &brush);
                 QBrush brush() const;
                 void setPen(const QPen &pen);
                 QPen pen() const;
             Q_SIGNALS:
-                void clicked(int index, QBoxSet *boxset);
+                void clicked(QBoxSet *boxset);
                 void hovered(bool status, QBoxSet *boxset);
                 void countChanged();
-                void labelsVisibleChanged();
                 void boxsetsAdded(QList<QBoxSet *> sets);
                 void boxsetsRemoved(QList<QBoxSet *> sets);
             private:
                 Q_DECLARE_PRIVATE(QBoxPlotSeries)
                 Q_DISABLE_COPY(QBoxPlotSeries)
                 friend class BoxPlotChartItem;
                 friend class QBoxPlotLegendMarkerPrivate;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QBOXPLOTSERIES_H

src/boxplotchart/qboxset.cpp +105 -7

             /****************************************************************************
             **
             ** 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
             /*!
-                Constructs QBoxSet with parent of \a parent
+                \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,
+                lower quartile, median, upper quartile and upper extre. Second method is to create an empty QBoxSet instance and
+                give the values using own 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,
+                lower quartile, median, upper quartile and upper extre. Second method is to create an empty BoxSet instance and
+                give the values using own methods.
+                \sa BoxPlotSeries
+            */
+            /*!
+                \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.
+            */
+            /*!
+                \property QBoxSet::borderColor
+                The line (pen) color 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.
+            */
+            /*!
+                \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.
+            */
+            /*!
+                \fn void QBoxSet::penChanged()
+                This signal is emitted when the pen of the box-and-whisker item has changed.
+                \sa pen
+            */
+            /*!
+                \fn void QBoxSet::brushChanged()
+                This signal is emitted when the brush of the box-and-whisker item has changed.
+                \sa brush
+            */
+            /*!
+                \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.
+            */
+            /*!
+                \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()
+            */
+            /*!
+                \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()
+            */
+            /*!
+                \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.
+            */
+            /*!
+                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))
             {
             }
-            QBoxSet::QBoxSet(qreal value1, qreal value2, qreal value3, qreal value4, qreal value5, const QString label, QObject *parent)
+            /*!
+                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(value1);
+                d_ptr->append(le);
-                d_ptr->append(value2);
+                d_ptr->append(lq);
-                d_ptr->append(value3);
+                d_ptr->append(m);
-                d_ptr->append(value4);
+                d_ptr->append(uq);
-                d_ptr->append(value5);
+                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);
                     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

src/boxplotchart/qboxset.h +2 -4

             /****************************************************************************
             **
             ** 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 QBOXSET_H
             #define QBOXSET_H
             #include <qchartglobal.h>
             #include <QPen>
             #include <QBrush>
             #include <QFont>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QBoxSetPrivate;
             class QTCOMMERCIALCHART_EXPORT QBoxSet : public QObject
             {
                 Q_OBJECT
                 Q_PROPERTY(QPen pen READ pen WRITE setPen NOTIFY penChanged)
                 Q_PROPERTY(QBrush brush READ brush WRITE setBrush NOTIFY brushChanged)
                 Q_PROPERTY(QColor color READ color WRITE setColor NOTIFY colorChanged)
                 Q_PROPERTY(QColor borderColor READ borderColor WRITE setBorderColor NOTIFY borderColorChanged)
             public:
                 explicit QBoxSet(const QString label = "", QObject *parent = 0);
-                explicit QBoxSet(const qreal value1, const qreal value2, const qreal value3, const qreal value4, const qreal value5, const QString label = "", QObject *parent = 0);
+                explicit QBoxSet(const qreal le, const qreal lq, const qreal m, const qreal uq, const qreal ue, const QString label = "", QObject *parent = 0);
                 virtual ~QBoxSet();
                 void append(const qreal value);
                 void append(const QList<qreal> &values);
                 void setLowerExtreme(const qreal value);
                 qreal lowerExtreme();
                 void setLowerQuartile(const qreal value);
                 qreal lowerQuartile();
                 void setMedian(const qreal value);
                 qreal median();
                 void setUpperQuartile(const qreal value);
                 qreal upperQuartile();
                 void setUpperExtreme(const qreal value);
                 qreal upperExtreme();
                 void setLabel(const QString label);
                 QString label() const;
                 QBoxSet &operator << (const qreal &value);
                 void insert(const int index, const qreal value);
-                void remove(const int index, const int count = 1);
                 void replace(const int index, const qreal value);
                 qreal at(const int index) const;
                 qreal operator [](const int index) const;
                 int count() const;
                 void setPen(const QPen &pen);
                 QPen pen() const;
                 void setBrush(const QBrush &brush);
                 QBrush brush() const;
                 QColor color();
                 void setColor(QColor color);
                 QColor borderColor();
                 void setBorderColor(QColor color);
             Q_SIGNALS:
-                void clicked(int index);
+                void clicked();
                 void hovered(bool status);
                 void penChanged();
                 void brushChanged();
                 void colorChanged(QColor color);
                 void borderColorChanged(QColor color);
                 void valuesAdded(int index, int count);
-                void valuesRemoved(int index, int count);
                 void valueChanged(int index);
             private:
                 QScopedPointer<QBoxSetPrivate> d_ptr;
                 Q_DISABLE_COPY(QBoxSet)
                 friend class BarLegendMarker;
                 friend class BarChartItem;
                 friend class BoxPlotChartItem;
                 friend class QBoxPlotSeriesPrivate;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QBOXSET_H

src/boxplotchart/qvboxplotmodelmapper.cpp +27 -27

             /****************************************************************************
             **
             ** 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 "qvboxplotmodelmapper.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QVBoxPlotModelMapper
                 \brief Vertical model mapper for bar series
                 \mainclass
                 Model mappers allow you to use QAbstractItemModel derived models as a data source for a chart series.
-                Vertical model mapper is used to create a connection between QAbstractBarSeries and QAbstractItemModel derived model object.
+                Vertical model mapper is used to create a connection between QBoxPlotSeries and QAbstractItemModel derived model object.
                 Model mapper maintains equal size of all the BarSets.
-                Adding/removing value from the BarSet causes the the same change in the rest of the BarSets added to the same series.
                 Note: used model has to support adding/removing rows/columns and modifying the data of the cells.
             */
             /*!
-                \qmlclass VBarModelMapper
+                \qmlclass VBoxPlotModelMapper
                 \mainclass
-                VBarModelMapper allows you to use your own QAbstractItemModel derived model with data in columns as a data source
+                VBoxPlotModelMapper allows you to use your own QAbstractItemModel derived model with data in columns as a data source
-                for any bar series. It is possible to use both QAbstractItemModel and bar series data API to manipulate data.
+                for any box-and-whiskers series. It is possible to use both QAbstractItemModel and box-and-whiskers series data API to
-                VBarModelMapper keeps the series and the model in sync.
+                manipulate data.
+                VBoxPlotModelMapper keeps the series and the model in sync.
-                The following QML example would create a bar series with three bar sets (assuming the
+                The following QML example would create a box-and-whiskers series with three box sets (assuming the
-                model has at least four columns). Each bar set would contain data starting from row 1. The name of a set would be
+                model has at least four columns). Each box set would contain data starting from row 1. The name of a set would be
                 defined by the horizontal header (of the column).
                 \code
                     BarSeries {
                         VBarModelMapper {
                             model: myCustomModel // QAbstractItemModel derived implementation
                             firstBarSetColumn: 1
                             lastBarSetColumn: 3
                             firstRow: 1
                         }
                     }
                 \endcode
             */
             /*!
                 \property QVBoxPlotModelMapper::series
-                \brief Defines the QPieSeries object that is used by the mapper.
+                \brief Defines the QBoxPlotSeries object that is used by the mapper.
                 All the data in the series is discarded when it is set to the mapper.
                 When new series is specified the old series is disconnected (it preserves its data)
             */
             /*!
                 \qmlproperty AbstractBarSeries VBarModelMapper::series
                 Defines the AbstractBarSeries based object that is used by the mapper. All the data in the series is discarded when it is
                 set to the mapper. When new series is specified the old series is disconnected (it preserves its data).
             */
             /*!
                 \property QVBoxPlotModelMapper::model
                 \brief Defines the model that is used by the mapper.
             */
             /*!
                 \qmlproperty SomeModel VBarModelMapper::model
                 The QAbstractItemModel based model that is used by the mapper. You need to implement the model and expose it to
                 QML as shown in \l {QML Custom Model} demo application. Note: the model has to support adding/removing rows/columns
                 and modifying the data of the cells.
             */
             /*!
-                \property QVBoxPlotModelMapper::firstBarSetColumn
+                \property QVBoxPlotModelMapper::firstBoxSetColumn
-                \brief Defines which column of the model is used as the data source for the first bar set
+                \brief Defines which column of the model is used as the data source for the first box-and-whiskers set
                 Default value is: -1 (invalid mapping)
             */
             /*!
-                \qmlproperty int VBarModelMapper::firstBarSetColumn
+                \qmlproperty int VBarModelMapper::firstBoxSetColumn
-                Defines which column of the model is used as the data source for the first bar set. Default value
+                Defines which column of the model is used as the data source for the first box-and-whiskers set. Default value
                 is: -1 (invalid mapping).
             */
             /*!
-                \property QVBoxPlotModelMapper::lastBarSetColumn
+                \property QVBoxPlotModelMapper::lastBoxSetColumn
-                \brief Defines which column of the model is used as the data source for the last bar set
+                \brief Defines which column of the model is used as the data source for the last box-and-whiskers set
                 Default value is: -1 (invalid mapping)
             */
             /*!
-                \qmlproperty int VBarModelMapper::lastBarSetColumn
+                \qmlproperty int VBarModelMapper::lastBoxSetColumn
-                Defines which column of the model is used as the data source for the last bar set. Default
+                Defines which column of the model is used as the data source for the last box-and-whiskers set. Default
                 value is: -1 (invalid mapping).
             */
             /*!
                 \property QVBoxPlotModelMapper::firstRow
-                \brief Defines which row of the model contains the first values of the QBarSets in the series.
+                \brief Defines which row of the model contains the first values of the QBoxSets in the series.
                 Minimal and default value is: 0
             */
             /*!
-                \qmlproperty int VBarModelMapper::firstRow
+                \qmlproperty int VBoxPlotModelMapper::firstRow
-                Defines which row of the model contains the first values of the QBarSets in the series.
+                Defines which row of the model contains the first values of the QBoxSets in the series.
                 The default value is 0.
             */
             /*!
                 \property QVBoxPlotModelMapper::rowCount
-                \brief Defines the number of rows of the model that are mapped as the data for QAbstractBarSeries
+                \brief Defines the number of rows of the model that are mapped as the data for QBoxPlotSeries
                 Minimal and default value is: -1 (count limited by the number of rows in the model)
             */
             /*!
-                \qmlproperty int VBarModelMapper::rowCount
+                \qmlproperty int VBoxModelMapper::rowCount
-                Defines the number of rows of the model that are mapped as the data for QAbstractBarSeries. The default value is
+                Defines the number of rows of the model that are mapped as the data for QBoxPlotSeries. The default value is
                 -1 (count limited by the number of rows in the model)
             */
             /*!
                 \fn void QVBoxPlotModelMapper::seriesReplaced()
                 Emitted when the series to which mapper is connected to has changed.
             */
             /*!
                 \fn void QVBoxPlotModelMapper::modelReplaced()
                 Emitted when the model to which mapper is connected to has changed.
             */
             /*!
-                \fn void QVBoxPlotModelMapper::firstBarSetColumnChanged()
+                \fn void QVBoxPlotModelMapper::firstBoxSetColumnChanged()
-                Emitted when the firstBarSetColumn has changed.
+                Emitted when the firstBoxSetColumn has changed.
             */
             /*!
-                \fn void QVBoxPlotModelMapper::lastBarSetColumnChanged()
+                \fn void QVBoxPlotModelMapper::lastBoxSetColumnChanged()
-                Emitted when the lastBarSetColumn has changed.
+                Emitted when the lastBoxSetColumn has changed.
             */
             /*!
                 \fn void QVBoxPlotModelMapper::firstRowChanged()
                 Emitted when the firstRow has changed.
             */
             /*!
                 \fn void QVBoxPlotModelMapper::rowCountChanged()
                 Emitted when the rowCount has changed.
             */
             /*!
                 Constructs a mapper object which is a child of \a parent.
             */
             QVBoxPlotModelMapper::QVBoxPlotModelMapper(QObject *parent) :
                 QBoxPlotModelMapper(parent)
             {
                 QBoxPlotModelMapper::setOrientation(Qt::Vertical);
             }
             QAbstractItemModel *QVBoxPlotModelMapper::model() const
             {
                 return QBoxPlotModelMapper::model();
             }
             void QVBoxPlotModelMapper::setModel(QAbstractItemModel *model)
             {
                 if (model != QBoxPlotModelMapper::model()) {
                     QBoxPlotModelMapper::setModel(model);
                     emit modelReplaced();
                 }
             }
             QBoxPlotSeries *QVBoxPlotModelMapper::series() const
             {
                 return QBoxPlotModelMapper::series();
             }
             void QVBoxPlotModelMapper::setSeries(QBoxPlotSeries *series)
             {
                 if (series != QBoxPlotModelMapper::series()) {
                     QBoxPlotModelMapper::setSeries(series);
                     emit seriesReplaced();
                 }
             }
             int QVBoxPlotModelMapper::firstBoxSetColumn() const
             {
                 return QBoxPlotModelMapper::firstBoxSetSection();
             }
             void QVBoxPlotModelMapper::setFirstBoxSetColumn(int firstBoxSetColumn)
             {
                 if (firstBoxSetColumn != firstBoxSetSection()) {
                     QBoxPlotModelMapper::setFirstBoxSetSection(firstBoxSetColumn);
                     emit firstBoxSetColumnChanged();
                 }
             }
             int QVBoxPlotModelMapper::lastBoxSetColumn() const
             {
                 return QBoxPlotModelMapper::lastBoxSetSection();
             }
             void QVBoxPlotModelMapper::setLastBoxSetColumn(int lastBoxSetColumn)
             {
                 if (lastBoxSetColumn != lastBoxSetSection()) {
                     QBoxPlotModelMapper::setLastBoxSetSection(lastBoxSetColumn);
                     emit lastBoxSetColumnChanged();
                 }
             }
             int QVBoxPlotModelMapper::firstRow() const
             {
                 return QBoxPlotModelMapper::first();
             }
             void QVBoxPlotModelMapper::setFirstRow(int firstRow)
             {
                 if (firstRow != first()) {
                     QBoxPlotModelMapper::setFirst(firstRow);
                     emit firstRowChanged();
                 }
             }
             int QVBoxPlotModelMapper::rowCount() const
             {
                 return QBoxPlotModelMapper::count();
             }
             void QVBoxPlotModelMapper::setRowCount(int rowCount)
             {
                 if (rowCount != count()) {
                     QBoxPlotModelMapper::setCount(rowCount);
                     emit rowCountChanged();
                 }
             }
             #include "moc_qvboxplotmodelmapper.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/legend/qlegendmarker.cpp +1 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$
              **
              ****************************************************************************/
             #include "qlegendmarker.h"
             #include "qlegendmarker_p.h"
             #include "legendmarkeritem_p.h"
             #include "qlegend.h"
             #include "qlegend_p.h"
             #include "legendlayout_p.h"
             #include <QFontMetrics>
             #include <QGraphicsSceneEvent>
             #include <QAbstractSeries>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QLegendMarker
                 \brief LegendMarker object
                 \mainclass
                 QLegendMarker is abstract object that can be used to access markers inside QLegend. Legend marker consists of two
                 items: The colored box, which reflects the color of series and label, which is the name of series (or label of slice/barset
                 in case of pie or bar series)
                 The QLegendMarker is always related to one series.
                 \image examples_percentbarchart_legend.png
                 \sa QLegend
             */
             /*!
                 \enum QLegendMarker::LegendMarkerType
                 The type of the legendmarker object.
                 \value LegendMarkerTypeArea
                 \value LegendMarkerTypeBar
                 \value LegendMarkerTypePie
                 \value LegendMarkerTypeXY
+                \value LegendMarkerTypeBoxPlot
             */
             /*!
                 \fn virtual LegendMarkerType QLegendMarker::type() = 0;
                 Returns the type of legendmarker. Type depends of the related series. LegendMarkerTypeXY is used for all QXYSeries derived
                 classes.
             */
             /*!
                 \fn virtual QAbstractSeries* QLegendMarker::series() = 0;
                 Returns pointer to series, which is related to this marker. Marker is always related to some series.
             */
             /*!
               \fn void QLegendMarker::clicked();
               This signal is emitted, when marker is clicked with mouse.
             */
             /*!
               \fn void QLegendMarker::hovered(bool status);
               This signal is emitted, when mouse is hovered over marker. \a status is true, when mouse enters the marker
               and false when it leaves the marker.
             */
             /*!
                 \fn void QLegendMarker::labelChanged()
                 This signal is emitted when the label of the legend marker has changed.
             */
             /*!
                 \fn void QLegendMarker::labelBrushChanged()
                 This signal is emitted when the label brush of the legend marker has changed.
             */
             /*!
                 \fn void QLegendMarker::fontChanged()
                 This signal is emitted when the (label) font of the legend marker has changed.
             */
             /*!
                 \fn void QLegendMarker::penChanged()
                 This signal is emitted when the pen of the legend marker has changed.
             */
             /*!
                 \fn void QLegendMarker::brushChanged()
                 This signal is emitted when the brush of the legend marker has changed.
             */
             /*!
                 \fn void QLegendMarker::visibleChanged()
                 This signal is emitted when the visibility of the legend marker has changed.
             */
             /*!
                 \property QLegendMarker::label
                 Label of the marker. This is the text that is shown in legend.
             */
             /*!
                 \property QLegendMarker::labelBrush
                 Brush of the label
             */
             /*!
                 \property QLegendMarker::font
                 Font of the label
             */
             /*!
                 \property QLegendMarker::pen
                 Pen of the marker. This is the outline of the colored square.
             */
             /*!
                 \property QLegendMarker::brush
                 Brush of the marker. This is the inside of the colored square.
             */
             /*!
                 \property QLegendMarker::visible
                 Visibility of the legend marker. Affects label and the colored square.
             */
             /*!
                 \internal
              */
             QLegendMarker::QLegendMarker(QLegendMarkerPrivate &d, QObject *parent) :
                 QObject(parent),
                 d_ptr(&d)
             {
                 d_ptr->m_item->setVisible(d_ptr->series()->isVisible());
             }
             /*!
               Destructor of marker
             */
             QLegendMarker::~QLegendMarker()
             {
             }
             /*!
               Returns the label of the marker.
             */
             QString QLegendMarker::label() const
             {
                 return d_ptr->m_item->label();
             }
             /*!
               Sets the \a label of marker. Note that changing name of series will also change label of its marker.
             */
             void QLegendMarker::setLabel(const QString &label)
             {
                 if (label.isEmpty()) {
                     d_ptr->m_customLabel = false;
                 } else {
                     d_ptr->m_customLabel = true;
                     d_ptr->m_item->setLabel(label);
                 }
             }
             /*!
               Returns the brush which is used to draw label.
             */
             QBrush QLegendMarker::labelBrush() const
             {
                 return d_ptr->m_item->labelBrush();
             }
             /*!
               Sets the \a brush of label
             */
             void QLegendMarker::setLabelBrush(const QBrush &brush)
             {
                 d_ptr->m_item->setLabelBrush(brush);
             }
             /*!
               Retuns the font of label
             */
             QFont QLegendMarker::font() const
             {
                 return d_ptr->m_item->font();
             }
             /*!
               Sets the \a font of label
             */
             void QLegendMarker::setFont(const QFont &font)
             {
                 d_ptr->m_item->setFont(font);
             }
             /*!
               Returns the pen of marker item
             */
             QPen QLegendMarker::pen() const
             {
                 return d_ptr->m_item->pen();
             }
             /*!
               Sets the \a pen of marker item
             */
             void QLegendMarker::setPen(const QPen &pen)
             {
                 if (pen == QPen(Qt::NoPen)) {
                     d_ptr->m_customPen = false;
                 } else {
                     d_ptr->m_customPen = true;
                     d_ptr->m_item->setPen(pen);
                 }
             }
             /*!
               Returns the brush of marker item
             */
             QBrush QLegendMarker::brush() const
             {
                 return d_ptr->m_item->brush();
             }
             /*!
               Sets the \a brush of marker item. Note that changing color of the series also changes this.
             */
             void QLegendMarker::setBrush(const QBrush &brush)
             {
                 if (brush == QBrush(Qt::NoBrush)) {
                     d_ptr->m_customBrush = false;
                 } else {
                     d_ptr->m_customBrush = true;
                     d_ptr->m_item->setBrush(brush);
                 }
             }
             /*!
               Returns visibility of the marker
             */
             bool QLegendMarker::isVisible() const
             {
                 return d_ptr->m_item->isVisible();
             }
             /*!
               Sets markers visibility to \a visible
             */
             void QLegendMarker::setVisible(bool visible)
             {
                 d_ptr->m_item->setVisible(visible);
             }
             ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QLegendMarkerPrivate::QLegendMarkerPrivate(QLegendMarker *q, QLegend *legend) :
                 m_legend(legend),
                 m_customLabel(false),
                 m_customBrush(false),
                 m_customPen(false),
                 q_ptr(q)
             {
                 m_item = new LegendMarkerItem(this);
             }
             QLegendMarkerPrivate::~QLegendMarkerPrivate()
             {
                 delete m_item;
             }
             void QLegendMarkerPrivate::invalidateLegend()
             {
                 m_legend->d_ptr->m_layout->invalidate();
             }
             #include "moc_qlegendmarker.cpp"
             #include "moc_qlegendmarker_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/qabstractseries.cpp +1 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$
             **
             ****************************************************************************/
             #include "qabstractseries.h"
             #include "qabstractseries_p.h"
             #include "chartdataset_p.h"
             #include "qchart.h"
             #include "qchart_p.h"
             #include "chartitem_p.h"
             #include "xydomain_p.h"
             #include "xlogydomain_p.h"
             #include "logxydomain_p.h"
             #include "logxlogydomain_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QAbstractSeries
                 \brief Base class for all QtCommercial Chart series.
                 \mainclass
                 Usually you use the series type specific inherited classes instead of the base class.
                 \sa QXYSeries, QLineSeries, QSplineSeries, QScatterSeries, QAreaSeries, QAbstractBarSeries, QStackedBarSeries,
                 QPercentBarSeries, QPieSeries
             */
             /*!
                 \qmlclass AbstractSeries
                 AbstractSeries is the base class for all series.
                 The class cannot be instantiated by the user.
             */
             /*!
                 \enum QAbstractSeries::SeriesType
                 The type of the series object.
                 \value SeriesTypeLine
                 \value SeriesTypeArea
                 \value SeriesTypeBar
                 \value SeriesTypeStackedBar
                 \value SeriesTypePercentBar
                 \value SeriesTypePie
                 \value SeriesTypeScatter
                 \value SeriesTypeSpline
                 \value SeriesTypeHorizontalBar
                 \value SeriesTypeHorizontalStackedBar
                 \value SeriesTypeHorizontalPercentBar
+                \value SeriesTypeBoxPlot
             */
             /*!
                 \property QAbstractSeries::type
                 The type of the series.
             */
             /*!
                 \qmlproperty ChartView.SeriesType AbstractSeries::type
                 The type of the series.
             */
             /*!
                 \property QAbstractSeries::name
                 \brief name of the series property. The name is shown in legend for QXYSeries.
             */
             /*!
                 \qmlproperty string AbstractSeries::name
                 Name of the series. The name is shown in legend for QXYSeries.
             */
             /*!
                 \fn void QAbstractSeries::nameChanged()
                 This signal is emitted when the series name changes.
             */
             /*!
                 \qmlsignal AbstractSeries::onNameChanged()
                 This signal is emitted when the series name changes.
             */
             /*!
                 \property QAbstractSeries::visible
                 \brief whether the series is visible or not; true by default.
             */
             /*!
                 \qmlproperty bool AbstractSeries::visible
                 Visibility of the series. True by default.
             */
             /*!
                 \fn void QAbstractSeries::visibleChanged()
                 Emitted when the series visibility changes.
             */
             /*!
                 \qmlsignal AbstractSeries::onVisibleChanged()
                 Emitted when the series visibility changes.
             */
             /*!
                 \property QAbstractSeries::opacity
                 \brief The opacity of the series.
                 By default the opacity is 1.0. The valid values range from 0.0 (transparent) to 1.0 (opaque).
             */
             /*!
                 \qmlproperty real AbstractSeries::opacity
                 The opacity of the series. By default the opacity is 1.0.
                 The valid values range from 0.0 (transparent) to 1.0 (opaque).
             */
             /*!
                 \fn void QAbstractSeries::opacityChanged()
                 Emitted when the opacity of the series changes.
             */
             /*!
                 \qmlsignal AbstractSeries::onOpacityChanged()
                 Emitted when the opacity of the series changes.
             */
             /*!
                 \internal
                 \brief Constructs ChartSeries object with \a parent.
             */
             QAbstractSeries::QAbstractSeries(QAbstractSeriesPrivate &d, QObject *parent) :
                 QObject(parent),
                 d_ptr(&d)
             {
             }
             /*!
                 \brief Virtual destructor for the chart series.
             */
             QAbstractSeries::~QAbstractSeries()
             {
                 if (d_ptr->m_chart)
                     qFatal("Still binded series detected !");
             }
             void QAbstractSeries::setName(const QString &name)
             {
                 if (name != d_ptr->m_name) {
                     d_ptr->m_name = name;
                     emit nameChanged();
                 }
             }
             QString QAbstractSeries::name() const
             {
                 return d_ptr->m_name;
             }
             /*!
                 Sets the visibility of series to \a visible
             */
             void QAbstractSeries::setVisible(bool visible)
             {
                 if (visible != d_ptr->m_visible) {
                     d_ptr->m_visible = visible;
                     emit visibleChanged();
                 }
             }
             /*!
                 Returns the visibility of series
             */
             bool QAbstractSeries::isVisible() const
             {
                 return d_ptr->m_visible;
             }
             qreal QAbstractSeries::opacity() const
             {
                 return d_ptr->m_opacity;
             }
             void QAbstractSeries::setOpacity(qreal opacity)
             {
                 if (opacity != d_ptr->m_opacity) {
                     d_ptr->m_opacity = opacity;
                     emit opacityChanged();
                 }
             }
             /*!
                 \brief Returns the chart where series belongs to.
                 Set automatically when the series is added to the chart
                 and unset when the series is removed from the chart.
             */
             QChart *QAbstractSeries::chart() const
             {
                 return d_ptr->m_chart;
             }
             /*!
                 \brief Sets the visibility of the series to true
                 \sa setVisible(), isVisible()
             */
             void QAbstractSeries::show()
             {
                 setVisible(true);
             }
             /*!
                 \brief Sets the visibility of the series to false
                 \sa setVisible(), isVisible()
             */
             void QAbstractSeries::hide()
             {
                 setVisible(false);
             }
             /*!
              Attach \a axis to the series.
              \return true if the axis was attached successfully, false otherwise.
              \sa QChart::addAxis(), QChart::createDefaultAxes()
              */
             bool QAbstractSeries::attachAxis(QAbstractAxis* axis)
             {
                 if(d_ptr->m_chart) {
                     return d_ptr->m_chart->d_ptr->m_dataset->attachAxis(this, axis);
                 } else {
                     qWarning()<<"Series not in the chart. Please addSeries to chart first.";
                     return false;
                 }
             }
             /*!
              Detach \a axis from the series.
              \return true if the axis was detached successfully, false otherwise.
              \sa QChart::removeAxis()
              */
             bool QAbstractSeries::detachAxis(QAbstractAxis* axis)
             {
                 if(d_ptr->m_chart) {
                     return d_ptr->m_chart->d_ptr->m_dataset->detachAxis(this, axis);
                 }
                 else {
                     qWarning()<<"Series not in the chart. Please addSeries to chart first.";
                     return false;
                 }
             }
             /*!
              Returns the list of axes attached to the series. Usually there is an x-axis and a y-axis attached to a series, except
              in case of a QPieSeries, which does not have any axes attached.
              \sa attachAxis(), detachAxis()
              */
             QList<QAbstractAxis*> QAbstractSeries::attachedAxes()
             {
                 return d_ptr->m_axes;
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////
             QAbstractSeriesPrivate::QAbstractSeriesPrivate(QAbstractSeries *q)
                 : q_ptr(q),
                   m_chart(0),
                   m_item(0),
                   m_domain(new XYDomain()),
                   m_visible(true),
                   m_opacity(1.0)
             {
             }
             QAbstractSeriesPrivate::~QAbstractSeriesPrivate()
             {
             }
             void QAbstractSeriesPrivate::setDomain(AbstractDomain* domain)
             {
                 Q_ASSERT(domain);
                 if(m_domain.data()!=domain) {
                     if(!m_item.isNull()) QObject::disconnect(m_domain.data(), SIGNAL(updated()), m_item.data(), SLOT(handleDomainUpdated()));
                     m_domain.reset(domain);
                     if(!m_item.isNull()) {
                         QObject::connect(m_domain.data(), SIGNAL(updated()),m_item.data(), SLOT(handleDomainUpdated()));
                         m_item->handleDomainUpdated();
                     }
                 }
             }
             void QAbstractSeriesPrivate::initializeGraphics(QGraphicsItem* parent)
             {
                 Q_ASSERT(!m_item.isNull());
                 Q_UNUSED(parent);
                 QObject::connect(m_domain.data(), SIGNAL(updated()),m_item.data(), SLOT(handleDomainUpdated()));
             }
             void QAbstractSeriesPrivate::initializeAnimations(QChart::AnimationOptions options)
             {
                 Q_UNUSED(options);
             }
             #include "moc_qabstractseries.cpp"
             #include "moc_qabstractseries_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

tests/boxplottester/mainwidget.cpp +31 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$
             **
             ****************************************************************************/
             #include "mainwidget.h"
             #include "customtablemodel.h"
             #include <QVBoxPlotModelMapper>
             #include <QTableView>
             #include <QHeaderView>
             #include <QChartView>
             #include <QBoxPlotSeries>
             #include <QBoxSet>
             #include <QLegend>
             #include <QBarCategoryAxis>
             #include <QBrush>
             #include <QColor>
             #include <QPushButton>
             #include <QComboBox>
             #include <QSpinBox>
             #include <QCheckBox>
             #include <QGridLayout>
             #include <QHBoxLayout>
             #include <QLabel>
             #include <QSpacerItem>
             #include <QMessageBox>
             #include <cmath>
             #include <QDebug>
             #include <QStandardItemModel>
             #include <QBarCategoryAxis>
             QTCOMMERCIALCHART_USE_NAMESPACE
             QString addCategories[] = {"Jul", "Aug", "Sep", "Nov", "Dec"};
             MainWidget::MainWidget(QWidget *parent) :
                 QWidget(parent),
                 m_chart(0),
                 rowPos(0),
                 nSeries(0),
                 nNewBoxes(0)
             {
                 m_chart = new QChart();
                 // Grid layout for the controls for configuring the chart widget
                 QGridLayout *grid = new QGridLayout();
                 // Create add a series button
                 QPushButton *addSeriesButton = new QPushButton("Add a series");
                 connect(addSeriesButton, SIGNAL(clicked()), this, SLOT(addSeries()));
                 grid->addWidget(addSeriesButton, rowPos++, 1);
                 // Create remove a series button
                 QPushButton *removeSeriesButton = new QPushButton("Remove a series");
                 connect(removeSeriesButton, SIGNAL(clicked()), this, SLOT(removeSeries()));
                 grid->addWidget(removeSeriesButton, rowPos++, 1);
                 // Create add a single box button
                 QPushButton *addBoxButton = new QPushButton("Add a box");
                 connect(addBoxButton, SIGNAL(clicked()), this, SLOT(addBox()));
                 grid->addWidget(addBoxButton, rowPos++, 1);
                 // Create insert a box button
                 QPushButton *insertBoxButton = new QPushButton("Insert a box");
                 connect(insertBoxButton, SIGNAL(clicked()), this, SLOT(insertBox()));
                 grid->addWidget(insertBoxButton, rowPos++, 1);
                 // Create add a single box button
                 QPushButton *removeBoxButton = new QPushButton("Remove a box");
                 connect(removeBoxButton, SIGNAL(clicked()), this, SLOT(removeBox()));
                 grid->addWidget(removeBoxButton, rowPos++, 1);
                 // Create clear button
                 QPushButton *clearButton = new QPushButton("Clear");
                 connect(clearButton, SIGNAL(clicked()), this, SLOT(clear()));
                 grid->addWidget(clearButton, rowPos++, 1);
                 // Create set brush button
                 QPushButton *setBrushButton = new QPushButton("Set brush");
                 connect(setBrushButton, SIGNAL(clicked()), this, SLOT(setBrush()));
                 grid->addWidget(setBrushButton, rowPos++, 1);
                 initThemeCombo(grid);
                 initCheckboxes(grid);
                 m_model = new CustomTableModel;
                 QTableView *tableView = new QTableView;
                 tableView->setModel(m_model);
                 tableView->setMaximumWidth(200);
                 grid->addWidget(tableView, rowPos++, 0, 3, 2, Qt::AlignLeft);
             #if (QT_VERSION >= QT_VERSION_CHECK(5, 0, 0))
                 tableView->horizontalHeader()->setSectionResizeMode(QHeaderView::Stretch);
                 tableView->verticalHeader()->setSectionResizeMode(QHeaderView::Stretch);
             #else
                 tableView->horizontalHeader()->setResizeMode(QHeaderView::Stretch);
                 tableView->verticalHeader()->setResizeMode(QHeaderView::Stretch);
             #endif
                 // add row with empty label to make all the other rows static
                 grid->addWidget(new QLabel(""), grid->rowCount(), 0);
                 grid->setRowStretch(grid->rowCount() - 1, 1);
                 // Create chart view with the chart
                 m_chartView = new QChartView(m_chart, this);
                 //m_chartView->setRubberBand(QChartView::HorizonalRubberBand);
                 // Another grid layout as a main layout
                 QGridLayout *mainLayout = new QGridLayout();
                 mainLayout->addLayout(grid, 0, 0);
                 mainLayout->addWidget(m_chartView, 0, 1, 3, 1);
                 setLayout(mainLayout);
                 legendToggled(false);
                 animationToggled(false);
             }
             // Combo box for selecting theme
             void MainWidget::initThemeCombo(QGridLayout *grid)
             {
                 QComboBox *chartTheme = new QComboBox();
                 chartTheme->addItem("Default");
                 chartTheme->addItem("Light");
                 chartTheme->addItem("Blue Cerulean");
                 chartTheme->addItem("Dark");
                 chartTheme->addItem("Brown Sand");
                 chartTheme->addItem("Blue NCS");
                 chartTheme->addItem("High Contrast");
                 chartTheme->addItem("Blue Icy");
                 connect(chartTheme, SIGNAL(currentIndexChanged(int)),
                         this, SLOT(changeChartTheme(int)));
                 grid->addWidget(new QLabel("Chart theme:"), rowPos, 0);
                 grid->addWidget(chartTheme, rowPos++, 1);
             }
             // Different check boxes for customizing chart
             void MainWidget::initCheckboxes(QGridLayout *grid)
             {
                 QCheckBox *animationCheckBox = new QCheckBox("Animation");
                 connect(animationCheckBox, SIGNAL(toggled(bool)), this, SLOT(animationToggled(bool)));
                 animationCheckBox->setChecked(false);
                 grid->addWidget(animationCheckBox, rowPos++, 0);
                 QCheckBox *legendCheckBox = new QCheckBox("Legend");
                 connect(legendCheckBox, SIGNAL(toggled(bool)), this, SLOT(legendToggled(bool)));
                 legendCheckBox->setChecked(false);
                 grid->addWidget(legendCheckBox, rowPos++, 0);
                 QCheckBox *titleCheckBox = new QCheckBox("Title");
                 connect(titleCheckBox, SIGNAL(toggled(bool)), this, SLOT(titleToggled(bool)));
                 titleCheckBox->setChecked(false);
                 grid->addWidget(titleCheckBox, rowPos++, 0);
                 QCheckBox *modelMapperCheckBox = new QCheckBox("Use model mapper");
                 connect(modelMapperCheckBox, SIGNAL(toggled(bool)), this, SLOT(modelMapperToggled(bool)));
                 modelMapperCheckBox->setChecked(false);
                 grid->addWidget(modelMapperCheckBox, rowPos++, 0);
             }
             void MainWidget::addSeries()
             {
                 qDebug() << "BoxPlotTester::MainWidget::addSeries()";
                 if (nSeries > 9)
                     return;
                 // Initial data
                 //![1]
                 QBoxSet *set0 = new QBoxSet();
                 QBoxSet *set1 = new QBoxSet();
                 QBoxSet *set2 = new QBoxSet();
                 QBoxSet *set3 = new QBoxSet();
                 QBoxSet *set4 = new QBoxSet();
                 QBoxSet *set5 = new QBoxSet();
                 //      low  bot   med   top  upp
                 *set0 << 3 << 4 << 4.4 << 6 << 7;
                 *set1 << 5 << 6 << 7.5 << 8 << 12;
                 *set2 << 3 << 5 << 5.7 << 8 << 9;
                 *set3 << 5 << 6 << 6.8 << 7 << 8;
                 *set4 << 4 << 5 << 5.2 << 6 << 7;
                 *set5 << 4 << 7 << 8.2 << 9 << 10;
                 m_series[nSeries] = new QBoxPlotSeries();
                 m_series[nSeries]->append(set0);
                 m_series[nSeries]->append(set1);
                 m_series[nSeries]->append(set2);
                 m_series[nSeries]->append(set3);
                 m_series[nSeries]->append(set4);
                 m_series[nSeries]->append(set5);
                 m_series[nSeries]->setName("Box & Whiskers");
+                connect(m_series[nSeries], SIGNAL(clicked(QBoxSet*)), this, SLOT(boxClicked(QBoxSet*)));
+                connect(m_series[nSeries], SIGNAL(hovered(bool, QBoxSet*)), this, SLOT(boxHovered(bool, QBoxSet*)));
+                connect(set1, SIGNAL(clicked()), this, SLOT(singleBoxClicked()));
+                connect(set2, SIGNAL(hovered(bool)), this, SLOT(singleBoxHovered(bool)));
                 m_chart->addSeries(m_series[nSeries]);
                 if (nSeries == 0) {
                     QStringList categories;
                     categories << "Jan" << "Feb" << "Mar" << "Apr" << "May" << "Jun";
                     m_axis = new QBarCategoryAxis();
                     m_axis->append(categories);
                     m_chart->createDefaultAxes();
                     m_chart->setAxisX(m_axis, m_series[nSeries]);
                 }
                 nSeries++;
             }
             void MainWidget::removeSeries()
             {
                 qDebug() << "BoxPlotTester::MainWidget::removeSeries()";
                 if (nSeries > 0) {
                     nSeries--;
                     m_chart->removeSeries(m_series[nSeries]);
                     delete m_series[nSeries];
                 } else {
                     qDebug() << "Create a series first";
                 }
             }
             void MainWidget::addBox()
             {
                 qDebug() << "BoxPlotTester::MainWidget::addBox()";
                 if (nSeries > 0) {
                     QBoxSet *newSet = new QBoxSet();
                     *newSet << 5 << 6 << 6.8 << 7 << 8;
                     m_series[0]->append(newSet);
                     m_axis->append(addCategories[nNewBoxes]);
                     nNewBoxes++;
                 }
             }
             void MainWidget::insertBox()
             {
                 qDebug() << "BoxPlotTester::MainWidget::insertBox()";
                 if (nSeries > 0) {
                     QBoxSet *newSet = new QBoxSet();
                     *newSet << 2 << 6 << 6.8 << 7 << 10;
                     m_series[0]->insert(1, newSet);
                     m_axis->append(addCategories[nNewBoxes]);
                     nNewBoxes++;
                 }
             }
             void MainWidget::removeBox()
             {
                 qDebug() << "BoxPlotTester::MainWidget::removeBox";
                 if (nSeries > 0) {
                     QList<QBoxSet *> sets = m_series[0]->boxSets();
                     m_series[0]->remove(sets.at(m_series[0]->count() - 3));
                 } else {
                     qDebug() << "Create a series first";
                 }
             }
             void MainWidget::clear()
             {
                 qDebug() << "BoxPlotTester::MainWidget::clear";
                 if (nSeries > 0) {
                     m_series[0]->clear();
                 } else {
                     qDebug() << "Create a series first";
                 }
             }
             void MainWidget::setBrush()
             {
                 qDebug() << "BoxPlotTester::MainWidget::setBrush";
                 if (nSeries > 0) {
                     QList<QBoxSet *> sets = m_series[0]->boxSets();
                     sets.at(1)->setBrush(QBrush(QColor(Qt::yellow)));
                 } else {
                     qDebug() << "Create a series first";
                 }
             }
             void MainWidget::animationToggled(bool enabled)
             {
                 qDebug() << "BoxPlotTester::Animation toggled to " << enabled;
                 if (enabled)
                     m_chart->setAnimationOptions(QChart::SeriesAnimations);
                 else
                     m_chart->setAnimationOptions(QChart::NoAnimation);
             }
             void MainWidget::legendToggled(bool enabled)
             {
                 qDebug() << "BoxPlotTester::Legend toggled to " << enabled;
                 m_chart->legend()->setVisible(enabled);
                 if (enabled)
                     m_chart->legend()->setAlignment(Qt::AlignBottom);
             }
             void MainWidget::titleToggled(bool enabled)
             {
                 qDebug() << "BoxPlotTester::Title toggled to " << enabled;
                 if (enabled)
                     m_chart->setTitle("Simple boxplotchart example");
                 else
                     m_chart->setTitle("");
             }
             void MainWidget::modelMapperToggled(bool enabled)
             {
                 if (enabled) {
                     m_series[nSeries] = new QBoxPlotSeries();
                     int first = 0;
                     int count = 5;
                     QVBoxPlotModelMapper *mapper = new QVBoxPlotModelMapper(this);
                     mapper->setFirstBoxSetColumn(0);
                     mapper->setLastBoxSetColumn(5);
                     mapper->setFirstRow(first);
                     mapper->setRowCount(count);
                     mapper->setSeries(m_series[nSeries]);
                     mapper->setModel(m_model);
                     m_chart->addSeries(m_series[nSeries]);
                     nSeries++;
                 } else {
                     removeSeries();
                 }
             }
             void MainWidget::changeChartTheme(int themeIndex)
             {
                 qDebug() << "BoxPlotTester::changeChartTheme: " << themeIndex;
                 if (themeIndex == 0)
                     m_chart->setTheme(QChart::ChartThemeLight);
                 else
                     m_chart->setTheme((QChart::ChartTheme) (themeIndex - 1));
             }
+            void MainWidget::boxClicked(QBoxSet *set)
+            {
+                qDebug() << "boxClicked, median = " << set->median();
+            }
+            void MainWidget::boxHovered(bool state, QBoxSet *set)
+            {
+                if (state)
+                    qDebug() << "box median " << set->median() << " hover started";
+                else
+                    qDebug() << "box median " << set->median() << " hover ended";
+            }
+            void MainWidget::singleBoxClicked()
+            {
+                qDebug() << "singleBoxClicked";
+            }
+            void MainWidget::singleBoxHovered(bool state)
+            {
+                if (state)
+                    qDebug() << "single box hover started";
+                else
+                    qDebug() << "single box hover ended";
+            }

tests/boxplottester/mainwidget.h +5 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 MAINWIDGET_H
             #define MAINWIDGET_H
             #include "qchartglobal.h"
             #include "qchart.h"
             #include "qchartview.h"
             #include "customtablemodel.h"
             #include <QWidget>
             #include <QBoxPlotSeries>
             #include <QBarCategoryAxis>
+            #include <QBoxSet>
             class QGridLayout;
             QTCOMMERCIALCHART_USE_NAMESPACE
             class MainWidget : public QWidget
             {
                 Q_OBJECT
             public:
                 explicit MainWidget(QWidget *parent = 0);
             signals:
             private:
                 void initThemeCombo(QGridLayout *grid);
                 void initCheckboxes(QGridLayout *grid);
             private slots:
                 void addSeries();
                 void removeSeries();
                 void addBox();
                 void insertBox();
                 void removeBox();
                 void clear();
                 void setBrush();
                 void animationToggled(bool enabled);
                 void legendToggled(bool enabled);
                 void titleToggled(bool enabled);
                 void modelMapperToggled(bool enabled);
                 void changeChartTheme(int themeIndex);
+                void boxClicked(QBoxSet *set);
+                void boxHovered(bool state, QBoxSet *set);
+                void singleBoxClicked();
+                void singleBoxHovered(bool state);
             private:
                 QChart *m_chart;
                 QChartView *m_chartView;
                 QGridLayout *m_scatterLayout;
                 QBarCategoryAxis *m_axis;
                 CustomTableModel *m_model;
                 int rowPos;
                 int nSeries;
                 int nNewBoxes;
                 QBoxPlotSeries *m_series[10];
             };
             #endif // MAINWIDGET_H

General Comments 0

Write
Preview

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

No TODOs yet

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

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