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 <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 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,
 IMAGE,
 TEXT,
 ANCHOR,
 DXF,
 DIMENSION,
 KEEPOUT,
 ZONE,
 GRAPHIC_POLYGON,
 VIA
 };
 
 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 DrawLine( const TOOL_EVENT& aEvent );
 
 int DrawRectangle( const TOOL_EVENT& aEvent );
 
 int DrawCircle( const TOOL_EVENT& aEvent );
 
 int DrawArc( const TOOL_EVENT& aEvent );
 
 int PlaceImage( const TOOL_EVENT& aEvent );
 
 int PlaceText( 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:
 bool drawShape( const TOOL_EVENT& aTool, PCB_SHAPE** aGraphic,
 std::optional<VECTOR2D> aStartingPoint );
 
 bool drawArc( const TOOL_EVENT& aTool, PCB_SHAPE** aGraphic,
 std::optional<VECTOR2D> aStartingPoint );
 
 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 ) );
 }
 
 int getSegmentWidth( PCB_LAYER_ID aLayer ) const;
 
 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;
 
 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 */