mirror of
https://github.com/qgis/QGIS.git
synced 2025-02-28 00:17:30 -05:00
845894b313
* [FEATURE] Selective masking Advanced rendering feature that allows the definition of 'masks' areas around labels or with a new typ of symbol layer. These masks will "un-draw" symbol layers of other layers underneath. It modifies the rendering process by adding an optional second pass.
743 lines
20 KiB
Plaintext
743 lines
20 KiB
Plaintext
/************************************************************************
|
|
* This file has been generated automatically from *
|
|
* *
|
|
* src/core/qgsrendercontext.h *
|
|
* *
|
|
* Do not edit manually ! Edit header and run scripts/sipify.pl again *
|
|
************************************************************************/
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class QgsRenderContext
|
|
{
|
|
%Docstring
|
|
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( const QgsRenderContext &rh );
|
|
|
|
enum Flag
|
|
{
|
|
DrawEditingInfo,
|
|
ForceVectorOutput,
|
|
UseAdvancedEffects,
|
|
UseRenderingOptimization,
|
|
DrawSelection,
|
|
DrawSymbolBounds,
|
|
RenderMapTile,
|
|
Antialiasing,
|
|
RenderPartialOutput,
|
|
RenderPreviewJob,
|
|
RenderBlocking,
|
|
};
|
|
typedef QFlags<QgsRenderContext::Flag> Flags;
|
|
|
|
|
|
enum TextRenderFormat
|
|
{
|
|
// refs for below dox: https://github.com/qgis/QGIS/pull/1286#issuecomment-39806854
|
|
// https://github.com/qgis/QGIS/pull/8573#issuecomment-445585826
|
|
|
|
TextFormatAlwaysOutlines,
|
|
|
|
TextFormatAlwaysText,
|
|
};
|
|
|
|
void setFlags( QgsRenderContext::Flags flags );
|
|
%Docstring
|
|
Set combination of flags that will be used for rendering.
|
|
|
|
.. versionadded:: 2.14
|
|
%End
|
|
|
|
void setFlag( Flag flag, bool on = true );
|
|
%Docstring
|
|
Enable or disable a particular flag (other flags are not affected)
|
|
|
|
.. versionadded:: 2.14
|
|
%End
|
|
|
|
Flags flags() const;
|
|
%Docstring
|
|
Returns combination of flags used for rendering.
|
|
|
|
.. versionadded:: 2.14
|
|
%End
|
|
|
|
bool testFlag( Flag flag ) const;
|
|
%Docstring
|
|
Check whether a particular flag is enabled.
|
|
|
|
.. versionadded:: 2.14
|
|
%End
|
|
|
|
static QgsRenderContext fromMapSettings( const QgsMapSettings &mapSettings );
|
|
%Docstring
|
|
create initialized QgsRenderContext instance from given :py:class:`QgsMapSettings`
|
|
|
|
.. versionadded:: 2.4
|
|
%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.
|
|
|
|
.. versionadded:: 3.0
|
|
%End
|
|
|
|
|
|
QPainter *painter();
|
|
%Docstring
|
|
Returns the destination QPainter for the render operation.
|
|
|
|
.. seealso:: :py:func:`setPainter`
|
|
%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
|
|
|
|
QSet<const QgsSymbolLayer *> disabledSymbolLayers() 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 layers.
|
|
|
|
.. seealso:: :py:func:`setDisabledSymbolLayers`
|
|
|
|
.. seealso:: :py:func:`isSymbolLayerEnabled`
|
|
|
|
.. versionadded:: 3.12
|
|
%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.
|
|
|
|
.. versionadded:: 3.0
|
|
%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`
|
|
|
|
.. versionadded:: 3.0
|
|
%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`
|
|
|
|
.. versionadded:: 3.0
|
|
%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`
|
|
|
|
.. versionadded:: 3.0
|
|
%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`
|
|
|
|
.. versionadded:: 3.0
|
|
%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 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
|
|
|
|
bool renderingStopped() const;
|
|
%Docstring
|
|
Returns ``True`` if the rendering operation has been stopped and any ongoing
|
|
rendering should be canceled immediately.
|
|
|
|
.. seealso:: :py:func:`setRenderingStopped`
|
|
%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
|
|
%End
|
|
|
|
void setUseAdvancedEffects( bool enabled );
|
|
%Docstring
|
|
Used to enable or disable advanced effects such as blend modes
|
|
%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
|
|
|
|
|
|
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 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 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.
|
|
|
|
.. seealso:: :py:func:`renderingStopped`
|
|
%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 QgsUnitTypes.RenderMetersInMapUnits
|
|
|
|
.. versionadded:: 3.0
|
|
%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 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 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 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 setDisabledSymbolLayers( const QSet<const QgsSymbolLayer *> &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 layers.
|
|
|
|
.. seealso:: :py:func:`disabledSymbolLayers`
|
|
|
|
.. seealso:: :py:func:`isSymbolLayerEnabled`
|
|
|
|
.. versionadded:: 3.12
|
|
%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
|
|
%End
|
|
|
|
void setUseRenderingOptimization( bool enabled );
|
|
|
|
const QgsVectorSimplifyMethod &vectorSimplifyMethod() const;
|
|
%Docstring
|
|
Returns the simplification settings to use when rendering vector layers.
|
|
|
|
The default is to use no simplification.
|
|
|
|
.. seealso:: :py:func:`setVectorSimplifyMethod`
|
|
|
|
.. versionadded:: 2.4
|
|
%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`
|
|
|
|
.. versionadded:: 2.4
|
|
%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`
|
|
|
|
.. versionadded:: 2.12
|
|
%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`
|
|
|
|
.. versionadded:: 2.12
|
|
%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`
|
|
|
|
.. versionadded:: 2.14
|
|
%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`
|
|
|
|
.. versionadded:: 2.14
|
|
%End
|
|
|
|
void setSegmentationTolerance( double tolerance );
|
|
%Docstring
|
|
Sets the segmentation tolerance applied when rendering curved geometries
|
|
|
|
:param tolerance: the segmentation tolerance*
|
|
%End
|
|
double segmentationTolerance() const;
|
|
%Docstring
|
|
Gets the segmentation tolerance applied when rendering curved geometries
|
|
%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*
|
|
%End
|
|
QgsAbstractGeometry::SegmentationToleranceType segmentationToleranceType() const;
|
|
%Docstring
|
|
Gets segmentation tolerance type (maximum angle or maximum difference between curve and approximation)
|
|
%End
|
|
|
|
|
|
double convertToPainterUnits( double size, QgsUnitTypes::RenderUnit unit, const QgsMapUnitScale &scale = QgsMapUnitScale() ) const;
|
|
%Docstring
|
|
Converts a size from the specified units to painter units (pixels). The conversion respects the limits
|
|
specified by the optional scale parameter.
|
|
|
|
.. seealso:: :py:func:`convertToMapUnits`
|
|
|
|
.. versionadded:: 3.0
|
|
%End
|
|
|
|
double convertToMapUnits( double size, QgsUnitTypes::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`
|
|
|
|
.. versionadded:: 3.0
|
|
%End
|
|
|
|
double convertFromMapUnits( double sizeInMapUnits, QgsUnitTypes::RenderUnit outputUnit ) const;
|
|
%Docstring
|
|
Converts a size from map units to the specified units.
|
|
|
|
.. seealso:: :py:func:`convertToMapUnits`
|
|
|
|
.. versionadded:: 3.0
|
|
%End
|
|
|
|
double convertMetersToMapUnits( double meters ) const;
|
|
%Docstring
|
|
Convert meter distances to active MapUnit values for QgsUnitTypes.RenderMetersInMapUnits
|
|
\note
|
|
When the sourceCrs() is geographic, the center of the Extent will be used
|
|
|
|
.. versionadded:: 3.0
|
|
%End
|
|
|
|
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( 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 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
|
|
|
|
};
|
|
|
|
QFlags<QgsRenderContext::Flag> operator|(QgsRenderContext::Flag f1, QFlags<QgsRenderContext::Flag> f2);
|
|
|
|
|
|
/************************************************************************
|
|
* This file has been generated automatically from *
|
|
* *
|
|
* src/core/qgsrendercontext.h *
|
|
* *
|
|
* Do not edit manually ! Edit header and run scripts/sipify.pl again *
|
|
************************************************************************/
|