HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r1747:19ac79b0cec7

Fixes mouse handling in base class of chartseries

Michal Klocek -

r1747:19ac79b0cec7

parent child

Context file:

r1747:19ac79b0cec7

Collapse all files

src/areachart/areachartitem.cpp +1 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 "areachartitem_p.h"
             #include "qareaseries.h"
             #include "qareaseries_p.h"
             #include "qlineseries.h"
             #include "chartpresenter_p.h"
             #include "domain_p.h"
             #include <QPainter>
             #include <QGraphicsSceneMouseEvent>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             //TODO: optimize : remove points which are not visible
             AreaChartItem::AreaChartItem(QAreaSeries *areaSeries, ChartPresenter *presenter)
                 : ChartItem(presenter),
                 m_series(areaSeries),
                 m_upper(0),
                 m_lower(0),
                 m_pointsVisible(false)
             {
                 setZValue(ChartPresenter::LineChartZValue);
                 m_upper = new AreaBoundItem(this,m_series->upperSeries(),presenter);
                 if (m_series->lowerSeries()){
                     m_lower = new AreaBoundItem(this,m_series->lowerSeries(),presenter);
                 }
                 QObject::connect(m_series->d_func(),SIGNAL(updated()),this,SLOT(handleUpdated()));
                 QObject::connect(m_series, SIGNAL(visibleChanged()), this, SLOT(handleUpdated()));
                 QObject::connect(this,SIGNAL(clicked(QPointF)),areaSeries,SIGNAL(clicked(QPointF)));
                 handleUpdated();
             }
             AreaChartItem::~AreaChartItem()
             {
                 delete m_upper;
                 delete m_lower;
             }
             QRectF AreaChartItem::boundingRect() const
             {
                 return m_rect;
             }
             QPainterPath AreaChartItem::shape() const
             {
                 return m_path;
             }
             void AreaChartItem::updatePath()
             {
                 QPainterPath path;
                 path = m_upper->shape();
                 if (m_lower) {
                     path.connectPath(m_lower->shape().toReversed());
                 } else {
                     QPointF first = path.pointAtPercent(0);
                     QPointF last =  path.pointAtPercent(1);
                     path.lineTo(last.x(),m_clipRect.bottom());
                     path.lineTo(first.x(),m_clipRect.bottom());
                 }
                 path.closeSubpath();
                 prepareGeometryChange();
                 m_path = path;
                 m_rect = path.boundingRect();
                 update();
             }
             void AreaChartItem::handleUpdated()
             {
                 setVisible(m_series->isVisible());
                 m_pointsVisible = m_series->pointsVisible();
                 m_linePen = m_series->pen();
                 m_brush = m_series->brush();
                 m_pointPen = m_series->pen();
                 m_pointPen.setWidthF(2 * m_pointPen.width());
                 update();
             }
             void AreaChartItem::handleDomainUpdated()
             {
                 m_upper->setDomain(domain());
                 m_upper->handleDomainUpdated();
                 if (m_lower){
                     m_lower->setDomain(domain());
                     m_lower->handleDomainUpdated();
                 }
             }
             void AreaChartItem::handleGeometryChanged(const QRectF &rect)
             {
                 m_clipRect=rect.translated(-rect.topLeft());
                 setPos(rect.topLeft());
                 m_upper->handleGeometryChanged(rect);
                 if (m_lower)
                     m_lower->handleGeometryChanged(rect);
             }
             void AreaChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(widget)
                 Q_UNUSED(option)
                 painter->save();
                 painter->setPen(m_linePen);
                 painter->setBrush(m_brush);
                 painter->setClipRect(m_clipRect);
                 painter->drawPath(m_path);
                 if (m_pointsVisible) {
                        painter->setPen(m_pointPen);
                        painter->drawPoints(m_upper->geometryPoints());
                        if (m_lower)
                            painter->drawPoints(m_lower->geometryPoints());
                 }
                 painter->restore();
             }
             void AreaChartItem::mousePressEvent(QGraphicsSceneMouseEvent *event)
             {
                 emit clicked(m_upper->calculateDomainPoint(event->pos()));
+                ChartItem::mousePressEvent(event);
             }
             #include "moc_areachartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/bar.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 "bar_p.h"
             #include <QPainter>
             #include <QGraphicsSceneEvent>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             Bar::Bar(QBarSet *barset, int index, QGraphicsItem *parent) : QGraphicsRectItem(parent),
                 m_index(index),
                 m_barset(barset),
                 m_hovering(false)
             {
                 setAcceptedMouseButtons(Qt::LeftButton | Qt::RightButton);
                 setAcceptHoverEvents(true);
             }
             Bar::~Bar()
             {
                 // End hover event, if bar is deleted during it
                 if (m_hovering) {
                     emit hovered(false, m_barset);
                 }
             }
             void Bar::mousePressEvent(QGraphicsSceneMouseEvent *event)
             {
                 Q_UNUSED(event)
                 emit clicked(m_index, m_barset);
+                QGraphicsItem::mousePressEvent(event);
             }
             void Bar::hoverEnterEvent(QGraphicsSceneHoverEvent *event)
             {
                 Q_UNUSED(event)
                 m_hovering = true;
                 emit hovered(true, m_barset);
             }
             void Bar::hoverLeaveEvent(QGraphicsSceneHoverEvent *event)
             {
                 Q_UNUSED(event)
                 m_hovering = false;
                 emit hovered(false, m_barset);
             }
             #include "moc_bar_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/chartpresenter_p.h +4 -2

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             //  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 CHARTPRESENTER_H
             #define CHARTPRESENTER_H
             #include "qchartglobal.h"
             #include "qchart.h" //becouse of QChart::ChartThemeId //TODO
             #include <QRectF>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartElement;
             class QAbstractSeries;
             class ChartDataSet;
             class Domain;
             class ChartAxis;
             class ChartTheme;
             class ChartAnimator;
             class ChartBackground;
             class ChartAnimation;
             class ChartLayout;
             class ChartPresenter: public QObject
             {
                 Q_OBJECT
             public:
                 enum ZValues {
                     BackgroundZValue = -1,
-                    ShadesZValue,
+                    ShadesZValue ,
                     GridZValue,
                     SeriesZValue,
                     LineChartZValue = SeriesZValue,
+                    SplineChartZValue = SeriesZValue,
                     BarSeriesZValue = SeriesZValue,
                     ScatterSeriesZValue = SeriesZValue,
                     PieSeriesZValue = SeriesZValue,
                     AxisZValue,
-                    LegendZValue
+                    LegendZValue,
+                    TopMostZValue
                 };
                 enum State {
                     ShowState,
                     ScrollUpState,
                     ScrollDownState,
                     ScrollLeftState,
                     ScrollRightState,
                     ZoomInState,
                     ZoomOutState
                 };
                 ChartPresenter(QChart* chart,ChartDataSet *dataset);
                 virtual ~ChartPresenter();
                 ChartTheme *chartTheme() const { return m_chartTheme; }
                 ChartDataSet *dataSet() const { return m_dataset; }
                 QGraphicsItem* rootItem() const { return m_chart; }
                 QGraphicsRectItem* backgroundItem();
                 QGraphicsItem* titleItem();
                 QList<ChartAxis*> axisItems() const;
                 QLegend* legend();
                 void setBackgroundBrush(const QBrush& brush);
                 QBrush backgroundBrush() const;
                 void setBackgroundPen(const QPen& pen);
                 QPen backgroundPen() const;
                 void setTitle(const QString& title);
                 QString title() const;
                 void setTitleFont(const QFont& font);
                 QFont titleFont() const;
                 void setTitleBrush(const QBrush &brush);
                 QBrush titleBrush() const;
                 void setBackgroundVisible(bool visible);
                 bool isBackgroundVisible() const;
                 void setBackgroundDropShadowEnabled(bool enabled);
                 bool isBackgroundDropShadowEnabled() const;
                 void setVisible(bool visible);
                 void setTheme(QChart::ChartTheme theme,bool force = true);
                 QChart::ChartTheme theme();
                 void setAnimationOptions(QChart::AnimationOptions options);
                 QChart::AnimationOptions animationOptions() const;
                 void zoomIn(qreal factor);
                 void zoomIn(const QRectF& rect);
                 void zoomOut(qreal factor);
                 void scroll(qreal dx,qreal dy);
                 void setGeometry(const QRectF& rect);
                 QRectF geometry() { return m_rect; }
                 void startAnimation(ChartAnimation* animation);
                 State state() const { return m_state; }
                 QPointF statePoint() const { return m_statePoint; }
                 void resetAllElements();
                 void setMarginsMinimum(const QRectF& margins);
                 QRectF margins() const;
                 QGraphicsLayout* layout();
             private:
                 void createBackgroundItem();
                 void createTitleItem();
                 void selectVisibleAxis();
             public Q_SLOTS:
                 void handleSeriesAdded(QAbstractSeries* series,Domain* domain);
                 void handleSeriesRemoved(QAbstractSeries* series);
                 void handleAxisAdded(QAbstractAxis* axis,Domain* domain);
                 void handleAxisRemoved(QAbstractAxis* axis);
                 void handleAxisVisibleChanged(bool visible);
             private Q_SLOTS:
                 void handleAnimationFinished();
             Q_SIGNALS:
                 void geometryChanged(const QRectF& rect);
                 void animationsFinished();
                 void marginsChanged(QRectF margins);
             private:
                 QChart* m_chart;
                 ChartDataSet* m_dataset;
                 ChartTheme *m_chartTheme;
                 QMap<QAbstractSeries*, ChartElement*> m_chartItems;
                 QMap<QAbstractAxis*, ChartAxis*> m_axisItems;
                 QRectF m_rect;
                 QChart::AnimationOptions m_options;
                 State m_state;
                 QPointF m_statePoint;
                 QList<ChartAnimation*> m_animations;
                 ChartLayout* m_layout;
                 ChartBackground* m_backgroundItem;
                 QGraphicsSimpleTextItem* m_titleItem;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif /* CHARTPRESENTER_H_ */

src/linechart/linechartitem.cpp +1 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 "linechartitem_p.h"
             #include "qlineseries.h"
             #include "qlineseries_p.h"
             #include "chartpresenter_p.h"
             #include <QPainter>
             #include <QGraphicsSceneMouseEvent>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             //TODO: optimize : remove points which are not visible
             LineChartItem::LineChartItem(QLineSeries* series,ChartPresenter *presenter):
                 XYChart(series, presenter),
                 QGraphicsItem(presenter ? presenter->rootItem() : 0),
                 m_series(series),
                 m_pointsVisible(false)
             {
                 setZValue(ChartPresenter::LineChartZValue);
                 QObject::connect(series->d_func(),SIGNAL(updated()),this,SLOT(handleUpdated()));
                 QObject::connect(series, SIGNAL(visibleChanged()), this, SLOT(handleUpdated()));
                 handleUpdated();
             }
             QRectF LineChartItem::boundingRect() const
             {
             	return m_rect;
             }
             QPainterPath LineChartItem::shape() const
             {
                 return m_path;
             }
             void LineChartItem::updateGeometry()
             {
                 const QVector<QPointF>& points = geometryPoints();
                 if(points.size()==0)
                 {
                     prepareGeometryChange();
                     m_path = QPainterPath();
                     m_rect = QRect();
                     return;
                 }
                 QPainterPath linePath(points.at(0));
                 for(int i=1; i< points.size();i++) {
                     linePath.lineTo(points.at(i));
                 }
                 prepareGeometryChange();
                 m_path = linePath;
                 m_rect = linePath.boundingRect();
                 setPos(origin());
             }
             void LineChartItem::handleUpdated()
             {
                 setVisible(m_series->isVisible());
                 m_pointsVisible = m_series->pointsVisible();
                 m_linePen = m_series->pen();
                 m_pointPen = m_series->pen();
                 m_pointPen.setWidthF(2*m_pointPen.width());
                 update();
             }
             //painter
             void LineChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(widget)
                 Q_UNUSED(option)
                 painter->save();
                 painter->setPen(m_linePen);
                 painter->setClipRect(clipRect());
                 painter->drawPath(m_path);
                 if (m_pointsVisible){
                     painter->setPen(m_pointPen);
                     painter->drawPoints(geometryPoints());
                 }
                 painter->restore();
             }
             void LineChartItem::mousePressEvent(QGraphicsSceneMouseEvent *event)
             {
                 emit XYChart::clicked(calculateDomainPoint(event->pos()));
+                QGraphicsItem::mousePressEvent(event);
             }
             #include "moc_linechartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/piesliceitem.cpp +1 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 "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);
                     switch (m_data.m_labelPosition)
                     {
                     case QPieSlice::LabelOutside:
                         painter->setClipRect(parentItem()->boundingRect());
                         painter->strokePath(m_labelArmPath, m_data.m_labelBrush.color());
                         painter->drawText(m_labelTextRect, Qt::AlignCenter, m_data.m_labelText);
                         break;
                     case QPieSlice::LabelInside:
                         painter->setClipPath(m_slicePath);
                         painter->drawText(m_labelTextRect, Qt::AlignCenter, m_data.m_labelText);
                         break;
                     case QPieSlice::LabelInsideTangential:
                         painter->setClipPath(m_slicePath);
                         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);
                         break;
                     case QPieSlice::LabelInsideNormal:
                         painter->setClipPath(m_slicePath);
                         painter->translate(m_labelTextRect.center());
                         if (m_data.m_startAngle + m_data.m_angleSpan / 2 < 180)
                             painter->rotate(m_data.m_startAngle + m_data.m_angleSpan / 2 - 90);
                         else
                             painter->rotate(m_data.m_startAngle + m_data.m_angleSpan / 2 + 90);
                         painter->drawText(-m_labelTextRect.width() / 2, -m_labelTextRect.height() / 2, m_labelTextRect.width(), m_labelTextRect.height(), Qt::AlignCenter, m_data.m_labelText);
                         break;
                     }
                     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());
+                QGraphicsItem::mousePressEvent(event);
             }
             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
                 switch (m_data.m_labelPosition)
                 {
                 case QPieSlice::LabelOutside:
                     m_labelTextRect.moveBottomLeft(labelTextStart);
                     break;
                 case QPieSlice::LabelInside:
                 case QPieSlice::LabelInsideTangential:
                 case QPieSlice::LabelInsideNormal:{
                     QPointF textCenter;
                     if (m_data.m_donut)
                         textCenter = m_data.m_center + offset(centerAngle, m_data.m_innerRadius + (m_data.m_radius - m_data.m_innerRadius) / 2);
                     else
                         textCenter = m_data.m_center + offset(centerAngle, m_data.m_radius / 2);
                     m_labelTextRect.moveCenter(textCenter);
                     break;
                 }
                 }
                 //  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/scatterchart/scatterchartitem.cpp +3 -2

             /****************************************************************************
              **
              ** Copyright (C) 2012 Digia Plc
              ** All rights reserved.
              ** For any questions to Digia, please use contact form at http://qt.digia.com
              **
              ** This file is part of the Qt Commercial Charts Add-on.
              **
              ** $QT_BEGIN_LICENSE$
              ** Licensees holding valid Qt Commercial licenses may use this file in
              ** accordance with the Qt Commercial License Agreement provided with the
              ** Software or, alternatively, in accordance with the terms contained in
              ** a written agreement between you and Digia.
              **
              ** If you have questions regarding the use of this file, please use
              ** contact form at http://qt.digia.com
              ** $QT_END_LICENSE$
              **
              ****************************************************************************/
             #include "scatterchartitem_p.h"
             #include "qscatterseries.h"
             #include "qscatterseries_p.h"
             #include "chartpresenter_p.h"
             #include <QPainter>
             #include <QGraphicsScene>
             #include <QDebug>
             #include <QGraphicsSceneMouseEvent>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ScatterChartItem::ScatterChartItem(QScatterSeries *series, ChartPresenter *presenter) :
                 XYChart(series,presenter),
                 QGraphicsItem(presenter ? presenter->rootItem() : 0),
                 m_series(series),
                 m_items(this),
                 m_visible(true),
                 m_shape(QScatterSeries::MarkerShapeRectangle),
                 m_size(15)
             {
                 QObject::connect(m_series->d_func(),SIGNAL(updated()), this, SLOT(handleUpdated()));
                 QObject::connect(m_series, SIGNAL(visibleChanged()), this, SLOT(handleUpdated()));
                 setZValue(ChartPresenter::ScatterSeriesZValue);
                 setFlags(QGraphicsItem::ItemClipsChildrenToShape);
                 handleUpdated();
                 m_items.setHandlesChildEvents(false);
                 // TODO: how to draw a drop shadow?
             //    QGraphicsDropShadowEffect *dropShadow = new QGraphicsDropShadowEffect();
             //    dropShadow->setOffset(2.0);
             //    dropShadow->setBlurRadius(2.0);
             //    setGraphicsEffect(dropShadow);
             }
             QRectF ScatterChartItem::boundingRect() const
             {
                 return m_rect;
             }
             void ScatterChartItem::createPoints(int count)
             {
                 for (int i = 0; i < count; ++i) {
                     QGraphicsItem *item = 0;
                     switch (m_shape) {
                         case QScatterSeries::MarkerShapeCircle: {
-                            QGraphicsEllipseItem* i = new QGraphicsEllipseItem(0,0,m_size,m_size);
+                            QGraphicsEllipseItem* i = new QGraphicsEllipseItem(0,0,m_size,m_size,this);
                             const QRectF& rect = i->boundingRect();
                             i->setPos(-rect.width()/2,-rect.height()/2);
                             item = new Marker(i,this);
                             break;
                         }
                         case QScatterSeries::MarkerShapeRectangle: {
-                            QGraphicsRectItem* i = new QGraphicsRectItem(0,0,m_size,m_size);
+                            QGraphicsRectItem* i = new QGraphicsRectItem(0,0,m_size,m_size,this);
                             i->setPos(-m_size/2,-m_size/2);
                             item = new Marker(i,this);
                             break;
                         }
                         default:
                         qWarning()<<"Unsupported marker type";
                         break;
                     }
                     m_items.addToGroup(item);
                 }
             }
             void ScatterChartItem::deletePoints(int count)
             {
                 QList<QGraphicsItem *> items = m_items.childItems();
                 for (int i = 0; i < count; ++i) {
                     delete(items.takeLast());
                 }
             }
             void ScatterChartItem::markerSelected(Marker *marker)
             {
                 emit XYChart::clicked(calculateDomainPoint(marker->point()));
             }
             void ScatterChartItem::updateGeometry()
             {
                 const QVector<QPointF>& points = geometryPoints();
                 if(points.size()==0)
                 {
                     deletePoints(m_items.childItems().count());
                     return;
                 }
                 int diff = m_items.childItems().size() - points.size();
                 if(diff>0) {
                     deletePoints(diff);
                 }
                 else if(diff<0) {
                     createPoints(-diff);
                 }
                 if(diff!=0) handleUpdated();
                 QList<QGraphicsItem*> items = m_items.childItems();
                 for (int i = 0; i < points.size(); i++) {
                     Marker* item = static_cast<Marker*>(items.at(i));
                     const QPointF& point = points.at(i);
                     const QRectF& rect = item->boundingRect();
                     item->setPoint(point);
                     item->setPos(point.x()-rect.width()/2,point.y()-rect.height()/2);
                     if(!m_visible || !clipRect().contains(point)) {
                         item->setVisible(false);
                     }
                     else {
                         item->setVisible(true);
                     }
                 }
                 prepareGeometryChange();
                 m_rect = clipRect();
                 setPos(origin());
             }
             void ScatterChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(painter)
                 Q_UNUSED(option)
                 Q_UNUSED(widget)
             }
             void ScatterChartItem::setPen(const QPen& pen)
             {
                 foreach(QGraphicsItem* item , m_items.childItems()) {
                     static_cast<Marker*>(item)->setPen(pen);
                 }
             }
             void ScatterChartItem::setBrush(const QBrush& brush)
             {
                 foreach(QGraphicsItem* item , m_items.childItems()) {
                     static_cast<Marker*>(item)->setBrush(brush);
                 }
             }
             void ScatterChartItem::handleUpdated()
             {
                 int count = m_items.childItems().count();
                 if(count==0) return;
                 bool recreate = m_visible != m_series->isVisible()
                         || m_size != m_series->markerSize()
                         || m_shape != m_series->markerShape();
                 m_visible = m_series->isVisible();
                 m_size = m_series->markerSize();
                 m_shape = m_series->markerShape();
                 if(recreate) {
                     // TODO: optimize handleUpdate to recreate points only in case shape changed
                     deletePoints(count);
                     createPoints(count);
                     // Updating geometry is now safe, because it won't call handleUpdated unless it creates/deletes points
                     updateGeometry();
                 }
                 setPen(m_series->pen());
                 setBrush(m_series->brush());
                 update();
             }
             void ScatterChartItem::mousePressEvent(QGraphicsSceneMouseEvent *event)
             {
                 emit XYChart::clicked(calculateDomainPoint(event->pos()));
+                QGraphicsItem::mousePressEvent(event);
             }
             #include "moc_scatterchartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/scatterchart/scatterchartitem_p.h +1 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$
             **
             ****************************************************************************/
             //  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 SCATTERCHARTITEM_H
             #define SCATTERCHARTITEM_H
             #include "qchartglobal.h"
             #include "xychart_p.h"
             #include <QGraphicsEllipseItem>
             #include <QPen>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QScatterSeries;
             class Marker;
             class ScatterChartItem : public XYChart, public QGraphicsItem
             {
                 Q_OBJECT
                 Q_INTERFACES(QGraphicsItem)
             public:
                 explicit ScatterChartItem(QScatterSeries *series, ChartPresenter *presenter);
             public:
                 //from QGraphicsItem
                 QRectF boundingRect() const;
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
                 void setPen(const QPen &pen);
                 void setBrush(const QBrush &brush);
                 void markerSelected(Marker *item);
             public Q_SLOTS:
                 void handleUpdated();
             private:
                 void createPoints(int count);
                 void deletePoints(int count);
             protected:
                 void updateGeometry();
                 void mousePressEvent(QGraphicsSceneMouseEvent *event);
             private:
                 QScatterSeries *m_series;
                 QGraphicsItemGroup m_items;
                 bool m_visible;
                 int m_shape;
                 int m_size;
                 QRectF m_rect;
             };
             class Marker: public QAbstractGraphicsShapeItem
             {
             public:
                Marker(QAbstractGraphicsShapeItem *item , ScatterChartItem *parent) : QAbstractGraphicsShapeItem(0) ,m_item(item), m_parent(parent)
                {
                }
                ~Marker()
                {
                    delete m_item;
                }
                void setPoint(const QPointF& point)
                {
                    m_point=point;
                }
                QPointF point() const
                {
                    return m_point;
                }
                QPainterPath shape() const
                {
                    return m_item->shape();
                }
                QRectF boundingRect() const
                {
                    return m_item->boundingRect();
                }
                bool contains(const QPointF &point) const
                {
                    return m_item->contains(point);
                }
                void setPen(const QPen &pen)
                {
                    m_item->setPen(pen);
                }
                void setBrush(const QBrush &brush)
                {
                    m_item->setBrush(brush);
                }
                void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
                {
                    m_item->paint(painter,option,widget);
                }
             protected:
                void mousePressEvent(QGraphicsSceneMouseEvent *event)
                {
                    Q_UNUSED(event)
                    m_parent->markerSelected(this);
+                   QAbstractGraphicsShapeItem::mousePressEvent(event);
                }
             private:
                QAbstractGraphicsShapeItem* m_item;
                ScatterChartItem* m_parent;
                QPointF m_point;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // SCATTERPRESENTER_H

src/splinechart/splinechartitem.cpp +2 -1

             /****************************************************************************
              **
              ** Copyright (C) 2012 Digia Plc
              ** All rights reserved.
              ** For any questions to Digia, please use contact form at http://qt.digia.com
              **
              ** This file is part of the Qt Commercial Charts Add-on.
              **
              ** $QT_BEGIN_LICENSE$
              ** Licensees holding valid Qt Commercial licenses may use this file in
              ** accordance with the Qt Commercial License Agreement provided with the
              ** Software or, alternatively, in accordance with the terms contained in
              ** a written agreement between you and Digia.
              **
              ** If you have questions regarding the use of this file, please use
              ** contact form at http://qt.digia.com
              ** $QT_END_LICENSE$
              **
              ****************************************************************************/
             #include "splinechartitem_p.h"
             #include "qsplineseries_p.h"
             #include "chartpresenter_p.h"
             #include "splineanimation_p.h"
             #include <QPainter>
             #include <QGraphicsSceneMouseEvent>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             SplineChartItem::SplineChartItem(QSplineSeries *series, ChartPresenter *presenter) :
                 XYChart(series, presenter),
                 QGraphicsItem(presenter ? presenter->rootItem() : 0),
                 m_series(series),
                 m_pointsVisible(false),
                 m_animation(0)
             {
-                setZValue(ChartPresenter::LineChartZValue);
+                setZValue(ChartPresenter::SplineChartZValue);
                 QObject::connect(m_series->d_func(),SIGNAL(updated()),this,SLOT(handleUpdated()));
                 QObject::connect(series, SIGNAL(visibleChanged()), this, SLOT(handleUpdated()));
                 handleUpdated();
             }
             QRectF SplineChartItem::boundingRect() const
             {
                 return m_rect;
             }
             QPainterPath SplineChartItem::shape() const
             {
                 return m_path;
             }
             void SplineChartItem::setAnimation(SplineAnimation* animation)
             {
                 m_animation=animation;
                 XYChart::setAnimation(animation);
             }
             ChartAnimation* SplineChartItem::animation() const
             {
                 return m_animation;
             }
             void SplineChartItem::setControlGeometryPoints(QVector<QPointF>& points)
             {
                 m_controlPoints=points;
             }
             QVector<QPointF> SplineChartItem::controlGeometryPoints() const
             {
                 return m_controlPoints;
             }
             void SplineChartItem::updateChart(QVector<QPointF> &oldPoints, QVector<QPointF> &newPoints,int index)
             {
                 QVector<QPointF> controlPoints;
                 if(newPoints.count()>=2) {
                     controlPoints.resize(newPoints.count()*2-2);
                 }
                 for (int i = 0; i < newPoints.size() - 1; i++) {
                     controlPoints[2*i] = calculateGeometryControlPoint(2 * i);
                     controlPoints[2 * i + 1] = calculateGeometryControlPoint(2 * i + 1);
                 }
                 if (controlPoints.count()<2) {
                     setGeometryPoints(newPoints);
                     setControlGeometryPoints(controlPoints);
                     updateGeometry();
                     return;
                 }
                 if (m_animation) {
                     m_animation->setup(oldPoints,newPoints,m_controlPoints,controlPoints,index);
                     setGeometryPoints(newPoints);
                     setDirty(false);
                     presenter()->startAnimation(m_animation);
                 }
                 else {
                     setGeometryPoints(newPoints);
                     setControlGeometryPoints(controlPoints);
                     updateGeometry();
                 }
             }
             QPointF SplineChartItem::calculateGeometryControlPoint(int index) const
             {
                 return XYChart::calculateGeometryPoint(m_series->d_func()->controlPoint(index));
             }
             void SplineChartItem::updateGeometry()
             {
                 const QVector<QPointF> &points = geometryPoints();
                 const QVector<QPointF> &controlPoints = controlGeometryPoints();
                 if ((points.size()<2) || (controlPoints.size()<2)) {
                 	prepareGeometryChange();
                     m_path = QPainterPath();
                     m_rect = QRect();
                     return;
                 }
                 Q_ASSERT(points.count()*2-2 == controlPoints.count());
                 QPainterPath splinePath(points.at(0));
                 for (int i = 0; i < points.size() - 1; i++) {
                     const QPointF& point = points.at(i + 1);
                     splinePath.cubicTo(controlPoints[2*i],controlPoints[2 * i + 1],point);
                 }
                 prepareGeometryChange();
                 m_path = splinePath;
                 m_rect = splinePath.boundingRect();
                 setPos(origin());
             }
             //handlers
             void SplineChartItem::handleUpdated()
             {
                 setVisible(m_series->isVisible());
                 m_pointsVisible = m_series->pointsVisible();
                 m_linePen = m_series->pen();
                 m_pointPen = m_series->pen();
                 m_pointPen.setWidthF(2*m_pointPen.width());
                 update();
             }
             //painter
             void SplineChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(widget)
                 Q_UNUSED(option)
                 painter->save();
                 painter->setClipRect(clipRect());
                 painter->setPen(m_linePen);
                 painter->drawPath(m_path);
                 if (m_pointsVisible) {
                     painter->setPen(m_pointPen);
                     painter->drawPoints(geometryPoints());
                 }
                 painter->restore();
             }
             void SplineChartItem::mousePressEvent(QGraphicsSceneMouseEvent *event)
             {
                 emit XYChart::clicked(calculateDomainPoint(event->pos()));
+                QGraphicsItem::mousePressEvent(event);
             }
             #include "moc_splinechartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

General Comments 0

Write
Preview

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

No TODOs yet

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

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