qgsmaplayer.h

Go to the documentation of this file.

/***************************************************************************
                          qgsmaplayer.h  -  description
                             -------------------
    begin                : Fri Jun 28 2002
    copyright            : (C) 2002 by Gary E.Sherman
    email                : sherman at mrcc.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 QGSMAPLAYER_H
#define QGSMAPLAYER_H

#include "qgis_core.h"
#include <QDateTime>
#include <QDomNode>
#include <QImage>
#include <QObject>
#include <QPainter>
#include <QUndoStack>
#include <QVariant>

#include "qgis.h"
#include "qgserror.h"
#include "qgsobjectcustomproperties.h"
#include "qgsrectangle.h"
#include "qgscoordinatereferencesystem.h"
#include "qgsrendercontext.h"
#include "qgsmaplayerdependency.h"
#include "qgslayermetadata.h"

class QgsAbstract3DRenderer;
class QgsDataProvider;
class QgsMapLayerLegend;
class QgsMapLayerRenderer;
class QgsMapLayerStyleManager;
class QgsReadWriteContext;
class QgsProject;

class QDomDocument;
class QKeyEvent;
class QPainter;

/*
 * Constants used to describe copy-paste MIME types
 */
#define QGSCLIPBOARD_MAPLAYER_MIME "application/qgis.maplayer"

class CORE_EXPORT QgsMapLayer : public QObject
{
    Q_OBJECT

    Q_PROPERTY( QString name READ name WRITE setName NOTIFY nameChanged )
    Q_PROPERTY( int autoRefreshInterval READ autoRefreshInterval WRITE setAutoRefreshInterval NOTIFY autoRefreshIntervalChanged )
    Q_PROPERTY( QgsLayerMetadata metadata READ metadata WRITE setMetadata NOTIFY metadataChanged )

#ifdef SIP_RUN
    SIP_CONVERT_TO_SUBCLASS_CODE
    QgsMapLayer *layer = qobject_cast<QgsMapLayer *>( sipCpp );

    sipType = 0;

    if ( layer )
    {
      switch ( layer->type() )
      {
        case QgsMapLayer::VectorLayer:
          sipType = sipType_QgsVectorLayer;
          break;
        case QgsMapLayer::RasterLayer:
          sipType = sipType_QgsRasterLayer;
          break;
        case QgsMapLayer::PluginLayer:
          sipType = sipType_QgsPluginLayer;
          break;
        case QgsMapLayer::MeshLayer:
          sipType = sipType_QgsMeshLayer;
          break;
        default:
          sipType = nullptr;
          break;
      }
    }
    SIP_END
#endif

  public:

    enum LayerType
    {
      VectorLayer,
      RasterLayer,
      PluginLayer,
      MeshLayer      
    };

    enum PropertyType
    {
      Style = 0,
      Metadata,
    };

    QgsMapLayer( QgsMapLayer::LayerType type = VectorLayer, const QString &name = QString(), const QString &source = QString() );

    ~QgsMapLayer() override;

    QgsMapLayer( QgsMapLayer const & ) = delete;
    QgsMapLayer &operator=( QgsMapLayer const & ) = delete;

    virtual QgsMapLayer *clone() const = 0;

    QgsMapLayer::LayerType type() const;

    static QString extensionPropertyType( PropertyType type );

    QString id() const;

    void setName( const QString &name );

    QString name() const;

    virtual QgsDataProvider *dataProvider();

    virtual const QgsDataProvider *dataProvider() const SIP_SKIP;

    void setShortName( const QString &shortName ) { mShortName = shortName; }

    QString shortName() const { return mShortName; }

    void setTitle( const QString &title ) { mTitle = title; }

    QString title() const { return mTitle; }

    void setAbstract( const QString &abstract ) { mAbstract = abstract; }

    QString abstract() const { return mAbstract; }

    void setKeywordList( const QString &keywords ) { mKeywordList = keywords; }

    QString keywordList() const { return mKeywordList; }

    /* Layer dataUrl information */

    void setDataUrl( const QString &dataUrl ) { mDataUrl = dataUrl; }

    QString dataUrl() const { return mDataUrl; }

    void setDataUrlFormat( const QString &dataUrlFormat ) { mDataUrlFormat = dataUrlFormat; }

    QString dataUrlFormat() const { return mDataUrlFormat; }

    /* Layer attribution information */

    void setAttribution( const QString &attrib ) { mAttribution = attrib; }

    QString attribution() const { return mAttribution; }

    void setAttributionUrl( const QString &attribUrl ) { mAttributionUrl = attribUrl; }

    QString attributionUrl() const { return mAttributionUrl; }

    /* Layer metadataUrl information */

    void setMetadataUrl( const QString &metaUrl ) { mMetadataUrl = metaUrl; }

    QString metadataUrl() const { return mMetadataUrl; }

    void setMetadataUrlType( const QString &metaUrlType ) { mMetadataUrlType = metaUrlType; }

    QString metadataUrlType() const { return mMetadataUrlType; }

    void setMetadataUrlFormat( const QString &metaUrlFormat ) { mMetadataUrlFormat = metaUrlFormat; }

    QString metadataUrlFormat() const { return mMetadataUrlFormat; }

    void setBlendMode( QPainter::CompositionMode blendMode );

    QPainter::CompositionMode blendMode() const;

    bool readOnly() const { return isReadOnly(); }

    virtual void reload() {}

    virtual QgsMapLayerRenderer *createMapRenderer( QgsRenderContext &rendererContext ) = 0 SIP_FACTORY;

    virtual QgsRectangle extent() const;

    bool isValid() const;

    QString publicSource() const;

    QString source() const;

    virtual QStringList subLayers() const;

    virtual void setLayerOrder( const QStringList &layers );

    virtual void setSubLayerVisibility( const QString &name, bool visible );

    virtual bool isEditable() const;

    virtual bool isSpatial() const;

    bool readLayerXml( const QDomElement &layerElement, QgsReadWriteContext &context );

    bool writeLayerXml( QDomElement &layerElement, QDomDocument &document, const QgsReadWriteContext &context ) const;

    virtual void resolveReferences( QgsProject *project );

    QStringList customPropertyKeys() const;

    void setCustomProperty( const QString &key, const QVariant &value );

    QVariant customProperty( const QString &value, const QVariant &defaultValue = QVariant() ) const;

    void setCustomProperties( const QgsObjectCustomProperties &properties );

    void removeCustomProperty( const QString &key );

    virtual QgsError error() const;

    QgsCoordinateReferenceSystem crs() const;

    void setCrs( const QgsCoordinateReferenceSystem &srs, bool emitSignal = true );

    static QString formatLayerName( const QString &name );

    virtual QString metadataUri() const;

    void exportNamedMetadata( QDomDocument &doc, QString &errorMsg ) const;

    virtual QString saveDefaultMetadata( bool &resultFlag SIP_OUT );

    QString saveNamedMetadata( const QString &uri, bool &resultFlag );

    virtual QString loadNamedMetadata( const QString &uri, bool &resultFlag SIP_OUT );

    QString loadDefaultMetadata( bool &resultFlag );

    bool loadNamedMetadataFromDatabase( const QString &db, const QString &uri, QString &qmd );

    bool importNamedMetadata( QDomDocument &document, QString &errorMessage );

    virtual QString styleURI() const;

    virtual QString loadDefaultStyle( bool &resultFlag SIP_OUT );

    virtual QString loadNamedStyle( const QString &uri, bool &resultFlag SIP_OUT );

    virtual bool loadNamedStyleFromDatabase( const QString &db, const QString &uri, QString &qml SIP_OUT );

    virtual bool importNamedStyle( QDomDocument &doc, QString &errorMsg SIP_OUT );

    virtual void exportNamedStyle( QDomDocument &doc, QString &errorMsg ) const;


    virtual void exportSldStyle( QDomDocument &doc, QString &errorMsg ) const;

    virtual QString saveDefaultStyle( bool &resultFlag SIP_OUT );

    virtual QString saveNamedStyle( const QString &uri, bool &resultFlag SIP_OUT );

    virtual QString saveSldStyle( const QString &uri, bool &resultFlag ) const;

    virtual QString loadSldStyle( const QString &uri, bool &resultFlag );

    virtual bool readSld( const QDomNode &node, QString &errorMessage )
    { Q_UNUSED( node ); errorMessage = QStringLiteral( "Layer type %1 not supported" ).arg( type() ); return false; }



    virtual bool readSymbology( const QDomNode &node, QString &errorMessage, QgsReadWriteContext &context ) = 0;

    virtual bool readStyle( const QDomNode &node, QString &errorMessage, QgsReadWriteContext &context );

    virtual bool writeSymbology( QDomNode &node, QDomDocument &doc, QString &errorMessage, const QgsReadWriteContext &context ) const = 0;

    virtual bool writeStyle( QDomNode &node, QDomDocument &doc, QString &errorMessage, const QgsReadWriteContext &context ) const;

    QUndoStack *undoStack();

    QUndoStack *undoStackStyles();

    void setLegendUrl( const QString &legendUrl ) { mLegendUrl = legendUrl; }

    QString legendUrl() const { return mLegendUrl; }

    void setLegendUrlFormat( const QString &legendUrlFormat ) { mLegendUrlFormat = legendUrlFormat; }

    QString legendUrlFormat() const { return mLegendUrlFormat; }

    void setLegend( QgsMapLayerLegend *legend SIP_TRANSFER );

    QgsMapLayerLegend *legend() const;

    QgsMapLayerStyleManager *styleManager() const;

    void setRenderer3D( QgsAbstract3DRenderer *renderer SIP_TRANSFER );

    QgsAbstract3DRenderer *renderer3D() const;

    bool isInScaleRange( double scale ) const;

    double minimumScale() const;

    double maximumScale() const;

    bool hasScaleBasedVisibility() const;

    bool hasAutoRefreshEnabled() const;

    int autoRefreshInterval() const;

    void setAutoRefreshInterval( int interval );

    void setAutoRefreshEnabled( bool enabled );

    virtual const QgsLayerMetadata &metadata() const;

    virtual void setMetadata( const QgsLayerMetadata &metadata );

    virtual QString htmlMetadata() const;

    virtual QDateTime timestamp() const;

    virtual QSet<QgsMapLayerDependency> dependencies() const;

    QString refreshOnNotifyMessage() const { return mRefreshOnNofifyMessage; }

    bool isRefreshOnNotifyEnabled() const { return mIsRefreshOnNofifyEnabled; }

  public slots:

    void setMinimumScale( double scale );

    void setMaximumScale( double scale );

    void setScaleBasedVisibility( bool enabled );

    void triggerRepaint( bool deferredUpdate = false );

    void emitStyleChanged();

    virtual bool setDependencies( const QSet<QgsMapLayerDependency> &layers );

    void setRefreshOnNotifyEnabled( bool enabled );

    void setRefreshOnNofifyMessage( const QString &message ) { mRefreshOnNofifyMessage = message; }

  signals:

    void statusChanged( const QString &status );

    void nameChanged();

    void crsChanged();

    void repaintRequested( bool deferredUpdate = false );

    void recalculateExtents() const;

    void dataChanged();

    void blendModeChanged( QPainter::CompositionMode blendMode );

    void rendererChanged();

    void styleChanged();

    void legendChanged();

    void renderer3DChanged();

    void configChanged();

    void dependenciesChanged();

    void willBeDeleted();

    void autoRefreshIntervalChanged( int interval );

    void metadataChanged();

  private slots:

    void onNotifiedTriggerRepaint( const QString &message );

  protected:

    void clone( QgsMapLayer *layer ) const;

    virtual void setExtent( const QgsRectangle &rect );

    void setValid( bool valid );

    virtual bool readXml( const QDomNode &layer_node, QgsReadWriteContext &context );

    virtual bool writeXml( QDomNode &layer_node, QDomDocument &document, const QgsReadWriteContext &context ) const;

    virtual QString encodedSource( const QString &source, const QgsReadWriteContext &context ) const;

    virtual QString decodedSource( const QString &source, const QString &dataProvider, const QgsReadWriteContext &context ) const;

    void readCustomProperties( const QDomNode &layerNode, const QString &keyStartsWith = QString() );

    void writeCustomProperties( QDomNode &layerNode, QDomDocument &doc ) const;

    void readStyleManager( const QDomNode &layerNode );
    void writeStyleManager( QDomNode &layerNode, QDomDocument &doc ) const;

    void writeCommonStyle( QDomElement &layerElement, QDomDocument &document, const QgsReadWriteContext &context ) const;

    void readCommonStyle( const QDomElement &layerElement, const QgsReadWriteContext &context );

#ifndef SIP_RUN
#if 0
    void connectNotify( const char *signal ) override;
#endif
#endif

    void appendError( const QgsErrorMessage &error ) { mError.append( error );}
    void setError( const QgsError &error ) { mError = error;}

    mutable QgsRectangle mExtent;

    bool mValid = false;

    QString mDataSource;

    QString mLayerName;

    QString mShortName;
    QString mTitle;

    QString mAbstract;
    QString mKeywordList;

    QString mDataUrl;
    QString mDataUrlFormat;

    QString mAttribution;
    QString mAttributionUrl;

    QString mMetadataUrl;
    QString mMetadataUrlType;
    QString mMetadataUrlFormat;

    QString mLegendUrl;
    QString mLegendUrlFormat;

    QgsError mError;

    QSet<QgsMapLayerDependency> mDependencies;

    bool hasDependencyCycle( const QSet<QgsMapLayerDependency> &layers ) const;

    bool mIsRefreshOnNofifyEnabled = false;
    QString mRefreshOnNofifyMessage;

  private:

    virtual QString baseURI( PropertyType type ) const;
    QString saveNamedProperty( const QString &uri, QgsMapLayer::PropertyType type, bool &resultFlag );
    QString loadNamedProperty( const QString &uri, QgsMapLayer::PropertyType type, bool &resultFlag );
    bool loadNamedPropertyFromDatabase( const QString &db, const QString &uri, QString &xml, QgsMapLayer::PropertyType type );

    virtual bool isReadOnly() const;

    QgsCoordinateReferenceSystem mCRS;

    QString mID;

    QgsMapLayer::LayerType mLayerType;

    QPainter::CompositionMode mBlendMode = QPainter::CompositionMode_SourceOver;

    QString mTag;

    //set some generous  defaults for scale based visibility

    double mMinScale = 0;
    double mMaxScale = 100000000;
    bool mScaleBasedVisibility = false;

    QUndoStack *mUndoStack = nullptr;

    QUndoStack *mUndoStackStyles = nullptr;

    QgsObjectCustomProperties mCustomProperties;

    QgsMapLayerLegend *mLegend = nullptr;

    QgsMapLayerStyleManager *mStyleManager = nullptr;

    QTimer *mRefreshTimer = nullptr;

    QgsLayerMetadata mMetadata;

    QgsAbstract3DRenderer *m3DRenderer = nullptr;

};

Q_DECLARE_METATYPE( QgsMapLayer * )

#ifndef SIP_RUN

typedef QPointer< QgsMapLayer > QgsWeakMapLayerPointer;

typedef QList< QgsWeakMapLayerPointer > QgsWeakMapLayerPointerList;
#endif

#endif