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 The 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, see <https://www.gnu.org/licenses/>.
 */
 
#ifndef __DRAWING_TOOL_H
#define __DRAWING_TOOL_H
 
#include <functional>
#include <stack>
#include <optional>
#include <eda_shape.h>
#include <tool/shape_draw_behavior.h>
#include <tool/tool_menu.h>
#include <tools/pcb_selection.h>
#include <tools/pcb_tool_base.h>
#include <tools/pcb_actions.h>
 
namespace KIGFX
{
    class VIEW;
    class VIEW_CONTROLS;
}
 
class BOARD;
class BOARD_ITEM;
class PAD;
class PCB_TRACK;
class DRC_ENGINE;
class PCB_BASE_EDIT_FRAME;
class PCB_SHAPE;
class BOARD_CONNECTED_ITEM;
class PCB_VIA;
class POLYGON_GEOM_MANAGER;
class PCB_TUNING_PATTERN;
class STATUS_MIN_MAX_POPUP;
 

int  ComputeWorstViaClearance( PCB_BASE_EDIT_FRAME* aFrame, DRC_ENGINE* aEngine );
bool CheckItemDRCViolation( BOARD_CONNECTED_ITEM* aItem, PCB_BASE_EDIT_FRAME* aFrame, DRC_ENGINE* aEngine,
                            int aWorstClearance, int aEpsilon );
 

int        ViaSnapRange( PCB_BASE_EDIT_FRAME* aFrame );
PCB_TRACK* FindSnapTrack( PCB_BASE_EDIT_FRAME* aFrame, const PCB_VIA* aVia, const VECTOR2I& aPosition,
                          const LSET& aLayers, int aSnapRange = 0 );
PAD* FindSnapPad( PCB_BASE_EDIT_FRAME* aFrame, const PCB_VIA* aVia, const VECTOR2I& aPosition, const LSET& aLayers,
                  int aSnapRange = 0 );
 

 
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,
        ELLIPSE,
        ELLIPSE_ARC,
        ARC,
        BEZIER,
        IMAGE,
        TEXT,
        ANCHOR,
        MD_POINT, // Do not use POINT: it collide with a Windows header define
        DXF,
        DIMENSION,
        KEEPOUT,
        ZONE,
        GRAPHIC_POLYGON,
        VIA,
        TUNING,
        TABLE,
        BARCODE,
        STITCH
    };

    MODE GetDrawingMode() const;

    std::vector<BOARD_ITEM*> DrawSpecificationStackup( const VECTOR2I& origin, PCB_LAYER_ID aLayer,
                                                       bool aDrawNow, VECTOR2I* tablesize );

    int PlaceStackup( const TOOL_EVENT& aEvent );

    int PlaceTuningPattern( const TOOL_EVENT& aEvent );

    int PlaceViaStitch( const TOOL_EVENT& aEvent );

    int PlaceMicroviaStack( const TOOL_EVENT& aEvent );

    void SeedViaStackStart( const VECTOR2I& aPos, PCB_LAYER_ID aStart, PCB_LAYER_ID aEnd )
    {
        m_viaStackSeeded = true;
        m_viaStackSeedPos = aPos;
        m_viaStackSeedStart = aStart;
        m_viaStackSeedEnd = aEnd;
    }

    int DrawLine( const TOOL_EVENT& aEvent );

    int DrawRectangle( const TOOL_EVENT& aEvent );

    int DrawCircle( const TOOL_EVENT& aEvent );
 
    int DrawEllipse( const TOOL_EVENT& aEvent );
 
    int DrawEllipseArc( const TOOL_EVENT& aEvent );

    int DrawArc( const TOOL_EVENT& aEvent );

    int DrawBezier( const TOOL_EVENT& aEvent );

    int PlaceReferenceImage( const TOOL_EVENT& aEvent );

    int PlacePoint( 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 DrawBarcode( 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 SetAnchor( const TOOL_EVENT& aEvent );

    int PlaceGridItem( const TOOL_EVENT& aEvent );

    void setTransitions() override;
 
    void SetStroke( const STROKE_PARAMS& aStroke, PCB_LAYER_ID aLayer )
    {
        m_layer = aLayer;
        m_stroke = aStroke;
    }
 
    void UpdateStatusBar() const;
 
private:
    bool drawShape( const TOOL_EVENT& aTool, PCB_SHAPE** aGraphic, std::optional<VECTOR2D> aStartingPoint,
                    std::stack<PCB_SHAPE*>* aCommittedGraphics );
 
    int runSimpleShapeDraw( const TOOL_EVENT& aEvent, SHAPE_T aShapeType, MODE aMode, const wxString& aCommitLabel,
                            std::function<bool( const TOOL_EVENT&, PCB_SHAPE**, std::optional<VECTOR2D> )> aDrawer );

    SHAPE_DRAW_RESULT drawManagedShape( const TOOL_EVENT& aTool, std::unique_ptr<PCB_SHAPE>& aGraphic,
                                        SHAPE_DRAW_BEHAVIOR& aBehavior, const std::vector<VECTOR2D>& aInitialPts );

    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;
 
    // Router handoff: pre-anchored first hop and span for the next stack placement.
    bool         m_viaStackSeeded = false;
    VECTOR2I     m_viaStackSeedPos;
    PCB_LAYER_ID m_viaStackSeedStart = UNDEFINED_LAYER;
    PCB_LAYER_ID m_viaStackSeedEnd = UNDEFINED_LAYER;
 
    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 */