KDChartAbstractCoordinatePlane.h

Go to the documentation of this file.

/****************************************************************************
**
** This file is part of the KD Chart library.
**
** SPDX-FileCopyrightText: 2001 Klarälvdalens Datakonsult AB, a KDAB Group company <info@kdab.com>
**
** SPDX-License-Identifier: MIT
**
****************************************************************************/
 
#ifndef KDCHARTABSTRACTCOORDINATEPLANE_H
#define KDCHARTABSTRACTCOORDINATEPLANE_H
 
#include <QList>
#include <QObject>
 
#include "KDChartAbstractArea.h"
#include "KDChartAbstractDiagram.h"
#include "KDChartEnums.h"
 
namespace KDChart {
 
class Chart;
class GridAttributes;
class DataDimension;
 
typedef QList<DataDimension> DataDimensionsList;
 
class KDCHART_EXPORT AbstractCoordinatePlane : public AbstractArea
{
    Q_OBJECT
 
    KDCHART_DECLARE_PRIVATE_DERIVED_PARENT(AbstractCoordinatePlane, Chart *)
 
    friend class AbstractGrid;
 
public:
    enum AxesCalcMode
    {
        Linear,
        Logarithmic
    };
 
protected:
    explicit AbstractCoordinatePlane(Chart *parent = nullptr);
 
public:
    ~AbstractCoordinatePlane() override;
 
    virtual void addDiagram(AbstractDiagram *diagram);
 
    virtual void replaceDiagram(AbstractDiagram *diagram, AbstractDiagram *oldDiagram = nullptr);
 
    virtual void takeDiagram(AbstractDiagram *diagram);
 
    AbstractDiagram *diagram();
 
    AbstractDiagramList diagrams();
 
    ConstAbstractDiagramList diagrams() const;
 
    virtual void layoutDiagrams() = 0;
 
    virtual const QPointF translate(const QPointF &diagramPoint) const = 0;
 
    bool isRubberBandZoomingEnabled() const;
 
    void setRubberBandZoomingEnabled(bool enable);
 
    virtual qreal zoomFactorX() const
    {
        return 1.0;
    }
 
    virtual qreal zoomFactorY() const
    {
        return 1.0;
    }
 
    virtual void setZoomFactors(qreal factorX, qreal factorY)
    {
        Q_UNUSED(factorX);
        Q_UNUSED(factorY);
    }
 
    virtual void setZoomFactorX(qreal factor)
    {
        Q_UNUSED(factor);
    }
 
    virtual void setZoomFactorY(qreal factor)
    {
        Q_UNUSED(factor);
    }
 
    virtual QPointF zoomCenter() const
    {
        return QPointF(0.0, 0.0);
    }
 
    virtual void setZoomCenter(const QPointF &center)
    {
        Q_UNUSED(center);
    }
 
    void setGlobalGridAttributes(const GridAttributes &);
 
    GridAttributes globalGridAttributes() const;
 
    DataDimensionsList gridDimensionsList();
 
    void setReferenceCoordinatePlane(AbstractCoordinatePlane *plane);
 
    AbstractCoordinatePlane *referenceCoordinatePlane() const;
 
    bool isCornerSpacersEnabled() const;
 
    void setCornerSpacersEnabled(bool enable);
 
    virtual AbstractCoordinatePlane *sharedAxisMasterPlane(QPainter *p = nullptr); // KDChart 3: const method?
 
    bool isEmpty() const override;
    Qt::Orientations expandingDirections() const override;
    QSize maximumSize() const override;
    QSize minimumSize() const override;
    QSize sizeHint() const override;
    void setGeometry(const QRect &r) override;
    QRect geometry() const override;
 
    virtual void mousePressEvent(QMouseEvent *event);
    virtual void mouseDoubleClickEvent(QMouseEvent *event);
    virtual void mouseMoveEvent(QMouseEvent *event);
    virtual void mouseReleaseEvent(QMouseEvent *event);
 
    void setParent(Chart *parent);
    Chart *parent();
    const Chart *parent() const;
 
#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0) && defined(Q_COMPILER_MANGLES_RETURN_TYPE)
    const bool isVisiblePoint(const QPointF &point) const;
#else
    bool isVisiblePoint(const QPointF &point) const;
#endif
 
public Q_SLOTS:
    void update();
    void relayout();
    void layoutPlanes();
    void setGridNeedsRecalculate();
 
Q_SIGNALS:
    void destroyedCoordinatePlane(AbstractCoordinatePlane *);
 
    void needUpdate();
 
    void needRelayout();
 
    void needLayoutPlanes();
 
    void propertiesChanged();
 
    void boundariesChanged();
 
    void geometryChanged(QRect, QRect);
 
private:
Q_SIGNALS:
    // Emitted from inside the setGeometry()
    // This is connected via QueuedConnection to the geometryChanged() Signal
    // that users can connect to safely then.
    void internal_geometryChanged(QRect, QRect);
    void viewportCoordinateSystemChanged();
 
protected:
    virtual DataDimensionsList getDataDimensionsList() const = 0;
 
    // KDCHART_DECLARE_PRIVATE_DERIVED( AbstractCoordinatePlane )
};
 
class DataDimension
{
public:
    DataDimension()
    {
    }
    DataDimension(qreal start_,
                  qreal end_,
                  bool isCalculated_,
                  AbstractCoordinatePlane::AxesCalcMode calcMode_,
                  KDChartEnums::GranularitySequence sequence_,
                  qreal stepWidth_ = 0.0,
                  qreal subStepWidth_ = 0.0)
        : start(start_)
        , end(end_)
        , isCalculated(isCalculated_)
        , calcMode(calcMode_)
        , sequence(sequence_)
        , stepWidth(stepWidth_)
        , subStepWidth(subStepWidth_)
    {
    }
    qreal distance() const
    {
        return end - start;
    }
 
    bool operator==(const DataDimension &r) const
    {
        return (start == r.start) && (end == r.end) && (sequence == r.sequence) && (isCalculated == r.isCalculated) && (calcMode == r.calcMode) && (stepWidth == r.stepWidth) && (subStepWidth == r.subStepWidth);
    }
 
    bool operator!=(const DataDimension &other) const
    {
        return !operator==(other);
    }
 
    qreal start = 1.0;
    qreal end = 10.0;
    bool isCalculated = false;
    AbstractCoordinatePlane::AxesCalcMode calcMode = AbstractCoordinatePlane::Linear;
    KDChartEnums::GranularitySequence sequence = KDChartEnums::GranularitySequence_10_20;
    qreal stepWidth = 1.0;
    qreal subStepWidth = 0.0;
};
 
#if !defined(QT_NO_DEBUG_STREAM)
QDebug operator<<(QDebug stream, const DataDimension &r);
#endif
}
#endif