sharpetronics/QGIS
1
0
Fork 0
mirror of https://github.com/qgis/QGIS.git synced 2025-12-15 00:07:25 -05:00
Code Issues Packages Projects Releases Wiki Activity

move QgsTolerance::UnitType to Qgis::MapUnitType (#53347)

Browse Source 
* move QgsTolerance::UnitType to Qgis::MapUnitType

* missing forward declaration

* forward declaration

* use MapToolUnit

* forward declaration

* sipify

* fix tests

* Apply suggestions from code review

Co-authored-by: Nyall Dawson <nyall.dawson@gmail.com>

* forward declaration

* forward declaration

* forward declaration

* sipify

* fix missing parenthesis

---------

Co-authored-by: Nyall Dawson <nyall.dawson@gmail.com>
This commit is contained in:
Denis Rouzaud 2023-06-06 18:33:50 +02:00 committed by GitHub
parent 479d66ab69
commit 5bccd556e2
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
55 changed files with 223 additions and 171 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
python/core/auto_additions/qgis.py
View File

@ -3107,6 +3107,22 @@ QgsUnitTypes.USCSSystem.__doc__ = "United States customary system"
Qgis.SystemOfMeasurement.__doc__ = 'Systems of unit measurement.\n\n.. note::\n\n Prior to QGIS 3.30 this was available as :py:class:`QgsUnitTypes`.SystemOfMeasurement.\n\n.. versionadded:: 3.30\n\n' + '* ``UnknownSystem``: ' + Qgis.SystemOfMeasurement.Unknown.__doc__ + '\n' + '* ``MetricSystem``: ' + Qgis.SystemOfMeasurement.Metric.__doc__ + '\n' + '* ``ImperialSystem``: ' + Qgis.SystemOfMeasurement.Imperial.__doc__ + '\n' + '* ``USCSSystem``: ' + Qgis.SystemOfMeasurement.USCS.__doc__
# --
Qgis.SystemOfMeasurement.baseClass = Qgis
QgsTolerance.UnitType = Qgis.MapToolUnit
# monkey patching scoped based enum
QgsTolerance.LayerUnits = Qgis.MapToolUnit.Layer
QgsTolerance.UnitType.LayerUnits = Qgis.MapToolUnit.Layer
QgsTolerance.LayerUnits.is_monkey_patched = True
QgsTolerance.LayerUnits.__doc__ = "Layer unit value"
QgsTolerance.Pixels = Qgis.MapToolUnit.Pixels
QgsTolerance.Pixels.is_monkey_patched = True
QgsTolerance.Pixels.__doc__ = "Pixels unit of tolerance"
QgsTolerance.ProjectUnits = Qgis.MapToolUnit.Project
QgsTolerance.UnitType.ProjectUnits = Qgis.MapToolUnit.Project
QgsTolerance.ProjectUnits.is_monkey_patched = True
QgsTolerance.ProjectUnits.__doc__ = "Map (project) units"
Qgis.MapToolUnit.__doc__ = 'Type of unit of tolerance value from settings.\nFor map (project) units, use MapToolUnit.Project.\n\n.. versionadded:: 3.32\n\n' + '* ``LayerUnits``: ' + Qgis.MapToolUnit.Layer.__doc__ + '\n' + '* ``Pixels``: ' + Qgis.MapToolUnit.Pixels.__doc__ + '\n' + '* ``ProjectUnits``: ' + Qgis.MapToolUnit.Project.__doc__
# --
Qgis.MapToolUnit.baseClass = Qgis
QgsUnitTypes.UnitType = Qgis.UnitType
# monkey patching scoped based enum
QgsUnitTypes.TypeDistance = Qgis.UnitType.Distance

2
python/core/auto_additions/qgstolerance.py
View File

@ -1,2 +0,0 @@
# The following has been generated automatically from src/core/qgstolerance.h
QgsTolerance.UnitType.baseClass = QgsTolerance

1
python/core/auto_generated/expression/qgsexpressioncontextutils.sip.in
View File

@ -9,6 +9,7 @@
class QgsExpressionContextUtils
{
%Docstring(signature="appended")

1
python/core/auto_generated/labeling/qgslabelingresults.sip.in
View File

@ -9,6 +9,7 @@
class QgsLabelingResults
{
%Docstring(signature="appended")

9
python/core/auto_generated/qgis.sip.in
View File

@ -1863,6 +1863,13 @@ The development version
USCS,
};
enum class MapToolUnit
{
Layer,
Pixels,
Project
};
enum class UnitType
{
Distance,
@ -2114,7 +2121,7 @@ The development version
static const double DEFAULT_SNAP_TOLERANCE;
static const QgsTolerance::UnitType DEFAULT_SNAP_UNITS;
static const Qgis::MapToolUnit DEFAULT_SNAP_UNITS;
static QString defaultProjectScales();
%Docstring

2
python/core/auto_generated/qgsmaplayerelevationproperties.sip.in
View File

@ -11,6 +11,8 @@
class QgsMapLayerElevationProperties : QObject
{
%Docstring(signature="appended")

2
python/core/auto_generated/qgsmaplayerfactory.sip.in
View File

@ -10,6 +10,8 @@
class QgsMapLayerFactory
{
%Docstring(signature="appended")

1
python/core/auto_generated/qgsogcutils.sip.in
View File

@ -10,6 +10,7 @@
class QgsOgcUtils
{
%Docstring(signature="appended")

12
python/core/auto_generated/qgssnappingconfig.sip.in
View File

@ -93,7 +93,7 @@ This is a container of advanced configuration (per layer) of the snapping of the
%End
public:
IndividualLayerSettings( bool enabled, SnappingType type, double tolerance, QgsTolerance::UnitType units ) /Deprecated/;
IndividualLayerSettings( bool enabled, SnappingType type, double tolerance, Qgis::MapToolUnit units ) /Deprecated/;
%Docstring
IndividualLayerSettings
@ -106,7 +106,7 @@ IndividualLayerSettings
use the method with :py:class:`Qgis`.SnappingTypes instead.
%End
IndividualLayerSettings( bool enabled, Qgis::SnappingTypes type, double tolerance, QgsTolerance::UnitType units, double minScale = 0.0, double maxScale = 0.0 );
IndividualLayerSettings( bool enabled, Qgis::SnappingTypes type, double tolerance, Qgis::MapToolUnit units, double minScale = 0.0, double maxScale = 0.0 );
%Docstring
IndividualLayerSettings
@ -180,12 +180,12 @@ Returns the tolerance
Sets the tolerance
%End
QgsTolerance::UnitType units() const;
Qgis::MapToolUnit units() const;
%Docstring
Returns the type of units
%End
void setUnits( QgsTolerance::UnitType units );
void setUnits( Qgis::MapToolUnit units );
%Docstring
Sets the type of units
%End
@ -338,12 +338,12 @@ Returns the scale dependency mode
.. versionadded:: 3.14
%End
QgsTolerance::UnitType units() const;
Qgis::MapToolUnit units() const;
%Docstring
Returns the type of units
%End
void setUnits( QgsTolerance::UnitType units );
void setUnits( Qgis::MapToolUnit units );
%Docstring
Sets the type of units
%End

8
python/core/auto_generated/qgssnappingutils.sip.in
View File

@ -115,7 +115,7 @@ Find out which strategy is used for indexing - by default hybrid indexing is use
struct LayerConfig
{
LayerConfig( QgsVectorLayer *l, QgsPointLocator::Types t, double tol, QgsTolerance::UnitType u );
LayerConfig( QgsVectorLayer *l, QgsPointLocator::Types t, double tol, Qgis::MapToolUnit u );
%Docstring
Create a new configuration for a snapping layer.
@ -123,8 +123,8 @@ Create a new configuration for a snapping layer.
snapper = QgsMapCanvasSnappingUtils(mapCanvas)
snapping_layer1 = QgsSnappingUtils.LayerConfig(layer1, QgsPointLocator.Vertex, 10, QgsTolerance.Pixels)
snapping_layer2 = QgsSnappingUtils.LayerConfig(layer2, QgsPointLocator.Vertex and QgsPointLocator.Edge, 10, QgsTolerance.Pixels)
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])
@ -140,7 +140,7 @@ Create a new configuration for a snapping layer.
QgsVectorLayer *layer;
QgsPointLocator::Types type;
double tolerance;
QgsTolerance::UnitType unit;
Qgis::MapToolUnit unit;
};
QList<QgsSnappingUtils::LayerConfig> layers() const;

14
python/core/auto_generated/qgstolerance.sip.in
View File

@ -24,16 +24,6 @@ This is the class is providing tolerance value in map unit values.
public:
enum UnitType
{
//! Layer unit value
LayerUnits,
//! Pixels unit of tolerance
Pixels,
//! Map (project) units. Added in 2.8
ProjectUnits
};
static double vertexSearchRadius( const QgsMapSettings &mapSettings );
%Docstring
Static function to get vertex tolerance value.
@ -60,7 +50,7 @@ The value is read from settings and transformed if necessary.
:return: value of default tolerance in layer units
%End
static double toleranceInProjectUnits( double tolerance, QgsMapLayer *layer, const QgsMapSettings &mapSettings, QgsTolerance::UnitType units );
static double toleranceInProjectUnits( double tolerance, QgsMapLayer *layer, const QgsMapSettings &mapSettings, Qgis::MapToolUnit units );
%Docstring
Static function to translate tolerance value into map units
@ -74,7 +64,7 @@ Static function to translate tolerance value into map units
.. versionadded:: 2.8
%End
static double toleranceInMapUnits( double tolerance, QgsMapLayer *layer, const QgsMapSettings &mapSettings, UnitType units = LayerUnits );
static double toleranceInMapUnits( double tolerance, QgsMapLayer *layer, const QgsMapSettings &mapSettings, Qgis::MapToolUnit units = Qgis::MapToolUnit::Layer );
%Docstring
Static function to translate tolerance value into layer units

14
python/gui/auto_additions/qgsadvanceddigitizingfloater.py Normal file
View File

@ -0,0 +1,14 @@
# The following has been generated automatically from src/gui/qgsadvanceddigitizingfloater.h
# monkey patching scoped based enum
QgsAdvancedDigitizingFloater.FloaterItem.XCoordinate.__doc__ = ""
QgsAdvancedDigitizingFloater.FloaterItem.YCoordinate.__doc__ = ""
QgsAdvancedDigitizingFloater.FloaterItem.MCoordinate.__doc__ = ""
QgsAdvancedDigitizingFloater.FloaterItem.ZCoordinate.__doc__ = ""
QgsAdvancedDigitizingFloater.FloaterItem.Angle.__doc__ = ""
QgsAdvancedDigitizingFloater.FloaterItem.CommonAngleSnapping.__doc__ = ""
QgsAdvancedDigitizingFloater.FloaterItem.Distance.__doc__ = ""
QgsAdvancedDigitizingFloater.FloaterItem.Bearing.__doc__ = ""
QgsAdvancedDigitizingFloater.FloaterItem.__doc__ = 'Available floater items\n\n' + '* ``XCoordinate``: ' + QgsAdvancedDigitizingFloater.FloaterItem.XCoordinate.__doc__ + '\n' + '* ``YCoordinate``: ' + QgsAdvancedDigitizingFloater.FloaterItem.YCoordinate.__doc__ + '\n' + '* ``MCoordinate``: ' + QgsAdvancedDigitizingFloater.FloaterItem.MCoordinate.__doc__ + '\n' + '* ``ZCoordinate``: ' + QgsAdvancedDigitizingFloater.FloaterItem.ZCoordinate.__doc__ + '\n' + '* ``Angle``: ' + QgsAdvancedDigitizingFloater.FloaterItem.Angle.__doc__ + '\n' + '* ``CommonAngleSnapping``: ' + QgsAdvancedDigitizingFloater.FloaterItem.CommonAngleSnapping.__doc__ + '\n' + '* ``Distance``: ' + QgsAdvancedDigitizingFloater.FloaterItem.Distance.__doc__ + '\n' + '* ``Bearing``: ' + QgsAdvancedDigitizingFloater.FloaterItem.Bearing.__doc__
# --
QgsAdvancedDigitizingFloater.FloaterItem.baseClass = QgsAdvancedDigitizingFloater
FloaterItem = QgsAdvancedDigitizingFloater # dirty hack since SIP seems to introduce the flags in module

1
python/gui/auto_generated/symbology/qgssymbolwidgetcontext.sip.in
View File

@ -9,7 +9,6 @@
class QgsSymbolWidgetContext
{
%Docstring(signature="appended")

12
src/app/options/qgsoptions.cpp
View File

@ -1077,8 +1077,8 @@ QgsOptions::QgsOptions( QWidget *parent, Qt::WindowFlags fl, const QList<QgsOpti
mDefaultSnappingToleranceSpinBox->setClearValue( QgsSettingsRegistryCore::settingsDigitizingDefaultSnappingTolerance->defaultValue() );
mSearchRadiusVertexEditSpinBox->setValue( QgsSettingsRegistryCore::settingsDigitizingSearchRadiusVertexEdit->value() );
mSearchRadiusVertexEditSpinBox->setClearValue( QgsSettingsRegistryCore::settingsDigitizingSearchRadiusVertexEdit->defaultValue() );
QgsTolerance::UnitType defSnapUnits = QgsSettingsRegistryCore::settingsDigitizingDefaultSnappingToleranceUnit->value();
if ( defSnapUnits == QgsTolerance::ProjectUnits || defSnapUnits == QgsTolerance::LayerUnits )
Qgis::MapToolUnit defSnapUnits = QgsSettingsRegistryCore::settingsDigitizingDefaultSnappingToleranceUnit->value();
if ( defSnapUnits == Qgis::MapToolUnit::Project || defSnapUnits == Qgis::MapToolUnit::Layer )
{
index = mDefaultSnappingToleranceComboBox->findText( tr( "map units" ) );
}
@ -1087,8 +1087,8 @@ QgsOptions::QgsOptions( QWidget *parent, Qt::WindowFlags fl, const QList<QgsOpti
index = mDefaultSnappingToleranceComboBox->findText( tr( "pixels" ) );
}
mDefaultSnappingToleranceComboBox->setCurrentIndex( index );
QgsTolerance::UnitType defRadiusUnits = QgsSettingsRegistryCore::settingsDigitizingSearchRadiusVertexEditUnit->value();
if ( defRadiusUnits == QgsTolerance::ProjectUnits || defRadiusUnits == QgsTolerance::LayerUnits )
Qgis::MapToolUnit defRadiusUnits = QgsSettingsRegistryCore::settingsDigitizingSearchRadiusVertexEditUnit->value();
if ( defRadiusUnits == Qgis::MapToolUnit::Project || defRadiusUnits == Qgis::MapToolUnit::Layer )
{
index = mSearchRadiusVertexEditComboBox->findText( tr( "map units" ) );
}
@ -1740,9 +1740,9 @@ void QgsOptions::saveOptions()
QgsSettingsRegistryCore::settingsDigitizingDefaultSnappingTolerance->setValue( mDefaultSnappingToleranceSpinBox->value() );
QgsSettingsRegistryCore::settingsDigitizingSearchRadiusVertexEdit->setValue( mSearchRadiusVertexEditSpinBox->value() );
QgsSettingsRegistryCore::settingsDigitizingDefaultSnappingToleranceUnit->setValue(
( mDefaultSnappingToleranceComboBox->currentIndex() == 0 ? QgsTolerance::ProjectUnits : QgsTolerance::Pixels ) );
( mDefaultSnappingToleranceComboBox->currentIndex() == 0 ? Qgis::MapToolUnit::Project : Qgis::MapToolUnit::Pixels ) );
QgsSettingsRegistryCore::settingsDigitizingSearchRadiusVertexEditUnit->setValue(
( mSearchRadiusVertexEditComboBox->currentIndex() == 0 ? QgsTolerance::ProjectUnits : QgsTolerance::Pixels ) );
( mSearchRadiusVertexEditComboBox->currentIndex() == 0 ? Qgis::MapToolUnit::Project : Qgis::MapToolUnit::Pixels ) );
QgsSettingsRegistryCore::settingsDigitizingSnapColor->setValue( mSnappingMarkerColorButton->color() );
QgsSettingsRegistryCore::settingsDigitizingSnapTooltip->setValue( mSnappingTooltipsCheckbox->isChecked() );

1
src/app/qgsgeometryvalidationdock.h
View File

@ -25,6 +25,7 @@ class QgsGeometryValidationModel;
class QgsGeometryValidationService;
class QgsRubberBand;
class QgisApp;
class QgsMapLayer;
class QgsVectorLayer;
/**

18
src/app/qgsmaptoolsimplify.cpp
View File

@ -41,9 +41,9 @@ QgsSimplifyUserInputWidget::QgsSimplifyUserInputWidget( QWidget *parent )
mMethodComboBox->addItem( tr( "Simplify by Area (Visvalingam)" ), QgsMapToolSimplify::SimplifyVisvalingam );
mMethodComboBox->addItem( tr( "Smooth" ), QgsMapToolSimplify::Smooth );
mToleranceUnitsComboBox->addItem( tr( "Layer Units" ), QgsTolerance::LayerUnits );
mToleranceUnitsComboBox->addItem( tr( "Pixels" ), QgsTolerance::Pixels );
mToleranceUnitsComboBox->addItem( tr( "Map Units" ), QgsTolerance::ProjectUnits );
mToleranceUnitsComboBox->addItem( tr( "Layer Units" ), QVariant::fromValue( Qgis::MapToolUnit::Layer ) );
mToleranceUnitsComboBox->addItem( tr( "Pixels" ), QVariant::fromValue( Qgis::MapToolUnit::Pixels ) );
mToleranceUnitsComboBox->addItem( tr( "Map Units" ), QVariant::fromValue( Qgis::MapToolUnit::Project ) );
mToleranceSpinBox->setShowClearButton( false );
@ -56,7 +56,7 @@ QgsSimplifyUserInputWidget::QgsSimplifyUserInputWidget( QWidget *parent )
// communication with map tool
connect( mToleranceSpinBox, static_cast < void ( QDoubleSpinBox::* )( double ) > ( &QDoubleSpinBox::valueChanged ), this, &QgsSimplifyUserInputWidget::toleranceChanged );
connect( mToleranceUnitsComboBox, static_cast<void ( QComboBox::* )( int )>( &QComboBox::currentIndexChanged ), this, [ = ]( const int index ) {emit toleranceUnitsChanged( ( QgsTolerance::UnitType )index );} );
connect( mToleranceUnitsComboBox, static_cast<void ( QComboBox::* )( int )>( &QComboBox::currentIndexChanged ), this, [ = ]( int ) {emit toleranceUnitsChanged( mToleranceUnitsComboBox->currentData().value<Qgis::MapToolUnit>() );} );
connect( mMethodComboBox, static_cast<void ( QComboBox::* )( int )>( &QComboBox::currentIndexChanged ), this, [ = ]( const int method ) {emit methodChanged( ( QgsMapToolSimplify::Method )method );} );
connect( mMethodComboBox, static_cast<void ( QComboBox::* )( int )>( &QComboBox::currentIndexChanged ), this, [ = ]
{
@ -81,14 +81,14 @@ QgsSimplifyUserInputWidget::QgsSimplifyUserInputWidget( QWidget *parent )
void QgsSimplifyUserInputWidget::setConfig( QgsMapToolSimplify::Method method,
double tolerance,
QgsTolerance::UnitType units,
Qgis::MapToolUnit units,
double smoothOffset,
int smoothIterations )
{
mMethodComboBox->setCurrentIndex( mMethodComboBox->findData( method ) );
mToleranceSpinBox->setValue( tolerance );
mToleranceUnitsComboBox->setCurrentIndex( mToleranceUnitsComboBox->findData( units ) );
mToleranceUnitsComboBox->setCurrentIndex( mToleranceUnitsComboBox->findData( QVariant::fromValue( units ) ) );
mOffsetSpin->setValue( 100 * smoothOffset );
mIterationsSpin->setValue( smoothIterations );
}
@ -142,7 +142,7 @@ QgsMapToolSimplify::QgsMapToolSimplify( QgsMapCanvas *canvas )
{
const QgsSettings settings;
mTolerance = settings.value( QStringLiteral( "digitizing/simplify_tolerance" ), 1 ).toDouble();
mToleranceUnits = static_cast< QgsTolerance::UnitType >( settings.value( QStringLiteral( "digitizing/simplify_tolerance_units" ), 0 ).toInt() );
mToleranceUnits = static_cast< Qgis::MapToolUnit >( settings.value( QStringLiteral( "digitizing/simplify_tolerance_units" ), 0 ).toInt() );
mMethod = static_cast< QgsMapToolSimplify::Method >( settings.value( QStringLiteral( "digitizing/simplify_method" ), 0 ).toInt() );
mSmoothIterations = settings.value( QStringLiteral( "digitizing/smooth_iterations" ), 1 ).toInt();
mSmoothOffset = settings.value( QStringLiteral( "digitizing/smooth_offset" ), 0.25 ).toDouble();
@ -165,12 +165,12 @@ void QgsMapToolSimplify::setTolerance( double tolerance )
updateSimplificationPreview();
}
void QgsMapToolSimplify::setToleranceUnits( QgsTolerance::UnitType units )
void QgsMapToolSimplify::setToleranceUnits( Qgis::MapToolUnit units )
{
mToleranceUnits = units;
QgsSettings settings;
settings.setValue( QStringLiteral( "digitizing/simplify_tolerance_units" ), units );
settings.setValue( QStringLiteral( "digitizing/simplify_tolerance_units" ), QVariant::fromValue( units ) );
if ( !mSelectedFeatures.isEmpty() )
updateSimplificationPreview();

10
src/app/qgsmaptoolsimplify.h
View File

@ -58,7 +58,7 @@ class APP_EXPORT QgsMapToolSimplify: public QgsMapToolEdit
double tolerance() const { return mTolerance; }
QgsTolerance::UnitType toleranceUnits() const { return mToleranceUnits; }
Qgis::MapToolUnit toleranceUnits() const { return mToleranceUnits; }
QString statusText() const;
@ -74,7 +74,7 @@ class APP_EXPORT QgsMapToolSimplify: public QgsMapToolEdit
//! Slot to change display when slidebar is moved
void setTolerance( double tolerance );
void setToleranceUnits( QgsTolerance::UnitType units );
void setToleranceUnits( Qgis::MapToolUnit units );
//! Slot to store feature after simplification
void storeSimplified();
@ -110,7 +110,7 @@ class APP_EXPORT QgsMapToolSimplify: public QgsMapToolEdit
//! Real value of tolerance
double mTolerance = 1.0;
QgsTolerance::UnitType mToleranceUnits = QgsTolerance::LayerUnits;
Qgis::MapToolUnit mToleranceUnits = Qgis::MapToolUnit::Layer;
//! stores actual selection rect
QRect mSelectionRect;
@ -142,14 +142,14 @@ class APP_EXPORT QgsSimplifyUserInputWidget : public QWidget, private Ui::Simpli
void enableOkButton( bool enabled );
void setConfig( QgsMapToolSimplify::Method method, double tolerance,
QgsTolerance::UnitType units, double smoothOffset,
Qgis::MapToolUnit units, double smoothOffset,
int smoothIterations );
signals:
void accepted();
void rejected();
void toleranceChanged( double tolerance );
void toleranceUnitsChanged( QgsTolerance::UnitType units );
void toleranceUnitsChanged( Qgis::MapToolUnit units );
void methodChanged( QgsMapToolSimplify::Method method );
void smoothOffsetChanged( double offset );
void smoothIterationsChanged( int iterations );

20
src/app/qgssnappinglayertreemodel.cpp
View File

@ -70,8 +70,8 @@ QWidget *QgsSnappingLayerDelegate::createEditor( QWidget *parent, const QStyleOp
const QVariant val = index.model()->data( index.model()->sibling( index.row(), QgsSnappingLayerTreeModel::UnitsColumn, index ), Qt::UserRole );
if ( val.isValid() )
{
const QgsTolerance::UnitType units = static_cast<QgsTolerance::UnitType>( val.toInt() );
if ( units == QgsTolerance::Pixels )
const Qgis::MapToolUnit units = static_cast<Qgis::MapToolUnit>( val.toInt() );
if ( units == Qgis::MapToolUnit::Pixels )
{
w->setDecimals( 0 );
}
@ -91,8 +91,8 @@ QWidget *QgsSnappingLayerDelegate::createEditor( QWidget *parent, const QStyleOp
if ( index.column() == QgsSnappingLayerTreeModel::UnitsColumn )
{
QComboBox *w = new QComboBox( parent );
w->addItem( tr( "px" ), QgsTolerance::Pixels );
w->addItem( QgsUnitTypes::toString( mCanvas->mapSettings().mapUnits() ), QgsTolerance::ProjectUnits );
w->addItem( tr( "px" ), QVariant::fromValue( Qgis::MapToolUnit::Pixels ) );
w->addItem( QgsUnitTypes::toString( mCanvas->mapSettings().mapUnits() ), QVariant::fromValue( Qgis::MapToolUnit::Project ) );
return w;
}
@ -149,11 +149,11 @@ void QgsSnappingLayerDelegate::setEditorData( QWidget *editor, const QModelIndex
}
else if ( index.column() == QgsSnappingLayerTreeModel::UnitsColumn )
{
const QgsTolerance::UnitType units = static_cast<QgsTolerance::UnitType>( val.toInt() );
const Qgis::MapToolUnit units = static_cast<Qgis::MapToolUnit>( val.toInt() );
QComboBox *w = qobject_cast<QComboBox *>( editor );
if ( w )
{
w->setCurrentIndex( w->findData( units ) );
w->setCurrentIndex( w->findData( QVariant::fromValue( units ) ) );
}
}
else if ( index.column() == QgsSnappingLayerTreeModel::MinScaleColumn )
@ -611,9 +611,9 @@ QVariant QgsSnappingLayerTreeModel::data( const QModelIndex &idx, int role ) con
{
switch ( ls.units() )
{
case QgsTolerance::Pixels:
case Qgis::MapToolUnit::Pixels:
return tr( "pixels" );
case QgsTolerance::ProjectUnits:
case Qgis::MapToolUnit::Project:
return QgsUnitTypes::toString( mCanvas->mapSettings().mapUnits() );
default:
return QVariant();
@ -622,7 +622,7 @@ QVariant QgsSnappingLayerTreeModel::data( const QModelIndex &idx, int role ) con
if ( role == Qt::UserRole )
{
return ls.units();
return QVariant::fromValue( ls.units() );
}
}
@ -784,7 +784,7 @@ bool QgsSnappingLayerTreeModel::setData( const QModelIndex &index, const QVarian
if ( !ls.valid() )
return false;
ls.setUnits( static_cast<QgsTolerance::UnitType>( value.toInt() ) );
ls.setUnits( static_cast<Qgis::MapToolUnit>( value.toInt() ) );
QgsSnappingConfig config = mProject->snappingConfig();
config.setIndividualLayerSettings( vl, ls );
mProject->setSnappingConfig( config );

12
src/app/qgssnappingwidget.cpp
View File

@ -203,10 +203,10 @@ QgsSnappingWidget::QgsSnappingWidget( QgsProject *project, QgsMapCanvas *canvas,
// units
mUnitsComboBox = new QComboBox();
mUnitsComboBox->addItem( tr( "px" ), QgsTolerance::Pixels );
mUnitsComboBox->addItem( tr( "px" ), QVariant::fromValue( Qgis::MapToolUnit::Pixels ) );
// Get canvas units
const QString mapCanvasDistanceUnits { QgsUnitTypes::toString( mCanvas->mapSettings().mapUnits() ) };
mUnitsComboBox->addItem( mapCanvasDistanceUnits, QgsTolerance::ProjectUnits );
mUnitsComboBox->addItem( mapCanvasDistanceUnits, QVariant::fromValue( Qgis::MapToolUnit::Project ) );
mUnitsComboBox->setToolTip( tr( "Snapping Unit Type: Pixels (px) or Project/Map Units (%1)" ).arg( mapCanvasDistanceUnits ) );
mUnitsComboBox->setObjectName( QStringLiteral( "SnappingUnitComboBox" ) );
connect( mUnitsComboBox, qOverload<int>( &QComboBox::currentIndexChanged ),
@ -446,9 +446,9 @@ void QgsSnappingWidget::projectSnapSettingsChanged()
mTypeButton->setDefaultAction( action );
}
if ( static_cast<QgsTolerance::UnitType>( mUnitsComboBox->currentData().toInt() ) != config.units() )
if ( static_cast<Qgis::MapToolUnit>( mUnitsComboBox->currentData().toInt() ) != config.units() )
{
mUnitsComboBox->setCurrentIndex( mUnitsComboBox->findData( config.units() ) );
mUnitsComboBox->setCurrentIndex( mUnitsComboBox->findData( QVariant::fromValue( config.units() ) ) );
}
if ( mToleranceSpinBox->value() != config.tolerance() )
@ -580,7 +580,7 @@ void QgsSnappingWidget::changeMaxScale( double maxScale )
void QgsSnappingWidget::changeUnit( int idx )
{
QgsTolerance::UnitType unit = static_cast<QgsTolerance::UnitType>( mUnitsComboBox->itemData( idx ).toInt() );
Qgis::MapToolUnit unit = mUnitsComboBox->itemData( idx ).value< Qgis::MapToolUnit >();
mConfig.setUnits( unit );
mProject->setSnappingConfig( mConfig );
@ -732,7 +732,7 @@ void QgsSnappingWidget::snappingScaleModeTriggered( QAction *action )
void QgsSnappingWidget::updateToleranceDecimals()
{
if ( mConfig.units() == QgsTolerance::Pixels )
if ( mConfig.units() == Qgis::MapToolUnit::Pixels )
{
mToleranceSpinBox->setDecimals( 0 );
}

8
src/app/vertextool/qgsvertextool.cpp
View File

@ -871,12 +871,12 @@ QgsPointLocator::Match QgsVertexTool::snapToEditableLayer( QgsMapMouseEvent *e )
layerSettings.setEnabled( vlayer == currentVlayer );
layerSettings.setTolerance( tol );
layerSettings.setTypeFlag( static_cast<Qgis::SnappingTypes>( Qgis::SnappingType::Vertex | Qgis::SnappingType::Segment ) );
layerSettings.setUnits( QgsTolerance::ProjectUnits );
layerSettings.setUnits( Qgis::MapToolUnit::Project );
}
else
{
layerSettings = QgsSnappingConfig::IndividualLayerSettings(
vlayer == currentVlayer, static_cast<Qgis::SnappingTypes>( Qgis::SnappingType::Vertex | Qgis::SnappingType::Segment ), tol, QgsTolerance::ProjectUnits, 0.0, 0.0 );
vlayer == currentVlayer, static_cast<Qgis::SnappingTypes>( Qgis::SnappingType::Vertex | Qgis::SnappingType::Segment ), tol, Qgis::MapToolUnit::Project, 0.0, 0.0 );
}
config.setIndividualLayerSettings( vlayer, layerSettings );
@ -913,11 +913,11 @@ QgsPointLocator::Match QgsVertexTool::snapToEditableLayer( QgsMapMouseEvent *e )
layerSettings.setEnabled( vlayer->isEditable() );
layerSettings.setTolerance( tol );
layerSettings.setTypeFlag( static_cast<Qgis::SnappingTypes>( Qgis::SnappingType::Vertex | Qgis::SnappingType::Segment ) );
layerSettings.setUnits( QgsTolerance::ProjectUnits );
layerSettings.setUnits( Qgis::MapToolUnit::Project );
}
else
{
layerSettings = QgsSnappingConfig::IndividualLayerSettings( vlayer->isEditable(), static_cast<Qgis::SnappingTypes>( Qgis::SnappingType::Vertex | Qgis::SnappingType::Segment ), tol, QgsTolerance::ProjectUnits, 0.0, 0.0 );
layerSettings = QgsSnappingConfig::IndividualLayerSettings( vlayer->isEditable(), static_cast<Qgis::SnappingTypes>( Qgis::SnappingType::Vertex | Qgis::SnappingType::Segment ), tol, Qgis::MapToolUnit::Project, 0.0, 0.0 );
}
config.setIndividualLayerSettings( vlayer, layerSettings );
}

2
src/core/expression/qgsexpressioncontextutils.h
View File

@ -21,6 +21,7 @@
#include "qgspointlocator.h"
#include "qgsexpressioncontext.h"
#include "qgsmeshdataprovider.h"
#include <QString>
#include <QVariantMap>
@ -30,6 +31,7 @@ class QgsLayout;
class QgsSymbol;
class QgsLayoutAtlas;
class QgsLayoutItem;
class QgsMapSettings;
class QgsProcessingAlgorithm;
class QgsProcessingModelAlgorithm;
class QgsProcessingContext;

1
src/core/expression/qgsexpressionutils.h
View File

@ -31,6 +31,7 @@
#include <QLocale>
#include <functional>
class QgsMapLayer;
class QgsGradientColorRamp;
class QgsVectorLayerFeatureSource;

2
src/core/labeling/qgslabelingresults.cpp
View File

@ -15,6 +15,8 @@
#include "qgslabelingresults.h"
#include "qgslabelsearchtree.h"
#include "qgsmapsettings.h"
QgsLabelingResults::QgsLabelingResults()
: mLabelSearchTree( std::make_unique< QgsLabelSearchTree >() )

2
src/core/labeling/qgslabelingresults.h
View File

@ -20,8 +20,10 @@
#include "qgis_sip.h"
#include "qgslabelposition.h"
#include "qgscalloutposition.h"
#include <memory>
class QgsMapSettings;
class QgsLabelSearchTree;
/**

1
src/core/labeling/qgspallabeling.h
View File

@ -67,6 +67,7 @@ class QPicture;
class QgsGeometry;
class QgsCoordinateTransform;
class QgsLabelSearchTree;
class QgsMapLayer;
class QgsMapSettings;
class QgsLabelFeature;
class QgsLabelingEngine;

2
src/core/qgis.cpp
View File

@ -60,7 +60,7 @@ const double Qgis::DEFAULT_M_COORDINATE = 0.0;
const double Qgis::DEFAULT_SNAP_TOLERANCE = 12.0;
const QgsTolerance::UnitType Qgis::DEFAULT_SNAP_UNITS = QgsTolerance::Pixels;
const Qgis::MapToolUnit Qgis::DEFAULT_SNAP_UNITS = Qgis::MapToolUnit::Pixels;
#ifdef Q_OS_WIN
const double Qgis::UI_SCALE_FACTOR = 1.5;

17
src/core/qgis.h
View File

@ -24,7 +24,6 @@
#include <memory>
#include <cmath>
#include "qgstolerance.h"
#include "qgis_core.h"
#include "qgis_sip.h"
@ -3237,6 +3236,20 @@ class CORE_EXPORT Qgis
};
Q_ENUM( SystemOfMeasurement )
/**
* Type of unit of tolerance value from settings.
* For map (project) units, use MapToolUnit::Project.
*
* \since QGIS 3.32
*/
enum class MapToolUnit SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsTolerance, UnitType ) : int
{
Layer SIP_MONKEYPATCH_COMPAT_NAME( LayerUnits ), //!< Layer unit value
Pixels, //!< Pixels unit of tolerance
Project SIP_MONKEYPATCH_COMPAT_NAME( ProjectUnits ) //!< Map (project) units
};
Q_ENUM( MapToolUnit )
/**
* Unit types.
*
@ -3713,7 +3726,7 @@ class CORE_EXPORT Qgis
* Default snapping distance units.
* \since QGIS 3.0
*/
static const QgsTolerance::UnitType DEFAULT_SNAP_UNITS;
static const Qgis::MapToolUnit DEFAULT_SNAP_UNITS;
/**
* A string with default project scales.

1
src/core/qgselevationutils.h
View File

@ -20,6 +20,7 @@
#include "qgsrange.h"
class QgsProject;
class QgsMapLayer;
/**
* \ingroup core

3
src/core/qgsmaplayerelevationproperties.h
View File

@ -28,6 +28,9 @@
#include <QObject>
#include <QDomElement>
class QgsMapLayer;
/**
* \class QgsMapLayerElevationProperties
* \ingroup core

3
src/core/qgsmaplayerfactory.h
View File

@ -24,6 +24,9 @@
#include <QString>
class QgsMapLayer;
/**
* \ingroup core
* \brief Contains utility functions for creating map layers.

1
src/core/qgsmaplayertemporalproperties.h
View File

@ -27,6 +27,7 @@
#include <QDomElement>
class QgsMapLayer;
class QgsDataProviderTemporalCapabilities;
/**

2
src/core/qgsogcutils.h
View File

@ -31,6 +31,8 @@ class QgsGeometry;
class QgsPointXY;
class QgsRectangle;
class QgsVectorLayer;
class QgsMapLayer;
#include "qgsgeometry.h"
#include "qgsexpression.h"

28
src/core/qgssnappingconfig.cpp
View File

@ -27,7 +27,7 @@
#include "qgssettingsentryenumflag.h"
QgsSnappingConfig::IndividualLayerSettings::IndividualLayerSettings( bool enabled, Qgis::SnappingTypes type, double tolerance, QgsTolerance::UnitType units, double minScale, double maxScale )
QgsSnappingConfig::IndividualLayerSettings::IndividualLayerSettings( bool enabled, Qgis::SnappingTypes type, double tolerance, Qgis::MapToolUnit units, double minScale, double maxScale )
: mValid( true )
, mEnabled( enabled )
, mType( type )
@ -37,7 +37,7 @@ QgsSnappingConfig::IndividualLayerSettings::IndividualLayerSettings( bool enable
, mMaximumScale( maxScale )
{}
QgsSnappingConfig::IndividualLayerSettings::IndividualLayerSettings( bool enabled, SnappingType type, double tolerance, QgsTolerance::UnitType units )
QgsSnappingConfig::IndividualLayerSettings::IndividualLayerSettings( bool enabled, SnappingType type, double tolerance, Qgis::MapToolUnit units )
: mValid( true )
, mEnabled( enabled )
, mTolerance( tolerance )
@ -113,12 +113,12 @@ void QgsSnappingConfig::IndividualLayerSettings::setTolerance( double tolerance
mTolerance = tolerance;
}
QgsTolerance::UnitType QgsSnappingConfig::IndividualLayerSettings::units() const
Qgis::MapToolUnit QgsSnappingConfig::IndividualLayerSettings::units() const
{
return mUnits;
}
void QgsSnappingConfig::IndividualLayerSettings::setUnits( QgsTolerance::UnitType units )
void QgsSnappingConfig::IndividualLayerSettings::setUnits( Qgis::MapToolUnit units )
{
mUnits = units;
}
@ -194,7 +194,7 @@ void QgsSnappingConfig::reset()
const Qgis::SnappingMode mode = QgsSettingsRegistryCore::settingsDigitizingDefaultSnapMode->value();
const Qgis::SnappingType type = QgsSettingsRegistryCore::settingsDigitizingDefaultSnapType->value();
const double tolerance = QgsSettingsRegistryCore::settingsDigitizingDefaultSnappingTolerance->value();
const QgsTolerance::UnitType units = QgsSettingsRegistryCore::settingsDigitizingDefaultSnappingToleranceUnit->value();
const Qgis::MapToolUnit units = QgsSettingsRegistryCore::settingsDigitizingDefaultSnappingToleranceUnit->value();
// assign main (standard) config
mEnabled = enabled;
@ -205,9 +205,9 @@ void QgsSnappingConfig::reset()
mMinimumScale = 0.0;
mMaximumScale = 0.0;
// do not allow unit to be "layer" if not in advanced configuration
if ( mUnits == QgsTolerance::LayerUnits && mMode != Qgis::SnappingMode::AdvancedConfiguration )
if ( mUnits == Qgis::MapToolUnit::Layer && mMode != Qgis::SnappingMode::AdvancedConfiguration )
{
mUnits = QgsTolerance::ProjectUnits;
mUnits = Qgis::MapToolUnit::Project;
}
else
{
@ -360,12 +360,12 @@ void QgsSnappingConfig::setTolerance( double tolerance )
mTolerance = tolerance;
}
QgsTolerance::UnitType QgsSnappingConfig::units() const
Qgis::MapToolUnit QgsSnappingConfig::units() const
{
return mUnits;
}
void QgsSnappingConfig::setUnits( QgsTolerance::UnitType units )
void QgsSnappingConfig::setUnits( Qgis::MapToolUnit units )
{
if ( mUnits == units )
{
@ -510,7 +510,7 @@ void QgsSnappingConfig::readProject( const QDomDocument &doc )
mMaximumScale = snapSettingsElem.attribute( QStringLiteral( "maxScale" ) ).toDouble();
if ( snapSettingsElem.hasAttribute( QStringLiteral( "unit" ) ) )
mUnits = static_cast< QgsTolerance::UnitType >( snapSettingsElem.attribute( QStringLiteral( "unit" ) ).toInt() );
mUnits = static_cast< Qgis::MapToolUnit >( snapSettingsElem.attribute( QStringLiteral( "unit" ) ).toInt() );
if ( snapSettingsElem.hasAttribute( QStringLiteral( "intersection-snapping" ) ) )
mIntersectionSnapping = snapSettingsElem.attribute( QStringLiteral( "intersection-snapping" ) ) == QLatin1String( "1" );
@ -538,7 +538,7 @@ void QgsSnappingConfig::readProject( const QDomDocument &doc )
const bool enabled = settingElement.attribute( QStringLiteral( "enabled" ) ) == QLatin1String( "1" );
const Qgis::SnappingTypes type = static_cast<Qgis::SnappingTypes>( settingElement.attribute( QStringLiteral( "type" ) ).toInt() );
const double tolerance = settingElement.attribute( QStringLiteral( "tolerance" ) ).toDouble();
const QgsTolerance::UnitType units = static_cast< QgsTolerance::UnitType >( settingElement.attribute( QStringLiteral( "units" ) ).toInt() );
const Qgis::MapToolUnit units = static_cast< Qgis::MapToolUnit >( settingElement.attribute( QStringLiteral( "units" ) ).toInt() );
const double minScale = settingElement.attribute( QStringLiteral( "minScale" ) ).toDouble();
const double maxScale = settingElement.attribute( QStringLiteral( "maxScale" ) ).toDouble();
@ -595,7 +595,7 @@ bool QgsSnappingConfig::addLayers( const QList<QgsMapLayer *> &layers )
const bool enabled = QgsSettingsRegistryCore::settingsDigitizingDefaultSnapEnabled->valueWithDefaultOverride( true );
const Qgis::SnappingTypes type = QgsSettingsRegistryCore::settingsDigitizingDefaultSnapType->value();
const double tolerance = QgsSettingsRegistryCore::settingsDigitizingDefaultSnappingTolerance->value();
const QgsTolerance::UnitType units = QgsSettingsRegistryCore::settingsDigitizingDefaultSnappingToleranceUnit->value();
const Qgis::MapToolUnit units = QgsSettingsRegistryCore::settingsDigitizingDefaultSnappingToleranceUnit->value();
const auto constLayers = layers;
for ( QgsMapLayer *ml : constLayers )
@ -634,7 +634,7 @@ void QgsSnappingConfig::readLegacySettings()
const QString snapMode = mProject->readEntry( QStringLiteral( "Digitizing" ), QStringLiteral( "/SnappingMode" ) );
mTolerance = mProject->readDoubleEntry( QStringLiteral( "Digitizing" ), QStringLiteral( "/DefaultSnapTolerance" ), 0 );
mUnits = static_cast< QgsTolerance::UnitType >( mProject->readNumEntry( QStringLiteral( "Digitizing" ), QStringLiteral( "/DefaultSnapToleranceUnit" ), QgsTolerance::ProjectUnits ) );
mUnits = static_cast< Qgis::MapToolUnit >( mProject->readNumEntry( QStringLiteral( "Digitizing" ), QStringLiteral( "/DefaultSnapToleranceUnit" ), static_cast<int>( Qgis::MapToolUnit::Project ) ) );
mIntersectionSnapping = mProject->readNumEntry( QStringLiteral( "Digitizing" ), QStringLiteral( "/IntersectionSnapping" ), 0 );
@ -678,7 +678,7 @@ void QgsSnappingConfig::readLegacySettings()
)
);
mIndividualLayerSettings.insert( vlayer, IndividualLayerSettings( *enabledIt == QLatin1String( "enabled" ), t, tolIt->toDouble(), static_cast<QgsTolerance::UnitType>( tolUnitIt->toInt() ), 0.0, 0.0 ) );
mIndividualLayerSettings.insert( vlayer, IndividualLayerSettings( *enabledIt == QLatin1String( "enabled" ), t, tolIt->toDouble(), static_cast<Qgis::MapToolUnit>( tolUnitIt->toInt() ), 0.0, 0.0 ) );
}
const QString snapType = mProject->readEntry( QStringLiteral( "Digitizing" ), QStringLiteral( "/DefaultSnapType" ), QStringLiteral( "off" ) );

16
src/core/qgssnappingconfig.h
View File

@ -116,7 +116,7 @@ class CORE_EXPORT QgsSnappingConfig
* \param units
* \deprecated since QGIS 3.12 use the method with Qgis::SnappingTypes instead.
*/
Q_DECL_DEPRECATED IndividualLayerSettings( bool enabled, SnappingType type, double tolerance, QgsTolerance::UnitType units ) SIP_DEPRECATED;
Q_DECL_DEPRECATED IndividualLayerSettings( bool enabled, SnappingType type, double tolerance, Qgis::MapToolUnit units ) SIP_DEPRECATED;
/**
* \brief IndividualLayerSettings
@ -128,7 +128,7 @@ class CORE_EXPORT QgsSnappingConfig
* \param maxScale 0.0 disable scale limit
* \since QGIS 3.12
*/
IndividualLayerSettings( bool enabled, Qgis::SnappingTypes type, double tolerance, QgsTolerance::UnitType units, double minScale = 0.0, double maxScale = 0.0 );
IndividualLayerSettings( bool enabled, Qgis::SnappingTypes type, double tolerance, Qgis::MapToolUnit units, double minScale = 0.0, double maxScale = 0.0 );
/**
* Constructs an invalid setting
@ -175,10 +175,10 @@ class CORE_EXPORT QgsSnappingConfig
void setTolerance( double tolerance );
//! Returns the type of units
QgsTolerance::UnitType units() const;
Qgis::MapToolUnit units() const;
//! Sets the type of units
void setUnits( QgsTolerance::UnitType units );
void setUnits( Qgis::MapToolUnit units );
/**
* Returns minimum scale on which snapping is limited
@ -217,7 +217,7 @@ class CORE_EXPORT QgsSnappingConfig
bool mEnabled = false;
Qgis::SnappingTypes mType = Qgis::SnappingType::Vertex;
double mTolerance = 0;
QgsTolerance::UnitType mUnits = QgsTolerance::Pixels;
Qgis::MapToolUnit mUnits = Qgis::MapToolUnit::Pixels;
double mMinimumScale = 0.0;
double mMaximumScale = 0.0;
};
@ -311,10 +311,10 @@ class CORE_EXPORT QgsSnappingConfig
ScaleDependencyMode scaleDependencyMode() const;
//! Returns the type of units
QgsTolerance::UnitType units() const;
Qgis::MapToolUnit units() const;
//! Sets the type of units
void setUnits( QgsTolerance::UnitType units );
void setUnits( Qgis::MapToolUnit units );
//! Returns if the snapping on intersection is enabled
bool intersectionSnapping() const;
@ -464,7 +464,7 @@ class CORE_EXPORT QgsSnappingConfig
ScaleDependencyMode mScaleDependencyMode = Disabled;
double mMinimumScale = 0.0;
double mMaximumScale = 0.0;
QgsTolerance::UnitType mUnits = QgsTolerance::ProjectUnits;
Qgis::MapToolUnit mUnits = Qgis::MapToolUnit::Project;
bool mIntersectionSnapping = false;
bool mSelfSnapping = false;

2
src/core/qgssnappingutils.cpp
View File

@ -649,7 +649,7 @@ QString QgsSnappingUtils::dump()
msg += QString( "layer : %1\n"
"config: %2 tolerance %3 %4\n" )
.arg( layer.layer->name() )
.arg( layer.type ).arg( layer.tolerance ).arg( layer.unit );
.arg( layer.type ).arg( layer.tolerance ).arg( static_cast<int>( layer.unit ) );
if ( mStrategy == IndexAlwaysFull || mStrategy == IndexHybrid || mStrategy == IndexExtent )
{

8
src/core/qgssnappingutils.h
View File

@ -128,8 +128,8 @@ class CORE_EXPORT QgsSnappingUtils : public QObject
* \code{.py}
* snapper = QgsMapCanvasSnappingUtils(mapCanvas)
*
* snapping_layer1 = QgsSnappingUtils.LayerConfig(layer1, QgsPointLocator.Vertex, 10, QgsTolerance.Pixels)
* snapping_layer2 = QgsSnappingUtils.LayerConfig(layer2, QgsPointLocator.Vertex and QgsPointLocator.Edge, 10, QgsTolerance.Pixels)
* 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])
* \endcode
@ -139,7 +139,7 @@ class CORE_EXPORT QgsSnappingUtils : public QObject
* \param tol The tolerance radius in which the snapping will trigger
* \param u The unit in which the tolerance is specified
*/
LayerConfig( QgsVectorLayer *l, QgsPointLocator::Types t, double tol, QgsTolerance::UnitType u )
LayerConfig( QgsVectorLayer *l, QgsPointLocator::Types t, double tol, Qgis::MapToolUnit u )
: layer( l )
, type( t )
, tolerance( tol )
@ -163,7 +163,7 @@ class CORE_EXPORT QgsSnappingUtils : public QObject
//! The range around snapping targets in which snapping should occur.
double tolerance;
//! The units in which the tolerance is specified.
QgsTolerance::UnitType unit;
Qgis::MapToolUnit unit;
};
//! Query layers used for snapping

22
src/core/qgstolerance.cpp
View File

@ -38,12 +38,12 @@ double _ratioMU2LU( const QgsMapSettings &mapSettings, QgsMapLayer *layer )
return ratio;
}
double QgsTolerance::toleranceInProjectUnits( double tolerance, QgsMapLayer *layer, const QgsMapSettings &mapSettings, QgsTolerance::UnitType units )
double QgsTolerance::toleranceInProjectUnits( double tolerance, QgsMapLayer *layer, const QgsMapSettings &mapSettings, Qgis::MapToolUnit units )
{
// converts to map units
if ( units == ProjectUnits )
if ( units == Qgis::MapToolUnit::Project )
return tolerance;
else if ( units == Pixels )
else if ( units == Qgis::MapToolUnit::Pixels )
return tolerance * mapSettings.mapUnitsPerPixel();
else // units == LayerUnits
{
@ -53,14 +53,14 @@ double QgsTolerance::toleranceInProjectUnits( double tolerance, QgsMapLayer *lay
}
double QgsTolerance::toleranceInMapUnits( double tolerance, QgsMapLayer *layer, const QgsMapSettings &mapSettings, QgsTolerance::UnitType units )
double QgsTolerance::toleranceInMapUnits( double tolerance, QgsMapLayer *layer, const QgsMapSettings &mapSettings, Qgis::MapToolUnit units )
{
// converts to layer units
if ( units == LayerUnits )
if ( units == Qgis::MapToolUnit::Layer )
{
return tolerance;
}
else if ( units == Pixels )
else if ( units == Qgis::MapToolUnit::Pixels )
{
const double layerUnitsPerPixel = computeMapUnitPerPixel( layer, mapSettings );
return tolerance * layerUnitsPerPixel;
@ -75,23 +75,23 @@ double QgsTolerance::toleranceInMapUnits( double tolerance, QgsMapLayer *layer,
double QgsTolerance::vertexSearchRadius( const QgsMapSettings &mapSettings )
{
const double tolerance = QgsSettingsRegistryCore::settingsDigitizingSearchRadiusVertexEdit->value();
UnitType units = QgsSettingsRegistryCore::settingsDigitizingSearchRadiusVertexEditUnit->value();
if ( units == LayerUnits )
units = ProjectUnits;
Qgis::MapToolUnit units = QgsSettingsRegistryCore::settingsDigitizingSearchRadiusVertexEditUnit->value();
if ( units == Qgis::MapToolUnit::Layer )
units = Qgis::MapToolUnit::Project;
return toleranceInProjectUnits( tolerance, nullptr, mapSettings, units );
}
double QgsTolerance::vertexSearchRadius( QgsMapLayer *layer, const QgsMapSettings &mapSettings )
{
const double tolerance = QgsSettingsRegistryCore::settingsDigitizingSearchRadiusVertexEdit->value();
const UnitType units = QgsSettingsRegistryCore::settingsDigitizingSearchRadiusVertexEditUnit->value();
const Qgis::MapToolUnit units = QgsSettingsRegistryCore::settingsDigitizingSearchRadiusVertexEditUnit->value();
return toleranceInMapUnits( tolerance, layer, mapSettings, units );
}
double QgsTolerance::defaultTolerance( QgsMapLayer *layer, const QgsMapSettings &mapSettings )
{
const double tolerance = QgsSettingsRegistryCore::settingsDigitizingDefaultSnappingTolerance->value();
const UnitType units = QgsSettingsRegistryCore::settingsDigitizingDefaultSnappingToleranceUnit->value();
const Qgis::MapToolUnit units = QgsSettingsRegistryCore::settingsDigitizingDefaultSnappingToleranceUnit->value();
return toleranceInMapUnits( tolerance, layer, mapSettings, units );
}

21
src/core/qgstolerance.h
View File

@ -19,7 +19,7 @@
#include <QObject>
#include "qgis_core.h"
#include "qgis_sip.h"
#include "qgis.h"
class QgsMapSettings;
class QgsMapLayer;
@ -34,21 +34,6 @@ class CORE_EXPORT QgsTolerance
Q_GADGET
public:
/**
* Type of unit of tolerance value from settings.
* For map (project) units, use ProjectUnits.
*/
enum UnitType
{
//! Layer unit value
LayerUnits,
//! Pixels unit of tolerance
Pixels,
//! Map (project) units. Added in 2.8
ProjectUnits
};
Q_ENUM( UnitType )
/**
* Static function to get vertex tolerance value.
* The value is read from settings and transformed if necessary.
@ -80,7 +65,7 @@ class CORE_EXPORT QgsTolerance
* \returns value of tolerance in map units
* \since QGIS 2.8
*/
static double toleranceInProjectUnits( double tolerance, QgsMapLayer *layer, const QgsMapSettings &mapSettings, QgsTolerance::UnitType units );
static double toleranceInProjectUnits( double tolerance, QgsMapLayer *layer, const QgsMapSettings &mapSettings, Qgis::MapToolUnit units );
/**
* Static function to translate tolerance value into layer units
@ -90,7 +75,7 @@ class CORE_EXPORT QgsTolerance
* \param units type of units to be translated
* \returns value of tolerance in layer units
*/
static double toleranceInMapUnits( double tolerance, QgsMapLayer *layer, const QgsMapSettings &mapSettings, UnitType units = LayerUnits );
static double toleranceInMapUnits( double tolerance, QgsMapLayer *layer, const QgsMapSettings &mapSettings, Qgis::MapToolUnit units = Qgis::MapToolUnit::Layer );
private:
static double computeMapUnitPerPixel( QgsMapLayer *layer, const QgsMapSettings &mapSettings );

5
src/core/settings/qgssettingsregistrycore.cpp
View File

@ -39,9 +39,9 @@ const QgsSettingsEntryEnumFlag<Qgis::SnappingMode> *QgsSettingsRegistryCore::set
const QgsSettingsEntryEnumFlag<Qgis::SnappingType> *QgsSettingsRegistryCore::settingsDigitizingDefaultSnapType = new QgsSettingsEntryEnumFlag<Qgis::SnappingType>( QStringLiteral( "default-snap-type" ), QgsSettingsTree::sTreeDigitizing, Qgis::SnappingType::Vertex );
const QgsSettingsEntryEnumFlag<QgsTolerance::UnitType> *QgsSettingsRegistryCore::settingsDigitizingDefaultSnappingToleranceUnit = new QgsSettingsEntryEnumFlag<QgsTolerance::UnitType>( QStringLiteral( "default-snapping-tolerance-unit" ), QgsSettingsTree::sTreeDigitizing, Qgis::DEFAULT_SNAP_UNITS );
const QgsSettingsEntryEnumFlag<Qgis::MapToolUnit> *QgsSettingsRegistryCore::settingsDigitizingDefaultSnappingToleranceUnit = new QgsSettingsEntryEnumFlag<Qgis::MapToolUnit>( QStringLiteral( "default-snapping-tolerance-unit" ), QgsSettingsTree::sTreeDigitizing, Qgis::DEFAULT_SNAP_UNITS );
const QgsSettingsEntryEnumFlag<QgsTolerance::UnitType> *QgsSettingsRegistryCore::settingsDigitizingSearchRadiusVertexEditUnit = new QgsSettingsEntryEnumFlag<QgsTolerance::UnitType>( QStringLiteral( "search-radius-vertex-edit-unit" ), QgsSettingsTree::sTreeDigitizing, QgsTolerance::Pixels );
const QgsSettingsEntryEnumFlag<Qgis::MapToolUnit> *QgsSettingsRegistryCore::settingsDigitizingSearchRadiusVertexEditUnit = new QgsSettingsEntryEnumFlag<Qgis::MapToolUnit>( QStringLiteral( "search-radius-vertex-edit-unit" ), QgsSettingsTree::sTreeDigitizing, Qgis::MapToolUnit::Pixels );
const QgsSettingsEntryEnumFlag<Qgis::JoinStyle> *QgsSettingsRegistryCore::settingsDigitizingOffsetJoinStyle = new QgsSettingsEntryEnumFlag<Qgis::JoinStyle>( QStringLiteral( "offset-join-style" ), QgsSettingsTree::sTreeDigitizing, Qgis::JoinStyle::Round );
@ -569,4 +569,3 @@ void QgsSettingsRegistryCore::backwardCompatibility()
}
}
}

4
src/core/settings/qgssettingsregistrycore.h
View File

@ -93,13 +93,13 @@ class CORE_EXPORT QgsSettingsRegistryCore : public QgsSettingsRegistry
static const QgsSettingsEntryDouble *settingsDigitizingDefaultSnappingTolerance;
//! Settings entry digitizing default snapping tolerance unit
static const QgsSettingsEntryEnumFlag<QgsTolerance::UnitType> *settingsDigitizingDefaultSnappingToleranceUnit;
static const QgsSettingsEntryEnumFlag<Qgis::MapToolUnit> *settingsDigitizingDefaultSnappingToleranceUnit;
//! Settings entry digitizing search radius vertex edit
static const QgsSettingsEntryDouble *settingsDigitizingSearchRadiusVertexEdit;
//! Settings entry digitizing search radius vertex edit unit
static const QgsSettingsEntryEnumFlag<QgsTolerance::UnitType> *settingsDigitizingSearchRadiusVertexEditUnit;
static const QgsSettingsEntryEnumFlag<Qgis::MapToolUnit> *settingsDigitizingSearchRadiusVertexEditUnit;
//! Settings entry digitizing snap color
static const QgsSettingsEntryColor *settingsDigitizingSnapColor;

1
src/core/vectortile/qgsmapboxglstyleconverter.h
View File

@ -29,6 +29,7 @@ class QgsVectorTileRenderer;
class QgsVectorTileLabeling;
class QgsVectorTileBasicRendererStyle;
class QgsVectorTileBasicLabelingStyle;
class QgsMapLayer;
class QgsRasterLayer;
/**

1
src/gui/qgsprojectionselectionwidget.h
View File

@ -27,6 +27,7 @@
#include "qgscoordinatereferencesystem.h"
#include "qgis_gui.h"
class QgsMapLayer;
class QgsHighlightableComboBox;
class QgsCrsSelectionWidget;
class QLabel;

1
src/gui/qgsprovidersourcewidgetproviderregistry.h
View File

@ -23,6 +23,7 @@
#include "qgis_sip.h"
#include "qgsguiutils.h"
class QgsMapLayer;
class QgsProviderSourceWidget;
class QgsProviderSourceWidgetProvider;
class QgsProviderGuiRegistry;

1
src/gui/qgsrubberband.h
View File

@ -30,6 +30,7 @@
#include "qgis_gui.h"
class QgsVectorLayer;
class QgsMapLayer;
class QPaintEvent;
class QgsSymbol;

2
src/gui/symbology/qgssymbolwidgetcontext.h
View File

@ -20,7 +20,7 @@
#include "qgsexpressioncontext.h"
#include "qgis_gui.h"
class QgsMapLayer;
class QgsMapCanvas;
class QgsMessageBar;

4
src/server/services/wfs/qgswfsutils.h
View File

@ -29,6 +29,8 @@
#include "qgswfsserviceexception.h"
#include "qgsserversettings.h"
class QgsMapLayer;
/**
* \ingroup server
* \brief WMS implementation
@ -77,5 +79,3 @@ namespace QgsWfs
} // namespace QgsWfs
#endif

2
tests/src/app/maptooladdfeatureline/testqgsmaptooladdfeatureline.cpp
View File

@ -642,7 +642,7 @@ void TestQgsMapToolAddFeatureLine::testSelfSnapping()
cfg.setMode( Qgis::SnappingMode::AllLayers );
cfg.setTypeFlag( Qgis::SnappingType::Vertex );
cfg.setTolerance( 50 );
cfg.setUnits( QgsTolerance::Pixels );
cfg.setUnits( Qgis::MapToolUnit::Pixels );
mCanvas->snappingUtils()->setConfig( cfg );

4
tests/src/app/testqgsmaptoolrotatefeature.cpp
View File

@ -214,9 +214,9 @@ void TestQgsMapToolRotateFeature::testRotateFeatureManualAnchorSnapping()
QgsSnappingConfig cfg = mCanvas->snappingUtils()->config();
const double tolerance = cfg.tolerance();
const QgsTolerance::UnitType units = cfg.units();
const Qgis::MapToolUnit units = cfg.units();
cfg.setTolerance( 0.5 );
cfg.setUnits( QgsTolerance::LayerUnits );
cfg.setUnits( Qgis::MapToolUnit::Layer );
mCanvas->snappingUtils()->setConfig( cfg );
// set anchor point, should snap to (1.1, 5)

4
tests/src/app/testqgsmaptoolscalefeature.cpp
View File

@ -238,9 +238,9 @@ void TestQgsMapToolScaleFeature::testScaleFeatureManualAnchorSnapping()
QgsSnappingConfig cfg = mCanvas->snappingUtils()->config();
const double tolerance = cfg.tolerance();
const QgsTolerance::UnitType units = cfg.units();
const Qgis::MapToolUnit units = cfg.units();
cfg.setTolerance( 0.5 );
cfg.setUnits( QgsTolerance::LayerUnits );
cfg.setUnits( Qgis::MapToolUnit::Layer );
mCanvas->snappingUtils()->setConfig( cfg );
//set manual anchor point, should snap to (-2, -2)

2
tests/src/app/testqgsmaptooltrimextendfeature.cpp
View File

@ -170,7 +170,7 @@ class TestQgsMapToolTrimExtendFeature : public QObject
snappingConfig.setEnabled( true );
snappingConfig.setTolerance( 100 );
snappingConfig.setTypeFlag( static_cast<Qgis::SnappingTypes>( Qgis::SnappingType::Vertex | Qgis::SnappingType::Segment ) );
snappingConfig.setUnits( QgsTolerance::Pixels );
snappingConfig.setUnits( Qgis::MapToolUnit::Pixels );
snappingConfig.setMode( Qgis::SnappingMode::AllLayers );
mSnappingUtils->setConfig( snappingConfig );

30
tests/src/core/testqgssnappingutils.cpp
View File

@ -106,7 +106,7 @@ class TestQgsSnappingUtils : public QObject
QgsSnappingConfig snappingConfig = u.config();
snappingConfig.setEnabled( false );
snappingConfig.setTolerance( 10 );
snappingConfig.setUnits( QgsTolerance::Pixels );
snappingConfig.setUnits( Qgis::MapToolUnit::Pixels );
snappingConfig.setMode( Qgis::SnappingMode::ActiveLayer );
u.setConfig( snappingConfig );
@ -178,7 +178,7 @@ class TestQgsSnappingUtils : public QObject
QgsSnappingConfig snappingConfig = u.config();
snappingConfig.setEnabled( false );
snappingConfig.setTolerance( 10 );
snappingConfig.setUnits( QgsTolerance::Pixels );
snappingConfig.setUnits( Qgis::MapToolUnit::Pixels );
snappingConfig.setMode( Qgis::SnappingMode::ActiveLayer );
u.setConfig( snappingConfig );
@ -250,7 +250,7 @@ class TestQgsSnappingUtils : public QObject
u.setMapSettings( mapSettings );
snappingConfig.setEnabled( true );
snappingConfig.setMode( Qgis::SnappingMode::AdvancedConfiguration );
snappingConfig.setIndividualLayerSettings( mVL, QgsSnappingConfig::IndividualLayerSettings( true, Qgis::SnappingType::Vertex, 10, QgsTolerance::Pixels, -1.0, -1.0 ) );
snappingConfig.setIndividualLayerSettings( mVL, QgsSnappingConfig::IndividualLayerSettings( true, Qgis::SnappingType::Vertex, 10, Qgis::MapToolUnit::Pixels, -1.0, -1.0 ) );
u.setConfig( snappingConfig );
const QgsPointLocator::Match m = u.snapToMap( QPoint( 100, 100 ) );
@ -297,7 +297,7 @@ class TestQgsSnappingUtils : public QObject
QgsSnappingConfig snappingConfig = u.config();
snappingConfig.setEnabled( true );
snappingConfig.setMode( Qgis::SnappingMode::AdvancedConfiguration );
const QgsSnappingConfig::IndividualLayerSettings layerSettings( true, Qgis::SnappingType::Vertex, 0.1, QgsTolerance::ProjectUnits, 0.0, 0.0 );
const QgsSnappingConfig::IndividualLayerSettings layerSettings( true, Qgis::SnappingType::Vertex, 0.1, Qgis::MapToolUnit::Project, 0.0, 0.0 );
snappingConfig.setIndividualLayerSettings( vl, layerSettings );
u.setConfig( snappingConfig );
@ -349,7 +349,7 @@ class TestQgsSnappingUtils : public QObject
QgsSnappingConfig snappingConfig = u.config();
snappingConfig.setEnabled( true );
snappingConfig.setMode( Qgis::SnappingMode::AdvancedConfiguration );
const QgsSnappingConfig::IndividualLayerSettings layerSettings( true, Qgis::SnappingType::Vertex, 0.2, QgsTolerance::ProjectUnits, 0.0, 0.0 );
const QgsSnappingConfig::IndividualLayerSettings layerSettings( true, Qgis::SnappingType::Vertex, 0.2, Qgis::MapToolUnit::Project, 0.0, 0.0 );
snappingConfig.setIntersectionSnapping( true );
snappingConfig.setIndividualLayerSettings( vCurveZ.get(), layerSettings );
u.setConfig( snappingConfig );
@ -386,7 +386,7 @@ class TestQgsSnappingUtils : public QObject
QgsSnappingConfig snappingConfig = u.config();
snappingConfig.setEnabled( true );
snappingConfig.setMode( Qgis::SnappingMode::AdvancedConfiguration );
const QgsSnappingConfig::IndividualLayerSettings layerSettings( true, Qgis::SnappingType::Vertex, 0.2, QgsTolerance::ProjectUnits, 0.0, 0.0 );
const QgsSnappingConfig::IndividualLayerSettings layerSettings( true, Qgis::SnappingType::Vertex, 0.2, Qgis::MapToolUnit::Project, 0.0, 0.0 );
snappingConfig.setIntersectionSnapping( true );
snappingConfig.setIndividualLayerSettings( vMulti.get(), layerSettings );
u.setConfig( snappingConfig );
@ -424,7 +424,7 @@ class TestQgsSnappingUtils : public QObject
QgsSnappingConfig snappingConfig = u.config();
snappingConfig.setEnabled( true );
snappingConfig.setMode( Qgis::SnappingMode::AdvancedConfiguration );
const QgsSnappingConfig::IndividualLayerSettings layerSettings( true, static_cast<Qgis::SnappingTypes>( Qgis::SnappingType::MiddleOfSegment | Qgis::SnappingType::Centroid ), 0.2, QgsTolerance::ProjectUnits, 0.0, 0.0 );
const QgsSnappingConfig::IndividualLayerSettings layerSettings( true, static_cast<Qgis::SnappingTypes>( Qgis::SnappingType::MiddleOfSegment | Qgis::SnappingType::Centroid ), 0.2, Qgis::MapToolUnit::Project, 0.0, 0.0 );
snappingConfig.setIndividualLayerSettings( vSnapCentroidMiddle.get(), layerSettings );
u.setConfig( snappingConfig );
@ -461,7 +461,7 @@ class TestQgsSnappingUtils : public QObject
QgsSnappingConfig snappingConfig = u.config();
snappingConfig.setEnabled( true );
snappingConfig.setMode( Qgis::SnappingMode::AdvancedConfiguration );
const QgsSnappingConfig::IndividualLayerSettings layerSettings( true, static_cast<Qgis::SnappingTypes>( Qgis::SnappingType::LineEndpoint ), 0.2, QgsTolerance::ProjectUnits, 0.0, 0.0 );
const QgsSnappingConfig::IndividualLayerSettings layerSettings( true, static_cast<Qgis::SnappingTypes>( Qgis::SnappingType::LineEndpoint ), 0.2, Qgis::MapToolUnit::Project, 0.0, 0.0 );
snappingConfig.setIndividualLayerSettings( vSnapCentroidMiddle.get(), layerSettings );
u.setConfig( snappingConfig );
@ -510,7 +510,7 @@ class TestQgsSnappingUtils : public QObject
QgsSnappingConfig snappingConfig = u.config();
snappingConfig.setEnabled( true );
snappingConfig.setMode( Qgis::SnappingMode::AdvancedConfiguration );
const QgsSnappingConfig::IndividualLayerSettings layerSettings( true, static_cast<Qgis::SnappingTypes>( Qgis::SnappingType::LineEndpoint ), 0.2, QgsTolerance::ProjectUnits, 0.0, 0.0 );
const QgsSnappingConfig::IndividualLayerSettings layerSettings( true, static_cast<Qgis::SnappingTypes>( Qgis::SnappingType::LineEndpoint ), 0.2, Qgis::MapToolUnit::Project, 0.0, 0.0 );
snappingConfig.setIndividualLayerSettings( vSnapCentroidMiddle.get(), layerSettings );
u.setConfig( snappingConfig );
@ -578,7 +578,7 @@ class TestQgsSnappingUtils : public QObject
QgsSnappingConfig snappingConfig = u.config();
snappingConfig.setEnabled( true );
snappingConfig.setMode( Qgis::SnappingMode::AdvancedConfiguration );
const QgsSnappingConfig::IndividualLayerSettings layerSettings( true, static_cast<Qgis::SnappingTypes>( Qgis::SnappingType::LineEndpoint ), 0.2, QgsTolerance::ProjectUnits, 0.0, 0.0 );
const QgsSnappingConfig::IndividualLayerSettings layerSettings( true, static_cast<Qgis::SnappingTypes>( Qgis::SnappingType::LineEndpoint ), 0.2, Qgis::MapToolUnit::Project, 0.0, 0.0 );
snappingConfig.setIndividualLayerSettings( vSnapCentroidMiddle.get(), layerSettings );
u.setConfig( snappingConfig );
@ -629,7 +629,7 @@ class TestQgsSnappingUtils : public QObject
QgsSnappingConfig snappingConfig = u.config();
snappingConfig.setEnabled( true );
snappingConfig.setMode( Qgis::SnappingMode::AdvancedConfiguration );
const QgsSnappingConfig::IndividualLayerSettings layerSettings( true, static_cast<Qgis::SnappingTypes>( Qgis::SnappingType::LineEndpoint ), 0.2, QgsTolerance::ProjectUnits, 0.0, 0.0 );
const QgsSnappingConfig::IndividualLayerSettings layerSettings( true, static_cast<Qgis::SnappingTypes>( Qgis::SnappingType::LineEndpoint ), 0.2, Qgis::MapToolUnit::Project, 0.0, 0.0 );
snappingConfig.setIndividualLayerSettings( vSnapCentroidMiddle.get(), layerSettings );
u.setConfig( snappingConfig );
@ -710,7 +710,7 @@ class TestQgsSnappingUtils : public QObject
snappingConfig.setEnabled( true );
snappingConfig.setMode( Qgis::SnappingMode::AdvancedConfiguration );
snappingConfig.setScaleDependencyMode( QgsSnappingConfig::Disabled );
snappingConfig.setIndividualLayerSettings( mVL, QgsSnappingConfig::IndividualLayerSettings( true, Qgis::SnappingType::Vertex, 10, QgsTolerance::Pixels, -1.0, -1.0 ) );
snappingConfig.setIndividualLayerSettings( mVL, QgsSnappingConfig::IndividualLayerSettings( true, Qgis::SnappingType::Vertex, 10, Qgis::MapToolUnit::Pixels, -1.0, -1.0 ) );
u.setConfig( snappingConfig );
//No limit on scale
@ -750,7 +750,7 @@ class TestQgsSnappingUtils : public QObject
QVERIFY( m3.hasVertex() );
snappingConfig.setScaleDependencyMode( QgsSnappingConfig::PerLayer );
snappingConfig.setIndividualLayerSettings( mVL, QgsSnappingConfig::IndividualLayerSettings( true, Qgis::SnappingType::Vertex, 10, QgsTolerance::Pixels, 10000.0, 1000.0 ) );
snappingConfig.setIndividualLayerSettings( mVL, QgsSnappingConfig::IndividualLayerSettings( true, Qgis::SnappingType::Vertex, 10, Qgis::MapToolUnit::Pixels, 10000.0, 1000.0 ) );
u.setConfig( snappingConfig );
//Per layer settings, but scale outside min max range of layer -> no snapping
@ -759,7 +759,7 @@ class TestQgsSnappingUtils : public QObject
QVERIFY( m4.hasVertex() == false );
snappingConfig.setScaleDependencyMode( QgsSnappingConfig::PerLayer );
snappingConfig.setIndividualLayerSettings( mVL, QgsSnappingConfig::IndividualLayerSettings( true, Qgis::SnappingType::Vertex, 10, QgsTolerance::Pixels, 100000.0, 1000.0 ) );
snappingConfig.setIndividualLayerSettings( mVL, QgsSnappingConfig::IndividualLayerSettings( true, Qgis::SnappingType::Vertex, 10, Qgis::MapToolUnit::Pixels, 100000.0, 1000.0 ) );
u.setConfig( snappingConfig );
//Per layer settings, scale inside min max range of layer -> snapping enabled
@ -783,7 +783,7 @@ class TestQgsSnappingUtils : public QObject
snappingConfig.setTypeFlag( Qgis::SnappingType::Vertex );
snappingConfig.setMode( Qgis::SnappingMode::AllLayers );
snappingConfig.setTolerance( 5 );
snappingConfig.setUnits( QgsTolerance::Pixels );
snappingConfig.setUnits( Qgis::MapToolUnit::Pixels );
u.setConfig( snappingConfig );
// additional vector layer

2
tests/src/core/testqgstracer.cpp
View File

@ -235,7 +235,7 @@ void TestQgsTracer::testInvisible()
QgsSnappingConfig snappingConfig = u.config();
snappingConfig.setEnabled( true );
snappingConfig.setTolerance( 10 );
snappingConfig.setUnits( QgsTolerance::Pixels );
snappingConfig.setUnits( Qgis::MapToolUnit::Pixels );
snappingConfig.setMode( Qgis::SnappingMode::ActiveLayer );
u.setConfig( snappingConfig );
QgsTracer tracer;

9
tests/src/python/test_core_additions.py
View File

@ -14,6 +14,7 @@ __copyright__ = 'Copyright 2015, The QGIS Project'
import qgis # NOQA
from qgis.core import (
Qgis,
QgsMapLayer,
QgsTolerance,
metaEnumFromValue,
@ -26,14 +27,14 @@ start_app()
class TestCoreAdditions(unittest.TestCase):
def testMetaEnum(self):
me = metaEnumFromValue(QgsTolerance.Pixels)
me = metaEnumFromValue(Qgis.MapToolUnit.Pixels)
self.assertIsNotNone(me)
self.assertEqual(me.valueToKey(QgsTolerance.Pixels), 'Pixels')
self.assertEqual(me.valueToKey(Qgis.MapToolUnit.Pixels), 'Pixels')
# check that using same variable twice doesn't segfault
me = metaEnumFromValue(QgsTolerance.Pixels, QgsTolerance)
me = metaEnumFromValue(Qgis.MapToolUnit.Pixels, QgsTolerance)
self.assertIsNotNone(me)
self.assertEqual(me.valueToKey(QgsTolerance.Pixels), 'Pixels')
self.assertEqual(me.valueToKey(Qgis.MapToolUnit.Pixels), 'Pixels')
# do not raise error
self.assertIsNone(metaEnumFromValue(1, QgsTolerance, False))

8
tests/src/python/test_layer_dependencies.py
View File

@ -100,7 +100,7 @@ class TestLayerDependencies(unittest.TestCase):
cfg.setMode(Qgis.SnappingMode.AdvancedConfiguration)
cfg.setIndividualLayerSettings(self.pointsLayer,
QgsSnappingConfig.IndividualLayerSettings(True,
Qgis.SnappingType.Vertex, 20, QgsTolerance.Pixels, 0.0, 0.0))
Qgis.SnappingType.Vertex, 20, Qgis.MapToolUnit.Pixels, 0.0, 0.0))
u.setConfig(cfg)
m = u.snapToMap(QPoint(95, 100))
@ -143,7 +143,7 @@ class TestLayerDependencies(unittest.TestCase):
# test chained layer dependencies A -> B -> C
cfg.setIndividualLayerSettings(self.pointsLayer2,
QgsSnappingConfig.IndividualLayerSettings(True,
Qgis.SnappingType.Vertex, 20, QgsTolerance.Pixels, 0.0, 0.0))
Qgis.SnappingType.Vertex, 20, Qgis.MapToolUnit.Pixels, 0.0, 0.0))
u.setConfig(cfg)
self.pointsLayer.setDependencies([QgsMapLayerDependency(self.linesLayer.id())])
self.pointsLayer2.setDependencies([QgsMapLayerDependency(self.pointsLayer.id())])
@ -293,10 +293,10 @@ class TestLayerDependencies(unittest.TestCase):
cfg.setMode(Qgis.SnappingMode.AdvancedConfiguration)
cfg.setIndividualLayerSettings(self.pointsLayer,
QgsSnappingConfig.IndividualLayerSettings(True,
Qgis.SnappingType.Vertex, 20, QgsTolerance.Pixels, 0.0, 0.0))
Qgis.SnappingType.Vertex, 20, Qgis.MapToolUnit.Pixels, 0.0, 0.0))
cfg.setIndividualLayerSettings(self.pointsLayer2,
QgsSnappingConfig.IndividualLayerSettings(True,
Qgis.SnappingType.Vertex, 20, QgsTolerance.Pixels, 0.0, 0.0))
Qgis.SnappingType.Vertex, 20, Qgis.MapToolUnit.Pixels, 0.0, 0.0))
u.setConfig(cfg)
# add another line
f = QgsFeature(self.linesLayer.fields())

16
tests/src/python/test_qgssettings.py
View File

@ -418,17 +418,17 @@ class TestQgsSettings(unittest.TestCase):
self.assertEqual(self.settings.value('testqQgisSettings/temp', section=QgsSettings.Core), None)
def test_enumValue(self):
self.settings.setValue('enum', 'LayerUnits')
self.assertEqual(self.settings.enumValue('enum', QgsTolerance.Pixels), QgsTolerance.LayerUnits)
self.settings.setValue('enum', 'Layer')
self.assertEqual(self.settings.enumValue('enum', Qgis.MapToolUnit.Pixels), Qgis.MapToolUnit.Layer)
self.settings.setValue('enum', 'dummy_setting')
self.assertEqual(self.settings.enumValue('enum', QgsTolerance.Pixels), QgsTolerance.Pixels)
self.assertEqual(type(self.settings.enumValue('enum', QgsTolerance.Pixels)), QgsTolerance.UnitType)
self.assertEqual(self.settings.enumValue('enum', Qgis.MapToolUnit.Pixels), Qgis.MapToolUnit.Pixels)
self.assertEqual(type(self.settings.enumValue('enum', Qgis.MapToolUnit.Pixels)), QgsTolerance.UnitType)
def test_setEnumValue(self):
self.settings.setValue('enum', 'LayerUnits')
self.assertEqual(self.settings.enumValue('enum', QgsTolerance.Pixels), QgsTolerance.LayerUnits)
self.settings.setEnumValue('enum', QgsTolerance.Pixels)
self.assertEqual(self.settings.enumValue('enum', QgsTolerance.Pixels), QgsTolerance.Pixels)
self.settings.setValue('enum', 'Layer')
self.assertEqual(self.settings.enumValue('enum', Qgis.MapToolUnit.Pixels), Qgis.MapToolUnit.Layer)
self.settings.setEnumValue('enum', Qgis.MapToolUnit.Pixels)
self.assertEqual(self.settings.enumValue('enum', Qgis.MapToolUnit.Pixels), Qgis.MapToolUnit.Pixels)
def test_flagValue(self):
pointAndLine = QgsMapLayerProxyModel.Filters(QgsMapLayerProxyModel.PointLayer | QgsMapLayerProxyModel.LineLayer)