qgscallout.h

Go to the documentation of this file.

/***************************************************************************
                             qgscallout.h
                             ----------------
    begin                : July 2019
    copyright            : (C) 2019 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 QGSCALLOUT_H
#define QGSCALLOUT_H
 
#include <memory>
 
#include "qgis.h"
#include "qgis_core.h"
#include "qgis_sip.h"
#include "qgscalloutposition.h"
#include "qgscoordinatetransform.h"
#include "qgsmapunitscale.h"
#include "qgsmargins.h"
#include "qgspropertycollection.h"
#include "qgsreadwritecontext.h"
 
#include <QPainter>
#include <QRectF>
#include <QString>
 
class QgsLineSymbol;
class QgsMarkerSymbol;
class QgsFillSymbol;
class QgsGeometry;
class QgsRenderContext;
 
class QgsCalloutWidget; //stop sip breaking

class CORE_EXPORT QgsCallout
{
#ifdef SIP_RUN
    SIP_CONVERT_TO_SUBCLASS_CODE
    if ( sipCpp->type() == "simple" && dynamic_cast<QgsSimpleLineCallout *>( sipCpp ) != NULL )
    {
      sipType = sipType_QgsSimpleLineCallout;
    }
    else if ( sipCpp->type() == "manhattan" && dynamic_cast<QgsManhattanLineCallout *>( sipCpp ) != NULL )
    {
      sipType = sipType_QgsManhattanLineCallout;
    }
    else if ( sipCpp->type() == "curved" && dynamic_cast<QgsCurvedLineCallout *>( sipCpp ) != NULL )
    {
      sipType = sipType_QgsCurvedLineCallout;
    }
    else if ( sipCpp->type() == "balloon" && dynamic_cast<QgsBalloonCallout *>( sipCpp ) != NULL )
    {
      sipType = sipType_QgsBalloonCallout;
    }
    else
    {
      sipType = 0;
    }
  SIP_END
#endif
 
  public:
    // *INDENT-OFF*
    enum class Property SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsCallout, Property ) : int
    {
      MinimumCalloutLength,     
      OffsetFromAnchor,         
      OffsetFromLabel,          
      DrawCalloutToAllParts,    
      AnchorPointPosition,      
      LabelAnchorPointPosition, 
      OriginX,                  
      OriginY,                  
      DestinationX,             
      DestinationY,             
      Curvature,                
      Orientation,              
      Margins,                  
      WedgeWidth,               
      CornerRadius,             
      BlendMode,                
    };
    // *INDENT-ON*

    enum DrawOrder
    {
      OrderBelowAllLabels,        
      OrderBelowIndividualLabels, 
    };

    enum AnchorPoint
    {
      PoleOfInaccessibility = 0, 
      PointOnExterior,           
      PointOnSurface,            
      Centroid,                  
    };

    enum LabelAnchorPoint
    {
      LabelPointOnExterior, 
      LabelCentroid,        
      LabelTopLeft,         
      LabelTopMiddle,       
      LabelTopRight,        
      LabelMiddleLeft,      
      LabelMiddleRight,     
      LabelBottomLeft,      
      LabelBottomMiddle,    
      LabelBottomRight,     
    };

    QgsCallout();
    virtual ~QgsCallout() = default;

    virtual QString type() const = 0;

    virtual QgsCallout *clone() const = 0 SIP_FACTORY;

    virtual QVariantMap properties( const QgsReadWriteContext &context ) const;

    virtual void readProperties( const QVariantMap &props, const QgsReadWriteContext &context );

    virtual bool saveProperties( QDomDocument &doc, QDomElement &element, const QgsReadWriteContext &context ) const;

    virtual void restoreProperties( const QDomElement &element, const QgsReadWriteContext &context );

    bool containsAdvancedEffects() const;

    virtual void startRender( QgsRenderContext &context );

    virtual void stopRender( QgsRenderContext &context );

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

    virtual DrawOrder drawOrder() const;

    class CORE_EXPORT QgsCalloutContext
    {
      public:
        bool allFeaturePartsLabeled = false;

        QgsCoordinateReferenceSystem originalFeatureCrs;

        QgsCoordinateTransform originalFeatureToMapTransform( const QgsRenderContext &renderContext ) const;

        void addCalloutPosition( const QgsCalloutPosition &position ) { return mPositions.push_back( position ); }

        QList< QgsCalloutPosition > positions() const { return mPositions; }
 
      private:
        mutable QgsCoordinateTransform mOriginalFeatureToMapTransform;
 
        QList< QgsCalloutPosition > mPositions;
    };

    void render( QgsRenderContext &context, const QRectF &rect, const double angle, const QgsGeometry &anchor, QgsCalloutContext &calloutContext );

    bool enabled() const { return mEnabled; }

    void setEnabled( bool enabled );

    QgsPropertyCollection &dataDefinedProperties() { return mDataDefinedProperties; }

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

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

    static QgsPropertiesDefinition propertyDefinitions();

    AnchorPoint anchorPoint() const { return mAnchorPoint; }

    void setAnchorPoint( AnchorPoint anchor ) { mAnchorPoint = anchor; }

    static QString encodeAnchorPoint( AnchorPoint anchor );

    static QgsCallout::AnchorPoint decodeAnchorPoint( const QString &name, bool *ok = nullptr );
 

    LabelAnchorPoint labelAnchorPoint() const { return mLabelAnchorPoint; }

    void setLabelAnchorPoint( LabelAnchorPoint anchor ) { mLabelAnchorPoint = anchor; }

    static QString encodeLabelAnchorPoint( LabelAnchorPoint anchor );

    static QgsCallout::LabelAnchorPoint decodeLabelAnchorPoint( const QString &name, bool *ok = nullptr );

    QPainter::CompositionMode blendMode() const { return mBlendMode; }

    void setBlendMode( QPainter::CompositionMode mode ) { mBlendMode = mode; }
 
  protected:
    virtual void draw( QgsRenderContext &context, const QRectF &bodyBoundingBox, const double angle, const QgsGeometry &anchor, QgsCalloutContext &calloutContext ) = 0;

    Q_DECL_DEPRECATED QgsGeometry labelAnchorGeometry( const QRectF &bodyBoundingBox, const double angle, LabelAnchorPoint anchor ) const SIP_DEPRECATED;

    QgsGeometry calloutLabelPoint( const QRectF &bodyBoundingBox, double angle, LabelAnchorPoint anchor, QgsRenderContext &context, const QgsCalloutContext &calloutContext, bool &pinned ) const;

    QgsGeometry calloutLineToPart( const QgsGeometry &labelGeometry, const QgsAbstractGeometry *partGeometry, QgsRenderContext &context, const QgsCalloutContext &calloutContext, bool &pinned ) const;
 
  private:
    bool mEnabled = false;
 
    AnchorPoint mAnchorPoint = PoleOfInaccessibility;
    LabelAnchorPoint mLabelAnchorPoint = LabelPointOnExterior;
 
    QPainter::CompositionMode mBlendMode = QPainter::CompositionMode_SourceOver;

    QgsPropertyCollection mDataDefinedProperties;

    static QgsPropertiesDefinition sPropertyDefinitions;
 
    static void initPropertyDefinitions();
};

class CORE_EXPORT QgsSimpleLineCallout : public QgsCallout
{
  public:
    QgsSimpleLineCallout();
    ~QgsSimpleLineCallout() override;
 
#ifndef SIP_RUN
    QgsSimpleLineCallout( const QgsSimpleLineCallout &other );
    QgsSimpleLineCallout &operator=( const QgsSimpleLineCallout & ) = delete;
#endif

    static QgsCallout *create( const QVariantMap &properties = QVariantMap(), const QgsReadWriteContext &context = QgsReadWriteContext() ) SIP_FACTORY;
 
    QString type() const override;
    QgsSimpleLineCallout *clone() const override;
    QVariantMap properties( const QgsReadWriteContext &context ) const override;
    void readProperties( const QVariantMap &props, const QgsReadWriteContext &context ) override;
    void startRender( QgsRenderContext &context ) override;
    void stopRender( QgsRenderContext &context ) override;
    QSet< QString > referencedFields( const QgsRenderContext &context ) const override;

    QgsLineSymbol *lineSymbol();

    void setLineSymbol( QgsLineSymbol *symbol SIP_TRANSFER );

    double minimumLength() const { return mMinCalloutLength; }

    void setMinimumLength( double length ) { mMinCalloutLength = length; }

    void setMinimumLengthUnit( Qgis::RenderUnit unit ) { mMinCalloutLengthUnit = unit; }

    Qgis::RenderUnit minimumLengthUnit() const { return mMinCalloutLengthUnit; }

    void setMinimumLengthMapUnitScale( const QgsMapUnitScale &scale ) { mMinCalloutLengthScale = scale; }

    const QgsMapUnitScale &minimumLengthMapUnitScale() const { return mMinCalloutLengthScale; }
 

    double offsetFromAnchor() const { return mOffsetFromAnchorDistance; }

    void setOffsetFromAnchor( double distance ) { mOffsetFromAnchorDistance = distance; }

    void setOffsetFromAnchorUnit( Qgis::RenderUnit unit ) { mOffsetFromAnchorUnit = unit; }

    Qgis::RenderUnit offsetFromAnchorUnit() const { return mOffsetFromAnchorUnit; }

    void setOffsetFromAnchorMapUnitScale( const QgsMapUnitScale &scale ) { mOffsetFromAnchorScale = scale; }

    const QgsMapUnitScale &offsetFromAnchorMapUnitScale() const { return mOffsetFromAnchorScale; }

    double offsetFromLabel() const { return mOffsetFromLabelDistance; }

    void setOffsetFromLabel( double distance ) { mOffsetFromLabelDistance = distance; }

    void setOffsetFromLabelUnit( Qgis::RenderUnit unit ) { mOffsetFromLabelUnit = unit; }

    Qgis::RenderUnit offsetFromLabelUnit() const { return mOffsetFromLabelUnit; }

    void setOffsetFromLabelMapUnitScale( const QgsMapUnitScale &scale ) { mOffsetFromLabelScale = scale; }

    const QgsMapUnitScale &offsetFromLabelMapUnitScale() const { return mOffsetFromLabelScale; }

    bool drawCalloutToAllParts() const { return mDrawCalloutToAllParts; }

    void setDrawCalloutToAllParts( bool drawToAllParts ) { mDrawCalloutToAllParts = drawToAllParts; }
 
  protected:
    void draw( QgsRenderContext &context, const QRectF &bodyBoundingBox, const double angle, const QgsGeometry &anchor, QgsCallout::QgsCalloutContext &calloutContext ) override;

    virtual QgsCurve *createCalloutLine(
      const QgsPoint &start, const QgsPoint &end, QgsRenderContext &context, const QRectF &bodyBoundingBox, const double angle, const QgsGeometry &anchor, QgsCallout::QgsCalloutContext &calloutContext
    ) const SIP_FACTORY;
 
  private:
#ifdef SIP_RUN
    QgsSimpleLineCallout( const QgsSimpleLineCallout &other );
    QgsSimpleLineCallout &operator=( const QgsSimpleLineCallout & );
#endif
 
    std::unique_ptr< QgsLineSymbol > mLineSymbol;
    double mMinCalloutLength = 0;
    Qgis::RenderUnit mMinCalloutLengthUnit = Qgis::RenderUnit::Millimeters;
    QgsMapUnitScale mMinCalloutLengthScale;
 
    double mOffsetFromAnchorDistance = 0;
    Qgis::RenderUnit mOffsetFromAnchorUnit = Qgis::RenderUnit::Millimeters;
    QgsMapUnitScale mOffsetFromAnchorScale;
 
    double mOffsetFromLabelDistance = 0;
    Qgis::RenderUnit mOffsetFromLabelUnit = Qgis::RenderUnit::Millimeters;
    QgsMapUnitScale mOffsetFromLabelScale;
 
    bool mDrawCalloutToAllParts = false;
};
 

class CORE_EXPORT QgsManhattanLineCallout : public QgsSimpleLineCallout
{
  public:
    QgsManhattanLineCallout();
 
#ifndef SIP_RUN
    QgsManhattanLineCallout( const QgsManhattanLineCallout &other );
    QgsManhattanLineCallout &operator=( const QgsManhattanLineCallout & ) = delete;
#endif

    static QgsCallout *create( const QVariantMap &properties = QVariantMap(), const QgsReadWriteContext &context = QgsReadWriteContext() ) SIP_FACTORY; // cppcheck-suppress duplInheritedMember
 
    QString type() const override;
    QgsManhattanLineCallout *clone() const override;
 
  protected:
    QgsCurve *createCalloutLine(
      const QgsPoint &start, const QgsPoint &end, QgsRenderContext &context, const QRectF &bodyBoundingBox, const double angle, const QgsGeometry &anchor, QgsCallout::QgsCalloutContext &calloutContext
    ) const override SIP_FACTORY;
 
  private:
#ifdef SIP_RUN
    QgsManhattanLineCallout( const QgsManhattanLineCallout &other );
    QgsManhattanLineCallout &operator=( const QgsManhattanLineCallout & );
#endif
};
 

class CORE_EXPORT QgsCurvedLineCallout : public QgsSimpleLineCallout
{
  public:
    enum Orientation
    {
      Automatic,        
      Clockwise,        
      CounterClockwise, 
    };
 
    QgsCurvedLineCallout();
 
#ifndef SIP_RUN
    QgsCurvedLineCallout( const QgsCurvedLineCallout &other );
    QgsCurvedLineCallout &operator=( const QgsCurvedLineCallout & ) = delete;
#endif

    static QgsCallout *create( const QVariantMap &properties = QVariantMap(), const QgsReadWriteContext &context = QgsReadWriteContext() ) SIP_FACTORY; // cppcheck-suppress duplInheritedMember
 
    QString type() const override;
    QgsCurvedLineCallout *clone() const override;
    QVariantMap properties( const QgsReadWriteContext &context ) const override;

    double curvature() const;

    void setCurvature( double curvature );

    Orientation orientation() const;

    void setOrientation( Orientation orientation );
 
  protected:
    QgsCurve *createCalloutLine(
      const QgsPoint &start, const QgsPoint &end, QgsRenderContext &context, const QRectF &bodyBoundingBox, const double angle, const QgsGeometry &anchor, QgsCalloutContext &calloutContext
    ) const override SIP_FACTORY;
 
  private:
#ifdef SIP_RUN
    QgsCurvedLineCallout( const QgsCurvedLineCallout &other );
    QgsCurvedLineCallout &operator=( const QgsCurvedLineCallout & );
#endif

    static Orientation decodeOrientation( const QString &string );

    static QString encodeOrientation( Orientation orientation );
 
 
    Orientation mOrientation = Automatic;
    double mCurvature = 0.1;
};
 

class CORE_EXPORT QgsBalloonCallout : public QgsCallout
{
  public:
    QgsBalloonCallout();
    ~QgsBalloonCallout() override;
 
#ifndef SIP_RUN
    QgsBalloonCallout( const QgsBalloonCallout &other );
    QgsBalloonCallout &operator=( const QgsBalloonCallout & ) = delete;
#endif

    static QgsCallout *create( const QVariantMap &properties = QVariantMap(), const QgsReadWriteContext &context = QgsReadWriteContext() ) SIP_FACTORY;
 
    QString type() const override;
    QgsBalloonCallout *clone() const override;
    QVariantMap properties( const QgsReadWriteContext &context ) const override;
    void readProperties( const QVariantMap &props, const QgsReadWriteContext &context ) override;
    void startRender( QgsRenderContext &context ) override;
    void stopRender( QgsRenderContext &context ) override;
    QSet< QString > referencedFields( const QgsRenderContext &context ) const override;

    QgsFillSymbol *fillSymbol();

    void setFillSymbol( QgsFillSymbol *symbol SIP_TRANSFER );

    QgsMarkerSymbol *markerSymbol();

    void setMarkerSymbol( QgsMarkerSymbol *symbol SIP_TRANSFER );

    double offsetFromAnchor() const { return mOffsetFromAnchorDistance; }

    void setOffsetFromAnchor( double distance ) { mOffsetFromAnchorDistance = distance; }

    void setOffsetFromAnchorUnit( Qgis::RenderUnit unit ) { mOffsetFromAnchorUnit = unit; }

    Qgis::RenderUnit offsetFromAnchorUnit() const { return mOffsetFromAnchorUnit; }

    void setOffsetFromAnchorMapUnitScale( const QgsMapUnitScale &scale ) { mOffsetFromAnchorScale = scale; }

    const QgsMapUnitScale &offsetFromAnchorMapUnitScale() const { return mOffsetFromAnchorScale; }

    const QgsMargins &margins() const { return mMargins; }

    void setMargins( const QgsMargins &margins ) { mMargins = margins; }

    void setMarginsUnit( Qgis::RenderUnit unit ) { mMarginUnit = unit; }

    Qgis::RenderUnit marginsUnit() const { return mMarginUnit; }

    double wedgeWidth() const { return mWedgeWidth; }

    void setWedgeWidth( double width ) { mWedgeWidth = width; }

    void setWedgeWidthUnit( Qgis::RenderUnit unit ) { mWedgeWidthUnit = unit; }

    Qgis::RenderUnit wedgeWidthUnit() const { return mWedgeWidthUnit; }

    void setWedgeWidthMapUnitScale( const QgsMapUnitScale &scale ) { mWedgeWidthScale = scale; }

    const QgsMapUnitScale &wedgeWidthMapUnitScale() const { return mWedgeWidthScale; }

    double cornerRadius() const { return mCornerRadius; }

    void setCornerRadius( double radius ) { mCornerRadius = radius; }

    void setCornerRadiusUnit( Qgis::RenderUnit unit ) { mCornerRadiusUnit = unit; }

    Qgis::RenderUnit cornerRadiusUnit() const { return mCornerRadiusUnit; }

    void setCornerRadiusMapUnitScale( const QgsMapUnitScale &scale ) { mCornerRadiusScale = scale; }

    const QgsMapUnitScale &cornerRadiusMapUnitScale() const { return mCornerRadiusScale; }
 
 
  protected:
    void draw( QgsRenderContext &context, const QRectF &bodyBoundingBox, const double angle, const QgsGeometry &anchor, QgsCallout::QgsCalloutContext &calloutContext ) override;
 
  private:
    QPolygonF getPoints( QgsRenderContext &context, QgsPointXY origin, QRectF rect ) const;
 
#ifdef SIP_RUN
    QgsBalloonCallout( const QgsBalloonCallout &other );
    QgsBalloonCallout &operator=( const QgsBalloonCallout & );
#endif
 
    std::unique_ptr< QgsFillSymbol > mFillSymbol;
    std::unique_ptr< QgsMarkerSymbol > mMarkerSymbol;
 
    double mOffsetFromAnchorDistance = 0;
    Qgis::RenderUnit mOffsetFromAnchorUnit = Qgis::RenderUnit::Millimeters;
    QgsMapUnitScale mOffsetFromAnchorScale;
 
    QgsMargins mMargins;
    Qgis::RenderUnit mMarginUnit = Qgis::RenderUnit::Millimeters;
 
    double mWedgeWidth = 2.64;
    Qgis::RenderUnit mWedgeWidthUnit = Qgis::RenderUnit::Millimeters;
    QgsMapUnitScale mWedgeWidthScale;
 
    double mCornerRadius = 0.0;
    Qgis::RenderUnit mCornerRadiusUnit = Qgis::RenderUnit::Millimeters;
    QgsMapUnitScale mCornerRadiusScale;
};
 
 
#endif // QGSCALLOUT_H