qiurui
/
qtgraphs
mirror of https://github.com/qt/qtgraphs.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Remove AbstractDomain 

This concept is not used in QtGraphs2D, so remove it.

Pick-to: 6.7
Change-Id: Iff61ad73dff816f653b1d41247beb454c165a314
Reviewed-by: <owais.akhtar@qt.io>
Reviewed-by: Tomi Korpipää <tomi.korpipaa@qt.io>
Reviewed-by: Jere Tuliniemi <jere.tuliniemi@qt.io>
This commit is contained in:
Kaj Grönholm 2024-01-04 11:00:16 +02:00
parent 13348084de
commit be388b52b3
16 changed files with 0 additions and 528 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
src/graphs2d/CMakeLists.txt
View File

@ -14,7 +14,6 @@ qt_internal_add_qml_module(Graphs2D
qgraphsview.cpp qgraphsview_p.h
qabstractseries.cpp qabstractseries.h qabstractseries_p.h
charthelpers_p.h
domain/abstractdomain.cpp domain/abstractdomain_p.h
barchart/qbarseries.cpp barchart/qbarseries.h barchart/qbarseries_p.h
barchart/qabstractbarseries.cpp barchart/qabstractbarseries.h barchart/qabstractbarseries_p.h
barchart/qbarset.cpp barchart/qbarset.h barchart/qbarset_p.h

25
src/graphs2d/axis/barcategoryaxis/qbarcategoryaxis.cpp
View File

@ -5,7 +5,6 @@
#include <QtGraphs2D/QBarCategoryAxis>
#include <private/qbarcategoryaxis_p.h>
#include <private/abstractdomain_p.h>
#include <QtCore/QtMath>
QT_BEGIN_NAMESPACE
@ -228,8 +227,6 @@ void QBarCategoryAxis::remove(const QString &category)
setRange(d->m_categories.first(), d->m_maxCategory);
} else if (d->m_maxCategory == category) {
setRange(d->m_minCategory, d->m_categories.last());
} else {
d->updateCategoryDomain();
}
} else {
setRange(QString(), QString());
@ -262,8 +259,6 @@ void QBarCategoryAxis::insert(int index, const QString &category)
setRange(d->m_categories.first(), d->m_maxCategory);
} else if (index == count) {
setRange(d->m_minCategory, d->m_categories.last());
} else {
d->updateCategoryDomain();
}
emit categoriesChanged();
@ -532,26 +527,6 @@ void QBarCategoryAxisPrivate::setRange(const QString &minCategory, const QStrin
}
}
void QBarCategoryAxisPrivate::updateCategoryDomain()
{
bool changed = false;
qreal tmpMin = m_categories.indexOf(m_minCategory) - 0.5;
if (!qFuzzyIsNull(m_min - tmpMin)) {
m_min = tmpMin;
changed = true;
}
qreal tmpMax = m_categories.indexOf(m_maxCategory) + 0.5;
if (!qFuzzyIsNull(m_max - tmpMax)) {
m_max = tmpMax;
changed = true;
}
m_count = m_max - m_min;
if (changed)
emit rangeChanged(m_min,m_max);
}
QT_END_NAMESPACE
#include "moc_qbarcategoryaxis.cpp"

4
src/graphs2d/axis/barcategoryaxis/qbarcategoryaxis_p.h
View File

@ -18,8 +18,6 @@
QT_BEGIN_NAMESPACE
class AbstractDomain;
class QBarCategoryAxisPrivate : public QAbstractAxisPrivate
{
Q_OBJECT
@ -29,8 +27,6 @@ public:
~QBarCategoryAxisPrivate();
public:
void updateCategoryDomain();
//interface for manipulating range form base class
void setRange(const QVariant &min, const QVariant &max) override;
void setMin(const QVariant &min) override;

1
src/graphs2d/axis/qabstractaxis.h
View File

@ -122,7 +122,6 @@ protected:
friend class ChartDataSet;
friend class ChartPresenter;
friend class ChartThemeManager;
friend class AbstractDomain;
friend class ChartAxisElement;
friend class HorizontalAxis;
friend class VerticalAxis;

1
src/graphs2d/axis/qabstractaxis_p.h
View File

@ -26,7 +26,6 @@ QT_END_NAMESPACE
QT_BEGIN_NAMESPACE
class AbstractDomain;
class QAbstractSeries;
class QAbstractAxisPrivate : public QObject

1
src/graphs2d/axis/valueaxis/qvalueaxis.cpp
View File

@ -3,7 +3,6 @@
#include <QtGraphs2D/QValueAxis>
#include <private/qvalueaxis_p.h>
#include <private/abstractdomain_p.h>
#include <private/charthelpers_p.h>
#include <QtCore/QtMath>

18
src/graphs2d/barchart/qabstractbarseries.cpp
View File

@ -947,24 +947,6 @@ qreal QAbstractBarSeriesPrivate::labelsAngle() const
return m_labelsAngle;
}
void QAbstractBarSeriesPrivate::initializeDomain()
{
qreal minX(domain()->minX());
qreal minY(domain()->minY());
qreal maxX(domain()->maxX());
qreal maxY(domain()->maxY());
qreal seriesMinX = this->minX();
qreal seriesMaxX = this->maxX();
qreal y = max();
minX = qMin(minX, seriesMinX - (qreal)0.5);
minY = qMin(minY, y);
maxX = qMax(maxX, seriesMaxX + (qreal)0.5);
maxY = qMax(maxY, y);
domain()->setRange(minX, maxX, minY, maxY);
}
bool QAbstractBarSeriesPrivate::append(QBarSet *set)
{
if ((m_barSets.contains(set)) || (set == 0))

1
src/graphs2d/barchart/qabstractbarseries_p.h
View File

@ -37,7 +37,6 @@ public:
void setVisible(bool visible);
void setLabelsVisible(bool visible);
void initializeDomain() override;
void initializeAxes() override;
bool append(QBarSet *set);

17
src/graphs2d/barchart/qbarseries.cpp
View File

@ -102,23 +102,6 @@ QBarSeriesPrivate::QBarSeriesPrivate(QBarSeries *q) : QAbstractBarSeriesPrivate(
}
void QBarSeriesPrivate::initializeDomain()
{
qreal minX(domain()->minX());
qreal minY(domain()->minY());
qreal maxX(domain()->maxX());
qreal maxY(domain()->maxY());
qreal x = categoryCount();
minX = qMin(minX, - (qreal)0.5);
minY = qMin(minY, min());
maxX = qMax(maxX, x - (qreal)0.5);
maxY = qMax(maxY, max());
domain()->setRange(minX, maxX, minY, maxY);
}
void QBarSeriesPrivate::initializeGraphics(QGraphicsItem* parent)
{
QAbstractSeriesPrivate::initializeGraphics(parent);

2
src/graphs2d/barchart/qbarseries_p.h
View File

@ -14,7 +14,6 @@
#define QBARSERIES_P_H
#include <private/qabstractbarseries_p.h>
#include <private/abstractdomain_p.h>
QT_BEGIN_NAMESPACE
@ -24,7 +23,6 @@ class QBarSeriesPrivate : public QAbstractBarSeriesPrivate
public:
QBarSeriesPrivate(QBarSeries *q);
void initializeGraphics(QGraphicsItem* parent) override;
void initializeDomain() override;
private:
Q_DECLARE_PUBLIC(QBarSeries)

291
src/graphs2d/domain/abstractdomain.cpp
View File

@ -1,291 +0,0 @@
// Copyright (C) 2023 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
//#include <private/abstractdomain_p.h>
//#include <private/qabstractaxis_p.h>
#include <private/abstractdomain_p.h>
#include <QtCore/QtMath>
#include <cmath>
QT_BEGIN_NAMESPACE
AbstractDomain::AbstractDomain(QObject *parent)
: QObject(parent),
m_minX(0),
m_maxX(0),
m_minY(0),
m_maxY(0),
m_signalsBlocked(false),
m_zoomed(false),
m_zoomResetMinX(0),
m_zoomResetMaxX(0),
m_zoomResetMinY(0),
m_zoomResetMaxY(0),
m_reverseX(false),
m_reverseY(false)
{
}
AbstractDomain::~AbstractDomain()
{
}
void AbstractDomain::setSize(const QSizeF &size)
{
if (!size.isValid())
return;
if (m_size != size) {
m_size=size;
emit updated();
}
}
QSizeF AbstractDomain::size() const
{
return m_size;
}
void AbstractDomain::setRangeX(qreal min, qreal max)
{
setRange(min, max, m_minY, m_maxY);
}
void AbstractDomain::setRangeY(qreal min, qreal max)
{
setRange(m_minX, m_maxX, min, max);
}
void AbstractDomain::setMinX(qreal min)
{
setRange(min, m_maxX, m_minY, m_maxY);
}
void AbstractDomain::setMaxX(qreal max)
{
setRange(m_minX, max, m_minY, m_maxY);
}
void AbstractDomain::setMinY(qreal min)
{
setRange(m_minX, m_maxX, min, m_maxY);
}
void AbstractDomain::setMaxY(qreal max)
{
setRange(m_minX, m_maxX, m_minY, max);
}
qreal AbstractDomain::spanX() const
{
Q_ASSERT(m_maxX >= m_minX);
return m_maxX - m_minX;
}
qreal AbstractDomain::spanY() const
{
Q_ASSERT(m_maxY >= m_minY);
return m_maxY - m_minY;
}
bool AbstractDomain::isEmpty() const
{
return qFuzzyCompare(spanX(), 0) || qFuzzyCompare(spanY(), 0) || m_size.isEmpty();
}
// handlers
void AbstractDomain::handleVerticalAxisRangeChanged(qreal min, qreal max)
{
setRangeY(min, max);
}
void AbstractDomain::handleHorizontalAxisRangeChanged(qreal min, qreal max)
{
setRangeX(min, max);
}
void AbstractDomain::handleReverseXChanged(bool reverse)
{
m_reverseX = reverse;
emit updated();
}
void AbstractDomain::handleReverseYChanged(bool reverse)
{
m_reverseY = reverse;
emit updated();
}
void AbstractDomain::blockRangeSignals(bool block)
{
if (m_signalsBlocked!=block) {
m_signalsBlocked=block;
if (!block) {
emit rangeHorizontalChanged(m_minX,m_maxX);
emit rangeVerticalChanged(m_minY,m_maxY);
}
}
}
void AbstractDomain::zoomReset()
{
if (m_zoomed) {
setRange(m_zoomResetMinX,
m_zoomResetMaxX,
m_zoomResetMinY,
m_zoomResetMaxY);
m_zoomed = false;
}
}
void AbstractDomain::storeZoomReset()
{
if (!m_zoomed) {
m_zoomed = true;
m_zoomResetMinX = m_minX;
m_zoomResetMaxX = m_maxX;
m_zoomResetMinY = m_minY;
m_zoomResetMaxY = m_maxY;
}
}
//algorithm defined by Paul S.Heckbert GraphicalGems I
void AbstractDomain::looseNiceNumbers(qreal &min, qreal &max, int &ticksCount)
{
qreal range = niceNumber(max - min, true); //range with ceiling
qreal step = niceNumber(range / (ticksCount - 1), false);
min = std::floor(min / step);
max = std::ceil(max / step);
ticksCount = int(max - min) + 1;
min *= step;
max *= step;
}
//nice numbers can be expressed as form of 1*10^n, 2* 10^n or 5*10^n
qreal AbstractDomain::niceNumber(qreal x, bool ceiling)
{
qreal z = qPow(10, qFloor(std::log10(x))); //find corresponding number of the form of 10^n than is smaller than x
qreal q = x / z; //q<10 && q>=1;
if (ceiling) {
if (q <= 1.0) q = 1;
else if (q <= 2.0) q = 2;
else if (q <= 5.0) q = 5;
else q = 10;
} else {
if (q < 1.5) q = 1;
else if (q < 3.0) q = 2;
else if (q < 7.0) q = 5;
else q = 10;
}
return q * z;
}
/*
bool AbstractDomain::attachAxis(QAbstractAxis *axis)
{
if (axis->orientation() == Qt::Vertical) {
// Color axis isn't connected to range-related slots/signals as it doesn't need
// geometry domain and it doesn't need to handle zooming or scrolling.
if (axis->type() != QAbstractAxis::AxisTypeColor) {
QObject::connect(axis->d_ptr.data(), SIGNAL(rangeChanged(qreal, qreal)), this,
SLOT(handleVerticalAxisRangeChanged(qreal, qreal)));
QObject::connect(this, SIGNAL(rangeVerticalChanged(qreal, qreal)), axis->d_ptr.data(),
SLOT(handleRangeChanged(qreal, qreal)));
}
QObject::connect(axis, &QAbstractAxis::reverseChanged,
this, &AbstractDomain::handleReverseYChanged);
m_reverseY = axis->isReverse();
}
if (axis->orientation() == Qt::Horizontal) {
if (axis->type() != QAbstractAxis::AxisTypeColor) {
QObject::connect(axis->d_ptr.data(), SIGNAL(rangeChanged(qreal, qreal)), this,
SLOT(handleHorizontalAxisRangeChanged(qreal, qreal)));
QObject::connect(this, SIGNAL(rangeHorizontalChanged(qreal, qreal)), axis->d_ptr.data(),
SLOT(handleRangeChanged(qreal, qreal)));
}
QObject::connect(axis, &QAbstractAxis::reverseChanged,
this, &AbstractDomain::handleReverseXChanged);
m_reverseX = axis->isReverse();
}
return true;
}
bool AbstractDomain::detachAxis(QAbstractAxis *axis)
{
if (axis->orientation() == Qt::Vertical) {
QObject::disconnect(axis->d_ptr.data(), SIGNAL(rangeChanged(qreal,qreal)), this, SLOT(handleVerticalAxisRangeChanged(qreal,qreal)));
QObject::disconnect(this, SIGNAL(rangeVerticalChanged(qreal,qreal)), axis->d_ptr.data(), SLOT(handleRangeChanged(qreal,qreal)));
QObject::disconnect(axis, &QAbstractAxis::reverseChanged, this, &AbstractDomain::handleReverseYChanged);
}
if (axis->orientation() == Qt::Horizontal) {
QObject::disconnect(axis->d_ptr.data(), SIGNAL(rangeChanged(qreal,qreal)), this, SLOT(handleHorizontalAxisRangeChanged(qreal,qreal)));
QObject::disconnect(this, SIGNAL(rangeHorizontalChanged(qreal,qreal)), axis->d_ptr.data(), SLOT(handleRangeChanged(qreal,qreal)));
QObject::disconnect(axis, &QAbstractAxis::reverseChanged, this, &AbstractDomain::handleReverseXChanged);
}
return true;
}
*/
// operators
bool Q_AUTOTEST_EXPORT operator== (const AbstractDomain &domain1, const AbstractDomain &domain2)
{
return (qFuzzyIsNull(domain1.m_maxX - domain2.m_maxX)
&& qFuzzyIsNull(domain1.m_maxY - domain2.m_maxY)
&& qFuzzyIsNull(domain1.m_minX - domain2.m_minX)
&& qFuzzyIsNull(domain1.m_minY - domain2.m_minY));
}
bool Q_AUTOTEST_EXPORT operator!= (const AbstractDomain &domain1, const AbstractDomain &domain2)
{
return !(domain1 == domain2);
}
QDebug Q_AUTOTEST_EXPORT operator<<(QDebug dbg, const AbstractDomain &domain)
{
#ifdef QT_NO_TEXTSTREAM
Q_UNUSED(domain);
#else
dbg.nospace() << "AbstractDomain(" << domain.m_minX << ',' << domain.m_maxX << ',' << domain.m_minY << ',' << domain.m_maxY << ')' << domain.m_size;
#endif
return dbg.maybeSpace();
}
// This function adjusts min/max ranges to failsafe values if negative/zero values are attempted.
void AbstractDomain::adjustLogDomainRanges(qreal &min, qreal &max)
{
if (min <= 0) {
min = 1.0;
if (max <= min)
max = min + 1.0;
}
}
// This function fixes the zoom rect based on axis reversals
QRectF AbstractDomain::fixZoomRect(const QRectF &rect)
{
QRectF fixRect = rect;
if (m_reverseX || m_reverseY) {
QPointF center = rect.center();
if (m_reverseX)
center.setX(m_size.width() - center.x());
if (m_reverseY)
center.setY(m_size.height() - center.y());
fixRect.moveCenter(QPointF(center.x(), center.y()));
}
return fixRect;
}
QT_END_NAMESPACE
#include "moc_abstractdomain_p.cpp"

124
src/graphs2d/domain/abstractdomain_p.h
View File

@ -1,124 +0,0 @@
// Copyright (C) 2023 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
// W A R N I N G
// -------------
//
// This file is not part of the Qt Chart API. It exists purely as an
// implementation detail. This header file may change from version to
// version without notice, or even be removed.
//
// We mean it.
#ifndef ABSTRACTDOMAIN_H
#define ABSTRACTDOMAIN_H
#include <QtCore/QRectF>
#include <QtCore/QSizeF>
#include <QtCore/QDebug>
#include <QtCore/QObject>
QT_BEGIN_NAMESPACE
class QAbstractAxis;
class AbstractDomain: public QObject
{
Q_OBJECT
public:
enum DomainType { UndefinedDomain,
XYDomain,
XLogYDomain,
LogXYDomain,
LogXLogYDomain,
XYPolarDomain,
XLogYPolarDomain,
LogXYPolarDomain,
LogXLogYPolarDomain };
public:
explicit AbstractDomain(QObject *object = 0);
virtual ~AbstractDomain();
virtual void setSize(const QSizeF &size);
QSizeF size() const;
virtual DomainType type() = 0;
virtual void setRange(qreal minX, qreal maxX, qreal minY, qreal maxY) = 0;
void setRangeX(qreal min, qreal max);
void setRangeY(qreal min, qreal max);
void setMinX(qreal min);
void setMaxX(qreal max);
void setMinY(qreal min);
void setMaxY(qreal max);
qreal minX() const { return m_minX; }
qreal maxX() const { return m_maxX; }
qreal minY() const { return m_minY; }
qreal maxY() const { return m_maxY; }
qreal spanX() const;
qreal spanY() const;
bool isEmpty() const;
void blockRangeSignals(bool block);
bool rangeSignalsBlocked() const { return m_signalsBlocked; }
void zoomReset();
void storeZoomReset();
bool isZoomed() { return m_zoomed; }
friend bool Q_AUTOTEST_EXPORT operator== (const AbstractDomain &domain1, const AbstractDomain &domain2);
friend bool Q_AUTOTEST_EXPORT operator!= (const AbstractDomain &domain1, const AbstractDomain &domain2);
friend QDebug Q_AUTOTEST_EXPORT operator<<(QDebug dbg, const AbstractDomain &domain);
virtual void zoomIn(const QRectF &rect) = 0;
virtual void zoomOut(const QRectF &rect) = 0;
virtual void move(qreal dx, qreal dy) = 0;
virtual QPointF calculateGeometryPoint(const QPointF &point, bool &ok) const = 0;
virtual QPointF calculateDomainPoint(const QPointF &point) const = 0;
virtual QList<QPointF> calculateGeometryPoints(const QList<QPointF> &list) const = 0;
static void looseNiceNumbers(qreal &min, qreal &max, int &ticksCount);
static qreal niceNumber(qreal x, bool ceiling);
void setReverseX(bool reverse) { m_reverseX = reverse; }
void setReverseY(bool reverse) { m_reverseY = reverse; }
bool isReverseX() const { return m_reverseX; }
bool isReverseY() const { return m_reverseY; }
Q_SIGNALS:
void updated();
void rangeHorizontalChanged(qreal min, qreal max);
void rangeVerticalChanged(qreal min, qreal max);
public Q_SLOTS:
void handleVerticalAxisRangeChanged(qreal min,qreal max);
void handleHorizontalAxisRangeChanged(qreal min,qreal max);
void handleReverseXChanged(bool reverse);
void handleReverseYChanged(bool reverse);
protected:
void adjustLogDomainRanges(qreal &min, qreal &max);
QRectF fixZoomRect(const QRectF &rect);
qreal m_minX;
qreal m_maxX;
qreal m_minY;
qreal m_maxY;
QSizeF m_size;
bool m_signalsBlocked;
bool m_zoomed;
qreal m_zoomResetMinX;
qreal m_zoomResetMaxX;
qreal m_zoomResetMinY;
qreal m_zoomResetMaxY;
bool m_reverseX;
bool m_reverseY;
};
QT_END_NAMESPACE
#endif // ABSTRACTDOMAIN_H

5
src/graphs2d/qabstractseries.cpp
View File

@ -470,11 +470,6 @@ QAbstractSeriesPrivate::~QAbstractSeriesPrivate()
{
}
void QAbstractSeriesPrivate::setDomain(AbstractDomain* domain)
{
Q_UNUSED(domain);
}
void QAbstractSeriesPrivate::initializeGraphics(QGraphicsItem* parent)
{
Q_UNUSED(parent);

6
src/graphs2d/qabstractseries_p.h
View File

@ -15,7 +15,6 @@
// We mean it.
#include <QtGraphs2D/qabstractseries.h>
#include <private/abstractdomain_p.h>
#include <memory>
@ -44,13 +43,9 @@ public:
QAbstractSeriesPrivate(QAbstractSeries *q);
~QAbstractSeriesPrivate();
virtual void initializeDomain() = 0;
virtual void initializeAxes() = 0;
virtual void initializeGraphics(QGraphicsItem* parent) = 0;
virtual void setDomain(AbstractDomain* domain);
AbstractDomain* domain() { return m_domain.data(); }
Q_SIGNALS:
void countChanged();
@ -61,7 +56,6 @@ protected:
private:
SeriesTheme *m_theme = nullptr;
QScopedPointer<AbstractDomain> m_domain;
QString m_name;
bool m_visible;
bool m_selectable = false;

30
src/graphs2d/xychart/qxyseries.cpp
View File

@ -345,36 +345,6 @@ QXYSeriesPrivate::QXYSeriesPrivate(QXYSeries *q)
{
}
void QXYSeriesPrivate::initializeDomain()
{
qreal minX(0);
qreal minY(0);
qreal maxX(1);
qreal maxY(1);
Q_Q(QXYSeries);
const QList<QPointF> &points = q->points();
if (!points.isEmpty()) {
minX = points[0].x();
minY = points[0].y();
maxX = minX;
maxY = minY;
for (int i = 0; i < points.size(); 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 QXYSeriesPrivate::initializeAxes()
{
}

1
src/graphs2d/xychart/qxyseries_p.h
View File

@ -27,7 +27,6 @@ class QXYSeriesPrivate : public QAbstractSeriesPrivate
public:
QXYSeriesPrivate(QXYSeries *q);
void initializeDomain() override;
void initializeAxes() override;
void setPointSelected(int index, bool selected, bool &callSignal);