qgsadvanceddigitizingdockwidget.h

Go to the documentation of this file.

/***************************************************************************
    qgsadvanceddigitizingdockwidget.h  -  dock for CAD tools
    ----------------------
    begin                : October 2014
    copyright            : (C) Denis Rouzaud
    email                : [email protected]
 ***************************************************************************
 *                                                                         *
 *   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 QGSADVANCEDDIGITIZINGDOCK
#define QGSADVANCEDDIGITIZINGDOCK
 
#include "ui_qgsadvanceddigitizingdockwidgetbase.h"
 
#include <memory>
 
#include "qgis_gui.h"
#include "qgis_sip.h"
#include "qgsadvanceddigitizingtools.h"
#include "qgsdockwidget.h"
#include "qgsmessagebaritem.h"
#include "qgspointlocator.h"
#include "qgspointxy.h"
#include "qgssnapindicator.h"
 
#include <QList>
#include <QQueue>
 
class QgsAdvancedDigitizingCanvasItem;
class QgsAdvancedDigitizingFloater;
class QgsAdvancedDigitizingTool;
class QgsMapCanvas;
class QgsMapTool;
class QgsMapToolAdvancedDigitizing;
class QgsMapMouseEvent;
class QgsUserInputWidget;

class GUI_EXPORT QgsAdvancedDigitizingDockWidget : public QgsDockWidget, private Ui::QgsAdvancedDigitizingDockWidgetBase
{
    Q_OBJECT
 
  public:
    enum CadCapacity SIP_ENUM_BASETYPE( IntFlag )
    {
      AbsoluteAngle = 1,       
      RelativeAngle = 2,       
      RelativeCoordinates = 4, 
      Distance = 8,            
    };
    Q_DECLARE_FLAGS( CadCapacities, CadCapacity )
    Q_FLAG( CadCapacities )
 
    
    enum WidgetSetMode
    {
      ReturnPressed,
      FocusOut,
      TextEdited
    };
 

    class GUI_EXPORT CadConstraint
    {
      public:
        enum LockMode
        {
          NoLock,
          SoftLock,
          HardLock
        };

        CadConstraint( QLineEdit *lineEdit, QToolButton *lockerButton, QToolButton *relativeButton = nullptr, QToolButton *repeatingLockButton = nullptr )
          : mLineEdit( lineEdit )
          , mLockerButton( lockerButton )
          , mRelativeButton( relativeButton )
          , mRepeatingLockButton( repeatingLockButton )
        {}

        LockMode lockMode() const { return mLockMode; }

        bool isLocked() const { return mLockMode != NoLock; }

        bool isRepeatingLock() const { return mRepeatingLock; }

        bool relative() const { return mRelative; }

        double value() const { return mValue; }

        QLineEdit *lineEdit() const { return mLineEdit; }

        void setLockMode( LockMode mode );

        void setRepeatingLock( bool repeating );

        void setRelative( bool relative );

        void setValue( double value, bool updateWidget = true );

        QString displayValue() const;

        void toggleLocked();

        void toggleRelative();

        int precision() const { return mPrecision; }

        void setPrecision( int precision );

        Qgis::CadConstraintType cadConstraintType() const;

        void setCadConstraintType( Qgis::CadConstraintType constraintType );

        void setMapCanvas( QgsMapCanvas *mapCanvas );

        static QString removeSuffix( const QString &text, Qgis::CadConstraintType constraintType );
 
 
      private:
        QLineEdit *mLineEdit = nullptr;
        QToolButton *mLockerButton = nullptr;
        QToolButton *mRelativeButton = nullptr;
        QToolButton *mRepeatingLockButton = nullptr;
        LockMode mLockMode = NoLock;
        bool mRepeatingLock = false;
        bool mRelative = false;
        double mValue = 0.0;
        int mPrecision = 6;
        Qgis::CadConstraintType mCadConstraintType = Qgis::CadConstraintType::Generic;
        QgsMapCanvas *mMapCanvas = nullptr;
    };

    explicit QgsAdvancedDigitizingDockWidget( QgsMapCanvas *canvas, QWidget *parent = nullptr, QgsUserInputWidget *userInputWidget = nullptr );
    ~QgsAdvancedDigitizingDockWidget() override;

    bool canvasKeyPressEventFilter( QKeyEvent *e );

    bool applyConstraints( QgsMapMouseEvent *e );

    bool alignToSegment( QgsMapMouseEvent *e, QgsAdvancedDigitizingDockWidget::CadConstraint::LockMode lockMode = QgsAdvancedDigitizingDockWidget::CadConstraint::HardLock );

    void processCanvasPressEvent( QgsMapMouseEvent *event );

    void processCanvasMoveEvent( QgsMapMouseEvent *event );

    void processCanvasReleaseEvent( QgsMapMouseEvent *event );

    void setTool( QgsAdvancedDigitizingTool *tool );

    QgsAdvancedDigitizingTool *tool() const;

    void releaseLocks( bool releaseRepeatingLocks = true );

    void clear();
 
    void keyPressEvent( QKeyEvent *e ) override;

    bool cadEnabled() const { return mCadEnabled; }

    void switchZM();

    void setEnabledZ( bool enable );

    void setEnabledM( bool enable );

    bool constructionMode() const { return mConstructionMode; }

    QgsVectorLayer *constructionGuidesLayer() const { return mConstructionGuidesLayer.get(); }

    bool showConstructionGuides() const;

    bool snapToConstructionGuides() const;

    bool recordConstructionGuides() const;

    Qgis::BetweenLineConstraint betweenLineConstraint() const { return mBetweenLineConstraint; }
    const CadConstraint *constraintAngle() const { return mAngleConstraint.get(); }
    const CadConstraint *constraintDistance() const { return mDistanceConstraint.get(); }
    const CadConstraint *constraintX() const { return mXConstraint.get(); }
    const CadConstraint *constraintY() const { return mYConstraint.get(); }

    const CadConstraint *constraintZ() const { return mZConstraint.get(); }

    const CadConstraint *constraintM() const { return mMConstraint.get(); }
    bool commonAngleConstraint() const { return !qgsDoubleNear( mCommonAngleConstraint, 0.0 ); }

    const CadConstraint *constraintLineExtension() const { return mLineExtensionConstraint.get(); }

    Qgis::LineExtensionSide lineExtensionSide() const { return mSoftLockLineExtension; }

    const CadConstraint *constraintXyVertex() const { return mXyVertexConstraint.get(); }

    double softLockX() const { return mSoftLockX; }

    double softLockY() const { return mSoftLockY; }

    void toggleConstraintDistance();

    QgsPointLocator::Match mapPointMatch() const { return mSnapMatch; }

    QList<QgsPointLocator::Match> lockedSnapVertices() const { return mLockedSnapVertices; }

    void clearLockedSnapVertices( bool force = true );

    void clearPoints();

    void addPoint( const QgsPointXY &point );

    void removePreviousPoint();

    void updateCurrentPoint( const QgsPoint &point );

    void setPoints( const QList<QgsPointXY> &points );

    QgsPoint currentPointV2( bool *exists = nullptr ) const;

    QgsPoint currentPointLayerCoordinates( QgsMapLayer *layer ) const;

    Q_DECL_DEPRECATED QgsPointXY currentPoint( bool *exists = nullptr ) const SIP_DEPRECATED { return currentPointV2( exists ); };

    QgsPoint previousPointV2( bool *exists = nullptr ) const;

    Q_DECL_DEPRECATED QgsPointXY previousPoint( bool *exists = nullptr ) const SIP_DEPRECATED { return previousPointV2( exists ); };

    QgsPoint penultimatePointV2( bool *exists = nullptr ) const;

    Q_DECL_DEPRECATED QgsPointXY penultimatePoint( bool *exists = nullptr ) const SIP_DEPRECATED { return penultimatePointV2( exists ); };

    inline int pointsCount() const { return mCadPointList.count(); }

    inline bool snappedToVertex() const { return ( mSnapMatch.isValid() && ( mSnapMatch.hasVertex() || mSnapMatch.hasLineEndpoint() ) ); }

    QList<QgsPointXY> snappedSegment() const { return mSnappedSegment; }

    QAction *enableAction() { return mEnableAction; }

    void enable();

    void disable();

    void updateCadPaintItem();

    void setX( const QString &value, WidgetSetMode mode );

    void setY( const QString &value, WidgetSetMode mode );

    void setZ( const QString &value, WidgetSetMode mode );

    void setM( const QString &value, WidgetSetMode mode );

    void setAngle( const QString &value, WidgetSetMode mode );

    void setDistance( const QString &value, WidgetSetMode mode );

    double getLineZ() const;

    double getLineM() const;

    CadCapacities capacities() const { return mCapacities; };

    QString formatCommonAngleSnapping( double angle );
 
  signals:

    void pushWarning( const QString &message );

    void popWarning();

    void pointChangedV2( const QgsPoint &point );

    Q_DECL_DEPRECATED void pointChanged( const QgsPointXY &point ) SIP_DEPRECATED;


    void cadEnabledChanged( bool enabled );

    void valueXChanged( const QString &value );

    void valueYChanged( const QString &value );

    void valueZChanged( const QString &value );

    void valueMChanged( const QString &value );

    void valueAngleChanged( const QString &value );

    void valueDistanceChanged( const QString &value );

    void valueBearingChanged( const QString &value );

    void lockXChanged( bool locked );

    void lockYChanged( bool locked );

    void lockZChanged( bool locked );

    void lockMChanged( bool locked );

    void lockAngleChanged( bool locked );

    void lockDistanceChanged( bool locked );

    void relativeXChanged( bool relative );

    void relativeYChanged( bool relative );

    void relativeZChanged( bool relative );

    void relativeMChanged( bool relative );

    void relativeAngleChanged( bool relative );

    void softLockLineExtensionChanged( bool locked );

    void softLockXyChanged( bool locked );
 
    // relativeDistanceChanged doesn't exist as distance is always relative

    void enabledChangedX( bool enabled );

    void enabledChangedY( bool enabled );

    void enabledChangedZ( bool enabled );

    void enabledChangedM( bool enabled );

    void enabledChangedAngle( bool enabled );

    void enabledChangedDistance( bool enabled );

    void focusOnXRequested();

    void focusOnYRequested();

    void focusOnZRequested();

    void focusOnMRequested();

    void focusOnAngleRequested();

    void focusOnDistanceRequested();

    void valueCommonAngleSnappingChanged( double angle );

    void commonAngleSnappingShowInFloaterChanged( bool enabled ) SIP_SKIP;
 
  private slots:
    void betweenLineConstraintClicked( bool activated );

    void lockConstraint( bool activate = true );

    void lockParameterlessConstraint( bool activate = true );

    void constraintTextEdited( const QString &textValue );

    void constraintFocusOut();

    void setConstraintRelative( bool activate );

    void setConstraintRepeatingLock( bool activate );

    void activateCad( bool enabled );

    void setConstructionMode( bool enabled );

    void settingsButtonTriggered( QAction *action );
 
  private:
    QgsMapLayer *targetLayer() const;

    void setCadEnabled( bool enabled );

    void updateCapacity( bool updateUIwithoutChange = false );

    void lockBetweenLineConstraint( Qgis::BetweenLineConstraint constraint );

    QList<QgsPointXY> snapSegmentToAllLayers( const QgsPointXY &originalMapPoint, bool *snapped = nullptr ) const;

    bool filterKeyPress( QKeyEvent *e );

    bool eventFilter( QObject *obj, QEvent *event ) override SIP_SKIP;

    void triggerMouseMoveEvent();

    CadConstraint *objectToConstraint( const QObject *obj ) const;

    double parseUserInput( const QString &inputValue, const Qgis::CadConstraintType type, bool &ok ) const;

    void updateConstraintValue( CadConstraint *constraint, const QString &textValue, bool convertExpression = false );

    void updateUnlockedConstraintValues( const QgsPoint &point );

    void toggleLockedSnapVertex( const QgsPointLocator::Match &snapMatch, const QgsPointLocator::Match &previouslySnap );

    void resetConstructionGuides();

    void updateConstructionGuidesCrs();
 
    QgsMapCanvas *mMapCanvas = nullptr;
    QgsUserInputWidget *mUserInputWidget = nullptr;
 
    QgsAdvancedDigitizingCanvasItem *mCadPaintItem = nullptr;
    std::unique_ptr<QgsSnapIndicator> mSnapIndicator;
 
    CadCapacities mCapacities = CadCapacities();
 
    bool mCurrentMapToolSupportsCad = false;
 
    // Pointer to the floater
    QgsAdvancedDigitizingFloater *mFloater = nullptr;
 
    // CAD properties
    bool mCadEnabled = false;
    bool mConstructionMode = false;
 
    // constraints
    std::unique_ptr<CadConstraint> mAngleConstraint;
    std::unique_ptr<CadConstraint> mDistanceConstraint;
    std::unique_ptr<CadConstraint> mXConstraint;
    std::unique_ptr<CadConstraint> mYConstraint;
    std::unique_ptr<CadConstraint> mZConstraint;
    std::unique_ptr<CadConstraint> mMConstraint;
    std::unique_ptr<CadConstraint> mLineExtensionConstraint;
    std::unique_ptr<CadConstraint> mXyVertexConstraint;
    Qgis::BetweenLineConstraint mBetweenLineConstraint;
    double mCommonAngleConstraint; // if 0: do not snap to common angles

    bool mSnappingPrioritizeFeatures = false;
 
    // Point list and current snap point / segment
    QList<QgsPoint> mCadPointList;
    QList<QgsPointXY> mSnappedSegment;
 
    bool mSessionActive = false;
 
    // Construction path history
    std::unique_ptr<QgsVectorLayer> mConstructionGuidesLayer;
    QgsFeatureId mConstructionGuideId;
    QgsLineString mConstructionGuideLine;
    bool mDeferredUpdateConstructionGuidesCrs = false;
 
    // Error message
    std::unique_ptr<QgsMessageBarItem> mErrorMessage;
 
    // UI
    QMap<double, QAction *> mCommonAngleActions; // map the common angle actions with their angle values
    QAction *mLineExtensionAction = nullptr;
    QAction *mXyVertexAction = nullptr;
    QAction *mRecordConstructionGuides = nullptr;
    QAction *mShowConstructionGuides = nullptr;
    QAction *mSnapToConstructionGuides = nullptr;
    QAction *mClearConstructionGuides = nullptr;
 
    // Snap indicator
    QgsPointLocator::Match mSnapMatch;
    QgsPointLocator::Match mLastSnapMatch;
 
    // Extra constraint context
    Qgis::LineExtensionSide mSoftLockLineExtension;
    double mSoftLockX;
    double mSoftLockY;
    QQueue<QgsPointLocator::Match> mLockedSnapVertices;
 
    // Advanced digitizing tool
    QPointer<QgsAdvancedDigitizingTool> mCurrentTool;
 
#ifdef SIP_RUN
    bool eventFilter( QObject *obj, QEvent *event );
#endif
    QgsPoint pointXYToPoint( const QgsPointXY &point ) const;
 
    QMenu *mCommonAngleActionsMenu = nullptr;
    QMenu *mFloaterActionsMenu = nullptr;
 
    /* Store whether the target layer supports Z and M, to avoid unnecessary checks
     * when floater settings are changed */
    bool mTargetLayerSupportsZ = false;
    bool mTargetLayerSupportsM = false;
 
    static const QgsSettingsEntryBool *settingsCadSnappingPriorityPrioritizeFeature;
    static const QgsSettingsEntryBool *settingsCadRecordConstructionGuides;
    static const QgsSettingsEntryBool *settingsCadShowConstructionGuides;
    static const QgsSettingsEntryBool *settingsCadSnapToConstructionGuides;
 
    friend class TestQgsAdvancedDigitizing;
    friend class TestQgsAdvancedDigitizingDockWidget;
};
 
Q_DECLARE_OPERATORS_FOR_FLAGS( QgsAdvancedDigitizingDockWidget::CadCapacities )
 
#endif // QGSADVANCEDDIGITIZINGDOCK_H