mirror of
https://github.com/qgis/QGIS.git
synced 2025-03-03 00:02:25 -05:00
75635dbf0b
in simple line symbol layers New options are: - Align dash pattern to line length: If checked, the dash pattern lengths will be subtely adjusted in order to ensure that when a line is rendered it will end with a complete dash element, instead of a gap element or partial dash element - Tweak dash pattern at sharp corners: If checked, this option dynamically adjusts the dash pattern placement so that sharp corners are represented by a full dash element coming into and out of the sharp corner. It's designed to better represent the underlying geometry while rendering dashed lines, especially for jagged lines
977 lines
28 KiB
Plaintext
977 lines
28 KiB
Plaintext
/************************************************************************
|
|
* This file has been generated automatically from *
|
|
* *
|
|
* src/core/symbology/qgslinesymbollayer.h *
|
|
* *
|
|
* Do not edit manually ! Edit header and run scripts/sipify.pl again *
|
|
************************************************************************/
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class QgsSimpleLineSymbolLayer : QgsLineSymbolLayer
|
|
{
|
|
%Docstring
|
|
A simple line symbol layer, which renders lines using a line in a variety of styles (e.g. solid, dotted, dashed).
|
|
%End
|
|
|
|
%TypeHeaderCode
|
|
#include "qgslinesymbollayer.h"
|
|
%End
|
|
public:
|
|
|
|
QgsSimpleLineSymbolLayer( const QColor &color = DEFAULT_SIMPLELINE_COLOR,
|
|
double width = DEFAULT_SIMPLELINE_WIDTH,
|
|
Qt::PenStyle penStyle = DEFAULT_SIMPLELINE_PENSTYLE );
|
|
%Docstring
|
|
Constructor for QgsSimpleLineSymbolLayer. Creates a simple line
|
|
symbol in the specified ``color``, ``width`` (in millimeters)
|
|
and ``penStyle``.
|
|
%End
|
|
|
|
|
|
static QgsSymbolLayer *create( const QgsStringMap &properties = QgsStringMap() ) /Factory/;
|
|
%Docstring
|
|
Creates a new QgsSimpleLineSymbolLayer, using the settings
|
|
serialized in the ``properties`` map (corresponding to the output from
|
|
:py:func:`QgsSimpleLineSymbolLayer.properties()` ).
|
|
%End
|
|
|
|
static QgsSymbolLayer *createFromSld( QDomElement &element ) /Factory/;
|
|
%Docstring
|
|
Creates a new QgsSimpleLineSymbolLayer from an SLD XML DOM ``element``.
|
|
%End
|
|
|
|
virtual QString layerType() const;
|
|
|
|
virtual void startRender( QgsSymbolRenderContext &context );
|
|
|
|
virtual void stopRender( QgsSymbolRenderContext &context );
|
|
|
|
virtual void renderPolyline( const QPolygonF &points, QgsSymbolRenderContext &context );
|
|
|
|
virtual void renderPolygonStroke( const QPolygonF &points, const QVector<QPolygonF> *rings, QgsSymbolRenderContext &context );
|
|
|
|
virtual QgsStringMap properties() const;
|
|
|
|
virtual QgsSimpleLineSymbolLayer *clone() const /Factory/;
|
|
|
|
virtual void toSld( QDomDocument &doc, QDomElement &element, const QgsStringMap &props ) const;
|
|
|
|
virtual QString ogrFeatureStyle( double mmScaleFactor, double mapUnitScaleFactor ) const;
|
|
|
|
virtual void setOutputUnit( QgsUnitTypes::RenderUnit unit );
|
|
|
|
virtual QgsUnitTypes::RenderUnit outputUnit() const;
|
|
|
|
virtual void setMapUnitScale( const QgsMapUnitScale &scale );
|
|
|
|
virtual QgsMapUnitScale mapUnitScale() const;
|
|
|
|
virtual double estimateMaxBleed( const QgsRenderContext &context ) const;
|
|
|
|
virtual QVector<qreal> dxfCustomDashPattern( QgsUnitTypes::RenderUnit &unit ) const;
|
|
|
|
virtual Qt::PenStyle dxfPenStyle() const;
|
|
|
|
virtual double dxfWidth( const QgsDxfExport &e, QgsSymbolRenderContext &context ) const;
|
|
|
|
virtual double dxfOffset( const QgsDxfExport &e, QgsSymbolRenderContext &context ) const;
|
|
|
|
virtual QColor dxfColor( QgsSymbolRenderContext &context ) const;
|
|
|
|
|
|
Qt::PenStyle penStyle() const;
|
|
%Docstring
|
|
Returns the pen style used to render the line (e.g. solid, dashed, etc).
|
|
|
|
.. seealso:: :py:func:`setPenStyle`
|
|
%End
|
|
|
|
void setPenStyle( Qt::PenStyle style );
|
|
%Docstring
|
|
Sets the pen ``style`` used to render the line (e.g. solid, dashed, etc).
|
|
|
|
.. seealso:: :py:func:`penStyle`
|
|
%End
|
|
|
|
Qt::PenJoinStyle penJoinStyle() const;
|
|
%Docstring
|
|
Returns the pen join style used to render the line (e.g. miter, bevel, round, etc).
|
|
|
|
.. seealso:: :py:func:`setPenJoinStyle`
|
|
%End
|
|
|
|
void setPenJoinStyle( Qt::PenJoinStyle style );
|
|
%Docstring
|
|
Sets the pen join ``style`` used to render the line (e.g. miter, bevel, round, etc).
|
|
|
|
.. seealso:: :py:func:`penJoinStyle`
|
|
%End
|
|
|
|
Qt::PenCapStyle penCapStyle() const;
|
|
%Docstring
|
|
Returns the pen cap style used to render the line (e.g. flat, square, round, etc).
|
|
|
|
.. seealso:: :py:func:`setPenCapStyle`
|
|
%End
|
|
|
|
void setPenCapStyle( Qt::PenCapStyle style );
|
|
%Docstring
|
|
Sets the pen cap ``style`` used to render the line (e.g. flat, square, round, etc).
|
|
|
|
.. seealso:: :py:func:`penCapStyle`
|
|
%End
|
|
|
|
bool useCustomDashPattern() const;
|
|
%Docstring
|
|
Returns ``True`` if the line uses a custom dash pattern.
|
|
|
|
.. seealso:: :py:func:`setUseCustomDashPattern`
|
|
|
|
.. seealso:: :py:func:`customDashPatternUnit`
|
|
|
|
.. seealso:: :py:func:`customDashVector`
|
|
%End
|
|
|
|
void setUseCustomDashPattern( bool b );
|
|
%Docstring
|
|
Sets whether the line uses a custom dash pattern.
|
|
|
|
.. seealso:: :py:func:`useCustomDashPattern`
|
|
|
|
.. seealso:: :py:func:`setCustomDashPatternUnit`
|
|
|
|
.. seealso:: :py:func:`setCustomDashVector`
|
|
%End
|
|
|
|
void setCustomDashPatternUnit( QgsUnitTypes::RenderUnit unit );
|
|
%Docstring
|
|
Sets the ``unit`` for lengths used in the custom dash pattern.
|
|
|
|
.. seealso:: :py:func:`customDashPatternUnit`
|
|
%End
|
|
|
|
QgsUnitTypes::RenderUnit customDashPatternUnit() const;
|
|
%Docstring
|
|
Returns the units for lengths used in the custom dash pattern.
|
|
|
|
.. seealso:: :py:func:`setCustomDashPatternUnit`
|
|
%End
|
|
|
|
const QgsMapUnitScale &customDashPatternMapUnitScale() const;
|
|
%Docstring
|
|
Returns the map unit scale for lengths used in the custom dash pattern.
|
|
|
|
.. seealso:: :py:func:`setCustomDashPatternMapUnitScale`
|
|
%End
|
|
|
|
void setCustomDashPatternMapUnitScale( const QgsMapUnitScale &scale );
|
|
%Docstring
|
|
Sets the map unit ``scale`` for lengths used in the custom dash pattern.
|
|
|
|
.. seealso:: :py:func:`customDashPatternMapUnitScale`
|
|
%End
|
|
|
|
QVector<qreal> customDashVector() const;
|
|
%Docstring
|
|
Returns the custom dash vector, which is the pattern of alternating drawn/skipped lengths
|
|
used while rendering a custom dash pattern.
|
|
|
|
Units for the vector are specified by :py:func:`~QgsSimpleLineSymbolLayer.customDashPatternUnit`
|
|
|
|
This setting is only used when :py:func:`~QgsSimpleLineSymbolLayer.useCustomDashPattern` returns ``True``.
|
|
|
|
.. seealso:: :py:func:`setCustomDashVector`
|
|
|
|
.. seealso:: :py:func:`customDashPatternUnit`
|
|
|
|
.. seealso:: :py:func:`useCustomDashPattern`
|
|
%End
|
|
|
|
void setCustomDashVector( const QVector<qreal> &vector );
|
|
%Docstring
|
|
Sets the custom dash ``vector``, which is the pattern of alternating drawn/skipped lengths
|
|
used while rendering a custom dash pattern.
|
|
|
|
Units for the vector are specified by :py:func:`~QgsSimpleLineSymbolLayer.customDashPatternUnit`
|
|
|
|
This setting is only used when :py:func:`~QgsSimpleLineSymbolLayer.useCustomDashPattern` returns ``True``.
|
|
|
|
.. seealso:: :py:func:`customDashVector`
|
|
|
|
.. seealso:: :py:func:`setCustomDashPatternUnit`
|
|
|
|
.. seealso:: :py:func:`setUseCustomDashPattern`
|
|
%End
|
|
|
|
double dashPatternOffset() const;
|
|
%Docstring
|
|
Returns the dash pattern offset, which dictates how far along the dash pattern
|
|
the pattern should start rendering at.
|
|
|
|
Offset units can be retrieved by calling :py:func:`~QgsSimpleLineSymbolLayer.dashPatternOffsetUnit`.
|
|
|
|
.. seealso:: :py:func:`setDashPatternOffset`
|
|
|
|
.. seealso:: :py:func:`dashPatternOffsetUnit`
|
|
|
|
.. seealso:: :py:func:`dashPatternOffsetMapUnitScale`
|
|
|
|
.. versionadded:: 3.16
|
|
%End
|
|
|
|
void setDashPatternOffset( double offset );
|
|
%Docstring
|
|
Sets the dash pattern ``offset``, which dictates how far along the dash pattern
|
|
the pattern should start rendering at.
|
|
|
|
Offset units are set via :py:func:`~QgsSimpleLineSymbolLayer.setDashPatternOffsetUnit`.
|
|
|
|
.. seealso:: :py:func:`dashPatternOffset`
|
|
|
|
.. seealso:: :py:func:`setDashPatternOffsetUnit`
|
|
|
|
.. seealso:: :py:func:`setDashPatternOffsetMapUnitScale`
|
|
|
|
.. versionadded:: 3.16
|
|
%End
|
|
|
|
void setDashPatternOffsetUnit( QgsUnitTypes::RenderUnit unit );
|
|
%Docstring
|
|
Sets the ``unit`` for the dash pattern offset.
|
|
|
|
.. seealso:: :py:func:`dashPatternOffsetUnit`
|
|
|
|
.. seealso:: :py:func:`setDashPatternOffset`
|
|
|
|
.. seealso:: :py:func:`setDashPatternOffsetMapUnitScale`
|
|
|
|
.. versionadded:: 3.16
|
|
%End
|
|
|
|
QgsUnitTypes::RenderUnit dashPatternOffsetUnit() const;
|
|
%Docstring
|
|
Returns the units for the dash pattern offset.
|
|
|
|
.. seealso:: :py:func:`setDashPatternOffsetUnit`
|
|
|
|
.. seealso:: :py:func:`dashPatternOffset`
|
|
|
|
.. seealso:: :py:func:`dashPatternOffsetMapUnitScale`
|
|
|
|
.. versionadded:: 3.16
|
|
%End
|
|
|
|
const QgsMapUnitScale &dashPatternOffsetMapUnitScale() const;
|
|
%Docstring
|
|
Returns the map unit scale the dash pattern offset value.
|
|
|
|
.. seealso:: :py:func:`setDashPatternOffsetMapUnitScale`
|
|
|
|
.. seealso:: :py:func:`dashPatternOffsetUnit`
|
|
|
|
.. seealso:: :py:func:`dashPatternOffset`
|
|
|
|
.. versionadded:: 3.16
|
|
%End
|
|
|
|
void setDashPatternOffsetMapUnitScale( const QgsMapUnitScale &scale );
|
|
%Docstring
|
|
Sets the map unit ``scale`` for the dash pattern offset.
|
|
|
|
.. seealso:: :py:func:`dashPatternOffsetMapUnitScale`
|
|
|
|
.. seealso:: :py:func:`setDashPatternOffset`
|
|
|
|
.. seealso:: :py:func:`setDashPatternOffsetUnit`
|
|
|
|
.. versionadded:: 3.16
|
|
%End
|
|
|
|
bool drawInsidePolygon() const;
|
|
%Docstring
|
|
Returns ``True`` if the line should only be drawn inside polygons, and any portion
|
|
of the line which falls outside the polygon should be clipped away.
|
|
|
|
This setting only has an effect when the line symbol is being
|
|
used to render polygon rings.
|
|
|
|
.. seealso:: :py:func:`setDrawInsidePolygon`
|
|
%End
|
|
|
|
void setDrawInsidePolygon( bool drawInsidePolygon );
|
|
%Docstring
|
|
Sets whether the line should only be drawn inside polygons, and any portion
|
|
of the line which falls outside the polygon should be clipped away.
|
|
|
|
This setting only has an effect when the line symbol is being
|
|
used to render polygon rings.
|
|
|
|
.. seealso:: :py:func:`drawInsidePolygon`
|
|
%End
|
|
|
|
bool alignDashPattern() const;
|
|
%Docstring
|
|
Returns ``True`` if dash patterns should be aligned to the start and end of lines, by
|
|
applying subtle tweaks to the pattern sizing in order to ensure that the end of
|
|
a line is represented by a complete dash element.
|
|
|
|
.. seealso:: :py:func:`setAlignDashPattern`
|
|
|
|
.. seealso:: :py:func:`tweakDashPatternOnCorners`
|
|
|
|
.. versionadded:: 3.16
|
|
%End
|
|
|
|
void setAlignDashPattern( bool enabled );
|
|
%Docstring
|
|
Sets whether dash patterns should be aligned to the start and end of lines, by
|
|
applying subtle tweaks to the pattern sizing in order to ensure that the end of
|
|
a line is represented by a complete dash element.
|
|
|
|
.. seealso:: :py:func:`alignDashPattern`
|
|
|
|
.. seealso:: :py:func:`setTweakDashPatternOnCorners`
|
|
|
|
.. versionadded:: 3.16
|
|
%End
|
|
|
|
bool tweakDashPatternOnCorners() const;
|
|
%Docstring
|
|
Returns ``True`` if dash patterns tweaks should be applied on sharp corners, to ensure
|
|
that a double-length dash is drawn running into and out of the corner.
|
|
|
|
.. note::
|
|
|
|
This setting is only applied if :py:func:`~QgsSimpleLineSymbolLayer.alignDashPattern` is ``True``.
|
|
|
|
.. seealso:: :py:func:`setTweakDashPatternOnCorners`
|
|
|
|
.. seealso:: :py:func:`alignDashPattern`
|
|
|
|
.. versionadded:: 3.16
|
|
%End
|
|
|
|
void setTweakDashPatternOnCorners( bool enabled );
|
|
%Docstring
|
|
Sets whether dash patterns tweaks should be applied on sharp corners, to ensure
|
|
that a double-length dash is drawn running into and out of the corner.
|
|
|
|
.. note::
|
|
|
|
This setting is only applied if :py:func:`~QgsSimpleLineSymbolLayer.alignDashPattern` is ``True``.
|
|
|
|
.. seealso:: :py:func:`tweakDashPatternOnCorners`
|
|
|
|
.. seealso:: :py:func:`setAlignDashPattern`
|
|
|
|
.. versionadded:: 3.16
|
|
%End
|
|
|
|
};
|
|
|
|
|
|
|
|
class QgsTemplatedLineSymbolLayerBase : QgsLineSymbolLayer
|
|
{
|
|
%Docstring
|
|
|
|
Base class for templated line symbols, e.g. line symbols which draw markers or hash
|
|
lines at intervals along the line feature.
|
|
|
|
.. versionadded:: 3.8
|
|
%End
|
|
|
|
%TypeHeaderCode
|
|
#include "qgslinesymbollayer.h"
|
|
%End
|
|
public:
|
|
|
|
enum Placement
|
|
{
|
|
Interval,
|
|
Vertex,
|
|
LastVertex,
|
|
FirstVertex,
|
|
CentralPoint,
|
|
CurvePoint,
|
|
SegmentCenter,
|
|
};
|
|
|
|
QgsTemplatedLineSymbolLayerBase( bool rotateSymbol = true,
|
|
double interval = 3 );
|
|
%Docstring
|
|
Constructor for QgsTemplatedLineSymbolLayerBase. Creates a template
|
|
line placed at the specified ``interval`` (in millimeters).
|
|
|
|
The ``rotateSymbol`` argument specifies whether individual symbols
|
|
should be rotated to match the line segment alignment.
|
|
%End
|
|
|
|
bool rotateSymbols() const;
|
|
%Docstring
|
|
Returns ``True`` if the repeating symbols be rotated to match their line segment orientation.
|
|
|
|
.. seealso:: :py:func:`setRotateSymbols`
|
|
%End
|
|
|
|
void setRotateSymbols( bool rotate );
|
|
%Docstring
|
|
Sets whether the repeating symbols should be rotated to match their line segment orientation.
|
|
|
|
.. seealso:: :py:func:`rotateSymbols`
|
|
%End
|
|
|
|
double interval() const;
|
|
%Docstring
|
|
Returns the interval between individual symbols. Units are specified through :py:func:`~QgsTemplatedLineSymbolLayerBase.intervalUnits`.
|
|
|
|
.. seealso:: :py:func:`setInterval`
|
|
|
|
.. seealso:: :py:func:`intervalUnit`
|
|
%End
|
|
|
|
void setInterval( double interval );
|
|
%Docstring
|
|
Sets the interval between individual symbols.
|
|
|
|
:param interval: interval size. Units are specified through :py:func:`~QgsTemplatedLineSymbolLayerBase.setIntervalUnit`
|
|
|
|
.. seealso:: :py:func:`interval`
|
|
|
|
.. seealso:: :py:func:`setIntervalUnit`
|
|
%End
|
|
|
|
void setIntervalUnit( QgsUnitTypes::RenderUnit unit );
|
|
%Docstring
|
|
Sets the units for the interval between symbols.
|
|
|
|
:param unit: interval units
|
|
|
|
.. seealso:: :py:func:`intervalUnit`
|
|
|
|
.. seealso:: :py:func:`setInterval`
|
|
%End
|
|
|
|
QgsUnitTypes::RenderUnit intervalUnit() const;
|
|
%Docstring
|
|
Returns the units for the interval between symbols.
|
|
|
|
.. seealso:: :py:func:`setIntervalUnit`
|
|
|
|
.. seealso:: :py:func:`interval`
|
|
%End
|
|
|
|
void setIntervalMapUnitScale( const QgsMapUnitScale &scale );
|
|
%Docstring
|
|
Sets the map unit ``scale`` for the interval between symbols.
|
|
|
|
.. seealso:: :py:func:`intervalMapUnitScale`
|
|
|
|
.. seealso:: :py:func:`setIntervalUnit`
|
|
|
|
.. seealso:: :py:func:`setInterval`
|
|
%End
|
|
|
|
const QgsMapUnitScale &intervalMapUnitScale() const;
|
|
%Docstring
|
|
Returns the map unit scale for the interval between symbols.
|
|
|
|
.. seealso:: :py:func:`setIntervalMapUnitScale`
|
|
|
|
.. seealso:: :py:func:`intervalUnit`
|
|
|
|
.. seealso:: :py:func:`interval`
|
|
%End
|
|
|
|
Placement placement() const;
|
|
%Docstring
|
|
Returns the placement of the symbols.
|
|
|
|
.. seealso:: :py:func:`setPlacement`
|
|
%End
|
|
|
|
void setPlacement( Placement placement );
|
|
%Docstring
|
|
Sets the ``placement`` of the symbols.
|
|
|
|
.. seealso:: :py:func:`placement`
|
|
%End
|
|
|
|
double offsetAlongLine() const;
|
|
%Docstring
|
|
Returns the offset along the line for the symbol placement. For Interval placements, this is the distance
|
|
between the start of the line and the first symbol. For FirstVertex and LastVertex placements, this is the
|
|
distance between the symbol and the start of the line or the end of the line respectively.
|
|
This setting has no effect for Vertex or CentralPoint placements.
|
|
|
|
:return: The offset along the line. The unit for the offset is retrievable via offsetAlongLineUnit.
|
|
|
|
.. seealso:: :py:func:`setOffsetAlongLine`
|
|
|
|
.. seealso:: :py:func:`offsetAlongLineUnit`
|
|
|
|
.. seealso:: :py:func:`placement`
|
|
%End
|
|
|
|
void setOffsetAlongLine( double offsetAlongLine );
|
|
%Docstring
|
|
Sets the the offset along the line for the symbol placement. For Interval placements, this is the distance
|
|
between the start of the line and the first symbol. For FirstVertex and LastVertex placements, this is the
|
|
distance between the symbol and the start of the line or the end of the line respectively.
|
|
This setting has no effect for Vertex or CentralPoint placements.
|
|
|
|
:param offsetAlongLine: Distance to offset markers along the line. The offset
|
|
unit is set via setOffsetAlongLineUnit.
|
|
|
|
.. seealso:: :py:func:`offsetAlongLine`
|
|
|
|
.. seealso:: :py:func:`setOffsetAlongLineUnit`
|
|
|
|
.. seealso:: :py:func:`setPlacement`
|
|
%End
|
|
|
|
QgsUnitTypes::RenderUnit offsetAlongLineUnit() const;
|
|
%Docstring
|
|
Returns the unit used for calculating the offset along line for symbols.
|
|
|
|
:return: Offset along line unit type.
|
|
|
|
.. seealso:: :py:func:`setOffsetAlongLineUnit`
|
|
|
|
.. seealso:: :py:func:`offsetAlongLine`
|
|
%End
|
|
|
|
void setOffsetAlongLineUnit( QgsUnitTypes::RenderUnit unit );
|
|
%Docstring
|
|
Sets the unit used for calculating the offset along line for symbols.
|
|
|
|
:param unit: Offset along line unit type.
|
|
|
|
.. seealso:: :py:func:`offsetAlongLineUnit`
|
|
|
|
.. seealso:: :py:func:`setOffsetAlongLine`
|
|
%End
|
|
|
|
const QgsMapUnitScale &offsetAlongLineMapUnitScale() const;
|
|
%Docstring
|
|
Returns the map unit scale used for calculating the offset in map units along line for symbols.
|
|
|
|
.. seealso:: :py:func:`setOffsetAlongLineMapUnitScale`
|
|
%End
|
|
|
|
void setOffsetAlongLineMapUnitScale( const QgsMapUnitScale &scale );
|
|
%Docstring
|
|
Sets the map unit ``scale`` used for calculating the offset in map units along line for symbols.
|
|
|
|
.. seealso:: :py:func:`offsetAlongLineMapUnitScale`
|
|
%End
|
|
|
|
double averageAngleLength() const;
|
|
%Docstring
|
|
Returns the length of line over which the line's direction is averaged when
|
|
calculating individual symbol angles. Longer lengths smooth out angles from jagged lines to a greater extent.
|
|
|
|
Units are retrieved through :py:func:`~QgsTemplatedLineSymbolLayerBase.averageAngleUnit`
|
|
|
|
.. seealso:: :py:func:`setAverageAngleLength`
|
|
|
|
.. seealso:: :py:func:`averageAngleUnit`
|
|
|
|
.. seealso:: :py:func:`averageAngleMapUnitScale`
|
|
%End
|
|
|
|
void setAverageAngleLength( double length );
|
|
%Docstring
|
|
Sets the ``length`` of line over which the line's direction is averaged when
|
|
calculating individual symbol angles. Longer lengths smooth out angles from jagged lines to a greater extent.
|
|
|
|
Units are set through :py:func:`~QgsTemplatedLineSymbolLayerBase.setAverageAngleUnit`
|
|
|
|
.. seealso:: :py:func:`averageAngleLength`
|
|
|
|
.. seealso:: :py:func:`setAverageAngleUnit`
|
|
|
|
.. seealso:: :py:func:`setAverageAngleMapUnitScale`
|
|
%End
|
|
|
|
void setAverageAngleUnit( QgsUnitTypes::RenderUnit unit );
|
|
%Docstring
|
|
Sets the ``unit`` for the length over which the line's direction is averaged when
|
|
calculating individual symbol angles.
|
|
|
|
.. seealso:: :py:func:`averageAngleUnit`
|
|
|
|
.. seealso:: :py:func:`setAverageAngleLength`
|
|
|
|
.. seealso:: :py:func:`setAverageAngleMapUnitScale`
|
|
%End
|
|
|
|
QgsUnitTypes::RenderUnit averageAngleUnit() const;
|
|
%Docstring
|
|
Returns the unit for the length over which the line's direction is averaged when
|
|
calculating individual symbol angles.
|
|
|
|
.. seealso:: :py:func:`setAverageAngleUnit`
|
|
|
|
.. seealso:: :py:func:`averageAngleLength`
|
|
|
|
.. seealso:: :py:func:`averageAngleMapUnitScale`
|
|
%End
|
|
|
|
void setAverageAngleMapUnitScale( const QgsMapUnitScale &scale );
|
|
%Docstring
|
|
Sets the map unit ``scale`` for the length over which the line's direction is averaged when
|
|
calculating individual symbol angles.
|
|
|
|
.. seealso:: :py:func:`averageAngleMapUnitScale`
|
|
|
|
.. seealso:: :py:func:`setAverageAngleLength`
|
|
|
|
.. seealso:: :py:func:`setAverageAngleUnit`
|
|
%End
|
|
|
|
const QgsMapUnitScale &averageAngleMapUnitScale() const;
|
|
%Docstring
|
|
Returns the map unit scale for the length over which the line's direction is averaged when
|
|
calculating individual symbol angles.
|
|
|
|
.. seealso:: :py:func:`setAverageAngleMapUnitScale`
|
|
|
|
.. seealso:: :py:func:`averageAngleLength`
|
|
|
|
.. seealso:: :py:func:`averageAngleUnit`
|
|
%End
|
|
|
|
virtual void renderPolyline( const QPolygonF &points, QgsSymbolRenderContext &context ) ${SIP_FINAL};
|
|
|
|
virtual void renderPolygonStroke( const QPolygonF &points, const QVector<QPolygonF> *rings, QgsSymbolRenderContext &context ) ${SIP_FINAL};
|
|
|
|
virtual QgsUnitTypes::RenderUnit outputUnit() const ${SIP_FINAL};
|
|
|
|
virtual void setMapUnitScale( const QgsMapUnitScale &scale ) ${SIP_FINAL};
|
|
|
|
virtual QgsMapUnitScale mapUnitScale() const ${SIP_FINAL};
|
|
|
|
virtual QgsStringMap properties() const;
|
|
|
|
|
|
protected:
|
|
|
|
virtual void setSymbolLineAngle( double angle ) = 0;
|
|
%Docstring
|
|
Sets the line ``angle`` modification for the symbol's angle. This angle is added to
|
|
the symbol's rotation and data defined rotation before rendering the symbol, and
|
|
is used for orienting symbols to match the line's angle.
|
|
|
|
:param angle: Angle in degrees, valid values are between 0 and 360
|
|
%End
|
|
|
|
virtual double symbolAngle() const = 0;
|
|
%Docstring
|
|
Returns the symbol's current angle, in degrees clockwise.
|
|
%End
|
|
|
|
virtual void setSymbolAngle( double angle ) = 0;
|
|
%Docstring
|
|
Sets the symbol's ``angle``, in degrees clockwise.
|
|
%End
|
|
|
|
virtual void renderSymbol( const QPointF &point, const QgsFeature *feature, QgsRenderContext &context, int layer = -1, bool selected = false ) = 0;
|
|
%Docstring
|
|
Renders the templated symbol at the specified ``point``, using the given render ``context``.
|
|
|
|
The ``feature`` argument is used to pass the feature currently being rendered (when available).
|
|
|
|
If only a single symbol layer from the symbol should be rendered, it should be specified
|
|
in the ``layer`` argument. A ``layer`` of -1 indicates that all symbol layers should be
|
|
rendered.
|
|
|
|
If ``selected`` is true then the symbol will be drawn using the "selected feature"
|
|
style and colors instead of the symbol's normal style.
|
|
%End
|
|
|
|
void copyTemplateSymbolProperties( QgsTemplatedLineSymbolLayerBase *destLayer ) const;
|
|
%Docstring
|
|
Copies all common properties of this layer to another templated symbol layer.
|
|
%End
|
|
|
|
static void setCommonProperties( QgsTemplatedLineSymbolLayerBase *destLayer, const QgsStringMap &properties );
|
|
%Docstring
|
|
Sets all common symbol properties in the ``destLayer``, using the settings
|
|
serialized in the ``properties`` map.
|
|
%End
|
|
|
|
};
|
|
|
|
class QgsMarkerLineSymbolLayer : QgsTemplatedLineSymbolLayerBase
|
|
{
|
|
%Docstring
|
|
Line symbol layer type which draws repeating marker symbols along a line feature.
|
|
%End
|
|
|
|
%TypeHeaderCode
|
|
#include "qgslinesymbollayer.h"
|
|
%End
|
|
public:
|
|
|
|
QgsMarkerLineSymbolLayer( bool rotateMarker = DEFAULT_MARKERLINE_ROTATE,
|
|
double interval = DEFAULT_MARKERLINE_INTERVAL );
|
|
%Docstring
|
|
Constructor for QgsMarkerLineSymbolLayer. Creates a marker line
|
|
with a default marker symbol, placed at the specified ``interval`` (in millimeters).
|
|
|
|
The ``rotateMarker`` argument specifies whether individual marker symbols
|
|
should be rotated to match the line segment alignment.
|
|
%End
|
|
|
|
|
|
static QgsSymbolLayer *create( const QgsStringMap &properties = QgsStringMap() ) /Factory/;
|
|
%Docstring
|
|
Creates a new QgsMarkerLineSymbolLayer, using the settings
|
|
serialized in the ``properties`` map (corresponding to the output from
|
|
:py:func:`QgsMarkerLineSymbolLayer.properties()` ).
|
|
%End
|
|
|
|
static QgsSymbolLayer *createFromSld( QDomElement &element ) /Factory/;
|
|
%Docstring
|
|
Creates a new QgsMarkerLineSymbolLayer from an SLD XML DOM ``element``.
|
|
%End
|
|
|
|
|
|
virtual QString layerType() const;
|
|
|
|
virtual void startRender( QgsSymbolRenderContext &context );
|
|
|
|
virtual void stopRender( QgsSymbolRenderContext &context );
|
|
|
|
virtual QgsMarkerLineSymbolLayer *clone() const /Factory/;
|
|
|
|
virtual void toSld( QDomDocument &doc, QDomElement &element, const QgsStringMap &props ) const;
|
|
|
|
virtual void setColor( const QColor &color );
|
|
|
|
virtual QColor color() const;
|
|
|
|
virtual QgsSymbol *subSymbol();
|
|
|
|
virtual bool setSubSymbol( QgsSymbol *symbol /Transfer/ );
|
|
|
|
virtual void setWidth( double width );
|
|
|
|
virtual double width() const;
|
|
|
|
virtual double width( const QgsRenderContext &context ) const;
|
|
|
|
virtual double estimateMaxBleed( const QgsRenderContext &context ) const;
|
|
|
|
virtual void setOutputUnit( QgsUnitTypes::RenderUnit unit );
|
|
|
|
virtual QSet<QString> usedAttributes( const QgsRenderContext &context ) const;
|
|
|
|
virtual bool hasDataDefinedProperties() const;
|
|
|
|
virtual void setDataDefinedProperty( QgsSymbolLayer::Property key, const QgsProperty &property );
|
|
|
|
|
|
bool rotateMarker() const /Deprecated/;
|
|
%Docstring
|
|
Shall the marker be rotated.
|
|
|
|
:return: ``True`` if the marker should be rotated.
|
|
|
|
.. deprecated::
|
|
Use rotateSymbols() instead.
|
|
%End
|
|
|
|
void setRotateMarker( bool rotate ) /Deprecated/;
|
|
%Docstring
|
|
Shall the marker be rotated.
|
|
|
|
.. deprecated::
|
|
Use setRotateSymbols() instead.
|
|
%End
|
|
|
|
protected:
|
|
|
|
|
|
virtual void setSymbolLineAngle( double angle );
|
|
|
|
virtual double symbolAngle() const;
|
|
|
|
virtual void setSymbolAngle( double angle );
|
|
|
|
virtual void renderSymbol( const QPointF &point, const QgsFeature *feature, QgsRenderContext &context, int layer = -1, bool selected = false );
|
|
|
|
|
|
private:
|
|
QgsMarkerLineSymbolLayer( const QgsMarkerLineSymbolLayer &other );
|
|
};
|
|
|
|
|
|
class QgsHashedLineSymbolLayer : QgsTemplatedLineSymbolLayerBase
|
|
{
|
|
%Docstring
|
|
|
|
Line symbol layer type which draws repeating line sections along a line feature.
|
|
|
|
.. versionadded:: 3.8
|
|
%End
|
|
|
|
%TypeHeaderCode
|
|
#include "qgslinesymbollayer.h"
|
|
%End
|
|
public:
|
|
|
|
QgsHashedLineSymbolLayer( bool rotateSymbol = true,
|
|
double interval = 3 );
|
|
%Docstring
|
|
Constructor for QgsHashedLineSymbolLayer. Creates a line
|
|
with a default hash symbol, placed at the specified ``interval`` (in millimeters).
|
|
|
|
The ``rotateSymbol`` argument specifies whether individual hash symbols
|
|
should be rotated to match the line segment alignment.
|
|
%End
|
|
|
|
static QgsSymbolLayer *create( const QgsStringMap &properties = QgsStringMap() ) /Factory/;
|
|
%Docstring
|
|
Creates a new QgsHashedLineSymbolLayer, using the settings
|
|
serialized in the ``properties`` map (corresponding to the output from
|
|
:py:func:`QgsHashedLineSymbolLayer.properties()` ).
|
|
%End
|
|
|
|
virtual QString layerType() const;
|
|
|
|
virtual void startRender( QgsSymbolRenderContext &context );
|
|
|
|
virtual void stopRender( QgsSymbolRenderContext &context );
|
|
|
|
virtual QgsStringMap properties() const;
|
|
|
|
virtual QgsHashedLineSymbolLayer *clone() const /Factory/;
|
|
|
|
virtual void setColor( const QColor &color );
|
|
|
|
virtual QColor color() const;
|
|
|
|
virtual QgsSymbol *subSymbol();
|
|
|
|
virtual bool setSubSymbol( QgsSymbol *symbol /Transfer/ );
|
|
|
|
virtual void setWidth( double width );
|
|
|
|
virtual double width() const;
|
|
|
|
virtual double width( const QgsRenderContext &context ) const;
|
|
|
|
virtual double estimateMaxBleed( const QgsRenderContext &context ) const;
|
|
|
|
virtual void setOutputUnit( QgsUnitTypes::RenderUnit unit );
|
|
|
|
virtual QSet<QString> usedAttributes( const QgsRenderContext &context ) const;
|
|
|
|
virtual bool hasDataDefinedProperties() const;
|
|
|
|
virtual void setDataDefinedProperty( QgsSymbolLayer::Property key, const QgsProperty &property );
|
|
|
|
|
|
double hashAngle() const;
|
|
%Docstring
|
|
Returns the angle to use when drawing the hashed lines sections, in degrees clockwise.
|
|
|
|
.. seealso:: :py:func:`setHashAngle`
|
|
%End
|
|
|
|
void setHashAngle( double angle );
|
|
%Docstring
|
|
Sets the ``angle`` to use when drawing the hashed lines sections, in degrees clockwise.
|
|
|
|
.. seealso:: :py:func:`hashAngle`
|
|
%End
|
|
|
|
double hashLength() const;
|
|
%Docstring
|
|
Returns the length of hash symbols. Units are specified through :py:func:`~QgsHashedLineSymbolLayer.hashLengthUnits`.
|
|
|
|
.. seealso:: :py:func:`setHashLength`
|
|
|
|
.. seealso:: :py:func:`hashLengthUnit`
|
|
%End
|
|
|
|
void setHashLength( double length );
|
|
%Docstring
|
|
Sets the ``length`` of hash symbols. Units are specified through :py:func:`~QgsHashedLineSymbolLayer.setHashLengthUnit`
|
|
|
|
.. seealso:: :py:func:`hashLength`
|
|
|
|
.. seealso:: :py:func:`setHashLengthUnit`
|
|
%End
|
|
|
|
void setHashLengthUnit( QgsUnitTypes::RenderUnit unit );
|
|
%Docstring
|
|
Sets the ``unit`` for the length of hash symbols.
|
|
|
|
.. seealso:: :py:func:`hashLengthUnit`
|
|
|
|
.. seealso:: :py:func:`setHashLength`
|
|
%End
|
|
|
|
QgsUnitTypes::RenderUnit hashLengthUnit() const;
|
|
%Docstring
|
|
Returns the units for the length of hash symbols.
|
|
|
|
.. seealso:: :py:func:`setHashLengthUnit`
|
|
|
|
.. seealso:: :py:func:`hashLength`
|
|
%End
|
|
|
|
void setHashLengthMapUnitScale( const QgsMapUnitScale &scale );
|
|
%Docstring
|
|
Sets the map unit ``scale`` for the hash length.
|
|
|
|
.. seealso:: :py:func:`hashLengthMapUnitScale`
|
|
|
|
.. seealso:: :py:func:`setHashLengthUnit`
|
|
|
|
.. seealso:: :py:func:`setHashLength`
|
|
%End
|
|
|
|
const QgsMapUnitScale &hashLengthMapUnitScale() const;
|
|
%Docstring
|
|
Returns the map unit scale for the hash length.
|
|
|
|
.. seealso:: :py:func:`setHashLengthMapUnitScale`
|
|
|
|
.. seealso:: :py:func:`hashLengthUnit`
|
|
|
|
.. seealso:: :py:func:`hashLength`
|
|
%End
|
|
|
|
protected:
|
|
|
|
virtual void setSymbolLineAngle( double angle );
|
|
|
|
virtual double symbolAngle() const;
|
|
|
|
virtual void setSymbolAngle( double angle );
|
|
|
|
virtual void renderSymbol( const QPointF &point, const QgsFeature *feature, QgsRenderContext &context, int layer = -1, bool selected = false );
|
|
|
|
|
|
private:
|
|
QgsHashedLineSymbolLayer( const QgsHashedLineSymbolLayer &other );
|
|
};
|
|
|
|
|
|
|
|
/************************************************************************
|
|
* This file has been generated automatically from *
|
|
* *
|
|
* src/core/symbology/qgslinesymbollayer.h *
|
|
* *
|
|
* Do not edit manually ! Edit header and run scripts/sipify.pl again *
|
|
************************************************************************/
|