mirror of
https://github.com/qgis/QGIS.git
synced 2025-10-30 00:07:09 -04:00
1273 lines
35 KiB
Plaintext
1273 lines
35 KiB
Plaintext
/************************************************************************
|
|
* This file has been generated automatically from *
|
|
* *
|
|
* src/core/qgsrendercontext.h *
|
|
* *
|
|
* Do not edit manually ! Edit header and run scripts/sipify.py again *
|
|
************************************************************************/
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class QgsRenderContext : QgsTemporalRangeObject
|
|
{
|
|
%Docstring(signature="appended")
|
|
Contains information about the context of a rendering operation.
|
|
|
|
The context of a rendering operation defines properties such as
|
|
the conversion ratio between screen and map units, the extents
|
|
to be rendered etc.
|
|
%End
|
|
|
|
%TypeHeaderCode
|
|
#include "qgsrendercontext.h"
|
|
%End
|
|
public:
|
|
QgsRenderContext();
|
|
~QgsRenderContext();
|
|
|
|
QgsRenderContext( const QgsRenderContext &rh );
|
|
|
|
void setFlags( Qgis::RenderContextFlags flags );
|
|
%Docstring
|
|
Set combination of flags that will be used for rendering.
|
|
%End
|
|
|
|
void setFlag( Qgis::RenderContextFlag flag, bool on = true );
|
|
%Docstring
|
|
Enable or disable a particular flag (other flags are not affected)
|
|
%End
|
|
|
|
Qgis::RenderContextFlags flags() const;
|
|
%Docstring
|
|
Returns combination of flags used for rendering.
|
|
%End
|
|
|
|
bool testFlag( Qgis::RenderContextFlag flag ) const;
|
|
%Docstring
|
|
Check whether a particular flag is enabled.
|
|
%End
|
|
|
|
static QgsRenderContext fromMapSettings( const QgsMapSettings &mapSettings );
|
|
%Docstring
|
|
create initialized QgsRenderContext instance from given :py:class:`QgsMapSettings`
|
|
%End
|
|
|
|
static QgsRenderContext fromQPainter( QPainter *painter );
|
|
%Docstring
|
|
Creates a default render context given a pixel based QPainter destination.
|
|
If no painter is specified or the painter has no device, then a default
|
|
DPI of 88 will be assumed.
|
|
%End
|
|
|
|
|
|
QPainter *painter();
|
|
%Docstring
|
|
Returns the destination QPainter for the render operation.
|
|
|
|
.. seealso:: :py:func:`setPainter`
|
|
%End
|
|
|
|
|
|
QPainter *previewRenderPainter();
|
|
%Docstring
|
|
Returns the const destination QPainter for temporary in-progress preview renders.
|
|
|
|
May be ``None`` if temporary in-progress preview renders are not required.
|
|
|
|
.. seealso:: :py:func:`setPreviewRenderPainter`
|
|
|
|
.. versionadded:: 3.34
|
|
%End
|
|
|
|
|
|
void setPainterFlagsUsingContext( QPainter *painter = 0 ) const;
|
|
%Docstring
|
|
Sets relevant flags on a destination ``painter``, using the flags and settings
|
|
currently defined for the render context.
|
|
|
|
If no ``painter`` is specified, then the flags will be applied to the render
|
|
context's :py:func:`~QgsRenderContext.painter`.
|
|
|
|
.. versionadded:: 3.16
|
|
%End
|
|
|
|
QPainter *maskPainter( int id = 0 );
|
|
%Docstring
|
|
Returns a mask QPainter for the render operation.
|
|
Multiple mask painters can be defined, each with a unique identifier.
|
|
None is returned if a mask painter with the given identifier does not exist.
|
|
This is currently used to implement selective masking.
|
|
|
|
.. seealso:: :py:func:`setMaskPainter`
|
|
|
|
.. seealso:: :py:func:`currentMaskId`
|
|
|
|
.. versionadded:: 3.12
|
|
%End
|
|
|
|
|
|
void setDisabledSymbolLayers( const QSet<const QgsSymbolLayer *> &symbolLayers ) /Deprecated/;
|
|
%Docstring
|
|
When rendering a map layer in a second pass (for selective masking),
|
|
some symbol layers may be disabled.
|
|
|
|
Sets the list of disabled symbol layers.
|
|
|
|
.. seealso:: :py:func:`disabledSymbolLayers`
|
|
|
|
.. seealso:: :py:func:`isSymbolLayerEnabled`
|
|
|
|
.. versionadded:: 3.12
|
|
|
|
.. deprecated:: 3.30
|
|
|
|
And replaced with setDisabledSymbolLayersV2.
|
|
%End
|
|
|
|
void setDisabledSymbolLayersV2( const QSet<QString> &symbolLayers );
|
|
%Docstring
|
|
When rendering a map layer in a second pass (for selective masking),
|
|
some symbol layers may be disabled.
|
|
|
|
Sets the list of disabled symbol layer ids.
|
|
|
|
.. seealso:: :py:func:`disabledSymbolLayersV2`
|
|
|
|
.. seealso:: :py:func:`isSymbolLayerEnabled`
|
|
|
|
.. versionadded:: 3.30
|
|
%End
|
|
|
|
QSet<const QgsSymbolLayer *> disabledSymbolLayers() const /Deprecated/;
|
|
%Docstring
|
|
When rendering a map layer in a second pass (for selective masking),
|
|
some symbol layers may be disabled.
|
|
|
|
Returns the list of disabled symbol layers.
|
|
|
|
.. seealso:: :py:func:`setDisabledSymbolLayers`
|
|
|
|
.. seealso:: :py:func:`isSymbolLayerEnabled`
|
|
|
|
.. versionadded:: 3.12
|
|
|
|
.. deprecated:: 3.30
|
|
|
|
And replaced with disabledSymbolLayersV2.
|
|
%End
|
|
|
|
QSet<QString> disabledSymbolLayersV2() const;
|
|
%Docstring
|
|
When rendering a map layer in a second pass (for selective masking),
|
|
some symbol layers may be disabled.
|
|
|
|
Returns the list of disabled symbol layer ids.
|
|
|
|
.. seealso:: :py:func:`setDisabledSymbolLayers`
|
|
|
|
.. seealso:: :py:func:`isSymbolLayerEnabled`
|
|
|
|
.. versionadded:: 3.30
|
|
%End
|
|
|
|
bool isSymbolLayerEnabled( const QgsSymbolLayer *layer ) const;
|
|
%Docstring
|
|
When rendering a map layer in a second pass (for selective masking),
|
|
some symbol layers may be disabled.
|
|
|
|
Checks whether a given symbol layer has been disabled for the current pass.
|
|
|
|
.. seealso:: :py:func:`setDisabledSymbolLayers`
|
|
|
|
.. seealso:: :py:func:`disabledSymbolLayers`
|
|
|
|
.. versionadded:: 3.12
|
|
%End
|
|
|
|
QgsCoordinateTransform coordinateTransform() const;
|
|
%Docstring
|
|
Returns the current coordinate transform for the context.
|
|
|
|
This represents the coordinate transform required to transform a layer
|
|
which is being rendered back to the CRS of the rendered map. If no coordinate
|
|
transformation is required, or the render context is not associated with
|
|
a map layer render, then an invalid coordinate transformation is returned.
|
|
|
|
.. seealso:: :py:func:`setCoordinateTransform`
|
|
%End
|
|
|
|
const QgsDistanceArea &distanceArea() const;
|
|
%Docstring
|
|
A general purpose distance and area calculator, capable of performing ellipsoid based calculations.
|
|
%End
|
|
|
|
QgsCoordinateTransformContext transformContext() const;
|
|
%Docstring
|
|
Returns the context's coordinate transform context, which stores various
|
|
information regarding which datum transforms should be used when transforming points
|
|
from a source to destination coordinate reference system.
|
|
|
|
.. seealso:: :py:func:`setTransformContext`
|
|
%End
|
|
|
|
void setTransformContext( const QgsCoordinateTransformContext &context );
|
|
%Docstring
|
|
Sets the context's coordinate transform ``context``, which stores various
|
|
information regarding which datum transforms should be used when transforming points
|
|
from a source to destination coordinate reference system.
|
|
|
|
.. seealso:: :py:func:`transformContext`
|
|
%End
|
|
|
|
const QgsPathResolver &pathResolver() const;
|
|
%Docstring
|
|
Returns the path resolver for conversion between relative and absolute paths
|
|
during rendering operations, e.g. for resolving relative symbol paths.
|
|
|
|
.. seealso:: :py:func:`setPathResolver`
|
|
%End
|
|
|
|
void setPathResolver( const QgsPathResolver &resolver );
|
|
%Docstring
|
|
Sets the path ``resolver`` for conversion between relative and absolute paths
|
|
during rendering operations, e.g. for resolving relative symbol paths.
|
|
|
|
.. seealso:: :py:func:`pathResolver`
|
|
%End
|
|
|
|
const QgsRectangle &extent() const;
|
|
%Docstring
|
|
When rendering a map layer, calling this method returns the "clipping"
|
|
extent for the layer (in the layer's CRS).
|
|
|
|
This extent is a "worst-case" scenario, which is guaranteed to cover the complete
|
|
visible portion of the layer when it is rendered to a map. It is often larger
|
|
than the actual visible portion of that layer.
|
|
|
|
.. warning::
|
|
|
|
For some layers, depending on the visible extent and the coordinate
|
|
transforms involved, this extent will represent the entire globe. This method
|
|
should never be used to determine the actual visible extent of a map render.
|
|
|
|
.. seealso:: :py:func:`setExtent`
|
|
|
|
.. seealso:: :py:func:`mapExtent`
|
|
%End
|
|
|
|
QgsRectangle mapExtent() const;
|
|
%Docstring
|
|
Returns the original extent of the map being rendered.
|
|
|
|
Unlike :py:func:`~QgsRenderContext.extent`, this extent is always in the final destination CRS for the map
|
|
render and represents the exact bounds of the map being rendered.
|
|
|
|
.. seealso:: :py:func:`extent`
|
|
|
|
.. seealso:: :py:func:`setMapExtent`
|
|
|
|
.. versionadded:: 3.4.8
|
|
%End
|
|
|
|
const QgsMapToPixel &mapToPixel() const;
|
|
%Docstring
|
|
Returns the context's map to pixel transform, which transforms between map coordinates and device coordinates.
|
|
|
|
.. seealso:: :py:func:`setMapToPixel`
|
|
%End
|
|
|
|
double scaleFactor() const;
|
|
%Docstring
|
|
Returns the scaling factor for the render to convert painter units
|
|
to physical sizes. This is usually equal to the number of pixels
|
|
per millimeter.
|
|
|
|
.. seealso:: :py:func:`setScaleFactor`
|
|
%End
|
|
|
|
double dpiTarget() const;
|
|
%Docstring
|
|
Returns the targeted DPI for rendering.
|
|
|
|
.. seealso:: :py:func:`setDpiTarget`
|
|
|
|
.. versionadded:: 3.20
|
|
%End
|
|
|
|
bool renderingStopped() const;
|
|
%Docstring
|
|
Returns ``True`` if the rendering operation has been stopped and any ongoing
|
|
rendering should be canceled immediately.
|
|
|
|
.. note::
|
|
|
|
Since QGIS 3.22 the :py:func:`~QgsRenderContext.feedback` member exists as an alternative means of cancellation support.
|
|
|
|
.. seealso:: :py:func:`setRenderingStopped`
|
|
|
|
.. seealso:: :py:func:`feedback`
|
|
%End
|
|
|
|
void setFeedback( QgsFeedback *feedback );
|
|
%Docstring
|
|
Attach a ``feedback`` object that can be queried regularly during rendering to check
|
|
if rendering should be canceled.
|
|
|
|
Ownership of ``feedback`` is NOT transferred, and the caller must take care that it exists
|
|
for the lifetime of the render context.
|
|
|
|
.. seealso:: :py:func:`feedback`
|
|
|
|
.. versionadded:: 3.22
|
|
%End
|
|
|
|
QgsFeedback *feedback() const;
|
|
%Docstring
|
|
Returns the feedback object that can be queried regularly during rendering to check
|
|
if rendering should be canceled, if set. Maybe be ``None``.
|
|
|
|
.. seealso:: :py:func:`setFeedback`
|
|
|
|
.. versionadded:: 3.22
|
|
%End
|
|
|
|
bool forceVectorOutput() const;
|
|
%Docstring
|
|
Returns ``True`` if rendering operations should use vector operations instead
|
|
of any faster raster shortcuts.
|
|
|
|
.. seealso:: :py:func:`setForceVectorOutput`
|
|
%End
|
|
|
|
bool useAdvancedEffects() const;
|
|
%Docstring
|
|
Returns ``True`` if advanced effects such as blend modes such be used
|
|
|
|
.. seealso:: :py:func:`setUseAdvancedEffects`
|
|
%End
|
|
|
|
void setUseAdvancedEffects( bool enabled );
|
|
%Docstring
|
|
Used to enable or disable advanced effects such as blend modes
|
|
|
|
.. seealso:: :py:func:`useAdvancedEffects`
|
|
%End
|
|
|
|
bool drawEditingInformation() const;
|
|
%Docstring
|
|
Returns ``True`` if edit markers should be drawn during the render operation.
|
|
|
|
.. seealso:: :py:func:`setDrawEditingInformation`
|
|
%End
|
|
|
|
double rendererScale() const;
|
|
%Docstring
|
|
Returns the renderer map scale. This will match the desired scale denominator
|
|
for the rendered map, eg 1000.0 for a 1:1000 map render.
|
|
|
|
.. seealso:: :py:func:`setRendererScale`
|
|
%End
|
|
|
|
|
|
double symbologyReferenceScale() const;
|
|
%Docstring
|
|
Returns the symbology reference scale.
|
|
|
|
This represents the desired scale denominator for the rendered map, eg 1000.0 for a 1:1000 map render.
|
|
A value of -1 indicates that symbology scaling by reference scale is disabled.
|
|
|
|
The symbology reference scale is an optional property which specifies the reference
|
|
scale at which symbology in paper units (such a millimeters or points) is fixed
|
|
to. For instance, if the scale is 1000 then a 2mm thick line will be rendered at
|
|
exactly 2mm thick when a map is rendered at 1:1000, or 1mm thick when rendered at 1:2000, or 4mm thick at 1:500.
|
|
|
|
.. seealso:: :py:func:`setSymbologyReferenceScale`
|
|
|
|
.. seealso:: :py:func:`rendererScale`
|
|
|
|
.. versionadded:: 3.22
|
|
%End
|
|
|
|
|
|
|
|
QColor selectionColor() const;
|
|
%Docstring
|
|
Returns the color to use when rendering selected features.
|
|
|
|
.. seealso:: :py:func:`setSelectionColor`
|
|
%End
|
|
|
|
bool showSelection() const;
|
|
%Docstring
|
|
Returns ``True`` if vector selections should be shown in the rendered map
|
|
|
|
:return: ``True`` if selections should be shown
|
|
|
|
.. seealso:: :py:func:`setShowSelection`
|
|
|
|
.. seealso:: :py:func:`selectionColor`
|
|
|
|
.. versionadded:: 2.4
|
|
%End
|
|
|
|
|
|
void setCoordinateTransform( const QgsCoordinateTransform &t );
|
|
%Docstring
|
|
Sets the current coordinate transform for the context.
|
|
|
|
This represents the coordinate transform required to transform the layer
|
|
which is being rendered back to the CRS of the rendered map.
|
|
|
|
Set to an invalid :py:class:`QgsCoordinateTransform` to indicate that no transformation is required.
|
|
|
|
.. seealso:: :py:func:`coordinateTransform`
|
|
%End
|
|
|
|
void setMapToPixel( const QgsMapToPixel &mtp );
|
|
%Docstring
|
|
Sets the context's map to pixel transform, which transforms between map coordinates and device coordinates.
|
|
|
|
.. seealso:: :py:func:`mapToPixel`
|
|
%End
|
|
|
|
void setExtent( const QgsRectangle &extent );
|
|
%Docstring
|
|
When rendering a map layer, calling this method sets the "clipping"
|
|
extent for the layer (in the layer's CRS).
|
|
|
|
This extent should be a "worst-case" scenario, which is guaranteed to
|
|
completely cover the entire visible portion of the layer when it is rendered
|
|
to the map. It may be larger than the actual visible area, but MUST contain at least the
|
|
entire visible area.
|
|
|
|
.. seealso:: :py:func:`setExtent`
|
|
|
|
.. seealso:: :py:func:`setMapExtent`
|
|
%End
|
|
|
|
void setMapExtent( const QgsRectangle &extent );
|
|
%Docstring
|
|
Sets the original ``extent`` of the map being rendered.
|
|
|
|
Unlike :py:func:`~QgsRenderContext.setExtent`, this extent is always in the final destination CRS for the map
|
|
render and represents the exact bounds of the map being rendered.
|
|
|
|
.. seealso:: :py:func:`mapExtent`
|
|
|
|
.. seealso:: :py:func:`setExtent`
|
|
|
|
.. versionadded:: 3.4.8
|
|
%End
|
|
|
|
void setDrawEditingInformation( bool b );
|
|
%Docstring
|
|
Sets whether edit markers should be drawn during the render operation.
|
|
|
|
.. seealso:: :py:func:`drawEditingInformation`
|
|
%End
|
|
|
|
void setRenderingStopped( bool stopped );
|
|
%Docstring
|
|
Sets whether the rendering operation has been ``stopped`` and any ongoing
|
|
rendering should be canceled immediately.
|
|
|
|
.. note::
|
|
|
|
Since QGIS 3.22 the :py:func:`~QgsRenderContext.feedback` member exists as an alternative means of cancellation support.
|
|
|
|
.. seealso:: :py:func:`renderingStopped`
|
|
|
|
.. seealso:: :py:func:`feedback`
|
|
|
|
.. seealso:: :py:func:`setFeedback`
|
|
%End
|
|
|
|
void setDistanceArea( const QgsDistanceArea &distanceArea );
|
|
%Docstring
|
|
A general purpose distance and area calculator, capable of performing ellipsoid based calculations.
|
|
Will be used to convert meter distances to active MapUnit values for :py:class:`QgsUnitTypes`.RenderMetersInMapUnits
|
|
%End
|
|
|
|
void setScaleFactor( double factor );
|
|
%Docstring
|
|
Sets the scaling factor for the render to convert painter units
|
|
to physical sizes. This should usually be equal to the number of pixels
|
|
per millimeter.
|
|
|
|
.. seealso:: :py:func:`scaleFactor`
|
|
%End
|
|
|
|
void setDpiTarget( double dpi );
|
|
%Docstring
|
|
Sets the targeted ``dpi`` for rendering.
|
|
|
|
.. seealso:: :py:func:`dpiTarget`
|
|
|
|
.. versionadded:: 3.20
|
|
%End
|
|
|
|
void setRendererScale( double scale );
|
|
%Docstring
|
|
Sets the renderer map scale. This should match the desired scale denominator
|
|
for the rendered map, eg 1000.0 for a 1:1000 map render.
|
|
|
|
.. seealso:: :py:func:`rendererScale`
|
|
%End
|
|
|
|
void setSymbologyReferenceScale( double scale );
|
|
%Docstring
|
|
Sets the symbology reference ``scale``.
|
|
|
|
This should match the desired scale denominator for the rendered map, eg 1000.0 for a 1:1000 map render.
|
|
Set to -1 to disable symbology scaling by reference scale.
|
|
|
|
The symbology reference scale is an optional property which specifies the reference
|
|
scale at which symbology in paper units (such a millimeters or points) is fixed
|
|
to. For instance, if ``scale`` is set to 1000 then a 2mm thick line will be rendered at
|
|
exactly 2mm thick when a map is rendered at 1:1000, or 1mm thick when rendered at 1:2000, or 4mm thick at 1:500.
|
|
|
|
.. seealso:: :py:func:`symbologyReferenceScale`
|
|
|
|
.. seealso:: :py:func:`rendererScale`
|
|
|
|
.. versionadded:: 3.22
|
|
%End
|
|
|
|
void setPainter( QPainter *p );
|
|
%Docstring
|
|
Sets the destination QPainter for the render operation. Ownership of the painter
|
|
is not transferred and the QPainter destination must stay alive for the duration
|
|
of any rendering operations.
|
|
|
|
.. seealso:: :py:func:`painter`
|
|
%End
|
|
|
|
void setPreviewRenderPainter( QPainter *painter );
|
|
%Docstring
|
|
Sets the destination ``painter`` for temporary in-progress preview renders.
|
|
Ownership of ``painter`` is not transferred and the QPainter destination must
|
|
stay alive for the duration of any rendering operations.
|
|
|
|
``painter`` may be ``None`` if temporary in-progress preview renders are not required.
|
|
|
|
.. seealso:: :py:func:`previewRenderPainter`
|
|
|
|
.. versionadded:: 3.34
|
|
%End
|
|
|
|
void setMaskPainter( QPainter *p, int id = 0 );
|
|
%Docstring
|
|
Sets a mask QPainter for the render operation. Ownership of the painter
|
|
is not transferred and the QPainter must stay alive for the duration
|
|
of any rendering operations.
|
|
Multiple mask painters can be defined and the second parameter gives a unique identifier to each one.
|
|
|
|
.. seealso:: :py:func:`maskPainter`
|
|
%End
|
|
|
|
void setForceVectorOutput( bool force );
|
|
%Docstring
|
|
Sets whether rendering operations should use vector operations instead
|
|
of any faster raster shortcuts.
|
|
|
|
.. seealso:: :py:func:`forceVectorOutput`
|
|
%End
|
|
|
|
|
|
|
|
void setSelectionColor( const QColor &color );
|
|
%Docstring
|
|
Sets the ``color`` to use when rendering selected features.
|
|
|
|
.. seealso:: :py:func:`selectionColor`
|
|
%End
|
|
|
|
void setShowSelection( bool showSelection );
|
|
%Docstring
|
|
Sets whether vector selections should be shown in the rendered map
|
|
|
|
:param showSelection: set to ``True`` if selections should be shown
|
|
|
|
.. seealso:: :py:func:`showSelection`
|
|
|
|
.. seealso:: :py:func:`setSelectionColor`
|
|
|
|
.. versionadded:: 2.4
|
|
%End
|
|
|
|
bool useRenderingOptimization() const;
|
|
%Docstring
|
|
Returns ``True`` if the rendering optimization (geometry simplification) can be executed
|
|
|
|
.. seealso:: :py:func:`setUseRenderingOptimization`
|
|
%End
|
|
|
|
void setUseRenderingOptimization( bool enabled );
|
|
%Docstring
|
|
Sets whether the rendering optimization (geometry simplification) should be executed
|
|
|
|
.. seealso:: :py:func:`useRenderingOptimization`
|
|
%End
|
|
|
|
QgsVectorSimplifyMethod &vectorSimplifyMethod();
|
|
%Docstring
|
|
Returns the simplification settings to use when rendering vector layers.
|
|
|
|
The default is to use no simplification.
|
|
|
|
.. seealso:: :py:func:`setVectorSimplifyMethod`
|
|
%End
|
|
|
|
|
|
void setVectorSimplifyMethod( const QgsVectorSimplifyMethod &simplifyMethod );
|
|
%Docstring
|
|
Sets the simplification setting to use when rendering vector layers.
|
|
|
|
This can be used to specify simplification methods to apply during map exports and renders,
|
|
e.g. to allow vector layers to be simplified to an appropriate maximum level of detail
|
|
during PDF exports or to speed up layer rendering
|
|
|
|
The default is to use no simplification.
|
|
|
|
.. seealso:: :py:func:`vectorSimplifyMethod`
|
|
%End
|
|
|
|
void setExpressionContext( const QgsExpressionContext &context );
|
|
%Docstring
|
|
Sets the expression context. This context is used for all expression evaluation
|
|
associated with this render context.
|
|
|
|
.. seealso:: :py:func:`expressionContext`
|
|
%End
|
|
|
|
QgsExpressionContext &expressionContext();
|
|
%Docstring
|
|
Gets the expression context. This context should be used for all expression evaluation
|
|
associated with this render context.
|
|
|
|
.. seealso:: :py:func:`setExpressionContext`
|
|
%End
|
|
|
|
|
|
const QgsAbstractGeometry *geometry() const;
|
|
%Docstring
|
|
Returns pointer to the unsegmentized geometry
|
|
%End
|
|
void setGeometry( const QgsAbstractGeometry *geometry );
|
|
%Docstring
|
|
Sets pointer to original (unsegmentized) geometry
|
|
%End
|
|
|
|
void setFeatureFilterProvider( const QgsFeatureFilterProvider *ffp );
|
|
%Docstring
|
|
Set a filter feature provider used for additional filtering of rendered features.
|
|
|
|
:param ffp: the filter feature provider
|
|
|
|
.. seealso:: :py:func:`featureFilterProvider`
|
|
%End
|
|
|
|
const QgsFeatureFilterProvider *featureFilterProvider() const;
|
|
%Docstring
|
|
Gets the filter feature provider used for additional filtering of rendered features.
|
|
|
|
:return: the filter feature provider
|
|
|
|
.. seealso:: :py:func:`setFeatureFilterProvider`
|
|
%End
|
|
|
|
void setSegmentationTolerance( double tolerance );
|
|
%Docstring
|
|
Sets the segmentation tolerance applied when rendering curved geometries
|
|
|
|
:param tolerance: the segmentation tolerance
|
|
|
|
.. seealso:: :py:func:`segmentationTolerance`
|
|
|
|
.. seealso:: :py:func:`segmentationToleranceType`
|
|
%End
|
|
|
|
double segmentationTolerance() const;
|
|
%Docstring
|
|
Gets the segmentation tolerance applied when rendering curved geometries
|
|
|
|
.. seealso:: :py:func:`setSegmentationTolerance`
|
|
%End
|
|
|
|
void setSegmentationToleranceType( QgsAbstractGeometry::SegmentationToleranceType type );
|
|
%Docstring
|
|
Sets segmentation tolerance type (maximum angle or maximum difference between curve and approximation)
|
|
|
|
:param type: the segmentation tolerance typename
|
|
|
|
.. seealso:: :py:func:`segmentationToleranceType`
|
|
|
|
.. seealso:: :py:func:`segmentationTolerance`
|
|
%End
|
|
|
|
QgsAbstractGeometry::SegmentationToleranceType segmentationToleranceType() const;
|
|
%Docstring
|
|
Gets segmentation tolerance type (maximum angle or maximum difference between curve and approximation)
|
|
|
|
.. seealso:: :py:func:`setSegmentationToleranceType`
|
|
%End
|
|
|
|
|
|
double convertToPainterUnits( double size, Qgis::RenderUnit unit, const QgsMapUnitScale &scale = QgsMapUnitScale(), Qgis::RenderSubcomponentProperty property = Qgis::RenderSubcomponentProperty::Generic ) const;
|
|
%Docstring
|
|
Converts a size from the specified units to painter units (pixels). The conversion respects the limits
|
|
specified by the optional scale parameter.
|
|
|
|
Since QGIS 3.22 the optional ``property`` argument can be used to specify the associated property. This
|
|
is used in some contexts to refine the converted size. For example, a :py:class:`Qgis`.RenderSubcomponentProperty.BlurSize
|
|
property will be limited to a suitably fast range when the render context has the :py:class:`Qgis`.RenderContextFlag.RenderSymbolPreview set.
|
|
|
|
.. seealso:: :py:func:`convertFromPainterUnits`
|
|
|
|
.. seealso:: :py:func:`convertToMapUnits`
|
|
%End
|
|
|
|
double convertFromPainterUnits( double size, Qgis::RenderUnit unit ) const;
|
|
%Docstring
|
|
Converts a size from painter units (pixels) to the specified render unit.
|
|
|
|
.. seealso:: :py:func:`convertToPainterUnits`
|
|
|
|
.. seealso:: :py:func:`convertToMapUnits`
|
|
|
|
.. versionadded:: 3.40
|
|
%End
|
|
|
|
double convertToMapUnits( double size, Qgis::RenderUnit unit, const QgsMapUnitScale &scale = QgsMapUnitScale() ) const;
|
|
%Docstring
|
|
Converts a size from the specified units to map units. The conversion respects the limits
|
|
specified by the optional scale parameter.
|
|
|
|
.. seealso:: :py:func:`convertToPainterUnits`
|
|
%End
|
|
|
|
double convertFromMapUnits( double sizeInMapUnits, Qgis::RenderUnit outputUnit ) const;
|
|
%Docstring
|
|
Converts a size from map units to the specified units.
|
|
|
|
.. seealso:: :py:func:`convertToMapUnits`
|
|
%End
|
|
|
|
double convertMetersToMapUnits( double meters ) const;
|
|
%Docstring
|
|
Convert meter distances to active MapUnit values for :py:class:`QgsUnitTypes`.RenderMetersInMapUnits
|
|
|
|
.. note::
|
|
|
|
When the :py:func:`~QgsRenderContext.sourceCrs` is geographic, the center of the Extent will be used
|
|
%End
|
|
|
|
Qgis::TextRenderFormat textRenderFormat() const;
|
|
%Docstring
|
|
Returns the text render format, which dictates how text is rendered (e.g. as paths or real text objects).
|
|
|
|
.. seealso:: :py:func:`setTextRenderFormat`
|
|
|
|
.. versionadded:: 3.4.3
|
|
%End
|
|
|
|
void setTextRenderFormat( Qgis::TextRenderFormat format );
|
|
%Docstring
|
|
Sets the text render ``format``, which dictates how text is rendered (e.g. as paths or real text objects).
|
|
|
|
.. seealso:: :py:func:`textRenderFormat`
|
|
|
|
.. versionadded:: 3.4.3
|
|
%End
|
|
|
|
QList<QgsRenderedFeatureHandlerInterface *> renderedFeatureHandlers() const;
|
|
%Docstring
|
|
Returns the list of rendered feature handlers to use while rendering map layers.
|
|
|
|
.. seealso:: :py:func:`hasRenderedFeatureHandlers`
|
|
|
|
.. versionadded:: 3.10
|
|
%End
|
|
|
|
bool hasRenderedFeatureHandlers() const;
|
|
%Docstring
|
|
Returns ``True`` if the context has any rendered feature handlers.
|
|
|
|
.. seealso:: :py:func:`renderedFeatureHandlers`
|
|
|
|
.. versionadded:: 3.10
|
|
%End
|
|
|
|
void setMaskIdProvider( QgsMaskIdProvider *provider );
|
|
%Docstring
|
|
Attaches a mask id provider to the context. It will allow some rendering operations to set the current mask id
|
|
based on the context (label layer names and label rules for instance).
|
|
|
|
.. seealso:: :py:class:`QgsMaskIdProvider`
|
|
|
|
.. seealso:: :py:func:`setCurrentMaskId`
|
|
|
|
.. seealso:: :py:func:`maskIdProvider`
|
|
|
|
.. versionadded:: 3.12
|
|
%End
|
|
|
|
const QgsMaskIdProvider *maskIdProvider() const;
|
|
%Docstring
|
|
Returns the mask id provider attached to the context.
|
|
|
|
.. seealso:: :py:func:`setMaskIdProvider`
|
|
|
|
.. versionadded:: 3.12
|
|
%End
|
|
|
|
void setCurrentMaskId( int id );
|
|
%Docstring
|
|
Stores a mask id as the "current" one.
|
|
|
|
.. seealso:: :py:func:`currentMaskId`
|
|
|
|
.. versionadded:: 3.12
|
|
%End
|
|
|
|
int currentMaskId() const;
|
|
%Docstring
|
|
Returns the current mask id, which can be used with :py:func:`~QgsRenderContext.maskPainter`
|
|
|
|
.. seealso:: :py:func:`setCurrentMaskId`
|
|
|
|
.. seealso:: :py:func:`maskPainter`
|
|
|
|
.. versionadded:: 3.12
|
|
%End
|
|
|
|
void setIsGuiPreview( bool preview );
|
|
%Docstring
|
|
Sets GUI preview mode.
|
|
GUI preview mode is used to change the behavior of some renderings when
|
|
they are done to preview of symbology in the GUI.
|
|
This is especially used to display mask symbol layers rather than painting them
|
|
in a mask painter, which is not meant to be visible, by definition.
|
|
|
|
.. seealso:: :py:func:`isGuiPreview`
|
|
|
|
.. versionadded:: 3.12
|
|
%End
|
|
|
|
bool isGuiPreview() const;
|
|
%Docstring
|
|
Returns the Gui preview mode.
|
|
GUI preview mode is used to change the behavior of some renderings when
|
|
they are done to preview of symbology in the GUI.
|
|
This is especially used to display mask symbol layers rather than painting them
|
|
in a mask painter, which is not meant to be visible, by definition.
|
|
|
|
.. seealso:: :py:func:`isGuiPreview`
|
|
|
|
.. seealso:: :py:func:`setIsGuiPreview`
|
|
|
|
.. versionadded:: 3.12
|
|
%End
|
|
|
|
QVariantMap customRenderingFlags() const /Deprecated/;
|
|
%Docstring
|
|
Gets custom rendering flags. Layers might honour these to alter their rendering.
|
|
|
|
:return: a map of custom flags
|
|
|
|
.. seealso:: :py:func:`setCustomRenderingFlag`
|
|
|
|
.. deprecated:: 3.40
|
|
|
|
Use :py:func:`~QgsRenderContext.customProperties` instead.
|
|
%End
|
|
|
|
QVariantMap customProperties() const;
|
|
%Docstring
|
|
Returns custom rendering properties.
|
|
|
|
Objects might honour these to alter their rendering.
|
|
|
|
.. seealso:: :py:func:`setCustomProperty`
|
|
|
|
.. versionadded:: 3.40
|
|
%End
|
|
|
|
void setCustomRenderingFlag( const QString &flag, const QVariant &value ) /Deprecated/;
|
|
%Docstring
|
|
Sets a custom rendering flag. Layers might honour these to alter their rendering.
|
|
|
|
:param flag: the flag name
|
|
:param value: the flag value
|
|
|
|
.. seealso:: :py:func:`customRenderingFlags`
|
|
|
|
.. deprecated:: 3.40
|
|
|
|
Use :py:func:`~QgsRenderContext.setCustomProperty` instead.
|
|
%End
|
|
|
|
void setCustomProperty( const QString &property, const QVariant &value );
|
|
%Docstring
|
|
Sets a custom rendering property.
|
|
|
|
Objects might honour these to alter their rendering.
|
|
|
|
.. seealso:: :py:func:`customProperties`
|
|
|
|
.. versionadded:: 3.40
|
|
%End
|
|
|
|
void clearCustomRenderingFlag( const QString &flag ) /Deprecated/;
|
|
%Docstring
|
|
Clears the specified custom rendering flag.
|
|
|
|
:param flag: the flag name
|
|
|
|
.. seealso:: :py:func:`setCustomRenderingFlag`
|
|
|
|
.. deprecated:: 3.40
|
|
|
|
Use :py:func:`~QgsRenderContext.clearCustomProperty` instead.
|
|
%End
|
|
|
|
void clearCustomProperty( const QString &property );
|
|
%Docstring
|
|
Clears the specified custom rendering property.
|
|
|
|
.. seealso:: :py:func:`setCustomProperty`
|
|
|
|
.. versionadded:: 3.40
|
|
%End
|
|
|
|
QList< QgsMapClippingRegion > clippingRegions() const;
|
|
%Docstring
|
|
Returns the list of clipping regions to apply during the render.
|
|
|
|
These regions are always in the final destination CRS for the map.
|
|
|
|
.. versionadded:: 3.16
|
|
%End
|
|
|
|
QgsGeometry featureClipGeometry() const;
|
|
%Docstring
|
|
Returns the geometry to use to clip features at render time.
|
|
|
|
When vector features are rendered, they should be clipped to this geometry.
|
|
|
|
.. warning::
|
|
|
|
The clipping must take effect for rendering the feature's symbol only,
|
|
and should never be applied directly to the feature being rendered. Doing so would
|
|
impact the results of rendering rules which rely on feature geometry, such as
|
|
a rule-based renderer using the feature's area.
|
|
|
|
.. seealso:: :py:func:`setFeatureClipGeometry`
|
|
|
|
.. versionadded:: 3.16
|
|
%End
|
|
|
|
void setFeatureClipGeometry( const QgsGeometry &geometry );
|
|
%Docstring
|
|
Sets a ``geometry`` to use to clip features at render time.
|
|
|
|
.. note::
|
|
|
|
This is not usually set directly, but rather specified by calling :py:class:`QgsMapSettings`::py:func:`~QgsRenderContext.addClippingRegion`
|
|
prior to constructing a QgsRenderContext.
|
|
|
|
.. seealso:: :py:func:`featureClipGeometry`
|
|
|
|
.. versionadded:: 3.16
|
|
%End
|
|
|
|
QPointF textureOrigin() const;
|
|
%Docstring
|
|
Returns the texture origin, which should be used as a brush transform when
|
|
rendering using QBrush objects.
|
|
|
|
.. seealso:: :py:func:`setTextureOrigin`
|
|
|
|
.. versionadded:: 3.16
|
|
%End
|
|
|
|
void setTextureOrigin( const QPointF &origin );
|
|
%Docstring
|
|
Sets the texture ``origin``, which should be used as a brush transform when
|
|
rendering using QBrush objects.
|
|
|
|
.. seealso:: :py:func:`textureOrigin`
|
|
|
|
.. versionadded:: 3.16
|
|
%End
|
|
|
|
|
|
QgsMaskRenderSettings &maskSettings();
|
|
%Docstring
|
|
Returns a reference to the mask render settings, which control how masks
|
|
are drawn and behave during render operations.
|
|
|
|
.. seealso:: :py:func:`setMaskSettings`
|
|
|
|
.. versionadded:: 3.38
|
|
%End
|
|
|
|
void setMaskSettings( const QgsMaskRenderSettings &settings );
|
|
%Docstring
|
|
Sets the mask render ``settings``, which control how masks
|
|
are drawn and behave during render operations.
|
|
|
|
.. seealso:: :py:func:`maskSettings`
|
|
|
|
.. versionadded:: 3.38
|
|
%End
|
|
|
|
void addSymbolLayerClipPath( const QString &symbolLayerId, QPainterPath path ) /Deprecated/;
|
|
%Docstring
|
|
Add a clip ``path`` to be applied to the ``symbolLayer`` before rendering
|
|
|
|
.. seealso:: :py:func:`addSymbolLayerClipGeometry`
|
|
|
|
.. deprecated:: 3.38
|
|
|
|
Use :py:func:`~QgsRenderContext.addSymbolLayerClipGeometry` instead.
|
|
%End
|
|
|
|
QList<QPainterPath> symbolLayerClipPaths( const QString &symbolLayerId ) const /Deprecated/;
|
|
%Docstring
|
|
Returns clip paths to be applied to the ``symbolLayer`` before rendering
|
|
|
|
.. seealso:: :py:func:`symbolLayerClipGeometries`
|
|
|
|
.. deprecated:: 3.38
|
|
|
|
Use :py:func:`~QgsRenderContext.symbolLayerClipGeometries` instead.
|
|
%End
|
|
|
|
void addSymbolLayerClipGeometry( const QString &symbolLayerId, const QgsGeometry &geometry );
|
|
%Docstring
|
|
Add a clip ``geometry`` to be applied to the ``symbolLayer`` before rendering.
|
|
|
|
.. seealso:: :py:func:`symbolLayerClipGeometries`
|
|
|
|
.. versionadded:: 3.38
|
|
%End
|
|
|
|
bool symbolLayerHasClipGeometries( const QString &symbolLayerId ) const;
|
|
%Docstring
|
|
Returns ``True`` if the symbol layer with matching ID has any associated clip geometries.
|
|
|
|
.. seealso:: :py:func:`symbolLayerClipGeometries`
|
|
|
|
.. versionadded:: 3.38
|
|
%End
|
|
|
|
QVector<QgsGeometry> symbolLayerClipGeometries( const QString &symbolLayerId ) const;
|
|
%Docstring
|
|
Returns clipping geometries to be applied to the ``symbolLayer`` before rendering
|
|
|
|
.. seealso:: :py:func:`symbolLayerHasClipGeometries`
|
|
|
|
.. seealso:: :py:func:`addSymbolLayerClipGeometry`
|
|
|
|
.. versionadded:: 3.38
|
|
%End
|
|
|
|
QgsDoubleRange zRange() const;
|
|
%Docstring
|
|
Returns the range of z-values which should be rendered.
|
|
|
|
.. seealso:: :py:func:`setZRange`
|
|
|
|
.. versionadded:: 3.18
|
|
%End
|
|
|
|
void setZRange( const QgsDoubleRange &range );
|
|
%Docstring
|
|
Sets the ``range`` of z-values which should be rendered.
|
|
|
|
.. seealso:: :py:func:`zRange`
|
|
|
|
.. versionadded:: 3.18
|
|
%End
|
|
|
|
QSize outputSize() const;
|
|
%Docstring
|
|
Returns the size of the resulting rendered image, in pixels.
|
|
|
|
.. seealso:: :py:func:`deviceOutputSize`
|
|
|
|
.. seealso:: :py:func:`setOutputSize`
|
|
|
|
.. versionadded:: 3.22
|
|
%End
|
|
|
|
void setOutputSize( QSize size );
|
|
%Docstring
|
|
Sets the ``size`` of the resulting rendered image, in pixels.
|
|
|
|
.. seealso:: :py:func:`outputSize`
|
|
|
|
.. versionadded:: 3.22
|
|
%End
|
|
|
|
float devicePixelRatio() const;
|
|
%Docstring
|
|
Returns the device pixel ratio.
|
|
|
|
Common values are 1 for normal-dpi displays and 2 for high-dpi "retina" displays.
|
|
|
|
.. seealso:: :py:func:`setDevicePixelRatio`
|
|
|
|
.. versionadded:: 3.22
|
|
%End
|
|
|
|
void setDevicePixelRatio( float ratio );
|
|
%Docstring
|
|
Sets the device pixel ``ratio``.
|
|
|
|
Common values are 1 for normal-dpi displays and 2 for high-dpi "retina" displays.
|
|
|
|
.. seealso:: :py:func:`devicePixelRatio`
|
|
|
|
.. versionadded:: 3.22
|
|
%End
|
|
|
|
QSize deviceOutputSize() const;
|
|
%Docstring
|
|
Returns the device output size of the render.
|
|
|
|
This is equivalent to the output size multiplicated by the device pixel ratio.
|
|
|
|
.. seealso:: :py:func:`outputSize`
|
|
|
|
.. seealso:: :py:func:`devicePixelRatio`
|
|
|
|
.. seealso:: :py:func:`setOutputSize`
|
|
|
|
.. versionadded:: 3.22
|
|
%End
|
|
|
|
void setImageFormat( QImage::Format format );
|
|
%Docstring
|
|
Sets QImage ``format`` which should be used for QImages created
|
|
during rendering.
|
|
|
|
.. seealso:: :py:func:`imageFormat`
|
|
|
|
.. versionadded:: 3.22
|
|
%End
|
|
|
|
QImage::Format imageFormat() const;
|
|
%Docstring
|
|
Returns the QImage format which should be used for QImages created
|
|
during rendering.
|
|
|
|
.. seealso:: :py:func:`setImageFormat`
|
|
|
|
.. versionadded:: 3.22
|
|
%End
|
|
|
|
Qgis::RendererUsage rendererUsage() const;
|
|
%Docstring
|
|
Returns the renderer usage
|
|
|
|
.. seealso:: :py:func:`setRendererUsage`
|
|
|
|
.. versionadded:: 3.24
|
|
%End
|
|
|
|
void setRendererUsage( Qgis::RendererUsage usage );
|
|
%Docstring
|
|
Sets the renderer usage
|
|
|
|
.. note::
|
|
|
|
This usage not alter how the map gets rendered but the intention is that data provider
|
|
knows the context of rendering and may report that to the backend.
|
|
|
|
.. seealso:: :py:func:`rendererUsage`
|
|
|
|
.. versionadded:: 3.24
|
|
%End
|
|
|
|
double frameRate() const;
|
|
%Docstring
|
|
Returns the frame rate of the map, for maps which are part of an animation.
|
|
|
|
Returns -1 if the map is not associated with an animation.
|
|
|
|
.. seealso:: :py:func:`setFrameRate`
|
|
|
|
.. versionadded:: 3.26
|
|
%End
|
|
|
|
void setFrameRate( double rate );
|
|
%Docstring
|
|
Sets the frame ``rate`` of the map (in frames per second), for maps which are part of an animation.
|
|
|
|
Defaults to -1 if the map is not associated with an animation.
|
|
|
|
.. seealso:: :py:func:`frameRate`
|
|
|
|
.. versionadded:: 3.26
|
|
%End
|
|
|
|
long long currentFrame() const;
|
|
%Docstring
|
|
Returns the current frame number of the map (in frames per second), for maps which are part of an animation.
|
|
|
|
Returns -1 if the map is not associated with an animation.
|
|
|
|
.. seealso:: :py:func:`setCurrentFrame`
|
|
|
|
.. versionadded:: 3.26
|
|
%End
|
|
|
|
void setCurrentFrame( long long frame );
|
|
%Docstring
|
|
Sets the current ``frame`` of the map, for maps which are part of an animation.
|
|
|
|
Defaults to -1 if the map is not associated with an animation.
|
|
|
|
.. seealso:: :py:func:`currentFrame`
|
|
|
|
.. versionadded:: 3.26
|
|
%End
|
|
|
|
|
|
QgsElevationMap *elevationMap() const;
|
|
%Docstring
|
|
Returns the destination elevation map for the render operation.
|
|
|
|
.. seealso:: :py:func:`setElevationMap`
|
|
|
|
.. versionadded:: 3.30
|
|
%End
|
|
|
|
void setElevationMap( QgsElevationMap *map );
|
|
%Docstring
|
|
Sets the destination elevation ``map`` for the render operation. Ownership of the elevation map
|
|
is not transferred and the :py:class:`QgsElevationMap` destination must stay alive for the duration
|
|
of any rendering operations.
|
|
|
|
.. seealso:: :py:func:`elevationMap`
|
|
|
|
.. versionadded:: 3.30
|
|
%End
|
|
|
|
};
|
|
|
|
|
|
/************************************************************************
|
|
* This file has been generated automatically from *
|
|
* *
|
|
* src/core/qgsrendercontext.h *
|
|
* *
|
|
* Do not edit manually ! Edit header and run scripts/sipify.py again *
|
|
************************************************************************/
|