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

Merge pull request #42954 from domi4484/settingsRegistryQep124PartThree

Browse Source 
Settings registry (QEP 124) part three
This commit is contained in:
Denis Rouzaud 2021-04-30 14:10:53 +02:00 committed by GitHub
commit 4e9932c37f
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
90 changed files with 997 additions and 639 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
python/core/__init__.py.in
View File

@ -34,7 +34,7 @@ from .additions.qgsfeature import mapping_feature
from .additions.qgsfunction import register_function, qgsfunction
from .additions.qgsgeometry import _geometryNonZero, mapping_geometry
from .additions.qgssettings import _qgssettings_enum_value, _qgssettings_set_enum_value, _qgssettings_flag_value
from .additions.qgssettingsentry import PyQgsSettingsEntryEnum, PyQgsSettingsEntryFlag
from .additions.qgssettingsentry import PyQgsSettingsEntryEnumFlag
from .additions.qgstaskwrapper import QgsTaskWrapper
from .additions.readwritecontextentercategory import ReadWriteContextEnterCategory
from .additions.runtimeprofiler import ScopedRuntimeProfileContextManager
@ -59,8 +59,7 @@ QgsDateTimeRange.__repr__ = datetime_range_repr
QgsDateRange.__repr__ = date_range_repr
# Classes patched
QgsSettingsEntryEnum = PyQgsSettingsEntryEnum
QgsSettingsEntryFlag = PyQgsSettingsEntryFlag
QgsSettingsEntryEnumFlag = PyQgsSettingsEntryEnumFlag
# Classes patched using a derived class
QgsProviderMetadata = PyProviderMetadata

119
python/core/additions/qgssettingsentry.py
View File

@ -22,24 +22,21 @@ from qgis.core import QgsSettings, QgsSettingsEntryBase, QgsLogger
import qgis # required to get base class of enums
class _PyQgsSettingsEntryEnumFlag(QgsSettingsEntryBase):
""" class QgsSettingsEntryEnum
ingroup core
An enum settings entry.
since QGIS 3.20
class PyQgsSettingsEntryEnumFlag(QgsSettingsEntryBase):
""" class PyQgsSettingsEntryEnumFlag
ingroup core
An enum settings entry.
since QGIS 3.20
"""
def __init__(self, key, pluginName, defaultValue, description=str()):
""" Constructor for _PyQgsSettingsEntryEnumFlag.
""" Constructor for PyQgsSettingsEntryEnumFlag.
:param self: the QgsSettingsEntryEnum object
:param key: argument specifies the final part of the settings key.
:param pluginName: argument is inserted in the key after the section.
:param defaultValue: argument specifies the default value for the settings entry.
:param description: argument specifies a description for the settings entry.
.. note:: This constructor should not be used. Use PyQgsSettingsEntryEnum
or PyQgsSettingsEntryFlag instead.
:param self: the PyQgsSettingsEntryEnumFlag object
:param key: argument specifies the final part of the settings key.
:param pluginName: argument is inserted in the key after the section.
:param defaultValue: argument specifies the default value for the settings entry.
:param description: argument specifies a description for the settings entry.
"""
defaultValueStr = str()
@ -47,10 +44,10 @@ class _PyQgsSettingsEntryEnumFlag(QgsSettingsEntryBase):
if self.__metaEnum is None or not self.__metaEnum.isValid():
QgsLogger.debug("Invalid metaenum. Enum/Flag probably misses Q_ENUM/Q_FLAG declaration. Settings key: '{0}'".format(self.key()))
else:
if self.settingsType() is self.SettingsType.Enum:
defaultValueStr = self.__metaEnum.valueToKey(defaultValue)
else:
if self.__metaEnum.isFlag():
defaultValueStr = self.__metaEnum.valueToKeys(defaultValue)
else:
defaultValueStr = self.__metaEnum.valueToKey(defaultValue)
self.__enumFlagClass = defaultValue.__class__
super().__init__(key, pluginName, defaultValueStr, description)
@ -58,29 +55,29 @@ class _PyQgsSettingsEntryEnumFlag(QgsSettingsEntryBase):
def value(self, dynamicKeyPart=None, useDefaultValueOverride=False, defaultValueOverride=None):
""" Get settings value.
:param self: the _PyQgsSettingsEntryEnumFlag object
:param dynamicKeyPart: argument specifies the dynamic part of the settings key.
:param useDefaultValueOverride: argument specifies if defaultValueOverride should be used.
:param defaultValueOverride: argument if valid is used instead of the normal default value.
:param self: the PyQgsSettingsEntryEnumFlag object
:param dynamicKeyPart: argument specifies the dynamic part of the settings key.
:param useDefaultValueOverride: argument specifies if defaultValueOverride should be used.
:param defaultValueOverride: argument if valid is used instead of the normal default value.
"""
defaultValue = self.defaultValue()
if useDefaultValueOverride:
defaultValue = defaultValueOverride
if self.settingsType() is self.SettingsType.Enum:
return QgsSettings().enumValue(self.key(dynamicKeyPart),
if self.__metaEnum.isFlag():
return QgsSettings().flagValue(self.key(dynamicKeyPart),
defaultValue,
self.section())
else:
return QgsSettings().flagValue(self.key(dynamicKeyPart),
return QgsSettings().enumValue(self.key(dynamicKeyPart),
defaultValue,
self.section())
def defaultValue(self):
""" Get settings default value.
:param self: the _PyQgsSettingsEntryEnumFlag object
:param self: the PyQgsSettingsEntryEnumFlag object
"""
if self.__metaEnum is None or not self.__metaEnum.isValid():
@ -88,10 +85,10 @@ class _PyQgsSettingsEntryEnumFlag(QgsSettingsEntryBase):
return -1
defaultValueString = self.defaultValueAsVariant()
if self.settingsType() is self.SettingsType.Enum:
(defaultValue, ok) = self.__metaEnum.keyToValue(defaultValueString)
else:
if self.__metaEnum.isFlag():
(defaultValue, ok) = self.__metaEnum.keysToValue(defaultValueString)
else:
(defaultValue, ok) = self.__metaEnum.keyToValue(defaultValueString)
if not ok:
QgsLogger.debug("Invalid enum/flag key/s '{0}'.".format(self.defaultValueAsVariant()))
return -1
@ -103,8 +100,8 @@ class _PyQgsSettingsEntryEnumFlag(QgsSettingsEntryBase):
def setValue(self, value, dynamicKeyPart=None):
""" Set settings value.
:param self: the _PyQgsSettingsEntryEnumFlag object
:param dynamicKeyPart: argument specifies the dynamic part of the settings key.
:param self: the PyQgsSettingsEntryEnumFlag object
:param dynamicKeyPart: argument specifies the dynamic part of the settings key.
"""
if self.__metaEnum is None or not self.__metaEnum.isValid():
@ -112,72 +109,20 @@ class _PyQgsSettingsEntryEnumFlag(QgsSettingsEntryBase):
return False
enumFlagKey = str()
if self.settingsType() is self.SettingsType.Enum:
enumFlagKey = self.__metaEnum.valueToKey(value)
else:
if self.__metaEnum.isFlag():
enumFlagKey = self.__metaEnum.valueToKeys(value)
else:
enumFlagKey = self.__metaEnum.valueToKey(value)
if not enumFlagKey:
QgsLogger.debug("Invalid enum/flag value '{0}'.".format(value))
return False
return super().setVariantValue(enumFlagKey, dynamicKeyPart)
class PyQgsSettingsEntryEnum(_PyQgsSettingsEntryEnumFlag):
""" class QgsSettingsEntryEnum
ingroup core
An enum settings entry.
since QGIS 3.20
"""
def __init__(self, key, pluginName, defaultValue, description=str()):
""" Constructor for QgsSettingsEntryEnum.
:param self: the QgsSettingsEntryEnum object
:param key: argument specifies the final part of the settings key.
:param pluginName: argument is inserted in the key after the section.
:param defaultValue: argument specifies the default value for the settings entry.
:param description: argument specifies a description for the settings entry.
.. note:: The enum needs to be declared with Q_ENUM.
"""
super().__init__(key, pluginName, defaultValue, description)
def settingsType(self):
""" Get the settings entry type.
:param self: the QgsSettingsEntryEnum object
:param self: the PyQgsSettingsEntryEnumFlag object
"""
return self.SettingsType.Enum
class PyQgsSettingsEntryFlag(_PyQgsSettingsEntryEnumFlag):
""" class QgsSettingsEntryFlag
ingroup core
A flag settings entry.
since QGIS 3.20
"""
def __init__(self, key, pluginName, defaultValue, description=str()):
""" Constructor for QgsSettingsEntryFlag.
:param self: the QgsSettingsEntryFlag object
:param key: argument specifies the final part of the settings key.
:param pluginName: argument is inserted in the key after the section.
:param defaultValue: argument specifies the default value for the settings entry.
:param description: argument specifies a description for the settings entry.
.. note:: The flag needs to be declared with Q_FLAG (not Q_FLAGS).
"""
super().__init__(key, pluginName, defaultValue, description)
def settingsType(self):
""" Get the settings entry type.
:param self: the QgsSettingsEntryFlag object
"""
return self.SettingsType.Flag
return self.SettingsType.EnumFlag

6
python/core/auto_additions/qgssettingsentry.py
View File

@ -6,7 +6,7 @@ QgsSettingsEntryBase.SettingsType.StringList.__doc__ = ""
QgsSettingsEntryBase.SettingsType.Bool.__doc__ = ""
QgsSettingsEntryBase.SettingsType.Integer.__doc__ = ""
QgsSettingsEntryBase.SettingsType.Double.__doc__ = ""
QgsSettingsEntryBase.SettingsType.Enum.__doc__ = ""
QgsSettingsEntryBase.SettingsType.Flag.__doc__ = ""
QgsSettingsEntryBase.SettingsType.__doc__ = '\n\n' + '* ``Variant``: ' + QgsSettingsEntryBase.SettingsType.Variant.__doc__ + '\n' + '* ``String``: ' + QgsSettingsEntryBase.SettingsType.String.__doc__ + '\n' + '* ``StringList``: ' + QgsSettingsEntryBase.SettingsType.StringList.__doc__ + '\n' + '* ``Bool``: ' + QgsSettingsEntryBase.SettingsType.Bool.__doc__ + '\n' + '* ``Integer``: ' + QgsSettingsEntryBase.SettingsType.Integer.__doc__ + '\n' + '* ``Double``: ' + QgsSettingsEntryBase.SettingsType.Double.__doc__ + '\n' + '* ``Enum``: ' + QgsSettingsEntryBase.SettingsType.Enum.__doc__ + '\n' + '* ``Flag``: ' + QgsSettingsEntryBase.SettingsType.Flag.__doc__
QgsSettingsEntryBase.SettingsType.EnumFlag.__doc__ = ""
QgsSettingsEntryBase.SettingsType.Color.__doc__ = ""
QgsSettingsEntryBase.SettingsType.__doc__ = '\n\n' + '* ``Variant``: ' + QgsSettingsEntryBase.SettingsType.Variant.__doc__ + '\n' + '* ``String``: ' + QgsSettingsEntryBase.SettingsType.String.__doc__ + '\n' + '* ``StringList``: ' + QgsSettingsEntryBase.SettingsType.StringList.__doc__ + '\n' + '* ``Bool``: ' + QgsSettingsEntryBase.SettingsType.Bool.__doc__ + '\n' + '* ``Integer``: ' + QgsSettingsEntryBase.SettingsType.Integer.__doc__ + '\n' + '* ``Double``: ' + QgsSettingsEntryBase.SettingsType.Double.__doc__ + '\n' + '* ``EnumFlag``: ' + QgsSettingsEntryBase.SettingsType.EnumFlag.__doc__ + '\n' + '* ``Color``: ' + QgsSettingsEntryBase.SettingsType.Color.__doc__
# --

1
python/core/auto_generated/layout/qgslayout.sip.in
View File

@ -614,7 +614,6 @@ should be canceled.
.. versionadded:: 3.10
%End
const QgsSettingsEntryStringList settingsSearchPathForTemplates;
public slots:

3
python/core/auto_generated/locator/qgslocator.sip.in
View File

@ -141,9 +141,6 @@ This list is updated when preparing the search
.. versionadded:: 3.16
%End
const QgsSettingsEntryBool settingsLocatorFilterEnabled;
const QgsSettingsEntryBool settingsLocatorFilterDefault;
const QgsSettingsEntryString settingsLocatorFilterPrefix;
signals:

2
python/core/auto_generated/network/qgsnetworkaccessmanager.sip.in
View File

@ -343,6 +343,8 @@ Forwards an external browser login closure request to the authentication handler
.. versionadded:: 3.20
%End
signals:
void requestAboutToBeCreated( QNetworkAccessManager::Operation, const QNetworkRequest &, QIODevice * ) /Deprecated/;

1
python/core/auto_generated/network/qgsnewsfeedparser.sip.in
View File

@ -93,6 +93,7 @@ Returns the authentication configuration for the parser.
Returns the settings key used for a feed with the given ``baseUrl``.
%End
public slots:
void fetch();

1
python/core/auto_generated/processing/qgsprocessing.sip.in
View File

@ -52,6 +52,7 @@ Converts a source ``type`` to a string representation.
%End
static const QString TEMPORARY_OUTPUT;
};
/************************************************************************

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

@ -1003,6 +1003,7 @@ Emits the signal to collect all the strings of .qgs to be included in ts file
.. versionadded:: 3.4
%End
%If (ANDROID)
//dummy method to workaround sip generation issue
bool x11EventFilter( XEvent *event );

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

@ -118,6 +118,7 @@ Read the geometry options from ``node``.
.. versionadded:: 3.4
%End
signals:
void checkConfigurationChanged();

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

@ -60,6 +60,7 @@ Since the paths are stored by order of preference, lower positions in the list t
Unregisters a localized path
%End
private:
QgsLocalizedDataPathRegistry( const QgsLocalizedDataPathRegistry &other );
};

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

@ -157,6 +157,7 @@ Returns map settings with which this job was started.
signals:
void renderingLayersFinished();

152
python/core/auto_generated/settings/qgssettingsentry.sip.in
View File

@ -36,6 +36,8 @@ to validate set values and provide more accurate settings description for the gu
sipType = sipType_QgsSettingsEntryInteger;
else if ( dynamic_cast< QgsSettingsEntryDouble * >( sipCpp ) )
sipType = sipType_QgsSettingsEntryDouble;
else if ( dynamic_cast< QgsSettingsEntryColor * >( sipCpp ) )
sipType = sipType_QgsSettingsEntryColor;
else
sipType = NULL;
%End
@ -49,8 +51,8 @@ to validate set values and provide more accurate settings description for the gu
Bool,
Integer,
Double,
Enum,
Flag
EnumFlag,
Color
};
@ -725,10 +727,156 @@ Returns how much decimals should be shown in the Gui.
};
template <T>
class QgsSettingsEntryEnumFlag : QgsSettingsEntryBase
{
%Docstring(signature="appended")
A template class for enum and flag settings entry.
.. note::
This template class has a dedicated handling in sipify.pl
.. versionadded:: 3.20
%End
%TypeHeaderCode
#include "qgssettingsentry.h"
%End
public:
QgsSettingsEntryEnumFlag( const QString &key, QgsSettings::Section section, const T &defaultValue, const QString &description = QString() );
%Docstring
Constructor for :py:class:`QgsSettingsEntryEnumFlagBase`.
The ``key`` argument specifies the final part of the settings key.
The ``section`` argument specifies the section.
The ``default`` value argument specifies the default value for the settings entry.
The ``description`` argument specifies a description for the settings entry.
.. note::
The enum needs to be declared with Q_ENUM, and flags with Q_FLAG (not Q_FLAGS).
.. note::
for Python bindings, a custom implementation is achieved in Python directly
%End
T value( const QString &dynamicKeyPart = QString(), bool useDefaultValueOverride = false, const T &defaultValueOverride = T() ) const;
%Docstring
Get settings value.
The ``dynamicKeyPart`` argument specifies the dynamic part of the settings key.
The ``useDefaultValueOverride`` argument specifies if defaultValueOverride should be used.
The ``defaultValueOverride`` argument if valid is used instead of the normal default value.
%End
T value( const QStringList &dynamicKeyPartList, bool useDefaultValueOverride = false, const T &defaultValueOverride = T() ) const;
%Docstring
Get settings value.
The ``dynamicKeyParts`` argument specifies the list of dynamic parts of the settings key.
The ``useDefaultValueOverride`` argument specifies if defaultValueOverride should be used.
The ``defaultValueOverride`` argument if valid is used instead of the normal default value.
%End
T defaultValue() const;
%Docstring
Get settings default value.
%End
bool setValue( const T &value, const QString &dynamicKeyPart = QString() ) const;
%Docstring
\copydoc :py:class:`QgsSettingsEntryBase`.setValue
%End
bool setValue( const T &value, const QStringList &dynamicKeyPartList ) const;
%Docstring
\copydoc :py:class:`QgsSettingsEntryBase`.setValue
%End
virtual QgsSettingsEntryBase::SettingsType settingsType() const;
%Docstring
\copydoc :py:class:`QgsSettingsEntryBase`.settingsType
%End
};
class QgsSettingsEntryColor : QgsSettingsEntryBase
{
%Docstring(signature="appended")
A color settings entry.
.. versionadded:: 3.20
%End
%TypeHeaderCode
#include "qgssettingsentry.h"
%End
public:
QgsSettingsEntryColor( const QString &key,
const QString &pluginName,
const QColor &defaultValue = QColor(),
const QString &description = QString() );
%Docstring
Constructor for QgsSettingsEntryColor.
This constructor is intended to be used from plugins.
The ``key`` argument specifies the key of the settings.
The ``pluginName`` argument is inserted in the key after the section.
The ``default`` value argument specifies the default value for the settings entry.
The ``description`` argument specifies a description for the settings entry.
%End
bool setValue( const QColor &value, const QString &dynamicKeyPart = QString() ) const;
%Docstring
Set settings value.
The ``value`` to set.
The ``dynamicKeyPart`` argument specifies the dynamic part of the settings key.
%End
bool setValue( const QColor &value, const QStringList &dynamicKeyPartList ) const;
%Docstring
Set settings value.
The ``value`` to set.
The ``dynamicKeyParts`` argument specifies the list of dynamic parts of the settings key.
%End
QColor value( const QString &dynamicKeyPart = QString(), bool useDefaultValueOverride = false, const QString &defaultValueOverride = QString() ) const;
%Docstring
Get settings value.
The ``dynamicKeyPart`` argument specifies the dynamic part of the settings key.
The ``useDefaultValueOverride`` argument specifies if defaultValueOverride should be used.
The ``defaultValueOverride`` argument if valid is used instead of the normal default value.
%End
QColor value( const QStringList &dynamicKeyPartList, bool useDefaultValueOverride = false, const QString &defaultValueOverride = QString() ) const;
%Docstring
Get settings value.
The ``dynamicKeyParts`` argument specifies the list of dynamic parts of the settings key.
The ``useDefaultValueOverride`` argument specifies if defaultValueOverride should be used.
The ``defaultValueOverride`` argument if valid is used instead of the normal default value.
%End
QColor defaultValue() const;
%Docstring
Get settings default value.
%End
virtual SettingsType settingsType() const;
%Docstring
\copydoc :py:class:`QgsSettingsEntryBase`.settingsType
%End
};
/************************************************************************
* This file has been generated automatically from *

8
python/core/auto_generated/settings/qgssettingsregistry.sip.in
View File

@ -31,24 +31,24 @@ Constructor for QgsSettingsRegistry.
virtual ~QgsSettingsRegistry();
QList<const QgsSettingsEntryBase *> getChildSettingsEntries() const;
QList<const QgsSettingsEntryBase *> settingEntries() const;
%Docstring
Returns the list of registered :py:class:`QgsSettingsEntryBase`.
%End
const QgsSettingsEntryBase *getSettingsEntry( const QString &key, bool searchChildRegistries = true ) const;
const QgsSettingsEntryBase *settingsEntry( const QString &key, bool searchChildRegistries = true ) const;
%Docstring
Returns the :py:class:`QgsSettingsEntry` with the given ``key`` or None if not found.
The ``searchChildRegistries`` parameter specifies if child registries should be included in the search
%End
void appendRegistry( const QgsSettingsRegistry *settingsRegistry );
void addSubRegistry( const QgsSettingsRegistry *settingsRegistry );
%Docstring
Append a child ``settingsRegistry`` to the register.
%End
QList<const QgsSettingsRegistry *> getChildSettingsRegistries() const;
QList<const QgsSettingsRegistry *> subRegistries() const;
%Docstring
Returns the list of registered child QgsSettingsRegistry.
%End

2
python/core/auto_generated/settings/qgssettingsregistrycore.sip.in
View File

@ -9,6 +9,7 @@
class QgsSettingsRegistryCore : QgsSettingsRegistry
{
%Docstring(signature="appended")
@ -30,6 +31,7 @@ Constructor for QgsSettingsRegistryCore.
virtual ~QgsSettingsRegistryCore();
};
/************************************************************************

4
src/analysis/vector/geometry_checker/qgsgeometryisvalidcheck.cpp
View File

@ -15,7 +15,7 @@ email : matthias@opengis.ch
#include "qgsgeometryisvalidcheck.h"
#include "qgsfeature.h"
#include "qgssettings.h"
#include "qgssettingsregistrycore.h"
#include "qgsgeos.h"
#include "qgsgeometryvalidator.h"
@ -33,7 +33,7 @@ QList<QgsSingleGeometryCheckError *> QgsGeometryIsValidCheck::processGeometry( c
QVector<QgsGeometry::Error> errors;
QgsGeometry::ValidationMethod method = QgsGeometry::ValidatorQgisInternal;
if ( QgsSettings().value( QStringLiteral( "qgis/digitizing/validate_geometries" ), 1 ).toInt() == 2 )
if ( QgsSettingsRegistryCore::settingsDigitizingValidateGeometries.value() == 2 )
method = QgsGeometry::ValidatorGeos;
QgsGeometryValidator validator( geometry, &errors, method );

11
src/app/labeling/qgsmaptoollabel.cpp
View File

@ -24,7 +24,7 @@
#include "qgsvectorlayer.h"
#include "qgsvectorlayerlabeling.h"
#include "qgsdiagramrenderer.h"
#include "qgssettings.h"
#include "qgssettingsregistrycore.h"
#include "qgsvectorlayerjoininfo.h"
#include "qgsvectorlayerjoinbuffer.h"
#include "qgsauxiliarystorage.h"
@ -189,11 +189,10 @@ void QgsMapToolLabel::createRubberBands()
// instead, just use the boundary of the polygon for the rubber band
geom = QgsGeometry( geom.constGet()->boundary() );
}
QgsSettings settings;
int r = settings.value( QStringLiteral( "qgis/digitizing/line_color_red" ), 255 ).toInt();
int g = settings.value( QStringLiteral( "qgis/digitizing/line_color_green" ), 0 ).toInt();
int b = settings.value( QStringLiteral( "qgis/digitizing/line_color_blue" ), 0 ).toInt();
int a = settings.value( QStringLiteral( "qgis/digitizing/line_color_alpha" ), 200 ).toInt();
int r = QgsSettingsRegistryCore::settingsDigitizingLineColorRed.value();
int g = QgsSettingsRegistryCore::settingsDigitizingLineColorGreen.value();
int b = QgsSettingsRegistryCore::settingsDigitizingLineColorBlue.value();
int a = QgsSettingsRegistryCore::settingsDigitizingLineColorAlpha.value();
mFeatureRubberBand = new QgsRubberBand( mCanvas, geom.type() );
mFeatureRubberBand->setColor( QColor( r, g, b, a ) );
mFeatureRubberBand->setToGeometry( geom, vlayer );

14
src/app/main.cpp
View File

@ -966,20 +966,18 @@ int main( int argc, char *argv[] )
delete profile;
{
QgsSettings settings;
/* Translation file for QGIS.
*/
QString myUserTranslation = settings.value( QStringLiteral( "locale/userLocale" ), "" ).toString();
QString myGlobalLocale = settings.value( QStringLiteral( "locale/globalLocale" ), "" ).toString();
QString myUserTranslation = QgsApplication::settingsLocaleUserLocale.value();
QString myGlobalLocale = QgsApplication::settingsLocaleGlobalLocale.value();
bool myShowGroupSeparatorFlag = false; // Default to false
bool myLocaleOverrideFlag = settings.value( QStringLiteral( "locale/overrideFlag" ), false ).toBool();
bool myLocaleOverrideFlag = QgsApplication::settingsLocaleOverrideFlag.value();
// Override Show Group Separator if the global override flag is set
if ( myLocaleOverrideFlag )
{
// Default to false again
myShowGroupSeparatorFlag = settings.value( QStringLiteral( "locale/showGroupSeparator" ), false ).toBool();
myShowGroupSeparatorFlag = QgsApplication::settingsLocaleShowGroupSeparator.value();
}
//
@ -993,7 +991,7 @@ int main( int argc, char *argv[] )
//
if ( !translationCode.isNull() && !translationCode.isEmpty() )
{
settings.setValue( QStringLiteral( "locale/userLocale" ), translationCode );
QgsApplication::settingsLocaleUserLocale.setValue( translationCode );
}
else
{
@ -1002,7 +1000,7 @@ int main( int argc, char *argv[] )
translationCode = QLocale().name();
//setting the locale/userLocale when the --lang= option is not set will allow third party
//plugins to always use the same locale as the QGIS, otherwise they can be out of sync
settings.setValue( QStringLiteral( "locale/userLocale" ), translationCode );
QgsApplication::settingsLocaleUserLocale.setValue( translationCode );
}
else
{

9
src/app/maptools/qgsappmaptools.cpp
View File

@ -69,6 +69,7 @@
#include "qgsmaptoolpinlabels.h"
#include "qgsmaptooloffsetpointsymbol.h"
#include "qgsspinbox.h"
#include "qgssettingsregistrycore.h"
//
// QgsStreamDigitizingSettingsAction
@ -80,9 +81,6 @@ QgsStreamDigitizingSettingsAction::QgsStreamDigitizingSettingsAction( QWidget *p
QGridLayout *gLayout = new QGridLayout();
gLayout->setContentsMargins( 3, 2, 3, 2 );
QgsSettings settings;
int defaultTolerance = settings.value( QStringLiteral( "/qgis/digitizing/stream_tolerance" ), 2 ).toInt();
mStreamToleranceSpinBox = new QgsSpinBox();
mStreamToleranceSpinBox->setSuffix( tr( "px" ) );
mStreamToleranceSpinBox->setKeyboardTracking( false );
@ -90,15 +88,14 @@ QgsStreamDigitizingSettingsAction::QgsStreamDigitizingSettingsAction( QWidget *p
mStreamToleranceSpinBox->setWrapping( false );
mStreamToleranceSpinBox->setSingleStep( 1 );
mStreamToleranceSpinBox->setClearValue( 2 );
mStreamToleranceSpinBox->setValue( defaultTolerance );
mStreamToleranceSpinBox->setValue( QgsSettingsRegistryCore::settingsDigitizingStreamTolerance.value() );
QLabel *label = new QLabel( tr( "Streaming Tolerance" ) );
gLayout->addWidget( label, 1, 0 );
gLayout->addWidget( mStreamToleranceSpinBox, 1, 1 );
connect( mStreamToleranceSpinBox, qOverload<int>( &QgsSpinBox::valueChanged ), this, [ = ]( int value )
{
QgsSettings settings;
settings.setValue( QStringLiteral( "/qgis/digitizing/stream_tolerance" ), value );
QgsSettingsRegistryCore::settingsDigitizingStreamTolerance.setValue( value );
} );
QWidget *w = new QWidget();

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

@ -24,6 +24,7 @@
#include "qgsgdalutils.h"
#include "qgshighlight.h"
#include "qgsmapcanvas.h"
#include "qgsmaprendererjob.h"
#include "qgsprojectionselectiondialog.h"
#include "qgscoordinatereferencesystem.h"
#include "qgstolerance.h"
@ -53,6 +54,7 @@
#include "qgsunittypes.h"
#include "qgsclipboard.h"
#include "qgssettings.h"
#include "qgssettingsregistrycore.h"
#include "qgsoptionswidgetfactory.h"
#include "qgslocatorwidget.h"
#include "qgslocatoroptionswidget.h"
@ -357,7 +359,7 @@ QgsOptions::QgsOptions( QWidget *parent, Qt::WindowFlags fl, const QList<QgsOpti
//Network timeout
mNetworkTimeoutSpinBox->setValue( QgsNetworkAccessManager::timeout() );
mNetworkTimeoutSpinBox->setClearValue( 60000 );
mNetworkTimeoutSpinBox->setClearValue( QgsNetworkAccessManager::settingsNetworkTimeout.defaultValue() );
leUserAgent->setText( mSettings->value( QStringLiteral( "/qgis/networkAndProxy/userAgent" ), "Mozilla/5.0" ).toString() );
// WMS capabilities expiry time
@ -474,7 +476,7 @@ QgsOptions::QgsOptions( QWidget *parent, Qt::WindowFlags fl, const QList<QgsOpti
cmbScanZipInBrowser->setCurrentIndex( index );
// log rendering events, for userspace debugging
mLogCanvasRefreshChkBx->setChecked( mSettings->value( QStringLiteral( "/Map/logCanvasRefreshEvent" ), false ).toBool() );
mLogCanvasRefreshChkBx->setChecked( QgsMapRendererJob::settingsLogCanvasRefreshEvent.value() );
//set the default projection behavior radio buttons
const QgsOptions::UnknownLayerCrsBehavior mode = QgsSettings().enumValue( QStringLiteral( "/projections/unknownCrsBehavior" ), QgsOptions::UnknownLayerCrsBehavior::NoAction, QgsSettings::App );
@ -577,7 +579,7 @@ QgsOptions::QgsOptions( QWidget *parent, Qt::WindowFlags fl, const QList<QgsOpti
mAngleUnitsComboBox->setCurrentIndex( mAngleUnitsComboBox->findData( unit ) );
// set decimal places of the measure tool
int decimalPlaces = mSettings->value( QStringLiteral( "/qgis/measure/decimalplaces" ), "3" ).toInt();
int decimalPlaces = mSettings->value( QStringLiteral( "/qgis/measure/decimalplaces" ), 3 ).toInt();
mDecimalPlacesSpinBox->setClearValue( 3 );
mDecimalPlacesSpinBox->setRange( 0, 12 );
mDecimalPlacesSpinBox->setValue( decimalPlaces );
@ -1014,9 +1016,9 @@ QgsOptions::QgsOptions( QWidget *parent, Qt::WindowFlags fl, const QList<QgsOpti
//
QString currentLocale = QLocale().name();
lblSystemLocale->setText( tr( "Detected active locale on your system: %1" ).arg( currentLocale ) );
QString userLocale = mSettings->value( QStringLiteral( "locale/userLocale" ), QString( ) ).toString();
bool showGroupSeparator = mSettings->value( QStringLiteral( "locale/showGroupSeparator" ), false ).toBool();
QString globalLocale = mSettings->value( QStringLiteral( "locale/globalLocale" ), currentLocale ).toString();
QString userLocale = QgsApplication::settingsLocaleUserLocale.value();
bool showGroupSeparator = QgsApplication::settingsLocaleShowGroupSeparator.value();
QString globalLocale = QgsApplication::settingsLocaleGlobalLocale.value();
const QStringList language18nList( i18nList() );
for ( const auto &l : language18nList )
{
@ -1043,40 +1045,35 @@ QgsOptions::QgsOptions( QWidget *parent, Qt::WindowFlags fl, const QList<QgsOpti
cboTranslation->setCurrentIndex( cboTranslation->findData( userLocale ) );
cboGlobalLocale->setCurrentIndex( cboGlobalLocale->findData( globalLocale ) );
bool localeOverrideFlag = mSettings->value( QStringLiteral( "locale/overrideFlag" ), false ).toBool();
grpLocale->setChecked( localeOverrideFlag );
grpLocale->setChecked( QgsApplication::settingsLocaleOverrideFlag.value() );
cbShowGroupSeparator->setChecked( showGroupSeparator );
//set elements in digitizing tab
mLineWidthSpinBox->setValue( mSettings->value( QStringLiteral( "/qgis/digitizing/line_width" ), 1 ).toInt() );
red = mSettings->value( QStringLiteral( "/qgis/digitizing/line_color_red" ), 255 ).toInt();
green = mSettings->value( QStringLiteral( "/qgis/digitizing/line_color_green" ), 0 ).toInt();
blue = mSettings->value( QStringLiteral( "/qgis/digitizing/line_color_blue" ), 0 ).toInt();
alpha = mSettings->value( QStringLiteral( "/qgis/digitizing/line_color_alpha" ), 200 ).toInt();
mLineColorToolButton->setColor( QColor( red, green, blue, alpha ) );
mLineWidthSpinBox->setValue( QgsSettingsRegistryCore::settingsDigitizingLineWidth.value() );
mLineColorToolButton->setColor( QColor( QgsSettingsRegistryCore::settingsDigitizingLineColorRed.value(),
QgsSettingsRegistryCore::settingsDigitizingLineColorGreen.value(),
QgsSettingsRegistryCore::settingsDigitizingLineColorBlue.value(),
QgsSettingsRegistryCore::settingsDigitizingLineColorAlpha.value() ) );
mLineColorToolButton->setAllowOpacity( true );
mLineColorToolButton->setContext( QStringLiteral( "gui" ) );
mLineColorToolButton->setDefaultColor( QColor( 255, 0, 0, 200 ) );
red = mSettings->value( QStringLiteral( "/qgis/digitizing/fill_color_red" ), 255 ).toInt();
green = mSettings->value( QStringLiteral( "/qgis/digitizing/fill_color_green" ), 0 ).toInt();
blue = mSettings->value( QStringLiteral( "/qgis/digitizing/fill_color_blue" ), 0 ).toInt();
alpha = mSettings->value( QStringLiteral( "/qgis/digitizing/fill_color_alpha" ), 30 ).toInt();
mFillColorToolButton->setColor( QColor( red, green, blue, alpha ) );
mFillColorToolButton->setColor( QColor( QgsSettingsRegistryCore::settingsDigitizingFillColorRed.value(),
QgsSettingsRegistryCore::settingsDigitizingFillColorGreen.value(),
QgsSettingsRegistryCore::settingsDigitizingFillColorBlue.value(),
QgsSettingsRegistryCore::settingsDigitizingFillColorAlpha.value() ) );
mFillColorToolButton->setAllowOpacity( true );
mFillColorToolButton->setContext( QStringLiteral( "gui" ) );
mFillColorToolButton->setDefaultColor( QColor( 255, 0, 0, 30 ) );
mLineGhostCheckBox->setChecked( mSettings->value( QStringLiteral( "/qgis/digitizing/line_ghost" ), false ).toBool() );
mLineGhostCheckBox->setChecked( QgsSettingsRegistryCore::settingsDigitizingLineGhost.value() );
mDefaultZValueSpinBox->setValue(
mSettings->value( QStringLiteral( "/qgis/digitizing/default_z_value" ), Qgis::DEFAULT_Z_COORDINATE ).toDouble()
);
mDefaultZValueSpinBox->setClearValue( Qgis::DEFAULT_Z_COORDINATE );
mDefaultZValueSpinBox->setValue( QgsSettingsRegistryCore::settingsDigitizingDefaultZValue.value() );
mDefaultZValueSpinBox->setClearValue( QgsSettingsRegistryCore::settingsDigitizingDefaultZValue.defaultValue() );
//default snap mode
mSnappingEnabledDefault->setChecked( mSettings->value( QStringLiteral( "/qgis/digitizing/default_snap_enabled" ), false ).toBool() );
mSnappingEnabledDefault->setChecked( QgsSettingsRegistryCore::settingsDigitizingDefaultSnapEnabled.value() );
for ( QgsSnappingConfig::SnappingTypes type :
{
@ -1094,13 +1091,13 @@ QgsOptions::QgsOptions( QWidget *parent, Qt::WindowFlags fl, const QList<QgsOpti
type );
}
QgsSnappingConfig::SnappingTypeFlag defaultSnapMode = mSettings->flagValue( QStringLiteral( "/qgis/digitizing/default_snap_type" ), QgsSnappingConfig::VertexFlag );
QgsSnappingConfig::SnappingTypeFlag defaultSnapMode = QgsSettingsRegistryCore::settingsDigitizingDefaultSnapType.value();
mDefaultSnapModeComboBox->setCurrentIndex( mDefaultSnapModeComboBox->findData( static_cast<int>( defaultSnapMode ) ) );
mDefaultSnappingToleranceSpinBox->setValue( mSettings->value( QStringLiteral( "/qgis/digitizing/default_snapping_tolerance" ), Qgis::DEFAULT_SNAP_TOLERANCE ).toDouble() );
mDefaultSnappingToleranceSpinBox->setClearValue( Qgis::DEFAULT_SNAP_TOLERANCE );
mSearchRadiusVertexEditSpinBox->setValue( mSettings->value( QStringLiteral( "/qgis/digitizing/search_radius_vertex_edit" ), 10 ).toDouble() );
mSearchRadiusVertexEditSpinBox->setClearValue( 10 );
QgsTolerance::UnitType defSnapUnits = mSettings->enumValue( QStringLiteral( "/qgis/digitizing/default_snapping_tolerance_unit" ), Qgis::DEFAULT_SNAP_UNITS );
mDefaultSnappingToleranceSpinBox->setValue( QgsSettingsRegistryCore::settingsDigitizingDefaultSnappingTolerance.value() );
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 )
{
index = mDefaultSnappingToleranceComboBox->findText( tr( "map units" ) );
@ -1110,7 +1107,7 @@ QgsOptions::QgsOptions( QWidget *parent, Qt::WindowFlags fl, const QList<QgsOpti
index = mDefaultSnappingToleranceComboBox->findText( tr( "pixels" ) );
}
mDefaultSnappingToleranceComboBox->setCurrentIndex( index );
QgsTolerance::UnitType defRadiusUnits = mSettings->enumValue( QStringLiteral( "/qgis/digitizing/search_radius_vertex_edit_unit" ), QgsTolerance::Pixels );
QgsTolerance::UnitType defRadiusUnits = QgsSettingsRegistryCore::settingsDigitizingSearchRadiusVertexEditUnit.value();
if ( defRadiusUnits == QgsTolerance::ProjectUnits || defRadiusUnits == QgsTolerance::LayerUnits )
{
index = mSearchRadiusVertexEditComboBox->findText( tr( "map units" ) );
@ -1121,12 +1118,12 @@ QgsOptions::QgsOptions( QWidget *parent, Qt::WindowFlags fl, const QList<QgsOpti
}
mSearchRadiusVertexEditComboBox->setCurrentIndex( index );
mSnappingMarkerColorButton->setColor( mSettings->value( QStringLiteral( "/qgis/digitizing/snap_color" ), QColor( Qt::magenta ) ).value<QColor>() );
mSnappingTooltipsCheckbox->setChecked( mSettings->value( QStringLiteral( "/qgis/digitizing/snap_tooltip" ), false ).toBool() );
mEnableSnappingOnInvisibleFeatureCheckbox->setChecked( mSettings->value( QStringLiteral( "/qgis/digitizing/snap_invisible_feature" ), false ).toBool() );
mSnappingMarkerColorButton->setColor( QgsSettingsRegistryCore::settingsDigitizingSnapColor.value() );
mSnappingTooltipsCheckbox->setChecked( QgsSettingsRegistryCore::settingsDigitizingSnapTooltip.value() );
mEnableSnappingOnInvisibleFeatureCheckbox->setChecked( QgsSettingsRegistryCore::settingsDigitizingSnapInvisibleFeature.value() );
//vertex marker
mMarkersOnlyForSelectedCheckBox->setChecked( mSettings->value( QStringLiteral( "/qgis/digitizing/marker_only_for_selected" ), true ).toBool() );
mMarkersOnlyForSelectedCheckBox->setChecked( QgsSettingsRegistryCore::settingsDigitizingMarkerOnlyForSelected.value() );
mMarkerStyleComboBox->addItem( tr( "Semi Transparent Circle" ) );
mMarkerStyleComboBox->addItem( tr( "Cross" ) );
@ -1137,7 +1134,7 @@ QgsOptions::QgsOptions( QWidget *parent, Qt::WindowFlags fl, const QList<QgsOpti
mValidateGeometries->addItem( tr( "QGIS" ) );
mValidateGeometries->addItem( tr( "GEOS" ) );
QString markerStyle = mSettings->value( QStringLiteral( "/qgis/digitizing/marker_style" ), "Cross" ).toString();
QString markerStyle = QgsSettingsRegistryCore::settingsDigitizingMarkerStyle.value();
if ( markerStyle == QLatin1String( "SemiTransparentCircle" ) )
{
mMarkerStyleComboBox->setCurrentIndex( mMarkerStyleComboBox->findText( tr( "Semi Transparent Circle" ) ) );
@ -1150,12 +1147,12 @@ QgsOptions::QgsOptions( QWidget *parent, Qt::WindowFlags fl, const QList<QgsOpti
{
mMarkerStyleComboBox->setCurrentIndex( mMarkerStyleComboBox->findText( tr( "None" ) ) );
}
mMarkerSizeSpinBox->setValue( mSettings->value( QStringLiteral( "/qgis/digitizing/marker_size_mm" ), 2.0 ).toDouble() );
mMarkerSizeSpinBox->setClearValue( 2.0 );
mMarkerSizeSpinBox->setValue( QgsSettingsRegistryCore::settingsDigitizingMarkerSizeMm.value() );
mMarkerSizeSpinBox->setClearValue( QgsSettingsRegistryCore::settingsDigitizingMarkerSizeMm.defaultValue() );
chkReuseLastValues->setChecked( mSettings->value( QStringLiteral( "/qgis/digitizing/reuseLastValues" ), false ).toBool() );
chkDisableAttributeValuesDlg->setChecked( mSettings->value( QStringLiteral( "/qgis/digitizing/disable_enter_attribute_values_dialog" ), false ).toBool() );
mValidateGeometries->setCurrentIndex( mSettings->value( QStringLiteral( "/qgis/digitizing/validate_geometries" ), 1 ).toInt() );
chkReuseLastValues->setChecked( QgsSettingsRegistryCore::settingsDigitizingReuseLastValues.value() );
chkDisableAttributeValuesDlg->setChecked( QgsSettingsRegistryCore::settingsDigitizingDisableEnterAttributeValuesDialog.value() );
mValidateGeometries->setCurrentIndex( QgsSettingsRegistryCore::settingsDigitizingValidateGeometries.value() );
mSnappingMainDialogComboBox->clear();
mSnappingMainDialogComboBox->addItem( tr( "Dialog" ), "dialog" );
@ -1165,18 +1162,18 @@ QgsOptions::QgsOptions( QWidget *parent, Qt::WindowFlags fl, const QList<QgsOpti
mOffsetJoinStyleComboBox->addItem( tr( "Round" ), QgsGeometry::JoinStyleRound );
mOffsetJoinStyleComboBox->addItem( tr( "Miter" ), QgsGeometry::JoinStyleMiter );
mOffsetJoinStyleComboBox->addItem( tr( "Bevel" ), QgsGeometry::JoinStyleBevel );
QgsGeometry::JoinStyle joinStyleSetting = mSettings->enumValue( QStringLiteral( "/qgis/digitizing/offset_join_style" ), QgsGeometry::JoinStyleRound );
QgsGeometry::JoinStyle joinStyleSetting = QgsSettingsRegistryCore::settingsDigitizingOffsetJoinStyle.value();
mOffsetJoinStyleComboBox->setCurrentIndex( mOffsetJoinStyleComboBox->findData( joinStyleSetting ) );
mOffsetQuadSegSpinBox->setValue( mSettings->value( QStringLiteral( "/qgis/digitizing/offset_quad_seg" ), 8 ).toInt() );
mOffsetQuadSegSpinBox->setClearValue( 8 );
mCurveOffsetMiterLimitComboBox->setValue( mSettings->value( QStringLiteral( "/qgis/digitizing/offset_miter_limit" ), 5.0 ).toDouble() );
mCurveOffsetMiterLimitComboBox->setClearValue( 5.0 );
mOffsetQuadSegSpinBox->setValue( QgsSettingsRegistryCore::settingsDigitizingOffsetQuadSeg.value() );
mOffsetQuadSegSpinBox->setClearValue( QgsSettingsRegistryCore::settingsDigitizingOffsetQuadSeg.defaultValue() );
mCurveOffsetMiterLimitComboBox->setValue( QgsSettingsRegistryCore::settingsDigitizingOffsetMiterLimit.value() );
mCurveOffsetMiterLimitComboBox->setClearValue( QgsSettingsRegistryCore::settingsDigitizingOffsetMiterLimit.defaultValue() );
mTracingConvertToCurveCheckBox->setChecked( mSettings->value( QStringLiteral( "/qgis/digitizing/convert_to_curve" ), false ).toBool() );
mTracingCustomAngleToleranceSpinBox->setValue( mSettings->value( QStringLiteral( "/qgis/digitizing/convert_to_curve_angle_tolerance" ), 1e-6 ).toDouble() );
mTracingCustomAngleToleranceSpinBox->setClearValue( 1e-6 );
mTracingCustomDistanceToleranceSpinBox->setValue( mSettings->value( QStringLiteral( "/qgis/digitizing/convert_to_curve_distance_tolerance" ), 1e-6 ).toDouble() );
mTracingCustomDistanceToleranceSpinBox->setClearValue( 1e-6 );
mTracingConvertToCurveCheckBox->setChecked( QgsSettingsRegistryCore::settingsDigitizingConvertToCurve.value() );
mTracingCustomAngleToleranceSpinBox->setValue( QgsSettingsRegistryCore::settingsDigitizingConvertToCurveAngleTolerance.value() );
mTracingCustomAngleToleranceSpinBox->setClearValue( QgsSettingsRegistryCore::settingsDigitizingConvertToCurveAngleTolerance.defaultValue() );
mTracingCustomDistanceToleranceSpinBox->setValue( QgsSettingsRegistryCore::settingsDigitizingConvertToCurveDistanceTolerance.value() );
mTracingCustomDistanceToleranceSpinBox->setClearValue( QgsSettingsRegistryCore::settingsDigitizingConvertToCurveDistanceTolerance.defaultValue() );
// load gdal driver list only when gdal tab is first opened
mLoadedGdalDriverList = false;
@ -1673,7 +1670,7 @@ void QgsOptions::saveOptions()
mSettings->setValue( QStringLiteral( "/Raster/cumulativeCutUpper" ), mRasterCumulativeCutUpperDoubleSpinBox->value() / 100.0 );
// log rendering events, for userspace debugging
mSettings->setValue( QStringLiteral( "/Map/logCanvasRefreshEvent" ), mLogCanvasRefreshChkBx->isChecked() );
QgsMapRendererJob::settingsLogCanvasRefreshEvent.setValue( mLogCanvasRefreshChkBx->isChecked() );
//check behavior so default projection when new layer is added with no
//projection defined...
@ -1739,65 +1736,65 @@ void QgsOptions::saveOptions()
mSettings->setValue( QStringLiteral( "/qgis/zoom_factor" ), zoomFactorValue() );
//digitizing
mSettings->setValue( QStringLiteral( "/qgis/digitizing/line_width" ), mLineWidthSpinBox->value() );
QgsSettingsRegistryCore::settingsDigitizingLineWidth.setValue( mLineWidthSpinBox->value() );
QColor digitizingColor = mLineColorToolButton->color();
mSettings->setValue( QStringLiteral( "/qgis/digitizing/line_color_red" ), digitizingColor.red() );
mSettings->setValue( QStringLiteral( "/qgis/digitizing/line_color_green" ), digitizingColor.green() );
mSettings->setValue( QStringLiteral( "/qgis/digitizing/line_color_blue" ), digitizingColor.blue() );
mSettings->setValue( QStringLiteral( "/qgis/digitizing/line_color_alpha" ), digitizingColor.alpha() );
QgsSettingsRegistryCore::settingsDigitizingLineColorRed.setValue( digitizingColor.red() );
QgsSettingsRegistryCore::settingsDigitizingLineColorGreen.setValue( digitizingColor.green() );
QgsSettingsRegistryCore::settingsDigitizingLineColorBlue.setValue( digitizingColor.blue() );
QgsSettingsRegistryCore::settingsDigitizingLineColorAlpha.setValue( digitizingColor.alpha() );
digitizingColor = mFillColorToolButton->color();
mSettings->setValue( QStringLiteral( "/qgis/digitizing/fill_color_red" ), digitizingColor.red() );
mSettings->setValue( QStringLiteral( "/qgis/digitizing/fill_color_green" ), digitizingColor.green() );
mSettings->setValue( QStringLiteral( "/qgis/digitizing/fill_color_blue" ), digitizingColor.blue() );
mSettings->setValue( QStringLiteral( "/qgis/digitizing/fill_color_alpha" ), digitizingColor.alpha() );
QgsSettingsRegistryCore::settingsDigitizingFillColorRed.setValue( digitizingColor.red() );
QgsSettingsRegistryCore::settingsDigitizingFillColorGreen.setValue( digitizingColor.green() );
QgsSettingsRegistryCore::settingsDigitizingFillColorBlue.setValue( digitizingColor.blue() );
QgsSettingsRegistryCore::settingsDigitizingFillColorAlpha.setValue( digitizingColor.alpha() );
settings.setValue( QStringLiteral( "/qgis/digitizing/line_ghost" ), mLineGhostCheckBox->isChecked() );
QgsSettingsRegistryCore::settingsDigitizingLineGhost.setValue( mLineGhostCheckBox->isChecked() );
mSettings->setValue( QStringLiteral( "/qgis/digitizing/default_z_value" ), mDefaultZValueSpinBox->value() );
QgsSettingsRegistryCore::settingsDigitizingDefaultZValue.setValue( mDefaultZValueSpinBox->value() );
//default snap mode
mSettings->setValue( QStringLiteral( "/qgis/digitizing/default_snap_enabled" ), mSnappingEnabledDefault->isChecked() );
mSettings->setFlagValue( QStringLiteral( "/qgis/digitizing/default_snap_type" ), static_cast<QgsSnappingConfig::SnappingTypeFlag>( mDefaultSnapModeComboBox->currentData().toInt() ) );
mSettings->setValue( QStringLiteral( "/qgis/digitizing/default_snapping_tolerance" ), mDefaultSnappingToleranceSpinBox->value() );
mSettings->setValue( QStringLiteral( "/qgis/digitizing/search_radius_vertex_edit" ), mSearchRadiusVertexEditSpinBox->value() );
mSettings->setEnumValue( QStringLiteral( "/qgis/digitizing/default_snapping_tolerance_unit" ),
( mDefaultSnappingToleranceComboBox->currentIndex() == 0 ? QgsTolerance::ProjectUnits : QgsTolerance::Pixels ) );
mSettings->setEnumValue( QStringLiteral( "/qgis/digitizing/search_radius_vertex_edit_unit" ),
( mSearchRadiusVertexEditComboBox->currentIndex() == 0 ? QgsTolerance::ProjectUnits : QgsTolerance::Pixels ) );
QgsSettingsRegistryCore::settingsDigitizingDefaultSnapEnabled.setValue( mSnappingEnabledDefault->isChecked() );
QgsSettingsRegistryCore::settingsDigitizingDefaultSnapType.setValue( static_cast<QgsSnappingConfig::SnappingTypes>( mDefaultSnapModeComboBox->currentData().toInt() ) );
QgsSettingsRegistryCore::settingsDigitizingDefaultSnappingTolerance.setValue( mDefaultSnappingToleranceSpinBox->value() );
QgsSettingsRegistryCore::settingsDigitizingSearchRadiusVertexEdit.setValue( mSearchRadiusVertexEditSpinBox->value() );
QgsSettingsRegistryCore::settingsDigitizingDefaultSnappingToleranceUnit.setValue(
( mDefaultSnappingToleranceComboBox->currentIndex() == 0 ? QgsTolerance::ProjectUnits : QgsTolerance::Pixels ) );
QgsSettingsRegistryCore::settingsDigitizingSearchRadiusVertexEditUnit.setValue(
( mSearchRadiusVertexEditComboBox->currentIndex() == 0 ? QgsTolerance::ProjectUnits : QgsTolerance::Pixels ) );
mSettings->setValue( QStringLiteral( "/qgis/digitizing/snap_color" ), mSnappingMarkerColorButton->color() );
mSettings->setValue( QStringLiteral( "/qgis/digitizing/snap_tooltip" ), mSnappingTooltipsCheckbox->isChecked() );
mSettings->setValue( QStringLiteral( "/qgis/digitizing/snap_invisible_feature" ), mEnableSnappingOnInvisibleFeatureCheckbox->isChecked() );
QgsSettingsRegistryCore::settingsDigitizingSnapColor.setValue( mSnappingMarkerColorButton->color() );
QgsSettingsRegistryCore::settingsDigitizingSnapTooltip.setValue( mSnappingTooltipsCheckbox->isChecked() );
QgsSettingsRegistryCore::settingsDigitizingSnapInvisibleFeature.setValue( mEnableSnappingOnInvisibleFeatureCheckbox->isChecked() );
mSettings->setValue( QStringLiteral( "/qgis/digitizing/marker_only_for_selected" ), mMarkersOnlyForSelectedCheckBox->isChecked() );
QgsSettingsRegistryCore::settingsDigitizingMarkerOnlyForSelected.setValue( mMarkersOnlyForSelectedCheckBox->isChecked() );
QString markerComboText = mMarkerStyleComboBox->currentText();
if ( markerComboText == tr( "Semi Transparent Circle" ) )
{
mSettings->setValue( QStringLiteral( "/qgis/digitizing/marker_style" ), "SemiTransparentCircle" );
QgsSettingsRegistryCore::settingsDigitizingMarkerStyle.setValue( QStringLiteral( "SemiTransparentCircle" ) );
}
else if ( markerComboText == tr( "Cross" ) )
{
mSettings->setValue( QStringLiteral( "/qgis/digitizing/marker_style" ), "Cross" );
QgsSettingsRegistryCore::settingsDigitizingMarkerStyle.setValue( QStringLiteral( "Cross" ) );
}
else if ( markerComboText == tr( "None" ) )
{
mSettings->setValue( QStringLiteral( "/qgis/digitizing/marker_style" ), "None" );
QgsSettingsRegistryCore::settingsDigitizingMarkerStyle.setValue( QStringLiteral( "None" ) );
}
mSettings->setValue( QStringLiteral( "/qgis/digitizing/marker_size_mm" ), ( mMarkerSizeSpinBox->value() ) );
QgsSettingsRegistryCore::settingsDigitizingMarkerSizeMm.setValue( mMarkerSizeSpinBox->value() );
mSettings->setValue( QStringLiteral( "/qgis/digitizing/reuseLastValues" ), chkReuseLastValues->isChecked() );
mSettings->setValue( QStringLiteral( "/qgis/digitizing/disable_enter_attribute_values_dialog" ), chkDisableAttributeValuesDlg->isChecked() );
mSettings->setValue( QStringLiteral( "/qgis/digitizing/validate_geometries" ), mValidateGeometries->currentIndex() );
QgsSettingsRegistryCore::settingsDigitizingReuseLastValues.setValue( chkReuseLastValues->isChecked() );
QgsSettingsRegistryCore::settingsDigitizingDisableEnterAttributeValuesDialog.setValue( chkDisableAttributeValuesDlg->isChecked() );
QgsSettingsRegistryCore::settingsDigitizingValidateGeometries.setValue( mValidateGeometries->currentIndex() );
mSettings->setEnumValue( QStringLiteral( "/qgis/digitizing/offset_join_style" ), mOffsetJoinStyleComboBox->currentData().value<QgsGeometry::JoinStyle>() );
mSettings->setValue( QStringLiteral( "/qgis/digitizing/offset_quad_seg" ), mOffsetQuadSegSpinBox->value() );
mSettings->setValue( QStringLiteral( "/qgis/digitizing/offset_miter_limit" ), mCurveOffsetMiterLimitComboBox->value() );
QgsSettingsRegistryCore::settingsDigitizingOffsetJoinStyle.setValue( mOffsetJoinStyleComboBox->currentData().value<QgsGeometry::JoinStyle>() );
QgsSettingsRegistryCore::settingsDigitizingOffsetQuadSeg.setValue( mOffsetQuadSegSpinBox->value() );
QgsSettingsRegistryCore::settingsDigitizingOffsetMiterLimit.setValue( mCurveOffsetMiterLimitComboBox->value() );
mSettings->setValue( QStringLiteral( "/qgis/digitizing/convert_to_curve" ), mTracingConvertToCurveCheckBox->isChecked() );
mSettings->setValue( QStringLiteral( "/qgis/digitizing/convert_to_curve_angle_tolerance" ), mTracingCustomAngleToleranceSpinBox->value() );
mSettings->setValue( QStringLiteral( "/qgis/digitizing/convert_to_curve_distance_tolerance" ), mTracingCustomDistanceToleranceSpinBox->value() );
QgsSettingsRegistryCore::settingsDigitizingConvertToCurve.setValue( mTracingConvertToCurveCheckBox->isChecked() );
QgsSettingsRegistryCore::settingsDigitizingConvertToCurveAngleTolerance.setValue( mTracingCustomAngleToleranceSpinBox->value() );
QgsSettingsRegistryCore::settingsDigitizingConvertToCurveDistanceTolerance.setValue( mTracingCustomDistanceToleranceSpinBox->value() );
// default scale list
QString myPaths;
@ -1856,12 +1853,12 @@ void QgsOptions::saveOptions()
//
// Locale settings
//
mSettings->setValue( QStringLiteral( "locale/userLocale" ), cboTranslation->currentData().toString() );
mSettings->setValue( QStringLiteral( "locale/overrideFlag" ), grpLocale->isChecked() );
mSettings->setValue( QStringLiteral( "locale/globalLocale" ), cboGlobalLocale->currentData( ).toString() );
QgsApplication::settingsLocaleUserLocale.setValue( cboTranslation->currentData().toString() );
QgsApplication::settingsLocaleOverrideFlag.setValue( grpLocale->isChecked() );
QgsApplication::settingsLocaleGlobalLocale.setValue( cboGlobalLocale->currentData( ).toString() );
// Number settings
mSettings->setValue( QStringLiteral( "locale/showGroupSeparator" ), cbShowGroupSeparator->isChecked( ) );
QgsApplication::settingsLocaleShowGroupSeparator.setValue( cbShowGroupSeparator->isChecked( ) );
QgsLocalDefaultSettings::setBearingFormat( mBearingFormat.get() );

9
src/app/qgisapp.cpp
View File

@ -76,7 +76,7 @@
#include <QWidgetAction>
#include <mutex>
#include "qgssettings.h"
#include "qgssettingsregistrycore.h"
#include "qgsnetworkaccessmanager.h"
#include "qgsrelationmanager.h"
#include "qgsapplication.h"
@ -11111,9 +11111,8 @@ bool QgisApp::toggleEditing( QgsMapLayer *layer, bool allowCancel )
vlayer->startEditing();
QgsSettings settings;
QString markerType = settings.value( QStringLiteral( "qgis/digitizing/marker_style" ), "Cross" ).toString();
bool markSelectedOnly = settings.value( QStringLiteral( "qgis/digitizing/marker_only_for_selected" ), true ).toBool();
QString markerType = QgsSettingsRegistryCore::settingsDigitizingMarkerStyle.value();
bool markSelectedOnly = QgsSettingsRegistryCore::settingsDigitizingMarkerOnlyForSelected.value();
// redraw only if markers will be drawn
if ( ( !markSelectedOnly || vlayer->selectedFeatureCount() > 0 ) &&
@ -14347,7 +14346,7 @@ void QgisApp::showPanMessage( double distance, QgsUnitTypes::DistanceUnit unit,
return;
const double distanceInProjectUnits = distance * QgsUnitTypes::fromUnitToUnitFactor( unit, QgsProject::instance()->distanceUnits() );
const int distanceDecimalPlaces = QgsSettings().value( QStringLiteral( "qgis/measure/decimalplaces" ), "3" ).toInt();
const int distanceDecimalPlaces = QgsSettings().value( QStringLiteral( "qgis/measure/decimalplaces" ), 3 ).toInt();
const QString distanceString = QgsDistanceArea::formatDistance( distanceInProjectUnits, distanceDecimalPlaces, QgsProject::instance()->distanceUnits() );
const QString bearingString = mBearingNumericFormat->formatDouble( bearing, QgsNumericFormatContext() );
mStatusBar->showMessage( tr( "Pan distance %1 (%2)" ).arg( distanceString, bearingString ), 2000 );

2
src/app/qgsdisplayangle.cpp
View File

@ -39,6 +39,6 @@ void QgsDisplayAngle::updateUi()
{
QgsSettings settings;
QgsUnitTypes::AngleUnit unit = QgsUnitTypes::decodeAngleUnit( settings.value( QStringLiteral( "qgis/measure/angleunits" ), QgsUnitTypes::encodeUnit( QgsUnitTypes::AngleDegrees ) ).toString() );
int decimals = settings.value( QStringLiteral( "qgis/measure/decimalplaces" ), "3" ).toInt();
int decimals = settings.value( QStringLiteral( "qgis/measure/decimalplaces" ), 3 ).toInt();
mAngleLineEdit->setText( QgsUnitTypes::formatAngle( mValue * QgsUnitTypes::fromUnitToUnitFactor( QgsUnitTypes::AngleRadians, unit ), decimals, unit ) );
}

7
src/app/qgsfeatureaction.cpp
View File

@ -30,7 +30,7 @@
#include "qgsactionmanager.h"
#include "qgsaction.h"
#include "qgsvectorlayerutils.h"
#include "qgssettings.h"
#include "qgssettingsregistrycore.h"
#include <QPushButton>
@ -173,8 +173,7 @@ bool QgsFeatureAction::addFeature( const QgsAttributeMap &defaultAttributes, boo
if ( !mLayer || !mLayer->isEditable() )
return false;
QgsSettings settings;
const bool reuseAllLastValues = settings.value( QStringLiteral( "qgis/digitizing/reuseLastValues" ), false ).toBool();
const bool reuseAllLastValues = QgsSettingsRegistryCore::settingsDigitizingReuseLastValues.value();
QgsDebugMsgLevel( QStringLiteral( "reuseAllLastValues: %1" ).arg( reuseAllLastValues ), 2 );
QgsFields fields = mLayer->fields();
@ -204,7 +203,7 @@ bool QgsFeatureAction::addFeature( const QgsAttributeMap &defaultAttributes, boo
//show the dialog to enter attribute values
//only show if enabled in settings
bool isDisabledAttributeValuesDlg = settings.value( QStringLiteral( "qgis/digitizing/disable_enter_attribute_values_dialog" ), false ).toBool();
bool isDisabledAttributeValuesDlg = QgsSettingsRegistryCore::settingsDigitizingDisableEnterAttributeValuesDialog.value();
// override application-wide setting if layer is non-spatial -- BECAUSE it's bad UX if
// it appears that nothing happens when you click the add row button for a non-spatial layer. Unlike

4
src/app/qgsmaptooladdellipse.h
View File

@ -18,7 +18,7 @@
#include "qgsmaptoolcapture.h"
#include "qgsellipse.h"
#include "qgssettings.h"
#include "qgssettingsregistrycore.h"
#include "qgis_app.h"
class QgsGeometryRubberBand;
@ -57,7 +57,7 @@ class APP_EXPORT QgsMapToolAddEllipse: public QgsMapToolCapture
//! Ellipse
QgsEllipse mEllipse;
//! convenient method to return the number of segments
unsigned int segments( ) { return QgsSettings().value( QStringLiteral( "/qgis/digitizing/offset_quad_seg" ), 8 ).toInt() * 12; }
unsigned int segments( ) { return QgsSettingsRegistryCore::settingsDigitizingOffsetQuadSeg.value() * 12; }
//! Layer type which will be used for rubberband
QgsWkbTypes::GeometryType mLayerType = QgsWkbTypes::LineGeometry;

32
src/app/qgsmaptooloffsetcurve.cpp
View File

@ -27,7 +27,7 @@
#include "qgsvectorlayer.h"
#include "qgssnapindicator.h"
#include "qgssnappingconfig.h"
#include "qgssettings.h"
#include "qgssettingsregistrycore.h"
#include "qgisapp.h"
#include "qgsmapmouseevent.h"
#include "qgslogger.h"
@ -619,11 +619,10 @@ void QgsMapToolOffsetCurve::updateGeometryAndRubberBand( double offset )
}
QgsGeometry offsetGeom;
QgsSettings s;
QgsGeometry::JoinStyle joinStyle = s.enumValue( QStringLiteral( "/qgis/digitizing/offset_join_style" ), QgsGeometry::JoinStyleRound );
int quadSegments = s.value( QStringLiteral( "/qgis/digitizing/offset_quad_seg" ), 8 ).toInt();
double miterLimit = s.value( QStringLiteral( "/qgis/digitizing/offset_miter_limit" ), 5.0 ).toDouble();
QgsGeometry::EndCapStyle capStyle = s.enumValue( QStringLiteral( "/qgis/digitizing/offset_cap_style" ), QgsGeometry::CapRound );
QgsGeometry::JoinStyle joinStyle = QgsSettingsRegistryCore::settingsDigitizingOffsetJoinStyle.value();
int quadSegments = QgsSettingsRegistryCore::settingsDigitizingOffsetQuadSeg.value();
double miterLimit = QgsSettingsRegistryCore::settingsDigitizingOffsetMiterLimit.value();
QgsGeometry::EndCapStyle capStyle = QgsSettingsRegistryCore::settingsDigitizingOffsetCapStyle.value();
if ( QgsWkbTypes::geometryType( mOriginalGeometry.wkbType() ) == QgsWkbTypes::LineGeometry )
@ -671,11 +670,10 @@ QgsOffsetUserWidget::QgsOffsetUserWidget( QWidget *parent )
mCapStyleComboBox->addItem( tr( "Flat" ), QgsGeometry::CapFlat );
mCapStyleComboBox->addItem( tr( "Square" ), QgsGeometry::CapSquare );
QgsSettings s;
QgsGeometry::JoinStyle joinStyle = s.enumValue( QStringLiteral( "/qgis/digitizing/offset_join_style" ), QgsGeometry::JoinStyleRound );
int quadSegments = s.value( QStringLiteral( "/qgis/digitizing/offset_quad_seg" ), 8 ).toInt();
double miterLimit = s.value( QStringLiteral( "/qgis/digitizing/offset_miter_limit" ), 5.0 ).toDouble();
QgsGeometry::EndCapStyle capStyle = s.enumValue( QStringLiteral( "/qgis/digitizing/offset_cap_style" ), QgsGeometry::CapRound );
QgsGeometry::JoinStyle joinStyle = QgsSettingsRegistryCore::settingsDigitizingOffsetJoinStyle.value();
int quadSegments = QgsSettingsRegistryCore::settingsDigitizingOffsetQuadSeg.value();
double miterLimit = QgsSettingsRegistryCore::settingsDigitizingOffsetMiterLimit.value();
QgsGeometry::EndCapStyle capStyle = QgsSettingsRegistryCore::settingsDigitizingOffsetCapStyle.value();
mJoinStyleComboBox->setCurrentIndex( mJoinStyleComboBox->findData( joinStyle ) );
mQuadrantSpinBox->setValue( quadSegments );
@ -688,16 +686,16 @@ QgsOffsetUserWidget::QgsOffsetUserWidget( QWidget *parent )
mOffsetSpinBox->installEventFilter( this );
connect( mOffsetSpinBox, static_cast < void ( QDoubleSpinBox::* )( double ) > ( &QDoubleSpinBox::valueChanged ), this, &QgsOffsetUserWidget::offsetChanged );
connect( mJoinStyleComboBox, static_cast < void ( QComboBox::* )( int ) > ( &QComboBox::currentIndexChanged ), this, [ = ] { QgsSettings().setEnumValue( QStringLiteral( "/qgis/digitizing/offset_join_style" ), static_cast< QgsGeometry::JoinStyle >( mJoinStyleComboBox->currentData().toInt() ) ); emit offsetConfigChanged(); } );
connect( mQuadrantSpinBox, static_cast < void ( QSpinBox::* )( int ) > ( &QSpinBox::valueChanged ), this, [ = ]( const int quadSegments ) { QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/offset_quad_seg" ), quadSegments ); emit offsetConfigChanged(); } );
connect( mMiterLimitSpinBox, static_cast < void ( QDoubleSpinBox::* )( double ) > ( &QDoubleSpinBox::valueChanged ), this, [ = ]( double miterLimit ) { QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/offset_miter_limit" ), miterLimit ); emit offsetConfigChanged(); } );
connect( mCapStyleComboBox, static_cast < void ( QComboBox::* )( int ) > ( &QComboBox::currentIndexChanged ), this, [ = ] { QgsSettings().setEnumValue( QStringLiteral( "/qgis/digitizing/offset_cap_style" ), static_cast< QgsGeometry::EndCapStyle >( mCapStyleComboBox->currentData().toInt() ) ); emit offsetConfigChanged(); } );
connect( mJoinStyleComboBox, static_cast < void ( QComboBox::* )( int ) > ( &QComboBox::currentIndexChanged ), this, [ = ] { QgsSettingsRegistryCore::settingsDigitizingOffsetJoinStyle.setValue( static_cast< QgsGeometry::JoinStyle >( mJoinStyleComboBox->currentData().toInt() ) ); emit offsetConfigChanged(); } );
connect( mQuadrantSpinBox, static_cast < void ( QSpinBox::* )( int ) > ( &QSpinBox::valueChanged ), this, [ = ]( const int quadSegments ) { QgsSettingsRegistryCore::settingsDigitizingOffsetQuadSeg.setValue( quadSegments ); emit offsetConfigChanged(); } );
connect( mMiterLimitSpinBox, static_cast < void ( QDoubleSpinBox::* )( double ) > ( &QDoubleSpinBox::valueChanged ), this, [ = ]( double miterLimit ) { QgsSettingsRegistryCore::settingsDigitizingOffsetMiterLimit.setValue( miterLimit ); emit offsetConfigChanged(); } );
connect( mCapStyleComboBox, static_cast < void ( QComboBox::* )( int ) > ( &QComboBox::currentIndexChanged ), this, [ = ] { QgsSettingsRegistryCore::settingsDigitizingOffsetCapStyle.setValue( static_cast< QgsGeometry::EndCapStyle >( mCapStyleComboBox->currentData().toInt() ) ); emit offsetConfigChanged(); } );
bool showAdvanced = s.value( QStringLiteral( "/qgis/digitizing/offset_show_advanced" ), false ).toBool();
bool showAdvanced = QgsSettingsRegistryCore::settingsDigitizingOffsetShowAdvanced.value();
mShowAdvancedButton->setChecked( showAdvanced );
mAdvancedConfigWidget->setVisible( showAdvanced );
connect( mShowAdvancedButton, &QToolButton::clicked, mAdvancedConfigWidget, &QWidget::setVisible );
connect( mShowAdvancedButton, &QToolButton::clicked, this, [ = ]( const bool clicked ) {QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/offset_show_advanced" ), clicked );} );
connect( mShowAdvancedButton, &QToolButton::clicked, this, [ = ]( const bool clicked ) {QgsSettingsRegistryCore::settingsDigitizingConvertToCurveDistanceTolerance.setValue( clicked );} );
// config focus
setFocusProxy( mOffsetSpinBox );

2
src/app/qgsmeasuredialog.cpp
View File

@ -143,7 +143,7 @@ void QgsMeasureDialog::updateSettings()
{
QgsSettings settings;
mDecimalPlaces = settings.value( QStringLiteral( "qgis/measure/decimalplaces" ), "3" ).toInt();
mDecimalPlaces = settings.value( QStringLiteral( "qgis/measure/decimalplaces" ), 3 ).toInt();
mCanvasUnits = mCanvas->mapUnits();
// Configure QgsDistanceArea
mDistanceUnits = QgsProject::instance()->distanceUnits();

2
src/app/qgsprojectproperties.cpp
View File

@ -983,7 +983,7 @@ QgsProjectProperties::QgsProjectProperties( QgsMapCanvas *mapCanvas, QWidget *pa
}
cbtsLocale->addItem( QIcon( QStringLiteral( ":/images/flags/%1.svg" ).arg( QLatin1String( "en_US" ) ) ), QLocale( QStringLiteral( "en_US" ) ).nativeLanguageName(), QStringLiteral( "en_US" ) );
cbtsLocale->setCurrentIndex( cbtsLocale->findData( settings.value( QStringLiteral( "locale/userLocale" ), QString() ).toString() ) );
cbtsLocale->setCurrentIndex( cbtsLocale->findData( QgsApplication::settingsLocaleUserLocale.value() ) );
connect( generateTsFileButton, &QPushButton::clicked, this, &QgsProjectProperties::onGenerateTsFileButton );

37
src/app/qgssettingstree.cpp
View File

@ -48,6 +48,7 @@
#include "qgssettingsentry.h"
#include "qgssettingsregistrycore.h"
#include "qgsapplication.h"
#include "qgsguiutils.h"
#include <QMenu>
#include <QMessageBox>
@ -80,14 +81,14 @@ QgsSettingsTree::QgsSettingsTree( QWidget *parent )
void QgsSettingsTree::setSettingsObject( QgsSettings *settings )
{
delete this->mSettings;
this->mSettings = settings;
mSettings = settings;
clear();
if ( settings )
if ( mSettings )
{
settings->setParent( this );
refresh();
mSettings->setParent( this );
if ( isVisible() )
refresh();
if ( mAutoRefresh )
mRefreshTimer.start();
}
@ -104,18 +105,16 @@ QSize QgsSettingsTree::sizeHint() const
void QgsSettingsTree::setAutoRefresh( bool autoRefresh )
{
this->mAutoRefresh = autoRefresh;
if ( mSettings )
mAutoRefresh = autoRefresh;
if ( mAutoRefresh )
{
if ( autoRefresh )
{
maybeRefresh();
maybeRefresh();
if ( mSettings )
mRefreshTimer.start();
}
else
{
mRefreshTimer.stop();
}
}
else
{
mRefreshTimer.stop();
}
}
@ -162,6 +161,12 @@ bool QgsSettingsTree::event( QEvent *event )
return QTreeWidget::event( event );
}
void QgsSettingsTree::showEvent( QShowEvent * )
{
QgsTemporaryCursorOverride waitCursor( Qt::BusyCursor );
refresh();
}
void QgsSettingsTree::updateSetting( QTreeWidgetItem *item )
{
QString key = itemKey( item );
@ -326,7 +331,7 @@ QTreeWidgetItem *QgsSettingsTree::createItem( const QString &text,
// If settings registered add description
if ( !isGroup )
{
const QgsSettingsEntryBase *settingsEntry = QgsApplication::settingsRegistryCore()->getSettingsEntry( completeSettingsPath, true );
const QgsSettingsEntryBase *settingsEntry = QgsApplication::settingsRegistryCore()->settingsEntry( completeSettingsPath, true );
if ( settingsEntry )
{
item->setText( ColumnDescription, settingsEntry->description() );

1
src/app/qgssettingstree.h
View File

@ -83,6 +83,7 @@ class QgsSettingsTree : public QTreeWidget
protected:
bool event( QEvent *event ) override;
void showEvent( QShowEvent * ) override;
private slots:
void updateSetting( QTreeWidgetItem *item );

5
src/app/qgssnappingwidget.cpp
View File

@ -40,7 +40,7 @@
#include "qgssnappinglayertreemodel.h"
#include "qgssnappingwidget.h"
#include "qgsunittypes.h"
#include "qgssettings.h"
#include "qgssettingsregistrycore.h"
#include "qgsscalewidget.h"
#ifdef ENABLE_MODELTEST
@ -417,8 +417,7 @@ QgsSnappingWidget::QgsSnappingWidget( QgsProject *project, QgsMapCanvas *canvas,
modeChanged();
updateToleranceDecimals();
bool defaultSnapEnabled = QgsSettings().value( QStringLiteral( "/qgis/digitizing/default_snap_enabled" ), false ).toBool();
enableSnapping( defaultSnapEnabled );
enableSnapping( QgsSettingsRegistryCore::settingsDigitizingDefaultSnapEnabled.value() );
restoreGeometry( QgsSettings().value( QStringLiteral( "/Windows/SnappingWidget/geometry" ) ).toByteArray() );
}

7
src/app/vertextool/qgslockedfeature.cpp
View File

@ -18,7 +18,7 @@
#include "qgsfeatureiterator.h"
#include "qgspoint.h"
#include "qgssettings.h"
#include "qgssettingsregistrycore.h"
#include "qgslogger.h"
#include "qgsvertexmarker.h"
#include "qgsgeometryvalidator.h"
@ -123,8 +123,7 @@ void QgsLockedFeature::geometryChanged( QgsFeatureId fid, const QgsGeometry &geo
void QgsLockedFeature::validateGeometry( QgsGeometry *g )
{
QgsSettings settings;
if ( settings.value( QStringLiteral( "qgis/digitizing/validate_geometries" ), 1 ).toInt() == 0 )
if ( QgsSettingsRegistryCore::settingsDigitizingValidateGeometries.value() == 0 )
return;
if ( !g )
@ -149,7 +148,7 @@ void QgsLockedFeature::validateGeometry( QgsGeometry *g )
}
QgsGeometry::ValidationMethod method = QgsGeometry::ValidatorQgisInternal;
if ( settings.value( QStringLiteral( "qgis/digitizing/validate_geometries" ), 1 ).toInt() == 2 )
if ( QgsSettingsRegistryCore::settingsDigitizingValidateGeometries.value() == 2 )
method = QgsGeometry::ValidatorGeos;
mValidator = new QgsGeometryValidator( *g, nullptr, method );
connect( mValidator, &QgsGeometryValidator::errorFound, this, &QgsLockedFeature::addError );

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

@ -28,7 +28,7 @@
#include "qgspointlocator.h"
#include "qgsproject.h"
#include "qgsrubberband.h"
#include "qgssettings.h"
#include "qgssettingsregistrycore.h"
#include "qgssnapindicator.h"
#include "qgssnappingutils.h"
#include "qgsvectorlayer.h"
@ -2728,8 +2728,7 @@ void QgsVertexTool::GeometryValidation::start( QgsGeometry &geom, QgsVertexTool
tool = t;
layer = l;
QgsGeometry::ValidationMethod method = QgsGeometry::ValidatorQgisInternal;
QgsSettings settings;
if ( settings.value( QStringLiteral( "qgis/digitizing/validate_geometries" ), 1 ).toInt() == 2 )
if ( QgsSettingsRegistryCore::settingsDigitizingValidateGeometries.value() == 2 )
method = QgsGeometry::ValidatorGeos;
validator = new QgsGeometryValidator( geom, nullptr, method );
@ -2778,8 +2777,7 @@ void QgsVertexTool::GeometryValidation::cleanup()
void QgsVertexTool::validateGeometry( QgsVectorLayer *layer, QgsFeatureId featureId )
{
QgsSettings settings;
if ( settings.value( QStringLiteral( "qgis/digitizing/validate_geometries" ), 1 ).toInt() == 0 )
if ( QgsSettingsRegistryCore::settingsDigitizingValidateGeometries.value() == 0 )
return;
QPair<QgsVectorLayer *, QgsFeatureId> id( layer, featureId );

2
src/core/layout/qgslayout.h
View File

@ -658,8 +658,10 @@ class CORE_EXPORT QgsLayout : public QGraphicsScene, public QgsExpressionContext
*/
bool accept( QgsStyleEntityVisitorInterface *visitor ) const;
#ifndef SIP_RUN
//! Settings entry search path for templates
static const inline QgsSettingsEntryStringList settingsSearchPathForTemplates = QgsSettingsEntryStringList( QStringLiteral( "Layout/searchPathsForTemplates" ), QgsSettings::Core, QStringList(), QObject::tr( "Search path for templates" ) );
#endif
public slots:

2
src/core/locator/qgslocator.h
View File

@ -153,12 +153,14 @@ class CORE_EXPORT QgsLocator : public QObject
*/
QStringList completionList() const {return mAutocompletionList;}
#ifndef SIP_RUN
//! Settings entry locator filter enabled
static const inline QgsSettingsEntryBool settingsLocatorFilterEnabled = QgsSettingsEntryBool( QStringLiteral( "locator_filters/enabled_%1" ), QgsSettings::Gui, true, "Locator filter enabled" );
//! Settings entry locator filter default value
static const inline QgsSettingsEntryBool settingsLocatorFilterDefault = QgsSettingsEntryBool( QStringLiteral( "locator_filters/default_%1" ), QgsSettings::Gui, false, "Locator filter default value" );
//! Settings entry locator filter prefix
static const inline QgsSettingsEntryString settingsLocatorFilterPrefix = QgsSettingsEntryString( QStringLiteral( "locator_filters/prefix_%1" ), QgsSettings::Gui, QString(), "Locator filter prefix" );
#endif
signals:

4
src/core/network/qgsnetworkaccessmanager.cpp
View File

@ -674,12 +674,12 @@ void QgsNetworkAccessManager::setupDefaultProxyAndCache( Qt::ConnectionType conn
int QgsNetworkAccessManager::timeout()
{
return QgsSettings().value( QStringLiteral( "/qgis/networkAndProxy/networkTimeout" ), 60000 ).toInt();
return settingsNetworkTimeout.value();
}
void QgsNetworkAccessManager::setTimeout( const int time )
{
QgsSettings().setValue( QStringLiteral( "/qgis/networkAndProxy/networkTimeout" ), time );
settingsNetworkTimeout.setValue( time );
}
QgsNetworkReplyContent QgsNetworkAccessManager::blockingGet( QNetworkRequest &request, const QString &authCfg, bool forceRefresh, QgsFeedback *feedback )

7
src/core/network/qgsnetworkaccessmanager.h
View File

@ -31,6 +31,7 @@
#include "qgis_core.h"
#include "qgis_sip.h"
#include "qgssettingsentry.h"
class QgsFeedback;
@ -529,6 +530,12 @@ class CORE_EXPORT QgsNetworkAccessManager : public QNetworkAccessManager
*/
void requestAuthCloseBrowser() const;
#ifndef SIP_RUN
//! Settings entry network timeout
static const inline QgsSettingsEntryInteger settingsNetworkTimeout = QgsSettingsEntryInteger( QStringLiteral( "/qgis/networkAndProxy/networkTimeout" ), QgsSettings::NoSection, 60000, QObject::tr( "Network timeout" ) );
#endif
signals:
/**

17
src/core/network/qgsnewsfeedparser.cpp
View File

@ -40,24 +40,23 @@ QgsNewsFeedParser::QgsNewsFeedParser( const QUrl &feedUrl, const QString &authcf
QUrlQuery query( feedUrl );
const qint64 after = QgsSettings().value( QStringLiteral( "%1/lastFetchTime" ).arg( mSettingsKey ), 0, QgsSettings::Core ).toUInt();
const qint64 after = settingsFeedLastFetchTime.value( mSettingsKey );
if ( after > 0 )
query.addQueryItem( QStringLiteral( "after" ), qgsDoubleToString( after, 0 ) );
QString feedLanguage = QgsSettings().value( QStringLiteral( "%1/lang" ).arg( mSettingsKey ), QString(), QgsSettings::Core ).toString();
QString feedLanguage = settingsFeedLanguage.value( mSettingsKey );
if ( feedLanguage.isEmpty() )
{
feedLanguage = QgsSettings().value( QStringLiteral( "locale/userLocale" ), QStringLiteral( "en_US" ) ).toString().left( 2 );
feedLanguage = QgsApplication::settingsLocaleUserLocale.value( QString(), true, QStringLiteral( "en" ) );
}
if ( !feedLanguage.isEmpty() && feedLanguage != QLatin1String( "C" ) )
query.addQueryItem( QStringLiteral( "lang" ), feedLanguage );
bool latOk = false;
bool longOk = false;
const double feedLat = QgsSettings().value( QStringLiteral( "%1/latitude" ).arg( mSettingsKey ), QString(), QgsSettings::Core ).toDouble( &latOk );
const double feedLong = QgsSettings().value( QStringLiteral( "%1/longitude" ).arg( mSettingsKey ), QString(), QgsSettings::Core ).toDouble( &longOk );
if ( latOk && longOk )
if ( settingsFeedLatitude.exists( mSettingsKey ) && settingsFeedLongitude.exists( mSettingsKey ) )
{
const double feedLat = settingsFeedLatitude.value( mSettingsKey );
const double feedLong = settingsFeedLongitude.value( mSettingsKey );
// hack to allow testing using local files
if ( feedUrl.isLocalFile() )
{
@ -170,7 +169,7 @@ void QgsNewsFeedParser::fetch()
void QgsNewsFeedParser::onFetch( const QString &content )
{
QgsSettings().setValue( mSettingsKey + "/lastFetchTime", mFetchStartTime, QgsSettings::Core );
settingsFeedLastFetchTime.setValue( mFetchStartTime, mSettingsKey );
const QVariant json = QgsJsonUtils::parseJson( content );

12
src/core/network/qgsnewsfeedparser.h
View File

@ -17,6 +17,7 @@
#include "qgis_core.h"
#include "qgis_sip.h"
#include "qgssettingsentry.h"
#include <QObject>
#include <QUrl>
#include <QPixmap>
@ -110,6 +111,17 @@ class CORE_EXPORT QgsNewsFeedParser : public QObject
*/
static QString keyForFeed( const QString &baseUrl );
#ifndef SIP_RUN
//! Settings entry last fetch time
static const inline QgsSettingsEntryInteger settingsFeedLastFetchTime = QgsSettingsEntryInteger( QStringLiteral( "%1/lastFetchTime" ), QgsSettings::Core, 0, QObject::tr( "Feed last fetch time" ), 0 );
//! Settings entry feed language
static const inline QgsSettingsEntryString settingsFeedLanguage = QgsSettingsEntryString( QStringLiteral( "%1/lang" ), QgsSettings::Core, QString(), QObject::tr( "Feed language" ) );
//! Settings entry feed latitude
static const inline QgsSettingsEntryDouble settingsFeedLatitude = QgsSettingsEntryDouble( QStringLiteral( "%1/latitude" ), QgsSettings::Core, 0.0, QObject::tr( "Feed latitude" ) );
//! Settings entry feed longitude
static const inline QgsSettingsEntryDouble settingsFeedLongitude = QgsSettingsEntryDouble( QStringLiteral( "%1/longitude" ), QgsSettings::Core, 0.0, QObject::tr( "Feed longitude" ) );
#endif
public slots:
/**

12
src/core/processing/qgsprocessing.h
View File

@ -19,6 +19,7 @@
#define QGSPROCESSING_H
#include "qgis_core.h"
#include "qgssettingsentry.h"
#include <QString>
//
@ -97,6 +98,17 @@ class CORE_EXPORT QgsProcessing
* \since QGIS 3.6
*/
static const QString TEMPORARY_OUTPUT;
#ifndef SIP_RUN
//! Settings entry prefer filename as layer name
static const inline QgsSettingsEntryBool settingsPreferFilenameAsLayerName = QgsSettingsEntryBool( QStringLiteral( "Processing/Configuration/PREFER_FILENAME_AS_LAYER_NAME" ), QgsSettings::NoSection, true, QObject::tr( "Prefer filename as layer name" ) );
//! Settings entry temp path
static const inline QgsSettingsEntryString settingsTempPath = QgsSettingsEntryString( QStringLiteral( "Processing/Configuration/TEMP_PATH2" ), QgsSettings::NoSection, QString() );
//! Settings entry default output vector layer ext
static const inline QgsSettingsEntryInteger settingsDefaultOutputVectorLayerExt = QgsSettingsEntryInteger( QStringLiteral( "Processing/Configuration/DefaultOutputVectorLayerExt" ), QgsSettings::NoSection, -1 );
//! Settings entry default output raster layer ext
static const inline QgsSettingsEntryInteger settingsDefaultOutputRasterLayerExt = QgsSettingsEntryInteger( QStringLiteral( "Processing/Configuration/DefaultOutputRasterLayerExt" ), QgsSettings::NoSection, -1 );
#endif
};
#endif // QGSPROCESSING_H

2
src/core/processing/qgsprocessingcontext.cpp
View File

@ -197,7 +197,7 @@ void QgsProcessingContext::LayerDetails::setOutputLayerName( QgsMapLayer *layer
if ( !layer )
return;
const bool preferFilenameAsLayerName = QgsSettings().value( QStringLiteral( "Processing/Configuration/PREFER_FILENAME_AS_LAYER_NAME" ), true ).toBool();
const bool preferFilenameAsLayerName = QgsProcessing::settingsPreferFilenameAsLayerName.value();
// note - for temporary layers, we don't use the filename, regardless of user setting (it will be meaningless!)
if ( ( !forceName && preferFilenameAsLayerName && !layer->isTemporary() ) || name.isEmpty() )

2
src/core/processing/qgsprocessingprovider.cpp
View File

@ -193,7 +193,6 @@ bool QgsProcessingProvider::isSupportedOutputValue( const QVariant &outputValue,
QString QgsProcessingProvider::defaultVectorFileExtension( bool hasGeometry ) const
{
QgsSettings settings;
const QString userDefault = QgsProcessingUtils::defaultVectorExtension();
const QStringList supportedExtensions = supportedOutputVectorLayerExtensions();
@ -216,7 +215,6 @@ QString QgsProcessingProvider::defaultVectorFileExtension( bool hasGeometry ) co
QString QgsProcessingProvider::defaultRasterFileExtension() const
{
QgsSettings settings;
const QString userDefault = QgsProcessingUtils::defaultRasterExtension();
const QStringList supportedExtensions = supportedOutputRasterLayerExtensions();

8
src/core/processing/qgsprocessingutils.cpp
View File

@ -954,7 +954,7 @@ QString QgsProcessingUtils::tempFolder()
static QString sFolder;
static QMutex sMutex;
QMutexLocker locker( &sMutex );
const QString basePath = QgsSettings().value( QStringLiteral( "Processing/Configuration/TEMP_PATH2" ) ).toString();
const QString basePath = QgsProcessing::settingsTempPath.value();
if ( basePath.isEmpty() )
{
// default setting -- automatically create a temp folder
@ -1211,8 +1211,7 @@ QgsFields QgsProcessingUtils::indicesToFields( const QList<int> &indices, const
QString QgsProcessingUtils::defaultVectorExtension()
{
QgsSettings settings;
const int setting = settings.value( QStringLiteral( "Processing/Configuration/DefaultOutputVectorLayerExt" ), -1 ).toInt();
const int setting = QgsProcessing::settingsDefaultOutputVectorLayerExt.value();
if ( setting == -1 )
return QStringLiteral( "gpkg" );
return QgsVectorFileWriter::supportedFormatExtensions().value( setting, QStringLiteral( "gpkg" ) );
@ -1220,8 +1219,7 @@ QString QgsProcessingUtils::defaultVectorExtension()
QString QgsProcessingUtils::defaultRasterExtension()
{
QgsSettings settings;
const int setting = settings.value( QStringLiteral( "Processing/Configuration/DefaultOutputRasterLayerExt" ), -1 ).toInt();
const int setting = QgsProcessing::settingsDefaultOutputRasterLayerExt.value();
if ( setting == -1 )
return QStringLiteral( "tif" );
return QgsRasterFileWriter::supportedFormatExtensions().value( setting, QStringLiteral( "tif" ) );

2
src/core/project/qgsproject.cpp
View File

@ -1353,7 +1353,7 @@ bool QgsProject::readProjectFile( const QString &filename, QgsProject::ReadFlags
QgsApplication::profiler()->clear( QStringLiteral( "projectload" ) );
QgsScopedRuntimeProfile profile( tr( "Setting up translations" ), QStringLiteral( "projectload" ) );
QString localeFileName = QStringLiteral( "%1_%2" ).arg( QFileInfo( projectFile.fileName() ).baseName(), mSettings.value( QStringLiteral( "locale/userLocale" ), QString() ).toString() );
QString localeFileName = QStringLiteral( "%1_%2" ).arg( QFileInfo( projectFile.fileName() ).baseName(), QgsApplication::settingsLocaleUserLocale.value() );
if ( QFile( QStringLiteral( "%1/%2.qm" ).arg( QFileInfo( projectFile.fileName() ).absolutePath(), localeFileName ) ).exists() )
{

11
src/core/qgsapplication.cpp
View File

@ -1063,7 +1063,7 @@ QString QgsApplication::srsDatabaseFilePath()
void QgsApplication::setSvgPaths( const QStringList &svgPaths )
{
QgsSettings().setValue( QStringLiteral( "svg/searchPathsForSVG" ), svgPaths );
settingsSearchPathsForSVG.setValue( svgPaths );
members()->mSvgPathCacheValid = false;
}
@ -1082,8 +1082,7 @@ QStringList QgsApplication::svgPaths()
locker.changeMode( QgsReadWriteLocker::Write );
//local directories to search when looking for an SVG with a given basename
//defined by user in options dialog
QgsSettings settings;
const QStringList pathList = settings.value( QStringLiteral( "svg/searchPathsForSVG" ) ).toStringList();
const QStringList pathList = settingsSearchPathsForSVG.value();
// maintain user set order while stripping duplicates
QStringList paths;
@ -1225,11 +1224,9 @@ QString QgsApplication::platform()
QString QgsApplication::locale()
{
QgsSettings settings;
bool overrideLocale = settings.value( QStringLiteral( "locale/overrideFlag" ), false ).toBool();
if ( overrideLocale )
if ( settingsLocaleOverrideFlag.value() )
{
QString locale = settings.value( QStringLiteral( "locale/userLocale" ), QString() ).toString();
QString locale = settingsLocaleUserLocale.value();
// don't differentiate en_US and en_GB
if ( locale.startsWith( QLatin1String( "en" ), Qt::CaseInsensitive ) )
{

14
src/core/qgsapplication.h
View File

@ -23,6 +23,7 @@
#include "qgis_sip.h"
#include "qgsconfig.h"
#include "qgssettingsentry.h"
#include "qgstranslationcontext.h"
class QgsSettingsRegistryCore;
@ -943,6 +944,19 @@ class CORE_EXPORT QgsApplication : public QApplication
*/
void collectTranslatableObjects( QgsTranslationContext *translationContext );
#ifndef SIP_RUN
//! Settings entry locale user locale
static const inline QgsSettingsEntryString settingsLocaleUserLocale = QgsSettingsEntryString( QStringLiteral( "locale/userLocale" ), QgsSettings::NoSection, QString() );
//! Settings entry locale override flag
static const inline QgsSettingsEntryBool settingsLocaleOverrideFlag = QgsSettingsEntryBool( QStringLiteral( "locale/overrideFlag" ), QgsSettings::NoSection, false );
//! Settings entry locale global locale
static const inline QgsSettingsEntryString settingsLocaleGlobalLocale = QgsSettingsEntryString( QStringLiteral( "locale/globalLocale" ), QgsSettings::NoSection, QString() );
//! Settings entry locale show group separator
static const inline QgsSettingsEntryBool settingsLocaleShowGroupSeparator = QgsSettingsEntryBool( QStringLiteral( "locale/showGroupSeparator" ), QgsSettings::NoSection, false );
//! Settings entry search path for SVG
static const inline QgsSettingsEntryStringList settingsSearchPathsForSVG = QgsSettingsEntryStringList( QStringLiteral( "svg/searchPathsForSVG" ), QgsSettings::NoSection, QStringList() );
#endif
#ifdef SIP_RUN
SIP_IF_FEATURE( ANDROID )
//dummy method to workaround sip generation issue

2
src/core/qgsgeometryoptions.cpp
View File

@ -23,7 +23,7 @@
QgsGeometryOptions::QgsGeometryOptions()
{
mGeometryChecks = QgsSettings().value( QStringLiteral( "geometry_validation/default_checks" ) ).toString().split( ',' ) ;
mGeometryChecks = settingsGeometryValidationDefaultChecks.value().split( ',' ) ;
}
bool QgsGeometryOptions::removeDuplicateNodes() const

6
src/core/qgsgeometryoptions.h
View File

@ -21,6 +21,7 @@
#include "qgis_core.h"
#include "qgis_sip.h"
#include "qgsgeometry.h"
#include "qgssettingsentry.h"
#include <QObject>
@ -131,6 +132,11 @@ class CORE_EXPORT QgsGeometryOptions : public QObject
*/
void readXml( const QDomNode &node );
#ifndef SIP_RUN
//! Settings entry search path for templates
static const inline QgsSettingsEntryString settingsGeometryValidationDefaultChecks = QgsSettingsEntryString( QStringLiteral( "geometry_validation/default_checks" ), QgsSettings::NoSection, QString() );
#endif
signals:
/**

4
src/core/qgslocalizeddatapathregistry.cpp
View File

@ -105,10 +105,10 @@ void QgsLocalizedDataPathRegistry::unregisterPath( const QString &path )
void QgsLocalizedDataPathRegistry::readFromSettings()
{
setPaths( QgsSettings().value( QStringLiteral( "/qgis/localized_data_paths" ) ).toStringList() );
setPaths( settingsLocalizedDataPaths.value() );
}
void QgsLocalizedDataPathRegistry::writeToSettings()
{
QgsSettings().setValue( QStringLiteral( "/qgis/localized_data_paths" ), paths() );
settingsLocalizedDataPaths.setValue( paths() );
}

6
src/core/qgslocalizeddatapathregistry.h
View File

@ -24,6 +24,7 @@
#include "qgis_core.h"
#include "qgis_sip.h"
#include "qgssettingsentry.h"
/**
* \ingroup core
@ -65,6 +66,11 @@ class CORE_EXPORT QgsLocalizedDataPathRegistry
//! Unregisters a localized path
void unregisterPath( const QString &path );
#ifndef SIP_RUN
//! Settings entry localized data paths
static const inline QgsSettingsEntryStringList settingsLocalizedDataPaths = QgsSettingsEntryStringList( QStringLiteral( "/qgis/localized_data_paths" ), QgsSettings::NoSection, QStringList() );
#endif
private:
#ifdef SIP_RUN
QgsLocalizedDataPathRegistry( const QgsLocalizedDataPathRegistry &other )

3
src/core/qgsmaprendererjob.cpp
View File

@ -977,8 +977,7 @@ void QgsMapRendererJob::composeSecondPass( LayerRenderJobs &secondPassJobs, Labe
void QgsMapRendererJob::logRenderingTime( const LayerRenderJobs &jobs, const LayerRenderJobs &secondPassJobs, const LabelRenderJob &labelJob )
{
QgsSettings settings;
if ( !settings.value( QStringLiteral( "Map/logCanvasRefreshEvent" ), false ).toBool() )
if ( !settingsLogCanvasRefreshEvent.value() )
return;
QMultiMap<int, QString> elapsed;

6
src/core/qgsmaprendererjob.h
View File

@ -29,6 +29,7 @@
#include "qgsmapsettings.h"
#include "qgsmaskidprovider.h"
#include "qgssettingsentry.h"
class QgsLabelingEngine;
@ -343,6 +344,11 @@ class CORE_EXPORT QgsMapRendererJob : public QObject
*/
static const QString LABEL_PREVIEW_CACHE_ID SIP_SKIP;
#ifndef SIP_RUN
//! Settings entry log canvas refresh event
static const inline QgsSettingsEntryBool settingsLogCanvasRefreshEvent = QgsSettingsEntryBool( QStringLiteral( "Map/logCanvasRefreshEvent" ), QgsSettings::NoSection, false );
#endif
signals:
/**

18
src/core/qgssnappingconfig.cpp
View File

@ -19,7 +19,7 @@
#include <QHeaderView>
#include <QRegularExpression>
#include "qgssettings.h"
#include "qgssettingsregistrycore.h"
#include "qgslogger.h"
#include "qgsvectorlayer.h"
#include "qgsproject.h"
@ -189,7 +189,7 @@ bool QgsSnappingConfig::operator==( const QgsSnappingConfig &other ) const
void QgsSnappingConfig::reset()
{
// get defaults values. They are both used for standard and advanced configuration (per layer)
bool enabled = QgsSettings().value( QStringLiteral( "/qgis/digitizing/default_snap_enabled" ), false ).toBool();
bool enabled = QgsSettingsRegistryCore::settingsDigitizingDefaultSnapEnabled.value();
SnappingMode mode = QgsSettings().enumValue( QStringLiteral( "/qgis/digitizing/default_snap_mode" ), AllLayers );
if ( mode == 0 )
{
@ -197,9 +197,9 @@ void QgsSnappingConfig::reset()
// could be removed in 3.4+
mode = AllLayers;
}
QgsSnappingConfig::SnappingTypeFlag type = QgsSettings().flagValue( QStringLiteral( "/qgis/digitizing/default_snap_type" ), VertexFlag );
double tolerance = QgsSettings().value( QStringLiteral( "/qgis/digitizing/default_snapping_tolerance" ), Qgis::DEFAULT_SNAP_TOLERANCE ).toDouble();
QgsTolerance::UnitType units = QgsSettings().enumValue( QStringLiteral( "/qgis/digitizing/default_snapping_tolerance_unit" ), Qgis::DEFAULT_SNAP_UNITS );
QgsSnappingConfig::SnappingTypeFlag type = QgsSettingsRegistryCore::settingsDigitizingDefaultSnapType.value();
double tolerance = QgsSettingsRegistryCore::settingsDigitizingDefaultSnappingTolerance.value();
QgsTolerance::UnitType units = QgsSettingsRegistryCore::settingsDigitizingDefaultSnappingToleranceUnit.value();
// assign main (standard) config
mEnabled = enabled;
@ -597,10 +597,10 @@ void QgsSnappingConfig::writeProject( QDomDocument &doc )
bool QgsSnappingConfig::addLayers( const QList<QgsMapLayer *> &layers )
{
bool changed = false;
bool enabled = QgsSettings().value( QStringLiteral( "/qgis/digitizing/default_snap_enabled" ), true ).toBool();
QgsSnappingConfig::SnappingTypeFlag type = QgsSettings().enumValue( QStringLiteral( "/qgis/digitizing/default_snap_type" ), VertexFlag );
double tolerance = QgsSettings().value( QStringLiteral( "/qgis/digitizing/default_snapping_tolerance" ), Qgis::DEFAULT_SNAP_TOLERANCE ).toDouble();
QgsTolerance::UnitType units = QgsSettings().enumValue( QStringLiteral( "/qgis/digitizing/default_snapping_tolerance_unit" ), Qgis::DEFAULT_SNAP_UNITS );
bool enabled = QgsSettingsRegistryCore::settingsDigitizingDefaultSnapEnabled.value( QString(), true, true );
QgsSnappingConfig::SnappingTypeFlag type = QgsSettingsRegistryCore::settingsDigitizingDefaultSnapType.value();
double tolerance = QgsSettingsRegistryCore::settingsDigitizingDefaultSnappingTolerance.value();
QgsTolerance::UnitType units = QgsSettingsRegistryCore::settingsDigitizingDefaultSnappingToleranceUnit.value();
const auto constLayers = layers;
for ( QgsMapLayer *ml : constLayers )

17
src/core/qgstolerance.cpp
View File

@ -15,7 +15,7 @@
#include "qgstolerance.h"
#include "qgsmapsettings.h"
#include "qgssettings.h"
#include "qgssettingsregistrycore.h"
#include "qgspointxy.h"
#include <QPoint>
@ -72,9 +72,8 @@ double QgsTolerance::toleranceInMapUnits( double tolerance, QgsMapLayer *layer,
double QgsTolerance::vertexSearchRadius( const QgsMapSettings &mapSettings )
{
QgsSettings settings;
double tolerance = settings.value( QStringLiteral( "qgis/digitizing/search_radius_vertex_edit" ), 10 ).toDouble();
UnitType units = settings.enumValue( QStringLiteral( "qgis/digitizing/search_radius_vertex_edit_unit" ), QgsTolerance::Pixels );
double tolerance = QgsSettingsRegistryCore::settingsDigitizingSearchRadiusVertexEdit.value();
UnitType units = QgsSettingsRegistryCore::settingsDigitizingSearchRadiusVertexEditUnit.value();
if ( units == LayerUnits )
units = ProjectUnits;
return toleranceInProjectUnits( tolerance, nullptr, mapSettings, units );
@ -82,17 +81,15 @@ double QgsTolerance::vertexSearchRadius( const QgsMapSettings &mapSettings )
double QgsTolerance::vertexSearchRadius( QgsMapLayer *layer, const QgsMapSettings &mapSettings )
{
QgsSettings settings;
double tolerance = settings.value( QStringLiteral( "qgis/digitizing/search_radius_vertex_edit" ), 10 ).toDouble();
UnitType units = settings.enumValue( QStringLiteral( "qgis/digitizing/search_radius_vertex_edit_unit" ), QgsTolerance::Pixels );
double tolerance = QgsSettingsRegistryCore::settingsDigitizingSearchRadiusVertexEdit.value();
UnitType units = QgsSettingsRegistryCore::settingsDigitizingSearchRadiusVertexEditUnit.value();
return toleranceInMapUnits( tolerance, layer, mapSettings, units );
}
double QgsTolerance::defaultTolerance( QgsMapLayer *layer, const QgsMapSettings &mapSettings )
{
QgsSettings settings;
double tolerance = settings.value( QStringLiteral( "qgis/digitizing/default_snapping_tolerance" ), Qgis::DEFAULT_SNAP_TOLERANCE ).toDouble();
UnitType units = settings.enumValue( QStringLiteral( "qgis/digitizing/default_snapping_tolerance_unit" ), Qgis::DEFAULT_SNAP_UNITS );
double tolerance = QgsSettingsRegistryCore::settingsDigitizingDefaultSnappingTolerance.value();
UnitType units = QgsSettingsRegistryCore::settingsDigitizingDefaultSnappingToleranceUnit.value();
return toleranceInMapUnits( tolerance, layer, mapSettings, units );
}

4
src/core/qgstracer.cpp
View File

@ -24,7 +24,7 @@
#include "qgsvectorlayer.h"
#include "qgsexception.h"
#include "qgsrenderer.h"
#include "qgssettings.h"
#include "qgssettingsregistrycore.h"
#include "qgsexpressioncontextutils.h"
#include <queue>
@ -484,7 +484,6 @@ bool QgsTracer::initGraph()
t1.start();
int featuresCounted = 0;
bool enableInvisibleFeature = QgsSettings().value( QStringLiteral( "/qgis/digitizing/snap_invisible_feature" ), false ).toBool();
for ( const QgsVectorLayer *vl : std::as_const( mLayers ) )
{
QgsFeatureRequest request;
@ -492,6 +491,7 @@ bool QgsTracer::initGraph()
std::unique_ptr< QgsFeatureRenderer > renderer;
std::unique_ptr<QgsRenderContext> ctx;
bool enableInvisibleFeature = QgsSettingsRegistryCore::settingsDigitizingSnapInvisibleFeature.value();
if ( !enableInvisibleFeature && mRenderContext && vl->renderer() )
{
renderer.reset( vl->renderer()->clone() );

55
src/core/settings/qgssettingsentry.cpp
View File

@ -85,6 +85,12 @@ QString QgsSettingsEntryBase::key( const QStringList &dynamicKeyPartList ) const
bool QgsSettingsEntryBase::keyIsValid( const QString &key ) const
{
if ( !hasDynamicKey() )
{
if ( !key.contains( definitionKey() ) )
return false;
}
// Key to check
QString completeKeyToCheck = key;
@ -642,4 +648,53 @@ int QgsSettingsEntryDouble::displayHintDecimals() const
return mDisplayHintDecimals;
}
QgsSettingsEntryColor::QgsSettingsEntryColor( const QString &key, QgsSettings::Section section, const QColor &defaultValue, const QString &description )
: QgsSettingsEntryBase( key,
section,
defaultValue,
description )
{
}
QgsSettingsEntryColor::QgsSettingsEntryColor( const QString &key, const QString &pluginName, const QColor &defaultValue, const QString &description )
: QgsSettingsEntryBase( key,
pluginName,
defaultValue,
description )
{
}
bool QgsSettingsEntryColor::setValue( const QColor &value, const QString &dynamicKeyPart ) const
{
QStringList dynamicKeyPartList;
if ( !dynamicKeyPart.isNull() )
dynamicKeyPartList.append( dynamicKeyPart );
return setValue( value, dynamicKeyPartList );
}
bool QgsSettingsEntryColor::setValue( const QColor &value, const QStringList &dynamicKeyPartList ) const
{
return QgsSettingsEntryBase::setVariantValue( value, dynamicKeyPartList );
}
QColor QgsSettingsEntryColor::value( const QString &dynamicKeyPart, bool useDefaultValueOverride, const QString &defaultValueOverride ) const
{
return valueAsVariant( dynamicKeyPart, useDefaultValueOverride, defaultValueOverride ).value<QColor>();
}
QColor QgsSettingsEntryColor::value( const QStringList &dynamicKeyPartList, bool useDefaultValueOverride, const QString &defaultValueOverride ) const
{
return valueAsVariant( dynamicKeyPartList, useDefaultValueOverride, defaultValueOverride ).value<QColor>();
}
QColor QgsSettingsEntryColor::defaultValue() const
{
return defaultValueAsVariant().value<QColor>();
}
QgsSettingsEntryBase::SettingsType QgsSettingsEntryColor::settingsType() const
{
return QgsSettingsEntryBase::SettingsType::Color;
}

166
src/core/settings/qgssettingsentry.h
View File

@ -17,6 +17,7 @@
#define QGSSETTINGSENTRY_H
#include <QString>
#include <QColor>
#include <limits>
#include "qgis_core.h"
@ -50,6 +51,8 @@ class CORE_EXPORT QgsSettingsEntryBase
sipType = sipType_QgsSettingsEntryInteger;
else if ( dynamic_cast< QgsSettingsEntryDouble * >( sipCpp ) )
sipType = sipType_QgsSettingsEntryDouble;
else if ( dynamic_cast< QgsSettingsEntryColor * >( sipCpp ) )
sipType = sipType_QgsSettingsEntryColor;
else
sipType = NULL;
SIP_END
@ -65,8 +68,8 @@ class CORE_EXPORT QgsSettingsEntryBase
Bool,
Integer,
Double,
Enum,
Flag
EnumFlag,
Color
};
#ifndef SIP_RUN
@ -866,16 +869,16 @@ class CORE_EXPORT QgsSettingsEntryDouble : public QgsSettingsEntryBase
};
#ifndef SIP_RUN
/**
* \class QgsSettingsEntryEnum
* \class QgsSettingsEntryEnumFlag
* \ingroup core
* A base class for enum and flag settings entry.
* \since QGIS 3.20
* A template class for enum and flag settings entry.
*
* \note This template class has a dedicated handling in sipify.pl
* \since QGIS 3.20
*/
template <typename T>
class QgsSettingsEntryEnumFlagBase : public QgsSettingsEntryBase
class CORE_EXPORT QgsSettingsEntryEnumFlag : public QgsSettingsEntryBase
{
public:
@ -890,16 +893,8 @@ class QgsSettingsEntryEnumFlagBase : public QgsSettingsEntryBase
* \note The enum needs to be declared with Q_ENUM, and flags with Q_FLAG (not Q_FLAGS).
* \note for Python bindings, a custom implementation is achieved in Python directly
*/
QgsSettingsEntryEnumFlagBase( const QString &key,
QgsSettings::Section section,
const T &defaultValue,
const QString &description = QString() )
: QgsSettingsEntryBase( key,
section,
QMetaEnum::fromType<T>().isFlag() ?
QVariant( QMetaEnum::fromType<T>().valueToKeys( defaultValue ) ) :
QVariant( QMetaEnum::fromType<T>().valueToKey( defaultValue ) ),
description )
QgsSettingsEntryEnumFlag( const QString &key, QgsSettings::Section section, const T &defaultValue, const QString &description = QString() )
: QgsSettingsEntryBase( key, section, QMetaEnum::fromType<T>().isFlag() ? QVariant( QMetaEnum::fromType<T>().valueToKeys( defaultValue ) ) : QVariant( QMetaEnum::fromType<T>().valueToKey( defaultValue ) ), description )
{
mMetaEnum = QMetaEnum::fromType<T>();
Q_ASSERT( mMetaEnum.isValid() );
@ -936,7 +931,7 @@ class QgsSettingsEntryEnumFlagBase : public QgsSettingsEntryBase
if ( useDefaultValueOverride )
defaultVal = defaultValueOverride;
if ( settingsType() == QgsSettingsEntryBase::SettingsType::Enum )
if ( !mMetaEnum.isFlag() )
return QgsSettings().enumValue( key( dynamicKeyPartList ),
defaultVal,
section() );
@ -959,7 +954,7 @@ class QgsSettingsEntryEnumFlagBase : public QgsSettingsEntryBase
bool ok = false;
T defaultValue;
if ( settingsType() == QgsSettingsEntryBase::SettingsType::Enum )
if ( !mMetaEnum.isFlag() )
defaultValue = static_cast<T>( mMetaEnum.keyToValue( defaultValueAsVariant().toByteArray(), &ok ) );
else
defaultValue = static_cast<T>( mMetaEnum.keysToValue( defaultValueAsVariant().toByteArray(), &ok ) );
@ -992,7 +987,7 @@ class QgsSettingsEntryEnumFlagBase : public QgsSettingsEntryBase
return false;
}
if ( settingsType() == QgsSettingsEntryBase::SettingsType::Enum )
if ( !mMetaEnum.isFlag() )
{
const char *enumKey = mMetaEnum.valueToKey( value );
if ( enumKey == nullptr )
@ -1015,99 +1010,102 @@ class QgsSettingsEntryEnumFlagBase : public QgsSettingsEntryBase
}
}
//! \copydoc QgsSettingsEntryBase::settingsType
virtual QgsSettingsEntryBase::SettingsType settingsType() const override
{
return QgsSettingsEntryBase::SettingsType::EnumFlag;
}
private:
QMetaEnum mMetaEnum;
};
#endif
#ifndef SIP_RUN
/**
* \class QgsSettingsEntryEnum
* \class QgsSettingsEntryColor
* \ingroup core
* An enum settings entry.
* \since QGIS 3.20
* A color settings entry.
* \since QGIS 3.20
*/
template <typename T>
class QgsSettingsEntryEnum : public QgsSettingsEntryEnumFlagBase<T>
class CORE_EXPORT QgsSettingsEntryColor : public QgsSettingsEntryBase
{
public:
#ifndef SIP_RUN
/**
* Constructor for QgsSettingsEntryEnum.
* Constructor for QgsSettingsEntryColor.
*
* The \a key argument specifies the final part of the settings key.
* The \a section argument specifies the section.
* The \a default value argument specifies the default value for the settings entry.
* The \a description argument specifies a description for the settings entry.
*
* \note The enum needs to be declared with Q_ENUM, and flags with Q_FLAG (not Q_FLAGS).
* \note for Python bindings, a custom implementation is achieved in Python directly
*/
QgsSettingsEntryEnum( const QString &key,
QgsSettings::Section section,
const T &defaultValue,
const QString &description = QString() )
: QgsSettingsEntryEnumFlagBase<T>( key,
section,
defaultValue,
description )
{
}
QgsSettingsEntryColor( const QString &key,
QgsSettings::Section section,
const QColor &defaultValue = QColor(),
const QString &description = QString() );
//! \copydoc QgsSettingsEntryBase::settingsType
virtual QgsSettingsEntryBase::SettingsType settingsType() const override
{
return QgsSettingsEntryBase::SettingsType::Enum;
}
};
#endif
#ifndef SIP_RUN
/**
* \class QgsSettingsEntryFlag
* \ingroup core
* An flag settings entry.
* \since QGIS 3.20
*/
template <typename T>
class QgsSettingsEntryFlag : public QgsSettingsEntryEnumFlagBase<T>
{
public:
/**
* Constructor for QgsSettingsEntryFlag.
* Constructor for QgsSettingsEntryColor.
* This constructor is intended to be used from plugins.
*
* The \a key argument specifies the final part of the settings key.
* The \a section argument specifies the section.
* The \a key argument specifies the key of the settings.
* The \a pluginName argument is inserted in the key after the section.
* The \a default value argument specifies the default value for the settings entry.
* The \a description argument specifies a description for the settings entry.
*
* \note The flag needs to be declared with Q_FLAG (not Q_FLAGS).
* \note for Python bindings, a custom implementation is achieved in Python directly.
*/
QgsSettingsEntryFlag( const QString &key,
QgsSettings::Section section,
const T &defaultValue,
const QString &description = QString() )
: QgsSettingsEntryEnumFlagBase<T>( key,
section,
defaultValue,
description )
{
}
QgsSettingsEntryColor( const QString &key,
const QString &pluginName,
const QColor &defaultValue = QColor(),
const QString &description = QString() );
/**
* Set settings value.
*
* The \a value to set.
* The \a dynamicKeyPart argument specifies the dynamic part of the settings key.
*/
bool setValue( const QColor &value, const QString &dynamicKeyPart = QString() ) const;
/**
* Set settings value.
*
* The \a value to set.
* The \a dynamicKeyParts argument specifies the list of dynamic parts of the settings key.
*/
bool setValue( const QColor &value, const QStringList &dynamicKeyPartList ) const;
/**
* Get settings value.
*
* The \a dynamicKeyPart argument specifies the dynamic part of the settings key.
* The \a useDefaultValueOverride argument specifies if defaultValueOverride should be used.
* The \a defaultValueOverride argument if valid is used instead of the normal default value.
*/
QColor value( const QString &dynamicKeyPart = QString(), bool useDefaultValueOverride = false, const QString &defaultValueOverride = QString() ) const;
/**
* Get settings value.
*
* The \a dynamicKeyParts argument specifies the list of dynamic parts of the settings key.
* The \a useDefaultValueOverride argument specifies if defaultValueOverride should be used.
* The \a defaultValueOverride argument if valid is used instead of the normal default value.
*/
QColor value( const QStringList &dynamicKeyPartList, bool useDefaultValueOverride = false, const QString &defaultValueOverride = QString() ) const;
/**
* Get settings default value.
*/
QColor defaultValue() const;
//! \copydoc QgsSettingsEntryBase::settingsType
virtual QgsSettingsEntryBase::SettingsType settingsType() const override
{
return QgsSettingsEntryBase::SettingsType::Flag;
}
virtual SettingsType settingsType() const override;
};
#endif
#endif // QGSSETTINGSENTRY_H

10
src/core/settings/qgssettingsregistry.cpp
View File

@ -52,12 +52,12 @@ void QgsSettingsRegistry::addSettingsEntry( const QgsSettingsEntryBase *settings
mSettingsEntriesMap.insert( settingsEntry->definitionKey(), settingsEntry );
}
QList<const QgsSettingsEntryBase *> QgsSettingsRegistry::getChildSettingsEntries() const
QList<const QgsSettingsEntryBase *> QgsSettingsRegistry::settingEntries() const
{
return mSettingsEntriesMap.values();
}
const QgsSettingsEntryBase *QgsSettingsRegistry::getSettingsEntry( const QString &key, bool searchChildRegistries ) const
const QgsSettingsEntryBase *QgsSettingsRegistry::settingsEntry( const QString &key, bool searchChildRegistries ) const
{
// Search in this registry
const QMap<QString, const QgsSettingsEntryBase *> settingsEntriesMap = mSettingsEntriesMap;
@ -72,7 +72,7 @@ const QgsSettingsEntryBase *QgsSettingsRegistry::getSettingsEntry( const QString
{
for ( const QgsSettingsRegistry *settingsRegistry : std::as_const( mSettingsRegistryChildList ) )
{
const QgsSettingsEntryBase *settingsEntry = settingsRegistry->getSettingsEntry( key, true );
const QgsSettingsEntryBase *settingsEntry = settingsRegistry->settingsEntry( key, true );
if ( settingsEntry )
return settingsEntry;
}
@ -81,7 +81,7 @@ const QgsSettingsEntryBase *QgsSettingsRegistry::getSettingsEntry( const QString
return nullptr;
}
void QgsSettingsRegistry::appendRegistry( const QgsSettingsRegistry *settingsRegistry )
void QgsSettingsRegistry::addSubRegistry( const QgsSettingsRegistry *settingsRegistry )
{
if ( !settingsRegistry )
{
@ -98,7 +98,7 @@ void QgsSettingsRegistry::appendRegistry( const QgsSettingsRegistry *settingsReg
mSettingsRegistryChildList.append( settingsRegistry );
}
QList<const QgsSettingsRegistry *> QgsSettingsRegistry::getChildSettingsRegistries() const
QList<const QgsSettingsRegistry *> QgsSettingsRegistry::subRegistries() const
{
return mSettingsRegistryChildList;
}

8
src/core/settings/qgssettingsregistry.h
View File

@ -48,24 +48,24 @@ class CORE_EXPORT QgsSettingsRegistry
/**
* Returns the list of registered QgsSettingsEntryBase.
*/
QList<const QgsSettingsEntryBase *> getChildSettingsEntries() const;
QList<const QgsSettingsEntryBase *> settingEntries() const;
/**
* Returns the QgsSettingsEntry with the given \a key or nullptr if not found.
*
* The \a searchChildRegistries parameter specifies if child registries should be included in the search
*/
const QgsSettingsEntryBase *getSettingsEntry( const QString &key, bool searchChildRegistries = true ) const;
const QgsSettingsEntryBase *settingsEntry( const QString &key, bool searchChildRegistries = true ) const;
/**
* Append a child \a settingsRegistry to the register.
*/
void appendRegistry( const QgsSettingsRegistry *settingsRegistry );
void addSubRegistry( const QgsSettingsRegistry *settingsRegistry );
/**
* Returns the list of registered child QgsSettingsRegistry.
*/
QList<const QgsSettingsRegistry *> getChildSettingsRegistries() const;
QList<const QgsSettingsRegistry *> subRegistries() const;
protected:

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

@ -17,6 +17,13 @@
#include "qgslayout.h"
#include "qgslocator.h"
#include "qgsnetworkaccessmanager.h"
#include "qgsnewsfeedparser.h"
#include "qgsprocessing.h"
#include "qgsapplication.h"
#include "qgsgeometryoptions.h"
#include "qgslocalizeddatapathregistry.h"
#include "qgsmaprendererjob.h"
QgsSettingsRegistryCore::QgsSettingsRegistryCore()
: QgsSettingsRegistry()
@ -26,6 +33,68 @@ QgsSettingsRegistryCore::QgsSettingsRegistryCore()
addSettingsEntry( &QgsLocator::settingsLocatorFilterEnabled );
addSettingsEntry( &QgsLocator::settingsLocatorFilterDefault );
addSettingsEntry( &QgsLocator::settingsLocatorFilterPrefix );
addSettingsEntry( &QgsNetworkAccessManager::settingsNetworkTimeout );
addSettingsEntry( &QgsNewsFeedParser::settingsFeedLastFetchTime );
addSettingsEntry( &QgsNewsFeedParser::settingsFeedLanguage );
addSettingsEntry( &QgsNewsFeedParser::settingsFeedLatitude );
addSettingsEntry( &QgsNewsFeedParser::settingsFeedLongitude );
addSettingsEntry( &QgsProcessing::settingsPreferFilenameAsLayerName );
addSettingsEntry( &QgsProcessing::settingsTempPath );
addSettingsEntry( &QgsProcessing::settingsDefaultOutputVectorLayerExt );
addSettingsEntry( &QgsProcessing::settingsDefaultOutputRasterLayerExt );
addSettingsEntry( &QgsApplication::settingsLocaleUserLocale );
addSettingsEntry( &QgsApplication::settingsLocaleOverrideFlag );
addSettingsEntry( &QgsApplication::settingsLocaleGlobalLocale );
addSettingsEntry( &QgsApplication::settingsLocaleShowGroupSeparator );
addSettingsEntry( &QgsApplication::settingsSearchPathsForSVG );
addSettingsEntry( &QgsGeometryOptions::settingsGeometryValidationDefaultChecks );
addSettingsEntry( &QgsLocalizedDataPathRegistry::settingsLocalizedDataPaths );
addSettingsEntry( &QgsMapRendererJob::settingsLogCanvasRefreshEvent );
addSettingsEntry( &settingsDigitizingStreamTolerance );
addSettingsEntry( &settingsDigitizingLineWidth );
addSettingsEntry( &settingsDigitizingLineColorRed );
addSettingsEntry( &settingsDigitizingLineColorGreen );
addSettingsEntry( &settingsDigitizingLineColorBlue );
addSettingsEntry( &settingsDigitizingLineColorAlpha );
addSettingsEntry( &settingsDigitizingLineColorAlphaScale );
addSettingsEntry( &settingsDigitizingFillColorRed );
addSettingsEntry( &settingsDigitizingFillColorGreen );
addSettingsEntry( &settingsDigitizingFillColorBlue );
addSettingsEntry( &settingsDigitizingFillColorAlpha );
addSettingsEntry( &settingsDigitizingLineGhost );
addSettingsEntry( &settingsDigitizingDefaultZValue );
addSettingsEntry( &settingsDigitizingDefaultSnapEnabled );
addSettingsEntry( &settingsDigitizingDefaultSnapType );
addSettingsEntry( &settingsDigitizingDefaultSnappingTolerance );
addSettingsEntry( &settingsDigitizingDefaultSnappingToleranceUnit );
addSettingsEntry( &settingsDigitizingSearchRadiusVertexEdit );
addSettingsEntry( &settingsDigitizingSearchRadiusVertexEditUnit );
addSettingsEntry( &settingsDigitizingSnapColor );
addSettingsEntry( &settingsDigitizingSnapTooltip );
addSettingsEntry( &settingsDigitizingSnapInvisibleFeature );
addSettingsEntry( &settingsDigitizingMarkerOnlyForSelected );
addSettingsEntry( &settingsDigitizingMarkerStyle );
addSettingsEntry( &settingsDigitizingMarkerSizeMm );
addSettingsEntry( &settingsDigitizingReuseLastValues );
addSettingsEntry( &settingsDigitizingDisableEnterAttributeValuesDialog );
addSettingsEntry( &settingsDigitizingValidateGeometries );
addSettingsEntry( &settingsDigitizingOffsetJoinStyle );
addSettingsEntry( &settingsDigitizingOffsetQuadSeg );
addSettingsEntry( &settingsDigitizingOffsetMiterLimit );
addSettingsEntry( &settingsDigitizingConvertToCurve );
addSettingsEntry( &settingsDigitizingConvertToCurveAngleTolerance );
addSettingsEntry( &settingsDigitizingConvertToCurveDistanceTolerance );
addSettingsEntry( &settingsDigitizingOffsetCapStyle );
addSettingsEntry( &settingsDigitizingOffsetShowAdvanced );
addSettingsEntry( &settingsDigitizingTracingMaxFeatureCount );
}
QgsSettingsRegistryCore::~QgsSettingsRegistryCore()

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

@ -20,6 +20,11 @@
#include "qgis_core.h"
#include "qgis_sip.h"
#include "qgssettingsregistry.h"
#include "qgssettingsentry.h"
#include "qgis.h"
#include "qgssnappingconfig.h"
#include "qgsgeometry.h"
/**
* \ingroup core
@ -43,6 +48,119 @@ class CORE_EXPORT QgsSettingsRegistryCore : public QgsSettingsRegistry
*/
virtual ~QgsSettingsRegistryCore();
#ifndef SIP_RUN
//! Settings entry digitizing stream tolerance
static const inline QgsSettingsEntryInteger settingsDigitizingStreamTolerance = QgsSettingsEntryInteger( QStringLiteral( "/qgis/digitizing/stream_tolerance" ), QgsSettings::NoSection, 2 );
//! Settings entry digitizing line width
static const inline QgsSettingsEntryInteger settingsDigitizingLineWidth = QgsSettingsEntryInteger( QStringLiteral( "/qgis/digitizing/line_width" ), QgsSettings::NoSection, 1 );
//! Settings entry digitizing line color red
static const inline QgsSettingsEntryInteger settingsDigitizingLineColorRed = QgsSettingsEntryInteger( QStringLiteral( "/qgis/digitizing/line_color_red" ), QgsSettings::NoSection, 255 );
//! Settings entry digitizing line color green
static const inline QgsSettingsEntryInteger settingsDigitizingLineColorGreen = QgsSettingsEntryInteger( QStringLiteral( "/qgis/digitizing/line_color_green" ), QgsSettings::NoSection, 0 );
//! Settings entry digitizing line color blue
static const inline QgsSettingsEntryInteger settingsDigitizingLineColorBlue = QgsSettingsEntryInteger( QStringLiteral( "/qgis/digitizing/line_color_blue" ), QgsSettings::NoSection, 0 );
//! Settings entry digitizing line color alpha
static const inline QgsSettingsEntryInteger settingsDigitizingLineColorAlpha = QgsSettingsEntryInteger( QStringLiteral( "/qgis/digitizing/line_color_alpha" ), QgsSettings::NoSection, 200 );
//! Settings entry digitizing line color alpha scale
static const inline QgsSettingsEntryDouble settingsDigitizingLineColorAlphaScale = QgsSettingsEntryDouble( QStringLiteral( "/qgis/digitizing/line_color_alpha_scale" ), QgsSettings::NoSection, 0.75 );
//! Settings entry digitizing fill color red
static const inline QgsSettingsEntryInteger settingsDigitizingFillColorRed = QgsSettingsEntryInteger( QStringLiteral( "/qgis/digitizing/fill_color_red" ), QgsSettings::NoSection, 255 );
//! Settings entry digitizing fill color green
static const inline QgsSettingsEntryInteger settingsDigitizingFillColorGreen = QgsSettingsEntryInteger( QStringLiteral( "/qgis/digitizing/fill_color_green" ), QgsSettings::NoSection, 0 );
//! Settings entry digitizing fill color blue
static const inline QgsSettingsEntryInteger settingsDigitizingFillColorBlue = QgsSettingsEntryInteger( QStringLiteral( "/qgis/digitizing/fill_color_blue" ), QgsSettings::NoSection, 0 );
//! Settings entry digitizing fill color alpha
static const inline QgsSettingsEntryInteger settingsDigitizingFillColorAlpha = QgsSettingsEntryInteger( QStringLiteral( "/qgis/digitizing/fill_color_alpha" ), QgsSettings::NoSection, 30 );
//! Settings entry digitizing line ghost
static const inline QgsSettingsEntryBool settingsDigitizingLineGhost = QgsSettingsEntryBool( QStringLiteral( "/qgis/digitizing/line_ghost" ), QgsSettings::NoSection, false );
//! Settings entry digitizing default z value
static const inline QgsSettingsEntryDouble settingsDigitizingDefaultZValue = QgsSettingsEntryDouble( QStringLiteral( "/qgis/digitizing/default_z_value" ), QgsSettings::NoSection, Qgis::DEFAULT_Z_COORDINATE );
//! Settings entry digitizing default snap enabled
static const inline QgsSettingsEntryBool settingsDigitizingDefaultSnapEnabled = QgsSettingsEntryBool( QStringLiteral( "/qgis/digitizing/default_snap_enabled" ), QgsSettings::NoSection, false );
//! Settings entry digitizing default snap type
static const inline QgsSettingsEntryEnumFlag<QgsSnappingConfig::SnappingTypes> settingsDigitizingDefaultSnapType = QgsSettingsEntryEnumFlag<QgsSnappingConfig::SnappingTypes>( QStringLiteral( "/qgis/digitizing/default_snap_type" ), QgsSettings::NoSection, QgsSnappingConfig::VertexFlag );
//! Settings entry digitizing default snapping tolerance
static const inline QgsSettingsEntryDouble settingsDigitizingDefaultSnappingTolerance = QgsSettingsEntryDouble( QStringLiteral( "/qgis/digitizing/default_snapping_tolerance" ), QgsSettings::NoSection, Qgis::DEFAULT_SNAP_TOLERANCE );
//! Settings entry digitizing default snapping tolerance unit
static const inline QgsSettingsEntryEnumFlag<QgsTolerance::UnitType> settingsDigitizingDefaultSnappingToleranceUnit = QgsSettingsEntryEnumFlag<QgsTolerance::UnitType>( QStringLiteral( "/qgis/digitizing/default_snapping_tolerance_unit" ), QgsSettings::NoSection, Qgis::DEFAULT_SNAP_UNITS );
//! Settings entry digitizing search radius vertex edit
static const inline QgsSettingsEntryDouble settingsDigitizingSearchRadiusVertexEdit = QgsSettingsEntryDouble( QStringLiteral( "/qgis/digitizing/search_radius_vertex_edit" ), QgsSettings::NoSection, 10 );
//! Settings entry digitizing search radius vertex edit unit
static const inline QgsSettingsEntryEnumFlag<QgsTolerance::UnitType> settingsDigitizingSearchRadiusVertexEditUnit = QgsSettingsEntryEnumFlag<QgsTolerance::UnitType>( QStringLiteral( "/qgis/digitizing/search_radius_vertex_edit_unit" ), QgsSettings::NoSection, QgsTolerance::Pixels );
//! Settings entry digitizing snap color
static const inline QgsSettingsEntryColor settingsDigitizingSnapColor = QgsSettingsEntryColor( QStringLiteral( "/qgis/digitizing/snap_color" ), QgsSettings::NoSection, QColor( Qt::magenta ) );
//! Settings entry digitizing snap tooltip
static const inline QgsSettingsEntryBool settingsDigitizingSnapTooltip = QgsSettingsEntryBool( QStringLiteral( "/qgis/digitizing/snap_tooltip" ), QgsSettings::NoSection, false );
//! Settings entry digitizing snap invisible feature
static const inline QgsSettingsEntryBool settingsDigitizingSnapInvisibleFeature = QgsSettingsEntryBool( QStringLiteral( "/qgis/digitizing/snap_invisible_feature" ), QgsSettings::NoSection, false );
//! Settings entry digitizing marker only for selected
static const inline QgsSettingsEntryBool settingsDigitizingMarkerOnlyForSelected = QgsSettingsEntryBool( QStringLiteral( "/qgis/digitizing/marker_only_for_selected" ), QgsSettings::NoSection, true );
//! Settings entry digitizing marker style
static const inline QgsSettingsEntryString settingsDigitizingMarkerStyle = QgsSettingsEntryString( QStringLiteral( "/qgis/digitizing/marker_style" ), QgsSettings::NoSection, "Cross" );
//! Settings entry digitizing marker size mm
static const inline QgsSettingsEntryDouble settingsDigitizingMarkerSizeMm = QgsSettingsEntryDouble( QStringLiteral( "/qgis/digitizing/marker_size_mm" ), QgsSettings::NoSection, 2.0 );
//! Settings entry digitizing reuseLastValues
static const inline QgsSettingsEntryBool settingsDigitizingReuseLastValues = QgsSettingsEntryBool( QStringLiteral( "/qgis/digitizing/reuseLastValues" ), QgsSettings::NoSection, false );
//! Settings entry digitizing disable enter attribute values dialog
static const inline QgsSettingsEntryBool settingsDigitizingDisableEnterAttributeValuesDialog = QgsSettingsEntryBool( QStringLiteral( "/qgis/digitizing/disable_enter_attribute_values_dialog" ), QgsSettings::NoSection, false );
//! Settings entry digitizing validate geometries
static const inline QgsSettingsEntryInteger settingsDigitizingValidateGeometries = QgsSettingsEntryInteger( QStringLiteral( "/qgis/digitizing/validate_geometries" ), QgsSettings::NoSection, 1 );
//! Settings entry digitizing offset join style
static const inline QgsSettingsEntryEnumFlag<QgsGeometry::JoinStyle> settingsDigitizingOffsetJoinStyle = QgsSettingsEntryEnumFlag<QgsGeometry::JoinStyle>( QStringLiteral( "/qgis/digitizing/offset_join_style" ), QgsSettings::NoSection, QgsGeometry::JoinStyleRound );
//! Settings entry digitizing offset quad seg
static const inline QgsSettingsEntryInteger settingsDigitizingOffsetQuadSeg = QgsSettingsEntryInteger( QStringLiteral( "/qgis/digitizing/offset_quad_seg" ), QgsSettings::NoSection, 8 );
//! Settings entry digitizing offset miter limit
static const inline QgsSettingsEntryDouble settingsDigitizingOffsetMiterLimit = QgsSettingsEntryDouble( QStringLiteral( "/qgis/digitizing/offset_miter_limit" ), QgsSettings::NoSection, 5.0 );
//! Settings entry digitizing convert to curve
static const inline QgsSettingsEntryBool settingsDigitizingConvertToCurve = QgsSettingsEntryBool( QStringLiteral( "/qgis/digitizing/convert_to_curve" ), QgsSettings::NoSection, false );
//! Settings entry digitizing convert to curve angle tolerance
static const inline QgsSettingsEntryDouble settingsDigitizingConvertToCurveAngleTolerance = QgsSettingsEntryDouble( QStringLiteral( "/qgis/digitizing/convert_to_curve_angle_tolerance" ), QgsSettings::NoSection, 1e-6 );
//! Settings entry digitizing convert to curve distance tolerance
static const inline QgsSettingsEntryDouble settingsDigitizingConvertToCurveDistanceTolerance = QgsSettingsEntryDouble( QStringLiteral( "/qgis/digitizing/convert_to_curve_distance_tolerance" ), QgsSettings::NoSection, 1e-6 );
//! Settings entry digitizing offset cap style
static const inline QgsSettingsEntryEnumFlag<QgsGeometry::EndCapStyle> settingsDigitizingOffsetCapStyle = QgsSettingsEntryEnumFlag<QgsGeometry::EndCapStyle>( QStringLiteral( "/qgis/digitizing/offset_cap_style" ), QgsSettings::NoSection, QgsGeometry::CapRound );
//! Settings entry digitizing offset show advanced
static const inline QgsSettingsEntryBool settingsDigitizingOffsetShowAdvanced = QgsSettingsEntryBool( QStringLiteral( "/qgis/digitizing/offset_show_advanced" ), QgsSettings::NoSection, false );
//! Settings entry digitizing tracing max feature count
static const inline QgsSettingsEntryInteger settingsDigitizingTracingMaxFeatureCount = QgsSettingsEntryInteger( QStringLiteral( "/qgis/digitizing/tracing_max_feature_count" ), QgsSettings::NoSection, 10000 );
#endif
};
#endif // QGSSETTINGSREGISTRYCORE_H

9
src/core/vector/qgsvectorlayerrenderer.cpp
View File

@ -35,7 +35,7 @@
#include "qgsfeaturefilterprovider.h"
#include "qgsexception.h"
#include "qgslogger.h"
#include "qgssettings.h"
#include "qgssettingsregistrycore.h"
#include "qgsexpressioncontextutils.h"
#include "qgsrenderedfeaturehandlerinterface.h"
#include "qgsvectorlayertemporalproperties.h"
@ -115,10 +115,9 @@ QgsVectorLayerRenderer::QgsVectorLayerRenderer( QgsVectorLayer *layer, QgsRender
mSimplifyGeometry = layer->simplifyDrawingCanbeApplied( *renderContext(), QgsVectorSimplifyMethod::GeometrySimplification );
}
QgsSettings settings;
mVertexMarkerOnlyForSelection = settings.value( QStringLiteral( "qgis/digitizing/marker_only_for_selected" ), true ).toBool();
mVertexMarkerOnlyForSelection = QgsSettingsRegistryCore::settingsDigitizingMarkerOnlyForSelected.value();
QString markerTypeString = settings.value( QStringLiteral( "qgis/digitizing/marker_style" ), "Cross" ).toString();
QString markerTypeString = QgsSettingsRegistryCore::settingsDigitizingMarkerStyle.value();
if ( markerTypeString == QLatin1String( "Cross" ) )
{
mVertexMarkerStyle = QgsSymbolLayerUtils::Cross;
@ -132,7 +131,7 @@ QgsVectorLayerRenderer::QgsVectorLayerRenderer( QgsVectorLayer *layer, QgsRender
mVertexMarkerStyle = QgsSymbolLayerUtils::NoMarker;
}
mVertexMarkerSize = settings.value( QStringLiteral( "qgis/digitizing/marker_size_mm" ), 2.0 ).toDouble();
mVertexMarkerSize = QgsSettingsRegistryCore::settingsDigitizingMarkerSizeMm.value();
QgsDebugMsgLevel( "rendering v2:\n " + mRenderer->dump(), 2 );

8
src/gui/qgsconfigureshortcutsdialog.cpp
View File

@ -16,6 +16,7 @@
#include "qgsconfigureshortcutsdialog.h"
#include "qgsshortcutsmanager.h"
#include "qgsapplication.h"
#include "qgslogger.h"
#include "qgssettings.h"
#include "qgsgui.h"
@ -135,7 +136,7 @@ void QgsConfigureShortcutsDialog::saveShortcuts()
QDomDocument doc( QStringLiteral( "shortcuts" ) );
QDomElement root = doc.createElement( QStringLiteral( "qgsshortcuts" ) );
root.setAttribute( QStringLiteral( "version" ), QStringLiteral( "1.0" ) );
root.setAttribute( QStringLiteral( "locale" ), settings.value( QStringLiteral( "locale/userLocale" ), "en_US" ).toString() );
root.setAttribute( QStringLiteral( "locale" ), settings.value( QgsApplication::settingsLocaleUserLocale.key(), "en_US" ).toString() );
doc.appendChild( root );
settings.beginGroup( mManager->settingsPath() );
@ -202,13 +203,12 @@ void QgsConfigureShortcutsDialog::loadShortcuts()
return;
}
QgsSettings settings;
QString currentLocale;
bool localeOverrideFlag = settings.value( QStringLiteral( "locale/overrideFlag" ), false ).toBool();
bool localeOverrideFlag = QgsApplication::settingsLocaleOverrideFlag.value();
if ( localeOverrideFlag )
{
currentLocale = settings.value( QStringLiteral( "locale/userLocale" ), "en_US" ).toString();
currentLocale = QgsApplication::settingsLocaleUserLocale.value( QString(), true, "en_US" );
}
else // use QGIS locale
{

3
src/gui/qgsgui.cpp
View File

@ -174,8 +174,7 @@ void QgsGui::setWindowManager( QgsWindowManagerInterface *manager )
QgsGui::HigFlags QgsGui::higFlags()
{
QgsSettings settings;
if ( settings.value( QStringLiteral( "locale/userLocale" ), QString() ).toString().startsWith( QLatin1String( "en" ) ) )
if ( QgsApplication::settingsLocaleUserLocale.value().startsWith( QLatin1String( "en" ) ) )
{
return HigMenuTextIsTitleCase | HigDialogTitleIsTitleCase;
}

4
src/gui/qgsmapcanvas.cpp
View File

@ -61,6 +61,7 @@ email : sherman at mrcc.com
#include "qgsmapoverviewcanvas.h"
#include "qgsmaprenderercache.h"
#include "qgsmaprenderercustompainterjob.h"
#include "qgsmaprendererjob.h"
#include "qgsmaprendererparalleljob.h"
#include "qgsmaprenderersequentialjob.h"
#include "qgsmapsettingsutils.h"
@ -705,8 +706,7 @@ void QgsMapCanvas::rendererJobFinished()
QPainter p( &img );
emit renderComplete( &p );
QgsSettings settings;
if ( settings.value( QStringLiteral( "Map/logCanvasRefreshEvent" ), false ).toBool() )
if ( QgsMapRendererJob::settingsLogCanvasRefreshEvent.value() )
{
QString logMsg = tr( "Canvas refresh: %1 ms" ).arg( mJob->renderingTime() );
QgsMessageLog::logMessage( logMsg, tr( "Rendering" ) );

8
src/gui/qgsmapcanvassnappingutils.cpp
View File

@ -16,13 +16,13 @@
#include "qgsmapcanvas.h"
#include "qgsvectorlayer.h"
#include "qgssettings.h"
#include "qgssettingsregistrycore.h"
#include <QApplication>
#include <QProgressDialog>
QgsMapCanvasSnappingUtils::QgsMapCanvasSnappingUtils( QgsMapCanvas *canvas, QObject *parent )
: QgsSnappingUtils( parent, QgsSettings().value( QStringLiteral( "/qgis/digitizing/snap_invisible_feature" ), false ).toBool() )
: QgsSnappingUtils( parent, QgsSettingsRegistryCore::settingsDigitizingSnapInvisibleFeature.value() )
, mCanvas( canvas )
{
@ -39,7 +39,7 @@ QgsMapCanvasSnappingUtils::QgsMapCanvasSnappingUtils( QgsMapCanvas *canvas, QObj
void QgsMapCanvasSnappingUtils::canvasMapSettingsChanged()
{
setMapSettings( mCanvas->mapSettings() );
setEnableSnappingForInvisibleFeature( QgsSettings().value( QStringLiteral( "/qgis/digitizing/snap_invisible_feature" ), false ).toBool() );
setEnableSnappingForInvisibleFeature( QgsSettingsRegistryCore::settingsDigitizingSnapInvisibleFeature.value() );
}
void QgsMapCanvasSnappingUtils::canvasTransformContextChanged()
@ -56,7 +56,7 @@ void QgsMapCanvasSnappingUtils::canvasCurrentLayerChanged()
void QgsMapCanvasSnappingUtils::canvasMapToolChanged()
{
setEnableSnappingForInvisibleFeature( QgsSettings().value( QStringLiteral( "/qgis/digitizing/snap_invisible_feature" ), false ).toBool() );
setEnableSnappingForInvisibleFeature( QgsSettingsRegistryCore::settingsDigitizingSnapInvisibleFeature.value() );
}
void QgsMapCanvasSnappingUtils::prepareIndexStarting( int count )

4
src/gui/qgsmapcanvastracer.cpp
View File

@ -22,7 +22,7 @@
#include "qgssnappingutils.h"
#include "qgsvectorlayer.h"
#include "qgssnappingconfig.h"
#include "qgssettings.h"
#include "qgssettingsregistrycore.h"
#include <QAction>
@ -49,7 +49,7 @@ QgsMapCanvasTracer::QgsMapCanvasTracer( QgsMapCanvas *canvas, QgsMessageBar *mes
// arbitrarily chosen limit that should allow for fairly fast initialization
// of the underlying graph structure
setMaxFeatureCount( QgsSettings().value( QStringLiteral( "/qgis/digitizing/tracing_max_feature_count" ), 10000 ).toInt() );
setMaxFeatureCount( QgsSettingsRegistryCore::settingsDigitizingTracingMaxFeatureCount.value() );
}
QgsMapCanvasTracer::~QgsMapCanvasTracer()

20
src/gui/qgsmaptoolcapture.cpp
View File

@ -28,7 +28,7 @@
#include "qgssnapindicator.h"
#include "qgsvectorlayer.h"
#include "qgsvertexmarker.h"
#include "qgssettings.h"
#include "qgssettingsregistrycore.h"
#include "qgsapplication.h"
#include "qgsadvanceddigitizingdockwidget.h"
#include "qgsproject.h"
@ -284,8 +284,7 @@ bool QgsMapToolCapture::tracingAddVertex( const QgsPointXY &point )
resetRubberBand();
// Curves de-approximation
QgsSettings settings;
if ( settings.value( QStringLiteral( "/qgis/digitizing/convert_to_curve" ), false ).toBool() )
if ( QgsSettingsRegistryCore::settingsDigitizingConvertToCurve.value() )
{
// If the tool and the layer support curves
QgsVectorLayer *vlayer = qobject_cast<QgsVectorLayer *>( mCanvas->currentLayer() );
@ -293,8 +292,8 @@ bool QgsMapToolCapture::tracingAddVertex( const QgsPointXY &point )
{
QgsGeometry linear = QgsGeometry( mCaptureCurve.segmentize() );
QgsGeometry curved = linear.convertToCurves(
settings.value( QStringLiteral( "/qgis/digitizing/convert_to_curve_angle_tolerance" ), 1e-6 ).toDouble(),
settings.value( QStringLiteral( "/qgis/digitizing/convert_to_curve_distance_tolerance" ), 1e-6 ).toDouble()
QgsSettingsRegistryCore::settingsDigitizingConvertToCurveAngleTolerance.value(),
QgsSettingsRegistryCore::settingsDigitizingConvertToCurveDistanceTolerance.value()
);
mCaptureCurve = *qgsgeometry_cast<QgsCompoundCurve *>( curved.constGet() );
}
@ -316,12 +315,11 @@ bool QgsMapToolCapture::tracingAddVertex( const QgsPointXY &point )
QgsMapToolCaptureRubberBand *QgsMapToolCapture::createCurveRubberBand() const
{
QgsSettings settings;
QgsMapToolCaptureRubberBand *rb = new QgsMapToolCaptureRubberBand( mCanvas );
rb->setStrokeWidth( digitizingStrokeWidth() );
QColor color = digitizingStrokeColor();
double alphaScale = settings.value( QStringLiteral( "qgis/digitizing/line_color_alpha_scale" ), 0.75 ).toDouble();
double alphaScale = QgsSettingsRegistryCore::settingsDigitizingLineColorAlphaScale.value();
color.setAlphaF( color.alphaF() * alphaScale );
rb->setLineStyle( Qt::DotLine );
rb->setStrokeColor( color );
@ -370,8 +368,7 @@ void QgsMapToolCapture::setStreamDigitizingEnabled( bool enable )
mStartNewCurve = true;
if ( enable )
{
QgsSettings settings;
mStreamingToleranceInPixels = settings.value( QStringLiteral( "/qgis/digitizing/stream_tolerance" ), 2 ).toInt();
mStreamingToleranceInPixels = QgsSettingsRegistryCore::settingsDigitizingStreamTolerance.value();
}
}
@ -865,8 +862,7 @@ void QgsMapToolCapture::closePolygon()
void QgsMapToolCapture::validateGeometry()
{
QgsSettings settings;
if ( settings.value( QStringLiteral( "qgis/digitizing/validate_geometries" ), 1 ).toInt() == 0 )
if ( QgsSettingsRegistryCore::settingsDigitizingValidateGeometries.value() == 0 )
return;
if ( mValidator )
@ -908,7 +904,7 @@ void QgsMapToolCapture::validateGeometry()
return;
QgsGeometry::ValidationMethod method = QgsGeometry::ValidatorQgisInternal;
if ( settings.value( QStringLiteral( "qgis/digitizing/validate_geometries" ), 1 ).toInt() == 2 )
if ( QgsSettingsRegistryCore::settingsDigitizingValidateGeometries.value() == 2 )
method = QgsGeometry::ValidatorGeos;
mValidator = new QgsGeometryValidator( geom, nullptr, method );
connect( mValidator, &QgsGeometryValidator::errorFound, this, &QgsMapToolCapture::addError );

44
src/gui/qgsmaptooledit.cpp
View File

@ -19,7 +19,7 @@
#include "qgsgeometryrubberband.h"
#include "qgsrubberband.h"
#include "qgsvectorlayer.h"
#include "qgssettings.h"
#include "qgssettingsregistrycore.h"
#include <QKeyEvent>
@ -36,37 +36,28 @@ QgsMapToolEdit::QgsMapToolEdit( QgsMapCanvas *canvas )
double QgsMapToolEdit::defaultZValue() const
{
return QgsSettings().value( QStringLiteral( "/qgis/digitizing/default_z_value" ), Qgis::DEFAULT_Z_COORDINATE ).toDouble();
return QgsSettingsRegistryCore::settingsDigitizingDefaultZValue.value();
}
QColor QgsMapToolEdit::digitizingStrokeColor()
{
QgsSettings settings;
QColor color(
settings.value( QStringLiteral( "qgis/digitizing/line_color_red" ), 255 ).toInt(),
settings.value( QStringLiteral( "qgis/digitizing/line_color_green" ), 0 ).toInt(),
settings.value( QStringLiteral( "qgis/digitizing/line_color_blue" ), 0 ).toInt() );
double myAlpha = settings.value( QStringLiteral( "qgis/digitizing/line_color_alpha" ), 200 ).toInt() / 255.0;
color.setAlphaF( myAlpha );
return color;
return QColor( QgsSettingsRegistryCore::settingsDigitizingLineColorRed.value(),
QgsSettingsRegistryCore::settingsDigitizingLineColorGreen.value(),
QgsSettingsRegistryCore::settingsDigitizingLineColorBlue.value(),
QgsSettingsRegistryCore::settingsDigitizingLineColorAlpha.value() );
}
int QgsMapToolEdit::digitizingStrokeWidth()
{
QgsSettings settings;
return settings.value( QStringLiteral( "qgis/digitizing/line_width" ), 1 ).toInt();
return QgsSettingsRegistryCore::settingsDigitizingLineWidth.value();
}
QColor QgsMapToolEdit::digitizingFillColor()
{
QgsSettings settings;
QColor fillColor(
settings.value( QStringLiteral( "qgis/digitizing/fill_color_red" ), 255 ).toInt(),
settings.value( QStringLiteral( "qgis/digitizing/fill_color_green" ), 0 ).toInt(),
settings.value( QStringLiteral( "qgis/digitizing/fill_color_blue" ), 0 ).toInt() );
double myAlpha = settings.value( QStringLiteral( "qgis/digitizing/fill_color_alpha" ), 30 ).toInt() / 255.0;
fillColor.setAlphaF( myAlpha );
return fillColor;
return QColor( QgsSettingsRegistryCore::settingsDigitizingFillColorRed.value(),
QgsSettingsRegistryCore::settingsDigitizingFillColorGreen.value(),
QgsSettingsRegistryCore::settingsDigitizingFillColorBlue.value(),
QgsSettingsRegistryCore::settingsDigitizingFillColorAlpha.value() );
}
@ -78,7 +69,7 @@ QgsRubberBand *QgsMapToolEdit::createRubberBand( QgsWkbTypes::GeometryType geome
QColor color = digitizingStrokeColor();
if ( alternativeBand )
{
double alphaScale = settings.value( QStringLiteral( "qgis/digitizing/line_color_alpha_scale" ), 0.75 ).toDouble();
double alphaScale = QgsSettingsRegistryCore::settingsDigitizingLineColorAlphaScale.value();
color.setAlphaF( color.alphaF() * alphaScale );
rb->setLineStyle( Qt::DotLine );
}
@ -148,15 +139,14 @@ QgsMapToolEdit::TopologicalResult QgsMapToolEdit::addTopologicalPoints( const QV
QgsGeometryRubberBand *QgsMapToolEdit::createGeometryRubberBand( QgsWkbTypes::GeometryType geometryType, bool alternativeBand ) const
{
QgsSettings settings;
QgsGeometryRubberBand *rb = new QgsGeometryRubberBand( mCanvas, geometryType );
QColor color( settings.value( QStringLiteral( "qgis/digitizing/line_color_red" ), 255 ).toInt(),
settings.value( QStringLiteral( "qgis/digitizing/line_color_green" ), 0 ).toInt(),
settings.value( QStringLiteral( "qgis/digitizing/line_color_blue" ), 0 ).toInt() );
double myAlpha = settings.value( QStringLiteral( "qgis/digitizing/line_color_alpha" ), 200 ).toInt() / 255.0;
QColor color( QgsSettingsRegistryCore::settingsDigitizingLineColorRed.value(),
QgsSettingsRegistryCore::settingsDigitizingLineColorGreen.value(),
QgsSettingsRegistryCore::settingsDigitizingLineColorBlue.value() );
double myAlpha = QgsSettingsRegistryCore::settingsDigitizingLineColorAlpha.value() / 255.0;
if ( alternativeBand )
{
myAlpha = myAlpha * settings.value( QStringLiteral( "qgis/digitizing/line_color_alpha_scale" ), 0.75 ).toDouble();
myAlpha = myAlpha * QgsSettingsRegistryCore::settingsDigitizingLineColorAlphaScale.value();
rb->setLineStyle( Qt::DotLine );
}
color.setAlphaF( myAlpha );

8
src/gui/qgssnapindicator.cpp
View File

@ -17,7 +17,7 @@
#include "qgsguiutils.h"
#include "qgsmapcanvas.h"
#include "qgssettings.h"
#include "qgssettingsregistrycore.h"
#include "qgsvectorlayer.h"
#include "qgsvertexmarker.h"
@ -72,9 +72,7 @@ void QgsSnapIndicator::setMatch( const QgsPointLocator::Match &match )
mSnappingMarker->setPenWidth( QgsGuiUtils::scaleIconSize( 3 ) );
}
QgsSettings s;
QColor color = s.value( QStringLiteral( "/qgis/digitizing/snap_color" ), QColor( Qt::magenta ) ).value<QColor>();
QColor color = QgsSettingsRegistryCore::settingsDigitizingSnapColor.value();
mSnappingMarker->setColor( color );
int iconType;
@ -111,7 +109,7 @@ void QgsSnapIndicator::setMatch( const QgsPointLocator::Match &match )
mSnappingMarker->setCenter( match.point() );
// tooltip
if ( s.value( QStringLiteral( "/qgis/digitizing/snap_tooltip" ), false ).toBool() )
if ( QgsSettingsRegistryCore::settingsDigitizingSnapTooltip.value() )
{
QPoint ptCanvas = mSnappingMarker->toCanvasCoordinates( match.point() ).toPoint();
QPoint ptGlobal = mCanvas->mapToGlobal( ptCanvas );

5
src/gui/vector/qgsattributesformproperties.cpp
View File

@ -30,6 +30,7 @@
#include "qgsattributeeditorcontainer.h"
#include "qgsattributeeditorqmlelement.h"
#include "qgsattributeeditorhtmlelement.h"
#include "qgssettingsregistrycore.h"
QgsAttributesFormProperties::QgsAttributesFormProperties( QgsVectorLayer *layer, QWidget *parent )
@ -169,9 +170,7 @@ void QgsAttributesFormProperties::initFormLayoutTree()
void QgsAttributesFormProperties::initSuppressCombo()
{
QgsSettings settings;
if ( settings.value( QStringLiteral( "qgis/digitizing/disable_enter_attribute_values_dialog" ), false ).toBool() )
if ( QgsSettingsRegistryCore::settingsDigitizingDisableEnterAttributeValuesDialog.value() )
{
mFormSuppressCmbBx->addItem( tr( "Hide Form on Add Feature (global settings)" ) );
}

20
tests/src/analysis/testqgsprocessing.cpp
View File

@ -2303,11 +2303,11 @@ void TestQgsProcessing::parameters()
context2.layersToLoadOnCompletion().values().at( 0 ).setOutputLayerName( rl.get() );
QCOMPARE( rl->name(), QStringLiteral( "landsat" ) );
// unless setting prohibits it...
QgsSettings().setValue( QStringLiteral( "Processing/Configuration/PREFER_FILENAME_AS_LAYER_NAME" ), false );
QgsProcessing::settingsPreferFilenameAsLayerName.setValue( false );
context2.layersToLoadOnCompletion().values().at( 0 ).setOutputLayerName( rl.get() );
QCOMPARE( rl->name(), QStringLiteral( "my_dest" ) );
// if layer has a layername, we should use that instead of the base file name...
QgsSettings().setValue( QStringLiteral( "Processing/Configuration/PREFER_FILENAME_AS_LAYER_NAME" ), true );
QgsProcessing::settingsPreferFilenameAsLayerName.setValue( true );
vl = std::make_unique< QgsVectorLayer >( QStringLiteral( TEST_DATA_DIR ) + "/points_gpkg.gpkg|layername=points_small", QString() );
context2.layersToLoadOnCompletion().values().at( 0 ).setOutputLayerName( vl.get() );
QCOMPARE( vl->name(), QStringLiteral( "points_small" ) );
@ -11042,7 +11042,7 @@ void TestQgsProcessing::tempUtils()
QgsSettings settings;
QString alternative_tempFolder1 = tempDirPath + QStringLiteral( "/alternative_temp_test_one" );
settings.setValue( QStringLiteral( "Processing/Configuration/TEMP_PATH2" ), alternative_tempFolder1 );
QgsProcessing::settingsTempPath.setValue( alternative_tempFolder1 );
// check folder and if it's constant with alternative temp folder 1
tempFolder = QgsProcessingUtils::tempFolder();
QCOMPARE( tempFolder.left( alternative_tempFolder1.length() ), alternative_tempFolder1 );
@ -11054,7 +11054,7 @@ void TestQgsProcessing::tempUtils()
QVERIFY( alternativeTempFile1.startsWith( alternative_tempFolder1 ) );
// change temp folder in the settings again
QString alternative_tempFolder2 = tempDirPath + QStringLiteral( "/alternative_temp_test_two" );
settings.setValue( QStringLiteral( "Processing/Configuration/TEMP_PATH2" ), alternative_tempFolder2 );
QgsProcessing::settingsTempPath.setValue( alternative_tempFolder2 );
// check folder and if it's constant constant with alternative temp folder 2
tempFolder = QgsProcessingUtils::tempFolder();
QCOMPARE( tempFolder.left( alternative_tempFolder2.length() ), alternative_tempFolder2 );
@ -11064,7 +11064,7 @@ void TestQgsProcessing::tempUtils()
QVERIFY( alternativeTempFile2.endsWith( "alternative_temptest.txt" ) );
QVERIFY( alternativeTempFile2.startsWith( tempFolder ) );
QVERIFY( alternativeTempFile2.startsWith( alternative_tempFolder2 ) );
settings.setValue( QStringLiteral( "Processing/Configuration/TEMP_PATH2" ), QString() );
QgsProcessing::settingsTempPath.setValue( QString() );
}
@ -11529,10 +11529,8 @@ void TestQgsProcessing::defaultExtensionsForProvider()
QCOMPARE( context.preferredRasterFormat(), QStringLiteral( "tif" ) );
// unless the user has set a default format, which IS supported by that provider
QgsSettings settings;
settings.setValue( QStringLiteral( "Processing/Configuration/DefaultOutputVectorLayerExt" ), QgsVectorFileWriter::supportedFormatExtensions().indexOf( QLatin1String( "tab" ) ) );
settings.setValue( QStringLiteral( "Processing/Configuration/DefaultOutputRasterLayerExt" ), QgsRasterFileWriter::supportedFormatExtensions().indexOf( QLatin1String( "sdat" ) ) );
QgsProcessing::settingsDefaultOutputVectorLayerExt.setValue( QgsVectorFileWriter::supportedFormatExtensions().indexOf( QLatin1String( "tab" ) ) );
QgsProcessing::settingsDefaultOutputRasterLayerExt.setValue( QgsRasterFileWriter::supportedFormatExtensions().indexOf( QLatin1String( "sdat" ) ) );
QCOMPARE( provider.defaultVectorFileExtension( true ), QStringLiteral( "tab" ) );
QCOMPARE( provider.defaultRasterFileExtension(), QStringLiteral( "sdat" ) );
@ -11543,8 +11541,8 @@ void TestQgsProcessing::defaultExtensionsForProvider()
QCOMPARE( context2.preferredRasterFormat(), QStringLiteral( "sdat" ) );
// but if default is not supported by provider, we use a supported format
settings.setValue( QStringLiteral( "Processing/Configuration/DefaultOutputVectorLayerExt" ), QgsVectorFileWriter::supportedFormatExtensions().indexOf( QLatin1String( "gpkg" ) ) );
settings.setValue( QStringLiteral( "Processing/Configuration/DefaultOutputRasterLayerExt" ), QgsRasterFileWriter::supportedFormatExtensions().indexOf( QLatin1String( "ecw" ) ) );
QgsProcessing::settingsDefaultOutputVectorLayerExt.setValue( QgsVectorFileWriter::supportedFormatExtensions().indexOf( QLatin1String( "gpkg" ) ) );
QgsProcessing::settingsDefaultOutputRasterLayerExt.setValue( QgsRasterFileWriter::supportedFormatExtensions().indexOf( QLatin1String( "ecw" ) ) );
QCOMPARE( provider.defaultVectorFileExtension( true ), QStringLiteral( "mif" ) );
QCOMPARE( provider.defaultRasterFileExtension(), QStringLiteral( "mig" ) );
}

3
tests/src/app/testqgsgpsinformationwidget.cpp
View File

@ -20,6 +20,7 @@
#include "qgsvectorlayer.h"
#include "qgsproject.h"
#include "qgsmapcanvas.h"
#include "qgssettingsregistrycore.h"
#include "gps/qgsgpsinformationwidget.h"
#include "nmeatime.h"
@ -86,7 +87,7 @@ void TestQgsGpsInformationWidget::initTestCase()
QStringLiteral( "vl4" ),
QStringLiteral( "memory" ) );
QgsSettings().setValue( QStringLiteral( "qgis/digitizing/disable_enter_attribute_values_dialog" ), true );
QgsSettingsRegistryCore::settingsDigitizingDisableEnterAttributeValuesDialog.setValue( true );
QString tempPath = QDir::tempPath() + QStringLiteral( "/gps_timestamp.gpkg" );
QFile::copy( TEST_DATA_DIR + QStringLiteral( "/gps_timestamp.gpkg" ), tempPath );

29
tests/src/app/testqgsmaptooladdfeatureline.cpp
View File

@ -24,7 +24,7 @@
#include "qgsmaptooladdfeature.h"
#include "qgsmapcanvastracer.h"
#include "qgsproject.h"
#include "qgssettings.h"
#include "qgssettingsregistrycore.h"
#include "qgsvectorlayer.h"
#include "qgswkbtypes.h"
#include "qgsmapmouseevent.h"
@ -461,7 +461,7 @@ void TestQgsMapToolAddFeatureLine::testTracingWithConvertToCurves()
QSet<QgsFeatureId> oldFids = utils.existingFeatureIds();
// tracing enabled - without converting to curves
QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/convert_to_curve" ), false );
QgsSettingsRegistryCore::settingsDigitizingConvertToCurve.setValue( false );
utils.mouseClick( 6, 1, Qt::LeftButton );
utils.mouseClick( 7, 1, Qt::LeftButton );
@ -477,7 +477,7 @@ void TestQgsMapToolAddFeatureLine::testTracingWithConvertToCurves()
mLayerLineCurved->undoStack()->undo();
// we redo the same with convert to curves enabled
QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/convert_to_curve" ), true );
QgsSettingsRegistryCore::settingsDigitizingConvertToCurve.setValue( true );
// tracing enabled - without converting to curves
utils.mouseClick( 6, 1, Qt::LeftButton );
@ -506,8 +506,8 @@ void TestQgsMapToolAddFeatureLine::testTracingWithConvertToCurvesCustomTolerance
// At this distance, the arcs aren't correctly detected with the default tolerance
double offset = 100000000; // remember to change the feature geometry accordingly in initTestCase (sic)
QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/convert_to_curve_angle_tolerance" ), 1e-5 );
QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/convert_to_curve_distance_tolerance" ), 1e-5 );
QgsSettingsRegistryCore::settingsDigitizingConvertToCurveAngleTolerance.setValue( 1e-5 );
QgsSettingsRegistryCore::settingsDigitizingConvertToCurveDistanceTolerance.setValue( 1e-5 );
mCanvas->setExtent( QgsRectangle( offset + 0, offset + 0, offset + 8, offset + 8 ) );
QCOMPARE( mCanvas->mapSettings().visibleExtent(), QgsRectangle( offset + 0, offset + 0, offset + 8, offset + 8 ) );
@ -522,7 +522,7 @@ void TestQgsMapToolAddFeatureLine::testTracingWithConvertToCurvesCustomTolerance
QSet<QgsFeatureId> oldFids = utils.existingFeatureIds();
// tracing enabled - without converting to curves
QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/convert_to_curve" ), false );
QgsSettingsRegistryCore::settingsDigitizingConvertToCurve.setValue( false );
utils.mouseClick( offset + 6, offset + 1, Qt::LeftButton );
utils.mouseClick( offset + 7, offset + 1, Qt::LeftButton );
@ -538,7 +538,7 @@ void TestQgsMapToolAddFeatureLine::testTracingWithConvertToCurvesCustomTolerance
mLayerLineCurvedOffset->undoStack()->undo();
// we redo the same with convert to curves enabled
QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/convert_to_curve" ), true );
QgsSettingsRegistryCore::settingsDigitizingConvertToCurve.setValue( true );
// tracing enabled - without converting to curves
utils.mouseClick( offset + 6, offset + 1, Qt::LeftButton );
@ -572,7 +572,7 @@ void TestQgsMapToolAddFeatureLine::testZ()
mCanvas->setCurrentLayer( mLayerLineZ );
// test with default Z value = 333
QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/default_z_value" ), 333 );
QgsSettingsRegistryCore::settingsDigitizingDefaultZValue.setValue( 333 );
QSet<QgsFeatureId> oldFids = utils.existingFeatureIds();
utils.mouseClick( 4, 0, Qt::LeftButton );
@ -588,7 +588,7 @@ void TestQgsMapToolAddFeatureLine::testZ()
mLayerLine->undoStack()->undo();
// test with default Z value = 222
QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/default_z_value" ), 222 );
QgsSettingsRegistryCore::settingsDigitizingDefaultZValue.setValue( 222 );
oldFids = utils.existingFeatureIds();
utils.mouseClick( 4, 0, Qt::LeftButton );
@ -633,7 +633,7 @@ void TestQgsMapToolAddFeatureLine::testZMSnapping()
mCanvas->setCurrentLayer( mLayerLineZ );
oldFids = utils.existingFeatureIds();
// test with default Z value = 222
QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/default_z_value" ), 222 );
QgsSettingsRegistryCore::settingsDigitizingDefaultZValue.setValue( 222 );
// snap a on a layer without ZM support
utils.mouseClick( 9, 9, Qt::LeftButton, Qt::KeyboardModifiers(), true );
utils.mouseClick( 8, 7, Qt::LeftButton );
@ -656,7 +656,7 @@ void TestQgsMapToolAddFeatureLine::testZMSnapping()
mCanvas->snappingUtils()->setConfig( cfg );
// create geometry will be snapped
QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/default_z_value" ), 123 );
QgsSettingsRegistryCore::settingsDigitizingDefaultZValue.setValue( 123 );
oldFids = utils.existingFeatureIds();
utils.mouseClick( 20, 20, Qt::LeftButton, Qt::KeyboardModifiers(), true );
@ -668,7 +668,7 @@ void TestQgsMapToolAddFeatureLine::testZMSnapping()
wkt = "LineStringZ (20 20 123, 30 20 123)";
QCOMPARE( mLayerLineZ->getFeature( newFid ).geometry(), QgsGeometry::fromWkt( wkt ) );
QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/default_z_value" ), 321 );
QgsSettingsRegistryCore::settingsDigitizingDefaultZValue.setValue( 321 );
oldFids = utils.existingFeatureIds();
utils.mouseClick( 25, 20, Qt::LeftButton, Qt::KeyboardModifiers(), true );
utils.mouseClick( 25, 25, Qt::LeftButton );
@ -693,7 +693,7 @@ void TestQgsMapToolAddFeatureLine::testTopologicalEditingZ()
mCanvas->setCurrentLayer( mLayerTopoZ );
// test with default Z value = 333
QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/default_z_value" ), 333 );
QgsSettingsRegistryCore::settingsDigitizingDefaultZValue.setValue( 333 );
QSet<QgsFeatureId> oldFids = utils.existingFeatureIds();
@ -995,8 +995,7 @@ void TestQgsMapToolAddFeatureLine::testUndo()
void TestQgsMapToolAddFeatureLine::testStreamTolerance()
{
// test streaming mode digitizing with tolerance
QgsSettings settings;
settings.setValue( QStringLiteral( "/qgis/digitizing/stream_tolerance" ), 10 );
QgsSettingsRegistryCore::settingsDigitizingStreamTolerance.setValue( 10 );
TestQgsMapToolAdvancedDigitizingUtils utils( mCaptureTool );

6
tests/src/app/testqgsmaptooladdfeaturepoint.cpp
View File

@ -25,7 +25,7 @@
#include "qgsmaptooladdfeature.h"
#include "qgsmapcanvastracer.h"
#include "qgsproject.h"
#include "qgssettings.h"
#include "qgssettingsregistrycore.h"
#include "qgsvectorlayer.h"
#include "qgsmapmouseevent.h"
#include "testqgsmaptoolutils.h"
@ -158,7 +158,7 @@ void TestQgsMapToolAddFeaturePoint::testPointZ()
TestQgsMapToolAdvancedDigitizingUtils utils( mCaptureTool );
// test with default Z value = 333
QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/default_z_value" ), 333 );
QgsSettingsRegistryCore::settingsDigitizingDefaultZValue.setValue( 333 );
QSet<QgsFeatureId> oldFids = utils.existingFeatureIds();
@ -190,7 +190,7 @@ void TestQgsMapToolAddFeaturePoint::testTopologicalEditingZ()
TestQgsMapToolAdvancedDigitizingUtils utils( mCaptureTool );
// test with default Z value = 333
QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/default_z_value" ), 333 );
QgsSettingsRegistryCore::settingsDigitizingDefaultZValue.setValue( 333 );
QSet<QgsFeatureId> oldFids = utils.existingFeatureIds();

26
tests/src/app/testqgsmaptoolcircle.cpp
View File

@ -18,7 +18,7 @@
#include "qgisapp.h"
#include "qgsgeometry.h"
#include "qgsmapcanvas.h"
#include "qgssettings.h"
#include "qgssettingsregistrycore.h"
#include "qgsvectorlayer.h"
#include "qgsmaptooladdfeature.h"
@ -86,7 +86,7 @@ void TestQgsMapToolCircle::cleanupTestCase()
void TestQgsMapToolCircle::testCircleFrom2Points()
{
QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/default_z_value" ), 333 );
QgsSettingsRegistryCore::settingsDigitizingDefaultZValue.setValue( 333 );
mLayer->startEditing();
QgsMapToolCircle2Points mapTool( mParentTool, mCanvas );
@ -105,12 +105,12 @@ void TestQgsMapToolCircle::testCircleFrom2Points()
QCOMPARE( f.geometry().asWkt(), wkt );
mLayer->rollBack();
QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/default_z_value" ), 0 );
QgsSettingsRegistryCore::settingsDigitizingDefaultZValue.setValue( 0 );
}
void TestQgsMapToolCircle::testCircleFrom2PointsWithDeletedVertex()
{
QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/default_z_value" ), 333 );
QgsSettingsRegistryCore::settingsDigitizingDefaultZValue.setValue( 333 );
mLayer->startEditing();
QgsMapToolCircle2Points mapTool( mParentTool, mCanvas );
@ -132,12 +132,12 @@ void TestQgsMapToolCircle::testCircleFrom2PointsWithDeletedVertex()
QCOMPARE( f.geometry().asWkt(), wkt );
mLayer->rollBack();
QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/default_z_value" ), 0 );
QgsSettingsRegistryCore::settingsDigitizingDefaultZValue.setValue( 0 );
}
void TestQgsMapToolCircle::testCircleFrom3Points()
{
QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/default_z_value" ), 111 );
QgsSettingsRegistryCore::settingsDigitizingDefaultZValue.setValue( 111 );
mLayer->startEditing();
QgsMapToolCircle3Points mapTool( mParentTool, mCanvas );
@ -157,12 +157,12 @@ void TestQgsMapToolCircle::testCircleFrom3Points()
QCOMPARE( f.geometry().asWkt(), wkt );
mLayer->rollBack();
QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/default_z_value" ), 0 );
QgsSettingsRegistryCore::settingsDigitizingDefaultZValue.setValue( 0 );
}
void TestQgsMapToolCircle::testCircleFrom3PointsWithDeletedVertex()
{
QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/default_z_value" ), 111 );
QgsSettingsRegistryCore::settingsDigitizingDefaultZValue.setValue( 111 );
mLayer->startEditing();
QgsMapToolCircle3Points mapTool( mParentTool, mCanvas );
@ -184,12 +184,12 @@ void TestQgsMapToolCircle::testCircleFrom3PointsWithDeletedVertex()
QCOMPARE( f.geometry().asWkt(), wkt );
mLayer->rollBack();
QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/default_z_value" ), 0 );
QgsSettingsRegistryCore::settingsDigitizingDefaultZValue.setValue( 0 );
}
void TestQgsMapToolCircle::testCircleFromCenterPoint()
{
QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/default_z_value" ), 222 );
QgsSettingsRegistryCore::settingsDigitizingDefaultZValue.setValue( 222 );
mLayer->startEditing();
QgsMapToolCircleCenterPoint mapTool( mParentTool, mCanvas );
@ -208,12 +208,12 @@ void TestQgsMapToolCircle::testCircleFromCenterPoint()
QCOMPARE( f.geometry().asWkt(), wkt );
mLayer->rollBack();
QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/default_z_value" ), 0 );
QgsSettingsRegistryCore::settingsDigitizingDefaultZValue.setValue( 0 );
}
void TestQgsMapToolCircle::testCircleFromCenterPointWithDeletedVertex()
{
QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/default_z_value" ), 222 );
QgsSettingsRegistryCore::settingsDigitizingDefaultZValue.setValue( 222 );
mLayer->startEditing();
QgsMapToolCircleCenterPoint mapTool( mParentTool, mCanvas );
@ -235,7 +235,7 @@ void TestQgsMapToolCircle::testCircleFromCenterPointWithDeletedVertex()
QCOMPARE( f.geometry().asWkt(), wkt );
mLayer->rollBack();
QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/default_z_value" ), 0 );
QgsSettingsRegistryCore::settingsDigitizingDefaultZValue.setValue( 0 );
}
QGSTEST_MAIN( TestQgsMapToolCircle )

22
tests/src/app/testqgsmaptoolcircularstring.cpp
View File

@ -18,7 +18,7 @@
#include "qgisapp.h"
#include "qgsgeometry.h"
#include "qgsmapcanvas.h"
#include "qgssettings.h"
#include "qgssettingsregistrycore.h"
#include "qgsvectorlayer.h"
#include "qgsmaptooladdfeature.h"
@ -84,7 +84,7 @@ void TestQgsMapToolCircularString::cleanupTestCase()
void TestQgsMapToolCircularString::testAddCircularStringCurvePoint()
{
QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/default_z_value" ), 333 );
QgsSettingsRegistryCore::settingsDigitizingDefaultZValue.setValue( 333 );
mLayer->startEditing();
QgsMapToolCircularStringCurvePoint mapTool( mParentTool, mCanvas );
@ -104,12 +104,12 @@ void TestQgsMapToolCircularString::testAddCircularStringCurvePoint()
QCOMPARE( f.geometry().asWkt(), wkt );
mLayer->rollBack();
QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/default_z_value" ), 0 );
QgsSettingsRegistryCore::settingsDigitizingDefaultZValue.setValue( 0 );
}
void TestQgsMapToolCircularString::testAddCircularStringCurvePointWithDeletedVertex()
{
QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/default_z_value" ), 333 );
QgsSettingsRegistryCore::settingsDigitizingDefaultZValue.setValue( 333 );
mLayer->startEditing();
QgsMapToolCircularStringCurvePoint mapTool( mParentTool, mCanvas );
@ -133,11 +133,11 @@ void TestQgsMapToolCircularString::testAddCircularStringCurvePointWithDeletedVer
QCOMPARE( f.geometry().asWkt(), wkt );
mLayer->rollBack();
QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/default_z_value" ), 0 );
QgsSettingsRegistryCore::settingsDigitizingDefaultZValue.setValue( 0 );
}
void TestQgsMapToolCircularString::testAddCircularStringRadius()
{
QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/default_z_value" ), 111 );
QgsSettingsRegistryCore::settingsDigitizingDefaultZValue.setValue( 111 );
mLayer->startEditing();
QgsMapToolCircularStringRadius mapTool( mParentTool, mCanvas );
@ -157,12 +157,12 @@ void TestQgsMapToolCircularString::testAddCircularStringRadius()
QCOMPARE( f.geometry().asWkt(), wkt );
mLayer->rollBack();
QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/default_z_value" ), 0 );
QgsSettingsRegistryCore::settingsDigitizingDefaultZValue.setValue( 0 );
}
void TestQgsMapToolCircularString::testAddCircularStringRadiusWithDeletedVertex()
{
QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/default_z_value" ), 111 );
QgsSettingsRegistryCore::settingsDigitizingDefaultZValue.setValue( 111 );
mLayer->startEditing();
QgsMapToolCircularStringRadius mapTool( mParentTool, mCanvas );
@ -186,12 +186,12 @@ void TestQgsMapToolCircularString::testAddCircularStringRadiusWithDeletedVertex(
QCOMPARE( f.geometry().asWkt(), wkt );
mLayer->rollBack();
QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/default_z_value" ), 0 );
QgsSettingsRegistryCore::settingsDigitizingDefaultZValue.setValue( 0 );
}
void TestQgsMapToolCircularString::testAddCircularStringAfterClassicDigitizing()
{
QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/default_z_value" ), 333 );
QgsSettingsRegistryCore::settingsDigitizingDefaultZValue.setValue( 333 );
mLayer->startEditing();
TestQgsMapToolAdvancedDigitizingUtils utilsClassic( mParentTool );
@ -224,7 +224,7 @@ void TestQgsMapToolCircularString::testAddCircularStringAfterClassicDigitizing()
QCOMPARE( f.geometry().asWkt(), wkt );
mLayer->rollBack();
QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/default_z_value" ), 0 );
QgsSettingsRegistryCore::settingsDigitizingDefaultZValue.setValue( 0 );
}
QGSTEST_MAIN( TestQgsMapToolCircularString )
#include "testqgsmaptoolcircularstring.moc"

34
tests/src/app/testqgsmaptoolellipse.cpp
View File

@ -18,7 +18,7 @@
#include "qgisapp.h"
#include "qgsgeometry.h"
#include "qgsmapcanvas.h"
#include "qgssettings.h"
#include "qgssettingsregistrycore.h"
#include "qgsvectorlayer.h"
#include "qgsmaptooladdfeature.h"
#include "qgsgeometryutils.h"
@ -90,7 +90,7 @@ void TestQgsMapToolEllipse::cleanupTestCase()
void TestQgsMapToolEllipse::testEllipseFromCenterAndPoint()
{
QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/default_z_value" ), 333 );
QgsSettingsRegistryCore::settingsDigitizingDefaultZValue.setValue( 333 );
mLayer->startEditing();
QgsMapToolEllipseCenterPoint mapTool( mParentTool, mCanvas );
@ -114,11 +114,11 @@ void TestQgsMapToolEllipse::testEllipseFromCenterAndPoint()
}
mLayer->rollBack();
QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/default_z_value" ), 0 );
QgsSettingsRegistryCore::settingsDigitizingDefaultZValue.setValue( 0 );
}
void TestQgsMapToolEllipse::testEllipseFromCenterAndPointWithDeletedVertex()
{
QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/default_z_value" ), 333 );
QgsSettingsRegistryCore::settingsDigitizingDefaultZValue.setValue( 333 );
mLayer->startEditing();
QgsMapToolEllipseCenterPoint mapTool( mParentTool, mCanvas );
@ -144,13 +144,13 @@ void TestQgsMapToolEllipse::testEllipseFromCenterAndPointWithDeletedVertex()
}
mLayer->rollBack();
QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/default_z_value" ), 0 );
QgsSettingsRegistryCore::settingsDigitizingDefaultZValue.setValue( 0 );
}
void TestQgsMapToolEllipse::testEllipseFromCenterAnd2Points()
{
QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/default_z_value" ), 111 );
QgsSettingsRegistryCore::settingsDigitizingDefaultZValue.setValue( 111 );
mLayer->startEditing();
QgsMapToolEllipseCenter2Points mapTool( mParentTool, mCanvas );
@ -175,12 +175,12 @@ void TestQgsMapToolEllipse::testEllipseFromCenterAnd2Points()
}
mLayer->rollBack();
QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/default_z_value" ), 0 );
QgsSettingsRegistryCore::settingsDigitizingDefaultZValue.setValue( 0 );
}
void TestQgsMapToolEllipse::testEllipseFromCenterAnd2PointsWithDeletedVertex()
{
QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/default_z_value" ), 111 );
QgsSettingsRegistryCore::settingsDigitizingDefaultZValue.setValue( 111 );
mLayer->startEditing();
QgsMapToolEllipseCenter2Points mapTool( mParentTool, mCanvas );
@ -207,12 +207,12 @@ void TestQgsMapToolEllipse::testEllipseFromCenterAnd2PointsWithDeletedVertex()
}
mLayer->rollBack();
QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/default_z_value" ), 0 );
QgsSettingsRegistryCore::settingsDigitizingDefaultZValue.setValue( 0 );
}
void TestQgsMapToolEllipse::testEllipseFromExtent()
{
QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/default_z_value" ), 222 );
QgsSettingsRegistryCore::settingsDigitizingDefaultZValue.setValue( 222 );
mLayer->startEditing();
QgsMapToolEllipseExtent mapTool( mParentTool, mCanvas );
@ -236,12 +236,12 @@ void TestQgsMapToolEllipse::testEllipseFromExtent()
}
mLayer->rollBack();
QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/default_z_value" ), 0 );
QgsSettingsRegistryCore::settingsDigitizingDefaultZValue.setValue( 0 );
}
void TestQgsMapToolEllipse::testEllipseFromExtentWithDeletedVertex()
{
QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/default_z_value" ), 222 );
QgsSettingsRegistryCore::settingsDigitizingDefaultZValue.setValue( 222 );
mLayer->startEditing();
QgsMapToolEllipseExtent mapTool( mParentTool, mCanvas );
@ -267,12 +267,12 @@ void TestQgsMapToolEllipse::testEllipseFromExtentWithDeletedVertex()
}
mLayer->rollBack();
QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/default_z_value" ), 0 );
QgsSettingsRegistryCore::settingsDigitizingDefaultZValue.setValue( 0 );
}
void TestQgsMapToolEllipse::testEllipseFromFoci()
{
QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/default_z_value" ), 444 );
QgsSettingsRegistryCore::settingsDigitizingDefaultZValue.setValue( 444 );
mLayer->startEditing();
QgsMapToolEllipseFoci mapTool( mParentTool, mCanvas );
@ -297,12 +297,12 @@ void TestQgsMapToolEllipse::testEllipseFromFoci()
}
mLayer->rollBack();
QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/default_z_value" ), 0 );
QgsSettingsRegistryCore::settingsDigitizingDefaultZValue.setValue( 0 );
}
void TestQgsMapToolEllipse::testEllipseFromFociWithDeletedVertex()
{
QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/default_z_value" ), 444 );
QgsSettingsRegistryCore::settingsDigitizingDefaultZValue.setValue( 444 );
mLayer->startEditing();
QgsMapToolEllipseFoci mapTool( mParentTool, mCanvas );
@ -329,7 +329,7 @@ void TestQgsMapToolEllipse::testEllipseFromFociWithDeletedVertex()
}
mLayer->rollBack();
QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/default_z_value" ), 0 );
QgsSettingsRegistryCore::settingsDigitizingDefaultZValue.setValue( 0 );
}
QGSTEST_MAIN( TestQgsMapToolEllipse )

34
tests/src/app/testqgsmaptoolrectangle.cpp
View File

@ -18,7 +18,7 @@
#include "qgisapp.h"
#include "qgsgeometry.h"
#include "qgsmapcanvas.h"
#include "qgssettings.h"
#include "qgssettingsregistrycore.h"
#include "qgsvectorlayer.h"
#include "qgsmaptooladdfeature.h"
#include "qgsgeometryutils.h"
@ -89,7 +89,7 @@ void TestQgsMapToolRectangle::cleanupTestCase()
void TestQgsMapToolRectangle::testRectangleFromCenter()
{
QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/default_z_value" ), 333 );
QgsSettingsRegistryCore::settingsDigitizingDefaultZValue.setValue( 333 );
mLayer->startEditing();
QgsMapToolRectangleCenter mapTool( mParentTool, mCanvas );
@ -110,12 +110,12 @@ void TestQgsMapToolRectangle::testRectangleFromCenter()
QVERIFY( static_cast<QgsLineString *>( f.geometry().get() )->equals( line ) );
mLayer->rollBack();
QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/default_z_value" ), 0 );
QgsSettingsRegistryCore::settingsDigitizingDefaultZValue.setValue( 0 );
}
void TestQgsMapToolRectangle::testRectangleFromCenterWithDeletedVertex()
{
QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/default_z_value" ), 333 );
QgsSettingsRegistryCore::settingsDigitizingDefaultZValue.setValue( 333 );
mLayer->startEditing();
QgsMapToolRectangleCenter mapTool( mParentTool, mCanvas );
@ -138,12 +138,12 @@ void TestQgsMapToolRectangle::testRectangleFromCenterWithDeletedVertex()
QVERIFY( static_cast<QgsLineString *>( f.geometry().get() )->equals( line ) );
mLayer->rollBack();
QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/default_z_value" ), 0 );
QgsSettingsRegistryCore::settingsDigitizingDefaultZValue.setValue( 0 );
}
void TestQgsMapToolRectangle::testRectangleFromExtent()
{
QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/default_z_value" ), 222 );
QgsSettingsRegistryCore::settingsDigitizingDefaultZValue.setValue( 222 );
mLayer->startEditing();
QgsMapToolRectangleExtent mapTool( mParentTool, mCanvas );
@ -164,11 +164,11 @@ void TestQgsMapToolRectangle::testRectangleFromExtent()
QVERIFY( static_cast<QgsLineString *>( f.geometry().get() )->equals( line ) );
mLayer->rollBack();
QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/default_z_value" ), 0 );
QgsSettingsRegistryCore::settingsDigitizingDefaultZValue.setValue( 0 );
}
void TestQgsMapToolRectangle::testRectangleFromExtentWithDeletedVertex()
{
QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/default_z_value" ), 222 );
QgsSettingsRegistryCore::settingsDigitizingDefaultZValue.setValue( 222 );
mLayer->startEditing();
QgsMapToolRectangleExtent mapTool( mParentTool, mCanvas );
@ -191,13 +191,13 @@ void TestQgsMapToolRectangle::testRectangleFromExtentWithDeletedVertex()
QVERIFY( static_cast<QgsLineString *>( f.geometry().get() )->equals( line ) );
mLayer->rollBack();
QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/default_z_value" ), 0 );
QgsSettingsRegistryCore::settingsDigitizingDefaultZValue.setValue( 0 );
}
void TestQgsMapToolRectangle::testRectangleFrom3PointsDistance()
{
QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/default_z_value" ), 111 );
QgsSettingsRegistryCore::settingsDigitizingDefaultZValue.setValue( 111 );
mLayer->startEditing();
QgsMapToolRectangle3Points mapTool( mParentTool, mCanvas, QgsMapToolRectangle3Points::DistanceMode );
@ -220,11 +220,11 @@ void TestQgsMapToolRectangle::testRectangleFrom3PointsDistance()
QVERIFY( static_cast<QgsLineString *>( f.geometry().get() )->equals( line ) );
mLayer->rollBack();
QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/default_z_value" ), 0 );
QgsSettingsRegistryCore::settingsDigitizingDefaultZValue.setValue( 0 );
}
void TestQgsMapToolRectangle::testRectangleFrom3PointsDistanceWithDeletedVertex()
{
QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/default_z_value" ), 111 );
QgsSettingsRegistryCore::settingsDigitizingDefaultZValue.setValue( 111 );
mLayer->startEditing();
QgsMapToolRectangle3Points mapTool( mParentTool, mCanvas, QgsMapToolRectangle3Points::DistanceMode );
@ -249,12 +249,12 @@ void TestQgsMapToolRectangle::testRectangleFrom3PointsDistanceWithDeletedVertex(
QVERIFY( static_cast<QgsLineString *>( f.geometry().get() )->equals( line ) );
mLayer->rollBack();
QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/default_z_value" ), 0 );
QgsSettingsRegistryCore::settingsDigitizingDefaultZValue.setValue( 0 );
}
void TestQgsMapToolRectangle::testRectangleFrom3PointsProjected()
{
QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/default_z_value" ), 111 );
QgsSettingsRegistryCore::settingsDigitizingDefaultZValue.setValue( 111 );
mLayer->startEditing();
QgsMapToolRectangle3Points mapTool( mParentTool, mCanvas, QgsMapToolRectangle3Points::ProjectedMode );
@ -277,11 +277,11 @@ void TestQgsMapToolRectangle::testRectangleFrom3PointsProjected()
QVERIFY( static_cast<QgsLineString *>( f.geometry().get() )->equals( line ) );
mLayer->rollBack();
QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/default_z_value" ), 0 );
QgsSettingsRegistryCore::settingsDigitizingDefaultZValue.setValue( 0 );
}
void TestQgsMapToolRectangle::testRectangleFrom3PointsProjectedWithDeletedVertex()
{
QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/default_z_value" ), 111 );
QgsSettingsRegistryCore::settingsDigitizingDefaultZValue.setValue( 111 );
mLayer->startEditing();
QgsMapToolRectangle3Points mapTool( mParentTool, mCanvas, QgsMapToolRectangle3Points::ProjectedMode );
@ -306,7 +306,7 @@ void TestQgsMapToolRectangle::testRectangleFrom3PointsProjectedWithDeletedVertex
QVERIFY( static_cast<QgsLineString *>( f.geometry().get() )->equals( line ) );
mLayer->rollBack();
QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/default_z_value" ), 0 );
QgsSettingsRegistryCore::settingsDigitizingDefaultZValue.setValue( 0 );
}
QGSTEST_MAIN( TestQgsMapToolRectangle )
#include "testqgsmaptoolrectangle.moc"

26
tests/src/app/testqgsmaptoolregularpolygon.cpp
View File

@ -18,7 +18,7 @@
#include "qgisapp.h"
#include "qgsgeometry.h"
#include "qgsmapcanvas.h"
#include "qgssettings.h"
#include "qgssettingsregistrycore.h"
#include "qgsvectorlayer.h"
#include "qgsmaptooladdfeature.h"
#include "qgsgeometryutils.h"
@ -87,7 +87,7 @@ void TestQgsMapToolRegularPolygon::cleanupTestCase()
void TestQgsMapToolRegularPolygon::testRegularPolygonFrom2Points()
{
QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/default_z_value" ), 333 );
QgsSettingsRegistryCore::settingsDigitizingDefaultZValue.setValue( 333 );
mLayer->startEditing();
QgsMapToolRegularPolygon2Points mapTool( mParentTool, mCanvas );
@ -106,11 +106,11 @@ void TestQgsMapToolRegularPolygon::testRegularPolygonFrom2Points()
QCOMPARE( f.geometry().asWkt( 0 ), wkt );
mLayer->rollBack();
QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/default_z_value" ), 0 );
QgsSettingsRegistryCore::settingsDigitizingDefaultZValue.setValue( 0 );
}
void TestQgsMapToolRegularPolygon::testRegularPolygonFrom2PointsWithDeletedVertex()
{
QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/default_z_value" ), 333 );
QgsSettingsRegistryCore::settingsDigitizingDefaultZValue.setValue( 333 );
mLayer->startEditing();
QgsMapToolRegularPolygon2Points mapTool( mParentTool, mCanvas );
@ -131,13 +131,13 @@ void TestQgsMapToolRegularPolygon::testRegularPolygonFrom2PointsWithDeletedVerte
QCOMPARE( f.geometry().asWkt( 0 ), wkt );
mLayer->rollBack();
QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/default_z_value" ), 0 );
QgsSettingsRegistryCore::settingsDigitizingDefaultZValue.setValue( 0 );
}
void TestQgsMapToolRegularPolygon::testRegularPolygonFromCenterAndPoint()
{
QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/default_z_value" ), 222 );
QgsSettingsRegistryCore::settingsDigitizingDefaultZValue.setValue( 222 );
mLayer->startEditing();
QgsMapToolRegularPolygonCenterPoint mapTool( mParentTool, mCanvas );
@ -156,11 +156,11 @@ void TestQgsMapToolRegularPolygon::testRegularPolygonFromCenterAndPoint()
QCOMPARE( f.geometry().asWkt( 0 ), wkt );
mLayer->rollBack();
QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/default_z_value" ), 0 );
QgsSettingsRegistryCore::settingsDigitizingDefaultZValue.setValue( 0 );
}
void TestQgsMapToolRegularPolygon::testRegularPolygonFromCenterAndPointWithDeletedVertex()
{
QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/default_z_value" ), 222 );
QgsSettingsRegistryCore::settingsDigitizingDefaultZValue.setValue( 222 );
mLayer->startEditing();
QgsMapToolRegularPolygonCenterPoint mapTool( mParentTool, mCanvas );
@ -181,13 +181,13 @@ void TestQgsMapToolRegularPolygon::testRegularPolygonFromCenterAndPointWithDelet
QCOMPARE( f.geometry().asWkt( 0 ), wkt );
mLayer->rollBack();
QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/default_z_value" ), 0 );
QgsSettingsRegistryCore::settingsDigitizingDefaultZValue.setValue( 0 );
}
void TestQgsMapToolRegularPolygon::testRegularPolygonFromCenterAndCroner()
{
QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/default_z_value" ), 111 );
QgsSettingsRegistryCore::settingsDigitizingDefaultZValue.setValue( 111 );
mLayer->startEditing();
QgsMapToolRegularPolygonCenterCorner mapTool( mParentTool, mCanvas );
@ -206,11 +206,11 @@ void TestQgsMapToolRegularPolygon::testRegularPolygonFromCenterAndCroner()
QCOMPARE( f.geometry().asWkt( 0 ), wkt );
mLayer->rollBack();
QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/default_z_value" ), 0 );
QgsSettingsRegistryCore::settingsDigitizingDefaultZValue.setValue( 0 );
}
void TestQgsMapToolRegularPolygon::testRegularPolygonFromCenterAndCronerWithDeletedVertex()
{
QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/default_z_value" ), 111 );
QgsSettingsRegistryCore::settingsDigitizingDefaultZValue.setValue( 111 );
mLayer->startEditing();
QgsMapToolRegularPolygonCenterCorner mapTool( mParentTool, mCanvas );
@ -231,7 +231,7 @@ void TestQgsMapToolRegularPolygon::testRegularPolygonFromCenterAndCronerWithDele
QCOMPARE( f.geometry().asWkt( 0 ), wkt );
mLayer->rollBack();
QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/default_z_value" ), 0 );
QgsSettingsRegistryCore::settingsDigitizingDefaultZValue.setValue( 0 );
}

6
tests/src/app/testqgsmaptoolreshape.cpp
View File

@ -24,7 +24,7 @@
#include "qgssnappingutils.h"
#include "qgsmaptoolreshape.h"
#include "qgsproject.h"
#include "qgssettings.h"
#include "qgssettingsregistrycore.h"
#include "qgsvectorlayer.h"
#include "qgsmapmouseevent.h"
#include "testqgsmaptoolutils.h"
@ -191,7 +191,7 @@ void TestQgsMapToolReshape::testReshapeZ()
TestQgsMapToolAdvancedDigitizingUtils utils( mCaptureTool );
// test with default Z value = 333
QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/default_z_value" ), 333 );
QgsSettingsRegistryCore::settingsDigitizingDefaultZValue.setValue( 333 );
// snap on a linestringz layer
utils.mouseClick( 1, 2, Qt::LeftButton, Qt::KeyboardModifiers(), true );
@ -233,7 +233,7 @@ void TestQgsMapToolReshape::testTopologicalEditing()
TestQgsMapToolAdvancedDigitizingUtils utils( mCaptureTool );
// test with default Z value = 333
QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/default_z_value" ), 333 );
QgsSettingsRegistryCore::settingsDigitizingDefaultZValue.setValue( 333 );
utils.mouseClick( 4, 4, Qt::LeftButton, Qt::KeyboardModifiers(), true );
utils.mouseClick( 7, 2, Qt::LeftButton, Qt::KeyboardModifiers(), true );

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

@ -26,7 +26,7 @@
#include "qgslinestring.h"
#include "qgscircularstring.h"
#include "qgssnappingconfig.h"
#include "qgssettings.h"
#include "qgssettingsregistrycore.h"
#include "testqgsmaptoolutils.h"
bool operator==( const QgsGeometry &g1, const QgsGeometry &g2 )
@ -373,7 +373,7 @@ void TestQgsVertexTool::testTopologicalEditingMoveVertexZ()
void TestQgsVertexTool::testTopologicalEditingMoveVertexOnSegmentZ()
{
QgsSettings().setValue( QStringLiteral( "/qgis/digitizing/default_z_value" ), 333 );
QgsSettingsRegistryCore::settingsDigitizingDefaultZValue.setValue( 333 );
bool topologicalEditing = QgsProject::instance()->topologicalEditing();
QgsProject::instance()->setTopologicalEditing( true );

3
tests/src/core/testqgscompositionconverter.cpp
View File

@ -163,8 +163,7 @@ void TestQgsCompositionConverter::initTestCase()
QgsApplication::init();
QgsApplication::initQgis();
mReport = QStringLiteral( "<h1>Layout Tests</h1>\n" );
QgsSettings settings;
settings.setValue( QStringLiteral( "svg/searchPathsForSVG" ), QStringLiteral( TEST_DATA_DIR ) ) ;
QgsApplication::settingsSearchPathsForSVG.setValue( QStringList() << QStringLiteral( TEST_DATA_DIR ) );
}
void TestQgsCompositionConverter::cleanupTestCase()

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

@ -175,7 +175,7 @@ void TestQgsNetworkAccessManager::initTestCase()
QgsApplication::init();
QgsApplication::initQgis();
QgsSettings().setValue( QStringLiteral( "/qgis/networkAndProxy/networkTimeout" ), 5000 );
QgsNetworkAccessManager::settingsNetworkTimeout.setValue( 5000 );
mHttpBinHost = QStringLiteral( "httpbin.org" );
QString overrideHost = qgetenv( "QGIS_HTTPBIN_HOST" );

10
tests/src/core/testqgsnewsfeedparser.cpp
View File

@ -111,12 +111,12 @@ void TestQgsNewsFeedParser::testFetch()
entries.clear();
// after a fetch, the current timestamp should be saved to avoid refetching these
uint after = QgsSettings().value( feedKey + "/lastFetchTime", 0, QgsSettings::Core ).toUInt();
uint after = QgsNewsFeedParser::settingsFeedLastFetchTime.value( feedKey );
QVERIFY( after >= beforeTime );
// reset to a standard known last time
QgsSettings().remove( feedKey, QgsSettings::Core );
QgsSettings().setValue( feedKey + "/lastFetchTime", 1457360008, QgsSettings::Core );
QgsNewsFeedParser::settingsFeedLastFetchTime.setValue( 1457360008, feedKey );
// refetch, only new items should be fetched
QgsNewsFeedParser parser2( url );
@ -230,7 +230,7 @@ void TestQgsNewsFeedParser::testLang()
const QString feedKey = QgsNewsFeedParser::keyForFeed( url.toString() );
QgsSettings().remove( feedKey, QgsSettings::Core );
// force to Spanish language
QgsSettings().setValue( QStringLiteral( "%1/lang" ).arg( feedKey ), QStringLiteral( "es" ), QgsSettings::Core );
QgsNewsFeedParser::settingsFeedLanguage.setValue( QStringLiteral( "es" ), feedKey );
QgsNewsFeedParser parser( url );
QSignalSpy spy( &parser, &QgsNewsFeedParser::entryAdded );
@ -256,8 +256,8 @@ void TestQgsNewsFeedParser::testGeoFencing()
const QUrl url( QUrl::fromLocalFile( QStringLiteral( TEST_DATA_DIR ) + "/newsfeed/feed" ) );
const QString feedKey = QgsNewsFeedParser::keyForFeed( url.toString() );
QgsSettings().remove( feedKey, QgsSettings::Core );
QgsSettings().setValue( QStringLiteral( "%1/latitude" ).arg( feedKey ), 37.2343, QgsSettings::Core );
QgsSettings().setValue( QStringLiteral( "%1/longitude" ).arg( feedKey ), -115.8067, QgsSettings::Core );
QgsNewsFeedParser::settingsFeedLatitude.setValue( 37.2343, feedKey );
QgsNewsFeedParser::settingsFeedLongitude.setValue( -115.8067, feedKey );
QgsNewsFeedParser parser( url );
QSignalSpy spy( &parser, &QgsNewsFeedParser::entryAdded );

8
tests/src/core/testqgssettingsentry.cpp
View File

@ -101,7 +101,7 @@ void TestQgsSettingsEntry::enumValue()
// Make sure the setting is not existing
QgsSettings().remove( settingsKey, QgsSettings::NoSection );
QgsSettingsEntryEnum settingsEntryEnum( settingsKey, QgsSettings::NoSection, QgsUnitTypes::LayoutMeters, QStringLiteral( "Layout unit" ) );
QgsSettingsEntryEnumFlag settingsEntryEnum( settingsKey, QgsSettings::NoSection, QgsUnitTypes::LayoutMeters, QStringLiteral( "Layout unit" ) );
// Check default value
QCOMPARE( settingsEntryEnum.defaultValue(), QgsUnitTypes::LayoutMeters );
@ -119,7 +119,7 @@ void TestQgsSettingsEntry::enumValue()
QCOMPARE( settingsEntryEnum.value(), QgsUnitTypes::LayoutPicas );
// Check settings type
QCOMPARE( settingsEntryEnum.settingsType(), QgsSettingsEntryBase::SettingsType::Enum );
QCOMPARE( settingsEntryEnum.settingsType(), QgsSettingsEntryBase::SettingsType::EnumFlag );
// assign to inexisting value
{
@ -150,7 +150,7 @@ void TestQgsSettingsEntry::flagValue()
// Make sure the setting is not existing
QgsSettings().remove( settingsKey, QgsSettings::NoSection );
QgsSettingsEntryFlag settingsEntryFlag( settingsKey, QgsSettings::NoSection, pointAndLine, QStringLiteral( "Filters" ) );
QgsSettingsEntryEnumFlag settingsEntryFlag( settingsKey, QgsSettings::NoSection, pointAndLine, QStringLiteral( "Filters" ) );
// Check default value
QCOMPARE( settingsEntryFlag.defaultValue(), pointAndLine );
@ -168,7 +168,7 @@ void TestQgsSettingsEntry::flagValue()
QCOMPARE( settingsEntryFlag.value(), pointAndLine );
// Check settings type
QCOMPARE( settingsEntryFlag.settingsType(), QgsSettingsEntryBase::SettingsType::Flag );
QCOMPARE( settingsEntryFlag.settingsType(), QgsSettingsEntryBase::SettingsType::EnumFlag );
// check that value is stored as string
QCOMPARE( settingsEntryFlag.valueAsVariant().toByteArray(), QMetaEnum::fromType<QgsMapLayerProxyModel::Filters>().valueToKeys( pointAndLine ) );

28
tests/src/core/testqgssettingsregistry.cpp
View File

@ -61,9 +61,9 @@ void TestQgsSettingsRegistry::getSettingsEntries()
settingsRegistry.addSettingsEntry( &settingsEntryBool );
settingsRegistry.addSettingsEntry( &settingsEntryInteger );
QCOMPARE( settingsRegistry.getSettingsEntry( settingsEntryBoolKey ), &settingsEntryBool );
QCOMPARE( settingsRegistry.getSettingsEntry( settingsEntryIntegerKey ), &settingsEntryInteger );
QCOMPARE( settingsRegistry.getSettingsEntry( settingsEntryInexisting ), nullptr );
QCOMPARE( settingsRegistry.settingsEntry( settingsEntryBoolKey ), &settingsEntryBool );
QCOMPARE( settingsRegistry.settingsEntry( settingsEntryIntegerKey ), &settingsEntryInteger );
QCOMPARE( settingsRegistry.settingsEntry( settingsEntryInexisting ), nullptr );
}
void TestQgsSettingsRegistry::getSettingsEntriesWithDynamicKeys()
@ -82,13 +82,13 @@ void TestQgsSettingsRegistry::getSettingsEntriesWithDynamicKeys()
settingsRegistry.addSettingsEntry( &settingsEntryInteger );
settingsRegistry.addSettingsEntry( &settingsEntryDouble );
QCOMPARE( settingsRegistry.getSettingsEntry( settingsEntryBoolKey ), &settingsEntryBool );
QCOMPARE( settingsRegistry.getSettingsEntry( settingsEntryBoolKey.replace( QStringLiteral( "%1" ), QStringLiteral( "1st" ) ) ), &settingsEntryBool );
QCOMPARE( settingsRegistry.getSettingsEntry( settingsEntryIntegerKey ), &settingsEntryInteger );
QCOMPARE( settingsRegistry.getSettingsEntry( settingsEntryIntegerKey.replace( QStringLiteral( "%1" ), QStringLiteral( "Second" ) ) ), &settingsEntryInteger );
QCOMPARE( settingsRegistry.getSettingsEntry( settingsEntryDoubleKey ), &settingsEntryDouble );
QCOMPARE( settingsRegistry.getSettingsEntry( settingsEntryDoubleKey.replace( QStringLiteral( "%1" ), QStringLiteral( "1st" ) ).replace( QStringLiteral( "%2" ), QStringLiteral( "2nd" ) ) ), &settingsEntryDouble );
QCOMPARE( settingsRegistry.getSettingsEntry( settingsEntryInexisting ), nullptr );
QCOMPARE( settingsRegistry.settingsEntry( settingsEntryBoolKey ), &settingsEntryBool );
QCOMPARE( settingsRegistry.settingsEntry( settingsEntryBoolKey.replace( QStringLiteral( "%1" ), QStringLiteral( "1st" ) ) ), &settingsEntryBool );
QCOMPARE( settingsRegistry.settingsEntry( settingsEntryIntegerKey ), &settingsEntryInteger );
QCOMPARE( settingsRegistry.settingsEntry( settingsEntryIntegerKey.replace( QStringLiteral( "%1" ), QStringLiteral( "Second" ) ) ), &settingsEntryInteger );
QCOMPARE( settingsRegistry.settingsEntry( settingsEntryDoubleKey ), &settingsEntryDouble );
QCOMPARE( settingsRegistry.settingsEntry( settingsEntryDoubleKey.replace( QStringLiteral( "%1" ), QStringLiteral( "1st" ) ).replace( QStringLiteral( "%2" ), QStringLiteral( "2nd" ) ) ), &settingsEntryDouble );
QCOMPARE( settingsRegistry.settingsEntry( settingsEntryInexisting ), nullptr );
}
void TestQgsSettingsRegistry::childRegistry()
@ -103,14 +103,14 @@ void TestQgsSettingsRegistry::childRegistry()
SettingsRegistryTest settingsRegistry;
settingsRegistry.addSettingsEntry( &settingsEntryBool );
settingsRegistry.appendRegistry( nullptr ); // should not crash
settingsRegistry.appendRegistry( &settingsRegistryChild );
settingsRegistry.addSubRegistry( nullptr ); // should not crash
settingsRegistry.addSubRegistry( &settingsRegistryChild );
// Search only in parent
QCOMPARE( settingsRegistry.getSettingsEntry( settingsEntryIntegerKey, false ), nullptr );
QCOMPARE( settingsRegistry.settingsEntry( settingsEntryIntegerKey, false ), nullptr );
// Search including child registries
QCOMPARE( settingsRegistry.getSettingsEntry( settingsEntryIntegerKey, true ), &settingsEntryInteger );
QCOMPARE( settingsRegistry.settingsEntry( settingsEntryIntegerKey, true ), &settingsEntryInteger );
}
QGSTEST_MAIN( TestQgsSettingsRegistry )

9
tests/src/core/testqgstranslateproject.cpp
View File

@ -47,7 +47,6 @@ class TestQgsTranslateProject : public QObject
void translateProject();
private:
QgsSettings settings;
QString original_locale;
};
@ -58,12 +57,12 @@ void TestQgsTranslateProject::initTestCase()
QgsApplication::init();
QgsApplication::initQgis();
original_locale = settings.value( QStringLiteral( "locale/userLocale" ), "" ).toString() ;
original_locale = QgsApplication::settingsLocaleUserLocale.value();
}
void TestQgsTranslateProject::cleanupTestCase()
{
settings.setValue( QStringLiteral( "locale/userLocale" ), original_locale );
QgsApplication::settingsLocaleUserLocale.setValue( original_locale );
QgsApplication::exitQgis();
//delete translated project file
@ -92,7 +91,7 @@ void TestQgsTranslateProject::cleanup()
void TestQgsTranslateProject::createTsFile()
{
//open project in english
settings.setValue( QStringLiteral( "locale/userLocale" ), "en" );
QgsApplication::settingsLocaleUserLocale.setValue( "en" );
QString projectFileName( TEST_DATA_DIR );
projectFileName = projectFileName + "/project_translation/points_translation.qgs";
QgsProject::instance()->read( projectFileName );
@ -164,7 +163,7 @@ void TestQgsTranslateProject::createTsFile()
void TestQgsTranslateProject::translateProject()
{
//open project in german
settings.setValue( QStringLiteral( "locale/userLocale" ), "de" );
QgsApplication::settingsLocaleUserLocale.setValue( "de" );
QString projectFileName( TEST_DATA_DIR );
projectFileName = projectFileName + "/project_translation/points_translation.qgs";
QgsProject::instance()->read( projectFileName );

7
tests/src/gui/testqgsmaptooledit.cpp
View File

@ -20,7 +20,7 @@
#include "qgsapplication.h"
#include "qgsmapcanvas.h"
#include "qgslogger.h"
#include "qgssettings.h"
#include "qgssettingsregistrycore.h"
class TestQgsMapToolEdit : public QObject
{
@ -65,14 +65,13 @@ void TestQgsMapToolEdit::cleanup()
void TestQgsMapToolEdit::checkDefaultZValue()
{
QgsSettings settings;
settings.remove( QStringLiteral( "/qgis/digitizing/default_z_value" ) );
QgsSettingsRegistryCore::settingsDigitizingDefaultZValue.remove();
QgsMapToolEdit *tool = new QgsMapToolEdit( mCanvas );
QCOMPARE( tool->defaultZValue(), Qgis::DEFAULT_Z_COORDINATE );
double z_value_for_test = Qgis::DEFAULT_Z_COORDINATE + 1;
settings.setValue( QStringLiteral( "/qgis/digitizing/default_z_value" ), z_value_for_test );
QgsSettingsRegistryCore::settingsDigitizingDefaultZValue.setValue( z_value_for_test );
QCOMPARE( tool->defaultZValue(), z_value_for_test );
}

10
tests/src/python/test_qgssettingsentry.py
View File

@ -10,7 +10,7 @@ the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
"""
from qgis.core import QgsSettings, QgsSettingsEntryBase, QgsSettingsEntryVariant, QgsSettingsEntryString, QgsSettingsEntryStringList, QgsSettingsEntryBool, QgsSettingsEntryInteger, QgsSettingsEntryDouble, QgsSettingsEntryEnum, QgsSettingsEntryFlag, QgsUnitTypes, QgsMapLayerProxyModel
from qgis.core import QgsSettings, QgsSettingsEntryBase, QgsSettingsEntryVariant, QgsSettingsEntryString, QgsSettingsEntryStringList, QgsSettingsEntryBool, QgsSettingsEntryInteger, QgsSettingsEntryDouble, QgsSettingsEntryEnumFlag, QgsUnitTypes, QgsMapLayerProxyModel
from qgis.testing import start_app, unittest
__author__ = 'Damiano Lombardi'
@ -298,7 +298,7 @@ class TestQgsSettingsEntry(unittest.TestCase):
defaultValue = QgsUnitTypes.LayoutMeters
description = "Enum value functionality test"
settingsEntryEnum = QgsSettingsEntryEnum(settingsKey, self.pluginName, defaultValue, description)
settingsEntryEnum = QgsSettingsEntryEnumFlag(settingsKey, self.pluginName, defaultValue, description)
# Check default value
self.assertEqual(settingsEntryEnum.defaultValue(), QgsUnitTypes.LayoutMeters)
@ -314,7 +314,7 @@ class TestQgsSettingsEntry(unittest.TestCase):
self.assertEqual(settingsEntryEnum.value(), QgsUnitTypes.LayoutPicas)
# Check settings type
self.assertEqual(settingsEntryEnum.settingsType(), QgsSettingsEntryBase.SettingsType.Enum)
self.assertEqual(settingsEntryEnum.settingsType(), QgsSettingsEntryBase.SettingsType.EnumFlag)
# assign to inexisting value
success = settingsEntryEnum.setValue(-1)
@ -336,7 +336,7 @@ class TestQgsSettingsEntry(unittest.TestCase):
QgsSettings().remove(settingsKeyComplete, QgsSettings.Plugins)
description = "Flag value functionality test"
settingsEntryFlag = QgsSettingsEntryFlag(settingsKey, self.pluginName, pointAndLine, description)
settingsEntryFlag = QgsSettingsEntryEnumFlag(settingsKey, self.pluginName, pointAndLine, description)
# Check default value
self.assertEqual(settingsEntryFlag.defaultValue(), pointAndLine)
@ -352,7 +352,7 @@ class TestQgsSettingsEntry(unittest.TestCase):
self.assertEqual(settingsEntryFlag.value(), pointAndPolygon)
# Check settings type
self.assertEqual(settingsEntryFlag.settingsType(), QgsSettingsEntryBase.SettingsType.Flag)
self.assertEqual(settingsEntryFlag.settingsType(), QgsSettingsEntryBase.SettingsType.EnumFlag)
if __name__ == '__main__':

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

@ -10,7 +10,7 @@ the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
"""
from qgis.core import QgsSettingsRegistry, QgsSettingsEntryBase, QgsSettingsEntryInteger, QgsApplication
from qgis.core import QgsSettingsRegistry, QgsSettingsRegistryCore, QgsSettingsEntryBase, QgsSettingsEntryInteger, QgsApplication
from qgis.testing import start_app, unittest
__author__ = 'Damiano Lombardi'
@ -35,12 +35,12 @@ class PyQgsSettingsRegistry(unittest.TestCase):
settingsRegistry.addSettingsEntry(settingsEntry)
# check get settings entry
self.assertEqual(settingsRegistry.getSettingsEntry(settingsEntry.key(), False), settingsEntry)
self.assertEqual(settingsRegistry.settingsEntry(settingsEntry.key(), False), settingsEntry)
# add registry to core registry
QgsApplication.settingsRegistryCore().appendRegistry(settingsRegistry)
QgsApplication.settingsRegistryCore().addSubRegistry(settingsRegistry)
self.assertEqual(QgsApplication.settingsRegistryCore().getSettingsEntry(settingsEntry.key(), True), settingsEntry)
self.assertEqual(QgsApplication.settingsRegistryCore().settingsEntry(settingsEntry.key(), True), settingsEntry)
if __name__ == '__main__':