mirror of
https://github.com/qgis/QGIS.git
synced 2025-10-25 00:05:24 -04:00
249 lines
7.4 KiB
Plaintext
249 lines
7.4 KiB
Plaintext
/************************************************************************
|
|
* This file has been generated automatically from *
|
|
* *
|
|
* src/core/qgssnappingutils.h *
|
|
* *
|
|
* Do not edit manually ! Edit header and run scripts/sipify.py again *
|
|
************************************************************************/
|
|
|
|
|
|
|
|
|
|
|
|
class QgsSnappingUtils : QObject
|
|
{
|
|
%Docstring(signature="appended")
|
|
This class has all the configuration of snapping and can return answers to snapping queries.
|
|
|
|
Internally, it keeps a cache of :py:class:`QgsPointLocator` instances for multiple layers.
|
|
|
|
Currently it supports the following queries:
|
|
|
|
- :py:func:`~snapToMap` - has multiple modes of operation
|
|
- :py:func:`~snapToCurrentLayer`
|
|
|
|
For more complex queries it is possible to use :py:func:`~locatorForLayer` method that returns
|
|
point locator instance with layer's indexed data.
|
|
|
|
Indexing strategy determines how fast the queries will be and how much memory will be used.
|
|
|
|
When working with map canvas, it may be useful to use derived class :py:class:`QgsMapCanvasSnappingUtils`
|
|
which keeps the configuration in sync with map canvas (e.g. current view, active layer).
|
|
%End
|
|
|
|
%TypeHeaderCode
|
|
#include "qgssnappingutils.h"
|
|
%End
|
|
public:
|
|
|
|
QgsSnappingUtils( QObject *parent /TransferThis/ = 0, bool enableSnappingForInvisibleFeature = true );
|
|
%Docstring
|
|
Constructor for QgsSnappingUtils
|
|
|
|
:param parent: parent object
|
|
:param enableSnappingForInvisibleFeature: ``True`` if we want to snap feature even if there are not visible
|
|
%End
|
|
~QgsSnappingUtils();
|
|
|
|
|
|
QgsPointLocator *locatorForLayer( QgsVectorLayer *vl );
|
|
%Docstring
|
|
Gets a point locator for the given layer. If such locator does not exist, it will be created
|
|
|
|
:param vl: the vector layer
|
|
%End
|
|
|
|
QgsPointLocator::Match snapToMap( QPoint point, QgsPointLocator::MatchFilter *filter = 0, bool relaxed = false );
|
|
%Docstring
|
|
Snap to map according to the current configuration.
|
|
|
|
:param point: point in canvas coordinates
|
|
:param filter: allows discarding unwanted matches.
|
|
:param relaxed: ``True`` if this method is non blocking and the matching result can be invalid while indexing
|
|
%End
|
|
|
|
QgsPointLocator::Match snapToMap( const QgsPointXY &pointMap, QgsPointLocator::MatchFilter *filter = 0, bool relaxed = false );
|
|
%Docstring
|
|
Snap to map according to the current configuration.
|
|
|
|
:param pointMap: point in map coordinates
|
|
:param filter: allows discarding unwanted matches.
|
|
:param relaxed: ``True`` if this method is non blocking and the matching result can be invalid while indexing
|
|
%End
|
|
|
|
QgsPointLocator::Match snapToCurrentLayer( QPoint point, QgsPointLocator::Types type, QgsPointLocator::MatchFilter *filter = 0 );
|
|
%Docstring
|
|
Snap to current layer
|
|
%End
|
|
|
|
|
|
void setMapSettings( const QgsMapSettings &settings );
|
|
%Docstring
|
|
Assign current map settings to the utils - used for conversion between screen coords to map coords
|
|
%End
|
|
QgsMapSettings mapSettings() const;
|
|
|
|
void setCurrentLayer( QgsVectorLayer *layer );
|
|
%Docstring
|
|
Sets current layer so that if mode is SnapCurrentLayer we know which layer to use
|
|
%End
|
|
QgsVectorLayer *currentLayer() const;
|
|
%Docstring
|
|
The current layer used if mode is SnapCurrentLayer
|
|
%End
|
|
|
|
|
|
enum IndexingStrategy
|
|
{
|
|
IndexAlwaysFull,
|
|
IndexNeverFull,
|
|
IndexHybrid,
|
|
IndexExtent
|
|
};
|
|
|
|
void setIndexingStrategy( IndexingStrategy strategy );
|
|
%Docstring
|
|
Sets a strategy for indexing geometry data - determines how fast and memory consuming the data structures will be
|
|
%End
|
|
IndexingStrategy indexingStrategy() const;
|
|
%Docstring
|
|
Find out which strategy is used for indexing - by default hybrid indexing is used
|
|
%End
|
|
|
|
struct LayerConfig
|
|
{
|
|
|
|
LayerConfig( QgsVectorLayer *l, QgsPointLocator::Types t, double tol, Qgis::MapToolUnit u );
|
|
%Docstring
|
|
Create a new configuration for a snapping layer.
|
|
|
|
.. code-block:: python
|
|
|
|
snapper = QgsMapCanvasSnappingUtils(mapCanvas)
|
|
|
|
snapping_layer1 = QgsSnappingUtils.LayerConfig(layer1, QgsPointLocator.Vertex, 10, Qgis::MapToolUnit::Pixels)
|
|
snapping_layer2 = QgsSnappingUtils.LayerConfig(layer2, QgsPointLocator.Vertex and QgsPointLocator.Edge, 10, Qgis::MapToolUnit::Pixels)
|
|
|
|
snapper.setLayers([snapping_layer1, snapping_layer2])
|
|
|
|
:param l: The vector layer for which this configuration is
|
|
:param t: Which parts of the geometry should be snappable
|
|
:param tol: The tolerance radius in which the snapping will trigger
|
|
:param u: The unit in which the tolerance is specified
|
|
%End
|
|
|
|
bool operator==( const QgsSnappingUtils::LayerConfig &other ) const;
|
|
bool operator!=( const QgsSnappingUtils::LayerConfig &other ) const;
|
|
|
|
QgsVectorLayer *layer;
|
|
QgsPointLocator::Types type;
|
|
double tolerance;
|
|
Qgis::MapToolUnit unit;
|
|
};
|
|
|
|
QList<QgsSnappingUtils::LayerConfig> layers() const;
|
|
%Docstring
|
|
Query layers used for snapping
|
|
%End
|
|
|
|
QString dump();
|
|
%Docstring
|
|
Gets extra information about the instance
|
|
%End
|
|
|
|
QgsSnappingConfig config() const;
|
|
%Docstring
|
|
The snapping configuration controls the behavior of this object
|
|
%End
|
|
|
|
void setEnableSnappingForInvisibleFeature( bool enable );
|
|
%Docstring
|
|
Set if invisible features must be snapped or not.
|
|
|
|
:param enable: Enable or not this feature
|
|
|
|
.. versionadded:: 3.2
|
|
%End
|
|
|
|
void addExtraSnapLayer( QgsVectorLayer *vl );
|
|
%Docstring
|
|
Supply an extra snapping layer (typically a memory layer).
|
|
This can be used by map tools to provide additional
|
|
snappings points.
|
|
|
|
.. seealso:: :py:func:`removeExtraSnapLayer`
|
|
|
|
.. seealso:: :py:func:`getExtraSnapLayers`
|
|
|
|
.. versionadded:: 3.14
|
|
%End
|
|
|
|
void removeExtraSnapLayer( QgsVectorLayer *vl );
|
|
%Docstring
|
|
Removes an extra snapping layer
|
|
|
|
.. seealso:: :py:func:`addExtraSnapLayer`
|
|
|
|
.. seealso:: :py:func:`getExtraSnapLayers`
|
|
|
|
.. versionadded:: 3.14
|
|
%End
|
|
|
|
QSet<QgsVectorLayer *> getExtraSnapLayers();
|
|
%Docstring
|
|
Returns the list of extra snapping layers
|
|
|
|
.. seealso:: :py:func:`addExtraSnapLayer`
|
|
|
|
.. seealso:: :py:func:`removeExtraSnapLayer`
|
|
|
|
.. versionadded:: 3.14
|
|
%End
|
|
|
|
|
|
public slots:
|
|
|
|
void setConfig( const QgsSnappingConfig &snappingConfig );
|
|
%Docstring
|
|
The snapping configuration controls the behavior of this object
|
|
%End
|
|
|
|
void toggleEnabled();
|
|
%Docstring
|
|
Toggles the state of snapping
|
|
%End
|
|
|
|
signals:
|
|
|
|
void configChanged( const QgsSnappingConfig &snappingConfig );
|
|
%Docstring
|
|
Emitted when the snapping settings object changes.
|
|
%End
|
|
|
|
protected:
|
|
|
|
virtual void prepareIndexStarting( int count );
|
|
%Docstring
|
|
Called when starting to index with snapToMap - can be overridden and e.g. progress dialog can be provided
|
|
%End
|
|
virtual void prepareIndexProgress( int index );
|
|
%Docstring
|
|
Called when finished indexing a layer with snapToMap. When index == count the indexing is complete
|
|
%End
|
|
|
|
void clearAllLocators();
|
|
%Docstring
|
|
Deletes all existing locators (e.g. when destination CRS has changed and we need to reindex)
|
|
%End
|
|
|
|
};
|
|
|
|
|
|
/************************************************************************
|
|
* This file has been generated automatically from *
|
|
* *
|
|
* src/core/qgssnappingutils.h *
|
|
* *
|
|
* Do not edit manually ! Edit header and run scripts/sipify.py again *
|
|
************************************************************************/
|