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 "qgis_core.h"
#include "qgis_sip.h"
#include "qgsexpressioncontext.h"
#include "qgsreadwritecontext.h"
#include "qgspropertycollection.h"
#include "qgsmapunitscale.h"
#include "qgscalloutposition.h"
#include "qgsmargins.h"
 
#include <QPainter>
#include <QString>
#include <QRectF>
#include <memory>
 
class QgsLineSymbol;
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:
 
    enum Property
    {
      MinimumCalloutLength, 
      OffsetFromAnchor, 
      OffsetFromLabel, 
      DrawCalloutToAllParts, 
      AnchorPointPosition, 
      LabelAnchorPointPosition, 
      OriginX, 
      OriginY, 
      DestinationX, 
      DestinationY, 
      Curvature, 
      Orientation, 
      Margins, 
      WedgeWidth, 
      CornerRadius, 
      BlendMode, 
    };
 
    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( QgsUnitTypes::RenderUnit unit ) { mMinCalloutLengthUnit = unit; }
 
    QgsUnitTypes::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( QgsUnitTypes::RenderUnit unit ) { mOffsetFromAnchorUnit = unit; }
 
    QgsUnitTypes::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( QgsUnitTypes::RenderUnit unit ) { mOffsetFromLabelUnit = unit; }
 
    QgsUnitTypes::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;
    QgsUnitTypes::RenderUnit mMinCalloutLengthUnit = QgsUnitTypes::RenderMillimeters;
    QgsMapUnitScale mMinCalloutLengthScale;
 
    double mOffsetFromAnchorDistance = 0;
    QgsUnitTypes::RenderUnit mOffsetFromAnchorUnit = QgsUnitTypes::RenderMillimeters;
    QgsMapUnitScale mOffsetFromAnchorScale;
 
    double mOffsetFromLabelDistance = 0;
    QgsUnitTypes::RenderUnit mOffsetFromLabelUnit = QgsUnitTypes::RenderMillimeters;
    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;
 
    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;
 
    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 );
 
    double offsetFromAnchor() const { return mOffsetFromAnchorDistance; }
 
    void setOffsetFromAnchor( double distance ) { mOffsetFromAnchorDistance = distance; }
 
    void setOffsetFromAnchorUnit( QgsUnitTypes::RenderUnit unit ) { mOffsetFromAnchorUnit = unit; }
 
    QgsUnitTypes::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( QgsUnitTypes::RenderUnit unit ) { mMarginUnit = unit; }
 
    QgsUnitTypes::RenderUnit marginsUnit() const { return mMarginUnit; }
 
    double wedgeWidth() const { return mWedgeWidth; }
 
    void setWedgeWidth( double width ) { mWedgeWidth = width; }
 
    void setWedgeWidthUnit( QgsUnitTypes::RenderUnit unit ) { mWedgeWidthUnit = unit; }
 
    QgsUnitTypes::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( QgsUnitTypes::RenderUnit unit ) { mCornerRadiusUnit = unit; }
 
    QgsUnitTypes::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;
 
    double mOffsetFromAnchorDistance = 0;
    QgsUnitTypes::RenderUnit mOffsetFromAnchorUnit = QgsUnitTypes::RenderMillimeters;
    QgsMapUnitScale mOffsetFromAnchorScale;
 
    QgsMargins mMargins;
    QgsUnitTypes::RenderUnit mMarginUnit = QgsUnitTypes::RenderMillimeters;
 
    double mWedgeWidth = 2.64;
    QgsUnitTypes::RenderUnit mWedgeWidthUnit = QgsUnitTypes::RenderMillimeters;
    QgsMapUnitScale mWedgeWidthScale;
 
    double mCornerRadius = 0.0;
    QgsUnitTypes::RenderUnit mCornerRadiusUnit = QgsUnitTypes::RenderMillimeters;
    QgsMapUnitScale mCornerRadiusScale;
 
};
 
 
 
#endif // QGSCALLOUT_H