HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r1693:8b01a00ae1fe

Added insert, remove and other common methodds to QDonutGroup. Donut example added

Marek Rosa -

r1693:8b01a00ae1fe

parent child

Context file:

r1693:8b01a00ae1fe

Collapse all files

examples/donut/donut.pro created 644 +8 0

@@ -0,0 +1,8
	1	!include( ../examples.pri ) {
	2	error( "Couldn't find the examples.pri file!" )
	3	}
	4
	5	TARGET = donut
	6	SOURCES += main.cpp\
	7	widget.cpp
	8	HEADERS += widget.h

examples/donut/main.cpp created 644 +11 0

@@ -0,0 +1,11
	1	#include <QApplication>
	2	#include "widget.h"
	3
	4	int main(int argc, char *argv[])
	5	{
	6	QApplication a(argc, argv);
	7	Widget w;
	8	w.show();
	9
	10	return a.exec();
	11	}

examples/donut/widget.cpp created 644 +65 0

@@ -0,0 +1,65
	1	#include "widget.h"
	2	#include <QChartView>
	3	#include <QPieSeries>
	4	#include <QPieSlice>
	5	#include <QTime>
	6	#include <QGridLayout>
	7	#include <QTimer>
	8
	9	QTCOMMERCIALCHART_USE_NAMESPACE
	10
	11	Widget::Widget(QWidget *parent)
	12	: QWidget(parent)
	13	{
	14	setMinimumSize(800, 600);
	15	qsrand(QTime(0,0,0).secsTo(QTime::currentTime()));
	16
	17	QChartView *chartView = new QChartView;
	18	chartView->setRenderHint(QPainter::Antialiasing);
	19
	20	for (int i = 0; i < 7; i++) {
	21	QPieSeries *donut = new QPieSeries;
	22	donut->setLabelsVisible();
	23	for (int j = 0; j < 4; j++) {
	24	qreal value = 100 + qrand() % 100;
	25	donut->append(QString("%1").arg(value), value);
	26	donut->slices().last()->setLabelVisible(true);
	27	// QFont labelFont = donut->slices().last()->labelFont();
	28	// // labelFont.setUnderline(true);
	29	// labelFont.setBold(true);
	30	// donut->slices().last()->setLabelFont(labelFont);
	31	donut->slices().last()->setLabelColor(Qt::white);
	32	}
	33	qreal phase = qrand() % 180;
	34	donut->setPieStartAngle(phase);
	35	donut->setPieEndAngle(360 + phase);
	36	chartView->chart()->addSeries(donut);
	37	m_donutsGroup.append(donut);
	38	}
	39
	40	// create main layout
	41	QGridLayout* mainLayout = new QGridLayout;
	42	mainLayout->addWidget(chartView, 1, 1);
	43	setLayout(mainLayout);
	44
	45	chartView->chart()->setAnimationOptions(QChart::AllAnimations);
	46
	47	QTimer *updateTimer = new QTimer(this);
	48	connect(updateTimer, SIGNAL(timeout()), this, SLOT(updateRotation()));
	49	updateTimer->start(750);
	50	}
	51
	52	Widget::~Widget()
	53	{
	54
	55	}
	56
	57	void Widget::updateRotation()
	58	{
	59	for (int i = 0; i < m_donutsGroup.count(); i++) {
	60	QPieSeries *donut = m_donutsGroup.donuts().at(i);
	61	qreal phaseShift = -50 + qrand() % 100;
	62	donut->setPieStartAngle(donut->pieStartAngle() + phaseShift);
	63	donut->setPieEndAngle(donut->pieEndAngle() + phaseShift);
	64	}
	65	}

examples/donut/widget.h created 644 +24 0

@@ -0,0 +1,24
	1	#ifndef WIDGET_H
	2	#define WIDGET_H
	3
	4	#include <QWidget>
	5	#include <QDonutGroup>
	6
	7	QTCOMMERCIALCHART_USE_NAMESPACE
	8
	9	class Widget : public QWidget
	10	{
	11	Q_OBJECT
	12
	13	public:
	14	Widget(QWidget *parent = 0);
	15	~Widget();
	16
	17	public slots:
	18	void updateRotation();
	19
	20	private:
	21	QDonutGroup m_donutsGroup;
	22	};
	23
	24	#endif // WIDGET_H

examples/examples.pro +2 -1

             CURRENTLY_BUILDING_COMPONENTS = "examples"
             !include( ../config.pri ) {
                 error( "Couldn't find the config.pri file!" )
             }
             TEMPLATE = subdirs
             SUBDIRS += \
                        areachart \
                        customchart \
                        linechart \
                        percentbarchart \
                        piechart \
                        piechartdrilldown \
                        presenterchart \
                        scatterchart \
                        scatterinteractions \
                        splinechart \
                        stackedbarchart \
                        stackedbarchartdrilldown \
                        zoomlinechart \
                        modeldata \
                        barchart \
                        legend \
                        barmodelmapper \
                        qmlpiechart \
                        lineandbar \
                        horizontalbarchart \
                        horizontalstackedbarchart \
-                       horizontalpercentbarchart
+                       horizontalpercentbarchart \
+                       donut

src/piechart/piesliceitem.cpp +12 -4

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "piesliceitem_p.h"
             #include "piechartitem_p.h"
             #include "qpieseries.h"
             #include "qpieslice.h"
             #include "chartpresenter_p.h"
             #include <QPainter>
             #include <qmath.h>
             #include <QGraphicsSceneEvent>
             #include <QTime>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             QPointF offset(qreal angle, qreal length)
             {
                 qreal dx = qSin(angle*(M_PI/180)) * length;
                 qreal dy = qCos(angle*(M_PI/180)) * length;
                 return QPointF(dx, -dy);
             }
             PieSliceItem::PieSliceItem(QGraphicsItem* parent)
                 :QGraphicsObject(parent),
                   m_hovered(false)
             {
                 setAcceptHoverEvents(true);
                 setAcceptedMouseButtons(Qt::MouseButtonMask);
                 setZValue(ChartPresenter::PieSeriesZValue);
             }
             PieSliceItem::~PieSliceItem()
             {
                 // If user is hovering over the slice and it gets destroyed we do
                 // not get a hover leave event. So we must emit the signal here.
                 if (m_hovered)
                     emit hovered(false);
             }
             QRectF PieSliceItem::boundingRect() const
             {
                 return m_boundingRect;
             }
             QPainterPath PieSliceItem::shape() const
             {
                 // Don't include the label and label arm.
                 // This is used to detect a mouse clicks. We do not want clicks from label.
                 return m_slicePath;
             }
             void PieSliceItem::paint(QPainter* painter, const QStyleOptionGraphicsItem* /*option*/, QWidget* /*widget*/)
             {
                 painter->save();
                 painter->setClipRect(parentItem()->boundingRect());
                 painter->setPen(m_data.m_slicePen);
                 painter->setBrush(m_data.m_sliceBrush);
                 painter->drawPath(m_slicePath);
                 painter->restore();
                 if (m_data.m_isLabelVisible) {
                     painter->save();
                     // Pen for label arm not defined in the QPieSeries api, let's use brush's color instead
                     // Also, the drawText actually uses the pen color for the text color (unlike QGraphicsSimpleTextItem)
                     painter->setPen(m_data.m_labelBrush.color());
                     painter->setBrush(m_data.m_labelBrush);
                     painter->setFont(m_data.m_labelFont);
-                    if (m_data.m_labelPosition == QPieSlice::LabelOutside) {
+                    if (m_data.m_donut) {
+                        painter->translate(m_labelTextRect.center());
+                        painter->rotate(m_data.m_startAngle + m_data.m_angleSpan / 2);
+                        painter->drawText(-m_labelTextRect.width() / 2, -m_labelTextRect.height() / 2, m_labelTextRect.width(), m_labelTextRect.height(), Qt::AlignCenter, m_data.m_labelText);
+                    }else if (m_data.m_labelPosition == QPieSlice::LabelOutside) {
                         painter->setClipRect(parentItem()->boundingRect());
                         painter->strokePath(m_labelArmPath, m_data.m_labelBrush.color());
                     } else { // QPieSlice::LabelInside
                         painter->setClipPath(m_slicePath);
+                        painter->drawText(m_labelTextRect, Qt::AlignCenter, m_data.m_labelText);
                     }
-                    painter->drawText(m_labelTextRect, Qt::AlignCenter, m_data.m_labelText);
                     painter->restore();
                 }
             }
             void PieSliceItem::hoverEnterEvent(QGraphicsSceneHoverEvent* /*event*/)
             {
                 m_hovered = true;
                 emit hovered(true);
             }
             void PieSliceItem::hoverLeaveEvent(QGraphicsSceneHoverEvent* /*event*/)
             {
                 m_hovered = false;
                 emit hovered(false);
             }
             void PieSliceItem::mousePressEvent(QGraphicsSceneMouseEvent *event)
             {
                 emit clicked(event->buttons());
             }
             void PieSliceItem::setLayout(const PieSliceData &sliceData)
             {
                 m_data = sliceData;
                 updateGeometry();
                 update();
             }
             void PieSliceItem::updateGeometry()
             {
                 if (m_data.m_radius <= 0)
                     return;
                 prepareGeometryChange();
                 // slice path
                 qreal centerAngle;
                 QPointF armStart;
                 m_slicePath = slicePath(m_data.m_center, m_data.m_radius, m_data.m_startAngle, m_data.m_angleSpan, &centerAngle, &armStart);
                 // text rect
                 QFontMetricsF fm(m_data.m_labelFont);
                 m_labelTextRect = QRectF(0, 0, fm.width(m_data.m_labelText), fm.height());
                 // label arm path
                 QPointF labelTextStart;
                 m_labelArmPath = labelArmPath(armStart, centerAngle, m_data.m_radius * m_data.m_labelArmLengthFactor, m_labelTextRect.width(), &labelTextStart);
                 // text position
-                if (m_data.m_labelPosition == QPieSlice::LabelOutside)
+                if (m_data.m_donut) {
+                    QPointF donutCenter = m_data.m_center + offset(centerAngle, m_data.m_innerRadius + (m_data.m_radius - m_data.m_innerRadius) / 2);
+                    m_labelTextRect.moveCenter(donutCenter);
+                } else if (m_data.m_labelPosition == QPieSlice::LabelOutside) {
                     m_labelTextRect.moveBottomLeft(labelTextStart);
-                else {// QPieSlice::LabelInside
+                } else {// QPieSlice::LabelInside
                     QPointF sliceCenter = m_data.m_center + offset(centerAngle, m_data.m_radius / 2);
                     m_labelTextRect.moveCenter(sliceCenter);
                 }
                 //  bounding rect
                 if (m_data.m_isLabelVisible)
                     m_boundingRect = m_slicePath.boundingRect().united(m_labelArmPath.boundingRect()).united(m_labelTextRect);
                 else
                     m_boundingRect = m_slicePath.boundingRect();
             }
             QPointF PieSliceItem::sliceCenter(QPointF point, qreal radius, QPieSlice *slice)
             {
                 if (slice->isExploded()) {
                     qreal centerAngle = slice->startAngle() + (slice->angleSpan()/2);
                     qreal len = radius * slice->explodeDistanceFactor();
                     point += offset(centerAngle, len);
                 }
                 return point;
             }
             QPainterPath PieSliceItem::slicePath(QPointF center, qreal radius, qreal startAngle, qreal angleSpan, qreal *centerAngle, QPointF* armStart)
             {
                 // calculate center angle
                 *centerAngle = startAngle + (angleSpan/2);
                 // calculate slice rectangle
                 QRectF rect(center.x()-radius, center.y()-radius, radius*2, radius*2);
                 // slice path
                 QPainterPath path;
                 if (m_data.m_donut) {
                     QRectF insideRect(center.x() - m_data.m_innerRadius, center.y()-m_data.m_innerRadius, m_data.m_innerRadius*2, m_data.m_innerRadius*2);
                     path.arcMoveTo(rect, -startAngle + 90);
                     path.arcTo(rect, -startAngle + 90, -angleSpan);
                     path.arcTo(insideRect, -startAngle + 90 - angleSpan, angleSpan);
                     path.closeSubpath();
                 } else {
                     path.moveTo(rect.center());
                     path.arcTo(rect, -startAngle + 90, -angleSpan);
                     path.closeSubpath();
                 }
                 // calculate label arm start point
                 *armStart = center;
                 *armStart += offset(*centerAngle, radius + PIESLICE_LABEL_GAP);
                 return path;
             }
             QPainterPath PieSliceItem::labelArmPath(QPointF start, qreal angle, qreal length, qreal textWidth, QPointF *textStart)
             {
                 // Normalize the angle to 0-360 range
                 // NOTE: We are using int here on purpose. Depenging on platform and hardware
                 // qreal can be a double, float or something the user gives to the Qt configure
                 // (QT_COORD_TYPE). Compilers do not seem to support modulo for double or float
                 // but there are fmod() and fmodf() functions for that. So instead of some #ifdef
                 // that might break we just use int. Precision for this is just fine for our needs.
                 int normalized = angle * 10.0;
                 normalized = normalized % 3600;
                 if (normalized < 0)
                     normalized += 3600;
                 angle = (qreal) normalized / 10.0;
                 // prevent label arm pointing straight down because it will look bad
                 if (angle < 180 && angle > 170)
                     angle = 170;
                 if (angle > 180 && angle < 190)
                     angle = 190;
                 // line from slice to label
                 QPointF parm1 = start + offset(angle, length);
                 // line to underline the label
                 QPointF parm2 = parm1;
                 if (angle < 180) { // arm swings the other way on the left side
                     parm2 += QPointF(textWidth, 0);
                     *textStart = parm1;
                 }
                 else {
                     parm2 += QPointF(-textWidth,0);
                     *textStart = parm2;
                 }
                 QPainterPath path;
                 path.moveTo(start);
                 path.lineTo(parm1);
                 path.lineTo(parm2);
                 return path;
             }
             #include "moc_piesliceitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/qdonutgroup.cpp +38 -2

             #include "qdonutgroup.h"
             #include "qdonutgroup_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             QDonutGroup::QDonutGroup(QObject *parent) :
                 QObject(parent),
                 d_ptr(new QDonutGroupPrivate(this))
             {
             }
             void QDonutGroup::append(QPieSeries *donut)
             {
+                insert(count(), donut);
+            }
+            bool QDonutGroup::insert(int index, QPieSeries* donut)
+            {
                 if (donut == 0)
-                    return;
+                    return false;
                 donut->setDonut();
                 Q_D(QDonutGroup);
-                d->m_donuts.append(donut);
+                d->m_donuts.insert(index, donut);
                 qreal donutFraction = 1.0 / (d->m_donuts.count() + 1);
                 for(int i = 0; i < d->m_donuts.count(); i++) {
                     d->m_donuts[i]->setPieSize( (i + 2) * donutFraction);
                     d->m_donuts[i]->setDonutInnerSize( (i + 1)  * donutFraction);
                 }
+                return true;
+            }
+            bool QDonutGroup::remove(QPieSeries* donut)
+            {
+                Q_D(QDonutGroup);
+                int index = d->m_donuts.indexOf(donut);
+                if (index == -1)
+                    return false;
+                else
+                    d->m_donuts.removeOne(donut);
+                return true;
+            }
+            void QDonutGroup::clear()
+            {
+                Q_D(QDonutGroup);
+                d->m_donuts.clear();
+            }
+            QList<QPieSeries*> QDonutGroup::donuts() const
+            {
+                Q_D(const QDonutGroup);
+                return d->m_donuts;
+            }
+            int QDonutGroup::count() const
+            {
+                Q_D(const QDonutGroup);
+                return d->m_donuts.count();
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QDonutGroupPrivate::QDonutGroupPrivate(QDonutGroup *q):
                 QObject(q),
                 q_ptr(q)
             {
                 //
             }
             #include "moc_qdonutgroup.cpp"
             #include "moc_qdonutgroup_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/qdonutgroup.h +8 0

             #ifndef QDONUTGROUP_H
             #define QDONUTGROUP_H
             #include <QObject>
             #include <QPieSeries>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             //class QPieSeries;
             class QDonutGroupPrivate;
             class QTCOMMERCIALCHART_EXPORT QDonutGroup : public QObject
             {
                 Q_OBJECT
             public:
                 explicit QDonutGroup(QObject *parent = 0);
                 void append(QPieSeries *donut);
+                bool insert(int index, QPieSeries* donut);
+                bool remove(QPieSeries* donut);
+                void clear();
+                QList<QPieSeries*> donuts() const;
+                int count() const;
             protected:
                 QDonutGroupPrivate * const d_ptr;
                 Q_DECLARE_PRIVATE(QDonutGroup)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QDONUTGROUP_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