qgsmaptoolcapture.h

Go to the documentation of this file.

/***************************************************************************
    qgsmaptoolcapture.h  -  map tool for capturing points, lines, polygons
    ---------------------
    begin                : January 2006
    copyright            : (C) 2006 by Martin Dobias
    email                : wonder.sk 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 QGSMAPTOOLCAPTURE_H
#define QGSMAPTOOLCAPTURE_H
 
 
#include "qgsmaptooladvanceddigitizing.h"
#include "qgspointlocator.h"
#include "qgscompoundcurve.h"
#include "qgsgeometry.h"
#include "qobjectuniqueptr.h"
#include "qgssnappingutils.h"
#include "qgsgeometryrubberband.h"
 
#include <QPoint>
#include <QList>
#include "qgis_gui.h"
 
class QgsRubberBand;
class QgsSnapIndicator;
class QgsVertexMarker;
class QgsMapLayer;
class QgsGeometryValidator;
class QgsMapToolCaptureRubberBand;
 
 
#ifndef SIP_RUN
 
 
class QgsMapToolCaptureRubberBand: public QgsGeometryRubberBand
{
  public:
    QgsMapToolCaptureRubberBand( QgsMapCanvas *mapCanvas, QgsWkbTypes::GeometryType geomType = QgsWkbTypes::LineGeometry );
 
    QgsCurve *curve();
 
    bool curveIsComplete() const;
 
    void reset( QgsWkbTypes::GeometryType geomType = QgsWkbTypes::LineGeometry, QgsWkbTypes::Type stringType = QgsWkbTypes::LineString, const QgsPoint &firstPolygonPoint = QgsPoint() );
 
    void setRubberBandGeometryType( QgsWkbTypes::GeometryType geomType );
 
    void addPoint( const QgsPoint &point, bool doUpdate = true );
 
    void movePoint( const QgsPoint &point );
 
    void movePoint( int index, const QgsPoint &point );
 
    int pointsCount();
 
    QgsWkbTypes::Type stringType() const;
 
    void setStringType( const QgsWkbTypes::Type &type );
 
    QgsPoint lastPoint() const;
 
    QgsPoint pointFromEnd( int posFromEnd ) const;
 
    void removeLastPoint();
 
  private:
    QgsWkbTypes::Type mStringType = QgsWkbTypes::LineString;
 
    void setGeometry( QgsAbstractGeometry *geom ) override;
    void updateCurve();
 
    QgsCurve *createLinearString();
    QgsCurve *createCircularString();
 
    QgsPointSequence mPoints;
    QgsPoint mFirstPolygonPoint;
};
 
 
#endif //SIP_RUN
 
class GUI_EXPORT QgsMapToolCapture : public QgsMapToolAdvancedDigitizing
{
    Q_OBJECT
 
  public:
 
    enum CaptureMode
    {
      CaptureNone,    
      CapturePoint,   
      CaptureLine,    
      CapturePolygon  
    };
 
    enum CaptureTechnique
    {
      StraightSegments, 
      CircularString, 
      Streaming, 
    };
 
    enum Capability
    {
      NoCapabilities = 1 << 0, 
      SupportsCurves = 1 << 1, 
      ValidateGeometries = 1 << 2, 
    };
 
    Q_DECLARE_FLAGS( Capabilities, Capability )
 
    
    QgsMapToolCapture( QgsMapCanvas *canvas, QgsAdvancedDigitizingDockWidget *cadDockWidget, CaptureMode mode );
 
    ~QgsMapToolCapture() override;
 
    virtual QgsMapToolCapture::Capabilities capabilities() const;
 
    virtual bool supportsTechnique( CaptureTechnique technique ) const;
 
    void activate() override;
    void deactivate() override;
 
    CaptureMode mode() const { return mCaptureMode; }
 
    int addCurve( QgsCurve *c );
 
    void clearCurve( );
 
    const QgsCompoundCurve *captureCurve() const { return &mCaptureCurve; }
 
    QList<QgsPointLocator::Match> snappingMatches() const;
 
    void cadCanvasMoveEvent( QgsMapMouseEvent *e ) override;
 
    void keyPressEvent( QKeyEvent *e ) override;
 
    void deleteTempRubberBand();
 
    void clean() override;
 
    QgsRubberBand *takeRubberBand() SIP_FACTORY;
 
  public slots:
    void setCircularDigitizingEnabled( bool enable );
 
    void setStreamDigitizingEnabled( bool enable );
 
  private slots:
    void addError( const QgsGeometry::Error &error );
    void currentLayerChanged( QgsMapLayer *layer );
    void updateExtraSnapLayer();
 
  protected:
 
    // TODO QGIS 4.0 returns an enum instead of a magic constant
 
    int nextPoint( const QgsPoint &mapPoint, QgsPoint &layerPoint );
 
    // TODO QGIS 4.0 returns an enum instead of a magic constant
 
    int nextPoint( QPoint p, QgsPoint &layerPoint, QgsPoint &mapPoint );
 
    // TODO QGIS 4.0 returns an enum instead of a magic constant
 
    int fetchLayerPoint( const QgsPointLocator::Match &match, QgsPoint &layerPoint );
 
    QgsPoint mapPoint( const QgsMapMouseEvent &e ) const;
 
    QgsPoint mapPoint( const QgsPointXY &point ) const;
 
    // TODO QGIS 4.0 returns an enum instead of a magic constant
 
    int addVertex( const QgsPointXY &point );
 
    int addVertex( const QgsPointXY &mapPoint, const QgsPointLocator::Match &match );
 
    void undo( bool isAutoRepeat = false );
 
    void startCapturing();
 
    bool isCapturing() const;
 
    int size();
 
    Q_DECL_DEPRECATED QVector<QgsPointXY> points() const SIP_DEPRECATED;
 
    // TODO QGIS 4.0 rename it to points()
 
    QgsPointSequence pointsZM() const;
 
    Q_DECL_DEPRECATED void setPoints( const QVector<QgsPointXY> &pointList ) SIP_DEPRECATED;
 
    void setPoints( const QgsPointSequence &pointList );
 
    void closePolygon();
 
  protected slots:
 
    void stopCapturing();
 
  private:
    bool tracingEnabled();
    QgsPointXY tracingStartPoint();
    bool tracingMouseMove( QgsMapMouseEvent *e );
    bool tracingAddVertex( const QgsPointXY &point );
 
    QgsMapToolCaptureRubberBand *createCurveRubberBand() const;
 
    QgsPoint firstCapturedMapPoint();
    QgsPoint lastCapturedMapPoint();
 
    void resetRubberBand();
 
  private:
    CaptureMode mCaptureMode;
 
 
 
    bool mCapturing = false;
 
    QgsPoint mCaptureFirstPoint;
    QgsPoint mCaptureLastPoint;
 
    QObjectUniquePtr<QgsRubberBand> mRubberBand;
 
    std::unique_ptr<QgsMapToolCaptureRubberBand> mTempRubberBand;
 
    QgsCompoundCurve mCaptureCurve;
 
    QList<QgsPointLocator::Match> mSnappingMatches;
    QgsPointLocator::Match mCircularIntermediateMatch;
    QgsPoint mCircularItermediatePoint;
 
    void validateGeometry();
    QgsGeometryValidator *mValidator = nullptr;
    QList< QgsGeometry::Error > mGeomErrors;
    QList< QgsVertexMarker * > mGeomErrorMarkers;
 
    QgsVectorLayer *mExtraSnapLayer = nullptr;
    QgsFeatureId mExtraSnapFeatureId;
 
    bool mCaptureModeFromLayer = false;
 
    std::unique_ptr<QgsSnapIndicator> mSnapIndicator;
 
    QgsPointXY mTracingStartPoint;
 
    QgsWkbTypes::Type mDigitizingType = QgsWkbTypes::LineString;
 
    bool mStreamingEnabled = false;
    bool mAllowAddingStreamingPoints = false;
    int mStreamingToleranceInPixels = 1;
 
    bool mStartNewCurve = false;
 
    bool mIgnoreSubsequentAutoRepeatUndo = false;
 
    friend class TestQgsMapToolCapture;
 
};
 
Q_DECLARE_OPERATORS_FOR_FLAGS( QgsMapToolCapture::Capabilities )
 
#endif