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 <memory>
 
#include "qgis.h"
#include "qgis_core.h"
#include "qgis_sip.h"
#include "qgsabstractsensor.h"
#include "qgsarchive.h"
#include "qgscolorscheme.h"
#include "qgscoordinatereferencesystem.h"
#include "qgscoordinatetransformcontext.h"
#include "qgselevationshadingrenderer.h"
#include "qgsexpressioncontextgenerator.h"
#include "qgsexpressioncontextscopegenerator.h"
#include "qgsmaplayerstore.h"
#include "qgsmapthemecollection.h"
#include "qgsprojectdisplaysettings.h"
#include "qgsprojectmetadata.h"
#include "qgsprojectproperty.h"
#include "qgsprojecttranslator.h"
#include "qgsprojectversion.h"
#include "qgspropertycollection.h"
#include "qgsreadwritecontext.h"
#include "qgsrelationmanager.h"
#include "qgssettings.h"
#include "qgssnappingconfig.h"
#include "qgstranslationcontext.h"
#include "qgsvectorlayereditbuffergroup.h"
 
#include <QFileInfo>
#include <QHash>
#include <QList>
#include <QObject>
#include <QPair>
#include <QString>
#include <QStringList>
#include <QTranslator>
 
using namespace Qt::StringLiterals;
 
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 QgsElevationProfileManager;
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 QgsObjectEntityVisitorInterface;
class QgsObjectVisitorContext;
class QgsSelectiveMaskingSourceSetManager;

 
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 title READ title WRITE setTitle NOTIFY titleChanged )
    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;

    std::unique_ptr< 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 QgsElevationProfileManager *elevationProfileManager() const SIP_SKIP;

    QgsElevationProfileManager *elevationProfileManager();

    const QgsSelectiveMaskingSourceSetManager *selectiveMaskingSourceSetManager() const SIP_SKIP;

    QgsSelectiveMaskingSourceSetManager *selectiveMaskingSourceSetManager();

    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 5.0 - add PyName alias to avoid list type conversion error

    void removeMapLayers( const QList<QgsMapLayer *> &layers );
#else
    // clang-format off

    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
// clang-format on
#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;

    bool accept( QgsObjectEntityVisitorInterface *visitor, const QgsObjectVisitorContext &context ) const;

    QgsElevationShadingRenderer elevationShadingRenderer() const;

    void setElevationShadingRenderer( const QgsElevationShadingRenderer &elevationShadingRenderer );

    bool loadFunctionsFromProject( bool force = false ) SIP_SKIP;

    void cleanFunctionsFromProject() SIP_SKIP;
 
#ifdef SIP_RUN
    // clang-format off
    SIP_PYOBJECT __repr__();
    % MethodCode
    QString str = u"<QgsProject: '%1'%2>"_s.arg( sipCpp->fileName(),
                  sipCpp == QgsProject::instance() ? u" (singleton instance)"_s : QString() ); // skip-keyword-check
    sipRes = PyUnicode_FromString( str.toUtf8().constData() );
    % End
// clang-format on
#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 titleChanged();

    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 5.0 - rename to past tense

    void removeAll();

    void layersAdded( const QList<QgsMapLayer *> &layers );

    void layerWasAdded( QgsMapLayer *layer );

    void legendLayersAdded( const QList<QgsMapLayer *> &layers );

    void layersAddedWithoutLegend( 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 5.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<QgsElevationProfileManager> mElevationProfileManager;
    std::unique_ptr<QgsSelectiveMaskingSourceSetManager> mSelectiveMaskingSourceSetManager;
    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