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-2015 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 <wxPcbStruct.h>
35 #include <kiway.h>
36 #include <class_draw_panel_gal.h>
37 #include <module_editor_frame.h>
38 #include <array_creator.h>
39 #include <pcbnew_id.h>
40 
41 #include <tool/tool_manager.h>
42 #include <view/view_controls.h>
43 #include <view/view.h>
45 #include <connectivity.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 "grid_helper.h"
58 
59 #include <router/router_tool.h>
60 
64 
65 #include <tools/tool_event_utils.h>
66 
68 
69 #include <board_commit.h>
70 
71 // Edit tool actions
72 TOOL_ACTION PCB_ACTIONS::editFootprintInFpEditor( "pcbnew.InteractiveEdit.editFootprintInFpEditor",
74  _( "Open in Footprint Editor" ),
75  _( "Opens the selected footprint in the Footprint Editor" ),
76  module_editor_xpm );
77 
78 TOOL_ACTION PCB_ACTIONS::copyPadToSettings( "pcbnew.InteractiveEdit.copyPadToSettings",
79  AS_GLOBAL, 0,
80  _( "Copy Pad Settings to Current Settings" ),
81  _( "Copies the properties of selected pad to the current template pad settings." ) );
82 
83 TOOL_ACTION PCB_ACTIONS::copySettingsToPads( "pcbnew.InteractiveEdit.copySettingsToPads",
84  AS_GLOBAL, 0,
85  _( "Copy Current Settings to Pads" ),
86  _( "Copies the current template pad settings to the selected pad(s)." ) );
87 
88 TOOL_ACTION PCB_ACTIONS::globalEditPads( "pcbnew.InteractiveEdit.globalPadEdit",
89  AS_GLOBAL, 0,
90  _( "Global Pad Edition" ),
91  _( "Changes pad properties globally." ), push_pad_settings_xpm );
92 
93 TOOL_ACTION PCB_ACTIONS::editActivate( "pcbnew.InteractiveEdit",
95  _( "Move" ), _( "Moves the selected item(s)" ), move_xpm, AF_ACTIVATE );
96 
97 TOOL_ACTION PCB_ACTIONS::duplicate( "pcbnew.InteractiveEdit.duplicate",
99  _( "Duplicate" ), _( "Duplicates the selected item(s)" ), duplicate_module_xpm );
100 
101 TOOL_ACTION PCB_ACTIONS::duplicateIncrement( "pcbnew.InteractiveEdit.duplicateIncrementPads",
103  _( "Duplicate" ), _( "Duplicates the selected item(s), incrementing pad numbers" ) );
104 
105 TOOL_ACTION PCB_ACTIONS::moveExact( "pcbnew.InteractiveEdit.moveExact",
107  _( "Move Exactly" ), _( "Moves the selected item(s) by an exact amount" ),
108  move_module_xpm );
109 
110 TOOL_ACTION PCB_ACTIONS::createArray( "pcbnew.InteractiveEdit.createArray",
112  _( "Create Array" ), _( "Create array" ), array_module_xpm, AF_ACTIVATE );
113 
114 TOOL_ACTION PCB_ACTIONS::rotateCw( "pcbnew.InteractiveEdit.rotateCw",
115  AS_GLOBAL, MD_SHIFT + 'R',
116  _( "Rotate 90 deg CW" ), _( "Rotates selected item(s) clockwise" ),
117  rotate_cw_xpm, AF_NONE, (void*) -1 );
118 
119 TOOL_ACTION PCB_ACTIONS::rotateCcw( "pcbnew.InteractiveEdit.rotateCcw",
121  _( "Rotate 90 deg CCW" ), _( "Rotates selected item(s) counter-clockwise" ),
122  rotate_ccw_xpm, AF_NONE, (void*) 1 );
123 
124 TOOL_ACTION PCB_ACTIONS::flip( "pcbnew.InteractiveEdit.flip",
126  _( "Flip" ), _( "Flips selected item(s)" ), swap_layer_xpm );
127 
128 TOOL_ACTION PCB_ACTIONS::mirror( "pcbnew.InteractiveEdit.mirror",
129  AS_GLOBAL, 0,
130  _( "Mirror" ), _( "Mirrors selected item" ), mirror_h_xpm );
131 
132 TOOL_ACTION PCB_ACTIONS::remove( "pcbnew.InteractiveEdit.remove",
134  _( "Delete" ), _( "Deletes selected item(s)" ), delete_xpm,
135  AF_NONE, (void*) REMOVE_FLAGS::NORMAL );
136 
137 TOOL_ACTION PCB_ACTIONS::removeAlt( "pcbnew.InteractiveEdit.removeAlt",
139  _( "Delete (Alternative)" ), _( "Deletes selected item(s)" ), delete_xpm,
140  AF_NONE, (void*) REMOVE_FLAGS::ALT );
141 
142 TOOL_ACTION PCB_ACTIONS::exchangeFootprints( "pcbnew.InteractiveEdit.ExchangeFootprints",
143  AS_GLOBAL, 0,
144  _( "Exchange Footprint" ), _( "Change the footprint used for modules" ),
145  exchange_xpm );
146 
147 TOOL_ACTION PCB_ACTIONS::properties( "pcbnew.InteractiveEdit.properties",
149  _( "Properties" ), _( "Displays item properties dialog" ), config_xpm );
150 
151 TOOL_ACTION PCB_ACTIONS::selectionModified( "pcbnew.InteractiveEdit.ModifiedSelection",
152  AS_GLOBAL, 0,
153  "", "", nullptr, AF_NOTIFY );
154 
155 TOOL_ACTION PCB_ACTIONS::measureTool( "pcbnew.InteractiveEdit.measureTool",
156  AS_GLOBAL, MD_CTRL + MD_SHIFT + 'M',
157  _( "Measuring tool" ), _( "Interactively measure distance between points" ),
158  nullptr, AF_ACTIVATE );
159 
160 
162  PCB_TOOL( "pcbnew.InteractiveEdit" ), m_selectionTool( NULL ),
163  m_dragging( false )
164 {
165 }
166 
167 
169 {
170  m_dragging = false;
171 
172  if( aReason != RUN )
173  m_commit.reset( new BOARD_COMMIT( this ) );
174 }
175 
176 
178 {
179  // Find the selection tool, so they can cooperate
180  m_selectionTool = static_cast<SELECTION_TOOL*>( m_toolMgr->FindTool( "pcbnew.InteractiveSelection" ) );
181 
182  if( !m_selectionTool )
183  {
184  DisplayError( NULL, wxT( "pcbnew.InteractiveSelection tool is not available" ) );
185  return false;
186  }
187 
188  auto editingModuleCondition = [ this ] ( const SELECTION& aSelection ) {
189  return m_editModules;
190  };
191 
192  auto singleModuleCondition = SELECTION_CONDITIONS::OnlyType( PCB_MODULE_T )
194 
195  // Add context menu entries that are displayed when selection tool is active
208 
209  // Mirror only available in modedit
210  menu.AddItem( PCB_ACTIONS::mirror, editingModuleCondition && SELECTION_CONDITIONS::NotEmpty );
211 
212  // Footprint actions
214  singleModuleCondition );
216  singleModuleCondition );
217 
218  m_offset.x = 0;
219  m_offset.y = 0;
220 
221  return true;
222 }
223 
224 
226 
227 
228 {
229  TRACK* track = uniqueSelected<TRACK>();
230  VIA* via = uniqueSelected<VIA>();
231 
232  if( track || via )
233  {
234  ROUTER_TOOL* theRouter = static_cast<ROUTER_TOOL*>( m_toolMgr->FindTool( "pcbnew.InteractiveRouter" ) );
235  assert( theRouter );
236 
237  if( !theRouter->PNSSettings().InlineDragEnabled() )
238  return false;
239 
241  return true;
242  }
243 
244  return false;
245 }
246 
247 
248 int EDIT_TOOL::Main( const TOOL_EVENT& aEvent )
249 {
251  PCB_BASE_EDIT_FRAME* editFrame = getEditFrame<PCB_BASE_EDIT_FRAME>();
252 
253  VECTOR2I originalCursorPos = controls->GetCursorPosition();
254 
255  // Be sure that there is at least one item that we can modify. If nothing was selected before,
256  // try looking for the stuff under mouse cursor (i.e. Kicad old-style hover selection)
258 
259  if( selection.Empty() )
260  return 0;
261 
262  bool unselect = selection.IsHover();
263 
264  Activate();
265 
266  m_dragging = false; // Are selected items being dragged?
267  bool restore = false; // Should items' state be restored when finishing the tool?
268  bool lockOverride = false;
269 
270  controls->ShowCursor( true );
271  controls->SetSnapping( true );
272  controls->SetAutoPan( true );
273 
274  // cumulative translation
275  wxPoint totalMovement( 0, 0 );
276 
277  GRID_HELPER grid( editFrame );
278  OPT_TOOL_EVENT evt = aEvent;
279 
280  // Main loop: keep receiving events
281  do
282  {
283  if( evt->IsAction( &PCB_ACTIONS::editActivate )
284  || evt->IsMotion() || evt->IsDrag( BUT_LEFT ) )
285  {
286  if( selection.Empty() )
287  break;
288 
289  BOARD_ITEM* curr_item = static_cast<BOARD_ITEM*>( selection.Front() );
290 
291  if( m_dragging && evt->Category() == TC_MOUSE )
292  {
293  m_cursor = grid.BestSnapAnchor( evt->Position(), curr_item );
294  controls->ForceCursorPosition( true, m_cursor );
295 
296  wxPoint movement = wxPoint( m_cursor.x, m_cursor.y ) - curr_item->GetPosition();
297  totalMovement += movement;
298 
299  // Drag items to the current cursor position
300  for( auto item : selection )
301  {
302  static_cast<BOARD_ITEM*>( item )->Move( movement + m_offset );
303  }
304 
305  updateRatsnest( true );
306  }
307  else if( !m_dragging ) // Prepare to start dragging
308  {
309  if( !invokeInlineRouter() )
310  {
312 
313  if( selection.Empty() )
314  break;
315 
316  // deal with locked items (override lock or abort the operation)
318 
319  if( lockFlags == SELECTION_LOCKED )
320  break;
321  else if( lockFlags == SELECTION_LOCK_OVERRIDE )
322  lockOverride = true;
323 
324  // Save items, so changes can be undone
325  for( auto item : selection )
326  m_commit->Modify( item );
327 
328  m_cursor = controls->GetCursorPosition();
329 
330  if( selection.Size() == 1 )
331  {
332  // Set the current cursor position to the first dragged item origin, so the
333  // movement vector could be computed later
334  m_cursor = grid.BestDragOrigin( originalCursorPos, curr_item );
335  grid.SetAuxAxes( true, m_cursor );
336  }
337  else
338  {
339  m_cursor = grid.Align( m_cursor );
340  }
341 
342  controls->ForceCursorPosition( true, m_cursor );
343  controls->WarpCursor( m_cursor, true );
344 
345  VECTOR2I o = VECTOR2I( curr_item->GetPosition() );
346  m_offset.x = o.x - m_cursor.x;
347  m_offset.y = o.y - m_cursor.y;
348 
349  controls->SetAutoPan( true );
350  m_dragging = true;
351  }
352  }
353 
355  }
356 
357  else if( evt->IsCancel() || evt->IsActivate() )
358  {
359  restore = true; // Cancelling the tool means that items have to be restored
360  break; // Finish
361  }
362 
363  else if( evt->Action() == TA_UNDO_REDO_PRE )
364  {
365  unselect = true;
366  break;
367  }
368 
369  // Dispatch TOOL_ACTIONs
370  else if( evt->Category() == TC_COMMAND )
371  {
372  wxPoint modPoint = getModificationPoint( selection );
373 
374  if( evt->IsAction( &PCB_ACTIONS::remove ) )
375  {
376  // exit the loop, as there is no further processing for removed items
377  break;
378  }
379  else if( evt->IsAction( &PCB_ACTIONS::duplicate ) )
380  {
381  // On duplicate, stop moving this item
382  // The duplicate tool should then select the new item and start
383  // a new move procedure
384  break;
385  }
386  else if( evt->IsAction( &PCB_ACTIONS::moveExact ) )
387  {
388  // Can't do this, because the selection will then contain
389  // stale pointers and it will all go horribly wrong...
390  //editFrame->RestoreCopyFromUndoList( dummy );
391  //
392  // So, instead, reset the position manually
393  for( auto item : selection )
394  {
395  BOARD_ITEM* i = static_cast<BOARD_ITEM*>( item );
396  i->SetPosition( i->GetPosition() - totalMovement );
397 
398  // And what about flipping and rotation?
399  // for now, they won't be undone, but maybe that is how
400  // it should be, so you can flip and move exact in the
401  // same action?
402  }
403 
404  // This causes a double event, so we will get the dialogue
405  // correctly, somehow - why does Rotate not?
406  //MoveExact( aEvent );
407  break; // exit the loop - we move exactly, so we have finished moving
408  }
409 
410  if( m_dragging )
411  {
412  // Update dragging offset (distance between cursor and the first dragged item)
413  m_offset = static_cast<BOARD_ITEM*>( selection.Front() )->GetPosition() - modPoint;
414  getView()->Update( &selection );
415  updateRatsnest( true );
416  }
417  }
418 
419  else if( evt->IsMouseUp( BUT_LEFT ) || evt->IsClick( BUT_LEFT ) )
420  {
421  if( !lockOverride )
422  break; // Finish
423 
424  lockOverride = false;
425  }
426  } while( ( evt = Wait() ) ); //Should be assignment not equality test
427 
428  getModel<BOARD>()->GetConnectivity()->ClearDynamicRatsnest();
429 
430  controls->ForceCursorPosition( false );
431  controls->ShowCursor( false );
432  controls->SetSnapping( false );
433  controls->SetAutoPan( false );
434 
435  m_dragging = false;
436  m_offset.x = 0;
437  m_offset.y = 0;
438 
439  if( unselect || restore )
441 
442  if( restore )
443  m_commit->Revert();
444  else
445  m_commit->Push( _( "Drag" ) );
446 
447  return 0;
448 }
449 
450 
451 int EDIT_TOOL::Properties( const TOOL_EVENT& aEvent )
452 {
453  PCB_BASE_EDIT_FRAME* editFrame = getEditFrame<PCB_BASE_EDIT_FRAME>();
454 
456 
457  if( selection.Empty() )
458  return 0;
459 
460  // Tracks & vias are treated in a special way:
462  {
463  DIALOG_TRACK_VIA_PROPERTIES dlg( editFrame, selection );
464 
465  if( dlg.ShowModal() )
466  {
467  dlg.Apply( *m_commit );
468  m_commit->Push( _( "Edit track/via properties" ) );
469  }
470  }
471  else if( selection.Size() == 1 ) // Properties are displayed when there is only one item selected
472  {
473  // Display properties dialog
474  BOARD_ITEM* item = static_cast<BOARD_ITEM*>( selection.Front() );
475 
476  // Some of properties dialogs alter pointers, so we should deselect them
478 
479  // Store flags, so they can be restored later
480  STATUS_FLAGS flags = item->GetFlags();
481  item->ClearFlags();
482 
483  // Do not handle undo buffer, it is done by the properties dialogs @todo LEGACY
484  // Display properties dialog provided by the legacy canvas frame
485  editFrame->OnEditItemRequest( NULL, item );
486 
488  item->SetFlags( flags );
489  }
490 
491  if( selection.IsHover() )
493 
494  return 0;
495 }
496 
497 
498 int EDIT_TOOL::Rotate( const TOOL_EVENT& aEvent )
499 {
500  PCB_BASE_EDIT_FRAME* editFrame = getEditFrame<PCB_BASE_EDIT_FRAME>();
501 
502  const auto& selection = m_selectionTool->RequestSelection();
503 
504  if( selection.Empty() )
505  return 0;
506 
508  return 0;
509 
510  wxPoint modPoint = getModificationPoint( selection );
511  const int rotateAngle = TOOL_EVT_UTILS::GetEventRotationAngle( *editFrame, aEvent );
512 
513  for( auto item : selection )
514  {
515  m_commit->Modify( item );
516  static_cast<BOARD_ITEM*>( item )->Rotate( modPoint, rotateAngle );
517  }
518 
519  // Update the dragging point offset
520  m_offset = static_cast<BOARD_ITEM*>( selection.Front() )->GetPosition() - modPoint;
521 
522  if( !m_dragging )
523  m_commit->Push( _( "Rotate" ) );
524  else
525  updateRatsnest( true );
526 
527  if( selection.IsHover() )
529 
531 
532  return 0;
533 }
534 
535 
539 static wxPoint mirrorPointX( const wxPoint& aPoint, const wxPoint& aMirrorPoint )
540 {
541  wxPoint mirrored = aPoint;
542 
543  mirrored.x -= aMirrorPoint.x;
544  mirrored.x = -mirrored.x;
545  mirrored.x += aMirrorPoint.x;
546 
547  return mirrored;
548 }
549 
550 
554 static void mirrorPadX( D_PAD& aPad, const wxPoint& aMirrorPoint )
555 {
556  wxPoint tmpPt = mirrorPointX( aPad.GetPosition(), aMirrorPoint );
557 
558  aPad.SetPosition( tmpPt );
559 
560  aPad.SetX0( aPad.GetPosition().x );
561 
562  tmpPt = aPad.GetOffset();
563  tmpPt.x = -tmpPt.x;
564  aPad.SetOffset( tmpPt );
565 
566  auto tmpz = aPad.GetDelta();
567  tmpz.x = -tmpz.x;
568  aPad.SetDelta( tmpz );
569 
570  aPad.SetOrientation( -aPad.GetOrientation() );
571 }
572 
573 
574 int EDIT_TOOL::Mirror( const TOOL_EVENT& aEvent )
575 {
576  const auto& selection = m_selectionTool->RequestSelection();
577 
579  return 0;
580 
581  if( selection.Empty() )
582  return 0;
583 
584  wxPoint mirrorPoint = getModificationPoint( selection );
585 
586  for( auto item : selection )
587  {
588  // only modify items we can mirror
589  switch( item->Type() )
590  {
591  case PCB_MODULE_EDGE_T:
592  case PCB_MODULE_TEXT_T:
593  case PCB_PAD_T:
594  m_commit->Modify( item );
595  break;
596  default:
597  continue;
598  }
599 
600  // modify each object as necessary
601  switch( item->Type() )
602  {
603  case PCB_MODULE_EDGE_T:
604  {
605  auto& edge = static_cast<EDGE_MODULE&>( *item );
606  edge.Mirror( mirrorPoint, false );
607  break;
608  }
609 
610  case PCB_MODULE_TEXT_T:
611  {
612  auto& modText = static_cast<TEXTE_MODULE&>( *item );
613  modText.Mirror( mirrorPoint, false );
614  break;
615  }
616 
617  case PCB_PAD_T:
618  {
619  auto& pad = static_cast<D_PAD&>( *item );
620  mirrorPadX( pad, mirrorPoint );
621  break;
622  }
623 
624  default:
625  // it's likely the commit object is wrong if you get here
626  assert( false );
627  break;
628  }
629  }
630 
631  if( !m_dragging )
632  m_commit->Push( _( "Mirror" ) );
633  else
634  updateRatsnest( true );
635 
636  if( selection.IsHover() )
638 
640 
641  return 0;
642 }
643 
644 
645 int EDIT_TOOL::Flip( const TOOL_EVENT& aEvent )
646 {
647  const auto& selection = m_selectionTool->RequestSelection();
648 
650  return 0;
651 
652  if( selection.Empty() )
653  return 0;
654 
655  wxPoint modPoint = getModificationPoint( selection );
656 
657  for( auto item : selection )
658  {
659  m_commit->Modify( item );
660  static_cast<BOARD_ITEM*>( item )->Flip( modPoint );
661  }
662 
663  // Update the dragging point offset
664  m_offset = static_cast<BOARD_ITEM*>( selection.Front() )->GetPosition() - modPoint;
665 
666  if( !m_dragging )
667  m_commit->Push( _( "Flip" ) );
668  else
669  updateRatsnest( true );
670 
671  if( selection.IsHover() )
673 
675 
676  return 0;
677 }
678 
679 
680 int EDIT_TOOL::Remove( const TOOL_EVENT& aEvent )
681 {
682  // get a copy instead of reference (as we're going to clear the selectio before removing items)
684 
686  return 0;
687 
688  if( selection.Empty() )
689  return 0;
690 
691  // is this "alternative" remove?
692  const bool isAlt = aEvent.Parameter<intptr_t>() ==
694 
695  // in "alternative" mode, deletion is not just a simple list
696  // of selected items, it is:
697  // - whole tracks, not just segments
698  if( isAlt && selection.IsHover() )
699  {
702  }
703 
704  // As we are about to remove items, they have to be removed from the selection first
706 
707  for( auto item : selection )
708  {
709  m_commit->Remove( item );
710  }
711 
712  m_commit->Push( _( "Delete" ) );
713 
714  return 0;
715 }
716 
717 
718 int EDIT_TOOL::MoveExact( const TOOL_EVENT& aEvent )
719 {
720  const auto& selection = m_selectionTool->RequestSelection();
721 
723  return 0;
724 
725  if( selection.Empty() )
726  return 0;
727 
728  PCB_BASE_FRAME* editFrame = getEditFrame<PCB_BASE_FRAME>();
729 
730  MOVE_PARAMETERS params;
732 
733  DIALOG_MOVE_EXACT dialog( editFrame, params );
734  int ret = dialog.ShowModal();
735 
736  if( ret == wxID_OK )
737  {
738  VECTOR2I rp = selection.GetCenter();
739  wxPoint rotPoint( rp.x, rp.y );
740 
741  // Begin at the center of the selection determined above
742  wxPoint anchorPoint = rotPoint;
743 
744  // If the anchor is not ANCHOR_FROM_LIBRARY then the user applied an override.
745  // Also run through this block if only one item is slected because it may be a module,
746  // in which case we want something different than the center of the selection
747  if( ( params.anchor != ANCHOR_FROM_LIBRARY ) || ( selection.GetSize() == 1 ) )
748  {
749  BOARD_ITEM* topLeftItem = static_cast<BOARD_ITEM*>( selection.GetTopLeftModule() );
750 
751  // no module found if the GetTopLeftModule() returns null, retry for
752  if( topLeftItem == nullptr )
753  {
754  topLeftItem = static_cast<BOARD_ITEM*>( selection.GetTopLeftItem() );
755  anchorPoint = topLeftItem->GetPosition();
756  }
757 
758  if( topLeftItem->Type() == PCB_MODULE_T )
759  {
760  // Cast to module to allow access to the pads
761  MODULE* mod = static_cast<MODULE*>( topLeftItem );
762 
763  switch( params.anchor )
764  {
765  case ANCHOR_FROM_LIBRARY:
766  anchorPoint = mod->GetPosition();
767  break;
768  case ANCHOR_TOP_LEFT_PAD:
769  topLeftItem = mod->GetTopLeftPad();
770  break;
772  anchorPoint = mod->GetFootprintRect().GetCenter();
773  break;
774  }
775  }
776 
777  if( topLeftItem->Type() == PCB_PAD_T )
778  {
779  if( static_cast<D_PAD*>( topLeftItem )->GetAttribute() == PAD_ATTRIB_SMD )
780  {
781  // Use the top left corner of SMD pads as an anchor instead of the center
782  anchorPoint = topLeftItem->GetBoundingBox().GetPosition();
783  }
784  else
785  {
786  anchorPoint = topLeftItem->GetPosition();
787  }
788  }
789  }
790 
791  wxPoint origin;
792 
793  switch( params.origin )
794  {
796  origin = editFrame->GetScreen()->m_O_Curseur;
797  break;
798 
800  origin = editFrame->GetGridOrigin();
801  break;
802 
804  origin = editFrame->GetAuxOrigin();
805  break;
806 
808  origin = wxPoint( 0, 0 );
809  break;
810 
812  // relative movement means that only the translation values should be used:
813  // -> set origin and anchor to zero
814  origin = wxPoint( 0, 0 );
815  anchorPoint = wxPoint( 0, 0 );
816  break;
817  }
818 
819  wxPoint finalMoveVector = params.translation + origin - anchorPoint;
820 
821  // Make sure the rotation is from the right reference point
822  rotPoint += finalMoveVector;
823 
824  for( auto item : selection )
825  {
826  m_commit->Modify( item );
827  static_cast<BOARD_ITEM*>( item )->Move( finalMoveVector );
828  static_cast<BOARD_ITEM*>( item )->Rotate( rotPoint, params.rotation );
829 
830  if( !m_dragging )
831  getView()->Update( item );
832  }
833 
834  m_commit->Push( _( "Move exact" ) );
835 
836  if( selection.IsHover() )
838 
840  }
841 
842  return 0;
843 }
844 
845 
846 int EDIT_TOOL::Duplicate( const TOOL_EVENT& aEvent )
847 {
848  bool increment = aEvent.IsAction( &PCB_ACTIONS::duplicateIncrement );
849 
850  // Be sure that there is at least one item that we can modify
852 
853  if( selection.Empty() )
854  return 0;
855 
856  // we have a selection to work on now, so start the tool process
857  PCB_BASE_EDIT_FRAME* editFrame = getEditFrame<PCB_BASE_EDIT_FRAME>();
858 
859  std::vector<BOARD_ITEM*> new_items;
860  new_items.reserve( selection.Size() );
861 
862  BOARD_ITEM* orig_item = nullptr;
863  BOARD_ITEM* dupe_item = nullptr;
864 
865  // Each selected item is duplicated and pushed to new_items list
866  // Old selection is cleared, and new items are then selected.
867  for( auto item : selection )
868  {
869  if( !item )
870  continue;
871 
872  orig_item = static_cast<BOARD_ITEM*>( item );
873 
874  if( m_editModules )
875  {
876  dupe_item = editFrame->GetBoard()->m_Modules->Duplicate( orig_item, increment );
877  }
878  else
879  {
880 #if 0
881  // @TODO: see if we allow zone duplication here
882  // Duplicate zones is especially tricky (overlaping zones must be merged)
883  // so zones are not duplicated
884  if( item->Type() != PCB_ZONE_AREA_T )
885 #endif
886  dupe_item = editFrame->GetBoard()->Duplicate( orig_item );
887  }
888 
889  if( dupe_item )
890  {
891  // Clear the selection flag here, otherwise the SELECTION_TOOL
892  // will not properly select it later on
893  dupe_item->ClearSelected();
894 
895  new_items.push_back( dupe_item );
896  m_commit->Add( dupe_item );
897  }
898  }
899 
900  // Clear the old selection first
902 
903  // Select the new items
904  m_toolMgr->RunAction( PCB_ACTIONS::selectItems, true, &new_items );
905 
906  // record the new items as added
907  if( !selection.Empty() )
908  {
909  editFrame->DisplayToolMsg( wxString::Format( _( "Duplicated %d item(s)" ),
910  (int) new_items.size() ) );
911 
912  // If items were duplicated, pick them up
913  // this works well for "dropping" copies around and pushes the commit
915  Main( evt );
916  }
917 
918  return 0;
919 }
920 
921 
923 {
924 public:
925 
926  GAL_ARRAY_CREATOR( PCB_BASE_FRAME& editFrame, bool editModules,
927  const SELECTION& selection ):
928  ARRAY_CREATOR( editFrame ),
929  m_editModules( editModules ),
930  m_selection( selection )
931  {}
932 
933 private:
934 
935  int getNumberOfItemsToArray() const override
936  {
937  // only handle single items
938  return m_selection.Size();
939  }
940 
941  BOARD_ITEM* getNthItemToArray( int n ) const override
942  {
943  return static_cast<BOARD_ITEM*>( m_selection[n] );
944  }
945 
946  BOARD* getBoard() const override
947  {
948  return m_parent.GetBoard();
949  }
950 
951  MODULE* getModule() const override
952  {
953  // Remember this is valid and used only in the module editor.
954  // in board editor, the parent of items is usually the board.
955  return m_editModules ? m_parent.GetBoard()->m_Modules.GetFirst() : NULL;
956  }
957 
958  wxPoint getRotationCentre() const override
959  {
960  const VECTOR2I rp = m_selection.GetCenter();
961  return wxPoint( rp.x, rp.y );
962  }
963 
964  void prePushAction( BOARD_ITEM* aItem ) override
965  {
966  // Because aItem is/can be created from a selected item, and inherits from
967  // it this state, reset the selected stated of aItem:
968  aItem->ClearSelected();
969 
970  if( aItem->Type() == PCB_MODULE_T )
971  {
972  static_cast<MODULE*>( aItem )->RunOnChildren( [&] ( BOARD_ITEM* item )
973  {
974  item->ClearSelected();
975  }
976  );
977  }
978  }
979 
980  void postPushAction( BOARD_ITEM* new_item ) override
981  {
982  }
983 
984  void finalise() override
985  {
986  }
987 
990 };
991 
992 
993 int EDIT_TOOL::CreateArray( const TOOL_EVENT& aEvent )
994 {
995  const auto& selection = m_selectionTool->RequestSelection();
996 
997  if( selection.Empty() )
998  return 0;
999 
1000  // we have a selection to work on now, so start the tool process
1001  PCB_BASE_FRAME* editFrame = getEditFrame<PCB_BASE_FRAME>();
1002  GAL_ARRAY_CREATOR array_creator( *editFrame, m_editModules, selection );
1003  array_creator.Invoke();
1004 
1005  return 0;
1006 }
1007 
1008 
1010 {
1011  const auto& selection = m_selectionTool->RequestSelection();
1012 
1013  if( selection.Empty() )
1014  return 0;
1015 
1016  MODULE* mod = selection.FirstOfKind<MODULE> ();
1017 
1018  if( !mod )
1019  return 0;
1020 
1021  frame()->SetCurItem( mod );
1022 
1023  // Footprint exchange could remove modules, so they have to be
1024  // removed from the selection first
1026 
1027  // invoke the exchange dialog process
1028  {
1029  DIALOG_EXCHANGE_MODULE dialog( frame(), mod );
1030  dialog.ShowQuasiModal();
1031  }
1032 
1033  // The current item can be deleted by exchange module, and the
1034  // selection is emptied, so remove current item from frame info area
1035  frame()->SetCurItem( nullptr );
1036 
1037  return 0;
1038 }
1039 
1040 
1042 {
1043  auto& view = *getView();
1044  auto& controls = *getViewControls();
1045 
1046  Activate();
1049  wxCURSOR_PENCIL, _( "Measure distance" ) );
1050 
1052 
1053  KIGFX::PREVIEW::RULER_ITEM ruler( twoPtMgr );
1054 
1055  view.Add( &ruler );
1056  view.SetVisible( &ruler, false );
1057 
1058  bool originSet = false;
1059 
1060  controls.ShowCursor( true );
1061  controls.SetSnapping( true );
1062 
1063  while( auto evt = Wait() )
1064  {
1065  const VECTOR2I cursorPos = controls.GetCursorPosition();
1066 
1067  if( evt->IsCancel() || evt->IsActivate() )
1068  {
1069  break;
1070  }
1071 
1072  // click or drag starts
1073  else if( !originSet &&
1074  ( evt->IsDrag( BUT_LEFT ) || evt->IsClick( BUT_LEFT ) ) )
1075  {
1076  if( !evt->IsDrag( BUT_LEFT ) )
1077  {
1078  twoPtMgr.SetOrigin( cursorPos );
1079  twoPtMgr.SetEnd( cursorPos );
1080  }
1081 
1082  controls.CaptureCursor( true );
1083  controls.SetAutoPan( true );
1084 
1085  originSet = true;
1086  }
1087 
1088  else if( !originSet && evt->IsMotion() )
1089  {
1090  // make sure the origin is set before a drag starts
1091  // otherwise you can miss a step
1092  twoPtMgr.SetOrigin( cursorPos );
1093  twoPtMgr.SetEnd( cursorPos );
1094  }
1095 
1096  // second click or mouse up after drag ends
1097  else if( originSet &&
1098  ( evt->IsClick( BUT_LEFT ) || evt->IsMouseUp( BUT_LEFT ) ) )
1099  {
1100  originSet = false;
1101 
1102  controls.SetAutoPan( false );
1103  controls.CaptureCursor( false );
1104 
1105  view.SetVisible( &ruler, false );
1106  }
1107 
1108  // move or drag when origin set updates rules
1109  else if( originSet &&
1110  ( evt->IsMotion() || evt->IsDrag( BUT_LEFT ) ) )
1111  {
1112  twoPtMgr.SetAngleSnap( evt->Modifier( MD_CTRL ) );
1113  twoPtMgr.SetEnd( cursorPos );
1114 
1115  view.SetVisible( &ruler, true );
1116  view.Update( &ruler, KIGFX::GEOMETRY );
1117  }
1118 
1119  else if( evt->IsClick( BUT_RIGHT ) )
1120  {
1121  GetManager()->PassEvent();
1122  }
1123  }
1124 
1125  view.SetVisible( &ruler, false );
1126  view.Remove( &ruler );
1127 
1128  frame()->SetNoToolSelected();
1129 
1130  return 0;
1131 }
1132 
1133 
1135 {
1136  Go( &EDIT_TOOL::Main, PCB_ACTIONS::editActivate.MakeEvent() );
1137  Go( &EDIT_TOOL::Rotate, PCB_ACTIONS::rotateCw.MakeEvent() );
1138  Go( &EDIT_TOOL::Rotate, PCB_ACTIONS::rotateCcw.MakeEvent() );
1139  Go( &EDIT_TOOL::Flip, PCB_ACTIONS::flip.MakeEvent() );
1140  Go( &EDIT_TOOL::Remove, PCB_ACTIONS::remove.MakeEvent() );
1141  Go( &EDIT_TOOL::Remove, PCB_ACTIONS::removeAlt.MakeEvent() );
1147  Go( &EDIT_TOOL::Mirror, PCB_ACTIONS::mirror.MakeEvent() );
1151 }
1152 
1153 
1154 void EDIT_TOOL::updateRatsnest( bool aRedraw )
1155 {
1156  auto& selection = m_selectionTool->GetSelection();
1157  auto connectivity = getModel<BOARD>()->GetConnectivity();
1158  std::vector<BOARD_ITEM *> items;
1159 
1160  for ( auto item : selection )
1161  items.push_back ( static_cast<BOARD_ITEM *>( item ) );
1162 
1163  connectivity->ComputeDynamicRatsnest( items );
1164 }
1165 
1166 
1168 {
1169  if( aSelection.Size() == 1 )
1170  {
1171  return static_cast<BOARD_ITEM*>( aSelection.Front() )->GetPosition() - m_offset;
1172  }
1173  else
1174  {
1175  // If EDIT_TOOL is not currently active then it means that the cursor position is not
1176  // updated, so we have to fetch the latest value
1177  if( m_toolMgr->GetCurrentToolId() != m_toolId )
1179 
1180  return wxPoint( m_cursor.x, m_cursor.y );
1181  }
1182 }
1183 
1184 
1186 {
1187  const auto& selection = m_selectionTool->RequestSelection();
1188 
1189  if( selection.Empty() )
1190  return 0;
1191 
1192  MODULE* mod = selection.FirstOfKind<MODULE>();
1193 
1194  if( !mod )
1195  return 0;
1196 
1197  PCB_BASE_EDIT_FRAME* editFrame = getEditFrame<PCB_BASE_EDIT_FRAME>();
1198 
1199  editFrame->SetCurItem( mod );
1200 
1201  if( editFrame->GetCurItem()->GetTimeStamp() == 0 ) // Module Editor needs a non null timestamp
1202  {
1203  editFrame->GetCurItem()->SetTimeStamp( GetNewTimeStamp() );
1204  editFrame->OnModify();
1205  }
1206 
1208 
1209  editor->Load_Module_From_BOARD( (MODULE*) editFrame->GetCurItem() );
1210  editFrame->SetCurItem( NULL ); // the current module could be deleted by
1211 
1212  editor->Show( true );
1213  editor->Raise(); // Iconize( false );
1214 
1215  if( selection.IsHover() )
1217 
1218  return 0;
1219 }
1220 
1221 
1222 template<class T>
1224 {
1225  const auto selection = m_selectionTool->GetSelection();
1226 
1227  if( selection.Size() != 1 )
1228  return nullptr;
1229 
1230  auto item = selection[0];
1231  return dyn_cast<T*>( item );
1232 }
static TOOL_ACTION selectItems
Selects a list of items (specified as the event parameter)
Definition: pcb_actions.h:59
static TOOL_ACTION selectionClear
Clears the current selection.
Definition: pcb_actions.h:53
VECTOR2I BestDragOrigin(const VECTOR2I &aMousePos, BOARD_ITEM *aItem)
wxPoint getModificationPoint(const SELECTION &aSelection)
Returns the right modification point (e.g.
Definition: edit_tool.cpp:1167
virtual void ShowCursor(bool aEnabled)
Function ShowCursor() Enables or disables display of cursor.
VECTOR2I m_cursor
Last cursor position (needed for getModificationPoint() to avoid changes of edit reference point)...
Definition: edit_tool.h:146
KICAD_T Type() const
Function Type()
Definition: base_struct.h:198
int Main(const TOOL_EVENT &aEvent)
Function Main()
Definition: edit_tool.cpp:248
KIGFX::VIEW * view() const
Definition: pcb_tool.h:123
Definition of class FOOTPRINT_EDIT_FRAME.
STATUS_FLAGS GetFlags() const
Definition: base_struct.h:255
virtual const EDA_RECT GetBoundingBox() const
Function GetBoundingBox returns the orthogonal, bounding box of this object for display purposes...
int Properties(const TOOL_EVENT &aEvent)
Function Edit()
Definition: edit_tool.cpp:451
int Rotate(const TOOL_EVENT &aEvent)
Function Rotate()
Definition: edit_tool.cpp:498
TOOL_BASE * FindTool(int aId) const
Function FindTool() Searches for a tool with given ID.
KIWAY & Kiway() const
Function Kiway returns a reference to the KIWAY that this object has an opportunity to participate in...
Definition: kiway_player.h:60
virtual void SetToolID(int aId, int aCursor, const wxString &aToolMsg) override
Function SetToolID sets the tool command ID to aId and sets the cursor to aCursor.
int ExchangeFootprints(const TOOL_EVENT &aEvent)
Function ExchangeFootprints()
Definition: edit_tool.cpp:1009
static TOOL_ACTION editActivate
Activation of the edit tool.
Definition: pcb_actions.h:87
static const KICAD_T Tracks[]
A scan list for only TRACKS.
Definition: collectors.h:294
int GetCurrentToolId() const
Returns id of the tool that is on the top of the active tools stack (was invoked the most recently)...
Definition: tool_manager.h:268
SELECTION & RequestSelection(int aFlags=SELECTION_DEFAULT)
Function RequestSelection()
static TOOL_ACTION globalEditPads
Definition: pcb_actions.h:374
virtual void SetPosition(const wxPoint &aPos)=0
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...
std::unique_ptr< BOARD_COMMIT > m_commit
Definition: edit_tool.h:207
T
enum T contains all this lexer's tokens.
void ClearSelected()
Definition: base_struct.h:231
VECTOR2I Align(const VECTOR2I &aPoint) const
Definition: grid_helper.cpp:95
VIEW_CONTROLS class definition.
Class SELECTION_TOOL.
Class TWO_POINT_GEOMETRY_MANAGER.
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.
const wxPoint & GetPosition() const override
Definition: class_module.h:155
SELECTION_LOCK_FLAGS CheckLock()
Checks if the user has agreed to modify locked items for the given selection.
CONDITIONAL_MENU & GetMenu()
Function GetMenu.
Definition: tool_menu.cpp:49
Tool is invoked after being inactive.
Definition: tool_base.h:82
TOOL_MENU & GetToolMenu()
EDA_ITEM * Front() const
Definition: selection.h:144
TOOL_MANAGER * m_toolMgr
Definition: tool_base.h:220
BOARD_ITEM * Duplicate(const BOARD_ITEM *aItem, bool aIncrementPadNumbers, bool aAddToModule=false)
Function Duplicate Duplicate a given item within the module, without adding to the board...
PCB_BASE_FRAME & m_parent
Definition: array_creator.h:61
Smd pad, appears on the solder paste layer (default)
Definition: pad_shapes.h:59
const wxPoint & GetGridOrigin() const override
Function GetGridOrigin returns the absolute coordinates of the origin of the snap grid...
class ZONE_CONTAINER, a zone area
Definition: typeinfo.h:114
void Remove(VIEW_ITEM *aItem)
Function Remove() Removes a VIEW_ITEM from the view.
Definition: view.cpp:341
static TOOL_ACTION properties
Activation of the edit tool.
Definition: pcb_actions.h:102
void SetCurItem(BOARD_ITEM *aItem, bool aDisplayInfo=true)
Function SetCurItem sets the currently selected item and displays it in the MsgPanel.
time_t GetNewTimeStamp()
Definition: common.cpp:166
OPT_TOOL_EVENT Wait(const TOOL_EVENT_LIST &aEventList=TOOL_EVENT(TC_ANY, TA_ANY))
Function Wait()
Action activates a tool
Definition: tool_event.h:146
TOOL_ID m_toolId
Unique identifier for the tool, assigned by a TOOL_MANAGER instance.
Definition: tool_base.h:215
virtual const wxPoint & GetPosition() const =0
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 TOOL_ACTION selectConnection
Selects a connection between junctions.
Definition: pcb_actions.h:68
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:174
BOARD * GetBoard() const
void SetPosition(const wxPoint &aPos) override
Definition: class_pad.h:169
static TOOL_ACTION removeAlt
Definition: pcb_actions.h:121
Classes to handle copper zones.
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 mirror
Mirroring of selected items.
Definition: pcb_actions.h:99
class D_PAD, a pad in a footprint
Definition: typeinfo.h:102
VECTOR2I BestSnapAnchor(const VECTOR2I &aOrigin, BOARD_ITEM *aDraggedItem)
SELECTION_TOOL * m_selectionTool
Selection tool used for obtaining selected items
Definition: edit_tool.h:136
wxPoint m_offset
Offset from the dragged item's center (anchor)
Definition: edit_tool.h:142
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...
VECTOR2< int > VECTOR2I
Definition: vector2d.h:590
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.
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:106
Casted dyn_cast(From aObject)
Function dyn_cast()
Definition: typeinfo.h:73
const wxPoint & GetAuxOrigin() const override
Function GetAuxOrigin returns the origin of the axis used for plotting and various exports...
static TOOL_ACTION copyPadToSettings
Definition: pcb_actions.h:372
MODULE * getModule() const override
Definition: edit_tool.cpp:951
static TOOL_ACTION selectionModified
Modified selection notification.
Definition: pcb_actions.h:105
void SetTimeStamp(time_t aNewTimeStamp)
Definition: base_struct.h:203
int Mirror(const TOOL_EVENT &aEvent)
Function Mirror.
Definition: edit_tool.cpp:574
Pcbnew hotkeys.
BOARD_ITEM * getNthItemToArray(int n) const override
Definition: edit_tool.cpp:941
static TOOL_ACTION moveExact
Activation of the exact move tool.
Definition: pcb_actions.h:108
const ROUTING_SETTINGS & PNSSettings() const
Definition: pns_tool_base.h:54
void finalise() override
Definition: edit_tool.cpp:984
static TOOL_ACTION copySettingsToPads
Definition: pcb_actions.h:373
void PassEvent()
Allows a tool to pass the already handled event to the next tool on the stack.
Definition: tool_manager.h:336
KIGFX::VIEW_CONTROLS * controls() const
Definition: pcb_tool.h:124
static TOOL_ACTION duplicate
Activation of the duplication tool.
Definition: pcb_actions.h:111
void Mirror(const wxPoint aCentre, bool aMirrorAroundXAxis)
Mirror an edge of the footprint.
class MODULE, a footprint
Definition: typeinfo.h:101
int Flip(const TOOL_EVENT &aEvent)
Function Flip()
Definition: edit_tool.cpp:645
static TOOL_ACTION duplicateIncrement
Activation of the duplication tool with incrementing (e.g. pad number)
Definition: pcb_actions.h:114
virtual void WarpCursor(const VECTOR2D &aPosition, bool aWorldCoordinates=false, bool aWarpView=false) const =0
Function WarpCursor() If enabled (.
static TOOL_ACTION rotateCw
Rotation of selected objects clockwise.
Definition: pcb_actions.h:90
VTBL_ENTRY KIWAY_PLAYER * Player(FRAME_T aFrameType, bool doCreate=true, KIWAY_PLAYER *aParent=NULL)
Function Player returns the KIWAY_PLAYER* given a FRAME_T.
Definition: kiway.cpp:302
int getNumberOfItemsToArray() const override
Definition: edit_tool.cpp:935
wxPoint getRotationCentre() const override
Definition: edit_tool.cpp:958
void SetFlags(STATUS_FLAGS aMask)
Definition: base_struct.h:253
virtual VECTOR2D GetCursorPosition() const =0
Function GetCursorPosition() Returns the current cursor position in world coordinates.
bool m_dragging
Flag determining if anything is being dragged right now
Definition: edit_tool.h:139
virtual void CaptureCursor(bool aEnabled)
Function CaptureCursor() Forces the cursor to stay within the drawing panel area. ...
EDA_RECT GetFootprintRect() const
Function GetFootprintRect() Returns the area of the module footprint excluding any text...
int ShowQuasiModal()
static SELECTION_CONDITION OnlyTypes(const std::vector< KICAD_T > &aTypes)
Function OnlyTypes Creates a functor that tests if the selected items are only of given types...
const wxPoint & GetPosition() const override
Definition: class_pad.h:170
SELECTION_LOCK_FLAGS
Definition: selection.h:184
T * uniqueSelected()
Function uniqueSelected()
Definition: edit_tool.cpp:1223
PCB_EDIT_FRAME * frame() const
Definition: pcb_tool.h:125
Class TOOL_EVENT.
Definition: tool_event.h:162
static TOOL_ACTION createArray
Tool for creating an array of objects.
Definition: pcb_actions.h:287
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:926
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
SELECTION & GetSelection()
Function GetSelection()
unsigned STATUS_FLAGS
Definition: base_struct.h:144
bool Init() override
Function Init() Init() is called once upon a registration of the tool.
Definition: edit_tool.cpp:177
Class VIEW_CONTROLS is an interface for classes handling user events controlling the view behaviour (...
Definition: view_controls.h:94
bool Load_Module_From_BOARD(MODULE *Module)
Function Load_Module_From_BOARD load in Modedit a footprint from the main board.
Definition: loadcmp.cpp:75
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.
static TOOL_ACTION exchangeFootprints
Exchange footprints of modules.
Definition: pcb_actions.h:117
All active tools
Definition: tool_event.h:138
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:1385
BOARD * getBoard() const override
Definition: edit_tool.cpp:946
const SELECTION & m_selection
Definition: edit_tool.cpp:989
static TOOL_ACTION routerInlineDrag
Activation of the Push and Shove router (inline dragging mode)
Definition: pcb_actions.h:198
bool invokeInlineRouter()
Definition: edit_tool.cpp:225
D_PAD * GetTopLeftPad()
const wxPoint & GetPosition() const
virtual void SetAutoPan(bool aEnabled)
Function SetAutoPan Turns on/off auto panning (this feature is used when there is a tool active (eg...
KIGFX::VIEW_CONTROLS * getViewControls() const
Function getViewControls()
Definition: tool_base.cpp:36
void updateRatsnest(bool aRedraw)
Updates ratsnest for selected items.
Definition: edit_tool.cpp:1154
time_t GetTimeStamp() const
Definition: base_struct.h:204
bool m_editModules
Definition: pcb_tool.h:128
void Reset(RESET_REASON aReason) override
Function Reset() Brings the tool to a known, initial state.
Definition: edit_tool.cpp:168
KIGFX::VIEW * getView() const
Function getView()
Definition: tool_base.cpp:30
static TOOL_ACTION rotateCcw
Rotation of selected objects counter-clockwise.
Definition: pcb_actions.h:93
class TEXTE_MODULE, text in a footprint
Definition: typeinfo.h:105
int MoveExact(const TOOL_EVENT &aEvent)
Function MoveExact()
Definition: edit_tool.cpp:718
int Remove(const TOOL_EVENT &aEvent)
Function Remove()
Definition: edit_tool.cpp:680
static ROUTER * theRouter
Definition: pns_router.cpp:59
bool EditingModules() const
Definition: pcb_tool.h:91
static TOOL_ACTION flip
Flipping of selected objects.
Definition: pcb_actions.h:96
virtual void SetNoToolSelected()
Select the ID_NO_TOOL_SELECTED id tool (Idle tool)
Definition: draw_frame.cpp:560
virtual void OnModify()
Function OnModify Virtual Must be called after a change in order to set the "modify" flag of the curr...
T Parameter() const
Function Parameter() Returns a non-standard parameter assigned to the event.
Definition: tool_event.h:373
TOOL_EVENT MakeEvent() const
Function HasHotKey() Checks if the action has a hot key assigned.
Definition: tool_action.h:104
void DisplayToolMsg(const wxString &msg)
Definition: draw_frame.cpp:497
int CreateArray(const TOOL_EVENT &aEvent)
Function CreateArray()
Definition: edit_tool.cpp:993
Common, abstract interface for edit frames.
int MeasureTool(const TOOL_EVENT &aEvent)
Launches a tool to measure between points
Definition: edit_tool.cpp:1041
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:169
void AddItem(const TOOL_ACTION &aAction, const SELECTION_CONDITION &aCondition=SELECTION_CONDITIONS::ShowAlways, int aOrder=ANY_ORDER)
Function AddItem()
static TOOL_ACTION editFootprintInFpEditor
Definition: pcb_actions.h:371
DLIST< MODULE > m_Modules
Definition: class_board.h:245
Class TOOL_ACTION.
Definition: tool_action.h:46
double GetOrientation() const
Function GetOrientation returns the rotation angle of the pad in tenths of degrees, but soon degrees.
Definition: class_pad.h:214
static SELECTION_CONDITION OnlyType(KICAD_T aType)
Function OnlyType Creates a functor that tests if the selected items are only of given type...
const wxSize & GetDelta() const
Definition: class_pad.h:185
void SetAuxAxes(bool aEnable, const VECTOR2I &aOrigin=VECTOR2I(0, 0), bool aEnableDiagonal=false)
Definition: grid_helper.cpp:84
static wxPoint mirrorPointX(const wxPoint &aPoint, const wxPoint &aMirrorPoint)
Definition: edit_tool.cpp:539
PCB_SCREEN * GetScreen() const override
Function GetScreen returns 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:228
RESET_REASON
Determines the reason of reset for a tool
Definition: tool_base.h:80
void Mirror(const wxPoint &aCentre, bool aMirrorAroundXAxis)
Mirror text position in footprint edition the text itself is not mirrored, and the layer not modified...
int editFootprintInFpEditor(const TOOL_EVENT &aEvent)
Definition: edit_tool.cpp:1185
bool IsHover() const
Definition: selection.h:66
void SetOrientation(double aAngle)
Function SetOrientation sets the rotation angle of the pad.
Definition: class_pad.cpp:357
TOOL_MANAGER * GetManager() const
Function GetManager() Returns the instance of TOOL_MANAGER that takes care of the tool...
Definition: tool_base.h:144
void ClearFlags(STATUS_FLAGS aMask=EDA_ITEM_ALL_FLAGS)
Definition: base_struct.h:254
void SetVisible(VIEW_ITEM *aItem, bool aIsVisible=true)
Sets the item visibility.
Definition: view.cpp:1331
void Activate()
Function Activate() Runs the tool.
void SetTransitions() override
Sets up handlers for various events.
Definition: edit_tool.cpp:1134
int Size() const
Returns the number of selected parts.
Definition: selection.h:112
void Add(VIEW_ITEM *aItem, int aDrawPriority=-1)
Function Add() Adds a VIEW_ITEM to the view.
Definition: view.cpp:311
void SetX0(int x)
Definition: class_pad.h:179
Module description (excepted pads)
static TOOL_ACTION remove
Deleting a BOARD_ITEM.
Definition: pcb_actions.h:120
EDGE_MODULE class definition.
void postPushAction(BOARD_ITEM *new_item) override
Definition: edit_tool.cpp:980
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:190
VECTOR2I GetCenter() const
Returns the center point of the selection area bounding box.
int Duplicate(const TOOL_EVENT &aEvent)
Function Duplicate()
Definition: edit_tool.cpp:846
void DisplayError(wxWindow *parent, const wxString &text, int displaytime)
Function DisplayError displays an error or warning message box with aMessage.
Definition: confirm.cpp:69
static void mirrorPadX(D_PAD &aPad, const wxPoint &aMirrorPoint)
Mirror a pad in the vertical axis passing through a point.
Definition: edit_tool.cpp:554
#define mod(a, n)
Definition: greymap.cpp:24
class PCB_BASE_FRAME basic PCB main window class for Pcbnew, Gerbview, and CvPcb footprint viewer...
static TOOL_ACTION measureTool
Definition: pcb_actions.h:352
const wxPoint & GetOffset() const
Definition: class_pad.h:191
void SetDelta(const wxSize &aSize)
Definition: class_pad.h:184
PCB_EDIT_FRAME::OnResetModuleTextSizes PCB_EDIT_FRAME::OnSelectOptionToolbar PCB_EDIT_FRAME::OnSelectOptionToolbar PCB_EDIT_FRAME::OnSelectOptionToolbar PCB_EDIT_FRAME::OnSelectOptionToolbar ID_PCB_MEASUREMENT_TOOL
Definition: pcbframe.cpp:262
bool Apply(COMMIT &aCommit)
Applies values from the dialog to the selected items.
void prePushAction(BOARD_ITEM *aItem) override
Definition: edit_tool.cpp:964
void SetEnd(const VECTOR2I &aEnd)
Set the current end of the rectangle (the end that moves with the cursor.
Color has changed.
Definition: view_item.h:57
BOARD_ITEM * Duplicate(const BOARD_ITEM *aItem, bool aAddToBoard=false)
const wxPoint GetCenter() const