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 <QIcon>
#include <QSet>
 
#include "qgis_sip.h"
#include "qgserror.h"
#include "qgsobjectcustomproperties.h"
#include "qgsrectangle.h"
#include "qgscoordinatereferencesystem.h"
#include "qgsmaplayerdependency.h"
#include "qgslayermetadata.h"
#include "qgsmaplayerserverproperties.h"
#include "qgsreadwritecontext.h"
#include "qgsdataprovider.h"
#include "qgis.h"
#include "qgslogger.h"
 
class QgsAbstract3DRenderer;
class QgsDataProvider;
class QgsMapLayerLegend;
class QgsMapLayerRenderer;
class QgsMapLayerStyleManager;
class QgsProject;
class QgsProviderMetadata;
class QgsStyleEntityVisitorInterface;
class QgsMapLayerTemporalProperties;
class QgsMapLayerElevationProperties;
class QgsMapLayerSelectionProperties;
class QgsSldExportContext;
 
class QDomDocument;
class QKeyEvent;
class QPainter;
class QgsRenderContext;
class QgsBox3D;
 
/*
 * 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 id READ id WRITE setId NOTIFY idChanged )
    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 )
    Q_PROPERTY( QgsCoordinateReferenceSystem crs READ crs WRITE setCrs NOTIFY crsChanged )
    Q_PROPERTY( QgsCoordinateReferenceSystem verticalCrs READ verticalCrs WRITE setVerticalCrs NOTIFY verticalCrsChanged )
    Q_PROPERTY( QgsCoordinateReferenceSystem crs3D READ crs3D NOTIFY crs3DChanged )
    Q_PROPERTY( Qgis::LayerType type READ type CONSTANT )
    Q_PROPERTY( bool isValid READ isValid NOTIFY isValidChanged )
    Q_PROPERTY( double opacity READ opacity WRITE setOpacity NOTIFY opacityChanged )
    Q_PROPERTY( QString mapTipTemplate READ mapTipTemplate WRITE setMapTipTemplate NOTIFY mapTipTemplateChanged )
    Q_PROPERTY( bool mapTipsEnabled READ mapTipsEnabled WRITE setMapTipsEnabled NOTIFY mapTipsEnabledChanged )
 
#ifdef SIP_RUN
    SIP_CONVERT_TO_SUBCLASS_CODE
    QgsMapLayer *layer = qobject_cast<QgsMapLayer *>( sipCpp );
 
    sipType = 0;
 
    if ( layer )
    {
      switch ( layer->type() )
      {
        case Qgis::LayerType::Vector:
          sipType = sipType_QgsVectorLayer;
          break;
        case Qgis::LayerType::Raster:
          sipType = sipType_QgsRasterLayer;
          break;
        case Qgis::LayerType::Plugin:
          sipType = sipType_QgsPluginLayer;
          break;
        case Qgis::LayerType::Mesh:
          sipType = sipType_QgsMeshLayer;
          break;
        case Qgis::LayerType::VectorTile:
          sipType = sipType_QgsVectorTileLayer;
          break;
        case Qgis::LayerType::Annotation:
          sipType = sipType_QgsAnnotationLayer;
          break;
        case Qgis::LayerType::PointCloud:
          sipType = sipType_QgsPointCloudLayer;
          break;
        case Qgis::LayerType::Group:
          sipType = sipType_QgsGroupLayer;
          break;
        case Qgis::LayerType::TiledScene:
          sipType = sipType_QgsTiledSceneLayer;
          break;
        default:
          sipType = nullptr;
          break;
      }
    }
    SIP_END
#endif
 
  public:
 
    enum PropertyType
    {
      Style = 0,
      Metadata,
    };
 
    enum LayerFlag SIP_ENUM_BASETYPE( IntFlag )
    {
      Identifiable = 1 << 0, 
      Removable = 1 << 1,    
      Searchable = 1 << 2,   
      Private = 1 << 3,       
    };
    Q_ENUM( LayerFlag )
    Q_DECLARE_FLAGS( LayerFlags, LayerFlag )
    Q_FLAG( LayerFlags )
 
    enum StyleCategory SIP_ENUM_BASETYPE( IntFlag )
    {
      LayerConfiguration = 1 << 0,  
      Symbology          = 1 << 1,  
      Symbology3D        = 1 << 2,  
      Labeling           = 1 << 3,  
      Fields             = 1 << 4,  
      Forms              = 1 << 5,  
      Actions            = 1 << 6,  
      MapTips            = 1 << 7,  
      Diagrams           = 1 << 8,  
      AttributeTable     = 1 << 9,  
      Rendering          = 1 << 10, 
      CustomProperties   = 1 << 11, 
      GeometryOptions    = 1 << 12, 
      Relations          = 1 << 13, 
      Temporal           = 1 << 14, 
      Legend             = 1 << 15, 
      Elevation          = 1 << 16, 
      Notes              = 1 << 17, 
      AllStyleCategories = LayerConfiguration | Symbology | Symbology3D | Labeling | Fields | Forms | Actions |
                           MapTips | Diagrams | AttributeTable | Rendering | CustomProperties | GeometryOptions | Relations | Temporal | Legend | Elevation | Notes,
    };
    Q_ENUM( StyleCategory )
    Q_DECLARE_FLAGS( StyleCategories, StyleCategory )
    Q_FLAG( StyleCategories )
 
    QgsMapLayer( Qgis::LayerType type = Qgis::LayerType::Vector, const QString &name = QString(), const QString &source = QString() );
 
    ~QgsMapLayer() override;
 
    QgsMapLayer( const QgsMapLayer & ) = delete;
    QgsMapLayer &operator=( const QgsMapLayer & ) = delete;
 
    virtual QgsMapLayer *clone() const = 0;
 
    Qgis::LayerType type() const;
 
    QgsMapLayer::LayerFlags flags() const;
 
    void setFlags( QgsMapLayer::LayerFlags flags );
 
    virtual Qgis::MapLayerProperties properties() const;
 
    static QString extensionPropertyType( PropertyType type );
 
    QString id() const;
 
    bool setId( const QString &id );
 
    void setName( const QString &name );
 
    QString name() const;
 
    Q_INVOKABLE virtual QgsDataProvider *dataProvider();
 
    virtual const QgsDataProvider *dataProvider() const SIP_SKIP;
 
    QgsProviderMetadata *providerMetadata() const;
 
    Q_DECL_DEPRECATED void setShortName( const QString &shortName ) SIP_DEPRECATED;
 
    Q_DECL_DEPRECATED QString shortName() const SIP_DEPRECATED;
 
    Q_DECL_DEPRECATED void setTitle( const QString &title ) SIP_DEPRECATED;
 
    Q_DECL_DEPRECATED QString title() const SIP_DEPRECATED;
 
    Q_DECL_DEPRECATED void setAbstract( const QString &abstract ) SIP_DEPRECATED;
 
    Q_DECL_DEPRECATED QString abstract() const SIP_DEPRECATED;
 
    Q_DECL_DEPRECATED void setKeywordList( const QString &keywords ) SIP_DEPRECATED;
 
    Q_DECL_DEPRECATED QString keywordList() const SIP_DEPRECATED;
 
    Q_DECL_DEPRECATED void setDataUrl( const QString &dataUrl ) SIP_DEPRECATED;
 
    Q_DECL_DEPRECATED QString dataUrl() const SIP_DEPRECATED;
 
    Q_DECL_DEPRECATED void setDataUrlFormat( const QString &dataUrlFormat ) SIP_DEPRECATED;
 
    Q_DECL_DEPRECATED QString dataUrlFormat() const SIP_DEPRECATED;
 
    Q_DECL_DEPRECATED void setAttribution( const QString &attrib ) SIP_DEPRECATED;
 
    Q_DECL_DEPRECATED QString attribution() const SIP_DEPRECATED;
 
    Q_DECL_DEPRECATED void setAttributionUrl( const QString &attribUrl ) SIP_DEPRECATED;
 
    Q_DECL_DEPRECATED QString attributionUrl() const SIP_DEPRECATED;
 
    /* Layer metadataUrl information */
 
    QgsMapLayerServerProperties *serverProperties() { return mServerProperties.get(); };
 
    const QgsMapLayerServerProperties *serverProperties() const { return mServerProperties.get(); } SIP_SKIP;
 
    Q_DECL_DEPRECATED void setMetadataUrl( const QString &metaUrl ) SIP_DEPRECATED;
 
    Q_DECL_DEPRECATED QString metadataUrl() const SIP_DEPRECATED;
 
    Q_DECL_DEPRECATED void setMetadataUrlType( const QString &metaUrlType ) SIP_DEPRECATED;
 
    Q_DECL_DEPRECATED QString metadataUrlType() const SIP_DEPRECATED;
 
    Q_DECL_DEPRECATED void setMetadataUrlFormat( const QString &metaUrlFormat ) SIP_DEPRECATED;
 
    Q_DECL_DEPRECATED QString metadataUrlFormat() const SIP_DEPRECATED;
 
    void setBlendMode( QPainter::CompositionMode blendMode );
 
    QPainter::CompositionMode blendMode() const;
 
    virtual void setOpacity( double opacity );
 
    virtual double opacity() const;
 
    bool readOnly() const { return isReadOnly(); }
 
    Q_INVOKABLE virtual void reload() {}
 
    virtual QgsMapLayerRenderer *createMapRenderer( QgsRenderContext &rendererContext ) = 0 SIP_FACTORY;
 
    virtual QgsRectangle extent() const;
 
    virtual QgsBox3D extent3D() const;
 
    QgsRectangle wgs84Extent( bool forceRecalculate = false ) const;
 
    bool isValid() const;
 
    QString publicSource( bool hidePassword = false ) const;
 
    QString source() const;
 
    virtual QStringList subLayers() const;
 
    virtual void setLayerOrder( const QStringList &layers );
 
    virtual void setSubLayerVisibility( const QString &name, bool visible );
 
    virtual bool supportsEditing() const;
 
    virtual bool isEditable() const;
 
    virtual bool isModified() const;
 
    virtual bool isSpatial() const;
 
    virtual bool isTemporary() const;
 
    enum ReadFlag SIP_ENUM_BASETYPE( IntFlag )
    {
      FlagDontResolveLayers = 1 << 0, 
      FlagTrustLayerMetadata = 1 << 1, 
      FlagReadExtentFromXml = 1 << 2, 
      FlagForceReadOnly = 1 << 3, 
    };
    Q_DECLARE_FLAGS( ReadFlags, ReadFlag )
 
    
    bool readLayerXml( const QDomElement &layerElement, QgsReadWriteContext &context,
                       QgsMapLayer::ReadFlags flags = QgsMapLayer::ReadFlags(), QgsDataProvider *preloadedProvider SIP_TRANSFER = nullptr );
 
    bool writeLayerXml( QDomElement &layerElement, QDomDocument &document, const QgsReadWriteContext &context ) const;
 
    virtual void resolveReferences( QgsProject *project );
 
    Q_INVOKABLE QStringList customPropertyKeys() const;
 
    Q_INVOKABLE void setCustomProperty( const QString &key, const QVariant &value );
 
    Q_INVOKABLE QVariant customProperty( const QString &value, const QVariant &defaultValue = QVariant() ) const;
 
    void setCustomProperties( const QgsObjectCustomProperties &properties );
 
    const QgsObjectCustomProperties &customProperties() const;
 
    virtual int listStylesInDatabase( QStringList &ids SIP_OUT, QStringList &names SIP_OUT,
                                      QStringList &descriptions SIP_OUT, QString &msgError SIP_OUT );
 
    virtual QString getStyleFromDatabase( const QString &styleId, QString &msgError SIP_OUT );
 
    virtual bool deleteStyleFromDatabase( const QString &styleId, QString &msgError SIP_OUT );
 
    virtual void saveStyleToDatabase( const QString &name, const QString &description,
                                      bool useAsDefault, const QString &uiFileContent,
                                      QString &msgError SIP_OUT,
                                      QgsMapLayer::StyleCategories categories = QgsMapLayer::AllStyleCategories );
 
 
    // TODO QGIS 4.0 -- fix this. We incorrectly have a single boolean flag which in which false is used inconsistently for "a style WAS found but an error occurred loading it" vs "no style was found".
    // The first (style found, error occurred loading it) should trigger a user-facing warning, whereas the second (no style found) isn't reflective of an error at all.
 
    virtual QString loadNamedStyle( const QString &theURI, bool &resultFlag SIP_OUT, bool loadFromLocalDb,
                                    QgsMapLayer::StyleCategories categories = QgsMapLayer::AllStyleCategories,
                                    Qgis::LoadStyleFlags flags = Qgis::LoadStyleFlags() );
 
#ifndef SIP_RUN
 
    template <class T>
    T customEnumProperty( const QString &key, const T &defaultValue )
    {
      const QMetaEnum metaEnum = QMetaEnum::fromType<T>();
      Q_ASSERT( metaEnum.isValid() );
      if ( !metaEnum.isValid() )
      {
        QgsDebugError( QStringLiteral( "Invalid metaenum. Enum probably misses Q_ENUM or Q_FLAG declaration." ) );
      }
 
      T v;
      bool ok = false;
 
      if ( metaEnum.isValid() )
      {
        // read as string
        QByteArray ba = customProperty( key, metaEnum.valueToKey( static_cast<int>( defaultValue ) ) ).toString().toUtf8();
        const char *vs = ba.data();
        v = static_cast<T>( metaEnum.keyToValue( vs, &ok ) );
        if ( ok )
          return v;
      }
 
      // if failed, try to read as int (old behavior)
      // this code shall be removed later
      // then the method could be marked as const
      v = static_cast<T>( customProperty( key, static_cast<int>( defaultValue ) ).toInt( &ok ) );
      if ( metaEnum.isValid() )
      {
        if ( !ok || !metaEnum.valueToKey( static_cast<int>( v ) ) )
        {
          v = defaultValue;
        }
        else
        {
          // found property as an integer
          // convert the property to the new form (string)
          setCustomEnumProperty( key, v );
        }
      }
 
      return v;
    }
 
    template <class T>
    void setCustomEnumProperty( const QString &key, const T &value )
    {
      const QMetaEnum metaEnum = QMetaEnum::fromType<T>();
      Q_ASSERT( metaEnum.isValid() );
      if ( metaEnum.isValid() )
      {
        setCustomProperty( key, metaEnum.valueToKey( static_cast<int>( value ) ) );
      }
      else
      {
        QgsDebugError( QStringLiteral( "Invalid metaenum. Enum probably misses Q_ENUM or Q_FLAG declaration." ) );
      }
    }
 
    template <class T>
    T customFlagProperty( const QString &key, const T &defaultValue )
    {
      const QMetaEnum metaEnum = QMetaEnum::fromType<T>();
      Q_ASSERT( metaEnum.isValid() );
      if ( !metaEnum.isValid() )
      {
        QgsDebugError( QStringLiteral( "Invalid metaenum. Enum probably misses Q_ENUM or Q_FLAG declaration." ) );
      }
 
      T v = defaultValue;
      bool ok = false;
 
      if ( metaEnum.isValid() )
      {
        // read as string
        QByteArray ba = customProperty( key, metaEnum.valueToKeys( defaultValue ) ).toString().toUtf8();
        const char *vs = ba.data();
        v = static_cast<T>( metaEnum.keysToValue( vs, &ok ) );
      }
      if ( !ok )
      {
        // if failed, try to read as int
        const int intValue = customProperty( key, static_cast<int>( defaultValue ) ).toInt( &ok );
        if ( metaEnum.isValid() )
        {
          if ( ok )
          {
            // check that the int value does correspond to a flag
            // see https://stackoverflow.com/a/68495949/1548052
            const QByteArray keys = metaEnum.valueToKeys( intValue );
            const int intValueCheck = metaEnum.keysToValue( keys );
            if ( intValue != intValueCheck )
            {
              v = defaultValue;
            }
            else
            {
              // found property as an integer
              v = T( intValue );
              // convert the property to the new form (string)
              // this code could be removed
              // then the method could be marked as const
              setCustomFlagProperty( key, v );
            }
          }
          else
          {
            v = defaultValue;
          }
        }
      }
 
      return v;
    }
 
    template <class T>
    void setCustomFlagProperty( const QString &key, const T &value )
    {
      const QMetaEnum metaEnum = QMetaEnum::fromType<T>();
      Q_ASSERT( metaEnum.isValid() );
      if ( metaEnum.isValid() )
      {
        setCustomProperty( key, metaEnum.valueToKeys( value ) );
      }
      else
      {
        QgsDebugError( QStringLiteral( "Invalid metaenum. Enum probably misses Q_ENUM or Q_FLAG declaration." ) );
      }
    }
#endif
 
 
    void removeCustomProperty( const QString &key );
 
    virtual QgsError error() const;
 
    QgsCoordinateReferenceSystem crs() const;
 
    QgsCoordinateReferenceSystem verticalCrs() const;
 
    QgsCoordinateReferenceSystem crs3D() const;
 
    void setCrs( const QgsCoordinateReferenceSystem &srs, bool emitSignal = true );
 
    bool setVerticalCrs( const QgsCoordinateReferenceSystem &crs, QString *errorMessage SIP_OUT = nullptr );
 
    QgsCoordinateTransformContext transformContext( ) const;
 
 
    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 );
 
    // TODO QGIS 4.0 -- fix this. We incorrectly have a single boolean flag which in which false is used inconsistently for "metadata WAS found but an error occurred loading it" vs "no metadata was found".
    // The first (metadata found, error occurred loading it) should trigger a user-facing warning, whereas the second (no metadata found) isn't reflective of an error at all.
 
    virtual QString loadNamedMetadata( const QString &uri, bool &resultFlag SIP_OUT );
 
    // TODO QGIS 4.0 -- fix this. We incorrectly have a single boolean flag which in which false is used inconsistently for "metadata WAS found but an error occurred loading it" vs "no metadata was found".
    // The first (metadata found, error occurred loading it) should trigger a user-facing warning, whereas the second (no metadata found) isn't reflective of an error at all.
 
    virtual QString loadDefaultMetadata( bool &resultFlag );
 
    bool loadNamedMetadataFromDatabase( const QString &db, const QString &uri, QString &qmd );
 
    bool importNamedMetadata( QDomDocument &document, QString &errorMessage );
 
    virtual QString styleURI() const;
 
    // TODO QGIS 4.0 -- fix this. We incorrectly have a single boolean flag which in which false is used inconsistently for "a style WAS found but an error occurred loading it" vs "no style was found".
    // The first (style found, error occurred loading it) should trigger a user-facing warning, whereas the second (no style found) isn't reflective of an error at all.
 
    virtual QString loadDefaultStyle( bool &resultFlag SIP_OUT );
 
    // TODO QGIS 4.0 -- fix this. We incorrectly have a single boolean flag which in which false is used inconsistently for "a style WAS found but an error occurred loading it" vs "no style was found".
    // The first (style found, error occurred loading it) should trigger a user-facing warning, whereas the second (no style found) isn't reflective of an error at all.
 
    virtual QString loadNamedStyle( const QString &uri, bool &resultFlag SIP_OUT, QgsMapLayer::StyleCategories categories = QgsMapLayer::AllStyleCategories, Qgis::LoadStyleFlags flags = Qgis::LoadStyleFlags() );
 
    virtual bool loadNamedStyleFromDatabase( const QString &db, const QString &uri, QString &qml SIP_OUT );
 
    virtual bool importNamedStyle( QDomDocument &doc, QString &errorMsg SIP_OUT,
                                   QgsMapLayer::StyleCategories categories = QgsMapLayer::AllStyleCategories );
 
    virtual void exportNamedStyle( QDomDocument &doc, QString &errorMsg SIP_OUT, const QgsReadWriteContext &context = QgsReadWriteContext(),
                                   QgsMapLayer::StyleCategories categories = QgsMapLayer::AllStyleCategories ) const;
 
 
    virtual void exportSldStyle( QDomDocument &doc, QString &errorMsg ) const;
 
    virtual void exportSldStyleV2( QDomDocument &doc, QString &errorMsg, const QgsSldExportContext &exportContext ) const;
 
    virtual QString saveDefaultStyle( bool &resultFlag SIP_OUT, StyleCategories categories );
 
    Q_DECL_DEPRECATED virtual QString saveDefaultStyle( bool &resultFlag SIP_OUT ) SIP_DEPRECATED;
 
    virtual QString saveNamedStyle( const QString &uri, bool &resultFlag SIP_OUT, StyleCategories categories = AllStyleCategories );
 
    virtual QString saveSldStyle( const QString &uri, bool &resultFlag ) const;
 
    virtual QString saveSldStyleV2( bool &resultFlag SIP_OUT, const QgsSldExportContext &exportContext ) 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( static_cast<int>( type() ) ); return false; }
 
 
 
    virtual bool readSymbology( const QDomNode &node, QString &errorMessage,
                                QgsReadWriteContext &context, StyleCategories categories = AllStyleCategories ) = 0;
 
    virtual bool readStyle( const QDomNode &node, QString &errorMessage,
                            QgsReadWriteContext &context, StyleCategories categories = AllStyleCategories );
 
    virtual bool writeSymbology( QDomNode &node, QDomDocument &doc, QString &errorMessage, const QgsReadWriteContext &context,
                                 StyleCategories categories = AllStyleCategories ) const = 0;
 
    virtual bool writeStyle( QDomNode &node, QDomDocument &doc, QString &errorMessage, const QgsReadWriteContext &context,
                             StyleCategories categories = AllStyleCategories ) const;
 
 
    void setDataSource( const QString &dataSource, const QString &baseName = QString(), const QString &provider = QString(), bool loadDefaultStyleFlag = false );
 
    void setDataSource( const QString &dataSource, const QString &baseName, const QString &provider, const QgsDataProvider::ProviderOptions &options, bool loadDefaultStyleFlag = false );
 
    void setDataSource( const QString &dataSource, const QString &baseName, const QString &provider, const QgsDataProvider::ProviderOptions &options, Qgis::DataProviderReadFlags flags );
 
    QString providerType() 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;
 
    Q_DECL_DEPRECATED bool hasAutoRefreshEnabled() const SIP_DEPRECATED;
 
    Qgis::AutoRefreshMode autoRefreshMode() const;
 
    int autoRefreshInterval() const;
 
    void setAutoRefreshInterval( int interval );
 
    Q_DECL_DEPRECATED void setAutoRefreshEnabled( bool enabled ) SIP_DEPRECATED;
 
    void setAutoRefreshMode( Qgis::AutoRefreshMode mode );
 
    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; }
 
    QString originalXmlProperties() const;
 
    void setOriginalXmlProperties( const QString &originalXmlProperties );
 
    static QString generateId( const QString &layerName );
 
    virtual bool accept( QgsStyleEntityVisitorInterface *visitor ) const;
 
    virtual QgsMapLayerSelectionProperties *selectionProperties() { return nullptr; }
 
    virtual QgsMapLayerTemporalProperties *temporalProperties() { return nullptr; }
 
    virtual QgsMapLayerElevationProperties *elevationProperties() { return nullptr; }
 
    QString legendPlaceholderImage() const { return mLegendPlaceholderImage;}
 
    void setLegendPlaceholderImage( const QString &imgPath ) { mLegendPlaceholderImage = imgPath; }
 
    virtual bool hasMapTips() const;
 
    QString mapTipTemplate() const;
 
    void setMapTipTemplate( const QString &mapTipTemplate );
 
    void setMapTipsEnabled( bool enabled );
 
    bool mapTipsEnabled() const;
 
    static Qgis::DataProviderReadFlags providerReadFlags( const QDomNode &layerNode, QgsMapLayer::ReadFlags layerReadFlags );
 
  public slots:
 
    void setMinimumScale( double scale );
 
    void setMaximumScale( double scale );
 
    void setScaleBasedVisibility( bool enabled );
 
    void triggerRepaint( bool deferredUpdate = false );
 
    void trigger3DUpdate();
 
    void emitStyleChanged();
 
    virtual bool setDependencies( const QSet<QgsMapLayerDependency> &layers );
 
    void setRefreshOnNotifyEnabled( bool enabled );
 
    void setRefreshOnNofifyMessage( const QString &message ) { mRefreshOnNofifyMessage = message; }
 
    virtual void setTransformContext( const QgsCoordinateTransformContext &transformContext ) = 0;
 
#ifdef SIP_RUN
    SIP_PYOBJECT __repr__();
    % MethodCode
    QString str = QStringLiteral( "<QgsMapLayer: '%1' (%2)>" ).arg( sipCpp->name(), sipCpp->dataProvider() ? sipCpp->dataProvider()->name() : QStringLiteral( "Invalid" ) );
    sipRes = PyUnicode_FromString( str.toUtf8().constData() );
    % End
#endif
 
    QgsProject *project() const;
 
  signals:
 
    void beforeResolveReferences( QgsProject *project );
 
    void statusChanged( const QString &status );
 
    void idChanged( const QString &id );
 
    void nameChanged();
 
    void crsChanged();
 
    void crs3DChanged();
 
    void verticalCrsChanged();
 
    void repaintRequested( bool deferredUpdate = false );
 
    void recalculateExtents() const;
 
    void dataChanged();
 
    void blendModeChanged( QPainter::CompositionMode blendMode );
 
    void opacityChanged( double opacity );
 
    void rendererChanged();
 
    void styleChanged();
 
    void legendChanged();
 
    void renderer3DChanged();
 
    void request3DUpdate();
 
    void configChanged();
 
    void dependenciesChanged();
 
    void willBeDeleted();
 
    void autoRefreshIntervalChanged( int interval );
 
    void metadataChanged();
 
    void flagsChanged();
 
    void dataSourceChanged();
 
    void styleLoaded( QgsMapLayer::StyleCategories categories );
 
    void isValidChanged();
 
    void customPropertyChanged( const QString &key );
 
    void editingStarted();
 
    void editingStopped();
 
    void layerModified();
 
    void mapTipTemplateChanged();
 
    void mapTipsEnabledChanged();
 
  private slots:
 
    void onNotified( const QString &message );
 
    virtual void setDataSourcePrivate( const QString &dataSource, const QString &baseName, const QString &provider, const QgsDataProvider::ProviderOptions &options, Qgis::DataProviderReadFlags flags );
 
  protected:
 
    void clone( QgsMapLayer *layer ) const;
 
    virtual void setExtent( const QgsRectangle &rect );
 
    virtual void setExtent3D( const QgsBox3D &box );
 
    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,
                           StyleCategories categories = AllStyleCategories ) const;
 
    void readCommonStyle( const QDomElement &layerElement, const QgsReadWriteContext &context,
                          StyleCategories categories = AllStyleCategories );
 
    void setProviderType( const QString &providerType );
 
#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;}
 
    void invalidateWgs84Extent();
 
    bool mValid = false;
 
    QString mDataSource;
 
    QString mLayerName;
 
    QString mLegendUrl;
    QString mLegendUrlFormat;
 
    QgsError mError;
 
    QSet<QgsMapLayerDependency> mDependencies;
 
    Q_DECL_DEPRECATED bool hasDependencyCycle( const QSet<QgsMapLayerDependency> & ) const {return false;}
 
    bool mIsRefreshOnNofifyEnabled = false;
    QString mRefreshOnNofifyMessage;
 
    QString mProviderKey;
 
    //TODO QGIS 4 - move to readXml as a new argument (breaks API)
 
    QgsMapLayer::ReadFlags mReadFlags = QgsMapLayer::ReadFlags();
 
    bool mShouldValidateCrs = true;
 
    double mLayerOpacity = 1.0;
 
    int mBlockStyleChangedSignal = 0;
 
#ifndef SIP_RUN
 
    QString crsHtmlMetadata() const;
#endif
 
#ifndef SIP_RUN
 
    QString generalHtmlMetadata() const;
 
    QString customPropertyHtmlMetadata() const;
#endif
 
#ifndef SIP_RUN
 
    std::unique_ptr<QgsDataProvider> mPreloadedProvider;
#endif
 
  private:
 
    virtual QString baseURI( PropertyType type ) const;
    QString saveNamedProperty( const QString &uri, QgsMapLayer::PropertyType type,
                               bool &resultFlag, StyleCategories categories = AllStyleCategories );
    QString loadNamedProperty( const QString &uri, QgsMapLayer::PropertyType type,
                               bool &namedPropertyExists, bool &propertySuccessfullyLoaded, StyleCategories categories = AllStyleCategories, Qgis::LoadStyleFlags flags = Qgis::LoadStyleFlags() );
    bool loadNamedPropertyFromDatabase( const QString &db, const QString &uri, QString &xml, QgsMapLayer::PropertyType type );
 
    // const method because extents are mutable
    void updateExtent( const QgsRectangle &extent ) const;
    void updateExtent( const QgsBox3D &extent ) const;
 
    bool rebuildCrs3D( QString *error = nullptr );
 
    virtual bool isReadOnly() const;
 
    QgsCoordinateReferenceSystem mCRS;
    QgsCoordinateReferenceSystem mVerticalCrs;
    QgsCoordinateReferenceSystem mCrs3D;
 
    QString mID;
 
    Qgis::LayerType mLayerType;
 
    LayerFlags mFlags = LayerFlags( Identifiable | Removable | Searchable );
 
    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;
 
    std::unique_ptr< QgsMapLayerServerProperties > mServerProperties;
 
    QUndoStack *mUndoStack = nullptr;
 
    QUndoStack *mUndoStackStyles = nullptr;
 
    QgsObjectCustomProperties mCustomProperties;
 
    QgsMapLayerLegend *mLegend = nullptr;
 
    QgsMapLayerStyleManager *mStyleManager = nullptr;
 
    Qgis::AutoRefreshMode mAutoRefreshMode = Qgis::AutoRefreshMode::Disabled;
 
    QTimer *mRefreshTimer = nullptr;
 
    QgsLayerMetadata mMetadata;
 
    QgsAbstract3DRenderer *m3DRenderer = nullptr;
 
    mutable QgsBox3D mExtent3D;
 
    mutable QgsRectangle mExtent2D;
 
    mutable QgsRectangle mWgs84Extent;
 
    QString mOriginalXmlProperties;
 
    bool mRepaintRequestedFired = false;
 
    QString mLegendPlaceholderImage;
 
    QString mMapTipTemplate;
 
    bool mMapTipsEnabled = true;
 
    friend class QgsVectorLayer;
    friend class TestQgsProject;
    friend class TestQgsMapLayer;
};
 
Q_DECLARE_METATYPE( QgsMapLayer * )
Q_DECLARE_OPERATORS_FOR_FLAGS( QgsMapLayer::LayerFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( QgsMapLayer::StyleCategories )
Q_DECLARE_OPERATORS_FOR_FLAGS( QgsMapLayer::ReadFlags )
 
 
#ifndef SIP_RUN
 
typedef QPointer< QgsMapLayer > QgsWeakMapLayerPointer;
 
typedef QList< QgsWeakMapLayerPointer > QgsWeakMapLayerPointerList;
#endif
 
#endif