diff options
Diffstat (limited to 'src/charts/areachart/qareaseries.cpp')
| -rw-r--r-- | src/charts/areachart/qareaseries.cpp | 657 |
1 files changed, 657 insertions, 0 deletions
diff --git a/src/charts/areachart/qareaseries.cpp b/src/charts/areachart/qareaseries.cpp new file mode 100644 index 00000000..e2a2ea2f --- /dev/null +++ b/src/charts/areachart/qareaseries.cpp @@ -0,0 +1,657 @@ +/**************************************************************************** +** +** Copyright (C) 2014 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 Enterprise Charts Add-on. +** +** $QT_BEGIN_LICENSE$ +** Licensees holding valid Qt Enterprise licenses may use this file in +** accordance with the Qt Enterprise 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 "qareaseries.h" +#include "qareaseries_p.h" +#include "qlineseries.h" +#include "areachartitem_p.h" +#include "abstractdomain_p.h" +#include "chartdataset_p.h" +#include "charttheme_p.h" +#include "qvalueaxis.h" +#include "qarealegendmarker.h" +#include "qchart_p.h" + +QT_CHARTS_BEGIN_NAMESPACE + +/*! + \class QAreaSeries + \inmodule Qt Charts + \brief The QAreaSeries class is used for making area charts. + + \mainclass + + An area chart is used to show quantitative data. It is based on line chart, in the way that area between axis and the line + is emphasized with color. Since the area chart is based on line chart, QAreaSeries constructor needs QLineSeries instance, + which defines "upper" boundary of the area. "Lower" boundary is defined by default by axis X. Instead of axis X "lower" boundary can be specified by other line. + In that case QAreaSeries should be initiated with two QLineSeries instances. Please note terms "upper" and "lower" boundary can be misleading in cases + where "lower" boundary had bigger values than the "upper" one, however the main point that area between these two boundary lines will be filled. + + See the \l {AreaChart Example} {area chart example} to learn how to create a simple area chart. + \image examples_areachart.png +*/ + +/*! + \qmltype AreaSeries + \instantiates QAreaSeries + \inqmlmodule QtCharts + + \inherits AbstractSeries + + \brief The AreaSeries type is used for making area charts. + + The following QML shows how to create a simple area chart: + \snippet qmlchart/qml/qmlchart/View4.qml 1 + \beginfloatleft + \image examples_qmlchart4.png + \endfloat + \clearfloat +*/ + +/*! + \property QAreaSeries::upperSeries + \brief The upper one of the two line series used to define area series boundaries. +*/ +/*! + \qmlproperty LineSeries AreaSeries::upperSeries + The upper one of the two line series used to define area series boundaries. +*/ + +/*! + \property QAreaSeries::lowerSeries + The lower one of the two line series used to define are series boundaries. Note if + QAreaSeries was constructed without a\ lowerSeries this is null. +*/ +/*! + \qmlproperty LineSeries AreaSeries::lowerSeries + The lower one of the two line series used to define are series boundaries. Note if + AreaSeries was constructed without a\ lowerSeries this is null. +*/ + +/*! + \property QAreaSeries::color + Fill (brush) color of the series. This is a convenience property for modifying the color of brush. + \sa QAreaSeries::brush() +*/ +/*! + \qmlproperty color AreaSeries::color + Fill (brush) color of the series. +*/ + +/*! + \property QAreaSeries::borderColor + Line (pen) color of the series. This is a convenience property for modifying the color of pen. + \sa QAreaSeries::pen() +*/ +/*! + \qmlproperty color AreaSeries::borderColor + Line (pen) color of the series. +*/ + +/*! + \qmlproperty real AreaSeries::borderWidth + The width of the border line. By default the width is 2.0. +*/ + +/*! + \fn QPen QAreaSeries::pen() const + \brief Returns the pen used to draw line for this series. + \sa setPen() +*/ + +/*! + \fn QPen QAreaSeries::brush() const + \brief Returns the brush used to draw line for this series. + \sa setBrush() +*/ + +/*! + \qmlproperty QString AreaSeries::brushFilename + The name of the file used as a brush image for the series. +*/ + +/*! + \fn void QAreaSeries::colorChanged(QColor color) + \brief Signal is emitted when the fill (brush) color has changed to \a color. +*/ +/*! + \qmlsignal AreaSeries::onColorChanged(color color) + Signal is emitted when the fill (brush) color has changed to \a color. +*/ + +/*! + \fn void QAreaSeries::borderColorChanged(QColor color) + \brief Signal is emitted when the line (pen) color has changed to \a color. +*/ +/*! + \qmlsignal AreaSeries::onBorderColorChanged(color color) + Signal is emitted when the line (pen) color has changed to \a color. +*/ + +/*! + \fn void QAreaSeries::clicked(const QPointF& point) + \brief Signal is emitted when user clicks the \a point on area chart. +*/ +/*! + \qmlsignal AreaSeries::onClicked(QPointF point) + Signal is emitted when user clicks the \a point on area chart. +*/ + +/*! + \fn void QAreaSeries::hovered(const QPointF &point, bool state) + This signal is emitted when user has hovered over or away from the series. \a point shows the origin (coordinate) + of the hover event. \a state is true when user has hovered over the series and false when hover has moved away from + the series. +*/ +/*! + \qmlsignal AreaSeries::onHovered(point point, bool state) + This signal is emitted when user has hovered over or away from the series. \a point shows the origin (coordinate) + of the hover event. \a state is true when user has hovered over the series and false when hover has moved away from + the series. +*/ + +/*! + \fn void QAreaSeries::selected() + The signal is emitted if the user selects/deselects the XY series. The logic for maintaining selections should be + implemented by the user of QAreaSeries API. +*/ +/*! + \qmlsignal AreaSeries::onSelected() + The signal is emitted if the user selects/deselects the XY series. The logic for maintaining selections should be + implemented by the user of AreaSeries API. +*/ + +/*! + \fn void QAreaSeriesPrivate::updated() + \brief \internal +*/ + +/*! + \property QAreaSeries::pointLabelsFormat + The \a format used for showing labels with series points. + + QAreaSeries supports the following format tags: + \table + \row + \li @xPoint \li The x value of the data point + \row + \li @yPoint \li The y value of the data point + \endtable + + For example, the following usage of the format tags would produce labels that have the data + point (x, y) shown inside brackets separated by a comma: + \code + series->setPointLabelsFormat("(@xPoint, @yPoint)"); + \endcode + + By default, the labels format is set to '@xPoint, @yPoint'. The labels are shown on the plot + area, labels on the edge of the plot area are cut. If the points are close to each other the + labels may overlap. + + \sa QAreaSeries::pointLabelsVisible, QAreaSeries::pointLabelsFont, QAreaSeries::pointLabelsColor +*/ +/*! + \qmlproperty string AreaSeries::pointLabelsFormat + The \a format used for showing labels with series points. + + \sa QAreaSeries::pointLabelsFormat, pointLabelsVisible, pointLabelsFont, pointLabelsColor +*/ +/*! + \fn void QAreaSeries::pointLabelsFormatChanged(const QString &format) + Signal is emitted when the \a format of data point labels is changed. +*/ +/*! + \qmlsignal AreaSeries::onPointLabelsFormatChanged(string format) + Signal is emitted when the \a format of data point labels is changed. +*/ + +/*! + \property QAreaSeries::pointLabelsVisible + Defines the visibility for data point labels. False by default. + + \sa QAreaSeries::pointLabelsFormat +*/ +/*! + \qmlproperty bool AreaSeries::pointLabelsVisible + Defines the visibility for data point labels. + + \sa pointLabelsFormat +*/ +/*! + \fn void QAreaSeries::pointLabelsVisibilityChanged(bool visible) + The visibility of the data point labels is changed to \a visible. +*/ +/*! + \qmlsignal AreaSeries::onPointLabelsVisibilityChanged(bool visible) + The visibility of the data point labels is changed to \a visible. +*/ + +/*! + \property QAreaSeries::pointLabelsFont + Defines the font used for data point labels. + + \sa QAreaSeries::pointLabelsFormat +*/ +/*! + \qmlproperty font AreaSeries::pointLabelsFont + Defines the font used for data point labels. + + \sa pointLabelsFormat +*/ +/*! + \fn void QAreaSeries::pointLabelsFontChanged(const QFont &font); + The font used for data point labels is changed to \a font. +*/ +/*! + \qmlsignal AreaSeries::onPointLabelsFontChanged(Font font) + The font used for data point labels is changed to \a font. +*/ + +/*! + \property QAreaSeries::pointLabelsColor + Defines the color used for data point labels. By default, the color is the color of the brush + defined in theme for labels. + + \sa QAreaSeries::pointLabelsFormat +*/ +/*! + \qmlproperty font AreaSeries::pointLabelsColor + Defines the color used for data point labels. By default, the color is the color of the brush + defined in theme for labels. + + \sa pointLabelsFormat +*/ +/*! + \fn void QAreaSeries::pointLabelsColorChanged(const QColor &color); + The color used for data point labels is changed to \a color. +*/ +/*! + \qmlsignal AreaSeries::onPointLabelsColorChanged(Color color) + The color used for data point labels is changed to \a color. +*/ + +/*! + Constructs area series object which is a child of \a upperSeries. Area will be spanned between \a + upperSeries line and \a lowerSeries line. If no \a lowerSeries is passed to constructor, area is specified by axis x (y=0) instead. + When series object is added to QChartView or QChart instance ownerships is transferred. +*/ +QAreaSeries::QAreaSeries(QLineSeries *upperSeries, QLineSeries *lowerSeries) + : QAbstractSeries(*new QAreaSeriesPrivate(upperSeries, lowerSeries, this), upperSeries) +{ +} + +/*! + Constructs area series object without upper or lower series with \a parent object. +*/ +QAreaSeries::QAreaSeries(QObject *parent) + : QAbstractSeries(*new QAreaSeriesPrivate(0, 0, this), parent) +{ +} + +/*! + Destroys the object. +*/ +QAreaSeries::~QAreaSeries() +{ + Q_D(QAreaSeries); + if (d->m_chart) + d->m_chart->removeSeries(this); +} + +/*! + Returns QAbstractSeries::SeriesTypeArea. +*/ +QAbstractSeries::SeriesType QAreaSeries::type() const +{ + return QAbstractSeries::SeriesTypeArea; +} + +/*! + Sets the \a series that is to be used as the area chart upper series. +*/ +void QAreaSeries::setUpperSeries(QLineSeries *series) +{ + Q_D(QAreaSeries); + if (d->m_upperSeries != series) + d->m_upperSeries = series; +} + +QLineSeries *QAreaSeries::upperSeries() const +{ + Q_D(const QAreaSeries); + return d->m_upperSeries; +} + +/*! + Sets the \a series that is to be used as the area chart lower series. +*/ +void QAreaSeries::setLowerSeries(QLineSeries *series) +{ + Q_D(QAreaSeries); + d->m_lowerSeries = series; +} + +QLineSeries *QAreaSeries::lowerSeries() const +{ + Q_D(const QAreaSeries); + return d->m_lowerSeries; +} + +/*! + Sets \a pen used for drawing area outline. +*/ +void QAreaSeries::setPen(const QPen &pen) +{ + Q_D(QAreaSeries); + if (d->m_pen != pen) { + d->m_pen = pen; + emit d->updated(); + } +} + +QPen QAreaSeries::pen() const +{ + Q_D(const QAreaSeries); + if (d->m_pen == QChartPrivate::defaultPen()) + return QPen(); + else + return d->m_pen; +} + +/*! + Sets \a brush used for filling the area. +*/ +void QAreaSeries::setBrush(const QBrush &brush) +{ + Q_D(QAreaSeries); + if (d->m_brush != brush) { + bool emitColorChanged = brush.color() != d->m_brush.color(); + d->m_brush = brush; + emit d->updated(); + if (emitColorChanged) + emit colorChanged(brush.color()); + } +} + +QBrush QAreaSeries::brush() const +{ + Q_D(const QAreaSeries); + if (d->m_brush == QChartPrivate::defaultBrush()) + return QBrush(); + else + return d->m_brush; +} + +void QAreaSeries::setColor(const QColor &color) +{ + QBrush b = brush(); + if (b == QBrush()) + b.setStyle(Qt::SolidPattern); + b.setColor(color); + setBrush(b); +} + +QColor QAreaSeries::color() const +{ + return brush().color(); +} + +void QAreaSeries::setBorderColor(const QColor &color) +{ + QPen p = pen(); + if (p.color() != color) { + p.setColor(color); + setPen(p); + emit borderColorChanged(color); + } +} + +QColor QAreaSeries::borderColor() const +{ + return pen().color(); +} + +/*! + Sets if data points are \a visible and should be drawn on line. +*/ +void QAreaSeries::setPointsVisible(bool visible) +{ + Q_D(QAreaSeries); + if (d->m_pointsVisible != visible) { + d->m_pointsVisible = visible; + emit d->updated(); + } +} + +/*! + Returns if the points are drawn for this series. + \sa setPointsVisible() +*/ +bool QAreaSeries::pointsVisible() const +{ + Q_D(const QAreaSeries); + return d->m_pointsVisible; +} + +void QAreaSeries::setPointLabelsFormat(const QString &format) +{ + Q_D(QAreaSeries); + if (d->m_pointLabelsFormat != format) { + d->m_pointLabelsFormat = format; + emit pointLabelsFormatChanged(format); + } +} + +QString QAreaSeries::pointLabelsFormat() const +{ + Q_D(const QAreaSeries); + return d->m_pointLabelsFormat; +} + +void QAreaSeries::setPointLabelsVisible(bool visible) +{ + Q_D(QAreaSeries); + if (d->m_pointLabelsVisible != visible) { + d->m_pointLabelsVisible = visible; + emit pointLabelsVisibilityChanged(visible); + } +} + +bool QAreaSeries::pointLabelsVisible() const +{ + Q_D(const QAreaSeries); + return d->m_pointLabelsVisible; +} + +void QAreaSeries::setPointLabelsFont(const QFont &font) +{ + Q_D(QAreaSeries); + if (d->m_pointLabelsFont != font) { + d->m_pointLabelsFont = font; + emit pointLabelsFontChanged(font); + } +} + +QFont QAreaSeries::pointLabelsFont() const +{ + Q_D(const QAreaSeries); + return d->m_pointLabelsFont; +} + +void QAreaSeries::setPointLabelsColor(const QColor &color) +{ + Q_D(QAreaSeries); + if (d->m_pointLabelsColor != color) { + d->m_pointLabelsColor = color; + emit pointLabelsColorChanged(color); + } +} + +QColor QAreaSeries::pointLabelsColor() const +{ + Q_D(const QAreaSeries); + if (d->m_pointLabelsColor == QChartPrivate::defaultPen().color()) + return QPen().color(); + else + return d->m_pointLabelsColor; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +QAreaSeriesPrivate::QAreaSeriesPrivate(QLineSeries *upperSeries, QLineSeries *lowerSeries, QAreaSeries *q) + : QAbstractSeriesPrivate(q), + m_brush(QChartPrivate::defaultBrush()), + m_pen(QChartPrivate::defaultPen()), + m_upperSeries(upperSeries), + m_lowerSeries(lowerSeries), + m_pointsVisible(false), + m_pointLabelsFormat(QLatin1String("@xPoint, @yPoint")), + m_pointLabelsVisible(false), + m_pointLabelsFont(QChartPrivate::defaultFont()), + m_pointLabelsColor(QChartPrivate::defaultPen().color()) +{ +} + +void QAreaSeriesPrivate::initializeDomain() +{ + Q_Q(QAreaSeries); + + qreal minX(domain()->minX()); + qreal minY(domain()->minY()); + qreal maxX(domain()->maxX()); + qreal maxY(domain()->maxY()); + + QLineSeries *upperSeries = q->upperSeries(); + QLineSeries *lowerSeries = q->lowerSeries(); + + if (upperSeries) { + const QList<QPointF>& points = upperSeries->points(); + + for (int i = 0; i < points.count(); i++) { + qreal x = points[i].x(); + qreal y = points[i].y(); + minX = qMin(minX, x); + minY = qMin(minY, y); + maxX = qMax(maxX, x); + maxY = qMax(maxY, y); + } + } + if (lowerSeries) { + + const QList<QPointF>& points = lowerSeries->points(); + + for (int i = 0; i < points.count(); i++) { + qreal x = points[i].x(); + qreal y = points[i].y(); + minX = qMin(minX, x); + minY = qMin(minY, y); + maxX = qMax(maxX, x); + maxY = qMax(maxY, y); + } + } + + domain()->setRange(minX, maxX, minY, maxY); +} + +void QAreaSeriesPrivate::initializeGraphics(QGraphicsItem* parent) +{ + Q_Q(QAreaSeries); + AreaChartItem *area = new AreaChartItem(q,parent); + m_item.reset(area); + QAbstractSeriesPrivate::initializeGraphics(parent); +} +void QAreaSeriesPrivate::initializeAnimations(QChart::AnimationOptions options) +{ + Q_Q(QAreaSeries); + AreaChartItem *area = static_cast<AreaChartItem *>(m_item.data()); + + if (q->upperSeries() && area->upperLineItem()->animation()) + area->upperLineItem()->animation()->stopAndDestroyLater(); + if (q->lowerSeries() && area->lowerLineItem()->animation()) + area->lowerLineItem()->animation()->stopAndDestroyLater(); + + if (options.testFlag(QChart::SeriesAnimations)) { + area->upperLineItem()->setAnimation(new XYAnimation(area->upperLineItem())); + if (q->lowerSeries()) + area->lowerLineItem()->setAnimation(new XYAnimation(area->lowerLineItem())); + } else { + if (q->upperSeries()) + area->upperLineItem()->setAnimation(0); + if (q->lowerSeries()) + area->lowerLineItem()->setAnimation(0); + } + QAbstractSeriesPrivate::initializeAnimations(options); +} + +QList<QLegendMarker*> QAreaSeriesPrivate::createLegendMarkers(QLegend* legend) +{ + Q_Q(QAreaSeries); + QList<QLegendMarker*> list; + return list << new QAreaLegendMarker(q,legend); +} + + +void QAreaSeriesPrivate::initializeAxes() +{ + +} + +QAbstractAxis::AxisType QAreaSeriesPrivate::defaultAxisType(Qt::Orientation orientation) const +{ + Q_UNUSED(orientation); + return QAbstractAxis::AxisTypeValue; +} + +QAbstractAxis* QAreaSeriesPrivate::createDefaultAxis(Qt::Orientation orientation) const +{ + Q_UNUSED(orientation); + return new QValueAxis; +} + +void QAreaSeriesPrivate::initializeTheme(int index, ChartTheme* theme, bool forced) +{ + Q_Q(QAreaSeries); + + const QList<QGradient> gradients = theme->seriesGradients(); + const QList<QColor> colors = theme->seriesColors(); + + if (forced || QChartPrivate::defaultPen() == m_pen) { + QPen pen; + pen.setColor(ChartThemeManager::colorAt(gradients.at(index % gradients.size()), 0.0)); + pen.setWidthF(2); + q->setPen(pen); + } + + if (forced || QChartPrivate::defaultBrush() == m_brush) { + QBrush brush(colors.at(index % colors.size())); + q->setBrush(brush); + } + + if (forced || QChartPrivate::defaultPen().color() == m_pointLabelsColor) { + QColor color = theme->labelBrush().color(); + q->setPointLabelsColor(color); + } +} + + +#include "moc_qareaseries.cpp" +#include "moc_qareaseries_p.cpp" + +QT_CHARTS_END_NAMESPACE |