src/core/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 "qgssnapper.h"
#include "qgsfield.h"

class QPainter;
class QImage;

class QgsAttributeAction;
class QgsCoordinateTransform;
class QgsGeometry;
class QgsGeometryVertexIndex;
class QgsMapToPixel;
class QgsLabel;
class QgsRectangle;
class QgsRenderer;
class QgsUndoCommand;
class QgsVectorDataProvider;
class QgsVectorOverlay;
class QgsSingleSymbolRendererV2;
class QgsRectangle;
class QgsVectorLayerJoinBuffer;
class QgsFeatureRendererV2;
class QgsDiagramRendererV2;
struct QgsDiagramLayerSettings;

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

struct CORE_EXPORT QgsVectorJoinInfo
{
  int targetField;
  QString joinLayerId;
  int joinField;
  bool memoryCache;
  QHash< QString, QgsAttributeMap> cachedAttributes;
};

struct CORE_EXPORT QgsFetchJoinInfo
{
  const QgsVectorJoinInfo* joinInfo;
  QgsAttributeList attributes; //attributes to fetch
  int indexOffset; //index offset between this layer and join layer
};

class CORE_EXPORT QgsVectorLayer : public QgsMapLayer
{
    Q_OBJECT

  public:
    enum EditType
    {
      LineEdit,
      UniqueValues,
      UniqueValuesEditable,
      ValueMap,
      Classification,
      EditRange,
      SliderRange,
      CheckBox,      /* added in 1.4 */
      FileName,
      Enumeration,
      Immutable,     /* The attribute value should not be changed in the attribute form*/
      Hidden,        /* The attribute value should not be shown in the attribute form @added in 1.4 */
      TextEdit,      /* multiline edit @added in 1.4*/
      Calendar,      /* calendar widget @added in 1.5 */
      DialRange,     /* dial range @added in 1.5 */
      ValueRelation, /* value map from an table @added in 1.8 */
      UuidGenerator, /* uuid generator - readonly and automatically intialized @added in 1.9 */
    };

    struct RangeData
    {
      RangeData() {}
      RangeData( QVariant theMin, QVariant theMax, QVariant theStep )
          : mMin( theMin ), mMax( theMax ), mStep( theStep ) {}

      QVariant mMin;
      QVariant mMax;
      QVariant mStep;
    };

    struct ValueRelationData
    {
      ValueRelationData() {}
      ValueRelationData( QString layer, QString key, QString value, bool allowNull, bool orderByValue )
          : mLayer( layer ), mKey( key ), mValue( value ), mAllowNull( allowNull ), mOrderByValue( orderByValue ) {}

      QString mLayer;
      QString mKey;
      QString mValue;
      bool mAllowNull;
      bool mOrderByValue;
    };

    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;

    QgsVectorDataProvider* dataProvider();

    const QgsVectorDataProvider* dataProvider() const;

    void setProviderEncoding( const QString& encoding );

    void setCoordinateSystem();

    void addJoin( QgsVectorJoinInfo joinInfo );

    void removeJoin( const QString& joinLayerId );

    const QList< QgsVectorJoinInfo >& vectorJoins() const;

    QgsLabel *label();

    const QgsLabel *label() const;

    QgsAttributeAction* actions() { return mActions; }

    int selectedFeatureCount();

    void select( QgsRectangle & rect, bool lock );

    void invertSelection();

    void invertSelectionInRectangle( QgsRectangle & rect );

    QgsFeatureList selectedFeatures();

    const QgsFeatureIds& selectedFeaturesIds() const;

    void setSelectedFeatures( const QgsFeatureIds& ids );

    QgsRectangle boundingBoxOfSelected();

    bool copySymbologySettings( const QgsMapLayer& other );

    bool hasCompatibleSymbology( const QgsMapLayer& other ) const;

    const QgsRenderer* renderer() const;

    void setRenderer( QgsRenderer * r );

    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 );
    bool isUsingRendererV2();
    void setUsingRendererV2( bool usingRendererV2 );

    void drawRendererV2( QgsRenderContext& rendererContext, bool labeling );

    void drawRendererV2Levels( QgsRenderContext& rendererContext, bool labeling );

    QGis::GeometryType geometryType() const;

    bool hasGeometryType() const;

    QGis::WkbType wkbType() const;

    QString providerType() const;

    virtual bool readXml( const QDomNode& layer_node );

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

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

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

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

    virtual long featureCount() const;

    virtual long updateFeatureCount() const;

    virtual bool setSubsetString( QString subset );

    virtual QString subsetString();

    void select( QgsAttributeList fetchAttributes,
                 QgsRectangle rect = QgsRectangle(),
                 bool fetchGeometry = true,
                 bool useIntersect = false );

    bool nextFeature( QgsFeature& feature );

    bool featureAtId( QgsFeatureId featureId, QgsFeature &f, bool fetchGeometries = true, bool fetchAttributes = true );

    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 addRing( const QList<QgsPoint>& ring );

    int addPart( const QList<QgsPoint>& ring );
    Q_DECL_DEPRECATED int addIsland( const QList<QgsPoint>& ring ) { return addPart( ring ); }

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

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

    int removePolygonIntersections( QgsGeometry* geom );

    int addTopologicalPoints( QgsGeometry* geom );

    int addTopologicalPoints( const QgsPoint& p );

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

    void enableLabels( bool on );

    bool hasLabelsEnabled( void ) const;

    virtual bool isEditable() const;

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

    bool draw( QgsRenderContext& rendererContext );

    void drawLabels( QgsRenderContext& rendererContext );

    const QgsFieldMap &pendingFields() const;

    QgsAttributeList pendingAllAttributesList();

    int pendingFeatureCount();

    bool setReadOnly( bool readonly = true );

    void setModified( bool modified = true, bool onlyGeometryWasModified = false );

    bool startEditing();

    bool changeGeometry( QgsFeatureId fid, QgsGeometry* geom );

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

    bool addAttribute( const QgsField &field );

    Q_DECL_DEPRECATED bool addAttribute( QString name, QString type );

    void addAttributeAlias( int attIndex, QString aliasString );

    QString attributeAlias( int attributeIndex ) const;

    QString attributeDisplayName( int attributeIndex ) const;

    bool deleteAttribute( int attr );

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

    bool deleteFeature( QgsFeatureId fid );

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

    bool rollBack();

    EditType editType( int idx );

    void setEditType( int idx, EditType edit );

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

    QPair<QString, QString> checkedState( int idx );

    QString editForm();

    void setEditForm( QString ui );

    QString annotationForm() const { return mAnnotationForm; }

    void setAnnotationForm( const QString& ui );

    QString editFormInit();

    void setEditFormInit( QString function );

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

    RangeData &range( int idx );

    ValueRelationData &valueRelation( int idx );

    void addOverlay( QgsVectorOverlay* overlay );

    void removeOverlay( const QString& typeName );

    void vectorOverlays( QList<QgsVectorOverlay*>& overlayList );

    QgsVectorOverlay* findOverlayByType( const QString& typeName );


    void beginEditCommand( QString text );

    void endEditCommand();

    void destroyEditCommand();

    void undoEditCommand( QgsUndoCommand* cmd );

    void redoEditCommand( QgsUndoCommand* cmd );

    int fieldNameIndex( const QString& fieldName ) const;

    enum VertexMarkerType
    {
      SemiTransparentCircle,
      Cross,
      NoMarker  /* added in version 1.1 */
    };

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

    void updateFieldMap();

    void createJoinCaches();

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

    QVariant minimumValue( int index );

    QVariant maximumValue( int index );

  public slots:
    void select( QgsFeatureId featureId, bool emitSignal = true );

    void deselect( QgsFeatureId featureId, bool emitSignal = true );

    void removeSelection( bool emitSignal = true );

    void triggerRepaint();

    virtual void updateExtents();

    void checkJoinLayerRemove( QString theLayerId );

    QString metadata();

  signals:

    void selectionChanged();

    void layerModified( bool onlyGeometry );

    void editingStarted();
    void editingStopped();
    void attributeAdded( int idx );
    void attributeDeleted( int idx );
    void featureAdded( QgsFeatureId fid );  // added in 1.7
    void featureDeleted( QgsFeatureId fid );
    void layerDeleted();

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

    void committedAttributesDeleted( const QString& layerId, const QgsAttributeIds& deletedAttributeIds );
    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 );

  private:                       // Private methods

    QgsVectorLayer( QgsVectorLayer const & rhs );

    QgsVectorLayer & operator=( QgsVectorLayer const & rhs );

    bool setDataProvider( QString const & provider );

    void drawFeature( QgsRenderContext &renderContext,
                      QgsFeature& fet,
                      QImage* marker );

    void transformPoint( double& x, double& y,
                         const QgsMapToPixel* mtp, const QgsCoordinateTransform* ct );

    void transformPoints( std::vector<double>& x, std::vector<double>& y, std::vector<double>& z, QgsRenderContext &renderContext );

    unsigned char *drawLineString( unsigned char *WKBlinestring, QgsRenderContext &renderContext );

    unsigned char *drawPolygon( unsigned char *WKBpolygon, QgsRenderContext &renderContext );

    QgsFeatureId findFreeId();

    void deleteCachedGeometries();

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

    int boundingBoxFromPointList( const QList<QgsPoint>& list, double& xmin, double& ymin, double& xmax, double& ymax ) const;

    static QgsVectorLayer::VertexMarkerType currentVertexMarkerType();

    static int currentVertexMarkerSize();

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

    void addJoinedFeatureAttributes( QgsFeature& f, const QgsVectorJoinInfo& joinInfo, const QString& joinFieldName, const QVariant& joinValue,
                                     const QgsAttributeList& attributes, int attributeIndexOffset );

    void updateFeatureGeometry( QgsFeature &f );

    void editGeometryChange( QgsFeatureId featureId, QgsGeometry& geometry );

    void editFeatureAdd( QgsFeature& feature );

    void editFeatureDelete( QgsFeatureId featureId );

    void editAttributeChange( QgsFeatureId featureId, int field, QVariant value );

    void stopRendererV2( QgsRenderContext& rendererContext, QgsSingleSymbolRendererV2* selRenderer );

    void updateAttributeMapIndex( QgsAttributeMap& map, int oldIndex, int newIndex ) const;

    void prepareLabelingAndDiagrams( QgsRenderContext& rendererContext, QgsAttributeList& attributes, bool& labeling );

  private:                       // Private attributes

    int mUpdateThreshold;

    QgsVectorDataProvider *mDataProvider;

    QString mDisplayField;

    QString mProviderKey;

    QgsAttributeAction* mActions;

    bool mEditable;

    bool mReadOnly;

    bool mModified;

    QgsGeometryMap mCachedGeometries;

    QgsRectangle mCachedGeometriesRect;

    QgsFeatureIds mSelectedFeatureIds;

    QgsFeatureIds mDeletedFeatureIds;

    QgsFeatureList mAddedFeatures;

    QgsChangedAttributesMap mChangedAttributeValues;

    QgsAttributeIds mDeletedAttributeIds;

    QgsAttributeIds mAddedAttributeIds;

    QgsGeometryMap mChangedGeometries;

    QgsFieldMap mUpdatedFields;

    QMap< QString, QString > mAttributeAliasMap;

    int mMaxUpdatedIndex;

    int mWkbType;

    QgsUndoCommand * mActiveCommand;

    QgsRenderer *mRenderer;

    QgsFeatureRendererV2 *mRendererV2;

    bool mUsingRendererV2;

    QgsLabel *mLabel;

    bool mLabelOn;

    QgsVectorLayer::VertexMarkerType mCurrentVertexMarkerType;

    int mCurrentVertexMarkerSize;

    bool mVertexMarkerOnlyForSelection;

    QList<QgsVectorOverlay*> mOverlays;

    QStringList mCommitErrors;

    QMap< QString, EditType > mEditTypes;
    QMap< QString, QMap<QString, QVariant> > mValueMaps;
    QMap< QString, RangeData > mRanges;
    QMap< QString, QPair<QString, QString> > mCheckedStates;
    QMap< QString, ValueRelationData > mValueRelations;

    QString mEditForm, mEditFormInit;
    //annotation form for this layer
    QString mAnnotationForm;

    bool mFetching;
    QgsRectangle mFetchRect;
    QgsAttributeList mFetchAttributes;
    QgsAttributeList mFetchProvAttributes;
    bool mFetchGeometry;

    QSet<QgsFeatureId> mFetchConsidered;
    QgsGeometryMap::iterator mFetchChangedGeomIt;
    QgsFeatureList::iterator mFetchAddedFeaturesIt;

    //stores information about joined layers
    QgsVectorLayerJoinBuffer* mJoinBuffer;

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

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

#endif

---