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 "qgsdockwidget.h"
#include "qgsmapmouseevent.h"
#include "qgsmessagebaritem.h"

#include <ui_qgsadvanceddigitizingdockwidgetbase.h>


class QgsAdvancedDigitizingCanvasItem;
class QgsMapCanvas;
class QgsMapTool;
class QgsMapToolAdvancedDigitizing;
class QgsPoint;

// tolerances for soft constraints (last values, and common angles)
// for angles, both tolerance in pixels and degrees are used for better performance
static const double SoftConstraintTolerancePixel = 15;
static const double SoftConstraintToleranceDegrees = 10;

class GUI_EXPORT QgsAdvancedDigitizingDockWidget : public QgsDockWidget, private Ui::QgsAdvancedDigitizingDockWidgetBase
{
    Q_OBJECT
    Q_FLAGS( CadCapacities )

  public:

    enum CadCapacity
    {
      AbsoluteAngle = 1, 
      RelativeAngle = 2, 
      RelativeCoordinates = 4, 
    };
    Q_DECLARE_FLAGS( CadCapacities, CadCapacity )

    
    enum AdditionalConstraint
    {
      NoConstraint,  
      Perpendicular, 
      Parallel       
    };

    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 )
            , mLockMode( NoLock )
            , mRepeatingLock( false )
            , mRelative( false )
            , mValue( 0.0 )
        {}

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

        void toggleLocked();

        void toggleRelative();

      private:
        QLineEdit* mLineEdit;
        QToolButton* mLockerButton;
        QToolButton* mRelativeButton;
        QToolButton* mRepeatingLockButton;
        LockMode mLockMode;
        bool mRepeatingLock;
        bool mRelative;
        double mValue;
    };

    static bool lineCircleIntersection( const QgsPoint& center, const double radius, const QList<QgsPoint>& segment, QgsPoint& intersection );

    explicit QgsAdvancedDigitizingDockWidget( QgsMapCanvas* canvas, QWidget *parent = nullptr );

    void hideEvent( QHideEvent* ) override;

    bool canvasPressEvent( QgsMapMouseEvent* e );
    bool canvasReleaseEvent( QgsMapMouseEvent* e , bool captureSegment );
    bool canvasMoveEvent( QgsMapMouseEvent* e );
    bool canvasKeyPressEventFilter( QKeyEvent *e );

    virtual bool applyConstraints( QgsMapMouseEvent* e );

    void clear();

    QgsMapMouseEvent::SnappingMode snappingMode() { return mSnappingMode; }

    void keyPressEvent( QKeyEvent* e ) override;

    bool cadEnabled() const { return mCadEnabled; }

    bool constructionMode() const { return mConstructionMode; }

    AdditionalConstraint additionalConstraint() const  { return mAdditionalConstraint; }
    const CadConstraint* constraintAngle() const  { return mAngleConstraint.data(); }
    const CadConstraint* constraintDistance() const { return mDistanceConstraint.data(); }
    const CadConstraint* constraintX() const { return mXConstraint.data(); }
    const CadConstraint* constraintY() const { return mYConstraint.data(); }
    bool commonAngleConstraint() const { return mCommonAngleConstraint; }

    QgsPoint currentPoint( bool* exists  = nullptr ) const;

    QgsPoint previousPoint( bool* exists = nullptr ) const;

    QgsPoint penultimatePoint( bool* exists = nullptr ) const;

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

    inline bool snappedToVertex() const { return mSnappedToVertex; }

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

    QAction* enableAction() { return mEnableAction; }

    void enable();

    void disable();

  signals:
    void pushWarning( const QString& message );

    void popWarning();

    void pointChanged( const QgsPoint& point );

  private slots:
    void addtionalConstraintClicked( bool activated );

    void lockConstraint( bool activate = true );

    void constraintTextEdited( const QString& textValue );

    void constraintFocusOut();

    void releaseLocks( bool releaseRepeatingLocks = true );

    void setConstraintRelative( bool activate );

    void setConstraintRepeatingLock( bool activate );

    void activateCad( bool enabled );

    void setConstructionMode( bool enabled );

    void settingsButtonTriggered( QAction* action );

  private:
    void setCadEnabled( bool enabled );

    void updateCapacity( bool updateUIwithoutChange = false );

    void lockAdditionalConstraint( AdditionalConstraint constraint );

    QList<QgsPoint> snapSegment( const QgsPointLocator::Match& snapMatch );

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

    void addPoint( const QgsPoint& point );
    void updateCurrentPoint( const QgsPoint& point );
    void removePreviousPoint();
    void clearPoints();

    bool filterKeyPress( QKeyEvent* e );

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

    void triggerMouseMoveEvent();

    CadConstraint* objectToConstraint( const QObject* obj ) const;

    double parseUserInput( const QString& inputValue, bool& ok ) const;

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

    QgsMapCanvas* mMapCanvas;
    QgsAdvancedDigitizingCanvasItem* mCadPaintItem;

    CadCapacities mCapacities;

    bool mCurrentMapToolSupportsCad;

    // CAD properties
    bool mCadEnabled;
    bool mConstructionMode;
    QgsMapMouseEvent::SnappingMode mSnappingMode;

    // constraints
    QScopedPointer< CadConstraint > mAngleConstraint;
    QScopedPointer< CadConstraint > mDistanceConstraint;
    QScopedPointer< CadConstraint > mXConstraint;
    QScopedPointer< CadConstraint > mYConstraint;
    AdditionalConstraint mAdditionalConstraint;
    int mCommonAngleConstraint; // if 0: do not snap to common angles

    // point list and current snap point / segment
    QList<QgsPoint> mCadPointList;
    QList<QgsPoint> mSnappedSegment;
    bool mSnappedToVertex;

    bool mSessionActive;

    // error message
    QScopedPointer<QgsMessageBarItem> mErrorMessage;

    // UI
    QAction* mEnableAction;
    QMap< QAction*, int > mCommonAngleActions; // map the common angle actions with their angle values
    QMap< QAction*, QgsMapMouseEvent::SnappingMode > mSnappingActions; // map the snapping mode actions with their values

};

Q_DECLARE_OPERATORS_FOR_FLAGS( QgsAdvancedDigitizingDockWidget::CadCapacities )

#endif // QGSADVANCEDDIGITIZINGDOCK_H