qgsannotationitemguiregistry.h

Go to the documentation of this file.

/***************************************************************************
                            qgsannotationitemguiregistry.h
                            --------------------------
    begin                : September 2021
    copyright            : (C) 2021 by Nyall Dawson
    email                : nyall dot dawson 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 QGSANNOTATIONITEMGUIREGISTRY_H
#define QGSANNOTATIONITEMGUIREGISTRY_H
 
#include <functional>
 
#include "qgis.h"
#include "qgis_gui.h"
#include "qgis_sip.h"
#include "qgsannotationitemregistry.h"
#include "qgsapplication.h"
#include "qgspathresolver.h"
 
#include <QIcon>
 
class QgsAnnotationLayer;
class QgsAnnotationItem;
class QgsAnnotationItemBaseWidget;
class QgsCreateAnnotationItemMapToolInterface;
class QgsMapCanvas;
class QgsAdvancedDigitizingDockWidget;

class GUI_EXPORT QgsAnnotationItemAbstractGuiMetadata
{
  public:
    QgsAnnotationItemAbstractGuiMetadata( const QString &type, const QString &visibleName, const QString &groupId = QString(), Qgis::AnnotationItemGuiFlags flags = Qgis::AnnotationItemGuiFlags() )
      : mType( type )
      , mGroupId( groupId )
      , mName( visibleName )
      , mFlags( flags )
    {}
 
    virtual ~QgsAnnotationItemAbstractGuiMetadata() = default;

    QString type() const { return mType; }

    Qgis::AnnotationItemGuiFlags flags() const { return mFlags; }

    QString groupId() const { return mGroupId; }

    QString visibleName() const { return mName; }

    virtual QIcon creationIcon() const;
 
    /*
     * IMPORTANT: While it seems like /Factory/ would be the correct annotations here, that's not
     * the case.
     * As per Phil Thomson's advice on https://www.riverbankcomputing.com/pipermail/pyqt/2017-July/039450.html:
     *
     * "
     * /Factory/ is used when the instance returned is guaranteed to be new to Python.
     * In this case it isn't because it has already been seen when being returned by QgsProcessingAlgorithm::createInstance()
     * (However for a different sub-class implemented in C++ then it would be the first time it was seen
     * by Python so the /Factory/ on create() would be correct.)
     *
     * You might try using /TransferBack/ on create() instead - that might be the best compromise.
     * "
     */

    virtual QgsAnnotationItemBaseWidget *createItemWidget( QgsAnnotationItem *item ) SIP_TRANSFERBACK;

    virtual QgsCreateAnnotationItemMapToolInterface *createMapTool( QgsMapCanvas *canvas, QgsAdvancedDigitizingDockWidget *cadDockWidget ) SIP_TRANSFERBACK;

    virtual QgsAnnotationItem *createItem() SIP_TRANSFERBACK;

    virtual void newItemAddedToLayer( QgsAnnotationItem *item, QgsAnnotationLayer *layer );
 
  private:
    QString mType;
    QString mGroupId;
    QString mName;
    Qgis::AnnotationItemGuiFlags mFlags;
};

typedef std::function<QgsAnnotationItemBaseWidget *( QgsAnnotationItem * )> QgsAnnotationItemWidgetFunc SIP_SKIP;

typedef std::function<QgsCreateAnnotationItemMapToolInterface *( QgsMapCanvas *, QgsAdvancedDigitizingDockWidget * )> QgsCreateAnnotationItemMapToolFunc SIP_SKIP;

typedef std::function<void( QgsAnnotationItem *, QgsAnnotationLayer *layer )> QgsAnnotationItemAddedToLayerFunc SIP_SKIP;
 
#ifndef SIP_RUN

class GUI_EXPORT QgsAnnotationItemGuiMetadata : public QgsAnnotationItemAbstractGuiMetadata
{
  public:
    QgsAnnotationItemGuiMetadata( const QString &type, const QString &visibleName, const QIcon &creationIcon, const QgsAnnotationItemWidgetFunc &pfWidget = nullptr, const QString &groupId = QString(), Qgis::AnnotationItemGuiFlags flags = Qgis::AnnotationItemGuiFlags(), const QgsAnnotationItemCreateFunc &pfCreateFunc = nullptr, const QgsCreateAnnotationItemMapToolFunc &pfCreateMapToolFunc = nullptr )
      : QgsAnnotationItemAbstractGuiMetadata( type, visibleName, groupId, flags )
      , mIcon( creationIcon )
      , mWidgetFunc( pfWidget )
      , mCreateFunc( pfCreateFunc )
      , mCreateMapToolFunc( pfCreateMapToolFunc )
    {}

    QgsAnnotationItemWidgetFunc widgetFunction() const { return mWidgetFunc; }

    void setWidgetFunction( const QgsAnnotationItemWidgetFunc &function ) { mWidgetFunc = function; }

    QgsCreateAnnotationItemMapToolFunc createMapToolFunction() const { return mCreateMapToolFunc; }

    void setCreateMapToolFunction( const QgsCreateAnnotationItemMapToolFunc &function ) { mCreateMapToolFunc = function; }

    QgsAnnotationItemCreateFunc itemCreationFunction() const { return mCreateFunc; }

    void setItemCreationFunction( const QgsAnnotationItemCreateFunc &function ) { mCreateFunc = function; }

    QgsAnnotationItemAddedToLayerFunc itemAddToLayerFunction() const { return mAddedToLayerFunc; }

    void setItemAddedToLayerFunction( const QgsAnnotationItemAddedToLayerFunc &function ) { mAddedToLayerFunc = function; }
 
    QIcon creationIcon() const override;
    QgsAnnotationItemBaseWidget *createItemWidget( QgsAnnotationItem *item ) override;
 
    QgsAnnotationItem *createItem() override;
    void newItemAddedToLayer( QgsAnnotationItem *item, QgsAnnotationLayer *layer ) override;
    QgsCreateAnnotationItemMapToolInterface *createMapTool( QgsMapCanvas *canvas, QgsAdvancedDigitizingDockWidget *cadDockWidget ) override;
 
  protected:
    QIcon mIcon;
    QgsAnnotationItemWidgetFunc mWidgetFunc = nullptr;
    QgsAnnotationItemCreateFunc mCreateFunc = nullptr;
    QgsCreateAnnotationItemMapToolFunc mCreateMapToolFunc = nullptr;
    QgsAnnotationItemAddedToLayerFunc mAddedToLayerFunc = nullptr;
};
 
#endif

class GUI_EXPORT QgsAnnotationItemGuiGroup
{
  public:
    QgsAnnotationItemGuiGroup( const QString &id = QString(), const QString &name = QString(), const QIcon &icon = QIcon() )
      : id( id )
      , name( name )
      , icon( icon )
    {}

    QString id;

    QString name;

    QIcon icon;
};
 

class GUI_EXPORT QgsAnnotationItemGuiRegistry : public QObject
{
    Q_OBJECT
 
  public:
    QgsAnnotationItemGuiRegistry( QObject *parent = nullptr );
 
    ~QgsAnnotationItemGuiRegistry() override;
 
    QgsAnnotationItemGuiRegistry( const QgsAnnotationItemGuiRegistry &rh ) = delete;
    QgsAnnotationItemGuiRegistry &operator=( const QgsAnnotationItemGuiRegistry &rh ) = delete;

    QgsAnnotationItemAbstractGuiMetadata *itemMetadata( int metadataId ) const;

    int metadataIdForItemType( const QString &type ) const;

    bool addAnnotationItemGuiMetadata( QgsAnnotationItemAbstractGuiMetadata *metadata SIP_TRANSFER );

    bool addItemGroup( const QgsAnnotationItemGuiGroup &group );

    const QgsAnnotationItemGuiGroup &itemGroup( const QString &id ) const;
 
    /*
     * IMPORTANT: While it seems like /Factory/ would be the correct annotations here, that's not
     * the case.
     * As per Phil Thomson's advice on https://www.riverbankcomputing.com/pipermail/pyqt/2017-July/039450.html:
     *
     * "
     * /Factory/ is used when the instance returned is guaranteed to be new to Python.
     * In this case it isn't because it has already been seen when being returned by QgsProcessingAlgorithm::createInstance()
     * (However for a different sub-class implemented in C++ then it would be the first time it was seen
     * by Python so the /Factory/ on create() would be correct.)
     *
     * You might try using /TransferBack/ on create() instead - that might be the best compromise.
     * "
     */

    QgsAnnotationItem *createItem( int metadataId ) const SIP_TRANSFERBACK;

    void newItemAddedToLayer( int metadataId, QgsAnnotationItem *item, QgsAnnotationLayer *layer );
 
    /*
     * IMPORTANT: While it seems like /Factory/ would be the correct annotations here, that's not
     * the case.
     * As per Phil Thomson's advice on https://www.riverbankcomputing.com/pipermail/pyqt/2017-July/039450.html:
     *
     * "
     * /Factory/ is used when the instance returned is guaranteed to be new to Python.
     * In this case it isn't because it has already been seen when being returned by QgsProcessingAlgorithm::createInstance()
     * (However for a different sub-class implemented in C++ then it would be the first time it was seen
     * by Python so the /Factory/ on create() would be correct.)
     *
     * You might try using /TransferBack/ on create() instead - that might be the best compromise.
     * "
     */

    QgsAnnotationItemBaseWidget *createItemWidget( QgsAnnotationItem *item ) const SIP_TRANSFERBACK;

    QList<int> itemMetadataIds() const;

    void addDefaultItems();
 
  signals:

    void typeAdded( int metadataId );
 
  private:
#ifdef SIP_RUN
    QgsAnnotationItemGuiRegistry( const QgsAnnotationItemGuiRegistry &rh );
#endif
 
    QMap<int, QgsAnnotationItemAbstractGuiMetadata *> mMetadata;
 
    QMap<QString, QgsAnnotationItemGuiGroup> mItemGroups;
};
 
#endif //QGSANNOTATIONITEMGUIREGISTRY_H