declarativechart.cpp
1054 lines
| 33.2 KiB
| text/x-c
|
CppLexer
|
r830 | /**************************************************************************** | ||
** | ||||
|
r2688 | ** Copyright (C) 2014 Digia Plc | ||
|
r830 | ** All rights reserved. | ||
** For any questions to Digia, please use contact form at http://qt.digia.com | ||||
** | ||||
|
r2574 | ** This file is part of the Qt Enterprise Charts Add-on. | ||
|
r830 | ** | ||
** $QT_BEGIN_LICENSE$ | ||||
|
r2574 | ** Licensees holding valid Qt Enterprise licenses may use this file in | ||
** accordance with the Qt Enterprise License Agreement provided with the | ||||
|
r830 | ** 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$ | ||||
** | ||||
****************************************************************************/ | ||||
|
r1 | #include "declarativechart.h" | ||
|
r660 | #include <QPainter> | ||
|
r1240 | #include "declarativelineseries.h" | ||
#include "declarativeareaseries.h" | ||||
#include "declarativebarseries.h" | ||||
#include "declarativepieseries.h" | ||||
#include "declarativesplineseries.h" | ||||
|
r2548 | #include "declarativeboxplotseries.h" | ||
|
r1240 | #include "declarativescatterseries.h" | ||
|
r1810 | #include "qbarcategoryaxis.h" | ||
|
r1813 | #include "qvalueaxis.h" | ||
|
r2493 | #include "qlogvalueaxis.h" | ||
|
r1818 | #include "qcategoryaxis.h" | ||
|
r1813 | #include "qabstractseries_p.h" | ||
|
r1928 | #include "declarativemargins.h" | ||
|
r2273 | #include "chartdataset_p.h" | ||
|
r2296 | #include "declarativeaxes.h" | ||
|
r2068 | #include "qchart_p.h" | ||
|
r2483 | #include "qpolarchart.h" | ||
|
r1 | |||
|
r1867 | #ifndef QT_ON_ARM | ||
#include "qdatetimeaxis.h" | ||||
#endif | ||||
|
r2495 | #ifdef CHARTS_FOR_QUICK2 | ||
#include <QGraphicsSceneMouseEvent> | ||||
#include <QGraphicsSceneHoverEvent> | ||||
#include <QApplication> | ||||
|
r2505 | #include <QTimer> | ||
|
r2506 | #include <QThread> | ||
|
r2495 | #endif | ||
|
r120 | QTCOMMERCIALCHART_BEGIN_NAMESPACE | ||
|
r2639 | #ifdef QDOC_QT5 | ||
|
r1443 | /*! | ||
|
r2639 | \qmltype ChartView | ||
\instantiates DeclarativeChart | ||||
\inqmlmodule QtCommercial.Chart | ||||
|
r1443 | |||
|
r2650 | \include doc/src/chartview.qdocinc | ||
|
r2639 | */ | ||
#else | ||||
/*! | ||||
\qmlclass ChartView DeclarativeChart | ||||
|
r1443 | |||
|
r2639 | \include ../doc/src/chartview.qdocinc | ||
|
r1443 | */ | ||
|
r2639 | #endif | ||
|
r1443 | |||
|
r1462 | /*! | ||
\qmlproperty Theme ChartView::theme | ||||
Theme defines the visual appearance of the chart, including for example colors, fonts, line | ||||
widths and chart background. | ||||
*/ | ||||
/*! | ||||
|
r2113 | \qmlproperty Animation ChartView::animationOptions | ||
|
r1462 | Animation configuration of the chart. One of ChartView.NoAnimation, ChartView.GridAxisAnimations, | ||
ChartView.SeriesAnimations or ChartView.AllAnimations. | ||||
*/ | ||||
|
r1517 | /*! | ||
\qmlproperty Font ChartView::titleFont | ||||
|
r2639 | The title font of the chart. | ||
|
r1517 | |||
|
r2639 | See the Qt documentation for more details of Font. | ||
|
r1517 | */ | ||
|
r1462 | /*! | ||
\qmlproperty string ChartView::title | ||||
The title of the chart, shown on top of the chart. | ||||
|
r1473 | \sa ChartView::titleColor | ||
|
r1462 | */ | ||
/*! | ||||
|
r2113 | \qmlproperty color ChartView::titleColor | ||
|
r1462 | The color of the title text. | ||
*/ | ||||
|
r1473 | /*! | ||
\qmlproperty Legend ChartView::legend | ||||
The legend of the chart. Legend lists all the series, pie slices and bar sets added on the chart. | ||||
*/ | ||||
/*! | ||||
\qmlproperty int ChartView::count | ||||
The count of series added to the chart. | ||||
*/ | ||||
/*! | ||||
\qmlproperty color ChartView::backgroundColor | ||||
The color of the chart's background. By default background color is defined by chart theme. | ||||
\sa ChartView::theme | ||||
*/ | ||||
|
r2549 | /*! | ||
\qmlproperty real ChartView::backgroundRoundness | ||||
The diameter of the rounding cirle at the corners of the chart background. | ||||
*/ | ||||
|
r2498 | /*! | ||
\qmlproperty color ChartView::plotAreaColor | ||||
The color of the background of the chart's plot area. By default plot area background uses chart's | ||||
background color. | ||||
\sa ChartView::backgroundColor | ||||
*/ | ||||
|
r1473 | /*! | ||
\qmlproperty bool ChartView::dropShadowEnabled | ||||
The chart's border drop shadow. Set to true to enable drop shadow. | ||||
*/ | ||||
|
r1524 | /*! | ||
\qmlproperty real ChartView::topMargin | ||||
|
r2634 | Deprecated; use margins instead. | ||
|
r1524 | */ | ||
/*! | ||||
\qmlproperty real ChartView::bottomMargin | ||||
|
r2634 | Deprecated; use margins instead. | ||
|
r1524 | */ | ||
/*! | ||||
\qmlproperty real ChartView::leftMargin | ||||
|
r2634 | Deprecated; use margins instead. | ||
|
r1524 | */ | ||
/*! | ||||
\qmlproperty real ChartView::rightMargin | ||||
|
r2634 | Deprecated; use margins instead. | ||
|
r1928 | */ | ||
/*! | ||||
\qmlproperty Margins ChartView::minimumMargins | ||||
|
r2369 | Deprecated; use margins instead. | ||
|
r1929 | The minimum margins allowed between the outer bounds and the plotArea of the ChartView. Margins | ||
area of ChartView is used for drawing title, axes and legend. Please note that setting the | ||||
properties of minimumMargins may be bigger than the defined value, depending on other ChartView | ||||
properties that affect it's layout. If you need to know the actual plotting area used at any | ||||
given time, you can check ChartView::plotArea instead. | ||||
*/ | ||||
/*! | ||||
\qmlproperty rect ChartView::plotArea | ||||
The area on the ChartView that is used for drawing series. This is the ChartView rect without the | ||||
margins. | ||||
\sa ChartView::minimumMargins | ||||
|
r1524 | */ | ||
|
r2369 | /*! | ||
\qmlproperty Margins ChartView::margins | ||||
The minimum margins allowed between the outer bounds and the plotArea of the ChartView. Margins | ||||
area of ChartView is used for drawing title, axes and legend. | ||||
*/ | ||||
|
r2707 | /*! | ||
\qmlproperty bool ChartView::localizeNumbers | ||||
\since QtCharts 2.0 | ||||
When \c{true}, all generated numbers appearing in various series and axis labels will be | ||||
localized using the default QLocale of the application, which defaults to the system locale. | ||||
When \c{false}, the "C" locale is always used. | ||||
|
r2708 | Defaults to \c{true}. | ||
|
r2707 | */ | ||
|
r1521 | /*! | ||
\qmlmethod AbstractSeries ChartView::series(int index) | ||||
Returns the series with \a index on the chart. This allows you to loop through the series of a chart together with | ||||
the count property of the chart. | ||||
*/ | ||||
/*! | ||||
\qmlmethod AbstractSeries ChartView::series(string name) | ||||
Returns the first series on the chart with \a name. If there is no series with that name, returns null. | ||||
*/ | ||||
/*! | ||||
|
r1960 | \qmlmethod AbstractSeries ChartView::createSeries(SeriesType type, string name, AbstractAxis axisX, AbstractAxis axisY) | ||
Creates a series object of \a type to the chart with name \a name, optional axis \a axisX and | ||||
optional axis \a axisY. For example: | ||||
|
r1521 | \code | ||
|
r1960 | // lineSeries is a LineSeries object that has already been added to the ChartView; re-use it's axes | ||
var myAxisX = chartView.axisX(lineSeries); | ||||
var myAxisY = chartView.axisY(lineSeries); | ||||
var scatter = chartView.createSeries(ChartView.SeriesTypeScatter, "scatter series", myAxisX, myAxisY); | ||||
|
r1521 | \endcode | ||
*/ | ||||
|
r1948 | /*! | ||
\qmlmethod ChartView::removeSeries(AbstractSeries series) | ||||
Removes the \a series from the chart. The series object is also destroyed. | ||||
*/ | ||||
/*! | ||||
\qmlmethod ChartView::removeAllSeries() | ||||
Removes all series from the chart. All the series objects are also destroyed. | ||||
*/ | ||||
|
r1960 | /*! | ||
|
r2068 | \qmlmethod Axis ChartView::axisX(AbstractSeries series) | ||
|
r1960 | The x-axis of the series. | ||
*/ | ||||
|
r1462 | /*! | ||
|
r2068 | \qmlmethod Axis ChartView::axisY(AbstractSeries series) | ||
|
r1960 | The y-axis of the series. | ||
|
r1521 | */ | ||
/*! | ||||
\qmlmethod ChartView::zoomY(real factor) | ||||
Zooms in by \a factor on the center of the chart. | ||||
*/ | ||||
/*! | ||||
\qmlmethod ChartView::scrollLeft(real pixels) | ||||
Scrolls to left by \a pixels. This is a convenience function that suits for example for key navigation. | ||||
*/ | ||||
/*! | ||||
\qmlmethod ChartView::scrollRight(real pixels) | ||||
Scrolls to right by \a pixels. This is a convenience function that suits for example for key navigation. | ||||
*/ | ||||
/*! | ||||
\qmlmethod ChartView::scrollUp(real pixels) | ||||
Scrolls up by \a pixels. This is a convenience function that suits for example for key navigation. | ||||
*/ | ||||
/*! | ||||
\qmlmethod ChartView::scrollDown(real pixels) | ||||
Scrolls down by \a pixels. This is a convenience function that suits for example for key navigation. | ||||
|
r1462 | */ | ||
|
r1531 | /*! | ||
|
r1946 | \qmlsignal ChartView::onPlotAreaChanged(rect plotArea) | ||
The plot area of the chart has changed. This may happen for example, if you modify minimumMargins | ||||
or if you resize the chart, or if you modify font size related properties of the legend or chart | ||||
title. | ||||
|
r1531 | */ | ||
|
r2068 | /*! | ||
\qmlsignal ChartView::seriesAdded(AbstractSeries series) | ||||
The \a series has been added to the chart. | ||||
*/ | ||||
/*! | ||||
\qmlsignal ChartView::seriesRemoved(AbstractSeries series) | ||||
The \a series has been removed from the chart. Please note that \a series is no longer a valid | ||||
object after the signal handler has completed. | ||||
*/ | ||||
|
r2488 | DeclarativeChart::DeclarativeChart(QDECLARATIVE_ITEM *parent) | ||
: QDECLARATIVE_PAINTED_ITEM(parent) | ||||
|
r1 | { | ||
|
r2483 | initChart(QChart::ChartTypeCartesian); | ||
} | ||||
|
r2488 | DeclarativeChart::DeclarativeChart(QChart::ChartType type, QDECLARATIVE_ITEM *parent) | ||
: QDECLARATIVE_PAINTED_ITEM(parent) | ||||
|
r2483 | { | ||
initChart(type); | ||||
} | ||||
void DeclarativeChart::initChart(QChart::ChartType type) | ||||
{ | ||||
|
r2488 | #ifdef CHARTS_FOR_QUICK2 | ||
|
r2505 | m_currentSceneImage = 0; | ||
|
r2506 | m_guiThreadId = QThread::currentThreadId(); | ||
m_paintThreadId = 0; | ||||
|
r2594 | m_updatePending = false; | ||
|
r2505 | |||
|
r2488 | if (type == QChart::ChartTypePolar) | ||
m_chart = new QPolarChart(); | ||||
else | ||||
m_chart = new QChart(); | ||||
m_scene = new QGraphicsScene(this); | ||||
m_scene->addItem(m_chart); | ||||
setAntialiasing(QQuickItem::antialiasing()); | ||||
|
r2505 | connect(m_scene, SIGNAL(changed(QList<QRectF>)), this, SLOT(sceneChanged(QList<QRectF>))); | ||
|
r2488 | connect(this, SIGNAL(antialiasingChanged(bool)), this, SLOT(handleAntialiasingChanged(bool))); | ||
|
r2495 | |||
setAcceptedMouseButtons(Qt::AllButtons); | ||||
setAcceptHoverEvents(true); | ||||
|
r2488 | #else | ||
|
r2483 | if (type == QChart::ChartTypePolar) | ||
m_chart = new QPolarChart(this); | ||||
else | ||||
m_chart = new QChart(this); | ||||
|
r1 | setFlag(QGraphicsItem::ItemHasNoContents, false); | ||
|
r2488 | #endif | ||
|
r2090 | m_margins = new DeclarativeMargins(this); | ||
m_margins->setTop(m_chart->margins().top()); | ||||
m_margins->setLeft(m_chart->margins().left()); | ||||
m_margins->setRight(m_chart->margins().right()); | ||||
m_margins->setBottom(m_chart->margins().bottom()); | ||||
|
r2110 | connect(m_margins, SIGNAL(topChanged(int,int,int,int)), this, SLOT(changeMinimumMargins(int,int,int,int))); | ||
connect(m_margins, SIGNAL(bottomChanged(int,int,int,int)), this, SLOT(changeMinimumMargins(int,int,int,int))); | ||||
connect(m_margins, SIGNAL(leftChanged(int,int,int,int)), this, SLOT(changeMinimumMargins(int,int,int,int))); | ||||
connect(m_margins, SIGNAL(rightChanged(int,int,int,int)), this, SLOT(changeMinimumMargins(int,int,int,int))); | ||||
|
r2277 | connect(m_chart->d_ptr->m_dataset, SIGNAL(seriesAdded(QAbstractSeries*)), this, SLOT(handleSeriesAdded(QAbstractSeries*))); | ||
|
r2110 | connect(m_chart->d_ptr->m_dataset, SIGNAL(seriesRemoved(QAbstractSeries*)), this, SIGNAL(seriesRemoved(QAbstractSeries*))); | ||
|
r2068 | } | ||
|
r2277 | void DeclarativeChart::handleSeriesAdded(QAbstractSeries *series) | ||
|
r2068 | { | ||
emit seriesAdded(series); | ||||
|
r1524 | } | ||
|
r1928 | void DeclarativeChart::changeMinimumMargins(int top, int bottom, int left, int right) | ||
|
r1524 | { | ||
|
r1965 | m_chart->setMargins(QMargins(left, top, right, bottom)); | ||
|
r1946 | emit minimumMarginsChanged(); | ||
emit plotAreaChanged(m_chart->plotArea()); | ||||
|
r1 | } | ||
|
r722 | DeclarativeChart::~DeclarativeChart() | ||
{ | ||||
delete m_chart; | ||||
|
r2505 | #ifdef CHARTS_FOR_QUICK2 | ||
m_sceneImageLock.lock(); | ||||
delete m_currentSceneImage; | ||||
m_currentSceneImage = 0; | ||||
m_sceneImageLock.unlock(); | ||||
#endif | ||||
|
r722 | } | ||
|
r1117 | void DeclarativeChart::childEvent(QChildEvent *event) | ||
{ | ||||
if (event->type() == QEvent::ChildAdded) { | ||||
if (qobject_cast<QAbstractSeries *>(event->child())) { | ||||
m_chart->addSeries(qobject_cast<QAbstractSeries *>(event->child())); | ||||
} | ||||
} | ||||
} | ||||
void DeclarativeChart::componentComplete() | ||||
{ | ||||
|
r2100 | foreach (QObject *child, children()) { | ||
|
r1117 | if (qobject_cast<QAbstractSeries *>(child)) { | ||
|
r1903 | // Add series to the chart | ||
QAbstractSeries *series = qobject_cast<QAbstractSeries *>(child); | ||||
m_chart->addSeries(series); | ||||
|
r2296 | // Connect to axis changed signals (unless this is a pie series) | ||
if (!qobject_cast<DeclarativePieSeries *>(series)) { | ||||
connect(series, SIGNAL(axisXChanged(QAbstractAxis*)), this, SLOT(handleAxisXSet(QAbstractAxis*))); | ||||
|
r2576 | connect(series, SIGNAL(axisXTopChanged(QAbstractAxis*)), this, SLOT(handleAxisXTopSet(QAbstractAxis*))); | ||
|
r2296 | connect(series, SIGNAL(axisYChanged(QAbstractAxis*)), this, SLOT(handleAxisYSet(QAbstractAxis*))); | ||
connect(series, SIGNAL(axisYRightChanged(QAbstractAxis*)), this, SLOT(handleAxisYRightSet(QAbstractAxis*))); | ||||
|
r1813 | } | ||
|
r2296 | |||
initializeAxes(series); | ||||
|
r1117 | } | ||
} | ||||
|
r1813 | |||
|
r2488 | QDECLARATIVE_ITEM::componentComplete(); | ||
|
r1117 | } | ||
|
r2101 | void DeclarativeChart::handleAxisXSet(QAbstractAxis *axis) | ||
|
r1813 | { | ||
|
r2296 | QAbstractSeries *s = qobject_cast<QAbstractSeries *>(sender()); | ||
if (axis && s) { | ||||
if (!m_chart->axes(Qt::Horizontal).contains(axis)) | ||||
|
r2597 | m_chart->setAxisX(axis, s); | ||
|
r2296 | if (!s->attachedAxes().contains(axis)) | ||
s->attachAxis(axis); | ||||
} else { | ||||
|
r1947 | qWarning() << "Trying to set axisX to null."; | ||
|
r2296 | } | ||
} | ||||
void DeclarativeChart::handleAxisXTopSet(QAbstractAxis *axis) | ||||
{ | ||||
QAbstractSeries *s = qobject_cast<QAbstractSeries *>(sender()); | ||||
if (axis && s) { | ||||
|
r2597 | if (!m_chart->axes(Qt::Horizontal).contains(axis)) { | ||
QList<QAbstractAxis *> oldAxes = m_chart->axes(Qt::Horizontal, s); | ||||
foreach (QAbstractAxis* a, oldAxes) { | ||||
m_chart->removeAxis(a); | ||||
delete a; | ||||
} | ||||
|
r2296 | m_chart->addAxis(axis, Qt::AlignTop); | ||
|
r2597 | } | ||
|
r2296 | if (!s->attachedAxes().contains(axis)) | ||
s->attachAxis(axis); | ||||
} else { | ||||
qWarning() << "Trying to set axisXTop to null."; | ||||
} | ||||
|
r1813 | } | ||
|
r2101 | void DeclarativeChart::handleAxisYSet(QAbstractAxis *axis) | ||
|
r1813 | { | ||
|
r2296 | QAbstractSeries *s = qobject_cast<QAbstractSeries *>(sender()); | ||
if (axis && s) { | ||||
if (!m_chart->axes(Qt::Vertical).contains(axis)) | ||||
|
r2597 | m_chart->setAxisY(axis, s); | ||
|
r2296 | if (!s->attachedAxes().contains(axis)) | ||
s->attachAxis(axis); | ||||
} else { | ||||
|
r1947 | qWarning() << "Trying to set axisY to null."; | ||
|
r2296 | } | ||
} | ||||
void DeclarativeChart::handleAxisYRightSet(QAbstractAxis *axis) | ||||
{ | ||||
QAbstractSeries *s = qobject_cast<QAbstractSeries *>(sender()); | ||||
if (axis && s) { | ||||
|
r2597 | if (!m_chart->axes(Qt::Vertical).contains(axis)) { | ||
QList<QAbstractAxis *> oldAxes = m_chart->axes((Qt::Vertical), s); | ||||
foreach (QAbstractAxis* a, oldAxes) { | ||||
m_chart->removeAxis(a); | ||||
delete a; | ||||
} | ||||
|
r2296 | m_chart->addAxis(axis, Qt::AlignRight); | ||
|
r2597 | } | ||
|
r2296 | if (!s->attachedAxes().contains(axis)) | ||
s->attachAxis(axis); | ||||
} else { | ||||
qWarning() << "Trying to set axisYRight to null."; | ||||
} | ||||
|
r1813 | } | ||
|
r120 | void DeclarativeChart::geometryChanged(const QRectF &newGeometry, const QRectF &oldGeometry) | ||
|
r1 | { | ||
|
r200 | if (newGeometry.isValid()) { | ||
if (newGeometry.width() > 0 && newGeometry.height() > 0) { | ||||
|
r642 | m_chart->resize(newGeometry.width(), newGeometry.height()); | ||
|
r200 | } | ||
} | ||||
|
r2488 | QDECLARATIVE_ITEM::geometryChanged(newGeometry, oldGeometry); | ||
|
r1946 | |||
// It would be better to trigger the plotAreaChanged signal from QChart::plotAreaChanged or | ||||
// similar. Since that kind of a signal is not clearly needed in the C++ API the work-around is | ||||
// to implement it here for the QML API purposes. | ||||
emit plotAreaChanged(m_chart->plotArea()); | ||||
|
r1 | } | ||
|
r2488 | #ifdef CHARTS_FOR_QUICK2 | ||
|
r2505 | void DeclarativeChart::sceneChanged(QList<QRectF> region) | ||
{ | ||||
Q_UNUSED(region); | ||||
|
r2506 | if (m_guiThreadId == m_paintThreadId) { | ||
// Rendering in gui thread, no need for shenannigans, just update | ||||
update(); | ||||
} else { | ||||
// Multi-threaded rendering, need to ensure scene is actually rendered in gui thread | ||||
if (!m_updatePending) { | ||||
m_updatePending = true; | ||||
// Do async render to avoid some unnecessary renders. | ||||
QTimer::singleShot(0, this, SLOT(renderScene())); | ||||
} | ||||
|
r2505 | } | ||
} | ||||
void DeclarativeChart::renderScene() | ||||
{ | ||||
m_updatePending = false; | ||||
m_sceneImageLock.lock(); | ||||
delete m_currentSceneImage; | ||||
m_currentSceneImage = new QImage(m_chart->size().toSize(), QImage::Format_ARGB32); | ||||
m_currentSceneImage->fill(Qt::transparent); | ||||
QPainter painter(m_currentSceneImage); | ||||
|
r2506 | if (antialiasing()) | ||
painter.setRenderHints(QPainter::Antialiasing | QPainter::TextAntialiasing | QPainter::SmoothPixmapTransform); | ||||
|
r2505 | QRect renderRect(QPoint(0, 0), m_chart->size().toSize()); | ||
m_scene->render(&painter, renderRect, renderRect); | ||||
m_sceneImageLock.unlock(); | ||||
update(); | ||||
} | ||||
|
r2488 | void DeclarativeChart::paint(QPainter *painter) | ||
{ | ||||
|
r2506 | if (!m_paintThreadId) { | ||
m_paintThreadId = QThread::currentThreadId(); | ||||
if (m_guiThreadId == m_paintThreadId) { | ||||
// No need for scene image in single threaded rendering, so delete | ||||
// the one that got made by default before the rendering type was | ||||
// detected. | ||||
delete m_currentSceneImage; | ||||
m_currentSceneImage = 0; | ||||
} | ||||
} | ||||
if (m_guiThreadId == m_paintThreadId) { | ||||
QRectF renderRect(QPointF(0, 0), m_chart->size()); | ||||
m_scene->render(painter, renderRect, renderRect); | ||||
} else { | ||||
m_sceneImageLock.lock(); | ||||
if (m_currentSceneImage) { | ||||
QRect imageRect(QPoint(0, 0), m_currentSceneImage->size()); | ||||
QRect itemRect(QPoint(0, 0), QSize(width(), height())); | ||||
painter->drawImage(itemRect, *m_currentSceneImage, imageRect); | ||||
} | ||||
m_sceneImageLock.unlock(); | ||||
|
r2505 | } | ||
|
r2488 | } | ||
|
r2495 | void DeclarativeChart::mousePressEvent(QMouseEvent *event) | ||
{ | ||||
m_mousePressScenePoint = event->pos(); | ||||
m_mousePressScreenPoint = event->globalPos(); | ||||
m_lastMouseMoveScenePoint = m_mousePressScenePoint; | ||||
m_lastMouseMoveScreenPoint = m_mousePressScreenPoint; | ||||
m_mousePressButton = event->button(); | ||||
m_mousePressButtons = event->buttons(); | ||||
QGraphicsSceneMouseEvent mouseEvent(QEvent::GraphicsSceneMousePress); | ||||
mouseEvent.setWidget(0); | ||||
mouseEvent.setButtonDownScenePos(m_mousePressButton, m_mousePressScenePoint); | ||||
mouseEvent.setButtonDownScreenPos(m_mousePressButton, m_mousePressScreenPoint); | ||||
mouseEvent.setScenePos(m_mousePressScenePoint); | ||||
mouseEvent.setScreenPos(m_mousePressScreenPoint); | ||||
mouseEvent.setLastScenePos(m_lastMouseMoveScenePoint); | ||||
mouseEvent.setLastScreenPos(m_lastMouseMoveScreenPoint); | ||||
mouseEvent.setButtons(m_mousePressButtons); | ||||
mouseEvent.setButton(m_mousePressButton); | ||||
mouseEvent.setModifiers(event->modifiers()); | ||||
mouseEvent.setAccepted(false); | ||||
QApplication::sendEvent(m_scene, &mouseEvent); | ||||
} | ||||
void DeclarativeChart::mouseReleaseEvent(QMouseEvent *event) | ||||
{ | ||||
QGraphicsSceneMouseEvent mouseEvent(QEvent::GraphicsSceneMouseRelease); | ||||
mouseEvent.setWidget(0); | ||||
mouseEvent.setButtonDownScenePos(m_mousePressButton, m_mousePressScenePoint); | ||||
mouseEvent.setButtonDownScreenPos(m_mousePressButton, m_mousePressScreenPoint); | ||||
mouseEvent.setScenePos(event->pos()); | ||||
mouseEvent.setScreenPos(event->globalPos()); | ||||
mouseEvent.setLastScenePos(m_lastMouseMoveScenePoint); | ||||
mouseEvent.setLastScreenPos(m_lastMouseMoveScreenPoint); | ||||
mouseEvent.setButtons(event->buttons()); | ||||
mouseEvent.setButton(event->button()); | ||||
mouseEvent.setModifiers(event->modifiers()); | ||||
mouseEvent.setAccepted(false); | ||||
QApplication::sendEvent(m_scene, &mouseEvent); | ||||
m_mousePressButtons = event->buttons(); | ||||
m_mousePressButton = Qt::NoButton; | ||||
} | ||||
void DeclarativeChart::hoverMoveEvent(QHoverEvent *event) | ||||
{ | ||||
// Convert hover move to mouse move, since we don't seem to get actual mouse move events. | ||||
// QGraphicsScene generates hover events from mouse move events, so we don't need | ||||
// to pass hover events there. | ||||
QGraphicsSceneMouseEvent mouseEvent(QEvent::GraphicsSceneMouseMove); | ||||
mouseEvent.setWidget(0); | ||||
mouseEvent.setButtonDownScenePos(m_mousePressButton, m_mousePressScenePoint); | ||||
mouseEvent.setButtonDownScreenPos(m_mousePressButton, m_mousePressScreenPoint); | ||||
mouseEvent.setScenePos(event->pos()); | ||||
// Hover events do not have global pos in them, and the screen position doesn't seem to | ||||
// matter anyway in this use case, so just pass event pos instead of trying to | ||||
// calculate the real screen position. | ||||
mouseEvent.setScreenPos(event->pos()); | ||||
mouseEvent.setLastScenePos(m_lastMouseMoveScenePoint); | ||||
mouseEvent.setLastScreenPos(m_lastMouseMoveScreenPoint); | ||||
mouseEvent.setButtons(m_mousePressButtons); | ||||
mouseEvent.setButton(m_mousePressButton); | ||||
mouseEvent.setModifiers(event->modifiers()); | ||||
m_lastMouseMoveScenePoint = mouseEvent.scenePos(); | ||||
m_lastMouseMoveScreenPoint = mouseEvent.screenPos(); | ||||
mouseEvent.setAccepted(false); | ||||
QApplication::sendEvent(m_scene, &mouseEvent); | ||||
} | ||||
|
r2488 | void DeclarativeChart::handleAntialiasingChanged(bool enable) | ||
{ | ||||
setAntialiasing(enable); | ||||
} | ||||
#endif | ||||
|
r1240 | void DeclarativeChart::setTheme(DeclarativeChart::Theme theme) | ||
|
r1094 | { | ||
|
r1357 | QChart::ChartTheme chartTheme = (QChart::ChartTheme) theme; | ||
|
r1481 | if (chartTheme != m_chart->theme()) | ||
|
r1357 | m_chart->setTheme(chartTheme); | ||
|
r1094 | } | ||
|
r1240 | DeclarativeChart::Theme DeclarativeChart::theme() | ||
{ | ||||
return (DeclarativeChart::Theme) m_chart->theme(); | ||||
} | ||||
void DeclarativeChart::setAnimationOptions(DeclarativeChart::Animation animations) | ||||
{ | ||||
|
r1357 | QChart::AnimationOption animationOptions = (QChart::AnimationOption) animations; | ||
|
r1481 | if (animationOptions != m_chart->animationOptions()) | ||
|
r1357 | m_chart->setAnimationOptions(animationOptions); | ||
|
r1240 | } | ||
DeclarativeChart::Animation DeclarativeChart::animationOptions() | ||||
|
r1094 | { | ||
if (m_chart->animationOptions().testFlag(QChart::AllAnimations)) | ||||
|
r1240 | return DeclarativeChart::AllAnimations; | ||
|
r1094 | else if (m_chart->animationOptions().testFlag(QChart::GridAxisAnimations)) | ||
|
r1240 | return DeclarativeChart::GridAxisAnimations; | ||
|
r1094 | else if (m_chart->animationOptions().testFlag(QChart::SeriesAnimations)) | ||
|
r1240 | return DeclarativeChart::SeriesAnimations; | ||
|
r1094 | else | ||
|
r1240 | return DeclarativeChart::NoAnimation; | ||
|
r1094 | } | ||
|
r1357 | void DeclarativeChart::setTitle(QString title) | ||
{ | ||||
|
r1481 | if (title != m_chart->title()) | ||
|
r1357 | m_chart->setTitle(title); | ||
|
r1095 | } | ||
|
r1357 | QString DeclarativeChart::title() | ||
|
r1095 | { | ||
|
r1357 | return m_chart->title(); | ||
|
r1095 | } | ||
|
r1550 | QAbstractAxis *DeclarativeChart::axisX(QAbstractSeries *series) | ||
|
r1139 | { | ||
|
r2296 | QList<QAbstractAxis *> axes = m_chart->axes(Qt::Horizontal, series); | ||
if (axes.count()) | ||||
return axes[0]; | ||||
return 0; | ||||
|
r1139 | } | ||
|
r1541 | QAbstractAxis *DeclarativeChart::axisY(QAbstractSeries *series) | ||
|
r1139 | { | ||
|
r2296 | QList<QAbstractAxis *> axes = m_chart->axes(Qt::Vertical, series); | ||
if (axes.count()) | ||||
return axes[0]; | ||||
return 0; | ||||
|
r1139 | } | ||
|
r1357 | QLegend *DeclarativeChart::legend() | ||
{ | ||||
return m_chart->legend(); | ||||
} | ||||
void DeclarativeChart::setTitleColor(QColor color) | ||||
{ | ||||
QBrush b = m_chart->titleBrush(); | ||||
if (color != b.color()) { | ||||
b.setColor(color); | ||||
m_chart->setTitleBrush(b); | ||||
|
r1524 | emit titleColorChanged(color); | ||
|
r1357 | } | ||
} | ||||
|
r1517 | QFont DeclarativeChart::titleFont() const | ||
{ | ||||
return m_chart->titleFont(); | ||||
} | ||||
|
r2101 | void DeclarativeChart::setTitleFont(const QFont &font) | ||
|
r1517 | { | ||
m_chart->setTitleFont(font); | ||||
} | ||||
|
r1357 | QColor DeclarativeChart::titleColor() | ||
{ | ||||
return m_chart->titleBrush().color(); | ||||
} | ||||
void DeclarativeChart::setBackgroundColor(QColor color) | ||||
{ | ||||
QBrush b = m_chart->backgroundBrush(); | ||||
|
r1473 | if (b.style() != Qt::SolidPattern || color != b.color()) { | ||
b.setStyle(Qt::SolidPattern); | ||||
|
r1357 | b.setColor(color); | ||
m_chart->setBackgroundBrush(b); | ||||
emit backgroundColorChanged(); | ||||
} | ||||
} | ||||
QColor DeclarativeChart::backgroundColor() | ||||
{ | ||||
return m_chart->backgroundBrush().color(); | ||||
|
r1157 | } | ||
|
r2498 | void QtCommercialChart::DeclarativeChart::setPlotAreaColor(QColor color) | ||
{ | ||||
QBrush b = m_chart->plotAreaBackgroundBrush(); | ||||
if (b.style() != Qt::SolidPattern || color != b.color()) { | ||||
b.setStyle(Qt::SolidPattern); | ||||
b.setColor(color); | ||||
m_chart->setPlotAreaBackgroundBrush(b); | ||||
m_chart->setPlotAreaBackgroundVisible(true); | ||||
emit plotAreaColorChanged(); | ||||
} | ||||
} | ||||
QColor QtCommercialChart::DeclarativeChart::plotAreaColor() | ||||
{ | ||||
return m_chart->plotAreaBackgroundBrush().color(); | ||||
} | ||||
|
r2707 | void DeclarativeChart::setLocalizeNumbers(bool localize) | ||
{ | ||||
if (m_chart->localizeNumbers() != localize) { | ||||
m_chart->setLocalizeNumbers(localize); | ||||
emit localizeNumbersChanged(); | ||||
} | ||||
} | ||||
bool DeclarativeChart::localizeNumbers() const | ||||
{ | ||||
return m_chart->localizeNumbers(); | ||||
} | ||||
|
r1240 | int DeclarativeChart::count() | ||
{ | ||||
return m_chart->series().count(); | ||||
} | ||||
|
r1461 | void DeclarativeChart::setDropShadowEnabled(bool enabled) | ||
{ | ||||
|
r1462 | if (enabled != m_chart->isDropShadowEnabled()) { | ||
m_chart->setDropShadowEnabled(enabled); | ||||
|
r1461 | dropShadowEnabledChanged(enabled); | ||
} | ||||
} | ||||
bool DeclarativeChart::dropShadowEnabled() | ||||
{ | ||||
|
r1462 | return m_chart->isDropShadowEnabled(); | ||
|
r1461 | } | ||
|
r2549 | qreal DeclarativeChart::backgroundRoundness() const | ||
{ | ||||
return m_chart->backgroundRoundness(); | ||||
} | ||||
void DeclarativeChart::setBackgroundRoundness(qreal diameter) | ||||
{ | ||||
if (m_chart->backgroundRoundness() != diameter) { | ||||
m_chart->setBackgroundRoundness(diameter); | ||||
emit backgroundRoundnessChanged(diameter); | ||||
} | ||||
} | ||||
|
r1524 | qreal DeclarativeChart::topMargin() | ||
{ | ||||
|
r2369 | qWarning() << "ChartView.topMargin is deprecated. Use margins instead."; | ||
return m_chart->margins().top(); | ||||
|
r1524 | } | ||
qreal DeclarativeChart::bottomMargin() | ||||
{ | ||||
|
r2369 | qWarning() << "ChartView.bottomMargin is deprecated. Use margins instead."; | ||
return m_chart->margins().bottom(); | ||||
|
r1524 | } | ||
qreal DeclarativeChart::leftMargin() | ||||
{ | ||||
|
r2369 | qWarning() << "ChartView.leftMargin is deprecated. Use margins instead."; | ||
return m_chart->margins().left(); | ||||
|
r1524 | } | ||
qreal DeclarativeChart::rightMargin() | ||||
{ | ||||
|
r2369 | qWarning() << "ChartView.rightMargin is deprecated. Use margins instead."; | ||
return m_chart->margins().right(); | ||||
|
r1524 | } | ||
|
r1461 | void DeclarativeChart::zoom(qreal factor) | ||
{ | ||||
m_chart->zoom(factor); | ||||
} | ||||
void DeclarativeChart::scrollLeft(qreal pixels) | ||||
{ | ||||
|
r1955 | m_chart->scroll(-pixels, 0); | ||
|
r1461 | } | ||
void DeclarativeChart::scrollRight(qreal pixels) | ||||
{ | ||||
|
r1955 | m_chart->scroll(pixels, 0); | ||
|
r1461 | } | ||
void DeclarativeChart::scrollUp(qreal pixels) | ||||
{ | ||||
|
r1553 | m_chart->scroll(0, pixels); | ||
|
r1461 | } | ||
void DeclarativeChart::scrollDown(qreal pixels) | ||||
{ | ||||
|
r1553 | m_chart->scroll(0, -pixels); | ||
|
r1461 | } | ||
|
r2488 | QDECLARATIVE_LIST_PROPERTY<QAbstractAxis> DeclarativeChart::axes() | ||
|
r2296 | { | ||
|
r2488 | return QDECLARATIVE_LIST_PROPERTY<QAbstractAxis>(this, 0, | ||
|
r2296 | &DeclarativeChart::axesAppendFunc, | ||
&DeclarativeChart::axesCountFunc, | ||||
|
r2488 | #ifdef CHARTS_FOR_QUICK2 | ||
&DeclarativeChart::axesAtFunc, | ||||
&DeclarativeChart::axesClearFunc); | ||||
#else | ||||
|
r2296 | &DeclarativeChart::axesAtFunc); | ||
|
r2488 | #endif | ||
|
r2296 | } | ||
|
r2488 | void DeclarativeChart::axesAppendFunc(QDECLARATIVE_LIST_PROPERTY<QAbstractAxis> *list, QAbstractAxis *element) | ||
|
r2296 | { | ||
// Empty implementation | ||||
Q_UNUSED(list); | ||||
Q_UNUSED(element); | ||||
} | ||||
|
r2488 | int DeclarativeChart::axesCountFunc(QDECLARATIVE_LIST_PROPERTY<QAbstractAxis> *list) | ||
|
r2296 | { | ||
if (qobject_cast<DeclarativeChart *>(list->object)) { | ||||
DeclarativeChart *chart = qobject_cast<DeclarativeChart *>(list->object); | ||||
|
r2300 | return chart->m_chart->axes(Qt::Horizontal | Qt::Vertical).count(); | ||
|
r2296 | } | ||
return 0; | ||||
} | ||||
|
r2488 | QAbstractAxis *DeclarativeChart::axesAtFunc(QDECLARATIVE_LIST_PROPERTY<QAbstractAxis> *list, int index) | ||
|
r2296 | { | ||
if (qobject_cast<DeclarativeChart *>(list->object)) { | ||||
DeclarativeChart *chart = qobject_cast<DeclarativeChart *>(list->object); | ||||
QList<QAbstractAxis *> axes = chart->m_chart->axes(Qt::Horizontal | Qt::Vertical, chart->m_chart->series()[0]); | ||||
return axes.at(index); | ||||
} | ||||
return 0; | ||||
} | ||||
|
r2488 | void DeclarativeChart::axesClearFunc(QDECLARATIVE_LIST_PROPERTY<QAbstractAxis> *list) | ||
{ | ||||
// Empty implementation | ||||
Q_UNUSED(list); | ||||
} | ||||
|
r1240 | QAbstractSeries *DeclarativeChart::series(int index) | ||
{ | ||||
if (index < m_chart->series().count()) { | ||||
return m_chart->series().at(index); | ||||
} | ||||
return 0; | ||||
} | ||||
QAbstractSeries *DeclarativeChart::series(QString seriesName) | ||||
{ | ||||
|
r2100 | foreach (QAbstractSeries *series, m_chart->series()) { | ||
|
r1240 | if (series->name() == seriesName) | ||
return series; | ||||
} | ||||
return 0; | ||||
} | ||||
|
r2389 | QAbstractSeries *DeclarativeChart::createSeries(int type, QString name, QAbstractAxis *axisX, QAbstractAxis *axisY) | ||
|
r1240 | { | ||
QAbstractSeries *series = 0; | ||||
|
r1813 | |||
|
r1240 | switch (type) { | ||
case DeclarativeChart::SeriesTypeLine: | ||||
series = new DeclarativeLineSeries(); | ||||
break; | ||||
|
r2114 | case DeclarativeChart::SeriesTypeArea: { | ||
DeclarativeAreaSeries *area = new DeclarativeAreaSeries(); | ||||
area->setUpperSeries(new DeclarativeLineSeries()); | ||||
series = area; | ||||
|
r1240 | break; | ||
|
r2114 | } | ||
|
r1240 | case DeclarativeChart::SeriesTypeStackedBar: | ||
|
r1690 | series = new DeclarativeStackedBarSeries(); | ||
|
r1240 | break; | ||
case DeclarativeChart::SeriesTypePercentBar: | ||||
|
r1690 | series = new DeclarativePercentBarSeries(); | ||
|
r1240 | break; | ||
|
r1594 | case DeclarativeChart::SeriesTypeBar: | ||
series = new DeclarativeBarSeries(); | ||||
|
r1240 | break; | ||
|
r1811 | case DeclarativeChart::SeriesTypeHorizontalBar: | ||
series = new DeclarativeHorizontalBarSeries(); | ||||
break; | ||||
case DeclarativeChart::SeriesTypeHorizontalPercentBar: | ||||
series = new DeclarativeHorizontalPercentBarSeries(); | ||||
break; | ||||
case DeclarativeChart::SeriesTypeHorizontalStackedBar: | ||||
series = new DeclarativeHorizontalStackedBarSeries(); | ||||
break; | ||||
|
r2548 | case DeclarativeChart::SeriesTypeBoxPlot: | ||
series = new DeclarativeBoxPlotSeries(); | ||||
break; | ||||
|
r1240 | case DeclarativeChart::SeriesTypePie: | ||
series = new DeclarativePieSeries(); | ||||
break; | ||||
case DeclarativeChart::SeriesTypeScatter: | ||||
series = new DeclarativeScatterSeries(); | ||||
break; | ||||
case DeclarativeChart::SeriesTypeSpline: | ||||
series = new DeclarativeSplineSeries(); | ||||
break; | ||||
default: | ||||
qWarning() << "Illegal series type"; | ||||
} | ||||
|
r1813 | |||
if (series) { | ||||
|
r2296 | // Connect to axis changed signals (unless this is a pie series) | ||
if (!qobject_cast<DeclarativePieSeries *>(series)) { | ||||
connect(series, SIGNAL(axisXChanged(QAbstractAxis*)), this, SLOT(handleAxisXSet(QAbstractAxis*))); | ||||
connect(series, SIGNAL(axisXTopChanged(QAbstractAxis*)), this, SLOT(handleAxisXSet(QAbstractAxis*))); | ||||
connect(series, SIGNAL(axisYChanged(QAbstractAxis*)), this, SLOT(handleAxisYSet(QAbstractAxis*))); | ||||
connect(series, SIGNAL(axisYRightChanged(QAbstractAxis*)), this, SLOT(handleAxisYRightSet(QAbstractAxis*))); | ||||
} | ||||
|
r1813 | series->setName(name); | ||
m_chart->addSeries(series); | ||||
|
r2296 | |||
if (axisX) | ||||
setAxisX(axisX, series); | ||||
if (axisY) | ||||
setAxisY(axisY, series); | ||||
if (series->attachedAxes().count() < 2) | ||||
initializeAxes(series); | ||||
|
r1813 | } | ||
|
r1240 | return series; | ||
} | ||||
|
r2068 | void DeclarativeChart::removeSeries(QAbstractSeries *series) | ||
{ | ||||
if (series) | ||||
m_chart->removeSeries(series); | ||||
else | ||||
qWarning("removeSeries: cannot remove null"); | ||||
} | ||||
|
r1813 | void DeclarativeChart::setAxisX(QAbstractAxis *axis, QAbstractSeries *series) | ||
|
r1604 | { | ||
|
r1813 | if (axis) | ||
m_chart->setAxisX(axis, series); | ||||
|
r1604 | } | ||
|
r1813 | void DeclarativeChart::setAxisY(QAbstractAxis *axis, QAbstractSeries *series) | ||
|
r1604 | { | ||
|
r1813 | if (axis) | ||
m_chart->setAxisY(axis, series); | ||||
|
r1604 | } | ||
void DeclarativeChart::createDefaultAxes() | ||||
{ | ||||
|
r1813 | qWarning() << "ChartView.createDefaultAxes() is deprecated. Axes are created automatically."; | ||
} | ||||
|
r2296 | QAbstractAxis *DeclarativeChart::defaultAxis(Qt::Orientation orientation, QAbstractSeries *series) | ||
|
r1813 | { | ||
|
r2296 | if (!series) { | ||
qWarning() << "No axis type defined for null series"; | ||||
return 0; | ||||
|
r1813 | } | ||
|
r2296 | foreach (QAbstractAxis *existingAxis, m_chart->axes(orientation)) { | ||
if (existingAxis->type() == series->d_ptr->defaultAxisType(orientation)) | ||||
return existingAxis; | ||||
|
r1813 | } | ||
|
r2296 | switch (series->d_ptr->defaultAxisType(orientation)) { | ||
case QAbstractAxis::AxisTypeValue: | ||||
return new QValueAxis(this); | ||||
case QAbstractAxis::AxisTypeBarCategory: | ||||
return new QBarCategoryAxis(this); | ||||
case QAbstractAxis::AxisTypeCategory: | ||||
return new QCategoryAxis(this); | ||||
|
r1867 | #ifndef QT_ON_ARM | ||
|
r2296 | case QAbstractAxis::AxisTypeDateTime: | ||
return new QDateTimeAxis(this); | ||||
|
r1867 | #endif | ||
|
r2493 | case QAbstractAxis::AxisTypeLogValue: | ||
return new QLogValueAxis(this); | ||||
|
r2296 | default: | ||
// assume AxisTypeNoAxis | ||||
return 0; | ||||
|
r1813 | } | ||
|
r2296 | } | ||
|
r1813 | |||
|
r2296 | void DeclarativeChart::initializeAxes(QAbstractSeries *series) | ||
{ | ||||
if (qobject_cast<DeclarativeLineSeries *>(series)) | ||||
doInitializeAxes(series, qobject_cast<DeclarativeLineSeries *>(series)->m_axes); | ||||
else if (qobject_cast<DeclarativeScatterSeries *>(series)) | ||||
doInitializeAxes(series, qobject_cast<DeclarativeScatterSeries *>(series)->m_axes); | ||||
else if (qobject_cast<DeclarativeSplineSeries *>(series)) | ||||
doInitializeAxes(series, qobject_cast<DeclarativeSplineSeries *>(series)->m_axes); | ||||
else if (qobject_cast<DeclarativeAreaSeries *>(series)) | ||||
doInitializeAxes(series, qobject_cast<DeclarativeAreaSeries *>(series)->m_axes); | ||||
else if (qobject_cast<DeclarativeBarSeries *>(series)) | ||||
doInitializeAxes(series, qobject_cast<DeclarativeBarSeries *>(series)->m_axes); | ||||
else if (qobject_cast<DeclarativeStackedBarSeries *>(series)) | ||||
doInitializeAxes(series, qobject_cast<DeclarativeStackedBarSeries *>(series)->m_axes); | ||||
else if (qobject_cast<DeclarativePercentBarSeries *>(series)) | ||||
doInitializeAxes(series, qobject_cast<DeclarativePercentBarSeries *>(series)->m_axes); | ||||
else if (qobject_cast<DeclarativeHorizontalBarSeries *>(series)) | ||||
doInitializeAxes(series, qobject_cast<DeclarativeHorizontalBarSeries *>(series)->m_axes); | ||||
else if (qobject_cast<DeclarativeHorizontalStackedBarSeries *>(series)) | ||||
doInitializeAxes(series, qobject_cast<DeclarativeHorizontalStackedBarSeries *>(series)->m_axes); | ||||
else if (qobject_cast<DeclarativeHorizontalPercentBarSeries *>(series)) | ||||
doInitializeAxes(series, qobject_cast<DeclarativeHorizontalPercentBarSeries *>(series)->m_axes); | ||||
|
r2548 | else if (qobject_cast<DeclarativeBoxPlotSeries *>(series)) | ||
doInitializeAxes(series, qobject_cast<DeclarativeBoxPlotSeries *>(series)->m_axes); | ||||
|
r2296 | // else: do nothing | ||
} | ||||
void DeclarativeChart::doInitializeAxes(QAbstractSeries *series, DeclarativeAxes *axes) | ||||
{ | ||||
// Initialize axis X | ||||
if (axes->axisX()) | ||||
axes->emitAxisXChanged(); | ||||
else if (axes->axisXTop()) | ||||
axes->emitAxisXTopChanged(); | ||||
else | ||||
axes->setAxisX(defaultAxis(Qt::Horizontal, series)); | ||||
// Initialize axis Y | ||||
if (axes->axisY()) | ||||
axes->emitAxisYChanged(); | ||||
else if (axes->axisYRight()) | ||||
axes->emitAxisYRightChanged(); | ||||
else | ||||
axes->setAxisY(defaultAxis(Qt::Vertical, series)); | ||||
|
r1604 | } | ||
|
r120 | #include "moc_declarativechart.cpp" | ||
QTCOMMERCIALCHART_END_NAMESPACE | ||||