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 <memory>
#include <QHash>
#include <QList>
#include <QObject>
#include <QPair>
#include <QFileInfo>
#include <QStringList>
#include <QTranslator>

#include "qgsunittypes.h"
#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 "qgsprojecttranslator.h"
#include "qgsattributeeditorelement.h"
#include "qgscolorscheme.h"

class QFileInfo;
class QDomDocument;
class QDomElement;
class QDomNode;

class QgsLayerTreeGroup;
class QgsLayerTreeRegistryBridge;
class QgsMapLayer;
class QgsMapThemeCollection;
class QgsPathResolver;
class QgsProjectBadLayerHandler;
class QgsProjectStorage;
class QgsRelationManager;
class QgsTolerance;
class QgsTransactionGroup;
class QgsVectorLayer;
class QgsAnnotationManager;
class QgsLayoutManager;
class QgsLayerTree;
class QgsLabelingEngineSettings;
class QgsAuxiliaryStorage;
class QgsMapLayer;
class QgsBookmarkManager;

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( 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 )

  public:
    static QgsProject *instance();

    explicit QgsProject( QObject *parent SIP_TRANSFERTHIS = nullptr );

    ~QgsProject() override;

    void setTitle( const QString &title );

    QString title() const;

    bool isDirty() const;

    void setFileName( const QString &name );

    QString fileName() const;

    Q_DECL_DEPRECATED QFileInfo fileInfo() const SIP_DEPRECATED;

    QgsProjectStorage *projectStorage() const;

    QDateTime lastModified() const;

    QString absoluteFilePath() const;

    QString absolutePath() const;

    QString baseName() const;

    QgsCoordinateReferenceSystem crs() const;

    void setCrs( const QgsCoordinateReferenceSystem &crs, bool adjustEllipsoid = false );

    QString ellipsoid() const;

    void setEllipsoid( const QString &ellipsoid );


    QgsCoordinateTransformContext transformContext() const;

    void setTransformContext( const QgsCoordinateTransformContext &context );

    void clear();

    enum ReadFlag
    {
      FlagDontResolveLayers = 1 << 0, 
      FlagDontLoadLayouts = 1 << 1, 
    };
    Q_DECLARE_FLAGS( ReadFlags, ReadFlag )

    
    bool read( const QString &filename, QgsProject::ReadFlags flags = nullptr );

    bool read( QgsProject::ReadFlags flags = nullptr );

    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 = nullptr ) const;

    QString readEntry( const QString &scope, const QString &key, const QString &def = QString(), bool *ok = nullptr ) const;
    int readNumEntry( const QString &scope, const QString &key, int def = 0, bool *ok = nullptr ) const;
    double readDoubleEntry( const QString &scope, const QString &key, double def = 0, bool *ok = nullptr ) const;
    bool readBoolEntry( const QString &scope, const QString &key, bool def = false, bool *ok = 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, QgsProject::ReadFlags flags = nullptr ) SIP_SKIP;

    QgsLayerTreeGroup *createEmbeddedGroup( const QString &groupName, const QString &projectFilePath, const QStringList &invisibleLayers, QgsProject::ReadFlags flags = nullptr );

    void setTopologicalEditing( bool enabled );

    bool topologicalEditing() const;

    QgsUnitTypes::DistanceUnit distanceUnits() const;

    void setDistanceUnits( QgsUnitTypes::DistanceUnit unit );

    QgsUnitTypes::AreaUnit areaUnits() const;

    void setAreaUnits( QgsUnitTypes::AreaUnit unit );

    QString homePath() const;

    QString presetHomePath() const;

    QgsRelationManager *relationManager() const;

    const QgsLayoutManager *layoutManager() const SIP_SKIP;

    QgsLayoutManager *layoutManager();

    const QgsBookmarkManager *bookmarkManager() const SIP_SKIP;

    QgsBookmarkManager *bookmarkManager();

    QgsLayerTree *layerTreeRoot() const;

    QgsLayerTreeRegistryBridge *layerTreeRegistryBridge() const { return mLayerTreeRegistryBridge; }

    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;

    bool autoTransaction() const;

    void setAutoTransaction( bool autoTransaction );

    QMap< QPair< QString, QString>, QgsTransactionGroup *> transactionGroups() SIP_SKIP;

    QgsTransactionGroup *transactionGroup( const QString &providerKey, const QString &connString );

    bool evaluateDefaultValues() const;

    void setEvaluateDefaultValues( bool evaluateDefaultValues );

    QgsExpressionContext createExpressionContext() const override;
    QgsExpressionContextScope *createExpressionContextScope() const override;

    QgsSnappingConfig snappingConfig() const;

    QList<QgsVectorLayer *> avoidIntersectionsLayers() const;

    void setAvoidIntersectionsLayers( const QList<QgsVectorLayer *> &layers );

    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

    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->shortName().isEmpty() )
        {
          if ( l->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 );

    void removeMapLayers( const QStringList &layerIds );

    //TODO QGIS 4.0 - add PyName alias to avoid list type conversion error

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

    void removeMapLayer( const QString &layerId );

    void removeMapLayer( QgsMapLayer *layer );

    QgsMapLayer *takeMapLayer( QgsMapLayer *layer ) SIP_TRANSFERBACK;

    void removeAllMapLayers();

    void reloadAllLayers();

    QgsCoordinateReferenceSystem defaultCrsForNewLayers() const;

    void setTrustLayerMetadata( bool trust );

    bool trustLayerMetadata() const { return mTrustLayerMetadata; }

    const QgsAuxiliaryStorage *auxiliaryStorage() const SIP_SKIP;

    QgsAuxiliaryStorage *auxiliaryStorage();

    QString attachedFile( const QString &fileName ) const SIP_SKIP;

    QgsStringMap attachedFiles() const SIP_SKIP;

    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;

    void setMapScales( const QVector<double> &scales );

    QVector<double> mapScales() const;

    void setUseProjectScales( bool enabled );

    bool useProjectScales() const;

    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;

#ifdef SIP_RUN
    SIP_PYOBJECT __repr__();
    % MethodCode
    QString str = QStringLiteral( "<QgsProject: '%1'%2>" ).arg( sipCpp->fileName(),
                  sipCpp == QgsProject::instance() ? QStringLiteral( " (singleton instance)" ) : QString() );
    sipRes = PyUnicode_FromString( str.toUtf8().constData() );
    % End
#endif

  signals:

    void cleared();

    void readProject( const QDomDocument & );

    void readProjectWithContext( const QDomDocument &, QgsReadWriteContext &context );

    void writeProject( QDomDocument & );

    void readMapLayer( QgsMapLayer *mapLayer, const QDomElement &layerNode );

    void writeMapLayer( QgsMapLayer *mapLayer, QDomElement &layerElem, QDomDocument &doc );

    void projectSaved();

    void oldProjectVersionWarning( const QString & );

    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 customVariablesChanged();

    void crsChanged();

    void ellipsoidChanged( const QString &ellipsoid );


    void transformContextChanged();

    void missingDatumTransforms( const QStringList &missingTransforms );

    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 collectAttachedFiles( QgsStringMap &files SIP_INOUT ) SIP_SKIP;

    void mapScalesChanged();

  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 );

  private slots:
    void onMapLayersAdded( const QList<QgsMapLayer *> &layers );
    void onMapLayersRemoved( const QList<QgsMapLayer *> &layers );
    void cleanTransactionGroups( bool force = false );

  private:

    static QgsProject *sProject;

    static void setInstance( QgsProject *project ) SIP_SKIP;

    bool _getMapLayers( const QDomDocument &doc, QList<QDomNode> &brokenNodes, QgsProject::ReadFlags flags = nullptr );

    void setError( const QString &errorMessage ) SIP_SKIP;

    void clearError() SIP_SKIP;

    bool addLayer( const QDomElement &layerElem, QList<QDomNode> &brokenNodes, QgsReadWriteContext &context, QgsProject::ReadFlags flags = nullptr ) SIP_SKIP;

    void initializeEmbeddedSubtree( const QString &projectFilePath, QgsLayerTreeGroup *group, QgsProject::ReadFlags flags = nullptr ) SIP_SKIP;

    void loadEmbeddedNodes( QgsLayerTreeGroup *group, QgsProject::ReadFlags flags = nullptr ) SIP_SKIP;

    bool readProjectFile( const QString &filename, QgsProject::ReadFlags flags = nullptr );

    bool writeProjectFile( const QString &filename );

    bool unzip( const QString &filename, QgsProject::ReadFlags flags = nullptr );

    bool zip( const QString &filename );

    bool saveAuxiliaryStorage( const QString &filename = QString() );

    std::unique_ptr< QgsMapLayerStore > mLayerStore;

    QString mErrorMessage;

    QgsProjectBadLayerHandler *mBadLayerHandler = nullptr;

    QHash< QString, QPair< QString, bool> > mEmbeddedLayers;

    QgsSnappingConfig mSnappingConfig;

    QgsRelationManager *mRelationManager = nullptr;

    std::unique_ptr<QgsAnnotationManager> mAnnotationManager;
    std::unique_ptr<QgsLayoutManager> mLayoutManager;

    QgsBookmarkManager *mBookmarkManager = nullptr;

    QgsLayerTree *mRootGroup = nullptr;

    QgsLayerTreeRegistryBridge *mLayerTreeRegistryBridge = nullptr;

    QMap< QPair< QString, QString>, QgsTransactionGroup *> mTransactionGroups;

    std::unique_ptr<QgsMapThemeCollection> mMapThemeCollection;

    std::unique_ptr<QgsLabelingEngineSettings> mLabelingEngineSettings;

    QVariantMap mCustomVariables;

    std::unique_ptr<QgsProjectArchive> mArchive;

    std::unique_ptr<QgsAuxiliaryStorage> mAuxiliaryStorage;

    QFile mFile;                 // current physical project file

    QString mHomePath;
    mutable QString mCachedHomePath;

    QColor mBackgroundColor;
    QColor mSelectionColor;

    mutable QgsProjectPropertyKey mProperties;  // property hierarchy, TODO: this shouldn't be mutable
    bool mAutoTransaction = false;       // transaction grouped editing
    bool mEvaluateDefaultValues = false; // evaluate default values immediately
    QgsCoordinateReferenceSystem mCrs;
    bool mDirty = false;                 // project has been modified since it has been read or saved
    int mDirtyBlockCount = 0;
    bool mTrustLayerMetadata = false;

    QgsCoordinateTransformContext mTransformContext;

    QgsProjectMetadata mMetadata;

    std::unique_ptr< QTranslator > mTranslator;

    bool mIsBeingDeleted = false;

    mutable std::unique_ptr< QgsExpressionContextScope > mProjectScope;

    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 QgsConfigCache;
};

Q_DECLARE_OPERATORS_FOR_FLAGS( QgsProject::ReadFlags )


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;

};

#endif

#endif