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 <QList>
 
#include <memory>
 
#include "ui_qgsadvanceddigitizingdockwidgetbase.h"
#include "qgsadvanceddigitizingfloater.h"
#include "qgis_gui.h"
#include "qgis_sip.h"
#include "qgsdockwidget.h"
#include "qgsmessagebaritem.h"
#include "qgspointxy.h"
#include "qgspointlocator.h"
#include "qgssnapindicator.h"
 
 
class QgsAdvancedDigitizingCanvasItem;
class QgsAdvancedDigitizingFloater;
class QgsMapCanvas;
class QgsMapTool;
class QgsMapToolAdvancedDigitizing;
class QgsMapMouseEvent;
 
class GUI_EXPORT QgsAdvancedDigitizingDockWidget : public QgsDockWidget, private Ui::QgsAdvancedDigitizingDockWidgetBase
{
    Q_OBJECT
 
  public:
 
    enum CadCapacity
    {
      AbsoluteAngle = 1, 
      RelativeAngle = 2, 
      RelativeCoordinates = 4, 
    };
    Q_DECLARE_FLAGS( CadCapacities, CadCapacity )
    Q_FLAG( CadCapacities )
 
    
    enum class AdditionalConstraint SIP_MONKEYPATCH_SCOPEENUM : int
    {
      NoConstraint,  
      Perpendicular, 
      Parallel       
    };
 
    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 )
          , 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 = nullptr;
        QToolButton *mLockerButton = nullptr;
        QToolButton *mRelativeButton = nullptr;
        QToolButton *mRepeatingLockButton = nullptr;
        LockMode mLockMode;
        bool mRepeatingLock;
        bool mRelative;
        double mValue;
    };
 
    explicit QgsAdvancedDigitizingDockWidget( QgsMapCanvas *canvas, QWidget *parent = nullptr );
 
    bool canvasKeyPressEventFilter( QKeyEvent *e );
 
    bool applyConstraints( QgsMapMouseEvent *e );
 
    bool alignToSegment( QgsMapMouseEvent *e, QgsAdvancedDigitizingDockWidget::CadConstraint::LockMode lockMode = QgsAdvancedDigitizingDockWidget::CadConstraint::HardLock );
 
    void releaseLocks( bool releaseRepeatingLocks = true );
 
    void clear();
 
    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.get(); }
    const CadConstraint *constraintDistance() const { return mDistanceConstraint.get(); }
    const CadConstraint *constraintX() const { return mXConstraint.get(); }
    const CadConstraint *constraintY() const { return mYConstraint.get(); }
    bool commonAngleConstraint() const { return !qgsDoubleNear( mCommonAngleConstraint, 0.0 ); }
 
    QgsPointLocator::Match mapPointMatch() const { return mSnapMatch; }
 
    void clearPoints();
 
    void addPoint( const QgsPointXY &point );
 
    void removePreviousPoint();
 
    void setPoints( const QList<QgsPointXY> &points );
 
    QgsPointXY currentPoint( bool *exists  = nullptr ) const;
 
    QgsPointXY previousPoint( bool *exists = nullptr ) const;
 
    QgsPointXY penultimatePoint( bool *exists = nullptr ) const;
 
    inline int pointsCount() const { return mCadPointList.count(); }
 
    inline bool snappedToVertex() const { return ( mSnapMatch.isValid() && mSnapMatch.hasVertex() ); }
 
    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 setAngle( const QString &value, WidgetSetMode mode );
 
    void setDistance( const QString &value, WidgetSetMode mode );
 
 
 
  signals:
 
    void pushWarning( const QString &message );
 
    void popWarning();
 
    void pointChanged( const QgsPointXY &point );
 
 
    void cadEnabledChanged( bool enabled );
 
    void valueXChanged( const QString &value );
 
    void valueYChanged( const QString &value );
 
    void valueAngleChanged( const QString &value );
 
    void valueDistanceChanged( const QString &value );
 
    void lockXChanged( bool locked );
 
    void lockYChanged( bool locked );
 
    void lockAngleChanged( bool locked );
 
    void lockDistanceChanged( bool locked );
 
    void relativeXChanged( bool relative );
 
    void relativeYChanged( bool relative );
 
    void relativeAngleChanged( bool relative );
 
    // relativeDistanceChanged doesn't exist as distance is always relative
 
    void enabledChangedX( bool enabled );
 
    void enabledChangedY( bool enabled );
 
    void enabledChangedAngle( bool enabled );
 
    void enabledChangedDistance( bool enabled );
 
    void focusOnXRequested();
 
    void focusOnYRequested();
 
    void focusOnAngleRequested();
 
    void focusOnDistanceRequested();
 
 
  private slots:
    void additionalConstraintClicked( bool activated );
 
    void lockConstraint( 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:
    void setCadEnabled( bool enabled );
 
    void updateCapacity( bool updateUIwithoutChange = false );
 
    void lockAdditionalConstraint( AdditionalConstraint constraint );
 
    QList<QgsPointXY> snapSegmentToAllLayers( const QgsPointXY &originalMapPoint, bool *snapped = nullptr ) const;
 
    void updateCurrentPoint( const QgsPointXY &point );
 
 
    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, bool &ok ) const;
 
    void updateConstraintValue( CadConstraint *constraint, const QString &textValue, bool convertExpression = false );
 
    void updateUnlockedConstraintValues( const QgsPointXY &point );
 
    QgsMapCanvas *mMapCanvas = 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;
    AdditionalConstraint mAdditionalConstraint;
    double mCommonAngleConstraint; // if 0: do not snap to common angles
 
    // point list and current snap point / segment
    QList<QgsPointXY> mCadPointList;
    QList<QgsPointXY> mSnappedSegment;
 
    bool mSessionActive = false;
 
    // error message
    std::unique_ptr<QgsMessageBarItem> mErrorMessage;
 
    // UI
    QMap< QAction *, double > mCommonAngleActions; // map the common angle actions with their angle values
 
    // Snap indicator
 
    QgsPointLocator::Match mSnapMatch;
  private:
#ifdef SIP_RUN
    bool eventFilter( QObject *obj, QEvent *event );
#endif
};
 
Q_DECLARE_OPERATORS_FOR_FLAGS( QgsAdvancedDigitizingDockWidget::CadCapacities )
 
#endif // QGSADVANCEDDIGITIZINGDOCK_H