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 <QDateTime>
#include <QDomNode>
#include <QImage>
#include <QObject>
#include <QPainter>
#include <QUndoStack>
#include <QVariant>

#include "qgis.h"
#include "qgserror.h"
#include "qgsmaprenderer.h"
#include "qgsobjectcustomproperties.h"
#include "qgsrectangle.h"

class QgsRenderContext;
class QgsCoordinateReferenceSystem;
class QgsMapLayerLegend;
class QgsMapLayerRenderer;
class QgsMapLayerStyleManager;

class QDomDocument;
class QKeyEvent;
class QPainter;

class CORE_EXPORT QgsMapLayer : public QObject
{
    Q_OBJECT

    Q_PROPERTY( QString name READ name WRITE setName NOTIFY nameChanged )

  public:
    enum LayerType
    {
      VectorLayer,
      RasterLayer,
      PluginLayer
    };

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

    virtual ~QgsMapLayer();

    QgsMapLayer::LayerType type() const;

    QString id() const;

    Q_DECL_DEPRECATED void setLayerName( const QString & name );

    void setName( const QString& name );

    QString name() const;

    QString originalName() const { return mLayerOrigName; }

    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 ) { Q_UNUSED( rendererContext ); return nullptr; }

    virtual bool draw( QgsRenderContext& rendererContext );

    virtual void drawLabels( QgsRenderContext& rendererContext );

    virtual QgsRectangle extent();

    bool isValid();

    QString publicSource() const;

    QString source() const;

    virtual QStringList subLayers() const;

    virtual void setLayerOrder( const QStringList &layers );

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

    virtual bool isEditable() const;

    virtual bool isSpatial() const { return true; }

    bool readLayerXML( const QDomElement& layerElement, const QString& relativeBasePath = QString() );


    bool writeLayerXML( QDomElement& layerElement, QDomDocument& document, const QString& relativeBasePath = QString() );

    static QDomDocument asLayerDefinition( const QList<QgsMapLayer*>& layers, const QString& relativeBasePath = QString() );

    static QList<QgsMapLayer*> fromLayerDefinition( QDomDocument& document, bool addToRegistry = false, bool addToLegend = false, const QString& relativeBasePath = QString() );
    static QList<QgsMapLayer*> fromLayerDefinitionFile( const QString &qlrfile );

    void setCustomProperty( const QString& key, const QVariant& value );
    QVariant customProperty( const QString& value, const QVariant& defaultValue = QVariant() ) const;
    void removeCustomProperty( const QString& key );


    Q_DECL_DEPRECATED virtual QString lastErrorTitle();

    Q_DECL_DEPRECATED virtual QString lastError();

    virtual QgsError error() const { return mError; }

    //TODO QGIS 3.0 - return QgsCoordinateReferenceSystem object, not reference (since they are implicitly shared)
    const QgsCoordinateReferenceSystem& crs() const;

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

    static QString capitaliseLayerName( const QString& name );

    virtual QString styleURI();

    virtual QString loadDefaultStyle( bool & theResultFlag );

    virtual QString loadNamedStyle( const QString &theURI, bool &theResultFlag );

    virtual bool loadNamedStyleFromDb( const QString &db, const QString &theURI, QString &qml );

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

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


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

    virtual QString saveDefaultStyle( bool & theResultFlag );

    virtual QString saveNamedStyle( const QString &theURI, bool &theResultFlag );

    virtual QString saveSldStyle( const QString &theURI, bool &theResultFlag );
    virtual QString loadSldStyle( const QString &theURI, bool &theResultFlag );

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



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

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

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

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

    QUndoStack *undoStack();

    QUndoStack *undoStackStyles();

    /* Layer legendUrl information */
    void setLegendUrl( const QString& legendUrl ) { mLegendUrl = legendUrl; }
    QString legendUrl() const { return mLegendUrl; }
    void setLegendUrlFormat( const QString& legendUrlFormat ) { mLegendUrlFormat = legendUrlFormat; }
    QString legendUrlFormat() const { return mLegendUrlFormat; }

    Q_DECL_DEPRECATED QImage *cacheImage() { return nullptr; }
    Q_DECL_DEPRECATED void setCacheImage( QImage * );
    Q_DECL_DEPRECATED virtual void onCacheImageDelete() {}

    void setLegend( QgsMapLayerLegend* legend );
    QgsMapLayerLegend* legend() const;

    QgsMapLayerStyleManager* styleManager() const;

    bool isInScaleRange( double scale ) const;

    double minimumScale() const;

    double maximumScale() const;

    bool hasScaleBasedVisibility() const;

  public slots:

    virtual void invalidTransformInput();

    void setMinimumScale( double theMinScale );

    void setMaximumScale( double theMaxScale );

    void setScaleBasedVisibility( const bool enabled );

    Q_DECL_DEPRECATED void toggleScaleBasedVisibility( bool theVisibilityFlag );

    Q_DECL_DEPRECATED void clearCacheImage();

    void triggerRepaint();

    virtual QString metadata();

    virtual QDateTime timestamp() const { return QDateTime() ; }

    void emitStyleChanged();

  signals:

    Q_DECL_DEPRECATED void drawingProgress( int theProgress, int theTotalSteps );

    void statusChanged( const QString& theStatus );

    Q_DECL_DEPRECATED void layerNameChanged();

    void nameChanged();

    void layerCrsChanged();

    void repaintRequested();

    void screenUpdateRequested();

    void recalculateExtents();

    void dataChanged();

    void blendModeChanged( QPainter::CompositionMode blendMode );

    void rendererChanged();

    void styleChanged();

    void legendChanged();

    void configChanged();

  protected:
    virtual void setExtent( const QgsRectangle &rect );

    void setValid( bool valid );

    virtual bool readXml( const QDomNode& layer_node );

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


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

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

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

#if 0

    void connectNotify( const char * signal ) override;
#endif

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

    QgsRectangle mExtent;

    bool mValid;

    QString mDataSource;

    QString mLayerName;

    QString mLayerOrigName;

    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;

  private:
    virtual bool isReadOnly() const { return true; }

    QgsCoordinateReferenceSystem mCRS;

    QgsMapLayer( QgsMapLayer const & );

    QgsMapLayer & operator=( QgsMapLayer const & );

    QString mID;

    QgsMapLayer::LayerType mLayerType;

    QPainter::CompositionMode mBlendMode;

    QString mTag;

    double mMinScale;
    double mMaxScale;
    bool mScaleBasedVisibility;

    QUndoStack mUndoStack;

    QUndoStack mUndoStackStyles;

    QgsObjectCustomProperties mCustomProperties;

    QgsMapLayerLegend* mLegend;

    QgsMapLayerStyleManager* mStyleManager;
};

Q_DECLARE_METATYPE( QgsMapLayer* )

#endif