QGIS API Documentation 4.3.0-Master (0cef2469b72)
Loading...
Searching...
No Matches
qgsapplication.cpp
Go to the documentation of this file.
1/***************************************************************************
2 qgsapplication.cpp - Accessors for application-wide data
3 --------------------------------------
4 Date : 02-Jan-2006
5 Copyright : (C) 2006 by Tom Elwertowski
6 Email : telwertowski at users dot sourceforge dot net
7 ***************************************************************************
8 * *
9 * This program is free software; you can redistribute it and/or modify *
10 * it under the terms of the GNU General Public License as published by *
11 * the Free Software Foundation; either version 2 of the License, or *
12 * (at your option) any later version. *
13 * *
14 ***************************************************************************/
15
16#include "qgsapplication.h"
17
24#include "qgs3dsymbolregistry.h"
30#include "qgsauthmanager.h"
32#include "qgsbookmarkmanager.h"
33#include "qgscalloutsregistry.h"
35#include "qgscolorrampimpl.h"
41#include "qgsdbquerylog.h"
42#include "qgsexception.h"
43#include "qgsexpression.h"
45#include "qgsfeaturestore.h"
47#include "qgsfontmanager.h"
48#include "qgsgeometry.h"
49#include "qgsgpsconnection.h"
50#include "qgsimagecache.h"
51#include "qgsinterval.h"
54#include "qgslayout.h"
58#include "qgslocator.h"
59#include "qgslogger.h"
60#include "qgsmaterialregistry.h"
61#include "qgsmeshlayer.h"
62#include "qgsmessagelog.h"
65#include "qgsnetworkreply.h"
66#include "qgsnewsfeedparser.h"
69#include "qgsplotregistry.h"
74#include "qgsproject.h"
76#include "qgsprojutils.h"
77#include "qgsproviderregistry.h"
79#include "qgsreadwritelocker.h"
83#include "qgsrendererregistry.h"
84#include "qgsruntimeprofiler.h"
87#include "qgssensorregistry.h"
89#include "qgssettings.h"
91#include "qgssourcecache.h"
92#include "qgssqliteutils.h"
93#include "qgsstyle.h"
94#include "qgsstylemodel.h"
95#include "qgssvgcache.h"
98#include "qgssymbollayerutils.h"
99#include "qgstaskmanager.h"
102#include "qgsunittypes.h"
104#include "qgsuserprofile.h"
107
108#include <QAuthenticator>
109#include <QDir>
110#include <QFile>
111#include <QFileInfo>
112#include <QFileOpenEvent>
113#include <QIcon>
114#include <QImageReader>
115#include <QLibraryInfo>
116#include <QLocale>
117#include <QMessageBox>
118#include <QPalette>
119#include <QPixmap>
120#include <QProcess>
121#include <QProcessEnvironment>
122#include <QRecursiveMutex>
123#include <QRegularExpression>
124#include <QScreen>
125#include <QStandardPaths>
126#include <QString>
127#include <QStyle>
128#include <QTextStream>
129#include <QThreadPool>
130
131#include "moc_qgsapplication.cpp"
132
133using namespace Qt::StringLiterals;
134
136
138
141 = new QgsSettingsEntryVariant( u"value"_s, sTreeCustomVariables, QVariant(), u"User-defined custom application variable, keyed by variable name. Available as @-prefixed variables in expressions."_s );
142
144
146
148
150
152
153// The default template directory depends on the active profile, which is not known now, so we use an empty default,
154// and it will be handled later on by the getter QgsApplication::projectTemplatePaths.
156
158
160 = new QgsSettingsEntryInteger( u"connection-pool-maximum-concurrent-connections"_s, QgsSettingsTree::sTreeCore, 4, QObject::tr( "Maximum number of concurrent connections per connection pool" ), Qgis::SettingsOptions(), 4, 999 );
161
162#ifndef Q_OS_WIN
163#include <netinet/in.h>
164#include <pwd.h>
165#else
166#include <winsock.h>
167#include <windows.h>
168#include <lmcons.h>
169#define SECURITY_WIN32
170#include <security.h>
171#ifdef _MSC_VER
172#pragma comment( lib, "Secur32.lib" )
173#endif
174#endif
175
176#include "qgsconfig.h"
177
178#include <gdal.h>
179#include <ogr_api.h>
180#include <cpl_conv.h> // for setting gdal options
181#include <sqlite3.h>
182#include <mutex>
183
184#include <proj.h>
185
186#if defined( Q_OS_LINUX )
187#include <sys/sysinfo.h>
188#endif
189
190#define CONN_POOL_MAX_CONCURRENT_CONNS 4
191
193{
194 std::unique_ptr<QgsSettingsRegistryCore > mSettingsRegistryCore;
195 std::unique_ptr<QgsCoordinateReferenceSystemRegistry > mCrsRegistry;
196 std::unique_ptr<Qgs3DRendererRegistry > m3DRendererRegistry;
197 std::unique_ptr<Qgs3DSymbolRegistry > m3DSymbolRegistry;
198 std::unique_ptr<QgsMaterialRegistry > mMaterialRegistry;
199 std::unique_ptr<QgsActionScopeRegistry > mActionScopeRegistry;
200 std::unique_ptr<QgsAnnotationRegistry > mAnnotationRegistry;
201 std::unique_ptr<QgsApplicationThemeRegistry > mApplicationThemeRegistry;
202 std::unique_ptr<QgsColorSchemeRegistry > mColorSchemeRegistry;
203 std::unique_ptr<QgsLocalizedDataPathRegistry > mLocalizedDataPathRegistry;
204 std::unique_ptr<QgsNumericFormatRegistry > mNumericFormatRegistry;
205 std::unique_ptr<QgsFieldFormatterRegistry > mFieldFormatterRegistry;
206 std::unique_ptr<QgsGpsConnectionRegistry > mGpsConnectionRegistry;
207 std::unique_ptr<QgsBabelFormatRegistry > mGpsBabelFormatRegistry;
208 std::unique_ptr<QgsNetworkContentFetcherRegistry > mNetworkContentFetcherRegistry;
209 std::unique_ptr<QgsScaleBarRendererRegistry > mScaleBarRendererRegistry;
210 std::unique_ptr<QgsLabelingEngineRuleRegistry > mLabelingEngineRuleRegistry;
211 std::unique_ptr<QgsSymbolConverterRegistry > mSymbolConverterRegistry;
212 std::unique_ptr<QgsValidityCheckRegistry > mValidityCheckRegistry;
213 std::unique_ptr<QgsMessageLog > mMessageLog;
214 std::unique_ptr<QgsPaintEffectRegistry > mPaintEffectRegistry;
215 std::unique_ptr<QgsPluginLayerRegistry > mPluginLayerRegistry;
216 std::unique_ptr<QgsClassificationMethodRegistry > mClassificationMethodRegistry;
217 std::unique_ptr<QgsProcessingRegistry > mProcessingRegistry;
218 std::unique_ptr<QgsConnectionRegistry > mConnectionRegistry;
219 std::unique_ptr<QgsProjectStorageRegistry > mProjectStorageRegistry;
220 std::unique_ptr<QgsLayerMetadataProviderRegistry > mLayerMetadataProviderRegistry;
221 std::unique_ptr<QgsExternalStorageRegistry > mExternalStorageRegistry;
222 std::unique_ptr<QgsProfileSourceRegistry > mProfileSourceRegistry;
223 std::unique_ptr<QgsPageSizeRegistry > mPageSizeRegistry;
224 std::unique_ptr<QgsRasterRendererRegistry > mRasterRendererRegistry;
225 std::unique_ptr<QgsRendererRegistry > mRendererRegistry;
226 std::unique_ptr<QgsPointCloudRendererRegistry > mPointCloudRendererRegistry;
227 std::unique_ptr<QgsTiledSceneRendererRegistry > mTiledSceneRendererRegistry;
228 std::unique_ptr<QgsSvgCache > mSvgCache;
229 std::unique_ptr<QgsImageCache > mImageCache;
230 std::unique_ptr<QgsSourceCache > mSourceCache;
231 std::unique_ptr<QgsSymbolLayerRegistry > mSymbolLayerRegistry;
232 std::unique_ptr<QgsCalloutRegistry > mCalloutRegistry;
233 std::unique_ptr<QgsTaskManager > mTaskManager;
234 std::unique_ptr<QgsLayoutItemRegistry > mLayoutItemRegistry;
235 std::unique_ptr<QgsAnnotationItemRegistry > mAnnotationItemRegistry;
236 std::unique_ptr<QgsSensorRegistry > mSensorRegistry;
237 std::unique_ptr<QgsPlotRegistry > mPlotRegistry;
238 std::unique_ptr<QgsBookmarkManager > mBookmarkManager;
239 std::unique_ptr<QgsTileDownloadManager > mTileDownloadManager;
240 std::unique_ptr<QgsStyleModel > mStyleModel;
241 std::unique_ptr<QgsRecentStyleHandler > mRecentStyleHandler;
242 std::unique_ptr<QgsDatabaseQueryLog > mQueryLogger;
243 std::unique_ptr<QgsFontManager > mFontManager;
245 QStringList mSvgPathCache;
246 bool mSvgPathCacheValid = false;
247
250};
251
252
253QObject *ABISYM( QgsApplication::mFileOpenEventReceiver ) = nullptr;
254bool ABISYM( QgsApplication::mInitialized ) = false;
255bool ABISYM( QgsApplication::mRunningFromBuildDir ) = false;
256const char *QgsApplication::QGIS_ORGANIZATION_NAME = "QGIS";
257const char *QgsApplication::QGIS_ORGANIZATION_DOMAIN = "qgis.org";
258const char *QgsApplication::QGIS_APPLICATION_NAME = "QGIS4";
259QgsApplication::ApplicationMembers *QgsApplication::sApplicationMembers = nullptr;
260QgsAuthManager *QgsApplication::sAuthManager = nullptr;
261int ABISYM( QgsApplication::sMaxThreads ) = -1;
262
263Q_GLOBAL_STATIC( QStringList, sFileOpenEventList )
264Q_GLOBAL_STATIC( QString, sPrefixPath )
265Q_GLOBAL_STATIC( QString, sPluginPath )
266Q_GLOBAL_STATIC( QString, sPkgDataPath )
267Q_GLOBAL_STATIC( QString, sLibraryPath )
268Q_GLOBAL_STATIC( QString, sLibexecPath )
269Q_GLOBAL_STATIC( QString, sQmlImportPath )
270Q_GLOBAL_STATIC( QString, sThemeName )
271Q_GLOBAL_STATIC( QString, sProfilePath )
272
273Q_GLOBAL_STATIC( QStringList, sDefaultSvgPaths )
274Q_GLOBAL_STATIC( QgsStringMap, sSystemEnvVars )
275Q_GLOBAL_STATIC( QString, sConfigPath )
276
277Q_GLOBAL_STATIC( QString, sBuildSourcePath )
278#if defined( _MSC_VER ) && !defined( USING_NMAKE ) && !defined( USING_NINJA )
279Q_GLOBAL_STATIC( QString, sCfgIntDir )
280#endif
281Q_GLOBAL_STATIC( QString, sBuildOutputPath )
282Q_GLOBAL_STATIC( QStringList, sGdalSkipList )
283Q_GLOBAL_STATIC( QStringList, sDeferredSkippedGdalDrivers )
284Q_GLOBAL_STATIC( QString, sAuthDbDirPath )
285Q_GLOBAL_STATIC( QString, sAuthDbUri )
286
287Q_GLOBAL_STATIC( QString, sUserName )
288Q_GLOBAL_STATIC( QString, sUserFullName )
289Q_GLOBAL_STATIC_WITH_ARGS( QString, sPlatformName, ( "external" ) )
290Q_GLOBAL_STATIC( QString, sApplicationFullName )
291Q_GLOBAL_STATIC( QString, sTranslation )
292
293Q_GLOBAL_STATIC( QTemporaryDir, sIconCacheDir )
294
295QgsApplication::QgsApplication( int &argc, char **argv, bool GUIenabled, const QString &profileFolder, const QString &platformName )
296 : QApplication( argc, argv, GUIenabled )
297{
298 *sPlatformName() = platformName;
299
301
302 // Delay application members initialization in desktop app (In desktop app, profile folder is not known at this point)
303 if ( platformName != "desktop"_L1 )
304 {
305 mApplicationMembers = std::make_unique<ApplicationMembers>();
306 try
307 {
308 mApplicationMembers->mSettingsRegistryCore->migrateOldSettings();
309 }
310 catch ( QgsSettingsException &e )
311 {
312 QgsDebugError( u"Error migrating old settings: %1"_s.arg( e.what() ) );
313 }
314 }
315 else
316 {
317 *sProfilePath() = profileFolder;
318 }
319}
320
322{
323 qRegisterMetaType<QgsGeometry::Error>( "QgsGeometry::Error" );
324 qRegisterMetaType<QgsDatabaseQueryLogEntry>( "QgsDatabaseQueryLogEntry" );
325 qRegisterMetaType<QgsProcessingFeatureSourceDefinition>( "QgsProcessingFeatureSourceDefinition" );
326 qRegisterMetaType<QgsProcessingOutputLayerDefinition>( "QgsProcessingOutputLayerDefinition" );
327 qRegisterMetaType<Qgis::LayoutUnit>( "Qgis::LayoutUnit" );
328 qRegisterMetaType<QgsUnsetAttributeValue>( "QgsUnsetAttributeValue" );
329 qRegisterMetaType<QgsFeatureId>( "QgsFeatureId" );
330 qRegisterMetaType<QgsFields>( "QgsFields" );
331 qRegisterMetaType<QgsFeatureIds>( "QgsFeatureIds" );
332 qRegisterMetaType<QgsProperty>( "QgsProperty" );
333 qRegisterMetaType<QgsFeatureStoreList>( "QgsFeatureStoreList" );
334 qRegisterMetaType<Qgis::MessageLevel>( "Qgis::MessageLevel" );
335 qRegisterMetaType<Qgis::BrowserItemState>( "Qgis::BrowserItemState" );
336 qRegisterMetaType<Qgis::GpsFixStatus>( "Qgis::GpsFixStatus" );
337 qRegisterMetaType<QgsReferencedRectangle>( "QgsReferencedRectangle" );
338 qRegisterMetaType<QgsReferencedPointXY>( "QgsReferencedPointXY" );
339 qRegisterMetaType<QgsReferencedGeometry>( "QgsReferencedGeometry" );
340 qRegisterMetaType<Qgis::LayoutRenderFlags>( "Qgis::LayoutRenderFlags" );
341 qRegisterMetaType<QgsStyle::StyleEntity>( "QgsStyle::StyleEntity" );
342 qRegisterMetaType<QgsCoordinateReferenceSystem>( "QgsCoordinateReferenceSystem" );
343 qRegisterMetaType<QgsAuthManager::MessageLevel>( "QgsAuthManager::MessageLevel" );
344 qRegisterMetaType<QgsNetworkRequestParameters>( "QgsNetworkRequestParameters" );
345 qRegisterMetaType<QgsNetworkReplyContent>( "QgsNetworkReplyContent" );
346 qRegisterMetaType<QgsFeature>( "QgsFeature" );
347 qRegisterMetaType<QgsGeometry>( "QgsGeometry" );
348 qRegisterMetaType<QgsInterval>( "QgsInterval" );
349 qRegisterMetaType<QgsRectangle>( "QgsRectangle" );
350 qRegisterMetaType<QgsPointXY>( "QgsPointXY" );
351 qRegisterMetaType<QgsPoint>( "QgsPoint" );
352 qRegisterMetaType<QgsDatumTransform::GridDetails>( "QgsDatumTransform::GridDetails" );
353 qRegisterMetaType<QgsDatumTransform::TransformDetails>( "QgsDatumTransform::TransformDetails" );
354 qRegisterMetaType<QgsNewsFeedParser::Entry>( "QgsNewsFeedParser::Entry" );
355 qRegisterMetaType<QgsRectangle>( "QgsRectangle" );
356 qRegisterMetaType<QgsLocatorResult>( "QgsLocatorResult" );
357 qRegisterMetaType<QgsGradientColorRamp>( "QgsGradientColorRamp" );
358 qRegisterMetaType<QgsProcessingModelChildParameterSource>( "QgsProcessingModelChildParameterSource" );
359 qRegisterMetaType<QgsRemappingSinkDefinition>( "QgsRemappingSinkDefinition" );
360 qRegisterMetaType<QgsProcessingModelChildDependency>( "QgsProcessingModelChildDependency" );
361 qRegisterMetaType<QgsProcessingModelChildAlgorithmResult>( "QgsProcessingModelChildAlgorithmResult" );
362 qRegisterMetaType<QgsTextFormat>( "QgsTextFormat" );
363 qRegisterMetaType<QPainter::CompositionMode>( "QPainter::CompositionMode" );
364 qRegisterMetaType<QgsDateTimeRange>( "QgsDateTimeRange" );
365 qRegisterMetaType<QgsDoubleRange>( "QgsDoubleRange" );
366 qRegisterMetaType<QgsIntRange>( "QgsIntRange" );
367 qRegisterMetaType<QList<QgsMapLayer *>>( "QList<QgsMapLayer*>" );
368 qRegisterMetaType<QMap<QNetworkRequest::Attribute, QVariant>>( "QMap<QNetworkRequest::Attribute,QVariant>" );
369 qRegisterMetaType<QMap<QNetworkRequest::KnownHeaders, QVariant>>( "QMap<QNetworkRequest::KnownHeaders,QVariant>" );
370 qRegisterMetaType<QList<QNetworkReply::RawHeaderPair>>( "QList<QNetworkReply::RawHeaderPair>" );
371 qRegisterMetaType<QNetworkReply::NetworkError>( "QNetworkReply::NetworkError" );
372 qRegisterMetaType< QAuthenticator * >( "QAuthenticator*" );
373 qRegisterMetaType< QgsGpsInformation >( "QgsGpsInformation" );
374 qRegisterMetaType< QgsSensorThingsExpansionDefinition >( "QgsSensorThingsExpansionDefinition" );
375 qRegisterMetaType< QTimeZone >( "QTimeZone" );
376 qRegisterMetaType< QgsSelectiveMaskingSourceSet >( "QgsSelectiveMaskingSourceSet" );
377};
378
379void QgsApplication::init( QString profileFolder )
380{
381 // Initialize application members in desktop app (at this point, profile folder is known)
382 if ( platform() == "desktop"_L1 )
383 {
384 instance()->mApplicationMembers = std::make_unique<ApplicationMembers>();
385 try
386 {
387 instance()->mApplicationMembers->mSettingsRegistryCore->migrateOldSettings();
388 }
389 catch ( QgsSettingsException &e )
390 {
391 QgsDebugError( u"Error migrating old settings: %1"_s.arg( e.what() ) );
392 }
393 }
394
395 if ( profileFolder.isEmpty() )
396 {
397 if ( getenv( "QGIS_CUSTOM_CONFIG_PATH" ) )
398 {
399 profileFolder = getenv( "QGIS_CUSTOM_CONFIG_PATH" );
400 }
401 else
402 {
403 profileFolder = QStandardPaths::standardLocations( QStandardPaths::AppDataLocation ).value( 0 );
404 }
405 // This will normally get here for custom scripts that use QgsApplication.
406 // This doesn't get this hit for QGIS Desktop because we setup the profile via main
407 QString rootProfileFolder = QgsUserProfileManager::resolveProfilesFolder( profileFolder );
408 QgsUserProfileManager manager( rootProfileFolder );
409 std::unique_ptr< QgsUserProfile > profile = manager.getProfile();
410 profileFolder = profile->folder();
411 }
412
413 *sProfilePath() = profileFolder;
414
415 static std::once_flag sMetaTypesRegistered;
416 std::call_once( sMetaTypesRegistered, registerMetaTypes );
417
418 ( void ) resolvePkgPath();
419
420 if ( ABISYM( mRunningFromBuildDir ) )
421 {
422 // we run from source directory - not installed to destination (specified prefix)
423 *sPrefixPath() = QString(); // set invalid path
424#if defined( _MSC_VER ) && !defined( USING_NMAKE ) && !defined( USING_NINJA )
425 setPluginPath( *sBuildOutputPath() + '/' + QString( QGIS_PLUGIN_SUBDIR ) + '/' + *sCfgIntDir() );
426#else
427 setPluginPath( *sBuildOutputPath() + '/' + QStringLiteral( QGIS_PLUGIN_SUBDIR ) );
428#endif
429 setPkgDataPath( *sBuildOutputPath() + u"/data"_s ); // in buildDir/data - used for: doc, resources, svg
430 *sLibraryPath() = *sBuildOutputPath() + '/' + QGIS_LIB_SUBDIR + '/';
431#if defined( _MSC_VER ) && !defined( USING_NMAKE ) && !defined( USING_NINJA )
432 *sLibexecPath() = *sBuildOutputPath() + '/' + QGIS_LIBEXEC_SUBDIR + '/' + *sCfgIntDir() + '/';
433#else
434 *sLibexecPath() = *sBuildOutputPath() + '/' + QGIS_LIBEXEC_SUBDIR + '/';
435#endif
436#if defined( HAVE_QUICK )
437 *sQmlImportPath() = *sBuildOutputPath() + '/' + QGIS_QML_SUBDIR + '/';
438#endif
439 }
440 else
441 {
442 char *prefixPath = getenv( "QGIS_PREFIX_PATH" );
443 if ( !prefixPath )
444 {
445 if ( sPrefixPath()->isNull() )
446 {
447#if defined( Q_OS_WIN ) || defined( Q_OS_MACOS ) && !defined( QGIS_MAC_BUNDLE )
448 setPrefixPath( applicationDirPath(), true );
449#elif defined( QGIS_MAC_BUNDLE )
450 QDir myDir( applicationDirPath() + "/../.."_L1 );
451 setPrefixPath( myDir.absolutePath(), true );
452#elif defined( ANDROID )
453 // this is "/data/data/org.qgis.qgis" in android
454 QDir myDir( QDir::homePath() );
455 myDir.cdUp();
456 QString myPrefix = myDir.absolutePath();
457 setPrefixPath( myPrefix, true );
458#else
459 QDir myDir( applicationDirPath() );
460 // Fix for server which is one level deeper in /usr/lib/cgi-bin
461 if ( applicationDirPath().contains( u"cgi-bin"_s ) )
462 {
463 myDir.cdUp();
464 }
465 myDir.cdUp(); // Go from /usr/bin or /usr/lib (for server) to /usr
466 QString myPrefix = myDir.absolutePath();
467 setPrefixPath( myPrefix, true );
468#endif
469 }
470 }
471 else
472 {
473 setPrefixPath( prefixPath, true );
474 }
475 }
476
477 *sConfigPath() = profileFolder + '/'; // make sure trailing slash is included
478 *sDefaultSvgPaths() << qgisSettingsDirPath() + u"svg/"_s;
479
480 // Determine the auth DB URI, the first match wins:
481 // 1 - get it from QGIS_AUTH_DB_URI environment variable
482 // 2 - get it from QGIS_AUTH_DB_DIR_PATH environment variable, assume QSQLITE driver and add "qgis-auth.db"
483 // 3 - use the default path from settings dir path, assume QSQLITE and add "qgis-auth.db"
484 *sAuthDbDirPath() = qgisSettingsDirPath();
485
486 if ( getenv( "QGIS_AUTH_DB_DIR_PATH" ) )
487 {
488 setAuthDatabaseDirPath( getenv( "QGIS_AUTH_DB_DIR_PATH" ) );
489 sAuthDbUri()->clear();
490 }
491
492 if ( getenv( "QGIS_AUTH_DB_URI" ) )
493 {
494 *sAuthDbUri() = getenv( "QGIS_AUTH_DB_URI" );
495 }
496
497 // Default to sAuthDbDirPath
498 if ( sAuthDbUri->isEmpty() )
499 {
500 *sAuthDbUri() = u"QSQLITE://"_s + *sAuthDbDirPath() + u"qgis-auth.db"_s;
501 }
502
503 // force use of OpenGL renderer for Qt3d.
504 qputenv( "QT3D_RENDERER", "opengl" );
505
506 // store system environment variables passed to application, before they are adjusted
507 QMap<QString, QString> systemEnvVarMap;
508 QString passfile( u"QGIS_AUTH_PASSWORD_FILE"_s ); // QString, for comparison
509
510 const auto systemEnvironment = QProcessEnvironment::systemEnvironment().toStringList();
511 for ( const QString &varStr : systemEnvironment )
512 {
513 int pos = varStr.indexOf( '='_L1 );
514 if ( pos == -1 )
515 continue;
516 QString varStrName = varStr.left( pos );
517 QString varStrValue = varStr.mid( pos + 1 );
518 if ( varStrName != passfile )
519 {
520 systemEnvVarMap.insert( varStrName, varStrValue );
521 }
522 }
523 *sSystemEnvVars() = systemEnvVarMap;
524
525 // append local user-writable folder as a proj search path
526 QStringList currentProjSearchPaths = QgsProjUtils::searchPaths();
527 currentProjSearchPaths.append( qgisSettingsDirPath() + u"proj"_s );
528#ifdef Q_OS_MACOS
529 // Set bundled proj data path as env var, so it's also available for pyproj and subprocesses (e.g. processing algorithms)
530 const QString projData( QDir::cleanPath( pkgDataPath().append( "/proj" ) ) );
531 if ( QFile::exists( projData ) )
532 {
533 qputenv( "PROJ_DATA", projData.toUtf8() );
534 currentProjSearchPaths.append( projData );
535 }
536#endif // Q_OS_MACOS
537
538 char **newPaths = new char *[currentProjSearchPaths.length()];
539 for ( int i = 0; i < currentProjSearchPaths.count(); ++i )
540 {
541 newPaths[i] = CPLStrdup( currentProjSearchPaths.at( i ).toUtf8().constData() );
542 }
543 proj_context_set_search_paths( nullptr, currentProjSearchPaths.count(), newPaths );
544 for ( int i = 0; i < currentProjSearchPaths.count(); ++i )
545 {
546 CPLFree( newPaths[i] );
547 }
548 delete[] newPaths;
549
550 // allow Qt to search for Qt plugins (e.g. sqldrivers) in our plugin directory
551 QCoreApplication::addLibraryPath( pluginPath() );
552
553 // the default of 256 is not enough for QGIS
554 QImageReader::setAllocationLimit( 512 );
555
556 {
557 QgsScopedRuntimeProfile profile( tr( "Load user fonts" ) );
559 }
560
561 // set max. thread count to -1
562 // this should be read from QgsSettings but we don't know where they are at this point
563 // so we read actual value in main.cpp
564 ABISYM( sMaxThreads ) = -1;
565
566 // initialize built in expression functions upfront. While the expression engine API is setup
567 // in such a way that these will be lazy loaded on first use, manually pre-loading them on the main
568 // thread while nothing else is happening avoids ANY potential thread-safety issues with the lazy loading.
569 // This is cheap to call anyway, so there's no harm in being overly vigilant...
571
572 // trigger creation of default style, but defer initialization until
573 // it's actually required
574 // The default style creation should be done before instantiating the QgsProject singleton
575 QgsStyle *defaultStyle = QgsStyle::defaultStyle( false );
576 if ( !members()->mStyleModel )
577 members()->mStyleModel = std::make_unique<QgsStyleModel>( defaultStyle );
578
579 {
580 QgsScopedRuntimeProfile profile( tr( "Load color schemes" ) );
581 // TODO QGIS 5.0 - remove the default inclusion of the project instance
582 // the default inclusion of the project instance ensures that the "Project colors" scheme is available as it was before
583 colorSchemeRegistry()->setProject( QgsProject::instance() ); // skip-keyword-check
586 }
587
588 {
589 QgsScopedRuntimeProfile profile( tr( "Load bookmarks" ) );
591 }
592
594
595 ABISYM( mInitialized ) = true;
596}
597
598
599void QgsApplication::installTranslators()
600{
601 // Remove translators if any are already installed
602 if ( mQgisTranslator )
603 {
604 removeTranslator( mQgisTranslator.get() );
605 mQgisTranslator.reset();
606 }
607 if ( mQtTranslator )
608 {
609 removeTranslator( mQtTranslator.get() );
610 mQtTranslator.reset();
611 }
612 if ( mQtBaseTranslator )
613 {
614 removeTranslator( mQtBaseTranslator.get() );
615 mQtBaseTranslator.reset();
616 }
617
618 if ( *sTranslation() != "C"_L1 )
619 {
620 mQgisTranslator = std::make_unique<QTranslator>( this );
621 if ( mQgisTranslator->load( u"qgis_"_s + *sTranslation(), i18nPath() ) )
622 {
623 installTranslator( mQgisTranslator.get() );
624 }
625 else
626 {
627 QgsDebugMsgLevel( u"loading of qgis translation failed %1/qgis_%2"_s.arg( i18nPath(), *sTranslation() ), 2 );
628 }
629
630 /* Translation file for Qt.
631 * The strings from the QMenuBar context section are used by Qt/Mac to shift
632 * the About, Preferences and Quit items to the Mac Application menu.
633 * These items must be translated identically in both qt_ and qgis_ files.
634 */
635 QString qtTranslationsPath = QLibraryInfo::path( QLibraryInfo::TranslationsPath );
636#ifdef __MINGW32__
637 QString prefix = QDir( QString( "%1/../" ).arg( QApplication::applicationDirPath() ) ).absolutePath();
638 qtTranslationsPath = prefix + qtTranslationsPath.mid( QLibraryInfo::location( QLibraryInfo::PrefixPath ).length() );
639#endif
640
641 mQtTranslator = std::make_unique<QTranslator>( this );
642 if ( mQtTranslator->load( u"qt_"_s + *sTranslation(), qtTranslationsPath ) )
643 {
644 installTranslator( mQtTranslator.get() );
645 }
646 else
647 {
648 QgsDebugMsgLevel( u"loading of qt translation failed %1/qt_%2"_s.arg( qtTranslationsPath, *sTranslation() ), 2 );
649 }
650
651 mQtBaseTranslator = std::make_unique<QTranslator>( this );
652 if ( mQtBaseTranslator->load( u"qtbase_"_s + *sTranslation(), qtTranslationsPath ) )
653 {
654 installTranslator( mQtBaseTranslator.get() );
655 }
656 else
657 {
658 QgsDebugMsgLevel( u"loading of qtbase translation failed %1/qt_%2"_s.arg( qtTranslationsPath, *sTranslation() ), 2 );
659 }
660 }
661}
662
664{
665 if ( mApplicationMembers )
666 {
667 try
668 {
669 mApplicationMembers->mSettingsRegistryCore->backwardCompatibility();
670 }
671 catch ( QgsSettingsException &e )
672 {
673 QgsDebugError( u"An error occurred while performing backwards compatibility for settings: %1"_s.arg( e.what() ) );
674 }
675 }
676
677 // we do this here as well as in exitQgis() -- it's safe to call as often as we want,
678 // and there's just a *chance* that someone hasn't properly called exitQgis prior to
679 // this destructor...
680 invalidateCaches();
681}
682
683void QgsApplication::invalidateCaches()
684{
685 // invalidate coordinate cache while the PROJ context held by the thread-locale
686 // QgsProjContextStore object is still alive. Otherwise if this later object
687 // is destroyed before the static variables of the cache, we might use freed memory.
691}
692
694{
695 return qobject_cast<QgsApplication *>( QCoreApplication::instance() );
696}
697
699{
700 bool done = false;
701 if ( event->type() == QEvent::FileOpen )
702 {
703 // handle FileOpen event (double clicking a file icon in Mac OS X Finder)
704 if ( ABISYM( mFileOpenEventReceiver ) )
705 {
706 // Forward event to main window.
707 done = notify( ABISYM( mFileOpenEventReceiver ), event );
708 }
709 else
710 {
711 // Store filename because receiver has not registered yet.
712 // If QGIS has been launched by double clicking a file icon, FileOpen will be
713 // the first event; the main window is not yet ready to handle the event.
714 sFileOpenEventList()->append( static_cast<QFileOpenEvent *>( event )->file() );
715 done = true;
716 }
717 }
718 else
719 {
720 // pass other events to base class
721 done = QApplication::event( event );
722 }
723 return done;
724}
725
726bool QgsApplication::notify( QObject *receiver, QEvent *event )
727{
728 bool done = false;
729 // Crashes in customization (especially on Mac), if we're not in the main/UI thread, see #5597
730 if ( thread() == receiver->thread() )
731 emit preNotify( receiver, event, &done );
732
733 if ( done )
734 return true;
735
736 // Send event to receiver and catch unhandled exceptions
737 done = true;
738 try
739 {
740 done = QApplication::notify( receiver, event );
741 }
742 catch ( QgsException &e )
743 {
744 qCritical() << "Caught unhandled QgsException: " << e.what();
745 if ( qApp->thread() == QThread::currentThread() )
746 QMessageBox::critical( activeWindow(), tr( "Exception" ), e.what() );
747 }
748 catch ( std::exception &e )
749 {
750 qCritical() << "Caught unhandled std::exception: " << e.what();
751 if ( qApp->thread() == QThread::currentThread() )
752 QMessageBox::critical( activeWindow(), tr( "Exception" ), e.what() );
753 }
754 catch ( ... )
755 {
756 qCritical() << "Caught unhandled unknown exception";
757 if ( qApp->thread() == QThread::currentThread() )
758 QMessageBox::critical( activeWindow(), tr( "Exception" ), tr( "unknown exception" ) );
759 }
760
761 return done;
762}
763
765{
766 return QgsRuntimeProfiler::threadLocalInstance();
767}
768
770{
771 // Set receiver for FileOpen events
772 ABISYM( mFileOpenEventReceiver ) = receiver;
773 // Propagate any events collected before the receiver has registered.
774 if ( sFileOpenEventList()->count() > 0 )
775 {
776 const QStringList fileOpenEventList = *sFileOpenEventList();
777 for ( const QString &file : fileOpenEventList )
778 {
779 QFileOpenEvent foe( file );
780 QgsApplication::sendEvent( ABISYM( mFileOpenEventReceiver ), &foe );
781 }
782 sFileOpenEventList()->clear();
783 }
784}
785
786void QgsApplication::setPrefixPath( const QString &prefixPath, bool useDefaultPaths )
787{
788 *sPrefixPath() = prefixPath;
789#if defined( Q_OS_WIN )
790 if ( sPrefixPath()->endsWith( "/bin" ) )
791 {
792 sPrefixPath()->chop( 4 );
793 }
794#endif
795 if ( useDefaultPaths && !ABISYM( mRunningFromBuildDir ) )
796 {
797 setPluginPath( *sPrefixPath() + '/' + QStringLiteral( QGIS_PLUGIN_SUBDIR ) );
798 setPkgDataPath( *sPrefixPath() + '/' + QStringLiteral( QGIS_DATA_SUBDIR ) );
799 }
800 *sLibraryPath() = *sPrefixPath() + '/' + QGIS_LIB_SUBDIR + '/';
801 *sLibexecPath() = *sPrefixPath() + '/' + QGIS_LIBEXEC_SUBDIR + '/';
802#if defined( HAVE_QUICK )
803 *sQmlImportPath() = *sPrefixPath() + '/' + QGIS_QML_SUBDIR + '/';
804#endif
805}
806
808{
809 *sPluginPath() = pluginPath;
810}
811
813{
814 *sPkgDataPath() = pkgDataPath;
815
816 QString mySvgPath = pkgDataPath + u"/svg/"_s;
817
818 // avoid duplicate entries
819 if ( !sDefaultSvgPaths()->contains( mySvgPath ) )
820 *sDefaultSvgPaths() << mySvgPath;
821}
822
823void QgsApplication::setDefaultSvgPaths( const QStringList &pathList )
824{
825 *sDefaultSvgPaths() = pathList;
826}
827
828void QgsApplication::setAuthDatabaseDirPath( const QString &authDbDirPath )
829{
830 QFileInfo fi( authDbDirPath );
831 if ( fi.exists() && fi.isDir() && fi.isWritable() )
832 {
833 *sAuthDbDirPath() = fi.canonicalFilePath() + QDir::separator();
834 }
835}
836
838{
839#if 0
840 if ( ABISYM( mRunningFromBuildDir ) )
841 {
842 static bool sOnce = true;
843 if ( sOnce )
844 {
845 QgsMessageLogNotifyBlocker blockNotifications;
846 ( void ) blockNotifications;
847 qWarning( "!!! prefix path was requested, but it is not valid - we do not run from installed path !!!" );
848 }
849 sOnce = false;
850 }
851#endif
852
853 return *sPrefixPath();
854}
856{
857 return *sPluginPath();
858}
859
861{
862 if ( sPkgDataPath()->isNull() )
863 return resolvePkgPath();
864 else
865 return *sPkgDataPath();
866}
867
869{
870 return u":/images/themes/default/"_s;
871}
873{
874 QString usersThemes = userThemesFolder() + QDir::separator() + themeName() + QDir::separator() + "icons/";
875 QDir dir( usersThemes );
876 if ( dir.exists() )
877 {
878 return usersThemes;
879 }
880 else
881 {
882 QString defaultThemes = defaultThemesFolder() + QDir::separator() + themeName() + QDir::separator() + "icons/";
883 return defaultThemes;
884 }
885}
886
888{
889 return iconsPath() + u"qgis-icon-60x60.png"_s;
890}
891
893{
894 return ABISYM( sMaxThreads );
895}
896
897QString QgsApplication::iconPath( const QString &iconFile )
898{
899 // try active theme
900 QString path = activeThemePath();
901 if ( QFile::exists( path + iconFile ) )
902 return path + iconFile;
903
904 // use default theme
905 return defaultThemePath() + iconFile;
906}
907
908QIcon QgsApplication::getThemeIcon( const QString &name, const QColor &fillColor, const QColor &strokeColor )
909{
910 const QString cacheKey = ( name.startsWith( '/' ) ? name.mid( 1 ) : name )
911 + ( fillColor.isValid() ? u"_%1"_s.arg( fillColor.name( QColor::HexArgb ).mid( 1 ) ) : QString() )
912 + ( strokeColor.isValid() ? u"_%1"_s.arg( strokeColor.name( QColor::HexArgb ).mid( 1 ) ) : QString() );
913 QgsApplication *app = instance();
914 if ( app && app->mIconCache.contains( cacheKey ) )
915 return app->mIconCache.value( cacheKey );
916
917 QIcon icon;
918 const bool colorBased = fillColor.isValid() || strokeColor.isValid();
919
920 auto iconFromColoredSvg = [fillColor, strokeColor, cacheKey]( const QString &path ) -> QIcon {
921 // sizes are unused here!
922 const QByteArray svgContent = QgsApplication::svgCache()->svgContent( path, 16, fillColor, strokeColor, 1, 1 );
923
924 const QString iconPath = sIconCacheDir()->filePath( cacheKey + u".svg"_s );
925 if ( const QDir dir = QFileInfo( iconPath ).dir(); !dir.exists() )
926 {
927 dir.mkpath( "." );
928 }
929
930 QFile f( iconPath );
931 if ( f.open( QFile::WriteOnly | QFile::Truncate ) )
932 {
933 f.write( svgContent );
934 f.close();
935 }
936 else
937 {
938 QgsDebugError( u"Could not create colorized icon svg at %1"_s.arg( iconPath ) );
939 return QIcon();
940 }
941
942 return QIcon( f.fileName() );
943 };
944
945 QString preferredPath = activeThemePath() + QDir::separator() + name;
946 QString defaultPath = defaultThemePath() + QDir::separator() + name;
947 if ( QFile::exists( preferredPath ) )
948 {
949 if ( colorBased )
950 {
951 icon = iconFromColoredSvg( preferredPath );
952 }
953 else
954 {
955 icon = QIcon( preferredPath );
956 }
957 }
958 else if ( QFile::exists( defaultPath ) )
959 {
960 //could still return an empty icon if it
961 //doesn't exist in the default theme either!
962 if ( colorBased )
963 {
964 icon = iconFromColoredSvg( defaultPath );
965 }
966 else
967 {
968 icon = QIcon( defaultPath );
969 }
970 }
971 else
972 {
973 icon = QIcon();
974 }
975
976 if ( app )
977 app->mIconCache.insert( cacheKey, icon );
978 return icon;
979}
980
982{
983 QgsApplication *app = instance();
984 if ( app && app->mCursorCache.contains( cursor ) )
985 return app->mCursorCache.value( cursor );
986
987 // All calculations are done on 32x32 icons
988 // Defaults to center, individual cursors may override
989 int activeX = 16;
990 int activeY = 16;
991
992 QString name;
993 switch ( cursor )
994 {
995 case ZoomIn:
996 name = u"mZoomIn.svg"_s;
997 activeX = 13;
998 activeY = 13;
999 break;
1000 case ZoomOut:
1001 name = u"mZoomOut.svg"_s;
1002 activeX = 13;
1003 activeY = 13;
1004 break;
1005 case Identify:
1006 activeX = 3;
1007 activeY = 6;
1008 name = u"mIdentify.svg"_s;
1009 break;
1010 case CrossHair:
1011 name = u"mCrossHair.svg"_s;
1012 break;
1013 case CapturePoint:
1014 name = u"mCapturePoint.svg"_s;
1015 break;
1016 case Select:
1017 name = u"mSelect.svg"_s;
1018 activeX = 6;
1019 activeY = 6;
1020 break;
1021 case Sampler:
1022 activeX = 0;
1023 activeY = 0;
1024 name = u"mSampler.svg"_s;
1025 break;
1026 // No default
1027 }
1028 // It should never get here!
1029 Q_ASSERT( !name.isEmpty() );
1030
1031 QIcon icon = getThemeIcon( u"cursors"_s + QDir::separator() + name );
1032 QCursor cursorIcon;
1033 // Check if an icon exists for this cursor (the O.S. default cursor will be used if it does not)
1034 if ( !icon.isNull() )
1035 {
1036 // Apply scaling
1037 float scale = Qgis::UI_SCALE_FACTOR * QFontMetricsF( QgsApplication::font() ).height() / 32.0;
1038 cursorIcon = QCursor( icon.pixmap( std::ceil( scale * 32 ), std::ceil( scale * 32 ) ), std::ceil( scale * activeX ), std::ceil( scale * activeY ) );
1039 }
1040 if ( app )
1041 app->mCursorCache.insert( cursor, cursorIcon );
1042 return cursorIcon;
1043}
1044
1045// TODO: add some caching mechanism ?
1046QPixmap QgsApplication::getThemePixmap( const QString &name, const QColor &foreColor, const QColor &backColor, const int size )
1047{
1048 const QString preferredPath = activeThemePath() + QDir::separator() + name;
1049 const QString defaultPath = defaultThemePath() + QDir::separator() + name;
1050 const QString path = QFile::exists( preferredPath ) ? preferredPath : defaultPath;
1051 if ( foreColor.isValid() || backColor.isValid() )
1052 {
1053 bool fitsInCache = false;
1054 const QImage image = svgCache()->svgAsImage( path, size, backColor, foreColor, 1, 1, fitsInCache );
1055 return QPixmap::fromImage( image );
1056 }
1057
1058 return QPixmap( path );
1059}
1060
1062{
1063 *sThemeName() = themeName;
1064}
1065
1067{
1068 static QString appPath;
1069 if ( appPath.isNull() )
1070 {
1071 if ( QCoreApplication::instance() )
1072 {
1073 appPath = applicationDirPath();
1074 }
1075 else
1076 {
1077 qWarning( "Application path not initialized" );
1078 }
1079 }
1080
1081 if ( !appPath.isNull() || getenv( "QGIS_PREFIX_PATH" ) )
1082 {
1083 QString prefix = getenv( "QGIS_PREFIX_PATH" ) ? getenv( "QGIS_PREFIX_PATH" ) : appPath;
1084
1085 // check if QGIS is run from build directory (not the install directory)
1086 QFile f;
1087 // "/../../.." is for Mac bundled app in build directory
1088 static const QStringList paths { QStringList() << QString() << u"/.."_s << u"/bin"_s << u"/../../.."_s };
1089 for ( const QString &path : paths )
1090 {
1091 f.setFileName( prefix + path + "/qgisbuildpath.txt" );
1092 if ( f.exists() )
1093 break;
1094 }
1095 if ( f.exists() && f.open( QIODevice::ReadOnly ) )
1096 {
1097 ABISYM( mRunningFromBuildDir ) = true;
1098 *sBuildSourcePath() = f.readLine().trimmed();
1099 *sBuildOutputPath() = f.readLine().trimmed();
1100 QgsDebugMsgLevel( u"Running from build directory!"_s, 4 );
1101 QgsDebugMsgLevel( u"- source directory: %1"_s.arg( sBuildSourcePath()->toUtf8().constData() ), 4 );
1102 QgsDebugMsgLevel( u"- output directory of the build: %1"_s.arg( sBuildOutputPath()->toUtf8().constData() ), 4 );
1103#if defined( _MSC_VER ) && !defined( USING_NMAKE ) && !defined( USING_NINJA )
1104 *sCfgIntDir() = prefix.split( '/', Qt::SkipEmptyParts ).last();
1105 qDebug( "- cfg: %s", sCfgIntDir()->toUtf8().constData() );
1106#endif
1107 }
1108 }
1109
1110 QString prefixPath;
1111 if ( getenv( "QGIS_PREFIX_PATH" ) )
1112 prefixPath = getenv( "QGIS_PREFIX_PATH" );
1113 else
1114 {
1115#if defined( ANDROID )
1116 // this is "/data/data/org.qgis.qgis" in android
1117 QDir dir( QDir::homePath() );
1118 dir.cdUp();
1119 prefixPath = dir.absolutePath();
1120#else
1121
1122#if defined( Q_OS_MACOS ) && defined( QGIS_MAC_BUNDLE )
1123 // Go from QGIS.app/Contents/MacOS to the bundle root, like QgsApplication::init() does
1124 QDir dir( appPath + "/../.."_L1 );
1125 prefixPath = dir.absolutePath();
1126#elif defined( Q_OS_MACOS )
1127 prefixPath = appPath;
1128#elif defined( Q_OS_WIN )
1129 prefixPath = appPath;
1130 if ( prefixPath.endsWith( "/bin" ) )
1131 prefixPath.chop( 4 );
1132#else
1133 QDir dir( appPath );
1134 // Fix for server which is one level deeper in /usr/lib/cgi-bin
1135 if ( appPath.contains( u"cgi-bin"_s ) )
1136 {
1137 dir.cdUp();
1138 }
1139 dir.cdUp(); // Go from /usr/bin or /usr/lib (for server) to /usr
1140 prefixPath = dir.absolutePath();
1141#endif
1142#endif
1143 }
1144
1145 if ( ABISYM( mRunningFromBuildDir ) )
1146 return *sBuildOutputPath() + u"/data"_s;
1147 else
1148 return prefixPath + '/' + QStringLiteral( QGIS_DATA_SUBDIR );
1149}
1150
1152{
1153 return *sThemeName();
1154}
1155
1157{
1158 // Loop all style sheets, find matching name, load it.
1159 const QString path = applicationThemeRegistry()->themeFolder( themeName );
1160 if ( themeName == "default"_L1 || path.isEmpty() )
1161 {
1162 setThemeName( u"default"_s );
1163 qApp->setStyleSheet( QString() );
1165 return;
1166 }
1167
1168 QFile file( path + "/style.qss" );
1169 QFile variablesfile( path + "/variables.qss" );
1170 QFileInfo variableInfo( variablesfile );
1171
1172 if ( !file.open( QIODevice::ReadOnly ) || ( variableInfo.exists() && !variablesfile.open( QIODevice::ReadOnly ) ) )
1173 {
1174 qApp->setStyleSheet( QString() );
1176 return;
1177 }
1178
1179 QFile palettefile( path + "/palette.txt" );
1180 QFileInfo paletteInfo( palettefile );
1181 if ( paletteInfo.exists() && palettefile.open( QIODevice::ReadOnly ) )
1182 {
1183 QPalette pal = qApp->palette();
1184 QTextStream in( &palettefile );
1185 while ( !in.atEnd() )
1186 {
1187 QString line = in.readLine();
1188 QStringList parts = line.split( ':' );
1189 if ( parts.count() == 2 )
1190 {
1191 int role = parts.at( 0 ).trimmed().toInt();
1192 QColor color = QgsSymbolLayerUtils::decodeColor( parts.at( 1 ).trimmed() );
1193 pal.setColor( static_cast< QPalette::ColorRole >( role ), color );
1194 }
1195 }
1196 palettefile.close();
1197 qApp->setPalette( pal );
1198 }
1199
1200 QString styledata = file.readAll();
1201 styledata.replace( "@theme_path"_L1, path );
1202
1203 if ( variableInfo.exists() )
1204 {
1205 QTextStream in( &variablesfile );
1206 while ( !in.atEnd() )
1207 {
1208 QString line = in.readLine();
1209 // This is a variable
1210 if ( line.startsWith( '@' ) )
1211 {
1212 int index = line.indexOf( ':' );
1213 QString name = line.mid( 0, index );
1214 QString value = line.mid( index + 1, line.length() );
1215 styledata.replace( name, value );
1216 }
1217 }
1218 variablesfile.close();
1219 }
1220 file.close();
1221
1222 if ( Qgis::UI_SCALE_FACTOR != 1.0 )
1223 {
1224 // apply OS-specific UI scale factor to stylesheet's em values
1225 int index = 0;
1226 const thread_local QRegularExpression regex( u"(?<=[\\s:])([0-9\\.]+)(?=em)"_s );
1227 QRegularExpressionMatch match = regex.match( styledata, index );
1228 while ( match.hasMatch() )
1229 {
1230 index = match.capturedStart();
1231 styledata.remove( index, match.captured( 0 ).length() );
1232 QString number = QString::number( match.captured( 0 ).toDouble() * Qgis::UI_SCALE_FACTOR );
1233 styledata.insert( index, number );
1234 index += number.length();
1235 match = regex.match( styledata, index );
1236 }
1237 }
1238
1239 qApp->setStyleSheet( styledata );
1240
1243}
1244
1245QHash<QString, QString> QgsApplication::uiThemes()
1246{
1247 QHash<QString, QString> mapping = applicationThemeRegistry()->themeFolders();
1248 mapping.insert( u"default"_s, QString() );
1249 return mapping;
1250}
1251
1253{
1254 return pkgDataPath() + u"/doc/AUTHORS"_s;
1255}
1256
1258{
1259 return pkgDataPath() + u"/doc/CONTRIBUTORS"_s;
1260}
1261
1263{
1264 return pkgDataPath() + u"/doc/SPONSORS"_s;
1265}
1266
1268{
1269 return pkgDataPath() + u"/doc/DONORS"_s;
1270}
1271
1273{
1274 return pkgDataPath() + u"/doc/TRANSLATORS"_s;
1275}
1276
1278{
1279 return pkgDataPath() + u"/doc/LICENSE"_s;
1280}
1281
1283{
1284 if ( ABISYM( mRunningFromBuildDir ) )
1285 return *sBuildOutputPath() + u"/i18n/"_s;
1286 else
1287 return pkgDataPath() + u"/i18n/"_s;
1288}
1289
1291{
1292 return pkgDataPath() + u"/resources/metadata-ISO/"_s;
1293}
1294
1296{
1297 return pkgDataPath() + u"/resources/qgis.db"_s;
1298}
1299
1301{
1302 return *sConfigPath();
1303}
1304
1306{
1307 return qgisSettingsDirPath() + u"qgis.db"_s;
1308}
1309
1311{
1312 return *sAuthDbDirPath() + u"qgis-auth.db"_s;
1313}
1314
1316{
1317 return *sAuthDbUri();
1318}
1319
1321{
1322 return u":/images/splash/"_s;
1323}
1324
1326{
1327 return pkgDataPath() + u"/images/icons/"_s;
1328}
1329
1331{
1332 if ( ABISYM( mRunningFromBuildDir ) )
1333 {
1334 QString tempCopy = QDir::tempPath() + "/srs.db";
1335
1336 if ( !QFile( tempCopy ).exists() )
1337 {
1338 QFile f( buildSourcePath() + "/resources/srs.db" );
1339 if ( !f.copy( tempCopy ) )
1340 {
1341 qFatal( "Could not create temporary copy" );
1342 }
1343 }
1344
1345 return tempCopy;
1346 }
1347 else
1348 {
1349 return pkgDataPath() + u"/resources/srs.db"_s;
1350 }
1351}
1352
1357
1359{
1360 QStringList configuredPaths = settingsProjectTemplatePaths->value();
1361
1362 // Normalize the paths and avoid duplicates
1363 QStringList paths;
1364 for ( const QString &configuredPath : std::as_const( configuredPaths ) )
1365 {
1366 const QString path = QDir::cleanPath( QDir( configuredPath ).absolutePath() );
1367 if ( !paths.contains( path ) )
1368 paths.append( path );
1369 }
1370 return paths;
1371}
1372
1374{
1375 return { qgisSettingsDirPath() + u"/project_templates"_s };
1376}
1377
1378void QgsApplication::setSvgPaths( const QStringList &svgPaths )
1379{
1381 members()->mSvgPathCacheValid = false;
1382}
1383
1385{
1386 static QReadWriteLock lock;
1387
1389
1390 if ( members()->mSvgPathCacheValid )
1391 {
1392 return members()->mSvgPathCache;
1393 }
1394 else
1395 {
1397 //local directories to search when looking for an SVG with a given basename
1398 //defined by user in options dialog
1399 const QStringList pathList = settingsSearchPathsForSVG->value();
1400
1401 // maintain user set order while stripping duplicates
1402 QStringList paths;
1403 for ( const QString &path : pathList )
1404 {
1405 if ( !paths.contains( path ) )
1406 paths.append( path );
1407 }
1408 for ( const QString &path : std::as_const( *sDefaultSvgPaths() ) )
1409 {
1410 if ( !paths.contains( path ) )
1411 paths.append( path );
1412 }
1413 members()->mSvgPathCache = paths;
1414
1415 return paths;
1416 }
1417}
1418
1420{
1421 //local directories to search when looking for an template with a given basename
1422 //defined by user in options dialog
1424}
1425
1426QMap<QString, QString> QgsApplication::systemEnvVars()
1427{
1428 return *sSystemEnvVars();
1429}
1430
1432{
1433 return qgisSettingsDirPath() + u"symbology-style.db"_s;
1434}
1435
1437{
1438 const thread_local QRegularExpression regexp( QRegularExpression::anchoredPattern( u"^[A-Za-z][A-Za-z0-9\\._-]*"_s ) );
1439 return regexp;
1440}
1441
1443{
1444 if ( !sUserName()->isEmpty() )
1445 return *sUserName();
1446
1447#ifdef _MSC_VER
1448 TCHAR name[UNLEN + 1];
1449 DWORD size = UNLEN + 1;
1450
1451 if ( GetUserName( ( TCHAR * ) name, &size ) )
1452 {
1453 *sUserName() = QString::fromWCharArray( name );
1454 }
1455
1456
1457#elif QT_CONFIG( process )
1458 QProcess process;
1459
1460 process.start( u"whoami"_s, QStringList() );
1461 process.waitForFinished();
1462 *sUserName() = process.readAllStandardOutput().trimmed();
1463#endif
1464
1465 if ( !sUserName()->isEmpty() )
1466 return *sUserName();
1467
1468 //backup plan - use environment variables
1469 *sUserName() = qgetenv( "USER" );
1470 if ( !sUserName()->isEmpty() )
1471 return *sUserName();
1472
1473 //last resort
1474 *sUserName() = qgetenv( "USERNAME" );
1475 return *sUserName();
1476}
1477
1479{
1480 if ( !sUserFullName()->isEmpty() )
1481 return *sUserFullName();
1482
1483#ifdef _MSC_VER
1484 TCHAR name[UNLEN + 1];
1485 DWORD size = UNLEN + 1;
1486
1487 //note - this only works for accounts connected to domain
1488 if ( GetUserNameEx( NameDisplay, ( TCHAR * ) name, &size ) )
1489 {
1490 *sUserFullName() = QString::fromWCharArray( name );
1491 }
1492
1493 //fall back to login name
1494 if ( sUserFullName()->isEmpty() )
1495 *sUserFullName() = userLoginName();
1496#elif defined( Q_OS_ANDROID ) || defined( __MINGW32__ )
1497 *sUserFullName() = u"Not available"_s;
1498#else
1499 struct passwd *p = getpwuid( getuid() );
1500
1501 if ( p )
1502 {
1503 QString gecosName = QString( p->pw_gecos );
1504 *sUserFullName() = gecosName.left( gecosName.indexOf( ',', 0 ) );
1505 }
1506
1507#endif
1508
1509 return *sUserFullName();
1510}
1511
1513{
1514#if defined( Q_OS_ANDROID )
1515 return "android"_L1;
1516#elif defined( Q_OS_MAC )
1517 return "osx"_L1;
1518#elif defined( Q_OS_WIN )
1519 return "windows"_L1;
1520#elif defined( Q_OS_LINUX )
1521 return u"linux"_s;
1522#elif defined( Q_OS_FREEBSD )
1523 return u"freebsd"_s;
1524#elif defined( Q_OS_OPENBSD )
1525 return u"openbsd"_s;
1526#elif defined( Q_OS_NETBSD )
1527 return u"netbsd"_s;
1528#elif defined( Q_OS_UNIX )
1529 return "unix"_L1;
1530#else
1531 return "unknown"_L1;
1532#endif
1533}
1534
1536{
1537 // Bytes to Mb (using 1024 * 1024)
1538 return static_cast<int>( CPLGetUsablePhysicalRAM() / 1048576 );
1539}
1540
1542{
1543 return *sPlatformName();
1544}
1545
1547{
1548 if ( !sApplicationFullName()->isEmpty() )
1549 return *sApplicationFullName();
1550
1551 //use environment variables
1552 *sApplicationFullName() = qgetenv( "QGIS_APPLICATION_FULL_NAME" );
1553 if ( !sApplicationFullName()->isEmpty() )
1554 return *sApplicationFullName();
1555
1556 //last resort
1557 const QString storedFullName = settingsApplicationFullName->value();
1558 if ( !storedFullName.isEmpty() )
1559 *sApplicationFullName() = storedFullName;
1560 else
1561 *sApplicationFullName() = u"%1 %2"_s.arg( applicationName(), platform() );
1562 return *sApplicationFullName();
1563}
1564
1566{
1567 if ( settingsLocaleOverrideFlag->value() )
1568 {
1569 QString locale = settingsLocaleUserLocale->value();
1570 // don't differentiate en_US and en_GB
1571 if ( locale.startsWith( "en"_L1, Qt::CaseInsensitive ) )
1572 {
1573 return locale.left( 2 );
1574 }
1575
1576 return locale;
1577 }
1578 else
1579 {
1580 return QLocale().name().left( 2 );
1581 }
1582}
1583
1584void QgsApplication::setLocale( const QLocale &locale )
1585{
1586 QLocale::setDefault( locale );
1587 emit instance() -> localeChanged();
1588}
1589
1591{
1592 return qgisSettingsDirPath() + u"/themes"_s;
1593}
1594
1596{
1597 return pkgDataPath() + u"/resources/symbology-style.xml"_s;
1598}
1599
1601{
1602 return pkgDataPath() + u"/resources/themes"_s;
1603}
1604
1606{
1607 return pkgDataPath() + u"/resources/server/"_s;
1608}
1609
1611{
1612 return *sLibraryPath();
1613}
1614
1616{
1617 return *sLibexecPath();
1618}
1619
1621{
1622 return *sQmlImportPath();
1623}
1624
1626{
1627 return ( htonl( 1 ) == 1 ) ? XDR : NDR;
1628}
1629
1631{
1632 if ( !ABISYM( mInitialized ) && QgsApplication::instance() )
1633 {
1634 init( *sProfilePath() );
1635 }
1636
1637 // set the provider plugin path (this creates provider registry)
1639
1640 // create data item provider registry
1642
1643 // create project instance if doesn't exist
1644 QgsProject::instance(); // skip-keyword-check
1645
1646 // Setup authentication manager for lazy initialization
1648
1649 // Make sure we have a NAM created on the main thread.
1650 // Note that this might call QgsApplication::authManager to
1651 // setup the proxy configuration that's why it needs to be
1652 // called after the QgsAuthManager instance has been created
1654}
1655
1657{
1658 if ( auto *lInstance = instance() )
1659 {
1660 if ( !lInstance->mAuthManager )
1661 {
1662 lInstance->mAuthManager = QgsAuthManager::instance();
1663 }
1664 return lInstance->mAuthManager;
1665 }
1666 else
1667 {
1668 // no QgsApplication instance
1669 if ( !sAuthManager )
1670 sAuthManager = QgsAuthManager::instance();
1671 return sAuthManager;
1672 }
1673}
1674
1679
1680
1682{
1683 // make sure all threads are done before exiting
1684 QThreadPool::globalInstance()->waitForDone();
1685
1686 // don't create to delete
1687 if ( auto *lInstance = instance() )
1688 delete lInstance->mAuthManager;
1689 else
1690 delete sAuthManager;
1691
1692 //Ensure that all remaining deleteLater QObjects are actually deleted before we exit.
1693 QgsApplication::sendPostedEvents( nullptr, QEvent::DeferredDelete );
1694
1695 //delete all registered functions from expression engine (see above comment)
1697
1698 // avoid creating instance just to delete it!
1699 if ( QgsProject::sProject )
1700 delete QgsProject::instance(); // skip-keyword-check
1701
1702 //Ensure that providers/layers which called deleteLater on objects as part of their cleanup
1703 //result in fully deleted objects before we do the provider registry cleanup.
1704 //E.g. the QgsOgrConnPool instance has deleteLater calls when unrefing layers, so clearing
1705 //the project above has not yet fully cleaned up OGR objects, which we MUST do before
1706 //cleaning up the provider
1707 QgsApplication::sendPostedEvents( nullptr, QEvent::DeferredDelete );
1708
1709 // avoid creating instance just to delete it!
1710 if ( QgsProviderRegistry::exists() )
1712
1713 invalidateCaches();
1714
1716
1717 // tear-down GDAL/OGR, but only if there are no remaining opened
1718 // datasets (cf https://github.com/qgis/QGIS/issues/58724)
1719 // Outputting to stdin is obviously absurd, but intended here, since
1720 // we are just interested in the count of still open datasets.
1721 if ( GDALDumpOpenDatasets( stdin ) == 0 )
1722 {
1723 OGRCleanupAll();
1724 GDALDestroyDriverManager();
1725 }
1726 else
1727 QgsDebugMsgLevel( u"Skipping call to GDALDestroyDriverManager() due to still opened datasets"_s, 5 );
1728}
1729
1731{
1732 QString myEnvironmentVar( getenv( "QGIS_PREFIX_PATH" ) );
1733 QString myState
1734 = tr(
1735 "QgsApplication state:\n"
1736 " - QGIS_PREFIX_PATH env var: %1\n"
1737 " - Prefix: %2\n"
1738 " - Plugin Path: %3\n"
1739 " - Package Data Path: %4\n"
1740 " - Active Theme Name: %5\n"
1741 " - Active Theme Path: %6\n"
1742 " - Default Theme Path: %7\n"
1743 " - SVG Search Paths: %8\n"
1744 " - User DB Path: %9\n"
1745 " - Auth DB Path: %10\n"
1746 )
1747 .arg( myEnvironmentVar, prefixPath(), pluginPath(), pkgDataPath(), themeName(), activeThemePath(), defaultThemePath(), svgPaths().join( tr( "\n ", "match indentation of application state" ) ), qgisMasterDatabaseFilePath() )
1748 .arg( QgsAuthManager::instance()->authenticationDatabaseUriStripped() );
1749 return myState;
1750}
1751
1753{
1754 //
1755 // Make the style sheet desktop preferences aware by using qapplication
1756 // palette as a basis for colors where appropriate
1757 //
1758 // QColor myColor1 = palette().highlight().color();
1759 QColor myColor1( Qt::lightGray );
1760 QColor myColor2 = myColor1;
1761 myColor2 = myColor2.lighter( 110 ); //10% lighter
1762 QString myStyle;
1763 myStyle = QStringLiteral(
1764 ".overview{"
1765 " font: 1.82em;"
1766 " font-weight: bold;"
1767 "}"
1768 "body{"
1769 " background: white;"
1770 " color: black;"
1771 " font-family: 'Lato', 'Open Sans', 'Lucida Grande', 'Segoe UI', 'Arial', sans-serif;"
1772 " width: 100%;"
1773 "}"
1774 "h1{ background-color: #F6F6F6;"
1775 " color: #589632; " // from https://qgis.org/styleguide/
1776 " font-size: x-large; "
1777 " font-weight: normal;"
1778 " background: none;"
1779 " padding: 0.75em 0 0;"
1780 " margin: 0;"
1781 " line-height: 3em;"
1782 "}"
1783 "h2{ background-color: #F6F6F6;"
1784 " color: #589632; " // from https://qgis.org/styleguide/
1785 " font-size: medium; "
1786 " font-weight: normal;"
1787 " background: none;"
1788 " padding: 0.75em 0 0;"
1789 " margin: 0;"
1790 " line-height: 1.1em;"
1791 "}"
1792 "h3{ background-color: #F6F6F6;"
1793 " color: #93b023;" // from https://qgis.org/styleguide/
1794 " font-weight: bold;"
1795 " font-size: large;"
1796 " text-align: left;"
1797 " border-bottom: 5px solid #DCEB5C;"
1798 "}"
1799 "h4{ background-color: #F6F6F6;"
1800 " color: #93b023;" // from https://qgis.org/styleguide/
1801 " font-weight: bold;"
1802 " font-size: medium;"
1803 " text-align: left;"
1804 "}"
1805 "h5{ background-color: #F6F6F6;"
1806 " color: #93b023;" // from https://qgis.org/styleguide/
1807 " font-weight: bold;"
1808 " font-size: small;"
1809 " text-align: left;"
1810 "}"
1811 "a{ color: #729FCF;"
1812 " font-family: arial,sans-serif;"
1813 "}"
1814 "label{ background-color: #FFFFCC;"
1815 " border: 1px solid black;"
1816 " margin: 1px;"
1817 " padding: 0px 3px; "
1818 " font-size: small;"
1819 "}"
1820 "th .strong {"
1821 " font-weight: bold;"
1822 "}"
1823 "hr {"
1824 " border: 0;"
1825 " height: 0;"
1826 " border-top: 1px solid black;"
1827 "}"
1828 ".list-view .highlight {"
1829 " text-align: left;"
1830 " border: 0px;"
1831 " width: 20%;"
1832 " padding-right: 15px;"
1833 " padding-left: 20px;"
1834 " font-weight: bold;"
1835 "}"
1836 ".tabular-view .odd-row {"
1837 " background-color: #f9f9f9;"
1838 "}"
1839 ".section {"
1840 " font-weight: bold;"
1841 " padding-top:25px;"
1842 "}"
1843 );
1844
1845 // We have some subtle differences between Qt based style and QWebKit style
1846 switch ( styleSheetType )
1847 {
1848 case StyleSheetType::Qt:
1849 myStyle += QStringLiteral(
1850 ".tabular-view{ "
1851 " border-collapse: collapse;"
1852 " width: 95%;"
1853 "}"
1854 ".tabular-view th, .tabular-view td { "
1855 " border:1px solid black;"
1856 "}"
1857 );
1858 break;
1859
1861 myStyle += QStringLiteral(
1862 "body { "
1863 " margin: auto;"
1864 " width: 97%;"
1865 "}"
1866 "table.tabular-view, table.list-view { "
1867 " border-collapse: collapse;"
1868 " table-layout:fixed;"
1869 " width: 100% !important;"
1870 " font-size: 90%;"
1871 "}"
1872 // Override
1873 "h1 { "
1874 " line-height: inherit;"
1875 "}"
1876 "td, th {"
1877 " word-wrap: break-word; "
1878 " vertical-align: top;"
1879 "}"
1880 // Set first column width
1881 ".list-view th:first-child, .list-view td:first-child {"
1882 " width: 20%;"
1883 "}"
1884 ".list-view.highlight { "
1885 " padding-left: inherit; "
1886 "}"
1887 // Set first column width for inner tables
1888 ".tabular-view th:first-child, .tabular-view td:first-child { "
1889 " width: 20%; "
1890 "}"
1891 // Makes titles bg stand up
1892 ".tabular-view th.strong { "
1893 " background-color: #eee; "
1894 "}"
1895 // Give some visual appearance to those ugly nested tables
1896 ".tabular-view th, .tabular-view td { "
1897 " border: 1px solid #eee;"
1898 "}"
1899 );
1900 break;
1901 }
1902
1903 return myStyle;
1904}
1905
1907{
1908 if ( 0 >= OGRGetDriverCount() )
1909 {
1910 OGRRegisterAll();
1911 }
1912}
1913
1914QString QgsApplication::absolutePathToRelativePath( const QString &aPath, const QString &targetPath )
1915{
1916 QString aPathUrl = aPath;
1917 QString tPathUrl = targetPath;
1918#if defined( Q_OS_WIN )
1919 const Qt::CaseSensitivity cs = Qt::CaseInsensitive;
1920
1921 aPathUrl.replace( '\\', '/' );
1922 if ( aPathUrl.startsWith( "//" ) )
1923 {
1924 // keep UNC prefix
1925 aPathUrl = "\\\\" + aPathUrl.mid( 2 );
1926 }
1927
1928 tPathUrl.replace( '\\', '/' );
1929 if ( tPathUrl.startsWith( "//" ) )
1930 {
1931 // keep UNC prefix
1932 tPathUrl = "\\\\" + tPathUrl.mid( 2 );
1933 }
1934#else
1935 const Qt::CaseSensitivity cs = Qt::CaseSensitive;
1936#endif
1937
1938 QStringList targetElems = tPathUrl.split( '/', Qt::SkipEmptyParts );
1939 QStringList aPathElems = aPathUrl.split( '/', Qt::SkipEmptyParts );
1940
1941 targetElems.removeAll( u"."_s );
1942 aPathElems.removeAll( u"."_s );
1943
1944 // remove common part
1945 int n = 0;
1946 while ( !aPathElems.isEmpty() && !targetElems.isEmpty() && aPathElems[0].compare( targetElems[0], cs ) == 0 )
1947 {
1948 aPathElems.removeFirst();
1949 targetElems.removeFirst();
1950 n++;
1951 }
1952
1953 if ( n == 0 )
1954 {
1955 // no common parts; might not even be a file
1956 return aPathUrl;
1957 }
1958
1959 if ( !targetElems.isEmpty() )
1960 {
1961 // go up to the common directory
1962 for ( int i = 0; i < targetElems.size(); i++ )
1963 {
1964 aPathElems.insert( 0, u".."_s );
1965 }
1966 }
1967 else
1968 {
1969 // let it start with . nevertheless,
1970 // so relative path always start with either ./ or ../
1971 aPathElems.insert( 0, u"."_s );
1972 }
1973
1974 return aPathElems.join( '/'_L1 );
1975}
1976
1977QString QgsApplication::relativePathToAbsolutePath( const QString &rpath, const QString &targetPath )
1978{
1979 // relative path should always start with ./ or ../
1980 if ( !rpath.startsWith( "./"_L1 ) && !rpath.startsWith( "../"_L1 ) )
1981 {
1982 return rpath;
1983 }
1984
1985 QString rPathUrl = rpath;
1986 QString targetPathUrl = targetPath;
1987
1988#if defined( Q_OS_WIN )
1989 rPathUrl.replace( '\\', '/' );
1990 targetPathUrl.replace( '\\', '/' );
1991
1992 bool uncPath = targetPathUrl.startsWith( "//" );
1993#endif
1994
1995 QStringList srcElems = rPathUrl.split( '/', Qt::SkipEmptyParts );
1996 QStringList targetElems = targetPathUrl.split( '/', Qt::SkipEmptyParts );
1997
1998#if defined( Q_OS_WIN )
1999 if ( uncPath )
2000 {
2001 targetElems.insert( 0, "" );
2002 targetElems.insert( 0, "" );
2003 }
2004#endif
2005
2006 // append source path elements
2007 targetElems << srcElems;
2008 targetElems.removeAll( u"."_s );
2009
2010 // resolve ..
2011 int pos;
2012 while ( ( pos = targetElems.indexOf( ".."_L1 ) ) > 0 )
2013 {
2014 // remove preceding element and ..
2015 targetElems.removeAt( pos - 1 );
2016 targetElems.removeAt( pos - 1 );
2017 }
2018
2019#if !defined( Q_OS_WIN )
2020 // make path absolute
2021 targetElems.prepend( QString() );
2022#endif
2023
2024 return targetElems.join( '/'_L1 );
2025}
2026
2028{
2029 return *sBuildSourcePath();
2030}
2031
2033{
2034 return *sBuildOutputPath();
2035}
2036
2037#if defined( _MSC_VER ) && !defined( USING_NMAKE ) && !defined( USING_NINJA )
2038QString QgsApplication::cfgIntDir()
2039{
2040 return *sCfgIntDir();
2041}
2042#endif
2043
2044void QgsApplication::skipGdalDriver( const QString &driver )
2045{
2046 if ( sGdalSkipList()->contains( driver ) || driver.isEmpty() )
2047 {
2048 return;
2049 }
2050 *sGdalSkipList() << driver;
2052}
2053
2054void QgsApplication::restoreGdalDriver( const QString &driver )
2055{
2056 if ( !sGdalSkipList()->contains( driver ) )
2057 {
2058 return;
2059 }
2060 int myPos = sGdalSkipList()->indexOf( driver );
2061 if ( myPos >= 0 )
2062 {
2063 sGdalSkipList()->removeAt( myPos );
2064 }
2066}
2067
2069{
2070 return *sGdalSkipList();
2071}
2072
2074{
2075 *sGdalSkipList() = skippedGdalDrivers;
2076 *sDeferredSkippedGdalDrivers() = deferredSkippedGdalDrivers;
2077
2079
2081}
2082
2088
2090{
2091 return *sDeferredSkippedGdalDrivers();
2092}
2093
2095{
2096 sGdalSkipList()->removeDuplicates();
2097 QStringList realDisabledDriverList;
2098 for ( const auto &driverName : *sGdalSkipList() )
2099 {
2100 if ( !sDeferredSkippedGdalDrivers()->contains( driverName ) )
2101 realDisabledDriverList << driverName;
2102 }
2103 QString myDriverList = realDisabledDriverList.join( ',' );
2104 QgsDebugMsgLevel( u"Gdal Skipped driver list set to:"_s, 2 );
2105 QgsDebugMsgLevel( myDriverList, 2 );
2106 CPLSetConfigOption( "GDAL_SKIP", myDriverList.toUtf8() );
2107 GDALAllRegister(); //to update driver list and skip missing ones
2108}
2109
2111{
2112 QString folder = userThemesFolder();
2113 QDir myDir( folder );
2114 if ( !myDir.exists() )
2115 {
2116 myDir.mkpath( folder );
2117 }
2118
2119 return true;
2120}
2121
2122void QgsApplication::copyPath( const QString &src, const QString &dst )
2123{
2124 QDir dir( src );
2125 if ( !dir.exists() )
2126 return;
2127
2128 const auto subDirectories = dir.entryList( QDir::Dirs | QDir::NoDotAndDotDot );
2129 for ( const QString &d : subDirectories )
2130 {
2131 QString dst_path = dst + QDir::separator() + d;
2132 dir.mkpath( dst_path );
2133 copyPath( src + QDir::separator() + d, dst_path );
2134 }
2135
2136 const auto files = dir.entryList( QDir::Files );
2137 for ( const QString &f : files )
2138 {
2139 QFile::copy( src + QDir::separator() + f, dst + QDir::separator() + f );
2140 }
2141}
2142
2144{
2145 QVariantMap variables;
2146
2147 const QStringList names = sTreeCustomVariables->items();
2148 for ( const QString &name : names )
2149 {
2150 variables.insert( name, settingsCustomVariable->value( name ) );
2151 }
2152
2153 return variables;
2154}
2155
2156void QgsApplication::setCustomVariables( const QVariantMap &variables )
2157{
2158 sTreeCustomVariables->deleteAllItems();
2159 for ( auto it = variables.constBegin(); it != variables.constEnd(); ++it )
2160 {
2161 settingsCustomVariable->setValue( it.value(), { it.key() } );
2162 }
2163
2164 emit instance() -> customVariablesChanged();
2165}
2166
2167void QgsApplication::setCustomVariable( const QString &name, const QVariant &value )
2168{
2169 settingsCustomVariable->setValue( value, { name } );
2170
2171 emit instance() -> customVariablesChanged();
2172}
2173
2175{
2176 return instance()->mTemporarilyTrustedProjectFolders;
2177}
2178
2179void QgsApplication::setTemporarilyTrustedProjectsFolders( const QStringList &trustedProjectsFolders )
2180{
2181 instance()->mTemporarilyTrustedProjectFolders = trustedProjectsFolders;
2182}
2183
2185{
2186 return instance()->mTemporarilyUntrustedProjectFolders;
2187}
2188
2189void QgsApplication::setTemporarilyUntrustedProjectsFolders( const QStringList &untrustedProjectsFolders )
2190{
2191 instance()->mTemporarilyUntrustedProjectFolders = untrustedProjectsFolders;
2192}
2193
2194int QgsApplication::scaleIconSize( int standardSize, bool applyDevicePixelRatio )
2195{
2196 QFontMetrics fm( ( QFont() ) );
2197 const double scale = 1.1 * standardSize / 24;
2198 int scaledIconSize = static_cast< int >( std::floor( std::max( Qgis::UI_SCALE_FACTOR * fm.height() * scale, static_cast< double >( standardSize ) ) ) );
2199 if ( applyDevicePixelRatio )
2200 {
2201 if ( QWidget *activeWindow = QApplication::activeWindow() )
2202 scaledIconSize *= ( activeWindow->screen() ? QApplication::activeWindow()->screen()->devicePixelRatio() : 1 );
2203 }
2204 return scaledIconSize;
2205}
2206
2211
2213{
2214 *sTranslation() = translation;
2215 if ( auto app = QgsApplication::instance() )
2216 {
2217 app->installTranslators();
2218 }
2219}
2220
2222{
2223 return *sTranslation();
2224}
2225
2227{
2228 emit requestForTranslatableObjects( translationContext );
2229}
2230
2232{
2233 ApplicationMembers *appMembers = members();
2234 if ( appMembers->mNullRepresentation.isNull() )
2235 {
2236 appMembers->mNullRepresentation = settingsNullRepresentation->value();
2237 }
2238 return appMembers->mNullRepresentation;
2239}
2240
2242{
2243 ApplicationMembers *appMembers = members();
2244 if ( !appMembers || appMembers->mNullRepresentation == nullRepresentation )
2245 return;
2246
2249
2250 QgsApplication *app = instance();
2251 if ( app )
2252 emit app->nullRepresentationChanged();
2253}
2254
2256{
2257 return members()->mActionScopeRegistry.get();
2258}
2259
2260bool QgsApplication::createDatabase( QString *errorMessage )
2261{
2262 // set a working directory up for gdal to write .aux.xml files into
2263 // for cases where the raster dir is read only to the user
2264 // if the env var is already set it will be used preferentially
2265 QString myPamPath = qgisSettingsDirPath() + u"gdal_pam/"_s;
2266 QDir myDir( myPamPath );
2267 if ( !myDir.exists() )
2268 {
2269 myDir.mkpath( myPamPath ); //fail silently
2270 }
2271
2272#if defined( Q_OS_WIN )
2273 CPLSetConfigOption( "GDAL_PAM_PROXY_DIR", myPamPath.toUtf8() );
2274#else
2275 //under other OS's we use an environment var so the user can
2276 //override the path if he likes
2277 int myChangeFlag = 0; //whether we want to force the env var to change
2278 setenv( "GDAL_PAM_PROXY_DIR", myPamPath.toUtf8(), myChangeFlag );
2279#endif
2280
2281 // Check qgis.db and make private copy if necessary
2282 QFile qgisPrivateDbFile( QgsApplication::qgisUserDatabaseFilePath() );
2283
2284 // first we look for ~/.qgis/qgis.db
2285 if ( !qgisPrivateDbFile.exists() )
2286 {
2287 // if it doesn't exist we copy it in from the global resources dir
2288 QString qgisMasterDbFileName = QgsApplication::qgisMasterDatabaseFilePath();
2289 QFile masterFile( qgisMasterDbFileName );
2290
2291 // Must be sure there is destination directory ~/.qgis
2292 QDir().mkpath( QgsApplication::qgisSettingsDirPath() );
2293
2294 //now copy the master file into the users .qgis dir
2295 bool isDbFileCopied = masterFile.copy( qgisPrivateDbFile.fileName() );
2296
2297 if ( !isDbFileCopied )
2298 {
2299 if ( errorMessage )
2300 {
2301 *errorMessage = tr( "[ERROR] Can not make qgis.db private copy" );
2302 }
2303 return false;
2304 }
2305
2306 QFile::Permissions perms = QFile( qgisPrivateDbFile.fileName() ).permissions();
2307 if ( !( perms & QFile::WriteOwner ) )
2308 {
2309 if ( !qgisPrivateDbFile.setPermissions( perms | QFile::WriteOwner ) )
2310 {
2311 if ( errorMessage )
2312 {
2313 *errorMessage = tr( "Can not make '%1' user writable" ).arg( qgisPrivateDbFile.fileName() );
2314 }
2315 return false;
2316 }
2317 }
2318 }
2319 else
2320 {
2321 // migrate if necessary
2323 if ( database.open( QgsApplication::qgisUserDatabaseFilePath() ) != SQLITE_OK )
2324 {
2325 if ( errorMessage )
2326 {
2327 *errorMessage = tr( "Could not open qgis.db" );
2328 }
2329 return false;
2330 }
2331
2332 char *errmsg = nullptr;
2333 int res = sqlite3_exec( database.get(), "SELECT srs_id FROM tbl_srs LIMIT 0", nullptr, nullptr, &errmsg );
2334 if ( res != SQLITE_OK )
2335 {
2336 sqlite3_free( errmsg );
2337
2338 // qgis.db is missing tbl_srs, create it
2339 if ( sqlite3_exec(
2340 database.get(),
2341 "DROP INDEX IF EXISTS idx_srsauthid;"
2342 "CREATE TABLE tbl_srs ("
2343 "srs_id INTEGER PRIMARY KEY,"
2344 "description text NOT NULL,"
2345 "projection_acronym text NOT NULL,"
2346 "ellipsoid_acronym NOT NULL,"
2347 "parameters text NOT NULL,"
2348 "srid integer,"
2349 "auth_name varchar,"
2350 "auth_id varchar,"
2351 "is_geo integer NOT NULL,"
2352 "deprecated boolean,"
2353 "wkt text);"
2354 "CREATE INDEX idx_srsauthid on tbl_srs(auth_name,auth_id);",
2355 nullptr,
2356 nullptr,
2357 &errmsg
2358 )
2359 != SQLITE_OK )
2360 {
2361 if ( errorMessage )
2362 {
2363 *errorMessage = tr( "Creation of missing tbl_srs in the private qgis.db failed.\n%1" ).arg( QString::fromUtf8( errmsg ) );
2364 }
2365 sqlite3_free( errmsg );
2366 return false;
2367 }
2368 }
2369 else
2370 {
2371 // test if wkt column exists in database
2372 res = sqlite3_exec( database.get(), "SELECT wkt FROM tbl_srs LIMIT 0", nullptr, nullptr, &errmsg );
2373 if ( res != SQLITE_OK )
2374 {
2375 // need to add wkt column
2376 sqlite3_free( errmsg );
2377 if ( sqlite3_exec(
2378 database.get(),
2379 "DROP INDEX IF EXISTS idx_srsauthid;"
2380 "DROP TABLE IF EXISTS tbl_srs_bak;"
2381 "ALTER TABLE tbl_srs RENAME TO tbl_srs_bak;"
2382 "CREATE TABLE tbl_srs ("
2383 "srs_id INTEGER PRIMARY KEY,"
2384 "description text NOT NULL,"
2385 "projection_acronym text NOT NULL,"
2386 "ellipsoid_acronym NOT NULL,"
2387 "parameters text NOT NULL,"
2388 "srid integer,"
2389 "auth_name varchar,"
2390 "auth_id varchar,"
2391 "is_geo integer NOT NULL,"
2392 "deprecated boolean,"
2393 "wkt text);"
2394 "CREATE INDEX idx_srsauthid on tbl_srs(auth_name,auth_id);"
2395 "INSERT INTO tbl_srs(srs_id,description,projection_acronym,ellipsoid_acronym,parameters,srid,auth_name,auth_id,is_geo,deprecated) SELECT "
2396 "srs_id,description,projection_acronym,ellipsoid_acronym,parameters,srid,'','',is_geo,0 FROM tbl_srs_bak;"
2397 "DROP TABLE tbl_srs_bak",
2398 nullptr,
2399 nullptr,
2400 &errmsg
2401 )
2402 != SQLITE_OK )
2403 {
2404 if ( errorMessage )
2405 {
2406 *errorMessage = tr( "Migration of private qgis.db failed.\n%1" ).arg( QString::fromUtf8( errmsg ) );
2407 }
2408 sqlite3_free( errmsg );
2409 return false;
2410 }
2411 }
2412 }
2413
2414 res = sqlite3_exec( database.get(), "SELECT acronym FROM tbl_projection LIMIT 0", nullptr, nullptr, &errmsg );
2415 if ( res != SQLITE_OK )
2416 {
2417 sqlite3_free( errmsg );
2418
2419 // qgis.db is missing tbl_projection, create it
2420 if ( sqlite3_exec(
2421 database.get(),
2422 "CREATE TABLE tbl_projection ("
2423 "acronym varchar(20) NOT NULL PRIMARY KEY,"
2424 "name varchar(255) NOT NULL default '',"
2425 "notes varchar(255) NOT NULL default '',"
2426 "parameters varchar(255) NOT NULL default ''"
2427 ")",
2428 nullptr,
2429 nullptr,
2430 &errmsg
2431 )
2432 != SQLITE_OK )
2433 {
2434 if ( errorMessage )
2435 {
2436 *errorMessage = tr( "Creation of missing tbl_projection in the private qgis.db failed.\n%1" ).arg( QString::fromUtf8( errmsg ) );
2437 }
2438 sqlite3_free( errmsg );
2439 return false;
2440 }
2441 }
2442
2443 res = sqlite3_exec( database.get(), "SELECT epsg FROM tbl_srs LIMIT 0", nullptr, nullptr, &errmsg );
2444 if ( res == SQLITE_OK )
2445 {
2446 // epsg column exists => need migration
2447 if ( sqlite3_exec(
2448 database.get(),
2449 "DROP INDEX IF EXISTS idx_srsauthid;"
2450 "DROP TABLE IF EXISTS tbl_srs_bak;"
2451 "ALTER TABLE tbl_srs RENAME TO tbl_srs_bak;"
2452 "CREATE TABLE tbl_srs ("
2453 "srs_id INTEGER PRIMARY KEY,"
2454 "description text NOT NULL,"
2455 "projection_acronym text NOT NULL,"
2456 "ellipsoid_acronym NOT NULL,"
2457 "parameters text NOT NULL,"
2458 "srid integer,"
2459 "auth_name varchar,"
2460 "auth_id varchar,"
2461 "is_geo integer NOT NULL,"
2462 "deprecated boolean,"
2463 "wkt text);"
2464 "CREATE INDEX idx_srsauthid on tbl_srs(auth_name,auth_id);"
2465 "INSERT INTO tbl_srs(srs_id,description,projection_acronym,ellipsoid_acronym,parameters,srid,auth_name,auth_id,is_geo,deprecated) SELECT "
2466 "srs_id,description,projection_acronym,ellipsoid_acronym,parameters,srid,'','',is_geo,0 FROM tbl_srs_bak;"
2467 "DROP TABLE tbl_srs_bak",
2468 nullptr,
2469 nullptr,
2470 &errmsg
2471 )
2472 != SQLITE_OK )
2473 {
2474 if ( errorMessage )
2475 {
2476 *errorMessage = tr( "Migration of private qgis.db failed.\n%1" ).arg( QString::fromUtf8( errmsg ) );
2477 }
2478 sqlite3_free( errmsg );
2479 return false;
2480 }
2481 }
2482 else
2483 {
2484 sqlite3_free( errmsg );
2485 }
2486
2487 if ( sqlite3_exec( database.get(), "DROP VIEW vw_srs", nullptr, nullptr, &errmsg ) != SQLITE_OK )
2488 {
2489 QgsDebugError( u"vw_srs didn't exists in private qgis.db: %1"_s.arg( errmsg ) );
2490 }
2491
2492 if ( sqlite3_exec(
2493 database.get(),
2494 "CREATE VIEW vw_srs AS"
2495 " SELECT"
2496 " a.description AS description"
2497 ",a.srs_id AS srs_id"
2498 ",a.is_geo AS is_geo"
2499 ",coalesce(b.name,a.projection_acronym) AS name"
2500 ",a.parameters AS parameters"
2501 ",a.auth_name AS auth_name"
2502 ",a.auth_id AS auth_id"
2503 ",a.deprecated AS deprecated"
2504 " FROM tbl_srs a"
2505 " LEFT OUTER JOIN tbl_projection b ON a.projection_acronym=b.acronym"
2506 " ORDER BY coalesce(b.name,a.projection_acronym),a.description",
2507 nullptr,
2508 nullptr,
2509 &errmsg
2510 )
2511 != SQLITE_OK )
2512 {
2513 if ( errorMessage )
2514 {
2515 *errorMessage = tr( "Update of view in private qgis.db failed.\n%1" ).arg( QString::fromUtf8( errmsg ) );
2516 }
2517 sqlite3_free( errmsg );
2518 return false;
2519 }
2520 }
2521 return true;
2522}
2523
2525{
2526 QgsDebugMsgLevel( u"maxThreads: %1"_s.arg( maxThreads ), 2 );
2527
2528 // make sure value is between 1 and #cores, if not set to -1 (use #cores)
2529 if ( maxThreads < 1 || maxThreads > QThread::idealThreadCount() )
2530 maxThreads = -1;
2531
2532 // force at least 2 threads -- anything less risks deadlocks within Qt itself (e.g in QImage internal mutexes)
2533 if ( maxThreads > 0 && maxThreads < 2 )
2534 maxThreads = 2;
2535
2536 // save value
2537 ABISYM( sMaxThreads ) = maxThreads;
2538
2539 // if -1 use #cores
2540 if ( maxThreads == -1 )
2541 maxThreads = QThread::idealThreadCount();
2542
2543 // set max thread count in QThreadPool
2544 QThreadPool::globalInstance()->setMaxThreadCount( maxThreads );
2545 QgsDebugMsgLevel( u"set QThreadPool max thread count to %1"_s.arg( QThreadPool::globalInstance()->maxThreadCount() ), 2 );
2546}
2547
2549{
2550 return members()->mTaskManager.get();
2551}
2552
2554{
2555 return members()->mSettingsRegistryCore.get();
2556}
2557
2559{
2560 return members()->mColorSchemeRegistry.get();
2561}
2562
2564{
2565 return members()->mPaintEffectRegistry.get();
2566}
2567
2569{
2570 return members()->mRendererRegistry.get();
2571}
2572
2574{
2575 return members()->mRasterRendererRegistry.get();
2576}
2577
2579{
2580 return members()->mPointCloudRendererRegistry.get();
2581}
2582
2584{
2585 return members()->mTiledSceneRendererRegistry.get();
2586}
2587
2589{
2590 if ( auto *lInstance = instance() )
2591 {
2592 if ( !instance()->mDataItemProviderRegistry )
2593 {
2594 lInstance->mDataItemProviderRegistry = std::make_unique<QgsDataItemProviderRegistry>();
2595 }
2596 return lInstance->mDataItemProviderRegistry.get();
2597 }
2598 else
2599 {
2600 // no QgsApplication instance
2601 static QgsDataItemProviderRegistry *sDataItemProviderRegistry = nullptr;
2602 if ( !sDataItemProviderRegistry )
2603 sDataItemProviderRegistry = new QgsDataItemProviderRegistry();
2604 return sDataItemProviderRegistry;
2605 }
2606}
2607
2609{
2610 return members()->mCrsRegistry.get();
2611}
2612
2614{
2615 return members()->mSvgCache.get();
2616}
2617
2619{
2620 return members()->mImageCache.get();
2621}
2622
2624{
2625 return members()->mSourceCache.get();
2626}
2627
2629{
2630 return members()->mNetworkContentFetcherRegistry.get();
2631}
2632
2634{
2635 return members()->mValidityCheckRegistry.get();
2636}
2637
2639{
2640 return members()->mSymbolLayerRegistry.get();
2641}
2642
2644{
2645 return members()->mCalloutRegistry.get();
2646}
2647
2649{
2650 return members()->mLayoutItemRegistry.get();
2651}
2652
2654{
2655 return members()->mAnnotationItemRegistry.get();
2656}
2657
2659{
2660 return members()->mSensorRegistry.get();
2661}
2662
2664{
2665 return members()->mPlotRegistry.get();
2666}
2667
2669{
2670 return members()->mGpsConnectionRegistry.get();
2671}
2672
2674{
2675 return members()->mGpsBabelFormatRegistry.get();
2676}
2677
2679{
2680 return members()->mPluginLayerRegistry.get();
2681}
2682
2684{
2685 return members()->mClassificationMethodRegistry.get();
2686}
2687
2689{
2690 return members()->mBookmarkManager.get();
2691}
2692
2694{
2695 return members()->mTileDownloadManager.get();
2696}
2697
2699{
2700 return members()->mRecentStyleHandler.get();
2701}
2702
2704{
2705 return members()->mQueryLogger.get();
2706}
2707
2709{
2710 return members()->mStyleModel.get();
2711}
2712
2714{
2715 return members()->mFontManager.get();
2716}
2717
2719{
2720 return members()->mMessageLog.get();
2721}
2722
2724{
2725 return members()->mProcessingRegistry.get();
2726}
2727
2729{
2730 return members()->mConnectionRegistry.get();
2731}
2732
2734{
2735 return members()->mLayerMetadataProviderRegistry.get();
2736}
2737
2739{
2740 return members()->mPageSizeRegistry.get();
2741}
2742
2744{
2745 return members()->mAnnotationRegistry.get();
2746}
2747
2749{
2750 return members()->mApplicationThemeRegistry.get();
2751}
2752
2754{
2755 return members()->mNumericFormatRegistry.get();
2756}
2757
2759{
2760 return members()->mFieldFormatterRegistry.get();
2761}
2762
2764{
2765 return members()->m3DRendererRegistry.get();
2766}
2767
2769{
2770 return members()->m3DSymbolRegistry.get();
2771}
2772
2774{
2775 return members()->mMaterialRegistry.get();
2776}
2777
2779{
2780 return members()->mScaleBarRendererRegistry.get();
2781}
2782
2784{
2785 return members()->mLabelingEngineRuleRegistry.get();
2786}
2787
2789{
2790 return members()->mSymbolConverterRegistry.get();
2791}
2792
2794{
2795 return members()->mProjectStorageRegistry.get();
2796}
2797
2799{
2800 return members()->mExternalStorageRegistry.get();
2801}
2802
2804{
2805 return members()->mProfileSourceRegistry.get();
2806}
2807
2809{
2810 return members()->mLocalizedDataPathRegistry.get();
2811}
2812
2814{
2815 // don't use initializer lists or scoped pointers - as more objects are added here we
2816 // will need to be careful with the order of creation/destruction
2817 mSettingsRegistryCore = std::make_unique<QgsSettingsRegistryCore>();
2818 mLocalizedDataPathRegistry = std::make_unique<QgsLocalizedDataPathRegistry>();
2819 mMessageLog = std::make_unique<QgsMessageLog>();
2820 QgsRuntimeProfiler *profiler = QgsRuntimeProfiler::threadLocalInstance();
2821
2822 {
2823 profiler->start( tr( "Create query logger" ) );
2824 mQueryLogger = std::make_unique<QgsDatabaseQueryLog>();
2825 profiler->end();
2826 }
2827 {
2828 profiler->start( tr( "Setup coordinate reference system registry" ) );
2829 mCrsRegistry = std::make_unique<QgsCoordinateReferenceSystemRegistry>();
2830 profiler->end();
2831 }
2832 {
2833 profiler->start( tr( "Create connection registry" ) );
2834 mConnectionRegistry = std::make_unique<QgsConnectionRegistry>();
2835 profiler->end();
2836 }
2837 {
2838 profiler->start( tr( "Create project storage registry" ) );
2839 mProjectStorageRegistry = std::make_unique<QgsProjectStorageRegistry>();
2840 profiler->end();
2841 }
2842 {
2843 profiler->start( tr( "Create layer metadata provider registry" ) );
2844 mLayerMetadataProviderRegistry = std::make_unique<QgsLayerMetadataProviderRegistry>();
2845 profiler->end();
2846 }
2847 {
2848 profiler->start( tr( "Create font manager" ) );
2849 mFontManager = std::make_unique<QgsFontManager>();
2850 profiler->end();
2851 }
2852 {
2853 profiler->start( tr( "Setup task manager" ) );
2854 mTaskManager = std::make_unique<QgsTaskManager>();
2855 profiler->end();
2856 }
2857 {
2858 profiler->start( tr( "Setup action scope registry" ) );
2859 mActionScopeRegistry = std::make_unique<QgsActionScopeRegistry>();
2860 profiler->end();
2861 }
2862 {
2863 profiler->start( tr( "Setup numeric formats" ) );
2864 mNumericFormatRegistry = std::make_unique<QgsNumericFormatRegistry>();
2865 profiler->end();
2866 }
2867 {
2868 profiler->start( tr( "Setup field formats" ) );
2869 mFieldFormatterRegistry = std::make_unique<QgsFieldFormatterRegistry>();
2870 profiler->end();
2871 }
2872 {
2873 profiler->start( tr( "Setup SVG cache" ) );
2874 mSvgCache = std::make_unique<QgsSvgCache>();
2875 profiler->end();
2876 }
2877 {
2878 profiler->start( tr( "Setup image cache" ) );
2879 mImageCache = std::make_unique<QgsImageCache>();
2880 profiler->end();
2881 }
2882 {
2883 profiler->start( tr( "Setup source cache" ) );
2884 mSourceCache = std::make_unique<QgsSourceCache>();
2885 profiler->end();
2886 }
2887 {
2888 profiler->start( tr( "Setup color scheme registry" ) );
2889 mColorSchemeRegistry = std::make_unique<QgsColorSchemeRegistry>();
2890 profiler->end();
2891 }
2892 {
2893 profiler->start( tr( "Setup paint effect" ) );
2894 mPaintEffectRegistry = std::make_unique<QgsPaintEffectRegistry>();
2895 profiler->end();
2896 }
2897 {
2898 profiler->start( tr( "Setup symbol layer registry" ) );
2899 mSymbolLayerRegistry = std::make_unique<QgsSymbolLayerRegistry>();
2900 profiler->end();
2901 }
2902 {
2903 profiler->start( tr( "Recent style handler" ) );
2904 mRecentStyleHandler = std::make_unique<QgsRecentStyleHandler>();
2905 profiler->end();
2906 }
2907 {
2908 profiler->start( tr( "Setup callout registry" ) );
2909 mCalloutRegistry = std::make_unique<QgsCalloutRegistry>();
2910 profiler->end();
2911 }
2912 {
2913 profiler->start( tr( "Setup renderer registry" ) );
2914 mRendererRegistry = std::make_unique<QgsRendererRegistry>();
2915 profiler->end();
2916 }
2917 {
2918 profiler->start( tr( "Setup raster renderer registry" ) );
2919 mRasterRendererRegistry = std::make_unique<QgsRasterRendererRegistry>();
2920 profiler->end();
2921 }
2922 {
2923 profiler->start( tr( "Setup point cloud renderer registry" ) );
2924 mPointCloudRendererRegistry = std::make_unique<QgsPointCloudRendererRegistry>();
2925 profiler->end();
2926 }
2927 {
2928 profiler->start( tr( "Setup tiled scene renderer registry" ) );
2929 mTiledSceneRendererRegistry = std::make_unique<QgsTiledSceneRendererRegistry>();
2930 profiler->end();
2931 }
2932 {
2933 profiler->start( tr( "Setup GPS registry" ) );
2934 mGpsConnectionRegistry = std::make_unique<QgsGpsConnectionRegistry>();
2935 profiler->end();
2936 }
2937 {
2938 profiler->start( tr( "Setup GPSBabel format registry" ) );
2939 mGpsBabelFormatRegistry = std::make_unique<QgsBabelFormatRegistry>();
2940 profiler->end();
2941 }
2942 {
2943 profiler->start( tr( "Setup plugin layer registry" ) );
2944 mPluginLayerRegistry = std::make_unique<QgsPluginLayerRegistry>();
2945 profiler->end();
2946 }
2947 {
2948 profiler->start( tr( "Setup Processing registry" ) );
2949 mProcessingRegistry = std::make_unique<QgsProcessingRegistry>();
2950 profiler->end();
2951 }
2952 mPageSizeRegistry = std::make_unique<QgsPageSizeRegistry>();
2953 {
2954 profiler->start( tr( "Setup layout item registry" ) );
2955 mLayoutItemRegistry = std::make_unique<QgsLayoutItemRegistry>();
2956 mLayoutItemRegistry->populate();
2957 profiler->end();
2958 }
2959 {
2960 profiler->start( tr( "Setup annotation registry" ) );
2961 mAnnotationRegistry = std::make_unique<QgsAnnotationRegistry>();
2962 profiler->end();
2963 }
2964 {
2965 profiler->start( tr( "Setup application theme registry" ) );
2966 mApplicationThemeRegistry = std::make_unique<QgsApplicationThemeRegistry>();
2967 profiler->end();
2968 }
2969 {
2970 profiler->start( tr( "Setup annotation item registry" ) );
2971 mAnnotationItemRegistry = std::make_unique<QgsAnnotationItemRegistry>();
2972 mAnnotationItemRegistry->populate();
2973 profiler->end();
2974 }
2975 {
2976 profiler->start( tr( "Setup labeling engine rule registry" ) );
2977 mLabelingEngineRuleRegistry = std::make_unique<QgsLabelingEngineRuleRegistry>();
2978 profiler->end();
2979 }
2980 {
2981 profiler->start( tr( "Setup symbol converter registry" ) );
2982 mSymbolConverterRegistry = std::make_unique<QgsSymbolConverterRegistry>();
2983 mSymbolConverterRegistry->populate();
2984 profiler->end();
2985 }
2986 {
2987 profiler->start( tr( "Setup sensor registry" ) );
2988 mSensorRegistry = std::make_unique<QgsSensorRegistry>();
2989 mSensorRegistry->populate();
2990 profiler->end();
2991 }
2992 {
2993 profiler->start( tr( "Setup plot registry" ) );
2994 mPlotRegistry = std::make_unique<QgsPlotRegistry>();
2995 mPlotRegistry->populate();
2996 profiler->end();
2997 }
2998 {
2999 profiler->start( tr( "Setup 3D material registry" ) );
3000 mMaterialRegistry = std::make_unique<QgsMaterialRegistry>();
3001 mMaterialRegistry->populate();
3002 profiler->end();
3003 }
3004 {
3005 profiler->start( tr( "Setup 3D symbol registry" ) );
3006 m3DSymbolRegistry = std::make_unique<Qgs3DSymbolRegistry>();
3007 profiler->end();
3008 }
3009 {
3010 profiler->start( tr( "Setup 3D renderer registry" ) );
3011 m3DRendererRegistry = std::make_unique<Qgs3DRendererRegistry>();
3012 profiler->end();
3013 }
3014 {
3015 profiler->start( tr( "Setup external storage registry" ) );
3016 mExternalStorageRegistry = std::make_unique<QgsExternalStorageRegistry>();
3017 profiler->end();
3018 }
3019 {
3020 profiler->start( tr( "Setup profile source registry" ) );
3021 mProfileSourceRegistry = std::make_unique<QgsProfileSourceRegistry>();
3022 profiler->end();
3023 }
3024 {
3025 profiler->start( tr( "Setup network content cache" ) );
3026 mNetworkContentFetcherRegistry = std::make_unique<QgsNetworkContentFetcherRegistry>();
3027 profiler->end();
3028 }
3029 {
3030 profiler->start( tr( "Setup layout check registry" ) );
3031 mValidityCheckRegistry = std::make_unique<QgsValidityCheckRegistry>();
3032 profiler->end();
3033 }
3034 {
3035 profiler->start( tr( "Setup classification registry" ) );
3036 mClassificationMethodRegistry = std::make_unique<QgsClassificationMethodRegistry>();
3037 profiler->end();
3038 }
3039 {
3040 profiler->start( tr( "Setup bookmark manager" ) );
3041 mBookmarkManager = std::make_unique<QgsBookmarkManager>( nullptr );
3042 profiler->end();
3043 }
3044 {
3045 profiler->start( tr( "Setup tile download manager" ) );
3046 mTileDownloadManager = std::make_unique<QgsTileDownloadManager>();
3047 profiler->end();
3048 }
3049 {
3050 profiler->start( tr( "Setup scalebar registry" ) );
3051 mScaleBarRendererRegistry = std::make_unique<QgsScaleBarRendererRegistry>();
3052 profiler->end();
3053 }
3054}
3055
3057{
3058 // we reset unique_ptr manually because we care about destruction order
3059 mStyleModel.reset();
3060 mTileDownloadManager.reset();
3062 mValidityCheckRegistry.reset();
3063 mActionScopeRegistry.reset();
3064 m3DRendererRegistry.reset();
3065 m3DSymbolRegistry.reset();
3066 mMaterialRegistry.reset();
3067 mAnnotationRegistry.reset();
3069 mColorSchemeRegistry.reset();
3071 mGpsConnectionRegistry.reset();
3073 mPaintEffectRegistry.reset();
3074 mPluginLayerRegistry.reset();
3075 mProcessingRegistry.reset();
3076 mPageSizeRegistry.reset();
3078 mSensorRegistry.reset();
3079 mPlotRegistry.reset();
3080 mLayoutItemRegistry.reset();
3084 mRendererRegistry.reset();
3085 mSvgCache.reset();
3086 mImageCache.reset();
3087 mSourceCache.reset();
3088 mCalloutRegistry.reset();
3089 mRecentStyleHandler.reset();
3092 mSymbolLayerRegistry.reset();
3094 mProfileSourceRegistry.reset();
3095 mTaskManager.reset();
3098 mNumericFormatRegistry.reset();
3099 mBookmarkManager.reset();
3100 mConnectionRegistry.reset();
3103 mFontManager.reset();
3105 mCrsRegistry.reset();
3106 mQueryLogger.reset();
3107 mMessageLog.reset();
3108}
3109
3110QgsApplication::ApplicationMembers *QgsApplication::members()
3111{
3112 if ( auto *lInstance = instance() )
3113 {
3114 return lInstance->mApplicationMembers.get();
3115 }
3116 else
3117 {
3118 static QRecursiveMutex sMemberMutex;
3119 QMutexLocker lock( &sMemberMutex );
3120 if ( !sApplicationMembers )
3121 sApplicationMembers = new ApplicationMembers();
3122 return sApplicationMembers;
3123 }
3124}
QFlags< SettingsOption > SettingsOptions
Definition qgis.h:790
static const double UI_SCALE_FACTOR
UI scaling factor.
Definition qgis.h:7405
A registry for available 3D renderers.
Registry of available 3D symbol classes.
The action scope registry is an application wide registry that contains a list of available action sc...
Registry of available annotation item types.
Registry of user interface themes.
QHash< QString, QString > themeFolders() const
Returns a map of user interface theme names and folders.
QString themeFolder(const QString &name) const
Returns the user interface theme folder for a matching name.
static QString resolvePkgPath()
Calculate the application pkg path.
static int scaleIconSize(int standardSize, bool applyDevicePixelRatio=false)
Scales an icon size to compensate for display pixel density, making the icon size hi-dpi friendly,...
static void restoreGdalDriver(const QString &driver)
Sets the GDAL_SKIP environment variable to exclude the specified driver and then calls GDALDriverMana...
static const QgsSettingsEntryString * settingsApplicationFullName
static QgsLabelingEngineRuleRegistry * labelingEngineRuleRegistry()
Gets the registry of available labeling engine rules.
static void setCustomVariables(const QVariantMap &customVariables)
Custom expression variables for this application.
QString translation() const
Returns the current application translation locale code.
static QString i18nPath()
Returns the path to the translation directory.
static QgsAnnotationItemRegistry * annotationItemRegistry()
Returns the application's annotation item registry, used for annotation item types.
static QString osName()
Returns a string name of the operating system QGIS is running on.
static void registerOgrDrivers()
Register OGR drivers ensuring this only happens once.
static QString sponsorsFilePath()
Returns the path to the sponsors file.
static QgsRecentStyleHandler * recentStyleHandler()
Returns the handler for recently used style items.
endian_t
Constants for endian-ness.
@ XDR
Network, or big-endian, byte order.
@ NDR
Little-endian byte order.
static QString qgisMasterDatabaseFilePath()
Returns the path to the master qgis.db file.
static void skipGdalDriver(const QString &driver)
Sets the GDAL_SKIP environment variable to include the specified driver and then calls GDALDriverMana...
static QString defaultThemePath()
Returns the path to the default theme directory.
static QgsPageSizeRegistry * pageSizeRegistry()
Returns the application's page size registry, used for managing layout page sizes.
static QgsValidityCheckRegistry * validityCheckRegistry()
Returns the application's validity check registry, used for managing validity checks.
static QgsDataItemProviderRegistry * dataItemProviderRegistry()
Returns the application's data item provider registry, which keeps a list of data item providers that...
static QString userStylePath()
Returns the path to user's style.
static QString platform()
Returns the QGIS platform name, e.g., "desktop", "server", "qgis_process" or "external" (for external...
static QgsProcessingRegistry * processingRegistry()
Returns the application's processing registry, used for managing processing providers,...
static QgsLayerMetadataProviderRegistry * layerMetadataProviderRegistry()
Returns registry of available layer metadata provider implementations.
static QgsSymbolConverterRegistry * symbolConverterRegistry()
Gets the registry of available symbol converters.
static QgsConnectionRegistry * connectionRegistry()
Returns the application's connection registry, used for managing saved data provider connections.
static void exitQgis()
deletes provider registry and map layer registry
static void setPluginPath(const QString &pluginPath)
Alters plugin path - used by 3rd party apps.
static const QgsSettingsEntryStringList * settingsSearchPathsForSVG
Settings entry search path for SVG.
void themeChanged()
Emitted when the application theme has changed.
static QPixmap getThemePixmap(const QString &name, const QColor &foreColor=QColor(), const QColor &backColor=QColor(), int size=16)
Helper to get a theme icon as a pixmap.
static QString nullRepresentation()
Returns the string used to represent the value NULL throughout QGIS.
static QVariantMap customVariables()
Custom expression variables for this application.
static QgsPointCloudRendererRegistry * pointCloudRendererRegistry()
Returns the application's point cloud renderer registry, used for managing point cloud layer 2D rende...
static QgsPaintEffectRegistry * paintEffectRegistry()
Returns the application's paint effect registry, used for managing paint effects.
static QgsSensorRegistry * sensorRegistry()
Returns the application's sensor registry, used for sensor types.
static QString pluginPath()
Returns the path to the application plugin directory.
static void setUITheme(const QString &themeName)
Set the current UI theme used to style the interface.
static bool createDatabase(QString *errorMessage=nullptr)
initialize qgis.db
static const QgsSettingsEntryBool * settingsLocaleOverrideFlag
Settings entry locale override flag.
static void setTemporarilyUntrustedProjectsFolders(const QStringList &untrustedProjectsFolders)
Sets the list of projects and folders that have been temporarily determined as untrusted by the user.
static QCursor getThemeCursor(Cursor cursor)
Helper to get a theme cursor.
static int systemMemorySizeMb()
Returns the size of the system memory (RAM) in megabytes.
static void setLocale(const QLocale &locale)
Sets the QGIS locale - used mainly by 3rd party apps and tests.
static void init(QString profileFolder=QString())
This method initializes paths etc for QGIS.
static const QgsSettingsEntryString * settingsNullRepresentation
static void setThemeName(const QString &themeName)
Set the active theme to the specified theme.
void customVariablesChanged()
Emitted whenever a custom global variable changes.
static QString buildSourcePath()
Returns path to the source directory.
static QString buildOutputPath()
Returns path to the build output directory.
bool notify(QObject *receiver, QEvent *event) override
Catch exceptions when sending event to receiver.
static int maxThreads()
Gets maximum concurrent thread count.
static QgsColorSchemeRegistry * colorSchemeRegistry()
Returns the application's color scheme registry, used for managing color schemes.
static QgsSettingsTreeNamedListNode * sTreeCustomVariables
static QgsApplication * instance()
Returns the singleton instance of the QgsApplication.
static QString reportStyleSheet(QgsApplication::StyleSheetType styleSheetType=QgsApplication::StyleSheetType::Qt)
Returns a css style sheet for reports, the styleSheetType argument determines what type of stylesheet...
static QString pkgDataPath()
Returns the common root path of all application data directories.
static QgsScaleBarRendererRegistry * scaleBarRendererRegistry()
Gets the registry of available scalebar renderers.
static QgsLayoutItemRegistry * layoutItemRegistry()
Returns the application's layout item registry, used for layout item types.
static void setFileOpenEventReceiver(QObject *receiver)
Sets the FileOpen event receiver.
static QgsSymbolLayerRegistry * symbolLayerRegistry()
Returns the application's symbol layer registry, used for managing symbol layers.
static QStringList projectTemplatePaths()
Returns the paths to project templates.
static QgsRasterRendererRegistry * rasterRendererRegistry()
Returns the application's raster renderer registry, used for managing raster layer renderers.
static void applyGdalSkippedDrivers()
Apply the skipped drivers list to gdal.
static void setMaxThreads(int maxThreads)
Set maximum concurrent thread count.
static QgsNumericFormatRegistry * numericFormatRegistry()
Gets the registry of available numeric formats.
static QgsNetworkContentFetcherRegistry * networkContentFetcherRegistry()
Returns the application's network content registry used for fetching temporary files during QGIS sess...
static QgsProjectStorageRegistry * projectStorageRegistry()
Returns registry of available project storage implementations.
static QString licenceFilePath()
Returns the path to the licence file.
static QString libexecPath()
Returns the path with utility executables (help viewer, crssync, ...).
static QStringList skippedGdalDrivers()
Returns the list of gdal drivers that should be skipped (based on GDAL_SKIP environment variable).
StyleSheetType
The StyleSheetType enum represents the stylesheet type that a widget supports.
@ Qt
StyleSheet for Qt GUI widgets (based on QLabel or QTextBrowser), supports basic CSS and Qt extensions...
@ WebBrowser
StyleSheet for embedded browsers (QtWebKit), supports full standard CSS.
static QString translatorsFilePath()
Returns the path to the sponsors file.
static const QgsSettingsEntryString * settingsLocaleGlobalLocale
Settings entry locale global locale.
static QIcon getThemeIcon(const QString &name, const QColor &fillColor=QColor(), const QColor &strokeColor=QColor())
Helper to get a theme icon.
static void setNullRepresentation(const QString &nullRepresentation)
Sets the string used to represent the value NULL throughout QGIS.
static QStringList temporarilyTrustedProjectsFolders()
Returns the list of projects and folders that have been temporarily determined as trusted by the user...
static QString applicationFullName()
Returns the QGIS application full name.
static QgsGpsConnectionRegistry * gpsConnectionRegistry()
Returns the application's GPS connection registry, used for managing GPS connections.
static QString locale()
Returns the QGIS locale.
static QgsImageCache * imageCache()
Returns the application's image cache, used for caching resampled versions of raster images.
static QStringList svgPaths()
Returns the paths to svg directories.
static void initQgis()
loads providers
static QString showSettings()
Convenience function to get a summary of the paths used in this application instance useful for debug...
static const QgsSettingsEntryStringList * settingsProjectTemplatePaths
Settings entry search path for project templates.
bool event(QEvent *event) override
Watch for QFileOpenEvent.
static void setPkgDataPath(const QString &pkgDataPath)
Alters pkg data path - used by 3rd party apps.
static QString absolutePathToRelativePath(const QString &apath, const QString &targetPath)
Converts absolute path to path relative to target.
static const QgsSettingsEntryString * settingsLocaleUserLocale
Settings entry locale user locale.
static QgsRuntimeProfiler * profiler()
Returns the application runtime profiler.
~QgsApplication() override
static QgsLocalizedDataPathRegistry * localizedDataPathRegistry()
Returns the registry of data repositories These are used as paths for basemaps, logos,...
static const char * QGIS_APPLICATION_NAME
static QgsTileDownloadManager * tileDownloadManager()
Returns the application's tile download manager, used for download of map tiles when rendering.
static const char * QGIS_ORGANIZATION_DOMAIN
static QMap< QString, QString > systemEnvVars()
Returns the system environment variables passed to application.
static void setAuthDatabaseDirPath(const QString &authDbDirPath)
Alters authentication data base directory path - used by 3rd party apps.
static const QgsSettingsEntryStringList * settingsSkippedGdalDrivers
static QgsAuthConfigurationStorageRegistry * authConfigurationStorageRegistry()
Returns the application's authentication configuration storage registry.
static QString prefixPath()
Returns the path to the application prefix directory.
static QgsSvgCache * svgCache()
Returns the application's SVG cache, used for caching SVG images and handling parameter replacement w...
static QgsFontManager * fontManager()
Returns the application font manager, which manages available fonts and font installation for the QGI...
static QString qgisSettingsDirPath()
Returns the path to the settings directory in user's home dir.
static QgsDatabaseQueryLog * databaseQueryLog()
Returns the database query log.
static QgsMessageLog * messageLog()
Returns the application's message log.
void preNotify(QObject *receiver, QEvent *event, bool *done)
static bool createThemeFolder()
Create the users theme folder.
static QString metadataPath()
Returns the path to the metadata directory.
void localeChanged()
Emitted when project locale has been changed.
static QgsActionScopeRegistry * actionScopeRegistry()
Returns the action scope registry.
static QgsCoordinateReferenceSystemRegistry * coordinateReferenceSystemRegistry()
Returns the application's coordinate reference system (CRS) registry, which handles known CRS definit...
static const char * QGIS_ORGANIZATION_NAME
static QString contributorsFilePath()
Returns the path to the contributors file.
void collectTranslatableObjects(QgsTranslationContext *translationContext)
Emits the signal to collect all the strings of .qgs to be included in ts file.
static QgsSourceCache * sourceCache()
Returns the application's source cache, used for caching embedded and remote source strings as local ...
static QStringList temporarilyUntrustedProjectsFolders()
Returns the list of projects and folders that have been temporarily determined as untrusted by the us...
static QRegularExpression shortNameRegularExpression()
Returns the short name regular expression for line edit validator.
static QgsTaskManager * taskManager()
Returns the application's task manager, used for managing application wide background task handling.
static QgsProfileSourceRegistry * profileSourceRegistry()
Returns registry of available profile source implementations.
static QgsAnnotationRegistry * annotationRegistry()
Returns the application's annotation registry, used for managing annotation types.
static QgsPluginLayerRegistry * pluginLayerRegistry()
Returns the application's plugin layer registry, used for managing plugin layer types.
static QgsClassificationMethodRegistry * classificationMethodRegistry()
Returns the application's classification methods registry, used in graduated renderer.
static QStringList deferredSkippedGdalDrivers()
Returns the list of gdal drivers that have been disabled in the current session, and thus,...
static QString qgisAuthDatabaseUri()
Returns the URI to the user authentication database.
static QString defaultStylePath()
Returns the path to default style (works as a starting point).
static QgsAuthManager * authManager()
Returns the application's authentication manager instance.
static QString qmlImportPath()
Returns the path where QML components are installed for QGIS Quick library.
static QgsApplicationThemeRegistry * applicationThemeRegistry()
Returns the application's theme registry, used for styling the user interface.
QgsApplication(int &argc, char **argv, bool GUIenabled, const QString &profileFolder=QString(), const QString &platformName="external")
Constructor for QgsApplication.
Cursor
The Cursor enum defines constants for QGIS custom cursors.
@ ZoomOut
Zoom out.
@ CrossHair
Precisely identify a point on the canvas.
@ Identify
Identify: obtain information about the object.
@ Select
Select a rectangle.
@ CapturePoint
Select and capture a point or a feature.
@ Sampler
Color/Value picker.
static const QgsSettingsEntryInteger * settingsConnectionPoolMaximumConcurrentConnections
Settings entry to configure the maximum number of concurrent connections within connection pools.
static Q_DECL_DEPRECATED QString qgisAuthDatabaseFilePath()
Returns the path to the user authentication database file: qgis-auth.db.
static QString authorsFilePath()
Returns the path to the authors file.
static QgsBookmarkManager * bookmarkManager()
Returns the application's bookmark manager, used for storing installation-wide bookmarks.
static QString qgisUserDatabaseFilePath()
Returns the path to the user qgis.db file.
static QgsFieldFormatterRegistry * fieldFormatterRegistry()
Gets the registry of available field formatters.
static QString activeThemePath()
Returns the path to the currently active theme directory.
static QString defaultThemesFolder()
Returns the path to default themes folder from install (works as a starting point).
static void setTemporarilyTrustedProjectsFolders(const QStringList &trustedProjectsFolders)
Sets the list of projects and folders that have been temporarily determined as trusted by the user.
static void setSkippedGdalDrivers(const QStringList &skippedGdalDrivers, const QStringList &deferredSkippedGdalDrivers)
Sets the list of gdal drivers that should be disabled (skippedGdalDrivers), but excludes for now the ...
static void setProjectTemplatePaths(const QStringList &projectTemplatePaths)
Sets the paths to project templates.
static QgsRendererRegistry * rendererRegistry()
Returns the application's renderer registry, used for managing vector layer renderers.
static QgsMaterialRegistry * materialRegistry()
Returns registry of available 3D materials.
static void setTranslation(const QString &translation)
Set translation locale code.
static QgsCalloutRegistry * calloutRegistry()
Returns the application's callout registry, used for managing callout types.
static void setPrefixPath(const QString &prefixPath, bool useDefaultPaths=false)
Alters prefix path - used by 3rd party apps.
static QgsStyleModel * defaultStyleModel()
Returns a shared QgsStyleModel containing the default style library (see QgsStyle::defaultStyle()).
static QString relativePathToAbsolutePath(const QString &rpath, const QString &targetPath)
Converts path relative to target to an absolute path.
static void setSvgPaths(const QStringList &svgPaths)
Sets the paths to svg directories and invalidates the svg path list cache.
static QgsBabelFormatRegistry * gpsBabelFormatRegistry()
Returns the application's GPSBabel format registry, used for managing GPSBabel formats.
static endian_t endian()
Returns whether this machine uses big or little endian.
int maxConcurrentConnectionsPerPool() const
The maximum number of concurrent connections per connections pool.
static void setCustomVariable(const QString &name, const QVariant &value)
Set a single custom expression variable.
void requestForTranslatableObjects(QgsTranslationContext *translationContext)
Emitted when project strings which require translation are being collected for inclusion in a ....
static QString iconsPath()
Returns the path to the icons image directory.
static Qgs3DSymbolRegistry * symbol3DRegistry()
Returns registry of available 3D symbols.
static QgsExternalStorageRegistry * externalStorageRegistry()
Returns registry of available external storage implementations.
static QHash< QString, QString > uiThemes()
All themes found in ~/.qgis3/themes folder.
static QString splashPath()
Returns the path to the splash screen image directory.
static QString donorsFilePath()
Returns the path to the donors file.
static QString themeName()
Set the active theme to the specified theme.
void nullRepresentationChanged()
Emitted when the string representing the NULL value is changed.
static QString srsDatabaseFilePath()
Returns the path to the srs.db file.
static QString userThemesFolder()
Returns the path to user's themes folder.
static void registerGdalDriversFromSettings()
Register gdal drivers, excluding the ones mentioned in "gdal/skipList" setting.
static QgsPlotRegistry * plotRegistry()
Returns the application's plot registry, used for plot types.
static Qgs3DRendererRegistry * renderer3DRegistry()
Returns registry of available 3D renderers.
static QString iconPath(const QString &iconFile)
Returns path to the desired icon file.
static QgsTiledSceneRendererRegistry * tiledSceneRendererRegistry()
Returns the application's tiled scene renderer registry, used for managing tiled scene layer 2D rende...
static void setDefaultSvgPaths(const QStringList &pathList)
Alters default svg paths - used by 3rd party apps.
static QString libraryPath()
Returns the path containing qgis_core, qgis_gui, qgispython (and other) libraries.
static QStringList layoutTemplatePaths()
Returns the paths to layout template directories.
static const QgsSettingsEntryBool * settingsLocaleShowGroupSeparator
Settings entry locale show group separator.
static QString userFullName()
Returns the user's operating system login account full display name.
static Q_DECL_DEPRECATED QgsSettingsRegistryCore * settingsRegistryCore()
Returns the application's settings registry, used for managing application settings.
static QString serverResourcesPath()
Returns the path to the server resources directory.
static QString appIconPath()
Gets application icon.
static QStringList defaultProjectTemplatePaths()
Returns the default project template paths.
static QString userLoginName()
Returns the user's operating system login account name.
static const QgsSettingsEntryVariant * settingsCustomVariable
Registry for authentication configuration storages.
Singleton which offers an interface to manage the authentication configuration database and to utiliz...
QgsAuthConfigurationStorageRegistry * authConfigurationStorageRegistry() const
Returns the authentication configuration storage registry.
void setup(const QString &pluginPath=QString(), const QString &authDatabasePath=QString())
Sets up the authentication manager configuration.
static QgsAuthManager * instance()
Enforce singleton pattern.
A registry for QgsAbstractBabelFormat GPSBabel formats.
Manages storage of a set of bookmarks.
void initialize(const QString &filePath)
Initializes the bookmark manager.
Registry of available callout classes.
Manages all known classification methods.
Registry of color schemes.
void addDefaultSchemes()
Adds all default color schemes to this color scheme.
void setProject(QgsProject *project)
Sets the project associated with the registry, used to provide the "Project colors" scheme.
void initStyleScheme()
Initializes the default random style color scheme for the user.
A registry for saved data provider connections, allowing retrieval of saved connections by name and p...
A registry for known coordinate reference system (CRS) definitions, including any user-defined CRSes.
static void invalidateCache(bool disableCache=false)
Clears the internal cache used to initialize QgsCoordinateReferenceSystem objects.
static void invalidateCache(bool disableCache=false)
Clears the internal cache used to initialize QgsCoordinateTransform objects.
A registry for data item providers that may add items to the browser tree.
Handles logging of database queries.
static void applyLocaleChange()
Adjusts the date time display formats according to locale.
static void invalidateCache(bool disableCache=false)
Clears the internal cache used.
Defines a QGIS exception class.
QString what() const
static void cleanRegisteredFunctions()
Deletes all registered functions whose ownership have been transferred to the expression engine.
static const FunctionListSnapshot getFunctionsSnapshot()
Returns a thread-safe snapshot of all registered functions.
Registry of external storage backends used by QgsExternalResourceWidget.
A registry which manages classes of QgsFieldFormatter.
Manages available fonts and font installation for a QGIS instance.
void installUserFonts()
Installs user fonts from the profile/fonts directory as application fonts.
Registers existing GPS connections such that the information is available to all classes and plugins.
A cache for images derived from raster files.
A registry for labeling engine rules.
Registry of layer metadata provider backends.
Registry of available layout item types.
static const QgsSettingsEntryStringList * settingsSearchPathForTemplates
Settings entry search path for templates.
Definition qgslayout.h:662
A registry class to hold localized data paths which can be used for basemaps, logos,...
Registry of available 3d material settings classes.
Temporarily blocks the application QgsMessageLog (see QgsApplication::messageLog()) from emitting the...
Interface for logging messages from QGIS in GUI independent way.
static QgsNetworkAccessManager * instance(Qt::ConnectionType connectionType=Qt::BlockingQueuedConnection)
Returns a pointer to the active QgsNetworkAccessManager for the current thread.
Registry for temporary fetched files.
A registry which manages classes of QgsNumericFormat.
A registry for known page sizes.
Registry of available paint effects.
Registry of available plot types.
A registry of plugin layers types.
Registry of 2D renderers for point clouds.
void loadStyles()
Loads all saved styles from the configuration file.
Registry for various processing components, including providers, algorithms and various parameters an...
QgsProcessingDefaultStyleRegistry * defaultStyleRegistry() const
Returns the default style registry, responsible for styling layers generated by Processing tools.
Registry of profile sources used by QgsProfilePlotRenderer.
static QStringList searchPaths()
Returns the current list of Proj file search paths.
Registry of storage backends that QgsProject may use.
static QgsProject * instance()
Returns the QgsProject singleton instance.
static QgsProviderRegistry * instance(const QString &pluginPath=QString())
Means of accessing canonical single instance.
Registry for raster renderers.
A convenience class that simplifies locking and unlocking QReadWriteLocks.
@ Write
Lock for write.
void changeMode(Mode mode)
Change the mode of the lock to mode.
Handles and tracks style items recently used in the QGIS GUI.
Registry of renderers.
Provides a method of recording run time profiles of operations, allowing easy recording of their over...
A registry which manages registered scalebar renderers.
Scoped object for logging of the runtime for a single operation or group of operations.
Registry of available sensor types.
A boolean settings entry.
An integer settings entry.
A string list settings entry.
A string settings entry.
A variant settings entry.
Custom exception class for settings related exceptions.
Used for settings introspection and collects all QgsSettingsEntry instances of core.
A named list tree node for the settings tree to help organizing and introspecting the tree.
static QgsSettingsTreeNode * sTreeApp
static QgsSettingsTreeNode * sTreeLocale
static QgsSettingsTreeNode * sTreeGdal
static QgsSettingsTreeNode * sTreeSvg
static QgsSettingsTreeNode * sTreeProject
static QgsSettingsTreeNode * sTreeQgis
static QgsSettingsTreeNode * sTreeCore
A cache for source strings that returns a local file path containing the source content.
A QAbstractItemModel subclass for showing symbol and color ramp entities contained within a QgsStyle ...
A database of saved style entities, including symbols, color ramps, text formats and others.
Definition qgsstyle.h:91
static void cleanDefaultStyle()
Deletes the default style. Only to be used by QgsApplication::exitQgis().
Definition qgsstyle.cpp:221
static QgsStyle * defaultStyle(bool initialize=true)
Returns the default application-wide style.
Definition qgsstyle.cpp:164
A cache for images / pictures derived from SVG files.
QImage svgAsImage(const QString &path, double size, const QColor &fill, const QColor &stroke, double strokeWidth, double widthScaleFactor, bool &fitsInCache, double fixedAspectRatio=0, bool blocking=false, const QMap< QString, QString > &parameters=QMap< QString, QString >())
Returns an SVG drawing as a QImage.
QByteArray svgContent(const QString &path, double size, const QColor &fill, const QColor &stroke, double strokeWidth, double widthScaleFactor, double fixedAspectRatio=0, bool blocking=false, const QMap< QString, QString > &parameters=QMap< QString, QString >(), bool *isMissingImage=nullptr)
Gets the SVG content corresponding to the given path.
A registry of known symbol converters.
Registry of available symbol layer classes.
static QColor decodeColor(const QString &str)
Decodes a string to a color.
Task manager for managing a set of long-running QgsTask tasks.
Tile download manager handles downloads of map tiles for the purpose of map rendering.
QgsTileDownloadManagerReply * get(const QNetworkRequest &request)
Starts a request.
Registry of 2D renderers for tiled scenes.
Used for the collecting of strings from projects for translation and creation of ts files.
A manager for QGIS user profiles.
std::unique_ptr< QgsUserProfile > getProfile(const QString &defaultProfile="default", bool createNew=true, bool initSettings=true)
Returns the profile from the given root profile location.
static QString resolveProfilesFolder(const QString &basePath=QString())
Resolves the profiles folder for the given path.
A registry that keeps a list of QgsAbstractValidityCheck checks which can be used when performing val...
Unique pointer for sqlite3 databases, which automatically closes the database when the pointer goes o...
int open(const QString &path)
Opens the database at the specified file path.
QMap< QString, QString > QgsStringMap
Definition qgis.h:8418
void registerMetaTypes()
QObject * ABISYM(QgsApplication::mFileOpenEventReceiver)
Q_GLOBAL_STATIC_WITH_ARGS(PalPropertyList, palHiddenProperties,({ static_cast< int >(QgsPalLayerSettings::Property::PositionX), static_cast< int >(QgsPalLayerSettings::Property::PositionY), static_cast< int >(QgsPalLayerSettings::Property::Show), static_cast< int >(QgsPalLayerSettings::Property::LabelRotation), static_cast< int >(QgsPalLayerSettings::Property::Family), static_cast< int >(QgsPalLayerSettings::Property::FontStyle), static_cast< int >(QgsPalLayerSettings::Property::Size), static_cast< int >(QgsPalLayerSettings::Property::Bold), static_cast< int >(QgsPalLayerSettings::Property::Italic), static_cast< int >(QgsPalLayerSettings::Property::Underline), static_cast< int >(QgsPalLayerSettings::Property::Color), static_cast< int >(QgsPalLayerSettings::Property::Strikeout), static_cast< int >(QgsPalLayerSettings::Property::MultiLineAlignment), static_cast< int >(QgsPalLayerSettings::Property::BufferSize), static_cast< int >(QgsPalLayerSettings::Property::BufferDraw), static_cast< int >(QgsPalLayerSettings::Property::BufferColor), static_cast< int >(QgsPalLayerSettings::Property::LabelDistance), static_cast< int >(QgsPalLayerSettings::Property::Hali), static_cast< int >(QgsPalLayerSettings::Property::Vali), static_cast< int >(QgsPalLayerSettings::Property::ScaleVisibility), static_cast< int >(QgsPalLayerSettings::Property::MinScale), static_cast< int >(QgsPalLayerSettings::Property::MaxScale), static_cast< int >(QgsPalLayerSettings::Property::AlwaysShow), static_cast< int >(QgsPalLayerSettings::Property::CalloutDraw), static_cast< int >(QgsPalLayerSettings::Property::LabelAllParts) })) Q_GLOBAL_STATIC_WITH_ARGS(SymbolPropertyList
const QString cacheKey(const QString &pathIn)
Q_GLOBAL_STATIC(QReadWriteLock, sDefinitionCacheLock)
#define QgsDebugMsgLevel(str, level)
Definition qgslogger.h:80
#define QgsDebugError(str)
Definition qgslogger.h:71
std::unique_ptr< QgsBookmarkManager > mBookmarkManager
std::unique_ptr< QgsRasterRendererRegistry > mRasterRendererRegistry
std::unique_ptr< QgsProcessingRegistry > mProcessingRegistry
std::unique_ptr< QgsTaskManager > mTaskManager
std::unique_ptr< QgsAnnotationRegistry > mAnnotationRegistry
std::unique_ptr< QgsCoordinateReferenceSystemRegistry > mCrsRegistry
std::unique_ptr< QgsGpsConnectionRegistry > mGpsConnectionRegistry
std::unique_ptr< QgsLabelingEngineRuleRegistry > mLabelingEngineRuleRegistry
std::unique_ptr< QgsPointCloudRendererRegistry > mPointCloudRendererRegistry
std::unique_ptr< QgsRendererRegistry > mRendererRegistry
std::unique_ptr< Qgs3DSymbolRegistry > m3DSymbolRegistry
std::unique_ptr< QgsPlotRegistry > mPlotRegistry
std::unique_ptr< QgsApplicationThemeRegistry > mApplicationThemeRegistry
std::unique_ptr< QgsRecentStyleHandler > mRecentStyleHandler
std::unique_ptr< QgsClassificationMethodRegistry > mClassificationMethodRegistry
std::unique_ptr< QgsSensorRegistry > mSensorRegistry
std::unique_ptr< QgsPluginLayerRegistry > mPluginLayerRegistry
std::unique_ptr< QgsDatabaseQueryLog > mQueryLogger
std::unique_ptr< QgsScaleBarRendererRegistry > mScaleBarRendererRegistry
std::unique_ptr< QgsNumericFormatRegistry > mNumericFormatRegistry
std::unique_ptr< QgsLayoutItemRegistry > mLayoutItemRegistry
std::unique_ptr< QgsTiledSceneRendererRegistry > mTiledSceneRendererRegistry
std::unique_ptr< QgsStyleModel > mStyleModel
std::unique_ptr< QgsAnnotationItemRegistry > mAnnotationItemRegistry
std::unique_ptr< QgsImageCache > mImageCache
std::unique_ptr< Qgs3DRendererRegistry > m3DRendererRegistry
std::unique_ptr< QgsCalloutRegistry > mCalloutRegistry
std::unique_ptr< QgsSourceCache > mSourceCache
std::unique_ptr< QgsFontManager > mFontManager
std::unique_ptr< QgsSettingsRegistryCore > mSettingsRegistryCore
std::unique_ptr< QgsSymbolConverterRegistry > mSymbolConverterRegistry
std::unique_ptr< QgsPageSizeRegistry > mPageSizeRegistry
std::unique_ptr< QgsExternalStorageRegistry > mExternalStorageRegistry
std::unique_ptr< QgsProfileSourceRegistry > mProfileSourceRegistry
std::unique_ptr< QgsSvgCache > mSvgCache
std::unique_ptr< QgsPaintEffectRegistry > mPaintEffectRegistry
std::unique_ptr< QgsColorSchemeRegistry > mColorSchemeRegistry
std::unique_ptr< QgsActionScopeRegistry > mActionScopeRegistry
std::unique_ptr< QgsBabelFormatRegistry > mGpsBabelFormatRegistry
std::unique_ptr< QgsMaterialRegistry > mMaterialRegistry
std::unique_ptr< QgsTileDownloadManager > mTileDownloadManager
std::unique_ptr< QgsValidityCheckRegistry > mValidityCheckRegistry
std::unique_ptr< QgsNetworkContentFetcherRegistry > mNetworkContentFetcherRegistry
std::unique_ptr< QgsConnectionRegistry > mConnectionRegistry
std::unique_ptr< QgsFieldFormatterRegistry > mFieldFormatterRegistry
std::unique_ptr< QgsProjectStorageRegistry > mProjectStorageRegistry
std::unique_ptr< QgsMessageLog > mMessageLog
std::unique_ptr< QgsLocalizedDataPathRegistry > mLocalizedDataPathRegistry
std::unique_ptr< QgsLayerMetadataProviderRegistry > mLayerMetadataProviderRegistry
std::unique_ptr< QgsSymbolLayerRegistry > mSymbolLayerRegistry