49 if ( props.contains( QStringLiteral(
"arrow_width" ) ) )
50 l->
setArrowWidth( props[QStringLiteral(
"arrow_width" )].toDouble() );
52 if ( props.contains( QStringLiteral(
"arrow_width_unit" ) ) )
55 if ( props.contains( QStringLiteral(
"arrow_width_unit_scale" ) ) )
58 if ( props.contains( QStringLiteral(
"arrow_start_width" ) ) )
61 if ( props.contains( QStringLiteral(
"arrow_start_width_unit" ) ) )
64 if ( props.contains( QStringLiteral(
"arrow_start_width_unit_scale" ) ) )
67 if ( props.contains( QStringLiteral(
"is_curved" ) ) )
68 l->
setIsCurved( props[QStringLiteral(
"is_curved" )].toInt() == 1 );
70 if ( props.contains( QStringLiteral(
"is_repeated" ) ) )
71 l->
setIsRepeated( props[QStringLiteral(
"is_repeated" )].toInt() == 1 );
73 if ( props.contains( QStringLiteral(
"head_length" ) ) )
74 l->
setHeadLength( props[QStringLiteral(
"head_length" )].toDouble() );
76 if ( props.contains( QStringLiteral(
"head_length_unit" ) ) )
79 if ( props.contains( QStringLiteral(
"head_length_unit_scale" ) ) )
82 if ( props.contains( QStringLiteral(
"head_thickness" ) ) )
85 if ( props.contains( QStringLiteral(
"head_thickness_unit" ) ) )
88 if ( props.contains( QStringLiteral(
"head_thickness_unit_scale" ) ) )
91 if ( props.contains( QStringLiteral(
"head_type" ) ) )
94 if ( props.contains( QStringLiteral(
"arrow_type" ) ) )
97 if ( props.contains( QStringLiteral(
"offset" ) ) )
98 l->
setOffset( props[QStringLiteral(
"offset" )].toDouble() );
100 if ( props.contains( QStringLiteral(
"offset_unit" ) ) )
103 if ( props.contains( QStringLiteral(
"offset_unit_scale" ) ) )
106 if ( props.contains( QStringLiteral(
"ring_filter" ) ) )
127 return mSymbol.get();
132 return QStringLiteral(
"ArrowLine" );
139 map[QStringLiteral(
"arrow_width" )] = QString::number(
arrowWidth() );
143 map[QStringLiteral(
"arrow_start_width" )] = QString::number(
arrowStartWidth() );
147 map[QStringLiteral(
"is_curved" )] = QString::number(
isCurved() ? 1 : 0 );
148 map[QStringLiteral(
"is_repeated" )] = QString::number(
isRepeated() ? 1 : 0 );
150 map[QStringLiteral(
"head_length" )] = QString::number(
headLength() );
154 map[QStringLiteral(
"head_thickness" )] = QString::number(
headThickness() );
158 map[QStringLiteral(
"head_type" )] = QString::number(
headType() );
159 map[QStringLiteral(
"arrow_type" )] = QString::number(
arrowType() );
161 map[QStringLiteral(
"offset" )] = QString::number(
offset() );
165 map[QStringLiteral(
"ring_filter" )] = QString::number(
static_cast< int >(
mRingFilter ) );
174 attributes.unite( mSymbol->usedAttributes( context ) );
183 if ( mSymbol && mSymbol->hasDataDefinedProperties() )
201 mArrowWidthUnit = unit;
202 mArrowStartWidthUnit = unit;
203 mHeadLengthUnit = unit;
204 mHeadThicknessUnit = unit;
232 qreal startWidth, qreal width,
233 qreal headWidth, qreal headHeight,
244 po = pd - ( pd - po ) / length * headWidth;
249 pd = po + ( pd - po ) / length * headWidth;
254 const QPointF v = ( pd - po ) / length * headWidth;
255 const QPointF npo = ( po + pd ) / 2.0 - v;
256 const QPointF npd = ( po + pd ) / 2.0 + v;
259 length = 2 * headWidth;
262 const qreal bodyLength = length - headWidth;
265 const QPointF unitVec = ( pd - po ) / length;
267 const QPointF perpVec( -unitVec.y(), unitVec.x() );
270 po += perpVec * offset;
271 pd += perpVec * offset;
279 polygon << po + unitVec *headWidth + perpVec *headHeight;
280 polygon << po + unitVec *headWidth + perpVec * ( width * 0.5 );
282 polygon << po + unitVec *bodyLength + perpVec * ( width * 0.5 );
285 polygon << po + unitVec *bodyLength + perpVec *headHeight;
291 polygon << po + unitVec *bodyLength - perpVec *headHeight;
292 polygon << po + unitVec *bodyLength - perpVec * ( width * 0.5 );
295 polygon << po + unitVec *headWidth - perpVec * ( width * 0.5 );
296 polygon << po + unitVec *headWidth - perpVec *headHeight;
303 polygon << po + perpVec * ( startWidth * 0.5 );
304 polygon << po + unitVec *bodyLength + perpVec * ( width * 0.5 );
305 polygon << po + unitVec *bodyLength + perpVec *headHeight;
314 polygon << po + unitVec *bodyLength - perpVec *headHeight;
315 polygon << po + unitVec *bodyLength - perpVec * ( width * 0.5 );
316 polygon << po - perpVec * ( startWidth * 0.5 );
328 polygon << po + unitVec *headWidth + perpVec *headHeight;
329 polygon << po + unitVec *headWidth + perpVec * ( width * 0.5 );
331 polygon << pd + perpVec * ( startWidth * 0.5 );
339 polygon << pd - perpVec * ( startWidth * 0.5 );
341 polygon << po + unitVec *headWidth - perpVec * ( width * 0.5 );
342 polygon << po + unitVec *headWidth - perpVec *headHeight;
350 polygon << polygon.first();
374 const QPointF ab = b - a;
375 const QPointF bc =
c - b;
378 const QPointF ab2 = ( a + b ) / 2.0;
379 const QPointF bc2 = ( b +
c ) / 2.0;
382 if ( std::fabs( ab.x() * bc.y() - ab.y() * bc.x() ) < 0.001 )
389 cy = bc2.y() - ( cx - bc2.x() ) * bc.x() / bc.y();
392 else if ( bc.y() == 0 )
395 cy = ab2.y() - ( cx - ab2.x() ) * ab.x() / ab.y();
400 cx = ( bc2.y() - ab2.y() + bc.x() * bc2.x() / bc.y() - ab.x() * ab2.x() / ab.y() ) / ( bc.x() / bc.y() - ab.x() / ab.y() );
401 cy = bc2.y() - ( cx - bc2.x() ) * bc.x() / bc.y();
414 return QPointF( std::cos( -angle ) * radius + center.x(), std::sin( -angle ) * radius + center.y() );
417void pathArcTo( QPainterPath &path, QPointF circleCenter, qreal circleRadius, qreal angle_o, qreal angle_d,
int direction )
419 const QRectF circleRect( circleCenter - QPointF( circleRadius, circleRadius ), circleCenter + QPointF( circleRadius, circleRadius ) );
420 if ( direction == 1 )
422 if ( angle_o < angle_d )
423 path.arcTo( circleRect, angle_o / M_PI * 180.0, ( angle_d - angle_o ) / M_PI * 180.0 );
425 path.arcTo( circleRect, angle_o / M_PI * 180.0, 360.0 - ( angle_o - angle_d ) / M_PI * 180.0 );
429 if ( angle_o < angle_d )
430 path.arcTo( circleRect, angle_o / M_PI * 180.0, - ( 360.0 - ( angle_d - angle_o ) / M_PI * 180.0 ) );
432 path.arcTo( circleRect, angle_o / M_PI * 180.0, ( angle_d - angle_o ) / M_PI * 180.0 );
437void spiralArcTo( QPainterPath &path, QPointF center, qreal startAngle, qreal startRadius, qreal endAngle, qreal endRadius,
int direction )
440 const QPointF A =
circlePoint( center, startRadius, startAngle );
442 const QPointF B =
circlePoint( center, endRadius, endAngle );
446 deltaAngle = endAngle - startAngle;
447 if ( direction * deltaAngle < 0.0 )
448 deltaAngle = deltaAngle + direction * 2 * M_PI;
450 const QPointF I1 =
circlePoint( center, 0.75 * startRadius + 0.25 * endRadius, startAngle + 0.25 * deltaAngle );
451 const QPointF I2 =
circlePoint( center, 0.50 * startRadius + 0.50 * endRadius, startAngle + 0.50 * deltaAngle );
452 const QPointF I3 =
circlePoint( center, 0.25 * startRadius + 0.75 * endRadius, startAngle + 0.75 * deltaAngle );
465 const qreal a1 = std::atan2( cCenter.y() - A.y(), A.x() - cCenter.x() );
466 const qreal a2 = std::atan2( cCenter.y() - I2.y(), I2.x() - cCenter.x() );
467 pathArcTo( path, cCenter, cRadius, a1, a2, direction );
479 const qreal a1 = std::atan2( cCenter.y() - I2.y(), I2.x() - cCenter.x() );
480 const qreal a2 = std::atan2( cCenter.y() - B.y(), B.x() - cCenter.x() );
481 pathArcTo( path, cCenter, cRadius, a1, a2, direction );
486 qreal startWidth, qreal width,
487 qreal headWidth, qreal headHeight,
492 QPointF circleCenter;
496 return straightArrow( po, pd, startWidth, width, headWidth, headHeight, headType, arrowType, offset );
500 const qreal angle_o =
clampAngle( std::atan2( circleCenter.y() - po.y(), po.x() - circleCenter.x() ) );
501 const qreal angle_m =
clampAngle( std::atan2( circleCenter.y() - pm.y(), pm.x() - circleCenter.x() ) );
502 const qreal angle_d =
clampAngle( std::atan2( circleCenter.y() - pd.y(), pd.x() - circleCenter.x() ) );
505 const int direction =
clampAngle( angle_m - angle_o ) <
clampAngle( angle_m - angle_d ) ? 1 : -1;
514 qreal deltaAngle = angle_d - angle_o;
515 if ( direction * deltaAngle < 0.0 )
516 deltaAngle = deltaAngle + direction * 2 * M_PI;
524 return straightArrow( po, pd, startWidth, width, headWidth, headHeight, headType, arrowType, offset );
528 circleRadius += offset;
529 po =
circlePoint( circleCenter, circleRadius, angle_o );
530 pm =
circlePoint( circleCenter, circleRadius, angle_m );
531 pd =
circlePoint( circleCenter, circleRadius, angle_d );
533 const qreal headAngle = direction * std::atan( headWidth / circleRadius );
543 path.lineTo(
circlePoint( circleCenter, circleRadius + direction * headHeight, angle_o + headAngle ) );
545 pathArcTo( path, circleCenter, circleRadius + direction * width / 2, angle_o + headAngle, angle_d - headAngle, direction );
548 path.lineTo(
circlePoint( circleCenter, circleRadius + direction * headHeight, angle_d - headAngle ) );
553 pathArcTo( path, circleCenter, circleRadius, angle_o, angle_d, direction );
557 path.lineTo(
circlePoint( circleCenter, circleRadius - direction * headHeight, angle_d - headAngle ) );
559 pathArcTo( path, circleCenter, circleRadius - direction * width / 2, angle_d - headAngle, angle_o + headAngle, -direction );
562 path.lineTo(
circlePoint( circleCenter, circleRadius - direction * headHeight, angle_o + headAngle ) );
567 pathArcTo( path, circleCenter, circleRadius, angle_d, angle_o, -direction );
574 path.moveTo(
circlePoint( circleCenter, circleRadius + direction * startWidth / 2, angle_o ) );
576 spiralArcTo( path, circleCenter, angle_o, circleRadius + direction * startWidth / 2, angle_d - headAngle, circleRadius + direction * width / 2, direction );
579 path.lineTo(
circlePoint( circleCenter, circleRadius + direction * headHeight, angle_d - headAngle ) );
585 pathArcTo( path, circleCenter, circleRadius, angle_o, angle_d, direction );
589 path.lineTo(
circlePoint( circleCenter, circleRadius - direction * headHeight, angle_d - headAngle ) );
591 spiralArcTo( path, circleCenter, angle_d - headAngle, circleRadius - direction * width / 2, angle_o, circleRadius - direction * startWidth / 2, -direction );
593 path.lineTo(
circlePoint( circleCenter, circleRadius + direction * startWidth / 2, angle_o ) );
597 pathArcTo( path, circleCenter, circleRadius, angle_d, angle_o, -direction );
598 path.lineTo(
circlePoint( circleCenter, circleRadius + direction * startWidth / 2, angle_o ) );
606 path.lineTo(
circlePoint( circleCenter, circleRadius + direction * headHeight, angle_o + headAngle ) );
607 path.lineTo(
circlePoint( circleCenter, circleRadius + direction * width / 2, angle_o + headAngle ) );
609 spiralArcTo( path, circleCenter, angle_o + headAngle, circleRadius + direction * width / 2, angle_d, circleRadius + direction * startWidth / 2, direction );
613 pathArcTo( path, circleCenter, circleRadius, angle_o, angle_d, direction );
617 path.lineTo(
circlePoint( circleCenter, circleRadius - direction * startWidth / 2, angle_d ) );
619 spiralArcTo( path, circleCenter, angle_d, circleRadius - direction * startWidth / 2, angle_o + headAngle, circleRadius - direction * width / 2, - direction );
621 path.lineTo(
circlePoint( circleCenter, circleRadius - direction * headHeight, angle_o + headAngle ) );
627 pathArcTo( path, circleCenter, circleRadius, angle_d, angle_o, -direction );
631 return path.toSubpathPolygons().at( 0 );
646 const double w = exprVal.toDouble( &ok );
659 const double w = exprVal.toDouble( &ok );
672 const double w = exprVal.toDouble( &ok );
685 const double w = exprVal.toDouble( &ok );
696 const double w = exprVal.toDouble( &ok );
712 mComputedHeadType = h;
726 mComputedArrowType = h;
748 const double prevOpacity = mSymbol->opacity();
749 mSymbol->setOpacity( prevOpacity * context.
opacity() );
754 _resolveDataDefined( context );
758 if ( points.size() >= 3 )
761 const QPointF po( points.at( 0 ) );
763 const QPointF pm( points.at( points.size() / 2 ) );
765 const QPointF pd( points.back() );
767 const QPolygonF poly =
curvedArrow( po, pm, pd, mScaledArrowStartWidth, mScaledArrowWidth, mScaledHeadLength, mScaledHeadThickness, mComputedHeadType, mComputedArrowType, mScaledOffset );
768 mSymbol->renderPolygon( poly,
nullptr, context.
feature(), context.
renderContext(), -1, useSelectedColor );
771 else if ( points.size() == 2 )
774 const QPointF po( points.at( 0 ) );
776 const QPointF pd( points.at( 1 ) );
778 const QPolygonF poly =
straightArrow( po, pd, mScaledArrowStartWidth, mScaledArrowWidth, mScaledHeadLength, mScaledHeadThickness, mComputedHeadType, mComputedArrowType, mScaledOffset );
779 mSymbol->renderPolygon( poly,
nullptr, context.
feature(), context.
renderContext(), -1, useSelectedColor );
784 for (
int pIdx = 0; pIdx < points.size() - 1; pIdx += 2 )
790 _resolveDataDefined( context );
792 if ( points.size() - pIdx >= 3 )
795 const QPointF po( points.at( pIdx ) );
797 const QPointF pm( points.at( pIdx + 1 ) );
799 const QPointF pd( points.at( pIdx + 2 ) );
801 const QPolygonF poly =
curvedArrow( po, pm, pd, mScaledArrowStartWidth, mScaledArrowWidth, mScaledHeadLength, mScaledHeadThickness, mComputedHeadType, mComputedArrowType, mScaledOffset );
802 mSymbol->renderPolygon( poly,
nullptr, context.
feature(), context.
renderContext(), -1, useSelectedColor );
805 else if ( points.size() - pIdx == 2 )
808 const QPointF po( points.at( pIdx ) );
810 const QPointF pd( points.at( pIdx + 1 ) );
812 const QPolygonF poly =
straightArrow( po, pd, mScaledArrowStartWidth, mScaledArrowWidth, mScaledHeadLength, mScaledHeadThickness, mComputedHeadType, mComputedArrowType, mScaledOffset );
813 mSymbol->renderPolygon( poly,
nullptr, context.
feature(), context.
renderContext(), -1, useSelectedColor );
822 _resolveDataDefined( context );
824 if ( !points.isEmpty() )
827 const QPointF po( points.at( 0 ) );
829 const QPointF pd( points.back() );
831 const QPolygonF poly =
straightArrow( po, pd, mScaledArrowStartWidth, mScaledArrowWidth, mScaledHeadLength, mScaledHeadThickness, mComputedHeadType, mComputedArrowType, mScaledOffset );
832 mSymbol->renderPolygon( poly,
nullptr, context.
feature(), context.
renderContext(), -1, useSelectedColor );
838 for (
int pIdx = 0; pIdx < points.size() - 1; pIdx++ )
844 _resolveDataDefined( context );
847 const QPointF po( points.at( pIdx ) );
849 const QPointF pd( points.at( pIdx + 1 ) );
851 const QPolygonF poly =
straightArrow( po, pd, mScaledArrowStartWidth, mScaledArrowWidth, mScaledHeadLength, mScaledHeadThickness, mComputedHeadType, mComputedArrowType, mScaledOffset );
853 mSymbol->renderPolygon( poly,
nullptr, context.
feature(), context.
renderContext(), -1, useSelectedColor );
860 mSymbol->setOpacity( prevOpacity );
867 mSymbol->setColor(
c );
874 return mSymbol.get() ? mSymbol->color() :
mColor;
RenderUnit
Rendering size units.
@ Millimeters
Millimeters.
@ MetersInMapUnits
Meters value as Map units.
@ RenderingSubSymbol
Set whenever a sub-symbol of a parent symbol is currently being rendered. Can be used during symbol a...
Line symbol layer used for representing lines as arrows.
void setOutputUnit(Qgis::RenderUnit unit) override
Sets the units to use for sizes and widths within the symbol layer.
bool isCurved() const
Returns whether it is a curved arrow or a straight one.
ArrowType arrowType() const
Gets the current arrow type.
QString layerType() const override
Returns a string that represents this layer type.
HeadType
Possible head types.
HeadType headType() const
Gets the current head type.
void setArrowStartWidth(double width)
Sets the arrow start width.
bool isRepeated() const
Returns whether the arrow is repeated along the line or not.
bool hasDataDefinedProperties() const override
Returns true if the symbol layer (or any of its sub-symbols) contains data defined properties.
void startRender(QgsSymbolRenderContext &context) override
Called before a set of rendering operations commences on the supplied render context.
void setArrowWidth(double width)
Sets the arrow width.
void setArrowType(ArrowType type)
Sets the arrow type.
void setHeadLengthUnitScale(const QgsMapUnitScale &scale)
Sets the scale for the head length.
~QgsArrowSymbolLayer() override
QgsMapUnitScale headThicknessUnitScale() const
Gets the scale for the head height.
QgsSymbol * subSymbol() override
Returns the symbol's sub symbol, if present.
Qgis::RenderUnit arrowWidthUnit() const
Gets the unit for the arrow width.
Qgis::RenderUnit headLengthUnit() const
Gets the unit for the head length.
Qgis::RenderUnit headThicknessUnit() const
Gets the unit for the head height.
void setArrowWidthUnit(Qgis::RenderUnit unit)
Sets the unit for the arrow width.
void setIsCurved(bool isCurved)
Sets whether it is a curved arrow or a straight one.
bool canCauseArtifactsBetweenAdjacentTiles() const override
Returns true if the symbol layer rendering can cause visible artifacts across a single feature when t...
void setHeadThickness(double thickness)
Sets the arrow head height.
QgsArrowSymbolLayer * clone() const override
Shall be reimplemented by subclasses to create a deep copy of the instance.
void setHeadLengthUnit(Qgis::RenderUnit unit)
Sets the unit for the head length.
void setIsRepeated(bool isRepeated)
Sets whether the arrow is repeated along the line.
QColor color() const override
Returns the "representative" color of the symbol layer.
double arrowStartWidth() const
Gets current arrow start width. Only meaningful for single headed arrows.
void setArrowStartWidthUnitScale(const QgsMapUnitScale &scale)
Sets the scale for the arrow start width.
void setHeadThicknessUnitScale(const QgsMapUnitScale &scale)
Sets the scale for the head height.
void setHeadType(HeadType type)
Sets the head type.
QgsMapUnitScale arrowStartWidthUnitScale() const
Gets the scale for the arrow start width.
double headThickness() const
Gets the current arrow head height.
bool setSubSymbol(QgsSymbol *symbol) override
Sets layer's subsymbol. takes ownership of the passed symbol.
void setArrowWidthUnitScale(const QgsMapUnitScale &scale)
Sets the scale for the arrow width.
static QgsSymbolLayer * create(const QVariantMap &properties=QVariantMap())
Create a new QgsArrowSymbolLayer.
void setColor(const QColor &c) override
Sets the "representative" color for the symbol layer.
ArrowType
Possible arrow types.
double arrowWidth() const
Gets current arrow width.
void stopRender(QgsSymbolRenderContext &context) override
Called after a set of rendering operations has finished on the supplied render context.
QgsMapUnitScale arrowWidthUnitScale() const
Gets the scale for the arrow width.
QVariantMap properties() const override
Should be reimplemented by subclasses to return a string map that contains the configuration informat...
void renderPolyline(const QPolygonF &points, QgsSymbolRenderContext &context) override
Renders the line symbol layer along the line joining points, using the given render context.
void setArrowStartWidthUnit(Qgis::RenderUnit unit)
Sets the unit for the arrow start width.
Qgis::RenderUnit arrowStartWidthUnit() const
Gets the unit for the arrow start width.
QgsMapUnitScale headLengthUnitScale() const
Gets the scale for the head length.
QgsArrowSymbolLayer()
Simple constructor.
bool usesMapUnits() const override
Returns true if the symbol layer has any components which use map unit based sizes.
void setHeadLength(double length)
Sets the arrow head length.
double headLength() const
Gets the current arrow head length.
void setHeadThicknessUnit(Qgis::RenderUnit unit)
Sets the unit for the head height.
QSet< QString > usedAttributes(const QgsRenderContext &context) const override
Returns the set of attributes referenced by the layer.
Single scope for storing variables and functions for use within a QgsExpressionContext.
static const QString EXPR_GEOMETRY_POINT_COUNT
Inbuilt variable name for point count variable.
QgsExpressionContextScope * popScope()
Removes the last scope from the expression context and return it.
static const QString EXPR_GEOMETRY_POINT_NUM
Inbuilt variable name for point number variable.
void appendScope(QgsExpressionContextScope *scope)
Appends a scope to the end of the context.
A fill symbol type, for rendering Polygon and MultiPolygon geometries.
static QgsFillSymbol * createSimple(const QVariantMap &properties)
Create a fill symbol with one symbol layer: SimpleFill with specified properties.
static double distance2D(double x1, double y1, double x2, double y2)
Returns the 2D distance between (x1, y1) and (x2, y2).
Qgis::RenderUnit mOffsetUnit
RenderRingFilter
Options for filtering rings when the line symbol layer is being used to render a polygon's rings.
void setOutputUnit(Qgis::RenderUnit unit) override
Sets the units to use for sizes and widths within the symbol layer.
Qgis::RenderUnit mWidthUnit
void setOffset(double offset)
Sets the line's offset.
RenderRingFilter mRingFilter
void setOffsetUnit(Qgis::RenderUnit unit)
Sets the unit for the line's offset.
void setOffsetMapUnitScale(const QgsMapUnitScale &scale)
Sets the map unit scale for the line's offset.
void setRingFilter(QgsLineSymbolLayer::RenderRingFilter filter)
Sets the line symbol layer's ring filter, which controls which rings are rendered when the line symbo...
double offset() const
Returns the line's offset.
const QgsMapUnitScale & offsetMapUnitScale() const
Returns the map unit scale for the line's offset.
Qgis::RenderUnit offsetUnit() const
Returns the units for the line's offset.
QVariant value(int key, const QgsExpressionContext &context, const QVariant &defaultValue=QVariant()) const override
Returns the calculated value of the property with the specified key from within the collection.
bool isActive(int key) const override
Returns true if the collection contains an active property with the specified key.
Contains information about the context of a rendering operation.
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).
QPainter * painter()
Returns the destination QPainter for the render operation.
QgsExpressionContext & expressionContext()
Gets the expression context.
void setFlag(Qgis::RenderContextFlag flag, bool on=true)
Enable or disable a particular flag (other flags are not affected)
bool renderingStopped() const
Returns true if the rendering operation has been stopped and any ongoing rendering should be canceled...
Qgis::RenderContextFlags flags() const
Returns combination of flags used for rendering.
static QgsArrowSymbolLayer::HeadType decodeArrowHeadType(const QVariant &value, bool *ok=nullptr)
Decodes a value representing an arrow head type.
static QString encodeMapUnitScale(const QgsMapUnitScale &mapUnitScale)
static QgsMapUnitScale decodeMapUnitScale(const QString &str)
static QgsArrowSymbolLayer::ArrowType decodeArrowType(const QVariant &value, bool *ok=nullptr)
Decodes a value representing an arrow type.
@ PropertyArrowStartWidth
Arrow tail start width.
@ PropertyArrowHeadLength
Arrow head length.
@ PropertyArrowHeadThickness
Arrow head thickness.
@ PropertyOffset
Symbol offset.
@ PropertyArrowHeadType
Arrow head type.
@ PropertyArrowType
Arrow type.
@ PropertyArrowWidth
Arrow tail width.
bool shouldRenderUsingSelectionColor(const QgsSymbolRenderContext &context) const
Returns true if the symbol layer should be rendered using the selection color from the render context...
virtual QSet< QString > usedAttributes(const QgsRenderContext &context) const
Returns the set of attributes referenced by the layer.
void copyDataDefinedProperties(QgsSymbolLayer *destLayer) const
Copies all data defined properties of this layer to another symbol layer.
void restoreOldDataDefinedProperties(const QVariantMap &stringMap)
Restores older data defined properties from string map.
void copyPaintEffect(QgsSymbolLayer *destLayer) const
Copies paint effect of this layer to another symbol layer.
QgsPropertyCollection mDataDefinedProperties
QgsPropertyCollection & dataDefinedProperties()
Returns a reference to the symbol layer's property collection, used for data defined overrides.
virtual bool hasDataDefinedProperties() const
Returns true if the symbol layer (or any of its sub-symbols) contains data defined properties.
const QgsFeature * feature() const
Returns the current feature being rendered.
void setOriginalValueVariable(const QVariant &value)
Sets the original value variable value for data defined symbology.
qreal opacity() const
Returns the opacity for the symbol.
QgsRenderContext & renderContext()
Returns a reference to the context's render context.
Abstract base class for all rendered symbols.
Qgis::SymbolType type() const
Returns the symbol's type.
static Q_INVOKABLE Qgis::RenderUnit decodeRenderUnit(const QString &string, bool *ok=nullptr)
Decodes a render unit from a string.
static Q_INVOKABLE QString encodeUnit(Qgis::DistanceUnit unit)
Encodes a distance unit to a string.
static bool isNull(const QVariant &variant)
Returns true if the specified variant should be considered a NULL value.
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
void pathArcTo(QPainterPath &path, QPointF circleCenter, qreal circleRadius, qreal angle_o, qreal angle_d, int direction)
void spiralArcTo(QPainterPath &path, QPointF center, qreal startAngle, qreal startRadius, qreal endAngle, qreal endRadius, int direction)
qreal euclidean_distance(QPointF po, QPointF pd)
QPointF circlePoint(QPointF center, qreal radius, qreal angle)
QPolygonF straightArrow(QPointF po, QPointF pd, qreal startWidth, qreal width, qreal headWidth, qreal headHeight, QgsArrowSymbolLayer::HeadType headType, QgsArrowSymbolLayer::ArrowType arrowType, qreal offset)
bool pointsToCircle(QPointF a, QPointF b, QPointF c, QPointF ¢er, qreal &radius)
Compute the circumscribed circle from three points.
qreal clampAngle(qreal a)
QPolygonF curvedArrow(QPointF po, QPointF pm, QPointF pd, qreal startWidth, qreal width, qreal headWidth, qreal headHeight, QgsArrowSymbolLayer::HeadType headType, QgsArrowSymbolLayer::ArrowType arrowType, qreal offset)
Single variable definition for use within a QgsExpressionContextScope.