api/master/qgssymbollayer_8cpp_source.html

/***************************************************************************

 qgssymbollayer.cpp

 ---------------------

 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.                                   *

 *                                                                         *

 ***************************************************************************/


#include "qgssymbollayer.h"


#include "qgsdxfexport.h"

#include "qgsexpressioncontext.h"

#include "qgsexpressioncontextutils.h"

#include "qgsgeometrysimplifier.h"

#include "qgsgeos.h"

#include "qgslegendpatchshape.h"

#include "qgspainteffect.h"

#include "qgspainteffectregistry.h"

#include "qgsproperty.h"

#include "qgsrendercontext.h"

#include "qgssldexportcontext.h"

#include "qgsstyle.h"

#include "qgssymbol.h"

#include "qgssymbollayerreference.h"

#include "qgssymbollayerutils.h"


#include <QPainter>

#include <QPointF>

#include <QPolygonF>

#include <QSize>

#include <QString>

#include <QUuid>


using namespace Qt::StringLiterals;


QgsPropertiesDefinition QgsSymbolLayer::sPropertyDefinitions;


void QgsSymbolLayer::initPropertyDefinitions()

{

  if ( !sPropertyDefinitions.isEmpty() )

    return;


  QString origin = u"symbol"_s;


  sPropertyDefinitions = QgsPropertiesDefinition {

    { static_cast< int >( QgsSymbolLayer::Property::Size ), QgsPropertyDefinition( "size", QObject::tr( "Symbol size" ), QgsPropertyDefinition::Size, origin ) },

    { static_cast< int >( QgsSymbolLayer::Property::Angle ), QgsPropertyDefinition( "angle", QObject::tr( "Rotation angle" ), QgsPropertyDefinition::Rotation, origin ) },

    { static_cast< int >( QgsSymbolLayer::Property::Name ), QgsPropertyDefinition( "name", QObject::tr( "Symbol name" ), QgsPropertyDefinition::String, origin ) },

    { static_cast< int >( QgsSymbolLayer::Property::FillColor ), QgsPropertyDefinition( "fillColor", QObject::tr( "Symbol fill color" ), QgsPropertyDefinition::ColorWithAlpha, origin ) },

    { static_cast< int >( QgsSymbolLayer::Property::StrokeColor ), QgsPropertyDefinition( "outlineColor", QObject::tr( "Symbol stroke color" ), QgsPropertyDefinition::ColorWithAlpha, origin ) },

    { static_cast< int >( QgsSymbolLayer::Property::StrokeWidth ), QgsPropertyDefinition( "outlineWidth", QObject::tr( "Symbol stroke width" ), QgsPropertyDefinition::StrokeWidth, origin ) },

    { static_cast< int >( QgsSymbolLayer::Property::StrokeStyle ), QgsPropertyDefinition( "outlineStyle", QObject::tr( "Symbol stroke style" ), QgsPropertyDefinition::LineStyle, origin ) },

    { static_cast< int >( QgsSymbolLayer::Property::Offset ), QgsPropertyDefinition( "offset", QObject::tr( "Symbol offset" ), QgsPropertyDefinition::Offset, origin ) },

    { static_cast< int >( QgsSymbolLayer::Property::Character ), QgsPropertyDefinition( "char", QObject::tr( "Marker character(s)" ), QgsPropertyDefinition::String, origin ) },

    { static_cast< int >( QgsSymbolLayer::Property::FontFamily ), QgsPropertyDefinition( "fontFamily", QObject::tr( "Font family" ), QgsPropertyDefinition::String, origin ) },

    { static_cast< int >( QgsSymbolLayer::Property::FontStyle ), QgsPropertyDefinition( "fontStyle", QObject::tr( "Font style" ), QgsPropertyDefinition::String, origin ) },

    { static_cast< int >( QgsSymbolLayer::Property::Width ), QgsPropertyDefinition( "width", QObject::tr( "Symbol width" ), QgsPropertyDefinition::DoublePositive, origin ) },

    { static_cast< int >( QgsSymbolLayer::Property::Height ), QgsPropertyDefinition( "height", QObject::tr( "Symbol height" ), QgsPropertyDefinition::DoublePositive, origin ) },

    { static_cast< int >( QgsSymbolLayer::Property::PreserveAspectRatio ),

      QgsPropertyDefinition( "preserveAspectRatio", QObject::tr( "Preserve aspect ratio between width and height" ), QgsPropertyDefinition::Boolean, origin ) },

    { static_cast< int >( QgsSymbolLayer::Property::FillStyle ), QgsPropertyDefinition( "fillStyle", QObject::tr( "Symbol fill style" ), QgsPropertyDefinition::FillStyle, origin ) },

    { static_cast< int >( QgsSymbolLayer::Property::JoinStyle ), QgsPropertyDefinition( "joinStyle", QObject::tr( "Outline join style" ), QgsPropertyDefinition::PenJoinStyle, origin ) },

    { static_cast< int >( QgsSymbolLayer::Property::SecondaryColor ), QgsPropertyDefinition( "color2", QObject::tr( "Secondary fill color" ), QgsPropertyDefinition::ColorWithAlpha, origin ) },

    { static_cast< int >( QgsSymbolLayer::Property::LineAngle ), QgsPropertyDefinition( "lineAngle", QObject::tr( "Angle for line fills" ), QgsPropertyDefinition::Rotation, origin ) },

    { static_cast< int >( QgsSymbolLayer::Property::GradientType ),

      QgsPropertyDefinition( "gradientType", QgsPropertyDefinition::DataTypeString, QObject::tr( "Gradient type" ), QObject::tr( "string " ) + "[<b>linear</b>|<b>radial</b>|<b>conical</b>]"_L1, origin ) },

    { static_cast< int >( QgsSymbolLayer::Property::CoordinateMode ),

      QgsPropertyDefinition( "gradientMode", QgsPropertyDefinition::DataTypeString, QObject::tr( "Gradient mode" ), QObject::tr( "string " ) + "[<b>feature</b>|<b>viewport</b>]"_L1, origin ) },

    { static_cast< int >( QgsSymbolLayer::Property::GradientSpread ),

      QgsPropertyDefinition( "gradientSpread", QgsPropertyDefinition::DataTypeString, QObject::tr( "Gradient spread" ), QObject::tr( "string " ) + "[<b>pad</b>|<b>repeat</b>|<b>reflect</b>]"_L1, origin ) },

    { static_cast< int >( QgsSymbolLayer::Property::GradientReference1X ), QgsPropertyDefinition( "gradientRef1X", QObject::tr( "Reference point 1 (X)" ), QgsPropertyDefinition::Double0To1, origin ) },

    { static_cast< int >( QgsSymbolLayer::Property::GradientReference1Y ), QgsPropertyDefinition( "gradientRef1Y", QObject::tr( "Reference point 1 (Y)" ), QgsPropertyDefinition::Double0To1, origin ) },

    { static_cast< int >( QgsSymbolLayer::Property::GradientReference2X ), QgsPropertyDefinition( "gradientRef2X", QObject::tr( "Reference point 2 (X)" ), QgsPropertyDefinition::Double0To1, origin ) },

    { static_cast< int >( QgsSymbolLayer::Property::GradientReference2Y ), QgsPropertyDefinition( "gradientRef2Y", QObject::tr( "Reference point 2 (Y)" ), QgsPropertyDefinition::Double0To1, origin ) },

    { static_cast< int >( QgsSymbolLayer::Property::GradientReference1IsCentroid ),

      QgsPropertyDefinition( "gradientRef1Centroid", QObject::tr( "Reference point 1 follows feature centroid" ), QgsPropertyDefinition::Boolean, origin ) },

    { static_cast< int >( QgsSymbolLayer::Property::GradientReference2IsCentroid ),

      QgsPropertyDefinition( "gradientRef2Centroid", QObject::tr( "Reference point 2 follows feature centroid" ), QgsPropertyDefinition::Boolean, origin ) },

    { static_cast< int >( QgsSymbolLayer::Property::BlurRadius ),

      QgsPropertyDefinition( "blurRadius", QgsPropertyDefinition::DataTypeNumeric, QObject::tr( "Blur radius" ), QObject::tr( "Integer between 0 and 18" ), origin ) },

    { static_cast< int >( QgsSymbolLayer::Property::LineDistance ), QgsPropertyDefinition( "lineDistance", QObject::tr( "Distance between lines" ), QgsPropertyDefinition::DoublePositive, origin ) },

    { static_cast< int >( QgsSymbolLayer::Property::ShapeburstUseWholeShape ),

      QgsPropertyDefinition( "shapeburstWholeShape", QObject::tr( "Shade whole shape" ), QgsPropertyDefinition::Boolean, origin ) },

    { static_cast< int >( QgsSymbolLayer::Property::ShapeburstMaxDistance ),

      QgsPropertyDefinition( "shapeburstMaxDist", QObject::tr( "Maximum distance for shapeburst fill" ), QgsPropertyDefinition::DoublePositive, origin ) },

    { static_cast< int >( QgsSymbolLayer::Property::ShapeburstIgnoreRings ),

      QgsPropertyDefinition( "shapeburstIgnoreRings", QObject::tr( "Ignore rings in feature" ), QgsPropertyDefinition::Boolean, origin ) },

    { static_cast< int >( QgsSymbolLayer::Property::File ), QgsPropertyDefinition( "file", QObject::tr( "Symbol file path" ), QgsPropertyDefinition::String, origin ) },

    { static_cast< int >( QgsSymbolLayer::Property::DistanceX ),

      QgsPropertyDefinition( "distanceX", QObject::tr( "Horizontal distance between markers" ), QgsPropertyDefinition::DoublePositive, origin ) },

    { static_cast< int >( QgsSymbolLayer::Property::DistanceY ), QgsPropertyDefinition( "distanceY", QObject::tr( "Vertical distance between markers" ), QgsPropertyDefinition::DoublePositive, origin ) },

    { static_cast< int >( QgsSymbolLayer::Property::DisplacementX ),

      QgsPropertyDefinition( "displacementX", QObject::tr( "Horizontal displacement between rows" ), QgsPropertyDefinition::DoublePositive, origin ) },

    { static_cast< int >( QgsSymbolLayer::Property::DisplacementY ),

      QgsPropertyDefinition( "displacementY", QObject::tr( "Vertical displacement between columns" ), QgsPropertyDefinition::DoublePositive, origin ) },

    { static_cast< int >( QgsSymbolLayer::Property::OffsetX ), QgsPropertyDefinition( "offsetX", QObject::tr( "Horizontal offset" ), QgsPropertyDefinition::Double, origin ) },

    { static_cast< int >( QgsSymbolLayer::Property::OffsetY ), QgsPropertyDefinition( "offsetY", QObject::tr( "Vertical offset" ), QgsPropertyDefinition::Double, origin ) },

    { static_cast< int >( QgsSymbolLayer::Property::Opacity ), QgsPropertyDefinition( "alpha", QObject::tr( "Opacity" ), QgsPropertyDefinition::Opacity, origin ) },

    { static_cast< int >( QgsSymbolLayer::Property::CustomDash ),

      QgsPropertyDefinition( "customDash", QgsPropertyDefinition::DataTypeString, QObject::tr( "Custom dash pattern" ), QObject::tr( "[<b><dash>;<space></b>] e.g. '8;2;1;2'" ), origin ) },

    { static_cast< int >( QgsSymbolLayer::Property::CapStyle ), QgsPropertyDefinition( "capStyle", QObject::tr( "Line cap style" ), QgsPropertyDefinition::CapStyle, origin ) },

    { static_cast< int >( QgsSymbolLayer::Property::Placement ),

      QgsPropertyDefinition(

        "placement",

        QgsPropertyDefinition::DataTypeString,

        QObject::tr( "Marker placement" ),

        QObject::tr( "string " ) + "[<b>interval</b>|<b>innervertices</b>|<b>vertex</b>|<b>lastvertex</b>|<b>firstvertex</b>|<b>centerpoint</b>|<b>curvepoint</b>|<b>segmentcenter</b>]",

        origin

      ) },

    { static_cast< int >( QgsSymbolLayer::Property::Interval ), QgsPropertyDefinition( "interval", QObject::tr( "Marker interval" ), QgsPropertyDefinition::DoublePositive, origin ) },

    { static_cast< int >( QgsSymbolLayer::Property::OffsetAlongLine ), QgsPropertyDefinition( "offsetAlongLine", QObject::tr( "Offset along line" ), QgsPropertyDefinition::Double, origin ) },

    { static_cast< int >( QgsSymbolLayer::Property::AverageAngleLength ),

      QgsPropertyDefinition( "averageAngleLength", QObject::tr( "Average line angles over" ), QgsPropertyDefinition::DoublePositive, origin ) },

    { static_cast< int >( QgsSymbolLayer::Property::HorizontalAnchor ), QgsPropertyDefinition( "hAnchor", QObject::tr( "Horizontal anchor point" ), QgsPropertyDefinition::HorizontalAnchor, origin ) },

    { static_cast< int >( QgsSymbolLayer::Property::VerticalAnchor ), QgsPropertyDefinition( "vAnchor", QObject::tr( "Vertical anchor point" ), QgsPropertyDefinition::VerticalAnchor, origin ) },

    { static_cast< int >( QgsSymbolLayer::Property::LayerEnabled ), QgsPropertyDefinition( "enabled", QObject::tr( "Layer enabled" ), QgsPropertyDefinition::Boolean, origin ) },

    { static_cast< int >( QgsSymbolLayer::Property::ArrowWidth ), QgsPropertyDefinition( "arrowWidth", QObject::tr( "Arrow line width" ), QgsPropertyDefinition::StrokeWidth, origin ) },

    { static_cast< int >( QgsSymbolLayer::Property::ArrowStartWidth ), QgsPropertyDefinition( "arrowStartWidth", QObject::tr( "Arrow line start width" ), QgsPropertyDefinition::StrokeWidth, origin ) },

    { static_cast< int >( QgsSymbolLayer::Property::ArrowHeadLength ), QgsPropertyDefinition( "arrowHeadLength", QObject::tr( "Arrow head length" ), QgsPropertyDefinition::DoublePositive, origin ) },

    { static_cast< int >( QgsSymbolLayer::Property::ArrowHeadThickness ),

      QgsPropertyDefinition( "arrowHeadThickness", QObject::tr( "Arrow head thickness" ), QgsPropertyDefinition::DoublePositive, origin ) },

    { static_cast< int >( QgsSymbolLayer::Property::ArrowHeadType ),

      QgsPropertyDefinition( "arrowHeadType", QgsPropertyDefinition::DataTypeString, QObject::tr( "Arrow head type" ), QObject::tr( "string " ) + "[<b>single</b>|<b>reversed</b>|<b>double</b>]"_L1, origin ) },

    { static_cast< int >( QgsSymbolLayer::Property::ArrowType ),

      QgsPropertyDefinition( "arrowType", QgsPropertyDefinition::DataTypeString, QObject::tr( "Arrow type" ), QObject::tr( "string " ) + "[<b>plain</b>|<b>lefthalf</b>|<b>righthalf</b>]"_L1, origin ) },

    { static_cast< int >( QgsSymbolLayer::Property::PointCount ), QgsPropertyDefinition( "pointCount", QObject::tr( "Point count" ), QgsPropertyDefinition::IntegerPositive, origin ) },

    { static_cast< int >( QgsSymbolLayer::Property::RandomSeed ),

      QgsPropertyDefinition( "randomSeed", QgsPropertyDefinition::DataTypeNumeric, QObject::tr( "Random number seed" ), QObject::tr( "integer > 0, or 0 for completely random sequence" ), origin ) },

    { static_cast< int >( QgsSymbolLayer::Property::ClipPoints ), QgsPropertyDefinition( "clipPoints", QObject::tr( "Clip markers" ), QgsPropertyDefinition::Boolean, origin ) },

    { static_cast< int >( QgsSymbolLayer::Property::DensityArea ), QgsPropertyDefinition( "densityArea", QObject::tr( "Density area" ), QgsPropertyDefinition::DoublePositive, origin ) },

    { static_cast< int >( QgsSymbolLayer::Property::DashPatternOffset ),

      QgsPropertyDefinition( "dashPatternOffset", QObject::tr( "Dash pattern offset" ), QgsPropertyDefinition::DoublePositive, origin ) },

    { static_cast< int >( QgsSymbolLayer::Property::TrimStart ), QgsPropertyDefinition( "trimStart", QObject::tr( "Start trim distance" ), QgsPropertyDefinition::DoublePositive, origin ) },

    { static_cast< int >( QgsSymbolLayer::Property::TrimEnd ), QgsPropertyDefinition( "trimEnd", QObject::tr( "End trim distance" ), QgsPropertyDefinition::DoublePositive, origin ) },

    { static_cast< int >( QgsSymbolLayer::Property::LineStartWidthValue ),

      QgsPropertyDefinition( "lineStartWidthValue", QObject::tr( "Line start width value" ), QgsPropertyDefinition::Double, origin ) },

    { static_cast< int >( QgsSymbolLayer::Property::LineEndWidthValue ), QgsPropertyDefinition( "lineEndWidthValue", QObject::tr( "Line end width value" ), QgsPropertyDefinition::Double, origin ) },

    { static_cast< int >( QgsSymbolLayer::Property::LineStartColorValue ),

      QgsPropertyDefinition( "lineStartColorValue", QObject::tr( "Line start color value" ), QgsPropertyDefinition::Double, origin ) },

    { static_cast< int >( QgsSymbolLayer::Property::LineEndColorValue ), QgsPropertyDefinition( "lineEndColorValue", QObject::tr( "Line end color value" ), QgsPropertyDefinition::Double, origin ) },

    { static_cast< int >( QgsSymbolLayer::Property::MarkerClipping ),

      QgsPropertyDefinition( "markerClipping", QgsPropertyDefinition::DataTypeString, QObject::tr( "Marker clipping mode" ), QObject::tr( "string " ) + "[<b>no</b>|<b>shape</b>|<b>centroid_within</b>|<b>completely_within</b>]"_L1, origin ) },

    { static_cast< int >( QgsSymbolLayer::Property::RandomOffsetX ), QgsPropertyDefinition( "randomOffsetX", QObject::tr( "Horizontal random offset" ), QgsPropertyDefinition::Double, origin ) },

    { static_cast< int >( QgsSymbolLayer::Property::RandomOffsetY ), QgsPropertyDefinition( "randomOffsetY", QObject::tr( "Vertical random offset" ), QgsPropertyDefinition::Double, origin ) },

    { static_cast< int >( QgsSymbolLayer::Property::LineClipping ),

      QgsPropertyDefinition( "lineClipping", QgsPropertyDefinition::DataTypeString, QObject::tr( "Line clipping mode" ), QObject::tr( "string " ) + "[<b>no</b>|<b>during_render</b>|<b>before_render</b>]"_L1, origin ) },

    { static_cast< int >( QgsSymbolLayer::Property::SkipMultiples ), QgsPropertyDefinition( "skipMultiples", QObject::tr( "Skip multiples of" ), QgsPropertyDefinition::DoublePositive, origin ) },

    { static_cast< int >( QgsSymbolLayer::Property::ShowMarker ), QgsPropertyDefinition( "showMarker", QObject::tr( "Show marker" ), QgsPropertyDefinition::Boolean, origin ) },

    { static_cast< int >( QgsSymbolLayer::Property::BlankSegments ), QgsPropertyDefinition( "blankSegments", QObject::tr( "Line blank segments" ), QgsPropertyDefinition::String, origin ) },

    { static_cast< int >( QgsSymbolLayer::Property::ExtraItems ), QgsPropertyDefinition( "extraItems", QObject::tr( "Line extra item" ), QgsPropertyDefinition::String, origin ) },

  };

}


void QgsSymbolLayer::setDataDefinedProperty( QgsSymbolLayer::Property key, const QgsProperty &property )

{

  dataDefinedProperties().setProperty( key, property );

}


void QgsSymbolLayer::startFeatureRender( const QgsFeature &feature, QgsRenderContext &context )

{

  installMasks( context, false );


  if ( QgsSymbol *lSubSymbol = subSymbol() )

    lSubSymbol->startFeatureRender( feature, context );

}


void QgsSymbolLayer::stopFeatureRender( const QgsFeature &feature, QgsRenderContext &context )

{

  if ( QgsSymbol *lSubSymbol = subSymbol() )

    lSubSymbol->stopFeatureRender( feature, context );


  removeMasks( context, false );

}


QgsSymbol *QgsSymbolLayer::subSymbol()

{

  return nullptr;

}


bool QgsSymbolLayer::setSubSymbol( QgsSymbol *symbol )

{

  delete symbol;

  return false;

}


bool QgsSymbolLayer::writeDxf( QgsDxfExport &e, double mmMapUnitScaleFactor, const QString &layerName, QgsSymbolRenderContext &context, QPointF shift ) const

{

  Q_UNUSED( e )

  Q_UNUSED( mmMapUnitScaleFactor )

  Q_UNUSED( layerName )

  Q_UNUSED( context )

  Q_UNUSED( shift )

  return false;

}


double QgsSymbolLayer::dxfWidth( const QgsDxfExport &e, QgsSymbolRenderContext &context ) const

{

  Q_UNUSED( e )

  return dxfWidth( context );

}


double QgsSymbolLayer::dxfWidth( QgsSymbolRenderContext &context ) const

{

  Q_UNUSED( context )

  return 1.0;

}


double QgsSymbolLayer::dxfSize( const QgsDxfExport &e, QgsSymbolRenderContext &context ) const

{

  Q_UNUSED( e )

  return dxfSize( context );

}


double QgsSymbolLayer::dxfSize( QgsSymbolRenderContext &context ) const

{

  Q_UNUSED( context )

  return 1.0;

}


double QgsSymbolLayer::dxfOffset( const QgsDxfExport &e, QgsSymbolRenderContext &context ) const

{

  Q_UNUSED( e )

  return dxfOffset( context );

}


double QgsSymbolLayer::dxfOffset( QgsSymbolRenderContext &context ) const

{

  Q_UNUSED( context )

  return 0.0;

}


QColor QgsSymbolLayer::dxfColor( QgsSymbolRenderContext &context ) const

{

  Q_UNUSED( context )

  return color();

}


double QgsSymbolLayer::dxfAngle( QgsSymbolRenderContext &context ) const

{

  Q_UNUSED( context )

  return 0.0;

}


QVector<qreal> QgsSymbolLayer::dxfCustomDashPattern( Qgis::RenderUnit &unit ) const

{

  Q_UNUSED( unit )

  return QVector<qreal>();

}


Qt::PenStyle QgsSymbolLayer::dxfPenStyle() const

{

  return Qt::SolidLine;

}


QColor QgsSymbolLayer::dxfBrushColor( QgsSymbolRenderContext &context ) const

{

  Q_UNUSED( context )

  return color();

}


Qt::BrushStyle QgsSymbolLayer::dxfBrushStyle() const

{

  return Qt::NoBrush;

}


QgsPaintEffect *QgsSymbolLayer::paintEffect() const

{

  return mPaintEffect.get();

}


void QgsSymbolLayer::setPaintEffect( QgsPaintEffect *effect )

{

  if ( effect == mPaintEffect.get() )

    return;


  mPaintEffect.reset( effect );

}


QgsSymbolLayer::QgsSymbolLayer( const QgsSymbolLayer &other )

  : mType( other.mType )

  , mEnabled( other.mEnabled )

  , mUserFlags( other.mUserFlags )

  , mLocked( other.mLocked )

  , mColor( other.mColor )

  , mRenderingPass( other.mRenderingPass )

  , mId( other.mId )

  , mDataDefinedProperties( other.mDataDefinedProperties )

  , mSelectiveMaskingSourceSetId( other.mSelectiveMaskingSourceSetId )

  , mPaintEffect( other.mPaintEffect ? other.mPaintEffect->clone() : nullptr )

  , mFields( other.mFields )

  , mClipPath( other.mClipPath )

{}


QgsSymbolLayer::QgsSymbolLayer( Qgis::SymbolType type, bool locked )

  : mType( type )

  , mLocked( locked )

  , mId( QUuid::createUuid().toString() )

{}


bool QgsSymbolLayer::rendersIdenticallyTo( const QgsSymbolLayer *other ) const

{

  if ( !other )

    return false;


  if ( layerType() != other->layerType() )

    return false;


  // TODO -- we could consider each property individually

  if ( hasDataDefinedProperties() || other->hasDataDefinedProperties() )

    return false;


  // shortcut now that we know there's no randomness/changing overrides involved

  if ( other == this )

    return true;


  if ( mEnabled != other->mEnabled

       || mColor != other->mColor

       || mRenderingPass != other->mRenderingPass


       // TODO -- we could consider the actual settings of the paint effect

       || ( mPaintEffect && !QgsPaintEffectRegistry::isDefaultStack( mPaintEffect.get() ) )

       || ( other->mPaintEffect && !QgsPaintEffectRegistry::isDefaultStack( other->mPaintEffect.get() ) ) )

    return false;


  return properties() == other->properties();

}


Qgis::SymbolLayerFlags QgsSymbolLayer::flags() const

{

  return Qgis::SymbolLayerFlags();

}


Qgis::SymbolLayerUserFlags QgsSymbolLayer::userFlags() const

{

  return mUserFlags;

}


void QgsSymbolLayer::setUserFlags( Qgis::SymbolLayerUserFlags flags )

{

  mUserFlags = flags;

}


QColor QgsSymbolLayer::color() const

{

  return mColor;

}


void QgsSymbolLayer::setColor( const QColor &color )

{

  mColor = color;

}


void QgsSymbolLayer::setStrokeColor( const QColor & )

{}


QColor QgsSymbolLayer::strokeColor() const

{

  return QColor();

}


void QgsSymbolLayer::setFillColor( const QColor & )

{}


QColor QgsSymbolLayer::fillColor() const

{

  return QColor();

}


void QgsSymbolLayer::prepareExpressions( const QgsSymbolRenderContext &context )

{

  mDataDefinedProperties.prepare( context.renderContext().expressionContext() );


  if ( !context.fields().isEmpty() )

  {

    //QgsFields is implicitly shared, so it's cheap to make a copy

    mFields = context.fields();

  }

}


bool QgsSymbolLayer::hasDataDefinedProperties() const

{

  return mDataDefinedProperties.hasActiveProperties();

}


const QgsPropertiesDefinition &QgsSymbolLayer::propertyDefinitions()

{

  QgsSymbolLayer::initPropertyDefinitions();

  return sPropertyDefinitions;

}


QgsSymbolLayer::~QgsSymbolLayer() = default;


bool QgsSymbolLayer::isCompatibleWithSymbol( QgsSymbol *symbol ) const

{

  if ( symbol->type() == Qgis::SymbolType::Fill && mType == Qgis::SymbolType::Line )

    return true;


  return symbol->type() == mType;

}


bool QgsSymbolLayer::canCauseArtifactsBetweenAdjacentTiles() const

{

  return false;

}


bool QgsSymbolLayer::usesMapUnits() const

{

  return false;

}


void QgsSymbolLayer::setRenderingPass( int renderingPass )

{

  mRenderingPass = renderingPass;

}


int QgsSymbolLayer::renderingPass() const

{

  return mRenderingPass;

}


QSet<QString> QgsSymbolLayer::usedAttributes( const QgsRenderContext &context ) const

{

  // calling referencedFields() with ignoreContext=true because in our expression context

  // we do not have valid QgsFields yet - because of that the field names from expressions

  // wouldn't get reported

  QSet<QString> columns = mDataDefinedProperties.referencedFields( context.expressionContext(), true );


  return columns;

}


QgsProperty propertyFromMap( const QVariantMap &map, const QString &baseName )

{

  QString prefix;

  if ( !baseName.isEmpty() )

  {

    prefix.append( u"%1_dd_"_s.arg( baseName ) );

  }


  if ( !map.contains( u"%1expression"_s.arg( prefix ) ) )

  {

    //requires at least the expression value

    return QgsProperty();

  }


  bool active = ( map.value( u"%1active"_s.arg( prefix ), u"1"_s ) != "0"_L1 );

  QString expression = map.value( u"%1expression"_s.arg( prefix ) ).toString();

  bool useExpression = ( map.value( u"%1useexpr"_s.arg( prefix ), u"1"_s ) != "0"_L1 );

  QString field = map.value( u"%1field"_s.arg( prefix ), QString() ).toString();


  if ( useExpression )

    return QgsProperty::fromExpression( expression, active );

  else

    return QgsProperty::fromField( field, active );

}


void QgsSymbolLayer::restoreOldDataDefinedProperties( const QVariantMap &stringMap )

{

  // property string to type upgrade map

  static const QMap< QString, int > OLD_PROPS {

    { "color", static_cast< int >( QgsSymbolLayer::Property::FillColor ) },

    { "arrow_width", static_cast< int >( QgsSymbolLayer::Property::ArrowWidth ) },

    { "arrow_start_width", static_cast< int >( QgsSymbolLayer::Property::ArrowStartWidth ) },

    { "head_length", static_cast< int >( QgsSymbolLayer::Property::ArrowHeadLength ) },

    { "head_thickness", static_cast< int >( QgsSymbolLayer::Property::ArrowHeadThickness ) },

    { "offset", static_cast< int >( QgsSymbolLayer::Property::Offset ) },

    { "head_type", static_cast< int >( QgsSymbolLayer::Property::ArrowHeadType ) },

    { "arrow_type", static_cast< int >( QgsSymbolLayer::Property::ArrowType ) },

    { "width_field", static_cast< int >( QgsSymbolLayer::Property::Width ) },

    { "height_field", static_cast< int >( QgsSymbolLayer::Property::Height ) },

    { "rotation_field", static_cast< int >( QgsSymbolLayer::Property::Angle ) },

    { "outline_width_field", static_cast< int >( QgsSymbolLayer::Property::StrokeWidth ) },

    { "fill_color_field", static_cast< int >( QgsSymbolLayer::Property::FillColor ) },

    { "outline_color_field", static_cast< int >( QgsSymbolLayer::Property::StrokeColor ) },

    { "symbol_name_field", static_cast< int >( QgsSymbolLayer::Property::Name ) },

    { "outline_width", static_cast< int >( QgsSymbolLayer::Property::StrokeWidth ) },

    { "outline_style", static_cast< int >( QgsSymbolLayer::Property::StrokeStyle ) },

    { "join_style", static_cast< int >( QgsSymbolLayer::Property::JoinStyle ) },

    { "fill_color", static_cast< int >( QgsSymbolLayer::Property::FillColor ) },

    { "outline_color", static_cast< int >( QgsSymbolLayer::Property::StrokeColor ) },

    { "width", static_cast< int >( QgsSymbolLayer::Property::Width ) },

    { "height", static_cast< int >( QgsSymbolLayer::Property::Height ) },

    { "symbol_name", static_cast< int >( QgsSymbolLayer::Property::Name ) },

    { "angle", static_cast< int >( QgsSymbolLayer::Property::Angle ) },

    { "fill_style", static_cast< int >( QgsSymbolLayer::Property::FillStyle ) },

    { "color_border", static_cast< int >( QgsSymbolLayer::Property::StrokeColor ) },

    { "width_border", static_cast< int >( QgsSymbolLayer::Property::StrokeWidth ) },

    { "border_color", static_cast< int >( QgsSymbolLayer::Property::StrokeColor ) },

    { "border_style", static_cast< int >( QgsSymbolLayer::Property::StrokeStyle ) },

    { "color2", static_cast< int >( QgsSymbolLayer::Property::SecondaryColor ) },

    { "gradient_type", static_cast< int >( QgsSymbolLayer::Property::GradientType ) },

    { "coordinate_mode", static_cast< int >( QgsSymbolLayer::Property::CoordinateMode ) },

    { "spread", static_cast< int >( QgsSymbolLayer::Property::GradientSpread ) },

    { "reference1_x", static_cast< int >( QgsSymbolLayer::Property::GradientReference1X ) },

    { "reference1_y", static_cast< int >( QgsSymbolLayer::Property::GradientReference1Y ) },

    { "reference2_x", static_cast< int >( QgsSymbolLayer::Property::GradientReference2X ) },

    { "reference2_y", static_cast< int >( QgsSymbolLayer::Property::GradientReference2Y ) },

    { "reference1_iscentroid", static_cast< int >( QgsSymbolLayer::Property::GradientReference1IsCentroid ) },

    { "reference2_iscentroid", static_cast< int >( QgsSymbolLayer::Property::GradientReference2IsCentroid ) },

    { "blur_radius", static_cast< int >( QgsSymbolLayer::Property::BlurRadius ) },

    { "use_whole_shape", static_cast< int >( QgsSymbolLayer::Property::ShapeburstUseWholeShape ) },

    { "max_distance", static_cast< int >( QgsSymbolLayer::Property::ShapeburstMaxDistance ) },

    { "ignore_rings", static_cast< int >( QgsSymbolLayer::Property::ShapeburstIgnoreRings ) },

    { "svgFillColor", static_cast< int >( QgsSymbolLayer::Property::FillColor ) },

    { "svgOutlineColor", static_cast< int >( QgsSymbolLayer::Property::StrokeColor ) },

    { "svgOutlineWidth", static_cast< int >( QgsSymbolLayer::Property::StrokeWidth ) },

    { "svgFile", static_cast< int >( QgsSymbolLayer::Property::File ) },

    { "lineangle", static_cast< int >( QgsSymbolLayer::Property::LineAngle ) },

    { "distance", static_cast< int >( QgsSymbolLayer::Property::LineDistance ) },

    { "distance_x", static_cast< int >( QgsSymbolLayer::Property::DistanceX ) },

    { "distance_y", static_cast< int >( QgsSymbolLayer::Property::DistanceY ) },

    { "displacement_x", static_cast< int >( QgsSymbolLayer::Property::DisplacementX ) },

    { "displacement_y", static_cast< int >( QgsSymbolLayer::Property::DisplacementY ) },

    { "file", static_cast< int >( QgsSymbolLayer::Property::File ) },

    { "alpha", static_cast< int >( QgsSymbolLayer::Property::Opacity ) },

    { "customdash", static_cast< int >( QgsSymbolLayer::Property::CustomDash ) },

    { "line_style", static_cast< int >( QgsSymbolLayer::Property::StrokeStyle ) },

    { "joinstyle", static_cast< int >( QgsSymbolLayer::Property::JoinStyle ) },

    { "capstyle", static_cast< int >( QgsSymbolLayer::Property::CapStyle ) },

    { "placement", static_cast< int >( QgsSymbolLayer::Property::Placement ) },

    { "interval", static_cast< int >( QgsSymbolLayer::Property::Interval ) },

    { "offset_along_line", static_cast< int >( QgsSymbolLayer::Property::OffsetAlongLine ) },

    { "name", static_cast< int >( QgsSymbolLayer::Property::Name ) },

    { "size", static_cast< int >( QgsSymbolLayer::Property::Size ) },

    { "fill", static_cast< int >( QgsSymbolLayer::Property::FillColor ) },

    { "outline", static_cast< int >( QgsSymbolLayer::Property::StrokeColor ) },

    { "char", static_cast< int >( QgsSymbolLayer::Property::Character ) },

    { "enabled", static_cast< int >( QgsSymbolLayer::Property::LayerEnabled ) },

    { "rotation", static_cast< int >( QgsSymbolLayer::Property::Angle ) },

    { "horizontal_anchor_point", static_cast< int >( QgsSymbolLayer::Property::HorizontalAnchor ) },

    { "vertical_anchor_point", static_cast< int >( QgsSymbolLayer::Property::VerticalAnchor ) },

  };


  QVariantMap::const_iterator propIt = stringMap.constBegin();

  for ( ; propIt != stringMap.constEnd(); ++propIt )

  {

    std::unique_ptr<QgsProperty> prop;

    QString propertyName;


    if ( propIt.key().endsWith( "_dd_expression"_L1 ) )

    {

      //found a data defined property


      //get data defined property name by stripping "_dd_expression" from property key

      propertyName = propIt.key().left( propIt.key().length() - 14 );


      prop = std::make_unique<QgsProperty>( propertyFromMap( stringMap, propertyName ) );

    }

    else if ( propIt.key().endsWith( "_expression"_L1 ) )

    {

      //old style data defined property, upgrade


      //get data defined property name by stripping "_expression" from property key

      propertyName = propIt.key().left( propIt.key().length() - 11 );


      prop = std::make_unique<QgsProperty>( QgsProperty::fromExpression( propIt.value().toString() ) );

    }


    if ( !prop || !OLD_PROPS.contains( propertyName ) )

      continue;


    int key = OLD_PROPS.value( propertyName );


    if ( type() == Qgis::SymbolType::Line )

    {

      //these keys had different meaning for line symbol layers

      if ( propertyName == "width"_L1 )

        key = static_cast< int >( QgsSymbolLayer::Property::StrokeWidth );

      else if ( propertyName == "color"_L1 )

        key = static_cast< int >( QgsSymbolLayer::Property::StrokeColor );

    }


    setDataDefinedProperty( static_cast< QgsSymbolLayer::Property >( key ), QgsProperty( *prop.get() ) );

  }

}


void QgsSymbolLayer::copyCommonProperties( QgsSymbolLayer *destLayer ) const

{

  copyDataDefinedProperties( destLayer );

  copyPaintEffect( destLayer );

  destLayer->mSelectiveMaskingSourceSetId = mSelectiveMaskingSourceSetId;

}


void QgsSymbolLayer::copyDataDefinedProperties( QgsSymbolLayer *destLayer ) const

{

  if ( !destLayer )

    return;


  destLayer->setDataDefinedProperties( mDataDefinedProperties );

}


void QgsSymbolLayer::copyPaintEffect( QgsSymbolLayer *destLayer ) const

{

  if ( !destLayer || !mPaintEffect )

    return;


  if ( !QgsPaintEffectRegistry::isDefaultStack( mPaintEffect.get() ) )

    destLayer->setPaintEffect( mPaintEffect->clone() );

  else

    destLayer->setPaintEffect( nullptr );

}


QgsMarkerSymbolLayer::QgsMarkerSymbolLayer( bool locked )

  : QgsSymbolLayer( Qgis::SymbolType::Marker, locked )

{}


QgsLineSymbolLayer::QgsLineSymbolLayer( bool locked )

  : QgsSymbolLayer( Qgis::SymbolType::Line, locked )

{}


QgsLineSymbolLayer::RenderRingFilter QgsLineSymbolLayer::ringFilter() const

{

  return mRingFilter;

}


void QgsLineSymbolLayer::setRingFilter( const RenderRingFilter filter )

{

  mRingFilter = filter;

}


QgsFillSymbolLayer::QgsFillSymbolLayer( bool locked )

  : QgsSymbolLayer( Qgis::SymbolType::Fill, locked )

{}


QgsMarkerSymbolLayer::QgsMarkerSymbolLayer( const QgsMarkerSymbolLayer &other )

  : QgsSymbolLayer( other )

  , mAngle( other.mAngle )

  , mLineAngle( other.mLineAngle )

  , mSize( other.mSize )

  , mSizeUnit( other.mSizeUnit )

  , mSizeMapUnitScale( other.mSizeMapUnitScale )

  , mOffset( other.mOffset )

  , mOffsetUnit( other.mOffsetUnit )

  , mOffsetMapUnitScale( other.mOffsetMapUnitScale )

  , mScaleMethod( other.mScaleMethod )

  , mHorizontalAnchorPoint( other.mHorizontalAnchorPoint )

  , mVerticalAnchorPoint( other.mVerticalAnchorPoint )

{}


void QgsMarkerSymbolLayer::startRender( QgsSymbolRenderContext &context )

{

  Q_UNUSED( context )

}


void QgsMarkerSymbolLayer::stopRender( QgsSymbolRenderContext &context )

{

  Q_UNUSED( context )

}


void QgsMarkerSymbolLayer::drawPreviewIcon( QgsSymbolRenderContext &context, QSize size )

{

  startRender( context );

  QgsPaintEffect *effect = paintEffect();


  QPolygonF points = context.patchShape() ? context.patchShape()->toQPolygonF( Qgis::SymbolType::Marker, size ).value( 0 ).value( 0 )

                                          : QgsStyle::defaultStyle()->defaultPatchAsQPolygonF( Qgis::SymbolType::Marker, size ).value( 0 ).value( 0 );


  std::unique_ptr< QgsEffectPainter > effectPainter;

  if ( effect && effect->enabled() )

    effectPainter = std::make_unique< QgsEffectPainter >( context.renderContext(), effect );


  for ( QPointF point : std::as_const( points ) )

    renderPoint( point, context );


  effectPainter.reset();


  stopRender( context );

}


void QgsMarkerSymbolLayer::markerOffset( QgsSymbolRenderContext &context, double &offsetX, double &offsetY ) const

{

  markerOffset( context, mSize, mSize, mSizeUnit, mSizeUnit, offsetX, offsetY, mSizeMapUnitScale, mSizeMapUnitScale );

}


void QgsMarkerSymbolLayer::markerOffset( QgsSymbolRenderContext &context, double width, double height, double &offsetX, double &offsetY ) const

{

  markerOffset( context, width, height, mSizeUnit, mSizeUnit, offsetX, offsetY, mSizeMapUnitScale, mSizeMapUnitScale );

}


void QgsMarkerSymbolLayer::markerOffset(

  QgsSymbolRenderContext &context,

  double width,

  double height,

  Qgis::RenderUnit widthUnit,

  Qgis::RenderUnit heightUnit,

  double &offsetX,

  double &offsetY,

  const QgsMapUnitScale &widthMapUnitScale,

  const QgsMapUnitScale &heightMapUnitScale

) const

{

  offsetX = mOffset.x();

  offsetY = mOffset.y();


  if ( mDataDefinedProperties.isActive( QgsSymbolLayer::Property::Offset ) )

  {

    context.setOriginalValueVariable( QgsSymbolLayerUtils::encodePoint( mOffset ) );

    QVariant exprVal = mDataDefinedProperties.value( QgsSymbolLayer::Property::Offset, context.renderContext().expressionContext() );

    bool ok = false;

    const QPointF offset = QgsSymbolLayerUtils::toPoint( exprVal, &ok );

    if ( ok )

    {

      offsetX = offset.x();

      offsetY = offset.y();

    }

  }


  offsetX = context.renderContext().convertToPainterUnits( offsetX, mOffsetUnit, mOffsetMapUnitScale );

  offsetY = context.renderContext().convertToPainterUnits( offsetY, mOffsetUnit, mOffsetMapUnitScale );


  Qgis::HorizontalAnchorPoint horizontalAnchorPoint = mHorizontalAnchorPoint;

  Qgis::VerticalAnchorPoint verticalAnchorPoint = mVerticalAnchorPoint;

  if ( mDataDefinedProperties.isActive( QgsSymbolLayer::Property::HorizontalAnchor ) )

  {

    QVariant exprVal = mDataDefinedProperties.value( QgsSymbolLayer::Property::HorizontalAnchor, context.renderContext().expressionContext() );

    if ( !QgsVariantUtils::isNull( exprVal ) )

    {

      horizontalAnchorPoint = decodeHorizontalAnchorPoint( exprVal.toString() );

    }

  }

  if ( mDataDefinedProperties.isActive( QgsSymbolLayer::Property::VerticalAnchor ) )

  {

    QVariant exprVal = mDataDefinedProperties.value( QgsSymbolLayer::Property::VerticalAnchor, context.renderContext().expressionContext() );

    if ( !QgsVariantUtils::isNull( exprVal ) )

    {

      verticalAnchorPoint = decodeVerticalAnchorPoint( exprVal.toString() );

    }

  }


  //correct horizontal position according to anchor point

  if ( horizontalAnchorPoint == Qgis::HorizontalAnchorPoint::Center && verticalAnchorPoint == Qgis::VerticalAnchorPoint::Center )

  {

    return;

  }


  double anchorPointCorrectionX = context.renderContext().convertToPainterUnits( width, widthUnit, widthMapUnitScale ) / 2.0;

  if ( widthUnit == Qgis::RenderUnit::MetersInMapUnits

       && ( context.renderContext().flags() & Qgis::RenderContextFlag::RenderSymbolPreview || context.renderContext().flags() & Qgis::RenderContextFlag::RenderLayerTree ) )

  {

    // rendering for symbol previews -- an size in meters in map units can't be calculated, so treat the size as millimeters

    // and clamp it to a reasonable range. It's the best we can do in this situation!

    anchorPointCorrectionX = std::min( std::max( context.renderContext().convertToPainterUnits( width, Qgis::RenderUnit::Millimeters ), 3.0 ), 100.0 ) / 2.0;

  }


  double anchorPointCorrectionY = context.renderContext().convertToPainterUnits( height, heightUnit, heightMapUnitScale ) / 2.0;

  if ( heightUnit == Qgis::RenderUnit::MetersInMapUnits

       && ( context.renderContext().flags() & Qgis::RenderContextFlag::RenderSymbolPreview || context.renderContext().flags() & Qgis::RenderContextFlag::RenderLayerTree ) )

  {

    // rendering for symbol previews -- an size in meters in map units can't be calculated, so treat the size as millimeters

    // and clamp it to a reasonable range. It's the best we can do in this situation!

    anchorPointCorrectionY = std::min( std::max( context.renderContext().convertToPainterUnits( height, Qgis::RenderUnit::Millimeters ), 3.0 ), 100.0 ) / 2.0;

  }


  switch ( horizontalAnchorPoint )

  {

    case Qgis::HorizontalAnchorPoint::Left:

      offsetX += anchorPointCorrectionX;

      break;

    case Qgis::HorizontalAnchorPoint::Right:

      offsetX -= anchorPointCorrectionX;

      break;

    case Qgis::HorizontalAnchorPoint::Center:

      break;

  }


  //correct vertical position according to anchor point

  switch ( verticalAnchorPoint )

  {

    case Qgis::VerticalAnchorPoint::Top:

      offsetY += anchorPointCorrectionY;

      break;

    case Qgis::VerticalAnchorPoint::Bottom:

    case Qgis::VerticalAnchorPoint::Baseline:

      offsetY -= anchorPointCorrectionY;

      break;

    case Qgis::VerticalAnchorPoint::Center:

      break;

  }

}


QPointF QgsMarkerSymbolLayer::_rotatedOffset( QPointF offset, double angle )

{

  angle = DEG2RAD( angle );

  double c = std::cos( angle ), s = std::sin( angle );

  return QPointF( offset.x() * c - offset.y() * s, offset.x() * s + offset.y() * c );

}


Qgis::HorizontalAnchorPoint QgsMarkerSymbolLayer::decodeHorizontalAnchorPoint( const QString &str )

{

  if ( str.compare( "left"_L1, Qt::CaseInsensitive ) == 0 )

  {

    return Qgis::HorizontalAnchorPoint::Left;

  }

  else if ( str.compare( "right"_L1, Qt::CaseInsensitive ) == 0 )

  {

    return Qgis::HorizontalAnchorPoint::Right;

  }

  else

  {

    return Qgis::HorizontalAnchorPoint::Center;

  }

}


Qgis::VerticalAnchorPoint QgsMarkerSymbolLayer::decodeVerticalAnchorPoint( const QString &str )

{

  if ( str.compare( "top"_L1, Qt::CaseInsensitive ) == 0 )

  {

    return Qgis::VerticalAnchorPoint::Top;

  }

  else if ( str.compare( "bottom"_L1, Qt::CaseInsensitive ) == 0 )

  {

    return Qgis::VerticalAnchorPoint::Bottom;

  }

  else

  {

    return Qgis::VerticalAnchorPoint::Center;

  }

}


void QgsMarkerSymbolLayer::setOutputUnit( Qgis::RenderUnit unit )

{

  mSizeUnit = unit;

  mOffsetUnit = unit;

}


Qgis::RenderUnit QgsMarkerSymbolLayer::outputUnit() const

{

  if ( mOffsetUnit != mSizeUnit )

  {

    return Qgis::RenderUnit::Unknown;

  }

  return mOffsetUnit;

}


void QgsMarkerSymbolLayer::setMapUnitScale( const QgsMapUnitScale &scale )

{

  mSizeMapUnitScale = scale;

  mOffsetMapUnitScale = scale;

}


QgsMapUnitScale QgsMarkerSymbolLayer::mapUnitScale() const

{

  if ( mSizeMapUnitScale == mOffsetMapUnitScale )

  {

    return mSizeMapUnitScale;

  }

  return QgsMapUnitScale();

}


void QgsLineSymbolLayer::setOutputUnit( Qgis::RenderUnit unit )

{

  mWidthUnit = unit;

  mOffsetUnit = unit;

}


Qgis::RenderUnit QgsLineSymbolLayer::outputUnit() const

{

  return mWidthUnit;

}


void QgsLineSymbolLayer::setMapUnitScale( const QgsMapUnitScale &scale )

{

  mWidthMapUnitScale = scale;

}


QgsMapUnitScale QgsLineSymbolLayer::mapUnitScale() const

{

  return mWidthMapUnitScale;

}


void QgsLineSymbolLayer::drawPreviewIcon( QgsSymbolRenderContext &context, QSize size )

{

  const QList< QList< QPolygonF > > points = context.patchShape() ? context.patchShape()->toQPolygonF( Qgis::SymbolType::Line, size )

                                                                  : QgsStyle::defaultStyle()->defaultPatchAsQPolygonF( Qgis::SymbolType::Line, size );

  startRender( context );

  QgsPaintEffect *effect = paintEffect();


  std::unique_ptr< QgsEffectPainter > effectPainter;

  if ( effect && effect->enabled() )

    effectPainter = std::make_unique< QgsEffectPainter >( context.renderContext(), effect );


  for ( const QList< QPolygonF > &line : points )

    renderPolyline( line.value( 0 ), context );


  effectPainter.reset();


  stopRender( context );

}


void QgsLineSymbolLayer::renderPolygonStroke( const QPolygonF &points, const QVector<QPolygonF> *rings, QgsSymbolRenderContext &context )

{

  QgsExpressionContextScope *scope = nullptr;

  std::unique_ptr< QgsExpressionContextScopePopper > scopePopper;

  if ( hasDataDefinedProperties() )

  {

    scope = new QgsExpressionContextScope();

    scopePopper = std::make_unique< QgsExpressionContextScopePopper >( context.renderContext().expressionContext(), scope );

  }


  switch ( mRingFilter )

  {

    case AllRings:

    case ExteriorRingOnly:

    {

      if ( scope )

        scope->addVariable( QgsExpressionContextScope::StaticVariable( QgsExpressionContext::EXPR_GEOMETRY_RING_NUM, 0, true ) );

      renderPolyline( points, context );

      break;

    }

    case InteriorRingsOnly:

      break;

  }


  if ( rings )

  {

    switch ( mRingFilter )

    {

      case AllRings:

      case InteriorRingsOnly:

      {

        int ringIndex = 1;

        for ( const QPolygonF &ring : std::as_const( *rings ) )

        {

          if ( scope )

            scope->addVariable( QgsExpressionContextScope::StaticVariable( QgsExpressionContext::EXPR_GEOMETRY_RING_NUM, ringIndex, true ) );


          renderPolyline( ring, context );

          ringIndex++;

        }

      }

      break;

      case ExteriorRingOnly:

        break;

    }

  }

}


double QgsLineSymbolLayer::width( const QgsRenderContext &context ) const

{

  return context.convertToPainterUnits( mWidth, mWidthUnit, mWidthMapUnitScale );

}


double QgsLineSymbolLayer::dxfWidth( QgsSymbolRenderContext &context ) const

{

  return width() * QgsDxfExport::mapUnitScaleFactor( context.renderContext(), widthUnit() );

}


void QgsFillSymbolLayer::drawPreviewIcon( QgsSymbolRenderContext &context, QSize size )

{

  const QList< QList< QPolygonF > > polys = context.patchShape() ? context.patchShape()->toQPolygonF( Qgis::SymbolType::Fill, size )

                                                                 : QgsStyle::defaultStyle()->defaultPatchAsQPolygonF( Qgis::SymbolType::Fill, size );


  startRender( context );

  QgsPaintEffect *effect = paintEffect();


  std::unique_ptr< QgsEffectPainter > effectPainter;

  if ( effect && effect->enabled() )

    effectPainter = std::make_unique< QgsEffectPainter >( context.renderContext(), effect );


  for ( const QList< QPolygonF > &poly : polys )

  {

    QVector< QPolygonF > rings;

    for ( int i = 1; i < poly.size(); ++i )

      rings << poly.at( i );

    renderPolygon( poly.value( 0 ), &rings, context );

  }


  effectPainter.reset();


  stopRender( context );

}


QImage QgsFillSymbolLayer::toTiledPatternImage() const

{

  return QImage();

}


void QgsFillSymbolLayer::_renderPolygon( QPainter *p, const QPolygonF &points, const QVector<QPolygonF> *rings, QgsSymbolRenderContext &context )

{

  if ( !p )

  {

    return;

  }


  // Disable 'Antialiasing' if the geometry was generalized in the current RenderContext (We known that it must have least #5 points).

  if ( points.size() <= 5

       && ( context.renderContext().vectorSimplifyMethod().simplifyHints() & Qgis::VectorRenderingSimplificationFlag::AntialiasingSimplification )

       && QgsAbstractGeometrySimplifier::isGeneralizableByDeviceBoundingBox( points, context.renderContext().vectorSimplifyMethod().threshold() )

       && ( p->renderHints() & QPainter::Antialiasing ) )

  {

    p->setRenderHint( QPainter::Antialiasing, false );

    p->drawRect( points.boundingRect() );

    p->setRenderHint( QPainter::Antialiasing, true );

    return;

  }


  // polygons outlines are sometimes rendered wrongly with drawPolygon, when

  // clipped (see #13343), so use drawPath instead.

  if ( !rings && p->pen().style() == Qt::NoPen )

  {

    // simple polygon without holes

    p->drawPolygon( points );

  }

  else

  {

    // polygon with holes must be drawn using painter path

    QPainterPath path;

    path.addPolygon( points );


    if ( rings )

    {

      for ( auto it = rings->constBegin(); it != rings->constEnd(); ++it )

      {

        QPolygonF ring = *it;

        path.addPolygon( ring );

      }

    }


    p->drawPath( path );

  }

}


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

{

  QDomElement symbolizerElem = doc.createElement( u"se:PointSymbolizer"_s );

  const QVariantMap props = context.extraProperties();

  if ( !props.value( u"uom"_s, QString() ).toString().isEmpty() )

    symbolizerElem.setAttribute( u"uom"_s, props.value( u"uom"_s, QString() ).toString() );

  element.appendChild( symbolizerElem );


  // <Geometry>

  QgsSymbolLayerUtils::createGeometryElement( doc, symbolizerElem, props.value( u"geom"_s, QString() ).toString(), context );


  return writeSldMarker( doc, symbolizerElem, context );

}


void QgsMarkerSymbolLayer::writeSldMarker( QDomDocument &doc, QDomElement &element, const QVariantMap &props ) const

{

  QgsSldExportContext context;

  context.setExtraProperties( props );

  writeSldMarker( doc, element, context );

}


bool QgsMarkerSymbolLayer::writeSldMarker( QDomDocument &, QDomElement &, QgsSldExportContext &context ) const

{

  context.pushError( QObject::tr( "Marker symbol layer %1 cannot be converted to SLD" ).arg( layerType() ) );

  return false;

}


QList<QgsSymbolLayerReference> QgsSymbolLayer::masks() const

{

  return {};

}


QString QgsSymbolLayer::selectiveMaskingSourceSetId() const

{

  return mSelectiveMaskingSourceSetId;

}


void QgsSymbolLayer::setSelectiveMaskingSourceSetId( const QString &id )

{

  mSelectiveMaskingSourceSetId = id;

}


double QgsMarkerSymbolLayer::dxfSize( QgsSymbolRenderContext &context ) const

{

  double size = mSize;

  if ( mDataDefinedProperties.isActive( QgsSymbolLayer::Property::Size ) )

  {

    bool ok = false;

    size = mDataDefinedProperties.valueAsDouble( QgsSymbolLayer::Property::Size, context.renderContext().expressionContext(), mSize, &ok );


    if ( ok )

    {

      switch ( mScaleMethod )

      {

        case Qgis::ScaleMethod::ScaleArea:

          size = std::sqrt( size );

          break;

        case Qgis::ScaleMethod::ScaleDiameter:

          break;

      }

    }

  }

  return size * QgsDxfExport::mapUnitScaleFactor( context.renderContext(), mSizeUnit );

}


double QgsMarkerSymbolLayer::dxfAngle( QgsSymbolRenderContext &context ) const

{

  double angle = mAngle;

  if ( mDataDefinedProperties.isActive( QgsSymbolLayer::Property::Angle ) )

  {

    context.setOriginalValueVariable( mAngle );

    angle = mDataDefinedProperties.valueAsDouble( QgsSymbolLayer::Property::Angle, context.renderContext().expressionContext(), mAngle );

  }

  return angle;

}


QPainterPath generateClipPath( const QgsRenderContext &renderContext, const QString &id, const QRectF *rect, bool &foundGeometries )

{

  foundGeometries = false;

  const QVector<QgsGeometry> clipGeometries = rect ? QgsSymbolLayerUtils::collectSymbolLayerClipGeometries( renderContext, id, *rect ) : renderContext.symbolLayerClipGeometries( id );

  if ( !clipGeometries.empty() )

  {

    foundGeometries = true;

    QgsGeometry mergedGeom = QgsGeometry::unaryUnion( clipGeometries, QgsGeometryParameters(), renderContext.feedback() );

    if ( renderContext.maskSettings().simplifyTolerance() > 0 )

    {

      QgsGeos geos( mergedGeom.constGet() );

      mergedGeom = QgsGeometry( geos.simplify( renderContext.maskSettings().simplifyTolerance(), nullptr, renderContext.feedback() ) );

    }

#if GEOS_VERSION_MAJOR == 3 && GEOS_VERSION_MINOR < 10

    // structure would be better, but too old GEOS

    mergedGeom = mergedGeom.makeValid( Qgis::MakeValidMethod::Linework, false, renderContext.feedback() );

#else

    mergedGeom = mergedGeom.makeValid( Qgis::MakeValidMethod::Structure, false, renderContext.feedback() );

#endif

    if ( !mergedGeom.isEmpty() )

    {

      QgsGeometry exterior;

      const QgsRectangle contextBounds( 0, 0, renderContext.outputSize().width(), renderContext.outputSize().height() );

      if ( rect )

      {

        exterior = QgsGeometry::fromRect( QgsRectangle( *rect ).intersect( contextBounds ) );

      }

      else

      {

        exterior = QgsGeometry::fromRect( contextBounds );

      }

      const QgsGeometry maskGeom = exterior.difference( mergedGeom, QgsGeometryParameters(), renderContext.feedback() );

      if ( !maskGeom.isNull() )

      {

        return maskGeom.constGet()->asQPainterPath();

      }

    }

  }

  return QPainterPath();

}


void QgsSymbolLayer::prepareMasks( const QgsSymbolRenderContext &context )

{

  const QgsRenderContext &renderContext = context.renderContext();


  bool foundGeometries = false;

  mClipPath = generateClipPath( renderContext, id(), nullptr, foundGeometries );

}


bool QgsSymbolLayer::installMasks( QgsRenderContext &context, bool recursive, const QRectF &rect )

{

  bool res = false;

  if ( !mClipPath.isEmpty() )

  {

    context.painter()->save();

    context.painter()->setClipPath( mClipPath, Qt::IntersectClip );

    res = true;

  }

  else if ( rect.isValid() )

  {

    // find just the clip geometries within the area the symbol layer will be drawn over

    bool foundGeometries = false;

    const QPainterPath clipPath = generateClipPath( context, id(), &rect, foundGeometries );

    if ( !clipPath.isEmpty() )

    {

      context.painter()->setClipPath( clipPath, context.painter()->clipPath().isEmpty() ? Qt::ReplaceClip : Qt::IntersectClip );

      res = true;

    }

  }


  if ( QgsSymbol *lSubSymbol = recursive ? subSymbol() : nullptr )

  {

    const QList<QgsSymbolLayer *> layers = lSubSymbol->symbolLayers();

    for ( QgsSymbolLayer *sl : layers )

      res = sl->installMasks( context, true ) || res;

  }


  return res;

}


void QgsSymbolLayer::removeMasks( QgsRenderContext &context, bool recursive )

{

  if ( !mClipPath.isEmpty() )

  {

    context.painter()->restore();

  }


  if ( QgsSymbol *lSubSymbol = recursive ? subSymbol() : nullptr )

  {

    const QList<QgsSymbolLayer *> layers = lSubSymbol->symbolLayers();

    for ( QgsSymbolLayer *sl : layers )

      sl->removeMasks( context, true );

  }

}


bool QgsSymbolLayer::shouldRenderUsingSelectionColor( const QgsSymbolRenderContext &context ) const

{

  return context.selected() && !( mUserFlags & Qgis::SymbolLayerUserFlag::DisableSelectionRecoloring );

}


void QgsSymbolLayer::setId( const QString &id )

{

  mId = id;

}


QString QgsSymbolLayer::id() const

{

  return mId;

}


void QgsSymbolLayer::toSld( QDomDocument &doc, QDomElement &element, const QVariantMap &props ) const

{

  QgsSldExportContext context;

  context.setExtraProperties( props );

  toSld( doc, element, context );

}


bool QgsSymbolLayer::toSld( QDomDocument &, QDomElement &, QgsSldExportContext &context ) const

{

  context.pushError( QObject::tr( "Symbol layer %1 cannot be converted to SLD" ).arg( layerType() ) );

  return false;

}


Qgis
Provides global constants and enumerations for use throughout the application.
Definition qgis.h:62

Qgis::VectorRenderingSimplificationFlag::AntialiasingSimplification
@ AntialiasingSimplification
The geometries can be rendered with 'AntiAliasing' disabled because of it is '1-pixel size'.
Definition qgis.h:3200

Qgis::ScaleMethod::ScaleDiameter
@ ScaleDiameter
Calculate scale by the diameter.
Definition qgis.h:653

Qgis::ScaleMethod::ScaleArea
@ ScaleArea
Calculate scale by the area.
Definition qgis.h:652

Qgis::SymbolLayerFlags
QFlags< SymbolLayerFlag > SymbolLayerFlags
Symbol layer flags.
Definition qgis.h:935

Qgis::SymbolLayerUserFlags
QFlags< SymbolLayerUserFlag > SymbolLayerUserFlags
Symbol layer user flags.
Definition qgis.h:958

Qgis::VerticalAnchorPoint
VerticalAnchorPoint
Marker symbol vertical anchor points.
Definition qgis.h:862

Qgis::VerticalAnchorPoint::Bottom
@ Bottom
Align to bottom of symbol.
Definition qgis.h:865

Qgis::VerticalAnchorPoint::Center
@ Center
Align to vertical center of symbol.
Definition qgis.h:864

Qgis::VerticalAnchorPoint::Baseline
@ Baseline
Align to baseline of symbol, e.g. font baseline for font marker symbol layers. Treated as Bottom if n...
Definition qgis.h:866

Qgis::VerticalAnchorPoint::Top
@ Top
Align to top of symbol.
Definition qgis.h:863

Qgis::RenderUnit
RenderUnit
Rendering size units.
Definition qgis.h:5566

Qgis::RenderUnit::Millimeters
@ Millimeters
Millimeters.
Definition qgis.h:5567

Qgis::RenderUnit::Unknown
@ Unknown
Mixed or unknown units.
Definition qgis.h:5573

Qgis::RenderUnit::MetersInMapUnits
@ MetersInMapUnits
Meters value as Map units.
Definition qgis.h:5574

Qgis::RenderContextFlag::RenderSymbolPreview
@ RenderSymbolPreview
The render is for a symbol preview only and map based properties may not be available,...
Definition qgis.h:2924

Qgis::RenderContextFlag::RenderLayerTree
@ RenderLayerTree
The render is for a layer tree display where map based properties are not available and where avoidan...
Definition qgis.h:2935

Qgis::MakeValidMethod::Linework
@ Linework
Combines all rings into a set of noded lines and then extracts valid polygons from that linework.
Definition qgis.h:2314

Qgis::MakeValidMethod::Structure
@ Structure
Structured method, first makes all rings valid and then merges shells and subtracts holes from shells...
Definition qgis.h:2315

Qgis::SymbolLayerUserFlag::DisableSelectionRecoloring
@ DisableSelectionRecoloring
If present, indicates that the symbol layer should not be recolored when rendering selected features.
Definition qgis.h:949

Qgis::SymbolType
SymbolType
Symbol types.
Definition qgis.h:637

Qgis::SymbolType::Marker
@ Marker
Marker symbol.
Definition qgis.h:638

Qgis::SymbolType::Line
@ Line
Line symbol.
Definition qgis.h:639

Qgis::SymbolType::Fill
@ Fill
Fill symbol.
Definition qgis.h:640

Qgis::HorizontalAnchorPoint
HorizontalAnchorPoint
Marker symbol horizontal anchor points.
Definition qgis.h:848

Qgis::HorizontalAnchorPoint::Center
@ Center
Align to horizontal center of symbol.
Definition qgis.h:850

Qgis::HorizontalAnchorPoint::Right
@ Right
Align to right side of symbol.
Definition qgis.h:851

Qgis::HorizontalAnchorPoint::Left
@ Left
Align to left side of symbol.
Definition qgis.h:849

QgsAbstractGeometrySimplifier::isGeneralizableByDeviceBoundingBox
static bool isGeneralizableByDeviceBoundingBox(const QgsRectangle &envelope, float mapToPixelTol=1.0f)
Returns whether the device-envelope can be replaced by its BBOX when is applied the specified toleran...
Definition qgsgeometrysimplifier.cpp:25

QgsAbstractGeometry::asQPainterPath
virtual QPainterPath asQPainterPath() const =0
Returns the geometry represented as a QPainterPath.

QgsDxfExport
Exports QGIS layers to the DXF format.
Definition qgsdxfexport.h:69

QgsDxfExport::mapUnitScaleFactor
static Q_DECL_DEPRECATED double mapUnitScaleFactor(double scale, Qgis::RenderUnit symbolUnits, Qgis::DistanceUnit mapUnits, double mapUnitsPerPixel=1.0)
Returns scale factor for conversion to map units.
Definition qgsdxfexport.cpp:2020

QgsExpressionContextScope
Single scope for storing variables and functions for use within a QgsExpressionContext.
Definition qgsexpressioncontext.h:119

QgsExpressionContextScope::addVariable
void addVariable(const QgsExpressionContextScope::StaticVariable &variable)
Adds a variable into the context scope.
Definition qgsexpressioncontext.cpp:140

QgsExpressionContext::EXPR_GEOMETRY_RING_NUM
static const QString EXPR_GEOMETRY_RING_NUM
Inbuilt variable name for geometry ring number variable.
Definition qgsexpressioncontext.h:928

QgsFeature
The feature class encapsulates a single feature including its unique ID, geometry and a list of field...
Definition qgsfeature.h:60

QgsFields::isEmpty
bool isEmpty
Definition qgsfields.h:49

QgsFillSymbolLayer::renderPolygon
virtual void renderPolygon(const QPolygonF &points, const QVector< QPolygonF > *rings, QgsSymbolRenderContext &context)=0
Renders the fill symbol layer for the polygon whose outer ring is defined by points,...

QgsFillSymbolLayer::_renderPolygon
void _renderPolygon(QPainter *p, const QPolygonF &points, const QVector< QPolygonF > *rings, QgsSymbolRenderContext &context)
Default method to render polygon.
Definition qgssymbollayer.cpp:985

QgsFillSymbolLayer::toTiledPatternImage
virtual QImage toTiledPatternImage() const
Renders the symbol layer as an image that can be used as a seamless pattern fill for polygons,...
Definition qgssymbollayer.cpp:980

QgsFillSymbolLayer::drawPreviewIcon
void drawPreviewIcon(QgsSymbolRenderContext &context, QSize size) override
Definition qgssymbollayer.cpp:955

QgsFillSymbolLayer::QgsFillSymbolLayer
QgsFillSymbolLayer(const QgsFillSymbolLayer &other)=delete

QgsGeometryParameters
Encapsulates parameters under which a geometry operation is performed.
Definition qgsgeometry.h:127

QgsGeometry
A geometry is the spatial representation of a feature.
Definition qgsgeometry.h:178

QgsGeometry::fromRect
static QgsGeometry fromRect(const QgsRectangle &rect)
Creates a new geometry from a QgsRectangle.
Definition qgsgeometry.cpp:245

QgsGeometry::constGet
const QgsAbstractGeometry * constGet() const
Returns a non-modifiable (const) reference to the underlying abstract geometry primitive.
Definition qgsgeometry.cpp:135

QgsGeometry::makeValid
QgsGeometry makeValid(Qgis::MakeValidMethod method=Qgis::MakeValidMethod::Linework, bool keepCollapsed=false, QgsFeedback *feedback=nullptr) const
Attempts to make an invalid geometry valid without losing vertices.
Definition qgsgeometry.cpp:3657

QgsGeometry::unaryUnion
static QgsGeometry unaryUnion(const QVector< QgsGeometry > &geometries, const QgsGeometryParameters &parameters=QgsGeometryParameters(), QgsFeedback *feedback=nullptr)
Compute the unary union on a list of geometries.
Definition qgsgeometry.cpp:3989

QgsGeometry::isEmpty
bool isEmpty() const
Returns true if the geometry is empty (eg a linestring with no vertices, or a collection with no geom...
Definition qgsgeometry.cpp:502

QgsGeometry::difference
QgsGeometry difference(const QgsGeometry &geometry, const QgsGeometryParameters &parameters=QgsGeometryParameters(), QgsFeedback *feedback=nullptr) const
Returns a geometry representing the points making up this geometry that do not make up other.
Definition qgsgeometry.cpp:3432

QgsGeometry::isNull
bool isNull
Definition qgsgeometry.h:180

QgsGeos
Does vector analysis using the GEOS library and handles import, export, and exception handling.
Definition qgsgeos.h:175

QgsLegendPatchShape::toQPolygonF
QList< QList< QPolygonF > > toQPolygonF(Qgis::SymbolType type, QSizeF size) const
Converts the patch shape to a set of QPolygonF objects representing how the patch should be drawn for...
Definition qgslegendpatchshape.cpp:113

QgsLineSymbolLayer::mOffsetUnit
Qgis::RenderUnit mOffsetUnit
Definition qgssymbollayer.h:1380

QgsLineSymbolLayer::RenderRingFilter
RenderRingFilter
Options for filtering rings when the line symbol layer is being used to render a polygon's rings.
Definition qgssymbollayer.h:1205

QgsLineSymbolLayer::ExteriorRingOnly
@ ExteriorRingOnly
Render the exterior ring only.
Definition qgssymbollayer.h:1207

QgsLineSymbolLayer::InteriorRingsOnly
@ InteriorRingsOnly
Render the interior rings only.
Definition qgssymbollayer.h:1208

QgsLineSymbolLayer::AllRings
@ AllRings
Render both exterior and interior rings.
Definition qgssymbollayer.h:1206

QgsLineSymbolLayer::mWidthMapUnitScale
QgsMapUnitScale mWidthMapUnitScale
Definition qgssymbollayer.h:1378

QgsLineSymbolLayer::ringFilter
RenderRingFilter ringFilter() const
Returns the line symbol layer's ring filter, which controls which rings are rendered when the line sy...
Definition qgssymbollayer.cpp:616

QgsLineSymbolLayer::drawPreviewIcon
void drawPreviewIcon(QgsSymbolRenderContext &context, QSize size) override
Definition qgssymbollayer.cpp:877

QgsLineSymbolLayer::QgsLineSymbolLayer
QgsLineSymbolLayer(const QgsLineSymbolLayer &other)=delete

QgsLineSymbolLayer::setOutputUnit
void setOutputUnit(Qgis::RenderUnit unit) override
Sets the units to use for sizes and widths within the symbol layer.
Definition qgssymbollayer.cpp:855

QgsLineSymbolLayer::outputUnit
Qgis::RenderUnit outputUnit() const override
Returns the units to use for sizes and widths within the symbol layer.
Definition qgssymbollayer.cpp:861

QgsLineSymbolLayer::renderPolygonStroke
virtual void renderPolygonStroke(const QPolygonF &points, const QVector< QPolygonF > *rings, QgsSymbolRenderContext &context)
Renders the line symbol layer along the outline of polygon, using the given render context.
Definition qgssymbollayer.cpp:896

QgsLineSymbolLayer::mWidthUnit
Qgis::RenderUnit mWidthUnit
Definition qgssymbollayer.h:1377

QgsLineSymbolLayer::dxfWidth
double dxfWidth(QgsSymbolRenderContext &context) const override
Gets line width.
Definition qgssymbollayer.cpp:949

QgsLineSymbolLayer::renderPolyline
virtual void renderPolyline(const QPolygonF &points, QgsSymbolRenderContext &context)=0
Renders the line symbol layer along the line joining points, using the given render context.

QgsLineSymbolLayer::mRingFilter
RenderRingFilter mRingFilter
Definition qgssymbollayer.h:1383

QgsLineSymbolLayer::mWidth
double mWidth
Definition qgssymbollayer.h:1376

QgsLineSymbolLayer::width
virtual double width() const
Returns the estimated width for the line symbol layer.
Definition qgssymbollayer.h:1262

QgsLineSymbolLayer::mapUnitScale
QgsMapUnitScale mapUnitScale() const override
Definition qgssymbollayer.cpp:871

QgsLineSymbolLayer::setRingFilter
void setRingFilter(QgsLineSymbolLayer::RenderRingFilter filter)
Sets the line symbol layer's ring filter, which controls which rings are rendered when the line symbo...
Definition qgssymbollayer.cpp:621

QgsLineSymbolLayer::setMapUnitScale
void setMapUnitScale(const QgsMapUnitScale &scale) override
Definition qgssymbollayer.cpp:866

QgsLineSymbolLayer::widthUnit
Qgis::RenderUnit widthUnit() const
Returns the units for the line's width.
Definition qgssymbollayer.h:1344

QgsMapUnitScale
Struct for storing maximum and minimum scales for measurements in map units.
Definition qgsmapunitscale.h:37

QgsMarkerSymbolLayer::mSize
double mSize
Marker size.
Definition qgssymbollayer.h:1167

QgsMarkerSymbolLayer::QgsMarkerSymbolLayer
QgsMarkerSymbolLayer(const QgsMarkerSymbolLayer &other)
Definition qgssymbollayer.cpp:630

QgsMarkerSymbolLayer::drawPreviewIcon
void drawPreviewIcon(QgsSymbolRenderContext &context, QSize size) override
Definition qgssymbollayer.cpp:655

QgsMarkerSymbolLayer::mOffsetUnit
Qgis::RenderUnit mOffsetUnit
Offset units.
Definition qgssymbollayer.h:1175

QgsMarkerSymbolLayer::offset
QPointF offset() const
Returns the marker's offset, which is the horizontal and vertical displacement which the rendered mar...
Definition qgssymbollayer.h:993

QgsMarkerSymbolLayer::mLineAngle
double mLineAngle
Line rotation angle (see setLineAngle() for details).
Definition qgssymbollayer.h:1165

QgsMarkerSymbolLayer::toSld
bool toSld(QDomDocument &doc, QDomElement &element, QgsSldExportContext &context) const override
Saves the symbol layer as SLD.
Definition qgssymbollayer.cpp:1030

QgsMarkerSymbolLayer::outputUnit
Qgis::RenderUnit outputUnit() const override
Returns the units to use for sizes and widths within the symbol layer.
Definition qgssymbollayer.cpp:831

QgsMarkerSymbolLayer::renderPoint
virtual void renderPoint(QPointF point, QgsSymbolRenderContext &context)=0
Renders a marker at the specified point.

QgsMarkerSymbolLayer::mOffset
QPointF mOffset
Marker offset.
Definition qgssymbollayer.h:1173

QgsMarkerSymbolLayer::mapUnitScale
QgsMapUnitScale mapUnitScale() const override
Definition qgssymbollayer.cpp:846

QgsMarkerSymbolLayer::size
double size() const
Returns the symbol size.
Definition qgssymbollayer.h:927

QgsMarkerSymbolLayer::verticalAnchorPoint
Qgis::VerticalAnchorPoint verticalAnchorPoint() const
Returns the vertical anchor point for positioning the symbol.
Definition qgssymbollayer.h:1061

QgsMarkerSymbolLayer::mOffsetMapUnitScale
QgsMapUnitScale mOffsetMapUnitScale
Offset map unit scale.
Definition qgssymbollayer.h:1177

QgsMarkerSymbolLayer::mVerticalAnchorPoint
Qgis::VerticalAnchorPoint mVerticalAnchorPoint
Vertical anchor point.
Definition qgssymbollayer.h:1183

QgsMarkerSymbolLayer::_rotatedOffset
static QPointF _rotatedOffset(QPointF offset, double angle)
Adjusts a marker offset to account for rotation.
Definition qgssymbollayer.cpp:786

QgsMarkerSymbolLayer::dxfSize
double dxfSize(QgsSymbolRenderContext &context) const override
Gets marker size.
Definition qgssymbollayer.cpp:1072

QgsMarkerSymbolLayer::dxfAngle
double dxfAngle(QgsSymbolRenderContext &context) const override
Gets angle.
Definition qgssymbollayer.cpp:1095

QgsMarkerSymbolLayer::mScaleMethod
Qgis::ScaleMethod mScaleMethod
Marker size scaling method.
Definition qgssymbollayer.h:1179

QgsMarkerSymbolLayer::horizontalAnchorPoint
Qgis::HorizontalAnchorPoint horizontalAnchorPoint() const
Returns the horizontal anchor point for positioning the symbol.
Definition qgssymbollayer.h:1044

QgsMarkerSymbolLayer::stopRender
void stopRender(QgsSymbolRenderContext &context) override
Called after a set of rendering operations has finished on the supplied render context.
Definition qgssymbollayer.cpp:650

QgsMarkerSymbolLayer::mSizeMapUnitScale
QgsMapUnitScale mSizeMapUnitScale
Marker size map unit scale.
Definition qgssymbollayer.h:1171

QgsMarkerSymbolLayer::mSizeUnit
Qgis::RenderUnit mSizeUnit
Marker size unit.
Definition qgssymbollayer.h:1169

QgsMarkerSymbolLayer::setOutputUnit
void setOutputUnit(Qgis::RenderUnit unit) override
Sets the units to use for sizes and widths within the symbol layer.
Definition qgssymbollayer.cpp:825

QgsMarkerSymbolLayer::writeSldMarker
virtual Q_DECL_DEPRECATED void writeSldMarker(QDomDocument &doc, QDomElement &element, const QVariantMap &props) const
Writes the symbol layer definition as a SLD XML element.
Definition qgssymbollayer.cpp:1044

QgsMarkerSymbolLayer::markerOffset
void markerOffset(QgsSymbolRenderContext &context, double &offsetX, double &offsetY) const
Calculates the required marker offset, including both the symbol offset and any displacement required...
Definition qgssymbollayer.cpp:675

QgsMarkerSymbolLayer::mHorizontalAnchorPoint
Qgis::HorizontalAnchorPoint mHorizontalAnchorPoint
Horizontal anchor point.
Definition qgssymbollayer.h:1181

QgsMarkerSymbolLayer::mAngle
double mAngle
Marker rotation angle, in degrees clockwise from north.
Definition qgssymbollayer.h:1163

QgsMarkerSymbolLayer::startRender
void startRender(QgsSymbolRenderContext &context) override
Called before a set of rendering operations commences on the supplied render context.
Definition qgssymbollayer.cpp:645

QgsMarkerSymbolLayer::angle
double angle() const
Returns the rotation angle for the marker, in degrees clockwise from north.
Definition qgssymbollayer.h:900

QgsMarkerSymbolLayer::setMapUnitScale
void setMapUnitScale(const QgsMapUnitScale &scale) override
Definition qgssymbollayer.cpp:840

QgsMaskRenderSettings::simplifyTolerance
double simplifyTolerance() const
Returns the simplification tolerance (in painter units) to use for on-the-fly simplification of mask ...
Definition qgsmaskrendersettings.h:43

QgsPaintEffectRegistry::isDefaultStack
static bool isDefaultStack(QgsPaintEffect *effect)
Tests whether a paint effect matches the default effects stack.
Definition qgspainteffectregistry.cpp:128

QgsPaintEffect
Base class for visual effects which can be applied to QPicture drawings.
Definition qgspainteffect.h:58

QgsPaintEffect::enabled
bool enabled() const
Returns whether the effect is enabled.
Definition qgspainteffect.h:204

QgsPropertyCollection::setProperty
void setProperty(int key, const QgsProperty &property)
Adds a property to the collection and takes ownership of it.
Definition qgspropertycollection.cpp:192

QgsPropertyDefinition::HorizontalAnchor
@ HorizontalAnchor
Horizontal anchor point.
Definition qgsproperty.h:74

QgsPropertyDefinition::Double
@ Double
Double value (including negative values).
Definition qgsproperty.h:56

QgsPropertyDefinition::VerticalAnchor
@ VerticalAnchor
Vertical anchor point.
Definition qgsproperty.h:75

QgsPropertyDefinition::Double0To1
@ Double0To1
Double value between 0-1 (inclusive).
Definition qgsproperty.h:58

QgsPropertyDefinition::FillStyle
@ FillStyle
Fill style (eg solid, lines).
Definition qgsproperty.h:72

QgsPropertyDefinition::StrokeWidth
@ StrokeWidth
Line stroke width.
Definition qgsproperty.h:71

QgsPropertyDefinition::LineStyle
@ LineStyle
Line style (eg solid/dashed).
Definition qgsproperty.h:70

QgsPropertyDefinition::String
@ String
Any string value.
Definition qgsproperty.h:60

QgsPropertyDefinition::Boolean
@ Boolean
Boolean value.
Definition qgsproperty.h:52

QgsPropertyDefinition::PenJoinStyle
@ PenJoinStyle
Pen join style.
Definition qgsproperty.h:65

QgsPropertyDefinition::IntegerPositive
@ IntegerPositive
Positive integer values (including 0).
Definition qgsproperty.h:54

QgsPropertyDefinition::Offset
@ Offset
2D offset
Definition qgsproperty.h:77

QgsPropertyDefinition::Opacity
@ Opacity
Opacity (0-100).
Definition qgsproperty.h:61

QgsPropertyDefinition::CapStyle
@ CapStyle
Line cap style (eg round).
Definition qgsproperty.h:73

QgsPropertyDefinition::Rotation
@ Rotation
Rotation (value between 0-360 degrees).
Definition qgsproperty.h:59

QgsPropertyDefinition::Size
@ Size
1D size (eg marker radius, or square marker height/width)
Definition qgsproperty.h:68

QgsPropertyDefinition::ColorWithAlpha
@ ColorWithAlpha
Color with alpha channel.
Definition qgsproperty.h:63

QgsPropertyDefinition::DoublePositive
@ DoublePositive
Positive double value (including 0).
Definition qgsproperty.h:57

QgsPropertyDefinition::DataTypeString
@ DataTypeString
Property requires a string value.
Definition qgsproperty.h:91

QgsPropertyDefinition::DataTypeNumeric
@ DataTypeNumeric
Property requires a numeric value.
Definition qgsproperty.h:98

QgsProperty
A store for object properties.
Definition qgsproperty.h:228

QgsProperty::value
QVariant value(const QgsExpressionContext &context, const QVariant &defaultValue=QVariant(), bool *ok=nullptr) const
Calculates the current value of the property, including any transforms which are set for the property...
Definition qgsproperty.cpp:599

QgsProperty::fromExpression
static QgsProperty fromExpression(const QString &expression, bool isActive=true)
Returns a new ExpressionBasedProperty created from the specified expression.
Definition qgsproperty.cpp:245

QgsProperty::fromField
static QgsProperty fromField(const QString &fieldName, bool isActive=true)
Returns a new FieldBasedProperty created from the specified field name.
Definition qgsproperty.cpp:253

QgsRectangle
A rectangle specified with double values.
Definition qgsrectangle.h:47

QgsRectangle::intersect
QgsRectangle intersect(const QgsRectangle &rect) const
Returns the intersection with the given rectangle.
Definition qgsrectangle.h:375

QgsRenderContext
Contains information about the context of a rendering operation.
Definition qgsrendercontext.h:63

QgsRenderContext::vectorSimplifyMethod
QgsVectorSimplifyMethod & vectorSimplifyMethod()
Returns the simplification settings to use when rendering vector layers.
Definition qgsrendercontext.h:651

QgsRenderContext::convertToPainterUnits
double convertToPainterUnits(double size, Qgis::RenderUnit unit, const QgsMapUnitScale &scale=QgsMapUnitScale(), Qgis::RenderSubcomponentProperty property=Qgis::RenderSubcomponentProperty::Generic) const
Converts a size from the specified units to painter units (pixels).
Definition qgsrendercontext.cpp:548

QgsRenderContext::painter
QPainter * painter()
Returns the destination QPainter for the render operation.
Definition qgsrendercontext.h:111

QgsRenderContext::expressionContext
QgsExpressionContext & expressionContext()
Gets the expression context.
Definition qgsrendercontext.h:688

QgsRenderContext::outputSize
QSize outputSize() const
Returns the size of the resulting rendered image, in pixels.
Definition qgsrendercontext.cpp:958

QgsRenderContext::feedback
QgsFeedback * feedback() const
Returns the feedback object that can be queried regularly during rendering to check if rendering shou...
Definition qgsrendercontext.cpp:348

QgsRenderContext::symbolLayerClipGeometries
QVector< QgsGeometry > symbolLayerClipGeometries(const QString &symbolLayerId) const
Returns clipping geometries to be applied to the symbolLayer before rendering.
Definition qgsrendercontext.cpp:1087

QgsRenderContext::flags
Qgis::RenderContextFlags flags() const
Returns combination of flags used for rendering.
Definition qgsrendercontext.cpp:368

QgsRenderContext::maskSettings
const QgsMaskRenderSettings & maskSettings() const
Returns a reference to the mask render settings, which control how masks are drawn and behave during ...
Definition qgsrendercontext.h:989

QgsSldExportContext
Holds SLD export options and other information related to SLD export of a QGIS layer style.
Definition qgssldexportcontext.h:29

QgsSldExportContext::setExtraProperties
void setExtraProperties(const QVariantMap &properties)
Sets the open ended set of properties that can drive/inform the SLD encoding.
Definition qgssldexportcontext.cpp:59

QgsSldExportContext::extraProperties
QVariantMap extraProperties() const
Returns the open ended set of properties that can drive/inform the SLD encoding.
Definition qgssldexportcontext.cpp:54

QgsSldExportContext::pushError
void pushError(const QString &error)
Pushes a error message generated during the conversion.
Definition qgssldexportcontext.h:95

QgsStyle::defaultStyle
static QgsStyle * defaultStyle(bool initialize=true)
Returns the default application-wide style.
Definition qgsstyle.cpp:164

QgsStyle::defaultPatchAsQPolygonF
QList< QList< QPolygonF > > defaultPatchAsQPolygonF(Qgis::SymbolType type, QSizeF size) const
Returns the default patch geometry for the given symbol type and size as a set of QPolygonF objects (...
Definition qgsstyle.cpp:1334

QgsSymbolLayerUtils::toPoint
static QPointF toPoint(const QVariant &value, bool *ok=nullptr)
Converts a value to a point.
Definition qgssymbollayerutils.cpp:651

QgsSymbolLayerUtils::collectSymbolLayerClipGeometries
static QVector< QgsGeometry > collectSymbolLayerClipGeometries(const QgsRenderContext &context, const QString &symbolLayerId, const QRectF &bounds)
Returns a list of the symbol layer clip geometries to be used for the symbol layer with the specified...
Definition qgssymbollayerutils.cpp:5800

QgsSymbolLayerUtils::createGeometryElement
static Q_DECL_DEPRECATED void createGeometryElement(QDomDocument &doc, QDomElement &element, const QString &geomFunc)
Creates an SLD geometry element.
Definition qgssymbollayerutils.cpp:3163

QgsSymbolLayerUtils::encodePoint
static QString encodePoint(QPointF point)
Encodes a QPointF to a string.
Definition qgssymbollayerutils.cpp:638

QgsSymbolLayer::copyCommonProperties
void copyCommonProperties(QgsSymbolLayer *destLayer) const
Copies all common base class properties from this layer to another symbol layer.
Definition qgssymbollayer.cpp:582

QgsSymbolLayer::mFields
QgsFields mFields
Definition qgssymbollayer.h:791

QgsSymbolLayer::clone
virtual QgsSymbolLayer * clone() const =0
Shall be reimplemented by subclasses to create a deep copy of the instance.

QgsSymbolLayer::setSubSymbol
virtual bool setSubSymbol(QgsSymbol *symbol)
Sets layer's subsymbol. takes ownership of the passed symbol.
Definition qgssymbollayer.cpp:187

QgsSymbolLayer::shouldRenderUsingSelectionColor
bool shouldRenderUsingSelectionColor(const QgsSymbolRenderContext &context) const
Returns true if the symbol layer should be rendered using the selection color from the render context...
Definition qgssymbollayer.cpp:1201

QgsSymbolLayer::type
Qgis::SymbolType type() const
Definition qgssymbollayer.h:469

QgsSymbolLayer::startFeatureRender
virtual void startFeatureRender(const QgsFeature &feature, QgsRenderContext &context)
Called before the layer will be rendered for a particular feature.
Definition qgssymbollayer.cpp:166

QgsSymbolLayer::fillColor
virtual QColor fillColor() const
Returns the fill color for the symbol layer.
Definition qgssymbollayer.cpp:371

QgsSymbolLayer::setId
void setId(const QString &id)
Set symbol layer identifier This id has to be unique in the whole project.
Definition qgssymbollayer.cpp:1206

QgsSymbolLayer::setStrokeColor
virtual void setStrokeColor(const QColor &color)
Sets the stroke color for the symbol layer.
Definition qgssymbollayer.cpp:360

QgsSymbolLayer::mClipPath
QPainterPath mClipPath
Definition qgssymbollayer.h:794

QgsSymbolLayer::installMasks
bool installMasks(QgsRenderContext &context, bool recursive, const QRectF &rect=QRectF())
When rendering, install masks on context painter.
Definition qgssymbollayer.cpp:1155

QgsSymbolLayer::dxfSize
virtual Q_DECL_DEPRECATED double dxfSize(const QgsDxfExport &e, QgsSymbolRenderContext &context) const
Gets marker size.
Definition qgssymbollayer.cpp:215

QgsSymbolLayer::dxfOffset
virtual Q_DECL_DEPRECATED double dxfOffset(const QgsDxfExport &e, QgsSymbolRenderContext &context) const
Gets offset.
Definition qgssymbollayer.cpp:227

QgsSymbolLayer::dxfBrushColor
virtual QColor dxfBrushColor(QgsSymbolRenderContext &context) const
Gets brush/fill color.
Definition qgssymbollayer.cpp:262

QgsSymbolLayer::mType
Qgis::SymbolType mType
Definition qgssymbollayer.h:774

QgsSymbolLayer::removeMasks
void removeMasks(QgsRenderContext &context, bool recursive)
When rendering, remove previously installed masks from context painter if recursive is true masks are...
Definition qgssymbollayer.cpp:1186

QgsSymbolLayer::usedAttributes
virtual QSet< QString > usedAttributes(const QgsRenderContext &context) const
Returns the set of attributes referenced by the layer.
Definition qgssymbollayer.cpp:428

QgsSymbolLayer::copyDataDefinedProperties
void copyDataDefinedProperties(QgsSymbolLayer *destLayer) const
Copies all data defined properties of this layer to another symbol layer.
Definition qgssymbollayer.cpp:589

QgsSymbolLayer::Property
Property
Data definable properties.
Definition qgssymbollayer.h:148

QgsSymbolLayer::Property::SkipMultiples
@ SkipMultiples
Skip multiples of.
Definition qgssymbollayer.h:219

QgsSymbolLayer::Property::ArrowHeadLength
@ ArrowHeadLength
Arrow head length.
Definition qgssymbollayer.h:196

QgsSymbolLayer::Property::GradientType
@ GradientType
Gradient fill type.
Definition qgssymbollayer.h:166

QgsSymbolLayer::Property::SecondaryColor
@ SecondaryColor
Secondary color (eg for gradient fills).
Definition qgssymbollayer.h:163

QgsSymbolLayer::Property::File
@ File
Filename, eg for svg files.
Definition qgssymbollayer.h:179

QgsSymbolLayer::Property::VerticalAnchor
@ VerticalAnchor
Vertical anchor point.
Definition qgssymbollayer.h:192

QgsSymbolLayer::Property::FontStyle
@ FontStyle
Font style.
Definition qgssymbollayer.h:207

QgsSymbolLayer::Property::ArrowType
@ ArrowType
Arrow type.
Definition qgssymbollayer.h:199

QgsSymbolLayer::Property::GradientReference2Y
@ GradientReference2Y
Gradient reference point 2 y.
Definition qgssymbollayer.h:172

QgsSymbolLayer::Property::GradientReference1X
@ GradientReference1X
Gradient reference point 1 x.
Definition qgssymbollayer.h:169

QgsSymbolLayer::Property::OffsetY
@ OffsetY
Vertical offset.
Definition qgssymbollayer.h:201

QgsSymbolLayer::Property::OffsetX
@ OffsetX
Horizontal offset.
Definition qgssymbollayer.h:200

QgsSymbolLayer::Property::GradientReference1Y
@ GradientReference1Y
Gradient reference point 1 y.
Definition qgssymbollayer.h:170

QgsSymbolLayer::Property::ArrowWidth
@ ArrowWidth
Arrow tail width.
Definition qgssymbollayer.h:194

QgsSymbolLayer::Property::PointCount
@ PointCount
Point count.
Definition qgssymbollayer.h:202

QgsSymbolLayer::Property::BlankSegments
@ BlankSegments
String list of distance to define blank segments along line for templated line symbol layers.
Definition qgssymbollayer.h:221

QgsSymbolLayer::Property::DashPatternOffset
@ DashPatternOffset
Dash pattern offset,.
Definition qgssymbollayer.h:208

QgsSymbolLayer::Property::GradientSpread
@ GradientSpread
Gradient spread mode.
Definition qgssymbollayer.h:168

QgsSymbolLayer::Property::OffsetAlongLine
@ OffsetAlongLine
Offset along line.
Definition qgssymbollayer.h:189

QgsSymbolLayer::Property::ArrowHeadType
@ ArrowHeadType
Arrow head type.
Definition qgssymbollayer.h:198

QgsSymbolLayer::Property::Width
@ Width
Symbol width.
Definition qgssymbollayer.h:158

QgsSymbolLayer::Property::CustomDash
@ CustomDash
Custom dash pattern.
Definition qgssymbollayer.h:185

QgsSymbolLayer::Property::ShapeburstMaxDistance
@ ShapeburstMaxDistance
Shapeburst fill from edge distance.
Definition qgssymbollayer.h:177

QgsSymbolLayer::Property::HorizontalAnchor
@ HorizontalAnchor
Horizontal anchor point.
Definition qgssymbollayer.h:191

QgsSymbolLayer::Property::Angle
@ Angle
Symbol angle.
Definition qgssymbollayer.h:150

QgsSymbolLayer::Property::StrokeStyle
@ StrokeStyle
Stroke style (eg solid, dashed).
Definition qgssymbollayer.h:155

QgsSymbolLayer::Property::Name
@ Name
Name, eg shape name for simple markers.
Definition qgssymbollayer.h:151

QgsSymbolLayer::Property::DistanceY
@ DistanceY
Vertical distance between points.
Definition qgssymbollayer.h:181

QgsSymbolLayer::Property::LineEndColorValue
@ LineEndColorValue
End line color for interpolated line renderer.
Definition qgssymbollayer.h:214

QgsSymbolLayer::Property::DensityArea
@ DensityArea
Density area.
Definition qgssymbollayer.h:205

QgsSymbolLayer::Property::ClipPoints
@ ClipPoints
Whether markers should be clipped to polygon boundaries.
Definition qgssymbollayer.h:204

QgsSymbolLayer::Property::ArrowHeadThickness
@ ArrowHeadThickness
Arrow head thickness.
Definition qgssymbollayer.h:197

QgsSymbolLayer::Property::FillColor
@ FillColor
Fill color.
Definition qgssymbollayer.h:152

QgsSymbolLayer::Property::LineClipping
@ LineClipping
Line clipping mode.
Definition qgssymbollayer.h:218

QgsSymbolLayer::Property::Size
@ Size
Symbol size.
Definition qgssymbollayer.h:149

QgsSymbolLayer::Property::ShapeburstIgnoreRings
@ ShapeburstIgnoreRings
Shapeburst ignore rings.
Definition qgssymbollayer.h:178

QgsSymbolLayer::Property::Character
@ Character
Character, eg for font marker symbol layers.
Definition qgssymbollayer.h:157

QgsSymbolLayer::Property::ShapeburstUseWholeShape
@ ShapeburstUseWholeShape
Shapeburst use whole shape.
Definition qgssymbollayer.h:176

QgsSymbolLayer::Property::DisplacementX
@ DisplacementX
Horizontal displacement.
Definition qgssymbollayer.h:182

QgsSymbolLayer::Property::ShowMarker
@ ShowMarker
Show markers.
Definition qgssymbollayer.h:220

QgsSymbolLayer::Property::CoordinateMode
@ CoordinateMode
Gradient coordinate mode.
Definition qgssymbollayer.h:167

QgsSymbolLayer::Property::FillStyle
@ FillStyle
Fill style (eg solid, dots).
Definition qgssymbollayer.h:161

QgsSymbolLayer::Property::GradientReference2X
@ GradientReference2X
Gradient reference point 2 x.
Definition qgssymbollayer.h:171

QgsSymbolLayer::Property::StrokeColor
@ StrokeColor
Stroke color.
Definition qgssymbollayer.h:153

QgsSymbolLayer::Property::TrimStart
@ TrimStart
Trim distance from start of line.
Definition qgssymbollayer.h:209

QgsSymbolLayer::Property::ArrowStartWidth
@ ArrowStartWidth
Arrow tail start width.
Definition qgssymbollayer.h:195

QgsSymbolLayer::Property::CapStyle
@ CapStyle
Line cap style.
Definition qgssymbollayer.h:186

QgsSymbolLayer::Property::BlurRadius
@ BlurRadius
Shapeburst blur radius.
Definition qgssymbollayer.h:175

QgsSymbolLayer::Property::Placement
@ Placement
Line marker placement.
Definition qgssymbollayer.h:187

QgsSymbolLayer::Property::MarkerClipping
@ MarkerClipping
Marker clipping mode.
Definition qgssymbollayer.h:215

QgsSymbolLayer::Property::RandomSeed
@ RandomSeed
Random number seed.
Definition qgssymbollayer.h:203

QgsSymbolLayer::Property::LineAngle
@ LineAngle
Line angle, or angle of hash lines for hash line symbols.
Definition qgssymbollayer.h:164

QgsSymbolLayer::Property::JoinStyle
@ JoinStyle
Line join style.
Definition qgssymbollayer.h:162

QgsSymbolLayer::Property::RandomOffsetY
@ RandomOffsetY
Random offset Y.
Definition qgssymbollayer.h:217

QgsSymbolLayer::Property::Opacity
@ Opacity
Opacity.
Definition qgssymbollayer.h:184

QgsSymbolLayer::Property::DisplacementY
@ DisplacementY
Vertical displacement.
Definition qgssymbollayer.h:183

QgsSymbolLayer::Property::PreserveAspectRatio
@ PreserveAspectRatio
Preserve aspect ratio between width and height.
Definition qgssymbollayer.h:160

QgsSymbolLayer::Property::LineStartColorValue
@ LineStartColorValue
Start line color for interpolated line renderer.
Definition qgssymbollayer.h:213

QgsSymbolLayer::Property::DistanceX
@ DistanceX
Horizontal distance between points.
Definition qgssymbollayer.h:180

QgsSymbolLayer::Property::AverageAngleLength
@ AverageAngleLength
Length to average symbol angles over.
Definition qgssymbollayer.h:190

QgsSymbolLayer::Property::LineEndWidthValue
@ LineEndWidthValue
End line width for interpolated line renderer.
Definition qgssymbollayer.h:212

QgsSymbolLayer::Property::GradientReference1IsCentroid
@ GradientReference1IsCentroid
Gradient reference point 1 is centroid.
Definition qgssymbollayer.h:173

QgsSymbolLayer::Property::Interval
@ Interval
Line marker interval.
Definition qgssymbollayer.h:188

QgsSymbolLayer::Property::StrokeWidth
@ StrokeWidth
Stroke width.
Definition qgssymbollayer.h:154

QgsSymbolLayer::Property::FontFamily
@ FontFamily
Font family.
Definition qgssymbollayer.h:206

QgsSymbolLayer::Property::GradientReference2IsCentroid
@ GradientReference2IsCentroid
Gradient reference point 2 is centroid.
Definition qgssymbollayer.h:174

QgsSymbolLayer::Property::LineStartWidthValue
@ LineStartWidthValue
Start line width for interpolated line renderer.
Definition qgssymbollayer.h:211

QgsSymbolLayer::Property::LineDistance
@ LineDistance
Distance between lines, or length of lines for hash line symbols.
Definition qgssymbollayer.h:165

QgsSymbolLayer::Property::Offset
@ Offset
Symbol offset.
Definition qgssymbollayer.h:156

QgsSymbolLayer::Property::RandomOffsetX
@ RandomOffsetX
Random offset X.
Definition qgssymbollayer.h:216

QgsSymbolLayer::Property::ExtraItems
@ ExtraItems
String list of tuple (x, y and rotation angle) to define extra items to be rendered for templated lin...
Definition qgssymbollayer.h:222

QgsSymbolLayer::Property::TrimEnd
@ TrimEnd
Trim distance from end of line.
Definition qgssymbollayer.h:210

QgsSymbolLayer::Property::Height
@ Height
Symbol height.
Definition qgssymbollayer.h:159

QgsSymbolLayer::Property::LayerEnabled
@ LayerEnabled
Whether symbol layer is enabled.
Definition qgssymbollayer.h:193

QgsSymbolLayer::restoreOldDataDefinedProperties
void restoreOldDataDefinedProperties(const QVariantMap &stringMap)
Restores older data defined properties from string map.
Definition qgssymbollayer.cpp:462

QgsSymbolLayer::mRenderingPass
int mRenderingPass
Definition qgssymbollayer.h:784

QgsSymbolLayer::setPaintEffect
void setPaintEffect(QgsPaintEffect *effect)
Sets the current paint effect for the layer.
Definition qgssymbollayer.cpp:278

QgsSymbolLayer::setRenderingPass
void setRenderingPass(int renderingPass)
Specifies the rendering pass in which this symbol layer should be rendered.
Definition qgssymbollayer.cpp:418

QgsSymbolLayer::paintEffect
QgsPaintEffect * paintEffect() const
Returns the current paint effect for the layer.
Definition qgssymbollayer.cpp:273

QgsSymbolLayer::startRender
virtual void startRender(QgsSymbolRenderContext &context)=0
Called before a set of rendering operations commences on the supplied render context.

QgsSymbolLayer::selectiveMaskingSourceSetId
QString selectiveMaskingSourceSetId() const
Returns the selective masking source set ID for this symbol layer.
Definition qgssymbollayer.cpp:1062

QgsSymbolLayer::properties
virtual QVariantMap properties() const =0
Should be reimplemented by subclasses to return a string map that contains the configuration informat...

QgsSymbolLayer::mColor
QColor mColor
Definition qgssymbollayer.h:783

QgsSymbolLayer::mPaintEffect
std::unique_ptr< QgsPaintEffect > mPaintEffect
Definition qgssymbollayer.h:790

QgsSymbolLayer::dxfPenStyle
virtual Qt::PenStyle dxfPenStyle() const
Gets pen style.
Definition qgssymbollayer.cpp:257

QgsSymbolLayer::mSelectiveMaskingSourceSetId
QString mSelectiveMaskingSourceSetId
Definition qgssymbollayer.h:788

QgsSymbolLayer::setSelectiveMaskingSourceSetId
void setSelectiveMaskingSourceSetId(const QString &id)
Sets the selective masking source set id for this symbol layer.
Definition qgssymbollayer.cpp:1067

QgsSymbolLayer::setFillColor
virtual void setFillColor(const QColor &color)
Sets the fill color for the symbol layer.
Definition qgssymbollayer.cpp:368

QgsSymbolLayer::mEnabled
bool mEnabled
True if layer is enabled and should be drawn.
Definition qgssymbollayer.h:777

QgsSymbolLayer::prepareExpressions
virtual void prepareExpressions(const QgsSymbolRenderContext &context)
Prepares all data defined property expressions for evaluation.
Definition qgssymbollayer.cpp:376

QgsSymbolLayer::setUserFlags
void setUserFlags(Qgis::SymbolLayerUserFlags flags)
Sets user-controlled flags which control the symbol layer's behavior.
Definition qgssymbollayer.cpp:345

QgsSymbolLayer::dxfColor
virtual QColor dxfColor(QgsSymbolRenderContext &context) const
Gets color.
Definition qgssymbollayer.cpp:239

QgsSymbolLayer::rendersIdenticallyTo
virtual bool rendersIdenticallyTo(const QgsSymbolLayer *other) const
Returns true if this symbol layer will always render identically to an other symbol layer.
Definition qgssymbollayer.cpp:307

QgsSymbolLayer::layerType
virtual QString layerType() const =0
Returns a string that represents this layer type.

QgsSymbolLayer::renderingPass
int renderingPass() const
Specifies the rendering pass in which this symbol layer should be rendered.
Definition qgssymbollayer.cpp:423

QgsSymbolLayer::stopRender
virtual void stopRender(QgsSymbolRenderContext &context)=0
Called after a set of rendering operations has finished on the supplied render context.

QgsSymbolLayer::toSld
virtual Q_DECL_DEPRECATED void toSld(QDomDocument &doc, QDomElement &element, const QVariantMap &props) const
Saves the symbol layer as SLD.
Definition qgssymbollayer.cpp:1216

QgsSymbolLayer::isCompatibleWithSymbol
virtual bool isCompatibleWithSymbol(QgsSymbol *symbol) const
Returns if the layer can be used below the specified symbol.
Definition qgssymbollayer.cpp:400

QgsSymbolLayer::id
QString id() const
Returns symbol layer identifier This id is unique in the whole project.
Definition qgssymbollayer.cpp:1211

QgsSymbolLayer::setDataDefinedProperty
virtual void setDataDefinedProperty(Property key, const QgsProperty &property)
Sets a data defined property for the layer.
Definition qgssymbollayer.cpp:161

QgsSymbolLayer::setColor
virtual void setColor(const QColor &color)
Sets the "representative" color for the symbol layer.
Definition qgssymbollayer.cpp:355

QgsSymbolLayer::subSymbol
virtual QgsSymbol * subSymbol()
Returns the symbol's sub symbol, if present.
Definition qgssymbollayer.cpp:182

QgsSymbolLayer::userFlags
Qgis::SymbolLayerUserFlags userFlags() const
Returns user-controlled flags which control the symbol layer's behavior.
Definition qgssymbollayer.cpp:340

QgsSymbolLayer::color
virtual QColor color() const
Returns the "representative" color of the symbol layer.
Definition qgssymbollayer.cpp:350

QgsSymbolLayer::prepareMasks
virtual void prepareMasks(const QgsSymbolRenderContext &context)
Prepares all mask internal objects according to what is defined in context This should be called prio...
Definition qgssymbollayer.cpp:1147

QgsSymbolLayer::stopFeatureRender
virtual void stopFeatureRender(const QgsFeature &feature, QgsRenderContext &context)
Called after the layer has been rendered for a particular feature.
Definition qgssymbollayer.cpp:174

QgsSymbolLayer::propertyDefinitions
static const QgsPropertiesDefinition & propertyDefinitions()
Returns the symbol layer property definitions.
Definition qgssymbollayer.cpp:392

QgsSymbolLayer::dxfWidth
virtual Q_DECL_DEPRECATED double dxfWidth(const QgsDxfExport &e, QgsSymbolRenderContext &context) const
Gets line width.
Definition qgssymbollayer.cpp:203

QgsSymbolLayer::strokeColor
virtual QColor strokeColor() const
Returns the stroke color for the symbol layer.
Definition qgssymbollayer.cpp:363

QgsSymbolLayer::dxfAngle
virtual double dxfAngle(QgsSymbolRenderContext &context) const
Gets angle.
Definition qgssymbollayer.cpp:245

QgsSymbolLayer::mUserFlags
Qgis::SymbolLayerUserFlags mUserFlags
User controlled flags.
Definition qgssymbollayer.h:780

QgsSymbolLayer::canCauseArtifactsBetweenAdjacentTiles
virtual bool canCauseArtifactsBetweenAdjacentTiles() const
Returns true if the symbol layer rendering can cause visible artifacts across a single feature when t...
Definition qgssymbollayer.cpp:408

QgsSymbolLayer::mLocked
bool mLocked
Definition qgssymbollayer.h:782

QgsSymbolLayer::~QgsSymbolLayer
virtual ~QgsSymbolLayer()

QgsSymbolLayer::usesMapUnits
virtual bool usesMapUnits() const
Returns true if the symbol layer has any components which use map unit based sizes.
Definition qgssymbollayer.cpp:413

QgsSymbolLayer::writeDxf
virtual bool writeDxf(QgsDxfExport &e, double mmMapUnitScaleFactor, const QString &layerName, QgsSymbolRenderContext &context, QPointF shift=QPointF(0.0, 0.0)) const
write as DXF
Definition qgssymbollayer.cpp:193

QgsSymbolLayer::copyPaintEffect
void copyPaintEffect(QgsSymbolLayer *destLayer) const
Copies paint effect of this layer to another symbol layer.
Definition qgssymbollayer.cpp:597

QgsSymbolLayer::flags
virtual Qgis::SymbolLayerFlags flags() const
Returns flags which control the symbol layer's behavior.
Definition qgssymbollayer.cpp:335

QgsSymbolLayer::mDataDefinedProperties
QgsPropertyCollection mDataDefinedProperties
Definition qgssymbollayer.h:786

QgsSymbolLayer::masks
virtual QList< QgsSymbolLayerReference > masks() const
Returns masks defined by this symbol layer.
Definition qgssymbollayer.cpp:1057

QgsSymbolLayer::dataDefinedProperties
QgsPropertyCollection & dataDefinedProperties()
Returns a reference to the symbol layer's property collection, used for data defined overrides.
Definition qgssymbollayer.h:671

QgsSymbolLayer::dxfBrushStyle
virtual Qt::BrushStyle dxfBrushStyle() const
Gets brush/fill style.
Definition qgssymbollayer.cpp:268

QgsSymbolLayer::dxfCustomDashPattern
virtual QVector< qreal > dxfCustomDashPattern(Qgis::RenderUnit &unit) const
Gets dash pattern.
Definition qgssymbollayer.cpp:251

QgsSymbolLayer::hasDataDefinedProperties
virtual bool hasDataDefinedProperties() const
Returns true if the symbol layer (or any of its sub-symbols) contains data defined properties.
Definition qgssymbollayer.cpp:387

QgsSymbolLayer::mId
QString mId
Definition qgssymbollayer.h:785

QgsSymbolLayer::QgsSymbolLayer
QgsSymbolLayer(const QgsSymbolLayer &other)
Definition qgssymbollayer.cpp:286

QgsSymbolLayer::setDataDefinedProperties
void setDataDefinedProperties(const QgsPropertyCollection &collection)
Sets the symbol layer's property collection, used for data defined overrides.
Definition qgssymbollayer.h:684

QgsSymbolRenderContext
Encapsulates the context in which a symbol is being rendered.
Definition qgssymbolrendercontext.h:35

QgsSymbolRenderContext::fields
QgsFields fields() const
Fields of the layer.
Definition qgssymbolrendercontext.h:186

QgsSymbolRenderContext::selected
bool selected() const
Returns true if symbols should be rendered using the selected symbol coloring and style.
Definition qgssymbolrendercontext.h:123

QgsSymbolRenderContext::setOriginalValueVariable
void setOriginalValueVariable(const QVariant &value)
Sets the original value variable value for data defined symbology.
Definition qgssymbolrendercontext.cpp:38

QgsSymbolRenderContext::patchShape
const QgsLegendPatchShape * patchShape() const
Returns the symbol patch shape, to use if rendering symbol preview icons.
Definition qgssymbolrendercontext.cpp:79

QgsSymbolRenderContext::renderContext
QgsRenderContext & renderContext()
Returns a reference to the context's render context.
Definition qgssymbolrendercontext.h:68

QgsSymbol
Abstract base class for all rendered symbols.
Definition qgssymbol.h:227

QgsSymbol::type
Qgis::SymbolType type() const
Returns the symbol's type.
Definition qgssymbol.h:296

QgsVariantUtils::isNull
static bool isNull(const QVariant &variant, bool silenceNullWarnings=false)
Returns true if the specified variant should be considered a NULL value.
Definition qgsvariantutils.cpp:176

QgsVectorSimplifyMethod::simplifyHints
Qgis::VectorRenderingSimplificationFlags simplifyHints() const
Gets the simplification hints of the vector layer managed.
Definition qgsvectorsimplifymethod.h:40

QgsVectorSimplifyMethod::threshold
float threshold() const
Gets the simplification threshold of the vector layer managed.
Definition qgsvectorsimplifymethod.h:55

geos
Contains geos related utilities and functions.
Definition qgsgeos.h:112

c
As part of the API refactoring and improvements which landed in the Processing API was substantially reworked from the x version This was done in order to allow much of the underlying Processing framework to be ported into c
Definition porting_processing.dox:1

qgsdxfexport.h

qgsexpressioncontext.h

qgsexpressioncontextutils.h

qgsgeometrysimplifier.h

qgsgeos.h

qgslegendpatchshape.h

qgspainteffect.h

qgspainteffectregistry.h

qgsproperty.h

QgsPropertiesDefinition
QMap< int, QgsPropertyDefinition > QgsPropertiesDefinition
Definition of available properties.
Definition qgspropertycollection.h:32

qgsrendercontext.h

qgssldexportcontext.h

qgsstyle.h

qgssymbol.h

propertyFromMap
QgsProperty propertyFromMap(const QVariantMap &map, const QString &baseName)
Definition qgssymbollayer.cpp:437

generateClipPath
QPainterPath generateClipPath(const QgsRenderContext &renderContext, const QString &id, const QRectF *rect, bool &foundGeometries)
Definition qgssymbollayer.cpp:1106

qgssymbollayer.h

DEG2RAD
#define DEG2RAD(x)
Definition qgssymbollayer.h:18

qgssymbollayerreference.h

qgssymbollayerutils.h

QgsExpressionContextScope::StaticVariable
Single variable definition for use within a QgsExpressionContextScope.
Definition qgsexpressioncontext.h:125