qgsdiagramrenderer.h

Go to the documentation of this file.

/***************************************************************************
    qgsdiagramrenderer.h
    ---------------------
    begin                : March 2011
    copyright            : (C) 2011 by Marco Hugentobler
    email                : marco dot hugentobler at sourcepole dot ch
 ***************************************************************************
 *                                                                         *
 *   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 QGSDIAGRAMRENDERER_H
#define QGSDIAGRAMRENDERER_H
 
#include "qgis_core.h"
#include "qgis_sip.h"
#include "qgscoordinatetransform.h"
#include "qgsdiagram.h"
#include "qgsexpressioncontext.h"
#include "qgsmapunitscale.h"
#include "qgspropertycollection.h"
#include "qgsreadwritecontext.h"
 
#include <QColor>
#include <QDomDocument>
#include <QFont>
#include <QList>
#include <QPointF>
#include <QSizeF>
#include <QString>
 
using namespace Qt::StringLiterals;
 
class QgsDiagramRenderer;
class QgsFeature;
class QgsRenderContext;
class QDomElement;
class QgsMapToPixel;
class QgsReadWriteContext;
class QgsVectorLayer;
class QgsLayerTreeModelLegendNode;
class QgsLayerTreeLayer;
class QgsPaintEffect;
class QgsDataDefinedSizeLegend;
class QgsLineSymbol;
 
namespace pal SIP_SKIP
{
  class Layer;
}

 
class CORE_EXPORT QgsDiagramLayerSettings
{
  public:
    //avoid inclusion of QgsPalLabeling
    enum Placement
    {
      AroundPoint = 0, // Point / Polygon
      OverPoint,       // Point / Polygon
      Line,            // Line / Polygon
      Curved,          // Line
      Horizontal,      // Polygon
      Free             // Polygon
    };

    enum LinePlacementFlag SIP_ENUM_BASETYPE( IntFlag )
    {
      OnLine = 1,
      AboveLine = 1 << 1,
      BelowLine = 1 << 2,
      MapOrientation = 1 << 4,
    };
    Q_DECLARE_FLAGS( LinePlacementFlags, LinePlacementFlag )
 
    // *INDENT-OFF*
 
    
    enum class Property SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsDiagramLayerSettings, Property ) : int
    {
      BackgroundColor, 
      StrokeColor,     
      StrokeWidth,     
      PositionX,       
      PositionY,       
      Distance,        
      Priority,        
      ZIndex,          
      IsObstacle,      
      Show,            
      AlwaysShow,      
      StartAngle,      
    };
    // *INDENT-ON*

    enum DiagramType
    {
      Single,
      Stacked
    };

    static const QgsPropertiesDefinition &propertyDefinitions();
 
    QgsDiagramLayerSettings();
 
    QgsDiagramLayerSettings( const QgsDiagramLayerSettings &rh );
    SIP_SKIP QgsDiagramLayerSettings( QgsDiagramLayerSettings &&rh );
 
    QgsDiagramLayerSettings &operator=( const QgsDiagramLayerSettings &rh );
    QgsDiagramLayerSettings &operator=( QgsDiagramLayerSettings &&rh );
 
    ~QgsDiagramLayerSettings();

    Placement placement() const { return mPlacement; }

    void setPlacement( Placement value ) { mPlacement = value; }

    LinePlacementFlags linePlacementFlags() const { return mPlacementFlags; }

    void setLinePlacementFlags( LinePlacementFlags flags ) { mPlacementFlags = flags; }

    int priority() const { return mPriority; }

    void setPriority( int value ) { mPriority = value; }

    double zIndex() const { return mZIndex; }

    void setZIndex( double index ) { mZIndex = index; }

    bool isObstacle() const { return mObstacle; }

    void setIsObstacle( bool isObstacle ) { mObstacle = isObstacle; }

    double distance() const { return mDistance; }

    void setDistance( double distance ) { mDistance = distance; }

    QgsDiagramRenderer *renderer() { return mRenderer.get(); }

    const QgsDiagramRenderer *renderer() const SIP_SKIP { return mRenderer.get(); }

    void setRenderer( QgsDiagramRenderer *diagramRenderer SIP_TRANSFER );

    QgsCoordinateTransform coordinateTransform() const { return mCt; }

    void setCoordinateTransform( const QgsCoordinateTransform &transform );

    bool showAllDiagrams() const { return mShowAll; }

    void setShowAllDiagrams( bool showAllDiagrams ) { mShowAll = showAllDiagrams; }

    void readXml( const QDomElement &elem );

    void writeXml( QDomElement &layerElem, QDomDocument &doc ) const;

    bool prepare( const QgsExpressionContext &context = QgsExpressionContext() ) const;

    QSet< QString > referencedFields( const QgsExpressionContext &context = QgsExpressionContext() ) const;

    QgsPropertyCollection &dataDefinedProperties() { return mDataDefinedProperties; }

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

    void setDataDefinedProperties( const QgsPropertyCollection &collection ) { mDataDefinedProperties = collection; }
 
  private:
    QgsCoordinateTransform mCt;

    Placement mPlacement = AroundPoint;

    LinePlacementFlags mPlacementFlags = OnLine;

    int mPriority = 5;

    double mZIndex = 0.0;

    bool mObstacle = false;

    double mDistance = 0.0;

    std::unique_ptr<QgsDiagramRenderer> mRenderer;

    bool mShowAll = true;

    QgsPropertyCollection mDataDefinedProperties;
 
    static void initPropertyDefinitions();

    static QgsPropertiesDefinition sPropertyDefinitions;
};

 
class CORE_EXPORT QgsDiagramSettings
{
  public:
    enum LabelPlacementMethod
    {
      Height,
      XHeight
    };

    enum DiagramOrientation
    {
      Up,
      Down,
      Left,
      Right
    };

    enum Direction
    {
      Clockwise,        
      Counterclockwise, 
    };

    enum StackedDiagramMode
    {
      Horizontal,
      Vertical
    };
 
    QgsDiagramSettings();
    ~QgsDiagramSettings();
    QgsDiagramSettings( const QgsDiagramSettings &other );
 
    QgsDiagramSettings &operator=( const QgsDiagramSettings &other );
 
    bool enabled = true;
    QFont font;
    QList< QColor > categoryColors;
    QList< QString > categoryAttributes;
    QList< QString > categoryLabels;
    QSizeF size; //size

    Qgis::RenderUnit sizeType = Qgis::RenderUnit::Millimeters;

    QgsMapUnitScale sizeScale;

    Qgis::RenderUnit lineSizeUnit = Qgis::RenderUnit::Millimeters;

    QgsMapUnitScale lineSizeScale;
 
    QColor backgroundColor;
    QColor penColor;
    double penWidth = 0.0;
    LabelPlacementMethod labelPlacementMethod = QgsDiagramSettings::Height;
    DiagramOrientation diagramOrientation = QgsDiagramSettings::Up;
    StackedDiagramMode stackedDiagramMode = QgsDiagramSettings::Horizontal;
    double barWidth = 5.0;

    double opacity = 1.0;
 
    bool scaleByArea = true;

    double rotationOffset = 270;
 
    bool scaleBasedVisibility = false;

    double maximumScale = 0;

    double minimumScale = 0;

    double minimumSize = 0.0;

    double spacing() const { return mSpacing; }

    void setSpacing( double spacing ) { mSpacing = spacing; }

    void setSpacingUnit( Qgis::RenderUnit unit ) { mSpacingUnit = unit; }

    Qgis::RenderUnit spacingUnit() const { return mSpacingUnit; }

    void setSpacingMapUnitScale( const QgsMapUnitScale &scale ) { mSpacingMapUnitScale = scale; }

    const QgsMapUnitScale &spacingMapUnitScale() const { return mSpacingMapUnitScale; }

    double stackedDiagramSpacing() const { return mStackedDiagramSpacing; }

    void setStackedDiagramSpacing( double spacing ) { mStackedDiagramSpacing = spacing; }

    void setStackedDiagramSpacingUnit( Qgis::RenderUnit unit ) { mStackedDiagramSpacingUnit = unit; }

    Qgis::RenderUnit stackedDiagramSpacingUnit() const { return mStackedDiagramSpacingUnit; }

    void setStackedDiagramSpacingMapUnitScale( const QgsMapUnitScale &scale ) { mStackedDiagramSpacingMapUnitScale = scale; }

    const QgsMapUnitScale &stackedDiagramSpacingMapUnitScale() const { return mStackedDiagramSpacingMapUnitScale; }

    Direction direction() const;

    void setDirection( Direction direction );

    void readXml( const QDomElement &elem, const QgsReadWriteContext &context = QgsReadWriteContext() );
    void writeXml( QDomElement &rendererElem, QDomDocument &doc, const QgsReadWriteContext &context = QgsReadWriteContext() ) const;

    QList< QgsLayerTreeModelLegendNode * > legendItems( QgsLayerTreeLayer *nodeLayer ) const SIP_FACTORY;

    QgsLineSymbol *axisLineSymbol() const;

    void setAxisLineSymbol( QgsLineSymbol *symbol SIP_TRANSFER );

    bool showAxis() const;

    void setShowAxis( bool showAxis );

    QgsPaintEffect *paintEffect() const;

    void setPaintEffect( QgsPaintEffect *effect SIP_TRANSFER );
 
  private:
    double mSpacing = 0;
    Qgis::RenderUnit mSpacingUnit = Qgis::RenderUnit::Millimeters;
    QgsMapUnitScale mSpacingMapUnitScale;
 
    double mStackedDiagramSpacing = 0;
    Qgis::RenderUnit mStackedDiagramSpacingUnit = Qgis::RenderUnit::Millimeters;
    QgsMapUnitScale mStackedDiagramSpacingMapUnitScale;
 
    Direction mDirection = Counterclockwise;
 
    bool mShowAxis = false;
    std::unique_ptr< QgsLineSymbol > mAxisLineSymbol;
    std::unique_ptr< QgsPaintEffect > mPaintEffect;
};

class CORE_EXPORT QgsDiagramInterpolationSettings
{
  public:
    QSizeF lowerSize;
    QSizeF upperSize;
    double lowerValue;
    double upperValue;

    QString classificationField;
 
    QString classificationAttributeExpression;
    bool classificationAttributeIsExpression;
};
 

 
class CORE_EXPORT QgsDiagramRenderer
{
#ifdef SIP_RUN
    SIP_CONVERT_TO_SUBCLASS_CODE
    if ( sipCpp->rendererName() == "SingleCategory"_L1 )
      sipType = sipType_QgsSingleCategoryDiagramRenderer;
    else if ( sipCpp->rendererName() == "LinearlyInterpolated"_L1 )
      sipType = sipType_QgsLinearlyInterpolatedDiagramRenderer;
    else if ( sipCpp->rendererName() == "Stacked"_L1 )
      sipType = sipType_QgsStackedDiagramRenderer;
    else
      sipType = NULL;
  SIP_END
#endif
 
  public:
 
    QgsDiagramRenderer() = default;
    virtual ~QgsDiagramRenderer() = default;

    virtual QgsDiagramRenderer *clone() const = 0 SIP_FACTORY;

    virtual QSizeF sizeMapUnits( const QgsFeature &feature, const QgsRenderContext &c ) const;
 
    virtual QString rendererName() const = 0;

    virtual QList<QString> diagramAttributes() const = 0;

    virtual QSet< QString > referencedFields( const QgsExpressionContext &context = QgsExpressionContext() ) const;

    virtual void renderDiagram( const QgsFeature &feature, QgsRenderContext &c, QPointF pos, const QgsPropertyCollection &properties = QgsPropertyCollection() ) const;
 
    void setDiagram( QgsDiagram *d SIP_TRANSFER );
    QgsDiagram *diagram() const { return mDiagram.get(); }

    virtual QList<QgsDiagramSettings> diagramSettings() const = 0;

    virtual void readXml( const QDomElement &elem, const QgsReadWriteContext &context ) = 0;

    virtual void writeXml( QDomElement &layerElem, QDomDocument &doc, const QgsReadWriteContext &context ) const = 0;

    virtual QList< QgsLayerTreeModelLegendNode * > legendItems( QgsLayerTreeLayer *nodeLayer ) const SIP_FACTORY;

    bool attributeLegend() const { return mShowAttributeLegend; }

    void setAttributeLegend( bool enabled ) { mShowAttributeLegend = enabled; }
 
  protected:
    QgsDiagramRenderer( const QgsDiagramRenderer &other );
    QgsDiagramRenderer &operator=( const QgsDiagramRenderer &other );

    virtual bool diagramSettings( const QgsFeature &feature, const QgsRenderContext &c, QgsDiagramSettings &s ) const = 0;

    virtual QSizeF diagramSize( const QgsFeature &feature, const QgsRenderContext &c ) const = 0;

    void convertSizeToMapUnits( QSizeF &size, const QgsRenderContext &context ) const;

    static int dpiPaintDevice( const QPainter * );
 
    //read / write diagram

    void _readXml( const QDomElement &elem, const QgsReadWriteContext &context );

    void _writeXml( QDomElement &rendererElem, QDomDocument &doc, const QgsReadWriteContext &context ) const;

    std::unique_ptr< QgsDiagram > mDiagram;

    bool mShowAttributeLegend = true;
 
    friend class QgsStackedDiagramRenderer;
};

class CORE_EXPORT QgsSingleCategoryDiagramRenderer : public QgsDiagramRenderer
{
  public:
    static const QString DIAGRAM_RENDERER_NAME_SINGLE_CATEGORY SIP_SKIP;
 
    QgsSingleCategoryDiagramRenderer() = default;
 
    QgsSingleCategoryDiagramRenderer *clone() const override SIP_FACTORY;
 
    QString rendererName() const override { return QgsSingleCategoryDiagramRenderer::DIAGRAM_RENDERER_NAME_SINGLE_CATEGORY; }
 
    QList<QString> diagramAttributes() const override { return mSettings.categoryAttributes; }
 
    void setDiagramSettings( const QgsDiagramSettings &s ) { mSettings = s; }
 
    QList<QgsDiagramSettings> diagramSettings() const override;
 
    void readXml( const QDomElement &elem, const QgsReadWriteContext &context ) override;
    void writeXml( QDomElement &layerElem, QDomDocument &doc, const QgsReadWriteContext &context ) const override;
 
    QList< QgsLayerTreeModelLegendNode * > legendItems( QgsLayerTreeLayer *nodeLayer ) const override SIP_FACTORY;
 
  protected:
    bool diagramSettings( const QgsFeature &feature, const QgsRenderContext &c, QgsDiagramSettings &s ) const override;
 
    QSizeF diagramSize( const QgsFeature &, const QgsRenderContext &c ) const override;
 
  private:
    QgsDiagramSettings mSettings;
};

class CORE_EXPORT QgsLinearlyInterpolatedDiagramRenderer : public QgsDiagramRenderer
{
  public:
    static const QString DIAGRAM_RENDERER_NAME_LINEARLY_INTERPOLATED SIP_SKIP;
 
    QgsLinearlyInterpolatedDiagramRenderer();
    ~QgsLinearlyInterpolatedDiagramRenderer() override;
    QgsLinearlyInterpolatedDiagramRenderer( const QgsLinearlyInterpolatedDiagramRenderer &other );
 
    QgsLinearlyInterpolatedDiagramRenderer &operator=( const QgsLinearlyInterpolatedDiagramRenderer &other );
 
    QgsLinearlyInterpolatedDiagramRenderer *clone() const override SIP_FACTORY;

    QList<QgsDiagramSettings> diagramSettings() const override;
 
    void setDiagramSettings( const QgsDiagramSettings &s ) { mSettings = s; }
 
    QList<QString> diagramAttributes() const override;
 
    QSet< QString > referencedFields( const QgsExpressionContext &context = QgsExpressionContext() ) const override;
 
    QString rendererName() const override { return QgsLinearlyInterpolatedDiagramRenderer::DIAGRAM_RENDERER_NAME_LINEARLY_INTERPOLATED; }
 
    void setLowerValue( double val ) { mInterpolationSettings.lowerValue = val; }
    double lowerValue() const { return mInterpolationSettings.lowerValue; }
 
    void setUpperValue( double val ) { mInterpolationSettings.upperValue = val; }
    double upperValue() const { return mInterpolationSettings.upperValue; }
 
    void setLowerSize( QSizeF s ) { mInterpolationSettings.lowerSize = s; }
    QSizeF lowerSize() const { return mInterpolationSettings.lowerSize; }
 
    void setUpperSize( QSizeF s ) { mInterpolationSettings.upperSize = s; }
    QSizeF upperSize() const { return mInterpolationSettings.upperSize; }

    QString classificationField() const { return mInterpolationSettings.classificationField; }

    void setClassificationField( const QString &field ) { mInterpolationSettings.classificationField = field; }
 
    QString classificationAttributeExpression() const { return mInterpolationSettings.classificationAttributeExpression; }
    void setClassificationAttributeExpression( const QString &expression ) { mInterpolationSettings.classificationAttributeExpression = expression; }
 
    bool classificationAttributeIsExpression() const { return mInterpolationSettings.classificationAttributeIsExpression; }
    void setClassificationAttributeIsExpression( bool isExpression ) { mInterpolationSettings.classificationAttributeIsExpression = isExpression; }
 
    void readXml( const QDomElement &elem, const QgsReadWriteContext &context ) override;
    void writeXml( QDomElement &layerElem, QDomDocument &doc, const QgsReadWriteContext &context ) const override;
 
    QList< QgsLayerTreeModelLegendNode * > legendItems( QgsLayerTreeLayer *nodeLayer ) const override SIP_FACTORY;

    void setDataDefinedSizeLegend( QgsDataDefinedSizeLegend *settings SIP_TRANSFER );

    QgsDataDefinedSizeLegend *dataDefinedSizeLegend() const;
 
  protected:
    bool diagramSettings( const QgsFeature &feature, const QgsRenderContext &c, QgsDiagramSettings &s ) const override;
 
    QSizeF diagramSize( const QgsFeature &, const QgsRenderContext &c ) const override;
 
  private:
    QgsDiagramSettings mSettings;
    QgsDiagramInterpolationSettings mInterpolationSettings;

    std::unique_ptr<QgsDataDefinedSizeLegend> mDataDefinedSizeLegend;
};

class CORE_EXPORT QgsStackedDiagramRenderer : public QgsDiagramRenderer
{
  public:
    static const QString DIAGRAM_RENDERER_NAME_STACKED SIP_SKIP;
 
    QgsStackedDiagramRenderer() = default;
    ~QgsStackedDiagramRenderer() override;
 
    QgsStackedDiagramRenderer( const QgsStackedDiagramRenderer &other );
 
    QgsStackedDiagramRenderer &operator=( const QgsStackedDiagramRenderer &other );
 
    QgsStackedDiagramRenderer *clone() const override SIP_FACTORY;

    QSizeF sizeMapUnits( const QgsFeature &feature, const QgsRenderContext &c ) const override;

    void renderDiagram( const QgsFeature &feature, QgsRenderContext &c, QPointF pos, const QgsPropertyCollection &properties = QgsPropertyCollection() ) const override;

    QList<QgsDiagramSettings> diagramSettings() const override;
 
    void setDiagramSettings( const QgsDiagramSettings &s ) { mSettings = s; }
 
    QList<QString> diagramAttributes() const override;
 
    QString rendererName() const override { return QgsStackedDiagramRenderer::DIAGRAM_RENDERER_NAME_STACKED; }
 
    void readXml( const QDomElement &elem, const QgsReadWriteContext &context ) override;
    void writeXml( QDomElement &layerElem, QDomDocument &doc, const QgsReadWriteContext &context ) const override;

    void _readXmlSubRenderers( const QDomElement &elem, const QgsReadWriteContext &context );

    void _writeXmlSubRenderers( QDomElement &rendererElem, QDomDocument &doc, const QgsReadWriteContext &context ) const;
 
    QList< QgsLayerTreeModelLegendNode * > legendItems( QgsLayerTreeLayer *nodeLayer ) const override SIP_FACTORY;

    QList< QgsDiagramRenderer * > renderers( bool sortByDiagramMode = false ) const;

    void addRenderer( QgsDiagramRenderer *renderer SIP_TRANSFER );

    const QgsDiagramRenderer *renderer( const int index ) const;

    int rendererCount() const;
 
  protected:
    bool diagramSettings( const QgsFeature &feature, const QgsRenderContext &c, QgsDiagramSettings &s ) const override;
    QSizeF diagramSize( const QgsFeature &, const QgsRenderContext &c ) const override;
 
  private:
    QgsDiagramSettings mSettings;
    QList< QgsDiagramRenderer * > mDiagramRenderers;
};
 
 
#endif // QGSDIAGRAMRENDERER_H