mirror of
https://github.com/qgis/QGIS.git
synced 2025-03-10 00:13:55 -04:00
73d0ced5df
This new option, available under the "Advanced" button for fill symbols, allows forcing rendered polygons to follow the standard "right hand rule" for ring orientation (where exterior ring is clockwise, and interior rings are all counter-clockwise). The orientation fix is applied while rendering only, and the original feature geometry is unchanged. This allows for creation of fill symbols with consistent appearance, regardless of the dataset being rendered and the ring orientation of individual features. Refs #12652
970 lines
27 KiB
Plaintext
970 lines
27 KiB
Plaintext
/************************************************************************
|
|
* This file has been generated automatically from *
|
|
* *
|
|
* src/core/symbology/qgssymbol.h *
|
|
* *
|
|
* Do not edit manually ! Edit header and run scripts/sipify.pl again *
|
|
************************************************************************/
|
|
|
|
|
|
|
|
|
|
|
|
typedef QList<QgsSymbolLayer *> QgsSymbolLayerList;
|
|
|
|
class QgsSymbol
|
|
{
|
|
%Docstring
|
|
|
|
Abstract base class for all rendered symbols.
|
|
%End
|
|
|
|
%TypeHeaderCode
|
|
#include "qgssymbol.h"
|
|
%End
|
|
%ConvertToSubClassCode
|
|
switch ( sipCpp->type() )
|
|
{
|
|
case QgsSymbol::Marker: sipType = sipType_QgsMarkerSymbol; break;
|
|
case QgsSymbol::Line: sipType = sipType_QgsLineSymbol; break;
|
|
case QgsSymbol::Fill: sipType = sipType_QgsFillSymbol; break;
|
|
default: sipType = 0; break;
|
|
}
|
|
%End
|
|
public:
|
|
|
|
enum SymbolType
|
|
{
|
|
Marker,
|
|
Line,
|
|
Fill,
|
|
Hybrid
|
|
};
|
|
|
|
enum ScaleMethod
|
|
{
|
|
ScaleArea,
|
|
ScaleDiameter
|
|
};
|
|
|
|
|
|
enum RenderHint
|
|
{
|
|
DynamicRotation,
|
|
};
|
|
typedef QFlags<QgsSymbol::RenderHint> RenderHints;
|
|
|
|
|
|
virtual ~QgsSymbol();
|
|
|
|
static QgsSymbol *defaultSymbol( QgsWkbTypes::GeometryType geomType ) /Factory/;
|
|
%Docstring
|
|
Returns a new default symbol for the specified geometry type.
|
|
|
|
The caller takes ownership of the returned object.
|
|
%End
|
|
|
|
SymbolType type() const;
|
|
%Docstring
|
|
Returns the symbol's type.
|
|
%End
|
|
|
|
|
|
QgsSymbolLayerList symbolLayers();
|
|
%Docstring
|
|
Returns the list of symbol layers contained in the symbol.
|
|
|
|
:return: symbol layers list
|
|
|
|
.. seealso:: :py:func:`symbolLayer`
|
|
|
|
.. seealso:: :py:func:`symbolLayerCount`
|
|
|
|
.. versionadded:: 2.7
|
|
%End
|
|
|
|
QgsSymbolLayer *symbolLayer( int layer );
|
|
%Docstring
|
|
Returns a specific symbol layer contained in the symbol.
|
|
|
|
:param layer: layer number
|
|
|
|
:return: corresponding symbol layer
|
|
|
|
.. seealso:: :py:func:`symbolLayers`
|
|
|
|
.. seealso:: :py:func:`symbolLayerCount`
|
|
|
|
.. versionadded:: 2.7
|
|
%End
|
|
|
|
int symbolLayerCount() const;
|
|
%Docstring
|
|
Returns the total number of symbol layers contained in the symbol.
|
|
|
|
:return: count of symbol layers
|
|
|
|
.. seealso:: :py:func:`symbolLayers`
|
|
|
|
.. seealso:: :py:func:`symbolLayer`
|
|
|
|
.. versionadded:: 2.7
|
|
%End
|
|
|
|
bool insertSymbolLayer( int index, QgsSymbolLayer *layer /Transfer/ );
|
|
%Docstring
|
|
Inserts a symbol ``layer`` to specified ``index``.
|
|
Ownership of ``layer`` is transferred to the symbol.
|
|
|
|
:param index: The index at which the layer should be added
|
|
:param layer: The symbol layer to add
|
|
|
|
:return: True if the layer is added, False if the index or the layer is bad
|
|
%End
|
|
|
|
bool appendSymbolLayer( QgsSymbolLayer *layer /Transfer/ );
|
|
%Docstring
|
|
Appends a symbol ``layer`` at the end of the current symbol layer list.
|
|
Ownership of ``layer`` is transferred to the symbol.
|
|
|
|
:return: true if the layer was successfully added, false if the layer is not compatible with the
|
|
symbol's type().
|
|
%End
|
|
|
|
bool deleteSymbolLayer( int index );
|
|
%Docstring
|
|
Removes and deletes the symbol layer at the specified ``index``.
|
|
%End
|
|
|
|
QgsSymbolLayer *takeSymbolLayer( int index ) /TransferBack/;
|
|
%Docstring
|
|
Removes a symbol layer from the list and returns a pointer to it.
|
|
Ownership of the layer is handed to the caller.
|
|
|
|
:param index: The index of the layer to remove
|
|
|
|
:return: A pointer to the removed layer
|
|
%End
|
|
|
|
bool changeSymbolLayer( int index, QgsSymbolLayer *layer /Transfer/ );
|
|
%Docstring
|
|
Deletes the current layer at the specified ``index`` and replaces it with ``layer``.
|
|
Ownership of ``layer`` is transferred to the symbol.
|
|
|
|
Returns false if ``layer`` is not compatible with the symbol's type(), or
|
|
true if the layer was successfully replaced.
|
|
%End
|
|
|
|
void startRender( QgsRenderContext &context, const QgsFields &fields = QgsFields() );
|
|
%Docstring
|
|
Begins the rendering process for the symbol. This must be called before renderFeature(),
|
|
and should be followed by a call to stopRender().
|
|
|
|
:param context: render context which symbol will be drawn using
|
|
:param fields: fields for features to be rendered (usually the associated
|
|
vector layer's fields). Required for correct calculation of data defined
|
|
overrides.
|
|
|
|
.. seealso:: :py:func:`stopRender`
|
|
%End
|
|
|
|
void stopRender( QgsRenderContext &context );
|
|
%Docstring
|
|
Ends the rendering process. This should be called after rendering all desired features.
|
|
|
|
:param context: render context, must match the context specified when startRender()
|
|
was called.
|
|
|
|
.. seealso:: :py:func:`startRender`
|
|
%End
|
|
|
|
void setColor( const QColor &color );
|
|
%Docstring
|
|
Sets the ``color`` for the symbol.
|
|
|
|
Calling this method sets the color for each individual symbol layer contained
|
|
within the symbol to ``color``.
|
|
|
|
Locked symbol layers are skipped and are left unchanged.
|
|
|
|
.. seealso:: :py:func:`color`
|
|
%End
|
|
|
|
QColor color() const;
|
|
%Docstring
|
|
Returns the symbol's color.
|
|
|
|
For multi-layer symbols, this method returns the color of the first unlocked symbol
|
|
layer.
|
|
|
|
.. seealso:: :py:func:`setColor`
|
|
%End
|
|
|
|
void drawPreviewIcon( QPainter *painter, QSize size, QgsRenderContext *customContext = 0 );
|
|
%Docstring
|
|
Draws an icon of the symbol that occupies an area given by ``size`` using the specified ``painter``.
|
|
|
|
Optionally a custom render context may be given in order to ensure that the preview icon exactly
|
|
matches the settings from that context.
|
|
|
|
.. seealso:: :py:func:`exportImage`
|
|
|
|
.. seealso:: :py:func:`asImage`
|
|
|
|
.. versionadded:: 2.6
|
|
%End
|
|
|
|
void exportImage( const QString &path, const QString &format, QSize size );
|
|
%Docstring
|
|
Export the symbol as an image format, to the specified ``path`` and with the given ``size``.
|
|
|
|
If ``format`` is "SVG" then an SVG file will be created, otherwise a raster image of the
|
|
specified format will be created.
|
|
|
|
.. seealso:: :py:func:`asImage`
|
|
|
|
.. seealso:: :py:func:`drawPreviewIcon`
|
|
%End
|
|
|
|
QImage asImage( QSize size, QgsRenderContext *customContext = 0 );
|
|
%Docstring
|
|
Returns an image of the symbol at the specified ``size``.
|
|
|
|
Optionally a custom render context may be given in order to ensure that the preview icon exactly
|
|
matches the settings from that context.
|
|
|
|
.. seealso:: :py:func:`exportImage`
|
|
|
|
.. seealso:: :py:func:`drawPreviewIcon`
|
|
%End
|
|
|
|
QImage bigSymbolPreviewImage( QgsExpressionContext *expressionContext = 0 );
|
|
%Docstring
|
|
Returns a large (roughly 100x100 pixel) preview image for the symbol.
|
|
|
|
:param expressionContext: optional expression context, for evaluation of
|
|
data defined symbol properties
|
|
|
|
.. seealso:: :py:func:`asImage`
|
|
|
|
.. seealso:: :py:func:`drawPreviewIcon`
|
|
%End
|
|
|
|
QString dump() const;
|
|
%Docstring
|
|
Returns a string dump of the symbol's properties.
|
|
%End
|
|
|
|
virtual QgsSymbol *clone() const = 0 /Factory/;
|
|
%Docstring
|
|
Returns a deep copy of this symbol.
|
|
|
|
Ownership is transferred to the caller.
|
|
%End
|
|
|
|
void toSld( QDomDocument &doc, QDomElement &element, QgsStringMap props ) const;
|
|
%Docstring
|
|
Converts the symbol to a SLD representation.
|
|
%End
|
|
|
|
QgsUnitTypes::RenderUnit outputUnit() const;
|
|
%Docstring
|
|
Returns the units to use for sizes and widths within the symbol. Individual
|
|
symbol layer definitions will interpret this in different ways, e.g., a marker symbol
|
|
may use it to specify the units for the marker size, while a line symbol
|
|
may use it to specify the units for the line width.
|
|
|
|
:return: output unit, or QgsUnitTypes.RenderUnknownUnit if the symbol contains mixed units
|
|
|
|
.. seealso:: :py:func:`setOutputUnit`
|
|
%End
|
|
|
|
void setOutputUnit( QgsUnitTypes::RenderUnit unit );
|
|
%Docstring
|
|
Sets the units to use for sizes and widths within the symbol. Individual
|
|
symbol definitions will interpret this in different ways, e.g., a marker symbol
|
|
may use it to specify the units for the marker size, while a line symbol
|
|
may use it to specify the units for the line width.
|
|
|
|
:param unit: output units
|
|
|
|
.. seealso:: :py:func:`outputUnit`
|
|
%End
|
|
|
|
QgsMapUnitScale mapUnitScale() const;
|
|
%Docstring
|
|
Returns the map unit scale for the symbol.
|
|
|
|
If the symbol consists of multiple layers, the map unit scale is only
|
|
returned if all layers have the same scale settings. If the settings differ,
|
|
a default constructed map unit scale is returned.
|
|
|
|
.. seealso:: :py:func:`setMapUnitScale`
|
|
%End
|
|
|
|
void setMapUnitScale( const QgsMapUnitScale &scale );
|
|
%Docstring
|
|
Sets the map unit ``scale`` for the symbol.
|
|
|
|
Calling this method sets the scale for all symbol layers contained within the
|
|
symbol.
|
|
|
|
.. seealso:: :py:func:`mapUnitScale`
|
|
%End
|
|
|
|
qreal opacity() const;
|
|
%Docstring
|
|
Returns the opacity for the symbol.
|
|
|
|
:return: opacity value between 0 (fully transparent) and 1 (fully opaque)
|
|
|
|
.. seealso:: :py:func:`setOpacity`
|
|
%End
|
|
|
|
void setOpacity( qreal opacity );
|
|
%Docstring
|
|
Sets the ``opacity`` for the symbol.
|
|
|
|
:param opacity: opacity value between 0 (fully transparent) and 1 (fully opaque)
|
|
|
|
.. seealso:: :py:func:`opacity`
|
|
%End
|
|
|
|
void setRenderHints( RenderHints hints );
|
|
%Docstring
|
|
Sets rendering hint flags for the symbol.
|
|
|
|
.. seealso:: :py:func:`renderHints`
|
|
%End
|
|
|
|
RenderHints renderHints() const;
|
|
%Docstring
|
|
Returns the rendering hint flags for the symbol.
|
|
|
|
.. seealso:: :py:func:`setRenderHints`
|
|
%End
|
|
|
|
void setClipFeaturesToExtent( bool clipFeaturesToExtent );
|
|
%Docstring
|
|
Sets whether features drawn by the symbol should be clipped to the render context's
|
|
extent. If this option is enabled then features which are partially outside the extent
|
|
will be clipped. This speeds up rendering of the feature, but may have undesirable
|
|
side effects for certain symbol types.
|
|
|
|
:param clipFeaturesToExtent: set to true to enable clipping (defaults to true)
|
|
|
|
.. seealso:: :py:func:`clipFeaturesToExtent`
|
|
|
|
.. versionadded:: 2.9
|
|
%End
|
|
|
|
bool clipFeaturesToExtent() const;
|
|
%Docstring
|
|
Returns whether features drawn by the symbol will be clipped to the render context's
|
|
extent. If this option is enabled then features which are partially outside the extent
|
|
will be clipped. This speeds up rendering of the feature, but may have undesirable
|
|
side effects for certain symbol types.
|
|
|
|
:return: true if features will be clipped
|
|
|
|
.. seealso:: :py:func:`setClipFeaturesToExtent`
|
|
|
|
.. versionadded:: 2.9
|
|
%End
|
|
|
|
void setForceRHR( bool force );
|
|
%Docstring
|
|
Sets whether polygon features drawn by the symbol should be reoriented to follow the
|
|
standard right-hand-rule orientation, in which the area that is
|
|
bounded by the polygon is to the right of the boundary. In particular, the exterior
|
|
ring is oriented in a clockwise direction and the interior rings in a counter-clockwise
|
|
direction.
|
|
|
|
.. seealso:: :py:func:`forceRHR`
|
|
|
|
.. versionadded:: 3.6
|
|
%End
|
|
|
|
bool forceRHR() const;
|
|
%Docstring
|
|
Returns true if polygon features drawn by the symbol will be reoriented to follow the
|
|
standard right-hand-rule orientation, in which the area that is
|
|
bounded by the polygon is to the right of the boundary. In particular, the exterior
|
|
ring is oriented in a clockwise direction and the interior rings in a counter-clockwise
|
|
direction.
|
|
|
|
.. seealso:: :py:func:`setForceRHR`
|
|
|
|
.. versionadded:: 3.6
|
|
%End
|
|
|
|
QSet<QString> usedAttributes( const QgsRenderContext &context ) const;
|
|
%Docstring
|
|
Returns a list of attributes required to render this feature.
|
|
This should include any attributes required by the symbology including
|
|
the ones required by expressions.
|
|
%End
|
|
|
|
bool hasDataDefinedProperties() const;
|
|
%Docstring
|
|
Returns whether the symbol utilizes any data defined properties.
|
|
|
|
.. versionadded:: 2.12
|
|
%End
|
|
|
|
void setLayer( const QgsVectorLayer *layer ) /Deprecated/;
|
|
%Docstring
|
|
|
|
.. note::
|
|
|
|
the layer will be NULL after stopRender
|
|
|
|
.. deprecated:: Will be removed in QGIS 4.0
|
|
%End
|
|
|
|
const QgsVectorLayer *layer() const /Deprecated/;
|
|
%Docstring
|
|
|
|
.. deprecated:: Will be removed in QGIS 4.0
|
|
%End
|
|
|
|
void renderFeature( const QgsFeature &feature, QgsRenderContext &context, int layer = -1, bool selected = false, bool drawVertexMarker = false, int currentVertexMarkerType = 0, int currentVertexMarkerSize = 0 );
|
|
%Docstring
|
|
Render a feature. Before calling this the startRender() method should be called to initialize
|
|
the rendering process. After rendering all features stopRender() must be called.
|
|
%End
|
|
|
|
QgsSymbolRenderContext *symbolRenderContext();
|
|
%Docstring
|
|
Returns the symbol render context. Only valid between startRender and stopRender calls.
|
|
|
|
:return: The symbol render context
|
|
%End
|
|
|
|
protected:
|
|
QgsSymbol( SymbolType type, const QgsSymbolLayerList &layers /Transfer/ ); // can't be instantiated
|
|
|
|
static QPointF _getPoint( QgsRenderContext &context, const QgsPoint &point );
|
|
%Docstring
|
|
Creates a point in screen coordinates from a QgsPoint in map coordinates
|
|
%End
|
|
|
|
static QPolygonF _getLineString( QgsRenderContext &context, const QgsCurve &curve, bool clipToExtent = true );
|
|
%Docstring
|
|
Creates a line string in screen coordinates from a QgsCurve in map coordinates
|
|
%End
|
|
|
|
static QPolygonF _getPolygonRing( QgsRenderContext &context, const QgsCurve &curve, bool clipToExtent, bool isExteriorRing = false, bool correctRingOrientation = false );
|
|
%Docstring
|
|
Creates a polygon ring in screen coordinates from a QgsCurve in map coordinates.
|
|
|
|
If ``correctRingOrientation`` is true then the ring will be oriented to match standard ring orientation, e.g.
|
|
clockwise for exterior rings and counter-clockwise for interior rings.
|
|
%End
|
|
|
|
static void _getPolygon( QPolygonF &pts, QList<QPolygonF> &holes, QgsRenderContext &context, const QgsPolygon &polygon, bool clipToExtent = true, bool correctRingOrientation = false );
|
|
%Docstring
|
|
Creates a polygon in screen coordinates from a QgsPolygonXYin map coordinates
|
|
|
|
If ``correctRingOrientation`` is true then the ring will be oriented to match standard ring orientation, e.g.
|
|
clockwise for exterior rings and counter-clockwise for interior rings.
|
|
%End
|
|
|
|
QgsSymbolLayerList cloneLayers() const /Factory/;
|
|
%Docstring
|
|
Retrieve a cloned list of all layers that make up this symbol.
|
|
Ownership is transferred to the caller.
|
|
%End
|
|
|
|
void renderUsingLayer( QgsSymbolLayer *layer, QgsSymbolRenderContext &context );
|
|
%Docstring
|
|
Renders a context using a particular symbol layer without passing in a
|
|
geometry. This is used as fallback, if the symbol being rendered is not
|
|
compatible with the specified layer. In such a case, this method can be
|
|
called and will call the layer's rendering method anyway but the
|
|
geometry passed to the layer will be empty.
|
|
This is required for layers that generate their own geometry from other
|
|
information in the rendering context.
|
|
%End
|
|
|
|
void renderVertexMarker( QPointF pt, QgsRenderContext &context, int currentVertexMarkerType, int currentVertexMarkerSize );
|
|
%Docstring
|
|
Render editing vertex marker at specified point
|
|
|
|
.. versionadded:: 2.16
|
|
%End
|
|
|
|
|
|
|
|
|
|
|
|
private:
|
|
QgsSymbol( const QgsSymbol & );
|
|
};
|
|
|
|
QFlags<QgsSymbol::RenderHint> operator|(QgsSymbol::RenderHint f1, QFlags<QgsSymbol::RenderHint> f2);
|
|
|
|
|
|
|
|
class QgsSymbolRenderContext
|
|
{
|
|
|
|
%TypeHeaderCode
|
|
#include "qgssymbol.h"
|
|
%End
|
|
public:
|
|
|
|
QgsSymbolRenderContext( QgsRenderContext &c, QgsUnitTypes::RenderUnit u, qreal opacity = 1.0, bool selected = false, QgsSymbol::RenderHints renderHints = 0, const QgsFeature *f = 0, const QgsFields &fields = QgsFields(), const QgsMapUnitScale &mapUnitScale = QgsMapUnitScale() );
|
|
%Docstring
|
|
Constructor for QgsSymbolRenderContext
|
|
|
|
:param c:
|
|
:param u:
|
|
:param opacity: value between 0 (fully transparent) and 1 (fully opaque)
|
|
:param selected: set to true if symbol should be drawn in a "selected" state
|
|
:param renderHints: flags controlling rendering behavior
|
|
:param f:
|
|
:param fields:
|
|
:param mapUnitScale:
|
|
%End
|
|
|
|
|
|
QgsRenderContext &renderContext();
|
|
%Docstring
|
|
Returns a reference to the context's render context.
|
|
%End
|
|
|
|
|
|
void setOriginalValueVariable( const QVariant &value );
|
|
%Docstring
|
|
Sets the original value variable value for data defined symbology
|
|
|
|
:param value: value for original value variable. This usually represents the symbol property value
|
|
before any data defined overrides have been applied.
|
|
|
|
.. versionadded:: 2.12
|
|
%End
|
|
|
|
QgsUnitTypes::RenderUnit outputUnit() const;
|
|
%Docstring
|
|
Returns the output unit for the context
|
|
%End
|
|
|
|
void setOutputUnit( QgsUnitTypes::RenderUnit u );
|
|
%Docstring
|
|
Sets the output unit for the context
|
|
%End
|
|
|
|
QgsMapUnitScale mapUnitScale() const;
|
|
void setMapUnitScale( const QgsMapUnitScale &scale );
|
|
|
|
qreal opacity() const;
|
|
%Docstring
|
|
Returns the opacity for the symbol.
|
|
|
|
:return: opacity value between 0 (fully transparent) and 1 (fully opaque)
|
|
|
|
.. seealso:: :py:func:`setOpacity`
|
|
%End
|
|
|
|
void setOpacity( qreal opacity );
|
|
%Docstring
|
|
Sets the ``opacity`` for the symbol.
|
|
|
|
:param opacity: opacity value between 0 (fully transparent) and 1 (fully opaque)
|
|
|
|
.. seealso:: :py:func:`opacity`
|
|
%End
|
|
|
|
bool selected() const;
|
|
void setSelected( bool selected );
|
|
|
|
QgsSymbol::RenderHints renderHints() const;
|
|
%Docstring
|
|
Returns the rendering hint flags for the symbol.
|
|
|
|
.. seealso:: :py:func:`setRenderHints`
|
|
%End
|
|
|
|
void setRenderHints( QgsSymbol::RenderHints hints );
|
|
%Docstring
|
|
Sets rendering hint flags for the symbol.
|
|
|
|
.. seealso:: :py:func:`renderHints`
|
|
%End
|
|
|
|
void setFeature( const QgsFeature *f );
|
|
const QgsFeature *feature() const;
|
|
%Docstring
|
|
Current feature being rendered - may be null
|
|
%End
|
|
|
|
void setOriginalGeometryType( QgsWkbTypes::GeometryType type );
|
|
%Docstring
|
|
Sets the geometry type for the original feature geometry being rendered.
|
|
|
|
.. seealso:: :py:func:`originalGeometryType`
|
|
|
|
.. versionadded:: 3.0
|
|
%End
|
|
|
|
QgsWkbTypes::GeometryType originalGeometryType() const;
|
|
%Docstring
|
|
Returns the geometry type for the original feature geometry being rendered. This can be
|
|
useful if symbol layers alter their appearance based on geometry type - eg offsetting a
|
|
simple line style will look different if the simple line is rendering a polygon feature
|
|
(a closed buffer) vs a line feature (an unclosed offset line).
|
|
|
|
.. seealso:: :py:func:`originalGeometryType`
|
|
|
|
.. versionadded:: 3.0
|
|
%End
|
|
|
|
QgsFields fields() const;
|
|
%Docstring
|
|
Fields of the layer. Currently only available in startRender() calls
|
|
to allow symbols with data-defined properties prepare the expressions
|
|
(other times fields() returns null)
|
|
|
|
.. versionadded:: 2.4
|
|
%End
|
|
|
|
int geometryPartCount() const;
|
|
%Docstring
|
|
Part count of current geometry
|
|
|
|
.. versionadded:: 2.16
|
|
%End
|
|
|
|
void setGeometryPartCount( int count );
|
|
%Docstring
|
|
Sets the part count of current geometry
|
|
|
|
.. versionadded:: 2.16
|
|
%End
|
|
|
|
int geometryPartNum() const;
|
|
%Docstring
|
|
Part number of current geometry
|
|
|
|
.. versionadded:: 2.16
|
|
%End
|
|
|
|
void setGeometryPartNum( int num );
|
|
%Docstring
|
|
Sets the part number of current geometry
|
|
|
|
.. versionadded:: 2.16
|
|
%End
|
|
|
|
double outputLineWidth( double width ) const;
|
|
double outputPixelSize( double size ) const;
|
|
|
|
|
|
QgsExpressionContextScope *expressionContextScope();
|
|
%Docstring
|
|
This scope is always available when a symbol of this type is being rendered.
|
|
|
|
:return: An expression scope for details about this symbol
|
|
%End
|
|
|
|
void setExpressionContextScope( QgsExpressionContextScope *contextScope /Transfer/ );
|
|
%Docstring
|
|
Set an expression scope for this symbol.
|
|
|
|
Will take ownership.
|
|
|
|
:param contextScope: An expression scope for details about this symbol
|
|
%End
|
|
|
|
private:
|
|
QgsSymbolRenderContext( const QgsSymbolRenderContext &rh );
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
class QgsMarkerSymbol : QgsSymbol
|
|
{
|
|
|
|
%TypeHeaderCode
|
|
#include "qgssymbol.h"
|
|
%End
|
|
public:
|
|
|
|
static QgsMarkerSymbol *createSimple( const QgsStringMap &properties ) /Factory/;
|
|
%Docstring
|
|
Create a marker symbol with one symbol layer: SimpleMarker with specified properties.
|
|
This is a convenience method for easier creation of marker symbols.
|
|
%End
|
|
|
|
QgsMarkerSymbol( const QgsSymbolLayerList &layers /Transfer/ = QgsSymbolLayerList() );
|
|
|
|
void setAngle( double symbolAngle );
|
|
%Docstring
|
|
Sets the angle for the whole symbol. Individual symbol layer sizes
|
|
will be rotated to maintain their current relative angle to the whole symbol angle.
|
|
|
|
:param symbolAngle: new symbol angle
|
|
|
|
.. seealso:: :py:func:`angle`
|
|
%End
|
|
|
|
double angle() const;
|
|
%Docstring
|
|
Returns the marker angle for the whole symbol. Note that for symbols with
|
|
multiple symbol layers, this will correspond just to the angle of
|
|
the first symbol layer.
|
|
|
|
.. seealso:: :py:func:`setAngle`
|
|
|
|
.. versionadded:: 2.16
|
|
%End
|
|
|
|
void setDataDefinedAngle( const QgsProperty &property );
|
|
%Docstring
|
|
Set data defined angle for whole symbol (including all symbol layers).
|
|
|
|
.. seealso:: :py:func:`dataDefinedAngle`
|
|
|
|
.. versionadded:: 3.0
|
|
%End
|
|
|
|
QgsProperty dataDefinedAngle() const;
|
|
%Docstring
|
|
Returns data defined angle for whole symbol (including all symbol layers).
|
|
|
|
:return: data defined angle, or invalid property if angle is not set
|
|
at the marker level.
|
|
|
|
.. seealso:: :py:func:`setDataDefinedAngle`
|
|
|
|
.. versionadded:: 3.0
|
|
%End
|
|
|
|
void setLineAngle( double lineAngle );
|
|
%Docstring
|
|
Sets the line angle modification for the symbol's angle. This angle is added to
|
|
the marker's rotation and data defined rotation before rendering the symbol, and
|
|
is usually used for orienting symbols to match a line's angle.
|
|
|
|
:param lineAngle: Angle in degrees, valid values are between 0 and 360
|
|
|
|
.. versionadded:: 2.9
|
|
%End
|
|
|
|
void setSize( double size );
|
|
%Docstring
|
|
Sets the size for the whole symbol. Individual symbol layer sizes
|
|
will be scaled to maintain their current relative size to the whole symbol size.
|
|
|
|
:param size: new symbol size
|
|
|
|
.. seealso:: :py:func:`size`
|
|
|
|
.. seealso:: :py:func:`setSizeUnit`
|
|
|
|
.. seealso:: :py:func:`setSizeMapUnitScale`
|
|
%End
|
|
|
|
double size() const;
|
|
%Docstring
|
|
Returns the size for the whole symbol, which is the maximum size of
|
|
all marker symbol layers in the symbol.
|
|
|
|
.. seealso:: :py:func:`setSize`
|
|
|
|
.. seealso:: :py:func:`sizeUnit`
|
|
|
|
.. seealso:: :py:func:`sizeMapUnitScale`
|
|
%End
|
|
|
|
void setSizeUnit( QgsUnitTypes::RenderUnit unit );
|
|
%Docstring
|
|
Sets the size units for the whole symbol (including all symbol layers).
|
|
|
|
:param unit: size units
|
|
|
|
.. seealso:: :py:func:`sizeUnit`
|
|
|
|
.. seealso:: :py:func:`setSizeMapUnitScale`
|
|
|
|
.. seealso:: :py:func:`setSize`
|
|
|
|
.. versionadded:: 2.16
|
|
%End
|
|
|
|
QgsUnitTypes::RenderUnit sizeUnit() const;
|
|
%Docstring
|
|
Returns the size units for the whole symbol (including all symbol layers).
|
|
|
|
:return: size units, or mixed units if symbol layers have different units
|
|
|
|
.. seealso:: :py:func:`setSizeUnit`
|
|
|
|
.. seealso:: :py:func:`sizeMapUnitScale`
|
|
|
|
.. seealso:: :py:func:`size`
|
|
|
|
.. versionadded:: 2.16
|
|
%End
|
|
|
|
void setSizeMapUnitScale( const QgsMapUnitScale &scale );
|
|
%Docstring
|
|
Sets the size map unit scale for the whole symbol (including all symbol layers).
|
|
|
|
:param scale: map unit scale
|
|
|
|
.. seealso:: :py:func:`sizeMapUnitScale`
|
|
|
|
.. seealso:: :py:func:`setSizeUnit`
|
|
|
|
.. seealso:: :py:func:`setSize`
|
|
|
|
.. versionadded:: 2.16
|
|
%End
|
|
|
|
QgsMapUnitScale sizeMapUnitScale() const;
|
|
%Docstring
|
|
Returns the size map unit scale for the whole symbol. Note that for symbols with
|
|
multiple symbol layers, this will correspond just to the map unit scale
|
|
for the first symbol layer.
|
|
|
|
.. seealso:: :py:func:`setSizeMapUnitScale`
|
|
|
|
.. seealso:: :py:func:`sizeUnit`
|
|
|
|
.. seealso:: :py:func:`size`
|
|
|
|
.. versionadded:: 2.16
|
|
%End
|
|
|
|
void setDataDefinedSize( const QgsProperty &property );
|
|
%Docstring
|
|
Set data defined size for whole symbol (including all symbol layers).
|
|
|
|
.. seealso:: :py:func:`dataDefinedSize`
|
|
|
|
.. versionadded:: 3.0
|
|
%End
|
|
|
|
QgsProperty dataDefinedSize() const;
|
|
%Docstring
|
|
Returns data defined size for whole symbol (including all symbol layers).
|
|
|
|
:return: data defined size, or invalid property if size is not set
|
|
at the marker level.
|
|
|
|
.. seealso:: :py:func:`setDataDefinedSize`
|
|
|
|
.. versionadded:: 3.0
|
|
%End
|
|
|
|
void setScaleMethod( QgsSymbol::ScaleMethod scaleMethod );
|
|
ScaleMethod scaleMethod();
|
|
|
|
void renderPoint( QPointF point, const QgsFeature *f, QgsRenderContext &context, int layer = -1, bool selected = false );
|
|
|
|
QRectF bounds( QPointF point, QgsRenderContext &context, const QgsFeature &feature = QgsFeature() ) const;
|
|
%Docstring
|
|
Returns the approximate bounding box of the marker symbol, which includes the bounding box
|
|
of all symbol layers for the symbol. It is recommended to use this method only between startRender()
|
|
and stopRender() calls, or data defined rotation and offset will not be correctly calculated.
|
|
|
|
:param point: location of rendered point in painter units
|
|
:param context: render context
|
|
:param feature: feature being rendered at point (optional). If not specified, the bounds calculation will not
|
|
include data defined parameters such as offset and rotation
|
|
|
|
:return: approximate symbol bounds, in painter units
|
|
|
|
.. versionadded:: 2.14
|
|
%End
|
|
|
|
virtual QgsMarkerSymbol *clone() const /Factory/;
|
|
|
|
|
|
};
|
|
|
|
|
|
class QgsLineSymbol : QgsSymbol
|
|
{
|
|
|
|
%TypeHeaderCode
|
|
#include "qgssymbol.h"
|
|
%End
|
|
public:
|
|
|
|
static QgsLineSymbol *createSimple( const QgsStringMap &properties ) /Factory/;
|
|
%Docstring
|
|
Create a line symbol with one symbol layer: SimpleLine with specified properties.
|
|
This is a convenience method for easier creation of line symbols.
|
|
%End
|
|
|
|
QgsLineSymbol( const QgsSymbolLayerList &layers /Transfer/ = QgsSymbolLayerList() );
|
|
|
|
void setWidth( double width );
|
|
double width() const;
|
|
|
|
void setDataDefinedWidth( const QgsProperty &property );
|
|
%Docstring
|
|
Set data defined width for whole symbol (including all symbol layers).
|
|
|
|
.. seealso:: :py:func:`dataDefinedWidth`
|
|
|
|
.. versionadded:: 3.0
|
|
%End
|
|
|
|
QgsProperty dataDefinedWidth() const;
|
|
%Docstring
|
|
Returns data defined width for whole symbol (including all symbol layers).
|
|
|
|
:return: data defined width, or invalid property if size is not set
|
|
at the line level. Caller takes responsibility for deleting the returned object.
|
|
|
|
.. seealso:: :py:func:`setDataDefinedWidth`
|
|
|
|
.. versionadded:: 3.0
|
|
%End
|
|
|
|
void renderPolyline( const QPolygonF &points, const QgsFeature *f, QgsRenderContext &context, int layer = -1, bool selected = false );
|
|
|
|
virtual QgsLineSymbol *clone() const /Factory/;
|
|
|
|
|
|
};
|
|
|
|
|
|
class QgsFillSymbol : QgsSymbol
|
|
{
|
|
|
|
%TypeHeaderCode
|
|
#include "qgssymbol.h"
|
|
%End
|
|
public:
|
|
|
|
static QgsFillSymbol *createSimple( const QgsStringMap &properties ) /Factory/;
|
|
%Docstring
|
|
Create a fill symbol with one symbol layer: SimpleFill with specified properties.
|
|
This is a convenience method for easier creation of fill symbols.
|
|
%End
|
|
|
|
QgsFillSymbol( const QgsSymbolLayerList &layers /Transfer/ = QgsSymbolLayerList() );
|
|
void setAngle( double angle );
|
|
void renderPolygon( const QPolygonF &points, QList<QPolygonF> *rings, const QgsFeature *f, QgsRenderContext &context, int layer = -1, bool selected = false );
|
|
|
|
virtual QgsFillSymbol *clone() const /Factory/;
|
|
|
|
|
|
};
|
|
|
|
|
|
/************************************************************************
|
|
* This file has been generated automatically from *
|
|
* *
|
|
* src/core/symbology/qgssymbol.h *
|
|
* *
|
|
* Do not edit manually ! Edit header and run scripts/sipify.pl again *
|
|
************************************************************************/
|