qgsproject.h

Go to the documentation of this file.

/***************************************************************************
                                  qgsproject.h
 
                      Implements persistent project state.
 
                              -------------------
  begin                : July 23, 2004
  copyright            : (C) 2004 by Mark Coletti
  email                : mcoletti at gmail.com
 ***************************************************************************/
 
/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/
 
#ifndef QGSPROJECT_H
#define QGSPROJECT_H
 
#include "qgis_core.h"
#include "qgis_sip.h"
#include "qgis.h"
 
#include <memory>
#include <QHash>
#include <QList>
#include <QObject>
#include <QPair>
#include <QFileInfo>
#include <QStringList>
#include <QTranslator>
 
#include "qgssnappingconfig.h"
#include "qgsprojectversion.h"
#include "qgsexpressioncontextgenerator.h"
#include "qgsexpressioncontextscopegenerator.h"
#include "qgscoordinatereferencesystem.h"
#include "qgscoordinatetransformcontext.h"
#include "qgsprojectproperty.h"
#include "qgsmaplayerstore.h"
#include "qgsarchive.h"
#include "qgsreadwritecontext.h"
#include "qgsprojectmetadata.h"
#include "qgstranslationcontext.h"
#include "qgsprojectdisplaysettings.h"
#include "qgsprojecttranslator.h"
#include "qgscolorscheme.h"
#include "qgssettings.h"
#include "qgspropertycollection.h"
#include "qgsvectorlayereditbuffergroup.h"
#include "qgselevationshadingrenderer.h"
#include "qgsabstractsensor.h"
 
#include "qgsrelationmanager.h"
#include "qgsmapthemecollection.h"
 
class QFileInfo;
class QDomDocument;
class QDomElement;
class QDomNode;
 
class QgsLayerTreeGroup;
class QgsLayerTreeRegistryBridge;
class QgsMapLayer;
class QgsPathResolver;
class QgsProjectBadLayerHandler;
class QgsProjectStorage;
class QgsTolerance;
class QgsTransactionGroup;
class QgsVectorLayer;
class QgsAnnotationManager;
class QgsLayoutManager;
class QgsLayerTree;
class QgsLabelingEngineSettings;
class QgsAuxiliaryStorage;
class QgsMapLayer;
class QgsBookmarkManager;
class QgsProjectViewSettings;
class QgsProjectStyleSettings;
class QgsProjectTimeSettings;
class QgsAnnotationLayer;
class QgsAttributeEditorContainer;
class QgsPropertyCollection;
class QgsMapViewsManager;
class QgsProjectElevationProperties;
class QgsProjectGpsSettings;
class QgsSensorManager;
 
class CORE_EXPORT QgsProject : public QObject, public QgsExpressionContextGenerator, public QgsExpressionContextScopeGenerator, public QgsProjectTranslator
{
    Q_OBJECT
    Q_PROPERTY( QStringList nonIdentifiableLayers READ nonIdentifiableLayers WRITE setNonIdentifiableLayers NOTIFY nonIdentifiableLayersChanged )
    Q_PROPERTY( QString fileName READ fileName WRITE setFileName NOTIFY fileNameChanged )
    Q_PROPERTY( QString homePath READ homePath WRITE setPresetHomePath NOTIFY homePathChanged )
    Q_PROPERTY( QgsCoordinateReferenceSystem crs READ crs WRITE setCrs NOTIFY crsChanged )
    Q_PROPERTY( QgsCoordinateTransformContext transformContext READ transformContext WRITE setTransformContext NOTIFY transformContextChanged )
    Q_PROPERTY( QString ellipsoid READ ellipsoid WRITE setEllipsoid NOTIFY ellipsoidChanged )
    Q_PROPERTY( QgsMapThemeCollection *mapThemeCollection READ mapThemeCollection NOTIFY mapThemeCollectionChanged )
    Q_PROPERTY( QgsSnappingConfig snappingConfig READ snappingConfig WRITE setSnappingConfig NOTIFY snappingConfigChanged )
    Q_PROPERTY( QgsRelationManager *relationManager READ relationManager )
    Q_PROPERTY( Qgis::AvoidIntersectionsMode avoidIntersectionsMode READ avoidIntersectionsMode WRITE setAvoidIntersectionsMode NOTIFY avoidIntersectionsModeChanged )
    Q_PROPERTY( QList<QgsVectorLayer *> avoidIntersectionsLayers READ avoidIntersectionsLayers WRITE setAvoidIntersectionsLayers NOTIFY avoidIntersectionsLayersChanged )
    Q_PROPERTY( QgsProjectMetadata metadata READ metadata WRITE setMetadata NOTIFY metadataChanged )
    Q_PROPERTY( QColor backgroundColor READ backgroundColor WRITE setBackgroundColor NOTIFY backgroundColorChanged )
    Q_PROPERTY( QColor selectionColor READ selectionColor WRITE setSelectionColor NOTIFY selectionColorChanged )
    Q_PROPERTY( bool topologicalEditing READ topologicalEditing WRITE setTopologicalEditing NOTIFY topologicalEditingChanged )
    Q_PROPERTY( Qgis::DistanceUnit distanceUnits READ distanceUnits WRITE setDistanceUnits NOTIFY distanceUnitsChanged )
    Q_PROPERTY( Qgis::AreaUnit areaUnits READ areaUnits WRITE setAreaUnits NOTIFY areaUnitsChanged )
    Q_PROPERTY( QgsProjectDisplaySettings *displaySettings READ displaySettings CONSTANT )
    Q_PROPERTY( Qgis::TransactionMode transactionMode READ transactionMode WRITE setTransactionMode NOTIFY transactionModeChanged )
    Q_PROPERTY( Qgis::ScaleCalculationMethod scaleMethod READ scaleMethod WRITE setScaleMethod NOTIFY scaleMethodChanged )
 
  public:
 
    // *INDENT-OFF*
 
    enum class DataDefinedServerProperty SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsProject, DataDefinedServerProperty ) : int
      {
      NoProperty = 0, 
      AllProperties = 1, 
      WMSOnlineResource = 2, 
    };
    // *INDENT-ON*
 
    static QgsProject *instance();
 
    static void setInstance( QgsProject *project ) ;
 
    explicit QgsProject( QObject *parent SIP_TRANSFERTHIS = nullptr, Qgis::ProjectCapabilities capabilities = Qgis::ProjectCapability::ProjectStyles );
 
    ~QgsProject() override;
 
    void setTitle( const QString &title );
 
    QString title() const;
 
    Qgis::ProjectCapabilities capabilities() const { return mCapabilities; }
 
    Qgis::ProjectFlags flags() const { return mFlags; }
 
    void setFlags( Qgis::ProjectFlags flags );
 
    void setFlag( Qgis::ProjectFlag flag, bool enabled = true );
 
    QString saveUser() const;
 
    QString saveUserFullName() const;
 
    QDateTime lastSaveDateTime() const;
 
    QgsProjectVersion lastSaveVersion() const;
 
    bool isDirty() const;
 
    void setFileName( const QString &name );
 
    QString fileName() const;
 
    void setOriginalPath( const QString &path );
 
    QString originalPath() const;
 
    Q_DECL_DEPRECATED QFileInfo fileInfo() const SIP_DEPRECATED;
 
    QgsProjectStorage *projectStorage() const;
 
    QDateTime lastModified() const;
 
    QString absoluteFilePath() const;
 
    QString absolutePath() const;
 
    QString baseName() const;
 
    Qgis::FilePathType filePathStorage() const;
 
    void setFilePathStorage( Qgis::FilePathType type );
 
    QgsCoordinateReferenceSystem crs() const;
 
    QgsCoordinateReferenceSystem crs3D() const;
 
    void setCrs( const QgsCoordinateReferenceSystem &crs, bool adjustEllipsoid = false );
 
    QString ellipsoid() const;
 
    void setEllipsoid( const QString &ellipsoid );
 
    QgsCoordinateReferenceSystem verticalCrs() const;
 
    bool setVerticalCrs( const QgsCoordinateReferenceSystem &crs, QString *errorMessage SIP_OUT = nullptr );
 
    QgsCoordinateTransformContext transformContext() const;
 
    void setTransformContext( const QgsCoordinateTransformContext &context );
 
    void clear();
 
    bool read( const QString &filename, Qgis::ProjectReadFlags flags = Qgis::ProjectReadFlags() );
 
    bool read( Qgis::ProjectReadFlags flags = Qgis::ProjectReadFlags() );
 
    bool readLayer( const QDomNode &layerNode );
 
    bool write( const QString &filename );
 
    bool write();
 
    bool writeEntry( const QString &scope, const QString &key, bool value ) SIP_PYNAME( writeEntryBool );
 
    bool writeEntry( const QString &scope, const QString &key, double value ) SIP_PYNAME( writeEntryDouble );
 
    bool writeEntry( const QString &scope, const QString &key, int value );
 
    bool writeEntry( const QString &scope, const QString &key, const QString &value );
 
    bool writeEntry( const QString &scope, const QString &key, const QStringList &value );
 
    QStringList readListEntry( const QString &scope, const QString &key, const QStringList &def = QStringList(), bool *ok SIP_OUT = nullptr ) const;
 
    QString readEntry( const QString &scope, const QString &key, const QString &def = QString(), bool *ok SIP_OUT = nullptr ) const;
 
    int readNumEntry( const QString &scope, const QString &key, int def = 0, bool *ok SIP_OUT = nullptr ) const;
 
    double readDoubleEntry( const QString &scope, const QString &key, double def = 0, bool *ok SIP_OUT = nullptr ) const;
 
    bool readBoolEntry( const QString &scope, const QString &key, bool def = false, bool *ok SIP_OUT = nullptr ) const;
 
    bool removeEntry( const QString &scope, const QString &key );
 
    QStringList entryList( const QString &scope, const QString &key ) const;
 
    QStringList subkeyList( const QString &scope, const QString &key ) const;
 
    // TODO Now slightly broken since re-factoring.  Won't print out top-level key
    //           and redundantly prints sub-keys.
 
    void dumpProperties() const;
 
    QgsPathResolver pathResolver() const;
 
    QString writePath( const QString &filename ) const;
 
    QString readPath( const QString &filename ) const;
 
    QString error() const;
 
    void setBadLayerHandler( QgsProjectBadLayerHandler *handler SIP_TRANSFER );
 
    QString layerIsEmbedded( const QString &id ) const;
 
    bool createEmbeddedLayer( const QString &layerId, const QString &projectFilePath, QList<QDomNode> &brokenNodes,
                              bool saveFlag = true, Qgis::ProjectReadFlags flags = Qgis::ProjectReadFlags() ) SIP_SKIP;
 
    QgsLayerTreeGroup *createEmbeddedGroup( const QString &groupName, const QString &projectFilePath, const QStringList &invisibleLayers,  Qgis::ProjectReadFlags flags = Qgis::ProjectReadFlags() );
 
    void setTopologicalEditing( bool enabled );
 
    bool topologicalEditing() const;
 
    Qgis::DistanceUnit distanceUnits() const { return mDistanceUnits; }
 
    void setDistanceUnits( Qgis::DistanceUnit unit );
 
    Qgis::AreaUnit areaUnits() const { return mAreaUnits; }
 
    void setAreaUnits( Qgis::AreaUnit unit );
 
    Qgis::ScaleCalculationMethod scaleMethod() const { return mScaleMethod; }
 
    void setScaleMethod( Qgis::ScaleCalculationMethod method );
 
    QString homePath() const;
 
    QString presetHomePath() const;
 
    QgsRelationManager *relationManager() const;
 
    const QgsLayoutManager *layoutManager() const SIP_SKIP;
 
    QgsLayoutManager *layoutManager();
 
    const QgsMapViewsManager *viewsManager() const SIP_SKIP;
 
    QgsMapViewsManager *viewsManager();
 
    const QgsBookmarkManager *bookmarkManager() const SIP_SKIP;
 
    QgsBookmarkManager *bookmarkManager();
 
    const QgsSensorManager *sensorManager() const SIP_SKIP;
 
    QgsSensorManager *sensorManager();
 
    const QgsProjectViewSettings *viewSettings() const SIP_SKIP;
 
    QgsProjectViewSettings *viewSettings();
 
    const QgsProjectStyleSettings *styleSettings() const SIP_SKIP;
 
    QgsProjectStyleSettings *styleSettings();
 
    const QgsProjectTimeSettings *timeSettings() const SIP_SKIP;
 
    QgsProjectTimeSettings *timeSettings();
 
    const QgsProjectElevationProperties *elevationProperties() const SIP_SKIP;
 
    QgsProjectElevationProperties *elevationProperties();
 
    const QgsProjectDisplaySettings *displaySettings() const SIP_SKIP;
 
    QgsProjectDisplaySettings *displaySettings();
 
    const QgsProjectGpsSettings *gpsSettings() const SIP_SKIP;
 
    QgsProjectGpsSettings *gpsSettings();
 
    QgsLayerTree *layerTreeRoot() const;
 
    QgsLayerTreeRegistryBridge *layerTreeRegistryBridge() const { return mLayerTreeRegistryBridge.get(); }
 
    QgsMapThemeCollection *mapThemeCollection();
 
    QgsAnnotationManager *annotationManager();
 
    const QgsAnnotationManager *annotationManager() const SIP_SKIP;
 
    Q_DECL_DEPRECATED void setNonIdentifiableLayers( const QList<QgsMapLayer *> &layers );
 
    Q_DECL_DEPRECATED void setNonIdentifiableLayers( const QStringList &layerIds );
 
    Q_DECL_DEPRECATED QStringList nonIdentifiableLayers() const;
 
    Q_DECL_DEPRECATED bool autoTransaction() const SIP_DEPRECATED;
 
    Q_DECL_DEPRECATED void setAutoTransaction( bool autoTransaction ) SIP_DEPRECATED;
 
    Qgis::TransactionMode transactionMode() const;
 
    bool setTransactionMode( Qgis::TransactionMode transactionMode );
 
    QMap< QPair< QString, QString>, QgsTransactionGroup *> transactionGroups() SIP_SKIP;
 
    QgsTransactionGroup *transactionGroup( const QString &providerKey, const QString &connString );
 
    QgsVectorLayerEditBufferGroup *editBufferGroup();
 
    Q_DECL_DEPRECATED bool evaluateDefaultValues() const SIP_DEPRECATED;
 
    Q_DECL_DEPRECATED void setEvaluateDefaultValues( bool evaluateDefaultValues ) SIP_DEPRECATED;
 
    QgsExpressionContext createExpressionContext() const override;
    QgsExpressionContextScope *createExpressionContextScope() const override;
 
    QgsSnappingConfig snappingConfig() const;
 
    QList<QgsVectorLayer *> avoidIntersectionsLayers() const;
 
    void setAvoidIntersectionsLayers( const QList<QgsVectorLayer *> &layers );
 
    void setAvoidIntersectionsMode( const Qgis::AvoidIntersectionsMode mode );
 
    Qgis::AvoidIntersectionsMode avoidIntersectionsMode() const { return mAvoidIntersectionsMode; }
 
    QVariantMap customVariables() const;
 
    void setCustomVariables( const QVariantMap &customVariables );
 
    void setLabelingEngineSettings( const QgsLabelingEngineSettings &settings );
 
    const QgsLabelingEngineSettings &labelingEngineSettings() const;
 
    //
    // Functionality from QgsMapLayerRegistry
    //
 
    QgsMapLayerStore *layerStore();
 
    SIP_SKIP const QgsMapLayerStore *layerStore() const;
 
    int count() const;
 
    int validCount() const;
 
    Q_INVOKABLE QgsMapLayer *mapLayer( const QString &layerId ) const;
 
#ifndef SIP_RUN
 
    template <class T>
    T mapLayer( const QString &layerId ) const
    {
      return qobject_cast<T>( mapLayer( layerId ) );
    }
#endif
 
    Q_INVOKABLE QList<QgsMapLayer *> mapLayersByName( const QString &layerName ) const;
 
    QList<QgsMapLayer *> mapLayersByShortName( const QString &shortName ) const;
 
 
    QMap<QString, QgsMapLayer *> mapLayers( const bool validOnly = false ) const;
 
    bool isZipped() const;
 
#ifndef SIP_RUN
 
    template <typename T>
    QVector<T> layers() const
    {
      return mLayerStore->layers<T>();
    }
 
    template <typename T>
    QVector<T> mapLayersByShortName( const QString &shortName ) const
    {
      QVector<T> layers;
      const auto constMapLayers { mLayerStore->layers<T>() };
      for ( const auto l : constMapLayers )
      {
        if ( ! l->serverProperties()->shortName().isEmpty() )
        {
          if ( l->serverProperties()->shortName() == shortName )
            layers << l;
        }
        else if ( l->name() == shortName )
        {
          layers << l;
        }
      }
      return layers;
    }
 
#endif
 
    QList<QgsMapLayer *> addMapLayers( const QList<QgsMapLayer *> &mapLayers SIP_TRANSFER,
                                       bool addToLegend = true,
                                       bool takeOwnership SIP_PYARGREMOVE = true );
 
    QgsMapLayer *addMapLayer( QgsMapLayer *mapLayer SIP_TRANSFER,
                              bool addToLegend = true,
                              bool takeOwnership SIP_PYARGREMOVE = true );
 
#ifndef SIP_RUN
    void removeMapLayers( const QStringList &layerIds );
 
    //TODO QGIS 4.0 - add PyName alias to avoid list type conversion error
 
    void removeMapLayers( const QList<QgsMapLayer *> &layers );
#else
 
    void removeMapLayers( SIP_PYOBJECT layers SIP_TYPEHINT( Union[List[QgsVectorLayer], List[str]] ) );
    % MethodCode
    if ( !PyList_Check( a0 ) )
    {
      sipIsErr = 1;
      PyErr_SetString( PyExc_TypeError, "Expected a list of layers or layers IDs" );
    }
    else if ( PyList_GET_SIZE( a0 ) )
    {
      PyObject *firstLayerPyObj = PyList_GetItem( a0, 0 );
      if ( firstLayerPyObj )
      {
        int state;
        if ( sipCanConvertToType( firstLayerPyObj, sipType_QgsMapLayer, SIP_NOT_NONE ) )
        {
          const sipTypeDef *qlist_type = sipFindType( "QList<QgsMapLayer *>" );
          QList<QgsMapLayer *> *layersList = reinterpret_cast<QList<QgsMapLayer *> *>( sipConvertToType( a0, qlist_type, 0, SIP_NOT_NONE, &state, &sipIsErr ) );
          if ( !sipIsErr )
          {
            sipCpp->removeMapLayers( *layersList );
          }
          sipReleaseType( layersList, qlist_type, state );
        }
        else if ( sipCanConvertToType( firstLayerPyObj, sipType_QString, SIP_NOT_NONE ) )
        {
          QStringList *layersId = reinterpret_cast<QStringList *>( sipConvertToType( a0, sipType_QStringList, 0, SIP_NOT_NONE, &state, &sipIsErr ) );
          if ( !sipIsErr )
          {
            sipCpp->removeMapLayers( *layersId );
          }
          sipReleaseType( layersId, sipType_QStringList, state );
        }
        else
        {
          sipIsErr = 1;
          PyErr_SetString( PyExc_TypeError, "Expected a list of layers or layers IDs" );
        }
      }
    }
    % End
#endif
 
    void removeMapLayer( const QString &layerId );
 
    void removeMapLayer( QgsMapLayer *layer );
 
    QgsMapLayer *takeMapLayer( QgsMapLayer *layer ) SIP_TRANSFERBACK;
 
    QgsAnnotationLayer *mainAnnotationLayer();
 
    void removeAllMapLayers();
 
    void reloadAllLayers();
 
    QgsCoordinateReferenceSystem defaultCrsForNewLayers() const;
 
    Q_DECL_DEPRECATED void setTrustLayerMetadata( bool trust ) SIP_DEPRECATED;
 
    Q_DECL_DEPRECATED bool trustLayerMetadata() const SIP_DEPRECATED;
 
    const QgsAuxiliaryStorage *auxiliaryStorage() const SIP_SKIP;
 
    QgsAuxiliaryStorage *auxiliaryStorage();
 
    QString createAttachedFile( const QString &nameTemplate );
 
    QStringList attachedFiles() const;
 
    bool removeAttachedFile( const QString &path );
 
    QString attachmentIdentifier( const QString &attachedFile ) const;
 
    QString resolveAttachmentIdentifier( const QString &identifier ) const;
 
    const QgsProjectMetadata &metadata() const;
 
    void setMetadata( const QgsProjectMetadata &metadata );
 
    Q_DECL_DEPRECATED QSet<QgsMapLayer *> requiredLayers() const;
 
    Q_DECL_DEPRECATED void setRequiredLayers( const QSet<QgsMapLayer *> &layers );
 
    void setProjectColors( const QgsNamedColorList &colors );
 
    void setBackgroundColor( const QColor &color );
 
    QColor backgroundColor() const;
 
    void setSelectionColor( const QColor &color );
 
    QColor selectionColor() const;
 
    Q_DECL_DEPRECATED void setMapScales( const QVector<double> &scales ) SIP_DEPRECATED;
 
    Q_DECL_DEPRECATED QVector<double> mapScales() const SIP_DEPRECATED;
 
    Q_DECL_DEPRECATED void setUseProjectScales( bool enabled ) SIP_DEPRECATED;
 
    Q_DECL_DEPRECATED bool useProjectScales() const SIP_DEPRECATED;
 
    void generateTsFile( const QString &locale );
 
    QString translate( const QString &context, const QString &sourceText, const char *disambiguation = nullptr, int n = -1 ) const override;
 
    bool accept( QgsStyleEntityVisitorInterface *visitor ) const;
 
    QgsElevationShadingRenderer elevationShadingRenderer() const;
 
    void setElevationShadingRenderer( const QgsElevationShadingRenderer &elevationShadingRenderer );
 
    bool loadFunctionsFromProject( bool force = false ) SIP_SKIP;
 
    void cleanFunctionsFromProject() SIP_SKIP;
 
 
#ifdef SIP_RUN
    SIP_PYOBJECT __repr__();
    % MethodCode
    QString str = QStringLiteral( "<QgsProject: '%1'%2>" ).arg( sipCpp->fileName(),
                  sipCpp == QgsProject::instance() ? QStringLiteral( " (singleton instance)" ) : QString() ); // skip-keyword-check
    sipRes = PyUnicode_FromString( str.toUtf8().constData() );
    % End
#endif
 
  signals:
 
    void cleared();
 
    void aboutToBeCleared();
 
    void readProject( const QDomDocument &document );
 
    void readProjectWithContext( const QDomDocument &document, QgsReadWriteContext &context );
 
    void writeProject( QDomDocument &document );
 
    void readMapLayer( QgsMapLayer *mapLayer, const QDomElement &layerNode );
 
    void writeMapLayer( QgsMapLayer *mapLayer, QDomElement &layerElem, QDomDocument &doc );
 
    void projectSaved();
 
    Q_DECL_DEPRECATED void oldProjectVersionWarning( const QString &warning ) SIP_DEPRECATED;
 
    void readVersionMismatchOccurred( const QString &fileVersion );
 
    void layerLoaded( int i, int n );
 
    void loadingLayer( const QString &layerName );
 
    void loadingLayerMessageReceived( const QString &layerName, const QList<QgsReadWriteContext::ReadWriteMessage> &messages );
 
    Q_DECL_DEPRECATED void nonIdentifiableLayersChanged( QStringList nonIdentifiableLayers );
 
    void fileNameChanged();
 
    void homePathChanged();
 
    void snappingConfigChanged( const QgsSnappingConfig &config );
 
    void avoidIntersectionsModeChanged();
 
    void customVariablesChanged();
 
    void crsChanged();
 
    void crs3DChanged();
 
    void verticalCrsChanged();
 
    void ellipsoidChanged( const QString &ellipsoid );
 
    void distanceUnitsChanged();
 
    void areaUnitsChanged();
 
    void scaleMethodChanged();
 
    void transformContextChanged();
 
    void missingDatumTransforms( const QStringList &missingTransforms );
 
    void transactionModeChanged();
 
    void transactionGroupsChanged();
 
    void topologicalEditingChanged();
 
    void avoidIntersectionsLayersChanged();
 
    void mapThemeCollectionChanged();
 
    void labelingEngineSettingsChanged();
 
    void metadataChanged();
 
    void projectColorsChanged();
 
    void backgroundColorChanged();
 
    void selectionColorChanged();
 
    //
    // signals from QgsMapLayerRegistry
    //
 
    void layersWillBeRemoved( const QStringList &layerIds );
 
    void layersWillBeRemoved( const QList<QgsMapLayer *> &layers );
 
    void layerWillBeRemoved( const QString &layerId );
 
    void layerWillBeRemoved( QgsMapLayer *layer );
 
    void layersRemoved( const QStringList &layerIds );
 
    void layerRemoved( const QString &layerId );
 
    //TODO QGIS 4.0 - rename to past tense
 
    void removeAll();
 
    void layersAdded( const QList<QgsMapLayer *> &layers );
 
    void layerWasAdded( QgsMapLayer *layer );
 
    void legendLayersAdded( const QList<QgsMapLayer *> &layers );
 
    void isDirtyChanged( bool dirty );
 
    void dirtySet();
 
    Q_DECL_DEPRECATED void mapScalesChanged() SIP_DEPRECATED;
 
    void elevationShadingRendererChanged();
 
  public slots:
 
    void setSnappingConfig( const QgsSnappingConfig &snappingConfig );
 
    // TODO QGIS 4.0 - rename b to dirty
 
    void setDirty( bool b = true );
 
    void setPresetHomePath( const QString &path );
 
    void registerTranslatableContainers( QgsTranslationContext *translationContext, QgsAttributeEditorContainer *parent, const QString &layerId );
 
    void registerTranslatableObjects( QgsTranslationContext *translationContext );
 
    void setDataDefinedServerProperties( const QgsPropertyCollection &properties );
 
    QgsPropertyCollection dataDefinedServerProperties() const;
 
    bool startEditing( QgsVectorLayer *vectorLayer = nullptr );
 
    bool commitChanges( QStringList &commitErrors SIP_OUT, bool stopEditing = true, QgsVectorLayer *vectorLayer = nullptr );
 
    bool rollBack( QStringList &rollbackErrors SIP_OUT, bool stopEditing = true, QgsVectorLayer *vectorLayer = nullptr );
 
  private slots:
    void onMapLayersAdded( const QList<QgsMapLayer *> &layers );
    void onMapLayersRemoved( const QList<QgsMapLayer *> &layers );
    void cleanTransactionGroups( bool force = false );
    void updateTransactionGroups();
 
  private:
 
    static QgsProject *sProject;
 
 
    bool _getMapLayers( const QDomDocument &doc, QList<QDomNode> &brokenNodes, Qgis::ProjectReadFlags flags = Qgis::ProjectReadFlags() );
 
    void setError( const QString &errorMessage ) SIP_SKIP;
 
    void clearError() SIP_SKIP;
 
    bool addLayer( const QDomElement &layerElem,
                   QList<QDomNode> &brokenNodes,
                   QgsReadWriteContext &context,
                   Qgis::ProjectReadFlags flags = Qgis::ProjectReadFlags(),
                   QgsDataProvider *provider = nullptr ) SIP_SKIP;
 
    void removeAuxiliaryLayer( const QgsMapLayer *ml );
 
    void initializeEmbeddedSubtree( const QString &projectFilePath, QgsLayerTreeGroup *group, Qgis::ProjectReadFlags flags = Qgis::ProjectReadFlags() ) SIP_SKIP;
 
    bool loadEmbeddedNodes( QgsLayerTreeGroup *group, Qgis::ProjectReadFlags flags = Qgis::ProjectReadFlags() ) SIP_SKIP;
 
    bool readProjectFile( const QString &filename, Qgis::ProjectReadFlags flags = Qgis::ProjectReadFlags() );
 
    bool writeProjectFile( const QString &filename );
 
    bool unzip( const QString &filename, Qgis::ProjectReadFlags flags = Qgis::ProjectReadFlags() );
 
    bool zip( const QString &filename );
 
    bool saveAuxiliaryStorage( const QString &filename = QString() );
 
    void loadProjectFlags( const QDomDocument *doc );
 
    static QgsPropertiesDefinition &dataDefinedServerPropertyDefinitions();
 
    void preloadProviders( const QVector<QDomNode> &asynchronusLayerNodes,
                           const QgsReadWriteContext &context,
                           QMap<QString, QgsDataProvider *> &loadedProviders,
                           QgsMapLayer::ReadFlags layerReadFlags,
                           int totalProviderCount );
 
    void releaseHandlesToProjectArchive();
 
    bool rebuildCrs3D( QString *error = nullptr );
 
    Qgis::ProjectCapabilities mCapabilities;
 
    std::unique_ptr< QgsMapLayerStore > mLayerStore;
 
    QString mErrorMessage;
 
    std::unique_ptr<QgsProjectBadLayerHandler> mBadLayerHandler;
 
    QHash< QString, QPair< QString, bool> > mEmbeddedLayers;
 
    QgsSnappingConfig mSnappingConfig;
    Qgis::AvoidIntersectionsMode mAvoidIntersectionsMode = Qgis::AvoidIntersectionsMode::AllowIntersections;
 
    std::unique_ptr<QgsRelationManager> mRelationManager;
 
    std::unique_ptr<QgsAnnotationManager> mAnnotationManager;
    std::unique_ptr<QgsLayoutManager> mLayoutManager;
    std::unique_ptr<QgsMapViewsManager> m3DViewsManager;
 
    QgsBookmarkManager *mBookmarkManager = nullptr;
 
    QgsSensorManager *mSensorManager = nullptr;
 
    QgsProjectViewSettings *mViewSettings = nullptr;
 
    QgsProjectStyleSettings *mStyleSettings = nullptr;
 
    QgsProjectTimeSettings *mTimeSettings = nullptr;
 
    QgsProjectElevationProperties *mElevationProperties = nullptr;
 
    QgsProjectDisplaySettings *mDisplaySettings = nullptr;
 
    QgsProjectGpsSettings *mGpsSettings = nullptr;
 
    std::unique_ptr<QgsLayerTree> mRootGroup;
 
    std::unique_ptr<QgsLayerTreeRegistryBridge> mLayerTreeRegistryBridge;
 
    QgsAnnotationLayer *mMainAnnotationLayer = nullptr;
 
    QMap< QPair< QString, QString>, QgsTransactionGroup *> mTransactionGroups;
 
    QgsVectorLayerEditBufferGroup mEditBufferGroup;
 
    std::unique_ptr<QgsMapThemeCollection> mMapThemeCollection;
 
    std::unique_ptr<QgsLabelingEngineSettings> mLabelingEngineSettings;
 
    QVariantMap mCustomVariables;
 
    std::unique_ptr<QgsArchive> mArchive;
 
    std::unique_ptr<QgsAuxiliaryStorage> mAuxiliaryStorage;
 
    QFile mFile;                 // current physical project file
 
    QString mOriginalPath;
 
    QString mSaveUser;              // last saved user.
    QString mSaveUserFull;          // last saved user full name.
    QDateTime mSaveDateTime;
    QgsProjectVersion mSaveVersion;
 
    QString mHomePath;
    mutable QString mCachedHomePath;
 
    QColor mBackgroundColor;
    QColor mSelectionColor;
 
    Qgis::DistanceUnit mDistanceUnits = Qgis::DistanceUnit::Meters;
    Qgis::AreaUnit mAreaUnits = Qgis::AreaUnit::SquareMeters;
    Qgis::ScaleCalculationMethod mScaleMethod = Qgis::ScaleCalculationMethod::HorizontalMiddle;
 
    mutable QgsProjectPropertyKey mProperties;  // property hierarchy, TODO: this shouldn't be mutable
    Qgis::TransactionMode mTransactionMode = Qgis::TransactionMode::Disabled; // transaction grouped editing
 
    Qgis::ProjectFlags mFlags;
    QgsCoordinateReferenceSystem mCrs;
    QgsCoordinateReferenceSystem mVerticalCrs;
    QgsCoordinateReferenceSystem mCrs3D;
 
    bool mDirty = false;                 // project has been modified since it has been read or saved
    int mDirtyBlockCount = 0;
 
    QgsPropertyCollection mDataDefinedServerProperties;
 
    QgsCoordinateTransformContext mTransformContext;
 
    QgsProjectMetadata mMetadata;
 
    std::unique_ptr< QTranslator > mTranslator;
 
    bool mIsBeingDeleted = false;
 
    QgsSettings mSettings;
 
    mutable std::unique_ptr< QgsExpressionContextScope > mProjectScope;
 
    bool mBlockChangeSignalsDuringClear = false;
    int mBlockSnappingUpdates = 0;
 
    QgsElevationShadingRenderer mElevationShadingRenderer;
 
    friend class QgsApplication;
 
    friend class QgsProjectDirtyBlocker;
 
    // Required to avoid creating a new project in it's destructor
    friend class QgsProviderRegistry;
 
    // Required by QGIS Server for switching the current project instance
    friend class QgsServer;
 
    friend class TestQgsProject;
 
    Q_DISABLE_COPY( QgsProject )
};
 
class CORE_EXPORT QgsProjectDirtyBlocker
{
  public:
 
    QgsProjectDirtyBlocker( QgsProject *project )
      : mProject( project )
    {
      mProject->mDirtyBlockCount++;
    }
 
    QgsProjectDirtyBlocker( const QgsProjectDirtyBlocker &other ) = delete;
    QgsProjectDirtyBlocker &operator=( const QgsProjectDirtyBlocker &other ) = delete;
 
    ~QgsProjectDirtyBlocker()
    {
      mProject->mDirtyBlockCount--;
    }
 
  private:
    QgsProject *mProject = nullptr;
 
#ifdef SIP_RUN
    QgsProjectDirtyBlocker( const QgsProjectDirtyBlocker &other );
#endif
};
 
CORE_EXPORT QgsProjectVersion getVersion( QDomDocument const &doc ) SIP_SKIP;
 
 
 
#ifndef SIP_RUN
class GetNamedProjectColor : public QgsScopedExpressionFunction
{
  public:
    GetNamedProjectColor( const QgsProject *project );
 
    GetNamedProjectColor( const QHash< QString, QColor > &colors );
 
    QVariant func( const QVariantList &values, const QgsExpressionContext *, QgsExpression *, const QgsExpressionNodeFunction * ) override;
    QgsScopedExpressionFunction *clone() const override;
 
  private:
 
    QHash< QString, QColor > mColors;
};
 
class GetNamedProjectColorObject : public QgsScopedExpressionFunction
{
  public:
    GetNamedProjectColorObject( const QgsProject *project );
 
    GetNamedProjectColorObject( const QHash< QString, QColor > &colors );
 
    QVariant func( const QVariantList &values, const QgsExpressionContext *, QgsExpression *, const QgsExpressionNodeFunction * ) override;
    QgsScopedExpressionFunction *clone() const override;
 
  private:
 
    QHash< QString, QColor > mColors;
};
 
 
 
class GetSensorData : public QgsScopedExpressionFunction
{
  public:
    GetSensorData( const QMap<QString, QgsAbstractSensor::SensorData> &sensorData = QMap<QString, QgsAbstractSensor::SensorData>() );
    QVariant func( const QVariantList &values, const QgsExpressionContext *, QgsExpression *, const QgsExpressionNodeFunction * ) override;
    QgsScopedExpressionFunction *clone() const override;
 
  private:
 
    QMap<QString, QgsAbstractSensor::SensorData> mSensorData;
};
#endif
 
#endif