qgsvectorlayer.h

Go to the documentation of this file.

/***************************************************************************
                          qgsvectorlayer.h  -  description
                             -------------------
    begin                : Oct 29, 2003
    copyright            : (C) 2003 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 QGSVECTORLAYER_H
#define QGSVECTORLAYER_H

#include <QMap>
#include <QSet>
#include <QList>
#include <QStringList>

#include "qgis.h"
#include "qgsmaplayer.h"
#include "qgsfeature.h"
#include "qgsfeatureiterator.h"
#include "qgseditorwidgetconfig.h"
#include "qgsfield.h"
#include "qgssnapper.h"
#include "qgsfield.h"
#include "qgsrelation.h"
#include "qgsvectorsimplifymethod.h"

class QPainter;
class QImage;

class QgsAbstractGeometrySimplifier;
class QgsAttributeAction;
class QgsCoordinateTransform;
class QgsDiagramLayerSettings;
class QgsDiagramRendererV2;
class QgsEditorWidgetWrapper;
class QgsExpressionFieldBuffer;
class QgsFeatureRendererV2;
class QgsFeatureRequest;
class QgsGeometry;
class QgsGeometryCache;
class QgsGeometryVertexIndex;
class QgsLabel;
class QgsMapToPixel;
class QgsRectangle;
class QgsRectangle;
class QgsRelation;
class QgsRelationManager;
class QgsSingleSymbolRendererV2;
class QgsSymbolV2;
class QgsVectorDataProvider;
class QgsVectorLayerEditBuffer;
class QgsVectorLayerJoinBuffer;

typedef QList<int> QgsAttributeList;
typedef QSet<int> QgsAttributeIds;

class CORE_EXPORT QgsAttributeEditorElement : public QObject
{
    Q_OBJECT
  public:

    enum AttributeEditorType
    {
      AeTypeContainer,
      AeTypeField,
      AeTypeRelation,
      AeTypeInvalid
    };

    QgsAttributeEditorElement( AttributeEditorType type, QString name, QObject *parent = NULL )
        : QObject( parent ), mType( type ), mName( name ) {}

    virtual ~QgsAttributeEditorElement() {}

    QString name() const { return mName; }
    AttributeEditorType type() const { return mType; }

    virtual QDomElement toDomElement( QDomDocument& doc ) const = 0;

  protected:
    AttributeEditorType mType;
    QString mName;
};

class CORE_EXPORT QgsAttributeEditorContainer : public QgsAttributeEditorElement
{
  public:
    QgsAttributeEditorContainer( QString name, QObject *parent )
        : QgsAttributeEditorElement( AeTypeContainer, name, parent )
        , mIsGroupBox( true )
    {}

    ~QgsAttributeEditorContainer() {}

    virtual QDomElement toDomElement( QDomDocument& doc ) const override;
    virtual void addChildElement( QgsAttributeEditorElement *widget );
    virtual void setIsGroupBox( bool isGroupBox ) { mIsGroupBox = isGroupBox; }
    virtual bool isGroupBox() const { return mIsGroupBox; }
    QList<QgsAttributeEditorElement*> children() const { return mChildren; }
    virtual QList<QgsAttributeEditorElement*> findElements( AttributeEditorType type ) const;

  private:
    bool mIsGroupBox;
    QList<QgsAttributeEditorElement*> mChildren;
};


class CORE_EXPORT QgsAttributeEditorField : public QgsAttributeEditorElement
{
  public:
    QgsAttributeEditorField( QString name, int idx, QObject *parent )
        : QgsAttributeEditorElement( AeTypeField, name, parent ), mIdx( idx ) {}

    ~QgsAttributeEditorField() {}

    virtual QDomElement toDomElement( QDomDocument& doc ) const override;
    int idx() const { return mIdx; }

  private:
    int mIdx;
};

class CORE_EXPORT QgsAttributeEditorRelation : public QgsAttributeEditorElement
{
  public:
    QgsAttributeEditorRelation( QString name, const QString &relationId, QObject *parent )
        : QgsAttributeEditorElement( AeTypeRelation, name, parent )
        , mRelationId( relationId ) {}

    QgsAttributeEditorRelation( QString name, const QgsRelation& relation, QObject *parent )
        : QgsAttributeEditorElement( AeTypeRelation, name, parent )
        , mRelationId( relation.id() )
        , mRelation( relation ) {}

    ~QgsAttributeEditorRelation() {}

    virtual QDomElement toDomElement( QDomDocument& doc ) const override;
    const QgsRelation& relation() const { return mRelation; }

    bool init( QgsRelationManager *relManager );

  private:
    QString mRelationId;
    QgsRelation mRelation;
};


struct CORE_EXPORT QgsVectorJoinInfo
{
  QString targetFieldName;
  QString joinLayerId;
  QString joinFieldName;
  bool memoryCache;
  QHash< QString, QgsAttributes> cachedAttributes;

  int targetFieldIndex;
  int joinFieldIndex;

  QString prefix;

  bool operator==( const QgsVectorJoinInfo& other ) const
  {
    return targetFieldName == other.targetFieldName &&
           joinLayerId == other.joinLayerId &&
           joinFieldName == other.joinFieldName &&
           joinFieldsSubset == other.joinFieldsSubset &&
           memoryCache == other.memoryCache &&
           prefix == other.prefix;
  }

  void setJoinFieldNamesSubset( QStringList* fieldNamesSubset ) { joinFieldsSubset = QSharedPointer<QStringList>( fieldNamesSubset ); }
  QStringList* joinFieldNamesSubset() const { return joinFieldsSubset.data(); }

protected:
  QSharedPointer<QStringList> joinFieldsSubset;
};

class CORE_EXPORT QgsVectorLayer : public QgsMapLayer
{
    Q_OBJECT

  public:
    enum EditorLayout
    {
      GeneratedLayout = 0,
      TabLayout = 1,
      UiFileLayout = 2
    };

    enum EditType
    {
      LineEdit,
      UniqueValues,
      UniqueValuesEditable,
      ValueMap,
      Classification,
      EditRange,
      SliderRange,
      CheckBox,
      FileName,
      Enumeration,
      Immutable,      
      Hidden,         
      TextEdit,       
      Calendar,       
      DialRange,      
      ValueRelation,  
      UuidGenerator,  
      Photo,          
      WebView,        
      Color,          
      EditorWidgetV2, 
    };

    enum FeatureFormSuppress
    {
      SuppressDefault = 0, // use the application-wide setting
      SuppressOn = 1,
      SuppressOff = 2
    };

    struct RangeData
    {
      RangeData() { mMin = QVariant( 0 ); mMax = QVariant( 5 ); mStep = QVariant( 1 );}
      RangeData( QVariant theMin, QVariant theMax, QVariant theStep )
          : mMin( theMin ), mMax( theMax ), mStep( theStep ) {}

      QVariant mMin;
      QVariant mMax;
      QVariant mStep;
    };

    struct ValueRelationData
    {
      ValueRelationData() : mAllowNull( false ), mOrderByValue( false ), mAllowMulti( false ) {}
      ValueRelationData( QString layer, QString key, QString value, bool allowNull, bool orderByValue,
                         bool allowMulti = false,
                         QString filterExpression = QString::null )
          : mLayer( layer )
          , mKey( key )
          , mValue( value )
          , mFilterExpression( filterExpression )
          , mAllowNull( allowNull )
          , mOrderByValue( orderByValue )
          , mAllowMulti( allowMulti )
      {}

      QString mLayer;
      QString mKey;
      QString mValue;
      QString mFilterExpression;
      bool mAllowNull;
      bool mOrderByValue;
      bool mAllowMulti;  /* allow selection of multiple keys */
    };

    struct GroupData
    {
      GroupData() {}
      GroupData( QString name, QList<QString> fields )
          : mName( name ), mFields( fields ) {}
      QString mName;
      QList<QString> mFields;
    };

    struct TabData
    {
      TabData() {}
      TabData( QString name, QList<QString> fields, QList<GroupData> groups )
          : mName( name ), mFields( fields ), mGroups( groups ) {}
      QString mName;
      QList<QString> mFields;
      QList<GroupData> mGroups;
    };

    QgsVectorLayer( QString path = QString::null, QString baseName = QString::null,
                    QString providerLib = QString::null, bool loadDefaultStyleFlag = true );

    virtual ~QgsVectorLayer();

    QString storageType() const;

    QString capabilitiesString() const;

    QString dataComment() const;

    void setDisplayField( QString fldName = "" );

    const QString displayField() const;

    void setDisplayExpression( const QString &displayExpression );

    const QString displayExpression();

    QgsVectorDataProvider* dataProvider();

    const QgsVectorDataProvider* dataProvider() const;

    void setProviderEncoding( const QString& encoding );

    void setCoordinateSystem();

    bool addJoin( const QgsVectorJoinInfo& joinInfo );

    void removeJoin( const QString& joinLayerId );

    const QList< QgsVectorJoinInfo >& vectorJoins() const;

    void addExpressionField( const QString& exp, const QgsField& fld );

    void removeExpressionField( int index );

    QgsLabel *label();

    const QgsLabel *label() const;

    QgsAttributeAction *actions() { return mActions; }

    int selectedFeatureCount();

    void select( QgsRectangle & rect, bool addToSelection );

    void modifySelection( QgsFeatureIds selectIds, QgsFeatureIds deselectIds );

    void invertSelection();

    void selectAll();

    QgsFeatureIds allFeatureIds();

    void invertSelectionInRectangle( QgsRectangle & rect );

    QgsFeatureList selectedFeatures();

    QgsFeatureIterator selectedFeaturesIterator( QgsFeatureRequest request = QgsFeatureRequest() );

    const QgsFeatureIds &selectedFeaturesIds() const;

    void setSelectedFeatures( const QgsFeatureIds &ids );

    QgsRectangle boundingBoxOfSelected();

    void setDiagramRenderer( QgsDiagramRendererV2* r );
    const QgsDiagramRendererV2* diagramRenderer() const { return mDiagramRenderer; }

    void setDiagramLayerSettings( const QgsDiagramLayerSettings& s );
    const QgsDiagramLayerSettings *diagramLayerSettings() const { return mDiagramLayerSettings; }

    QgsFeatureRendererV2* rendererV2();
    void setRendererV2( QgsFeatureRendererV2* r );

    QGis::GeometryType geometryType() const;

    bool hasGeometryType() const;

    QGis::WkbType wkbType() const;

    QString providerType() const;

    virtual bool readXml( const QDomNode& layer_node ) override;

    virtual bool writeXml( QDomNode & layer_node, QDomDocument & doc ) override;

    virtual void saveStyleToDatabase( QString name, QString description,
                                      bool useAsDefault, QString uiFileContent,
                                      QString &msgError );

    virtual int listStylesInDatabase( QStringList &ids, QStringList &names,
                                      QStringList &descriptions, QString &msgError );

    virtual QString getStyleFromDatabase( QString styleId, QString &msgError );

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

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

    virtual bool applyNamedStyle( QString namedStyle, QString &errorMsg );

    QgsAttributeEditorElement* attributeEditorElementFromDomElement( QDomElement &elem, QObject* parent );

    bool readSymbology( const QDomNode& node, QString& errorMessage ) override;

    bool writeSymbology( QDomNode& node, QDomDocument& doc, QString& errorMessage ) const override;

    bool writeSld( QDomNode& node, QDomDocument& doc, QString& errorMessage ) const;
    bool readSld( const QDomNode& node, QString& errorMessage ) override;

    virtual long featureCount() const;

    long featureCount( QgsSymbolV2* symbol );

    bool countSymbolFeatures( bool showProgress = true );

    virtual bool setSubsetString( QString subset );

    virtual QString subsetString();

    QgsFeatureIterator getFeatures( const QgsFeatureRequest& request = QgsFeatureRequest() );

    bool addFeature( QgsFeature& f, bool alsoUpdateExtent = true );

    bool updateFeature( QgsFeature &f );

    bool insertVertex( double x, double y, QgsFeatureId atFeatureId, int beforeVertex );

    bool moveVertex( double x, double y, QgsFeatureId atFeatureId, int atVertex );

    bool deleteVertex( QgsFeatureId atFeatureId, int atVertex );

    bool deleteSelectedFeatures( int *deletedCount = 0 );

    int addRing( const QList<QgsPoint>& ring );

    int addPart( const QList<QgsPoint>& ring );

    int translateFeature( QgsFeatureId featureId, double dx, double dy );

    int splitParts( const QList<QgsPoint>& splitLine, bool topologicalEditing = false );

    int splitFeatures( const QList<QgsPoint>& splitLine, bool topologicalEditing = false );

    Q_DECL_DEPRECATED int removePolygonIntersections( QgsGeometry* geom, QgsFeatureIds ignoreFeatures = QgsFeatureIds() );

    int addTopologicalPoints( QgsGeometry* geom );

    int addTopologicalPoints( const QgsPoint& p );

    int insertSegmentVerticesForSnap( const QList<QgsSnappingResult>& snapResults );

    void enableLabels( bool on );

    bool hasLabelsEnabled() const;

    virtual bool isEditable() const override;

    virtual bool isReadOnly() const;

    virtual bool isModified() const;

    bool snapPoint( QgsPoint& point, double tolerance );

    int snapWithContext( const QgsPoint& startPoint,
                         double snappingTolerance,
                         QMultiMap < double, QgsSnappingResult > &snappingResults,
                         QgsSnapper::SnappingType snap_to );

    virtual void reload() override;

    virtual QgsMapLayerRenderer* createMapRenderer( QgsRenderContext& rendererContext ) override;

    bool draw( QgsRenderContext& rendererContext ) override;

    void drawLabels( QgsRenderContext& rendererContext ) override;

    QgsRectangle extent() override;

    const QgsFields &pendingFields() const;

    QgsAttributeList pendingAllAttributesList();

    QgsAttributeList pendingPkAttributesList();

    int pendingFeatureCount();

    bool setReadOnly( bool readonly = true );

    bool startEditing();

    bool changeGeometry( QgsFeatureId fid, QgsGeometry* geom );

    Q_DECL_DEPRECATED bool changeAttributeValue( QgsFeatureId fid, int field, QVariant value, bool emitSignal );

    bool changeAttributeValue( QgsFeatureId fid, int field, const QVariant &newValue, const QVariant &oldValue = QVariant() );

    bool addAttribute( const QgsField &field );

    void addAttributeAlias( int attIndex, QString aliasString );

    void remAttributeAlias( int attIndex );

    void addAttributeEditorWidget( QgsAttributeEditorElement* data );

    const QString editorWidgetV2( int fieldIdx ) const;

    const QString editorWidgetV2( const QString& fieldName ) const;

    const QgsEditorWidgetConfig editorWidgetV2Config( int fieldIdx ) const;

    const QgsEditorWidgetConfig editorWidgetV2Config( const QString& fieldName ) const;

    QList< QgsAttributeEditorElement* > &attributeEditorElements();
    void clearAttributeEditorWidgets();

    QString attributeAlias( int attributeIndex ) const;

    QString attributeDisplayName( int attributeIndex ) const;

    const QMap< QString, QString >& attributeAliases() const { return mAttributeAliasMap; }

    const QSet<QString>& excludeAttributesWMS() const { return mExcludeAttributesWMS; }
    void setExcludeAttributesWMS( const QSet<QString>& att ) { mExcludeAttributesWMS = att; }

    const QSet<QString>& excludeAttributesWFS() const { return mExcludeAttributesWFS; }
    void setExcludeAttributesWFS( const QSet<QString>& att ) { mExcludeAttributesWFS = att; }

    bool deleteAttribute( int attr );

    bool deleteAttributes( QList<int> attrs );

    bool addFeatures( QgsFeatureList features, bool makeSelected = true );

    bool deleteFeature( QgsFeatureId fid );

    bool commitChanges();
    const QStringList &commitErrors();

    bool rollBack( bool deleteBuffer = true );

    Q_DECL_DEPRECATED EditType editType( int idx );

    Q_DECL_DEPRECATED void setEditType( int idx, EditType edit );

    EditorLayout editorLayout();

    void setEditorLayout( EditorLayout editorLayout );

    void setEditorWidgetV2( int attrIdx, const QString& widgetType );

    void setEditorWidgetV2Config( int attrIdx, const QgsEditorWidgetConfig& config );

    Q_DECL_DEPRECATED void setCheckedState( int idx, QString checked, QString notChecked );

    QString editForm();

    void setEditForm( QString ui );

    QgsVectorLayer::FeatureFormSuppress featureFormSuppress() const { return mFeatureFormSuppress; }

    void setFeatureFormSuppress( QgsVectorLayer::FeatureFormSuppress s ) { mFeatureFormSuppress = s; }

    QString annotationForm() const { return mAnnotationForm; }

    void setAnnotationForm( const QString& ui );

    QString editFormInit();

    void setEditFormInit( QString function );

    Q_DECL_DEPRECATED QMap<QString, QVariant> valueMap( int idx );

    Q_DECL_DEPRECATED RangeData range( int idx );

    ValueRelationData valueRelation( int idx );

    QList<QgsRelation> referencingRelations( int idx );

    Q_DECL_DEPRECATED QString dateFormat( int idx );

    Q_DECL_DEPRECATED QSize widgetSize( int idx );

    bool fieldEditable( int idx );

    bool labelOnTop( int idx );

    void setFieldEditable( int idx, bool editable );

    void setLabelOnTop( int idx, bool onTop );

    QgsVectorLayerEditBuffer* editBuffer() { return mEditBuffer; }

    void beginEditCommand( QString text );

    void endEditCommand();

    void destroyEditCommand();

    int fieldNameIndex( const QString& fieldName ) const;

    enum VertexMarkerType
    {
      SemiTransparentCircle,
      Cross,
      NoMarker
    };

    static void drawVertexMarker( double x, double y, QPainter& p, QgsVectorLayer::VertexMarkerType type, int vertexSize );

    void updateFields();

    void createJoinCaches();

    void uniqueValues( int index, QList<QVariant> &uniqueValues, int limit = -1 );

    QVariant minimumValue( int index );

    QVariant maximumValue( int index );

    /* Set the blending mode used for rendering each feature */
    void setFeatureBlendMode( const QPainter::CompositionMode &blendMode );
    /* Returns the current blending mode for features */
    QPainter::CompositionMode featureBlendMode() const;

    /* Set the transparency for the vector layer */
    void setLayerTransparency( int layerTransparency );
    /* Returns the current transparency for the vector layer */
    int layerTransparency() const;

    QString metadata() override;

    inline QgsGeometryCache* cache() { return mCache; }

    void setSimplifyMethod( const QgsVectorSimplifyMethod& simplifyMethod ) { mSimplifyMethod = simplifyMethod; }
    inline const QgsVectorSimplifyMethod& simplifyMethod() const { return mSimplifyMethod; }

    bool simplifyDrawingCanbeApplied( const QgsRenderContext& renderContext, QgsVectorSimplifyMethod::SimplifyHint simplifyHint ) const;

  public slots:
    void select( const QgsFeatureId &featureId );

    void select( const QgsFeatureIds& featureIds );

    void deselect( const QgsFeatureId featureId );

    void deselect( const QgsFeatureIds& featureIds );

    void removeSelection();

    virtual void updateExtents();

    void checkJoinLayerRemove( QString theLayerId );

  protected slots:
    void invalidateSymbolCountedFlag();

  signals:

    void selectionChanged( const QgsFeatureIds selected, const QgsFeatureIds deselected, const bool clearAndSelect );

    void selectionChanged();

    void layerModified();

    void beforeModifiedCheck() const;

    void editingStarted();

    void editingStopped();

    void beforeCommitChanges();

    void beforeRollBack();

    void attributeAdded( int idx );
    void attributeDeleted( int idx );
    void featureAdded( QgsFeatureId fid );
    void featureDeleted( QgsFeatureId fid );
    void updatedFields();
    void layerDeleted();

    void attributeValueChanged( QgsFeatureId fid, int idx, const QVariant & );
    void geometryChanged( QgsFeatureId fid, QgsGeometry &geom );

    void committedAttributesDeleted( const QString& layerId, const QgsAttributeList& deletedAttributes );
    void committedAttributesAdded( const QString& layerId, const QList<QgsField>& addedAttributes );
    void committedFeaturesAdded( const QString& layerId, const QgsFeatureList& addedFeatures );
    void committedFeaturesRemoved( const QString& layerId, const QgsFeatureIds& deletedFeatureIds );
    void committedAttributeValuesChanges( const QString& layerId, const QgsChangedAttributesMap& changedAttributesValues );
    void committedGeometriesChanges( const QString& layerId, const QgsGeometryMap& changedGeometries );

    void saveLayerToProject();

    void labelingFontNotFound( QgsVectorLayer* layer, const QString& fontfamily );

    void featureBlendModeChanged( const QPainter::CompositionMode &blendMode );

    void layerTransparencyChanged( int layerTransparency );

    void editCommandStarted( const QString& text );

    void editCommandEnded();

    void editCommandDestroyed();

    void readCustomSymbology( const QDomElement& element, QString& errorMessage );

    void writeCustomSymbology( QDomElement& element, QDomDocument& doc, QString& errorMessage ) const;

  private slots:
    void onRelationsLoaded();
    void onJoinedFieldsChanged();

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

  private:                       // Private methods

    QgsVectorLayer( const QgsVectorLayer & rhs );

    QgsVectorLayer & operator=( QgsVectorLayer const & rhs );

    bool setDataProvider( QString const & provider );

    QgsFeatureId findFreeId();

    void snapToGeometry( const QgsPoint& startPoint,
                         QgsFeatureId featureId,
                         QgsGeometry* geom,
                         double sqrSnappingTolerance,
                         QMultiMap<double, QgsSnappingResult>& snappingResults,
                         QgsSnapper::SnappingType snap_to ) const;

    //void addJoinedAttributes( QgsFeature& f, bool all = false );

    void readSldLabeling( const QDomNode& node );

  private:                       // Private attributes

    QgsVectorDataProvider *mDataProvider;

    QString mDisplayField;

    QString mDisplayExpression;

    QString mProviderKey;

    QgsAttributeAction* mActions;

    bool mReadOnly;

    QgsFeatureIds mSelectedFeatureIds;

    QgsFields mUpdatedFields;

    QMap< QString, QString > mAttributeAliasMap;

    QList< QgsAttributeEditorElement* > mAttributeEditorElements;

    QSet<QString> mExcludeAttributesWMS;
    QSet<QString> mExcludeAttributesWFS;

    QList< TabData > mTabs;

    QGis::WkbType mWkbType;

    QgsFeatureRendererV2 *mRendererV2;

    QgsVectorSimplifyMethod mSimplifyMethod;

    QgsLabel *mLabel;

    bool mLabelOn;

    bool mLabelFontNotFoundNotified;

    QPainter::CompositionMode mFeatureBlendMode;

    int mLayerTransparency;

    bool mVertexMarkerOnlyForSelection;

    QStringList mCommitErrors;

    QMap< QString, bool> mFieldEditables;
    QMap< QString, bool> mLabelOnTop;

    QMap<QString, QString> mEditorWidgetV2Types;
    QMap<QString, QgsEditorWidgetConfig > mEditorWidgetV2Configs;

    EditorLayout mEditorLayout;

    QString mEditForm, mEditFormInit;

    QgsVectorLayer::FeatureFormSuppress mFeatureFormSuppress;

    //annotation form for this layer
    QString mAnnotationForm;

    QgsGeometryCache* mCache;

    QgsVectorLayerEditBuffer* mEditBuffer;
    friend class QgsVectorLayerEditBuffer;

    //stores information about joined layers
    QgsVectorLayerJoinBuffer* mJoinBuffer;

    QgsExpressionFieldBuffer* mExpressionFieldBuffer;

    //diagram rendering object. 0 if diagram drawing is disabled
    QgsDiagramRendererV2* mDiagramRenderer;

    //stores infos about diagram placement (placement type, priority, position distance)
    QgsDiagramLayerSettings *mDiagramLayerSettings;

    bool mValidExtent;
    bool mLazyExtent;

    // Features in renderer classes counted
    bool mSymbolFeatureCounted;

    // Feature counts for each renderer symbol
    QMap<QgsSymbolV2*, long> mSymbolFeatureCountMap;

    friend class QgsVectorLayerFeatureSource;
};

#endif