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 "qgsprojectversion.h"
#include <QHash>
#include <QList>
#include <QObject>
#include <QPair>
#include <QFileInfo>

//for the snap settings
#include "qgssnapper.h"
#include "qgstolerance.h"
#include "qgsunittypes.h"

//#include <QDomDocument>

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

class QgsLayerTreeGroup;
class QgsLayerTreeRegistryBridge;
class QgsMapLayer;
class QgsProjectBadLayerHandler;
class QgsRelationManager;
class QgsVectorLayer;
class QgsVisibilityPresetCollection;
class QgsTransactionGroup;

// TODO Might want to consider moving from Singleton; i.e., allowing more than one
// project.  Just as the GIMP can have simultaneous multiple images, perhaps
// QGIS can one day have simultaneous multiple projects.

class CORE_EXPORT QgsProject : public QObject
{
    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 )

  public:

    // TODO XXX Should have semantics for saving project if dirty as last gasp?
    ~QgsProject();

    static QgsProject * instance();

    Q_DECL_DEPRECATED inline void title( const QString & title ) { setTitle( title ); }

    void setTitle( const QString& title );

    QString title() const;

    bool isDirty() const;

    Q_DECL_DEPRECATED inline void dirty( bool b ) { setDirty( b ); }

    void setFileName( const QString& name );

    QString fileName() const;

    QFileInfo fileInfo() const;

    void clear();

    bool read( const QFileInfo& file );

    bool read();

    bool read( QDomNode& layerNode );

    bool write( const QFileInfo& file );

    bool write();

    Q_DECL_DEPRECATED void clearProperties();


    /* key value mutators
     *
     * keys would be the familiar QSettings-like '/' delimited entries, implying
     * a hierarchy of keys and corresponding values
     *
     * @note The key string must be valid xml tag names in order to be saved to the file.
     */
    bool writeEntry( const QString & scope, const QString & key, bool value );
    bool writeEntry( const QString & scope, const QString & key, double value );
    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::null, 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;

    QString writePath( const QString& filename, const QString& relativeBasePath = QString() ) const;

    QString readPath( QString filename, const QString& relativeBasePath = QString() ) const;

    QString error() const;

    void setBadLayerHandler( QgsProjectBadLayerHandler* handler );

    QString layerIsEmbedded( const QString& id ) const;

    bool createEmbeddedLayer( const QString& layerId, const QString& projectFilePath, QList<QDomNode>& brokenNodes,
                              QList< QPair< QgsVectorLayer*, QDomElement > >& vectorLayerList, bool saveFlag = true );

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

    void setSnapSettingsForLayer( const QString& layerId, bool enabled, QgsSnapper::SnappingType type, QgsTolerance::UnitType unit, double tolerance,
                                  bool avoidIntersection );

    bool snapSettingsForLayer( const QString& layerId, bool& enabled, QgsSnapper::SnappingType& type, QgsTolerance::UnitType& units, double& tolerance,
                               bool& avoidIntersection ) const;

    void setTopologicalEditing( bool enabled );

    bool topologicalEditing() const;

    QGis::UnitType distanceUnits() const;

    QgsUnitTypes::AreaUnit areaUnits() const;

    QString homePath() const;

    QgsRelationManager* relationManager() const;

    QgsLayerTreeGroup* layerTreeRoot() const;

    QgsLayerTreeRegistryBridge* layerTreeRegistryBridge() const { return mLayerTreeRegistryBridge; }

    QgsVisibilityPresetCollection* visibilityPresetCollection();

    void setNonIdentifiableLayers( QList<QgsMapLayer*> layers );

    void setNonIdentifiableLayers( const QStringList& layerIds );

    QStringList nonIdentifiableLayers() const;

    bool autoTransaction() const;

    void setAutoTransaction( bool autoTransaction );

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

    bool evaluateDefaultValues() const;


    void setEvaluateDefaultValues( bool evaluateDefaultValues );

  protected:
    void setError( const QString& errorMessage );

    void clearError();

    bool addLayer( const QDomElement& layerElem, QList<QDomNode>& brokenNodes, QList< QPair< QgsVectorLayer*, QDomElement > >& vectorLayerList );

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

    void loadEmbeddedNodes( QgsLayerTreeGroup* group );

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

    // @param i current layer
    // @param n number of layers
    void layerLoaded( int i, int n );

    void loadingLayer( const QString& );

    void snapSettingsChanged();

    void nonIdentifiableLayersChanged( QStringList nonIdentifiableLayers );

    void fileNameChanged();

    void homePathChanged();

    void variablesChanged();

  public slots:

    void setDirty( bool b = true );

    void emitVariablesChanged();

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

  private:

    QgsProject(); // private 'cause it's a singleton

    QgsProject( QgsProject const & ); // private 'cause it's a singleton

    struct Imp;

    QScopedPointer<Imp> imp_;

    static QgsProject * theProject_;

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

    void processLayerJoins( QgsVectorLayer* layer );

    QString mErrorMessage;

    QgsProjectBadLayerHandler* mBadLayerHandler;

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

    void snapSettings( QStringList& layerIdList, QStringList& enabledList, QStringList& snapTypeList, QStringList& snapUnitList, QStringList& toleranceUnitList,
                       QStringList& avoidIntersectionList ) const;

    QgsRelationManager* mRelationManager;

    QgsLayerTreeGroup* mRootGroup;

    QgsLayerTreeRegistryBridge* mLayerTreeRegistryBridge;

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

    QScopedPointer<QgsVisibilityPresetCollection> mVisibilityPresetCollection;
};


class CORE_EXPORT QgsProjectBadLayerHandler
{
  public:
    virtual void handleBadLayers( const QList<QDomNode>& layers, const QDomDocument& projectDom ) = 0;
    virtual ~QgsProjectBadLayerHandler() {}
};


class CORE_EXPORT QgsProjectBadLayerDefaultHandler : public QgsProjectBadLayerHandler
{
  public:
    virtual void handleBadLayers( const QList<QDomNode>& layers, const QDomDocument& projectDom ) override;

};


CORE_EXPORT QgsProjectVersion getVersion( QDomDocument const &doc );

#endif