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 "qgsunittypes.h"
#include "qgssnappingconfig.h"
#include "qgsprojectversion.h"
#include "qgsexpressioncontextgenerator.h"
#include "qgscoordinatereferencesystem.h"
#include "qgscoordinatetransformcontext.h"
#include "qgsprojectproperty.h"
#include "qgsmaplayer.h"
#include "qgsmaplayerstore.h"
#include "qgsarchive.h"

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

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

class CORE_EXPORT QgsProject : public QObject, public QgsExpressionContextGenerator
{
    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 NOTIFY homePathChanged )
    Q_PROPERTY( QgsCoordinateReferenceSystem crs READ crs WRITE setCrs NOTIFY crsChanged )
    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 )

  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;

    QFileInfo fileInfo() const;

    QgsCoordinateReferenceSystem crs() const;

    void setCrs( const QgsCoordinateReferenceSystem &crs );

    QString ellipsoid() const;

    void setEllipsoid( const QString &ellipsoid );


    QgsCoordinateTransformContext transformContext() const;

    void setTransformContext( const QgsCoordinateTransformContext &context );

    void clear();

    bool read( const QString &filename );

    bool read();

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

    QgsLayerTreeGroup *createEmbeddedGroup( const QString &groupName, const QString &projectFilePath, const QStringList &invisibleLayers );

    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;

    QgsRelationManager *relationManager() const;

    const QgsLayoutManager *layoutManager() const SIP_SKIP;

    QgsLayoutManager *layoutManager();

    QgsLayerTree *layerTreeRoot() const;

    QgsLayerTreeRegistryBridge *layerTreeRegistryBridge() const { return mLayerTreeRegistryBridge; }

    QgsMapThemeCollection *mapThemeCollection();

    QgsAnnotationManager *annotationManager();

    const QgsAnnotationManager *annotationManager() const SIP_SKIP;

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

    void setNonIdentifiableLayers( const QStringList &layerIds );

    QStringList nonIdentifiableLayers() const;

    bool autoTransaction() const;

    void setAutoTransaction( bool autoTransaction );

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

    bool evaluateDefaultValues() const;


    void setEvaluateDefaultValues( bool evaluateDefaultValues );

    QgsExpressionContext createExpressionContext() 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;

    QgsMapLayer *mapLayer( const QString &layerId ) const;

    QList<QgsMapLayer *> mapLayersByName( const QString &layerName ) const;

    QMap<QString, QgsMapLayer *> mapLayers() const;

    bool isZipped() const;

#ifndef SIP_RUN

    template <typename T>
    QVector<T> layers() const
    {
      return mLayerStore->layers<T>();
    }
#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 3.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();

  signals:
    void readProject( const QDomDocument & );

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

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

    //
    // 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 3.0 - rename to past tense
    void removeAll();

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

    void layerWasAdded( QgsMapLayer *layer );

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



  public slots:

    void setSnappingConfig( const QgsSnappingConfig &snappingConfig );

    void setDirty( bool b = true );

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

  private:

    static QgsProject *sProject;

    bool _getMapLayers( const QDomDocument &doc, QList<QDomNode> &brokenNodes );

    void setError( const QString &errorMessage ) SIP_SKIP;

    void clearError() SIP_SKIP;

    bool addLayer( const QDomElement &layerElem, QList<QDomNode> &brokenNodes, const QgsReadWriteContext &context ) SIP_SKIP;

    void initializeEmbeddedSubtree( const QString &projectFilePath, QgsLayerTreeGroup *group ) SIP_SKIP;

    void loadEmbeddedNodes( QgsLayerTreeGroup *group ) SIP_SKIP;

    bool readProjectFile( const QString &filename );

    bool writeProjectFile( const QString &filename );

    bool unzip( const QString &filename );

    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;

    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
    mutable QgsProjectPropertyKey mProperties;  // property hierarchy, TODO: this shouldn't be mutable
    QString mTitle;              // project title
    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
    bool mTrustLayerMetadata = false;

    QgsCoordinateTransformContext mTransformContext;
};

CORE_EXPORT QgsProjectVersion getVersion( QDomDocument const &doc ) SIP_SKIP;

#endif