mirror of
https://github.com/qgis/QGIS.git
synced 2025-03-18 00:02:24 -04:00
aaddfedda8
Fix #15823 Also reenable instant map refresh as map rotation changes. Since map refresh is done in the background now, this is safe to reenable.
576 lines
17 KiB
Plaintext
576 lines
17 KiB
Plaintext
/************************************************************************
|
|
* This file has been generated automatically from *
|
|
* *
|
|
* src/core/composer/qgscomposermap.h *
|
|
* *
|
|
* Do not edit manually ! Edit header and run scripts/sipify.pl again *
|
|
************************************************************************/
|
|
|
|
|
|
|
|
|
|
|
|
class QgsComposerMap : QgsComposerItem
|
|
{
|
|
%Docstring
|
|
Object representing map window.
|
|
%End
|
|
|
|
%TypeHeaderCode
|
|
#include "qgscomposermap.h"
|
|
%End
|
|
public:
|
|
QgsComposerMap( QgsComposition *composition /TransferThis/, int x, int y, int width, int height );
|
|
%Docstring
|
|
Constructor.
|
|
%End
|
|
QgsComposerMap( QgsComposition *composition /TransferThis/ );
|
|
%Docstring
|
|
Constructor. Settings are read from project.
|
|
%End
|
|
virtual ~QgsComposerMap();
|
|
|
|
virtual int type() const;
|
|
%Docstring
|
|
Return correct graphics item type.
|
|
:rtype: int
|
|
%End
|
|
|
|
enum AtlasScalingMode
|
|
{
|
|
Fixed,
|
|
|
|
Predefined,
|
|
|
|
Auto
|
|
};
|
|
|
|
void draw( QPainter *painter, const QgsRectangle &extent, QSizeF size, double dpi, double *forceWidthScale = 0 );
|
|
%Docstring
|
|
Draw to paint device
|
|
\param painter painter
|
|
\param extent map extent
|
|
\param size size in scene coordinates
|
|
\param dpi scene dpi
|
|
\param forceWidthScale force wysiwyg line widths / marker sizes
|
|
%End
|
|
|
|
virtual void paint( QPainter *painter, const QStyleOptionGraphicsItem *itemStyle, QWidget *pWidget );
|
|
|
|
|
|
QgsMapSettings mapSettings( const QgsRectangle &extent, QSizeF size, int dpi ) const;
|
|
%Docstring
|
|
Return map settings that would be used for drawing of the map
|
|
.. versionadded:: 2.6
|
|
:rtype: QgsMapSettings
|
|
%End
|
|
|
|
int id() const;
|
|
%Docstring
|
|
Get identification number
|
|
:rtype: int
|
|
%End
|
|
|
|
bool isDrawing() const;
|
|
%Docstring
|
|
True if a draw is already in progress
|
|
:rtype: bool
|
|
%End
|
|
|
|
void resize( double dx, double dy );
|
|
%Docstring
|
|
Resizes an item in x- and y direction (canvas coordinates)
|
|
%End
|
|
|
|
virtual void moveContent( double dx, double dy );
|
|
|
|
%Docstring
|
|
Move content of map
|
|
\param dx move in x-direction (item and canvas coordinates)
|
|
\param dy move in y-direction (item and canvas coordinates)
|
|
%End
|
|
|
|
virtual void zoomContent( const double factor, const QPointF point, const ZoomMode mode = QgsComposerItem::Zoom );
|
|
%Docstring
|
|
Zoom content of item. Does nothing per default (but implemented in composer map)
|
|
\param factor zoom factor, where > 1 results in a zoom in and < 1 results in a zoom out
|
|
\param point item point for zoom center
|
|
\param mode zoom mode
|
|
.. versionadded:: 2.5
|
|
%End
|
|
|
|
virtual void setSceneRect( const QRectF &rectangle );
|
|
|
|
%Docstring
|
|
Sets new scene rectangle bounds and recalculates hight and extent
|
|
%End
|
|
|
|
double scale() const;
|
|
%Docstring
|
|
Scale
|
|
:rtype: float
|
|
%End
|
|
|
|
void setNewScale( double scaleDenominator, bool forceUpdate = true );
|
|
%Docstring
|
|
Sets new scale and changes only mExtent
|
|
%End
|
|
|
|
void setNewExtent( const QgsRectangle &extent );
|
|
%Docstring
|
|
Sets new extent for the map. This method may change the width or height of the map
|
|
item to ensure that the extent exactly matches the specified extent, with no
|
|
overlap or margin. This method implicitly alters the map scale.
|
|
\param extent new extent for the map
|
|
.. seealso:: zoomToExtent
|
|
%End
|
|
|
|
void zoomToExtent( const QgsRectangle &extent );
|
|
%Docstring
|
|
Zooms the map so that the specified extent is fully visible within the map item.
|
|
This method will not change the width or height of the map, and may result in
|
|
an overlap or margin from the specified extent. This method implicitly alters the
|
|
map scale.
|
|
\param extent new extent for the map
|
|
.. seealso:: setNewExtent
|
|
.. versionadded:: 2.5
|
|
%End
|
|
|
|
void setNewAtlasFeatureExtent( const QgsRectangle &extent );
|
|
%Docstring
|
|
Sets new Extent for the current atlas preview and changes width, height (and implicitly also scale).
|
|
Atlas preview extents are only temporary, and are regenerated whenever the atlas feature changes
|
|
%End
|
|
|
|
const QgsRectangle *currentMapExtent() const;
|
|
%Docstring
|
|
Returns a pointer to the current map extent, which is either the original user specified
|
|
extent or the temporary atlas-driven feature extent depending on the current atlas state
|
|
of the composition. Both a const and non-const version are included.
|
|
:return: pointer to current map extent
|
|
.. seealso:: visibleExtentPolygon
|
|
:rtype: QgsRectangle
|
|
%End
|
|
|
|
|
|
QgsCoordinateReferenceSystem crs() const;
|
|
%Docstring
|
|
Returns coordinate reference system used for rendering the map.
|
|
This will match the presetCrs() if that is set, or if a preset
|
|
CRS is not set then the map's CRS will follow the composition's
|
|
project's CRS.
|
|
.. versionadded:: 3.0
|
|
.. seealso:: presetCrs()
|
|
.. seealso:: setCrs()
|
|
:rtype: QgsCoordinateReferenceSystem
|
|
%End
|
|
|
|
QgsCoordinateReferenceSystem presetCrs() const;
|
|
%Docstring
|
|
Returns the map's preset coordinate reference system. If set, this
|
|
CRS will be used to render the map regardless of any project CRS
|
|
setting. If the returned CRS is not valid then the project CRS
|
|
will be used to render the map.
|
|
.. versionadded:: 3.0
|
|
.. seealso:: crs()
|
|
.. seealso:: setCrs()
|
|
:rtype: QgsCoordinateReferenceSystem
|
|
%End
|
|
|
|
void setCrs( const QgsCoordinateReferenceSystem &crs );
|
|
%Docstring
|
|
Sets the map's preset coordinate reference system. If a valid CRS is
|
|
set, this CRS will be used to render the map regardless of any project CRS
|
|
setting. If the CRS is not valid then the project CRS will be used to render the map.
|
|
.. seealso:: crs()
|
|
.. seealso:: presetCrs()
|
|
.. versionadded:: 3.0
|
|
%End
|
|
|
|
bool keepLayerSet() const;
|
|
%Docstring
|
|
Getter for flag that determines if a stored layer set should be used
|
|
or the current layer set of the QGIS map canvas. This is just a GUI flag,
|
|
and itself does not change which layers are rendered in the map.
|
|
Instead, use setLayers() to control which layers are rendered.
|
|
.. seealso:: setKeepLayerSet()
|
|
.. seealso:: layers()
|
|
:rtype: bool
|
|
%End
|
|
|
|
void setKeepLayerSet( bool enabled );
|
|
%Docstring
|
|
Setter for flag that determines if the stored layer set should be used
|
|
or the current layer set of the QGIS map canvas. This is just a GUI flag,
|
|
and itself does not change which layers are rendered in the map.
|
|
Instead, use setLayers() to control which layers are rendered.
|
|
.. seealso:: keepLayerSet()
|
|
.. seealso:: layers()
|
|
%End
|
|
|
|
QList<QgsMapLayer *> layers() const;
|
|
%Docstring
|
|
Getter for stored layer set. If empty, the current canvas layers will
|
|
be used instead.
|
|
.. seealso:: setLayers()
|
|
.. seealso:: keepLayerSet()
|
|
:rtype: list of QgsMapLayer
|
|
%End
|
|
|
|
void setLayers( const QList<QgsMapLayer *> &layers );
|
|
%Docstring
|
|
Setter for stored layer set. If empty, the current canvas layers will
|
|
be used instead.
|
|
.. seealso:: layers()
|
|
.. seealso:: keepLayerSet()
|
|
%End
|
|
|
|
bool keepLayerStyles() const;
|
|
%Docstring
|
|
.. versionadded:: 2.8
|
|
:rtype: bool
|
|
%End
|
|
void setKeepLayerStyles( bool enabled );
|
|
%Docstring
|
|
.. versionadded:: 2.8
|
|
%End
|
|
|
|
QMap<QString, QString> layerStyleOverrides() const;
|
|
%Docstring
|
|
.. versionadded:: 2.8
|
|
:rtype: QMap<str, QString>
|
|
%End
|
|
void setLayerStyleOverrides( const QMap<QString, QString> &overrides );
|
|
%Docstring
|
|
.. versionadded:: 2.8
|
|
%End
|
|
void storeCurrentLayerStyles();
|
|
%Docstring
|
|
.. versionadded:: 2.8
|
|
%End
|
|
|
|
bool followVisibilityPreset() const;
|
|
%Docstring
|
|
Whether the map should follow a map theme. If true, the layers and layer styles
|
|
will be used from given preset name (configured with setFollowVisibilityPresetName() method).
|
|
This means when preset's settings are changed, the new settings are automatically
|
|
picked up next time when rendering, without having to explicitly update them.
|
|
At most one of the flags keepLayerSet() and followVisibilityPreset() should be enabled
|
|
at any time since they are alternative approaches - if both are enabled,
|
|
following map theme has higher priority. If neither is enabled (or if preset name is not set),
|
|
map will use the same configuration as the map canvas uses.
|
|
.. versionadded:: 2.16
|
|
:rtype: bool
|
|
%End
|
|
|
|
void setFollowVisibilityPreset( bool follow );
|
|
%Docstring
|
|
Sets whether the map should follow a map theme. See followVisibilityPreset() for more details.
|
|
.. versionadded:: 2.16
|
|
%End
|
|
|
|
QString followVisibilityPresetName() const;
|
|
%Docstring
|
|
Preset name that decides which layers and layer styles are used for map rendering. It is only
|
|
used when followVisibilityPreset() returns true.
|
|
.. versionadded:: 2.16
|
|
:rtype: str
|
|
%End
|
|
|
|
void setFollowVisibilityPresetName( const QString &name );
|
|
%Docstring
|
|
Sets preset name for map rendering. See followVisibilityPresetName() for more details.
|
|
.. versionadded:: 2.16
|
|
%End
|
|
|
|
QgsRectangle extent() const;
|
|
%Docstring
|
|
:rtype: QgsRectangle
|
|
%End
|
|
|
|
void setOffset( double xOffset, double yOffset );
|
|
%Docstring
|
|
Sets offset values to shift image (useful for live updates when moving item content)
|
|
%End
|
|
|
|
bool containsWmsLayer() const;
|
|
%Docstring
|
|
True if composer map renders a WMS layer
|
|
:rtype: bool
|
|
%End
|
|
|
|
bool containsAdvancedEffects() const;
|
|
%Docstring
|
|
True if composer map contains layers with blend modes or flattened layers for vectors
|
|
:rtype: bool
|
|
%End
|
|
|
|
virtual bool writeXml( QDomElement &elem, QDomDocument &doc ) const;
|
|
|
|
%Docstring
|
|
Stores state in Dom node
|
|
\param elem is Dom element corresponding to 'Composer' tag
|
|
\param doc Dom document
|
|
:rtype: bool
|
|
%End
|
|
|
|
virtual bool readXml( const QDomElement &itemElem, const QDomDocument &doc );
|
|
|
|
%Docstring
|
|
Sets state from Dom document
|
|
\param itemElem is Dom node corresponding to 'ComposerMap' tag
|
|
\param doc is Dom document
|
|
:rtype: bool
|
|
%End
|
|
|
|
QgsComposerMapGridStack *grids();
|
|
%Docstring
|
|
Returns the map item's grid stack, which is used to control how grids
|
|
are drawn over the map's contents.
|
|
:return: pointer to grid stack
|
|
.. seealso:: grid()
|
|
.. versionadded:: 2.5
|
|
:rtype: QgsComposerMapGridStack
|
|
%End
|
|
|
|
QgsComposerMapGrid *grid();
|
|
%Docstring
|
|
Returns the map item's first grid. This is a convenience function.
|
|
:return: pointer to first grid for map item
|
|
.. seealso:: grids()
|
|
.. versionadded:: 2.5
|
|
:rtype: QgsComposerMapGrid
|
|
%End
|
|
|
|
QgsComposerMapOverviewStack *overviews();
|
|
%Docstring
|
|
Returns the map item's overview stack, which is used to control how overviews
|
|
are drawn over the map's contents.
|
|
:return: pointer to overview stack
|
|
.. seealso:: overview()
|
|
.. versionadded:: 2.5
|
|
:rtype: QgsComposerMapOverviewStack
|
|
%End
|
|
|
|
QgsComposerMapOverview *overview();
|
|
%Docstring
|
|
Returns the map item's first overview. This is a convenience function.
|
|
:return: pointer to first overview for map item
|
|
.. seealso:: overviews()
|
|
.. versionadded:: 2.5
|
|
:rtype: QgsComposerMapOverview
|
|
%End
|
|
|
|
virtual QRectF boundingRect() const;
|
|
|
|
%Docstring
|
|
In case of annotations, the bounding rectangle can be larger than the map item rectangle
|
|
:rtype: QRectF
|
|
%End
|
|
|
|
virtual void setFrameStrokeWidth( const double strokeWidth );
|
|
%Docstring
|
|
reimplement setFrameStrokeWidth, so that updateBoundingRect() is called after setting the frame width */
|
|
%End
|
|
|
|
void setMapRotation( double rotation );
|
|
%Docstring
|
|
Sets the ``rotation`` for the map - this does not affect the composer item shape, only the
|
|
way the map is drawn within the item. Rotation is in degrees, clockwise.
|
|
.. versionadded:: 2.1
|
|
.. seealso:: mapRotation()
|
|
%End
|
|
|
|
double mapRotation( QgsComposerObject::PropertyValueType valueType = QgsComposerObject::EvaluatedValue ) const;
|
|
%Docstring
|
|
Returns the rotation used for drawing the map within the composer item, in degrees clockwise.
|
|
\param valueType controls whether the returned value is the user specified rotation,
|
|
or the current evaluated rotation (which may be affected by data driven rotation
|
|
settings).
|
|
.. seealso:: setMapRotation()
|
|
:rtype: float
|
|
%End
|
|
|
|
void setDrawAnnotations( bool draw );
|
|
%Docstring
|
|
Sets whether annotations are drawn within the composer map.
|
|
.. seealso:: drawAnnotations()
|
|
%End
|
|
|
|
bool drawAnnotations() const;
|
|
%Docstring
|
|
Returns whether annotations are drawn within the composer map.
|
|
.. seealso:: setDrawAnnotations()
|
|
:rtype: bool
|
|
%End
|
|
|
|
double mapUnitsToMM() const;
|
|
%Docstring
|
|
Returns the conversion factor map units -> mm
|
|
:rtype: float
|
|
%End
|
|
|
|
void assignFreeId();
|
|
%Docstring
|
|
Sets mId to a number not yet used in the composition. mId is kept if it is not in use.
|
|
Usually, this function is called before adding the composer map to the composition*
|
|
%End
|
|
|
|
bool atlasDriven() const;
|
|
%Docstring
|
|
Returns whether the map extent is set to follow the current atlas feature.
|
|
:return: true if map will follow the current atlas feature.
|
|
.. seealso:: setAtlasDriven
|
|
.. seealso:: atlasScalingMode
|
|
:rtype: bool
|
|
%End
|
|
|
|
void setAtlasDriven( bool enabled );
|
|
%Docstring
|
|
Sets whether the map extent will follow the current atlas feature.
|
|
\param enabled set to true if the map extents should be set by the current atlas feature.
|
|
.. seealso:: atlasDriven
|
|
.. seealso:: setAtlasScalingMode
|
|
%End
|
|
|
|
AtlasScalingMode atlasScalingMode() const;
|
|
%Docstring
|
|
Returns the current atlas scaling mode. This controls how the map's extents
|
|
are calculated for the current atlas feature when an atlas composition
|
|
is enabled.
|
|
:return: the current scaling mode
|
|
.. note::
|
|
|
|
this parameter is only used if atlasDriven() is true
|
|
.. seealso:: setAtlasScalingMode
|
|
.. seealso:: atlasDriven
|
|
:rtype: AtlasScalingMode
|
|
%End
|
|
|
|
void setAtlasScalingMode( AtlasScalingMode mode );
|
|
%Docstring
|
|
Sets the current atlas scaling mode. This controls how the map's extents
|
|
are calculated for the current atlas feature when an atlas composition
|
|
is enabled.
|
|
\param mode atlas scaling mode to set
|
|
.. note::
|
|
|
|
this parameter is only used if atlasDriven() is true
|
|
.. seealso:: atlasScalingMode
|
|
.. seealso:: atlasDriven
|
|
%End
|
|
|
|
double atlasMargin( const QgsComposerObject::PropertyValueType valueType = QgsComposerObject::EvaluatedValue );
|
|
%Docstring
|
|
Returns the margin size (percentage) used when the map is in atlas mode.
|
|
\param valueType controls whether the returned value is the user specified atlas margin,
|
|
or the current evaluated atlas margin (which may be affected by data driven atlas margin
|
|
settings).
|
|
:return: margin size in percentage to leave around the atlas feature's extent
|
|
.. note::
|
|
|
|
this is only used if atlasScalingMode() is Auto.
|
|
.. seealso:: atlasScalingMode
|
|
.. seealso:: setAtlasMargin
|
|
:rtype: float
|
|
%End
|
|
|
|
void setAtlasMargin( double margin );
|
|
%Docstring
|
|
Sets the margin size (percentage) used when the map is in atlas mode.
|
|
\param margin size in percentage to leave around the atlas feature's extent
|
|
.. note::
|
|
|
|
this is only used if atlasScalingMode() is Auto.
|
|
.. seealso:: atlasScalingMode
|
|
.. seealso:: atlasMargin
|
|
%End
|
|
|
|
virtual int numberExportLayers() const;
|
|
|
|
%Docstring
|
|
Get the number of layers that this item requires for exporting as layers
|
|
:return: 0 if this item is to be placed on the same layer as the previous item,
|
|
1 if it should be placed on its own layer, and >1 if it requires multiple export layers
|
|
.. versionadded:: 2.4
|
|
:rtype: int
|
|
%End
|
|
|
|
QPolygonF visibleExtentPolygon() const;
|
|
%Docstring
|
|
Returns a polygon representing the current visible map extent, considering map extents and rotation.
|
|
If the map rotation is 0, the result is the same as currentMapExtent
|
|
:return: polygon with the four corner points representing the visible map extent. The points are
|
|
clockwise, starting at the top-left point
|
|
.. seealso:: currentMapExtent
|
|
:rtype: QPolygonF
|
|
%End
|
|
|
|
virtual QString displayName() const;
|
|
|
|
QPolygonF transformedMapPolygon() const;
|
|
%Docstring
|
|
Returns extent that considers rotation and shift with mOffsetX / mOffsetY
|
|
:rtype: QPolygonF
|
|
%End
|
|
|
|
QPointF mapToItemCoords( QPointF mapCoords ) const;
|
|
%Docstring
|
|
Transforms map coordinates to item coordinates (considering rotation and move offset)
|
|
:rtype: QPointF
|
|
%End
|
|
|
|
void requestedExtent( QgsRectangle &extent ) const;
|
|
%Docstring
|
|
Calculates the extent to request and the yShift of the top-left point in case of rotation.
|
|
.. versionadded:: 2.6
|
|
%End
|
|
|
|
virtual QgsExpressionContext createExpressionContext() const;
|
|
|
|
signals:
|
|
void extentChanged();
|
|
|
|
void mapRotationChanged( double newRotation );
|
|
%Docstring
|
|
Is emitted on rotation change to notify north arrow pictures
|
|
%End
|
|
|
|
void preparedForAtlas();
|
|
%Docstring
|
|
Is emitted when the map has been prepared for atlas rendering, just before actual rendering
|
|
%End
|
|
|
|
void layerStyleOverridesChanged();
|
|
%Docstring
|
|
Emitted when layer style overrides are changed... a means to let
|
|
associated legend items know they should update
|
|
.. versionadded:: 2.10
|
|
%End
|
|
|
|
public slots:
|
|
|
|
void invalidateCache();
|
|
%Docstring
|
|
Forces a deferred update of the cached map image on next paint.
|
|
.. versionadded:: 3.0
|
|
%End
|
|
|
|
void updateBoundingRect();
|
|
%Docstring
|
|
Updates the bounding rect of this item. Call this function before doing any changes related to annotation out of the map rectangle
|
|
%End
|
|
|
|
virtual void refreshDataDefinedProperty( const QgsComposerObject::DataDefinedProperty property = QgsComposerObject::AllProperties, const QgsExpressionContext *context = 0 );
|
|
|
|
};
|
|
|
|
|
|
/************************************************************************
|
|
* This file has been generated automatically from *
|
|
* *
|
|
* src/core/composer/qgscomposermap.h *
|
|
* *
|
|
* Do not edit manually ! Edit header and run scripts/sipify.pl again *
|
|
************************************************************************/
|