drawing_tool.h

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2014-2017 CERN
 * Copyright (C) 2018-2022 KiCad Developers, see AUTHORS.txt for contributors.
 *
 * @author Maciej Suminski <[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.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, you may find one here:
 * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
 * or you may search the http://www.gnu.org website for the version 2 license,
 * or you may write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
 */
 
#ifndef __DRAWING_TOOL_H
#define __DRAWING_TOOL_H
 
#include <stack>
#include <optional>
#include <tool/tool_menu.h>
#include <tools/pcb_tool_base.h>
#include <tools/pcb_actions.h>
 
namespace KIGFX
{
    class VIEW;
    class VIEW_CONTROLS;
}
 
class BOARD;
class PCB_BASE_EDIT_FRAME;
class PCB_SHAPE;
class POLYGON_GEOM_MANAGER;
class PCB_TUNING_PATTERN;
class STATUS_MIN_MAX_POPUP;
 
 
class DRAWING_TOOL : public PCB_TOOL_BASE
{
public:
    DRAWING_TOOL();
    ~DRAWING_TOOL();
 
    bool Init() override;
 
    void Reset( RESET_REASON aReason ) override;
 
    enum class MODE
    {
        NONE,
        LINE,
        RECTANGLE,
        CIRCLE,
        ARC,
        BEZIER,
        IMAGE,
        TEXT,
        ANCHOR,
        DXF,
        DIMENSION,
        KEEPOUT,
        ZONE,
        GRAPHIC_POLYGON,
        VIA,
        TUNING
    };
 
    MODE GetDrawingMode() const;
 
    std::vector<BOARD_ITEM*> DrawBoardCharacteristics( const VECTOR2I& origin, PCB_LAYER_ID aLayer,
                                                       bool aDrawNow, VECTOR2I* tablesize );
 
    std::vector<BOARD_ITEM*> DrawSpecificationStackup( const VECTOR2I& origin, PCB_LAYER_ID aLayer,
                                                       bool aDrawNow, VECTOR2I* tablesize );
 
    int PlaceCharacteristics( const TOOL_EVENT& aEvent );
 
    int PlaceStackup( const TOOL_EVENT& aEvent );
 
    int PlaceTuningPattern( const TOOL_EVENT& aEvent );
 
    int DrawLine( const TOOL_EVENT& aEvent );
 
    int DrawRectangle( const TOOL_EVENT& aEvent );
 
    int DrawCircle( const TOOL_EVENT& aEvent );
 
    int DrawArc( const TOOL_EVENT& aEvent );
 
    int DrawBezier( const TOOL_EVENT& aEvent );
 
    int PlaceReferenceImage( const TOOL_EVENT& aEvent );
 
    int PlaceText( const TOOL_EVENT& aEvent );
 
    /*
     * Start interactively drawing a table (rows & columns of TEXTBOXes).
     */
    int DrawTable( const TOOL_EVENT& aEvent );
 
    int DrawDimension( const TOOL_EVENT& aEvent );
 
    int DrawZone(  const TOOL_EVENT& aEvent );
 
    int DrawVia( const TOOL_EVENT& aEvent );
 
    int PlaceImportedGraphics( const TOOL_EVENT& aEvent );
 
    int InteractivePlaceWithPreview( const TOOL_EVENT& aEvent,
                                     std::vector<BOARD_ITEM*>& aItems,
                                     std::vector<BOARD_ITEM*>& aPreview, LSET* aLayers );
 
 
    int SetAnchor( const TOOL_EVENT& aEvent );
 
    int ToggleHV45Mode( const TOOL_EVENT& toolEvent );
 
    void setTransitions() override;
 
    void SetStroke( const STROKE_PARAMS& aStroke, PCB_LAYER_ID aLayer )
    {
        m_layer = aLayer;
        m_stroke = aStroke;
    }
 
    void UpdateStatusBar() const;
 
private:
    enum class DRAW_ONE_RESULT
    {
        // The drawing was accepted "normally"
        // E.g. for a poly-line, you might then begin a chained next segment
        ACCEPTED,
        // The drawing was cancelled with no shape accepted.
        CANCELLED,
        // The drawing was reset - no shape was accepted this time,
        // but the tool remains active.
        RESET,
        // A shape was accepted, but the tool should reset for the
        // next one (e.g. no chaining)
        ACCEPTED_AND_RESET,
    };
 
    bool drawShape( const TOOL_EVENT& aTool, PCB_SHAPE** aGraphic,
                    std::optional<VECTOR2D> aStartingPoint,
                    std::stack<PCB_SHAPE*>* aCommittedGraphics );
 
    bool drawArc( const TOOL_EVENT& aTool, PCB_SHAPE** aGraphic,
                  std::optional<VECTOR2D> aStartingPoint );
 
    std::unique_ptr<PCB_SHAPE> drawOneBezier( const TOOL_EVENT&   aTool,
                                              const OPT_VECTOR2I& aStartingPoint,
                                              const OPT_VECTOR2I& aStartingControl1Point,
                                              DRAW_ONE_RESULT&    aResult );
 
 
    bool getSourceZoneForAction( ZONE_MODE aMode, ZONE** aZone );
 
    void constrainDimension( PCB_DIMENSION_BASE* aDim );
 
    VECTOR2I getClampedDifferenceEnd( const VECTOR2I& aOrigin, const VECTOR2I& aEnd )
    {
        typedef std::numeric_limits<int> coord_limits;
        const int                        guardValue = 1;
 
        VECTOR2I::extended_type maxDiff = coord_limits::max() - guardValue;
 
        VECTOR2I::extended_type xDiff = VECTOR2I::extended_type( aEnd.x ) - aOrigin.x;
        VECTOR2I::extended_type yDiff = VECTOR2I::extended_type( aEnd.y ) - aOrigin.y;
 
        if( xDiff > maxDiff )
            xDiff = maxDiff;
        if( yDiff > maxDiff )
            yDiff = maxDiff;
 
        if( xDiff < -maxDiff )
            xDiff = -maxDiff;
        if( yDiff < -maxDiff )
            yDiff = -maxDiff;
 
        return aOrigin + VECTOR2I( int( xDiff ), int( yDiff ) );
    }
 
    VECTOR2I getClampedRadiusEnd( const VECTOR2I& aOrigin, const VECTOR2I& aEnd )
    {
        typedef std::numeric_limits<int> coord_limits;
        const int                        guardValue = 10;
 
        VECTOR2I::extended_type xDiff = VECTOR2I::extended_type( aEnd.x ) - aOrigin.x;
        VECTOR2I::extended_type yDiff = VECTOR2I::extended_type( aEnd.y ) - aOrigin.y;
 
        double maxRadius = coord_limits::max() / 2 - guardValue;
        double radius = std::hypot( xDiff, yDiff );
 
        if( radius > maxRadius )
        {
            double scaleFactor = maxRadius / radius;
 
            xDiff = KiROUND<double, int>( xDiff * scaleFactor );
            yDiff = KiROUND<double, int>( yDiff * scaleFactor );
        }
 
        return aOrigin + VECTOR2I( int( xDiff ), int( yDiff ) );
    }
 
    KIGFX::VIEW*              m_view;
    KIGFX::VIEW_CONTROLS*     m_controls;
    BOARD*                    m_board;
    PCB_BASE_EDIT_FRAME*      m_frame;
    MODE                      m_mode;
    bool                      m_inDrawingTool;     // Re-entrancy guard
 
    PCB_LAYER_ID              m_layer;             // The layer we last drew on
    STROKE_PARAMS             m_stroke;            // Current stroke for multi-segment drawing
    TEXT_ATTRIBUTES           m_textAttrs;
 
    PCB_SELECTION             m_preview;
    BOARD_CONNECTED_ITEM*     m_pickerItem;
    PCB_TUNING_PATTERN*       m_tuningPattern;
 
    static const unsigned int WIDTH_STEP;          // Amount of width change for one -/+ key press
    static const unsigned int COORDS_PADDING;      // Padding from coordinates limits for this tool
 
 
    friend class              ZONE_CREATE_HELPER;  // give internal access to helper classes
};
 
#endif /* __DRAWING_TOOL_H */