chartdataset.cpp
639 lines
| 18.6 KiB
| text/x-c
|
CppLexer
|
r771 | /**************************************************************************** | ||
** | ||||
|
r2776 | ** Copyright (C) 2015 The Qt Company Ltd | ||
|
r771 | ** All rights reserved. | ||
|
r2776 | ** For any questions to The Qt Company, please use contact form at http://qt.io | ||
|
r771 | ** | ||
|
r2740 | ** This file is part of the Qt Charts module. | ||
|
r771 | ** | ||
|
r2740 | ** Licensees holding valid commercial license for Qt may use this file in | ||
** accordance with the Qt License Agreement provided with the Software | ||||
** or, alternatively, in accordance with the terms contained in a written | ||||
|
r2776 | ** agreement between you and The Qt Company. | ||
|
r771 | ** | ||
** If you have questions regarding the use of this file, please use | ||||
|
r2740 | ** contact form at http://qt.io | ||
|
r771 | ** | ||
****************************************************************************/ | ||||
|
r2714 | #include <private/chartdataset_p.h> | ||
#include <private/chartpresenter_p.h> | ||||
#include <QtCharts/QChart> | ||||
#include <private/qchart_p.h> | ||||
#include <QtCharts/QValueAxis> | ||||
#include <QtCharts/QBarCategoryAxis> | ||||
#include <private/qvalueaxis_p.h> | ||||
#include <QtCharts/QCategoryAxis> | ||||
#include <private/qabstractseries_p.h> | ||||
#include <QtCharts/QAbstractBarSeries> | ||||
#include <QtCharts/QStackedBarSeries> | ||||
#include <QtCharts/QPercentBarSeries> | ||||
#include <QtCharts/QPieSeries> | ||||
#include <private/chartitem_p.h> | ||||
#include <private/xydomain_p.h> | ||||
#include <private/xypolardomain_p.h> | ||||
#include <private/xlogydomain_p.h> | ||||
#include <private/logxydomain_p.h> | ||||
#include <private/logxlogydomain_p.h> | ||||
#include <private/xlogypolardomain_p.h> | ||||
#include <private/logxypolardomain_p.h> | ||||
#include <private/logxlogypolardomain_p.h> | ||||
|
r2820 | #include <private/glxyseriesdata_p.h> | ||
|
r131 | |||
|
r1867 | #ifndef QT_ON_ARM | ||
|
r2714 | #include <QtCharts/QDateTimeAxis> | ||
|
r1867 | #endif | ||
|
r2712 | QT_CHARTS_BEGIN_NAMESPACE | ||
|
r131 | |||
|
r2273 | ChartDataSet::ChartDataSet(QChart *chart) | ||
: QObject(chart), | ||||
|
r2820 | m_chart(chart), | ||
m_glXYSeriesDataManager(new GLXYSeriesDataManager(this)) | ||||
|
r131 | { | ||
|
r1556 | |||
|
r131 | } | ||
ChartDataSet::~ChartDataSet() | ||||
{ | ||||
|
r2284 | deleteAllSeries(); | ||
deleteAllAxes(); | ||||
|
r131 | } | ||
|
r2273 | /* | ||
* This method adds series to chartdataset, series ownership is taken from caller. | ||||
*/ | ||||
|
r2104 | void ChartDataSet::addSeries(QAbstractSeries *series) | ||
|
r131 | { | ||
|
r2273 | if (m_seriesList.contains(series)) { | ||
qWarning() << QObject::tr("Can not add series. Series already on the chart."); | ||||
return; | ||||
} | ||||
|
r2483 | // Ignore unsupported series added to polar chart | ||
if (m_chart && m_chart->chartType() == QChart::ChartTypePolar) { | ||||
if (!(series->type() == QAbstractSeries::SeriesTypeArea | ||||
|| series->type() == QAbstractSeries::SeriesTypeLine | ||||
|| series->type() == QAbstractSeries::SeriesTypeScatter | ||||
|| series->type() == QAbstractSeries::SeriesTypeSpline)) { | ||||
qWarning() << QObject::tr("Can not add series. Series type is not supported by a polar chart."); | ||||
return; | ||||
} | ||||
|
r2820 | // Disable OpenGL for series in polar charts | ||
series->setUseOpenGL(false); | ||||
|
r2483 | series->d_ptr->setDomain(new XYPolarDomain()); | ||
|
r2791 | // Set the correct domain for upper and lower series too | ||
if (series->type() == QAbstractSeries::SeriesTypeArea) { | ||||
foreach (QObject *child, series->children()) { | ||||
if (qobject_cast<QAbstractSeries *>(child)) { | ||||
QAbstractSeries *childSeries = qobject_cast<QAbstractSeries *>(child); | ||||
childSeries->d_ptr->setDomain(new XYPolarDomain()); | ||||
} | ||||
} | ||||
} | ||||
|
r2483 | } else { | ||
series->d_ptr->setDomain(new XYDomain()); | ||||
} | ||||
|
r2273 | series->d_ptr->initializeDomain(); | ||
m_seriesList.append(series); | ||||
series->setParent(this); // take ownership | ||||
series->d_ptr->m_chart = m_chart; | ||||
emit seriesAdded(series); | ||||
} | ||||
|
r910 | |||
|
r2273 | /* | ||
* This method adds axis to chartdataset, axis ownership is taken from caller. | ||||
*/ | ||||
|
r2483 | void ChartDataSet::addAxis(QAbstractAxis *axis, Qt::Alignment aligment) | ||
|
r2273 | { | ||
if (m_axisList.contains(axis)) { | ||||
qWarning() << QObject::tr("Can not add axis. Axis already on the chart."); | ||||
|
r439 | return; | ||
} | ||||
|
r223 | |||
|
r2273 | axis->d_ptr->setAlignment(aligment); | ||
|
r1695 | |||
|
r2483 | if (!axis->alignment()) { | ||
qWarning() << QObject::tr("No alignment specified !"); | ||||
|
r2273 | return; | ||
}; | ||||
|
r1695 | |||
|
r2483 | AbstractDomain *newDomain; | ||
|
r2547 | if (m_chart && m_chart->chartType() == QChart::ChartTypePolar) | ||
|
r2483 | newDomain = new XYPolarDomain(); | ||
|
r2547 | else | ||
|
r2483 | newDomain = new XYDomain(); | ||
QSharedPointer<AbstractDomain> domain(newDomain); | ||||
|
r2273 | axis->d_ptr->initializeDomain(domain.data()); | ||
|
r223 | |||
|
r2273 | axis->setParent(this); | ||
axis->d_ptr->m_chart = m_chart; | ||||
m_axisList.append(axis); | ||||
|
r421 | |||
|
r2273 | emit axisAdded(axis); | ||
|
r1695 | } | ||
|
r2273 | /* | ||
* This method removes series form chartdataset, series ownership is passed back to caller. | ||||
*/ | ||||
|
r2104 | void ChartDataSet::removeSeries(QAbstractSeries *series) | ||
|
r1695 | { | ||
|
r2273 | if (! m_seriesList.contains(series)) { | ||
qWarning() << QObject::tr("Can not remove series. Series not found on the chart."); | ||||
|
r1695 | return; | ||
} | ||||
|
r2273 | QList<QAbstractAxis*> axes = series->d_ptr->m_axes; | ||
|
r1695 | |||
|
r2273 | foreach(QAbstractAxis* axis, axes) { | ||
|
r2299 | detachAxis(series,axis); | ||
|
r910 | } | ||
|
r2284 | |||
|
r2299 | emit seriesRemoved(series); | ||
m_seriesList.removeAll(series); | ||||
|
r2483 | // Reset domain to default | ||
series->d_ptr->setDomain(new XYDomain()); | ||||
|
r2299 | series->setParent(0); | ||
series->d_ptr->m_chart = 0; | ||||
|
r2820 | |||
QXYSeries *xySeries = qobject_cast<QXYSeries *>(series); | ||||
if (xySeries) | ||||
m_glXYSeriesDataManager->removeSeries(xySeries); | ||||
|
r1695 | } | ||
|
r910 | |||
|
r2273 | /* | ||
* This method removes axis form chartdataset, series ownership is passed back to caller. | ||||
*/ | ||||
void ChartDataSet::removeAxis(QAbstractAxis *axis) | ||||
|
r1577 | { | ||
|
r2273 | if (! m_axisList.contains(axis)) { | ||
qWarning() << QObject::tr("Can not remove axis. Axis not found on the chart."); | ||||
|
r1813 | return; | ||
|
r1588 | } | ||
|
r1577 | |||
|
r2299 | QList<QAbstractSeries*> series = axis->d_ptr->m_series; | ||
foreach(QAbstractSeries* s, series) { | ||||
detachAxis(s,axis); | ||||
} | ||||
|
r2273 | emit axisRemoved(axis); | ||
m_axisList.removeAll(axis); | ||||
|
r1577 | |||
|
r2273 | axis->setParent(0); | ||
axis->d_ptr->m_chart = 0; | ||||
|
r1577 | } | ||
|
r2273 | /* | ||
|
r2284 | * This method attaches axis to series, return true if success. | ||
|
r2273 | */ | ||
|
r2483 | bool ChartDataSet::attachAxis(QAbstractSeries *series,QAbstractAxis *axis) | ||
|
r1588 | { | ||
|
r2273 | Q_ASSERT(axis); | ||
|
r1588 | |||
|
r2669 | if (!series) | ||
return false; | ||||
|
r2483 | QList<QAbstractSeries *> attachedSeriesList = axis->d_ptr->m_series; | ||
QList<QAbstractAxis *> attachedAxisList = series->d_ptr->m_axes; | ||||
|
r1588 | |||
|
r2273 | if (!m_seriesList.contains(series)) { | ||
qWarning() << QObject::tr("Can not find series on the chart."); | ||||
return false; | ||||
} | ||||
|
r1588 | |||
|
r2273 | if (axis && !m_axisList.contains(axis)) { | ||
qWarning() << QObject::tr("Can not find axis on the chart."); | ||||
return false; | ||||
} | ||||
|
r1588 | |||
|
r2273 | if (attachedAxisList.contains(axis)) { | ||
qWarning() << QObject::tr("Axis already attached to series."); | ||||
return false; | ||||
|
r1695 | } | ||
|
r1588 | |||
|
r2284 | if (attachedSeriesList.contains(series)) { | ||
qWarning() << QObject::tr("Axis already attached to series."); | ||||
return false; | ||||
} | ||||
|
r2483 | AbstractDomain *domain = series->d_ptr->domain(); | ||
|
r2284 | AbstractDomain::DomainType type = selectDomain(attachedAxisList<<axis); | ||
|
r2483 | if (type == AbstractDomain::UndefinedDomain) return false; | ||
|
r910 | |||
|
r2483 | if (domain->type() != type) { | ||
|
r2373 | AbstractDomain *old = domain; | ||
|
r2483 | domain = createDomain(type); | ||
|
r2373 | domain->setRange(old->minX(), old->maxX(), old->minY(), old->maxY()); | ||
|
r2483 | // Initialize domain size to old domain size, as it won't get updated | ||
// unless geometry changes. | ||||
domain->setSize(old->size()); | ||||
|
r439 | } | ||
|
r223 | |||
|
r2483 | if (!domain) | ||
return false; | ||||
if (!domain->attachAxis(axis)) | ||||
return false; | ||||
|
r2284 | |||
|
r2483 | QList<AbstractDomain *> blockedDomains; | ||
domain->blockRangeSignals(true); | ||||
blockedDomains << domain; | ||||
|
r2284 | |||
|
r2483 | if (domain != series->d_ptr->domain()) { | ||
foreach (QAbstractAxis *axis, series->d_ptr->m_axes) { | ||||
|
r2292 | series->d_ptr->domain()->detachAxis(axis); | ||
domain->attachAxis(axis); | ||||
|
r2483 | foreach (QAbstractSeries *otherSeries, axis->d_ptr->m_series) { | ||
if (otherSeries != series && otherSeries->d_ptr->domain()) { | ||||
if (!otherSeries->d_ptr->domain()->rangeSignalsBlocked()) { | ||||
otherSeries->d_ptr->domain()->blockRangeSignals(true); | ||||
blockedDomains << otherSeries->d_ptr->domain(); | ||||
} | ||||
} | ||||
} | ||||
|
r2292 | } | ||
|
r2288 | series->d_ptr->setDomain(domain); | ||
series->d_ptr->initializeDomain(); | ||||
} | ||||
|
r2292 | |||
series->d_ptr->m_axes<<axis; | ||||
axis->d_ptr->m_series<<series; | ||||
|
r2273 | series->d_ptr->initializeAxes(); | ||
|
r2285 | axis->d_ptr->initializeDomain(domain); | ||
|
r2273 | |||
|
r2483 | foreach (AbstractDomain *blockedDomain, blockedDomains) | ||
blockedDomain->blockRangeSignals(false); | ||||
|
r2273 | return true; | ||
|
r139 | } | ||
|
r2273 | /* | ||
|
r2284 | * This method detaches axis to series, return true if success. | ||
|
r2273 | */ | ||
bool ChartDataSet::detachAxis(QAbstractSeries* series,QAbstractAxis *axis) | ||||
|
r1725 | { | ||
|
r2273 | Q_ASSERT(series); | ||
Q_ASSERT(axis); | ||||
|
r1725 | |||
|
r2273 | QList<QAbstractSeries* > attachedSeriesList = axis->d_ptr->m_series; | ||
QList<QAbstractAxis* > attachedAxisList = series->d_ptr->m_axes; | ||||
|
r2285 | AbstractDomain* domain = series->d_ptr->domain(); | ||
|
r1725 | |||
|
r2273 | if (!m_seriesList.contains(series)) { | ||
qWarning() << QObject::tr("Can not find series on the chart."); | ||||
return false; | ||||
} | ||||
|
r1725 | |||
|
r2273 | if (axis && !m_axisList.contains(axis)) { | ||
qWarning() << QObject::tr("Can not find axis on the chart."); | ||||
return false; | ||||
} | ||||
|
r1725 | |||
|
r2273 | if (!attachedAxisList.contains(axis)) { | ||
qWarning() << QObject::tr("Axis not attached to series."); | ||||
return false; | ||||
|
r1725 | } | ||
|
r2273 | Q_ASSERT(axis->d_ptr->m_series.contains(series)); | ||
|
r2284 | domain->detachAxis(axis); | ||
|
r2273 | series->d_ptr->m_axes.removeAll(axis); | ||
axis->d_ptr->m_series.removeAll(series); | ||||
|
r139 | |||
|
r2273 | return true; | ||
|
r139 | } | ||
|
r2273 | void ChartDataSet::createDefaultAxes() | ||
|
r139 | { | ||
|
r2273 | if (m_seriesList.isEmpty()) | ||
return; | ||||
|
r1593 | |||
|
r2273 | QAbstractAxis::AxisTypes typeX(0); | ||
QAbstractAxis::AxisTypes typeY(0); | ||||
|
r1652 | |||
|
r2273 | // Remove possibly existing axes | ||
|
r2284 | deleteAllAxes(); | ||
|
r1593 | |||
|
r2273 | Q_ASSERT(m_axisList.isEmpty()); | ||
|
r1593 | |||
|
r2273 | // Select the required axis x and axis y types based on the types of the current series | ||
foreach(QAbstractSeries* s, m_seriesList) { | ||||
typeX |= s->d_ptr->defaultAxisType(Qt::Horizontal); | ||||
typeY |= s->d_ptr->defaultAxisType(Qt::Vertical); | ||||
|
r223 | } | ||
|
r1593 | |||
|
r2719 | createAxes(typeX, Qt::Horizontal); | ||
createAxes(typeY, Qt::Vertical); | ||||
|
r439 | } | ||
|
r223 | |||
|
r2273 | void ChartDataSet::createAxes(QAbstractAxis::AxisTypes type, Qt::Orientation orientation) | ||
|
r439 | { | ||
|
r2273 | QAbstractAxis *axis = 0; | ||
//decide what axis should be created | ||||
|
r1593 | |||
|
r2273 | switch (type) { | ||
case QAbstractAxis::AxisTypeValue: | ||||
axis = new QValueAxis(this); | ||||
break; | ||||
case QAbstractAxis::AxisTypeBarCategory: | ||||
axis = new QBarCategoryAxis(this); | ||||
break; | ||||
case QAbstractAxis::AxisTypeCategory: | ||||
axis = new QCategoryAxis(this); | ||||
break; | ||||
#ifndef Q_WS_QWS | ||||
case QAbstractAxis::AxisTypeDateTime: | ||||
axis = new QDateTimeAxis(this); | ||||
break; | ||||
#endif | ||||
default: | ||||
axis = 0; | ||||
break; | ||||
|
r439 | } | ||
|
r1593 | |||
|
r2273 | if (axis) { | ||
//create one axis for all | ||||
|
r1593 | |||
|
r2273 | addAxis(axis,orientation==Qt::Horizontal?Qt::AlignBottom:Qt::AlignLeft); | ||
|
r2408 | qreal min = 0; | ||
qreal max = 0; | ||||
findMinMaxForSeries(m_seriesList,orientation,min,max); | ||||
|
r2273 | foreach(QAbstractSeries *s, m_seriesList) { | ||
attachAxis(s,axis); | ||||
|
r1738 | } | ||
|
r2408 | axis->setRange(min,max); | ||
|
r2719 | } else { | ||
// Create separate axis for each series | ||||
|
r2273 | foreach(QAbstractSeries *s, m_seriesList) { | ||
QAbstractAxis *axis = s->d_ptr->createDefaultAxis(orientation); | ||||
if(axis) { | ||||
addAxis(axis,orientation==Qt::Horizontal?Qt::AlignBottom:Qt::AlignLeft); | ||||
attachAxis(s,axis); | ||||
} | ||||
} | ||||
|
r538 | } | ||
} | ||||
|
r2408 | void ChartDataSet::findMinMaxForSeries(QList<QAbstractSeries *> series,Qt::Orientations orientation, qreal &min, qreal &max) | ||
{ | ||||
|
r2712 | Q_ASSERT(!series.isEmpty()); | ||
|
r2408 | |||
|
r2483 | AbstractDomain *domain = series.first()->d_ptr->domain(); | ||
|
r2712 | min = (orientation == Qt::Vertical) ? domain->minY() : domain->minX(); | ||
max = (orientation == Qt::Vertical) ? domain->maxY() : domain->maxX(); | ||||
|
r2408 | |||
|
r2483 | for (int i = 1; i< series.size(); i++) { | ||
AbstractDomain *domain = series[i]->d_ptr->domain(); | ||||
|
r2712 | min = qMin((orientation == Qt::Vertical) ? domain->minY() : domain->minX(), min); | ||
max = qMax((orientation == Qt::Vertical) ? domain->maxY() : domain->maxX(), max); | ||||
} | ||||
|
r2414 | if (min == max) { | ||
min -= 0.5; | ||||
max += 0.5; | ||||
} | ||||
|
r2408 | } | ||
|
r2284 | void ChartDataSet::deleteAllSeries() | ||
|
r1554 | { | ||
|
r2284 | foreach (QAbstractSeries *s , m_seriesList){ | ||
|
r2273 | removeSeries(s); | ||
|
r2299 | s->deleteLater(); | ||
|
r2284 | } | ||
|
r2273 | Q_ASSERT(m_seriesList.count() == 0); | ||
|
r1554 | } | ||
|
r2284 | void ChartDataSet::deleteAllAxes() | ||
|
r223 | { | ||
|
r2284 | foreach (QAbstractAxis *a , m_axisList){ | ||
|
r2273 | removeAxis(a); | ||
|
r2299 | a->deleteLater(); | ||
|
r2284 | } | ||
|
r2273 | Q_ASSERT(m_axisList.count() == 0); | ||
|
r223 | } | ||
|
r2273 | void ChartDataSet::zoomInDomain(const QRectF &rect) | ||
|
r1554 | { | ||
|
r2275 | QList<AbstractDomain*> domains; | ||
|
r2273 | foreach(QAbstractSeries *s, m_seriesList) { | ||
|
r2285 | AbstractDomain* domain = s->d_ptr->domain(); | ||
|
r2289 | s->d_ptr->m_domain->blockRangeSignals(true); | ||
|
r2273 | domains<<domain; | ||
|
r1699 | } | ||
|
r2275 | foreach(AbstractDomain *domain, domains) | ||
|
r2273 | domain->zoomIn(rect); | ||
|
r1564 | |||
|
r2275 | foreach(AbstractDomain *domain, domains) | ||
|
r2289 | domain->blockRangeSignals(false); | ||
|
r2273 | } | ||
|
r1564 | |||
|
r2273 | void ChartDataSet::zoomOutDomain(const QRectF &rect) | ||
{ | ||||
|
r2275 | QList<AbstractDomain*> domains; | ||
|
r2273 | foreach(QAbstractSeries *s, m_seriesList) { | ||
|
r2285 | AbstractDomain* domain = s->d_ptr->domain(); | ||
|
r2289 | s->d_ptr->m_domain->blockRangeSignals(true); | ||
|
r2273 | domains<<domain; | ||
|
r1564 | } | ||
|
r2275 | foreach(AbstractDomain *domain, domains) | ||
|
r2273 | domain->zoomOut(rect); | ||
|
r1564 | |||
|
r2275 | foreach(AbstractDomain *domain, domains) | ||
|
r2289 | domain->blockRangeSignals(false); | ||
|
r2273 | } | ||
|
r1813 | |||
|
r2545 | void ChartDataSet::zoomResetDomain() | ||
{ | ||||
QList<AbstractDomain*> domains; | ||||
foreach (QAbstractSeries *s, m_seriesList) { | ||||
AbstractDomain *domain = s->d_ptr->domain(); | ||||
s->d_ptr->m_domain->blockRangeSignals(true); | ||||
domains << domain; | ||||
} | ||||
foreach (AbstractDomain *domain, domains) | ||||
domain->zoomReset(); | ||||
foreach (AbstractDomain *domain, domains) | ||||
domain->blockRangeSignals(false); | ||||
} | ||||
bool ChartDataSet::isZoomedDomain() | ||||
{ | ||||
foreach (QAbstractSeries *s, m_seriesList) { | ||||
if (s->d_ptr->domain()->isZoomed()) | ||||
return true; | ||||
} | ||||
return false; | ||||
} | ||||
|
r2273 | void ChartDataSet::scrollDomain(qreal dx, qreal dy) | ||
{ | ||||
|
r2275 | QList<AbstractDomain*> domains; | ||
|
r2273 | foreach(QAbstractSeries *s, m_seriesList) { | ||
|
r2289 | AbstractDomain* domain = s->d_ptr->domain(); | ||
s->d_ptr->m_domain->blockRangeSignals(true); | ||||
|
r2273 | domains<<domain; | ||
|
r1577 | } | ||
|
r1564 | |||
|
r2275 | foreach(AbstractDomain *domain, domains) | ||
|
r2273 | domain->move(dx, dy); | ||
|
r1564 | |||
|
r2275 | foreach(AbstractDomain *domain, domains) | ||
|
r2289 | domain->blockRangeSignals(false); | ||
|
r1542 | } | ||
|
r2344 | QPointF ChartDataSet::mapToValue(const QPointF &position, QAbstractSeries *series) | ||
{ | ||||
QPointF point; | ||||
if (series == 0 && !m_seriesList.isEmpty()) | ||||
series = m_seriesList.first(); | ||||
|
r2351 | if (series && series->type() == QAbstractSeries::SeriesTypePie) | ||
return point; | ||||
|
r2344 | if (series && m_seriesList.contains(series)) | ||
|
r2351 | point = series->d_ptr->m_domain->calculateDomainPoint(position - m_chart->plotArea().topLeft()); | ||
|
r2344 | return point; | ||
} | ||||
QPointF ChartDataSet::mapToPosition(const QPointF &value, QAbstractSeries *series) | ||||
{ | ||||
QPointF point = m_chart->plotArea().topLeft(); | ||||
if (series == 0 && !m_seriesList.isEmpty()) | ||||
series = m_seriesList.first(); | ||||
|
r2351 | if (series && series->type() == QAbstractSeries::SeriesTypePie) | ||
return QPoint(0, 0); | ||||
|
r2356 | bool ok; | ||
|
r2344 | if (series && m_seriesList.contains(series)) | ||
|
r2356 | point += series->d_ptr->m_domain->calculateGeometryPoint(value, ok); | ||
|
r2344 | return point; | ||
} | ||||
|
r2483 | QList<QAbstractAxis *> ChartDataSet::axes() const | ||
|
r531 | { | ||
|
r2273 | return m_axisList; | ||
|
r1078 | } | ||
|
r2104 | QList<QAbstractSeries *> ChartDataSet::series() const | ||
|
r1078 | { | ||
|
r2273 | return m_seriesList; | ||
|
r531 | } | ||
|
r2273 | |||
|
r2483 | AbstractDomain::DomainType ChartDataSet::selectDomain(QList<QAbstractAxis *> axes) | ||
|
r2284 | { | ||
enum Type { | ||||
|
r2288 | Undefined = 0, | ||
|
r2284 | LogType = 0x1, | ||
ValueType = 0x2 | ||||
}; | ||||
|
r2288 | int horizontal(Undefined); | ||
int vertical(Undefined); | ||||
|
r2284 | |||
|
r2483 | // Assume cartesian chart type, unless chart is set | ||
QChart::ChartType chartType(QChart::ChartTypeCartesian); | ||||
if (m_chart) | ||||
chartType = m_chart->chartType(); | ||||
|
r2288 | |||
|
r2483 | foreach (QAbstractAxis *axis, axes) | ||
{ | ||||
switch (axis->type()) { | ||||
case QAbstractAxis::AxisTypeLogValue: | ||||
if (axis->orientation() == Qt::Horizontal) | ||||
horizontal |= LogType; | ||||
if (axis->orientation() == Qt::Vertical) | ||||
vertical |= LogType; | ||||
|
r2284 | break; | ||
|
r2483 | case QAbstractAxis::AxisTypeValue: | ||
case QAbstractAxis::AxisTypeBarCategory: | ||||
case QAbstractAxis::AxisTypeCategory: | ||||
case QAbstractAxis::AxisTypeDateTime: | ||||
if (axis->orientation() == Qt::Horizontal) | ||||
horizontal |= ValueType; | ||||
if (axis->orientation() == Qt::Vertical) | ||||
vertical |= ValueType; | ||||
|
r2284 | break; | ||
|
r2483 | default: | ||
qWarning() << "Undefined type"; | ||||
|
r2284 | break; | ||
} | ||||
} | ||||
|
r2483 | if (vertical == Undefined) | ||
vertical = ValueType; | ||||
if (horizontal == Undefined) | ||||
horizontal = ValueType; | ||||
|
r2288 | |||
|
r2483 | if (vertical == ValueType && horizontal == ValueType) { | ||
if (chartType == QChart::ChartTypeCartesian) | ||||
return AbstractDomain::XYDomain; | ||||
else if (chartType == QChart::ChartTypePolar) | ||||
return AbstractDomain::XYPolarDomain; | ||||
|
r2284 | } | ||
|
r2483 | if (vertical == LogType && horizontal == ValueType) { | ||
if (chartType == QChart::ChartTypeCartesian) | ||||
return AbstractDomain::XLogYDomain; | ||||
if (chartType == QChart::ChartTypePolar) | ||||
return AbstractDomain::XLogYPolarDomain; | ||||
|
r2284 | } | ||
|
r2483 | if (vertical == ValueType && horizontal == LogType) { | ||
if (chartType == QChart::ChartTypeCartesian) | ||||
return AbstractDomain::LogXYDomain; | ||||
else if (chartType == QChart::ChartTypePolar) | ||||
return AbstractDomain::LogXYPolarDomain; | ||||
|
r2284 | } | ||
|
r2483 | if (vertical == LogType && horizontal == LogType) { | ||
if (chartType == QChart::ChartTypeCartesian) | ||||
return AbstractDomain::LogXLogYDomain; | ||||
else if (chartType == QChart::ChartTypePolar) | ||||
return AbstractDomain::LogXLogYPolarDomain; | ||||
|
r2284 | } | ||
return AbstractDomain::UndefinedDomain; | ||||
} | ||||
//refactor create factory | ||||
AbstractDomain* ChartDataSet::createDomain(AbstractDomain::DomainType type) | ||||
{ | ||||
|
r2483 | switch (type) | ||
{ | ||||
case AbstractDomain::LogXLogYDomain: | ||||
return new LogXLogYDomain(); | ||||
case AbstractDomain::XYDomain: | ||||
return new XYDomain(); | ||||
case AbstractDomain::XLogYDomain: | ||||
return new XLogYDomain(); | ||||
case AbstractDomain::LogXYDomain: | ||||
return new LogXYDomain(); | ||||
case AbstractDomain::XYPolarDomain: | ||||
return new XYPolarDomain(); | ||||
case AbstractDomain::XLogYPolarDomain: | ||||
return new XLogYPolarDomain(); | ||||
case AbstractDomain::LogXYPolarDomain: | ||||
return new LogXYPolarDomain(); | ||||
case AbstractDomain::LogXLogYPolarDomain: | ||||
return new LogXLogYPolarDomain(); | ||||
default: | ||||
return 0; | ||||
} | ||||
|
r2284 | } | ||
|
r131 | #include "moc_chartdataset_p.cpp" | ||
|
r2712 | QT_CHARTS_END_NAMESPACE | ||