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 "qgis_core.h"
#include "qgis_sip.h"
#include "qgstextformat.h"
#include "qgsmargins.h"
 
#include <QSizeF>
#include <memory>
 
class QgsLineSymbol;
class QgsFillSymbol;
class QgsRenderContext;
class QgsNumericFormat;
 
 
class CORE_EXPORT QgsPlot
{
  public:
 
    QgsPlot() = default;
 
    virtual ~QgsPlot();
 
    virtual bool writeXml( QDomElement &element, QDomDocument &document, QgsReadWriteContext &context ) const;
 
    virtual bool readXml( const QDomElement &element, QgsReadWriteContext &context );
 
  private:
 
 
};
 
class CORE_EXPORT QgsPlotAxis
{
  public:
 
    QgsPlotAxis();
    ~QgsPlotAxis();
 
    QgsPlotAxis( const QgsPlotAxis &other ) = delete;
    QgsPlotAxis &operator=( const QgsPlotAxis &other ) = delete;
 
    bool writeXml( QDomElement &element, QDomDocument &document, QgsReadWriteContext &context ) const;
 
    bool readXml( const QDomElement &element, QgsReadWriteContext &context );
 
    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();
 
    void setGridMajorSymbol( QgsLineSymbol *symbol SIP_TRANSFER );
 
    QgsLineSymbol *gridMinorSymbol();
 
    void setGridMinorSymbol( QgsLineSymbol *symbol SIP_TRANSFER );
 
    QgsTextFormat textFormat() const;
 
    void setTextFormat( const QgsTextFormat &format );
 
    QgsNumericFormat *numericFormat() const;
 
    void setNumericFormat( QgsNumericFormat *format SIP_TRANSFER );
 
  private:
 
#ifdef SIP_RUN
    QgsPlotAxis( const QgsPlotAxis &other );
#endif
 
    double mGridIntervalMinor = 1;
    double mGridIntervalMajor = 5;
 
    double mLabelInterval = 1;
 
    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, QgsReadWriteContext &context ) const override;
    bool readXml( const QDomElement &element, QgsReadWriteContext &context ) override;
 
    void render( QgsRenderContext &context );
 
    virtual void renderContent( QgsRenderContext &context, const QRectF &plotArea );
 
    QSizeF size() const;
 
    void setSize( QSizeF size );
 
    QRectF interiorPlotArea( QgsRenderContext &context ) const;
 
    void calculateOptimisedIntervals( QgsRenderContext &context );
 
    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();
 
    void setChartBackgroundSymbol( QgsFillSymbol *symbol SIP_TRANSFER );
 
    QgsFillSymbol *chartBorderSymbol();
 
    void setChartBorderSymbol( QgsFillSymbol *symbol SIP_TRANSFER );
 
    const QgsMargins &margins() const;
 
    void setMargins( const QgsMargins &margins );
 
  private:
 
#ifdef SIP_RUN
    Qgs2DPlot( const Qgs2DPlot &other );
#endif
 
    QSizeF mSize;
 
    double mMinX = 0;
    double mMinY = 0;
    double mMaxX = 10;
    double mMaxY = 10;
 
    std::unique_ptr< QgsFillSymbol > mChartBackgroundSymbol;
    std::unique_ptr< QgsFillSymbol > mChartBorderSymbol;
 
    QgsMargins mMargins;
 
    QgsPlotAxis mXAxis;
    QgsPlotAxis mYAxis;
};
 
#endif // QGSPLOT_H