qgssymbollayerregistry.h

Go to the documentation of this file.

/***************************************************************************
    qgssymbollayerregistry.h
    ---------------------
    begin                : November 2009
    copyright            : (C) 2009 by Martin Dobias
    email                : wonder dot sk at gmail dot 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 QGSSYMBOLLAYERREGISTRY_H
#define QGSSYMBOLLAYERREGISTRY_H
 
#include "qgis_core.h"
#include "qgis.h"
 
class QgsPathResolver;
class QgsVectorLayer;
class QgsSymbolLayerWidget SIP_EXTERNAL;
class QgsSymbolLayer;
class QDomElement;
class QgsReadWriteContext;
 
class CORE_EXPORT QgsSymbolLayerAbstractMetadata
{
  public:
 
    QgsSymbolLayerAbstractMetadata( const QString &name, const QString &visibleName, Qgis::SymbolType type )
      : mName( name )
      , mVisibleName( visibleName )
      , mType( type )
    {}
    QgsSymbolLayerAbstractMetadata( const QString &name, const QString &visibleName, Qgis::SymbolType type ) {…}
 
    virtual ~QgsSymbolLayerAbstractMetadata() = default;
 
    QString name() const { return mName; }
    QString visibleName() const { return mVisibleName; }
    Qgis::SymbolType type() const { return mType; }
 
    virtual QgsSymbolLayer *createSymbolLayer( const QVariantMap &map ) = 0 SIP_FACTORY;
    virtual QgsSymbolLayerWidget *createSymbolLayerWidget( QgsVectorLayer * ) SIP_FACTORY { return nullptr; }
    virtual QgsSymbolLayer *createSymbolLayerFromSld( QDomElement & ) SIP_FACTORY { return nullptr; }
 
    virtual void resolvePaths( QVariantMap &properties, const QgsPathResolver &pathResolver, bool saving )
    {
      Q_UNUSED( properties )
      Q_UNUSED( pathResolver )
      Q_UNUSED( saving )
    }
    virtual void resolvePaths( QVariantMap &properties, const QgsPathResolver &pathResolver, bool saving ) {…}
 
    virtual void resolveFonts( const QVariantMap &properties, const QgsReadWriteContext &context )
    {
      Q_UNUSED( properties )
      Q_UNUSED( context )
    }
    virtual void resolveFonts( const QVariantMap &properties, const QgsReadWriteContext &context ) {…}
 
  protected:
    QString mName;
    QString mVisibleName;
    Qgis::SymbolType mType;
};
class CORE_EXPORT QgsSymbolLayerAbstractMetadata {…};
 
typedef QgsSymbolLayer *( *QgsSymbolLayerCreateFunc )( const QVariantMap & ) SIP_SKIP;
typedef QgsSymbolLayerWidget *( *QgsSymbolLayerWidgetFunc )( QgsVectorLayer * ) SIP_SKIP;
typedef QgsSymbolLayer *( *QgsSymbolLayerCreateFromSldFunc )( QDomElement & ) SIP_SKIP;
typedef void ( *QgsSymbolLayerPathResolverFunc )( QVariantMap &, const QgsPathResolver &, bool ) SIP_SKIP;
typedef void ( *QgsSymbolLayerFontResolverFunc )( const QVariantMap &, const QgsReadWriteContext & ) SIP_SKIP;
 
class CORE_EXPORT QgsSymbolLayerMetadata : public QgsSymbolLayerAbstractMetadata
{
  public:
    QgsSymbolLayerMetadata( const QString &name, const QString &visibleName,
                            Qgis::SymbolType type,
                            QgsSymbolLayerCreateFunc pfCreate,
                            QgsSymbolLayerCreateFromSldFunc pfCreateFromSld = nullptr,
                            QgsSymbolLayerPathResolverFunc pfPathResolver = nullptr,
                            QgsSymbolLayerWidgetFunc pfWidget = nullptr,
                            QgsSymbolLayerFontResolverFunc pfFontResolver = nullptr ) SIP_SKIP
  : QgsSymbolLayerAbstractMetadata( name, visibleName, type )
    , mCreateFunc( pfCreate )
    , mWidgetFunc( pfWidget )
    , mCreateFromSldFunc( pfCreateFromSld )
    , mPathResolverFunc( pfPathResolver )
    , mFontResolverFunc( pfFontResolver )
    {}
    QgsSymbolLayerMetadata( const QString &name, const QString &visibleName, {…}
 
    QgsSymbolLayerCreateFunc createFunction() const SIP_SKIP { return mCreateFunc; }
    QgsSymbolLayerWidgetFunc widgetFunction() const SIP_SKIP { return mWidgetFunc; }
    QgsSymbolLayerCreateFromSldFunc createFromSldFunction() const SIP_SKIP { return mCreateFromSldFunc; }
    QgsSymbolLayerPathResolverFunc pathResolverFunction() const SIP_SKIP { return mPathResolverFunc; }
 
    void setWidgetFunction( QgsSymbolLayerWidgetFunc f ) SIP_SKIP { mWidgetFunc = f; }
 
    QgsSymbolLayer *createSymbolLayer( const QVariantMap &map ) override SIP_FACTORY { return mCreateFunc ? mCreateFunc( map ) : nullptr; }
    QgsSymbolLayerWidget *createSymbolLayerWidget( QgsVectorLayer *vl ) override SIP_FACTORY { return mWidgetFunc ? mWidgetFunc( vl ) : nullptr; }
    QgsSymbolLayer *createSymbolLayerFromSld( QDomElement &elem ) override SIP_FACTORY { return mCreateFromSldFunc ? mCreateFromSldFunc( elem ) : nullptr; }
    void resolvePaths( QVariantMap &properties, const QgsPathResolver &pathResolver, bool saving ) override
    {
      if ( mPathResolverFunc )
        mPathResolverFunc( properties, pathResolver, saving );
    }
    void resolvePaths( QVariantMap &properties, const QgsPathResolver &pathResolver, bool saving ) override {…}
 
    void resolveFonts( const QVariantMap &properties, const QgsReadWriteContext &context ) override
    {
      if ( mFontResolverFunc )
        mFontResolverFunc( properties, context );
    }
    void resolveFonts( const QVariantMap &properties, const QgsReadWriteContext &context ) override {…}
 
  protected:
    QgsSymbolLayerCreateFunc mCreateFunc;
    QgsSymbolLayerWidgetFunc mWidgetFunc;
    QgsSymbolLayerCreateFromSldFunc mCreateFromSldFunc;
    QgsSymbolLayerPathResolverFunc mPathResolverFunc;
 
    QgsSymbolLayerFontResolverFunc mFontResolverFunc;
 
  private:
#ifdef SIP_RUN
    QgsSymbolLayerMetadata();
#endif
};
class CORE_EXPORT QgsSymbolLayerMetadata : public QgsSymbolLayerAbstractMetadata {…};
 
 
class CORE_EXPORT QgsSymbolLayerRegistry
{
  public:
 
    QgsSymbolLayerRegistry();
    ~QgsSymbolLayerRegistry();
 
    QgsSymbolLayerRegistry( const QgsSymbolLayerRegistry &rh ) = delete;
    QgsSymbolLayerRegistry &operator=( const QgsSymbolLayerRegistry &rh ) = delete;
 
    QgsSymbolLayerAbstractMetadata *symbolLayerMetadata( const QString &name ) const;
 
    bool addSymbolLayerType( QgsSymbolLayerAbstractMetadata *metadata SIP_TRANSFER );
 
    bool removeSymbolLayerType( QgsSymbolLayerAbstractMetadata *metadata );
 
    std::unique_ptr< QgsSymbolLayer > createSymbolLayer( const QString &name, const QVariantMap &properties = QVariantMap() ) const;
 
    std::unique_ptr< QgsSymbolLayer > createSymbolLayerFromSld( const QString &name, QDomElement &element ) const;
 
    void resolvePaths( const QString &name, QVariantMap &properties, const QgsPathResolver &pathResolver, bool saving ) const;
 
    void resolveFonts( const QString &name, QVariantMap &properties, const QgsReadWriteContext &context ) const;
 
    QStringList symbolLayersForType( Qgis::SymbolType type );
 
    static std::unique_ptr< QgsSymbolLayer > defaultSymbolLayer( Qgis::SymbolType type );
 
  private:
#ifdef SIP_RUN
    QgsSymbolLayerRegistry( const QgsSymbolLayerRegistry &rh );
#endif
 
    QMap<QString, QgsSymbolLayerAbstractMetadata *> mMetadata;
};
class CORE_EXPORT QgsSymbolLayerRegistry {…};
 
#endif