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 <QString>
#include <QRectF>
#include <memory>
 
class QgsLineSymbol;
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
    {
      sipType = 0;
    }
    SIP_END
#endif
 
  public:
 
    enum Property
    {
      MinimumCalloutLength, 
      OffsetFromAnchor, 
      OffsetFromLabel, 
      DrawCalloutToAllParts, 
      AnchorPointPosition, 
      LabelAnchorPointPosition, 
    };
 
    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 );
 
    virtual void startRender( QgsRenderContext &context );
 
    virtual void stopRender( QgsRenderContext &context );
 
    virtual QSet< QString > referencedFields( const QgsRenderContext &context ) const;
 
    virtual DrawOrder drawOrder() const;
 
    struct CORE_EXPORT QgsCalloutContext
    {
      bool allFeaturePartsLabeled = false;
    };
 
    void render( QgsRenderContext &context, 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 );
 
  protected:
 
    virtual void draw( QgsRenderContext &context, QRectF bodyBoundingBox, const double angle, const QgsGeometry &anchor, QgsCalloutContext &calloutContext ) = 0;
 
    QgsGeometry labelAnchorGeometry( QRectF bodyBoundingBox, const double angle, LabelAnchorPoint anchor ) const;
 
  private:
 
    bool mEnabled = false;
 
    AnchorPoint mAnchorPoint = PoleOfInaccessibility;
    LabelAnchorPoint mLabelAnchorPoint = LabelPointOnExterior;
 
    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, QRectF bodyBoundingBox, const double angle, const QgsGeometry &anchor, QgsCallout::QgsCalloutContext &calloutContext ) override;
 
  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:
    void draw( QgsRenderContext &context, QRectF bodyBoundingBox, const double angle, const QgsGeometry &anchor, QgsCallout::QgsCalloutContext &calloutContext ) override;
 
  private:
#ifdef SIP_RUN
    QgsManhattanLineCallout( const QgsManhattanLineCallout &other );
    QgsManhattanLineCallout &operator=( const QgsManhattanLineCallout & );
#endif
};
 
 
#endif // QGSCALLOUT_H