qgsplot.h

Go to the documentation of this file.

/***************************************************************************
                         qgsplot.h
                         ---------------
    begin                : March 2022
    copyright            : (C) 2022 by Nyall Dawson
    email                : nyall dot dawson at gmail dot com
 ***************************************************************************/
 
/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/
#ifndef QGSPLOT_H
#define QGSPLOT_H
 
#include <memory>
 
#include "qgis_core.h"
#include "qgis_sip.h"
#include "qgsmargins.h"
#include "qgspropertycollection.h"
#include "qgstextformat.h"
 
#include <QSizeF>
 
class QgsColorRamp;
class QgsMarkerSymbol;
class QgsLineSymbol;
class QgsFillSymbol;
class QgsRenderContext;
class QgsSymbol;
class QgsNumericFormat;

class CORE_EXPORT QgsPlot
{
    //SIP_TYPEHEADER_INCLUDE( "qgsbarchartplot.h" );
    //SIP_TYPEHEADER_INCLUDE( "qgslinechartplot.h" );
    //SIP_TYPEHEADER_INCLUDE( "qgspiechartplot.h" );
 
#ifdef SIP_RUN
    SIP_CONVERT_TO_SUBCLASS_CODE
    if ( QgsPlot *item = dynamic_cast< QgsPlot * >( sipCpp ) )
    {
      if ( dynamic_cast<QgsBarChartPlot *>( item ) != NULL )
      {
        sipType = sipType_QgsBarChartPlot;
      }
      else if ( dynamic_cast<QgsLineChartPlot *>( item ) != NULL )
      {
        sipType = sipType_QgsLineChartPlot;
      }
      else if ( dynamic_cast<QgsPieChartPlot *>( item ) != NULL )
      {
        sipType = sipType_QgsPieChartPlot;
      }
      else if ( dynamic_cast<Qgs2DXyPlot *>( item ) != NULL )
      {
        sipType = sipType_Qgs2DXyPlot;
      }
      else if ( dynamic_cast<Qgs2DPlot *>( item ) != NULL )
      {
        sipType = sipType_Qgs2DPlot;
      }
      else
      {
        sipType = sipType_QgsPlot;
      }
    }
    else
    {
      sipType = NULL;
    }
  SIP_END
#endif
 
  public:

    enum class DataDefinedProperty SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsPlot, Property ) : int
    {
      MarginLeft,         
      MarginTop,          
      MarginRight,        
      MarginBottom,       
      XAxisMajorInterval, 
      XAxisMinorInterval, 
      XAxisLabelInterval, 
      YAxisMajorInterval, 
      YAxisMinorInterval, 
      YAxisLabelInterval, 
      XAxisMinimum,       
      XAxisMaximum,       
      YAxisMinimum,       
      YAxisMaximum,       
    };
 
    QgsPlot() = default;
 
    virtual ~QgsPlot();

    virtual QString type() const { return QString(); }

    void setDataDefinedProperty( DataDefinedProperty key, const QgsProperty &property ) { mDataDefinedProperties.setProperty( key, property ); }

    QgsPropertyCollection &dataDefinedProperties() { return mDataDefinedProperties; }

    const QgsPropertyCollection &dataDefinedProperties() const SIP_SKIP { return mDataDefinedProperties; }

    void setDataDefinedProperties( const QgsPropertyCollection &collection ) { mDataDefinedProperties = collection; }

    virtual bool writeXml( QDomElement &element, QDomDocument &document, const QgsReadWriteContext &context ) const;

    virtual bool readXml( const QDomElement &element, const QgsReadWriteContext &context );

    virtual void initFromPlot( const QgsPlot *plot );

    static const QgsPropertiesDefinition &propertyDefinitions();
 
  protected:
    QgsPropertyCollection mDataDefinedProperties;
 
  private:
    static void initPropertyDefinitions();
    static QgsPropertiesDefinition sPropertyDefinitions;
};
 

class CORE_EXPORT QgsPlotRenderContext
{
  public:
    QgsPlotRenderContext() = default;
    ~QgsPlotRenderContext() = default;
};
 

class CORE_EXPORT QgsAbstractPlotSeries
{
#ifdef SIP_RUN
    SIP_CONVERT_TO_SUBCLASS_CODE
    if ( QgsAbstractPlotSeries *item = dynamic_cast< QgsAbstractPlotSeries * >( sipCpp ) )
    {
      if ( dynamic_cast<QgsXyPlotSeries *>( item ) != NULL )
      {
        sipType = sipType_QgsXyPlotSeries;
      }
      else
      {
        sipType = sipType_QgsAbstractPlotSeries;
      }
    }
    else
    {
      sipType = NULL;
    }
  SIP_END
#endif
  public:
 
    QgsAbstractPlotSeries() = default;
    virtual ~QgsAbstractPlotSeries() = default;

    QString name() const;

    void setName( const QString &name );

    virtual QgsAbstractPlotSeries *clone() const = 0 SIP_FACTORY;
 
  private:
    QString mName;
};

class CORE_EXPORT QgsXyPlotSeries : public QgsAbstractPlotSeries
{
  public:
    QgsXyPlotSeries() = default;
    ~QgsXyPlotSeries() override = default;

    QList<std::pair<double, double>> data() const;

    void setData( const QList<std::pair<double, double>> &data );

    void append( double x, double y );

    void clear();
 
    QgsAbstractPlotSeries *clone() const override SIP_FACTORY;
 
  private:
    QList<std::pair<double, double>> mData;
};

class CORE_EXPORT QgsPlotData
{
  public:
    QgsPlotData() = default;
    ~QgsPlotData();
 
    QgsPlotData( const QgsPlotData &other );
    SIP_SKIP QgsPlotData( QgsPlotData &&other );
    QgsPlotData &operator=( const QgsPlotData &other );
    QgsPlotData &operator=( QgsPlotData &&other );

    QList<QgsAbstractPlotSeries *> series() const;

    void addSeries( QgsAbstractPlotSeries *series SIP_TRANSFER );

    void clearSeries();

    QStringList categories() const;

    void setCategories( const QStringList &categories );
 
  private:
    QList<QgsAbstractPlotSeries *> mSeries;
    QStringList mCategories;
};

class CORE_EXPORT QgsPlotAxis
{
  public:
    QgsPlotAxis();
    ~QgsPlotAxis();
 
    QgsPlotAxis( const QgsPlotAxis &other ) = delete;
    QgsPlotAxis &operator=( const QgsPlotAxis &other ) = delete;

    bool writeXml( QDomElement &element, QDomDocument &document, const QgsReadWriteContext &context ) const;

    bool readXml( const QDomElement &element, const QgsReadWriteContext &context );

    Qgis::PlotAxisType type() const;

    void setType( Qgis::PlotAxisType type );

    double gridIntervalMinor() const { return mGridIntervalMinor; }

    void setGridIntervalMinor( double interval ) { mGridIntervalMinor = interval; }

    double gridIntervalMajor() const { return mGridIntervalMajor; }

    void setGridIntervalMajor( double interval ) { mGridIntervalMajor = interval; }

    double labelInterval() const { return mLabelInterval; }

    void setLabelInterval( double interval ) { mLabelInterval = interval; }

    QgsLineSymbol *gridMajorSymbol();

    const QgsLineSymbol *gridMajorSymbol() const SIP_SKIP;

    void setGridMajorSymbol( QgsLineSymbol *symbol SIP_TRANSFER );

    QgsLineSymbol *gridMinorSymbol();

    const QgsLineSymbol *gridMinorSymbol() const SIP_SKIP;

    void setGridMinorSymbol( QgsLineSymbol *symbol SIP_TRANSFER );

    QgsTextFormat textFormat() const;

    void setTextFormat( const QgsTextFormat &format );

    QgsNumericFormat *numericFormat() const;

    void setNumericFormat( QgsNumericFormat *format SIP_TRANSFER );

    QString labelSuffix() const;

    void setLabelSuffix( const QString &suffix );

    Qgis::PlotAxisSuffixPlacement labelSuffixPlacement() const;

    void setLabelSuffixPlacement( Qgis::PlotAxisSuffixPlacement placement );

    static void copyProperties( const QgsPlotAxis &source, QgsPlotAxis &destination );
 
  private:
#ifdef SIP_RUN
    QgsPlotAxis( const QgsPlotAxis &other );
#endif
 
    Qgis::PlotAxisType mType = Qgis::PlotAxisType::Interval;
 
    double mGridIntervalMinor = 1;
    double mGridIntervalMajor = 5;
 
    double mLabelInterval = 1;
 
    QString mLabelSuffix;
    Qgis::PlotAxisSuffixPlacement mSuffixPlacement = Qgis::PlotAxisSuffixPlacement::EveryLabel;
 
    std::unique_ptr< QgsNumericFormat > mNumericFormat;
 
    std::unique_ptr< QgsLineSymbol > mGridMajorSymbol;
    std::unique_ptr< QgsLineSymbol > mGridMinorSymbol;
 
    QgsTextFormat mLabelTextFormat;
};

class CORE_EXPORT Qgs2DPlot : public QgsPlot
{
  public:
    Qgs2DPlot();
 
    ~Qgs2DPlot() override;
 
    Qgs2DPlot( const Qgs2DPlot &other ) = delete;
    Qgs2DPlot &operator=( const Qgs2DPlot &other ) = delete;
 
    bool writeXml( QDomElement &element, QDomDocument &document, const QgsReadWriteContext &context ) const override;
    bool readXml( const QDomElement &element, const QgsReadWriteContext &context ) override;

    virtual void render( QgsRenderContext &context, QgsPlotRenderContext &plotContext, const QgsPlotData &plotData = QgsPlotData() );

    virtual void renderContent( QgsRenderContext &context, QgsPlotRenderContext &plotContext, const QRectF &plotArea, const QgsPlotData &plotData = QgsPlotData() );

    QSizeF size() const;

    void setSize( QSizeF size );

    virtual QRectF interiorPlotArea( QgsRenderContext &context, QgsPlotRenderContext &plotContext, const QgsPlotData &plotData = QgsPlotData() ) const;

    const QgsMargins &margins() const;

    void setMargins( const QgsMargins &margins );

    void copyCommonProperties( const Qgs2DPlot *other );
 
  protected:
    void applyDataDefinedProperties( QgsRenderContext &context, QgsMargins &margins ) const;
 
  private:
#ifdef SIP_RUN
    Qgs2DPlot( const Qgs2DPlot &other );
#endif
 
    QSizeF mSize;
    QgsMargins mMargins;
 
    friend class Qgs2DXyPlot;
};

class CORE_EXPORT Qgs2DXyPlot : public Qgs2DPlot
{
  public:
    Qgs2DXyPlot();
 
    ~Qgs2DXyPlot() override;
 
    Qgs2DXyPlot( const Qgs2DXyPlot &other ) = delete;
    Qgs2DXyPlot &operator=( const Qgs2DXyPlot &other ) = delete;
 
    bool writeXml( QDomElement &element, QDomDocument &document, const QgsReadWriteContext &context ) const override;
    bool readXml( const QDomElement &element, const QgsReadWriteContext &context ) override;

    void render( QgsRenderContext &context, QgsPlotRenderContext &plotContext, const QgsPlotData &plotData = QgsPlotData() ) override;

    QRectF interiorPlotArea( QgsRenderContext &context, QgsPlotRenderContext &plotContext, const QgsPlotData &plotData = QgsPlotData() ) const override;

    void calculateOptimisedIntervals( QgsRenderContext &context, QgsPlotRenderContext &plotContext );

    double xMinimum() const { return mMinX; }

    void setXMinimum( double minimum ) { mMinX = minimum; }

    double yMinimum() const { return mMinY; }

    void setYMinimum( double minimum ) { mMinY = minimum; }

    double xMaximum() const { return mMaxX; }

    void setXMaximum( double maximum ) { mMaxX = maximum; }

    double yMaximum() const { return mMaxY; }

    void setYMaximum( double maximum ) { mMaxY = maximum; }

    QgsPlotAxis &xAxis() { return mXAxis; }

    const QgsPlotAxis &xAxis() const SIP_SKIP { return mXAxis; }

    QgsPlotAxis &yAxis() { return mYAxis; }

    const QgsPlotAxis &yAxis() const SIP_SKIP { return mYAxis; }

    QgsFillSymbol *chartBackgroundSymbol();

    const QgsFillSymbol *chartBackgroundSymbol() const SIP_SKIP;

    void setChartBackgroundSymbol( QgsFillSymbol *symbol SIP_TRANSFER );

    QgsFillSymbol *chartBorderSymbol();

    const QgsFillSymbol *chartBorderSymbol() const SIP_SKIP;

    void setChartBorderSymbol( QgsFillSymbol *symbol SIP_TRANSFER );

    bool flipAxes() const { return mFlipAxes; }

    void setFlipAxes( bool flipAxes );

    void copyCommonProperties( const Qgs2DXyPlot *other );
 
  protected:
    void applyDataDefinedProperties(
      QgsRenderContext &context,
      double &minX,
      double &maxX,
      double &minY,
      double &maxY,
      double &majorIntervalX,
      double &minorIntervalX,
      double &labelIntervalX,
      double &majorIntervalY,
      double &minorIntervalY,
      double &labelIntervalY
    ) const;
 
  private:
#ifdef SIP_RUN
    Qgs2DXyPlot( const Qgs2DXyPlot &other );
#endif
 
    double mMinX = 0;
    double mMinY = 0;
    double mMaxX = 10;
    double mMaxY = 10;
 
    std::unique_ptr< QgsFillSymbol > mChartBackgroundSymbol;
    std::unique_ptr< QgsFillSymbol > mChartBorderSymbol;
 
    QgsPlotAxis mXAxis;
    QgsPlotAxis mYAxis;
 
    bool mFlipAxes = false;
};

class CORE_EXPORT QgsPlotDefaultSettings
{
  public:
    static QgsNumericFormat *axisLabelNumericFormat() SIP_FACTORY;

    static QgsLineSymbol *axisGridMajorSymbol() SIP_FACTORY;

    static QgsLineSymbol *axisGridMinorSymbol() SIP_FACTORY;

    static QgsFillSymbol *chartBackgroundSymbol() SIP_FACTORY;

    static QgsFillSymbol *chartBorderSymbol() SIP_FACTORY;

    static QgsMarkerSymbol *lineChartMarkerSymbol() SIP_FACTORY;

    static QgsLineSymbol *lineChartLineSymbol() SIP_FACTORY;

    static QgsFillSymbol *barChartFillSymbol() SIP_FACTORY;

    static QgsFillSymbol *pieChartFillSymbol() SIP_FACTORY;

    static QgsColorRamp *pieChartColorRamp() SIP_FACTORY;

    static QgsNumericFormat *pieChartNumericFormat() SIP_FACTORY;
};
 
#endif // QGSPLOT_H