KiCad PCB EDA Suite
edit_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) 2013-2017 CERN
5  * @author Maciej Suminski <maciej.suminski@cern.ch>
6  * @author Tomasz Wlostowski <tomasz.wlostowski@cern.ch>
7  * Copyright (C) 2017 KiCad Developers, see CHANGELOG.TXT for contributors.
8  *
9  * This program is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU General Public License
11  * as published by the Free Software Foundation; either version 2
12  * of the License, or (at your option) any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, you may find one here:
21  * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
22  * or you may search the http://www.gnu.org website for the version 2 license,
23  * or you may write to the Free Software Foundation, Inc.,
24  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
25  */
26 
27 #include <limits>
28 
29 #include <class_board.h>
30 #include <class_module.h>
31 #include <class_edge_mod.h>
32 #include <class_zone.h>
33 #include <collectors.h>
34 #include <pcb_edit_frame.h>
35 #include <kiway.h>
36 #include <class_draw_panel_gal.h>
37 #include <footprint_edit_frame.h>
38 #include <array_creator.h>
39 #include <pcbnew_id.h>
40 #include <status_popup.h>
41 #include <tool/tool_manager.h>
42 #include <view/view_controls.h>
43 #include <view/view.h>
46 #include <confirm.h>
47 #include <bitmaps.h>
48 #include <hotkeys.h>
49 
50 #include <cassert>
51 #include <functional>
52 using namespace std::placeholders;
53 
54 #include "pcb_actions.h"
55 #include "selection_tool.h"
56 #include "edit_tool.h"
57 #include "picker_tool.h"
58 #include "grid_helper.h"
59 #include "kicad_clipboard.h"
60 #include "pcbnew_control.h"
61 
62 #include <router/router_tool.h>
63 
67 
68 #include <tools/tool_event_utils.h>
69 
71 
72 #include <board_commit.h>
73 
74 
75 // Edit tool actions
76 TOOL_ACTION PCB_ACTIONS::editFootprintInFpEditor( "pcbnew.InteractiveEdit.editFootprintInFpEditor",
78  _( "Open in Footprint Editor" ),
79  _( "Opens the selected footprint in the Footprint Editor" ),
80  module_editor_xpm );
81 
82 TOOL_ACTION PCB_ACTIONS::editActivate( "pcbnew.InteractiveEdit",
83  AS_GLOBAL, 0,
84  _( "Edit Activate" ), "", move_xpm, AF_ACTIVATE );
85 
86 TOOL_ACTION PCB_ACTIONS::move( "pcbnew.InteractiveEdit.move",
88  _( "Move" ), _( "Moves the selected item(s)" ), move_xpm, AF_ACTIVATE );
89 
90 TOOL_ACTION PCB_ACTIONS::duplicate( "pcbnew.InteractiveEdit.duplicate",
92  _( "Duplicate" ), _( "Duplicates the selected item(s)" ), duplicate_xpm );
93 
94 TOOL_ACTION PCB_ACTIONS::duplicateIncrement( "pcbnew.InteractiveEdit.duplicateIncrementPads",
96  _( "Duplicate" ), _( "Duplicates the selected item(s), incrementing pad numbers" ) );
97 
98 TOOL_ACTION PCB_ACTIONS::moveExact( "pcbnew.InteractiveEdit.moveExact",
100  _( "Move Exactly..." ), _( "Moves the selected item(s) by an exact amount" ),
101  move_exactly_xpm );
102 
103 TOOL_ACTION PCB_ACTIONS::createArray( "pcbnew.InteractiveEdit.createArray",
105  _( "Create Array..." ), _( "Create array" ), array_xpm, AF_ACTIVATE );
106 
107 TOOL_ACTION PCB_ACTIONS::rotateCw( "pcbnew.InteractiveEdit.rotateCw",
109  _( "Rotate Clockwise" ), _( "Rotates selected item(s) clockwise" ),
110  rotate_cw_xpm, AF_NONE, (void*) -1 );
111 
112 TOOL_ACTION PCB_ACTIONS::rotateCcw( "pcbnew.InteractiveEdit.rotateCcw",
114  _( "Rotate Counterclockwise" ), _( "Rotates selected item(s) counterclockwise" ),
115  rotate_ccw_xpm, AF_NONE, (void*) 1 );
116 
117 TOOL_ACTION PCB_ACTIONS::flip( "pcbnew.InteractiveEdit.flip",
119  _( "Flip" ), _( "Flips selected item(s)" ), swap_layer_xpm );
120 
121 TOOL_ACTION PCB_ACTIONS::mirror( "pcbnew.InteractiveEdit.mirror",
122  AS_GLOBAL, 0,
123  _( "Mirror" ), _( "Mirrors selected item" ), mirror_h_xpm );
124 
125 TOOL_ACTION PCB_ACTIONS::remove( "pcbnew.InteractiveEdit.remove",
127  _( "Delete" ), _( "Deletes selected item(s)" ), delete_xpm,
128  AF_NONE, (void*) REMOVE_FLAGS::NORMAL );
129 
130 TOOL_ACTION PCB_ACTIONS::removeAlt( "pcbnew.InteractiveEdit.removeAlt",
132  _( "Delete Full Track" ), _( "Deletes selected item(s) and copper connections" ),
133  delete_xpm, AF_NONE, (void*) REMOVE_FLAGS::ALT );
134 
135 TOOL_ACTION PCB_ACTIONS::updateFootprints( "pcbnew.InteractiveEdit.updateFootprints",
136  AS_GLOBAL, 0,
137  _( "Update Footprint..." ), _( "Update the footprint from the library" ),
138  reload_xpm );
139 
140 TOOL_ACTION PCB_ACTIONS::exchangeFootprints( "pcbnew.InteractiveEdit.ExchangeFootprints",
141  AS_GLOBAL, 0,
142  _( "Change Footprint..." ), _( "Assign a different footprint from the library" ),
143  exchange_xpm );
144 
145 TOOL_ACTION PCB_ACTIONS::properties( "pcbnew.InteractiveEdit.properties",
147  _( "Properties..." ), _( "Displays item properties dialog" ), config_xpm );
148 
149 TOOL_ACTION PCB_ACTIONS::measureTool( "pcbnew.InteractiveEdit.measureTool",
151  _( "Measuring Tool" ), _( "Interactively measure distance between points" ),
152  nullptr, AF_ACTIVATE );
153 
154 TOOL_ACTION PCB_ACTIONS::updateUnits( "pcbnew.InteractiveEdit.updateUnits",
155  AS_GLOBAL, 0,
156  "", "" );
157 
158 
159 void EditToolSelectionFilter( GENERAL_COLLECTOR& aCollector, int aFlags )
160 {
161  // Iterate from the back so we don't have to worry about removals.
162  for( int i = aCollector.GetCount() - 1; i >= 0; --i )
163  {
164  BOARD_ITEM* item = aCollector[ i ];
165 
166  if( ( aFlags & EXCLUDE_LOCKED ) && item->IsLocked() )
167  {
168  aCollector.Remove( item );
169  }
170  else if( item->Type() == PCB_PAD_T )
171  {
172  MODULE* mod = static_cast<MODULE*>( item->GetParent() );
173 
174  // case 1: handle locking
175  if( ( aFlags & EXCLUDE_LOCKED ) && mod && mod->IsLocked() )
176  {
177  aCollector.Remove( item );
178  }
179  else if( ( aFlags & EXCLUDE_LOCKED_PADS ) && mod && mod->PadsLocked() )
180  {
181  // Pad locking is considerably "softer" than item locking
182  aCollector.Remove( item );
183 
184  if( !mod->IsLocked() && !aCollector.HasItem( mod ) )
185  aCollector.Append( mod );
186  }
187 
188  // case 2: selection contains both the module and its pads - remove the pads
189  if( mod && aCollector.HasItem( mod ) )
190  aCollector.Remove( item );
191  }
192  else if( ( aFlags & EXCLUDE_TRANSIENTS ) && item->Type() == PCB_MARKER_T )
193  {
194  aCollector.Remove( item );
195  }
196  }
197 }
198 
199 
201  PCB_TOOL_BASE( "pcbnew.InteractiveEdit" ),
202  m_selectionTool( NULL ),
203  m_dragging( false ),
204  m_lockedSelected( false )
205 {
206 }
207 
208 
210 {
211  m_dragging = false;
212 
213  if( aReason != RUN )
214  m_commit.reset( new BOARD_COMMIT( this ) );
215 }
216 
217 
219 {
220  // Find the selection tool, so they can cooperate
221  m_selectionTool = static_cast<SELECTION_TOOL*>( m_toolMgr->FindTool( "pcbnew.InteractiveSelection" ) );
222 
223  if( !m_selectionTool )
224  {
225  DisplayError( NULL, _( "pcbnew.InteractiveSelection tool is not available" ) );
226  return false;
227  }
228 
229  auto editingModuleCondition = [ this ] ( const SELECTION& aSelection ) {
230  return m_editModules;
231  };
232 
233  auto singleModuleCondition = SELECTION_CONDITIONS::OnlyType( PCB_MODULE_T )
235 
236  auto noActiveToolCondition = [ this ] ( const SELECTION& aSelection ) {
237  return ( frame()->GetToolId() == ID_NO_TOOL_SELECTED );
238  };
239 
240  // Add context menu entries that are displayed when selection tool is active
242 
254 
255 
260 
261 
265  // Selection tool handles the context menu for some other tools, such as the Picker.
266  // Don't add things like Paste when another tool is active.
267  menu.AddItem( ACTIONS::paste, noActiveToolCondition );
268 
269  // Mirror only available in modedit
270  menu.AddSeparator( editingModuleCondition && SELECTION_CONDITIONS::NotEmpty );
271  menu.AddItem( PCB_ACTIONS::mirror, editingModuleCondition && SELECTION_CONDITIONS::NotEmpty );
274 
275  // Footprint actions
276  menu.AddSeparator( singleModuleCondition );
277  menu.AddItem( PCB_ACTIONS::editFootprintInFpEditor, singleModuleCondition );
278  menu.AddItem( PCB_ACTIONS::updateFootprints, singleModuleCondition );
279  menu.AddItem( PCB_ACTIONS::exchangeFootprints, singleModuleCondition );
280 
281  return true;
282 }
283 
284 
285 bool EDIT_TOOL::invokeInlineRouter( int aDragMode )
286 {
287  auto theRouter = static_cast<ROUTER_TOOL*>( m_toolMgr->FindTool( "pcbnew.InteractiveRouter" ) );
288 
289  if( !theRouter )
290  return false;
291 
292  // make sure we don't accidentally invoke inline routing mode while the router is already active!
293  if( theRouter->IsToolActive() )
294  return false;
295 
296  if( theRouter->CanInlineDrag() )
297  {
299  return true;
300  }
301 
302  return false;
303 }
304 
305 
307 {
308  auto theRouter = static_cast<ROUTER_TOOL*>( m_toolMgr->FindTool( "pcbnew.InteractiveRouter" ) );
309 
310  return theRouter ? theRouter->Router()->Settings().InlineDragEnabled() : false;
311 }
312 
313 
314 int EDIT_TOOL::Drag( const TOOL_EVENT& aEvent )
315 {
316  int mode = PNS::DM_ANY;
317 
318  if( aEvent.IsAction( &PCB_ACTIONS::dragFreeAngle ) )
319  mode |= PNS::DM_FREE_ANGLE;
320 
321  invokeInlineRouter( mode );
322 
323  return 0;
324 }
325 
326 int EDIT_TOOL::Main( const TOOL_EVENT& aEvent )
327 {
329  PCB_BASE_EDIT_FRAME* editFrame = getEditFrame<PCB_BASE_EDIT_FRAME>();
330  VECTOR2I originalCursorPos = controls->GetCursorPosition();
331 
332  // Be sure that there is at least one item that we can modify. If nothing was selected before,
333  // try looking for the stuff under mouse cursor (i.e. Kicad old-style hover selection)
335  []( const VECTOR2I& aPt, GENERAL_COLLECTOR& aCollector )
336  { EditToolSelectionFilter( aCollector, EXCLUDE_TRANSIENTS ); } );
337 
338  if( m_dragging || selection.Empty() )
339  return 0;
340 
341  LSET item_layers = static_cast<BOARD_ITEM*>( selection.Front() )->GetLayerSet();
342  bool unselect = selection.IsHover(); //N.B. This must be saved before the re-selection below
343 
344  // Filter out locked pads here
345  // We cannot do this in the selection filter as we need the pad layers
346  // when it is the curr_item.
348  []( const VECTOR2I& aPt, GENERAL_COLLECTOR& aCollector )
349  { EditToolSelectionFilter( aCollector, EXCLUDE_LOCKED_PADS ); } );
350 
351  if( selection.Empty() )
352  return 0;
353 
354  Activate();
355  controls->ShowCursor( true );
356  controls->SetAutoPan( true );
357 
358  auto curr_item = static_cast<BOARD_ITEM*>( selection.Front() );
359  std::vector<BOARD_ITEM*> sel_items;
360 
361  for( EDA_ITEM* item : selection )
362  {
363  BOARD_ITEM* boardItem = dynamic_cast<BOARD_ITEM*>( item );
364  MODULE* module = dynamic_cast<MODULE*>( item );
365 
366  if( boardItem )
367  sel_items.push_back( boardItem );
368 
369  if( module )
370  {
371  for( D_PAD* pad : module->Pads() )
372  sel_items.push_back( pad );
373  }
374  }
375 
376  bool restore_state = false;
377  VECTOR2I totalMovement;
378  GRID_HELPER grid( editFrame );
379  OPT_TOOL_EVENT evt = aEvent;
380  VECTOR2I prevPos;
381 
382  // Main loop: keep receiving events
383  do
384  {
385  grid.SetSnap( !evt->Modifier( MD_SHIFT ) );
386  grid.SetUseGrid( !evt->Modifier( MD_ALT ) );
387  controls->SetSnapping( !evt->Modifier( MD_ALT ) );
388 
389  if( evt->IsAction( &PCB_ACTIONS::editActivate ) ||
390  evt->IsAction( &PCB_ACTIONS::move ) ||
391  evt->IsMotion() || evt->IsDrag( BUT_LEFT ) )
392  {
393  if( m_dragging && evt->Category() == TC_MOUSE )
394  {
396  item_layers, sel_items );
398  VECTOR2I movement( m_cursor - prevPos );
400 
401  totalMovement += movement;
402  prevPos = m_cursor;
403 
404  // Drag items to the current cursor position
405  for( EDA_ITEM* item : selection )
406  {
407  // Don't double move footprint pads, fields, etc.
408  if( item->GetParent() && item->GetParent()->IsSelected() )
409  continue;
410 
411  static_cast<BOARD_ITEM*>( item )->Move( movement );
412  }
413 
414  frame()->UpdateMsgPanel();
415  }
416  else if( !m_dragging ) // Prepare to start dragging
417  {
418  if ( !evt->IsAction( &PCB_ACTIONS::move ) && isInteractiveDragEnabled() )
419  {
421  break;
422  }
423 
424  // deal with locked items (override lock or abort the operation)
426 
427  if( lockFlags == SELECTION_LOCKED )
428  break;
429 
430  // When editing modules, all items have the same parent
431  if( EditingModules() )
432  {
433  m_commit->Modify( selection.Front() );
434  }
435  else
436  {
437  // Save items, so changes can be undone
438  for( auto item : selection )
439  {
440  // Don't double move footprint pads, fields, etc.
441  if( item->GetParent() && item->GetParent()->IsSelected() )
442  continue;
443 
444  m_commit->Modify( item );
445  }
446  }
447 
448  editFrame->UndoRedoBlock( true );
450 
452  {
453  // start moving with the reference point attached to the cursor
454  grid.SetAuxAxes( false );
455 
457 
458  // Drag items to the current cursor position
459  for( auto item : selection )
460  {
461  // Don't double move footprint pads, fields, etc.
462  if( item->GetParent() && item->GetParent()->IsSelected() )
463  continue;
464 
465  static_cast<BOARD_ITEM*>( item )->Move( delta );
466  }
467 
469  }
470  else if( selection.Size() == 1 )
471  {
472  // Set the current cursor position to the first dragged item origin, so the
473  // movement vector could be computed later
475  m_cursor = grid.BestDragOrigin( originalCursorPos, curr_item );
476  grid.SetAuxAxes( true, m_cursor );
477  }
478  else
479  {
481  m_cursor = grid.Align( m_cursor );
482  }
483 
485 
486  prevPos = m_cursor;
487  controls->SetAutoPan( true );
488  m_dragging = true;
489  }
490 
493  }
494 
495  else if( evt->IsCancel() || evt->IsActivate() )
496  {
497  restore_state = true; // Canceling the tool means that items have to be restored
498  break; // Finish
499  }
500 
501  else if( evt->Action() == TA_UNDO_REDO_PRE )
502  {
503  unselect = true;
504  break;
505  }
506 
507  // Dispatch TOOL_ACTIONs
508  else if( evt->Category() == TC_COMMAND )
509  {
510  if( evt->IsAction( &PCB_ACTIONS::remove ) )
511  {
512  // exit the loop, as there is no further processing for removed items
513  break;
514  }
515  else if( evt->IsAction( &PCB_ACTIONS::duplicate ) )
516  {
517  // On duplicate, stop moving this item
518  // The duplicate tool should then select the new item and start
519  // a new move procedure
520  break;
521  }
522  else if( evt->IsAction( &PCB_ACTIONS::moveExact ) )
523  {
524  // Can't do this, because the selection will then contain
525  // stale pointers and it will all go horribly wrong...
526  //editFrame->RestoreCopyFromUndoList( dummy );
527  //
528  // So, instead, reset the position manually
529  for( auto item : selection )
530  {
531  BOARD_ITEM* i = static_cast<BOARD_ITEM*>( item );
532  auto delta = VECTOR2I( i->GetPosition() ) - totalMovement;
533  i->SetPosition( wxPoint( delta.x, delta.y ) );
534 
535  // And what about flipping and rotation?
536  // for now, they won't be undone, but maybe that is how
537  // it should be, so you can flip and move exact in the
538  // same action?
539  }
540 
541  // This causes a double event, so we will get the dialogue
542  // correctly, somehow - why does Rotate not?
543  //MoveExact( aEvent );
544  break; // exit the loop - we move exactly, so we have finished moving
545  }
546  }
547 
548  else if( evt->IsMouseUp( BUT_LEFT ) || evt->IsClick( BUT_LEFT ) )
549  {
550  break; // Finish
551  }
552 
553  } while( ( evt = Wait() ) ); //Should be assignment not equality test
554 
555  m_lockedSelected = false;
556  controls->ForceCursorPosition( false );
557  controls->ShowCursor( false );
558  controls->SetSnapping( false );
559  controls->SetAutoPan( false );
560 
561  m_dragging = false;
562  editFrame->UndoRedoBlock( false );
563 
564  // Discard reference point when selection is "dropped" onto the board (ie: not dragging anymore)
566 
567  if( unselect )
569 
570  if( restore_state )
571  m_commit->Revert();
572  else
573  m_commit->Push( _( "Drag" ) );
574 
575  return 0;
576 }
577 
579 {
581  {
582  auto item = static_cast<BOARD_ITEM *>( selection[0] );
583 
584  m_commit->Modify( item );
585 
586  if( auto via = dyn_cast<VIA*>( item ) )
587  {
588  int new_width, new_drill;
589 
590  if( via->GetViaType() == VIA_MICROVIA )
591  {
592  auto net = via->GetNet();
593 
594  new_width = net->GetMicroViaSize();
595  new_drill = net->GetMicroViaDrillSize();
596  }
597  else
598  {
599  new_width = board()->GetDesignSettings().GetCurrentViaSize();
600  new_drill = board()->GetDesignSettings().GetCurrentViaDrill();
601  }
602 
603  via->SetDrill( new_drill );
604  via->SetWidth( new_width );
605  }
606  else if ( auto track = dyn_cast<TRACK*>( item ) )
607  {
608  int new_width = board()->GetDesignSettings().GetCurrentTrackWidth();
609  track->SetWidth( new_width );
610  }
611 
612  m_commit->Push( _("Edit track width/via size") );
613  return true;
614  }
615 
616  return false;
617 }
618 
619 int EDIT_TOOL::Properties( const TOOL_EVENT& aEvent )
620 {
621  PCB_BASE_EDIT_FRAME* editFrame = getEditFrame<PCB_BASE_EDIT_FRAME>();
622 
624  []( const VECTOR2I& aPt, GENERAL_COLLECTOR& aCollector )
625  { EditToolSelectionFilter( aCollector, EXCLUDE_TRANSIENTS ); } );
626 
627  // Tracks & vias are treated in a special way:
629  {
631  {
632  DIALOG_TRACK_VIA_PROPERTIES dlg( editFrame, selection, *m_commit );
633  dlg.ShowQuasiModal(); // QuasiModal required for NET_SELECTOR
634  }
635  }
636  else if( selection.Size() == 1 ) // Properties are displayed when there is only one item selected
637  {
638  // Display properties dialog
639  BOARD_ITEM* item = static_cast<BOARD_ITEM*>( selection.Front() );
640 
641  // Do not handle undo buffer, it is done by the properties dialogs @todo LEGACY
642  // Display properties dialog provided by the legacy canvas frame
643  editFrame->OnEditItemRequest( NULL, item );
644 
645  // Notify other tools of the changes
647  }
648 
649  if( selection.IsHover() )
650  {
652 
653  // Notify other tools of the changes -- This updates the visual ratsnest
655  }
656 
657  return 0;
658 }
659 
660 
661 int EDIT_TOOL::Rotate( const TOOL_EVENT& aEvent )
662 {
663  PCB_BASE_EDIT_FRAME* editFrame = getEditFrame<PCB_BASE_EDIT_FRAME>();
664 
666  []( const VECTOR2I& aPt, GENERAL_COLLECTOR& aCollector )
667  { EditToolSelectionFilter( aCollector, EXCLUDE_LOCKED_PADS | EXCLUDE_TRANSIENTS ); }, nullptr, ! m_dragging );
668 
669  if( selection.Empty() )
670  return 0;
671 
673  auto refPt = selection.GetReferencePoint();
674  const int rotateAngle = TOOL_EVT_UTILS::GetEventRotationAngle( *editFrame, aEvent );
675 
676  // When editing modules, all items have the same parent
677  if( EditingModules() )
678  m_commit->Modify( selection.Front() );
679 
680  for( auto item : selection )
681  {
682  if( !item->IsNew() && !EditingModules() )
683  m_commit->Modify( item );
684 
685  static_cast<BOARD_ITEM*>( item )->Rotate( refPt, rotateAngle );
686  }
687 
688  if( !m_dragging )
689  m_commit->Push( _( "Rotate" ) );
690 
691  if( selection.IsHover() && !m_dragging )
693 
695 
696  if( m_dragging )
698 
699  return 0;
700 }
701 
702 
706 static wxPoint mirrorPointX( const wxPoint& aPoint, const wxPoint& aMirrorPoint )
707 {
708  wxPoint mirrored = aPoint;
709 
710  mirrored.x -= aMirrorPoint.x;
711  mirrored.x = -mirrored.x;
712  mirrored.x += aMirrorPoint.x;
713 
714  return mirrored;
715 }
716 
717 
721 static void mirrorPadX( D_PAD& aPad, const wxPoint& aMirrorPoint )
722 {
723  wxPoint tmpPt = mirrorPointX( aPad.GetPosition(), aMirrorPoint );
724 
725  if( aPad.GetShape() == PAD_SHAPE_CUSTOM )
726  aPad.MirrorXPrimitives( tmpPt.x );
727 
728  aPad.SetPosition( tmpPt );
729 
730  aPad.SetX0( aPad.GetPosition().x );
731 
732  tmpPt = aPad.GetOffset();
733  tmpPt.x = -tmpPt.x;
734  aPad.SetOffset( tmpPt );
735 
736  auto tmpz = aPad.GetDelta();
737  tmpz.x = -tmpz.x;
738  aPad.SetDelta( tmpz );
739 
740  aPad.SetOrientation( -aPad.GetOrientation() );
741 }
742 
743 
744 int EDIT_TOOL::Mirror( const TOOL_EVENT& aEvent )
745 {
747  []( const VECTOR2I& aPt, GENERAL_COLLECTOR& aCollector )
748  { EditToolSelectionFilter( aCollector, EXCLUDE_LOCKED_PADS | EXCLUDE_TRANSIENTS ); }, nullptr, ! m_dragging );
749 
750  if( selection.Empty() )
751  return 0;
752 
754  auto refPoint = selection.GetReferencePoint();
755  wxPoint mirrorPoint( refPoint.x, refPoint.y );
756 
757  // When editing modules, all items have the same parent
758  if( EditingModules() )
759  m_commit->Modify( selection.Front() );
760 
761  for( EDA_ITEM* item : selection )
762  {
763  // only modify items we can mirror
764  switch( item->Type() )
765  {
766  case PCB_MODULE_EDGE_T:
767  case PCB_MODULE_TEXT_T:
768  case PCB_PAD_T:
769  // Only create undo entry for items on the board
770  if( !item->IsNew() && !EditingModules() )
771  m_commit->Modify( item );
772 
773  break;
774  default:
775  continue;
776  }
777 
778  // modify each object as necessary
779  switch( item->Type() )
780  {
781  case PCB_MODULE_EDGE_T:
782  {
783  auto& edge = static_cast<EDGE_MODULE&>( *item );
784  edge.Mirror( mirrorPoint, false );
785  break;
786  }
787 
788  case PCB_MODULE_TEXT_T:
789  {
790  auto& modText = static_cast<TEXTE_MODULE&>( *item );
791  modText.Mirror( mirrorPoint, false );
792  break;
793  }
794 
795  case PCB_PAD_T:
796  {
797  auto& pad = static_cast<D_PAD&>( *item );
798  mirrorPadX( pad, mirrorPoint );
799  break;
800  }
801 
802  default:
803  // it's likely the commit object is wrong if you get here
804  assert( false );
805  break;
806  }
807  }
808 
809  if( !m_dragging )
810  m_commit->Push( _( "Mirror" ) );
811 
812  if( selection.IsHover() && !m_dragging )
814 
816 
817  if( m_dragging )
819 
820  return 0;
821 }
822 
823 
824 int EDIT_TOOL::Flip( const TOOL_EVENT& aEvent )
825 {
827  []( const VECTOR2I& aPt, GENERAL_COLLECTOR& aCollector )
828  { EditToolSelectionFilter( aCollector, EXCLUDE_LOCKED_PADS | EXCLUDE_TRANSIENTS ); }, nullptr, ! m_dragging );
829 
830  if( selection.Empty() )
831  return 0;
832 
834  auto modPoint = selection.GetReferencePoint();
835 
836  // When editing modules, all items have the same parent
837  if( EditingModules() )
838  m_commit->Modify( selection.Front() );
839 
840  for( EDA_ITEM* item : selection )
841  {
842  if( !item->IsNew() && !EditingModules() )
843  m_commit->Modify( item );
844 
845  static_cast<BOARD_ITEM*>( item )->Flip( modPoint );
846  }
847 
848  if( !m_dragging )
849  m_commit->Push( _( "Flip" ) );
850 
851  if( selection.IsHover() && !m_dragging )
853 
855 
856  if( m_dragging )
858 
859  return 0;
860 }
861 
862 
863 int EDIT_TOOL::Remove( const TOOL_EVENT& aEvent )
864 {
865  ROUTER_TOOL* routerTool = static_cast<ROUTER_TOOL*>
866  ( m_toolMgr->FindTool( "pcbnew.InteractiveRouter" ) );
867 
868  // Do not delete items while actively routing.
869  if( routerTool && routerTool->Router() && routerTool->Router()->RoutingInProgress() )
870  return 1;
871 
872  std::vector<BOARD_ITEM*> lockedItems;
873 
874  // get a copy instead of reference (as we're going to clear the selection before removing items)
875  SELECTION selectionCopy;
876  bool isCut = aEvent.Parameter<intptr_t>() == static_cast<intptr_t>( PCB_ACTIONS::REMOVE_FLAGS::CUT );
877  bool isAlt = aEvent.Parameter<intptr_t>() == static_cast<intptr_t>( PCB_ACTIONS::REMOVE_FLAGS::ALT );
878 
879  // If we are in a "Cut" operation, then the copied selection exists already
880  if( isCut )
881  {
882  selectionCopy = m_selectionTool->GetSelection();
883  }
884  else
885  {
886  selectionCopy = m_selectionTool->RequestSelection(
887  []( const VECTOR2I& aPt, GENERAL_COLLECTOR& aCollector )
889  }
890 
891  bool isHover = selectionCopy.IsHover();
892 
893  // in "alternative" mode, deletion is not just a simple list of selected items,
894  // it removes whole tracks, not just segments
895  if( isAlt && isHover
896  && ( selectionCopy.HasType( PCB_TRACE_T ) || selectionCopy.HasType( PCB_VIA_T ) ) )
897  {
899  }
900 
901  if( selectionCopy.Empty() )
902  return 0;
903 
904  // N.B. Setting the CUT flag prevents lock filtering as we only want to delete the items that
905  // were copied to the clipboard, no more, no fewer. Filtering for locked item, if any will be done
906  // in the copyToClipboard() routine
907  if( !m_lockedSelected && !isCut )
908  {
909  // Second RequestSelection removes locked items but keeps a copy of their pointers
910  selectionCopy = m_selectionTool->RequestSelection(
911  []( const VECTOR2I& aPt, GENERAL_COLLECTOR& aCollector )
912  { EditToolSelectionFilter( aCollector, EXCLUDE_LOCKED ); }, &lockedItems );
913  }
914 
915 
916  // As we are about to remove items, they have to be removed from the selection first
918 
919  for( EDA_ITEM* item : selectionCopy )
920  {
921  if( m_editModules )
922  {
923  m_commit->Remove( item );
924  continue;
925  }
926 
927  switch( item->Type() )
928  {
929  case PCB_MODULE_TEXT_T:
930  {
931  auto text = static_cast<TEXTE_MODULE*>( item );
932  auto parent = static_cast<MODULE*>( item->GetParent() );
933 
934  if( text->GetType() == TEXTE_MODULE::TEXT_is_DIVERS )
935  {
936  m_commit->Modify( text );
937  getView()->Remove( text );
938  parent->Remove( text );
939  }
940  }
941  break;
942 
943  default:
944  m_commit->Remove( item );
945  break;
946  }
947  }
948 
949  if( isCut )
950  m_commit->Push( _( "Cut" ) );
951  else
952  m_commit->Push( _( "Delete" ) );
953 
954  if( !m_lockedSelected && lockedItems.size() > 0 )
955  {
957  STATUS_TEXT_POPUP statusPopup( frame() );
958 
959  m_lockedSelected = true;
960  m_toolMgr->RunAction( PCB_ACTIONS::selectItems, true, &lockedItems );
961  statusPopup.SetText( _( "Delete again to remove locked items" ) );
962  statusPopup.Expire( 2000 );
963  statusPopup.Popup();
964  statusPopup.Move( wxGetMousePosition() + wxPoint( 20, 20 ) );
965 
966  Activate();
967 
968  while( m_lockedSelected && statusPopup.IsShown() )
969  {
970  statusPopup.Move( wxGetMousePosition() + wxPoint( 20, 20 ) );
971  Wait();
972  }
973  }
974 
975  m_lockedSelected = false;
976 
977  return 0;
978 }
979 
980 
981 int EDIT_TOOL::MoveExact( const TOOL_EVENT& aEvent )
982 {
984  []( const VECTOR2I& aPt, GENERAL_COLLECTOR& aCollector )
986 
987  if( selection.Empty() )
988  return 0;
989 
990  PCB_BASE_FRAME* editFrame = getEditFrame<PCB_BASE_FRAME>();
991  wxPoint translation;
992  double rotation;
993  ROTATION_ANCHOR rotationAnchor = selection.Size() > 1 ? ROTATE_AROUND_SEL_CENTER
995 
996  DIALOG_MOVE_EXACT dialog( editFrame, translation, rotation, rotationAnchor );
997  int ret = dialog.ShowModal();
998 
999  if( ret == wxID_OK )
1000  {
1001  VECTOR2I rp = selection.GetCenter();
1002  wxPoint selCenter( rp.x, rp.y );
1003 
1004  // Make sure the rotation is from the right reference point
1005  selCenter += translation;
1006 
1007  // When editing modules, all items have the same parent
1008  if( EditingModules() )
1009  m_commit->Modify( selection.Front() );
1010 
1011  for( EDA_ITEM* selItem : selection )
1012  {
1013  BOARD_ITEM* item = static_cast<BOARD_ITEM*>( selItem );
1014 
1015  if( !item->IsNew() && !EditingModules() )
1016  m_commit->Modify( item );
1017 
1018  item->Move( translation );
1019 
1020  switch( rotationAnchor )
1021  {
1023  item->Rotate( item->GetPosition(), rotation );
1024  break;
1026  item->Rotate( selCenter, rotation );
1027  break;
1029  item->Rotate( editFrame->GetScreen()->m_O_Curseur, rotation );
1030  break;
1032  item->Rotate( editFrame->GetAuxOrigin(), rotation );
1033  break;
1034  }
1035 
1036  if( !m_dragging )
1037  getView()->Update( item );
1038  }
1039 
1040  m_commit->Push( _( "Move exact" ) );
1041 
1042  if( selection.IsHover() )
1044 
1046 
1047  if( m_dragging )
1049  }
1050 
1051  return 0;
1052 }
1053 
1054 
1055 int EDIT_TOOL::Duplicate( const TOOL_EVENT& aEvent )
1056 {
1057  bool increment = aEvent.IsAction( &PCB_ACTIONS::duplicateIncrement );
1058 
1059  // Be sure that there is at least one item that we can modify
1061  []( const VECTOR2I& aPt, GENERAL_COLLECTOR& aCollector )
1063 
1064  if( selection.Empty() )
1065  return 0;
1066 
1067  // we have a selection to work on now, so start the tool process
1068  PCB_BASE_EDIT_FRAME* editFrame = getEditFrame<PCB_BASE_EDIT_FRAME>();
1069 
1070  std::vector<BOARD_ITEM*> new_items;
1071  new_items.reserve( selection.Size() );
1072 
1073  BOARD_ITEM* orig_item = nullptr;
1074  BOARD_ITEM* dupe_item = nullptr;
1075 
1076  // Each selected item is duplicated and pushed to new_items list
1077  // Old selection is cleared, and new items are then selected.
1078  for( EDA_ITEM* item : selection )
1079  {
1080  if( !item )
1081  continue;
1082 
1083  orig_item = static_cast<BOARD_ITEM*>( item );
1084 
1085  if( m_editModules )
1086  {
1087  dupe_item = editFrame->GetBoard()->m_Modules->Duplicate( orig_item, increment );
1088  }
1089  else
1090  {
1091 #if 0
1092  // @TODO: see if we allow zone duplication here
1093  // Duplicate zones is especially tricky (overlaping zones must be merged)
1094  // so zones are not duplicated
1095  if( item->Type() != PCB_ZONE_AREA_T )
1096 #endif
1097  dupe_item = editFrame->GetBoard()->Duplicate( orig_item );
1098  }
1099 
1100  if( dupe_item )
1101  {
1102  // Clear the selection flag here, otherwise the SELECTION_TOOL
1103  // will not properly select it later on
1104  dupe_item->ClearSelected();
1105 
1106  new_items.push_back( dupe_item );
1107  m_commit->Add( dupe_item );
1108  }
1109  }
1110 
1111  // Clear the old selection first
1113 
1114  // Select the new items
1115  m_toolMgr->RunAction( PCB_ACTIONS::selectItems, true, &new_items );
1116 
1117  // record the new items as added
1118  if( !selection.Empty() )
1119  {
1120  editFrame->DisplayToolMsg( wxString::Format( _( "Duplicated %d item(s)" ),
1121  (int) new_items.size() ) );
1122 
1123  // If items were duplicated, pick them up
1124  // this works well for "dropping" copies around and pushes the commit
1126  Main( evt );
1127  }
1128 
1129  return 0;
1130 }
1131 
1132 
1134 {
1135 public:
1136 
1137  GAL_ARRAY_CREATOR( PCB_BASE_FRAME& editFrame, bool editModules,
1138  const SELECTION& selection ):
1139  ARRAY_CREATOR( editFrame ),
1140  m_editModules( editModules ),
1141  m_selection( selection )
1142  {}
1143 
1144 private:
1145 
1146  int getNumberOfItemsToArray() const override
1147  {
1148  // only handle single items
1149  return m_selection.Size();
1150  }
1151 
1152  BOARD_ITEM* getNthItemToArray( int n ) const override
1153  {
1154  return static_cast<BOARD_ITEM*>( m_selection[n] );
1155  }
1156 
1157  BOARD* getBoard() const override
1158  {
1159  return m_parent.GetBoard();
1160  }
1161 
1162  MODULE* getModule() const override
1163  {
1164  // Remember this is valid and used only in the module editor.
1165  // in board editor, the parent of items is usually the board.
1166  return m_editModules ? m_parent.GetBoard()->m_Modules.GetFirst() : NULL;
1167  }
1168 
1169  wxPoint getRotationCentre() const override
1170  {
1171  const VECTOR2I rp = m_selection.GetCenter();
1172  return wxPoint( rp.x, rp.y );
1173  }
1174 
1175  void prePushAction( BOARD_ITEM* aItem ) override
1176  {
1177  // Because aItem is/can be created from a selected item, and inherits from
1178  // it this state, reset the selected stated of aItem:
1179  aItem->ClearSelected();
1180 
1181  if( aItem->Type() == PCB_MODULE_T )
1182  {
1183  static_cast<MODULE*>( aItem )->RunOnChildren( [&] ( BOARD_ITEM* item )
1184  {
1185  item->ClearSelected();
1186  }
1187  );
1188  }
1189  }
1190 
1191  void postPushAction( BOARD_ITEM* new_item ) override
1192  {
1193  }
1194 
1195  void finalise() override
1196  {
1197  }
1198 
1201 };
1202 
1203 
1205 {
1207  []( const VECTOR2I& aPt, GENERAL_COLLECTOR& aCollector )
1209 
1210  if( selection.Empty() )
1211  return 0;
1212 
1213  // we have a selection to work on now, so start the tool process
1214  PCB_BASE_FRAME* editFrame = getEditFrame<PCB_BASE_FRAME>();
1215  GAL_ARRAY_CREATOR array_creator( *editFrame, m_editModules, selection );
1216  array_creator.Invoke();
1217 
1218  return 0;
1219 }
1220 
1221 
1223 {
1224  for( int i = aCollector.GetCount() - 1; i >= 0; i-- )
1225  {
1226  BOARD_ITEM* item = static_cast<BOARD_ITEM*>( aCollector[i] );
1227 
1228  if( item->Type() != PCB_PAD_T )
1229  aCollector.Remove( i );
1230  }
1231 }
1232 
1233 
1235 {
1236  for( int i = aCollector.GetCount() - 1; i >= 0; i-- )
1237  {
1238  BOARD_ITEM* item = static_cast<BOARD_ITEM*>( aCollector[i] );
1239 
1240  if( item->Type() != PCB_MODULE_T )
1241  aCollector.Remove( i );
1242  }
1243 }
1244 
1245 
1247 {
1249 
1250  bool updateMode = aEvent.IsAction( &PCB_ACTIONS::updateFootprints );
1251 
1252  MODULE* mod = (selection.Empty() ? nullptr : selection.FirstOfKind<MODULE> () );
1253 
1254  frame()->SetCurItem( mod );
1255 
1256  // Footprint exchange could remove modules, so they have to be
1257  // removed from the selection first
1259 
1260  // invoke the exchange dialog process
1261  {
1262  DIALOG_EXCHANGE_FOOTPRINTS dialog( frame(), mod, updateMode, mod != nullptr );
1263  dialog.ShowQuasiModal();
1264  }
1265 
1266  return 0;
1267 }
1268 
1269 
1271 {
1272  if( EditingModules() && !frame()->GetModel())
1273  return 0;
1274 
1275  auto& view = *getView();
1276  auto& controls = *getViewControls();
1278 
1279  Activate();
1280  frame()->SetToolID( toolID, wxCURSOR_PENCIL, _( "Measure distance" ) );
1281 
1282  EDA_UNITS_T units = frame()->GetUserUnits();
1284  KIGFX::PREVIEW::RULER_ITEM ruler( twoPtMgr, units );
1285 
1286  view.Add( &ruler );
1287  view.SetVisible( &ruler, false );
1288 
1289  GRID_HELPER grid( frame() );
1290 
1291  bool originSet = false;
1292 
1293  controls.ShowCursor( true );
1294  controls.SetAutoPan( false );
1295  controls.CaptureCursor( false );
1296 
1297  while( auto evt = Wait() )
1298  {
1299  grid.SetSnap( !evt->Modifier( MD_SHIFT ) );
1300  grid.SetUseGrid( !evt->Modifier( MD_ALT ) );
1301  controls.SetSnapping( !evt->Modifier( MD_ALT ) );
1302  const VECTOR2I cursorPos = grid.BestSnapAnchor( controls.GetMousePosition(), nullptr );
1303  controls.ForceCursorPosition(true, cursorPos );
1304 
1306  {
1307  break;
1308  }
1309 
1310  // click or drag starts
1311  else if( !originSet && ( evt->IsDrag( BUT_LEFT ) || evt->IsClick( BUT_LEFT ) ) )
1312  {
1313  twoPtMgr.SetOrigin( cursorPos );
1314  twoPtMgr.SetEnd( cursorPos );
1315 
1316  controls.CaptureCursor( true );
1317  controls.SetAutoPan( true );
1318 
1319  originSet = true;
1320  }
1321 
1322  // second click or mouse up after drag ends
1323  else if( originSet && ( evt->IsClick( BUT_LEFT ) || evt->IsMouseUp( BUT_LEFT ) ) )
1324  {
1325  originSet = false;
1326 
1327  controls.SetAutoPan( false );
1328  controls.CaptureCursor( false );
1329  }
1330 
1331  // move or drag when origin set updates rules
1332  else if( originSet && ( evt->IsMotion() || evt->IsDrag( BUT_LEFT ) ) )
1333  {
1334  twoPtMgr.SetAngleSnap( evt->Modifier( MD_CTRL ) );
1335  twoPtMgr.SetEnd( cursorPos );
1336 
1337  view.SetVisible( &ruler, true );
1338  view.Update( &ruler, KIGFX::GEOMETRY );
1339  }
1340 
1341  else if( evt->IsAction( &ACTIONS::toggleUnits )
1342  || evt->IsAction( &PCB_ACTIONS::updateUnits ) )
1343  {
1344  if( frame()->GetUserUnits() != units )
1345  {
1346  units = frame()->GetUserUnits();
1347  ruler.SwitchUnits();
1348  view.Update( &ruler, KIGFX::GEOMETRY );
1349  }
1350  }
1351 
1352  else if( evt->IsClick( BUT_RIGHT ) )
1353  {
1355  }
1356  }
1357 
1358  view.SetVisible( &ruler, false );
1359  view.Remove( &ruler );
1360 
1361  frame()->SetNoToolSelected();
1362 
1363  return 0;
1364 }
1365 
1366 
1368 {
1369  if( m_dragging && aSelection.HasReferencePoint() )
1370  return false;
1371 
1372  // When there is only one item selected, the reference point is its position...
1373  if( aSelection.Size() == 1 )
1374  {
1375  auto item = static_cast<BOARD_ITEM*>( aSelection.Front() );
1376  auto pos = item->GetPosition();
1377  aSelection.SetReferencePoint( VECTOR2I( pos.x, pos.y ) );
1378  }
1379  // ...otherwise modify items with regard to the grid-snapped cursor position
1380  else
1381  {
1383  aSelection.SetReferencePoint( m_cursor );
1384  }
1385 
1386  return true;
1387 }
1388 
1389 
1391 {
1393 
1394  if( selection.Empty() )
1395  return 0;
1396 
1398 
1399  if( !mod )
1400  return 0;
1401 
1402  PCB_BASE_EDIT_FRAME* editFrame = getEditFrame<PCB_BASE_EDIT_FRAME>();
1403 
1404  editFrame->SetCurItem( mod );
1405 
1406  if( editFrame->GetCurItem()->GetTimeStamp() == 0 ) // Module Editor needs a non null timestamp
1407  {
1408  editFrame->GetCurItem()->SetTimeStamp( GetNewTimeStamp() );
1409  editFrame->OnModify();
1410  }
1411 
1413 
1414  editor->Load_Module_From_BOARD( (MODULE*) editFrame->GetCurItem() );
1415  editFrame->SetCurItem( NULL ); // the current module could be deleted by
1416 
1417  editor->Show( true );
1418  editor->Raise(); // Iconize( false );
1419 
1420  if( selection.IsHover() )
1422 
1423  return 0;
1424 }
1425 
1426 
1428 {
1429  STATUS_TEXT_POPUP statusPopup( frame() );
1430  PICKER_TOOL* picker = m_toolMgr->GetTool<PICKER_TOOL>();
1431  bool picking = true;
1432  bool retVal = true;
1433 
1434  statusPopup.SetText( _( "Select reference point for the copy..." ) );
1435  picker->Activate();
1436  picker->SetClickHandler( [&]( const VECTOR2D& aPoint ) -> bool
1437  {
1438  aP = aPoint;
1439  statusPopup.SetText( _( "Selection copied." ) );
1440  statusPopup.Expire( 800 );
1441  picking = false;
1442  return false; // we don't need any more points
1443  } );
1444  picker->SetCancelHandler( [&]()
1445  {
1446  statusPopup.SetText( _( "Copy cancelled." ) );
1447  statusPopup.Expire( 800 );
1448  picking = false;
1449  retVal = false;
1450  } );
1451 
1452  statusPopup.Move( wxGetMousePosition() + wxPoint( 20, -50 ) );
1453  statusPopup.Popup();
1454 
1455  while( picking )
1456  {
1457  statusPopup.Move( wxGetMousePosition() + wxPoint( 20, -50 ) );
1458  Wait();
1459  }
1460 
1461  statusPopup.Hide();
1462  return retVal;
1463 }
1464 
1465 
1466 int EDIT_TOOL::doCopyToClipboard( bool withAnchor )
1467 {
1468  CLIPBOARD_IO io;
1469 
1470  Activate();
1471 
1473  []( const VECTOR2I& aPt, GENERAL_COLLECTOR& aCollector )
1475 
1476  if( selection.Empty() )
1477  return 1;
1478 
1479  if( withAnchor )
1480  {
1481  VECTOR2I refPoint;
1482  bool rv = pickCopyReferencePoint( refPoint );
1483  frame()->SetMsgPanel( board() );
1484 
1485  if( !rv )
1486  return 1;
1487 
1488  selection.SetReferencePoint( refPoint );
1489  }
1490 
1491  io.SetBoard( board() );
1492  io.SaveSelection( selection );
1493 
1494  return 0;
1495 }
1496 
1497 
1499 {
1500  return doCopyToClipboard( true );
1501 }
1502 
1503 
1505 {
1506  return doCopyToClipboard( true );
1507 }
1508 
1509 
1511 {
1512  if( !copyToClipboard( aEvent ) )
1513  {
1514  // N.B. Setting the CUT flag prevents lock filtering as we only want to delete the items that
1515  // were copied to the clipboard, no more, no fewer. Filtering for locked item, if any will be done
1516  // in the copyToClipboard() routine
1517  TOOL_EVENT evt( aEvent.Category(), aEvent.Action(), TOOL_ACTION_SCOPE::AS_GLOBAL );
1519  Remove( evt );
1520  }
1521 
1522  return 0;
1523 }
1524 
1525 
1527 {
1528  Go( &EDIT_TOOL::Main, PCB_ACTIONS::editActivate.MakeEvent() );
1529  Go( &EDIT_TOOL::Main, PCB_ACTIONS::move.MakeEvent() );
1530  Go( &EDIT_TOOL::Drag, PCB_ACTIONS::drag45Degree.MakeEvent() );
1532  Go( &EDIT_TOOL::Rotate, PCB_ACTIONS::rotateCw.MakeEvent() );
1533  Go( &EDIT_TOOL::Rotate, PCB_ACTIONS::rotateCcw.MakeEvent() );
1534  Go( &EDIT_TOOL::Flip, PCB_ACTIONS::flip.MakeEvent() );
1535  Go( &EDIT_TOOL::Remove, PCB_ACTIONS::remove.MakeEvent() );
1536  Go( &EDIT_TOOL::Remove, PCB_ACTIONS::removeAlt.MakeEvent() );
1542  Go( &EDIT_TOOL::Mirror, PCB_ACTIONS::mirror.MakeEvent() );
1543 
1548 
1549  Go( &EDIT_TOOL::copyToClipboard, ACTIONS::copy.MakeEvent() );
1550  Go( &EDIT_TOOL::cutToClipboard, ACTIONS::cut.MakeEvent() );
1551 }
1552 
1553 
static TOOL_ACTION selectItems
Selects a list of items (specified as the event parameter)
Definition: pcb_actions.h:60
static TOOL_ACTION selectionClear
Clears the current selection.
Definition: pcb_actions.h:53
VECTOR2I GetReferencePoint() const
Definition: selection.h:203
VECTOR2I BestDragOrigin(const VECTOR2I &aMousePos, BOARD_ITEM *aItem)
virtual void ShowCursor(bool aEnabled)
Function ShowCursor() Enables or disables display of cursor.
void setTransitions() override
Sets up handlers for various events.
Definition: edit_tool.cpp:1526
VECTOR2I m_cursor
Last cursor position (needed for getModificationPoint() to avoid changes of edit reference point).
Definition: edit_tool.h:209
void ClearReferencePoint()
Definition: selection.h:213
TOOL_MENU m_menu
Menu model displayed by the tool.
int Main(const TOOL_EVENT &aEvent)
Function Main()
Definition: edit_tool.cpp:326
int Properties(const TOOL_EVENT &aEvent)
Function Edit()
Definition: edit_tool.cpp:619
int Rotate(const TOOL_EVENT &aEvent)
Function Rotate()
Definition: edit_tool.cpp:661
static TOOL_ACTION move
move an item
Definition: pcb_actions.h:92
KIWAY & Kiway() const
Function Kiway returns a reference to the KIWAY that this object has an opportunity to participate in...
Definition: kiway_player.h:61
VECTOR2I GetCenter() const
Returns the center point of the selection area bounding box.
virtual void SetToolID(int aId, int aCursor, const wxString &aToolMsg) override
Set the tool command ID to aId and sets the cursor to aCursor.
bool IsHover() const
Definition: selection.h:69
int ExchangeFootprints(const TOOL_EVENT &aEvent)
Function ExchangeFootprints()
Definition: edit_tool.cpp:1246
static TOOL_ACTION editActivate
Activation of the edit tool.
Definition: pcb_actions.h:89
static const KICAD_T Tracks[]
A scan list for only TRACKS.
Definition: collectors.h:313
virtual VECTOR2D GetMousePosition(bool aWorldCoordinates=true) const =0
Function GetMousePosition() Returns the current mouse pointer position.
BOARD * board() const
int GetCurrentViaDrill() const
Function GetCurrentViaDrill.
SELECTION & RequestSelection(CLIENT_SELECTION_FILTER aClientFilter, std::vector< BOARD_ITEM * > *aFiltered=NULL, bool aConfirmLockedItems=false)
Function RequestSelection()
int GetCurrentTrackWidth() const
Function GetCurrentTrackWidth.
virtual void Update(VIEW_ITEM *aItem, int aUpdateFlags) override
For dynamic VIEWs, informs the associated VIEW that the graphical representation of this item has cha...
Definition: pcb_view.cpp:91
This file is part of the common library.
Class BOARD_ITEM is a base class for any item which can be embedded within the BOARD container class,...
bool HasType(KICAD_T aType) const
Checks if there is at least one item of requested kind.
Definition: selection.h:185
void SetClickHandler(CLICK_HANDLER aHandler)
Function SetClickHandler() Sets a handler for mouse click event.
Definition: picker_tool.h:83
std::unique_ptr< BOARD_COMMIT > m_commit
Definition: edit_tool.h:223
void ClearSelected()
Definition: base_struct.h:237
int doCopyToClipboard(bool withAnchor)
Definition: edit_tool.cpp:1466
void AddSeparator(const SELECTION_CONDITION &aCondition=SELECTION_CONDITIONS::ShowAlways, int aOrder=ANY_ORDER)
Function AddSeparator()
VIEW_CONTROLS class definition.
TOOL_ACTIONS Action() const
Returns more specific information about the type of an event.
Definition: tool_event.h:239
static SELECTION_CONDITION OnlyTypes(const KICAD_T aTypes[])
Function OnlyTypes Creates a functor that tests if the selected items are only of given types.
virtual void OnEditItemRequest(wxDC *aDC, BOARD_ITEM *aItem)=0
Function OnEditItemRequest Install the corresponding dialog editor for the given item.
Class BOARD to handle a board.
SELECTION_LOCK_FLAGS CheckLock()
Checks if the user has agreed to modify locked items for the given selection.
Class STATUS_TEXT_POPUP.
Definition: status_popup.h:79
CONDITIONAL_MENU & GetMenu()
Function GetMenu.
Definition: tool_menu.cpp:46
bool updateModificationPoint(SELECTION &aSelection)
Returns the right modification point (e.g.
Definition: edit_tool.cpp:1367
static TOOL_ACTION dragFreeAngle
Definition: pcb_actions.h:133
Tool is invoked after being inactive.
Definition: tool_base.h:82
TOOL_MENU & GetToolMenu()
static TOOL_ACTION explodePadToShapes
Definition: pcb_actions.h:264
TOOL_MANAGER * m_toolMgr
Definition: tool_base.h:216
PCB_BASE_FRAME & m_parent
Definition: array_creator.h:61
class ZONE_CONTAINER, a zone area
Definition: typeinfo.h:100
virtual void Remove(VIEW_ITEM *aItem)
Function Remove() Removes a VIEW_ITEM from the view.
Definition: view.cpp:376
static TOOL_ACTION properties
Activation of the edit tool.
Definition: pcb_actions.h:105
void SetCurItem(BOARD_ITEM *aItem, bool aDisplayInfo=true)
Function SetCurItem sets the currently selected item and displays it in the MsgPanel.
DLIST_ITERATOR_WRAPPER< D_PAD > Pads()
Definition: class_module.h:168
OPT_TOOL_EVENT Wait(const TOOL_EVENT_LIST &aEventList=TOOL_EVENT(TC_ANY, TA_ANY))
Function Wait()
virtual void SetSnapping(bool aEnabled)
Function SetSnapping() Enables/disables snapping cursor to grid.
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
void SetPosition(const wxPoint &aPos) override
Definition: class_pad.h:221
static TOOL_ACTION removeAlt
Definition: pcb_actions.h:124
Classes to handle copper zones.
BOARD_DESIGN_SETTINGS & GetDesignSettings() const
Function GetDesignSettings.
Definition: class_board.h:534
static TOOL_ACTION drag45Degree
Definition: pcb_actions.h:132
TOOL_EVENT_CATEGORY Category() const
Returns the category (eg. mouse/keyboard/action) of an event..
Definition: tool_event.h:233
static TOOL_ACTION mirror
Mirroring of selected items.
Definition: pcb_actions.h:102
class D_PAD, a pad in a footprint
Definition: typeinfo.h:90
VECTOR2I BestSnapAnchor(const VECTOR2I &aOrigin, BOARD_ITEM *aDraggedItem)
static TOOL_ACTION updateUnits
Definition: pcb_actions.h:309
void UndoRedoBlock(bool aBlock=true)
Function UndoRedoBlock Enables/disable undo and redo operations.
TOOL_BASE * FindTool(int aId) const
Function FindTool() Searches for a tool with given ID.
SELECTION_TOOL * m_selectionTool
Selection tool used for obtaining selected items
Definition: edit_tool.h:199
static SELECTION_CONDITION Count(int aNumber)
Function Count Creates a functor that tests if the number of selected items is equal to the value giv...
void SaveSelection(const SELECTION &selected)
VECTOR2< int > VECTOR2I
Definition: vector2d.h:587
void SetBoard(BOARD *aBoard)
static bool NotEmpty(const SELECTION &aSelection)
Function NotEmpty Tests if there are any items selected.
wxPoint m_O_Curseur
Relative Screen cursor coordinate (on grid) in user units.
Definition: base_screen.h:185
void Go(int(T::*aStateFunc)(const TOOL_EVENT &), const TOOL_EVENT_LIST &aConditions=TOOL_EVENT(TC_ANY, TA_ANY))
Function Go()
class EDGE_MODULE, a footprint edge
Definition: typeinfo.h:94
static const int delta[8][2]
Definition: solve.cpp:112
void Remove(int aIndex)
Function Remove removes the item at aIndex (first position is 0);.
Definition: collector.h:143
virtual void Remove(VIEW_ITEM *aItem) override
Function Remove() Removes a VIEW_ITEM from the view.
Definition: pcb_view.cpp:74
const wxPoint & GetAuxOrigin() const override
Return the origin of the axis used for plotting and various exports.
static const TOOL_EVENT SelectedItemsModified
Definition: actions.h:136
MODULE * getModule() const override
Definition: edit_tool.cpp:1162
class TRACK, a track segment (segment on a copper layer)
Definition: typeinfo.h:95
int Mirror(const TOOL_EVENT &aEvent)
Function Mirror.
Definition: edit_tool.cpp:744
Pcbnew hotkeys.
BOARD_ITEM * getNthItemToArray(int n) const override
Definition: edit_tool.cpp:1152
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
static TOOL_ACTION moveExact
Activation of the exact move tool.
Definition: pcb_actions.h:108
int cutToClipboard(const TOOL_EVENT &aEvent)
Function cutToClipboard() Cuts the current selection to the clipboard by formatting it as a fake pcb ...
Definition: edit_tool.cpp:1510
Generic tool for picking a point.
Definition: picker_tool.h:34
void Append(EDA_ITEM *item)
Function Append adds an item to the end of the list.
Definition: collector.h:133
void finalise() override
Definition: edit_tool.cpp:1195
bool m_lockedSelected
Flag determining whether we are prompting for locked removal
Definition: edit_tool.h:205
void SetParameter(T aParam)
Function SetParameter() Sets a non-standard parameter assigned to the event.
Definition: tool_event.h:390
int GetCount() const
Function GetCount returns the number of objects in the list.
Definition: collector.h:114
static TOOL_ACTION duplicate
Activation of the duplication tool.
Definition: pcb_actions.h:111
class MODULE, a footprint
Definition: typeinfo.h:89
static TOOL_ACTION copy
Definition: actions.h:53
int Flip(const TOOL_EVENT &aEvent)
Function Flip()
Definition: edit_tool.cpp:824
void SetReferencePoint(const VECTOR2I &aP)
Definition: selection.h:208
static TOOL_ACTION duplicateIncrement
Activation of the duplication tool with incrementing (e.g. pad number)
Definition: pcb_actions.h:114
timestamp_t GetNewTimeStamp()
Definition: common.cpp:217
bool isInteractiveDragEnabled() const
Definition: edit_tool.cpp:306
static TOOL_ACTION rotateCw
Rotation of selected objects.
Definition: pcb_actions.h:95
Class LSET is a set of PCB_LAYER_IDs.
int getNumberOfItemsToArray() const override
Definition: edit_tool.cpp:1146
wxPoint getRotationCentre() const override
Definition: edit_tool.cpp:1169
VTBL_ENTRY KIWAY_PLAYER * Player(FRAME_T aFrameType, bool doCreate=true, wxTopLevelWindow *aParent=NULL)
Function Player returns the KIWAY_PLAYER* given a FRAME_T.
Definition: kiway.cpp:321
void SetMsgPanel(const std::vector< MSG_PANEL_ITEM > &aList)
Clear the message panel and populates it with the contents of aList.
bool m_dragging
Flag determining if anything is being dragged right now
Definition: edit_tool.h:202
bool ProcessEvent(const TOOL_EVENT &aEvent)
Propagates an event to tools that requested events of matching type(s).
virtual void Move(const wxPoint &aMoveVector)
Function Move move this object.
virtual void CaptureCursor(bool aEnabled)
Function CaptureCursor() Forces the cursor to stay within the drawing panel area.
PCB_GENERAL_SETTINGS & Settings()
int ShowQuasiModal()
EDA_UNITS_T GetUserUnits() const override
Return the user units currently in use.
Definition: draw_frame.h:289
SELECTION_LOCK_FLAGS
Definition: selection.h:232
T Parameter() const
Function Parameter() Returns a non-standard parameter assigned to the event.
Definition: tool_event.h:378
const wxPoint & GetOffset() const
Definition: class_pad.h:280
Class TOOL_EVENT.
Definition: tool_event.h:167
static TOOL_ACTION createArray
Tool for creating an array of objects.
Definition: pcb_actions.h:270
void SetOrigin(const VECTOR2I &aOrigin)
Set the origin of the ruler (the fixed end)
GAL_ARRAY_CREATOR(PCB_BASE_FRAME &editFrame, bool editModules, const SELECTION &selection)
Definition: edit_tool.cpp:1137
static TOOL_ACTION cut
Definition: actions.h:52
KIGFX::PCB_VIEW * view() const
timestamp_t GetTimeStamp() const
Definition: base_struct.h:210
SELECTION & GetSelection()
Function GetSelection()
bool HasItem(const EDA_ITEM *aItem) const
Function HasItem tests if aItem has already been collected.
Definition: collector.h:197
bool Init() override
Function Init() Init() is called once upon a registration of the tool.
Definition: edit_tool.cpp:218
Class VIEW_CONTROLS is an interface for classes handling user events controlling the view behaviour (...
bool Load_Module_From_BOARD(MODULE *Module)
Load in Modedit a footprint from the main board.
virtual void Popup(wxWindow *aFocus=nullptr)
int Drag(const TOOL_EVENT &aEvent)
Function Drag()
Definition: edit_tool.cpp:314
Class RULER_ITEM.
Definition: ruler_item.h:43
virtual void ForceCursorPosition(bool aEnabled, const VECTOR2D &aPosition=VECTOR2D(0, 0))
Function ForceCursorPosition() Places the cursor immediately at a given point.
virtual void Rotate(const wxPoint &aRotCentre, double aAngle)
Function Rotate Rotate this object.
PCB_EDIT_FRAME::OnSelectOptionToolbar ID_PCB_MEASUREMENT_TOOL
static TOOL_ACTION exchangeFootprints
Exchange footprints of modules.
Definition: pcb_actions.h:120
virtual void Move(const wxPoint &aWhere)
const wxSize & GetDelta() const
Definition: class_pad.h:274
bool IsCancelInteractive(const TOOL_EVENT &aEvt)
Function IsCancelInteractive()
Definition: tool_event.cpp:177
All active tools
Definition: tool_event.h:143
T * GetFirst() const
Function GetFirst returns the first T* in the list without removing it, or NULL if the list is empty.
Definition: dlist.h:163
virtual void Update(VIEW_ITEM *aItem, int aUpdateFlags)
For dynamic VIEWs, informs the associated VIEW that the graphical representation of this item has cha...
Definition: view.cpp:1539
BOARD * getBoard() const override
Definition: edit_tool.cpp:1157
void Expire(int aMsecs)
Hides the popup after a specified time.
const SELECTION & m_selection
Definition: edit_tool.cpp:1200
ROTATION_ANCHOR
static TOOL_ACTION routerInlineDrag
Activation of the Push and Shove router (inline dragging mode)
Definition: pcb_actions.h:185
PCB_EDIT_FRAME * frame() const
KIGFX::VIEW * getView() const
Function getView()
Definition: tool_base.cpp:35
virtual void SetAutoPan(bool aEnabled)
Function SetAutoPan Turns on/off auto panning (this feature is used when there is a tool active (eg.
#define EXCLUDE_TRANSIENTS
Definition: edit_tool.h:48
bool Empty() const
Checks if there is anything selected.
Definition: selection.h:119
static TOOL_ACTION inlineBreakTrack
Breaks track when router is not activated.
Definition: pcb_actions.h:130
void SetCancelHandler(CANCEL_HANDLER aHandler)
Function SetCancelHandler() Sets a handler for cancel events (ESC or context-menu Cancel).
Definition: picker_tool.h:93
virtual const wxPoint GetPosition() const =0
void SetSnap(bool aSnap)
Definition: grid_helper.h:72
void Reset(RESET_REASON aReason) override
Function Reset() Brings the tool to a known, initial state.
Definition: edit_tool.cpp:209
static TOOL_ACTION expandSelectedConnection
Expands the current selection to select a connection between two junctions.
Definition: pcb_actions.h:70
bool EditingModules() const
static TOOL_ACTION updateFootprints
Update footprints to reflect any changes in the library.
Definition: pcb_actions.h:117
static TOOL_ACTION rotateCcw
Definition: pcb_actions.h:96
static void PadFilter(const VECTOR2I &, GENERAL_COLLECTOR &aCollector)
Function PadFilter()
Definition: edit_tool.cpp:1222
class TEXTE_MODULE, text in a footprint
Definition: typeinfo.h:93
int MoveExact(const TOOL_EVENT &aEvent)
Function MoveExact()
Definition: edit_tool.cpp:981
ID_MODEDIT_MEASUREMENT_TOOL
VECTOR2I Align(const VECTOR2I &aPoint) const
int Remove(const TOOL_EVENT &aEvent)
Function Remove()
Definition: edit_tool.cpp:863
static ROUTER * theRouter
Definition: pns_router.cpp:59
static TOOL_ACTION createPadFromShapes
Definition: pcb_actions.h:263
static TOOL_ACTION flip
Flipping of selected objects.
Definition: pcb_actions.h:99
virtual void SetNoToolSelected()
Select the ID_NO_TOOL_SELECTED id tool (Idle tool)
virtual void OnModify()
Function OnModify Virtual Must be called after a change in order to set the "modify" flag of the curr...
int GetCurrentViaSize() const
Function GetCurrentViaSize.
virtual bool IsLocked() const
Function IsLocked.
bool invokeInlineRouter(int aDragMode)
Definition: edit_tool.cpp:285
bool HasReferencePoint() const
Definition: selection.h:198
class MARKER_PCB, a marker used to show something
Definition: typeinfo.h:97
bool pickCopyReferencePoint(VECTOR2I &aP)
Definition: edit_tool.cpp:1427
void DisplayToolMsg(const wxString &msg)
int CreateArray(const TOOL_EVENT &aEvent)
Function CreateArray()
Definition: edit_tool.cpp:1204
KIGFX::VIEW_CONTROLS * controls() const
bool changeTrackWidthOnClick(const SELECTION &selection)
Definition: edit_tool.cpp:578
Common, abstract interface for edit frames.
int MeasureTool(const TOOL_EVENT &aEvent)
Launches a tool to measure between points
Definition: edit_tool.cpp:1270
void Format(OUTPUTFORMATTER *out, int aNestLevel, int aCtl, CPTREE &aTree)
Function Format outputs a PTREE into s-expression format via an OUTPUTFORMATTER derivative.
Definition: ptree.cpp:205
Class BOARD holds information pertinent to a Pcbnew printed circuit board.
Definition: class_board.h:170
MODULE * module() const
static TOOL_ACTION editFootprintInFpEditor
Definition: pcb_actions.h:332
DLIST< MODULE > m_Modules
Definition: class_board.h:248
double GetOrientation() const
Function GetOrientation returns the rotation angle of the pad in tenths of degrees,...
Definition: class_pad.h:394
Used when the right click button is pressed, or when the select tool is in effect.
Definition: collectors.h:240
Class TOOL_ACTION.
Definition: tool_action.h:46
size_t i
Definition: json11.cpp:597
static SELECTION_CONDITION OnlyType(KICAD_T aType)
Function OnlyType Creates a functor that tests if the selected items are only of given type.
TOOL_EVENT MakeEvent() const
Function MakeEvent() Returns the event associated with the action (i.e.
Definition: tool_action.h:95
int Size() const
Returns the number of selected parts.
Definition: selection.h:125
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 SetAuxAxes(bool aEnable, const VECTOR2I &aOrigin=VECTOR2I(0, 0), bool aEnableDiagonal=false)
static wxPoint mirrorPointX(const wxPoint &aPoint, const wxPoint &aMirrorPoint)
Definition: edit_tool.cpp:706
PCB_SCREEN * GetScreen() const override
Return a pointer to a BASE_SCREEN or one of its derivatives.
static TOOL_ACTION positionRelative
Activation of the position relative tool.
Definition: pcb_actions.h:206
RESET_REASON
Determines the reason of reset for a tool
Definition: tool_base.h:80
int editFootprintInFpEditor(const TOOL_EVENT &aEvent)
Definition: edit_tool.cpp:1390
T * FirstOfKind() const
Definition: selection.h:166
void SetOrientation(double aAngle)
Function SetOrientation sets the rotation angle of the pad.
Definition: class_pad.cpp:429
void SetVisible(VIEW_ITEM *aItem, bool aIsVisible=true)
Sets the item visibility.
Definition: view.cpp:1485
void Activate()
Function Activate() Runs the tool.
class VIA, a via (like a track segment on a copper layer)
Definition: typeinfo.h:96
virtual void Add(VIEW_ITEM *aItem, int aDrawPriority=-1) override
Function Add() Adds a VIEW_ITEM to the view.
Definition: pcb_view.cpp:58
void SetUseGrid(bool aGrid=true)
Definition: grid_helper.h:77
void SetX0(int x)
Definition: class_pad.h:268
#define EXCLUDE_LOCKED
Function EditToolSelectionFilter.
Definition: edit_tool.h:46
int copyToClipboard(const TOOL_EVENT &aEvent)
Function copyToClipboard() Sends the current selection to the clipboard by formatting it as a fake pc...
Definition: edit_tool.cpp:1498
PAD_SHAPE_T GetShape() const
Function GetShape.
Definition: class_pad.h:218
static TOOL_ACTION updateLocalRatsnest
Definition: pcb_actions.h:324
int copyToClipboardWithAnchor(const TOOL_EVENT &aEvent)
Definition: edit_tool.cpp:1504
Module description (excepted pads)
static void FootprintFilter(const VECTOR2I &, GENERAL_COLLECTOR &aCollector)
Function FootprintFilter()
Definition: edit_tool.cpp:1234
BOARD * GetBoard() const
KIGFX::VIEW_CONTROLS * getViewControls() const
Function getViewControls()
Definition: tool_base.cpp:41
bool RoutingInProgress() const
Definition: pns_router.cpp:112
SGLIB_API S3DMODEL * GetModel(SCENEGRAPH *aNode)
Function GetModel creates an S3DMODEL representation of aNode (raw data, no transforms)
Definition: ifsg_api.cpp:471
static TOOL_ACTION remove
Deleting a BOARD_ITEM.
Definition: pcb_actions.h:123
void UpdateMsgPanel() override
ROUTER * Router() const
const wxPoint GetPosition() const override
Definition: class_pad.h:222
#define EXCLUDE_LOCKED_PADS
Definition: edit_tool.h:47
EDGE_MODULE class definition.
void postPushAction(BOARD_ITEM *new_item) override
Definition: edit_tool.cpp:1191
BOARD_ITEM_CONTAINER * GetParent() const
int GetEventRotationAngle(const PCB_BASE_EDIT_FRAME &aFrame, const TOOL_EVENT &aEvt)
Function getEventRotationAngle()
BOARD_ITEM * GetCurItem()
void SetOffset(const wxPoint &aOffset)
Definition: class_pad.h:279
void EditToolSelectionFilter(GENERAL_COLLECTOR &aCollector, int aFlags)
Definition: edit_tool.cpp:159
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
const SELECTION & selection() const
int Duplicate(const TOOL_EVENT &aEvent)
Function Duplicate()
Definition: edit_tool.cpp:1055
void AddItem(const TOOL_ACTION &aAction, const SELECTION_CONDITION &aCondition, int aOrder=ANY_ORDER)
Function AddItem()
void DisplayError(wxWindow *parent, const wxString &text, int displaytime)
Function DisplayError displays an error or warning message box with aMessage.
Definition: confirm.cpp:244
static TOOL_ACTION toggleUnits
Definition: actions.h:104
void ShowContextMenu(SELECTION &aSelection)
Function ShowContextMenu.
Definition: tool_menu.cpp:59
ROUTING_SETTINGS & Settings()
Definition: pns_router.h:187
static void mirrorPadX(D_PAD &aPad, const wxPoint &aMirrorPoint)
Mirror a pad in the vertical axis passing through a point.
Definition: edit_tool.cpp:721
void MirrorXPrimitives(int aX)
Mirror the primitives about a coordinate.
Definition: class_pad.cpp:496
#define mod(a, n)
Definition: greymap.cpp:24
static TOOL_ACTION paste
Definition: actions.h:54
class PCB_BASE_FRAME basic PCB main window class for Pcbnew, Gerbview, and CvPcb footprint viewer.
static TOOL_ACTION measureTool
Definition: pcb_actions.h:308
EDA_UNITS_T
Definition: common.h:157
void SetText(const wxString &aText)
Display a text.
int GetToolId() const
Definition: draw_frame.h:524
void SetDelta(const wxSize &aSize)
Definition: class_pad.h:273
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
void prePushAction(BOARD_ITEM *aItem) override
Definition: edit_tool.cpp:1175
void SetEnd(const VECTOR2I &aEnd)
Set the current end of the rectangle (the end that moves with the cursor.
OPT< TOOL_EVENT > OPT_TOOL_EVENT
Definition: tool_event.h:486
KICAD_T Type() const
Function Type()
Definition: base_struct.h:204
void SetTimeStamp(timestamp_t aNewTimeStamp)
Definition: base_struct.h:209
Color has changed.
Definition: view_item.h:57
BOARD_ITEM * Duplicate(const BOARD_ITEM *aItem, bool aAddToBoard=false)