SCH_MOVE_TOOL Class Reference

#include <sch_move_tool.h>

Inheritance diagram for SCH_MOVE_TOOL:

Public Types
enum	RESET_REASON { RUN , MODEL_RELOAD , GAL_SWITCH , REDRAW }
	Determine the reason of reset for a tool. More...

Public Member Functions
	SCH_MOVE_TOOL ()
	~SCH_MOVE_TOOL () override
bool	Init () override
	Init() is called once upon a registration of the tool. More...
int	Main (const TOOL_EVENT &aEvent)
	Run an interactive move of the selected items, or the item under the cursor. More...
int	AlignElements (const TOOL_EVENT &aEvent)
	Align selected elements to the grid. More...
void	Reset (RESET_REASON aReason) override
	Bring the tool to a known, initial state. More...
void	Activate ()
	Run the tool. More...
TOOL_MENU &	GetToolMenu ()
void	SetContextMenu (ACTION_MENU *aMenu, CONTEXT_MENU_TRIGGER aTrigger=CMENU_BUTTON)
	Assign a context menu and tells when it should be activated. More...
void	RunMainStack (std::function< void()> aFunc)
	Call a function using the main stack. More...
template<class T >
void	Go (int(T::*aStateFunc)(const TOOL_EVENT &), const TOOL_EVENT_LIST &aConditions=TOOL_EVENT(TC_ANY, TA_ANY))
	Define which state (aStateFunc) to go when a certain event arrives (aConditions). More...
TOOL_EVENT *	Wait (const TOOL_EVENT_LIST &aEventList=TOOL_EVENT(TC_ANY, TA_ANY))
	Suspend execution of the tool until an event specified in aEventList arrives. More...
TOOL_TYPE	GetType () const
	Return the type of the tool. More...
TOOL_ID	GetId () const
	Return the unique identifier of the tool. More...
const std::string &	GetName () const
	Return the name of the tool. More...
TOOL_MANAGER *	GetManager () const
	Return the instance of TOOL_MANAGER that takes care of the tool. More...
bool	IsToolActive () const

Protected Member Functions
void	updateItem (EDA_ITEM *aItem, bool aUpdateRTree) const
	Similar to getView()->Update(), but handles items that are redrawn by their parents and updating the SCH_SCREEN's RTree. More...
void	saveCopyInUndoList (EDA_ITEM *aItem, UNDO_REDO aType, bool aAppend=false, bool aDirtyConnectivity=true)
void	attachManager (TOOL_MANAGER *aManager)
	Set the TOOL_MANAGER the tool will belong to. More...
KIGFX::VIEW *	getView () const
	Returns the instance of #VIEW object used in the application. More...
KIGFX::VIEW_CONTROLS *	getViewControls () const
	Return the instance of VIEW_CONTROLS object used in the application. More...
template<typename T >
T *	getEditFrame () const
	Return the application window object, casted to requested user type. More...
template<typename T >
T *	getModel () const
	Return the model object if it matches the requested type. More...

Protected Attributes
SCH_EDIT_FRAME *	m_frame
KIGFX::SCH_VIEW *	m_view
EE_SELECTION_TOOL *	m_selectionTool
bool	m_isSymbolEditor
TOOL_MENU	m_menu
	The functions below are not yet implemented - their interface may change. More...
TOOL_TYPE	m_type
	Unique identifier for the tool, assigned by a TOOL_MANAGER instance. More...
TOOL_ID	m_toolId
	Name of the tool. More...
std::string	m_toolName
TOOL_MANAGER *	m_toolMgr

Private Member Functions
void	moveItem (EDA_ITEM *aItem, const VECTOR2I &aDelta)
	Find additional items for a drag operation. More...
void	getConnectedItems (SCH_ITEM *aOriginalItem, const VECTOR2I &aPoint, EDA_ITEMS &aList)
void	getConnectedDragItems (SCH_ITEM *fixed, const VECTOR2I &selected, EDA_ITEMS &aList, bool &aAppendUndo)
void	orthoLineDrag (SCH_LINE *line, const VECTOR2I &splitDelta, int &xBendCount, int &yBendCount, const EE_GRID_HELPER &grid)
	Saves the new drag lines to the undo list. More...
void	commitDragLines ()
	Clears the new drag lines and removes them from the screen. More...
void	clearNewDragLines ()
	Set up handlers for various events. More...
void	setTransitions () override
	Cleanup dangling lines left after a drag. More...
void	trimDanglingLines ()
void	resetTransitions ()
	Clear the current transition map and restores the default one created by setTransitions(). More...
void	goInternal (TOOL_STATE_FUNC &aState, const TOOL_EVENT_LIST &aConditions)
EDA_ITEM *	getModelInt () const
TOOLS_HOLDER *	getToolHolderInt () const

Private Attributes
bool	m_inMoveTool
	< Re-entrancy guard More...
bool	m_moveInProgress
bool	m_isDrag
	Items (such as wires) which were added to the selection for a drag. More...
std::vector< KIID >	m_dragAdditions
	Cache of the line's original connections before dragging started. More...
std::map< SCH_LINE *, EDA_ITEMS >	m_lineConnectionCache
	Lines added at bend points dynamically during the move. More...
std::unordered_set< SCH_LINE * >	m_newDragLines
	Lines changed by drag algorithm that weren't selected. More...
std::unordered_set< SCH_LINE * >	m_changedDragLines
	Used for chaining commands. More...
VECTOR2I	m_moveOffset
	Last cursor position (needed for getModificationPoint() to avoid changes of edit reference point). More...
VECTOR2I	m_cursor
OPT_VECTOR2I	m_anchorPos
std::map< SCH_LABEL_BASE *, SPECIAL_CASE_LABEL_INFO >	m_specialCaseLabels
std::map< SCH_SHEET_PIN *, std::pair< SCH_LINE *, bool > >	m_specialCaseSheetPins

Detailed Description

Definition at line 43 of file sch_move_tool.h.

Member Enumeration Documentation

RESET_REASON

enum TOOL_BASE::RESET_REASON

inherited

Determine the reason of reset for a tool.

Enumerator
RUN	Tool is invoked after being inactive.
MODEL_RELOAD	Model changes (required full reload)
GAL_SWITCH	Rendering engine changes.
REDRAW	Full drawing refresh.

Definition at line 77 of file tool_base.h.

 {
 RUN, 
 MODEL_RELOAD, 
 GAL_SWITCH, 
 REDRAW 
 };

Constructor & Destructor Documentation

SCH_MOVE_TOOL()

SCH_MOVE_TOOL::SCH_MOVE_TOOL

(

)

Definition at line 50 of file sch_move_tool.cpp.

 :
 EE_TOOL_BASE<SCH_EDIT_FRAME>( "eeschema.InteractiveMove" ),
 m_inMoveTool( false ),
 m_moveInProgress( false ),
 m_isDrag( false ),
 m_moveOffset( 0, 0 )
{
}

~SCH_MOVE_TOOL()

SCH_MOVE_TOOL::~SCH_MOVE_TOOL ( )

inlineoverride

Definition at line 47 of file sch_move_tool.h.

{ }

Member Function Documentation

Activate()

void TOOL_INTERACTIVE::Activate ( )

inherited

Run the tool.

After activation, the tool starts receiving events until it is finished.

Definition at line 51 of file tool_interactive.cpp.

{
 m_toolMgr->InvokeTool( m_toolId );
}

References TOOL_MANAGER::InvokeTool(), TOOL_BASE::m_toolId, and TOOL_BASE::m_toolMgr.

Referenced by AUTOPLACE_TOOL::autoplace(), EDIT_TOOL::copyToClipboard(), SCH_EDIT_TOOL::DeleteItemCursor(), SYMBOL_EDITOR_EDIT_TOOL::DeleteItemCursor(), PL_EDIT_TOOL::DeleteItemCursor(), PCB_CONTROL::DeleteItemCursor(), SCH_LINE_WIRE_BUS_TOOL::doDrawSegments(), PCB_TOOL_BASE::doInteractiveItemPlacement(), EDIT_TOOL::doMoveSelection(), EDIT_TOOL::DragArcTrack(), DRAWING_TOOL::DrawArc(), DRAWING_TOOL::DrawCircle(), DRAWING_TOOL::DrawDimension(), DRAWING_TOOL::DrawLine(), MICROWAVE_TOOL::drawMicrowaveInductor(), DRAWING_TOOL::DrawRectangle(), SCH_DRAWING_TOOLS::DrawShape(), SYMBOL_EDITOR_DRAWING_TOOLS::DrawShape(), PL_DRAWING_TOOLS::DrawShape(), SCH_DRAWING_TOOLS::DrawSheet(), DRAWING_TOOL::DrawZone(), BOARD_EDITOR_CONTROL::DrillOrigin(), PAD_TOOL::EnumeratePads(), PCB_CONTROL::GridSetOrigin(), SCH_EDITOR_CONTROL::HighlightNetCursor(), ROUTER_TOOL::InlineBreakTrack(), ROUTER_TOOL::InlineDrag(), DRAWING_TOOL::InteractivePlaceWithPreview(), BOARD_INSPECTION_TOOL::LocalRatsnestTool(), EE_POINT_EDITOR::Main(), Main(), SYMBOL_EDITOR_MOVE_TOOL::Main(), PICKER_TOOL::Main(), PL_EDIT_TOOL::Main(), PL_POINT_EDITOR::Main(), PCB_PICKER_TOOL::Main(), LENGTH_TUNER_TOOL::MainLoop(), ROUTER_TOOL::MainLoop(), GERBVIEW_INSPECTION_TOOL::MeasureTool(), PCB_VIEWER_TOOLS::MeasureTool(), PCB_POINT_EDITOR::OnSelectionChange(), GROUP_TOOL::PickNewMember(), SYMBOL_EDITOR_DRAWING_TOOLS::PlaceAnchor(), BOARD_EDITOR_CONTROL::PlaceFootprint(), SCH_DRAWING_TOOLS::PlaceImage(), DRAWING_TOOL::PlaceImage(), DRAWING_TOOL::PlaceImportedGraphics(), PL_DRAWING_TOOLS::PlaceItem(), SCH_DRAWING_TOOLS::PlaceSymbol(), DRAWING_TOOL::PlaceText(), EDIT_TOOL::Remove(), ROUTER_TOOL::RouteSelected(), POSITION_RELATIVE_TOOL::SelectPositionRelativeItem(), DRAWING_TOOL::SetAnchor(), DRC_TOOL::ShowDRCDialog(), SCH_DRAWING_TOOLS::SingleClickPlace(), SCH_DRAWING_TOOLS::TwoClickPlace(), SYMBOL_EDITOR_DRAWING_TOOLS::TwoClickPlace(), and SCH_LINE_WIRE_BUS_TOOL::UnfoldBus().

AlignElements()

int SCH_MOVE_TOOL::AlignElements

(

const TOOL_EVENT &

aEvent

)

Align selected elements to the grid.

Parameters

aEvent

current event that activated the tool

Returns

0

Definition at line 1571 of file sch_move_tool.cpp.

{
 EE_GRID_HELPER grid( m_toolMgr);
 EE_SELECTION& selection = m_selectionTool->RequestSelection( EE_COLLECTOR::MovableItems );
 bool appendUndo = false;
 
 auto doMoveItem =
 [&]( EDA_ITEM* item, const VECTOR2I& delta )
 {
 saveCopyInUndoList( item, UNDO_REDO::CHANGED, appendUndo );
 appendUndo = true;
 // Ensure only one end is moved when calling moveItem
 // i.e. we are in drag mode
 bool tmp_isDrag = m_isDrag;
 m_isDrag = true;
 moveItem( item, delta );
 m_isDrag = tmp_isDrag;
 
 item->ClearFlags( IS_MOVING );
 updateItem( item, true );
 };
 
 for( SCH_ITEM* it : m_frame->GetScreen()->Items() )
 {
 if( !it->IsSelected() )
 it->ClearFlags( STARTPOINT | ENDPOINT );
 
 if( !selection.IsHover() && it->IsSelected() )
 it->SetFlags( STARTPOINT | ENDPOINT );
 
 it->SetStoredPos( it->GetPosition() );
 
 if( it->Type() == SCH_SHEET_T )
 {
 for( SCH_SHEET_PIN* pin : static_cast<SCH_SHEET*>( it )->GetPins() )
 pin->SetStoredPos( pin->GetPosition() );
 }
 }
 
 for( EDA_ITEM* item : selection )
 {
 if( item->Type() == SCH_LINE_T )
 {
 SCH_LINE* line = static_cast<SCH_LINE*>( item );
 std::vector<int> flags{ STARTPOINT, ENDPOINT };
 std::vector<VECTOR2I> pts{ line->GetStartPoint(), line->GetEndPoint() };
 
 for( int ii = 0; ii < 2; ++ii )
 {
 EDA_ITEMS drag_items{ item };
 line->ClearFlags();
 line->SetFlags( SELECTED );
 line->SetFlags( flags[ii] );
 getConnectedDragItems( line, pts[ii], drag_items, appendUndo );
 std::set<EDA_ITEM*> unique_items( drag_items.begin(), drag_items.end() );
 
 VECTOR2I gridpt = grid.AlignGrid( pts[ii] ) - pts[ii];
 
 if( gridpt != VECTOR2I( 0, 0 ) )
 {
 for( EDA_ITEM* dragItem : unique_items )
 {
 if( dragItem->GetParent() && dragItem->GetParent()->IsSelected() )
 continue;
 
 doMoveItem( dragItem, gridpt );
 }
 }
 }
 }
 else if( item->Type() == SCH_FIELD_T )
 {
 VECTOR2I gridpt = grid.AlignGrid( item->GetPosition() ) - item->GetPosition();
 
 if( gridpt != VECTOR2I( 0, 0 ) )
 doMoveItem( item, gridpt );
 }
 else if( item->Type() == SCH_SHEET_T )
 {
 SCH_SHEET* sheet = static_cast<SCH_SHEET*>( item );
 VECTOR2I topLeft = sheet->GetPosition();
 VECTOR2I bottomRight = topLeft + sheet->GetSize();
 VECTOR2I tl_gridpt = grid.AlignGrid( topLeft ) - topLeft;
 VECTOR2I br_gridpt = grid.AlignGrid( bottomRight ) - bottomRight;
 
 if( tl_gridpt != VECTOR2I( 0, 0 ) || br_gridpt != VECTOR2I( 0, 0 ) )
 {
 doMoveItem( sheet, tl_gridpt );
 
 VECTOR2I newSize = (VECTOR2I) sheet->GetSize() - tl_gridpt + br_gridpt;
 sheet->SetSize( VECTOR2I( newSize.x, newSize.y ) );
 updateItem( sheet, true );
 
 for( SCH_SHEET_PIN* pin : sheet->GetPins() )
 {
 VECTOR2I gridpt;
 
 if( pin->GetSide() == SHEET_SIDE::TOP || pin->GetSide() == SHEET_SIDE::LEFT )
 gridpt = tl_gridpt;
 else
 gridpt = br_gridpt;
 
 if( gridpt != VECTOR2I( 0, 0 ) )
 {
 EDA_ITEMS drag_items;
 getConnectedDragItems( pin, pin->GetConnectionPoints()[0], drag_items,
 appendUndo );
 
 doMoveItem( pin, gridpt );
 
 for( EDA_ITEM* dragItem : drag_items )
 {
 if( dragItem->GetParent() && dragItem->GetParent()->IsSelected() )
 continue;
 
 doMoveItem( dragItem, gridpt );
 }
 }
 }
 }
 }
 else
 {
 SCH_ITEM* schItem = static_cast<SCH_ITEM*>( item );
 std::vector<VECTOR2I> connections = schItem->GetConnectionPoints();
 EDA_ITEMS drag_items{ item };
 
 for( const VECTOR2I& point : connections )
 getConnectedDragItems( schItem, point, drag_items, appendUndo );
 
 std::map<VECTOR2I, int> shifts;
 VECTOR2I most_common( 0, 0 );
 int max_count = 0;
 
 for( const VECTOR2I& conn : connections )
 {
 VECTOR2I gridpt = grid.AlignGrid( conn ) - conn;
 
 shifts[gridpt]++;
 
 if( shifts[gridpt] > max_count )
 {
 most_common = gridpt;
 max_count = shifts[most_common];
 }
 }
 
 if( most_common != VECTOR2I( 0, 0 ) )
 {
 for( EDA_ITEM* dragItem : drag_items )
 {
 if( dragItem->GetParent() && dragItem->GetParent()->IsSelected() )
 continue;
 
 doMoveItem( dragItem, most_common );
 }
 }
 }
 }
 
 SCH_LINE_WIRE_BUS_TOOL* lwbTool = m_toolMgr->GetTool<SCH_LINE_WIRE_BUS_TOOL>();
 lwbTool->TrimOverLappingWires( &selection );
 lwbTool->AddJunctionsIfNeeded( &selection );
 
 m_toolMgr->PostEvent( EVENTS::SelectedItemsMoved );
 
 m_frame->SchematicCleanUp();
 m_frame->TestDanglingEnds();
 
 m_frame->OnModify();
 return 0;
}

References SCH_LINE_WIRE_BUS_TOOL::AddJunctionsIfNeeded(), CHANGED, EDA_ITEM::ClearFlags(), delta, ENDPOINT, getConnectedDragItems(), SCH_ITEM::GetConnectionPoints(), SCH_LINE::GetEndPoint(), SCH_SHEET::GetPins(), EDA_ITEM::GetPosition(), SCH_SHEET::GetPosition(), SCH_EDIT_FRAME::GetScreen(), SCH_SHEET::GetSize(), SCH_LINE::GetStartPoint(), TOOL_MANAGER::GetTool(), grid, IS_MOVING, SELECTION::IsHover(), SCH_SCREEN::Items(), LEFT, EE_TOOL_BASE< SCH_EDIT_FRAME >::m_frame, m_isDrag, EE_TOOL_BASE< SCH_EDIT_FRAME >::m_selectionTool, TOOL_BASE::m_toolMgr, EE_COLLECTOR::MovableItems, moveItem(), SCH_EDIT_FRAME::OnModify(), pin, TOOL_MANAGER::PostEvent(), EE_SELECTION_TOOL::RequestSelection(), EE_TOOL_BASE< SCH_EDIT_FRAME >::saveCopyInUndoList(), SCH_FIELD_T, SCH_LINE_T, SCH_SHEET_T, SCH_EDIT_FRAME::SchematicCleanUp(), SELECTED, EVENTS::SelectedItemsMoved, EDA_ITEM::SetFlags(), SCH_SHEET::SetSize(), STARTPOINT, SCH_EDIT_FRAME::TestDanglingEnds(), TOP, SCH_LINE_WIRE_BUS_TOOL::TrimOverLappingWires(), EDA_ITEM::Type(), EE_TOOL_BASE< SCH_EDIT_FRAME >::updateItem(), VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by setTransitions().

attachManager()

void TOOL_BASE::attachManager ( TOOL_MANAGER *  aManager )

protectedinherited

Set the TOOL_MANAGER the tool will belong to.

Called by TOOL_MANAGER::RegisterTool()

Definition at line 60 of file tool_base.cpp.

{
 m_toolMgr = aManager;
}

References TOOL_BASE::m_toolMgr.

Referenced by TOOL_MANAGER::RegisterTool().

clearNewDragLines()

void SCH_MOVE_TOOL::clearNewDragLines ( )

private

Set up handlers for various events.

Definition at line 1765 of file sch_move_tool.cpp.

{
 // Remove new bend lines added during the drag
 for( SCH_LINE* newLine : m_newDragLines )
 {
 m_frame->RemoveFromScreen( newLine, m_frame->GetScreen() );
 delete newLine;
 }
 
 m_newDragLines.clear();
}

References SCH_EDIT_FRAME::GetScreen(), EE_TOOL_BASE< SCH_EDIT_FRAME >::m_frame, m_newDragLines, and SCH_BASE_FRAME::RemoveFromScreen().

Referenced by Main().

commitDragLines()

void SCH_MOVE_TOOL::commitDragLines ( )

private

Clears the new drag lines and removes them from the screen.

Definition at line 1745 of file sch_move_tool.cpp.

{
 for( SCH_LINE* newLine : m_newDragLines )
 {
 newLine->ClearEditFlags();
 saveCopyInUndoList( newLine, UNDO_REDO::NEWITEM, true );
 }
 
 // These lines have been changed, but aren't selected. We need
 // to manually clear these edit flags or they'll stick around.
 for( SCH_LINE* oldLine : m_changedDragLines )
 {
 oldLine->ClearEditFlags();
 }
 
 m_newDragLines.clear();
 m_changedDragLines.clear();
}

References m_changedDragLines, m_newDragLines, NEWITEM, and EE_TOOL_BASE< SCH_EDIT_FRAME >::saveCopyInUndoList().

Referenced by Main().

getConnectedDragItems()

void SCH_MOVE_TOOL::getConnectedDragItems ( SCH_ITEM *  fixed, const VECTOR2I &  selected, EDA_ITEMS &  aList, bool &  aAppendUndo  )

private

Definition at line 1123 of file sch_move_tool.cpp.

{
 EE_RTREE& items = m_frame->GetScreen()->Items();
 EE_RTREE::EE_TYPE itemsOverlappingRTree = items.Overlapping( aSelectedItem->GetBoundingBox() );
 std::vector<SCH_ITEM*> itemsConnectable;
 bool ptHasUnselectedJunction = false;
 
 auto makeNewWire =
 [&]( SCH_ITEM* fixed, SCH_ITEM* selected, const VECTOR2I& start, const VECTOR2I& end )
 {
 SCH_LINE* newWire;
 
 // Add a new newWire between the fixed item and the selected item so the selected
 // item can be dragged.
 if( fixed->GetLayer() == LAYER_BUS_JUNCTION || fixed->GetLayer() == LAYER_BUS
 || selected->GetLayer() == LAYER_BUS )
 {
 newWire = new SCH_LINE( start, LAYER_BUS );
 }
 else
 {
 newWire = new SCH_LINE( start, LAYER_WIRE );
 }
 
 newWire->SetFlags( IS_NEW );
 newWire->SetConnectivityDirty( true );
 newWire->SetLastResolvedState( selected );
 
 newWire->SetEndPoint( end );
 m_frame->AddToScreen( newWire, m_frame->GetScreen() );
 
 return newWire;
 };
 
 auto makeNewJunction =
 [&]( SCH_LINE* line, const VECTOR2I& pt )
 {
 SCH_JUNCTION* junction = new SCH_JUNCTION( pt );
 junction->SetFlags( IS_NEW );
 junction->SetConnectivityDirty( true );
 junction->SetLastResolvedState( line );
 
 if( line->IsBus() )
 junction->SetLayer( LAYER_BUS_JUNCTION );
 
 m_frame->AddToScreen( junction, m_frame->GetScreen() );
 
 return junction;
 };
 
 for( SCH_ITEM* item : itemsOverlappingRTree )
 {
 // Skip ourselves, skip already selected items (but not lines, they need both ends tested)
 // and skip unconnectable items
 if( item == aSelectedItem || ( item->Type() != SCH_LINE_T && item->IsSelected() )
 || !item->CanConnect( aSelectedItem ) )
 {
 continue;
 }
 
 itemsConnectable.push_back( item );
 }
 
 for( SCH_ITEM* item : itemsConnectable )
 {
 if( item->Type() == SCH_JUNCTION_T && item->IsConnected( aPoint ) && !item->IsSelected() )
 {
 ptHasUnselectedJunction = true;
 break;
 }
 }
 
 SCH_LINE* newWire = nullptr;
 
 for( SCH_ITEM* test : itemsConnectable )
 {
 KICAD_T testType = test->Type();
 
 switch( testType )
 {
 case SCH_LINE_T:
 {
 // Select the connected end of wires/bus connections that don't have an unselected
 // junction isolating them from the drag
 if( ptHasUnselectedJunction )
 break;
 
 SCH_LINE* line = static_cast<SCH_LINE*>( test );
 
 if( line->GetStartPoint() == aPoint )
 {
 // It's possible to manually select one end of a line and get a drag
 // connected other end, so we set the flag and then early exit the loop
 // later if the other drag items like labels attached to the line have
 // already been grabbed during the partial selection process.
 line->SetFlags( STARTPOINT );
 
 if( line->HasFlag( SELECTED ) || line->HasFlag( SELECTED_BY_DRAG ) )
 {
 continue;
 }
 else
 {
 line->SetFlags( SELECTED_BY_DRAG );
 aList.push_back( line );
 }
 }
 else if( line->GetEndPoint() == aPoint )
 {
 line->SetFlags( ENDPOINT );
 
 if( line->HasFlag( SELECTED ) || line->HasFlag( SELECTED_BY_DRAG ) )
 {
 continue;
 }
 else
 {
 line->SetFlags( SELECTED_BY_DRAG );
 aList.push_back( line );
 }
 }
 else
 {
 switch( aSelectedItem->Type() )
 {
 // These items can connect anywhere along a line
 case SCH_BUS_BUS_ENTRY_T:
 case SCH_BUS_WIRE_ENTRY_T:
 case SCH_LABEL_T:
 case SCH_HIER_LABEL_T:
 case SCH_GLOBAL_LABEL_T:
 case SCH_DIRECTIVE_LABEL_T:
 // Only add a line if this line is unselected; if the label and line are both
 // selected they'll move together
 if( line->HitTest( aPoint, 1 ) && !line->HasFlag( SELECTED )
 && !line->HasFlag( SELECTED_BY_DRAG ) )
 {
 newWire = makeNewWire( line, aSelectedItem, aPoint, aPoint );
 newWire->SetFlags( SELECTED_BY_DRAG | STARTPOINT );
 newWire->StoreAngle( ( line->Angle() + ANGLE_90 ).Normalize() );
 aList.push_back( newWire );
 
 saveCopyInUndoList( newWire, UNDO_REDO::NEWITEM, aAppendUndo );
 aAppendUndo = true;
 
 if( aPoint != line->GetStartPoint() && aPoint != line->GetEndPoint() )
 {
 // Split line in half
 if( !line->IsNew() )
 {
 saveCopyInUndoList( line, UNDO_REDO::CHANGED, aAppendUndo );
 aAppendUndo = true;
 }
 
 VECTOR2I oldEnd = line->GetEndPoint();
 line->SetEndPoint( aPoint );
 
 SCH_LINE* secondHalf = makeNewWire( line, line, aPoint, oldEnd );
 SCH_JUNCTION* junction = makeNewJunction( line, aPoint );
 
 saveCopyInUndoList( secondHalf, UNDO_REDO::NEWITEM, aAppendUndo );
 aAppendUndo = true;
 
 saveCopyInUndoList( junction, UNDO_REDO::NEWITEM, aAppendUndo );
 aAppendUndo = true;
 }
 else
 {
 m_lineConnectionCache[ newWire ] = { line };
 m_lineConnectionCache[ line ] = { newWire };
 }
 }
 break;
 
 default:
 break;
 }
 
 break;
 }
 
 // Since only one end is going to move, the movement vector of any labels attached to
 // it is scaled by the proportion of the line length the label is from the moving end.
 for( SCH_ITEM* item : items.Overlapping( line->GetBoundingBox() ) )
 {
 SCH_LABEL_BASE* label = dynamic_cast<SCH_LABEL_BASE*>( item );
 
 if( !label || label->IsSelected() )
 continue; // These will be moved on their own because they're selected
 
 if( label->HasFlag( SELECTED_BY_DRAG ) )
 continue;
 
 if( label->CanConnect( line ) && line->HitTest( label->GetPosition(), 1 ) )
 {
 label->SetFlags( SELECTED_BY_DRAG );
 aList.push_back( label );
 
 SPECIAL_CASE_LABEL_INFO info;
 info.attachedLine = line;
 info.originalLabelPos = label->GetPosition();
 m_specialCaseLabels[label] = info;
 }
 }
 
 break;
 }
 
 case SCH_SHEET_T:
 for( SCH_SHEET_PIN* pin : static_cast<SCH_SHEET*>( test )->GetPins() )
 {
 if( pin->IsConnected( aPoint ) )
 {
 if( pin->IsSelected() && aSelectedItem->Type() == SCH_LINE_T )
 {
 SCH_LINE* line = static_cast<SCH_LINE*>( aSelectedItem );
 m_specialCaseSheetPins[ pin ] = { line, line->GetStartPoint() == aPoint };
 }
 else if( !newWire )
 {
 // Add a new wire between the sheetpin and the selected item so the
 // selected item can be dragged.
 newWire = makeNewWire( pin, aSelectedItem, aPoint, aPoint );
 newWire->SetFlags( SELECTED_BY_DRAG | STARTPOINT );
 aList.push_back( newWire );
 
 saveCopyInUndoList( newWire, UNDO_REDO::NEWITEM, aAppendUndo );
 aAppendUndo = true;
 }
 }
 }
 
 break;
 
 case SCH_SYMBOL_T:
 case SCH_JUNCTION_T:
 if( test->IsConnected( aPoint ) && !newWire )
 {
 // Add a new wire between the symbol or junction and the selected item so
 // the selected item can be dragged.
 newWire = makeNewWire( test, aSelectedItem, aPoint, aPoint );
 newWire->SetFlags( SELECTED_BY_DRAG | STARTPOINT );
 aList.push_back( newWire );
 
 saveCopyInUndoList( newWire, UNDO_REDO::NEWITEM, aAppendUndo );
 aAppendUndo = true;
 }
 
 break;
 
 case SCH_NO_CONNECT_T:
 // Select no-connects that are connected to items being moved.
 if( !test->HasFlag( SELECTED_BY_DRAG ) && test->IsConnected( aPoint ) )
 {
 aList.push_back( test );
 test->SetFlags( SELECTED_BY_DRAG );
 }
 
 break;
 
 case SCH_LABEL_T:
 case SCH_GLOBAL_LABEL_T:
 case SCH_HIER_LABEL_T:
 case SCH_DIRECTIVE_LABEL_T:
 // Performance optimization:
 if( test->HasFlag( SELECTED_BY_DRAG ) )
 break;
 
 // Select labels that are connected to a wire (or bus) being moved.
 if( aSelectedItem->Type() == SCH_LINE_T && test->CanConnect( aSelectedItem ) )
 {
 SCH_LABEL_BASE* label = static_cast<SCH_LABEL_BASE*>( test );
 SCH_LINE* line = static_cast<SCH_LINE*>( aSelectedItem );
 
 bool oneEndFixed = !line->HasFlag( STARTPOINT ) || !line->HasFlag( ENDPOINT );
 
 if( line->HitTest( label->GetTextPos(), 1 ) )
 {
 if( ( !line->HasFlag( STARTPOINT )
 && label->GetPosition() == line->GetStartPoint() )
 || ( !line->HasFlag( ENDPOINT )
 && label->GetPosition() == line->GetEndPoint() ) )
 {
 //If we have a line selected at only one end, don't grab labels
 //connected directly to the unselected endpoint
 break;
 }
 else
 {
 label->SetFlags( SELECTED_BY_DRAG );
 aList.push_back( label );
 
 if( oneEndFixed )
 {
 SPECIAL_CASE_LABEL_INFO info;
 info.attachedLine = line;
 info.originalLabelPos = label->GetPosition();
 m_specialCaseLabels[label] = info;
 }
 }
 }
 }
 else if( test->IsConnected( aPoint ) && !newWire )
 {
 // Add a new wire between the label and the selected item so the selected item
 // can be dragged.
 newWire = makeNewWire( test, aSelectedItem, aPoint, aPoint );
 newWire->SetFlags( SELECTED_BY_DRAG | STARTPOINT );
 aList.push_back( newWire );
 
 saveCopyInUndoList( newWire, UNDO_REDO::NEWITEM, aAppendUndo );
 aAppendUndo = true;
 }
 
 break;
 
 case SCH_BUS_WIRE_ENTRY_T:
 case SCH_BUS_BUS_ENTRY_T:
 // Performance optimization:
 if( test->HasFlag( SELECTED_BY_DRAG ) )
 break;
 
 // Select bus entries that are connected to a bus being moved.
 if( aSelectedItem->Type() == SCH_LINE_T && test->CanConnect( aSelectedItem ) )
 {
 SCH_LINE* line = static_cast<SCH_LINE*>( aSelectedItem );
 
 if( ( !line->HasFlag( STARTPOINT ) && test->IsConnected( line->GetStartPoint() ) )
 || ( !line->HasFlag( ENDPOINT ) && test->IsConnected( line->GetEndPoint() ) ) )
 {
 // If we have a line selected at only one end, don't grab bus entries
 // connected directly to the unselected endpoint
 continue;
 }
 
 for( VECTOR2I& point : test->GetConnectionPoints() )
 {
 if( line->HitTest( point, 1 ) )
 {
 test->SetFlags( SELECTED_BY_DRAG );
 aList.push_back( test );
 
 // A bus entry needs its wire & label as well
 std::vector<VECTOR2I> ends = test->GetConnectionPoints();
 VECTOR2I otherEnd;
 
 if( ends[0] == point )
 otherEnd = ends[1];
 else
 otherEnd = ends[0];
 
 getConnectedDragItems( test, otherEnd, aList, aAppendUndo );
 
 // No need to test the other end of the bus entry
 break;
 }
 }
 }
 
 break;
 
 default:
 break;
 }
 }
}

References SCH_BASE_FRAME::AddToScreen(), SCH_LINE::Angle(), ANGLE_90, SCH_ITEM::CanConnect(), SCH_LABEL_BASE::CanConnect(), CHANGED, ENDPOINT, EDA_ITEM::GetBoundingBox(), SCH_LINE::GetBoundingBox(), getConnectedDragItems(), SCH_LINE::GetEndPoint(), SCH_ITEM::GetLayer(), SCH_SHEET::GetPins(), SCH_TEXT::GetPosition(), SCH_EDIT_FRAME::GetScreen(), SCH_LINE::GetStartPoint(), EDA_TEXT::GetTextPos(), EDA_ITEM::HasFlag(), SCH_LINE::HitTest(), info, IS_NEW, SCH_LINE::IsBus(), EDA_ITEM::IsNew(), EDA_ITEM::IsSelected(), SCH_SCREEN::Items(), LAYER_BUS, LAYER_BUS_JUNCTION, LAYER_WIRE, EE_TOOL_BASE< SCH_EDIT_FRAME >::m_frame, m_lineConnectionCache, m_specialCaseLabels, m_specialCaseSheetPins, NEWITEM, EE_RTREE::Overlapping(), pin, EE_TOOL_BASE< SCH_EDIT_FRAME >::saveCopyInUndoList(), SCH_BUS_BUS_ENTRY_T, SCH_BUS_WIRE_ENTRY_T, SCH_DIRECTIVE_LABEL_T, SCH_GLOBAL_LABEL_T, SCH_HIER_LABEL_T, SCH_JUNCTION_T, SCH_LABEL_T, SCH_LINE_T, SCH_NO_CONNECT_T, SCH_SHEET_T, SCH_SYMBOL_T, SELECTED, SELECTED_BY_DRAG, SCH_ITEM::SetConnectivityDirty(), SCH_LINE::SetEndPoint(), EDA_ITEM::SetFlags(), SCH_JUNCTION::SetLastResolvedState(), SCH_LINE::SetLastResolvedState(), SCH_ITEM::SetLayer(), STARTPOINT, SCH_LINE::StoreAngle(), and EDA_ITEM::Type().

Referenced by AlignElements(), getConnectedDragItems(), and Main().

getConnectedItems()

void SCH_MOVE_TOOL::getConnectedItems ( SCH_ITEM *  aOriginalItem, const VECTOR2I &  aPoint, EDA_ITEMS &  aList  )

private

Definition at line 994 of file sch_move_tool.cpp.

{
 EE_RTREE& items = m_frame->GetScreen()->Items();
 EE_RTREE::EE_TYPE itemsOverlapping = items.Overlapping( aOriginalItem->GetBoundingBox() );
 SCH_ITEM* foundJunction = nullptr;
 SCH_ITEM* foundSymbol = nullptr;
 
 // If you're connected to a junction, you're only connected to the junction.
 //
 // But, if you're connected to a junction on a pin, you're only connected to the pin. This
 // is because junctions and pins have different logic for how bend lines are generated and
 // we need to prioritize the pin version in some cases.
 for( SCH_ITEM* item : itemsOverlapping )
 {
 if( item != aOriginalItem && item->IsConnected( aPoint ) )
 {
 if( item->Type() == SCH_JUNCTION_T )
 foundJunction = item;
 else if( item->Type() == SCH_SYMBOL_T )
 foundSymbol = item;
 }
 }
 
 if( foundSymbol && foundJunction )
 {
 aList.push_back( foundSymbol );
 return;
 }
 
 if( foundJunction )
 {
 aList.push_back( foundJunction );
 return;
 }
 
 
 for( SCH_ITEM* test : itemsOverlapping )
 {
 if( test == aOriginalItem || !test->CanConnect( aOriginalItem ) )
 continue;
 
 switch( test->Type() )
 {
 case SCH_LINE_T:
 {
 SCH_LINE* line = static_cast<SCH_LINE*>( test );
 
 // When getting lines for the connection cache, it's important that we only add
 // items at the unselected end, since that is the only end that is handled specially.
 // Fully selected lines, and the selected end of a partially selected line, are moved
 // around normally and don't care about their connections.
 if( ( line->HasFlag( STARTPOINT ) && aPoint == line->GetStartPoint() )
 || ( line->HasFlag( ENDPOINT ) && aPoint == line->GetEndPoint() ) )
 {
 continue;
 }
 
 if( test->IsConnected( aPoint ) )
 aList.push_back( test );
 
 // Labels can connect to a wire (or bus) anywhere along the length
 if( SCH_LABEL_BASE* label = dynamic_cast<SCH_LABEL_BASE*>( aOriginalItem ) )
 {
 if( static_cast<SCH_LINE*>( test )->HitTest( label->GetPosition(), 1 ) )
 aList.push_back( test );
 }
 
 break;
 }
 
 case SCH_SHEET_T:
 if( aOriginalItem->Type() == SCH_LINE_T )
 {
 SCH_LINE* line = static_cast<SCH_LINE*>( aOriginalItem );
 
 for( SCH_SHEET_PIN* pin : static_cast<SCH_SHEET*>( test )->GetPins() )
 {
 if( pin->IsConnected( aPoint ) )
 m_specialCaseSheetPins[ pin ] = { line, line->GetStartPoint() == aPoint };
 }
 }
 
 KI_FALLTHROUGH;
 
 case SCH_SYMBOL_T:
 case SCH_JUNCTION_T:
 case SCH_NO_CONNECT_T:
 if( test->IsConnected( aPoint ) )
 aList.push_back( test );
 
 break;
 
 case SCH_LABEL_T:
 case SCH_GLOBAL_LABEL_T:
 case SCH_HIER_LABEL_T:
 case SCH_DIRECTIVE_LABEL_T:
 // Labels can connect to a wire (or bus) anywhere along the length
 if( aOriginalItem->Type() == SCH_LINE_T && test->CanConnect( aOriginalItem ) )
 {
 SCH_LABEL_BASE* label = static_cast<SCH_LABEL_BASE*>( test );
 SCH_LINE* line = static_cast<SCH_LINE*>( aOriginalItem );
 
 if( line->HitTest( label->GetPosition(), 1 ) )
 aList.push_back( label );
 }
 
 break;
 
 case SCH_BUS_WIRE_ENTRY_T:
 case SCH_BUS_BUS_ENTRY_T:
 if( aOriginalItem->Type() == SCH_LINE_T && test->CanConnect( aOriginalItem ) )
 {
 SCH_TEXT* label = static_cast<SCH_TEXT*>( test );
 SCH_LINE* line = static_cast<SCH_LINE*>( aOriginalItem );
 
 if( line->HitTest( aPoint, 1 ) )
 aList.push_back( label );
 }
 
 break;
 
 default:
 break;
 }
 }
}

References ENDPOINT, EDA_ITEM::GetBoundingBox(), SCH_LINE::GetEndPoint(), SCH_SHEET::GetPins(), SCH_TEXT::GetPosition(), SCH_EDIT_FRAME::GetScreen(), SCH_LINE::GetStartPoint(), EDA_ITEM::HasFlag(), SCH_LINE::HitTest(), SCH_ITEM::IsConnected(), SCH_SCREEN::Items(), KI_FALLTHROUGH, EE_TOOL_BASE< SCH_EDIT_FRAME >::m_frame, m_specialCaseSheetPins, EE_RTREE::Overlapping(), pin, SCH_BUS_BUS_ENTRY_T, SCH_BUS_WIRE_ENTRY_T, SCH_DIRECTIVE_LABEL_T, SCH_GLOBAL_LABEL_T, SCH_HIER_LABEL_T, SCH_JUNCTION_T, SCH_LABEL_T, SCH_LINE_T, SCH_NO_CONNECT_T, SCH_SHEET_T, SCH_SYMBOL_T, STARTPOINT, and EDA_ITEM::Type().

Referenced by Main().

getEditFrame()

template<typename T >

T * TOOL_BASE::getEditFrame ( ) const

inlineprotectedinherited

Return the application window object, casted to requested user type.

Definition at line 185 of file tool_base.h.

 {
#if !defined( QA_TEST ) // Dynamic casts give the linker a seizure in the test framework
 wxASSERT( dynamic_cast<T*>( getToolHolderInt() ) );
#endif
 return static_cast<T*>( getToolHolderInt() );
 }

References TOOL_BASE::getToolHolderInt().

Referenced by ZONE_CREATE_HELPER::createNewZone(), and ZONE_CREATE_HELPER::setUniquePriority().

GetId()

TOOL_ID TOOL_BASE::GetId ( ) const

inlineinherited

Return the unique identifier of the tool.

The identifier is set by an instance of TOOL_MANAGER.

Returns

Identifier of the tool.

Definition at line 121 of file tool_base.h.

 {
 return m_toolId;
 }

References TOOL_BASE::m_toolId.

Referenced by TOOL_MANAGER::finishTool(), TOOL_MANAGER::InitTools(), TOOL_MANAGER::isActive(), TOOL_MANAGER::RegisterTool(), ACTION_MANAGER::RunHotKey(), TOOL_MANAGER::runTool(), TOOL_MANAGER::saveViewControls(), and TOOL_MANAGER::ShutdownTool().

GetManager()

TOOL_MANAGER * TOOL_BASE::GetManager ( ) const

inlineinherited

Return the instance of TOOL_MANAGER that takes care of the tool.

Returns

Instance of the TOOL_MANAGER or NULL if there is no associated tool manager.

Definition at line 144 of file tool_base.h.

 {
 return m_toolMgr;
 }

References TOOL_BASE::m_toolMgr.

Referenced by BOARD_COMMIT::BOARD_COMMIT(), ZONE_CREATE_HELPER::commitZone(), ZONE_CREATE_HELPER::createNewZone(), PNS_KICAD_IFACE::DisplayItem(), PCB_TOOL_BASE::doInteractiveItemPlacement(), ACTION_MENU::getToolManager(), PNS_KICAD_IFACE::GetUnits(), ZONE_CREATE_HELPER::OnFirstPoint(), ACTION_MENU::OnMenuEvent(), and ZONE_CREATE_HELPER::performZoneCutout().

getModel()

template<typename T >

T * TOOL_BASE::getModel ( ) const

inlineprotectedinherited

Return the model object if it matches the requested type.

Store the type of the tool.

Definition at line 197 of file tool_base.h.

References TOOL_BASE::getModelInt().

Referenced by ZONE_CREATE_HELPER::commitZone(), and ZONE_CREATE_HELPER::createZoneFromExisting().

getModelInt()

EDA_ITEM * TOOL_BASE::getModelInt ( ) const

privateinherited

Definition at line 54 of file tool_base.cpp.

{
 return m_toolMgr->GetModel();
}

References TOOL_MANAGER::GetModel(), and TOOL_BASE::m_toolMgr.

Referenced by TOOL_BASE::getModel().

GetName()

const std::string & TOOL_BASE::GetName ( void  ) const

inlineinherited

Return the name of the tool.

Tool names are expected to obey the format: application.ToolName (eg. pcbnew.InteractiveSelection).

Returns

The name of the tool.

Definition at line 134 of file tool_base.h.

 {
 return m_toolName;
 }

References TOOL_BASE::m_toolName.

Referenced by TOOL_MANAGER::dispatchInternal(), TOOL_MANAGER::InitTools(), TOOL_MANAGER::invokeTool(), TOOL_MANAGER::RegisterTool(), TOOL_MANAGER::runTool(), and TOOL_MANAGER::ShutdownTool().

getToolHolderInt()

TOOLS_HOLDER * TOOL_BASE::getToolHolderInt ( ) const

privateinherited

Definition at line 48 of file tool_base.cpp.

{
 return m_toolMgr->GetToolHolder();
}

References TOOL_MANAGER::GetToolHolder(), and TOOL_BASE::m_toolMgr.

Referenced by TOOL_BASE::getEditFrame().

GetToolMenu()

TOOL_MENU & TOOL_INTERACTIVE::GetToolMenu ( )

inlineinherited

Definition at line 77 of file tool_interactive.h.

{ return m_menu; }

References TOOL_INTERACTIVE::m_menu.

Referenced by EE_INSPECTION_TOOL::Init(), EE_POINT_EDITOR::Init(), SCH_EDIT_TOOL::Init(), SCH_LINE_WIRE_BUS_TOOL::Init(), Init(), SYMBOL_EDITOR_EDIT_TOOL::Init(), SYMBOL_EDITOR_MOVE_TOOL::Init(), SYMBOL_EDITOR_PIN_TOOL::Init(), PL_EDIT_TOOL::Init(), BOARD_EDITOR_CONTROL::Init(), BOARD_INSPECTION_TOOL::Init(), CONVERT_TOOL::Init(), EDIT_TOOL::Init(), GROUP_TOOL::Init(), PAD_TOOL::Init(), PCB_POINT_EDITOR::Init(), and ALIGN_DISTRIBUTE_TOOL::Init().

GetType()

TOOL_TYPE TOOL_BASE::GetType ( ) const

inlineinherited

Return the type of the tool.

Returns

The type of the tool.

Definition at line 109 of file tool_base.h.

 {
 return m_type;
 }

References TOOL_BASE::m_type.

Referenced by TOOL_MANAGER::finishTool(), TOOL_MANAGER::InvokeTool(), TOOL_MANAGER::ResetTools(), TOOL_MANAGER::runTool(), and TOOL_MANAGER::ShutdownTool().

getView()

KIGFX::VIEW * TOOL_BASE::getView ( ) const

protectedinherited

Returns the instance of #VIEW object used in the application.

It allows tools to draw.

Returns

The instance of VIEW.

Definition at line 36 of file tool_base.cpp.

{
 return m_toolMgr->GetView();
}

References TOOL_MANAGER::GetView(), and TOOL_BASE::m_toolMgr.

Referenced by EE_POINT_EDITOR::addCornerCondition(), ALIGN_DISTRIBUTE_TOOL::AlignLeft(), ALIGN_DISTRIBUTE_TOOL::AlignRight(), COMMON_TOOLS::CenterContents(), SCH_EDIT_TOOL::ChangeTextType(), EE_INSPECTION_TOOL::CheckSymbol(), GERBVIEW_CONTROL::ClearAllLayers(), PL_SELECTION_TOOL::ClearSelection(), EE_SELECTION_TOOL::ClearSelection(), EE_SELECTION_TOOL::CollectHits(), SCH_LINE_WIRE_BUS_TOOL::computeBreakPoint(), COMMON_TOOLS::CursorControl(), SCH_EDIT_TOOL::DeleteItemCursor(), PL_EDIT_TOOL::DeleteItemCursor(), PCB_CONTROL::DeleteItemCursor(), EDIT_TOOL::DeleteItems(), PL_EDIT_TOOL::DoDelete(), SCH_LINE_WIRE_BUS_TOOL::doDrawSegments(), PCB_TOOL_BASE::doInteractiveItemPlacement(), EDIT_TOOL::doMoveSelection(), SELECTION_TOOL::doSelectionMenu(), COMMON_TOOLS::doZoomFit(), COMMON_TOOLS::doZoomInOut(), COMMON_TOOLS::doZoomToPreset(), EDIT_TOOL::DragArcTrack(), DRAWING_TOOL::drawArc(), DRAWING_TOOL::DrawDimension(), MICROWAVE_TOOL::drawMicrowaveInductor(), SCH_LINE_WIRE_BUS_TOOL::DrawSegments(), PL_DRAWING_TOOLS::DrawShape(), DRAWING_TOOL::drawShape(), DRAWING_TOOL::DrawZone(), BOARD_EDITOR_CONTROL::DrillOrigin(), SYMBOL_EDITOR_EDIT_TOOL::Duplicate(), PAD_TOOL::EnumeratePads(), EE_SELECTION_TOOL::GetNode(), ROUTER_TOOL::getStartLayer(), PCB_CONTROL::GridResetOrigin(), PCB_CONTROL::GridSetOrigin(), EE_SELECTION_TOOL::GuessSelectionCandidates(), PCB_SELECTION_TOOL::GuessSelectionCandidates(), ROUTER_TOOL::handleCommonEvents(), EE_SELECTION_TOOL::highlight(), PL_SELECTION_TOOL::highlight(), PCB_SELECTION_TOOL::highlight(), GERBVIEW_CONTROL::HighlightControl(), BOARD_INSPECTION_TOOL::highlightNet(), PNS::TOOL_BASE::highlightNets(), PCB_SELECTION_TOOL::hitTestDistance(), SCH_EDIT_TOOL::Init(), EDIT_TOOL::Init(), ROUTER_TOOL::InlineDrag(), EE_POINT_EDITOR::Main(), Main(), PL_POINT_EDITOR::Main(), PCB_PICKER_TOOL::Main(), GERBVIEW_INSPECTION_TOOL::MeasureTool(), PCB_VIEWER_TOOLS::MeasureTool(), SCH_EDIT_TOOL::Mirror(), EDIT_TOOL::MoveExact(), PL_EDIT_TOOL::moveItem(), COMMON_TOOLS::OnGridChanged(), PCB_POINT_EDITOR::OnSelectionChange(), COMMON_TOOLS::PanControl(), SCH_EDITOR_CONTROL::Paste(), SYMBOL_EDITOR_EDIT_TOOL::Paste(), PL_EDIT_TOOL::Paste(), ROUTER_TOOL::performRouting(), PNS::TOOL_BASE::pickSingleItem(), BOARD_EDITOR_CONTROL::PlaceFootprint(), DRAWING_TOOL::PlaceImage(), DRAWING_TOOL::PlaceImportedGraphics(), PL_DRAWING_TOOLS::PlaceItem(), SCH_DRAWING_TOOLS::PlaceSymbol(), DRAWING_TOOL::PlaceText(), ROUTER_TOOL::prepareInteractive(), SCH_EDIT_TOOL::Properties(), EDIT_TOOL::Properties(), EE_SELECTION_TOOL::Reset(), EE_TOOL_BASE< T >::Reset(), GERBVIEW_SELECTION_TOOL::Reset(), PNS::TOOL_BASE::Reset(), BOARD_EDITOR_CONTROL::Reset(), DRAWING_TOOL::Reset(), PCB_CONTROL::Reset(), PCB_SELECTION_TOOL::Reset(), SCH_EDIT_TOOL::Rotate(), GERBVIEW_SELECTION_TOOL::select(), PCB_SELECTION_TOOL::Selectable(), EE_SELECTION_TOOL::SelectAll(), PCB_SELECTION_TOOL::SelectAll(), EE_SELECTION_TOOL::selectionContains(), PL_SELECTION_TOOL::selectionContains(), PCB_SELECTION_TOOL::selectionContains(), EE_SELECTION_TOOL::selectMultiple(), PL_SELECTION_TOOL::selectMultiple(), PCB_SELECTION_TOOL::selectMultiple(), PL_SELECTION_TOOL::SelectPoint(), EE_SELECTION_TOOL::selectPoint(), ZOOM_TOOL::selectRegion(), GERBVIEW_SELECTION_TOOL::selectVisually(), DRAWING_TOOL::SetAnchor(), SCH_DRAWING_TOOLS::SingleClickPlace(), SCH_EDITOR_CONTROL::ToggleERCErrors(), SCH_EDITOR_CONTROL::ToggleERCExclusions(), SCH_EDITOR_CONTROL::ToggleERCWarnings(), SCH_EDITOR_CONTROL::ToggleHiddenFields(), SCH_EDITOR_CONTROL::ToggleHiddenPins(), SCH_EDITOR_CONTROL::ToggleOPCurrents(), SCH_EDITOR_CONTROL::ToggleOPVoltages(), SCH_DRAWING_TOOLS::TwoClickPlace(), SYMBOL_EDITOR_DRAWING_TOOLS::TwoClickPlace(), EE_SELECTION_TOOL::unhighlight(), PL_SELECTION_TOOL::unhighlight(), PCB_SELECTION_TOOL::unhighlight(), GERBVIEW_SELECTION_TOOL::unselect(), GERBVIEW_SELECTION_TOOL::unselectVisually(), EE_POINT_EDITOR::updateEditedPoint(), PL_POINT_EDITOR::updateEditedPoint(), PCB_POINT_EDITOR::updateEditedPoint(), SCH_FIND_REPLACE_TOOL::UpdateFind(), PL_POINT_EDITOR::updateItem(), PCB_POINT_EDITOR::updateItem(), EE_TOOL_BASE< T >::updateItem(), SCH_EDITOR_CONTROL::UpdateNetHighlighting(), EE_POINT_EDITOR::updatePoints(), PL_POINT_EDITOR::updatePoints(), PCB_POINT_EDITOR::updatePoints(), PCB_SELECTION_TOOL::updateSelection(), PNS::TOOL_BASE::updateStartItem(), PCB_SELECTION_TOOL::view(), PCB_TOOL_BASE::view(), PCB_VIEWER_TOOLS::view(), EE_SELECTION_TOOL::ZoomFitCrossProbeBBox(), PCB_SELECTION_TOOL::ZoomFitCrossProbeBBox(), PCB_SELECTION_TOOL::zoomFitSelection(), EE_SELECTION_TOOL::~EE_SELECTION_TOOL(), GERBVIEW_SELECTION_TOOL::~GERBVIEW_SELECTION_TOOL(), and PCB_SELECTION_TOOL::~PCB_SELECTION_TOOL().

getViewControls()

KIGFX::VIEW_CONTROLS * TOOL_BASE::getViewControls ( ) const

protectedinherited

Return the instance of VIEW_CONTROLS object used in the application.

It allows tools to read & modify user input and its settings (eg. show cursor, enable snapping to grid, etc.).

Returns

The instance of VIEW_CONTROLS.

Definition at line 42 of file tool_base.cpp.

{
 return m_toolMgr->GetViewControls();
}

References TOOL_MANAGER::GetViewControls(), and TOOL_BASE::m_toolMgr.

Referenced by EE_POINT_EDITOR::addCorner(), PCB_POINT_EDITOR::addCorner(), EE_POINT_EDITOR::addCornerCondition(), EE_SELECTION_TOOL::autostartEvent(), SCH_EDIT_TOOL::BreakWire(), PCB_SELECTION_TOOL::controls(), PCB_TOOL_BASE::controls(), EDIT_TOOL::copyToClipboard(), COMMON_TOOLS::CursorControl(), EDIT_TOOL::DeleteItems(), SCH_LINE_WIRE_BUS_TOOL::doDrawSegments(), EDIT_TOOL::doMoveSelection(), SCH_LINE_WIRE_BUS_TOOL::doUnfoldBus(), COMMON_TOOLS::doZoomToPreset(), EDIT_TOOL::DragArcTrack(), DRAWING_TOOL::DrawCircle(), DRAWING_TOOL::DrawLine(), MICROWAVE_TOOL::drawMicrowaveInductor(), DRAWING_TOOL::DrawRectangle(), SCH_DRAWING_TOOLS::DrawShape(), SYMBOL_EDITOR_DRAWING_TOOLS::DrawShape(), PL_DRAWING_TOOLS::DrawShape(), SCH_DRAWING_TOOLS::DrawSheet(), SYMBOL_EDITOR_EDIT_TOOL::Duplicate(), PAD_TOOL::EnumeratePads(), SCH_LINE_WIRE_BUS_TOOL::finishSegments(), SCH_EDITOR_CONTROL::HighlightNet(), BOARD_INSPECTION_TOOL::HighlightNet(), FOOTPRINT_EDITOR_CONTROL::ImportFootprint(), SCH_EDIT_TOOL::Init(), EDIT_TOOL::Init(), EE_POINT_EDITOR::Main(), EE_SELECTION_TOOL::Main(), Main(), SYMBOL_EDITOR_MOVE_TOOL::Main(), PICKER_TOOL::Main(), PL_EDIT_TOOL::Main(), PL_POINT_EDITOR::Main(), PCB_PICKER_TOOL::Main(), ROUTER_TOOL::MainLoop(), GERBVIEW_INSPECTION_TOOL::MeasureTool(), PCB_VIEWER_TOOLS::MeasureTool(), COMMON_TOOLS::OnGridChanged(), PCB_POINT_EDITOR::OnSelectionChange(), SCH_EDITOR_CONTROL::Paste(), SYMBOL_EDITOR_EDIT_TOOL::Paste(), ROUTER_TOOL::performDragging(), LENGTH_TUNER_TOOL::performTuning(), SYMBOL_EDITOR_DRAWING_TOOLS::PlaceAnchor(), PCB_CONTROL::placeBoardItems(), BOARD_EDITOR_CONTROL::PlaceFootprint(), SCH_DRAWING_TOOLS::PlaceImage(), DRAWING_TOOL::PlaceImage(), PL_DRAWING_TOOLS::PlaceItem(), SCH_DRAWING_TOOLS::PlaceSymbol(), SCH_EDIT_TOOL::Properties(), EDIT_TOOL::Properties(), SCH_EDIT_TOOL::RepeatDrawItem(), PL_SELECTION_TOOL::RequestSelection(), EE_SELECTION_TOOL::RequestSelection(), DRAWING_TOOL::Reset(), PCB_POINT_EDITOR::Reset(), COMMON_TOOLS::ResetLocalCoords(), ROUTER_TOOL::RouteSelected(), PCB_SELECTION_TOOL::selectCursor(), EE_SELECTION_TOOL::selectMultiple(), PL_SELECTION_TOOL::selectMultiple(), PCB_SELECTION_TOOL::selectMultiple(), EE_SELECTION_TOOL::SelectNode(), ZOOM_TOOL::selectRegion(), ALIGN_DISTRIBUTE_TOOL::selectTarget(), PICKER_TOOL::setControls(), PCB_PICKER_TOOL::setControls(), EE_POINT_EDITOR::setEditedPoint(), PL_POINT_EDITOR::setEditedPoint(), PCB_POINT_EDITOR::setEditedPoint(), SCH_DRAWING_TOOLS::SingleClickPlace(), SCH_DRAWING_TOOLS::TwoClickPlace(), SYMBOL_EDITOR_DRAWING_TOOLS::TwoClickPlace(), EE_POINT_EDITOR::updateEditedPoint(), PL_POINT_EDITOR::updateEditedPoint(), PCB_POINT_EDITOR::updateEditedPoint(), PCB_POINT_EDITOR::updateItem(), PL_EDIT_TOOL::updateModificationPoint(), and COMMON_TOOLS::ZoomCenter().

Go()

template<class T >

void TOOL_INTERACTIVE::Go ( int(T::*)(const TOOL_EVENT &)  aStateFunc, const TOOL_EVENT_LIST &  aConditions = TOOL_EVENT( TC_ANY, TA_ANY )  )

inherited

Define which state (aStateFunc) to go when a certain event arrives (aConditions).

No conditions means any event.

Definition at line 147 of file tool_interactive.h.

{
 TOOL_STATE_FUNC sptr = std::bind( aStateFunc, static_cast<T*>( this ), std::placeholders::_1 );
 
 goInternal( sptr, aConditions );
}

References TOOL_INTERACTIVE::goInternal().

Referenced by EDA_3D_CONTROLLER::setTransitions(), CVPCB_ASSOCIATION_TOOL::setTransitions(), CVPCB_CONTROL::setTransitions(), CVPCB_FOOTPRINT_VIEWER_SELECTION_TOOL::setTransitions(), EE_INSPECTION_TOOL::setTransitions(), EE_POINT_EDITOR::setTransitions(), EE_SELECTION_TOOL::setTransitions(), SCH_DRAWING_TOOLS::setTransitions(), SCH_EDIT_TOOL::setTransitions(), SCH_EDITOR_CONTROL::setTransitions(), SCH_FIND_REPLACE_TOOL::setTransitions(), SCH_LINE_WIRE_BUS_TOOL::setTransitions(), setTransitions(), SCH_NAVIGATE_TOOL::setTransitions(), SIMULATOR_CONTROL::setTransitions(), SYMBOL_EDITOR_CONTROL::setTransitions(), SYMBOL_EDITOR_DRAWING_TOOLS::setTransitions(), SYMBOL_EDITOR_EDIT_TOOL::setTransitions(), SYMBOL_EDITOR_MOVE_TOOL::setTransitions(), SYMBOL_EDITOR_PIN_TOOL::setTransitions(), GERBVIEW_CONTROL::setTransitions(), GERBVIEW_INSPECTION_TOOL::setTransitions(), GERBVIEW_SELECTION_TOOL::setTransitions(), COMMON_CONTROL::setTransitions(), COMMON_TOOLS::setTransitions(), PICKER_TOOL::setTransitions(), ZOOM_TOOL::setTransitions(), KICAD_MANAGER_CONTROL::setTransitions(), PL_DRAWING_TOOLS::setTransitions(), PL_EDIT_TOOL::setTransitions(), PL_EDITOR_CONTROL::setTransitions(), PL_POINT_EDITOR::setTransitions(), PL_SELECTION_TOOL::setTransitions(), AUTOPLACE_TOOL::setTransitions(), MICROWAVE_TOOL::setTransitions(), SCRIPTING_TOOL::setTransitions(), LENGTH_TUNER_TOOL::setTransitions(), ROUTER_TOOL::setTransitions(), BOARD_EDITOR_CONTROL::setTransitions(), BOARD_INSPECTION_TOOL::setTransitions(), BOARD_REANNOTATE_TOOL::setTransitions(), CONVERT_TOOL::setTransitions(), DRAWING_TOOL::setTransitions(), DRC_TOOL::setTransitions(), EDIT_TOOL::setTransitions(), FOOTPRINT_EDITOR_CONTROL::setTransitions(), GLOBAL_EDIT_TOOL::setTransitions(), GROUP_TOOL::setTransitions(), PAD_TOOL::setTransitions(), PCB_CONTROL::setTransitions(), PCB_PICKER_TOOL::setTransitions(), PCB_POINT_EDITOR::setTransitions(), PCB_SELECTION_TOOL::setTransitions(), PCB_VIEWER_TOOLS::setTransitions(), ALIGN_DISTRIBUTE_TOOL::setTransitions(), POSITION_RELATIVE_TOOL::setTransitions(), PROPERTIES_TOOL::setTransitions(), and ZONE_FILLER_TOOL::setTransitions().

goInternal()

void TOOL_INTERACTIVE::goInternal ( TOOL_STATE_FUNC &  aState, const TOOL_EVENT_LIST &  aConditions  )

privateinherited

Definition at line 70 of file tool_interactive.cpp.

{
 m_toolMgr->ScheduleNextState( this, aState, aConditions );
}

References TOOL_BASE::m_toolMgr, and TOOL_MANAGER::ScheduleNextState().

Referenced by TOOL_INTERACTIVE::Go().

Init()

bool SCH_MOVE_TOOL::Init ( )

overridevirtual

Init() is called once upon a registration of the tool.

Returns

True if the initialization went fine, false - otherwise.

Reimplemented from TOOL_BASE.

Definition at line 60 of file sch_move_tool.cpp.

{
 EE_TOOL_BASE::Init();
 
 auto moveCondition =
 []( const SELECTION& aSel )
 {
 if( aSel.Empty() || SELECTION_CONDITIONS::OnlyTypes( { SCH_MARKER_T } )( aSel ) )
 return false;
 
 if( SCH_LINE_WIRE_BUS_TOOL::IsDrawingLineWireOrBus( aSel ) )
 return false;
 
 return true;
 };
 
 // Add move actions to the selection tool menu
 //
 CONDITIONAL_MENU& selToolMenu = m_selectionTool->GetToolMenu().GetMenu();
 
 selToolMenu.AddItem( EE_ACTIONS::move, moveCondition, 150 );
 selToolMenu.AddItem( EE_ACTIONS::drag, moveCondition, 150 );
 selToolMenu.AddItem( EE_ACTIONS::alignToGrid, moveCondition, 150 );
 
 return true;
}

References CONDITIONAL_MENU::AddItem(), EE_ACTIONS::alignToGrid, EE_ACTIONS::drag, TOOL_MENU::GetMenu(), TOOL_INTERACTIVE::GetToolMenu(), EE_TOOL_BASE< T >::Init(), SCH_LINE_WIRE_BUS_TOOL::IsDrawingLineWireOrBus(), EE_TOOL_BASE< SCH_EDIT_FRAME >::m_selectionTool, EE_ACTIONS::move, SELECTION_CONDITIONS::OnlyTypes(), and SCH_MARKER_T.

IsToolActive()

bool TOOL_BASE::IsToolActive ( ) const

inherited

Definition at line 31 of file tool_base.cpp.

{
 return m_toolMgr->IsToolActive( m_toolId );
}

References TOOL_MANAGER::IsToolActive(), TOOL_BASE::m_toolId, and TOOL_BASE::m_toolMgr.

Referenced by EDIT_TOOL::Drag(), ROUTER_TOOL::handleLayerSwitch(), PCB_SELECTION_TOOL::Main(), BOARD_EDITOR_CONTROL::TrackWidthDec(), and BOARD_EDITOR_CONTROL::TrackWidthInc().

Main()

int SCH_MOVE_TOOL::Main

(

const TOOL_EVENT &

aEvent

)

Run an interactive move of the selected items, or the item under the cursor.

Definition at line 354 of file sch_move_tool.cpp.

{
 EESCHEMA_SETTINGS* cfg = Pgm().GetSettingsManager().GetAppSettings<EESCHEMA_SETTINGS>();
 KIGFX::VIEW_CONTROLS* controls = getViewControls();
 EE_GRID_HELPER grid( m_toolMgr );
 bool wasDragging = m_moveInProgress && m_isDrag;
 bool isSlice = false;
 
 m_anchorPos.reset();
 
 if( aEvent.IsAction( &EE_ACTIONS::move ) )
 m_isDrag = false;
 else if( aEvent.IsAction( &EE_ACTIONS::drag ) )
 {
 m_isDrag = true;
 isSlice = aEvent.Parameter<bool>();
 }
 else if( aEvent.IsAction( &EE_ACTIONS::moveActivate ) )
 m_isDrag = !cfg->m_Input.drag_is_move;
 else
 return 0;
 
 if( m_moveInProgress )
 {
 if( m_isDrag != wasDragging )
 {
 EDA_ITEM* sel = m_selectionTool->GetSelection().Front();
 
 if( sel && !sel->IsNew() )
 {
 // Reset the selected items so we can start again with the current m_isDrag
 // state.
 m_frame->RollbackSchematicFromUndo();
 m_selectionTool->RemoveItemsFromSel( &m_dragAdditions, QUIET_MODE );
 m_anchorPos = m_cursor - m_moveOffset;
 m_moveInProgress = false;
 controls->SetAutoPan( false );
 
 // And give it a kick so it doesn't have to wait for the first mouse movement
 // to refresh.
 m_toolMgr->RunAction( EE_ACTIONS::restartMove );
 }
 }
 else
 {
 // The tool hotkey is interpreted as a click when already dragging/moving
 m_toolMgr->RunAction( ACTIONS::cursorClick );
 }
 
 return 0;
 }
 
 if( m_inMoveTool ) // Must come after m_moveInProgress checks above...
 return 0;
 
 REENTRANCY_GUARD guard( &m_inMoveTool );
 
 // Be sure that there is at least one item that we can move. If there's no selection try
 // looking for the stuff under mouse cursor (i.e. Kicad old-style hover selection).
 EE_SELECTION& selection = m_selectionTool->RequestSelection( EE_COLLECTOR::MovableItems );
 bool unselect = selection.IsHover();
 
 // Keep an original copy of the starting points for cleanup after the move
 std::vector<DANGLING_END_ITEM> internalPoints;
 
 Activate();
 // Must be done after Activate() so that it gets set into the correct context
 controls->ShowCursor( true );
 
 m_frame->PushTool( aEvent );
 
 if( selection.Empty() )
 {
 // Note that it's important to go through push/pop even when the selection is empty.
 // This keeps other tools from having to special-case an empty move.
 m_frame->PopTool( aEvent );
 return 0;
 }
 
 bool restore_state = false;
 bool chain_commands = false;
 TOOL_EVENT copy = aEvent;
 TOOL_EVENT* evt = &copy;
 VECTOR2I prevPos;
 int snapLayer = UNDEFINED_LAYER;
 
 m_cursor = controls->GetCursorPosition();
 
 // Main loop: keep receiving events
 do
 {
 m_frame->GetCanvas()->SetCurrentCursor( KICURSOR::MOVING );
 grid.SetSnap( !evt->Modifier( MD_SHIFT ) );
 grid.SetUseGrid( getView()->GetGAL()->GetGridSnapping() && !evt->DisableGridSnapping() );
 
 if( evt->IsAction( &EE_ACTIONS::moveActivate )
 || evt->IsAction( &EE_ACTIONS::restartMove )
 || evt->IsAction( &EE_ACTIONS::move )
 || evt->IsAction( &EE_ACTIONS::drag )
 || evt->IsMotion()
 || evt->IsDrag( BUT_LEFT )
 || evt->IsAction( &ACTIONS::refreshPreview ) )
 {
 if( !m_moveInProgress ) // Prepare to start moving/dragging
 {
 SCH_ITEM* sch_item = (SCH_ITEM*) selection.Front();
 bool appendUndo = ( sch_item && sch_item->IsNew() ) || isSlice;
 bool placingNewItems = sch_item && sch_item->IsNew();
 
 //------------------------------------------------------------------------
 // Setup a drag or a move
 //
 m_dragAdditions.clear();
 m_specialCaseLabels.clear();
 m_specialCaseSheetPins.clear();
 internalPoints.clear();
 clearNewDragLines();
 
 for( SCH_ITEM* it : m_frame->GetScreen()->Items() )
 {
 it->ClearFlags( SELECTED_BY_DRAG );
 
 if( !it->IsSelected() )
 it->ClearFlags( STARTPOINT | ENDPOINT );
 }
 
 // Drag of split items start over top of their other segment so
 // we want to skip grabbing the segments we split from
 if( m_isDrag && !isSlice )
 {
 EDA_ITEMS connectedDragItems;
 
 // Add connections to the selection for a drag.
 // Do all non-labels/entries first so we don't add junctions to drag
 // when the line will eventually be drag selected.
 std::vector<SCH_ITEM*> stageTwo;
 
 for( EDA_ITEM* edaItem : selection )
 {
 SCH_ITEM* item = static_cast<SCH_ITEM*>( edaItem );
 std::vector<VECTOR2I> connections;
 
 switch( item->Type() )
 {
 case SCH_LABEL_T:
 case SCH_HIER_LABEL_T:
 case SCH_GLOBAL_LABEL_T:
 case SCH_DIRECTIVE_LABEL_T:
 stageTwo.emplace_back(item);
 break;
 
 case SCH_LINE_T:
 static_cast<SCH_LINE*>( item )->GetSelectedPoints( connections );
 break;
 default:
 connections = item->GetConnectionPoints();
 }
 
 for( const VECTOR2I& point : connections )
 getConnectedDragItems( item, point, connectedDragItems, appendUndo );
 }
 
 // Go back and get all label connections now that we can test for drag-selected
 // lines the labels might be on
 for( SCH_ITEM* item : stageTwo )
 {
 for( const VECTOR2I& point : item->GetConnectionPoints() )
 getConnectedDragItems( item, point, connectedDragItems, appendUndo );
 }
 
 for( EDA_ITEM* item : connectedDragItems )
 {
 m_dragAdditions.push_back( item->m_Uuid );
 m_selectionTool->AddItemToSel( item, QUIET_MODE );
 }
 
 // Pre-cache all connections of our selected objects so we can keep track of
 // what they were originally connected to as we drag them around
 for( EDA_ITEM* edaItem : selection )
 {
 SCH_ITEM* schItem = static_cast<SCH_ITEM*>( edaItem );
 
 if( schItem->Type() == SCH_LINE_T )
 {
 SCH_LINE* line = static_cast<SCH_LINE*>( schItem );
 
 //Also store the original angle of the line, is needed later to decide
 //which segment to extend when they've become zero length
 line->StoreAngle();
 
 for( const VECTOR2I& point : line->GetConnectionPoints() )
 getConnectedItems( line, point, m_lineConnectionCache[line] );
 }
 }
 }
 else
 {
 // Mark the edges of the block with dangling flags for a move.
 for( EDA_ITEM* item : selection )
 static_cast<SCH_ITEM*>( item )->GetEndPoints( internalPoints );
 
 for( EDA_ITEM* item : selection )
 static_cast<SCH_ITEM*>( item )->UpdateDanglingState( internalPoints );
 }
 
 // Generic setup
 //
 for( EDA_ITEM* item : selection )
 {
 if( static_cast<SCH_ITEM*>( item )->IsConnectable() )
 {
 if( snapLayer == LAYER_GRAPHICS )
 snapLayer = LAYER_ANY;
 else
 snapLayer = LAYER_CONNECTABLE;
 }
 else
 {
 if( snapLayer == LAYER_CONNECTABLE )
 snapLayer = LAYER_ANY;
 else
 snapLayer = LAYER_GRAPHICS;
 }
 
 if( item->IsNew() )
 {
 // Item was added in a previous command (and saved to undo by
 // that command)
 }
 else if( item->GetParent() && item->GetParent()->IsSelected() )
 {
 // Item will be (or has been) saved to undo by parent
 }
 else
 {
 saveCopyInUndoList( (SCH_ITEM*) item, UNDO_REDO::CHANGED, appendUndo );
 appendUndo = true;
 }
 
 SCH_ITEM* schItem = (SCH_ITEM*) item;
  schItem->SetStoredPos( schItem->GetPosition() );
 }
 
 // Set up the starting position and move/drag offset
 //
 m_cursor = controls->GetCursorPosition();
 
 if( evt->IsAction( &EE_ACTIONS::restartMove ) )
 {
 wxASSERT_MSG( m_anchorPos, "Should be already set from previous cmd" );
 }
 else if( placingNewItems )
 {
 m_anchorPos = selection.GetReferencePoint();
 }
 
 if( m_anchorPos )
 {
 VECTOR2I delta = m_cursor - (*m_anchorPos);
 bool isPasted = false;
 
 // Drag items to the current cursor position
 for( EDA_ITEM* item : selection )
 {
 // Don't double move pins, fields, etc.
 if( item->GetParent() && item->GetParent()->IsSelected() )
 continue;
 
 moveItem( item, delta );
 updateItem( item, false );
 
 isPasted |= ( item->GetFlags() & IS_PASTED ) != 0;
 item->ClearFlags( IS_PASTED );
 }
 
 // The first time pasted items are moved we need to store the position of the
 // cursor so that rotate while moving works as expected (instead of around the
 // original anchor point
 if( isPasted )
 selection.SetReferencePoint( m_cursor );
 
 m_anchorPos = m_cursor;
 }
 // For some items, moving the cursor to anchor is not good (for instance large
 // hierarchical sheets or symbols can have the anchor outside the view)
 else if( selection.Size() == 1 && !sch_item->IsMovableFromAnchorPoint() )
 {
 m_cursor = getViewControls()->GetCursorPosition( true );
 m_anchorPos = m_cursor;
 }
 else
 {
 if( m_frame->GetMoveWarpsCursor() )
 {
 // User wants to warp the mouse
 m_cursor = grid.BestDragOrigin( m_cursor, snapLayer, selection );
 selection.SetReferencePoint( m_cursor );
 }
 else
 {
 // User does not want to warp the mouse
 m_cursor = getViewControls()->GetCursorPosition( true );
 }
 }
 
 controls->SetCursorPosition( m_cursor, false );
 m_toolMgr->PostEvent( EVENTS::SelectedItemsModified );
 
 prevPos = m_cursor;
 controls->SetAutoPan( true );
 m_moveInProgress = true;
 }
 
 //------------------------------------------------------------------------
 // Follow the mouse
 //
 m_cursor = grid.BestSnapAnchor( controls->GetCursorPosition( false ),
 snapLayer, selection );
 
 VECTOR2I delta( m_cursor - prevPos );
 m_anchorPos = m_cursor;
 
 // We need to check if the movement will change the net offset direction on the
 // X an Y axes. This is because we remerge added bend lines in realtime, and we
 // also account for the direction of the move when adding bend lines. So, if the
 // move direction changes, we need to split it into a move that gets us back to
 // zero, then the rest of the move.
 std::vector<VECTOR2I> splitMoves;
 
 if( alg::signbit( m_moveOffset.x ) != alg::signbit( ( m_moveOffset + delta ).x ) )
 {
 splitMoves.emplace_back( VECTOR2I( -1 * m_moveOffset.x, 0 ) );
 splitMoves.emplace_back( VECTOR2I( delta.x + m_moveOffset.x, 0 ) );
 }
 else
 {
 splitMoves.emplace_back( VECTOR2I( delta.x, 0 ) );
 }
 
 if( alg::signbit( m_moveOffset.y ) != alg::signbit( ( m_moveOffset + delta ).y ) )
 {
 splitMoves.emplace_back( VECTOR2I( 0, -1 * m_moveOffset.y ) );
 splitMoves.emplace_back( VECTOR2I( 0, delta.y + m_moveOffset.y ) );
 }
 else
 {
 splitMoves.emplace_back( VECTOR2I( 0, delta.y ) );
 }
 
 
 m_moveOffset += delta;
 prevPos = m_cursor;
 
 // Used for tracking how far off a drag end should have its 90 degree elbow added
 int xBendCount = 1;
 int yBendCount = 1;
 
 // Split the move into X and Y moves so we can correctly drag orthogonal lines
 for( const VECTOR2I& splitDelta : splitMoves )
 {
 // Skip non-moves
 if( splitDelta == VECTOR2I( 0, 0 ) )
 continue;
 
 for( EDA_ITEM* item : selection.GetItemsSortedByTypeAndXY( ( delta.x >= 0 ),
 ( delta.y >= 0 ) ) )
 {
 // Don't double move pins, fields, etc.
 if( item->GetParent() && item->GetParent()->IsSelected() )
 continue;
 
 SCH_LINE* line = dynamic_cast<SCH_LINE*>( item );
 
 // Only partially selected drag lines in orthogonal line mode need special
 // handling
 if( m_isDrag
 && cfg->m_Drawing.line_mode != LINE_MODE::LINE_MODE_FREE
 && line
 && line->HasFlag( STARTPOINT ) != line->HasFlag( ENDPOINT ) )
 {
 orthoLineDrag( line, splitDelta, xBendCount, yBendCount, grid );
 }
 
 // Move all other items normally, including the selected end of partially
 // selected lines
 moveItem( item, splitDelta );
 updateItem( item, false );
 
 // Update any lines connected to sheet pins to the sheet pin's location
 // (which may not exactly follow the splitDelta as the pins are constrained
 // along the sheet edges.
 for( const auto& [pin, lineEnd] : m_specialCaseSheetPins )
 {
 if( lineEnd.second && lineEnd.first->HasFlag( STARTPOINT ) )
 lineEnd.first->SetStartPoint( pin->GetPosition() );
 else if( !lineEnd.second && lineEnd.first->HasFlag( ENDPOINT ) )
 lineEnd.first->SetEndPoint( pin->GetPosition() );
 }
 }
 }
 
 if( selection.HasReferencePoint() )
 selection.SetReferencePoint( selection.GetReferencePoint() + delta );
 
 m_toolMgr->PostEvent( EVENTS::SelectedItemsMoved );
 }
 
 //------------------------------------------------------------------------
 // Handle cancel
 //
 else if( evt->IsCancelInteractive() || evt->IsActivate() )
 {
 if( evt->IsCancelInteractive() )
 m_frame->GetInfoBar()->Dismiss();
 
 if( m_moveInProgress )
 {
 if( evt->IsActivate() )
 {
 // Allowing other tools to activate during a move runs the risk of race
 // conditions in which we try to spool up both event loops at once.
 
 if( m_isDrag )
 m_frame->ShowInfoBarMsg( _( "Press <ESC> to cancel drag." ) );
 else
 m_frame->ShowInfoBarMsg( _( "Press <ESC> to cancel move." ) );
 
 evt->SetPassEvent( false );
 continue;
 }
 
 evt->SetPassEvent( false );
 restore_state = true;
 }
 
 clearNewDragLines();
 
 break;
 }
 //------------------------------------------------------------------------
 // Handle TOOL_ACTION special cases
 //
 else if( evt->Action() == TA_UNDO_REDO_PRE )
 {
 unselect = true;
 break;
 }
 else if( evt->IsAction( &ACTIONS::doDelete ) )
 {
 evt->SetPassEvent();
 // Exit on a delete; there will no longer be anything to drag.
 break;
 }
 else if( evt->IsAction( &ACTIONS::duplicate ) )
 {
 if( selection.Front()->IsNew() )
 {
 // This doesn't really make sense; we'll just end up dragging a stack of
 // objects so we ignore the duplicate and just carry on.
 wxBell();
 continue;
 }
 
 // Move original back and exit. The duplicate will run in its own loop.
 restore_state = true;
 unselect = false;
 chain_commands = true;
 break;
 }
 else if( evt->IsAction( &EE_ACTIONS::rotateCW ) )
 {
 m_toolMgr->RunAction( EE_ACTIONS::rotateCW, true );
 }
 else if( evt->IsAction( &EE_ACTIONS::rotateCCW ) )
 {
 m_toolMgr->RunAction( EE_ACTIONS::rotateCCW, true );
 }
 else if( evt->Action() == TA_CHOICE_MENU_CHOICE )
 {
 if( *evt->GetCommandId() >= ID_POPUP_SCH_SELECT_UNIT_CMP
 && *evt->GetCommandId() <= ID_POPUP_SCH_SELECT_UNIT_SYM_MAX )
 {
 SCH_SYMBOL* symbol = dynamic_cast<SCH_SYMBOL*>( selection.Front() );
 int unit = *evt->GetCommandId() - ID_POPUP_SCH_SELECT_UNIT_CMP;
 
 if( symbol )
 {
 m_frame->SelectUnit( symbol, unit );
 m_toolMgr->RunAction( ACTIONS::refreshPreview );
 }
 }
 }
 else if( evt->IsAction( &EE_ACTIONS::highlightNet )
 || evt->IsAction( &EE_ACTIONS::selectOnPCB ) )
 {
 // These don't make any sense during a move. Eat them.
 }
 //------------------------------------------------------------------------
 // Handle context menu
 //
 else if( evt->IsClick( BUT_RIGHT ) )
 {
 m_menu.ShowContextMenu( m_selectionTool->GetSelection() );
 }
 //------------------------------------------------------------------------
 // Handle drop
 //
 else if( evt->IsMouseUp( BUT_LEFT )
 || evt->IsClick( BUT_LEFT )
 || evt->IsDblClick( BUT_LEFT ) )
 {
 break; // Finish
 }
 else
 {
 evt->SetPassEvent();
 }
 
 controls->SetAutoPan( m_moveInProgress );
 
 } while( ( evt = Wait() ) ); //Should be assignment not equality test
 
 // Create a selection of original selection, drag selected/changed items, and new
 // bend lines for later before we clear them in the commit. We'll need these
 // to check for new junctions needed, etc.
 EE_SELECTION selectionCopy( selection );
 
 for( SCH_LINE* line : m_newDragLines )
 selectionCopy.Add( line );
 
 for( SCH_LINE* line : m_changedDragLines )
 selectionCopy.Add( line );
 
 // Save whatever new bend lines and changed lines survived the drag
 commitDragLines();
 
 controls->ForceCursorPosition( false );
 controls->ShowCursor( false );
 controls->SetAutoPan( false );
 
 if( !chain_commands )
 m_moveOffset = { 0, 0 };
 
 m_anchorPos.reset();
 
 if( restore_state )
 {
 m_selectionTool->RemoveItemsFromSel( &m_dragAdditions, QUIET_MODE );
 m_frame->RollbackSchematicFromUndo();
 }
 else
 {
 // One last update after exiting loop (for slower stuff, such as updating SCREEN's RTree).
 for( EDA_ITEM* item : selection )
 updateItem( item, true );
 
 m_selectionTool->RemoveItemsFromSel( &m_dragAdditions, QUIET_MODE );
 
 // If we move items away from a junction, we _may_ want to add a junction there
 // to denote the state.
 for( const DANGLING_END_ITEM& it : internalPoints )
 {
 if( m_frame->GetScreen()->IsExplicitJunctionNeeded( it.GetPosition()) )
 m_frame->AddJunction( m_frame->GetScreen(), it.GetPosition(), true, false );
 }
 
 SCH_LINE_WIRE_BUS_TOOL* lwbTool = m_toolMgr->GetTool<SCH_LINE_WIRE_BUS_TOOL>();
 lwbTool->TrimOverLappingWires( &selectionCopy );
 lwbTool->AddJunctionsIfNeeded( &selectionCopy );
 
 // This needs to run prior to `RecalculateConnections` because we need to identify
 // the lines that are newly dangling
 if( m_isDrag && !isSlice )
 trimDanglingLines();
 
 // Auto-rotate any moved labels
 for( EDA_ITEM* item : selection )
 m_frame->AutoRotateItem( m_frame->GetScreen(), static_cast<SCH_ITEM*>( item ) );
 
 m_frame->SchematicCleanUp();
 m_frame->OnModify();
 }
 
 for( EDA_ITEM* item : m_frame->GetScreen()->Items() )
 item->ClearEditFlags();
 
 // ensure any selected item not in screen main list (for instance symbol fields)
 // has its edit flags cleared
 for( EDA_ITEM* item : selectionCopy )
 item->ClearEditFlags();
 
 if( unselect )
 m_toolMgr->RunAction( EE_ACTIONS::clearSelection, true );
 else
 m_selectionTool->RebuildSelection(); // Schematic cleanup might have merged lines, etc.
 
 m_dragAdditions.clear();
 m_lineConnectionCache.clear();
 m_moveInProgress = false;
 m_frame->PopTool( aEvent );
 
 return 0;
}

References _, TOOL_EVENT::Action(), TOOL_INTERACTIVE::Activate(), SELECTION::Add(), SELECTION_TOOL::AddItemToSel(), SCH_EDIT_FRAME::AddJunction(), SCH_LINE_WIRE_BUS_TOOL::AddJunctionsIfNeeded(), SCH_EDIT_FRAME::AutoRotateItem(), BUT_LEFT, BUT_RIGHT, CHANGED, clearNewDragLines(), EE_ACTIONS::clearSelection, commitDragLines(), copy, ACTIONS::cursorClick, delta, TOOL_EVENT::DisableGridSnapping(), WX_INFOBAR::Dismiss(), ACTIONS::doDelete, EE_ACTIONS::drag, EESCHEMA_SETTINGS::INPUT::drag_is_move, ACTIONS::duplicate, SELECTION::Empty(), ENDPOINT, SELECTION::Front(), SCH_BASE_FRAME::GetCanvas(), TOOL_EVENT::GetCommandId(), getConnectedDragItems(), getConnectedItems(), SCH_ITEM::GetConnectionPoints(), SCH_LINE::GetConnectionPoints(), KIGFX::VIEW_CONTROLS::GetCursorPosition(), EDA_BASE_FRAME::GetInfoBar(), SELECTION::GetItemsSortedByTypeAndXY(), TOOLS_HOLDER::GetMoveWarpsCursor(), EDA_ITEM::GetPosition(), SELECTION::GetReferencePoint(), SCH_EDIT_FRAME::GetScreen(), EE_SELECTION_TOOL::GetSelection(), TOOL_MANAGER::GetTool(), TOOL_BASE::getView(), TOOL_BASE::getViewControls(), grid, EDA_ITEM::HasFlag(), SELECTION::HasReferencePoint(), EE_ACTIONS::highlightNet, ID_POPUP_SCH_SELECT_UNIT_CMP, ID_POPUP_SCH_SELECT_UNIT_SYM_MAX, IS_PASTED, TOOL_EVENT::IsAction(), TOOL_EVENT::IsActivate(), TOOL_EVENT::IsCancelInteractive(), TOOL_EVENT::IsClick(), SCH_ITEM::IsConnectable(), TOOL_EVENT::IsDblClick(), TOOL_EVENT::IsDrag(), SCH_SCREEN::IsExplicitJunctionNeeded(), SELECTION::IsHover(), TOOL_EVENT::IsMotion(), TOOL_EVENT::IsMouseUp(), SCH_ITEM::IsMovableFromAnchorPoint(), EDA_ITEM::IsNew(), SCH_SCREEN::Items(), LAYER_ANY, LAYER_CONNECTABLE, LAYER_GRAPHICS, EESCHEMA_SETTINGS::DRAWING::line_mode, LINE_MODE_FREE, m_anchorPos, m_changedDragLines, m_cursor, m_dragAdditions, EESCHEMA_SETTINGS::m_Drawing, EE_TOOL_BASE< SCH_EDIT_FRAME >::m_frame, m_inMoveTool, EESCHEMA_SETTINGS::m_Input, m_isDrag, m_lineConnectionCache, TOOL_INTERACTIVE::m_menu, m_moveInProgress, m_moveOffset, m_newDragLines, EE_TOOL_BASE< SCH_EDIT_FRAME >::m_selectionTool, m_specialCaseLabels, m_specialCaseSheetPins, TOOL_BASE::m_toolMgr, MD_SHIFT, TOOL_EVENT::Modifier(), EE_COLLECTOR::MovableItems, EE_ACTIONS::move, EE_ACTIONS::moveActivate, moveItem(), MOVING, SCH_EDIT_FRAME::OnModify(), orthoLineDrag(), TOOL_EVENT::Parameter(), Pgm(), pin, TOOLS_HOLDER::PopTool(), TOOL_MANAGER::PostEvent(), TOOLS_HOLDER::PushTool(), QUIET_MODE, EE_SELECTION_TOOL::RebuildSelection(), ACTIONS::refreshPreview, SELECTION_TOOL::RemoveItemsFromSel(), EE_SELECTION_TOOL::RequestSelection(), EE_ACTIONS::restartMove, SCH_EDIT_FRAME::RollbackSchematicFromUndo(), EE_ACTIONS::rotateCCW, EE_ACTIONS::rotateCW, TOOL_MANAGER::RunAction(), EE_TOOL_BASE< SCH_EDIT_FRAME >::saveCopyInUndoList(), SCH_DIRECTIVE_LABEL_T, SCH_GLOBAL_LABEL_T, SCH_HIER_LABEL_T, SCH_LABEL_T, SCH_LINE_T, SCH_EDIT_FRAME::SchematicCleanUp(), SELECTED_BY_DRAG, EVENTS::SelectedItemsModified, EVENTS::SelectedItemsMoved, EE_ACTIONS::selectOnPCB, SCH_EDIT_FRAME::SelectUnit(), EDA_DRAW_PANEL_GAL::SetCurrentCursor(), TOOL_EVENT::SetPassEvent(), SELECTION::SetReferencePoint(), SCH_ITEM::SetStoredPos(), TOOL_MENU::ShowContextMenu(), EDA_BASE_FRAME::ShowInfoBarMsg(), alg::signbit(), STARTPOINT, SCH_LINE::StoreAngle(), TA_CHOICE_MENU_CHOICE, TA_UNDO_REDO_PRE, trimDanglingLines(), SCH_LINE_WIRE_BUS_TOOL::TrimOverLappingWires(), EDA_ITEM::Type(), UNDEFINED_LAYER, EE_TOOL_BASE< SCH_EDIT_FRAME >::updateItem(), TOOL_INTERACTIVE::Wait(), VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by setTransitions().

moveItem()

void SCH_MOVE_TOOL::moveItem ( EDA_ITEM *  aItem, const VECTOR2I &  aDelta  )

private

Find additional items for a drag operation.

Connected items with no wire are included (as there is no wire to adjust for the drag). Connected wires are included with any un-connected ends flagged (STARTPOINT or ENDPOINT).

Definition at line 1492 of file sch_move_tool.cpp.

{
 switch( aItem->Type() )
 {
 case SCH_LINE_T:
 {
 SCH_LINE* line = static_cast<SCH_LINE*>( aItem );
 
 if( aItem->HasFlag( STARTPOINT ) || !m_isDrag )
 line->MoveStart( aDelta );
 
 if( aItem->HasFlag( ENDPOINT ) || !m_isDrag )
 line->MoveEnd( aDelta );
 
 break;
 }
 
 case SCH_PIN_T:
 case SCH_FIELD_T:
 {
 SCH_ITEM* parent = (SCH_ITEM*) aItem->GetParent();
 VECTOR2I delta( aDelta );
 
 if( parent && parent->Type() == SCH_SYMBOL_T )
 {
 SCH_SYMBOL* symbol = (SCH_SYMBOL*) aItem->GetParent();
 TRANSFORM transform = symbol->GetTransform().InverseTransform();
 
 delta = transform.TransformCoordinate( delta );
 }
 
 static_cast<SCH_ITEM*>( aItem )->Move( delta );
 
 // If we're moving a field with respect to its parent then it's no longer auto-placed
 if( aItem->Type() == SCH_FIELD_T && parent && !parent->IsSelected() )
 parent->ClearFieldsAutoplaced();
 
 break;
 }
 
 case SCH_SHEET_PIN_T:
 {
 SCH_SHEET_PIN* pin = (SCH_SHEET_PIN*) aItem;
 
 pin->SetStoredPos( pin->GetStoredPos() + aDelta );
 pin->ConstrainOnEdge( pin->GetStoredPos() );
 break;
 }
 
 case SCH_LABEL_T:
 case SCH_DIRECTIVE_LABEL_T:
 case SCH_GLOBAL_LABEL_T:
 case SCH_HIER_LABEL_T:
 {
 SCH_LABEL_BASE* label = static_cast<SCH_LABEL_BASE*>( aItem );
 
 if( m_specialCaseLabels.count( label ) )
 {
 SPECIAL_CASE_LABEL_INFO info = m_specialCaseLabels[ label ];
 SEG currentLine( info.attachedLine->GetStartPoint(), info.attachedLine->GetEndPoint() );
 label->SetPosition( currentLine.NearestPoint( info.originalLabelPos ) );
 }
 else
 {
 label->Move( aDelta );
 }
 
 break;
 }
 
 default:
 static_cast<SCH_ITEM*>( aItem )->Move( aDelta );
 break;
 }
 
 aItem->SetFlags( IS_MOVING );
}

References SCH_ITEM::ClearFieldsAutoplaced(), delta, ENDPOINT, EDA_ITEM::GetParent(), SCH_SYMBOL::GetTransform(), EDA_ITEM::HasFlag(), info, TRANSFORM::InverseTransform(), IS_MOVING, EDA_ITEM::IsSelected(), m_isDrag, m_specialCaseLabels, SCH_LABEL_BASE::Move(), SCH_LINE::MoveEnd(), SCH_LINE::MoveStart(), SEG::NearestPoint(), pin, SCH_DIRECTIVE_LABEL_T, SCH_FIELD_T, SCH_GLOBAL_LABEL_T, SCH_HIER_LABEL_T, SCH_LABEL_T, SCH_LINE_T, SCH_PIN_T, SCH_SHEET_PIN_T, SCH_SYMBOL_T, EDA_ITEM::SetFlags(), SCH_TEXT::SetPosition(), STARTPOINT, TRANSFORM::TransformCoordinate(), and EDA_ITEM::Type().

Referenced by AlignElements(), and Main().

orthoLineDrag()

void SCH_MOVE_TOOL::orthoLineDrag ( SCH_LINE *  line, const VECTOR2I &  splitDelta, int &  xBendCount, int &  yBendCount, const EE_GRID_HELPER &  grid  )

private

Saves the new drag lines to the undo list.

Definition at line 88 of file sch_move_tool.cpp.

{
 // If the move is not the same angle as this move, then we need to do something special with
 // the unselected end to maintain orthogonality. Either drag some connected line that is the
 // same angle as the move or add two lines to make a 90 degree connection
 if( !EDA_ANGLE( splitDelta ).IsParallelTo( line->Angle() ) || line->GetLength() == 0 )
 {
 VECTOR2I unselectedEnd = line->HasFlag( STARTPOINT ) ? line->GetEndPoint()
 : line->GetStartPoint();
 VECTOR2I selectedEnd = line->HasFlag( STARTPOINT ) ? line->GetStartPoint()
 : line->GetEndPoint();
 
 // Look for pre-existing lines we can drag with us instead of creating new ones
 bool foundAttachment = false;
 bool foundJunction = false;
 bool foundPin = false;
 SCH_LINE* foundLine = nullptr;
 
 for( EDA_ITEM* cItem : m_lineConnectionCache[line] )
 {
 foundAttachment = true;
 
 // If the move is the same angle as a connected line, we can shrink/extend that line
 // endpoint
 switch( cItem->Type() )
 {
 case SCH_LINE_T:
 {
 SCH_LINE* cLine = static_cast<SCH_LINE*>( cItem );
 
 // A matching angle on a non-zero-length line means lengthen/shorten will work
 if( EDA_ANGLE( splitDelta ).IsParallelTo( cLine->Angle() )
 && cLine->GetLength() != 0 )
 {
 foundLine = cLine;
 }
 
 // Zero length lines are lines that this algorithm has shortened to 0 so they also
 // work but we should prefer using a segment with length and angle matching when
 // we can (otherwise the zero length line will draw overlapping segments on them)
 if( !foundLine && cLine->GetLength() == 0 )
 foundLine = cLine;
 
 break;
 }
 case SCH_JUNCTION_T:
 foundJunction = true;
 break;
 
 case SCH_PIN_T:
 foundPin = true;
 break;
 
 default:
 break;
 }
 }
 
 // Ok... what if our original line is length zero from moving in its direction, and the
 // last added segment of the 90 bend we are connected to is zero from moving it in its
 // direction after it was added?
 //
 // If we are moving in original direction, we should lengthen the original drag wire.
 // Otherwise we should lengthen the new wire.
 bool preferOriginalLine = false;
 
 if( foundLine
 && foundLine->GetLength() == 0
 && line->GetLength() == 0
 && EDA_ANGLE( splitDelta ).IsParallelTo( line->GetStoredAngle() ) )
 {
 preferOriginalLine = true;
 }
 // If we have found an attachment, but not a line, we want to check if it's a junction.
 // These are special-cased and get a single line added instead of a 90-degree bend. Except
 // when we're on a pin, because pins always need bends, and junctions are just added to
 // pins for visual clarity.
 else if( !foundLine && foundJunction && !foundPin )
 {
 // Create a new wire ending at the unselected end
 foundLine = new SCH_LINE( unselectedEnd, line->GetLayer() );
 foundLine->SetFlags( IS_NEW );
 foundLine->SetLastResolvedState( line );
 m_frame->AddToScreen( foundLine, m_frame->GetScreen() );
 m_newDragLines.insert( foundLine );
 
 // We just broke off of the existing items, so replace all of them with our new
 // end connection.
 m_lineConnectionCache[foundLine] = m_lineConnectionCache[line];
 m_lineConnectionCache[line].clear();
 m_lineConnectionCache[line].emplace_back( foundLine );
 }
 
 // We want to drag our found line if it's in the same angle as the move or zero length,
 // but if the original drag line is also zero and the same original angle we should extend
 // that one first
 if( foundLine && !preferOriginalLine )
 {
 // Move the connected line found oriented in the direction of our move.
 //
 // Make sure we grab the right endpoint, it's not always STARTPOINT since the user can
 // draw a box of lines. We need to only move one though, and preferably the start point,
 // in case we have a zero length line that we are extending (we want the foundLine
 // start point to be attached to the unselected end of our drag line).
 //
 // Also, new lines are added already so they'll be in the undo list, skip adding them.
 if( !foundLine->HasFlag( IS_CHANGED ) && !foundLine->HasFlag( IS_NEW ) )
 {
 saveCopyInUndoList( (SCH_ITEM*) foundLine, UNDO_REDO::CHANGED, true );
 
 if( !foundLine->IsSelected() )
 m_changedDragLines.insert( foundLine );
 }
 
 if( foundLine->GetStartPoint() == unselectedEnd )
 foundLine->MoveStart( splitDelta );
 else if( foundLine->GetEndPoint() == unselectedEnd )
 foundLine->MoveEnd( splitDelta );
 
 updateItem( foundLine, true );
 
 
 SCH_LINE* bendLine = nullptr;
 
 if( m_lineConnectionCache.count( foundLine ) == 1
 && m_lineConnectionCache[foundLine][0]->Type() == SCH_LINE_T )
 {
 bendLine = static_cast<SCH_LINE*>( m_lineConnectionCache[foundLine][0] );
 }
 
 // Remerge segments we've created if this is a segment that we've added whose only
 // other connection is also an added segment
 //
 // bendLine is first added segment at the original attachment point, foundLine is the
 // orthogonal line between bendLine and this line
 if( foundLine->HasFlag( IS_NEW )
 && foundLine->GetLength() == 0
 && bendLine && bendLine->HasFlag( IS_NEW ) )
 {
 if( line->HasFlag( STARTPOINT ) )
 line->SetEndPoint( bendLine->GetEndPoint() );
 else
 line->SetStartPoint( bendLine->GetEndPoint() );
 
 // Update our cache of the connected items.
 
 // First, re-attach our drag labels to the original line being re-merged.
 for( EDA_ITEM* candidate : m_lineConnectionCache[bendLine] )
 {
 SCH_LABEL_BASE* label = dynamic_cast<SCH_LABEL_BASE*>( candidate );
 
 if( label && m_specialCaseLabels.count( label ) )
 m_specialCaseLabels[label].attachedLine = line;
 }
 
 m_lineConnectionCache[line] = m_lineConnectionCache[bendLine];
 m_lineConnectionCache[bendLine].clear();
 m_lineConnectionCache[foundLine].clear();
 
 m_frame->RemoveFromScreen( bendLine, m_frame->GetScreen() );
 m_frame->RemoveFromScreen( foundLine, m_frame->GetScreen() );
 
 m_newDragLines.erase( bendLine );
 m_newDragLines.erase( foundLine );
 
 delete bendLine;
 delete foundLine;
 }
 //Ok, move the unselected end of our item
 else
 {
 if( line->HasFlag( STARTPOINT ) )
 line->MoveEnd( splitDelta );
 else
 line->MoveStart( splitDelta );
 }
 
 updateItem( line, true );
 }
 else if( line->GetLength() == 0 )
 {
 // We didn't find another line to shorten/lengthen, (or we did but it's also zero)
 // so now is a good time to use our existing zero-length original line
 }
 // Either no line was at the "right" angle, or this was a junction, pin, sheet, etc. We
 // need to add segments to keep the soon-to-move unselected end connected to these items.
 //
 // To keep our drag selections all the same, we'll move our unselected end point and then
 // put wires between it and its original endpoint.
 else if( foundAttachment && line->IsOrthogonal() )
 {
 // The bend counter handles a group of wires all needing their offset one grid movement
 // further out from each other to not overlap. The absolute value stuff finds the
 // direction of the line and hence the the bend increment on that axis
 unsigned int xMoveBit = splitDelta.x != 0;
 unsigned int yMoveBit = splitDelta.y != 0;
 int xLength = abs( unselectedEnd.x - selectedEnd.x );
 int yLength = abs( unselectedEnd.y - selectedEnd.y );
 int xMove = ( xLength - ( xBendCount * grid.GetGrid().x ) )
 * sign( selectedEnd.x - unselectedEnd.x );
 int yMove = ( yLength - ( yBendCount * grid.GetGrid().y ) )
 * sign( selectedEnd.y - unselectedEnd.y );
 
 // Create a new wire ending at the unselected end, we'll move the new wire's start
 // point to the unselected end
 SCH_LINE* a = new SCH_LINE( unselectedEnd, line->GetLayer() );
 a->MoveStart( VECTOR2I( xMove, yMove ) );
 a->SetFlags( IS_NEW );
 a->SetConnectivityDirty( true );
 a->SetLastResolvedState( line );
 m_frame->AddToScreen( a, m_frame->GetScreen() );
 m_newDragLines.insert( a );
 
 SCH_LINE* b = new SCH_LINE( a->GetStartPoint(), line->GetLayer() );
 b->MoveStart( VECTOR2I( splitDelta.x, splitDelta.y ) );
 b->SetFlags( IS_NEW | STARTPOINT );
 b->SetConnectivityDirty( true );
 b->SetLastResolvedState( line );
 m_frame->AddToScreen( b, m_frame->GetScreen() );
 m_newDragLines.insert( b );
 
 xBendCount += yMoveBit;
 yBendCount += xMoveBit;
 
 // Ok move the unselected end of our item
 if( line->HasFlag( STARTPOINT ) )
 {
 line->MoveEnd( VECTOR2I( splitDelta.x ? splitDelta.x : xMove,
 splitDelta.y ? splitDelta.y : yMove ) );
 }
 else
 {
 line->MoveStart( VECTOR2I( splitDelta.x ? splitDelta.x : xMove,
 splitDelta.y ? splitDelta.y : yMove ) );
 }
 
 // Update our cache of the connected items. First, attach our drag labels to the line
 // left behind.
 for( EDA_ITEM* candidate : m_lineConnectionCache[line] )
 {
 SCH_LABEL_BASE* label = dynamic_cast<SCH_LABEL_BASE*>( candidate );
 
 if( label && m_specialCaseLabels.count( label ) )
 m_specialCaseLabels[label].attachedLine = a;
 }
 
 // We just broke off of the existing items, so replace all of them with our new end
 // connection.
 m_lineConnectionCache[a] = m_lineConnectionCache[line];
 m_lineConnectionCache[b].emplace_back( a );
 m_lineConnectionCache[line].clear();
 m_lineConnectionCache[line].emplace_back( b );
 }
 // Original line has no attachments, just move the unselected end
 else if( !foundAttachment )
 {
 if( line->HasFlag( STARTPOINT ) )
 line->MoveEnd( splitDelta );
 else
 line->MoveStart( splitDelta );
 }
 }
}

References std::abs(), SCH_BASE_FRAME::AddToScreen(), SCH_LINE::Angle(), CHANGED, SCH_LINE::GetEndPoint(), SCH_LINE::GetLength(), SCH_EDIT_FRAME::GetScreen(), SCH_LINE::GetStartPoint(), grid, EDA_ITEM::HasFlag(), IS_CHANGED, IS_NEW, EDA_ANGLE::IsParallelTo(), EDA_ITEM::IsSelected(), m_changedDragLines, EE_TOOL_BASE< SCH_EDIT_FRAME >::m_frame, m_lineConnectionCache, m_newDragLines, m_specialCaseLabels, SCH_LINE::MoveEnd(), SCH_LINE::MoveStart(), SCH_BASE_FRAME::RemoveFromScreen(), EE_TOOL_BASE< SCH_EDIT_FRAME >::saveCopyInUndoList(), SCH_JUNCTION_T, SCH_LINE_T, SCH_PIN_T, SCH_ITEM::SetConnectivityDirty(), SCH_LINE::SetEndPoint(), EDA_ITEM::SetFlags(), SCH_LINE::SetLastResolvedState(), sign(), STARTPOINT, EE_TOOL_BASE< SCH_EDIT_FRAME >::updateItem(), VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by Main().

Reset()

void EE_TOOL_BASE< SCH_EDIT_FRAME >::Reset ( RESET_REASON  aReason )

inlineoverridevirtualinherited

Bring the tool to a known, initial state.

If the tool claimed anything from the model or the view, it must release it when its reset.

Parameters

aReason

contains information about the reason of tool reset.

Implements TOOL_BASE.

Definition at line 86 of file ee_tool_base.h.

 {
 if( aReason == MODEL_RELOAD )
 {
 // Init variables used by every drawing tool
 m_frame = getEditFrame<T>();
 m_isSymbolEditor = dynamic_cast<SYMBOL_EDIT_FRAME*>( m_frame ) != nullptr;
 }
 
 m_view = static_cast<KIGFX::SCH_VIEW*>( getView() );
 }

resetTransitions()

void TOOL_INTERACTIVE::resetTransitions ( )

privateinherited

Clear the current transition map and restores the default one created by setTransitions().

Definition at line 63 of file tool_interactive.cpp.

{
 m_toolMgr->ClearTransitions( this );
 setTransitions();
}

References TOOL_MANAGER::ClearTransitions(), TOOL_BASE::m_toolMgr, and TOOL_INTERACTIVE::setTransitions().

RunMainStack()

void TOOL_INTERACTIVE::RunMainStack ( std::function< void()>  aFunc )

inherited

Call a function using the main stack.

Parameters

aFunc

is the function to be calls.

Definition at line 87 of file tool_interactive.cpp.

{
 m_toolMgr->RunMainStack( this, std::move( aFunc ) );
}

References TOOL_BASE::m_toolMgr, and TOOL_MANAGER::RunMainStack().

Referenced by DRAWING_TOOL::PlaceText().

saveCopyInUndoList()

void EE_TOOL_BASE< SCH_EDIT_FRAME >::saveCopyInUndoList ( EDA_ITEM *  aItem, UNDO_REDO  aType, bool  aAppend = false, bool  aDirtyConnectivity = true  )

inlineprotectedinherited

Definition at line 134 of file ee_tool_base.h.

 {
 wxASSERT( aItem );
 
 KICAD_T itemType = aItem->Type();
 bool selected = aItem->IsSelected();
 
 // IS_SELECTED flag should not be set on undo items which were added for
 // a drag operation.
 if( selected && aItem->HasFlag( SELECTED_BY_DRAG ) )
 aItem->ClearSelected();
 
 if( m_isSymbolEditor )
 {
 SYMBOL_EDIT_FRAME* editFrame = dynamic_cast<SYMBOL_EDIT_FRAME*>( m_frame );
 wxCHECK_RET( editFrame, wxT( "editFrame is null" ) );
 
 editFrame->SaveCopyInUndoList( static_cast<LIB_ITEM*>( aItem ), aType, aAppend );
 }
 else
 {
 SCH_EDIT_FRAME* editFrame = dynamic_cast<SCH_EDIT_FRAME*>( m_frame );
 wxASSERT( editFrame );
 
 if( editFrame )
 {
 if( itemType == SCH_FIELD_T )
 {
 editFrame->SaveCopyInUndoList( editFrame->GetScreen(),
  static_cast<SCH_ITEM*>( aItem->GetParent() ),
 UNDO_REDO::CHANGED, aAppend,
 false );
 }
 else if( itemType == SCH_PIN_T || itemType == SCH_SHEET_PIN_T )
 {
 editFrame->SaveCopyInUndoList( editFrame->GetScreen(),
 static_cast<SCH_ITEM*>( aItem->GetParent() ),
 UNDO_REDO::CHANGED, aAppend,
 aDirtyConnectivity );
 }
 else
 {
 editFrame->SaveCopyInUndoList( editFrame->GetScreen(),
 static_cast<SCH_ITEM*>( aItem ), aType,
 aAppend, aDirtyConnectivity );
 }
 }
 }
 
 if( selected && aItem->HasFlag( SELECTED_BY_DRAG ) )
  aItem->SetSelected();
 }

SetContextMenu()

void TOOL_INTERACTIVE::SetContextMenu ( ACTION_MENU *  aMenu, CONTEXT_MENU_TRIGGER  aTrigger = CMENU_BUTTON  )

inherited

Assign a context menu and tells when it should be activated.

Parameters

aMenu	is the menu to be assigned.
aTrigger	determines conditions upon which the context menu is activated.

Definition at line 76 of file tool_interactive.cpp.

{
 if( aMenu )
 aMenu->SetTool( this );
 else
 aTrigger = CMENU_OFF;
 
 m_toolMgr->ScheduleContextMenu( this, aMenu, aTrigger );
}

References CMENU_OFF, TOOL_BASE::m_toolMgr, TOOL_MANAGER::ScheduleContextMenu(), and ACTION_MENU::SetTool().

Referenced by SELECTION_TOOL::doSelectionMenu(), TOOL_MENU::ShowContextMenu(), and SCH_LINE_WIRE_BUS_TOOL::UnfoldBus().

setTransitions()

void SCH_MOVE_TOOL::setTransitions ( )

overrideprivatevirtual

Cleanup dangling lines left after a drag.

Implements TOOL_INTERACTIVE.

Definition at line 1778 of file sch_move_tool.cpp.

{
 Go( &SCH_MOVE_TOOL::Main, EE_ACTIONS::moveActivate.MakeEvent() );
 Go( &SCH_MOVE_TOOL::Main, EE_ACTIONS::move.MakeEvent() );
 Go( &SCH_MOVE_TOOL::Main, EE_ACTIONS::drag.MakeEvent() );
 Go( &SCH_MOVE_TOOL::AlignElements, EE_ACTIONS::alignToGrid.MakeEvent() );
}

References AlignElements(), EE_ACTIONS::alignToGrid, EE_ACTIONS::drag, TOOL_INTERACTIVE::Go(), Main(), EE_ACTIONS::move, and EE_ACTIONS::moveActivate.

trimDanglingLines()

void SCH_MOVE_TOOL::trimDanglingLines ( )

private

Definition at line 959 of file sch_move_tool.cpp.

{
 // Need a local cleanup first to ensure we remove unneeded junctions
 m_frame->SchematicCleanUp( m_frame->GetScreen() );
 
 std::set<SCH_ITEM*> danglers;
 
 std::function<void( SCH_ITEM* )> changeHandler =
 [&]( SCH_ITEM* aChangedItem ) -> void
 {
 m_toolMgr->GetView()->Update( aChangedItem, KIGFX::REPAINT );
 
 // Delete newly dangling lines:
 // Find split segments (one segment is new, the other is changed) that
 // we aren't dragging and don't have selected
 if( aChangedItem->HasFlag( IS_BROKEN) && aChangedItem->IsDangling() && !aChangedItem->IsSelected() )
 {
 danglers.insert( aChangedItem );
 }
 };
 
 m_frame->GetScreen()->TestDanglingEnds( nullptr, &changeHandler );
 
 for( SCH_ITEM* line : danglers )
 {
 line->SetFlags( STRUCT_DELETED );
 saveCopyInUndoList( line, UNDO_REDO::DELETED, true );
 
 updateItem( line, false );
 
 m_frame->RemoveFromScreen( line, m_frame->GetScreen() );
 }
}

References DELETED, SCH_EDIT_FRAME::GetScreen(), TOOL_MANAGER::GetView(), IS_BROKEN, EE_TOOL_BASE< SCH_EDIT_FRAME >::m_frame, TOOL_BASE::m_toolMgr, SCH_BASE_FRAME::RemoveFromScreen(), KIGFX::REPAINT, EE_TOOL_BASE< SCH_EDIT_FRAME >::saveCopyInUndoList(), SCH_EDIT_FRAME::SchematicCleanUp(), STRUCT_DELETED, SCH_SCREEN::TestDanglingEnds(), KIGFX::VIEW::Update(), and EE_TOOL_BASE< SCH_EDIT_FRAME >::updateItem().

Referenced by Main().

updateItem()

void EE_TOOL_BASE< SCH_EDIT_FRAME >::updateItem ( EDA_ITEM *  aItem, bool  aUpdateRTree  ) const

inlineprotectedinherited

Similar to getView()->Update(), but handles items that are redrawn by their parents and updating the SCH_SCREEN's RTree.

Similar to m_frame->SaveCopyInUndoList(), but handles items that are owned by their parents.

Definition at line 103 of file ee_tool_base.h.

Wait()

TOOL_EVENT * TOOL_INTERACTIVE::Wait ( const TOOL_EVENT_LIST &  aEventList = TOOL_EVENT( TC_ANY, TA_ANY ) )

inherited

Suspend execution of the tool until an event specified in aEventList arrives.

No parameters means waiting for any event.

Definition at line 57 of file tool_interactive.cpp.

{
 return m_toolMgr->ScheduleWait( this, aEventList );
}

References TOOL_BASE::m_toolMgr, and TOOL_MANAGER::ScheduleWait().

Referenced by SCH_LINE_WIRE_BUS_TOOL::doDrawSegments(), PCB_TOOL_BASE::doInteractiveItemPlacement(), EDIT_TOOL::doMoveSelection(), SELECTION_TOOL::doSelectionMenu(), EDIT_TOOL::DragArcTrack(), DRAWING_TOOL::drawArc(), DRAWING_TOOL::DrawDimension(), MICROWAVE_TOOL::drawMicrowaveInductor(), SCH_DRAWING_TOOLS::DrawShape(), SYMBOL_EDITOR_DRAWING_TOOLS::DrawShape(), PL_DRAWING_TOOLS::DrawShape(), DRAWING_TOOL::drawShape(), SCH_DRAWING_TOOLS::DrawSheet(), DRAWING_TOOL::DrawZone(), PAD_TOOL::EnumeratePads(), ROUTER_TOOL::InlineDrag(), DRAWING_TOOL::InteractivePlaceWithPreview(), EDA_3D_CONTROLLER::Main(), CVPCB_CONTROL::Main(), CVPCB_FOOTPRINT_VIEWER_SELECTION_TOOL::Main(), EE_POINT_EDITOR::Main(), EE_SELECTION_TOOL::Main(), Main(), SYMBOL_EDITOR_MOVE_TOOL::Main(), GERBVIEW_SELECTION_TOOL::Main(), PICKER_TOOL::Main(), ZOOM_TOOL::Main(), PL_EDIT_TOOL::Main(), PL_POINT_EDITOR::Main(), PL_SELECTION_TOOL::Main(), PCB_PICKER_TOOL::Main(), PCB_SELECTION_TOOL::Main(), LENGTH_TUNER_TOOL::MainLoop(), ROUTER_TOOL::MainLoop(), GERBVIEW_INSPECTION_TOOL::MeasureTool(), PCB_VIEWER_TOOLS::MeasureTool(), PCB_POINT_EDITOR::OnSelectionChange(), ROUTER_TOOL::performDragging(), ROUTER_TOOL::performRouting(), LENGTH_TUNER_TOOL::performTuning(), EDIT_TOOL::pickReferencePoint(), SYMBOL_EDITOR_DRAWING_TOOLS::PlaceAnchor(), BOARD_EDITOR_CONTROL::PlaceFootprint(), SCH_DRAWING_TOOLS::PlaceImage(), DRAWING_TOOL::PlaceImage(), DRAWING_TOOL::PlaceImportedGraphics(), PL_DRAWING_TOOLS::PlaceItem(), SCH_DRAWING_TOOLS::PlaceSymbol(), DRAWING_TOOL::PlaceText(), EE_SELECTION_TOOL::selectMultiple(), PL_SELECTION_TOOL::selectMultiple(), PCB_SELECTION_TOOL::selectMultiple(), PCB_SELECTION_TOOL::selectPoint(), POSITION_RELATIVE_TOOL::SelectPositionRelativeItem(), ZOOM_TOOL::selectRegion(), DRAWING_TOOL::SetAnchor(), SCH_DRAWING_TOOLS::SingleClickPlace(), SCH_DRAWING_TOOLS::TwoClickPlace(), SYMBOL_EDITOR_DRAWING_TOOLS::TwoClickPlace(), and SCH_LINE_WIRE_BUS_TOOL::UnfoldBus().

Member Data Documentation

m_anchorPos

OPT_VECTOR2I SCH_MOVE_TOOL::m_anchorPos

private

Definition at line 114 of file sch_move_tool.h.

Referenced by Main().

m_changedDragLines

std::unordered_set<SCH_LINE*> SCH_MOVE_TOOL::m_changedDragLines

private

Used for chaining commands.

Definition at line 105 of file sch_move_tool.h.

Referenced by commitDragLines(), Main(), and orthoLineDrag().

m_cursor

VECTOR2I SCH_MOVE_TOOL::m_cursor

private

Definition at line 112 of file sch_move_tool.h.

Referenced by Main().

m_dragAdditions

std::vector<KIID> SCH_MOVE_TOOL::m_dragAdditions

private

Cache of the line's original connections before dragging started.

Definition at line 99 of file sch_move_tool.h.

Referenced by Main().

m_frame

SCH_EDIT_FRAME * EE_TOOL_BASE< SCH_EDIT_FRAME >::m_frame

protectedinherited

Definition at line 189 of file ee_tool_base.h.

m_inMoveTool

bool SCH_MOVE_TOOL::m_inMoveTool

private

< Re-entrancy guard

Flag determining if anything is being dragged right now

Definition at line 92 of file sch_move_tool.h.

Referenced by Main().

m_isDrag

bool SCH_MOVE_TOOL::m_isDrag

private

Items (such as wires) which were added to the selection for a drag.

Definition at line 96 of file sch_move_tool.h.

Referenced by AlignElements(), Main(), and moveItem().

m_isSymbolEditor

bool EE_TOOL_BASE< SCH_EDIT_FRAME >::m_isSymbolEditor

protectedinherited

Definition at line 192 of file ee_tool_base.h.

m_lineConnectionCache

std::map<SCH_LINE*, EDA_ITEMS> SCH_MOVE_TOOL::m_lineConnectionCache

private

Lines added at bend points dynamically during the move.

Definition at line 101 of file sch_move_tool.h.

Referenced by getConnectedDragItems(), Main(), and orthoLineDrag().

m_menu

TOOL_MENU TOOL_INTERACTIVE::m_menu

protectedinherited

The functions below are not yet implemented - their interface may change.

Definition at line 125 of file tool_interactive.h.

Referenced by SCH_LINE_WIRE_BUS_TOOL::doDrawSegments(), PCB_TOOL_BASE::doInteractiveItemPlacement(), DRAWING_TOOL::drawArc(), DRAWING_TOOL::DrawDimension(), MICROWAVE_TOOL::drawMicrowaveInductor(), SCH_DRAWING_TOOLS::DrawShape(), SYMBOL_EDITOR_DRAWING_TOOLS::DrawShape(), PL_DRAWING_TOOLS::DrawShape(), DRAWING_TOOL::drawShape(), SCH_DRAWING_TOOLS::DrawSheet(), DRAWING_TOOL::DrawZone(), PAD_TOOL::EnumeratePads(), TOOL_INTERACTIVE::GetToolMenu(), EDA_3D_CONTROLLER::Init(), CVPCB_FOOTPRINT_VIEWER_SELECTION_TOOL::Init(), EE_SELECTION_TOOL::Init(), EE_TOOL_BASE< T >::Init(), SCH_DRAWING_TOOLS::Init(), SCH_EDIT_TOOL::Init(), SCH_LINE_WIRE_BUS_TOOL::Init(), SYMBOL_EDITOR_CONTROL::Init(), SYMBOL_EDITOR_DRAWING_TOOLS::Init(), GERBVIEW_SELECTION_TOOL::Init(), PICKER_TOOL::Init(), ZOOM_TOOL::Init(), PL_DRAWING_TOOLS::Init(), PL_EDIT_TOOL::Init(), PL_SELECTION_TOOL::Init(), LENGTH_TUNER_TOOL::Init(), ROUTER_TOOL::Init(), BOARD_EDITOR_CONTROL::Init(), DRAWING_TOOL::Init(), FOOTPRINT_EDITOR_CONTROL::Init(), PAD_TOOL::Init(), PCB_SELECTION_TOOL::Init(), PCB_TOOL_BASE::Init(), PCB_VIEWER_TOOLS::Init(), DRAWING_TOOL::InteractivePlaceWithPreview(), EDA_3D_CONTROLLER::Main(), CVPCB_FOOTPRINT_VIEWER_SELECTION_TOOL::Main(), EE_SELECTION_TOOL::Main(), Main(), SYMBOL_EDITOR_MOVE_TOOL::Main(), GERBVIEW_SELECTION_TOOL::Main(), PICKER_TOOL::Main(), ZOOM_TOOL::Main(), PL_EDIT_TOOL::Main(), PL_SELECTION_TOOL::Main(), PCB_PICKER_TOOL::Main(), PCB_SELECTION_TOOL::Main(), LENGTH_TUNER_TOOL::MainLoop(), ROUTER_TOOL::MainLoop(), GERBVIEW_INSPECTION_TOOL::MeasureTool(), PCB_VIEWER_TOOLS::MeasureTool(), ROUTER_TOOL::performDragging(), ROUTER_TOOL::performRouting(), LENGTH_TUNER_TOOL::performTuning(), SYMBOL_EDITOR_DRAWING_TOOLS::PlaceAnchor(), BOARD_EDITOR_CONTROL::PlaceFootprint(), SCH_DRAWING_TOOLS::PlaceImage(), DRAWING_TOOL::PlaceImage(), DRAWING_TOOL::PlaceImportedGraphics(), PL_DRAWING_TOOLS::PlaceItem(), SCH_DRAWING_TOOLS::PlaceSymbol(), DRAWING_TOOL::PlaceText(), DRAWING_TOOL::SetAnchor(), SCH_DRAWING_TOOLS::SingleClickPlace(), SCH_DRAWING_TOOLS::TwoClickPlace(), and SYMBOL_EDITOR_DRAWING_TOOLS::TwoClickPlace().

m_moveInProgress

bool SCH_MOVE_TOOL::m_moveInProgress

private

Definition at line 95 of file sch_move_tool.h.

Referenced by Main().

m_moveOffset

VECTOR2I SCH_MOVE_TOOL::m_moveOffset

private

Last cursor position (needed for getModificationPoint() to avoid changes of edit reference point).

Definition at line 108 of file sch_move_tool.h.

Referenced by Main().

m_newDragLines

std::unordered_set<SCH_LINE*> SCH_MOVE_TOOL::m_newDragLines

private

Lines changed by drag algorithm that weren't selected.

Definition at line 103 of file sch_move_tool.h.

Referenced by clearNewDragLines(), commitDragLines(), Main(), and orthoLineDrag().

m_selectionTool

EE_SELECTION_TOOL* EE_TOOL_BASE< SCH_EDIT_FRAME >::m_selectionTool

protectedinherited

Definition at line 191 of file ee_tool_base.h.

m_specialCaseLabels

std::map<SCH_LABEL_BASE*, SPECIAL_CASE_LABEL_INFO> SCH_MOVE_TOOL::m_specialCaseLabels

private

Definition at line 118 of file sch_move_tool.h.

Referenced by getConnectedDragItems(), Main(), moveItem(), and orthoLineDrag().

m_specialCaseSheetPins

std::map<SCH_SHEET_PIN*, std::pair<SCH_LINE*, bool> > SCH_MOVE_TOOL::m_specialCaseSheetPins

private

Definition at line 122 of file sch_move_tool.h.

Referenced by getConnectedDragItems(), getConnectedItems(), and Main().

m_toolId

TOOL_ID TOOL_BASE::m_toolId

protectedinherited

Name of the tool.

Names are expected to obey the format application.ToolName (eg. pcbnew.InteractiveSelection).

Definition at line 210 of file tool_base.h.

Referenced by TOOL_INTERACTIVE::Activate(), TOOL_BASE::GetId(), and TOOL_BASE::IsToolActive().

m_toolMgr

TOOL_MANAGER* TOOL_BASE::m_toolMgr

protectedinherited

Definition at line 215 of file tool_base.h.

Referenced by TOOL_INTERACTIVE::Activate(), SELECTION_TOOL::AddItemsToSel(), SELECTION_TOOL::AddItemToSel(), AlignElements(), SCH_EDITOR_CONTROL::AssignNetclass(), BOARD_EDITOR_CONTROL::AssignNetclass(), CVPCB_ASSOCIATION_TOOL::Associate(), TOOL_BASE::attachManager(), SCH_EDIT_TOOL::AutoplaceFields(), EE_SELECTION_TOOL::autostartEvent(), SCH_EDIT_TOOL::BreakWire(), BOARD_INSPECTION_TOOL::calculateSelectionRatsnest(), ROUTER_TOOL::CanInlineDrag(), SCH_EDITOR_CONTROL::ChangeLineMode(), SCH_EDIT_TOOL::ChangeTextType(), EDIT_TOOL::ChangeTrackWidth(), SCH_EDIT_TOOL::CleanupSheetPins(), GERBVIEW_CONTROL::ClearAllLayers(), SCH_EDITOR_CONTROL::ClearHighlight(), BOARD_INSPECTION_TOOL::ClearHighlight(), GERBVIEW_SELECTION_TOOL::clearSelection(), PL_SELECTION_TOOL::ClearSelection(), EE_SELECTION_TOOL::ClearSelection(), PCB_SELECTION_TOOL::ClearSelection(), SCH_EDIT_TOOL::ConvertDeMorgan(), SYMBOL_EDITOR_EDIT_TOOL::Copy(), PL_EDIT_TOOL::Copy(), PAD_TOOL::copyPadSettings(), EDIT_TOOL::copyToClipboard(), EDIT_TOOL::CreateArray(), MICROWAVE_TOOL::createInductorBetween(), EE_INSPECTION_TOOL::CrossProbe(), DRC_TOOL::CrossProbe(), COMMON_TOOLS::CursorControl(), SCH_EDITOR_CONTROL::Cut(), SCH_EDIT_TOOL::DeleteItemCursor(), SYMBOL_EDITOR_EDIT_TOOL::DeleteItemCursor(), PL_EDIT_TOOL::DeleteItemCursor(), PCB_CONTROL::DeleteItemCursor(), EDIT_TOOL::DeleteItems(), SCH_EDITOR_CONTROL::doCopy(), BOARD_EDITOR_CONTROL::doCrossProbePcbToSch(), SCH_EDITOR_CONTROL::doCrossProbeSchToPcb(), SCH_EDIT_TOOL::DoDelete(), SYMBOL_EDITOR_EDIT_TOOL::DoDelete(), SCH_LINE_WIRE_BUS_TOOL::doDrawSegments(), BOARD_INSPECTION_TOOL::doHideRatsnestNet(), PCB_TOOL_BASE::doInteractiveItemPlacement(), EDIT_TOOL::doMoveSelection(), PCB_SELECTION_TOOL::doSyncSelection(), SCH_LINE_WIRE_BUS_TOOL::doUnfoldBus(), COMMON_TOOLS::doZoomInOut(), COMMON_TOOLS::doZoomToPreset(), EDIT_TOOL::Drag(), DRAWING_TOOL::DrawArc(), DRAWING_TOOL::drawArc(), DRAWING_TOOL::DrawCircle(), DRAWING_TOOL::DrawDimension(), DRAWING_TOOL::DrawRectangle(), SCH_LINE_WIRE_BUS_TOOL::DrawSegments(), SCH_DRAWING_TOOLS::DrawShape(), SYMBOL_EDITOR_DRAWING_TOOLS::DrawShape(), PL_DRAWING_TOOLS::DrawShape(), DRAWING_TOOL::drawShape(), SCH_DRAWING_TOOLS::DrawSheet(), DRAWING_TOOL::DrawZone(), BOARD_EDITOR_CONTROL::DrillOrigin(), SYMBOL_EDITOR_EDIT_TOOL::Duplicate(), EDIT_TOOL::Duplicate(), SCH_EDIT_TOOL::EditField(), SCH_EDIT_TOOL::editFieldText(), BOARD_EDITOR_CONTROL::EditFpInFpEditor(), PAD_TOOL::EditPad(), SYMBOL_EDITOR_EDIT_TOOL::editShapeProperties(), SYMBOL_EDITOR_EDIT_TOOL::editSymbolProperties(), SCH_EDITOR_CONTROL::EditWithSymbolEditor(), PCB_SELECTION_TOOL::EnterGroup(), GROUP_TOOL::EnterGroup(), SCH_NAVIGATE_TOOL::EnterSheet(), PAD_TOOL::EnumeratePads(), EE_INSPECTION_TOOL::ExcludeMarker(), PCB_SELECTION_TOOL::ExitGroup(), PCB_SELECTION_TOOL::expandConnection(), PAD_TOOL::explodePad(), PCB_SELECTION_TOOL::filterSelection(), PCB_SELECTION_TOOL::FindItem(), SCH_EDITOR_CONTROL::FindSymbolAndItem(), SCH_LINE_WIRE_BUS_TOOL::finishSegments(), EDIT_TOOL::Flip(), EDIT_TOOL::GetAndPlace(), TOOL_BASE::GetManager(), TOOL_BASE::getModelInt(), DRAWING_TOOL::getSourceZoneForAction(), TOOL_BASE::getToolHolderInt(), TOOL_BASE::getView(), TOOL_BASE::getViewControls(), TOOL_INTERACTIVE::goInternal(), PCB_SELECTION_TOOL::grabUnconnected(), COMMON_TOOLS::GridNext(), COMMON_TOOLS::GridPreset(), COMMON_TOOLS::GridPrev(), PCB_CONTROL::GridSetOrigin(), GROUP_TOOL::Group(), GERBVIEW_CONTROL::HighlightControl(), BOARD_INSPECTION_TOOL::HighlightItem(), SCH_EDITOR_CONTROL::HighlightNet(), BOARD_INSPECTION_TOOL::HighlightNet(), BOARD_INSPECTION_TOOL::highlightNet(), SCH_EDITOR_CONTROL::HighlightNetCursor(), PL_EDIT_TOOL::ImportDrawingSheetContent(), FOOTPRINT_EDITOR_CONTROL::ImportFootprint(), EE_TOOL_BASE< T >::Init(), SCH_EDIT_TOOL::Init(), SYMBOL_EDITOR_CONTROL::Init(), SYMBOL_EDITOR_EDIT_TOOL::Init(), PL_DRAWING_TOOLS::Init(), PL_EDIT_TOOL::Init(), PL_POINT_EDITOR::Init(), ROUTER_TOOL::Init(), BOARD_EDITOR_CONTROL::Init(), BOARD_INSPECTION_TOOL::Init(), BOARD_REANNOTATE_TOOL::Init(), CONVERT_TOOL::Init(), DRAWING_TOOL::Init(), EDIT_TOOL::Init(), GLOBAL_EDIT_TOOL::Init(), GROUP_TOOL::Init(), PAD_TOOL::Init(), PCB_POINT_EDITOR::Init(), PCB_SELECTION_TOOL::Init(), ALIGN_DISTRIBUTE_TOOL::Init(), POSITION_RELATIVE_TOOL::Init(), ROUTER_TOOL::InlineBreakTrack(), ROUTER_TOOL::InlineDrag(), BOARD_INSPECTION_TOOL::InspectClearance(), BOARD_INSPECTION_TOOL::InspectConstraints(), DRAWING_TOOL::InteractivePlaceWithPreview(), EDIT_TOOL::invokeInlineRouter(), EDIT_TOOL::isRouterActive(), TOOL_BASE::IsToolActive(), GROUP_TOOL::LeaveGroup(), BOARD_INSPECTION_TOOL::LocalRatsnestTool(), EDA_3D_CONTROLLER::Main(), CVPCB_CONTROL::Main(), CVPCB_FOOTPRINT_VIEWER_SELECTION_TOOL::Main(), EE_SELECTION_TOOL::Main(), Main(), SYMBOL_EDITOR_MOVE_TOOL::Main(), GERBVIEW_SELECTION_TOOL::Main(), PL_EDIT_TOOL::Main(), PL_SELECTION_TOOL::Main(), PCB_PICKER_TOOL::Main(), PCB_SELECTION_TOOL::Main(), LENGTH_TUNER_TOOL::MainLoop(), ROUTER_TOOL::MainLoop(), PCB_VIEWER_TOOLS::MeasureTool(), SCH_EDIT_TOOL::Mirror(), SYMBOL_EDITOR_EDIT_TOOL::Mirror(), EDIT_TOOL::Mirror(), BOARD_EDITOR_CONTROL::modifyLockSelected(), EDIT_TOOL::MoveExact(), SCH_EDITOR_CONTROL::NextLineMode(), SYMBOL_EDITOR_CONTROL::OnDeMorgan(), SELECTION_TOOL::onDisambiguationExpire(), COMMON_TOOLS::OnGridChanged(), PCB_POINT_EDITOR::OnSelectionChange(), SCH_EDITOR_CONTROL::Paste(), SYMBOL_EDITOR_EDIT_TOOL::Paste(), PL_EDIT_TOOL::Paste(), PAD_TOOL::pastePadProperties(), ROUTER_TOOL::performDragging(), ROUTER_TOOL::performRouting(), GROUP_TOOL::PickNewMember(), EDIT_TOOL::pickReferencePoint(), SYMBOL_EDITOR_EDIT_TOOL::PinTable(), PCB_CONTROL::placeBoardItems(), BOARD_EDITOR_CONTROL::PlaceFootprint(), SCH_DRAWING_TOOLS::PlaceImage(), DRAWING_TOOL::PlaceImage(), DRAWING_TOOL::PlaceImportedGraphics(), PL_DRAWING_TOOLS::PlaceItem(), SCH_DRAWING_TOOLS::PlaceSymbol(), DRAWING_TOOL::PlaceText(), GERBVIEW_CONTROL::Print(), PCB_CONTROL::Print(), SCH_EDIT_TOOL::Properties(), SYMBOL_EDITOR_EDIT_TOOL::Properties(), EDIT_TOOL::Properties(), PAD_TOOL::pushPadSettings(), EDIT_TOOL::rebuildConnectivity(), ZONE_FILLER_TOOL::rebuildConnectivity(), EE_SELECTION_TOOL::RebuildSelection(), PAD_TOOL::RecombinePad(), SCH_EDITOR_CONTROL::Redo(), SYMBOL_EDITOR_EDIT_TOOL::Redo(), POSITION_RELATIVE_TOOL::RelativeItemSelectionMove(), EDIT_TOOL::Remove(), PCB_POINT_EDITOR::removeCorner(), GROUP_TOOL::RemoveFromGroup(), SELECTION_TOOL::RemoveItemFromSel(), SELECTION_TOOL::RemoveItemsFromSel(), SCH_EDIT_TOOL::RepeatDrawItem(), SYMBOL_EDITOR_DRAWING_TOOLS::RepeatDrawItem(), PCB_SELECTION_TOOL::RequestSelection(), EE_SELECTION_TOOL::RequestSelection(), EDA_3D_CONTROLLER::Reset(), COMMON_TOOLS::Reset(), PNS::TOOL_BASE::Reset(), PAD_TOOL::Reset(), COMMON_TOOLS::ResetLocalCoords(), TOOL_INTERACTIVE::resetTransitions(), SCH_EDITOR_CONTROL::Revert(), SCH_EDIT_TOOL::Rotate(), SYMBOL_EDITOR_EDIT_TOOL::Rotate(), EDIT_TOOL::Rotate(), ROUTER_TOOL::RouteSelected(), TOOL_INTERACTIVE::RunMainStack(), DRC_TOOL::RunTests(), EE_SELECTION_TOOL::Selectable(), EE_SELECTION_TOOL::SelectAll(), PCB_SELECTION_TOOL::SelectAll(), EE_SELECTION_TOOL::SelectConnection(), PCB_TOOL_BASE::selection(), COMMON_TOOLS::SelectionTool(), GERBVIEW_SELECTION_TOOL::SelectItem(), GERBVIEW_SELECTION_TOOL::SelectItems(), EE_SELECTION_TOOL::selectMultiple(), PL_SELECTION_TOOL::selectMultiple(), PCB_SELECTION_TOOL::selectMultiple(), PCB_SELECTION_TOOL::selectNet(), GERBVIEW_SELECTION_TOOL::selectPoint(), PL_SELECTION_TOOL::SelectPoint(), PCB_SELECTION_TOOL::selectPoint(), EE_SELECTION_TOOL::selectPoint(), POSITION_RELATIVE_TOOL::SelectPositionRelativeItem(), PCB_SELECTION_TOOL::selectSameSheet(), PCB_SELECTION_TOOL::selectSheetContents(), DRAWING_TOOL::SetAnchor(), TOOL_INTERACTIVE::SetContextMenu(), EDA_3D_CONTROLLER::SetMaterial(), DRC_TOOL::ShowDRCDialog(), SCH_DRAWING_TOOLS::SingleClickPlace(), SCH_EDIT_TOOL::Swap(), EE_SELECTION_TOOL::SyncSelection(), COMMON_TOOLS::ToggleCursor(), COMMON_TOOLS::ToggleCursorStyle(), EDA_3D_CONTROLLER::ToggleVisibility(), BOARD_EDITOR_CONTROL::TrackWidthDec(), BOARD_EDITOR_CONTROL::TrackWidthInc(), trimDanglingLines(), SCH_DRAWING_TOOLS::TwoClickPlace(), SYMBOL_EDITOR_DRAWING_TOOLS::TwoClickPlace(), SCH_EDITOR_CONTROL::Undo(), SYMBOL_EDITOR_EDIT_TOOL::Undo(), GROUP_TOOL::Ungroup(), PCB_SELECTION_TOOL::unrouteSelected(), GERBVIEW_SELECTION_TOOL::UnselectItem(), GERBVIEW_SELECTION_TOOL::UnselectItems(), PNS::TOOL_BASE::updateEndItem(), BOARD_INSPECTION_TOOL::UpdateLocalRatsnest(), EE_INSPECTION_TOOL::UpdateMessagePanel(), GERBVIEW_CONTROL::UpdateMessagePanel(), PL_EDITOR_CONTROL::UpdateMessagePanel(), PCB_CONTROL::UpdateMessagePanel(), EDIT_TOOL::updateModificationPoint(), EE_POINT_EDITOR::updateParentItem(), PNS::TOOL_BASE::updateStartItem(), BOARD_EDITOR_CONTROL::ViaSizeDec(), BOARD_EDITOR_CONTROL::ViaSizeInc(), TOOL_INTERACTIVE::Wait(), BOARD_EDITOR_CONTROL::ZoneDuplicate(), and BOARD_EDITOR_CONTROL::ZoneMerge().

m_toolName

std::string TOOL_BASE::m_toolName

protectedinherited

Definition at line 214 of file tool_base.h.

Referenced by TOOL_BASE::GetName().

m_type

TOOL_TYPE TOOL_BASE::m_type

protectedinherited

Unique identifier for the tool, assigned by a TOOL_MANAGER instance.

Definition at line 207 of file tool_base.h.

Referenced by TOOL_BASE::GetType().

m_view

KIGFX::SCH_VIEW* EE_TOOL_BASE< SCH_EDIT_FRAME >::m_view

protectedinherited

Definition at line 190 of file ee_tool_base.h.

---

The documentation for this class was generated from the following files:

• sch_move_tool.h
• sch_move_tool.cpp