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.h"
#include "qgis_core.h"
#include "qgis_sip.h"
#include "qgsmimedatautils.h"
 
#include <QFutureWatcher>
#include <QIcon>
#include <QObject>
#include <QString>
 
using namespace Qt::StringLiterals;
 
class QgsDataItem;
class QMenu;
class QgsAbstractDatabaseProviderConnection;
class QgsAnimatedIcon;
class QgsCoordinateReferenceSystem;
 
class QAction;
class QWidget;
 
typedef QgsDataItem *dataItem_t( QString, QgsDataItem * ) SIP_SKIP;

class CORE_EXPORT QgsDataItem : public QObject
{
    //SIP_TYPEHEADER_INCLUDE( "qgslayeritem.h" );
    //SIP_TYPEHEADER_INCLUDE( "qgsdirectoryitem.h" );
    //SIP_TYPEHEADER_INCLUDE( "qgsfavoritesitem.h" );
    //SIP_TYPEHEADER_INCLUDE( "qgszipitem.h" );
    //SIP_TYPEHEADER_INCLUDE( "qgsdatacollectionitem.h" );
    //SIP_TYPEHEADER_INCLUDE( "qgsprojectitem.h" );
 
#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:

    QgsDataItem( Qgis::BrowserItemType type, QgsDataItem *parent SIP_TRANSFERTHIS, const QString &name, const QString &path, const QString &providerKey = QString() );
 
    ~QgsDataItem() override;
 
#ifdef SIP_RUN
    SIP_PYOBJECT __repr__();
    % MethodCode
    QString str = u"<QgsDataItem: \"%1\" %2>"_s.arg( sipCpp->name(), sipCpp->path() );
    sipRes = PyUnicode_FromString( str.toUtf8().constData() );
    % End
#endif

    bool hasChildren() const;

    virtual bool layerCollection() const;

    int rowCount() const;

    virtual QVector<QgsDataItem *> createChildren() SIP_TRANSFERBACK;
#ifdef SIP_RUN
    SIP_VIRTUAL_CATCHER_CODE
    PyObject *sipResObj = sipCallMethod( 0, sipMethod, "" );
    // H = Convert a Python object to a mapped type instance.
    // 5 = 1 (disallows the conversion of Py_None to NULL) + 4 (returns a copy of the C/C++ instance)
    sipIsErr = !sipResObj || sipParseResult( 0, sipMethod, sipResObj, "H5", sipType_QVector_0101QgsDataItem, &sipRes ) < 0;
    if ( !sipIsErr )
    {
      for ( QgsDataItem *item : sipRes )
      {
        PyObject *pyItem = sipGetPyObject( item, sipType_QgsDataItem );
        if ( pyItem != NULL )
        {
          // pyItem is given an extra reference which is removed when the C++ instance’s destructor is called.
          sipTransferTo( pyItem, Py_None );
        }
      }
    }
    if ( sipResObj != NULL )
    {
      Py_DECREF( sipResObj );
    }
    SIP_END
#endif

    int creatorAncestorDepth() const;
 
    Qgis::BrowserItemState state() const;

    virtual void setState( Qgis::BrowserItemState 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; }
 
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Woverloaded-virtual"
#endif

    Q_DECL_DEPRECATED virtual bool handleDrop( const QMimeData * /*data*/, Qt::DropAction /*action*/ ) SIP_DEPRECATED { return false; }
#ifdef __clang__
#pragma clang diagnostic pop
#endif

    virtual bool handleDoubleClick();

    virtual bool hasDragEnabled() const { return false; }

    Q_DECL_DEPRECATED virtual QgsMimeDataUtils::Uri mimeUri() const SIP_DEPRECATED;

    virtual QgsMimeDataUtils::UriList mimeUris() const;

    Q_DECL_DEPRECATED virtual bool setCrs( const QgsCoordinateReferenceSystem &crs ) SIP_DEPRECATED;

    Q_DECL_DEPRECATED virtual bool rename( const QString &name ) SIP_DEPRECATED;
 
    // ### QGIS 5 - rename to capabilities()

    virtual Qgis::BrowserItemCapabilities capabilities2() const { return mCapabilities; }

    virtual void setCapabilities( Qgis::BrowserItemCapabilities capabilities ) SIP_PYNAME( setCapabilitiesV2 ) { mCapabilities = capabilities; }

    Q_DECL_DEPRECATED void setCapabilities( int capabilities ) SIP_DEPRECATED;
 
    // static methods
 
    // Find child index in vector of items using '==' operator
    static int findItem( QVector<QgsDataItem *> items, QgsDataItem *item );
 
#ifndef SIP_RUN

    template<class T>
    static QList< T * > filteredItems( const QList< QgsDataItem * > &items )
    {
      QList< T * > result;
      result.reserve( items.size() );
      for ( QgsDataItem *item : items )
      {
        if ( T *matchedItem = qobject_cast< T * >( item ) )
          result << matchedItem;
      }
      return result;
    }
#endif
 
    // members
 
    Qgis::BrowserItemType type() const { return mType; }

    QgsDataItem *parent() const { return mParent; }

    QgsDataItem *ancestorAtDepth( int depth ) const;

    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 );

    virtual QgsAbstractDatabaseProviderConnection *databaseConnection() const SIP_FACTORY;
 
    // TODO should be private, but MSSQL data item provider is badly behaved and needs to
    // manually manipulate this!
    SIP_SKIP int mCreatorAncestorDepth = 0;
 
  protected:
    virtual void populate( const QVector<QgsDataItem *> &children );

    virtual void refresh( const QVector<QgsDataItem *> &children );

    bool deferredDelete() const { return mDeferredDelete; }
 
    Qgis::BrowserItemType mType;
    Qgis::BrowserItemCapabilities mCapabilities = Qgis::BrowserItemCapability::NoCapabilities;
    QgsDataItem *mParent = nullptr;
    QVector<QgsDataItem *> mChildren; // easier to have it always
    Qgis::BrowserItemState mState = Qgis::BrowserItemState::NotPopulated;
    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, Qgis::BrowserItemState 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 = false;
    std::unique_ptr<QFutureWatcher<QVector<QgsDataItem *> >> mFutureWatcher;
 
    // number of items currently in loading (populating) state
    static QgsAnimatedIcon *sPopulatingIcon;
};

class CORE_EXPORT QgsErrorItem : public QgsDataItem
{
    Q_OBJECT
  public:
 
    QgsErrorItem( QgsDataItem *parent, const QString &error, const QString &path );
 
#ifdef SIP_RUN
    SIP_PYOBJECT __repr__();
    % MethodCode
    QString str = u"<QgsErrorItem: \"%1\" %2>"_s.arg( sipCpp->name(), sipCpp->path() );
    sipRes = PyUnicode_FromString( str.toUtf8().constData() );
    % End
#endif
 
};
 
#endif // QGSDATAITEM_H