HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r481:676000b99479

Fixes for docs , adds xyseries docs

Michal Klocek -

r481:676000b99479

parent child

Context file:

r481:676000b99479

Collapse all files

doc/src/classes.qdoc +1 0

             /*!
                 \page classes.html
                 \title QtCommercial Charts API
                 \keyword All Classes
                 \image class_diagram.png
                 \raw HTML
                     <table cellpadding="2" cellspacing="1" border="0" width="100%" class="indextable">
                     <tr>
                     <th class="titleheader" width="33%">
                     List of classes
                     </th>
                     </tr>
                     <tr>
                     <td valign="top">
                     <ul>
                         <li><a href="qareaseries.html">QAreaSeries</a></li>
                         <li><a href="qbarseries.html">QBarSeries</a></li>
                         <li><a href="qbarset.html">QBarSet</a></li>
                         <li><a href="qchart.html">QChart</a></li>
                         <li><a href="qchartaxis.html">QChartAxis</a></li>
                         <li><a href="qchartview.html">QChartView</a></li>
                         <li><a href="qlineseries.html">QLineSeries</a></li>
                         <li><a href="qpercentbarseries.html">QPercentBarSeries</a></li>
                         <li><a href="qpieseries.html">QPieSeries</a></li>
                         <li><a href="qpieslice.html">QPieSlice</a></li>
                         <li><a href="qscatterseries.html">QScatterSeries</a></li>
                         <li><a href="qseries.html">QSeries</a></li>
                         <li><a href="qsplineseries.html">QSplineSeries</a></li>
                         <li><a href="qstackedbarseries.html">QStackedBarSeries</a></li>
+                        <li><a href="qxyseries.html">QXYSeries</a></li>
                     </ul>
                     </td>
                     </tr>
                     </table>
                     <table cellpadding="2" cellspacing="1" border="0" width="100%" class="indextable">
                     <tr>
                     <th class="titleheader" width="33%">
                     Other files:
                     </th>
                     </tr>
                     <tr>
                     <td valign="top">
                     <ul>
                         <li><a href="qchartglobal.html">QChartGlobal</a></li>
                     </ul>
                     </td>
                     </tr>
                     </table>
                 \endraw
             */

src/qchart.cpp +2 -2

             #include "qchart.h"
             #include "qchartaxis.h"
             #include "chartpresenter_p.h"
             #include "chartdataset_p.h"
             #include <QGraphicsScene>
             #include <QGraphicsSceneResizeEvent>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \enum QChart::ChartTheme
                 This enum describes the theme used by the chart.
                 \value ChartThemeDefault
                 \value ChartThemeVanilla
                 \value ChartThemeIcy
                 \value ChartThemeGrayscale
                 \value ChartThemeScientific
             */
             /*!
                 \enum QChart::AnimationOption
                 For enabling/disabling animations. Defaults to NoAnimation.
                 \value NoAnimation
                 \value GridAxisAnimations
                 \value SeriesAnimations
                 \value AllAnimations
             */
             /*!
                 \class QChart
                 \brief QtCommercial chart API.
                 QChart is a QGraphicsWidget that you can show in a QGraphicsScene. It manages the graphical
                 representation of different types of QChartSeries and other chart related objects like
                 QChartAxis and QChartLegend. If you simply want to show a chart in a layout, you can use the
                 convenience class QChartView instead of QChart.
                 \sa QChartView
             */
             /*!
                 Constructs a chart object which is a child of a\a parent. Parameter \a wFlags is passed to the QGraphicsWidget constructor.
             */
             QChart::QChart(QGraphicsItem *parent, Qt::WindowFlags wFlags) : QGraphicsWidget(parent,wFlags),
                 m_backgroundItem(0),
                 m_titleItem(0),
                 m_dataset(new ChartDataSet(this)),
                 m_presenter(new ChartPresenter(this,m_dataset))
             {
             }
             /*!
                 Destroys the object and it's children, like QChartSeries and QChartAxis object added to it.
             */
             QChart::~QChart()
             {
             }
             /*!
                 Adds the \a series and optional \a axisY onto the chart and takes the ownership of the objects.
                 If auto scaling is enabled, re-scales the axes the series is bound to (both the x axis and
                 the y axis).
             */
             void QChart::addSeries(QSeries* series, QChartAxis* axisY)
             {
                 m_dataset->addSeries(series, axisY);
             }
             /*!
                 Removes the \a series specified in a perameter from the QChartView.
                 It releses its ownership of the specified QChartSeries object.
                 It does not delete the pointed QChartSeries data object
                 \sa addSeries(), removeAllSeries()
             */
             void QChart::removeSeries(QSeries* series)
             {
                 m_dataset->removeSeries(series);
             }
             /*!
                 Removes all the QChartSeries that have been added to the QChartView
                 It also deletes the pointed QChartSeries data objects
                 \sa addSeries(), removeSeries()
             */
             void QChart::removeAllSeries()
             {
                 m_dataset->removeAllSeries();
             }
             /*!
                 Sets the \a brush that is used for painting the background of the chart area.
             */
             void QChart::setChartBackgroundBrush(const QBrush& brush)
             {
                 createChartBackgroundItem();
                 m_backgroundItem->setBrush(brush);
                 m_backgroundItem->update();
             }
             /*!
                 Sets the \a pen that is used for painting the background of the chart area.
             */
             void QChart::setChartBackgroundPen(const QPen& pen)
             {
                 createChartBackgroundItem();
                 m_backgroundItem->setPen(pen);
                 m_backgroundItem->update();
             }
             /*!
-                Sets the chart \a title. The description text that is rendered above the chart.
+                Sets the chart \a title. The description text that is drawn above the chart.
             */
             void QChart::setChartTitle(const QString& title)
             {
                 createChartTitleItem();
                 m_titleItem->setText(title);
             }
             /*!
-                Gets the chart \a title. The description text that is rendered above the chart.
+                Returns the chart title. The description text that is drawn above the chart.
             */
             QString QChart::chartTitle() const
             {
                 if(m_titleItem)
                 return m_titleItem->text();
                 else
                 return QString();
             }
             /*!
                 Sets the \a font that is used for rendering the description text that is rendered above the chart.
             */
             void QChart::setChartTitleFont(const QFont& font)
             {
                 createChartTitleItem();
                 m_titleItem->setFont(font);
             }
             void QChart::createChartBackgroundItem()
             {
                 if(!m_backgroundItem) {
                     m_backgroundItem = new QGraphicsRectItem(this);
                     m_backgroundItem->setPen(Qt::NoPen);
                     m_backgroundItem->setZValue(ChartPresenter::BackgroundZValue);
                 }
             }
             void QChart::createChartTitleItem()
             {
                 if(!m_titleItem) {
                     m_titleItem = new QGraphicsSimpleTextItem(this);
                     m_titleItem->setZValue(ChartPresenter::BackgroundZValue);
                 }
             }
             /*!
                 Returns the chart margin, which is the distance between the widget edge and the part of the chart where the actual data can be displayed.
                 \sa setMargin()
             */
             int QChart::margin() const
             {
                 return m_presenter->margin();
             }
             /*!
                 Sets the chart \a margin, which is the distance between the widget edge and the part of the chart where the actual data can be displayed.
                 \sa margin()
             */
             void QChart::setMargin(int margin)
             {
                 m_presenter->setMargin(margin);
             }
             /*!
                 Sets the \a theme used by the chart for rendering the graphical representation of the data
                 \sa ChartTheme, chartTheme()
             */
             void QChart::setChartTheme(QChart::ChartTheme theme)
             {
                 m_presenter->setChartTheme(theme);
             }
             /*!
                 Returns the theme enum used by the chart.
                 \sa ChartTheme, setChartTheme()
             */
             QChart::ChartTheme QChart::chartTheme() const
             {
                 return m_presenter->chartTheme();
             }
             /*!
                 Zooms in the view by a factor of 2
             */
             void QChart::zoomIn()
             {
                 m_presenter->zoomIn();
             }
             /*!
                 Zooms in the view to a maximum level at which \a rect is still fully visible.
             */
             void QChart::zoomIn(const QRectF& rect)
             {
                 if(!rect.isValid()) return;
                 m_presenter->zoomIn(rect);
             }
             /*!
                 Restores the view zoom level to the previous one.
             */
             void QChart::zoomOut()
             {
                 m_presenter->zoomOut();
             }
             /*!
                 Resets to the default view.
             */
             void QChart::zoomReset()
             {
                 m_presenter->zoomReset();
             }
             /*!
                 Returns the pointer to the x axis object of the chart
             */
             QChartAxis* QChart::axisX() const
             {
                 return m_dataset->axisX();
             }
             /*!
                 Returns the pointer to the y axis object of the chart
             */
             QChartAxis* QChart::axisY() const
             {
                 return m_dataset->axisY();
             }
             /*!
                 Resizes and updates the chart area using the \a event data
             */
             void QChart::resizeEvent(QGraphicsSceneResizeEvent *event)
             {
                 m_rect = QRectF(QPoint(0,0),event->newSize());
                 QRectF rect = m_rect.adjusted(margin(),margin(), -margin(), -margin());
                 // recalculate title position
                 if (m_titleItem) {
                     QPointF center = m_rect.center() -m_titleItem->boundingRect().center();
                     m_titleItem->setPos(center.x(),m_rect.top()/2 + margin()/2);
                 }
                 //recalculate background gradient
                 if (m_backgroundItem) {
                     m_backgroundItem->setRect(rect);
                 }
                 QGraphicsWidget::resizeEvent(event);
                 update();
             }
             /*!
                 Sets animation \a options for the chart
             */
             void QChart::setAnimationOptions(AnimationOptions options)
             {
                 m_presenter->setAnimationOptions(options);
             }
             /*!
                 Returns animation options for the chart
             */
             QChart::AnimationOptions QChart::animationOptions() const
             {
                 return m_presenter->animationOptions();
             }
             #include "moc_qchart.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/qchartview.cpp +2 -2

             #include "qchartview.h"
             #include "qchart.h"
             #include "qchartaxis.h"
             #include <QGraphicsView>
             #include <QGraphicsScene>
             #include <QRubberBand>
             #include <QResizeEvent>
             #include <QDebug>
             /*!
                 \enum QChartView::RubberBandPolicy
                 This enum describes the different types of rubber bands that can be used for zoom rect selection
                 \value NoRubberBand
                 \value VerticalRubberBand
                 \value HorizonalRubberBand
                 \value RectangleRubberBand
             */
             /*!
                 \class QChartView
                 \brief Standalone charting widget.
                 QChartView is a standalone widget that can display charts. It does not require separate
                 QGraphicsScene to work. It manages the graphical representation of different types of
                 QChartSeries and other chart related objects like QChartAxis and QChartLegend. If you want to
                 display a chart in your existing QGraphicsScene, you can use the QChart class instead.
                 \sa QChart
             */
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 Constructs a chartView object which is a child of a\a parent.
             */
             QChartView::QChartView(QWidget *parent) :
             QGraphicsView(parent),
             m_scene(new QGraphicsScene(this)),
             m_chart(new QChart()),
             m_rubberBand(0),
             m_verticalRubberBand(false),
             m_horizonalRubberBand(false)
             {
                 setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
                 setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
                 setScene(m_scene);
                 m_chart->setMargin(50);
                 m_scene->addItem(m_chart);
                 setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
             }
             /*!
                 Destroys the object and it's children, like QChartSeries and QChartAxis object added to it.
             */
             QChartView::~QChartView()
             {
             }
             /*!
                 Resizes and updates the chart area using the \a event data
             */
             void QChartView::resizeEvent(QResizeEvent *event)
             {
                 m_scene->setSceneRect(0,0,size().width(),size().height());
                 m_chart->resize(size());
                 QWidget::resizeEvent(event);
             }
             /*!
                 Adds the \a series and optional \a axisY onto the chart and takes the ownership of the objects.
                 If auto scaling is enabled, re-scales the axes the series is bound to (both the x axis and
                 the y axis).
                 \sa removeSeries(), removeAllSeries()
             */
             void QChartView::addSeries(QSeries* series,QChartAxis *axisY)
             {
                 m_chart->addSeries(series,axisY);
             }
             /*!
                 Removes the \a series specified in a perameter from the QChartView.
                 It releses its ownership of the specified QChartSeries object.
                 It does not delete the pointed QChartSeries data object
                 \sa addSeries(), removeAllSeries()
             */
             void QChartView::removeSeries(QSeries* series)
             {
                 m_chart->removeSeries(series);
             }
             /*!
                 Removes all the QChartSeries that have been added to the QChartView
                 It also deletes the pointed QChartSeries data objects
                 \sa addSeries(), removeSeries()
             */
             void QChartView::removeAllSeries()
             {
                 m_chart->removeAllSeries();
             }
             /*!
                 Zooms in the view by a factor of 2
             */
             void QChartView::zoomIn()
             {
                 m_chart->zoomIn();
             }
             /*!
                 Zooms in the view to a maximum level at which \a rect is still fully visible.
             */
             void QChartView::zoomIn(const QRect& rect)
             {
                 m_chart->zoomIn(rect);
             }
             /*!
                 Restores the view zoom level to the previous one.
             */
             void QChartView::zoomOut()
             {
                 m_chart->zoomOut();
             }
             /*!
                 Returns the chart margin, which is the distance between the widget edge and the part of the chart where the actual data can be displayed.
             */
             int QChartView::margin() const
             {
                 return m_chart->margin();
             }
             /*!
-                Sets the chart \a title. A description text that is rendered above the chart.
+                Sets the chart \a title. A description text that is drawn above the chart.
             */
             void QChartView::setChartTitle(const QString& title)
             {
                 m_chart->setChartTitle(title);
             }
             /*!
-                Returns the chart's title. A description text that is rendered above the chart.
+                Returns the chart's title. A description text that is drawn above the chart.
             */
             QString QChartView::chartTitle() const
             {
                 return m_chart->chartTitle();
             }
             /*!
                 Sets the \a font that is used for rendering the description text that is rendered above the chart.
             */
             void QChartView::setChartTitleFont(const QFont& font)
             {
                 m_chart->setChartTitleFont(font);
             }
             /*!
                 Sets the \a brush that is used for painting the background of the chart area of the QChartView widget.
             */
             void QChartView::setChartBackgroundBrush(const QBrush& brush)
             {
                 m_chart->setChartBackgroundBrush(brush);
             }
             /*!
                 Sets the \a pen that is used for painting the background of the chart area of the QChartView widget.
             */
             void QChartView::setChartBackgroundPen(const QPen& pen)
             {
                 m_chart->setChartBackgroundPen(pen);
             }
             /*!
                 Sets the RubberBandPlicy to \a policy. Selected policy determines the way zooming is performed.
             */
             void QChartView::setRubberBandPolicy(const RubberBandPolicy policy)
             {
                 switch(policy) {
                     case VerticalRubberBand:
                     m_verticalRubberBand = true;
                     m_horizonalRubberBand = false;
                     break;
                     case HorizonalRubberBand:
                     m_verticalRubberBand = false;
                     m_horizonalRubberBand = true;
                     break;
                     case RectangleRubberBand:
                     m_verticalRubberBand = true;
                     m_horizonalRubberBand = true;
                     break;
                     case NoRubberBand:
                     default:
                     delete m_rubberBand;
                     m_rubberBand=0;
                     m_horizonalRubberBand = false;
                     m_verticalRubberBand = false;
                     return;
                 }
                 if(!m_rubberBand) {
                     m_rubberBand = new QRubberBand(QRubberBand::Rectangle, this);
                     m_rubberBand->setEnabled(true);
                 }
             }
             /*!
                 Returns the RubberBandPolicy that is currently being used by the widget.
             */
             QChartView::RubberBandPolicy QChartView::rubberBandPolicy() const
             {
                 if(m_horizonalRubberBand && m_verticalRubberBand) return RectangleRubberBand;
                 if(m_horizonalRubberBand) return HorizonalRubberBand;
                 if(m_verticalRubberBand) return VerticalRubberBand;
                 return NoRubberBand;
             }
             /*!
                 If Left mouse button is pressed and the RubberBandPolicy is enabled the \a event is accepted and the rubber band is displayed on the screen allowing the user to select the zoom area.
                 If different mouse button is pressed and/or the RubberBandPolicy is disabled then the \a event is passed to QGraphicsView::mousePressEvent() implementation.
             */
             void QChartView::mousePressEvent(QMouseEvent *event)
             {
                 if(m_rubberBand && m_rubberBand->isEnabled() && event->button() == Qt::LeftButton) {
                     int margin = m_chart->margin();
                     QRect rect(margin, margin, width() - 2 * margin, height() - 2 * margin);
                     if (rect.contains(event->pos())) {
                         m_rubberBandOrigin = event->pos();
                         m_rubberBand->setGeometry(QRect(m_rubberBandOrigin, QSize()));
                         m_rubberBand->show();
                         event->accept();
                     }
                 }
                 else {
                     QGraphicsView::mousePressEvent(event);
                 }
             }
             /*!
                 If RubberBand rectange specification has been initiated in pressEvent then \a event data is used to update RubberBand geometry.
                 In other case the defualt QGraphicsView::mouseMoveEvent implementation is called.
             */
             void QChartView::mouseMoveEvent(QMouseEvent *event)
             {
                 if(m_rubberBand && m_rubberBand->isVisible()) {
                     int margin = m_chart->margin();
                     QRect rect(margin, margin, width() - 2 * margin, height() - 2 * margin);
                     int width = event->pos().x() - m_rubberBandOrigin.x();
                     int height = event->pos().y() - m_rubberBandOrigin.y();
                     if(!m_verticalRubberBand) {
                         m_rubberBandOrigin.setY(rect.top());
                         height = rect.height();
                     }
                     if(!m_horizonalRubberBand) {
                         m_rubberBandOrigin.setX(rect.left());
                         width= rect.width();
                     }
                     m_rubberBand->setGeometry(QRect(m_rubberBandOrigin.x(),m_rubberBandOrigin.y(), width,height).normalized());
                 }
                 else {
                     QGraphicsView::mouseMoveEvent(event);
                 }
             }
             /*!
                 If left mouse button is release and RubberBand is enabled then \a event is accepted and the view is zoomed in to rect specified by RubberBand
                 If it is the right mouse button \a event then RubberBand is dissmissed and zoom is canceled.
             */
             void QChartView::mouseReleaseEvent(QMouseEvent *event)
             {
                 if(m_rubberBand) {
                     if (event->button() == Qt::LeftButton && m_rubberBand->isVisible()) {
                         m_rubberBand->hide();
                         QRect rect = m_rubberBand->geometry();
                         m_chart->zoomIn(rect);
                         event->accept();
                     }
                     if(event->button()==Qt::RightButton)
                     m_chart->zoomReset();
                 }
                 else {
                     QGraphicsView::mouseReleaseEvent(event);
                 }
             }
             /*!
                 Pressing + and - keys performs zoomIn() and zoomOut() respectivly.
                 In other \a event is passed to the QGraphicsView::keyPressEvent() implementation
             */
             void QChartView::keyPressEvent(QKeyEvent *event)
             {
                 switch (event->key()) {
                     case Qt::Key_Plus:
                     zoomIn();
                     break;
                     case Qt::Key_Minus:
                     zoomOut();
                     break;
                     default:
                     QGraphicsView::keyPressEvent(event);
                     break;
                 }
             }
             /*!
                 Sets the \a theme used by the chart for rendering the graphical representation of the data
                 \sa QChart::ChartTheme, chartTheme()
             */
             void QChartView::setChartTheme(QChart::ChartTheme theme)
             {
                 m_chart->setChartTheme(theme);
             }
             /*!
                 Returns the theme enum used by the chart.
                 \sa setChartTheme()
             */
             QChart::ChartTheme QChartView::chartTheme() const
             {
                 return m_chart->chartTheme();
             }
             /*!
                 Returns the pointer to the x axis object of the chart
             */
             QChartAxis* QChartView::axisX() const
             {
                 return m_chart->axisX();
             }
             /*!
                 Returns the pointer to the y axis object of the chart
             */
             QChartAxis* QChartView::axisY() const
             {
                 return m_chart->axisY();
             }
             /*!
                 Sets animation \a options for the chart
             */
             void QChartView::setAnimationOptions(QChart::AnimationOptions options)
             {
                 m_chart->setAnimationOptions(options);
             }
             /*!
                 Returns animation options for the chart
             */
             QChart::AnimationOptions QChartView::animationOptions() const
             {
                 return m_chart->animationOptions();
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/scatterseries/qscatterseries.cpp +15 -113

             #include "qscatterseries.h"
             #include "qchart.h"
             /*!
                 \class QScatterSeries
-                \brief QtCommercial Chart series API for showing scatter series.
+                \brief The QScatterSeries class is used for making scatter charts.
                 \mainclass
-                Example on how to create a chart with scatter series:
+                The scatter data is displayed as a collection of points on the chart. Each point determines the position on the horizontal axis
-                \snippet ../example/scatter/main.cpp 1
+                and the vertical axis.
-                The example code would result the following:
+                \image scatterchart.png
-                \image scatter_example1.jpg
+                Creating basic scatter chart is simple:
+                \code
-                To customize the graphical representation of the series, you can modify pen, brush, shape and
+                QScatterSeries* series = new QScatterSeries();
-                size of the marker items. For example:
+                series->add(0, 6);
+                series->add(2, 4);
-                \snippet ../example/scatter/main.cpp 3
+                ...
+                chartView->addSeries(series);
-                Would present your scatter markers as big rectangles with opaque, uglyish green outlines and
+                \endcode
-                opaque red filling instead of the beatiful markers defined by the chart's theme:
-                \image scatter_example_custom.jpg
             */
             /*!
                 \enum QScatterSeries::MarkerShape
                 This enum describes the shape used when rendering marker items.
                 \value MarkerShapeDefault
                 \value MarkerShapeX
                 \value MarkerShapeRectangle
                 \value MarkerShapeRoundedRectangle
                 \value MarkerShapeTiltedRectangle
                 \value MarkerShapeTriangle
                 \value MarkerShapeCircle
             */
             /*!
                 \fn QChartSeriesType QScatterSeries::type() const
                 \brief Returns QChartSeries::SeriesTypeScatter.
+                \sa QSeries, QSeriesType
             */
             /*!
-                \fn void QScatterSeries::clicked(QPointF coordinate)
+                \fn void QScatterSeries::clicked(const QPointF& point)
-                User clicked the scatter series. Note that the \a coordinate is the chart coordinate that the
+                \brief Signal is emitted when user clicks the \a point on scatter chart.
-                click occurred on; not necessarily a data point coordinate. To find the corresponding (closest)
-                data point you can use closestPoint().
             */
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 Constructs a series object which is a child of \a parent.
             */
             QScatterSeries::QScatterSeries(QObject *parent) :
                 QXYSeries(parent),
                 m_shape(QScatterSeries::MarkerShapeDefault),
                 m_size(9.0)
             {
             }
             /*!
                 Destroys the object. Note that adding series to QChart transfers the ownership to the chart.
             */
             QScatterSeries::~QScatterSeries()
             {
             }
-            /*!
-                Stream operator for adding a data point with \a value to the series.
-                \sa add()
-                For example:
-                \snippet ../example/scatter/main.cpp 2
-            */
-            /*!
-                Stream operator for adding a list of points to the series.
-                \sa add()
-            */
-            /*!
-                Replaces the data of the series with the given list of data \a points.
-            */
-            /*!
-                Returns the current list of data points of the series.
-            */
-            /*!
-                Replaces the point at \a index with \a newPoint. Returns true if \a index is a valid position
-                in the series data, false otherwise.
-            */
-            /*!
-                Remove the data point at \a index. Returns true if a point was removed, false if the point
-                at \a index does not exist on the series.
-            */
-            /*!
-                Remove all occurrences of \a point from the series and returns the number of points removed.
-            */
-            /*!
-                Remove all data points from the series.
-            */
-            /*!
-                Returns the index of the data point that is closest to \a coordinate. If several data points
-                are at the same distance from the \a coordinate, returns the last one. If no points exist,
-                returns -1.
-            int QScatterSeries::closestPoint(QPointF coordinate)
-                qreal distance(-1);
-                int pointIndex(-1);
-                for (int i(0); i < d->m_data.count(); i++) {
-                    QPointF dataPoint = d->m_data.at(i);
-                    QPointF difference = dataPoint - coordinate;
-                    if (i == 0 || difference.manhattanLength() <= distance) {
-                        distance = difference.manhattanLength();
-                        pointIndex = i;
-                return pointIndex;
-            */
-            /*!
-                Returns the pen used for drawing markers.
-            */
-            /*!
-                Overrides the default pen used for drawing a marker item with a user defined \a pen. The
-                default pen is defined by chart theme setting.
-                \sa setBrush()
-                \sa QChart::setChartTheme()
-            */
-            /*!
-                Returns the brush used for drawing markers.
-            */
-            /*!
-                Overrides the default brush of the marker items with a user defined \a brush. The default brush
-                is defined by chart theme setting.
-                \sa setPen()
-                \sa QChart::setChartTheme()
-            */
             /*!
                 Returns the shape used for drawing markers.
             */
             QScatterSeries::MarkerShape QScatterSeries::shape() const
             {
                 return (QScatterSeries::MarkerShape) m_shape;
             }
             /*!
                 Overrides the default shape of the marker items with a user defined \a shape. The default shape
                 is defined by chart theme setting.
             */
             void QScatterSeries::setShape(MarkerShape shape)
             {
                 m_shape = shape;
                 emit updated();
             }
             /*!
                 Returns the size of the marker items.
             */
             qreal QScatterSeries::size() const
             {
                 return m_size;
             }
             /*!
                 Set the \a size of the marker items. The default size is 9.0.
             */
             void QScatterSeries::setSize(qreal size)
             {
                 m_size = size;
                 emit updated();
             }
             #include "moc_qscatterseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/scatterseries/qscatterseries.h +1 -3

             #ifndef QSCATTERSERIES_H
             #define QSCATTERSERIES_H
             #include "qchartglobal.h"
             #include "qxyseries.h"
             #include <QRectF>
             #include <QColor>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QScatterSeriesPrivate;
             class QTCOMMERCIALCHART_EXPORT QScatterSeries : public QXYSeries
             {
                 Q_OBJECT
             public:
                 enum MarkerShape {
                     // TODO: to be defined by the graphics design
                     // TODO: marker shapes: "x", star, rectangle, tilted rect, triangle, circle, dot
                     MarkerShapeDefault = 0,
                     MarkerShapeX,
                     MarkerShapeRectangle,
                     MarkerShapeRoundedRectangle,
                     MarkerShapeTiltedRectangle,
                     MarkerShapeTriangle,
                     MarkerShapeCircle
                 };
             public:
                 QScatterSeries(QObject *parent = 0);
                 ~QScatterSeries();
             public: // from QChartSeries
                 QSeriesType type() const { return QSeries::SeriesTypeScatter; }
             public:
-                //int closestPoint(QPointF coordinate);
                 MarkerShape shape() const;
                 void setShape(MarkerShape shape);
                 qreal size() const;
                 void setSize(qreal size);
             signals:
-                void clicked(QPointF coordinate);
+                void clicked(const QPointF& point);
             private:
                 MarkerShape m_shape;
                 qreal m_size;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QSCATTERSERIES_H

src/xychart/qxyseries.cpp +31 -10

             #include "qxyseries.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QXYSeries
                 \brief The QXYSeries class is a base class for line, spline and scatter series.
             */
             /*!
-                \fn virtual QSeriesType QXYSeries::type() const
-                \brief Returns type of series.
-                \sa QSeries, QSeriesType
-            */
-            /*!
                \fn QPen QXYSeries::pen() const
                \brief  Returns pen used to draw points for series.
                 \sa setPen()
             */
             /*!
                \fn QBrush QXYSeries::brush() const
                \brief  Returns brush used to draw points for series.
                 \sa setBrush()
             */
             /*!
                 \fn void QXYSeries::pointReplaced(int index)
                 \brief \internal \a index
             */
             /*!
                 \fn void QXYSeries::pointAdded(int index)
                 \brief \internal \a index
             */
             /*!
                 \fn void QXYSeries::pointRemoved(int index)
                 \brief \internal \a index
             */
             /*!
                 \fn void QXYSeries::updated()
                 \brief \internal
             */
             /*!
                 Constructs empty series object which is a child of \a parent.
                 When series object is added to QChartView or QChart instance ownerships is transfered.
             */
             QXYSeries::QXYSeries(QObject* parent):QSeries(parent)
             {
             }
             /*!
                 Destroys the object. Series added to QChartView or QChart instances are owned by those,
                 and are deleted when mentioned object are destroyed.
             */
             QXYSeries::~QXYSeries()
             {
             }
             /*!
                 Adds data point \a x \a y to the series. Points are connected with lines on the chart.
              */
             void QXYSeries::add(qreal x,qreal y)
             {
                 Q_ASSERT(m_x.size() == m_y.size());
                 m_x<<x;
                 m_y<<y;
                 emit pointAdded(m_x.size()-1);
             }
             /*!
                This is an overloaded function.
                Adds data \a point to the series. Points are connected with lines on the chart.
              */
             void QXYSeries::add(const QPointF& point)
             {
                 add(point.x(),point.y());
             }
             /*!
+               This is an overloaded function.
+               Adds list of data \a points to the series. Points are connected with lines on the chart.
+             */
+            void QXYSeries::add(const QList<QPointF> points)
+            {
+                foreach(const QPointF& point , points) {
+                    add(point.x(),point.y());
+                }
+            }
+            /*!
               Modifies \a y value for given \a x a value.
             */
             void QXYSeries::replace(qreal x,qreal y)
             {
                 int index = m_x.indexOf(x);
                 m_x[index]=x;
                 m_y[index]=y;
                 emit pointReplaced(index);
             }
             /*!
               This is an overloaded function.
               Replaces current y value of for given \a point x value with \a point y value.
             */
             void QXYSeries::replace(const QPointF& point)
             {
                replace(point.x(),point.y());
             }
             /*!
               Removes current \a x and y value.
             */
             void QXYSeries::remove(qreal x)
             {
                 int index = m_x.indexOf(x);
                 emit pointRemoved(index);
                 m_x.remove(index);
                 m_y.remove(index);
             }
             /*!
               Removes current \a point x value. Note \a point y value is ignored.
             */
             void QXYSeries::remove(const QPointF& point)
             {
                 remove(point.x());
             }
             /*!
-              Clears all the data.
+               Removes all data points from the series.
             */
-            void QXYSeries::clear()
+            void QXYSeries::removeAll()
             {
                 m_x.clear();
                 m_y.clear();
             }
             /*!
                 \internal \a pos
             */
             qreal QXYSeries::x(int pos) const
             {
                return m_x.at(pos);
             }
             /*!
                 \internal \a pos
             */
             qreal QXYSeries::y(int pos) const
             {
                return m_y.at(pos);
             }
             /*!
                 Returns number of data points within series.
             */
             int QXYSeries::count() const
             {
             	Q_ASSERT(m_x.size() == m_y.size());
             	return m_x.size();
             }
             /*!
-                Sets \a pen used for drawing points on the chart.
+                Sets \a pen used for drawing points on the chart. If the pen is not defined, the
+                pen from chart theme is used.
+                \sa QChart::setChartTheme()
             */
             void QXYSeries::setPen(const QPen& pen)
             {
                 if(pen!=m_pen){
                     m_pen=pen;
                     emit updated();
                 }
             }
             /*!
-                Sets \a brush used for drawing points on the chart.
+                Sets \a brush used for drawing points on the chart. If the brush is not defined, brush
+                from chart theme setting is used.
+                \sa QChart::setChartTheme()
             */
             void QXYSeries::setBrush(const QBrush& brush)
             {
                 if(brush!=m_brush){
                     m_brush=brush;
                     emit updated();
                 }
             }
             /*!
                 Stream operator for adding a data \a point to the series.
                 \sa add()
             */
             QXYSeries& QXYSeries::operator<< (const QPointF &point)
             {
                 add(point);
                 return *this;
             }
+            /*!
+                Stream operator for adding a list of \a points to the series.
+                \sa add()
+            */
+            QXYSeries& QXYSeries::operator<< (const QList<QPointF> points)
+            {
+                add(points);
+                return *this;
+            }
             #include "moc_qxyseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/xychart/qxyseries.h +3 -8

             #ifndef QXYSERIES_H_
             #define QXYSERIES_H_
             #include "qchartglobal.h"
             #include "qseries.h"
             #include <QDebug>
             #include <QPen>
             #include <QBrush>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QTCOMMERCIALCHART_EXPORT QXYSeries : public QSeries
             {
             	Q_OBJECT
             protected:
             	QXYSeries(QObject* parent=0);
             	virtual ~QXYSeries();
             public:
             	void add(qreal x, qreal y);
             	void add(const QPointF& point);
+                void add(const QList<QPointF> points);
             	void replace(qreal x,qreal y);
             	void replace(const QPointF& point);
             	void remove(qreal x);
             	void remove(const QPointF& point);
-            	void clear();
+            	void removeAll();
             	int count() const;
             	qreal x(int pos) const;
             	qreal y(int pos) const;
             	QXYSeries& operator << (const QPointF &point);
-            	/*
+            	QXYSeries& operator << (const QList<QPointF> points);
-            	void add(QList<QPointF> points);
-                void setData(QList<QPointF> points);
-                QScatterSeries& operator << (const QPointF &value);
-                QScatterSeries& operator << (QList<QPointF> points);
-               int removeAll(QPointF point);
-            	*/
             	void setPen(const QPen& pen);
             	QPen pen() const {return m_pen;}
                 void setBrush(const QBrush& pen);
                 QBrush brush() const {return m_brush;}
             signals:
             	void updated();
             	void pointReplaced(int index);
             	void pointRemoved(int index);
             	void pointAdded(int index);
             protected:
             	QVector<qreal> m_x;
             	QVector<qreal> m_y;
             	QPen m_pen;
             	QBrush m_brush;
             };
             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