HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r2484:f6ca68eccfda

Improved handling of different serieses....

Mika Salmela -

r2484:f6ca68eccfda

parent child

Context file:

r2484:f6ca68eccfda

Collapse all files

examples/boxplotchart/main.cpp +36 -6

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include <QApplication>
             #include <QMainWindow>
             #include <QChartView>
             #include <QBoxPlotSeries>
             #include <QBarSet>
             #include <QLegend>
             #include <QBarCategoryAxis>
+            #include <QLineSeries>
             #include <QBrush>
             #include <QColor>
             QTCOMMERCIALCHART_USE_NAMESPACE
             int main(int argc, char *argv[])
             {
                 QApplication a(argc, argv);
             //![1]
                 QBarSet *set0 = new QBarSet("Jan");
                 QBarSet *set1 = new QBarSet("Feb");
                 QBarSet *set2 = new QBarSet("Mar");
                 QBarSet *set3 = new QBarSet("Apr");
                 QBarSet *set4 = new QBarSet("May");
                 QBarSet *set5 = new QBarSet("Jun");
+                QBarSet *set6 = new QBarSet("Jul");
+                QBarSet *set7 = new QBarSet("Aug");
+                QBarSet *set8 = new QBarSet("Sep");
+                QBarSet *set9 = new QBarSet("Oct");
+                QBarSet *set10 = new QBarSet("Nov");
+                QBarSet *set11 = new QBarSet("Dec");
                 //      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;
+                *set6 << 2.5 << 5 << 5.4 << 6 << 7;
+                *set7 << 5 << 6.3 << 7.5 << 8 << 12;
+                *set8 << 2.6 << 5.1 << 5.7 << 8 << 9;
+                *set9 << 3.1 << 5.8 << 6.8 << 7 << 8;
+                *set10 << 4.2 << 5 << 5.8 << 6 << 7;
+                *set11 << 4.7 << 7 << 8.2 << 9 << 10;
-                set0->setBrush(QBrush(QColor(Qt::yellow)));
-                //set0->setColor(QColor(Qt::darkRed));
             //![1]
             //![2]
                 QBoxPlotSeries *series = new QBoxPlotSeries();
                 series->append(set0);
                 series->append(set1);
                 series->append(set2);
                 series->append(set3);
                 series->append(set4);
                 series->append(set5);
-                series->type();
+                series->append(set6);
+                series->append(set7);
+                series->append(set8);
+                series->append(set9);
+                series->append(set10);
+                series->append(set11);
                 series->setName("Box & Whiskers");
-                //series->setBrush(QBrush(QColor(Qt::yellow)));
             //![2]
+                QLineSeries *lineSeries = new QLineSeries();
+                lineSeries->append(0, 4.4);
+                lineSeries->append(1, 7.5);
+                lineSeries->append(2, 5.7);
+                lineSeries->append(3, 6.8);
+                lineSeries->append(4, 5.2);
+                lineSeries->append(5, 8.2);
+                lineSeries->append(6, 5.4);
+                lineSeries->append(7, 7.5);
+                lineSeries->append(8, 5.7);
+                lineSeries->append(9, 6.8);
+                lineSeries->append(10, 5.2);
+                lineSeries->append(11, 8.2);
+                lineSeries->setName("Medians");
             //![3]
                 QChart *chart = new QChart();
                 chart->addSeries(series);
+                chart->addSeries(lineSeries);
                 chart->setTitle("Simple boxplotchart example");
                 chart->setAnimationOptions(QChart::SeriesAnimations);
             //![3]
             //![4]
                 QStringList categories;
-                categories << "Jan" << "Feb" << "Mar" << "Apr" << "May" << "Jun";
+                categories << "Jan" << "Feb" << "Mar" << "Apr" << "May" << "Jun" << "Jul" << "Aug" << "Sep" << "Oct" << "Nov" << "Dec";
                 QBarCategoryAxis *axis = new QBarCategoryAxis();
                 axis->append(categories);
                 chart->createDefaultAxes();
                 chart->setAxisX(axis, series);
             //![4]
             //![5]
                 chart->legend()->setVisible(true);
                 chart->legend()->setAlignment(Qt::AlignBottom);
             //![5]
             //![6]
                 QChartView *chartView = new QChartView(chart);
                 chartView->setRenderHint(QPainter::Antialiasing);
             //![6]
             //![7]
                 QMainWindow window;
                 window.setCentralWidget(chartView);
                 window.resize(400, 300);
                 window.show();
             //![7]
                 return a.exec();
             }

src/boxplotchart/boxplotchartitem.cpp +9 0

             /****************************************************************************
             **
             ** 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 "qbarset_p.h"
             #include "qabstractbarseries_p.h"
             #include "qbarset.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(barsetsRemoved(QList<QBarSet*>)), this, SLOT(handleBarsetRemove(QList<QBarSet*>)));
                 connect(series->d_func(), SIGNAL(restructuredBars()), this, SLOT(handleDataStructureChanged()));
                 connect(series->d_func(), SIGNAL(updatedLayout()), this, SLOT(handleLayoutChanged()));
                 connect(series->d_func(), SIGNAL(updatedBars()), this, SLOT(handleUpdatedBars()));
                 connect(series->d_func(), SIGNAL(updated()), this, SLOT(handleUpdatedBars()));
                 // QBoxPlotSeriesPrivate calls handleDataStructureChanged(), don't do it here
                 setZValue(ChartPresenter::BoxPlotSeriesZValue);
                 m_barSets = m_series->barSets();
             }
             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++) {
                     QBarSet *set = m_series->d_func()->barsetAt(s);
                     BoxWhiskers *boxWhiskersItem = m_boxTable.value(set);
                     if (boxWhiskersItem == 0) {
                         // Item is not yet created, make a box and add it to hash table
                         boxWhiskersItem = new BoxWhiskers(domain(), this);
                         m_boxTable.insert(set, boxWhiskersItem);
                         boxWhiskersItem->setBrush(m_series->brush());
                         boxWhiskersItem->setPen(m_series->pen());
                     }
                     updateBoxGeometry(boxWhiskersItem, s);
                     boxWhiskersItem->updateGeometry();
                     if (m_animation)
                         m_animation->addBox(boxWhiskersItem);
                 }
                 //
                 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 QBarSet specific settings
+                foreach (QBarSet *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::handleBarsetRemove(QList<QBarSet*> barSets)
             {
                 //qDebug() << "BoxPlotChartItem::handleBarsetRemove";
                 foreach (QBarSet *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;
                 QBarSet *set = m_series->d_func()->barsetAt(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 +2 0

             /****************************************************************************
              **
              ** 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>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             BoxWhiskers::BoxWhiskers(AbstractDomain *domain, QGraphicsObject *parent) :
                 QGraphicsObject(parent),
                 m_domain(domain)
             {
                 //qDebug() << "BoxWhiskers::BoxWhiskers()";
             }
             BoxWhiskers::~BoxWhiskers()
             {
                 //qDebug() << "BoxWhiskers::~BoxWhiskers()";
             }
             void BoxWhiskers::mousePressEvent(QGraphicsSceneMouseEvent *event)
             {
                 Q_UNUSED(event)
                 qDebug() << "BoxWhiskers::mousePressEvent";
             }
             void BoxWhiskers::hoverEnterEvent(QGraphicsSceneHoverEvent *event)
             {
                 Q_UNUSED(event)
                 qDebug() << "BoxWhiskers::hoverEnterEvent";
             }
             void BoxWhiskers::hoverLeaveEvent(QGraphicsSceneHoverEvent *event)
             {
                 Q_UNUSED(event)
                 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;
             //    if (m_data.m_index == 1)
             //        qDebug() << "BoxWhiskers::setLayout";
                 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/qboxplotseries.cpp +14 -16

             /****************************************************************************
             **
             ** 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 "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 <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QBoxPlotSeries
                 \brief Series for creating stacked bar chart
                 \mainclass
                 QBoxPlotSeries represents a series of data shown as bars. The purpose of this class is to draw bars
                 as stacks, where bars in same category are stacked on top of each other.
                 QBoxPlotSeries groups the data from sets to categories, which are defined by QStringList.
                 See the \l {BoxPlotChart Example} {stacked bar chart example} to learn how to create a stacked bar chart.
                 \image examples_boxplotchart.png
                 \sa QBarSet, QPercentBarSeries, QAbstractBarSeries
             */
             /*!
                 \qmlclass BoxPlotSeries QBoxPlotSeries
                 \inherits AbstractBarSeries
                 The following QML shows how to create a simple stacked bar chart:
                 \snippet ../demos/qmlchart/qml/qmlchart/View7.qml 1
                 \beginfloatleft
                 \image demos_qmlchart7.png
                 \endfloat
                 \clearfloat
             */
             /*!
                 Constructs empty QBoxPlotSeries.
                 QBoxPlotSeries is QObject which is a child of a \a parent.
             */
             QBoxPlotSeries::QBoxPlotSeries(QObject *parent)
                 : QAbstractBarSeries(*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);
             }
             /*!
                 Returns QChartSeries::SeriesTypeBoxPlot.
             */
             QAbstractSeries::SeriesType QBoxPlotSeries::type() const
             {
                 return QAbstractSeries::SeriesTypeBoxPlot;
             }
             void QBoxPlotSeries::setBrush(const QBrush &brush)
             {
                 Q_D(QBoxPlotSeries);
                 if (d->m_brush != brush) {
                     d->m_brush = brush;
                     emit d->updated();
                 }
             }
             QBrush QBoxPlotSeries::brush() const
             {
                 Q_D(const QBoxPlotSeries);
                 return d->m_brush;
             }
             void QBoxPlotSeries::setPen(const QPen &pen)
             {
                 Q_D(QBoxPlotSeries);
                 if (d->m_pen != pen) {
                     d->m_pen = pen;
                     emit d->updated();
                 }
             }
             QPen QBoxPlotSeries::pen() const
             {
                 Q_D(const QBoxPlotSeries);
                 return d->m_pen;
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QBoxPlotSeriesPrivate::QBoxPlotSeriesPrivate(QBoxPlotSeries *q)
                 : QAbstractBarSeriesPrivate(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 = categoryCount();
                 minX = qMin(minX, - (qreal)0.5);
                 minY = qMin(minY, bottom());
                 maxX = qMax(maxX, x - (qreal)0.5);
                 //maxY = qMax(maxY, top());
                 maxY = qMax(maxY, max());
                 domain()->setRange(minX, maxX, minY, maxY);
             }
             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();
-                    boxPlot->m_seriesCount = serieses.count();
                     // Tries to find this series from the Chart's list of serieses and deduce the index
                     int index = 0;
                     foreach (QAbstractSeries *s, serieses) {
-                        if (q == static_cast<QBoxPlotSeries *>(s)) {
+                        if (s->type() == QAbstractSeries::SeriesTypeBoxPlot) {
-                            boxPlot->m_seriesIndex = index;
+                            if (q == static_cast<QBoxPlotSeries *>(s)) {
-                            m_index = index;
+                                boxPlot->m_seriesIndex = index;
+                                m_index = 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);
-            //        QPen pen;
-            //        pen.setColor(ChartThemeManager::colorAt(gradients.at(index % gradients.size()), 1.0));
-            //        pen.setWidthF(2.0);
-            //        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();
-                    boxPlot->m_seriesCount = serieses.count();
                     // Tries to find this series from the Chart's list of serieses and deduce the index
                     int index = 0;
                     foreach (QAbstractSeries *s, serieses) {
-                        if (q == static_cast<QBoxPlotSeries *>(s)) {
+                        if (s->type() == QAbstractSeries::SeriesTypeBoxPlot) {
-                            boxPlot->m_seriesIndex = index;
+                            if (q == static_cast<QBoxPlotSeries *>(s)) {
-                            m_index = index;
+                                boxPlot->m_seriesIndex = index;
+                                m_index = index;
+                            }
+                            index++;
                         }
-                        index++;
                     }
+                    boxPlot->m_seriesCount = index;
                 }
                 boxPlot->handleDataStructureChanged();
             }
             #include "moc_qboxplotseries.cpp"
             #include "moc_qboxplotseries_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

tests/boxplottester/mainwidget.cpp +57 -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 "mainwidget.h"
             #include "customtablemodel.h"
             #include <QVBarModelMapper>
             #include <QTableView>
             #include <QHeaderView>
             #include <QChartView>
             #include <QBoxPlotSeries>
             #include <QBarSet>
             #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]
                 QBarSet *set0 = new QBarSet("Jan");
                 QBarSet *set1 = new QBarSet("Feb");
                 QBarSet *set2 = new QBarSet("Mar");
                 QBarSet *set3 = new QBarSet("Apr");
                 QBarSet *set4 = new QBarSet("May");
                 QBarSet *set5 = new QBarSet("Jun");
                 //      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]->type();
                 m_series[nSeries]->setName("Box & Whiskers");
                 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) {
                     QBarSet *newSet = new QBarSet("New");
                     *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) {
+                    QBarSet *newSet = new QBarSet("New");
+                    *newSet << 2 << 6 << 6.8 << 7 << 10;
+                    m_series[0]->insert(1, newSet);
+                    m_axis->append(addCategories[nNewBoxes]);
+                    nNewBoxes++;
+                }
+            }
             void MainWidget::removeBox()
             {
-                qDebug() << "MainWidget::removeBox";
+                qDebug() << "BoxPlotTester::MainWidget::removeBox";
                 if (nSeries > 0) {
                     QList<QBarSet *> sets = m_series[0]->barSets();
                     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<QBarSet *> sets = m_series[0]->barSets();
+                    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;
                     QVBarModelMapper *mapper = new QVBarModelMapper(this);
                     mapper->setFirstBarSetColumn(0);
                     mapper->setLastBarSetColumn(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));
             }

tests/boxplottester/mainwidget.h +3 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>
             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);
             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