HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r2255:31c21c535136

Added hovered signal to QLineSeries. Updated callout example

Marek Rosa -

r2255:31c21c535136

parent child

Context file:

r2255:31c21c535136

Collapse all files

examples/callout/widget.cpp +24 -9

             #include "widget.h"
             #include <QGraphicsScene>
             #include <QGraphicsView>
             #include <QVBoxLayout>
             #include <QChart>
             #include <QLineSeries>
             #include <QGraphicsTextItem>
             #include <QGraphicsLineItem>
             #include "callout.h"
             QTCOMMERCIALCHART_USE_NAMESPACE
             Widget::Widget(QWidget *parent)
                 : QWidget(parent),
                   m_scene(0),
                   m_chart(0),
-                  m_view(0)
+                  m_view(0),
+                  m_tooltip(0)
             {
                 // chart
                 m_chart = new QChart;
                 m_chart->setMinimumSize(640, 480);
+                m_chart->setTitle("Hover the line to show callout. Click the line to make it stay");
+                m_chart->legend()->hide();
                 QLineSeries *series = new QLineSeries;
-                series->setName("Click the line to create a movable callout");
                 series->append(1, 3);
                 series->append(4, 5);
                 series->append(5, 4.5);
                 series->append(7, 1);
                 series->append(11, 2);
                 m_chart->addSeries(series);
                 m_chart->createDefaultAxes();
                 m_scene = new QGraphicsScene;
                 m_view = new QGraphicsView(m_scene);
                 m_view->setRenderHint(QPainter::Antialiasing);
                 m_scene->addItem(m_chart);
                 QVBoxLayout *mainLayout = new QVBoxLayout;
                 mainLayout->addWidget(m_view);
                 setLayout(mainLayout);
-                connect(series, SIGNAL(clicked(QPointF)), this, SLOT(addCallout(QPointF)));
+                connect(series, SIGNAL(clicked(QPointF)), this, SLOT(keepCallout()));
+                connect(series, SIGNAL(hovered(QPointF, bool)), this, SLOT(tooltip(QPointF,bool)));
             }
             Widget::~Widget()
             {
             }
-            void Widget::addCallout(QPointF point)
+            void Widget::keepCallout()
             {
-                Callout *label = new Callout(m_chart);
+                m_tooltip = new Callout(m_chart);
-                label->setText(QString("X: %1\nY: %2").arg(point.x()).arg(point.y()));
-                label->setAnchor(m_chart->mapFromParent(m_view->mapToScene(m_view->mapFromGlobal(QCursor::pos()))));
-                label->setPos(m_chart->mapFromParent(m_view->mapToScene(m_view->mapFromGlobal(QCursor::pos() + QPoint(10, -50)))));
+            void Widget::tooltip(QPointF point, bool state)
-                label->setZValue(11);
+                if (m_tooltip == 0)
+                    m_tooltip = new Callout(m_chart);
+                if (state) {
+                    m_tooltip->setText(QString("X: %1\nY: %2").arg(point.x()).arg(point.y()));
+                    m_tooltip->setAnchor(m_chart->mapFromParent(m_view->mapToScene(m_view->mapFromGlobal(QCursor::pos()))));
+                    m_tooltip->setPos(m_chart->mapFromParent(m_view->mapToScene(m_view->mapFromGlobal(QCursor::pos() + QPoint(10, -50)))));
+                    m_tooltip->setZValue(11);
+                    m_tooltip->show();
+                } else {
+                    m_tooltip->hide();
+                }
             }

examples/callout/widget.h +4 -1

             #ifndef WIDGET_H
             #define WIDGET_H
             #include <QWidget>
             #include <QChart>
             class QGraphicsScene;
             class QGraphicsView;
+            class Callout;
             QTCOMMERCIALCHART_USE_NAMESPACE
             class Widget : public QWidget
             {
                 Q_OBJECT
             public:
                 Widget(QWidget *parent = 0);
                 ~Widget();
             public slots:
-                void addCallout(QPointF point);
+                void keepCallout();
+                void tooltip(QPointF point, bool state);
             private:
                 QGraphicsScene *m_scene;
                 QChart *m_chart;
                 QGraphicsView *m_view;
+                Callout *m_tooltip;
             };
             #endif // WIDGET_H

src/linechart/linechartitem.cpp +13 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
             const qreal mouseEventMinWidth(12);
             LineChartItem::LineChartItem(QLineSeries *series, ChartPresenter *presenter)
                 : XYChart(series, presenter),
                   QGraphicsItem(presenter ? presenter->rootItem() : 0),
                   m_series(series),
                   m_pointsVisible(false)
             {
+                setAcceptHoverEvents(true);
                 setZValue(ChartPresenter::LineChartZValue);
                 QObject::connect(series->d_func(), SIGNAL(updated()), this, SLOT(handleUpdated()));
                 QObject::connect(series, SIGNAL(visibleChanged()), this, SLOT(handleUpdated()));
                 QObject::connect(series, SIGNAL(opacityChanged()), this, SLOT(handleUpdated()));
                 handleUpdated();
             }
             QRectF LineChartItem::boundingRect() const
             {
                 return m_rect;
             }
             QPainterPath LineChartItem::shape() const
             {
                 return m_path;
             }
             void LineChartItem::updateGeometry()
             {
                 m_points = geometryPoints();
                 if (m_points.size() == 0) {
                     prepareGeometryChange();
                     m_path = QPainterPath();
                     m_rect = QRect();
                     return;
                 }
                 QPainterPath linePath(m_points.at(0));
                 if (m_pointsVisible) {
                     int size = m_linePen.width();
                     linePath.addEllipse(m_points.at(0), size, size);
                     for (int i = 1; i < m_points.size(); i++) {
                         linePath.lineTo(m_points.at(i));
                         linePath.addEllipse(m_points.at(i), size, size);
                     }
                 } else {
                     for (int i = 1; i < m_points.size(); i++)
                         linePath.lineTo(m_points.at(i));
                 }
                 m_linePath = linePath;
                 QPainterPathStroker stroker;
                 // QPainter::drawLine does not respect join styles, for example BevelJoin becomes MiterJoin.
                 // This is why we are prepared for the "worst case" scenario, i.e. use always MiterJoin and
                 // multiply line width with square root of two when defining shape and bounding rectangle.
                 stroker.setWidth(m_linePen.width() * 1.42);
                 stroker.setJoinStyle(Qt::MiterJoin);
                 stroker.setCapStyle(Qt::SquareCap);
                 stroker.setMiterLimit(m_linePen.miterLimit());
                 prepareGeometryChange();
                 m_path = stroker.createStroke(linePath);
                 m_rect = m_path.boundingRect();
                 setPos(origin());
             }
             void LineChartItem::handleUpdated()
             {
                 setVisible(m_series->isVisible());
                 setOpacity(m_series->opacity());
                 m_pointsVisible = m_series->pointsVisible();
                 m_linePen = m_series->pen();
                 update();
             }
             void LineChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(widget)
                 Q_UNUSED(option)
                 painter->save();
                 painter->setPen(m_linePen);
                 painter->setBrush(m_linePen.color());
                 painter->setClipRect(clipRect());
                 if (m_pointsVisible) {
                     painter->drawPath(m_linePath);
                 } else {
                     for (int i(1); i < m_points.size(); i++)
                         painter->drawLine(m_points.at(i - 1), m_points.at(i));
                 }
                 painter->restore();
             }
             void LineChartItem::mousePressEvent(QGraphicsSceneMouseEvent *event)
             {
                 emit XYChart::clicked(calculateDomainPoint(event->pos()));
                 QGraphicsItem::mousePressEvent(event);
             }
+            void LineChartItem::hoverEnterEvent(QGraphicsSceneHoverEvent *event)
+            {
+                emit XYChart::hovered(calculateDomainPoint(event->pos()), true);
+                QGraphicsItem::hoverEnterEvent(event);
+            }
+            void LineChartItem::hoverLeaveEvent(QGraphicsSceneHoverEvent *event)
+            {
+                emit XYChart::hovered(calculateDomainPoint(event->pos()), false);
+                QGraphicsItem::hoverEnterEvent(event);
+            }
             #include "moc_linechartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/linechart/linechartitem_p.h +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$
             **
             ****************************************************************************/
             //  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 LINECHARTITEM_H
             #define LINECHARTITEM_H
             #include "qchartglobal.h"
             #include "xychart_p.h"
             #include <QPen>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QLineSeries;
             class ChartPresenter;
             class LineChartItem :  public XYChart , public QGraphicsItem
             {
                 Q_OBJECT
                 Q_INTERFACES(QGraphicsItem)
             public:
                 explicit LineChartItem(QLineSeries *series, ChartPresenter *presenter);
                 ~LineChartItem() {}
                 //from QGraphicsItem
                 QRectF boundingRect() const;
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
                 QPainterPath shape() const;
                 QPainterPath path() const { return m_linePath; }
             public Q_SLOTS:
                 void handleUpdated();
             protected:
                 void updateGeometry();
                 void mousePressEvent(QGraphicsSceneMouseEvent *event);
+                void hoverEnterEvent(QGraphicsSceneHoverEvent *event);
+                void hoverLeaveEvent(QGraphicsSceneHoverEvent *event);
             private:
                 QLineSeries *m_series;
                 QPainterPath m_path;
                 QPainterPath m_linePath;
                 QVector<QPointF> m_points;
                 QRectF m_rect;
                 QPen m_linePen;
                 bool m_pointsVisible;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/xychart/qxyseries.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$
             **
             ****************************************************************************/
             #ifndef QXYSERIES_H
             #define QXYSERIES_H
             #include <qchartglobal.h>
             #include <qabstractseries.h>
             #include <QPen>
             #include <QBrush>
             class QModelIndex;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QXYSeriesPrivate;
             class QXYModelMapper;
             class QTCOMMERCIALCHART_EXPORT QXYSeries : public QAbstractSeries
             {
                 Q_OBJECT
                 Q_PROPERTY(bool pointsVisible READ pointsVisible WRITE setPointsVisible)
                 Q_PROPERTY(QColor color READ color WRITE setColor NOTIFY colorChanged)
             protected:
                 explicit QXYSeries(QXYSeriesPrivate &d, QObject *parent = 0);
             public:
                 ~QXYSeries();
                 void append(qreal x, qreal y);
                 void append(const QPointF &point);
                 void append(const QList<QPointF> &points);
                 void replace(qreal oldX, qreal oldY, qreal newX, qreal newY);
                 void replace(const QPointF &oldPoint, const QPointF &newPoint);
                 void remove(qreal x, qreal y);
                 void remove(const QPointF &point);
                 void insert(int index, const QPointF &point);
                 void clear();
                 int count() const;
                 QList<QPointF> points() const;
                 QXYSeries &operator << (const QPointF &point);
                 QXYSeries &operator << (const QList<QPointF> &points);
                 virtual void setPen(const QPen &pen);
                 QPen pen() const;
                 virtual void setBrush(const QBrush &brush);
                 QBrush brush() const;
                 virtual void setColor(const QColor &color);
                 virtual QColor color() const;
                 void setPointsVisible(bool visible = true);
                 bool pointsVisible() const;
                 void replace(QList<QPointF> points);
             Q_SIGNALS:
                 void clicked(const QPointF &point);
+                void hovered(const QPointF &point, bool state);
                 void pointReplaced(int index);
                 void pointRemoved(int index);
                 void pointAdded(int index);
                 void colorChanged(QColor color);
                 void pointsReplaced();
             private:
                 Q_DECLARE_PRIVATE(QXYSeries)
                 Q_DISABLE_COPY(QXYSeries)
                 friend class QXYLegendMarkerPrivate;
                 friend class XYLegendMarker;
                 friend class XYChart;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QXYSERIES_H

src/xychart/xychart.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 "xychart_p.h"
             #include "qxyseries.h"
             #include "qxyseries_p.h"
             #include "chartpresenter_p.h"
             #include "domain_p.h"
             #include "qxymodelmapper.h"
             #include <QPainter>
             #include <QAbstractItemModel>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             //TODO: optimize : remove points which are not visible
             XYChart::XYChart(QXYSeries *series, ChartPresenter *presenter)
                 : ChartElement(presenter),
                   m_minX(0),
                   m_maxX(0),
                   m_minY(0),
                   m_maxY(0),
                   m_series(series),
                   m_animation(0),
                   m_dirty(true)
             {
                 QObject::connect(series, SIGNAL(pointReplaced(int)), this, SLOT(handlePointReplaced(int)));
                 QObject::connect(series, SIGNAL(pointsReplaced()), this, SLOT(handlePointsReplaced()));
                 QObject::connect(series, SIGNAL(pointAdded(int)), this, SLOT(handlePointAdded(int)));
                 QObject::connect(series, SIGNAL(pointRemoved(int)), this, SLOT(handlePointRemoved(int)));
                 QObject::connect(this, SIGNAL(clicked(QPointF)), series, SIGNAL(clicked(QPointF)));
+                QObject::connect(this, SIGNAL(hovered(QPointF,bool)), series, SIGNAL(hovered(QPointF,bool)));
             }
             void XYChart::setGeometryPoints(const QVector<QPointF>& points)
             {
                 m_points = points;
             }
             void XYChart::setClipRect(const QRectF &rect)
             {
                 m_clipRect = rect;
             }
             void XYChart::setAnimation(XYAnimation *animation)
             {
                 m_animation = animation;
             }
             void XYChart::setDirty(bool dirty)
             {
                 m_dirty = dirty;
             }
             QPointF XYChart::calculateGeometryPoint(const QPointF &point) const
             {
                 const qreal deltaX = m_size.width() / (m_maxX - m_minX);
                 const qreal deltaY = m_size.height() / (m_maxY - m_minY);
                 qreal x = (point.x() - m_minX) * deltaX;
                 qreal y = (point.y() - m_minY) * -deltaY + m_size.height();
                 return QPointF(x, y);
             }
             QPointF XYChart::calculateGeometryPoint(int index) const
             {
                 const qreal deltaX = m_size.width() / (m_maxX - m_minX);
                 const qreal deltaY = m_size.height() / (m_maxY - m_minY);
                 const QList<QPointF>& vector = m_series->points();
                 qreal x = (vector[index].x() - m_minX) * deltaX;
                 qreal y = (vector[index].y() - m_minY) * -deltaY + m_size.height();
                 return QPointF(x, y);
             }
             QVector<QPointF> XYChart::calculateGeometryPoints() const
             {
                 const qreal deltaX = m_size.width() / (m_maxX - m_minX);
                 const qreal deltaY = m_size.height() / (m_maxY - m_minY);
                 QVector<QPointF> result;
                 result.resize(m_series->count());
                 const QList<QPointF>& vector = m_series->points();
                 for (int i = 0; i < m_series->count(); ++i) {
                     qreal x = (vector[i].x() - m_minX) * deltaX;
                     qreal y = (vector[i].y() - m_minY) * -deltaY + m_size.height();
                     result[i].setX(x);
                     result[i].setY(y);
                 }
                 return result;
             }
             QPointF XYChart::calculateDomainPoint(const QPointF &point) const
             {
                 const qreal deltaX = m_size.width() / (m_maxX - m_minX);
                 const qreal deltaY = m_size.height() / (m_maxY - m_minY);
                 qreal x = point.x() / deltaX + m_minX;
                 qreal y = (point.y() - m_size.height()) / (-deltaY) + m_minY;
                 return QPointF(x, y);
             }
             void XYChart::updateChart(QVector<QPointF> &oldPoints, QVector<QPointF> &newPoints, int index)
             {
                 if (m_animation) {
                     m_animation->setup(oldPoints, newPoints, index);
                     m_points = newPoints;
                     setDirty(false);
                     presenter()->startAnimation(m_animation);
                 } else {
                     m_points = newPoints;
                     updateGeometry();
                 }
             }
             //handlers
             void XYChart::handlePointAdded(int index)
             {
                 Q_ASSERT(index < m_series->count());
                 Q_ASSERT(index >= 0);
                 QVector<QPointF> points;
                 if (m_dirty) {
                     points = calculateGeometryPoints();
                 } else {
                     points = m_points;
                     QPointF point = calculateGeometryPoint(index);
                     points.insert(index, point);
                 }
                 updateChart(m_points, points, index);
             }
             void XYChart::handlePointRemoved(int index)
             {
                 Q_ASSERT(index <= m_series->count());
                 Q_ASSERT(index >= 0);
                 QVector<QPointF> points;
                 if (m_dirty) {
                     points = calculateGeometryPoints();
                 } else {
                     points = m_points;
                     points.remove(index);
                 }
                 updateChart(m_points, points, index);
             }
             void XYChart::handlePointReplaced(int index)
             {
                 Q_ASSERT(index < m_series->count());
                 Q_ASSERT(index >= 0);
                 QVector<QPointF> points;
                 if (m_dirty) {
                     points = calculateGeometryPoints();
                 } else {
                     QPointF point = calculateGeometryPoint(index);
                     points = m_points;
                     points.replace(index, point);
                 }
                 updateChart(m_points, points, index);
             }
             void XYChart::handlePointsReplaced()
             {
                 // All the points were replaced -> recalculate
                 QVector<QPointF> points = calculateGeometryPoints();
                 updateChart(m_points, points, -1);
             }
             void XYChart::handleDomainUpdated()
             {
                 m_minX = domain()->minX();
                 m_maxX = domain()->maxX();
                 m_minY = domain()->minY();
                 m_maxY = domain()->maxY();
                 if (isEmpty()) return;
                 QVector<QPointF> points = calculateGeometryPoints();
                 updateChart(m_points, points);
             }
             void XYChart::handleGeometryChanged(const QRectF &rect)
             {
                 Q_ASSERT(rect.isValid());
                 m_size = rect.size();
                 m_clipRect = rect.translated(-rect.topLeft());
                 m_origin = rect.topLeft();
                 if (isEmpty()) return;
                 QVector<QPointF> points = calculateGeometryPoints();
                 updateChart(m_points, points);
             }
             bool XYChart::isEmpty()
             {
                 return !m_clipRect.isValid() || qFuzzyCompare(m_maxX, m_minX) || qFuzzyCompare(m_maxY, m_minY) || m_series->points().isEmpty();
             }
             #include "moc_xychart_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/xychart/xychart_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 XYCHART_H
             #define XYCHART_H
             #include "qchartglobal.h"
             #include "chartitem_p.h"
             #include "xyanimation_p.h"
             #include "qvalueaxis.h"
             #include <QPen>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartPresenter;
             class QXYSeries;
             class XYChart :  public ChartElement
             {
                 Q_OBJECT
             public:
                 explicit XYChart(QXYSeries *series, ChartPresenter *presenter);
                 ~XYChart() {}
                 void setGeometryPoints(const QVector<QPointF>& points);
                 QVector<QPointF> geometryPoints() const { return m_points; }
                 void setClipRect(const QRectF &rect);
                 QRectF clipRect() const { return m_clipRect; }
                 QSizeF size() const { return m_size; }
                 QPointF origin() const { return m_origin; }
                 void setAnimation(XYAnimation *animation);
                 ChartAnimation *animation() const { return m_animation; }
                 virtual void updateGeometry() = 0;
                 bool isDirty() const { return m_dirty; }
                 void setDirty(bool dirty);
             public Q_SLOTS:
                 void handlePointAdded(int index);
                 void handlePointRemoved(int index);
                 void handlePointReplaced(int index);
                 void handlePointsReplaced();
                 void handleDomainUpdated();
                 void handleGeometryChanged(const QRectF &size);
             Q_SIGNALS:
                 void clicked(const QPointF &point);
+                void hovered(const QPointF &point, bool state);
             protected:
                 virtual void updateChart(QVector<QPointF> &oldPoints, QVector<QPointF> &newPoints, int index = -1);
                 QPointF calculateGeometryPoint(const QPointF &point) const;
                 QPointF calculateGeometryPoint(int index) const;
                 QPointF calculateDomainPoint(const QPointF &point) const;
                 QVector<QPointF> calculateGeometryPoints() const;
             private:
                 inline bool isEmpty();
             protected:
                 qreal m_minX;
                 qreal m_maxX;
                 qreal m_minY;
                 qreal m_maxY;
                 QXYSeries *m_series;
                 QSizeF m_size;
                 QPointF m_origin;
                 QRectF m_clipRect;
                 QVector<QPointF> m_points;
                 XYAnimation *m_animation;
                 bool m_dirty;
                 friend class AreaChartItem;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

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