QGIS/python/gui/qgsadvanceddigitizingdockwidget.sip

/***************************************************************************
    qgsadvanceddigitizingdockwidget.sip  -  dock for CAD tools
    ----------------------
    begin                : October 2014
    copyright            : (C) Denis Rouzaud
    email                : denis.rouzaud@gmail.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.                                   *
 *                                                                         *
 ***************************************************************************/


/**
 * @brief The QgsAdvancedDigitizingDockWidget class is a dockable widget
 * used to handle the CAD tools on top of a selection of map tools.
 * It handles both the UI and the constraints. Constraints are applied
 * by implemeting filters called from QgsMapToolAdvancedDigitizing.
 */
class QgsAdvancedDigitizingDockWidget : QDockWidget
{
%TypeHeaderCode
#include <qgsadvanceddigitizingdockwidget.h>
%End
  public:

    /**
     * The CadCapacity enum defines the possible constraints to be set
     * depending on the number of points in the CAD point list (the list of points
     * currently digitized)
     */
    enum CadCapacity
    {
      AbsoluteAngle, //!< Azimuth
      RelativeAngle, //!< also for parallel and perpendicular
      RelativeCoordinates, //!< this corresponds to distance and relative coordinates
    };

    /**
     * Additional constraints which can be enabled
     */
    enum AdditionalConstraint
    {
      NoConstraint,  //!< No additional constraint
      Perpendicular, //!< Perpendicular
      Parallel       //!< Parallel
    };

    /**
     * Determines if the dock has to record one, two or many points.
     */
    enum AdvancedDigitizingMode
    {
      SinglePoint, //!< Capture a single point (e.g. for point digitizing)
      TwoPoints,   //!< Capture two points (e.g. for translation)
      ManyPoints   //!< Capture two or more points (e.g. line or polygon digitizing)
    };

    /**
     * @brief The CadConstraint is an abstract class for all basic constraints (angle/distance/x/y).
     * It contains all values (locked, value, relative) and pointers to corresponding widgets.
     * @note Relative is not mandatory since it is not used for distance.
     */
    class CadConstraint
    {
      public:
        /**
         * The lock mode
         */
        enum LockMode
        {
          NoLock,
          SoftLock,
          HardLock
        };

        /** Constructor for CadConstraint.
         * @param lineEdit associated line edit for constraint value
         * @param lockerButton associated button for locking constraint
         * @param relativeButton optional button for toggling relative constraint mode
         * @param repeatingLockButton optional button for toggling repeating lock mode
         */
        CadConstraint( QLineEdit* lineEdit, QToolButton* lockerButton, QToolButton* relativeButton = nullptr, QToolButton* repeatingLockButton = nullptr );

        /**
         * The current lock mode of this constraint
         * @return Lock mode
         */
        LockMode lockMode() const;
        /**
         * Is any kind of lock mode enabled
         */
        bool isLocked() const;

        /** Returns true if a repeating lock is set for the constraint. Repeating locks are not
         * automatically cleared after a new point is added.
         * @note added in QGIS 2.16
         * @see setRepeatingLock()
         */
        bool isRepeatingLock() const;

        /**
         * Is the constraint in relative mode
         */
        bool relative() const;
        /**
         * The value of the constraint
         */
        double value() const;

        /**
         * The line edit that manages the value of the constraint
         */
        QLineEdit* lineEdit() const;

        /**
         * Set the lock mode
         */
        void setLockMode( LockMode mode );

        /** Sets whether a repeating lock is set for the constraint. Repeating locks are not
         * automatically cleared after a new point is added.
         * @param repeating set to true to set the lock to repeat automatically
         * @note added in QGIS 2.16
         * @see isRepeatingLock()
         */
        void setRepeatingLock( bool repeating );

        /**
         * Set if the constraint should be treated relative
         */
        void setRelative( bool relative );

        /**
         * Set the value of the constraint
         * @param value new value for constraint
         * @param updateWidget set to false to prevent automatically updating the associated widget's value
         */
        void setValue( double value, bool updateWidget = true );

        /**
         * Toggle lock mode
         */
        void toggleLocked();

        /**
         * Toggle relative mode
         */
        void toggleRelative();
    };

    //! performs the intersection of a circle and a line
    //! @note from the two solutions, the intersection will be set to the closest point
    static bool lineCircleIntersection( const QgsPoint& center, const double radius, const QList<QgsPoint>& segment, QgsPoint& intersection );

    /**
     * Create an advanced digitizing dock widget
     * @param canvas The map canvas on which the widget operates
     * @param parent The parent
     */
    explicit QgsAdvancedDigitizingDockWidget( QgsMapCanvas* canvas, QWidget *parent = 0 );

    /**
     * Disables the CAD tools when hiding the dock
     */
    void hideEvent( QHideEvent* );

    /**
     * Will react on a canvas press event
     *
     * @param e A mouse event (may be modified)
     * @return  If the event is hidden (construction mode hides events from the maptool)
     */
    bool canvasPressEvent( QgsMapMouseEvent* e );
    /**
     * Will react on a canvas release event
     *
     * @param e A mouse event (may be modified)
     * @param mode determines if the dock has to record one, two or many points.
     * @return  If the event is hidden (construction mode hides events from the maptool)
     */
    bool canvasReleaseEvent( QgsMapMouseEvent* e, AdvancedDigitizingMode mode );
    /**
     * Will react on a canvas move event
     *
     * @param e A mouse event (may be modified)
     * @return  If the event is hidden (construction mode hides events from the maptool)
     */
    bool canvasMoveEvent( QgsMapMouseEvent* e );
    /**
     * Filter key events to e.g. toggle construction mode or adapt constraints
     *
     * @param e A mouse event (may be modified)
     * @return  If the event is hidden (construction mode hides events from the maptool)
     */
    bool canvasKeyPressEventFilter( QKeyEvent *e );

    //! apply the CAD constraints. The will modify the position of the map event in map coordinates by applying the CAD constraints.
    //! @return false if no solution was found (invalid constraints)
    virtual bool applyConstraints( QgsMapMouseEvent* e );

    /**
     * Clear any cached previous clicks and helper lines
     */
    void clear();

    /**
     * The snapping mode
     * @return Snapping mode
     */
    QgsMapMouseEvent::SnappingMode snappingMode();

    //! key press event on the dock
    void keyPressEvent( QKeyEvent* e );

    //! determines if CAD tools are enabled or if map tools behaves "nomally"
    bool cadEnabled() const;

    //! construction mode is used to draw intermediate points. These points won't be given any further (i.e. to the map tools)
    bool constructionMode() const;

    //! Additional constraints are used to place perpendicular/parallel segments to snapped segments on the canvas
    AdditionalConstraint additionalConstraint() const;
    //! Constraint on the angle
    const CadConstraint* constraintAngle()const;
    //! Constraint on the distance
    const CadConstraint* constraintDistance() const;
    //! Constraint on the X coordinate
    const CadConstraint* constraintX() const;
    //! Constraint on the Y coordinate
    const CadConstraint* constraintY() const;
    //! Constraint on a common angle
    bool commonAngleConstraint() const;

    /**
     * The last point.
     * Helper for the CAD point list. The CAD point list is the list of points
     * currently digitized. It contains both  "normal" points and intermediate points (construction mode).
     */
    QgsPoint currentPoint( bool* exists  = 0 ) const;

    /**
     * The previous point.
     * Helper for the CAD point list. The CAD point list is the list of points
     * currently digitized. It contains both  "normal" points and intermediate points (construction mode).
     */
    QgsPoint previousPoint( bool* exists = 0 ) const;

    /**
     * The penultimate point.
     * Helper for the CAD point list. The CAD point list is the list of points
     * currently digitized. It contains both  "normal" points and intermediate points (construction mode).
     */
    QgsPoint penultimatePoint( bool* exists = 0 ) const;

    /**
     * The number of points in the CAD point helper list
     */
    int pointsCount() const;

    /**
     * Is it snapped to a vertex
     */
    bool snappedToVertex() const;

    /**
     * Snapped to a segment
     */
    const QList<QgsPoint>& snappedSegment() const;

    //! return the action used to enable/disable the tools
    QAction* enableAction();

    /**
     * Enables the tool (call this when an appropriate map tool is set and in the condition to make use of
     * cad digitizing)
     * Normally done automatically from QgsMapToolAdvancedDigitizing::activate() but may need to be fine tuned
     * if the map tool depends on preconditions like a feature selection.
     */
    void enable();

    /**
     * Disable the widget. Normally done automatically from QgsMapToolAdvancedDigitizing::deactivate().
     */
    void disable();

  signals:
    /**
     * Push a warning
     *
     * @param message An informative message
     */
    void pushWarning( const QString& message );

    /**
     * Remove any previously emitted warnings (if any)
     */
    void popWarning();

    /**
     * Sometimes a constraint may change the current point out of a mouse event. This happens normally
     * when a constraint is toggled.
     *
     * @param point The last known digitizing point. Can be used to emulate a mouse event.
     */
    void pointChanged( const QgsPoint& point );

  private slots:
    //! set the additiona constraint by clicking on the perpendicular/parallel buttons
    void addtionalConstraintClicked( bool activated );

    //! lock/unlock a constraint and set its value
    void lockConstraint( bool activate = true );

    //! unlock all constraints
    //! @param releaseRepeatingLocks set to false to preserve the lock for any constraints set to repeating lock mode
    void releaseLocks( bool releaseRepeatingLocks = true );

    //! set the relative properties of constraints
    void setConstraintRelative( bool activate );

    //! activate/deactivate tools. It is called when tools are activated manually (from the GUI)
    //! it will call setCadEnabled to properly update the UI.
    void activateCad( bool enabled );

    //! enable/disable construction mode (events are not forwarded to the map tool)
    void setConstructionMode( bool enabled );

    //! settings button triggered
    void settingsButtonTriggered( QAction* action );

  private:
    bool eventFilter( QObject *obj, QEvent *event );
};