mirror of
https://github.com/qgis/QGIS.git
synced 2025-11-04 00:04:25 -05:00
919 lines
25 KiB
Plaintext
919 lines
25 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 : 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 );
|
|
|
|
enum Flag
|
|
{
|
|
DrawEditingInfo,
|
|
ForceVectorOutput,
|
|
UseAdvancedEffects,
|
|
UseRenderingOptimization,
|
|
DrawSelection,
|
|
DrawSymbolBounds,
|
|
RenderMapTile,
|
|
Antialiasing,
|
|
RenderPartialOutput,
|
|
RenderPreviewJob,
|
|
RenderBlocking,
|
|
RenderSymbolPreview,
|
|
LosslessImageRendering,
|
|
ApplyScalingWorkaroundForTextRendering,
|
|
Render3DMap,
|
|
ApplyClipAfterReprojection,
|
|
};
|
|
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
|
|
|
|
|
|
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
|
|
|
|
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 :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.
|
|
|
|
.. 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
|
|
|
|
.. 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
|
|
|
|
|
|
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.
|
|
|
|
.. 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 :py:class:`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 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 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
|
|
|
|
.. 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
|
|
|
|
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
|
|
|
|
.. 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, 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 :py:class:`QgsUnitTypes`.RenderMetersInMapUnits
|
|
\note
|
|
When the :py:func:`~QgsRenderContext.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 :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;
|
|
%Docstring
|
|
Gets custom rendering flags. Layers might honour these to alter their rendering.
|
|
|
|
:return: a map of custom flags
|
|
|
|
.. seealso:: :py:func:`setCustomRenderingFlag`
|
|
|
|
.. versionadded:: 3.12
|
|
%End
|
|
|
|
void setCustomRenderingFlag( const QString &flag, const QVariant &value );
|
|
%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`
|
|
|
|
.. versionadded:: 3.12
|
|
%End
|
|
|
|
void clearCustomRenderingFlag( const QString &flag );
|
|
%Docstring
|
|
Clears the specified custom rendering flag.
|
|
|
|
:param flag: the flag name
|
|
|
|
.. seealso:: :py:func:`setCustomRenderingFlag`
|
|
|
|
.. versionadded:: 3.12
|
|
%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
|
|
|
|
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
|
|
|
|
};
|
|
|
|
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 *
|
|
************************************************************************/
|