qgsdataitem.h

Go to the documentation of this file.

/***************************************************************************
                 qgsdataitem.h  - Items representing data
                             -------------------
    begin                : 2011-04-01
    copyright            : (C) 2011 Radim Blazek
    email                : radim dot blazek 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 QGSDATAITEM_H
#define QGSDATAITEM_H
 
#include "qgis_sip.h"
#include "qgis_core.h"
#include <QFileSystemWatcher>
#include <QFutureWatcher>
#include <QIcon>
#include <QObject>
#include <QPixmap>
#include <QString>
#include <QTreeWidget>
#include <QVector>
#include <QDateTime>
 
#include "qgsmaplayer.h"
#include "qgscoordinatereferencesystem.h"
#include "qgsmimedatautils.h"
#include "qgswkbtypes.h"
#include "qgsabstractdatabaseproviderconnection.h"
 
class QgsDataProvider;
class QgsDataItem;
class QgsAnimatedIcon;
class QgsBookmarkManager;
 
typedef QgsDataItem *dataItem_t( QString, QgsDataItem * ) SIP_SKIP;
 
class CORE_EXPORT QgsDataItem : public QObject
{
 
#ifdef SIP_RUN
    SIP_CONVERT_TO_SUBCLASS_CODE
    if ( qobject_cast<QgsLayerItem *>( sipCpp ) )
      sipType = sipType_QgsLayerItem;
    else if ( qobject_cast<QgsErrorItem *>( sipCpp ) )
      sipType = sipType_QgsErrorItem;
    else if ( qobject_cast<QgsDirectoryItem *>( sipCpp ) )
      sipType = sipType_QgsDirectoryItem;
    else if ( qobject_cast<QgsFavoritesItem *>( sipCpp ) )
      sipType = sipType_QgsFavoritesItem;
    else if ( qobject_cast<QgsZipItem *>( sipCpp ) )
      sipType = sipType_QgsZipItem;
    else if ( qobject_cast<QgsDataCollectionItem *>( sipCpp ) )
      sipType = sipType_QgsDataCollectionItem;
    else if ( qobject_cast<QgsProjectItem *>( sipCpp ) )
      sipType = sipType_QgsProjectItem;
    else
      sipType = 0;
    SIP_END
#endif
 
    Q_OBJECT
 
  public:
    enum Type
    {
      Collection,
      Directory,
      Layer,
      Error,
      Favorites, 
      Project, 
      Custom, 
      Fields, 
      Field, 
    };
 
    Q_ENUM( Type )
 
    
    QgsDataItem( QgsDataItem::Type type, QgsDataItem *parent SIP_TRANSFERTHIS, const QString &name, const QString &path, const QString &providerKey = QString() );
 
    ~QgsDataItem() override;
 
    bool hasChildren();
 
    virtual bool layerCollection() const;
 
    int rowCount();
 
    virtual QVector<QgsDataItem *> createChildren() SIP_FACTORY;
 
    enum State
    {
      NotPopulated, 
      Populating,   
      Populated     
    };
    Q_ENUM( State )
 
    
    State state() const;
 
    virtual void setState( State state );
 
    virtual void addChildItem( QgsDataItem *child SIP_TRANSFER, bool refresh = false );
 
    virtual void deleteChildItem( QgsDataItem *child );
 
    virtual QgsDataItem *removeChildItem( QgsDataItem *child ) SIP_TRANSFERBACK;
 
    virtual bool equal( const QgsDataItem *other );
 
    Q_DECL_DEPRECATED virtual QWidget *paramWidget() SIP_FACTORY SIP_DEPRECATED { return nullptr; }
 
    virtual QList<QAction *> actions( QWidget *parent );
 
    virtual QList<QMenu *> menus( QWidget *parent );
 
    Q_DECL_DEPRECATED virtual bool acceptDrop() SIP_DEPRECATED { return false; }
 
    Q_DECL_DEPRECATED virtual bool handleDrop( const QMimeData * /*data*/, Qt::DropAction /*action*/ ) SIP_DEPRECATED { return false; }
 
    virtual bool handleDoubleClick();
 
    virtual bool hasDragEnabled() const { return false; }
 
    virtual QgsMimeDataUtils::Uri mimeUri() const { return QgsMimeDataUtils::Uri(); }
 
    enum Capability
    {
      NoCapabilities    = 0,
      SetCrs            = 1 << 0, 
      Fertile           = 1 << 1, 
      Fast              = 1 << 2, 
      Collapse          = 1 << 3, 
      Rename            = 1 << 4, 
      Delete            = 1 << 5, 
    };
    Q_DECLARE_FLAGS( Capabilities, Capability )
 
    
    Q_DECL_DEPRECATED virtual bool setCrs( const QgsCoordinateReferenceSystem &crs ) SIP_DEPRECATED
    {
      Q_UNUSED( crs )
      return false;
    }
 
    Q_DECL_DEPRECATED virtual bool rename( const QString &name ) SIP_DEPRECATED;
 
    // ### QGIS 4 - rename to capabilities()
 
    virtual Capabilities capabilities2() const { return mCapabilities; }
 
    virtual void setCapabilities( Capabilities capabilities ) { mCapabilities = capabilities; }
 
    // static methods
 
    // Find child index in vector of items using '==' operator
    static int findItem( QVector<QgsDataItem *> items, QgsDataItem *item );
 
    // members
 
    Type type() const { return mType; }
 
    QgsDataItem *parent() const { return mParent; }
 
    void setParent( QgsDataItem *parent );
    QVector<QgsDataItem *> children() const { return mChildren; }
    virtual QIcon icon();
 
    QString name() const { return mName; }
 
    void setName( const QString &name );
 
    QString path() const { return mPath; }
    void setPath( const QString &path ) { mPath = path; }
 
    QString providerKey() const;
 
    void setProviderKey( const QString &value );
 
    static QString pathComponent( const QString &component );
 
    virtual QVariant sortKey() const;
 
    void setSortKey( const QVariant &key );
 
 
    // Because QIcon (QPixmap) must not be used in outside the GUI thread, it is
    // not possible to set mIcon in constructor. Either use mIconName/setIconName()
    // or implement icon().
    void setIcon( const QIcon &icon ) { mIcon = icon; }
    void setIconName( const QString &iconName ) { mIconName = iconName; }
 
    void setToolTip( const QString &msg ) { mToolTip = msg; }
    QString toolTip() const { return mToolTip; }
 
    // deleteLater() items and clear the vector
    static void deleteLater( QVector<QgsDataItem *> &items );
 
    void moveToThread( QThread *targetThread );
 
  protected:
    virtual void populate( const QVector<QgsDataItem *> &children );
 
    virtual void refresh( const QVector<QgsDataItem *> &children );
 
    bool deferredDelete() { return mDeferredDelete; }
 
    Type mType;
    Capabilities mCapabilities;
    QgsDataItem *mParent = nullptr;
    QVector<QgsDataItem *> mChildren; // easier to have it always
    State mState;
    QString mName;
    QString mProviderKey;
    // Path is slash ('/') separated chain of item identifiers which are usually item names, but may be different if it is
    // necessary to distinguish paths of two providers to the same source (e.g GRASS location and standard directory have the same
    // name but different paths). Identifiers in path must not contain '/' characters.
    // The path is used to identify item in tree.
    QString mPath;
    QString mToolTip;
    QString mIconName;
    QIcon mIcon;
    QMap<QString, QIcon> mIconMap;
 
    QVariant mSortKey;
 
  public slots:
 
    virtual void deleteLater();
 
    // Populate children using children vector created by createChildren()
    // \param foreground run createChildren in foreground
    virtual void populate( bool foreground = false );
 
    virtual void depopulate();
 
    virtual void refresh();
 
    virtual void refreshConnections( const QString &providerKey = QString() );
 
    virtual void childrenCreated();
 
  signals:
    void beginInsertItems( QgsDataItem *parent, int first, int last );
    void endInsertItems();
    void beginRemoveItems( QgsDataItem *parent, int first, int last );
    void endRemoveItems();
    void dataChanged( QgsDataItem *item );
    void stateChanged( QgsDataItem *item, QgsDataItem::State oldState );
 
    void connectionsChanged( const QString &providerKey = QString() );
 
  protected slots:
 
    void updateIcon();
 
  private:
    static QVector<QgsDataItem *> runCreateChildren( QgsDataItem *item );
 
    // Set to true if object has to be deleted when possible (nothing running in threads)
    bool mDeferredDelete;
    QFutureWatcher< QVector <QgsDataItem *> > *mFutureWatcher;
    // number of items currently in loading (populating) state
    static QgsAnimatedIcon *sPopulatingIcon;
};
 
Q_DECLARE_OPERATORS_FOR_FLAGS( QgsDataItem::Capabilities )
 
 
class CORE_EXPORT QgsLayerItem : public QgsDataItem
{
    Q_OBJECT
 
  public:
    enum LayerType
    {
      NoType,
      Vector,
      Raster,
      Point,
      Line,
      Polygon,
      TableLayer,
      Database,
      Table,
      Plugin,    
      Mesh,      
      VectorTile 
    };
 
    Q_ENUM( LayerType )
 
    QgsLayerItem( QgsDataItem *parent, const QString &name, const QString &path, const QString &uri, LayerType layerType, const QString &providerKey );
 
    // --- reimplemented from QgsDataItem ---
 
    bool equal( const QgsDataItem *other ) override;
 
    bool hasDragEnabled() const override { return true; }
 
    QgsMimeDataUtils::Uri mimeUri() const override;
 
    // --- New virtual methods for layer item derived classes ---
 
    QgsMapLayerType mapLayerType() const;
 
    static LayerType typeFromMapLayer( QgsMapLayer *layer );
 
    QString uri() const { return mUri; }
 
    QString providerKey() const { return mProviderKey; }
 
    QStringList supportedCrs() const { return mSupportedCRS; }
 
    QStringList supportedFormats() const { return mSupportFormats; }
 
    virtual QString comments() const { return QString(); }
 
    static QString layerTypeAsString( LayerType layerType );
 
    static QString iconName( LayerType layerType );
 
    Q_DECL_DEPRECATED virtual bool deleteLayer() SIP_DEPRECATED;
 
  protected:
    QString mUri;
    LayerType mLayerType;
    QStringList mSupportedCRS;
    QStringList mSupportFormats;
 
  public:
    static QIcon iconPoint();
    static QIcon iconLine();
    static QIcon iconPolygon();
    static QIcon iconTable();
    static QIcon iconRaster();
    static QIcon iconDefault();
    static QIcon iconMesh();
    static QIcon iconVectorTile();
 
    virtual QString layerName() const { return name(); }
};
 
 
class CORE_EXPORT QgsDataCollectionItem : public QgsDataItem
{
    Q_OBJECT
  public:
 
    QgsDataCollectionItem( QgsDataItem *parent SIP_TRANSFERTHIS, const QString &name, const QString &path = QString(), const QString &providerKey = QString() );
 
    ~QgsDataCollectionItem() override;
 
    void addChild( QgsDataItem *item SIP_TRANSFER ) { mChildren.append( item ); }
 
    static QIcon iconDir();
 
    static QIcon iconDataCollection();
 
  protected:
 
    static QIcon openDirIcon();
 
    static QIcon homeDirIcon();
};
 
 
class CORE_EXPORT QgsDatabaseSchemaItem : public QgsDataCollectionItem
{
    Q_OBJECT
  public:
 
    QgsDatabaseSchemaItem( QgsDataItem *parent SIP_TRANSFERTHIS, const QString &name, const QString &path = QString(), const QString &providerKey = QString() );
 
    ~QgsDatabaseSchemaItem() override;
 
 
    static QIcon iconDataCollection();
 
};
 
 
 
class CORE_EXPORT QgsConnectionsRootItem : public QgsDataCollectionItem
{
    Q_OBJECT
  public:
 
    QgsConnectionsRootItem( QgsDataItem *parent SIP_TRANSFERTHIS, const QString &name, const QString &path = QString(), const QString &providerKey = QString() );
 
    ~QgsConnectionsRootItem() override = default;
};
 
 
class CORE_EXPORT QgsDirectoryItem : public QgsDataCollectionItem
{
    Q_OBJECT
  public:
 
    QgsDirectoryItem( QgsDataItem *parent SIP_TRANSFERTHIS, const QString &name, const QString &path );
 
 
    // TODO QGIS 4.0 -- rename "name" to "title" or "text" or something more descriptive, and "path" to something
    // else to clarify the role of dirPath vs path
 
    QgsDirectoryItem( QgsDataItem *parent SIP_TRANSFERTHIS, const QString &name, const QString &dirPath, const QString &path, const QString &providerKey = QString() );
 
    void setState( State state ) override;
 
    QVector<QgsDataItem *> createChildren() override;
 
    QString dirPath() const { return mDirPath; }
 
    bool equal( const QgsDataItem *other ) override;
    QIcon icon() override;
    Q_DECL_DEPRECATED QWidget *paramWidget() override SIP_FACTORY SIP_DEPRECATED;
    bool hasDragEnabled() const override { return true; }
    QgsMimeDataUtils::Uri mimeUri() const override;
 
    static bool hiddenPath( const QString &path );
 
  public slots:
    void childrenCreated() override;
    void directoryChanged();
 
  protected:
    void init();
    QString mDirPath;
 
  private:
    QFileSystemWatcher *mFileSystemWatcher = nullptr;
    bool mRefreshLater;
    QDateTime mLastScan;
};
 
class CORE_EXPORT QgsProjectItem : public QgsDataItem
{
    Q_OBJECT
  public:
 
    QgsProjectItem( QgsDataItem *parent, const QString &name, const QString &path, const QString &providerKey = QString() );
 
    bool hasDragEnabled() const override { return true; }
 
    QgsMimeDataUtils::Uri mimeUri() const override;
 
};
 
class CORE_EXPORT QgsErrorItem : public QgsDataItem
{
    Q_OBJECT
  public:
 
    QgsErrorItem( QgsDataItem *parent, const QString &error, const QString &path );
 
};
 
// ---------
 
// TODO: move to qgis_gui for QGIS 4
 
class CORE_EXPORT QgsDirectoryParamWidget : public QTreeWidget
{
    Q_OBJECT
 
  public:
    QgsDirectoryParamWidget( const QString &path, QWidget *parent SIP_TRANSFERTHIS = nullptr );
 
  protected:
    void mousePressEvent( QMouseEvent *event ) override;
 
  public slots:
    void showHideColumn();
};
 
class CORE_EXPORT QgsFavoritesItem : public QgsDataCollectionItem
{
    Q_OBJECT
  public:
 
    QgsFavoritesItem( QgsDataItem *parent, const QString &name, const QString &path = QString() );
 
    QVector<QgsDataItem *> createChildren() override;
 
    void addDirectory( const QString &directory, const QString &name = QString() );
 
    void removeDirectory( QgsDirectoryItem *item );
 
    void renameFavorite( const QString &path, const QString &name );
 
    static QIcon iconFavorites();
 
    QVariant sortKey() const override;
 
  private:
    QVector<QgsDataItem *> createChildren( const QString &favDir, const QString &name );
};
 
class CORE_EXPORT QgsZipItem : public QgsDataCollectionItem
{
    Q_OBJECT
 
  protected:
    QString mFilePath;
    QString mVsiPrefix;
    QStringList mZipFileList;
 
  public:
    QgsZipItem( QgsDataItem *parent, const QString &name, const QString &path );
 
    QgsZipItem( QgsDataItem *parent, const QString &name, const QString &filePath, const QString &path, const QString &providerKey = QString() );
 
    QVector<QgsDataItem *> createChildren() override;
    QStringList getZipFileList();
 
    static QVector<dataItem_t *> sDataItemPtr SIP_SKIP;
    static QStringList sProviderNames;
 
    static QString vsiPrefix( const QString &uri ) { return qgsVsiPrefix( uri ); }
 
    static QgsDataItem *itemFromPath( QgsDataItem *parent, const QString &path, const QString &name ) SIP_FACTORY;
 
    static QgsDataItem *itemFromPath( QgsDataItem *parent, const QString &filePath, const QString &name, const QString &path ) SIP_FACTORY SIP_PYNAME( itemFromFilePath );
 
    static QIcon iconZip();
 
  private:
    void init();
};
 
 
class CORE_EXPORT QgsFieldsItem : public QgsDataItem
{
    Q_OBJECT
 
  public:
 
    QgsFieldsItem( QgsDataItem *parent SIP_TRANSFERTHIS,
                   const QString &path,
                   const QString &connectionUri,
                   const QString &providerKey,
                   const QString &schema,
                   const QString &tableName );
 
    ~QgsFieldsItem() override;
 
    QVector<QgsDataItem *> createChildren() override;
 
    QIcon icon() override;
 
    QString schema() const;
 
    QString tableName() const;
 
    QString connectionUri() const;
 
    QgsVectorLayer *layer() SIP_FACTORY;
 
    QgsAbstractDatabaseProviderConnection::TableProperty *tableProperty() const;
 
  private:
 
    QString mSchema;
    QString mTableName;
    QString mConnectionUri;
    std::unique_ptr<QgsAbstractDatabaseProviderConnection::TableProperty> mTableProperty;
 
};
 
 
class CORE_EXPORT QgsFieldItem : public QgsDataItem
{
    Q_OBJECT
  public:
 
    QgsFieldItem( QgsDataItem *parent SIP_TRANSFERTHIS,
                  const QgsField &field );
 
    ~QgsFieldItem() override;
 
    QIcon icon() override;
 
    //QgsField field() const;
 
 
  private:
 
    const QgsField mField;
 
};
 
 
 
#ifndef SIP_RUN
 
class CORE_EXPORT QgsProjectHomeItem : public QgsDirectoryItem
{
    Q_OBJECT
 
  public:
 
    QgsProjectHomeItem( QgsDataItem *parent, const QString &name, const QString &dirPath, const QString &path );
 
    QIcon icon() override;
    QVariant sortKey() const override;
 
};
 
Q_NOWARN_DEPRECATED_PUSH  // rename is deprecated
class CORE_EXPORT QgsFavoriteItem : public QgsDirectoryItem
{
    Q_OBJECT
 
  public:
 
    QgsFavoriteItem( QgsFavoritesItem *parent, const QString &name, const QString &dirPath, const QString &path );
 
    bool rename( const QString &name ) override;
 
  private:
 
    QgsFavoritesItem *mFavorites = nullptr;
};
Q_NOWARN_DEPRECATED_POP
 
#endif
 
#endif // QGSDATAITEM_H