qgssymbol.h

Go to the documentation of this file.

/***************************************************************************
 qgssymbol.h
 ---------------------
 begin                : November 2009
 copyright            : (C) 2009 by Martin Dobias
 email                : wonder dot sk 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 QGSSYMBOL_H
#define QGSSYMBOL_H
 
#include "qgis.h"
#include "qgis_core.h"
#include "qgspropertycollection.h"
#include "qgsrendercontext.h"
#include "qgsscreenproperties.h"
 
class QgsSymbolLayer;
class QgsLegendPatchShape;
class QgsSymbolRenderContext;
class QgsLineSymbolLayer;
 
typedef QList<QgsSymbolLayer *> QgsSymbolLayerList;

class CORE_EXPORT QgsSymbolAnimationSettings
{
  public:
    void setIsAnimated( bool animated ) { mIsAnimated = animated; }

    bool isAnimated() const { return mIsAnimated; }

    void setFrameRate( double rate ) { mFrameRate = rate; }

    double frameRate() const { return mFrameRate; }
 
  private:
    bool mIsAnimated = false;
    double mFrameRate = 10;
};
 

class CORE_EXPORT QgsSymbolBufferSettings
{
  public:
    QgsSymbolBufferSettings();
    ~QgsSymbolBufferSettings();
 
    QgsSymbolBufferSettings( const QgsSymbolBufferSettings &other );
    QgsSymbolBufferSettings &operator=( const QgsSymbolBufferSettings & );

    bool enabled() const { return mEnabled; }

    void setEnabled( bool enabled ) { mEnabled = enabled; }

    double size() const { return mSize; }

    void setSize( double size ) { mSize = size; }

    Qgis::RenderUnit sizeUnit() const { return mSizeUnit; }

    void setSizeUnit( Qgis::RenderUnit unit ) { mSizeUnit = unit; }

    QgsMapUnitScale sizeMapUnitScale() const { return mSizeMapUnitScale; }

    void setSizeMapUnitScale( const QgsMapUnitScale &scale ) { mSizeMapUnitScale = scale; }

    Qt::PenJoinStyle joinStyle() const { return mJoinStyle; }

    void setJoinStyle( Qt::PenJoinStyle style ) { mJoinStyle = style; }

    QgsFillSymbol *fillSymbol() const;

    void setFillSymbol( QgsFillSymbol *symbol SIP_TRANSFER );
 

    void writeXml( QDomElement &element, const QgsReadWriteContext &context ) const;

    void readXml( const QDomElement &element, const QgsReadWriteContext &context );
 
  private:
    bool mEnabled = false;
    double mSize = 1;
    Qgis::RenderUnit mSizeUnit = Qgis::RenderUnit::Millimeters;
    QgsMapUnitScale mSizeMapUnitScale;
    Qt::PenJoinStyle mJoinStyle = Qt::RoundJoin;
    std::unique_ptr< QgsFillSymbol > mFillSymbol;
};
 

class CORE_EXPORT QgsSymbol
{
#ifdef SIP_RUN
    SIP_CONVERT_TO_SUBCLASS_CODE
    switch ( sipCpp->type() )
    {
      case Qgis::SymbolType::Marker:
        sipType = sipType_QgsMarkerSymbol;
        break;
      case Qgis::SymbolType::Line:
        sipType = sipType_QgsLineSymbol;
        break;
      case Qgis::SymbolType::Fill:
        sipType = sipType_QgsFillSymbol;
        break;
      default:
        sipType = 0;
        break;
    }
    SIP_END
#endif
 
    friend class QgsFeatureRenderer;
 
  public:
    static QString symbolTypeToString( Qgis::SymbolType type );

    static Qgis::SymbolType symbolTypeForGeometryType( Qgis::GeometryType type );
 
    // *INDENT-OFF*

    enum class Property SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsSymbol, Property ) : int
    {
      Opacity SIP_MONKEYPATCH_COMPAT_NAME( PropertyOpacity ), 
      ExtentBuffer,                                           
    };
    // *INDENT-ON*

    static const QgsPropertiesDefinition &propertyDefinitions();
 
    virtual ~QgsSymbol();

    static QgsSymbol *defaultSymbol( Qgis::GeometryType geomType ) SIP_FACTORY;

    Qgis::SymbolType type() const { return mType; }
 
    // symbol layers handling

    QgsSymbolLayerList symbolLayers() const { return mLayers; }
 
#ifndef SIP_RUN

    QgsSymbolLayer *symbolLayer( int layer );

    const QgsSymbolLayer *symbolLayer( int layer ) const;
#else
    // clang-format off

    SIP_PYOBJECT symbolLayer( int layer ) SIP_TYPEHINT( QgsSymbolLayer );
    % MethodCode
    const int count = sipCpp->symbolLayerCount();
    if ( a0 < 0 || a0 >= count )
    {
      PyErr_SetString( PyExc_IndexError, QByteArray::number( a0 ) );
      sipIsErr = 1;
    }
    else
    {
      sipRes = sipConvertFromType( sipCpp->symbolLayer( a0 ), sipType_QgsSymbolLayer, NULL );
    }
    % End
// clang-format on
#endif

    int symbolLayerCount() const { return mLayers.count(); }
 
#ifdef SIP_RUN
    // clang-format off

    int __len__() const;
    % MethodCode
    sipRes = sipCpp->symbolLayerCount();
    % End

    int __bool__() const;
    % MethodCode
    sipRes = true;
    % End

    SIP_PYOBJECT __getitem__( int index ) SIP_TYPEHINT( QgsSymbolLayer );
    % MethodCode
    const int count = sipCpp->symbolLayerCount();
    if ( a0 < -count || a0 >= count )
    {
      PyErr_SetString( PyExc_IndexError, QByteArray::number( a0 ) );
      sipIsErr = 1;
    }
    else if ( a0 >= 0 )
    {
      return sipConvertFromType( sipCpp->symbolLayer( a0 ), sipType_QgsSymbolLayer, NULL );
    }
    else
    {
      return sipConvertFromType( sipCpp->symbolLayer( count + a0 ), sipType_QgsSymbolLayer, NULL );
    }
    % End

    void __delitem__( int index );
    % MethodCode
    const int count = sipCpp->symbolLayerCount();
    if ( a0 >= 0 && a0 < count )
      sipCpp->deleteSymbolLayer( a0 );
    else if ( a0 < 0 && a0 >= -count )
      sipCpp->deleteSymbolLayer( count + a0 );
    else
    {
      PyErr_SetString( PyExc_IndexError, QByteArray::number( a0 ) );
      sipIsErr = 1;
    }
    % End
// clang-format on
#endif

      bool insertSymbolLayer( int index, QgsSymbolLayer *layer SIP_TRANSFER );

    bool appendSymbolLayer( QgsSymbolLayer *layer SIP_TRANSFER );

    bool deleteSymbolLayer( int index );

    QgsSymbolLayer *takeSymbolLayer( int index ) SIP_TRANSFERBACK;

    bool changeSymbolLayer( int index, QgsSymbolLayer *layer SIP_TRANSFER );

    void startRender( QgsRenderContext &context, const QgsFields &fields = QgsFields() );

    void stopRender( QgsRenderContext &context );

    void setColor( const QColor &color ) const;

    QColor color() const;

    void drawPreviewIcon(
      QPainter *painter,
      QSize size,
      QgsRenderContext *customContext = nullptr,
      bool selected = false,
      const QgsExpressionContext *expressionContext = nullptr,
      const QgsLegendPatchShape *patchShape = nullptr,
      const QgsScreenProperties &screen = QgsScreenProperties()
    );

    void exportImage( const QString &path, const QString &format, QSize size );

    QImage asImage( QSize size, QgsRenderContext *customContext = nullptr );

    QImage bigSymbolPreviewImage(
      QgsExpressionContext *expressionContext = nullptr,
      Qgis::SymbolPreviewFlags flags = Qgis::SymbolPreviewFlag::FlagIncludeCrosshairsForMarkerSymbols,
      const QgsScreenProperties &screen = QgsScreenProperties()
    ) SIP_PYNAME( bigSymbolPreviewImageV2 );

    Q_DECL_DEPRECATED QImage bigSymbolPreviewImage( QgsExpressionContext *expressionContext = nullptr, int flags = static_cast< int >( Qgis::SymbolPreviewFlag::FlagIncludeCrosshairsForMarkerSymbols ) )
      SIP_DEPRECATED;

    QString dump() const;

    bool rendersIdenticallyTo( const QgsSymbol *other ) const;

    virtual QgsSymbol *clone() const = 0 SIP_FACTORY;

    Q_DECL_DEPRECATED void toSld( QDomDocument &doc, QDomElement &element, QVariantMap props ) const SIP_DEPRECATED;

    bool toSld( QDomDocument &doc, QDomElement &element, QgsSldExportContext &context ) const;

    Qgis::RenderUnit outputUnit() const;

    bool usesMapUnits() const;

    void setOutputUnit( Qgis::RenderUnit unit ) const;

    QgsMapUnitScale mapUnitScale() const;

    void setMapUnitScale( const QgsMapUnitScale &scale ) const;

    qreal opacity() const { return mOpacity; }

    void setOpacity( qreal opacity ) { mOpacity = opacity; }

    void setRenderHints( Qgis::SymbolRenderHints hints ) { mRenderHints = hints; }

    Qgis::SymbolRenderHints renderHints() const;

    void setFlags( Qgis::SymbolFlags flags ) { mSymbolFlags = flags; }

    Qgis::SymbolFlags flags() const;

    void setClipFeaturesToExtent( bool clipFeaturesToExtent ) { mClipFeaturesToExtent = clipFeaturesToExtent; }

    bool clipFeaturesToExtent() const { return mClipFeaturesToExtent; }

    void setForceRHR( bool force ) { mForceRHR = force; }

    bool forceRHR() const { return mForceRHR; }

    QgsSymbolBufferSettings *bufferSettings();

    const QgsSymbolBufferSettings *bufferSettings() const SIP_SKIP;

    void setBufferSettings( QgsSymbolBufferSettings *settings SIP_TRANSFER );

    QgsSymbolAnimationSettings &animationSettings();

    const QgsSymbolAnimationSettings &animationSettings() const SIP_SKIP;

    void setAnimationSettings( const QgsSymbolAnimationSettings &settings );

    QSet<QString> usedAttributes( const QgsRenderContext &context ) const;

    void setDataDefinedProperty( Property key, const QgsProperty &property );

    QgsPropertyCollection &dataDefinedProperties() { return mDataDefinedProperties; }

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

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

    bool hasDataDefinedProperties() const;

    bool canCauseArtifactsBetweenAdjacentTiles() const;

    Q_DECL_DEPRECATED void setLayer( const QgsVectorLayer *layer ) SIP_DEPRECATED;

    Q_DECL_DEPRECATED const QgsVectorLayer *layer() const SIP_DEPRECATED;

    void renderFeature(
      const QgsFeature &feature,
      QgsRenderContext &context,
      int layer = -1,
      bool selected = false,
      bool drawVertexMarker = false,
      Qgis::VertexMarkerType currentVertexMarkerType = Qgis::VertexMarkerType::SemiTransparentCircle,
      double currentVertexMarkerSize = 0.0
    ) SIP_THROW( QgsCsException );

    QgsSymbolRenderContext *symbolRenderContext();

    void startFeatureRender( const QgsFeature &feature, QgsRenderContext &context, int layer = -1 );

    void stopFeatureRender( const QgsFeature &feature, QgsRenderContext &context, int layer = -1 );

    double extentBuffer() const;

    void setExtentBuffer( double extentBuffer );

    Qgis::RenderUnit extentBufferSizeUnit() const { return mExtentBufferSizeUnit; }

    void setExtentBufferSizeUnit( Qgis::RenderUnit unit ) { mExtentBufferSizeUnit = unit; }
 
  protected:
    QgsSymbol( Qgis::SymbolType type, const QgsSymbolLayerList &layers SIP_TRANSFER ); // can't be instantiated

    static inline QPointF _getPoint( QgsRenderContext &context, const QgsPoint &point )
    {
      QPointF pt;
      if ( context.coordinateTransform().isValid() )
      {
        double x = point.x();
        double y = point.y();
        double z = 0.0;
        context.coordinateTransform().transformInPlace( x, y, z );
        pt = QPointF( x, y );
      }
      else
        pt = point.toQPointF();
 
      context.mapToPixel().transformInPlace( pt.rx(), pt.ry() );
      return pt;
    }

    static QPolygonF _getLineString( QgsRenderContext &context, const QgsCurve &curve, bool clipToExtent = true );

    static QPolygonF _getPolygonRing( QgsRenderContext &context, const QgsCurve &curve, bool clipToExtent, bool isExteriorRing = false, bool correctRingOrientation = false );

    static void _getPolygon( QPolygonF &pts, QVector<QPolygonF> &holes, QgsRenderContext &context, const QgsPolygon &polygon, bool clipToExtent = true, bool correctRingOrientation = false );

    QgsSymbolLayerList cloneLayers() const SIP_FACTORY;

    void copyCommonProperties( const QgsSymbol *other );

    void renderUsingLayer(
      QgsSymbolLayer *layer, QgsSymbolRenderContext &context, Qgis::GeometryType geometryType = Qgis::GeometryType::Unknown, const QPolygonF *points = nullptr, const QVector<QPolygonF> *rings = nullptr
    );

    void renderVertexMarker( QPointF pt, QgsRenderContext &context, Qgis::VertexMarkerType currentVertexMarkerType, double currentVertexMarkerSize );
 
    Qgis::SymbolType mType;
    QgsSymbolLayerList mLayers;
 
    double mExtentBuffer = 0;
    Qgis::RenderUnit mExtentBufferSizeUnit = Qgis::RenderUnit::MapUnits;

    qreal mOpacity = 1.0;
 
    Qgis::SymbolRenderHints mRenderHints;

    Qgis::SymbolFlags mSymbolFlags = Qgis::SymbolFlags();
 
    bool mClipFeaturesToExtent = true;
    bool mForceRHR = false;
 
    std::unique_ptr< QgsSymbolBufferSettings > mBufferSettings;
    QgsSymbolAnimationSettings mAnimationSettings;
 
    Q_DECL_DEPRECATED const QgsVectorLayer *mLayer = nullptr; //current vectorlayer
 
  private:
#ifdef SIP_RUN
    QgsSymbol( const QgsSymbol & );
#endif
 
    static void initPropertyDefinitions();

    static QgsPropertiesDefinition sPropertyDefinitions;

    bool mStarted = false;

    std::unique_ptr< QgsSymbolRenderContext > mSymbolRenderContext;
 
    QgsPropertyCollection mDataDefinedProperties;

    static QPolygonF _getLineString2d( QgsRenderContext &context, const QgsCurve &curve, bool clipToExtent = true );

    static QPolygonF _getLineString3d( QgsRenderContext &context, const QgsCurve &curve, bool clipToExtent = true );

    static QPolygonF _getPolygonRing2d( QgsRenderContext &context, const QgsCurve &curve, bool clipToExtent, bool isExteriorRing = false, bool correctRingOrientation = false );

    static QPolygonF _getPolygonRing3d( QgsRenderContext &context, const QgsCurve &curve, bool clipToExtent, bool isExteriorRing = false, bool correctRingOrientation = false );
 
    Q_DISABLE_COPY( QgsSymbol )
};
 
#endif