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.                                   *
 *                                                                         *
 ***************************************************************************/
/* $Id: qgsvectorlayer.h 9781 2008-12-13 11:07:45Z jef $ */

#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 "qgsfeature.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 QgsVectorDataProvider;

class QgsGeometry;
class QgsRectangle;

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

class CORE_EXPORT QgsVectorLayer : public QgsMapLayer
{
    Q_OBJECT

  public:
    enum EditType
    {
      LineEdit,
      UniqueValues,
      UniqueValuesEditable,
      ValueMap,
      Classification,
      EditRange,
      SliderRange,
      FileName
    };

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

      QVariant mMin;
      QVariant mMax;
      QVariant mStep;
    };

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

    virtual ~QgsVectorLayer();

    QString storageType() const;

    QString capabilitiesString() const;

    QString dataComment() const;

    void setDisplayField( QString fldName = 0 );

    const QString displayField() const;

    QgsVectorDataProvider* dataProvider();

    const QgsVectorDataProvider* dataProvider() const;

    void setProviderEncoding( const QString& encoding );

    void setCoordinateSystem();

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

    QGis::GeometryType geometryType() const;

    QGis::WkbType wkbType() const;

    QString providerType() const;

    virtual bool readXml( QDomNode & layer_node );

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

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

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


    virtual long featureCount() const;

    virtual long updateFeatureCount() const;

    virtual void 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( int featureId, QgsFeature &f, bool fetchGeometries = true, bool fetchAttributes = true );

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


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

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

    bool deleteVertex( int atFeatureId, int atVertex );

    bool deleteSelectedFeatures();

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

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

    int translateFeature( int 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 isModified() const;

    bool snapPoint( QgsPoint& point, double tolerance );

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

    bool draw( QgsRenderContext& rendererContext );

    void drawLabels( QgsRenderContext& rendererContext );

    const QgsFieldMap &pendingFields() const;

    QgsAttributeList pendingAllAttributesList();

    int pendingFeatureCount();

    void setModified( bool modified = TRUE, bool onlyGeometryWasModified = FALSE );

    bool startEditing();

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

    bool addAttribute( QString name, QString type );

    bool deleteAttribute( int attr );

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

    bool deleteFeature( int fid );

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

    bool rollBack();

    EditType editType( int idx );

    void setEditType( int idx, EditType edit );

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

    RangeData &range( int idx );

  public slots:
    void select( int featureId, bool emitSignal = TRUE );

    void deselect( int featureId, bool emitSignal = TRUE );

    void removeSelection( bool emitSignal = TRUE );

    void triggerRepaint();

    virtual void updateExtents();

  signals:

    void selectionChanged();

    void layerModified( bool onlyGeometry );

    void editingStarted();
    void editingStopped();
    void attributeAdded( int idx );
    void attributeDeleted( int idx );
    void featureDeleted( int fid );
    void layerDeleted();

    void attributeValueChanged( int fid, int idx, const QVariant & );

  private:                       // Private methods

    enum VertexMarkerType
    {
      SemiTransparentCircle,
      Cross
    };

    QgsVectorLayer( QgsVectorLayer const & rhs );

    QgsVectorLayer & operator=( QgsVectorLayer const & rhs );

    bool setDataProvider( QString const & provider );

    void drawFeature( QPainter* p,
                      QgsFeature& fet,
                      const QgsMapToPixel* cXf,
                      const QgsCoordinateTransform* ct,
                      QImage* marker,
                      double widthScale,
                      double markerScaleFactor,
                      bool drawingToEditingCanvas );

    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,
                          const QgsMapToPixel* mtp, const QgsCoordinateTransform* ct );

    unsigned char *drawLineString( unsigned char *WKBlinestring,
                                   QPainter *p,
                                   const QgsMapToPixel *mtp,
                                   const QgsCoordinateTransform *ct,
                                   bool drawingToEditingCanvas );

    unsigned char *drawPolygon( unsigned char *WKBpolygon,
                                QPainter *p,
                                const QgsMapToPixel *mtp,
                                const QgsCoordinateTransform *ct,
                                bool drawingToEditingCanvas );

    int findFreeId();

    void deleteCachedGeometries();

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

    void snapToGeometry( const QgsPoint& startPoint, int 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;

    QgsVectorLayer::VertexMarkerType currentVertexMarkerType();

    void updateFeatureAttributes( QgsFeature &f );

    void updateFeatureGeometry( QgsFeature &f );

  private:                       // Private attributes

    int mUpdateThreshold;

    QgsVectorDataProvider *mDataProvider;

    QString mDisplayField;

    QString mProviderKey;

    QgsAttributeAction* mActions;

    bool mEditable;

    bool mModified;

    QgsGeometryMap mCachedGeometries;

    QgsFeatureIds mSelectedFeatureIds;

    QgsFeatureIds mDeletedFeatureIds;

    QgsFeatureList mAddedFeatures;

    QgsChangedAttributesMap mChangedAttributeValues;

    QgsAttributeIds mDeletedAttributeIds;

    QgsAttributeIds mAddedAttributeIds;

    QgsGeometryMap mChangedGeometries;

    QgsFieldMap mUpdatedFields;

    int mMaxUpdatedIndex;

    int mWkbType;

    QgsRenderer *mRenderer;

    QgsLabel *mLabel;

    bool mLabelOn;

    QStringList mCommitErrors;

    QMap< QString, EditType > mEditTypes;
    QMap< QString, QMap<QString, QVariant> > mValueMaps;
    QMap< QString, RangeData > mRanges;

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

    QSet<int> mFetchConsidered;
    QgsGeometryMap::iterator mFetchChangedGeomIt;
    QgsFeatureList::iterator mFetchAddedFeaturesIt;
};

#endif

---