KiCad PCB EDA Suite
sch_move_tool.cpp
Go to the documentation of this file.
1 /*
2  * This program source code file is part of KiCad, a free EDA CAD application.
3  *
4  * Copyright (C) 2019 KiCad Developers, see AUTHORS.txt for contributors.
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version 2
9  * of the License, or (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, you may find one here:
18  * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
19  * or you may search the http://www.gnu.org website for the version 2 license,
20  * or you may write to the Free Software Foundation, Inc.,
21  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
22  */
23 
24 #include <tool/tool_manager.h>
27 #include <ee_actions.h>
28 #include <ee_hotkeys.h>
29 #include <bitmaps.h>
30 #include <base_struct.h>
31 #include <sch_item.h>
32 #include <sch_component.h>
33 #include <sch_sheet.h>
34 #include <sch_view.h>
35 #include <sch_line.h>
36 #include <sch_edit_frame.h>
37 #include <eeschema_id.h>
38 #include "sch_move_tool.h"
39 
40 
41 TOOL_ACTION EE_ACTIONS::move( "eeschema.InteractiveEdit.move",
43  _( "Move" ), _( "Moves the selected item(s)" ), move_xpm, AF_ACTIVATE );
44 
45 TOOL_ACTION EE_ACTIONS::drag( "eeschema.InteractiveEdit.drag",
47  _( "Drag" ), _( "Drags the selected item(s)" ), move_xpm, AF_ACTIVATE );
48 
49 
50 // For adding to or removing from selections
51 #define QUIET_MODE true
52 
53 
55  EE_TOOL_BASE<SCH_EDIT_FRAME>( "eeschema.InteractiveMove" ),
56  m_moveInProgress( false ),
57  m_moveOffset( 0, 0 )
58 {
59 }
60 
61 
63 {
64 }
65 
66 
68 {
70 
71  auto moveCondition = [] ( const SELECTION& aSel ) {
72  if( aSel.Empty() )
73  return false;
74 
76  return false;
77 
78  return true;
79  };
80 
81  //
82  // Add move actions to the selection tool menu
83  //
85 
86  selToolMenu.AddItem( EE_ACTIONS::move, moveCondition, 150 );
87  selToolMenu.AddItem( EE_ACTIONS::drag, moveCondition, 150 );
88 
89  return true;
90 }
91 
92 
93 int SCH_MOVE_TOOL::Main( const TOOL_EVENT& aEvent )
94 {
95  const KICAD_T movableItems[] =
96  {
102  SCH_LINE_T,
103  SCH_BITMAP_T,
104  SCH_TEXT_T,
105  SCH_LABEL_T,
108  SCH_FIELD_T,
111  SCH_SHEET_T,
112  EOT
113  };
114 
116 
117  controls->SetSnapping( true );
118  VECTOR2I originalCursorPos = controls->GetCursorPosition();
119 
120  // Be sure that there is at least one item that we can move. If there's no selection try
121  // looking for the stuff under mouse cursor (i.e. Kicad old-style hover selection).
122  SELECTION& selection = m_selectionTool->RequestSelection( movableItems );
123  EDA_ITEMS dragAdditions;
124  bool unselect = selection.IsHover();
125 
126  if( selection.Empty() )
127  return 0;
128 
129  if( aEvent.IsAction( &EE_ACTIONS::move ) )
130  m_frame->SetToolID( ID_SCH_MOVE, wxCURSOR_DEFAULT, _( "Move Items" ) );
131  else
132  m_frame->SetToolID( ID_SCH_DRAG, wxCURSOR_DEFAULT, _( "Drag Items" ) );
133 
134  Activate();
135  controls->ShowCursor( true );
136  controls->SetAutoPan( true );
137 
138  bool restore_state = false;
139  bool chain_commands = false;
140  bool appendUndo = false;
141  OPT_TOOL_EVENT evt = aEvent;
142  VECTOR2I prevPos;
143 
144  if( m_moveInProgress )
145  {
146  // User must have switched from move to drag or vice-versa. Reset the moved items
147  // so we can start again with the current m_isDragOperation and m_moveOffset.
149  m_selectionTool->RemoveItemsFromSel( &dragAdditions, QUIET_MODE );
150  m_moveInProgress = false;
151  // And give it a kick so it doesn't have to wait for the first mouse movement to
152  // refresh.
154  return 0;
155  }
156  else if( selection.Front()->IsNew() )
157  {
158  // New items will already be on the undo list
159  appendUndo = true;
160  }
161 
162  // Main loop: keep receiving events
163  do
164  {
165  controls->SetSnapping( !evt->Modifier( MD_ALT ) );
166 
167  if( evt->IsAction( &EE_ACTIONS::move ) || evt->IsAction( &EE_ACTIONS::drag )
168  || evt->IsMotion() || evt->IsDrag( BUT_LEFT )
169  || evt->IsAction( &EE_ACTIONS::refreshPreview ) )
170  {
171  if( !m_moveInProgress ) // Prepare to start moving/dragging
172  {
173  //------------------------------------------------------------------------
174  // Setup a drag or a move
175  //
176  for( SCH_ITEM* it = m_frame->GetScreen()->GetDrawItems(); it; it = it->Next() )
177  {
178  if( it->IsSelected() )
179  it->SetFlags( STARTPOINT | ENDPOINT | SELECTEDNODE );
180  else
181  it->ClearFlags( STARTPOINT | ENDPOINT | SELECTEDNODE );
182  }
183 
184  // Add connections to the selection for a drag.
185  //
186  if( m_frame->GetToolId() == ID_SCH_DRAG )
187  {
188  for( EDA_ITEM* item : selection )
189  {
190  if( static_cast<SCH_ITEM*>( item )->IsConnectable() )
191  {
192  std::vector<wxPoint> connections;
193  static_cast<SCH_ITEM*>( item )->GetConnectionPoints( connections );
194 
195  for( wxPoint point : connections )
196  getConnectedDragItems( (SCH_ITEM*) item, point, dragAdditions );
197  }
198  }
199 
200  m_selectionTool->AddItemsToSel( &dragAdditions, QUIET_MODE );
201  }
202 
203  // Mark the edges of the block with dangling flags for a move.
204  //
205  if( m_frame->GetToolId() == ID_SCH_MOVE )
206  {
207  std::vector<DANGLING_END_ITEM> internalPoints;
208 
209  for( EDA_ITEM* item : selection )
210  static_cast<SCH_ITEM*>( item )->GetEndPoints( internalPoints );
211 
212  for( EDA_ITEM* item : selection )
213  static_cast<SCH_ITEM*>( item )->UpdateDanglingState( internalPoints );
214  }
215 
216  // Generic setup
217  //
218  for( EDA_ITEM* item : selection )
219  {
220  if( item->IsNew() )
221  {
222  // TODO(snh): Remove extra tooling check after moving to schematic_commit model
223  if( ( item->GetFlags() & SELECTEDNODE ) != 0
224  && ( m_frame->GetToolId() == ID_SCH_DRAG ) )
225  {
226  // Item was added in getConnectedDragItems
227  saveCopyInUndoList( (SCH_ITEM*) item, UR_NEW, appendUndo );
228  appendUndo = true;
229  }
230  else
231  {
232  // Item was added in a previous command (and saved to undo by
233  // that command)
234  }
235  }
236  else if( item->GetParent() && item->GetParent()->IsSelected() )
237  {
238  // Item will be (or has been) saved to undo by parent
239  }
240  else
241  {
242  saveCopyInUndoList( (SCH_ITEM*) item, UR_CHANGED, appendUndo );
243  appendUndo = true;
244  }
245 
246  // Apply any initial offset in case we're coming from a previous command.
247  //
249  }
250 
251  // Set up the starting position and move/drag offset
252  //
253  m_cursor = controls->GetCursorPosition();
254 
255  if( selection.HasReferencePoint() )
256  {
257  VECTOR2I delta = m_cursor - selection.GetReferencePoint();
258 
259  // Drag items to the current cursor position
260  for( EDA_ITEM* item : selection )
261  {
262  // Don't double move pins, fields, etc.
263  if( item->GetParent() && item->GetParent()->IsSelected() )
264  continue;
265 
266  moveItem( item, delta, m_frame->GetToolId() == ID_SCH_DRAG );
267  updateView( item );
268  }
269 
270  selection.SetReferencePoint( m_cursor );
271  }
272  else if( selection.Size() == 1 )
273  {
274  // Set the current cursor position to the first dragged item origin,
275  // so the movement vector can be computed later
276  updateModificationPoint( selection );
277  m_cursor = originalCursorPos;
278  }
279  else
280  {
281  updateModificationPoint( selection );
282  }
283 
284  controls->SetCursorPosition( m_cursor, false );
286 
287  prevPos = m_cursor;
288  controls->SetAutoPan( true );
289  m_moveInProgress = true;
290  }
291 
292  //------------------------------------------------------------------------
293  // Follow the mouse
294  //
295  m_cursor = controls->GetCursorPosition();
296  VECTOR2I delta( m_cursor - prevPos );
297  selection.SetReferencePoint( m_cursor );
298 
299  m_moveOffset += delta;
300  prevPos = m_cursor;
301 
302  for( EDA_ITEM* item : selection )
303  {
304  // Don't double move pins, fields, etc.
305  if( item->GetParent() && item->GetParent()->IsSelected() )
306  continue;
307 
308  moveItem( item, delta, m_frame->GetToolId() == ID_SCH_DRAG );
309 
310  updateView( item );
311  }
312 
315  }
316  //------------------------------------------------------------------------
317  // Handle cancel
318  //
319  else if( TOOL_EVT_UTILS::IsCancelInteractive( evt.get() ) )
320  {
321  if( m_moveInProgress )
322  restore_state = true;
323 
324  break;
325  }
326  //------------------------------------------------------------------------
327  // Handle TOOL_ACTION special cases
328  //
329  else if( evt->Action() == TA_UNDO_REDO_PRE )
330  {
331  unselect = true;
332  break;
333  }
334  else if( evt->Category() == TC_COMMAND )
335  {
336  if( evt->IsAction( &EE_ACTIONS::doDelete ) )
337  {
338  // Exit on a remove operation; there is no further processing for removed items.
339  break;
340  }
341  else if( evt->IsAction( &EE_ACTIONS::duplicate ) )
342  {
343  if( selection.Front()->IsNew() )
344  {
345  // This doesn't really make sense; we'll just end up dragging a stack of
346  // objects so Duplicate() is going to ignore this and we'll just carry on.
347  continue;
348  }
349 
350  // Move original back and exit. The duplicate will run in its own loop.
351  restore_state = true;
352  unselect = false;
353  chain_commands = true;
354  break;
355  }
356  else if( evt->Action() == TA_CONTEXT_MENU_CHOICE )
357  {
358  if( evt->GetCommandId().get() >= ID_POPUP_SCH_SELECT_UNIT_CMP
359  && evt->GetCommandId().get() <= ID_POPUP_SCH_SELECT_UNIT_CMP_MAX )
360  {
361  SCH_COMPONENT* component = dynamic_cast<SCH_COMPONENT*>( selection.Front() );
362  int unit = evt->GetCommandId().get() - ID_POPUP_SCH_SELECT_UNIT_CMP;
363 
364  if( component )
365  {
366  m_frame->SelectUnit( component, unit );
368  }
369  }
370  }
371  }
372  //------------------------------------------------------------------------
373  // Handle context menu
374  //
375  else if( evt->IsClick( BUT_RIGHT ) )
376  {
378  }
379  //------------------------------------------------------------------------
380  // Handle drop
381  //
382  else if( evt->IsMouseUp( BUT_LEFT ) || evt->IsClick( BUT_LEFT ) )
383  {
384  break; // Finish
385  }
386 
387  } while( ( evt = Wait() ) ); //Should be assignment not equality test
388 
389  controls->ForceCursorPosition( false );
390  controls->ShowCursor( false );
391  controls->SetSnapping( false );
392  controls->SetAutoPan( false );
393 
394  if( !chain_commands )
395  m_moveOffset = { 0, 0 };
396 
397  m_moveInProgress = false;
399 
400  selection.ClearReferencePoint();
401 
402  for( auto item : selection )
403  item->ClearEditFlags();
404 
405  if( unselect )
407  else
408  m_selectionTool->RemoveItemsFromSel( &dragAdditions, QUIET_MODE );
409 
410  if( restore_state )
411  {
413  }
414  else
415  {
416  addJunctionsIfNeeded( selection );
419  m_frame->OnModify();
420  }
421 
422  return 0;
423 }
424 
425 
426 void SCH_MOVE_TOOL::getConnectedDragItems( SCH_ITEM* aOriginalItem, wxPoint aPoint,
427  EDA_ITEMS& aList )
428 {
429  for( SCH_ITEM* test = m_frame->GetScreen()->GetDrawItems(); test; test = test->Next() )
430  {
431  if( test->IsSelected() || !test->IsConnectable() || !test->CanConnect( aOriginalItem ) )
432  continue;
433 
434  switch( test->Type() )
435  {
436  case SCH_LINE_T:
437  {
438  // Select the connected end of wires/bus connections.
439  SCH_LINE* testLine = (SCH_LINE*) test;
440 
441  if( testLine->GetStartPoint() == aPoint )
442  {
443  if( !( testLine->GetFlags() & SELECTEDNODE ) )
444  aList.push_back( testLine );
445 
446  testLine->SetFlags( STARTPOINT | SELECTEDNODE );
447  }
448  else if( testLine->GetEndPoint() == aPoint )
449  {
450  if( !( testLine->GetFlags() & SELECTEDNODE ) )
451  aList.push_back( testLine );
452 
453  testLine->SetFlags( ENDPOINT | SELECTEDNODE );
454  }
455  break;
456  }
457 
458  case SCH_SHEET_T:
459  // Dragging a sheet just because it's connected to something else feels a bit like
460  // the tail wagging the dog, but this could be moved down to the next case.
461  break;
462 
463  case SCH_COMPONENT_T:
464  case SCH_NO_CONNECT_T:
465  case SCH_JUNCTION_T:
466  if( test->IsConnected( aPoint ) )
467  {
468  // Connected to a wire: anchor the connected end of the wire
469  if( aOriginalItem->Type() == SCH_LINE_T )
470  {
471  SCH_LINE* originalWire = (SCH_LINE*) aOriginalItem;
472 
473  if( originalWire->GetStartPoint() == aPoint )
474  originalWire->ClearFlags( STARTPOINT );
475  else if( originalWire->GetEndPoint() == aPoint )
476  originalWire->ClearFlags( ENDPOINT );
477  }
478  // Connected directly to a component: add a new wire and pick up the end
479  else if( test->Type() == SCH_COMPONENT_T)
480  {
481  SCH_LINE* newWire = new SCH_LINE( aPoint, LAYER_WIRE );
482  newWire->SetFlags( IS_NEW );
483  m_frame->AddToScreen( newWire, m_frame->GetScreen() );
484 
485  newWire->SetFlags( SELECTEDNODE | STARTPOINT );
486  aList.push_back( newWire );
487  }
488  // Connected to a no-connect or junction: pick it up
489  else
490  {
491  aList.push_back( test );
492  }
493  }
494  break;
495 
496  case SCH_LABEL_T:
497  case SCH_GLOBAL_LABEL_T:
498  case SCH_HIER_LABEL_T:
500  case SCH_BUS_BUS_ENTRY_T:
501  // Select labels and bus entries that are connected to a wire being moved.
502  if( aOriginalItem->Type() == SCH_LINE_T )
503  {
504  std::vector<wxPoint> connections;
505  test->GetConnectionPoints( connections );
506 
507  for( wxPoint& point : connections )
508  {
509  if( aOriginalItem->HitTest( point ) )
510  aList.push_back( test );
511  }
512  }
513  break;
514 
515  default:
516  break;
517  }
518  }
519 }
520 
521 
523 {
524  std::vector< wxPoint > pts;
525  std::vector< wxPoint > connections;
526 
527  m_frame->GetSchematicConnections( connections );
528 
529  for( unsigned ii = 0; ii < aSelection.GetSize(); ii++ )
530  {
531  SCH_ITEM* item = static_cast<SCH_ITEM*>( aSelection.GetItem( ii ) );
532  std::vector< wxPoint > new_pts;
533 
534  if( !item->IsConnectable() )
535  continue;
536 
537  item->GetConnectionPoints( new_pts );
538  pts.insert( pts.end(), new_pts.begin(), new_pts.end() );
539 
540  // If the item is a line, we also add any connection points from the rest of the schematic
541  // that terminate on the line after it is moved.
542  if( item->Type() == SCH_LINE_T )
543  {
544  SCH_LINE* line = (SCH_LINE*) item;
545  for( auto i : connections )
546  if( IsPointOnSegment( line->GetStartPoint(), line->GetEndPoint(), i ) )
547  pts.push_back( i );
548  }
549  else
550  {
551  // Clean up any wires that short non-wire connections in the list
552  for( auto point = new_pts.begin(); point != new_pts.end(); point++ )
553  {
554  for( auto second_point = point + 1; second_point != new_pts.end(); second_point++ )
555  m_frame->TrimWire( *point, *second_point );
556  }
557  }
558  }
559 
560  // We always have some overlapping connection points. Drop duplicates here
561  std::sort( pts.begin(), pts.end(), []( const wxPoint& a, const wxPoint& b ) -> bool
562  { return a.x < b.x || (a.x == b.x && a.y < b.y); } );
563 
564  pts.erase( unique( pts.begin(), pts.end() ), pts.end() );
565 
566  for( auto point : pts )
567  {
568  if( m_frame->GetScreen()->IsJunctionNeeded( point, true ) )
569  m_frame->AddJunction( point, true, false );
570  }
571 }
572 
573 
574 void SCH_MOVE_TOOL::moveItem( EDA_ITEM* aItem, VECTOR2I aDelta, bool isDrag )
575 {
576  switch( aItem->Type() )
577  {
578  case SCH_LINE_T:
579  if( aItem->GetFlags() & STARTPOINT )
580  static_cast<SCH_LINE*>( aItem )->MoveStart( (wxPoint) aDelta );
581 
582  if( aItem->GetFlags() & ENDPOINT )
583  static_cast<SCH_LINE*>( aItem )->MoveEnd( (wxPoint) aDelta );
584 
585  break;
586 
587  case SCH_PIN_T:
588  case SCH_FIELD_T:
589  {
590  SCH_COMPONENT* component = (SCH_COMPONENT*) aItem->GetParent();
591  TRANSFORM transform = component->GetTransform().InverseTransform();
592  wxPoint transformedDelta = transform.TransformCoordinate( (wxPoint) aDelta );
593 
594  static_cast<SCH_ITEM*>( aItem )->Move( transformedDelta );
595  break;
596  }
597  default:
598  static_cast<SCH_ITEM*>( aItem )->Move( (wxPoint) aDelta );
599  break;
600  }
601 
602  aItem->SetFlags( IS_MOVED );
603 }
604 
605 
607 {
608  if( m_moveInProgress && aSelection.HasReferencePoint() )
609  return false;
610 
611  // When there is only one item selected, the reference point is its position...
612  if( aSelection.Size() == 1 )
613  {
614  SCH_ITEM* item = static_cast<SCH_ITEM*>( aSelection.Front() );
615 
616  // For some items, moving the cursor to anchor is not good (for instance large
617  // hierarchical sheets or components can have the anchor outside the view)
618  if( item->IsMovableFromAnchorPoint() )
619  {
620  wxPoint pos = item->GetPosition();
621  aSelection.SetReferencePoint( pos );
622 
623  return true;
624  }
625  }
626 
627  // ...otherwise modify items with regard to the grid-snapped cursor position
629  aSelection.SetReferencePoint( m_cursor );
630 
631  return true;
632 }
633 
634 
636 {
637  Go( &SCH_MOVE_TOOL::Main, EE_ACTIONS::move.MakeEvent() );
638  Go( &SCH_MOVE_TOOL::Main, EE_ACTIONS::drag.MakeEvent() );
639 }
void addJunctionsIfNeeded(SELECTION &aSelection)
Adds junctions if needed to each item in the list after they have been moved.
virtual void ShowCursor(bool aEnabled)
Function ShowCursor() Enables or disables display of cursor.
void ClearReferencePoint()
Definition: selection.h:213
bool IsPointOnSegment(const wxPoint &aSegStart, const wxPoint &aSegEnd, const wxPoint &aTestPoint)
Function IsPointOnSegment.
Definition: trigo.cpp:39
bool SchematicCleanUp(SCH_SCREEN *aScreen=nullptr)
Performs routine schematic cleaning including breaking wire and buses and deleting identical objects ...
virtual bool IsConnectable() const
Function IsConnectable returns true if the schematic item can connect to another schematic item.
Definition: sch_item.h:299
bool IsHover() const
Definition: selection.h:69
void getConnectedDragItems(SCH_ITEM *aOriginalItem, wxPoint aPoint, EDA_ITEMS &aList)
Finds additional items for a drag operation.
void GetSchematicConnections(std::vector< wxPoint > &aConnections)
Collects a unique list of all possible connection points in the schematic.
wxPoint GetStartPoint() const
Definition: sch_line.h:90
static TOOL_ACTION duplicate
Definition: ee_actions.h:118
void AddToScreen(EDA_ITEM *aItem, SCH_SCREEN *aScreen=nullptr)
Add an item to the screen (and view) aScreen is the screen the item is located on,...
virtual bool IsMovableFromAnchorPoint()
Virtual function IsMovableFromAnchorPoint.
Definition: sch_item.h:172
TOOL_MENU & GetToolMenu()
bool IsJunctionNeeded(const wxPoint &aPosition, bool aNew=false)
Test if a junction is required for the items at aPosition on the screen.
Definition: sch_screen.cpp:350
SCH_ITEM * Next() const
Definition: sch_item.h:153
int Main(const TOOL_EVENT &aEvent)
Function Main()
VECTOR2I m_cursor
Last cursor position (needed for getModificationPoint() to avoid changes of edit reference point).
Definition: sch_move_tool.h:79
VECTOR2I m_moveOffset
Used for chaining commands
Definition: sch_move_tool.h:75
CONDITIONAL_MENU & GetMenu()
Function GetMenu.
Definition: tool_menu.cpp:46
TOOL_MANAGER * m_toolMgr
Definition: tool_base.h:216
TRANSFORM InverseTransform() const
Calculate the Inverse mirror/rotation transform.
Definition: transform.cpp:58
#define SELECTEDNODE
flag indicating that the structure has already selected
Definition: base_struct.h:122
OPT_TOOL_EVENT Wait(const TOOL_EVENT_LIST &aEventList=TOOL_EVENT(TC_ANY, TA_ANY))
Function Wait()
virtual void GetConnectionPoints(std::vector< wxPoint > &aPoints) const
Function GetConnectionPoints add all the connection points for this item to aPoints.
Definition: sch_item.h:309
virtual void SetSnapping(bool aEnabled)
Function SetSnapping() Enables/disables snapping cursor to grid.
static TOOL_ACTION refreshPreview
Definition: ee_actions.h:168
bool RunAction(const std::string &aActionName, bool aNow=false, T aParam=NULL)
Function RunAction() Runs the specified action.
Definition: tool_manager.h:125
static int LegacyHotKey(int aHotKey)
Creates a hot key code that refers to a legacy hot key setting, instead of a particular key.
Definition: tool_action.h:165
int AddItemsToSel(const TOOL_EVENT &aEvent)
Schematic editor (Eeschema) main window.
bool TestDanglingEnds()
Test all of the connectable objects in the schematic for unused connection points.
bool m_moveInProgress
Flag determining if anything is being dragged right now
Definition: sch_move_tool.h:72
void Go(int(T::*aStateFunc)(const TOOL_EVENT &), const TOOL_EVENT_LIST &aConditions=TOOL_EVENT(TC_ANY, TA_ANY))
Function Go()
static const int delta[8][2]
Definition: solve.cpp:112
search types array terminator (End Of Types)
Definition: typeinfo.h:82
KICAD_T
Enum KICAD_T is the set of class identification values, stored in EDA_ITEM::m_StructType.
Definition: typeinfo.h:78
static const TOOL_EVENT SelectedItemsModified
Definition: actions.h:136
wxPoint TransformCoordinate(const wxPoint &aPoint) const
Calculate a new coordinate according to the mirror/rotation transform.
Definition: transform.cpp:41
bool IsNew() const
Definition: base_struct.h:222
bool IsAction(const TOOL_ACTION *aAction) const
Function IsAction() Tests if the event contains an action issued upon activation of the given TOOL_AC...
Definition: tool_event.cpp:54
bool Init() override
Function Init() Init() is called once upon a registration of the tool.
Definition: ee_tool_base.h:69
#define IS_NEW
New item, just created.
Definition: base_struct.h:114
virtual bool HitTest(const wxPoint &aPosition, int aAccuracy=0) const
Function HitTest tests if aPosition is contained within or on the bounding box of an item.
Definition: base_struct.h:333
SCH_SCREEN * GetScreen() const override
Return a pointer to a BASE_SCREEN or one of its derivatives.
bool updateModificationPoint(SELECTION &aSelection)
Returns the right modification point (e.g.
void SetReferencePoint(const VECTOR2I &aP)
Definition: selection.h:208
virtual wxPoint GetPosition() const =0
Function GetPosition.
Class for tranforming drawing coordinates for a wxDC device context.
Definition: transform.h:45
void SetFlags(STATUS_FLAGS aMask)
Definition: base_struct.h:259
std::vector< EDA_ITEM * > EDA_ITEMS
Define list of drawing items for screens.
Definition: base_struct.h:588
TRANSFORM & GetTransform() const
Class TOOL_EVENT.
Definition: tool_event.h:167
SCH_JUNCTION * AddJunction(const wxPoint &aPos, bool aAppendToUndo=false, bool aFinal=true)
EDA_ITEM * GetParent() const
Definition: base_struct.h:214
Class VIEW_CONTROLS is an interface for classes handling user events controlling the view behaviour (...
static bool IsDrawingLineWireOrBus(const SELECTION &aSelection)
static TOOL_ACTION doDelete
Definition: ee_actions.h:131
EE_SELECTION_TOOL * m_selectionTool
Definition: ee_tool_base.h:143
virtual void ForceCursorPosition(bool aEnabled, const VECTOR2D &aPosition=VECTOR2D(0, 0))
Function ForceCursorPosition() Places the cursor immediately at a given point.
static TOOL_ACTION clearSelection
Clears the current selection.
Definition: ee_actions.h:57
virtual void SetToolID(int aId, int aCursor, const wxString &aToolMsg)
Set the tool command ID to aId and sets the cursor to aCursor.
bool Init() override
Function Init() Init() is called once upon a registration of the tool.
bool IsCancelInteractive(const TOOL_EVENT &aEvt)
Function IsCancelInteractive()
Definition: tool_event.cpp:177
All active tools
Definition: tool_event.h:143
virtual KIGFX::VIEW_ITEM * GetItem(unsigned int aIdx) const override
Definition: selection.h:103
TOOL_MENU m_menu
Menu model displayed by the tool.
Definition: ee_tool_base.h:147
virtual void SetAutoPan(bool aEnabled)
Function SetAutoPan Turns on/off auto panning (this feature is used when there is a tool active (eg.
void SelectUnit(SCH_COMPONENT *aComponent, int aUnit)
Definition: getpart.cpp:207
bool Empty() const
Checks if there is anything selected.
Definition: selection.h:119
virtual unsigned int GetSize() const override
Function GetSize() Returns the number of stored items.
Definition: selection.h:98
virtual void SetNoToolSelected()
Select the ID_NO_TOOL_SELECTED id tool (Idle tool)
bool HasReferencePoint() const
Definition: selection.h:198
void updateView(EDA_ITEM *aItem) const
Similar to getView()->Update(), but handles items that are redrawn by their parents.
Definition: ee_tool_base.h:107
Segment description base class to describe items which have 2 end points (track, wire,...
Definition: sch_line.h:37
void moveItem(EDA_ITEM *aItem, VECTOR2I aDelta, bool isDrag)
static TOOL_ACTION drag
Definition: ee_actions.h:117
void RollbackSchematicFromUndo()
Performs an undo of the last edit WITHOUT logging a corresponding redo.
Class TOOL_ACTION.
Definition: tool_action.h:46
size_t i
Definition: json11.cpp:597
#define ENDPOINT
ends. (Used to support dragging.)
Definition: base_struct.h:120
int Size() const
Returns the number of selected parts.
Definition: selection.h:125
Class SCH_COMPONENT describes a real schematic component.
Definition: sch_component.h:73
void saveCopyInUndoList(EDA_ITEM *aItem, UNDO_REDO_T aType, bool aAppend=false)
Similar to m_frame->SaveCopyInUndoList(), but handles items that are owned by their parents.
Definition: ee_tool_base.h:120
Class EDA_ITEM is a base class for most all the KiCad significant classes, used in schematics and boa...
Definition: base_struct.h:157
void ClearFlags(STATUS_FLAGS aMask=EDA_ITEM_ALL_FLAGS)
Definition: base_struct.h:260
void Activate()
Function Activate() Runs the tool.
bool TrimWire(const wxPoint &aStart, const wxPoint &aEnd)
If any single wire passes through both points, remove the portion between the two points,...
static TOOL_ACTION move
Definition: ee_actions.h:116
Class EE_TOOL_BASE.
Definition: ee_tool_base.h:49
void OnModify() override
Must be called after a schematic change in order to set the "modify" flag of the current screen and u...
Basic classes for most KiCad items.
KIGFX::VIEW_CONTROLS * getViewControls() const
Function getViewControls()
Definition: tool_base.cpp:41
#define QUIET_MODE
STATUS_FLAGS GetFlags() const
Definition: base_struct.h:261
int RemoveItemsFromSel(const TOOL_EVENT &aEvent)
void setTransitions() override
Sets up handlers for various events.
void PostEvent(const TOOL_EVENT &aEvent)
Puts an event to the event queue to be processed at the end of event processing cycle.
Definition: tool_manager.h:238
void AddItem(const TOOL_ACTION &aAction, const SELECTION_CONDITION &aCondition, int aOrder=ANY_ORDER)
Function AddItem()
SELECTION & RequestSelection(const KICAD_T *aFilterList=EE_COLLECTOR::AllItems)
Function RequestSelection()
Class SCH_ITEM is a base class for any item which can be embedded within the SCHEMATIC container clas...
Definition: sch_item.h:114
void ShowContextMenu(SELECTION &aSelection)
Function ShowContextMenu.
Definition: tool_menu.cpp:59
int GetToolId() const
Definition: draw_frame.h:524
virtual void SetCursorPosition(const VECTOR2D &aPosition, bool aWarpView=true, bool aTriggeredByArrows=false)=0
Moves cursor to the requested position expressed in world coordinates.
VECTOR2D GetCursorPosition() const
Returns the current cursor position in world coordinates.
EDA_ITEM * Front() const
Definition: selection.h:155
OPT< TOOL_EVENT > OPT_TOOL_EVENT
Definition: tool_event.h:486
KICAD_T Type() const
Function Type()
Definition: base_struct.h:204
virtual void UpdateMsgPanel()
Redraw the message panel.
#define STARTPOINT
When a line is selected, these flags indicate which.
Definition: base_struct.h:119
#define IS_MOVED
Item being moved.
Definition: base_struct.h:113
SCH_ITEM * GetDrawItems() const
Definition: sch_screen.h:153
wxPoint GetEndPoint() const
Definition: sch_line.h:93