HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r2554:93cea193b2c2

Changed BoxPlot to use domain for calculating geometry points....

Mika Salmela -

r2554:93cea193b2c2

parent child

Context file:

r2554:93cea193b2c2

Collapse all files

src/boxplotchart/boxplotchartitem.cpp +7 -14

             /****************************************************************************
             **
             ** 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 "boxplotchartitem_p.h"
             #include "qboxplotseries_p.h"
             #include "bar_p.h"
             #include "qboxset_p.h"
             #include "qabstractbarseries_p.h"
             #include "qboxset.h"
             #include "boxwhiskers_p.h"
             #include <QPainter>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             BoxPlotChartItem::BoxPlotChartItem(QBoxPlotSeries *series, QGraphicsItem *item) :
                 ChartItem(series->d_func(), item),
                 m_series(series),
                 m_animation(0),
-                m_animate(0),
+                m_animate(0)
-                m_domainMaxY(0.0),
-                m_domainMinY(0.0)
             {
                 connect(series, SIGNAL(boxsetsRemoved(QList<QBoxSet *>)), this, SLOT(handleBoxsetRemove(QList<QBoxSet *>)));
                 connect(series->d_func(), SIGNAL(restructuredBoxes()), this, SLOT(handleDataStructureChanged()));
                 connect(series->d_func(), SIGNAL(updatedLayout()), this, SLOT(handleLayoutChanged()));
                 connect(series->d_func(), SIGNAL(updatedBoxes()), this, SLOT(handleUpdatedBars()));
                 connect(series->d_func(), SIGNAL(updated()), this, SLOT(handleUpdatedBars()));
                 // QBoxPlotSeriesPrivate calls handleDataStructureChanged(), don't do it here
                 setZValue(ChartPresenter::BoxPlotSeriesZValue);
             }
             BoxPlotChartItem::~BoxPlotChartItem()
             {
             }
             void BoxPlotChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(painter);
                 Q_UNUSED(option);
                 Q_UNUSED(widget);
             }
             void BoxPlotChartItem::setAnimation(BoxPlotAnimation *animation)
             {
                 m_animation = animation;
                 if (m_animation) {
                     foreach (BoxWhiskers *item, m_boxTable.values())
                         m_animation->addBox(item);
                     handleDomainUpdated();
                 }
             }
             void BoxPlotChartItem::handleDataStructureChanged()
             {
                 int setCount = m_series->count();
                 for (int s = 0; s < setCount; s++) {
                     QBoxSet *set = m_series->d_func()->boxSetAt(s);
                     BoxWhiskers *box = m_boxTable.value(set);
                     if (!box) {
                         // Item is not yet created, make a box and add it to hash table
                         box = new BoxWhiskers(set, domain(), this);
                         m_boxTable.insert(set, box);
                         connect(box, SIGNAL(clicked(QBoxSet *)), m_series, SIGNAL(clicked(QBoxSet *)));
                         connect(box, SIGNAL(hovered(bool, QBoxSet *)), m_series, SIGNAL(hovered(bool, QBoxSet *)));
                         connect(box, SIGNAL(clicked(QBoxSet *)), set, SIGNAL(clicked()));
                         connect(box, SIGNAL(hovered(bool, QBoxSet *)), set, SIGNAL(hovered(bool)));
                         // Set the decorative issues for the newly created box
                         box->setBrush(m_series->brush());
                         box->setPen(m_series->pen());
                     }
                     updateBoxGeometry(box, s);
-                    box->updateGeometry();
+                    box->updateGeometry(domain());
                     if (m_animation)
                         m_animation->addBox(box);
                 }
                 handleDomainUpdated();
             }
             void 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)
             {
                 foreach (QBoxSet *set, barSets) {
                     BoxWhiskers *boxItem = m_boxTable.value(set);
                     m_boxTable.remove(set);
                     delete boxItem;
                 }
             }
             void BoxPlotChartItem::handleDomainUpdated()
             {
                 if ((domain()->size().width() <= 0) || (domain()->size().height() <= 0))
                     return;
-                // Set my bounding rect to same as domain size
+                // Set my bounding rect to same as domain size. Add one pixel at the top (-1.0) and the bottom as 0.0 would
-                m_boundingRect.setRect(0.0, 0.0, domain()->size().width(), domain()->size().height());
+                // snip a bit off from the whisker at the grid line
+                m_boundingRect.setRect(0.0, -1.0, domain()->size().width(), domain()->size().height() + 1.0);
                 foreach (BoxWhiskers *item, m_boxTable.values()) {
-                    // Update the domain size for each BoxWhisker item
+                    item->updateGeometry(domain());
-                    item->setDomainSize(domain()->size());
-                    if (domain()->minY() != m_domainMinY || domain()->maxY() != m_domainMaxY) {
-                        item->updateGeometry();
-                        m_domainMinY = domain()->minY();
-                        m_domainMaxY = domain()->maxY();
                     // If the animation is set, start the animation for each BoxWhisker item
                     if (m_animation)
                         presenter()->startAnimation(m_animation->boxAnimation(item));
                 }
             }
             void 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();
+                        item->updateGeometry(domain());
                 }
             }
             QRectF BoxPlotChartItem::boundingRect() const
             {
                 return m_boundingRect;
             }
             void BoxPlotChartItem::initializeLayout()
             {
             }
             QVector<QRectF> 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/boxplotchartitem_p.h 0 -2

             /****************************************************************************
             **
             ** Copyright (C) 2013 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             //  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 BOXPLOTCHARTITEM_H
             #define BOXPLOTCHARTITEM_H
             #include "boxwhiskers_p.h"
             #include "qboxplotseries.h"
             #include "chartitem_p.h"
             #include "boxplotanimation_p.h"
             #include "qboxset.h"
             #include <QGraphicsItem>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class BoxPlotSeriesPrivate;
             class BoxPlotChartItem : public ChartItem
             {
                 Q_OBJECT
             public:
                 BoxPlotChartItem(QBoxPlotSeries *series, QGraphicsItem *item = 0);
                 ~BoxPlotChartItem();
                 void setAnimation(BoxPlotAnimation *animation);
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
                 QRectF boundingRect() const;
             public Q_SLOTS:
                 void handleDataStructureChanged();
                 void handleDomainUpdated();
                 void handleLayoutChanged();
                 void handleUpdatedBars();
                 void handleBoxsetRemove(QList<QBoxSet *> barSets);
             private:
                 virtual QVector<QRectF> calculateLayout();
                 void initializeLayout();
                 bool updateBoxGeometry(BoxWhiskers *box, int index);
             protected:
                 friend class QBoxPlotSeriesPrivate;
                 QBoxPlotSeries *m_series; // Not owned.
                 QList<BoxWhiskers *> m_boxes;
                 QHash<QBoxSet *, BoxWhiskers *> m_boxTable;
                 int m_seriesIndex;
                 int m_seriesCount;
                 BoxPlotAnimation *m_animation;
                 bool m_animate;
-                qreal m_domainMaxY;
-                qreal m_domainMinY;
                 QRectF m_boundingRect;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // BOXPLOTCHARTITEM_H

src/boxplotchart/boxwhiskers.cpp +44 -40

             /****************************************************************************
              **
              ** 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 "boxwhiskers_p.h"
             #include <QPainter>
             #include <QWidget>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             BoxWhiskers::BoxWhiskers(QBoxSet *set, AbstractDomain *domain, QGraphicsObject *parent) :
                 QGraphicsObject(parent),
                 m_boxSet(set),
                 m_domain(domain)
             {
                 setAcceptHoverEvents(true);
                 setAcceptedMouseButtons(Qt::MouseButtonMask);
             }
             BoxWhiskers::~BoxWhiskers()
             {
             }
             void BoxWhiskers::mousePressEvent(QGraphicsSceneMouseEvent *event)
             {
                 Q_UNUSED(event)
                 emit clicked(m_boxSet);
             }
             void BoxWhiskers::hoverEnterEvent(QGraphicsSceneHoverEvent *event)
             {
                 Q_UNUSED(event)
                 emit hovered(true, m_boxSet);
             }
             void BoxWhiskers::hoverLeaveEvent(QGraphicsSceneHoverEvent *event)
             {
                 Q_UNUSED(event)
                 emit hovered(false, m_boxSet);
             }
             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();
+                updateGeometry(m_domain);
                 update();
             }
             QSizeF BoxWhiskers::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
             {
                 Q_UNUSED(which)
                 Q_UNUSED(constraint)
                 return QSizeF();
             }
             void BoxWhiskers::setGeometry(const QRectF &rect)
             {
                 Q_UNUSED(rect)
             }
-            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)
                 painter->setPen(m_pen);
                 painter->setBrush(m_brush);
                 painter->setClipRect(parentItem()->boundingRect());
-                painter->scale(m_domainSize.width() / m_data.m_boxItems, m_domainSize.height() / m_domain->spanY());
                 painter->drawPath(m_boxPath);
             }
-            void BoxWhiskers::updateGeometry()
+            void BoxWhiskers::updateGeometry(AbstractDomain *domain)
             {
+                m_domain = domain;
                 prepareGeometryChange();
                 QPainterPath path;
+                m_boxPath = path;
+                m_boundingRect = m_boxPath.boundingRect();
                 qreal columnWidth = 1.0 / m_data.m_seriesCount;
-                qreal left = 0.25 * columnWidth + columnWidth * m_data.m_seriesIndex;
+                qreal left = 0.25 * columnWidth + columnWidth * m_data.m_seriesIndex + m_data.m_index - 0.5;
-                qreal right = 0.75 * columnWidth + columnWidth * m_data.m_seriesIndex;
+                qreal barWidth = columnWidth / 2.0;
-                qreal middle = 0.5 * columnWidth + columnWidth * m_data.m_seriesIndex;
-                qreal domainMaxY = m_domain->maxY();
+                QPointF geometryPoint = m_domain->calculateGeometryPoint(QPointF(left, m_data.m_upperExtreme), m_validData);
+                if (!m_validData)
+                    return;
+                qreal geometryLeft = geometryPoint.x();
+                qreal geometryUpperExtreme = geometryPoint.y();
+                geometryPoint = m_domain->calculateGeometryPoint(QPointF(left + barWidth, m_data.m_upperQuartile), m_validData);
+                if (!m_validData)
+                    return;
+                qreal geometryRight = geometryPoint.x();
+                qreal geometryUpperQuartile = geometryPoint.y();
+                geometryPoint = m_domain->calculateGeometryPoint(QPointF(left, m_data.m_lowerQuartile), m_validData);
+                if (!m_validData)
+                    return;
+                qreal geometryLowerQuartile = geometryPoint.y();
+                geometryPoint = m_domain->calculateGeometryPoint(QPointF(left, m_data.m_lowerExtreme), m_validData);
+                if (!m_validData)
+                    return;
+                qreal geometryLowerExtreme = geometryPoint.y();
+                geometryPoint = m_domain->calculateGeometryPoint(QPointF(left, m_data.m_median), m_validData);
+                if (!m_validData)
+                    return;
+                qreal geometryMedian = geometryPoint.y();
                 // Upper whisker
-                path.moveTo(left + m_data.m_index, domainMaxY - m_data.m_upperExtreme);
+                path.moveTo(geometryLeft, geometryUpperExtreme);
-                path.lineTo(right + m_data.m_index, domainMaxY - m_data.m_upperExtreme);
+                path.lineTo(geometryRight, geometryUpperExtreme);
-                path.moveTo(middle + m_data.m_index, domainMaxY - m_data.m_upperExtreme);
+                path.moveTo((geometryLeft + geometryRight) / 2.0, geometryUpperExtreme);
-                path.lineTo(middle + m_data.m_index, domainMaxY - m_data.m_upperQuartile);
+                path.lineTo((geometryLeft + geometryRight) / 2.0, geometryUpperQuartile);
                 // Middle Box
-                path.addRect(left + m_data.m_index, domainMaxY - m_data.m_upperQuartile,
+                path.addRect(geometryLeft, geometryUpperQuartile, geometryRight - geometryLeft, geometryLowerQuartile - geometryUpperQuartile);
-.5 * columnWidth, m_data.m_upperQuartile - m_data.m_lowerQuartile);
-                // Median/mean line
+                // Median line
-                path.moveTo(left + m_data.m_index, domainMaxY - m_data.m_median);
+                path.moveTo(geometryLeft, geometryMedian);
-                path.lineTo(right + m_data.m_index, domainMaxY - m_data.m_median);
+                path.lineTo(geometryRight, geometryMedian);
                 // Lower whisker
-                path.moveTo(left + m_data.m_index, domainMaxY - m_data.m_lowerExtreme);
+                path.moveTo(geometryLeft, geometryLowerExtreme);
-                path.lineTo(right + m_data.m_index, domainMaxY - m_data.m_lowerExtreme);
+                path.lineTo(geometryRight, geometryLowerExtreme);
-                path.moveTo(middle + m_data.m_index, domainMaxY - m_data.m_lowerExtreme);
+                path.moveTo((geometryLeft + geometryRight) / 2.0, geometryLowerQuartile);
-                path.lineTo(middle + m_data.m_index, domainMaxY - m_data.m_lowerQuartile);
+                path.lineTo((geometryLeft + geometryRight) / 2.0, geometryLowerExtreme);
                 path.closeSubpath();
                 m_boxPath = path;
+                m_boundingRect = m_boxPath.boundingRect();
-                updateBoundingRect();
-            void BoxWhiskers::updateBoundingRect()
-                qreal scaleY = m_domainSize.height() / (m_domain->maxY() - m_domain->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 +1 -5

             /****************************************************************************
             **
             ** 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$
             **
             ****************************************************************************/
             //  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 "abstractdomain_p.h"
             #include <QBoxSet>
             #include <QGraphicsRectItem>
             #include <QGraphicsLineItem>
             #include <QGraphicsLayoutItem>
             #include <QPainterPath>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QBarSet;
             class BoxWhiskers : public QGraphicsObject
             {
                 Q_OBJECT
             public:
                 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);
-                void updateGeometry();
+                void updateGeometry(AbstractDomain *domain);
             protected:
                 QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint) const;
                 void setGeometry(const QRectF &rect);
-            private:
-                void updateBoundingRect();
             Q_SIGNALS:
                 void clicked(QBoxSet *boxset);
                 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 +2 -2

             /****************************************************************************
             **
             ** Copyright (C) 2013 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "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"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QBoxPlotSeries
                 \brief Series for creating box-and-whiskers chart
                 \mainclass
                 QBoxPlotSeries represents a series of data shown as box-and-whisker bars. The purpose of this class is to act as
                 a container for single box-and-whisker items. Each item is drawn to own slot. If chart includes multiple instances of
                 QBoxPlotSeries then box-and-whiskers items with the same index are drawn to same slot.
                 See the \l {Box and Whiskers Example} {box-and-whiskers chart example} to learn how to create a box-and-whiskers chart.
                 \image examples_boxplotchart.png
                 \sa QBoxSet
             */
             /*!
                 \qmlclass BoxPlotSeries QBoxPlotSeries
                 \inherits QAbstractSeries
                 BoxPlotSeries represents a series of data shown as box-and-whisker bars. The purpose of this class is to act as
                 a container for single box-and-whisker items. Each item is drawn to own slot. If chart includes multiple instances of
                 BoxPlotSeries then box-and-whiskers items with the same index are drawn to same slot.
                 The following QML shows how to create a simple box-and-whiskers chart:
                 \code
                 import QtQuick 1.0
                 import QtCommercial.Chart 1.1
                 ChartView {
                     title: "Box Plot series"
                     width: 400
                     height: 300
                     theme: ChartView.ChartThemeBrownSand
                     legend.alignment: Qt.AlignBottom
                     BoxPlotSeries {
                         id: plotSeries
                         name: "Income"
                         BoxSet { label: "Jan"; values: [3, 4, 5.1, 6.2, 8.5] }
                         BoxSet { label: "Feb"; values: [5, 6, 7.5, 8.6, 11.8] }
                         BoxSet { label: "Mar"; values: [3.2, 5, 5.7, 8, 9.2] }
                         BoxSet { label: "Apr"; values: [3.8, 5, 6.4, 7, 8] }
                         BoxSet { label: "May"; values: [4, 5, 5.2, 6, 7] }
                     }
                 }
                 \endcode
                 \beginfloatleft
                 \image examples_qmlboxplot.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.
             */
             /*!
                 \fn virtual SeriesType QBoxPlotSeries::type() const
                 \brief Returns type of series.
                 \sa QAbstractSeries, SeriesType
             */
             /*!
                 \qmlmethod BoxPlotSeries::append(const QString label, QVariantList values)
                 Appends a new box-and-whiskers set with \a label and \a values to the series.
              */
             /*!
                 \qmlmethod BoxPlotSeries::append(BoxSet *box)
                 Appends the \a box to the series.
             */
             /*!
                 \qmlmethod BoxPlotSeries::insert(int index, const QString label, QVariantList values)
                 Inserts a new box-and-whiskers set with \a label and \a values at the \a index position.
             */
             /*!
                 \qmlmethod BoxPlotSeries::remove(QBoxSet *boxset)
                 Removes the \a boxset from the series.
             */
             /*!
                 \qmlmethod BoxPlotSeries::clear()
                 Removes all boxsets from the series. Deletes removed sets.
             */
             /*!
                 \qmlsignal BoxPlotSeries::onClicked(BoxSet boxset);
                 Signal is emitted when the user clicks the \a boxset on the chart.
             */
             /*!
                 \qmlsignal BoxPlotSeries::onHovered(bool status, BoxSet boxset);
                 Signal is emitted when there is change in hover \a status over \a boxset.
             */
             /*!
                 \qmlsignal BoxPlotSeries::onCountChanged();
                 Signal is emitted when there is change in count of box-and-whiskers items in the series.
             */
             /*!
                 \qmlsignal BoxPlotSeries::onBoxsetsAdded()
                 Signal is emitted when new box-and-whiskers sets are added to the series.
              */
             /*!
                 \qmlsignal BoxPlotSeries::boxsetsRemoved()
                 Signal is emitted when new box-and-whiskers sets are removed from 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()
             {
                 Q_D(QBoxPlotSeries);
                 if (d->m_chart)
                     d->m_chart->removeSeries(this);
             }
             /*!
                 Adds a single box and whiskers set to series. Takes ownership of the \a set. If the set is null or is already in series, it won't be appended.
                 Returns true, if appending succeeded.
             */
             bool QBoxPlotSeries::append(QBoxSet *set)
             {
                 Q_D(QBoxPlotSeries);
                 bool success = d->append(set);
                 if (success) {
                     QList<QBoxSet *> sets;
                     sets.append(set);
                     set->setParent(this);
                     emit boxsetsAdded(sets);
                     emit countChanged();
                 }
                 return success;
             }
             /*!
                 Removes boxset from the series. Deletes the \a set and returns true if successful.
             */
             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 box-and-whiskers set to the series at \a index postion. Takes ownership of the \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 QAbstractSeries::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(QChartPrivate::defaultPen()),
                   m_brush(QChartPrivate::defaultBrush())
             {
             }
             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);
+                minX = qMin(minX, qreal(-0.5));
                 minY = qMin(minY, min());
-                maxX = qMax(maxX, x - (qreal)0.5);
+                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));
                     }
                 }
             }
             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);
                 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 series 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);
                 const QList<QGradient> gradients = theme->seriesGradients();
                 if (forced || QChartPrivate::defaultBrush() == m_brush) {
                     QColor brushColor = ChartThemeManager::colorAt(gradients.at(index % gradients.size()), 0.5);
                     q->setBrush(brushColor);
                 }
                 if (forced || QChartPrivate::defaultPen() == m_pen) {
                     QPen pen = theme->outlinePen();
                     pen.setCosmetic(true);
                     q->setPen(pen);
                 }
             }
             void QBoxPlotSeriesPrivate::initializeAnimations(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)
             {
                 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 series 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::min()
             {
                 if (m_boxSets.count() <= 0)
                     return 0;
                 qreal min = m_boxSets.at(0)->at(0);
                 foreach (QBoxSet *set, m_boxSets) {
                     for (int i = 0; i < 5; i++) {
                         if (set->at(i) < min)
                             min = set->at(i);
                     }
                 }
                 return min;
             }
             qreal QBoxPlotSeriesPrivate::max()
             {
                 if (m_boxSets.count() <= 0)
                     return 0;
                 qreal max = m_boxSets.at(0)->at(0);
                 foreach (QBoxSet *set, m_boxSets) {
                     for (int i = 0; i < 5; i++) {
                         if (set->at(i) > max)
                             max = set->at(i);
                     }
                 }
                 return max;
             }
             #include "moc_qboxplotseries.cpp"
             #include "moc_qboxplotseries_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

tests/boxplottester/mainwidget.cpp +15 -12

             /****************************************************************************
             **
             ** 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>
+            #include <QLogValueAxis>
             QTCOMMERCIALCHART_USE_NAMESPACE
             QString addCategories[] = {"Jul", "Aug", "Sep", "Nov", "Dec"};
+            static const int maxAddCategories = 5;
             MainWidget::MainWidget(QWidget *parent) :
                 QWidget(parent),
                 m_chart(0),
+                m_axis(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 clear button
                 QPushButton *clearBoxButton = new QPushButton("ClearBox");
                 connect(clearBoxButton, SIGNAL(clicked()), this, SLOT(clearBox()));
                 grid->addWidget(clearBoxButton, 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 << 1 << 2 << 4.4 << 13 << 15;
+                *set0 << -1 << 2 << 4 << 13 << 15;
                 *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) {
+                if (!m_axis) {
                     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]);
                 }
+                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) {
+                if (nSeries > 0 && nNewBoxes < maxAddCategories) {
                     QBoxSet *newSet = new QBoxSet();
                     newSet->setValue(QBoxSet::LowerExtreme, 5.0);
                     newSet->setValue(QBoxSet::LowerQuartile, 6.0);
                     newSet->setValue(QBoxSet::Median, 6.8);
                     newSet->setValue(QBoxSet::UpperQuartile, 7.0);
                     newSet->setValue(QBoxSet::UpperExtreme, 8.0);
-                    for (int i = 0; i < nSeries; i++)
+                    m_series[0]->append(newSet);
-                        m_series[i]->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;
                     for (int i = 0; i < nSeries; i++)
                         m_series[i]->insert(1, newSet);
                     m_axis->append(addCategories[nNewBoxes]);
                     nNewBoxes++;
                 }
             }
             void MainWidget::removeBox()
             {
                 qDebug() << "BoxPlotTester::MainWidget::removeBox";
                 if (nSeries > 0) {
                     for (int i = 0; i < nSeries; i++) {
-                        QList<QBoxSet *> sets = m_series[i]->boxSets();
+                        qDebug() << "m_series[i]->count() = " << m_series[i]->count();
-                        m_series[i]->remove(sets.at(m_series[i]->count() - 3));
+                        if (m_series[i]->count() > 3) {
+                            QList<QBoxSet *> sets = m_series[i]->boxSets();
+                            m_series[i]->remove(sets.at(m_series[i]->count() - 3));
+                        }
                     }
-                    m_axis->remove(m_axis->at(1));
+                    if (m_axis->count() > 3)
+                        m_axis->remove(m_axis->at(1));
                 } 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::clearBox()
             {
                 qDebug() << "BoxPlotTester::MainWidget::clearBox";
                 if (nSeries > 0) {
                     QList<QBoxSet *> sets = m_series[0]->boxSets();
                     sets.at(1)->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->at(QBoxSet::Median);
             }
             void MainWidget::boxHovered(bool state, QBoxSet *set)
             {
                 if (state)
                     qDebug() << "box median " << set->at(QBoxSet::Median) << " hover started";
                 else
                     qDebug() << "box median " << set->at(QBoxSet::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";
             }

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