mirror of
https://github.com/qgis/QGIS.git
synced 2025-10-04 00:04:03 -04:00
1340 lines
46 KiB
Plaintext
1340 lines
46 KiB
Plaintext
/************************************************************************
|
|
* This file has been generated automatically from *
|
|
* *
|
|
* src/core/symbology/qgssymbollayerutils.h *
|
|
* *
|
|
* Do not edit manually ! Edit header and run scripts/sipify.py again *
|
|
************************************************************************/
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
typedef QMap<QString, QString> QgsStringMap;
|
|
typedef QMap<QString, QgsSymbol * > QgsSymbolMap;
|
|
|
|
|
|
class QgsSymbolLayerUtils
|
|
{
|
|
%Docstring(signature="appended")
|
|
Contains utility functions for working with symbols and symbol layers.
|
|
%End
|
|
|
|
%TypeHeaderCode
|
|
#include "qgssymbollayerutils.h"
|
|
%End
|
|
public:
|
|
|
|
static QString encodeColor( const QColor &color );
|
|
static QColor decodeColor( const QString &str );
|
|
|
|
static QString encodeSldAlpha( int alpha );
|
|
static int decodeSldAlpha( const QString &str );
|
|
|
|
static QString encodeSldFontStyle( QFont::Style style );
|
|
static QFont::Style decodeSldFontStyle( const QString &str );
|
|
|
|
static QString encodeSldFontWeight( int weight );
|
|
static int decodeSldFontWeight( const QString &str );
|
|
|
|
static QString encodePenStyle( Qt::PenStyle style );
|
|
static Qt::PenStyle decodePenStyle( const QString &str );
|
|
|
|
static QString encodePenJoinStyle( Qt::PenJoinStyle style );
|
|
static Qt::PenJoinStyle decodePenJoinStyle( const QString &str );
|
|
|
|
static QString encodePenCapStyle( Qt::PenCapStyle style );
|
|
static Qt::PenCapStyle decodePenCapStyle( const QString &str );
|
|
|
|
static QString encodeSldLineJoinStyle( Qt::PenJoinStyle style );
|
|
static Qt::PenJoinStyle decodeSldLineJoinStyle( const QString &str );
|
|
|
|
static QString encodeSldLineCapStyle( Qt::PenCapStyle style );
|
|
static Qt::PenCapStyle decodeSldLineCapStyle( const QString &str );
|
|
|
|
static QString encodeBrushStyle( Qt::BrushStyle style );
|
|
static Qt::BrushStyle decodeBrushStyle( const QString &str );
|
|
|
|
static QString encodeSldBrushStyle( Qt::BrushStyle style );
|
|
static Qt::BrushStyle decodeSldBrushStyle( const QString &str );
|
|
|
|
static Qgis::EndCapStyle penCapStyleToEndCapStyle( Qt::PenCapStyle style );
|
|
%Docstring
|
|
Converts a Qt pen cap style to a QGIS end cap style.
|
|
|
|
.. versionadded:: 3.42
|
|
%End
|
|
|
|
static Qgis::JoinStyle penJoinStyleToJoinStyle( Qt::PenJoinStyle style );
|
|
%Docstring
|
|
Converts a Qt pen joinstyle to a QGIS join style.
|
|
|
|
.. versionadded:: 3.42
|
|
%End
|
|
|
|
static bool hasSldSymbolizer( const QDomElement &element );
|
|
%Docstring
|
|
Returns ``True`` if a DOM ``element`` contains an SLD Symbolizer
|
|
element.
|
|
|
|
.. versionadded:: 3.42
|
|
%End
|
|
|
|
static Qgis::SymbolCoordinateReference decodeCoordinateReference( const QString &string, bool *ok /Out/ = 0 );
|
|
%Docstring
|
|
Decodes a ``string`` representing a symbol coordinate reference mode.
|
|
|
|
:param string: string to decode
|
|
|
|
:return: - decoded marker clip mode
|
|
- ok: ``True`` if ``string`` was successfully decoded
|
|
|
|
.. seealso:: :py:func:`encodeCoordinateReference`
|
|
|
|
.. versionadded:: 3.24
|
|
%End
|
|
|
|
static QString encodeCoordinateReference( Qgis::SymbolCoordinateReference coordinateReference );
|
|
%Docstring
|
|
Encodes a symbol coordinate reference mode to a string.
|
|
|
|
:param coordinateReference: coordinate reference mode
|
|
|
|
.. seealso:: :py:func:`decodeCoordinateReference`
|
|
|
|
.. versionadded:: 3.24
|
|
%End
|
|
|
|
static QgsArrowSymbolLayer::HeadType decodeArrowHeadType( const QVariant &value, bool *ok /Out/ = 0 );
|
|
%Docstring
|
|
Decodes a ``value`` representing an arrow head type.
|
|
|
|
.. versionadded:: 3.2
|
|
%End
|
|
|
|
static QgsArrowSymbolLayer::ArrowType decodeArrowType( const QVariant &value, bool *ok /Out/ = 0 );
|
|
%Docstring
|
|
Decodes a ``value`` representing an arrow type.
|
|
|
|
.. versionadded:: 3.2
|
|
%End
|
|
|
|
static Qgis::MarkerClipMode decodeMarkerClipMode( const QString &string, bool *ok /Out/ = 0 );
|
|
%Docstring
|
|
Decodes a ``string`` representing a marker clip mode.
|
|
|
|
:param string: string to decode
|
|
|
|
:return: - decoded marker clip mode
|
|
- ok: ``True`` if ``string`` was successfully decoded
|
|
|
|
.. seealso:: :py:func:`encodeMarkerClipMode`
|
|
|
|
.. versionadded:: 3.24
|
|
%End
|
|
|
|
static QString encodeMarkerClipMode( Qgis::MarkerClipMode mode );
|
|
%Docstring
|
|
Encodes a marker clip ``mode`` to a string.
|
|
|
|
.. seealso:: :py:func:`decodeMarkerClipMode`
|
|
|
|
.. versionadded:: 3.24
|
|
%End
|
|
|
|
static Qgis::LineClipMode decodeLineClipMode( const QString &string, bool *ok /Out/ = 0 );
|
|
%Docstring
|
|
Decodes a ``string`` representing a line clip mode.
|
|
|
|
:param string: string to decode
|
|
|
|
:return: - decoded line clip mode
|
|
- ok: ``True`` if ``string`` was successfully decoded
|
|
|
|
.. seealso:: :py:func:`encodeLineClipMode`
|
|
|
|
.. versionadded:: 3.24
|
|
%End
|
|
|
|
static QString encodeLineClipMode( Qgis::LineClipMode mode );
|
|
%Docstring
|
|
Encodes a line clip ``mode`` to a string.
|
|
|
|
.. seealso:: :py:func:`decodeLineClipMode`
|
|
|
|
.. versionadded:: 3.24
|
|
%End
|
|
|
|
static QString encodePoint( QPointF point );
|
|
%Docstring
|
|
Encodes a QPointF to a string.
|
|
|
|
.. seealso:: :py:func:`decodePoint`
|
|
|
|
.. seealso:: :py:func:`encodeSize`
|
|
%End
|
|
|
|
static QPointF decodePoint( const QString &string );
|
|
%Docstring
|
|
Decodes a QSizeF from a string.
|
|
|
|
.. seealso:: :py:func:`encodePoint`
|
|
|
|
.. seealso:: :py:func:`decodeSize`
|
|
%End
|
|
|
|
static QPointF toPoint( const QVariant &value, bool *ok /Out/ = 0 );
|
|
%Docstring
|
|
Converts a ``value`` to a point.
|
|
|
|
:param value: value to convert
|
|
|
|
:return: - converted point
|
|
- ok: ``True`` if value was successfully converted
|
|
|
|
.. seealso:: :py:func:`decodePoint`
|
|
|
|
.. seealso:: :py:func:`toSize`
|
|
|
|
.. versionadded:: 3.10
|
|
%End
|
|
|
|
static QString encodeSize( QSizeF size );
|
|
%Docstring
|
|
Encodes a QSizeF to a string.
|
|
|
|
.. seealso:: :py:func:`decodeSize`
|
|
|
|
.. seealso:: :py:func:`encodePoint`
|
|
%End
|
|
|
|
static QSizeF decodeSize( const QString &string );
|
|
%Docstring
|
|
Decodes a QSizeF from a string.
|
|
|
|
.. seealso:: :py:func:`encodeSize`
|
|
|
|
.. seealso:: :py:func:`decodePoint`
|
|
%End
|
|
|
|
static QSizeF toSize( const QVariant &value, bool *ok /Out/ = 0 );
|
|
%Docstring
|
|
Converts a ``value`` to a size.
|
|
|
|
:param value: value to convert
|
|
|
|
:return: - converted size
|
|
- ok: ``True`` if value was successfully converted
|
|
|
|
.. seealso:: :py:func:`decodeSize`
|
|
|
|
.. seealso:: :py:func:`toPoint`
|
|
|
|
.. versionadded:: 3.10
|
|
%End
|
|
|
|
static QString encodeMapUnitScale( const QgsMapUnitScale &mapUnitScale );
|
|
static QgsMapUnitScale decodeMapUnitScale( const QString &str );
|
|
|
|
static QString encodeRealVector( const QVector<qreal> &v );
|
|
static QVector<qreal> decodeRealVector( const QString &s );
|
|
|
|
static QString encodeSldRealVector( const QVector<qreal> &v );
|
|
static QVector<qreal> decodeSldRealVector( const QString &s );
|
|
|
|
static QString encodeSldUom( Qgis::RenderUnit unit, double *scaleFactor );
|
|
%Docstring
|
|
Encodes a render unit into an SLD unit of measure string.
|
|
|
|
:param unit: unit to encode
|
|
:param scaleFactor: if specified, will be set to scale factor for unit
|
|
of measure
|
|
|
|
:return: encoded string
|
|
|
|
.. seealso:: :py:func:`decodeSldUom`
|
|
%End
|
|
|
|
static Qgis::RenderUnit decodeSldUom( const QString &str, double *scaleFactor = 0 );
|
|
%Docstring
|
|
Decodes a SLD unit of measure string to a render unit.
|
|
|
|
:param str: string to decode
|
|
:param scaleFactor: if specified, will be set to scale factor for unit
|
|
of measure
|
|
|
|
:return: matching render unit
|
|
|
|
.. seealso:: :py:func:`encodeSldUom`
|
|
%End
|
|
|
|
static double sizeInPixelsFromSldUom( const QString &uom, double size );
|
|
%Docstring
|
|
Returns the size scaled in pixels according to the uom attribute.
|
|
|
|
:param uom: The uom attribute from SLD 1.1 version
|
|
:param size: The original size
|
|
|
|
:return: the size in pixels
|
|
%End
|
|
|
|
static QString encodeScaleMethod( Qgis::ScaleMethod scaleMethod );
|
|
%Docstring
|
|
Encodes a symbol scale method to a string.
|
|
|
|
.. seealso:: :py:func:`decodeScaleMethod`
|
|
%End
|
|
|
|
static Qgis::ScaleMethod decodeScaleMethod( const QString &str );
|
|
%Docstring
|
|
Decodes a symbol scale method from a string.
|
|
|
|
.. seealso:: :py:func:`encodeScaleMethod`
|
|
%End
|
|
|
|
static QPainter::CompositionMode decodeBlendMode( const QString &s );
|
|
|
|
static QIcon symbolPreviewIcon( const QgsSymbol *symbol, QSize size, int padding = 0, QgsLegendPatchShape *shape = 0, const QgsScreenProperties &screen = QgsScreenProperties() );
|
|
%Docstring
|
|
Returns an icon preview for a color ramp.
|
|
|
|
:param symbol: symbol
|
|
:param size: target pixmap size
|
|
:param padding: space between icon edge and symbol
|
|
:param shape: optional legend patch shape to use for rendering the
|
|
preview icon
|
|
:param screen: can be used to specify the destination screen properties
|
|
for the icon. This allows the icon to be generated using
|
|
the correct DPI and device pixel ratio for the target
|
|
screen (since QGIS 3.32)
|
|
|
|
.. seealso:: :py:func:`symbolPreviewPixmap`
|
|
%End
|
|
|
|
static QPixmap symbolPreviewPixmap( const QgsSymbol *symbol, QSize size, int padding = 0, QgsRenderContext *customContext = 0, bool selected = false,
|
|
const QgsExpressionContext *expressionContext = 0,
|
|
const QgsLegendPatchShape *shape = 0,
|
|
const QgsScreenProperties &screen = QgsScreenProperties() );
|
|
%Docstring
|
|
Returns a pixmap preview for a color ramp.
|
|
|
|
:param symbol: symbol
|
|
:param size: target pixmap size
|
|
:param padding: space between icon edge and symbol
|
|
:param customContext: custom rendering context
|
|
:param selected: set to ``True`` to render the symbol in a selected
|
|
state (since QGIS 3.10)
|
|
:param expressionContext: optional custom expression context (since QGIS
|
|
3.10)
|
|
:param shape: optional legend patch shape to use for rendering the
|
|
preview icon (since QGIS 3.14)
|
|
:param screen: can be used to specify the destination screen properties
|
|
for the icon. This allows the icon to be generated using
|
|
the correct DPI and device pixel ratio for the target
|
|
screen (since QGIS 3.32)
|
|
|
|
.. seealso:: :py:func:`symbolPreviewIcon`
|
|
%End
|
|
|
|
static QPicture symbolLayerPreviewPicture( const QgsSymbolLayer *layer, Qgis::RenderUnit units, QSize size, const QgsMapUnitScale &scale = QgsMapUnitScale(), Qgis::SymbolType parentSymbolType = Qgis::SymbolType::Hybrid );
|
|
%Docstring
|
|
Draws a symbol layer preview to a QPicture
|
|
|
|
:param layer: symbol layer to draw
|
|
:param units: size units
|
|
:param size: target size of preview picture
|
|
:param scale: map unit scale for preview
|
|
:param parentSymbolType: since QGIS 3.22, can be used to specify the
|
|
parent symbol type so that geometry generator
|
|
preview icons are correctly calculated
|
|
|
|
:return: QPicture containing symbol layer preview
|
|
|
|
.. seealso:: :py:func:`symbolLayerPreviewIcon`
|
|
%End
|
|
|
|
static QIcon symbolLayerPreviewIcon( const QgsSymbolLayer *layer, Qgis::RenderUnit u, QSize size, const QgsMapUnitScale &scale = QgsMapUnitScale(), Qgis::SymbolType parentSymbolType = Qgis::SymbolType::Hybrid, QgsMapLayer *mapLayer = 0, const QgsScreenProperties &screen = QgsScreenProperties() );
|
|
%Docstring
|
|
Draws a symbol layer preview to an icon.
|
|
|
|
:param layer: symbol layer to draw
|
|
:param u: size units
|
|
:param size: target size of preview icon
|
|
:param scale: map unit scale for preview
|
|
:param parentSymbolType: since QGIS 3.22, can be used to specify the
|
|
parent symbol type so that geometry generator
|
|
preview icons are correctly calculated
|
|
:param mapLayer: since QGIS 3.28, can be used to specify the associated
|
|
map layer so that layer related expressions are
|
|
correctly calculated
|
|
:param screen: since QGIS 3.32, can be used to specify the destination
|
|
screen properties for the icon. This allows the icon to
|
|
be generated using the correct DPI and device pixel ratio
|
|
for the target screen.
|
|
|
|
:return: icon containing symbol layer preview
|
|
|
|
.. seealso:: :py:func:`symbolLayerPreviewPicture`
|
|
%End
|
|
|
|
static QIcon colorRampPreviewIcon( QgsColorRamp *ramp, QSize size, int padding = 0 );
|
|
%Docstring
|
|
Returns an icon preview for a color ramp.
|
|
|
|
:param ramp: color ramp
|
|
:param size: target icon size
|
|
:param padding: space between icon edge and color ramp
|
|
|
|
.. seealso:: :py:func:`colorRampPreviewPixmap`
|
|
%End
|
|
|
|
static QPixmap colorRampPreviewPixmap( QgsColorRamp *ramp, QSize size, int padding = 0, Qt::Orientation direction = Qt::Horizontal,
|
|
bool flipDirection = false, bool drawTransparentBackground = true );
|
|
%Docstring
|
|
Returns a pixmap preview for a color ramp.
|
|
|
|
:param ramp: color ramp
|
|
:param size: target pixmap size
|
|
:param padding: space between icon edge and color ramp
|
|
:param direction: direction to render pixmap (since QGIS 3.18)
|
|
:param flipDirection: set to ``True`` to flip the direction of the ramp.
|
|
For horizontal ``directions``, ramps will be
|
|
rendered left to right by default. For vertical
|
|
``directions``, ramps will be rendered top to
|
|
bottom by default. Setting this flag to ``True``
|
|
will reverse these default directions.
|
|
:param drawTransparentBackground: set to ``False`` to disable the
|
|
checkerboard effect drawn below
|
|
transparent colors in the ramp
|
|
|
|
.. seealso:: :py:func:`colorRampPreviewIcon`
|
|
%End
|
|
|
|
static void drawStippledBackground( QPainter *painter, QRect rect );
|
|
|
|
static void drawVertexMarker( double x, double y, QPainter &p, Qgis::VertexMarkerType type, int markerSize );
|
|
%Docstring
|
|
Draws a vertex symbol at (painter) coordinates x, y. (Useful to assist
|
|
vertex editing.)
|
|
|
|
.. versionadded:: 3.4.5
|
|
%End
|
|
|
|
static double estimateMaxSymbolBleed( QgsSymbol *symbol, const QgsRenderContext &context );
|
|
%Docstring
|
|
Returns the maximum estimated bleed for the symbol
|
|
%End
|
|
|
|
static std::unique_ptr< QgsSymbol > loadSymbol( const QDomElement &element, const QgsReadWriteContext &context );
|
|
%Docstring
|
|
Attempts to load a symbol from a DOM element
|
|
|
|
:param element: DOM element representing symbol
|
|
:param context: object to transform relative to absolute paths
|
|
|
|
:return: decoded symbol, if possible
|
|
%End
|
|
|
|
|
|
static std::unique_ptr< QgsSymbolLayer > loadSymbolLayer( QDomElement &element, const QgsReadWriteContext &context );
|
|
%Docstring
|
|
Reads and returns symbol layer from XML. Caller is responsible for
|
|
deleting the returned object
|
|
%End
|
|
|
|
static QDomElement saveSymbol( const QString &symbolName, const QgsSymbol *symbol, QDomDocument &doc, const QgsReadWriteContext &context );
|
|
%Docstring
|
|
Writes a symbol definition to XML
|
|
%End
|
|
|
|
static QString symbolProperties( QgsSymbol *symbol );
|
|
%Docstring
|
|
Returns a string representing the symbol. Can be used to test for
|
|
equality between symbols.
|
|
%End
|
|
|
|
static bool createSymbolLayerListFromSld( QDomElement &element, Qgis::GeometryType geomType, QList<QgsSymbolLayer *> &layers );
|
|
%Docstring
|
|
Creates a symbol layer list from a DOM ``element``.
|
|
%End
|
|
|
|
static std::unique_ptr< QgsSymbolLayer > createFillLayerFromSld( QDomElement &element );
|
|
%Docstring
|
|
Creates a new fill layer from a SLD DOM ``element``.
|
|
%End
|
|
|
|
static std::unique_ptr< QgsSymbolLayer > createLineLayerFromSld( QDomElement &element );
|
|
%Docstring
|
|
Creates a new line layer from a SLD DOM ``element``.
|
|
%End
|
|
|
|
static std::unique_ptr< QgsSymbolLayer > createMarkerLayerFromSld( QDomElement &element );
|
|
%Docstring
|
|
Creates a new marker layer from a SLD DOM ``element``.
|
|
%End
|
|
|
|
static bool convertPolygonSymbolizerToPointMarker( QDomElement &element, QList<QgsSymbolLayer *> &layerList );
|
|
%Docstring
|
|
Converts a polygon symbolizer ``element`` to a list of marker symbol
|
|
layers.
|
|
%End
|
|
|
|
static bool hasExternalGraphic( QDomElement &element );
|
|
%Docstring
|
|
Checks if ``element`` contains an ExternalGraphic element with format
|
|
"image/svg+xml"
|
|
|
|
:return: ``True`` if the ExternalGraphic with format "image/svg+xml" is
|
|
found .
|
|
%End
|
|
|
|
static bool hasExternalGraphicV2( const QDomElement &element, const QString format = QString() );
|
|
%Docstring
|
|
Checks if ``element`` contains an ExternalGraphic element, if the
|
|
optional ``format`` is specified it will also be checked.
|
|
|
|
:return: ``True`` if the ExternalGraphic element is found and the
|
|
optionally specified format matches.
|
|
|
|
.. versionadded:: 3.30
|
|
%End
|
|
|
|
static bool hasWellKnownMark( QDomElement &element );
|
|
|
|
static bool needFontMarker( QDomElement &element );
|
|
|
|
static bool needSvgMarker( const QDomElement &element );
|
|
%Docstring
|
|
Checks if ``element`` contains an ExternalGraphic element that should
|
|
translate to an SVG marker.
|
|
|
|
:return: ``True`` if the ExternalGraphic element is found and is of type
|
|
SVG.
|
|
%End
|
|
|
|
static bool needRasterMarker( const QDomElement &element );
|
|
%Docstring
|
|
Checks if ``element`` contains an ExternalGraphic element that should
|
|
translate to a raster marker.
|
|
|
|
This is the case for any type of ExternalGraphic that is not an SVG.
|
|
|
|
:return: ``True`` if the ExternalGraphic element is found and is not of
|
|
type SVG.
|
|
|
|
.. versionadded:: 3.44
|
|
%End
|
|
static bool needEllipseMarker( QDomElement &element );
|
|
static bool needMarkerLine( QDomElement &element );
|
|
static bool needLinePatternFill( QDomElement &element );
|
|
static bool needPointPatternFill( QDomElement &element );
|
|
static bool needSvgFill( QDomElement &element );
|
|
|
|
static bool needRasterImageFill( QDomElement &element );
|
|
%Docstring
|
|
Checks if ``element`` contains a graphic fill with a raster image of
|
|
type PNG, JPEG or GIF.
|
|
|
|
:return: ``True`` if element contains a graphic fill with a raster
|
|
image.
|
|
|
|
.. versionadded:: 3.30
|
|
%End
|
|
|
|
static void fillToSld( QDomDocument &doc, QDomElement &element,
|
|
Qt::BrushStyle brushStyle, const QColor &color = QColor() ) /Deprecated="Since 3.44. Use the version with QgsSldExportContext instead."/;
|
|
%Docstring
|
|
Exports fill details to an SLD element.
|
|
|
|
.. deprecated:: 3.44
|
|
|
|
Use the version with :py:class:`QgsSldExportContext` instead.
|
|
%End
|
|
|
|
static void fillToSld( QDomDocument &doc, QDomElement &element, QgsSldExportContext &context,
|
|
Qt::BrushStyle brushStyle, const QColor &color = QColor() );
|
|
%Docstring
|
|
Exports fill details to an SLD element.
|
|
|
|
.. versionadded:: 3.44
|
|
%End
|
|
|
|
static bool fillFromSld( QDomElement &element,
|
|
Qt::BrushStyle &brushStyle, QColor &color );
|
|
|
|
static bool lineFromSld( QDomElement &element,
|
|
Qt::PenStyle &penStyle, QColor &color, double &width,
|
|
Qt::PenJoinStyle *penJoinStyle = 0, Qt::PenCapStyle *penCapStyle = 0,
|
|
QVector<qreal> *customDashPattern = 0, double *dashOffset = 0 );
|
|
|
|
static void externalGraphicToSld( QDomDocument &doc, QDomElement &element,
|
|
const QString &path, const QString &mime,
|
|
const QColor &color, double size = -1 );
|
|
static bool externalGraphicFromSld( QDomElement &element,
|
|
QString &path, QString &mime,
|
|
QColor &color, double &size );
|
|
|
|
static void wellKnownMarkerToSld( QDomDocument &doc, QDomElement &element,
|
|
const QString &name, const QColor &color, const QColor &strokeColor, Qt::PenStyle strokeStyle,
|
|
double strokeWidth = -1, double size = -1 ) /Deprecated="Since 3.44. Use the version with QgsSldExportContext instead."/;
|
|
%Docstring
|
|
Exports a marker to SLD
|
|
|
|
.. deprecated:: 3.44
|
|
|
|
Use the version with :py:class:`QgsSldExportContext` instead.
|
|
%End
|
|
|
|
static void wellKnownMarkerToSld( QDomDocument &doc, QDomElement &element,
|
|
const QString &name, const QColor &color, const QColor &strokeColor, Qt::PenStyle strokeStyle,
|
|
QgsSldExportContext &context,
|
|
double strokeWidth = -1, double size = -1 );
|
|
%Docstring
|
|
Exports a marker to SLD
|
|
|
|
.. versionadded:: 3.44
|
|
%End
|
|
|
|
static bool wellKnownMarkerFromSld( QDomElement &element,
|
|
QString &name, QColor &color, QColor &strokeColor, Qt::PenStyle &strokeStyle,
|
|
double &strokeWidth, double &size ) /PyName=wellKnownMarkerFromSld2/;
|
|
%Docstring
|
|
Extracts properties from an SLD marker definition.
|
|
%End
|
|
|
|
static void externalMarkerToSld( QDomDocument &doc, QDomElement &element,
|
|
const QString &path, const QString &format, int *markIndex = 0,
|
|
const QColor &color = QColor(), double size = -1 ) /Deprecated="Since 3.44. Use the version with QgsSldExportContext instead."/;
|
|
%Docstring
|
|
Exports a marker to an SLD definition.
|
|
|
|
.. deprecated:: 3.44
|
|
|
|
Use the version with :py:class:`QgsSldExportContext` instead.
|
|
%End
|
|
|
|
static void externalMarkerToSld( QDomDocument &doc, QDomElement &element,
|
|
const QString &path, const QString &format, QgsSldExportContext &context, int *markIndex = 0,
|
|
const QColor &color = QColor(), double size = -1 );
|
|
%Docstring
|
|
Exports a marker to an SLD definition.
|
|
|
|
.. versionadded:: 3.44
|
|
%End
|
|
|
|
static bool externalMarkerFromSld( QDomElement &element,
|
|
QString &path, QString &format, int &markIndex,
|
|
QColor &color, double &size );
|
|
|
|
static void labelTextToSld( QDomDocument &doc, QDomElement &element, const QString &label,
|
|
const QFont &font, const QColor &color = QColor(), double size = -1 ) /Deprecated="Since 3.44. Use the version with QgsSldExportContext instead."/;
|
|
%Docstring
|
|
Exports label text to SLD
|
|
|
|
.. deprecated:: 3.44
|
|
|
|
Use the version with :py:class:`QgsSldExportContext` instead.
|
|
%End
|
|
|
|
static void labelTextToSld( QDomDocument &doc, QDomElement &element, const QString &label,
|
|
const QFont &font, QgsSldExportContext &context, const QColor &color = QColor(), double size = -1 );
|
|
%Docstring
|
|
Exports label text to SLD
|
|
|
|
.. versionadded:: 3.44
|
|
%End
|
|
|
|
static QString ogrFeatureStylePen( double width, double mmScaleFactor, double mapUnitsScaleFactor, const QColor &c,
|
|
Qt::PenJoinStyle joinStyle = Qt::MiterJoin,
|
|
Qt::PenCapStyle capStyle = Qt::FlatCap,
|
|
double offset = 0.0,
|
|
const QVector<qreal> *dashPattern = 0 );
|
|
%Docstring
|
|
Create ogr feature style string for pen
|
|
%End
|
|
|
|
static QString ogrFeatureStyleBrush( const QColor &fillColr );
|
|
%Docstring
|
|
Create ogr feature style string for brush
|
|
|
|
:param fillColr: fill color
|
|
%End
|
|
|
|
static void createRotationElement( QDomDocument &doc, QDomElement &element, const QString &rotationFunc ) /Deprecated="Since 3.44. Use the version with QgsSldExportContext instead."/;
|
|
%Docstring
|
|
Creates SLD rotation element.
|
|
|
|
.. deprecated:: 3.44
|
|
|
|
Use the version with :py:class:`QgsSldExportContext` instead.
|
|
%End
|
|
|
|
static void createRotationElement( QDomDocument &doc, QDomElement &element, const QString &rotationFunc, QgsSldExportContext &context );
|
|
%Docstring
|
|
Creates SLD rotation element.
|
|
|
|
.. versionadded:: 3.44
|
|
%End
|
|
|
|
static bool rotationFromSldElement( QDomElement &element, QString &rotationFunc );
|
|
|
|
static void createOpacityElement( QDomDocument &doc, QDomElement &element, const QString &alphaFunc ) /Deprecated="Since 3.44. Use the version with QgsSldExportContext instead."/;
|
|
%Docstring
|
|
Creates SLD opacity element.
|
|
|
|
.. deprecated:: 3.44
|
|
|
|
Use the version with :py:class:`QgsSldExportContext` instead.
|
|
%End
|
|
|
|
static void createOpacityElement( QDomDocument &doc, QDomElement &element, const QString &alphaFunc, QgsSldExportContext &context );
|
|
%Docstring
|
|
Creates SLD opacity element.
|
|
|
|
.. versionadded:: 3.44
|
|
%End
|
|
|
|
static bool opacityFromSldElement( QDomElement &element, QString &alphaFunc );
|
|
|
|
static void createDisplacementElement( QDomDocument &doc, QDomElement &element, QPointF offset );
|
|
static bool displacementFromSldElement( QDomElement &element, QPointF &offset );
|
|
|
|
static void createAnchorPointElement( QDomDocument &doc, QDomElement &element, QPointF anchor );
|
|
%Docstring
|
|
Creates a SE 1.1 anchor point element as a child of the specified
|
|
element
|
|
|
|
:param doc: The document
|
|
:param element: The parent element
|
|
:param anchor: An anchor specification, with values between 0 and 1
|
|
%End
|
|
|
|
static void createOnlineResourceElement( QDomDocument &doc, QDomElement &element, const QString &path, const QString &format );
|
|
static bool onlineResourceFromSldElement( QDomElement &element, QString &path, QString &format );
|
|
|
|
static void createGeometryElement( QDomDocument &doc, QDomElement &element, const QString &geomFunc ) /Deprecated="Since 3.44. Use the version with QgsSldExportContext instead."/;
|
|
%Docstring
|
|
Creates an SLD geometry element.
|
|
|
|
.. deprecated:: 3.44
|
|
|
|
Use the version with :py:class:`QgsSldExportContext` instead.
|
|
%End
|
|
|
|
static void createGeometryElement( QDomDocument &doc, QDomElement &element, const QString &geomFunc, QgsSldExportContext &context );
|
|
%Docstring
|
|
Creates an SLD geometry element.
|
|
|
|
.. versionadded:: 3.44
|
|
%End
|
|
|
|
static bool geometryFromSldElement( QDomElement &element, QString &geomFunc );
|
|
|
|
static bool createExpressionElement( QDomDocument &doc, QDomElement &element, const QString &function ) /Deprecated="Since 3.44. Use the version with QgsSldExportContext instead."/;
|
|
%Docstring
|
|
Creates a OGC Expression element based on the provided function
|
|
expression
|
|
|
|
:param doc: The document owning the element
|
|
:param element: The element parent
|
|
:param function: The expression to be encoded
|
|
|
|
.. deprecated:: 3.44
|
|
|
|
Use the version with :py:class:`QgsSldExportContext` instead.
|
|
%End
|
|
|
|
static bool createExpressionElement( QDomDocument &doc, QDomElement &element, const QString &function, QgsSldExportContext &context );
|
|
%Docstring
|
|
Creates a OGC Expression element based on the provided function
|
|
expression
|
|
|
|
:param doc: The document owning the element
|
|
:param element: The element parent
|
|
:param function: The expression to be encoded
|
|
:param context: export context
|
|
|
|
.. versionadded:: 3.44
|
|
%End
|
|
|
|
static bool createFunctionElement( QDomDocument &doc, QDomElement &element, const QString &function ) /Deprecated="Since 3.44. Use the version with QgsSldExportContext instead."/;
|
|
%Docstring
|
|
Creates an OGC function element
|
|
|
|
.. deprecated:: 3.44
|
|
|
|
Use the version with :py:class:`QgsSldExportContext` instead.
|
|
%End
|
|
|
|
static bool createFunctionElement( QDomDocument &doc, QDomElement &element, const QString &function, QgsSldExportContext &context );
|
|
%Docstring
|
|
Creates an OGC function element
|
|
|
|
.. versionadded:: 3.44
|
|
%End
|
|
|
|
static bool functionFromSldElement( QDomElement &element, QString &function );
|
|
|
|
static QDomElement createSvgParameterElement( QDomDocument &doc, const QString &name, const QString &value );
|
|
static QgsStringMap getSvgParameterList( QDomElement &element );
|
|
|
|
static QDomElement createVendorOptionElement( QDomDocument &doc, const QString &name, const QString &value );
|
|
static QgsStringMap getVendorOptionList( QDomElement &element );
|
|
|
|
static QVariantMap parseProperties( const QDomElement &element );
|
|
%Docstring
|
|
Parses the properties from XML and returns a map
|
|
%End
|
|
static void saveProperties( QVariantMap props, QDomDocument &doc, QDomElement &element );
|
|
%Docstring
|
|
Saves the map of properties to XML
|
|
%End
|
|
|
|
static QgsSymbolMap loadSymbols( QDomElement &element, const QgsReadWriteContext &context ) /Factory/;
|
|
%Docstring
|
|
Reads a collection of symbols from XML and returns them in a map. Caller
|
|
is responsible for deleting returned symbols.
|
|
%End
|
|
static QDomElement saveSymbols( QgsSymbolMap &symbols, const QString &tagName, QDomDocument &doc, const QgsReadWriteContext &context );
|
|
%Docstring
|
|
Writes a collection of symbols to XML with specified tagName for the
|
|
top-level element
|
|
%End
|
|
|
|
static void clearSymbolMap( QgsSymbolMap &symbols );
|
|
|
|
static QMimeData *symbolToMimeData( const QgsSymbol *symbol ) /Factory/;
|
|
%Docstring
|
|
Creates new mime data from a ``symbol``. This also sets the mime color
|
|
data to match the symbol's color, so that copied symbols can be paste in
|
|
places where a color is expected.
|
|
|
|
.. seealso:: :py:func:`symbolFromMimeData`
|
|
%End
|
|
|
|
static std::unique_ptr< QgsSymbol > symbolFromMimeData( const QMimeData *data );
|
|
%Docstring
|
|
Attempts to parse ``mime`` data as a symbol. A new symbol instance will
|
|
be returned if the data was successfully converted to a symbol.
|
|
|
|
.. seealso:: :py:func:`symbolToMimeData`
|
|
%End
|
|
|
|
static std::unique_ptr< QgsColorRamp > loadColorRamp( QDomElement &element );
|
|
%Docstring
|
|
Creates a color ramp from the settings encoded in an XML element
|
|
|
|
:param element: DOM element
|
|
|
|
:return: new color ramp. Caller takes responsibility for deleting the
|
|
returned value.
|
|
|
|
.. seealso:: :py:func:`saveColorRamp`
|
|
%End
|
|
|
|
static QDomElement saveColorRamp( const QString &name, const QgsColorRamp *ramp, QDomDocument &doc );
|
|
%Docstring
|
|
Encodes a color ramp's settings to an XML element
|
|
|
|
:param name: name of ramp
|
|
:param ramp: color ramp to save
|
|
:param doc: XML document
|
|
|
|
:return: DOM element representing state of color ramp
|
|
|
|
.. seealso:: :py:func:`loadColorRamp`
|
|
%End
|
|
|
|
static QVariant colorRampToVariant( const QString &name, QgsColorRamp *ramp );
|
|
%Docstring
|
|
Saves a color ramp to a QVariantMap, wrapped in a QVariant. You can use
|
|
:py:class:`QgsXmlUtils`.writeVariant to save it to an XML document.
|
|
|
|
.. seealso:: :py:func:`loadColorRamp`
|
|
%End
|
|
|
|
static std::unique_ptr< QgsColorRamp > loadColorRamp( const QVariant &value );
|
|
%Docstring
|
|
Load a color ramp from a QVariantMap, wrapped in a QVariant. You can use
|
|
:py:class:`QgsXmlUtils`.readVariant to load it from an XML document.
|
|
|
|
.. seealso:: :py:func:`colorRampToVariant`
|
|
%End
|
|
|
|
static QString colorToName( const QColor &color );
|
|
%Docstring
|
|
Returns a friendly display name for a color
|
|
|
|
:param color: source color
|
|
|
|
:return: display name for color
|
|
%End
|
|
|
|
static QList< QColor > parseColorList( const QString &colorStr );
|
|
%Docstring
|
|
Attempts to parse a string as a list of colors using a variety of common
|
|
formats, including hex codes, rgb and rgba strings.
|
|
|
|
:param colorStr: string representing the color list
|
|
|
|
:return: list of parsed colors
|
|
%End
|
|
|
|
static QMimeData *colorToMimeData( const QColor &color ) /Factory/;
|
|
%Docstring
|
|
Creates mime data from a color. Sets both the mime data's color data,
|
|
and the mime data's text with the color's hex code.
|
|
|
|
:param color: color to encode as mime data
|
|
|
|
.. seealso:: :py:func:`colorFromMimeData`
|
|
%End
|
|
|
|
static QColor colorFromMimeData( const QMimeData *data, bool &hasAlpha /Out/ );
|
|
%Docstring
|
|
Attempts to parse mime data as a color
|
|
|
|
:param data: mime data to parse
|
|
|
|
:return: - valid color if mimedata could be interpreted as a color,
|
|
otherwise an invalid color
|
|
- hasAlpha: ``True`` if mime data was interpreted as a color
|
|
containing an explicit alpha value
|
|
%End
|
|
|
|
static QgsNamedColorList colorListFromMimeData( const QMimeData *data );
|
|
%Docstring
|
|
Attempts to parse mime data as a list of named colors
|
|
|
|
:param data: mime data to parse
|
|
|
|
:return: list of parsed colors
|
|
%End
|
|
|
|
static QMimeData *colorListToMimeData( const QgsNamedColorList &colorList, bool allFormats = true ) /Factory/;
|
|
%Docstring
|
|
Creates mime data from a list of named colors
|
|
|
|
:param colorList: list of named colors
|
|
:param allFormats: set to ``True`` to include additional mime formats,
|
|
include text/plain and application/x-color
|
|
|
|
:return: mime data containing encoded colors
|
|
%End
|
|
|
|
static bool saveColorsToGpl( QFile &file, const QString &paletteName, const QgsNamedColorList &colors );
|
|
%Docstring
|
|
Exports colors to a gpl GIMP palette file
|
|
|
|
:param file: destination file
|
|
:param paletteName: name of palette, which is stored in gpl file
|
|
:param colors: colors to export
|
|
|
|
:return: ``True`` if export was successful
|
|
|
|
.. seealso:: :py:func:`importColorsFromGpl`
|
|
%End
|
|
|
|
static QgsNamedColorList importColorsFromGpl( QFile &file, bool &ok, QString &name );
|
|
%Docstring
|
|
Imports colors from a gpl GIMP palette file
|
|
|
|
:param file: source gpl file
|
|
:param ok: will be ``True`` if file was successfully read
|
|
:param name: will be set to palette name from gpl file, if present
|
|
|
|
:return: list of imported colors
|
|
|
|
.. seealso:: :py:func:`saveColorsToGpl`
|
|
%End
|
|
|
|
static QColor parseColor( const QString &colorStr, bool strictEval = false );
|
|
%Docstring
|
|
Attempts to parse a string as a color using a variety of common formats,
|
|
including hex codes, rgb and rgba strings.
|
|
|
|
:param colorStr: string representing the color
|
|
:param strictEval: set to ``True`` for stricter color parsing rules
|
|
|
|
:return: parsed color
|
|
%End
|
|
|
|
static QColor parseColorWithAlpha( const QString &colorStr, bool &containsAlpha, bool strictEval = false );
|
|
%Docstring
|
|
Attempts to parse a string as a color using a variety of common formats,
|
|
including hex codes, rgb and rgba, hsl and hsla strings.
|
|
|
|
:param colorStr: string representing the color
|
|
:param containsAlpha: if colorStr contains an explicit alpha value then
|
|
containsAlpha will be set to ``True``
|
|
:param strictEval: set to ``True`` for stricter color parsing rules
|
|
|
|
:return: parsed color
|
|
%End
|
|
|
|
static void multiplyImageOpacity( QImage *image, qreal opacity );
|
|
%Docstring
|
|
Multiplies opacity of image pixel values with a (global) transparency
|
|
value.
|
|
%End
|
|
|
|
static void blurImageInPlace( QImage &image, QRect rect, int radius, bool alphaOnly );
|
|
%Docstring
|
|
Blurs an image in place, e.g. creating Qt-independent drop shadows
|
|
%End
|
|
|
|
static void premultiplyColor( QColor &rgb, int alpha );
|
|
%Docstring
|
|
Converts a QColor into a premultiplied ARGB QColor value using a
|
|
specified alpha value
|
|
%End
|
|
|
|
static bool condenseFillAndOutline( QgsFillSymbolLayer *fill, QgsLineSymbolLayer *outline );
|
|
%Docstring
|
|
Attempts to condense a ``fill`` and ``outline`` layer, by moving the
|
|
outline layer to the fill symbol's stroke.
|
|
|
|
This will only be done if the ``outline`` can be transformed into a
|
|
stroke on the fill layer losslessly. If so, ``fill`` will be updated in
|
|
place with the new stroke. Any existing stroke settings in ``fill`` will
|
|
be replaced.
|
|
|
|
Returns ``True`` if the fill and outline were successfully condensed.
|
|
|
|
.. versionadded:: 3.20
|
|
%End
|
|
|
|
static void sortVariantList( QList<QVariant> &list, Qt::SortOrder order );
|
|
%Docstring
|
|
Sorts the passed list in requested order
|
|
%End
|
|
static QPointF pointOnLineWithDistance( QPointF startPoint, QPointF directionPoint, double distance );
|
|
%Docstring
|
|
Returns a point on the line from startPoint to directionPoint that is a
|
|
certain distance away from the starting point
|
|
%End
|
|
|
|
static QStringList listSvgFiles();
|
|
%Docstring
|
|
Returns a list of all available svg files
|
|
%End
|
|
|
|
static QStringList listSvgFilesAt( const QString &directory );
|
|
%Docstring
|
|
Returns a list of svg files at the specified directory
|
|
%End
|
|
|
|
static QString svgSymbolNameToPath( const QString &name, const QgsPathResolver &pathResolver );
|
|
%Docstring
|
|
Determines an SVG symbol's path from its ``name``. If ``name`` is not an
|
|
absolute path the file is scanned for in the SVG paths specified in
|
|
settings svg/searchPathsForSVG.
|
|
|
|
.. seealso:: :py:func:`svgSymbolPathToName`
|
|
%End
|
|
|
|
static QString svgSymbolPathToName( const QString &path, const QgsPathResolver &pathResolver );
|
|
%Docstring
|
|
Determines an SVG symbol's name from its ``path``.
|
|
|
|
.. seealso:: :py:func:`svgSymbolNameToPath`
|
|
%End
|
|
|
|
static QList< QList< QPolygonF > > toQPolygonF( const QgsGeometry &geometry, Qgis::SymbolType type );
|
|
%Docstring
|
|
Converts a ``geometry`` to a set of QPolygonF objects representing how
|
|
the geometry should be drawn for a symbol of the given ``type``, as a
|
|
list of geometry parts and rings.
|
|
|
|
.. versionadded:: 3.40
|
|
%End
|
|
|
|
static QList< QList< QPolygonF > > toQPolygonF( const QgsAbstractGeometry *geometry, Qgis::SymbolType type );
|
|
%Docstring
|
|
Converts a ``geometry`` to a set of QPolygonF objects representing how
|
|
the geometry should be drawn for a symbol of the given ``type``, as a
|
|
list of geometry parts and rings.
|
|
|
|
.. versionadded:: 3.42
|
|
%End
|
|
|
|
static QPointF polygonCentroid( const QPolygonF &points );
|
|
%Docstring
|
|
Calculate the centroid point of a QPolygonF
|
|
%End
|
|
|
|
static QPointF polygonPointOnSurface( const QPolygonF &points, const QVector<QPolygonF> *rings = 0 );
|
|
%Docstring
|
|
Calculate a point on the surface of a QPolygonF
|
|
%End
|
|
|
|
static bool pointInPolygon( const QPolygonF &points, QPointF point );
|
|
%Docstring
|
|
Calculate whether a point is within of a QPolygonF
|
|
%End
|
|
|
|
static double polylineLength( const QPolygonF &polyline );
|
|
%Docstring
|
|
Returns the total length of a ``polyline``.
|
|
|
|
.. versionadded:: 3.20
|
|
%End
|
|
|
|
static QPolygonF polylineSubstring( const QPolygonF &polyline, double startOffset, double endOffset );
|
|
%Docstring
|
|
Returns the substring of a ``polyline`` which starts at ``startOffset``
|
|
from the beginning of the line and ends at ``endOffset`` from the start
|
|
of the line.
|
|
|
|
If ``startOffset`` is less than 0, then the start point will be
|
|
calculated by subtracting that distance from the end of the line.
|
|
Similarly, if ``endOffset`` is less than zero then the end point will be
|
|
subtracted from the end of the line.
|
|
|
|
May return an empty linestring if the substring is zero length.
|
|
|
|
.. versionadded:: 3.16
|
|
%End
|
|
|
|
static bool isSharpCorner( QPointF p1, QPointF p2, QPointF p3 );
|
|
%Docstring
|
|
Returns ``True`` if the angle formed by the line ``p1`` - ``p2`` -
|
|
``p3`` forms a "sharp" corner.
|
|
|
|
Sharp corners form an angle which exceeds a 45 degree threshold.
|
|
|
|
.. versionadded:: 3.16
|
|
%End
|
|
|
|
static void appendPolyline( QPolygonF &target, const QPolygonF &line );
|
|
%Docstring
|
|
Appends a polyline ``line`` to an existing ``target`` polyline.
|
|
|
|
Any duplicate points at the start ``line`` which match the end point
|
|
from ``target`` will be skipped.
|
|
|
|
.. versionadded:: 3.16
|
|
%End
|
|
|
|
static std::unique_ptr< QgsExpression > fieldOrExpressionToExpression( const QString &fieldOrExpression );
|
|
%Docstring
|
|
Returns a new valid expression instance for given field or expression
|
|
string. If the input is not a valid expression, it is assumed that it is
|
|
a field name and gets properly quoted. If the string is empty, returns
|
|
``None``. This is useful when accepting input which could be either a
|
|
non-quoted field name or expression.
|
|
%End
|
|
|
|
static QString fieldOrExpressionFromExpression( QgsExpression *expression );
|
|
%Docstring
|
|
Returns a field name if the whole expression is just a name of the field
|
|
. Returns full expression string if the expression is more complex than
|
|
just one field. Using just
|
|
expression->:py:func:`~QgsSymbolLayerUtils.expression` method may return
|
|
quoted field name, but that is not wanted for saving (due to backward
|
|
compatibility) or display in GUI.
|
|
%End
|
|
|
|
static QList<double> prettyBreaks( double minimum, double maximum, int classes );
|
|
%Docstring
|
|
Computes a sequence of about 'classes' equally spaced round values which
|
|
cover the range of values from 'minimum' to 'maximum'. The values are
|
|
chosen so that they are 1, 2 or 5 times a power of 10.
|
|
%End
|
|
|
|
static double rescaleUom( double size, Qgis::RenderUnit unit, const QVariantMap &props );
|
|
%Docstring
|
|
Rescales the given size based on the uomScale found in the props, if any
|
|
is found, otherwise returns the value un-modified
|
|
%End
|
|
|
|
static QPointF rescaleUom( QPointF point, Qgis::RenderUnit unit, const QVariantMap &props ) /PyName=rescalePointUom/;
|
|
%Docstring
|
|
Rescales the given point based on the uomScale found in the props, if
|
|
any is found, otherwise returns a copy of the original point
|
|
%End
|
|
|
|
static QVector<qreal> rescaleUom( const QVector<qreal> &array, Qgis::RenderUnit unit, const QVariantMap &props ) /PyName=rescaleArrayUom/;
|
|
%Docstring
|
|
Rescales the given array based on the uomScale found in the props, if
|
|
any is found, otherwise returns a copy of the original point
|
|
%End
|
|
|
|
static void applyScaleDependency( QDomDocument &doc, QDomElement &ruleElem, QVariantMap &props );
|
|
%Docstring
|
|
Checks if the properties contain scaleMinDenom and scaleMaxDenom, if
|
|
available, they are added into the SE Rule element
|
|
%End
|
|
|
|
static void mergeScaleDependencies( double mScaleMinDenom, double mScaleMaxDenom, QVariantMap &props );
|
|
%Docstring
|
|
Merges the local scale limits, if any, with the ones already in the map,
|
|
if any
|
|
%End
|
|
|
|
static void parametricSvgToSld( QDomDocument &doc, QDomElement &graphicElem,
|
|
const QString &path,
|
|
const QColor &fillColor, double size, const QColor &strokeColor, double strokeWidth ) /Deprecated="Since 3.44. Use the version with QgsSldExportContext instead."/;
|
|
%Docstring
|
|
Encodes a reference to a parametric SVG into SLD, as a succession of
|
|
parametric SVG using URL parameters, a fallback SVG without parameters,
|
|
and a final fallback as a mark with the right colors and stroke for
|
|
systems that cannot do SVG at all
|
|
|
|
.. deprecated:: 3.44
|
|
|
|
Use the version with :py:class:`QgsSldExportContext` instead.
|
|
%End
|
|
|
|
static void parametricSvgToSld( QDomDocument &doc, QDomElement &graphicElem,
|
|
const QString &path,
|
|
const QColor &fillColor, double size, const QColor &strokeColor, double strokeWidth,
|
|
QgsSldExportContext &context );
|
|
%Docstring
|
|
Encodes a reference to a parametric SVG into SLD, as a succession of
|
|
parametric SVG using URL parameters, a fallback SVG without parameters,
|
|
and a final fallback as a mark with the right colors and stroke for
|
|
systems that cannot do SVG at all
|
|
|
|
.. versionadded:: 3.44
|
|
%End
|
|
|
|
static QString getSvgParametricPath( const QString &basePath, const QColor &fillColor, const QColor &strokeColor, double strokeWidth );
|
|
%Docstring
|
|
Encodes a reference to a parametric SVG into a path with parameters
|
|
according to the SVG Parameters spec
|
|
%End
|
|
|
|
static QSet<const QgsSymbolLayer *> toSymbolLayerPointers( const QgsFeatureRenderer *renderer, const QSet<QgsSymbolLayerId> &symbolLayerIds );
|
|
%Docstring
|
|
Converts a set of symbol layer id to a set of pointers to actual symbol
|
|
layers carried by the feature renderer.
|
|
|
|
.. versionadded:: 3.12
|
|
|
|
.. deprecated:: 3.30
|
|
|
|
Because it was related to old :py:class:`QgsSymbolLayerReference` system.
|
|
%End
|
|
|
|
static double rendererFrameRate( const QgsFeatureRenderer *renderer );
|
|
%Docstring
|
|
Calculates the frame rate (in frames per second) at which the given
|
|
``renderer`` must be redrawn.
|
|
|
|
Returns -1 if the ``renderer`` is not animated.
|
|
|
|
.. versionadded:: 3.26
|
|
%End
|
|
|
|
static QgsSymbol *restrictedSizeSymbol( const QgsSymbol *s, double minSize, double maxSize, QgsRenderContext *context, double &width, double &height, bool *ok = 0 );
|
|
%Docstring
|
|
Creates a new symbol with size restricted to min/max size if original
|
|
size is out of min/max range
|
|
|
|
:param s: the original symbol
|
|
:param minSize: the minimum size in mm
|
|
:param maxSize: the maximum size in mm
|
|
:param context: the render context
|
|
:param width: expected width, can be changed by the function
|
|
:param height: expected height, can be changed by the function
|
|
:param ok: if not None, ok is set to false if it's not possible to
|
|
compute a restricted symbol (if geometry generators are
|
|
involved for instance)
|
|
|
|
:return: None if size is within minSize/maxSize range or if it's not
|
|
possible to compute a restricted size symbol. New symbol if
|
|
size was out of min/max range. Caller takes ownership
|
|
%End
|
|
|
|
static QgsStringMap evaluatePropertiesMap( const QMap<QString, QgsProperty> &propertiesMap, const QgsExpressionContext &context );
|
|
%Docstring
|
|
Evaluates a map of properties using the given ``context`` and returns a
|
|
variant map with evaluated expressions from the properties.
|
|
|
|
.. versionadded:: 3.18
|
|
%End
|
|
|
|
static QSize tileSize( int width, int height, double &angleRad /In,Out/ );
|
|
%Docstring
|
|
Calculate the minimum size in pixels of a symbol tile given the symbol
|
|
``width`` and ``height`` and the symbol layer rotation ``angleRad`` in
|
|
radians (counter clockwise). The method makes approximations and can
|
|
modify ``angle`` in order to generate the smallest possible tile.
|
|
|
|
:param width: marker width, including margins
|
|
:param height: marker height, including margins
|
|
:param angleRad: symbol layer rotation angle in radians (counter
|
|
clockwise), it may be approximated by the method to
|
|
minimize the tile size.
|
|
|
|
:return: the size of the tile
|
|
|
|
.. versionadded:: 3.30
|
|
%End
|
|
|
|
static void clearSymbolLayerIds( QgsSymbol *symbol );
|
|
%Docstring
|
|
Remove recursively unique id from all ``symbol`` symbol layers and set
|
|
an empty string instead
|
|
|
|
.. versionadded:: 3.30
|
|
%End
|
|
|
|
static void clearSymbolLayerIds( QgsSymbolLayer *symbolLayer );
|
|
%Docstring
|
|
Remove recursively unique id from ``symbolLayer`` and its children and
|
|
set an empty string instead
|
|
|
|
.. versionadded:: 3.30
|
|
%End
|
|
|
|
static void resetSymbolLayerIds( QgsSymbol *symbol );
|
|
%Docstring
|
|
Regenerate recursively unique id from all ``symbol`` symbol layers
|
|
|
|
.. versionadded:: 3.30
|
|
%End
|
|
|
|
static void resetSymbolLayerIds( QgsSymbolLayer *symbolLayer );
|
|
%Docstring
|
|
Regenerate recursively unique id from ``symbolLayer`` and its children
|
|
|
|
.. versionadded:: 3.30
|
|
%End
|
|
|
|
static void clearSymbolLayerMasks( QgsSymbol *symbol );
|
|
%Docstring
|
|
Remove recursively masks from all ``symbol`` symbol layers
|
|
|
|
.. versionadded:: 3.42
|
|
%End
|
|
|
|
static QVector< QgsGeometry > collectSymbolLayerClipGeometries( const QgsRenderContext &context, const QString &symbolLayerId, const QRectF &bounds );
|
|
%Docstring
|
|
Returns a list of the symbol layer clip geometries to be used for the
|
|
symbol layer with the specified ID.
|
|
|
|
The ``bounds`` argument specifies the target bounds (in painter
|
|
coordinates) for matching geometries. Only mask geometries which
|
|
intersect ``bounds`` will be returned. If ``bounds`` is a null QRectF
|
|
then all clip geometries for the symbol layer will be returned.
|
|
|
|
.. versionadded:: 3.38
|
|
%End
|
|
|
|
|
|
};
|
|
|
|
|
|
|
|
/************************************************************************
|
|
* This file has been generated automatically from *
|
|
* *
|
|
* src/core/symbology/qgssymbollayerutils.h *
|
|
* *
|
|
* Do not edit manually ! Edit header and run scripts/sipify.py again *
|
|
************************************************************************/
|