KDChartAbstractCoordinatePlane.h

Go to the documentation of this file.

/****************************************************************************
** Copyright (C) 2001-2020 Klaralvdalens Datakonsult AB.  All rights reserved.
**
** This file is part of the KD Chart library.
**
** Licensees holding valid commercial KD Chart licenses may use this file in
** accordance with the KD Chart Commercial License Agreement provided with
** the Software.
**
**
** This file may be distributed and/or modified under the terms of the
** GNU General Public License version 2 and version 3 as published by the
** Free Software Foundation and appearing in the file LICENSE.GPL.txt included.
**
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
**
** Contact info@kdab.com if any conditions of this licensing are not
** clear to you.
**
**********************************************************************/

#ifndef KDCHARTABSTRACTCOORDINATEPLANE_H
#define KDCHARTABSTRACTCOORDINATEPLANE_H

#include <QObject>
#include <QList>

#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 = 0 );

    public:
        ~AbstractCoordinatePlane() override;

        virtual void addDiagram( AbstractDiagram* diagram );

        virtual void replaceDiagram( AbstractDiagram* diagram, AbstractDiagram* oldDiagram = 0 );

        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 = 0 ); // 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 < 0x040400 || 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()
            : start( 1.0 )
            , end( 10.0 )
            , isCalculated( false )
            , calcMode( AbstractCoordinatePlane::Linear )
            , sequence( KDChartEnums::GranularitySequence_10_20 )
            , stepWidth( 1.0 )
            , subStepWidth( 0.0 )
        {}
        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;
        qreal end;
        bool  isCalculated;
        AbstractCoordinatePlane::AxesCalcMode calcMode;
        KDChartEnums::GranularitySequence sequence;
        qreal stepWidth;
        qreal subStepWidth;
    };

#if !defined(QT_NO_DEBUG_STREAM)
    QDebug operator<<( QDebug stream, const DataDimension& r );
#endif

}
#endif