KiCad PCB EDA Suite
drawing_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) 2014-2017 CERN
5  * Copyright (C) 2018-2021 KiCad Developers, see AUTHORS.txt for contributors.
6  * @author Maciej Suminski <maciej.suminski@cern.ch>
7  *
8  * This program is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU General Public License
10  * as published by the Free Software Foundation; either version 2
11  * of the License, or (at your option) any later version.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, you may find one here:
20  * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
21  * or you may search the http://www.gnu.org website for the version 2 license,
22  * or you may write to the Free Software Foundation, Inc.,
23  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
24  */
25 
26 #include "drawing_tool.h"
27 #include "pcb_actions.h"
28 #include <pcb_edit_frame.h>
29 #include <confirm.h>
30 #include <import_gfx/dialog_import_gfx.h>
31 #include <view/view.h>
32 #include <tool/tool_manager.h>
33 #include <tools/pcb_grid_helper.h>
34 #include <tools/pcb_selection_tool.h>
35 #include <tools/tool_event_utils.h>
36 #include <tools/zone_create_helper.h>
37 #include <widgets/appearance_controls.h>
38 #include <router/router_tool.h>
39 #include <geometry/geometry_utils.h>
40 #include <geometry/shape_segment.h>
41 #include <board_commit.h>
42 #include <scoped_set_reset.h>
43 #include <bitmaps.h>
44 #include <painter.h>
45 #include <status_popup.h>
46 #include <dialogs/dialog_text_properties.h>
47 #include <preview_items/arc_assistant.h>
48 #include <board.h>
49 #include <fp_shape.h>
50 #include <pcb_group.h>
51 #include <pcb_text.h>
52 #include <pcb_dimension.h>
53 #include <zone.h>
54 #include <footprint.h>
55 #include <preview_items/two_point_assistant.h>
56 #include <preview_items/two_point_geom_manager.h>
57 #include <ratsnest/ratsnest_data.h>
58 #include <pcbnew_id.h>
59 #include <dialogs/dialog_track_via_size.h>
60 #include <kicad_string.h>
61 #include <macros.h>
62 #include <widgets/infobar.h>
63 #include <board_design_settings.h>
64 
65 using SCOPED_DRAW_MODE = SCOPED_SET_RESET<DRAWING_TOOL::MODE>;
66 
67 
68 class VIA_SIZE_MENU : public ACTION_MENU
69 {
70 public:
71  VIA_SIZE_MENU() :
72  ACTION_MENU( true )
73  {
74  SetIcon( BITMAPS::width_track_via );
75  SetTitle( _( "Select Via Size" ) );
76  }
77 
78 protected:
79  ACTION_MENU* create() const override
80  {
81  return new VIA_SIZE_MENU();
82  }
83 
84  void update() override
85  {
86  PCB_EDIT_FRAME* frame = (PCB_EDIT_FRAME*) getToolManager()->GetToolHolder();
87  EDA_UNITS units = frame->GetUserUnits();
88  BOARD_DESIGN_SETTINGS& bds = frame->GetBoard()->GetDesignSettings();
89  bool useIndex = !bds.m_UseConnectedTrackWidth
90  && !bds.UseCustomTrackViaSize();
91  wxString msg;
92 
93  Clear();
94 
95  Append( ID_POPUP_PCB_SELECT_CUSTOM_WIDTH, _( "Use Custom Values..." ),
96  _( "Specify custom track and via sizes" ), wxITEM_CHECK );
97  Check( ID_POPUP_PCB_SELECT_CUSTOM_WIDTH, bds.UseCustomTrackViaSize() );
98 
99  AppendSeparator();
100 
101  for( unsigned i = 1; i < bds.m_ViasDimensionsList.size(); i++ )
102  {
103  VIA_DIMENSION via = bds.m_ViasDimensionsList[i];
104 
105  if( via.m_Drill > 0 )
106  {
107  msg.Printf( _("Via %s, drill %s" ),
108  MessageTextFromValue( units, via.m_Diameter ),
109  MessageTextFromValue( units, via.m_Drill ) );
110  }
111  else
112  {
113  msg.Printf( _( "Via %s" ), MessageTextFromValue( units, via.m_Diameter ) );
114  }
115 
116  int menuIdx = ID_POPUP_PCB_SELECT_VIASIZE1 + i;
117  Append( menuIdx, msg, wxEmptyString, wxITEM_CHECK );
118  Check( menuIdx, useIndex && bds.GetViaSizeIndex() == i );
119  }
120  }
121 
122  OPT_TOOL_EVENT eventHandler( const wxMenuEvent& aEvent ) override
123  {
124  PCB_EDIT_FRAME* frame = (PCB_EDIT_FRAME*) getToolManager()->GetToolHolder();
125  BOARD_DESIGN_SETTINGS& bds = frame->GetBoard()->GetDesignSettings();
126  int id = aEvent.GetId();
127 
128  // On Windows, this handler can be called with an event ID not existing in any
129  // menuitem, so only set flags when we have an ID match.
130 
131  if( id == ID_POPUP_PCB_SELECT_CUSTOM_WIDTH )
132  {
133  DIALOG_TRACK_VIA_SIZE sizeDlg( frame, bds );
134 
135  if( sizeDlg.ShowModal() == wxID_OK )
136  {
137  bds.UseCustomTrackViaSize( true );
138  bds.m_UseConnectedTrackWidth = false;
139  }
140  }
141  else if( id >= ID_POPUP_PCB_SELECT_VIASIZE1 && id <= ID_POPUP_PCB_SELECT_VIASIZE16 )
142  {
143  bds.UseCustomTrackViaSize( false );
144  bds.m_UseConnectedTrackWidth = false;
145  bds.SetViaSizeIndex( id - ID_POPUP_PCB_SELECT_VIASIZE1 );
146  }
147 
148  return OPT_TOOL_EVENT( PCB_ACTIONS::trackViaSizeChanged.MakeEvent() );
149  }
150 };
151 
152 
153 DRAWING_TOOL::DRAWING_TOOL() :
154  PCB_TOOL_BASE( "pcbnew.InteractiveDrawing" ),
155  m_view( nullptr ),
156  m_controls( nullptr ),
157  m_board( nullptr ),
158  m_frame( nullptr ),
159  m_mode( MODE::NONE ),
160  m_lineWidth( 1 )
161 {
162 }
163 
164 
165 DRAWING_TOOL::~DRAWING_TOOL()
166 {
167 }
168 
169 
170 bool DRAWING_TOOL::Init()
171 {
172  auto activeToolFunctor = [this]( const SELECTION& aSel )
173  {
174  return m_mode != MODE::NONE;
175  };
176 
177  // some interactive drawing tools can undo the last point
178  auto canUndoPoint = [this]( const SELECTION& aSel )
179  {
180  return ( m_mode == MODE::ARC
181  || m_mode == MODE::ZONE
182  || m_mode == MODE::KEEPOUT
183  || m_mode == MODE::GRAPHIC_POLYGON );
184  };
185 
186  // functor for tools that can automatically close the outline
187  auto canCloseOutline = [this]( const SELECTION& aSel )
188  {
189  return ( m_mode == MODE::ZONE
190  || m_mode == MODE::KEEPOUT
191  || m_mode == MODE::GRAPHIC_POLYGON );
192  };
193 
194  auto viaToolActive = [this]( const SELECTION& aSel )
195  {
196  return m_mode == MODE::VIA;
197  };
198 
199  auto& ctxMenu = m_menu.GetMenu();
200 
201  // cancel current tool goes in main context menu at the top if present
202  ctxMenu.AddItem( ACTIONS::cancelInteractive, activeToolFunctor, 1 );
203  ctxMenu.AddSeparator( 1 );
204 
205  // tool-specific actions
206  ctxMenu.AddItem( PCB_ACTIONS::closeOutline, canCloseOutline, 200 );
207  ctxMenu.AddItem( PCB_ACTIONS::deleteLastPoint, canUndoPoint, 200 );
208 
209  ctxMenu.AddSeparator( 500 );
210 
211  std::shared_ptr<VIA_SIZE_MENU> viaSizeMenu = std::make_shared<VIA_SIZE_MENU>();
212  viaSizeMenu->SetTool( this );
213  m_menu.AddSubMenu( viaSizeMenu );
214  ctxMenu.AddMenu( viaSizeMenu.get(), viaToolActive, 500 );
215 
216  ctxMenu.AddSeparator( 500 );
217 
218  // Type-specific sub-menus will be added for us by other tools
219  // For example, zone fill/unfill is provided by the PCB control tool
220 
221  // Finally, add the standard zoom/grid items
222  getEditFrame<PCB_BASE_FRAME>()->AddStandardSubMenus( m_menu );
223 
224  return true;
225 }
226 
227 
228 void DRAWING_TOOL::Reset( RESET_REASON aReason )
229 {
230  // Init variables used by every drawing tool
231  m_view = getView();
232  m_controls = getViewControls();
233  m_board = getModel<BOARD>();
234  m_frame = getEditFrame<PCB_BASE_EDIT_FRAME>();
235 }
236 
237 
238 DRAWING_TOOL::MODE DRAWING_TOOL::GetDrawingMode() const
239 {
240  return m_mode;
241 }
242 
243 
244 int DRAWING_TOOL::DrawLine( const TOOL_EVENT& aEvent )
245 {
246  if( m_isFootprintEditor && !m_frame->GetModel() )
247  return 0;
248 
249  FOOTPRINT* parentFootprint = dynamic_cast<FOOTPRINT*>( m_frame->GetModel() );
250  PCB_SHAPE* line = m_isFootprintEditor ? new FP_SHAPE( parentFootprint ) : new PCB_SHAPE;
251  BOARD_COMMIT commit( m_frame );
252  SCOPED_DRAW_MODE scopedDrawMode( m_mode, MODE::LINE );
253  OPT<VECTOR2D> startingPoint = boost::make_optional<VECTOR2D>( false, VECTOR2D( 0, 0 ) );
254 
255  line->SetShape( PCB_SHAPE_TYPE::SEGMENT );
256  line->SetFlags( IS_NEW );
257 
258  if( aEvent.HasPosition() )
259  startingPoint = getViewControls()->GetCursorPosition( !aEvent.DisableGridSnapping() );
260 
261  std::string tool = aEvent.GetCommandStr().get();
262  m_frame->PushTool( tool );
263  Activate();
264 
265  while( drawSegment( tool, &line, startingPoint ) )
266  {
267  if( line )
268  {
269  if( m_isFootprintEditor )
270  static_cast<FP_SHAPE*>( line )->SetLocalCoord();
271 
272  commit.Add( line );
273  commit.Push( _( "Draw a line segment" ) );
274  startingPoint = VECTOR2D( line->GetEnd() );
275  }
276  else
277  {
278  startingPoint = NULLOPT;
279  }
280 
281  line = m_isFootprintEditor ? new FP_SHAPE( parentFootprint ) : new PCB_SHAPE;
282  line->SetShape( PCB_SHAPE_TYPE::SEGMENT );
283  line->SetFlags( IS_NEW );
284  }
285 
286  return 0;
287 }
288 
289 
290 int DRAWING_TOOL::DrawRectangle( const TOOL_EVENT& aEvent )
291 {
292  if( m_isFootprintEditor && !m_frame->GetModel() )
293  return 0;
294 
295  FOOTPRINT* parentFootprint = dynamic_cast<FOOTPRINT*>( m_frame->GetModel() );
296  PCB_SHAPE* rect = m_isFootprintEditor ? new FP_SHAPE( parentFootprint ) : new PCB_SHAPE;
297  BOARD_COMMIT commit( m_frame );
298  SCOPED_DRAW_MODE scopedDrawMode( m_mode, MODE::RECTANGLE );
299  OPT<VECTOR2D> startingPoint = boost::make_optional<VECTOR2D>( false, VECTOR2D( 0, 0 ) );
300 
301  rect->SetShape( PCB_SHAPE_TYPE::RECT );
302  rect->SetFilled( false );
303  rect->SetFlags(IS_NEW );
304 
305  if( aEvent.HasPosition() )
306  startingPoint = getViewControls()->GetCursorPosition( !aEvent.DisableGridSnapping() );
307 
308  std::string tool = aEvent.GetCommandStr().get();
309  m_frame->PushTool( tool );
310  Activate();
311 
312  while( drawSegment( tool, &rect, startingPoint ) )
313  {
314  if( rect )
315  {
316  if( m_isFootprintEditor )
317  static_cast<FP_SHAPE*>( rect )->SetLocalCoord();
318 
319  commit.Add( rect );
320  commit.Push( _( "Draw a rectangle" ) );
321 
322  m_toolMgr->RunAction( PCB_ACTIONS::selectItem, true, rect );
323  }
324 
325  rect = m_isFootprintEditor ? new FP_SHAPE( parentFootprint ) : new PCB_SHAPE;
326  rect->SetShape( PCB_SHAPE_TYPE::RECT );
327  rect->SetFilled( false );
328  rect->SetFlags(IS_NEW );
329  startingPoint = NULLOPT;
330  }
331 
332  return 0;
333 }
334 
335 
336 int DRAWING_TOOL::DrawCircle( const TOOL_EVENT& aEvent )
337 {
338  if( m_isFootprintEditor && !m_frame->GetModel() )
339  return 0;
340 
341  FOOTPRINT* parentFootprint = dynamic_cast<FOOTPRINT*>( m_frame->GetModel() );
342  PCB_SHAPE* circle = m_isFootprintEditor ? new FP_SHAPE( parentFootprint ) : new PCB_SHAPE;
343  BOARD_COMMIT commit( m_frame );
344  SCOPED_DRAW_MODE scopedDrawMode( m_mode, MODE::CIRCLE );
345  OPT<VECTOR2D> startingPoint = boost::make_optional<VECTOR2D>( false, VECTOR2D( 0, 0 ) );
346 
347  circle->SetShape( PCB_SHAPE_TYPE::CIRCLE );
348  circle->SetFilled( false );
349  circle->SetFlags( IS_NEW );
350 
351  if( aEvent.HasPosition() )
352  startingPoint = getViewControls()->GetCursorPosition( !aEvent.DisableGridSnapping() );
353 
354  std::string tool = aEvent.GetCommandStr().get();
355  m_frame->PushTool( tool );
356  Activate();
357 
358  while( drawSegment( tool, &circle, startingPoint ) )
359  {
360  if( circle )
361  {
362  if( m_isFootprintEditor )
363  static_cast<FP_SHAPE*>( circle )->SetLocalCoord();
364 
365  commit.Add( circle );
366  commit.Push( _( "Draw a circle" ) );
367 
368  m_toolMgr->RunAction( PCB_ACTIONS::selectItem, true, circle );
369  }
370 
371  circle = m_isFootprintEditor ? new FP_SHAPE( parentFootprint ) : new PCB_SHAPE;
372  circle->SetShape( PCB_SHAPE_TYPE::CIRCLE );
373  circle->SetFilled( false );
374  circle->SetFlags( IS_NEW );
375  startingPoint = NULLOPT;
376  }
377 
378  return 0;
379 }
380 
381 
382 int DRAWING_TOOL::DrawArc( const TOOL_EVENT& aEvent )
383 {
384  if( m_isFootprintEditor && !m_frame->GetModel() )
385  return 0;
386 
387  FOOTPRINT* parentFootprint = dynamic_cast<FOOTPRINT*>( m_frame->GetModel() );
388  PCB_SHAPE* arc = m_isFootprintEditor ? new FP_SHAPE( parentFootprint ) : new PCB_SHAPE;
389  BOARD_COMMIT commit( m_frame );
390  SCOPED_DRAW_MODE scopedDrawMode( m_mode, MODE::ARC );
391  bool immediateMode = aEvent.HasPosition();
392 
393  arc->SetShape( PCB_SHAPE_TYPE::ARC );
394  arc->SetFlags( IS_NEW );
395 
396  std::string tool = aEvent.GetCommandStr().get();
397  m_frame->PushTool( tool );
398  Activate();
399 
400  while( drawArc( tool, &arc, immediateMode ) )
401  {
402  if( arc )
403  {
404  if( m_isFootprintEditor )
405  static_cast<FP_SHAPE*>( arc )->SetLocalCoord();
406 
407  commit.Add( arc );
408  commit.Push( _( "Draw an arc" ) );
409 
410  m_toolMgr->RunAction( PCB_ACTIONS::selectItem, true, arc );
411  }
412 
413  arc = m_isFootprintEditor ? new FP_SHAPE( parentFootprint ) : new PCB_SHAPE;
414  arc->SetShape( PCB_SHAPE_TYPE::ARC );
415  arc->SetFlags( IS_NEW );
416  immediateMode = false;
417  }
418 
419  return 0;
420 }
421 
422 
423 int DRAWING_TOOL::PlaceText( const TOOL_EVENT& aEvent )
424 {
425  if( m_isFootprintEditor && !m_frame->GetModel() )
426  return 0;
427 
428  BOARD_ITEM* text = NULL;
429  const BOARD_DESIGN_SETTINGS& dsnSettings = m_frame->GetDesignSettings();
430  BOARD_COMMIT commit( m_frame );
431  SCOPED_DRAW_MODE scopedDrawMode( m_mode, MODE::TEXT );
432 
433  auto cleanup =
434  [&]()
435  {
436  m_toolMgr->RunAction( PCB_ACTIONS::selectionClear, true );
437  m_controls->ForceCursorPosition( false );
438  m_controls->ShowCursor( true );
439  m_controls->SetAutoPan( false );
440  m_controls->CaptureCursor( false );
441  delete text;
442  text = NULL;
443  };
444 
445  auto setCursor =
446  [&]()
447  {
448  if( text )
449  m_frame->GetCanvas()->SetCurrentCursor( KICURSOR::MOVING );
450  else
451  m_frame->GetCanvas()->SetCurrentCursor( KICURSOR::TEXT );
452  };
453 
454  m_toolMgr->RunAction( PCB_ACTIONS::selectionClear, true );
455  m_controls->ShowCursor( true );
456  // do not capture or auto-pan until we start placing some text
457 
458  std::string tool = aEvent.GetCommandStr().get();
459  m_frame->PushTool( tool );
460  Activate();
461 
462  // Prime the pump
463  if( !aEvent.IsReactivate() )
464  m_toolMgr->RunAction( ACTIONS::cursorClick );
465 
466  // Set initial cursor
467  setCursor();
468 
469  // Main loop: keep receiving events
470  while( TOOL_EVENT* evt = Wait() )
471  {
472  setCursor();
473  VECTOR2I cursorPos = m_controls->GetCursorPosition();
474 
475  if( evt->IsCancelInteractive() )
476  {
477  if( text )
478  {
479  cleanup();
480  }
481  else
482  {
483  m_frame->PopTool( tool );
484  break;
485  }
486  }
487  else if( evt->IsActivate() )
488  {
489  if( text )
490  cleanup();
491 
492  if( evt->IsMoveTool() )
493  {
494  // leave ourselves on the stack so we come back after the move
495  break;
496  }
497  else
498  {
499  m_frame->PopTool( tool );
500  break;
501  }
502  }
503  else if( evt->IsClick( BUT_RIGHT ) )
504  {
505  m_menu.ShowContextMenu( selection() );
506  }
507  else if( evt->IsClick( BUT_LEFT ) )
508  {
509  bool placing = text != nullptr;
510 
511  if( !text )
512  {
513  m_toolMgr->RunAction( PCB_ACTIONS::selectionClear, true );
514 
515  m_controls->ForceCursorPosition( true, m_controls->GetCursorPosition() );
516  PCB_LAYER_ID layer = m_frame->GetActiveLayer();
517 
518  // Init the new item attributes
519  if( m_isFootprintEditor )
520  {
521  FP_TEXT* fpText = new FP_TEXT( (FOOTPRINT*) m_frame->GetModel() );
522 
523  fpText->SetLayer( layer );
524  fpText->SetTextSize( dsnSettings.GetTextSize( layer ) );
525  fpText->SetTextThickness( dsnSettings.GetTextThickness( layer ) );
526  fpText->SetItalic( dsnSettings.GetTextItalic( layer ) );
527  fpText->SetKeepUpright( dsnSettings.GetTextUpright( layer ) );
528  fpText->SetTextPos( (wxPoint) cursorPos );
529 
530  text = fpText;
531 
532  DIALOG_TEXT_PROPERTIES textDialog( m_frame, fpText );
533  bool cancelled;
534 
535  RunMainStack( [&]()
536  {
537  cancelled = !textDialog.ShowModal();
538  } );
539 
540  if( cancelled || NoPrintableChars( fpText->GetText() ) )
541  {
542  delete text;
543  text = nullptr;
544  }
545  else if( fpText->GetTextPos() != (wxPoint) cursorPos )
546  {
547  // If the user modified the location then go ahead and place it there.
548  // Otherwise we'll drag.
549  placing = true;
550  }
551  }
552  else
553  {
554  PCB_TEXT* pcbText = new PCB_TEXT( m_frame->GetModel() );
555  // TODO we have to set IS_NEW, otherwise InstallTextPCB.. creates an undo entry :| LEGACY_CLEANUP
556  pcbText->SetFlags( IS_NEW );
557 
558  pcbText->SetLayer( layer );
559 
560  // Set the mirrored option for layers on the BACK side of the board
561  if( IsBackLayer( layer ) )
562  pcbText->SetMirrored( true );
563 
564  pcbText->SetTextSize( dsnSettings.GetTextSize( layer ) );
565  pcbText->SetTextThickness( dsnSettings.GetTextThickness( layer ) );
566  pcbText->SetItalic( dsnSettings.GetTextItalic( layer ) );
567  pcbText->SetTextPos( (wxPoint) cursorPos );
568 
569  RunMainStack( [&]()
570  {
571  m_frame->ShowTextPropertiesDialog( pcbText );
572  } );
573 
574  if( NoPrintableChars( pcbText->GetText() ) )
575  delete pcbText;
576  else
577  text = pcbText;
578  }
579 
580  if( text )
581  {
582  if( !m_view->IsLayerVisible( text->GetLayer() ) )
583  {
584  m_frame->GetAppearancePanel()->SetLayerVisible( text->GetLayer(), true );
585  m_frame->GetCanvas()->Refresh();
586  }
587 
588  m_controls->WarpCursor( text->GetPosition(), true );
589  m_toolMgr->RunAction( PCB_ACTIONS::selectItem, true, text );
590  m_view->Update( &selection() );
591 
592  // update the cursor so it looks correct before another event
593  setCursor();
594  }
595  }
596 
597  if( placing )
598  {
599  text->ClearFlags();
600  m_toolMgr->RunAction( PCB_ACTIONS::selectionClear, true );
601 
602  commit.Add( text );
603  commit.Push( _( "Place a text" ) );
604 
605  m_toolMgr->RunAction( PCB_ACTIONS::selectItem, true, text );
606 
607  text = nullptr;
608  }
609 
610  m_controls->ForceCursorPosition( false );
611  m_controls->ShowCursor( true );
612  m_controls->CaptureCursor( text != nullptr );
613  m_controls->SetAutoPan( text != nullptr );
614  }
615  else if( text && evt->IsMotion() )
616  {
617  text->SetPosition( (wxPoint) cursorPos );
618  selection().SetReferencePoint( cursorPos );
619  m_view->Update( &selection() );
620  }
621  else if( evt->IsAction( &PCB_ACTIONS::properties ) )
622  {
623  if( text )
624  {
625  frame()->OnEditItemRequest( text );
626  m_view->Update( &selection() );
627  frame()->SetMsgPanel( text );
628  }
629  else
630  {
631  evt->SetPassEvent();
632  }
633  }
634  else
635  {
636  evt->SetPassEvent();
637  }
638  }
639 
640  m_frame->GetCanvas()->SetCurrentCursor( KICURSOR::ARROW );
641  m_frame->SetMsgPanel( board() );
642  return 0;
643 }
644 
645 
646 void DRAWING_TOOL::constrainDimension( PCB_DIMENSION_BASE* aDim )
647 {
648  const VECTOR2I lineVector{ aDim->GetEnd() - aDim->GetStart() };
649 
650  aDim->SetEnd( wxPoint( VECTOR2I( aDim->GetStart() ) + GetVectorSnapped45( lineVector ) ) );
651  aDim->Update();
652 }
653 
654 
655 int DRAWING_TOOL::DrawDimension( const TOOL_EVENT& aEvent )
656 {
657  if( m_isFootprintEditor && !m_frame->GetModel() )
658  return 0;
659 
660  enum DIMENSION_STEPS
661  {
662  SET_ORIGIN = 0,
663  SET_END,
664  SET_HEIGHT,
665  FINISHED
666  };
667 
668  TOOL_EVENT originalEvent = aEvent;
669  PCB_DIMENSION_BASE* dimension = nullptr;
670  BOARD_COMMIT commit( m_frame );
671  PCB_GRID_HELPER grid( m_toolMgr, m_frame->GetMagneticItemsSettings() );
672  BOARD_DESIGN_SETTINGS& boardSettings = m_board->GetDesignSettings();
673  PCB_SELECTION preview; // A VIEW_GROUP that serves as a preview for the new item(s)
674  SCOPED_DRAW_MODE scopedDrawMode( m_mode, MODE::DIMENSION );
675  int step = SET_ORIGIN;
676 
677  m_view->Add( &preview );
678 
679  auto cleanup =
680  [&]()
681  {
682  m_controls->SetAutoPan( false );
683  m_controls->CaptureCursor( false );
684 
685  preview.Clear();
686  m_view->Update( &preview );
687 
688  delete dimension;
689  dimension = nullptr;
690  step = SET_ORIGIN;
691  };
692 
693  auto setCursor =
694  [&]()
695  {
696  m_frame->GetCanvas()->SetCurrentCursor( KICURSOR::MEASURE );
697  };
698 
699  m_toolMgr->RunAction( PCB_ACTIONS::selectionClear, true );
700  m_controls->ShowCursor( true );
701 
702  std::string tool = aEvent.GetCommandStr().get();
703  m_frame->PushTool( tool );
704  Activate();
705 
706  // Prime the pump
707  m_toolMgr->RunAction( ACTIONS::refreshPreview );
708 
709  if( aEvent.HasPosition() )
710  m_toolMgr->PrimeTool( aEvent.Position() );
711 
712  // Set initial cursor
713  setCursor();
714 
715  // Main loop: keep receiving events
716  while( TOOL_EVENT* evt = Wait() )
717  {
718  if( step > SET_ORIGIN )
719  frame()->SetMsgPanel( dimension );
720 
721  setCursor();
722 
723  grid.SetSnap( !evt->Modifier( MD_SHIFT ) );
724  grid.SetUseGrid( getView()->GetGAL()->GetGridSnapping() && !evt->DisableGridSnapping() );
725 
726  VECTOR2I cursorPos = evt->HasPosition() ? evt->Position() : m_controls->GetMousePosition();
727 
728  cursorPos = grid.BestSnapAnchor( cursorPos, nullptr );
729  m_controls->ForceCursorPosition( true, cursorPos );
730 
731  if( evt->IsCancelInteractive() )
732  {
733  m_controls->SetAutoPan( false );
734 
735  if( step != SET_ORIGIN ) // start from the beginning
736  {
737  cleanup();
738  }
739  else
740  {
741  m_frame->PopTool( tool );
742  break;
743  }
744  }
745  else if( evt->IsActivate() )
746  {
747  if( step != SET_ORIGIN )
748  cleanup();
749 
750  if( evt->IsPointEditor() )
751  {
752  // don't exit (the point editor runs in the background)
753  }
754  else if( evt->IsMoveTool() )
755  {
756  // leave ourselves on the stack so we come back after the move
757  break;
758  }
759  else
760  {
761  m_frame->PopTool( tool );
762  break;
763  }
764  }
765  else if( evt->IsAction( &PCB_ACTIONS::incWidth ) && step != SET_ORIGIN )
766  {
767  m_lineWidth += WIDTH_STEP;
768  dimension->SetLineThickness( m_lineWidth );
769  m_view->Update( &preview );
770  frame()->SetMsgPanel( dimension );
771  }
772  else if( evt->IsAction( &PCB_ACTIONS::decWidth ) && step != SET_ORIGIN )
773  {
774  if( m_lineWidth > WIDTH_STEP )
775  {
776  m_lineWidth -= WIDTH_STEP;
777  dimension->SetLineThickness( m_lineWidth );
778  m_view->Update( &preview );
779  frame()->SetMsgPanel( dimension );
780  }
781  }
782  else if( evt->IsClick( BUT_RIGHT ) )
783  {
784  m_menu.ShowContextMenu( selection() );
785  }
786  else if( evt->IsClick( BUT_LEFT ) )
787  {
788  switch( step )
789  {
790  case SET_ORIGIN:
791  {
792  m_toolMgr->RunAction( PCB_ACTIONS::selectionClear, true );
793 
794  PCB_LAYER_ID layer = m_frame->GetActiveLayer();
795 
796  // Init the new item attributes
797  auto setMeasurementAttributes =
798  [&]( PCB_DIMENSION_BASE* aDim )
799  {
800  aDim->SetUnitsMode( boardSettings.m_DimensionUnitsMode );
801  aDim->SetUnitsFormat( boardSettings.m_DimensionUnitsFormat );
802  aDim->SetPrecision( boardSettings.m_DimensionPrecision );
803  aDim->SetSuppressZeroes( boardSettings.m_DimensionSuppressZeroes );
804  aDim->SetTextPositionMode( boardSettings.m_DimensionTextPosition );
805  aDim->SetKeepTextAligned( boardSettings.m_DimensionKeepTextAligned );
806 
807  if( boardSettings.m_DimensionUnitsMode == DIM_UNITS_MODE::AUTOMATIC )
808  aDim->SetUnits( m_frame->GetUserUnits() );
809  };
810 
811  if( originalEvent.IsAction( &PCB_ACTIONS::drawAlignedDimension ) )
812  {
813  dimension = new PCB_DIM_ALIGNED( m_board );
814  setMeasurementAttributes( dimension );
815  }
816  else if( originalEvent.IsAction( &PCB_ACTIONS::drawOrthogonalDimension ) )
817  {
818  dimension = new PCB_DIM_ORTHOGONAL( m_board );
819  setMeasurementAttributes( dimension );
820  }
821  else if( originalEvent.IsAction( &PCB_ACTIONS::drawCenterDimension ) )
822  {
823  dimension = new PCB_DIM_CENTER( m_board );
824  }
825  else if( originalEvent.IsAction( &PCB_ACTIONS::drawLeader ) )
826  {
827  dimension = new PCB_DIM_LEADER( m_board );
828  dimension->Text().SetPosition( wxPoint( cursorPos ) );
829  }
830  else
831  {
832  wxFAIL_MSG( "Unhandled action in DRAWING_TOOL::DrawDimension" );
833  }
834 
835  dimension->SetLayer( layer );
836  dimension->Text().SetTextSize( boardSettings.GetTextSize( layer ) );
837  dimension->Text().SetTextThickness( boardSettings.GetTextThickness( layer ) );
838  dimension->Text().SetItalic( boardSettings.GetTextItalic( layer ) );
839  dimension->SetLineThickness( boardSettings.GetLineThickness( layer ) );
840  dimension->SetArrowLength( boardSettings.m_DimensionArrowLength );
841  dimension->SetExtensionOffset( boardSettings.m_DimensionExtensionOffset );
842  dimension->SetStart( (wxPoint) cursorPos );
843  dimension->SetEnd( (wxPoint) cursorPos );
844  dimension->Update();
845 
846  if( !m_view->IsLayerVisible( layer ) )
847  {
848  m_frame->GetAppearancePanel()->SetLayerVisible( layer, true );
849  m_frame->GetCanvas()->Refresh();
850  }
851 
852  preview.Add( dimension );
853  frame()->SetMsgPanel( dimension );
854 
855  m_controls->SetAutoPan( true );
856  m_controls->CaptureCursor( true );
857  }
858  break;
859 
860  case SET_END:
861  {
862  dimension->SetEnd( (wxPoint) cursorPos );
863  dimension->Update();
864 
865  if( !!evt->Modifier( MD_SHIFT ) || dimension->Type() == PCB_DIM_CENTER_T )
866  constrainDimension( dimension );
867 
868  // Dimensions that have origin and end in the same spot are not valid
869  if( dimension->GetStart() == dimension->GetEnd() )
870  --step;
871  else if( dimension->Type() == PCB_DIM_LEADER_T )
872  dimension->SetText( wxT( "?" ) );
873 
874  if( dimension->Type() == PCB_DIM_CENTER_T )
875  {
876  // No separate height/text step
877  ++step;
878  KI_FALLTHROUGH;
879  }
880  else
881  {
882  break;
883  }
884  }
885 
886  case SET_HEIGHT:
887  if( dimension->Type() == PCB_DIM_LEADER_T )
888  {
889  assert( dimension->GetStart() != dimension->GetEnd() );
890  assert( dimension->GetLineThickness() > 0 );
891 
892  preview.Remove( dimension );
893 
894  commit.Add( dimension );
895  commit.Push( _( "Draw a leader" ) );
896 
897  // Run the edit immediately to set the leader text
898  m_toolMgr->RunAction( PCB_ACTIONS::properties, true, dimension );
899  }
900  else if( (wxPoint) cursorPos != dimension->GetPosition() )
901  {
902  assert( dimension->GetStart() != dimension->GetEnd() );
903  assert( dimension->GetLineThickness() > 0 );
904 
905  preview.Remove( dimension );
906 
907  commit.Add( dimension );
908  commit.Push( _( "Draw a dimension" ) );
909 
910  m_toolMgr->RunAction( PCB_ACTIONS::selectItem, true, dimension );
911  }
912 
913  break;
914  }
915 
916  if( ++step == FINISHED )
917  {
918  step = SET_ORIGIN;
919  m_controls->SetAutoPan( false );
920  m_controls->CaptureCursor( false );
921  }
922  }
923  else if( evt->IsMotion() )
924  {
925  switch( step )
926  {
927  case SET_END:
928  dimension->SetEnd( (wxPoint) cursorPos );
929 
930  if( dimension->Type() == PCB_DIM_ORTHOGONAL_T )
931  {
932  PCB_DIM_ORTHOGONAL* ortho = static_cast<PCB_DIM_ORTHOGONAL*>( dimension );
933 
934  BOX2I bounds( dimension->GetStart(),
935  dimension->GetEnd() - dimension->GetStart() );
936 
937  // Create a nice preview by measuring the longer dimension
938  bool vert = bounds.GetWidth() < bounds.GetHeight();
939 
940  ortho->SetOrientation( vert ? PCB_DIM_ORTHOGONAL::DIR::VERTICAL
941  : PCB_DIM_ORTHOGONAL::DIR::HORIZONTAL );
942  }
943 
944  dimension->Update();
945 
946  if( !!evt->Modifier( MD_SHIFT ) || dimension->Type() == PCB_DIM_CENTER_T )
947  constrainDimension( dimension );
948 
949  break;
950 
951  case SET_HEIGHT:
952  {
953  if( dimension->Type() == PCB_DIM_ALIGNED_T )
954  {
955  PCB_DIM_ALIGNED* aligned = static_cast<PCB_DIM_ALIGNED*>( dimension );
956 
957  // Calculating the direction of travel perpendicular to the selected axis
958  double angle = aligned->GetAngle() + ( M_PI / 2 );
959 
960  wxPoint delta( (wxPoint) cursorPos - dimension->GetEnd() );
961  double height = ( delta.x * cos( angle ) ) + ( delta.y * sin( angle ) );
962  aligned->SetHeight( height );
963  aligned->Update();
964  }
965  else if( dimension->Type() == PCB_DIM_ORTHOGONAL_T )
966  {
967  PCB_DIM_ORTHOGONAL* ortho = static_cast<PCB_DIM_ORTHOGONAL*>( dimension );
968 
969  BOX2I bounds( dimension->GetStart(),
970  dimension->GetEnd() - dimension->GetStart() );
971  VECTOR2I direction( cursorPos - bounds.Centre() );
972  bool vert;
973 
974  // Only change the orientation when we move outside the bounds
975  if( !bounds.Contains( cursorPos ) )
976  {
977  // If the dimension is horizontal or vertical, set correct orientation
978  // otherwise, test if we're left/right of the bounding box or above/below it
979  if( bounds.GetWidth() == 0 )
980  {
981  vert = true;
982  }
983  else if( bounds.GetHeight() == 0 )
984  {
985  vert = false;
986  }
987  else if( cursorPos.x > bounds.GetLeft() && cursorPos.x < bounds.GetRight() )
988  {
989  vert = false;
990  }
991  else if( cursorPos.y > bounds.GetTop() && cursorPos.y < bounds.GetBottom() )
992  {
993  vert = true;
994  }
995  else
996  {
997  vert = std::abs( direction.y ) < std::abs( direction.x );
998  }
999  ortho->SetOrientation( vert ? PCB_DIM_ORTHOGONAL::DIR::VERTICAL
1000  : PCB_DIM_ORTHOGONAL::DIR::HORIZONTAL );
1001  }
1002  else
1003  {
1004  vert = ortho->GetOrientation() == PCB_DIM_ORTHOGONAL::DIR::VERTICAL;
1005  }
1006 
1007  VECTOR2I heightVector( cursorPos - dimension->GetStart() );
1008  ortho->SetHeight( vert ? heightVector.x : heightVector.y );
1009  ortho->Update();
1010  }
1011  else if( dimension->Type() == PCB_DIM_LEADER_T )
1012  {
1013  // Leader: SET_HEIGHT actually sets the text position directly
1014  VECTOR2I lineVector( cursorPos - dimension->GetEnd() );
1015  dimension->Text().SetPosition( wxPoint( VECTOR2I( dimension->GetEnd() ) +
1016  GetVectorSnapped45( lineVector ) ) );
1017  dimension->Update();
1018  }
1019  }
1020  break;
1021  }
1022 
1023  // Show a preview of the item
1024  m_view->Update( &preview );
1025  }
1026  else if( evt->IsAction( &PCB_ACTIONS::layerChanged ) )
1027  {
1028  if( dimension )
1029  {
1030  PCB_LAYER_ID layer = m_frame->GetActiveLayer();
1031 
1032  if( !m_view->IsLayerVisible( layer ) )
1033  {
1034  m_frame->GetAppearancePanel()->SetLayerVisible( layer, true );
1035  m_frame->GetCanvas()->Refresh();
1036  }
1037 
1038  dimension->SetLayer( layer );
1039  dimension->Text().SetTextSize( boardSettings.GetTextSize( layer ) );
1040  dimension->Text().SetTextThickness( boardSettings.GetTextThickness( layer ) );
1041  dimension->Text().SetItalic( boardSettings.GetTextItalic( layer ) );
1042  dimension->SetLineThickness( boardSettings.GetLineThickness( layer ) );
1043  dimension->Update();
1044 
1045  m_view->Update( &preview );
1046  frame()->SetMsgPanel( dimension );
1047  }
1048  else
1049  {
1050  evt->SetPassEvent();
1051  }
1052  }
1053  else if( evt->IsAction( &PCB_ACTIONS::properties ) )
1054  {
1055  if( step == SET_END || step == SET_HEIGHT )
1056  {
1057  frame()->OnEditItemRequest( dimension );
1058  dimension->Update();
1059  frame()->SetMsgPanel( dimension );
1060  break;
1061  }
1062  else
1063  {
1064  evt->SetPassEvent();
1065  }
1066  }
1067  else
1068  {
1069  evt->SetPassEvent();
1070  }
1071  }
1072 
1073  if( step != SET_ORIGIN )
1074  delete dimension;
1075 
1076  m_controls->SetAutoPan( false );
1077  m_controls->ForceCursorPosition( false );
1078  m_controls->CaptureCursor( false );
1079  m_frame->GetCanvas()->SetCurrentCursor( KICURSOR::ARROW );
1080 
1081  m_view->Remove( &preview );
1082  m_frame->SetMsgPanel( board() );
1083  return 0;
1084 }
1085 
1086 
1087 int DRAWING_TOOL::PlaceImportedGraphics( const TOOL_EVENT& aEvent )
1088 {
1089  if( !m_frame->GetModel() )
1090  return 0;
1091 
1092  // Note: PlaceImportedGraphics() will convert PCB_SHAPE_T and PCB_TEXT_T to footprint
1093  // items if needed
1094  DIALOG_IMPORT_GFX dlg( m_frame, m_isFootprintEditor );
1095  int dlgResult = dlg.ShowModal();
1096 
1097  std::list<std::unique_ptr<EDA_ITEM>>& list = dlg.GetImportedItems();
1098 
1099  if( dlgResult != wxID_OK )
1100  return 0;
1101 
1102  // Ensure the list is not empty:
1103  if( list.empty() )
1104  {
1105  wxMessageBox( _( "No graphic items found in file to import") );
1106  return 0;
1107  }
1108 
1109  m_toolMgr->RunAction( ACTIONS::cancelInteractive, true );
1110 
1111  std::vector<BOARD_ITEM*> newItems; // all new items, including group
1112  std::vector<BOARD_ITEM*> selectedItems; // the group, or newItems if no group
1113  PCB_SELECTION preview;
1114  BOARD_COMMIT commit( m_frame );
1115  PCB_GROUP* group = nullptr;
1116 
1117  if( dlg.ShouldGroupItems() )
1118  {
1119  if( m_isFootprintEditor )
1120  group = new PCB_GROUP( m_frame->GetBoard()->GetFirstFootprint() );
1121  else
1122  group = new PCB_GROUP( m_frame->GetBoard() );
1123 
1124  newItems.push_back( group );
1125  selectedItems.push_back( group );
1126  preview.Add( group );
1127  }
1128 
1129  for( std::unique_ptr<EDA_ITEM>& ptr : list )
1130  {
1131  BOARD_ITEM* item = static_cast<BOARD_ITEM*>( ptr.get() );
1132 
1133  if( m_isFootprintEditor )
1134  wxASSERT( item->Type() == PCB_FP_SHAPE_T || item->Type() == PCB_FP_TEXT_T );
1135  else
1136  wxASSERT( item->Type() == PCB_SHAPE_T || item->Type() == PCB_TEXT_T );
1137 
1138  newItems.push_back( item );
1139 
1140  if( group )
1141  group->AddItem( item );
1142  else
1143  selectedItems.push_back( item );
1144 
1145  preview.Add( item );
1146 
1147  ptr.release();
1148  }
1149 
1150  if( !dlg.IsPlacementInteractive() )
1151  {
1152  for( BOARD_ITEM* item : newItems )
1153  commit.Add( item );
1154 
1155  commit.Push( _( "Place a DXF_SVG drawing" ) );
1156  return 0;
1157  }
1158 
1159  m_view->Add( &preview );
1160 
1161  // Clear the current selection then select the drawings so that edit tools work on them
1162  m_toolMgr->RunAction( PCB_ACTIONS::selectionClear, true );
1163  m_toolMgr->RunAction( PCB_ACTIONS::selectItems, true, &selectedItems );
1164 
1165  m_controls->ShowCursor( true );
1166  m_controls->ForceCursorPosition( false );
1167 
1168  SCOPED_DRAW_MODE scopedDrawMode( m_mode, MODE::DXF );
1169 
1170  // Now move the new items to the current cursor position:
1171  VECTOR2I cursorPos = m_controls->GetCursorPosition();
1172  VECTOR2I delta = cursorPos - static_cast<BOARD_ITEM*>( preview.Front() )->GetPosition();
1173 
1174  for( BOARD_ITEM* item : selectedItems )
1175  item->Move( (wxPoint) delta );
1176 
1177  m_view->Update( &preview );
1178 
1179  std::string tool = aEvent.GetCommandStr().get();
1180  m_frame->PushTool( tool );
1181  Activate();
1182 
1183  auto setCursor =
1184  [&]()
1185  {
1186  m_frame->GetCanvas()->SetCurrentCursor( KICURSOR::MOVING );
1187  };
1188 
1189  // Set initial cursor
1190  setCursor();
1191 
1192  // Main loop: keep receiving events
1193  while( TOOL_EVENT* evt = Wait() )
1194  {
1195  setCursor();
1196  cursorPos = m_controls->GetCursorPosition();
1197 
1198  if( evt->IsCancelInteractive() || evt->IsActivate() )
1199  {
1200  m_toolMgr->RunAction( PCB_ACTIONS::selectionClear, true );
1201 
1202  for( BOARD_ITEM* item : newItems )
1203  delete item;
1204 
1205  break;
1206  }
1207  else if( evt->IsMotion() )
1208  {
1209  delta = cursorPos - static_cast<BOARD_ITEM*>( preview.Front() )->GetPosition();
1210 
1211  for( BOARD_ITEM* item : selectedItems )
1212  item->Move( (wxPoint) delta );
1213 
1214  m_view->Update( &preview );
1215  }
1216  else if( evt->IsClick( BUT_RIGHT ) )
1217  {
1218  m_menu.ShowContextMenu( selection() );
1219  }
1220  else if( evt->IsClick( BUT_LEFT ) || evt->IsDblClick( BUT_LEFT ) )
1221  {
1222  // Place the imported drawings
1223  for( BOARD_ITEM* item : newItems )
1224  commit.Add( item );
1225 
1226  commit.Push( _( "Place a DXF_SVG drawing" ) );
1227  break; // This is a one-shot command, not a tool
1228  }
1229  else
1230  {
1231  evt->SetPassEvent();
1232  }
1233  }
1234 
1235  preview.Clear();
1236  m_view->Remove( &preview );
1237 
1238  m_frame->GetCanvas()->SetCurrentCursor( KICURSOR::ARROW );
1239  m_frame->PopTool( tool );
1240  return 0;
1241 }
1242 
1243 
1244 int DRAWING_TOOL::SetAnchor( const TOOL_EVENT& aEvent )
1245 {
1246  wxASSERT( m_isFootprintEditor );
1247 
1248  if( !m_frame->GetModel() )
1249  return 0;
1250 
1251  SCOPED_DRAW_MODE scopedDrawMode( m_mode, MODE::ANCHOR );
1252  PCB_GRID_HELPER grid( m_toolMgr, m_frame->GetMagneticItemsSettings() );
1253 
1254  std::string tool = aEvent.GetCommandStr().get();
1255  m_frame->PushTool( tool );
1256  Activate();
1257 
1258  m_toolMgr->RunAction( PCB_ACTIONS::selectionClear, true );
1259  m_controls->ShowCursor( true );
1260  m_controls->SetAutoPan( true );
1261  m_controls->CaptureCursor( false );
1262 
1263  auto setCursor =
1264  [&]()
1265  {
1266  m_frame->GetCanvas()->SetCurrentCursor( KICURSOR::BULLSEYE );
1267  };
1268 
1269  // Set initial cursor
1270  setCursor();
1271 
1272  while( TOOL_EVENT* evt = Wait() )
1273  {
1274  setCursor();
1275 
1276  grid.SetSnap( !evt->Modifier( MD_SHIFT ) );
1277  grid.SetUseGrid( getView()->GetGAL()->GetGridSnapping() && !evt->DisableGridSnapping() );
1278  VECTOR2I cursorPos = grid.BestSnapAnchor( m_controls->GetMousePosition(),
1279  LSET::AllLayersMask() );
1280  m_controls->ForceCursorPosition( true, cursorPos );
1281 
1282  if( evt->IsClick( BUT_LEFT ) || evt->IsDblClick( BUT_LEFT ) )
1283  {
1284  FOOTPRINT* footprint = (FOOTPRINT*) m_frame->GetModel();
1285  BOARD_COMMIT commit( m_frame );
1286  commit.Modify( footprint );
1287 
1288  // set the new relative internal local coordinates of footprint items
1289  wxPoint moveVector = footprint->GetPosition() - (wxPoint) cursorPos;
1290  footprint->MoveAnchorPosition( moveVector );
1291 
1292  commit.Push( _( "Move the footprint reference anchor" ) );
1293 
1294  // Usually, we do not need to change twice the anchor position,
1295  // so deselect the active tool
1296  m_frame->PopTool( tool );
1297  break;
1298  }
1299  else if( evt->IsClick( BUT_RIGHT ) )
1300  {
1301  m_menu.ShowContextMenu( selection() );
1302  }
1303  else if( evt->IsCancelInteractive() || evt->IsActivate() )
1304  {
1305  m_frame->PopTool( tool );
1306  break;
1307  }
1308  else
1309  {
1310  evt->SetPassEvent();
1311  }
1312  }
1313 
1314  m_frame->GetCanvas()->SetCurrentCursor( KICURSOR::ARROW );
1315  return 0;
1316 }
1317 
1318 
1319 int DRAWING_TOOL::ToggleLine45degMode( const TOOL_EVENT& toolEvent )
1320 {
1321  m_frame->Settings().m_Use45DegreeGraphicSegments = !m_frame->Settings().m_Use45DegreeGraphicSegments;
1322 
1323  return 0;
1324 }
1325 
1326 
1330 static void updateSegmentFromGeometryMgr( const KIGFX::PREVIEW::TWO_POINT_GEOMETRY_MANAGER& aMgr,
1331  PCB_SHAPE* aGraphic )
1332 {
1333  if( !aMgr.IsReset() )
1334  {
1335  aGraphic->SetStart( (wxPoint) aMgr.GetOrigin() );
1336  aGraphic->SetEnd( (wxPoint) aMgr.GetEnd() );
1337  }
1338 }
1339 
1340 
1341 bool DRAWING_TOOL::drawSegment( const std::string& aTool, PCB_SHAPE** aGraphic,
1342  OPT<VECTOR2D> aStartingPoint )
1343 {
1344  PCB_SHAPE_TYPE shape = ( *aGraphic )->GetShape();
1345  // Only three shapes are currently supported
1346  wxASSERT( shape == PCB_SHAPE_TYPE::SEGMENT || shape == PCB_SHAPE_TYPE::CIRCLE
1347  || shape == PCB_SHAPE_TYPE::RECT );
1348 
1349  EDA_UNITS userUnits = m_frame->GetUserUnits();
1350  PCB_GRID_HELPER grid( m_toolMgr, m_frame->GetMagneticItemsSettings() );
1351  PCB_SHAPE*& graphic = *aGraphic;
1352  PCB_LAYER_ID drawingLayer = m_frame->GetActiveLayer();
1353 
1354  m_lineWidth = getSegmentWidth( drawingLayer );
1355 
1356  // geometric construction manager
1357  KIGFX::PREVIEW::TWO_POINT_GEOMETRY_MANAGER twoPointManager;
1358 
1359  // drawing assistant overlay
1360  // TODO: workaround because PCB_SHAPE_TYPE_T is not visible from commons.
1361  KIGFX::PREVIEW::GEOM_SHAPE geomShape( static_cast<KIGFX::PREVIEW::GEOM_SHAPE>( shape ) );
1362  KIGFX::PREVIEW::TWO_POINT_ASSISTANT twoPointAsst( twoPointManager, userUnits, geomShape );
1363 
1364  // Add a VIEW_GROUP that serves as a preview for the new item
1365  PCB_SELECTION preview;
1366  m_view->Add( &preview );
1367  m_view->Add( &twoPointAsst );
1368 
1369  m_controls->ShowCursor( true );
1370 
1371  bool started = false;
1372  bool cancelled = false;
1373  bool isLocalOriginSet = ( m_frame->GetScreen()->m_LocalOrigin != VECTOR2D( 0, 0 ) );
1374  VECTOR2I cursorPos = m_controls->GetMousePosition();
1375 
1376  auto setCursor =
1377  [&]()
1378  {
1379  m_frame->GetCanvas()->SetCurrentCursor( KICURSOR::PENCIL );
1380  };
1381 
1382  auto cleanup =
1383  [&]()
1384  {
1385  preview.Clear();
1386  m_view->Update( &preview );
1387  delete graphic;
1388  graphic = nullptr;
1389 
1390  if( !isLocalOriginSet )
1391  m_frame->GetScreen()->m_LocalOrigin = VECTOR2D( 0, 0 );
1392  };
1393 
1394  // Prime the pump
1395  m_toolMgr->RunAction( ACTIONS::refreshPreview );
1396 
1397  if( aStartingPoint )
1398  m_toolMgr->RunAction( ACTIONS::cursorClick );
1399 
1400  // Set initial cursor
1401  setCursor();
1402 
1403  // Main loop: keep receiving events
1404  while( TOOL_EVENT* evt = Wait() )
1405  {
1406  setCursor();
1407 
1408  if( started )
1409  m_frame->SetMsgPanel( graphic );
1410 
1411  grid.SetSnap( !evt->Modifier( MD_SHIFT ) );
1412  grid.SetUseGrid( getView()->GetGAL()->GetGridSnapping() && !evt->DisableGridSnapping() );
1413  cursorPos = grid.BestSnapAnchor( m_controls->GetMousePosition(), drawingLayer );
1414  m_controls->ForceCursorPosition( true, cursorPos );
1415 
1416  // 45 degree angle constraint enabled with an option and toggled with Ctrl
1417  bool limit45 = frame()->Settings().m_Use45DegreeGraphicSegments;
1418 
1419  if( evt->Modifier( MD_SHIFT ) )
1420  limit45 = !limit45;
1421 
1422  if( evt->IsCancelInteractive() )
1423  {
1424  cleanup();
1425 
1426  if( !started )
1427  {
1428  // We've handled the cancel event. Don't cancel other tools
1429  evt->SetPassEvent( false );
1430  m_frame->PopTool( aTool );
1431  cancelled = true;
1432  }
1433 
1434  break;
1435  }
1436  else if( evt->IsActivate() )
1437  {
1438  if( evt->IsPointEditor() )
1439  {
1440  // don't exit (the point editor runs in the background)
1441  }
1442  else if( evt->IsMoveTool() )
1443  {
1444  cleanup();
1445  // leave ourselves on the stack so we come back after the move
1446  cancelled = true;
1447  break;
1448  }
1449  else
1450  {
1451  cleanup();
1452  m_frame->PopTool( aTool );
1453  cancelled = true;
1454  break;
1455  }
1456  }
1457  else if( evt->IsAction( &PCB_ACTIONS::layerChanged ) )
1458  {
1459  drawingLayer = m_frame->GetActiveLayer();
1460  m_lineWidth = getSegmentWidth( drawingLayer );
1461 
1462  if( graphic )
1463  {
1464  if( !m_view->IsLayerVisible( drawingLayer ) )
1465  {
1466  m_frame->GetAppearancePanel()->SetLayerVisible( drawingLayer, true );
1467  m_frame->GetCanvas()->Refresh();
1468  }
1469 
1470  graphic->SetLayer( drawingLayer );
1471  graphic->SetWidth( m_lineWidth );
1472  m_view->Update( &preview );
1473  frame()->SetMsgPanel( graphic );
1474  }
1475  else
1476  {
1477  evt->SetPassEvent();
1478  }
1479  }
1480  else if( evt->IsAction( &PCB_ACTIONS::properties ) )
1481  {
1482  if( started )
1483  {
1484  frame()->OnEditItemRequest( graphic );
1485  m_view->Update( &preview );
1486  frame()->SetMsgPanel( graphic );
1487  break;
1488  }
1489  else
1490  {
1491  evt->SetPassEvent();
1492  }
1493  }
1494  else if( evt->IsClick( BUT_RIGHT ) )
1495  {
1496  m_menu.ShowContextMenu( selection() );
1497  }
1498  else if( evt->IsClick( BUT_LEFT ) || evt->IsDblClick( BUT_LEFT ) )
1499  {
1500  if( !started )
1501  {
1502  m_toolMgr->RunAction( PCB_ACTIONS::selectionClear, true );
1503 
1504  if( aStartingPoint )
1505  {
1506  cursorPos = aStartingPoint.get();
1507  aStartingPoint = NULLOPT;
1508  }
1509 
1510  m_lineWidth = getSegmentWidth( drawingLayer );
1511 
1512  // Init the new item attributes
1513  graphic->SetShape( static_cast<PCB_SHAPE_TYPE>( shape ) );
1514  graphic->SetFilled( false );
1515  graphic->SetWidth( m_lineWidth );
1516  graphic->SetLayer( drawingLayer );
1517  grid.SetSkipPoint( cursorPos );
1518 
1519  twoPointManager.SetOrigin( (wxPoint) cursorPos );
1520  twoPointManager.SetEnd( (wxPoint) cursorPos );
1521 
1522  if( !isLocalOriginSet )
1523  m_frame->GetScreen()->m_LocalOrigin = cursorPos;
1524 
1525  preview.Add( graphic );
1526  frame()->SetMsgPanel( graphic );
1527  m_controls->SetAutoPan( true );
1528  m_controls->CaptureCursor( true );
1529 
1530  if( !m_view->IsLayerVisible( drawingLayer ) )
1531  {
1532  m_frame->GetAppearancePanel()->SetLayerVisible( drawingLayer, true );
1533  m_frame->GetCanvas()->Refresh();
1534  }
1535 
1536  updateSegmentFromGeometryMgr( twoPointManager, graphic );
1537 
1538  started = true;
1539  }
1540  else if( shape == PCB_SHAPE_TYPE::CIRCLE )
1541  {
1542  // No clever logic if drawing a circle
1543  preview.Clear();
1544  twoPointManager.Reset();
1545  break;
1546  }
1547  else
1548  {
1549  PCB_SHAPE* snapItem = dyn_cast<PCB_SHAPE*>( grid.GetSnapped() );
1550 
1551  if( twoPointManager.GetOrigin() == twoPointManager.GetEnd()
1552  || ( evt->IsDblClick( BUT_LEFT ) && shape == PCB_SHAPE_TYPE::SEGMENT )
1553  || snapItem )
1554  // User has clicked twice in the same spot
1555  // or clicked on the end of an existing segment (closing a path)
1556  {
1557  BOARD_COMMIT commit( m_frame );
1558 
1559  // If the user clicks on an existing snap point from a drawsegment
1560  // we finish the segment as they are likely closing a path
1561  if( snapItem
1562  && ( shape == PCB_SHAPE_TYPE::RECT || graphic->GetLength() > 0.0 ) )
1563  {
1564  commit.Add( graphic );
1565  commit.Push( _( "Draw a line segment" ) );
1566  m_toolMgr->RunAction( PCB_ACTIONS::selectItem, true, graphic );
1567  }
1568  else
1569  {
1570  delete graphic;
1571  }
1572 
1573  graphic = nullptr;
1574  }
1575 
1576  preview.Clear();
1577  twoPointManager.Reset();
1578  break;
1579  }
1580 
1581  twoPointManager.SetEnd( cursorPos );
1582  }
1583  else if( evt->IsMotion() )
1584  {
1585  // 45 degree lines
1586  if( started
1587  && ( ( limit45 && shape == PCB_SHAPE_TYPE::SEGMENT )
1588  || ( evt->Modifier( MD_SHIFT ) && shape == PCB_SHAPE_TYPE::RECT ) ) )
1589  {
1590  const VECTOR2I lineVector( cursorPos - VECTOR2I( twoPointManager.GetOrigin() ) );
1591 
1592  // get a restricted 45/H/V line from the last fixed point to the cursor
1593  auto newEnd = GetVectorSnapped45( lineVector, ( shape == PCB_SHAPE_TYPE::RECT ) );
1594  m_controls->ForceCursorPosition( true, VECTOR2I( twoPointManager.GetEnd() ) );
1595  twoPointManager.SetEnd( twoPointManager.GetOrigin() + (wxPoint) newEnd );
1596  twoPointManager.SetAngleSnap( true );
1597  }
1598  else
1599  {
1600  twoPointManager.SetEnd( (wxPoint) cursorPos );
1601  twoPointManager.SetAngleSnap( false );
1602  }
1603 
1604  updateSegmentFromGeometryMgr( twoPointManager, graphic );
1605  m_view->Update( &preview );
1606  m_view->Update( &twoPointAsst );
1607  }
1608  else if( evt->IsAction( &PCB_ACTIONS::incWidth ) )
1609  {
1610  m_lineWidth += WIDTH_STEP;
1611  graphic->SetWidth( m_lineWidth );
1612  m_view->Update( &preview );
1613  frame()->SetMsgPanel( graphic );
1614  }
1615  else if( evt->IsAction( &PCB_ACTIONS::decWidth ) && ( m_lineWidth > WIDTH_STEP ) )
1616  {
1617  m_lineWidth -= WIDTH_STEP;
1618  graphic->SetWidth( m_lineWidth );
1619  m_view->Update( &preview );
1620  frame()->SetMsgPanel( graphic );
1621  }
1622  else if( evt->IsAction( &ACTIONS::resetLocalCoords ) )
1623  {
1624  isLocalOriginSet = true;
1625  evt->SetPassEvent();
1626  }
1627  else if( evt->IsAction( &ACTIONS::updateUnits ) )
1628  {
1629  if( frame()->GetUserUnits() != userUnits )
1630  {
1631  userUnits = frame()->GetUserUnits();
1632  twoPointAsst.SetUnits( userUnits );
1633  m_view->Update( &twoPointAsst );
1634  }
1635  evt->SetPassEvent();
1636  }
1637  else
1638  {
1639  evt->SetPassEvent();
1640  }
1641  }
1642 
1643  if( !isLocalOriginSet ) // reset the relative coordinate if it was not set before
1644  m_frame->GetScreen()->m_LocalOrigin = VECTOR2D( 0, 0 );
1645 
1646  m_view->Remove( &twoPointAsst );
1647  m_view->Remove( &preview );
1648  m_frame->SetMsgPanel( board() );
1649 
1650  m_frame->GetCanvas()->SetCurrentCursor( KICURSOR::ARROW );
1651  m_controls->SetAutoPan( false );
1652  m_controls->CaptureCursor( false );
1653  m_controls->ForceCursorPosition( false );
1654 
1655  return !cancelled;
1656 }
1657 
1658 
1663 static void updateArcFromConstructionMgr( const KIGFX::PREVIEW::ARC_GEOM_MANAGER& aMgr,
1664  PCB_SHAPE& aArc )
1665 {
1666  auto vec = aMgr.GetOrigin();
1667 
1668  aArc.SetCenter( { vec.x, vec.y } );
1669 
1670  vec = aMgr.GetStartRadiusEnd();
1671  aArc.SetArcStart( { vec.x, vec.y } );
1672 
1673  aArc.SetAngle( RAD2DECIDEG( -aMgr.GetSubtended() ) );
1674 
1675  vec = aMgr.GetEndRadiusEnd();
1676  aArc.SetArcEnd( { vec.x, vec.y } );
1677 }
1678 
1679 
1680 bool DRAWING_TOOL::drawArc( const std::string& aTool, PCB_SHAPE** aGraphic, bool aImmediateMode )
1681 {
1682  PCB_SHAPE*& graphic = *aGraphic;
1683  PCB_LAYER_ID drawingLayer = m_frame->GetActiveLayer();
1684 
1685  m_lineWidth = getSegmentWidth( drawingLayer );
1686 
1687  // Arc geometric construction manager
1688  KIGFX::PREVIEW::ARC_GEOM_MANAGER arcManager;
1689 
1690  // Arc drawing assistant overlay
1691  KIGFX::PREVIEW::ARC_ASSISTANT arcAsst( arcManager, m_frame->GetUserUnits() );
1692 
1693  // Add a VIEW_GROUP that serves as a preview for the new item
1694  PCB_SELECTION preview;
1695  m_view->Add( &preview );
1696  m_view->Add( &arcAsst );
1697  PCB_GRID_HELPER grid( m_toolMgr, m_frame->GetMagneticItemsSettings() );
1698 
1699  m_controls->ShowCursor( true );
1700 
1701  bool firstPoint = false;
1702  bool cancelled = false;
1703 
1704  // Set initial cursor
1705  auto setCursor =
1706  [&]()
1707  {
1708  m_frame->GetCanvas()->SetCurrentCursor( KICURSOR::PENCIL );
1709  };
1710 
1711  auto cleanup =
1712  [&] ()
1713  {
1714  preview.Clear();
1715  delete *aGraphic;
1716  *aGraphic = nullptr;
1717  };
1718 
1719  // Prime the pump
1720  m_toolMgr->RunAction( ACTIONS::refreshPreview );
1721 
1722  if( aImmediateMode )
1723  m_toolMgr->RunAction( ACTIONS::cursorClick );
1724 
1725  setCursor();
1726 
1727  // Main loop: keep receiving events
1728  while( TOOL_EVENT* evt = Wait() )
1729  {
1730  if( firstPoint )
1731  m_frame->SetMsgPanel( graphic );
1732 
1733  setCursor();
1734 
1735  graphic->SetLayer( drawingLayer );
1736 
1737  grid.SetSnap( !evt->Modifier( MD_SHIFT ) );
1738  grid.SetUseGrid( getView()->GetGAL()->GetGridSnapping() && !evt->DisableGridSnapping() );
1739  VECTOR2I cursorPos = grid.BestSnapAnchor( m_controls->GetMousePosition(), graphic );
1740  m_controls->ForceCursorPosition( true, cursorPos );
1741 
1742  if( evt->IsCancelInteractive() )
1743  {
1744  cleanup();
1745 
1746  if( !firstPoint )
1747  {
1748  // We've handled the cancel event. Don't cancel other tools
1749  evt->SetPassEvent( false );
1750  m_frame->PopTool( aTool );
1751  cancelled = true;
1752  }
1753 
1754  break;
1755  }
1756  else if( evt->IsActivate() )
1757  {
1758  if( evt->IsPointEditor() )
1759  {
1760  // don't exit (the point editor runs in the background)
1761  }
1762  else if( evt->IsMoveTool() )
1763  {
1764  cleanup();
1765  // leave ourselves on the stack so we come back after the move
1766  cancelled = true;
1767  break;
1768  }
1769  else
1770  {
1771  cleanup();
1772  m_frame->PopTool( aTool );
1773  cancelled = true;
1774  break;
1775  }
1776  }
1777  else if( evt->IsClick( BUT_LEFT ) )
1778  {
1779  if( !firstPoint )
1780  {
1781  m_toolMgr->RunAction( PCB_ACTIONS::selectionClear, true );
1782 
1783  m_controls->SetAutoPan( true );
1784  m_controls->CaptureCursor( true );
1785 
1786  drawingLayer = m_frame->GetActiveLayer();
1787  m_lineWidth = getSegmentWidth( drawingLayer );
1788 
1789  // Init the new item attributes
1790  // (non-geometric, those are handled by the manager)
1791  graphic->SetShape( PCB_SHAPE_TYPE::ARC );
1792  graphic->SetWidth( m_lineWidth );
1793 
1794  if( !m_view->IsLayerVisible( drawingLayer ) )
1795  {
1796  m_frame->GetAppearancePanel()->SetLayerVisible( drawingLayer, true );
1797  m_frame->GetCanvas()->Refresh();
1798  }
1799 
1800  preview.Add( graphic );
1801  frame()->SetMsgPanel( graphic );
1802  firstPoint = true;
1803  }
1804 
1805  arcManager.AddPoint( cursorPos, true );
1806  }
1807  else if( evt->IsAction( &PCB_ACTIONS::deleteLastPoint ) )
1808  {
1809  arcManager.RemoveLastPoint();
1810  }
1811  else if( evt->IsMotion() )
1812  {
1813  // set angle snap
1814  arcManager.SetAngleSnap( evt->Modifier( MD_SHIFT ) );
1815 
1816  // update, but don't step the manager state
1817  arcManager.AddPoint( cursorPos, false );
1818  }
1819  else if( evt->IsAction( &PCB_ACTIONS::layerChanged ) )
1820  {
1821  drawingLayer = m_frame->GetActiveLayer();
1822  m_lineWidth = getSegmentWidth( drawingLayer );
1823 
1824  if( graphic )
1825  {
1826  if( !m_view->IsLayerVisible( drawingLayer ) )
1827  {
1828  m_frame->GetAppearancePanel()->SetLayerVisible( drawingLayer, true );
1829  m_frame->GetCanvas()->Refresh();
1830  }
1831 
1832  graphic->SetLayer( drawingLayer );
1833  graphic->SetWidth( m_lineWidth );
1834  m_view->Update( &preview );
1835  frame()->SetMsgPanel( graphic );
1836  }
1837  else
1838  {
1839  evt->SetPassEvent();
1840  }
1841  }
1842  else if( evt->IsAction( &PCB_ACTIONS::properties ) )
1843  {
1844  if( arcManager.GetStep() == KIGFX::PREVIEW::ARC_GEOM_MANAGER::SET_START )
1845  {
1846  graphic->SetAngle( 900, true );
1847  frame()->OnEditItemRequest( graphic );
1848  m_view->Update( &preview );
1849  frame()->SetMsgPanel( graphic );
1850  break;
1851  }
1852  else if( arcManager.GetStep() == KIGFX::PREVIEW::ARC_GEOM_MANAGER::SET_ANGLE )
1853  {
1854  frame()->OnEditItemRequest( graphic );
1855  m_view->Update( &preview );
1856  frame()->SetMsgPanel( graphic );
1857  break;
1858  }
1859  else
1860  {
1861  evt->SetPassEvent();
1862  }
1863  }
1864  else if( evt->IsClick( BUT_RIGHT ) )
1865  {
1866  m_menu.ShowContextMenu( selection() );
1867  }
1868  else if( evt->IsAction( &PCB_ACTIONS::incWidth ) )
1869  {
1870  m_lineWidth += WIDTH_STEP;
1871  graphic->SetWidth( m_lineWidth );
1872  m_view->Update( &preview );
1873  frame()->SetMsgPanel( graphic );
1874  }
1875  else if( evt->IsAction( &PCB_ACTIONS::decWidth ) && m_lineWidth > WIDTH_STEP )
1876  {
1877  m_lineWidth -= WIDTH_STEP;
1878  graphic->SetWidth( m_lineWidth );
1879  m_view->Update( &preview );
1880  frame()->SetMsgPanel( graphic );
1881  }
1882  else if( evt->IsAction( &PCB_ACTIONS::arcPosture ) )
1883  {
1884  arcManager.ToggleClockwise();
1885  }
1886  else if( evt->IsAction( &ACTIONS::updateUnits ) )
1887  {
1888  arcAsst.SetUnits( frame()->GetUserUnits() );
1889  m_view->Update( &arcAsst );
1890  evt->SetPassEvent();
1891  }
1892  else
1893  {
1894  evt->SetPassEvent();
1895  }
1896 
1897  if( arcManager.IsComplete() )
1898  {
1899  break;
1900  }
1901  else if( arcManager.HasGeometryChanged() )
1902  {
1903  updateArcFromConstructionMgr( arcManager, *graphic );
1904  m_view->Update( &preview );
1905  m_view->Update( &arcAsst );
1906 
1907  if( firstPoint )
1908  frame()->SetMsgPanel( graphic );
1909  else
1910  frame()->SetMsgPanel( board() );
1911  }
1912  }
1913 
1914  preview.Remove( graphic );
1915  m_view->Remove( &arcAsst );
1916  m_view->Remove( &preview );
1917  m_frame->SetMsgPanel( board() );
1918 
1919  m_frame->GetCanvas()->SetCurrentCursor( KICURSOR::ARROW );
1920  m_controls->SetAutoPan( false );
1921  m_controls->CaptureCursor( false );
1922  m_controls->ForceCursorPosition( false );
1923 
1924  return !cancelled;
1925 }
1926 
1927 
1928 bool DRAWING_TOOL::getSourceZoneForAction( ZONE_MODE aMode, ZONE** aZone )
1929 {
1930  bool clearSelection = false;
1931  *aZone = nullptr;
1932 
1933  // not an action that needs a source zone
1934  if( aMode == ZONE_MODE::ADD || aMode == ZONE_MODE::GRAPHIC_POLYGON )
1935  return true;
1936 
1937  PCB_SELECTION_TOOL* selTool = m_toolMgr->GetTool<PCB_SELECTION_TOOL>();
1938  const PCB_SELECTION& selection = selTool->GetSelection();
1939 
1940  if( selection.Empty() )
1941  {
1942  clearSelection = true;
1943  m_toolMgr->RunAction( PCB_ACTIONS::selectionCursor, true );
1944  }
1945 
1946  // we want a single zone
1947  if( selection.Size() == 1 )
1948  *aZone = dyn_cast<ZONE*>( selection[0] );
1949 
1950  // expected a zone, but didn't get one
1951  if( !*aZone )
1952  {
1953  if( clearSelection )
1954  m_toolMgr->RunAction( PCB_ACTIONS::selectionClear, true );
1955 
1956  return false;
1957  }
1958 
1959  return true;
1960 }
1961 
1962 int DRAWING_TOOL::DrawZone( const TOOL_EVENT& aEvent )
1963 {
1964  if( m_isFootprintEditor && !m_frame->GetModel() )
1965  return 0;
1966 
1967  ZONE_MODE zoneMode = aEvent.Parameter<ZONE_MODE>();
1968  MODE drawMode = MODE::ZONE;
1969 
1970  if( aEvent.IsAction( &PCB_ACTIONS::drawRuleArea ) )
1971  drawMode = MODE::KEEPOUT;
1972 
1973  if( aEvent.IsAction( &PCB_ACTIONS::drawPolygon ) )
1974  drawMode = MODE::GRAPHIC_POLYGON;
1975 
1976  SCOPED_DRAW_MODE scopedDrawMode( m_mode, drawMode );
1977 
1978  // get a source zone, if we need one. We need it for:
1979  // ZONE_MODE::CUTOUT (adding a hole to the source zone)
1980  // ZONE_MODE::SIMILAR (creating a new zone using settings of source zone
1981  ZONE* sourceZone = nullptr;
1982 
1983  if( !getSourceZoneForAction( zoneMode, &sourceZone ) )
1984  return 0;
1985 
1986  // Turn zones on if they are off, so that the created object will be visible after completion
1987  m_frame->SetObjectVisible( LAYER_ZONES );
1988 
1989  ZONE_CREATE_HELPER::PARAMS params;
1990 
1991  params.m_keepout = drawMode == MODE::KEEPOUT;
1992  params.m_mode = zoneMode;
1993  params.m_sourceZone = sourceZone;
1994 
1995  if( zoneMode == ZONE_MODE::SIMILAR )
1996  params.m_layer = sourceZone->GetLayer();
1997  else
1998  params.m_layer = m_frame->GetActiveLayer();
1999 
2000  ZONE_CREATE_HELPER zoneTool( *this, params );
2001 
2002  // the geometry manager which handles the zone geometry, and
2003  // hands the calculated points over to the zone creator tool
2004  POLYGON_GEOM_MANAGER polyGeomMgr( zoneTool );
2005  bool constrainAngle = false;
2006 
2007  std::string tool = aEvent.GetCommandStr().get();
2008  m_frame->PushTool( tool );
2009  Activate(); // register for events
2010 
2011  m_controls->ShowCursor( true );
2012 
2013  bool started = false;
2014  PCB_GRID_HELPER grid( m_toolMgr, m_frame->GetMagneticItemsSettings() );
2015  STATUS_TEXT_POPUP status( m_frame );
2016  status.SetTextColor( wxColour( 255, 0, 0 ) );
2017  status.SetText( _( "Self-intersecting polygons are not allowed" ) );
2018 
2019  auto setCursor =
2020  [&]()
2021  {
2022  m_frame->GetCanvas()->SetCurrentCursor( KICURSOR::PENCIL );
2023  };
2024 
2025  auto cleanup =
2026  [&] ()
2027  {
2028  polyGeomMgr.Reset();
2029  started = false;
2030  grid.ClearSkipPoint();
2031  m_controls->SetAutoPan( false );
2032  m_controls->CaptureCursor( false );
2033  };
2034 
2035  // Prime the pump
2036  if( aEvent.HasPosition() )
2037  m_toolMgr->PrimeTool( aEvent.Position() );
2038 
2039  // Set initial cursor
2040  setCursor();
2041 
2042  // Main loop: keep receiving events
2043  while( TOOL_EVENT* evt = Wait() )
2044  {
2045  setCursor();
2046 
2047  LSET layers( m_frame->GetActiveLayer() );
2048  grid.SetSnap( !evt->Modifier( MD_SHIFT ) );
2049  grid.SetUseGrid( getView()->GetGAL()->GetGridSnapping() && !evt->DisableGridSnapping() );
2050 
2051  VECTOR2I cursorPos = evt->HasPosition() ? evt->Position() : m_controls->GetMousePosition();
2052  cursorPos = grid.BestSnapAnchor( cursorPos, layers );
2053 
2054  m_controls->ForceCursorPosition( true, cursorPos );
2055 
2056  if( ( sourceZone && sourceZone->GetHV45() ) || constrainAngle || evt->Modifier( MD_SHIFT ) )
2057  polyGeomMgr.SetLeaderMode( POLYGON_GEOM_MANAGER::LEADER_MODE::DEG45 );
2058  else
2059  polyGeomMgr.SetLeaderMode( POLYGON_GEOM_MANAGER::LEADER_MODE::DIRECT );
2060 
2061  if( evt->IsCancelInteractive() )
2062  {
2063  if( polyGeomMgr.IsPolygonInProgress() )
2064  {
2065  cleanup();
2066  }
2067  else
2068  {
2069  // We've handled the cancel event. Don't cancel other tools
2070  evt->SetPassEvent( false );
2071  m_frame->PopTool( tool );
2072  break;
2073  }
2074  }
2075  else if( evt->IsActivate() )
2076  {
2077  if( polyGeomMgr.IsPolygonInProgress() )
2078  cleanup();
2079 
2080  if( evt->IsPointEditor() )
2081  {
2082  // don't exit (the point editor runs in the background)
2083  }
2084  else if( evt->IsMoveTool() )
2085  {
2086  // leave ourselves on the stack so we come back after the move
2087  break;
2088  }
2089  else
2090  {
2091  m_frame->PopTool( tool );
2092  break;
2093  }
2094  }
2095  else if( evt->IsAction( &PCB_ACTIONS::layerChanged ) )
2096  {
2097  if( zoneMode != ZONE_MODE::SIMILAR )
2098  params.m_layer = frame()->GetActiveLayer();
2099 
2100  if( !m_view->IsLayerVisible( params.m_layer ) )
2101  {
2102  m_frame->GetAppearancePanel()->SetLayerVisible( params.m_layer, true );
2103  m_frame->GetCanvas()->Refresh();
2104  }
2105  }
2106  else if( evt->IsClick( BUT_RIGHT ) )
2107  {
2108  m_menu.ShowContextMenu( selection() );
2109  }
2110  // events that lock in nodes
2111  else if( evt->IsClick( BUT_LEFT )
2112  || evt->IsDblClick( BUT_LEFT )
2113  || evt->IsAction( &PCB_ACTIONS::closeOutline ) )
2114  {
2115  // Check if it is double click / closing line (so we have to finish the zone)
2116  const bool endPolygon = evt->IsDblClick( BUT_LEFT )
2117  || evt->IsAction( &PCB_ACTIONS::closeOutline )
2118  || polyGeomMgr.NewPointClosesOutline( cursorPos );
2119 
2120  if( endPolygon )
2121  {
2122  polyGeomMgr.SetFinished();
2123  polyGeomMgr.Reset();
2124 
2125  started = false;
2126  m_controls->SetAutoPan( false );
2127  m_controls->CaptureCursor( false );
2128  }
2129  // adding a corner
2130  else if( polyGeomMgr.AddPoint( cursorPos ) )
2131  {
2132  if( !started )
2133  {
2134  started = true;
2135 
2136  POLYGON_GEOM_MANAGER::LEADER_MODE leaderMode = polyGeomMgr.GetLeaderMode();
2137  constrainAngle = ( leaderMode == POLYGON_GEOM_MANAGER::LEADER_MODE::DEG45 );
2138 
2139  m_controls->SetAutoPan( true );
2140  m_controls->CaptureCursor( true );
2141 
2142  if( !m_view->IsLayerVisible( params.m_layer ) )
2143  {
2144  m_frame->GetAppearancePanel()->SetLayerVisible( params.m_layer, true );
2145  m_frame->GetCanvas()->Refresh();
2146  }
2147  }
2148  }
2149  }
2150  else if( evt->IsAction( &PCB_ACTIONS::deleteLastPoint ) )
2151  {
2152  polyGeomMgr.DeleteLastCorner();
2153 
2154  if( !polyGeomMgr.IsPolygonInProgress() )
2155  {
2156  // report finished as an empty shape
2157  polyGeomMgr.SetFinished();
2158 
2159  // start again
2160  started = false;
2161  m_controls->SetAutoPan( false );
2162  m_controls->CaptureCursor( false );
2163  }
2164  }
2165  else if( polyGeomMgr.IsPolygonInProgress()
2166  && ( evt->IsMotion() || evt->IsDrag( BUT_LEFT ) ) )
2167  {
2168  polyGeomMgr.SetCursorPosition( cursorPos );
2169 
2170  if( polyGeomMgr.IsSelfIntersecting( true ) )
2171  {
2172  wxPoint p = wxGetMousePosition() + wxPoint( 20, 20 );
2173  status.Move( p );
2174  status.PopupFor( 1500 );
2175  }
2176  else
2177  {
2178  status.Hide();
2179  }
2180  }
2181  else if( evt->IsAction( &PCB_ACTIONS::properties ) )
2182  {
2183  if( started )
2184  {
2185  frame()->OnEditItemRequest( zoneTool.GetZone() );
2186  zoneTool.OnGeometryChange( polyGeomMgr );
2187  frame()->SetMsgPanel( zoneTool.GetZone() );
2188  }
2189  else
2190  {
2191  evt->SetPassEvent();
2192  }
2193  }
2194  /*else if( evt->IsAction( &ACTIONS::updateUnits ) )
2195  {
2196  // If we ever have an assistant here that reports dimensions, we'll want to
2197  // update its units here....
2198  // zoneAsst.SetUnits( frame()->GetUserUnits() );
2199  // m_view->Update( &zoneAsst );
2200  evt->SetPassEvent();
2201  }*/
2202  else
2203  {
2204  evt->SetPassEvent();
2205  }
2206 
2207  } // end while
2208 
2209  m_frame->GetCanvas()->SetCurrentCursor( KICURSOR::ARROW );
2210  m_controls->ForceCursorPosition( false );
2211  controls()->SetAutoPan( false );
2212  m_controls->CaptureCursor( false );
2213  return 0;
2214 }
2215 
2216 
2217 int DRAWING_TOOL::DrawVia( const TOOL_EVENT& aEvent )
2218 {
2219  struct VIA_PLACER : public INTERACTIVE_PLACER_BASE
2220  {
2221  PCB_BASE_EDIT_FRAME* m_frame;
2222  PCB_GRID_HELPER m_gridHelper;
2223  std::shared_ptr<DRC_ENGINE> m_drcEngine;
2224  int m_drcEpsilon;
2225  int m_worstClearance;
2226  bool m_allowDRCViolations;
2227  bool m_flaggedDRC;
2228 
2229  VIA_PLACER( PCB_BASE_EDIT_FRAME* aFrame ) :
2230  m_frame( aFrame ),
2231  m_gridHelper( aFrame->GetToolManager(), aFrame->GetMagneticItemsSettings() ),
2232  m_drcEngine( aFrame->GetBoard()->GetDesignSettings().m_DRCEngine ),
2233  m_drcEpsilon( aFrame->GetBoard()->GetDesignSettings().GetDRCEpsilon() ),
2234  m_worstClearance( 0 ),
2235  m_flaggedDRC( false )
2236  {
2237  ROUTER_TOOL* router = m_frame->GetToolManager()->GetTool<ROUTER_TOOL>();
2238 
2239  m_allowDRCViolations = router->Router()->Settings().AllowDRCViolations();
2240 
2241  try
2242  {
2243  m_drcEngine->InitEngine( aFrame->GetDesignRulesPath() );
2244 
2245  DRC_CONSTRAINT constraint;
2246 
2247  if( m_drcEngine->QueryWorstConstraint( CLEARANCE_CONSTRAINT, constraint ) )
2248  m_worstClearance = constraint.GetValue().Min();
2249 
2250  if( m_drcEngine->QueryWorstConstraint( HOLE_CLEARANCE_CONSTRAINT, constraint ) )
2251  m_worstClearance = std::max( m_worstClearance, constraint.GetValue().Min() );
2252 
2253  for( FOOTPRINT* footprint : aFrame->GetBoard()->Footprints() )
2254  {
2255  for( PAD* pad : footprint->Pads() )
2256  m_worstClearance = std::max( m_worstClearance, pad->GetLocalClearance() );
2257  }
2258  }
2259  catch( PARSE_ERROR& )
2260  {
2261  }
2262  }
2263 
2264  virtual ~VIA_PLACER()
2265  {
2266  }
2267 
2268  PCB_TRACK* findTrack( PCB_VIA* aVia )
2269  {
2270  const LSET lset = aVia->GetLayerSet();
2271  wxPoint position = aVia->GetPosition();
2272  BOX2I bbox = aVia->GetBoundingBox();
2273 
2274  std::vector<KIGFX::VIEW::LAYER_ITEM_PAIR> items;
2275  auto view = m_frame->GetCanvas()->GetView();
2276  std::vector<PCB_TRACK*> possible_tracks;
2277 
2278  view->Query( bbox, items );
2279 
2280  for( auto it : items )
2281  {
2282  BOARD_ITEM* item = static_cast<BOARD_ITEM*>( it.first );
2283 
2284  if( !(item->GetLayerSet() & lset ).any() )
2285  continue;
2286 
2287  if( PCB_TRACK* track = dyn_cast<PCB_TRACK*>( item ) )
2288  {
2289  if( TestSegmentHit( position, track->GetStart(), track->GetEnd(),
2290  ( track->GetWidth() + aVia->GetWidth() ) / 2 ) )
2291  possible_tracks.push_back( track );
2292  }
2293  }
2294 
2295  PCB_TRACK* return_track = nullptr;
2296  int min_d = std::numeric_limits<int>::max();
2297 
2298  for( PCB_TRACK* track : possible_tracks )
2299  {
2300  SEG test( track->GetStart(), track->GetEnd() );
2301  int dist = ( test.NearestPoint( position ) - position ).EuclideanNorm();
2302 
2303  if( dist < min_d )
2304  {
2305  min_d = dist;
2306  return_track = track;
2307  }
2308  }
2309 
2310  return return_track;
2311  }
2312 
2313  bool hasDRCViolation( PCB_VIA* aVia, BOARD_ITEM* aOther )
2314  {
2315  // It would really be better to know what particular nets a nettie should allow,
2316  // but for now it is what it is.
2317  if( DRC_ENGINE::IsNetTie( aOther ) )
2318  return false;
2319 
2320  BOARD_CONNECTED_ITEM* cItem = dynamic_cast<BOARD_CONNECTED_ITEM*>( aOther );
2321 
2322  if( cItem && cItem->GetNetCode() == aVia->GetNetCode() )
2323  return false;
2324 
2325  DRC_CONSTRAINT constraint;
2326  int clearance;
2327 
2328  for( PCB_LAYER_ID layer : aOther->GetLayerSet().Seq() )
2329  {
2330  if( !IsCopperLayer( layer ) )
2331  continue;
2332 
2333  constraint = m_drcEngine->EvalRules( CLEARANCE_CONSTRAINT, aVia, aOther, layer );
2334  clearance = constraint.GetValue().Min();
2335 
2336  if( clearance >= 0 )
2337  {
2338  std::shared_ptr<SHAPE> viaShape = DRC_ENGINE::GetShape( aVia, layer );
2339  std::shared_ptr<SHAPE> otherShape = DRC_ENGINE::GetShape( aOther, layer );
2340 
2341  if( viaShape->Collide( otherShape.get(), clearance - m_drcEpsilon ) )
2342  return true;
2343  }
2344  }
2345 
2346  std::unique_ptr<SHAPE_SEGMENT> holeShape;
2347 
2348  if( aOther->Type() == PCB_VIA_T )
2349  {
2350  PCB_VIA* via = static_cast<PCB_VIA*>( aOther );
2351  wxPoint pos = via->GetPosition();
2352 
2353  holeShape.reset( new SHAPE_SEGMENT( pos, pos, via->GetDrill() ) );
2354  }
2355  else if( aOther->Type() == PCB_PAD_T )
2356  {
2357  PAD* pad = static_cast<PAD*>( aOther );
2358 
2359  if( pad->GetDrillSize().x )
2360  holeShape.reset( new SHAPE_SEGMENT( *pad->GetEffectiveHoleShape() ) );
2361  }
2362 
2363  if( holeShape )
2364  {
2365  constraint = m_drcEngine->EvalRules( HOLE_CLEARANCE_CONSTRAINT, aVia, aOther,
2366  UNDEFINED_LAYER );
2367  clearance = constraint.GetValue().Min();
2368 
2369  if( clearance >= 0 )
2370  {
2371  std::shared_ptr<SHAPE> viaShape = DRC_ENGINE::GetShape( aVia, UNDEFINED_LAYER );
2372 
2373  if( viaShape->Collide( holeShape.get(), clearance - m_drcEpsilon ) )
2374  return true;
2375  }
2376  }
2377 
2378  return false;
2379  }
2380 
2381  bool checkDRCViolation( PCB_VIA* aVia )
2382  {
2383  std::vector<KIGFX::VIEW::LAYER_ITEM_PAIR> items;
2384  std::set<BOARD_ITEM*> checkedItems;
2385  BOX2I bbox = aVia->GetBoundingBox();
2386 
2387  bbox.Inflate( m_worstClearance );
2388  m_frame->GetCanvas()->GetView()->Query( bbox, items );
2389 
2390  for( std::pair<KIGFX::VIEW_ITEM*, int> it : items )
2391  {
2392  BOARD_ITEM* item = dynamic_cast<BOARD_ITEM*>( it.first );
2393 
2394  if( !item )
2395  continue;
2396 
2397  if( item->Type() == PCB_ZONE_T || item->Type() == PCB_FP_ZONE_T )
2398  continue; // stitching vias bind to zones, so ignore them
2399 
2400  if( item->Type() == PCB_FOOTPRINT_T || item->Type() == PCB_GROUP_T )
2401  continue; // check against children, but not against footprint itself
2402 
2403  if( item->Type() == PCB_FP_TEXT_T && !static_cast<FP_TEXT*>( item )->IsVisible() )
2404  continue; // ignore hidden items
2405 
2406  if( checkedItems.count( item ) )
2407  continue;
2408 
2409  if( hasDRCViolation( aVia, item ) )
2410  return true;
2411 
2412  checkedItems.insert( item );
2413  }
2414 
2415  return false;
2416  }
2417 
2418  PAD* findPad( PCB_VIA* aVia )
2419  {
2420  const wxPoint position = aVia->GetPosition();
2421  const LSET lset = aVia->GetLayerSet();
2422 
2423  for( FOOTPRINT* fp : m_board->Footprints() )
2424  {
2425  for(PAD* pad : fp->Pads() )
2426  {
2427  if( pad->HitTest( position ) && ( pad->GetLayerSet() & lset ).any() )
2428  if( pad->GetNetCode() > 0 )
2429  return pad;
2430  }
2431  }
2432 
2433  return nullptr;
2434  }
2435 
2436  int findStitchedZoneNet( PCB_VIA* aVia )
2437  {
2438  const wxPoint position = aVia->GetPosition();
2439  const LSET lset = aVia->GetLayerSet();
2440 
2441  std::vector<ZONE*> foundZones;
2442 
2443  for( ZONE* zone : m_board->Zones() )
2444  {
2445  for( PCB_LAYER_ID layer : LSET( zone->GetLayerSet() & lset ).Seq() )
2446  {
2447  if( zone->HitTestFilledArea( layer, position ) )
2448  foundZones.push_back( zone );
2449  }
2450  }
2451 
2452  std::sort( foundZones.begin(), foundZones.end(),
2453  [] ( const ZONE* a, const ZONE* b )
2454  {
2455  return a->GetLayer() < b->GetLayer();
2456  } );
2457 
2458  // first take the net of the active layer
2459  for( ZONE* z : foundZones )
2460  {
2461  if( m_frame->GetActiveLayer() == z->GetLayer() )
2462  return z->GetNetCode();
2463  }
2464 
2465  // none? take the topmost visible layer
2466  for( ZONE* z : foundZones )
2467  {
2468  if( m_board->IsLayerVisible( z->GetLayer() ) )
2469  return z->GetNetCode();
2470  }
2471 
2472  return -1;
2473  }
2474 
2475  void SnapItem( BOARD_ITEM *aItem ) override
2476  {
2477  // If you place a Via on a track but not on its centerline, the current
2478  // connectivity algorithm will require us to put a kink in the track when
2479  // we break it (so that each of the two segments ends on the via center).
2480  // That's not ideal, and is in fact probably worse than forcing snap in
2481  // this situation.
2482 
2483  m_gridHelper.SetSnap( !( m_modifiers & MD_SHIFT ) );
2484  PCB_VIA* via = static_cast<PCB_VIA*>( aItem );
2485  wxPoint position = via->GetPosition();
2486  PCB_TRACK* track = findTrack( via );
2487 
2488  if( track )
2489  {
2490  SEG trackSeg( track->GetStart(), track->GetEnd() );
2491  VECTOR2I snap = m_gridHelper.AlignToSegment( position, trackSeg );
2492 
2493  aItem->SetPosition( (wxPoint) snap );
2494  }
2495  }
2496 
2497  bool PlaceItem( BOARD_ITEM* aItem, BOARD_COMMIT& aCommit ) override
2498  {
2499  PCB_VIA* via = static_cast<PCB_VIA*>( aItem );
2500  wxPoint viaPos = via->GetPosition();
2501  PCB_TRACK* track = findTrack( via );
2502  PAD * pad = findPad( via );
2503 
2504  if( track )
2505  via->SetNetCode( track->GetNetCode() );
2506  else if( pad )
2507  via->SetNetCode( pad->GetNetCode() );
2508 
2509  if( !m_allowDRCViolations && checkDRCViolation( via ) )
2510  {
2511  m_frame->ShowInfoBarError( _( "Via location violates DRC." ) );
2512  via->SetNetCode( 0 );
2513  m_flaggedDRC = true;
2514  return false;
2515  }
2516  else if( m_flaggedDRC )
2517  {
2518  m_frame->GetInfoBar()->Dismiss();
2519  }
2520 
2521  if( track )
2522  {
2523  if( viaPos != track->GetStart() && viaPos != track->GetEnd() )
2524  {
2525  aCommit.Modify( track );
2526 
2527  PCB_TRACK* newTrack = dynamic_cast<PCB_TRACK*>( track->Clone() );
2528  const_cast<KIID&>( newTrack->m_Uuid ) = KIID();
2529 
2530  track->SetEnd( viaPos );
2531  newTrack->SetStart( viaPos );
2532  aCommit.Add( newTrack );
2533  }
2534  }
2535  else if( !pad )
2536  {
2537  via->SetNetCode( findStitchedZoneNet( via ) );
2538  via->SetIsFree();
2539  }
2540 
2541  aCommit.Add( aItem );
2542  return true;
2543  }
2544 
2545  std::unique_ptr<BOARD_ITEM> CreateItem() override
2546  {
2547  BOARD_DESIGN_SETTINGS& bds = m_board->GetDesignSettings();
2548  PCB_VIA* via = new PCB_VIA( m_board );
2549 
2550  via->SetNetCode( 0 );
2551  via->SetViaType( bds.m_CurrentViaType );
2552 
2553  // for microvias, the size and hole will be changed later.
2554  via->SetWidth( bds.GetCurrentViaSize() );
2555  via->SetDrill( bds.GetCurrentViaDrill() );
2556 
2557  // Usual via is from copper to component.
2558  // layer pair is B_Cu and F_Cu.
2559  via->SetLayerPair( B_Cu, F_Cu );
2560 
2561  PCB_LAYER_ID first_layer = m_frame->GetActiveLayer();
2562  PCB_LAYER_ID last_layer;
2563 
2564  // prepare switch to new active layer:
2565  if( first_layer != m_frame->GetScreen()->m_Route_Layer_TOP )
2566  last_layer = m_frame->GetScreen()->m_Route_Layer_TOP;
2567  else
2568  last_layer = m_frame->GetScreen()->m_Route_Layer_BOTTOM;
2569 
2570  // Adjust the actual via layer pair
2571  switch( via->GetViaType() )
2572  {
2573  case VIATYPE::BLIND_BURIED:
2574  via->SetLayerPair( first_layer, last_layer );
2575  break;
2576 
2577  case VIATYPE::MICROVIA: // from external to the near neighbor inner layer
2578  {
2579  PCB_LAYER_ID last_inner_layer =
2580  ToLAYER_ID( ( m_board->GetCopperLayerCount() - 2 ) );
2581 
2582  if( first_layer == B_Cu )
2583  last_layer = last_inner_layer;
2584  else if( first_layer == F_Cu )
2585  last_layer = In1_Cu;
2586  else if( first_layer == last_inner_layer )
2587  last_layer = B_Cu;
2588  else if( first_layer == In1_Cu )
2589  last_layer = F_Cu;
2590 
2591  // else error: will be removed later
2592  via->SetLayerPair( first_layer, last_layer );
2593 
2594  // Update diameter and hole size, which where set previously for normal vias
2595  NETCLASS* netClass = via->GetNetClass();
2596 
2597  via->SetWidth( netClass->GetuViaDiameter() );
2598  via->SetDrill( netClass->GetuViaDrill() );
2599  }
2600  break;
2601 
2602  default:
2603  break;
2604  }
2605 
2606  return std::unique_ptr<BOARD_ITEM>( via );
2607  }
2608  };
2609 
2610  VIA_PLACER placer( frame() );
2611 
2612  SCOPED_DRAW_MODE scopedDrawMode( m_mode, MODE::VIA );
2613 
2614  doInteractiveItemPlacement( aEvent.GetCommandStr().get(), &placer, _( "Place via" ),
2615  IPO_REPEAT | IPO_SINGLE_CLICK );
2616 
2617  return 0;
2618 }
2619 
2620 
2621 int DRAWING_TOOL::getSegmentWidth( PCB_LAYER_ID aLayer ) const
2622 {
2623  assert( m_board );
2624  return m_board->GetDesignSettings().GetLineThickness( aLayer );
2625 }
2626 
2627 
2628 const unsigned int DRAWING_TOOL::WIDTH_STEP = Millimeter2iu( 0.1 );
2629 
2630 
2631 void DRAWING_TOOL::setTransitions()
2632 {
2633 
2634  Go( &DRAWING_TOOL::PlaceStackup, PCB_ACTIONS::placeStackup.MakeEvent() );
2635  Go( &DRAWING_TOOL::PlaceCharacteristics, PCB_ACTIONS::placeCharacteristics.MakeEvent() );
2636  Go( &DRAWING_TOOL::DrawLine, PCB_ACTIONS::drawLine.MakeEvent() );
2637  Go( &DRAWING_TOOL::DrawZone, PCB_ACTIONS::drawPolygon.MakeEvent() );
2638  Go( &DRAWING_TOOL::DrawRectangle, PCB_ACTIONS::drawRectangle.MakeEvent() );
2639  Go( &DRAWING_TOOL::DrawCircle, PCB_ACTIONS::drawCircle.MakeEvent() );
2640  Go( &DRAWING_TOOL::DrawArc, PCB_ACTIONS::drawArc.MakeEvent() );
2641  Go( &DRAWING_TOOL::DrawDimension, PCB_ACTIONS::drawAlignedDimension.MakeEvent() );
2642  Go( &DRAWING_TOOL::DrawDimension, PCB_ACTIONS::drawOrthogonalDimension.MakeEvent() );
2643  Go( &DRAWING_TOOL::DrawDimension, PCB_ACTIONS::drawCenterDimension.MakeEvent() );
2644  Go( &DRAWING_TOOL::DrawDimension, PCB_ACTIONS::drawLeader.MakeEvent() );
2645  Go( &DRAWING_TOOL::DrawZone, PCB_ACTIONS::drawZone.MakeEvent() );
2646  Go( &DRAWING_TOOL::DrawZone, PCB_ACTIONS::drawRuleArea.MakeEvent() );
2647  Go( &DRAWING_TOOL::DrawZone, PCB_ACTIONS::drawZoneCutout.MakeEvent() );
2648  Go( &DRAWING_TOOL::DrawZone, PCB_ACTIONS::drawSimilarZone.MakeEvent() );
2649  Go( &DRAWING_TOOL::DrawVia, PCB_ACTIONS::drawVia.MakeEvent() );
2650  Go( &DRAWING_TOOL::PlaceText, PCB_ACTIONS::placeText.MakeEvent() );
2651  Go( &DRAWING_TOOL::PlaceImportedGraphics, PCB_ACTIONS::placeImportedGraphics.MakeEvent() );
2652  Go( &DRAWING_TOOL::SetAnchor, PCB_ACTIONS::setAnchor.MakeEvent() );
2653  Go( &DRAWING_TOOL::ToggleLine45degMode, PCB_ACTIONS::toggleLine45degMode.MakeEvent() );
2654 }
EDA_TEXT::SetMirrored
void SetMirrored(bool isMirrored)
Definition: eda_text.h:195
EuclideanNorm
double EuclideanNorm(const wxPoint &vector)
Euclidean norm of a 2D vector.
Definition: trigo.h:148
VIA_SIZE_MENU::eventHandler
OPT_TOOL_EVENT eventHandler(const wxMenuEvent &aEvent) override
Event handler stub.
Definition: drawing_tool.cpp:122
PCB_ACTIONS::selectItems
static TOOL_ACTION selectItems
Select a list of items (specified as the event parameter)
Definition: pcb_actions.h:66
FP_SHAPE
Definition: fp_shape.h:39
BUT_LEFT
Definition: tool_event.h:126
PCB_ACTIONS::selectionClear
static TOOL_ACTION selectionClear
Clear the current selection.
Definition: pcb_actions.h:59
KIGFX::VIEW_CONTROLS::ShowCursor
virtual void ShowCursor(bool aEnabled)
Enable or disables display of cursor.
Definition: view_controls.cpp:34
PCB_DIM_ALIGNED::GetAngle
double GetAngle() const
Return the angle of the crossbar.
Definition: pcb_dimension.h:389
INTERACTIVE_PLACER_BASE
Definition: pcb_tool_base.h:52
PCB_ACTIONS::drawLine
static TOOL_ACTION drawLine
Definition: pcb_actions.h:142
PCB_ACTIONS::drawCenterDimension
static TOOL_ACTION drawCenterDimension
Definition: pcb_actions.h:149
VIA_DIMENSION
Container to handle a stock of specific vias each with unique diameter and drill sizes in the BOARD c...
Definition: board_design_settings.h:103
MessageTextFromValue
wxString MessageTextFromValue(EDA_UNITS aUnits, int aValue, bool aAddUnitLabel, EDA_DATA_TYPE aType)
Convert a value to a string using double notation.
Definition: base_units.cpp:103
PCB_TRACK::GetBoundingBox
const EDA_RECT GetBoundingBox() const override
Return the orthogonal bounding box of this object for display purposes.
Definition: pcb_track.cpp:240
KIGFX::PREVIEW::ARC_GEOM_MANAGER
Manage the construction of a circular arc though sequential setting of critical points: center,...
Definition: arc_geom_manager.h:41
PCB_BASE_EDIT_FRAME::SetObjectVisible
void SetObjectVisible(GAL_LAYER_ID aLayer, bool aVisible=true)
Definition: pcb_base_edit_frame.cpp:219
COMMIT::Modify
COMMIT & Modify(EDA_ITEM *aItem)
Create an undo entry for an item that has been already modified.
Definition: commit.h:103
DRAWING_TOOL::DrawCircle
int DrawCircle(const TOOL_EVENT &aEvent)
Start interactively drawing a circle.
Definition: drawing_tool.cpp:336
GetVectorSnapped45
VECTOR2< T > GetVectorSnapped45(const VECTOR2< T > &aVec, bool only45=false)
Snap a vector onto the nearest 0, 45 or 90 degree line.
Definition: geometry_utils.h:97
TOOL_INTERACTIVE::m_menu
TOOL_MENU m_menu
The functions below are not yet implemented - their interface may change.
Definition: tool_interactive.h:106
DRAWING_TOOL::MODE::LINE
PCB_ACTIONS::placeImportedGraphics
static TOOL_ACTION placeImportedGraphics
Definition: pcb_actions.h:161
dialog_track_via_size.h
PCB_DIM_ALIGNED_T
class PCB_DIM_ALIGNED, a linear dimension (graphic item)
Definition: typeinfo.h:100
SELECTION::Clear
virtual void Clear() override
Remove all the stored items from the group.
Definition: selection.h:82
BOARD_CONNECTED_ITEM::GetNetCode
int GetNetCode() const
Definition: board_connected_item.cpp:108
DRAWING_TOOL::~DRAWING_TOOL
~DRAWING_TOOL()
Definition: drawing_tool.cpp:165
FP_TEXT
Definition: fp_text.h:39
PCB_BASE_FRAME::GetDesignSettings
virtual BOARD_DESIGN_SETTINGS & GetDesignSettings() const
Returns the BOARD_DESIGN_SETTINGS for the open project.
Definition: pcb_base_frame.cpp:352
PCB_DIM_LEADER_T
class PCB_DIM_LEADER, a leader dimension (graphic item)
Definition: typeinfo.h:101
board_commit.h
KIGFX::PREVIEW::ARC_GEOM_MANAGER::GetEndRadiusEnd
VECTOR2I GetEndRadiusEnd() const
Get the radius of the arc (valid if step >= SET_START)
Definition: arc_geom_manager.cpp:80
EDA_DRAW_PANEL_GAL::SetCurrentCursor
void SetCurrentCursor(KICURSOR aCursor)
Set the current cursor shape for this panel.
Definition: draw_panel_gal.cpp:559
VIATYPE::MICROVIA
BITMAPS::pad
PCB_FP_TEXT_T
class FP_TEXT, text in a footprint
Definition: typeinfo.h:92
HOLE_CLEARANCE_CONSTRAINT
Definition: drc_rule.h:45
PCB_DIM_ALIGNED::SetHeight
void SetHeight(int aHeight)
Set the distance from the feature points to the crossbar line.
Definition: pcb_dimension.h:371
BOARD::Zones
ZONES & Zones()
Definition: board.h:239
ZONE_MODE::SIMILAR
Add a new zone with the same settings as an existing one.
DRAWING_TOOL::DrawVia
int DrawVia(const TOOL_EVENT &aEvent)
Definition: drawing_tool.cpp:2217
TOOL_INTERACTIVE::Wait
TOOL_EVENT * Wait(const TOOL_EVENT_LIST &aEventList=TOOL_EVENT(TC_ANY, TA_ANY))
Suspend execution of the tool until an event specified in aEventList arrives.
Definition: tool_interactive.cpp:57
KIGFX::VIEW_CONTROLS::GetMousePosition
virtual VECTOR2D GetMousePosition(bool aWorldCoordinates=true) const =0
Return the current mouse pointer position.
PCB_TOOL_BASE::board
BOARD * board() const
Definition: pcb_tool_base.h:159
DRAWING_TOOL::DrawZone
int DrawZone(const TOOL_EVENT &aEvent)
Start interactively drawing a zone.
Definition: drawing_tool.cpp:1962
DRAWING_TOOL::m_board
BOARD * m_board
Definition: drawing_tool.h:269
tool_event_utils.h
BOARD_DESIGN_SETTINGS::GetCurrentViaDrill
int GetCurrentViaDrill() const
Definition: board_design_settings.cpp:948
POLYGON_GEOM_MANAGER::LEADER_MODE
LEADER_MODE
The kind of the leader line.
Definition: polygon_geom_manager.h:69
ZONE_CREATE_HELPER::PARAMS::m_sourceZone
ZONE * m_sourceZone
Zone leader mode.
Definition: zone_create_helper.h:60
PCB_ACTIONS::incWidth
static TOOL_ACTION incWidth
Increase width of currently drawn line.
Definition: pcb_actions.h:170
PCB_VIA::GetPosition
wxPoint GetPosition() const override
Definition: pcb_track.h:392
dialog_text_properties.h
PCB_TEXT::SetPosition
virtual void SetPosition(const wxPoint &aPos) override
Definition: pcb_text.h:77
dialog_import_gfx.h
PCB_BASE_EDIT_FRAME::GetDesignRulesPath
wxString GetDesignRulesPath()
Return the absolute path to the design rules file for the currently-loaded board.
Definition: pcb_base_edit_frame.cpp:232
PCB_TRACK::GetEnd
const wxPoint & GetEnd() const
Definition: pcb_track.h:105
GetUserUnits
int GetUserUnits()
Returns the currently selected user unit value for the interface.
Definition: pcbnew_scripting_helpers.cpp:336
PCB_TRACK::Clone
virtual EDA_ITEM * Clone() const override
Create a duplicate of this item with linked list members set to NULL.
Definition: pcb_track.cpp:57
PCB_ACTIONS::drawSimilarZone
static TOOL_ACTION drawSimilarZone
Definition: pcb_actions.h:156
IS_NEW
#define IS_NEW
New item, just created.
Definition: eda_item_flags.h:41
BOARD_ITEM::SetLayer
virtual void SetLayer(PCB_LAYER_ID aLayer)
Set the layer this item is on.
Definition: board_item.h:192
DIALOG_IMPORT_GFX::ShouldGroupItems
bool ShouldGroupItems()
Definition: dialog_import_gfx.h:62
ACTION_MENU
Defines the structure of a menu based on ACTIONs.
Definition: action_menu.h:48
confirm.h
This file is part of the common library.
EDA_ITEM::SetPosition
virtual void SetPosition(const wxPoint &aPos)
Definition: eda_item.h:253
BOARD_ITEM
A base class for any item which can be embedded within the BOARD container class, and therefore insta...
Definition: board_item.h:80
DRAWING_TOOL::DRAWING_TOOL
DRAWING_TOOL()
Definition: drawing_tool.cpp:153
BOARD_COMMIT
Definition: board_commit.h:37
SELECTION::Add
virtual void Add(EDA_ITEM *aItem)
Definition: selection.cpp:31
PCB_ACTIONS::drawArc
static TOOL_ACTION drawArc
Definition: pcb_actions.h:146
PCB_GROUP_T
class PCB_GROUP, a set of BOARD_ITEMs
Definition: typeinfo.h:108
ACTION_MENU::SetIcon
void SetIcon(BITMAPS aIcon)
Assign an icon for the entry.
Definition: action_menu.cpp:73
DRAWING_TOOL::DrawLine
int DrawLine(const TOOL_EVENT &aEvent)
Start interactively drawing a line.
Definition: drawing_tool.cpp:244
DRC_CONSTRAINT
Definition: drc_rule.h:104
ZONE_MODE::GRAPHIC_POLYGON
DRC_ENGINE::GetShape
static std::shared_ptr< SHAPE > GetShape(BOARD_ITEM *aItem, PCB_LAYER_ID aLayer)
Definition: drc_engine.cpp:1287
PCB_TRACK::SetEnd
void SetEnd(const wxPoint &aEnd)
Definition: pcb_track.h:104
COMMIT::Add
COMMIT & Add(EDA_ITEM *aItem)
Notify observers that aItem has been added.
Definition: commit.h:78
KIGFX::PREVIEW::TWO_POINT_ASSISTANT
Represents an assistant draw when interactively drawing a line or circle on a canvas.
Definition: two_point_assistant.h:50
PCB_GROUP
A set of BOARD_ITEMs (i.e., without duplicates).
Definition: pcb_group.h:50
PCB_DIMENSION_BASE::Text
PCB_TEXT & Text()
Definition: pcb_dimension.h:211
TOOL_INTERACTIVE::RunMainStack
void RunMainStack(std::function< void()> aFunc)
Call a function using the main stack.
Definition: tool_interactive.cpp:87
PCB_TOOL_BASE
Definition: pcb_tool_base.h:70
BITMAPS::ortho
updateArcFromConstructionMgr
static void updateArcFromConstructionMgr(const KIGFX::PREVIEW::ARC_GEOM_MANAGER &aMgr, PCB_SHAPE &aArc)
Update an arc PCB_SHAPE from the current state of an Arc Geometry Manager.
Definition: drawing_tool.cpp:1663
IsBackLayer
bool IsBackLayer(PCB_LAYER_ID aLayerId)
Layer classification: check if it's a back layer.
Definition: layers_id_colors_and_visibility.h:890
LAYER_ZONES
Control for copper zone opacity/visibility (color ignored)
Definition: layers_id_colors_and_visibility.h:231
PCB_DIM_CENTER_T
class PCB_DIM_CENTER, a center point marking (graphic item)
Definition: typeinfo.h:102
KIGFX::PREVIEW::TWO_POINT_GEOMETRY_MANAGER
Represent a very simple geometry manager for items that have a start and end point.
Definition: two_point_geom_manager.h:40
DIALOG_IMPORT_GFX::GetImportedItems
std::list< std::unique_ptr< EDA_ITEM > > & GetImportedItems()
Definition: dialog_import_gfx.h:44
DRAWING_TOOL::DrawRectangle
int DrawRectangle(const TOOL_EVENT &aEvent)
Start interactively drawing a rectangle.
Definition: drawing_tool.cpp:290
STATUS_TEXT_POPUP
Extension of STATUS_POPUP for displaying a single line text.
Definition: status_popup.h:79
PCB_BASE_FRAME::GetCanvas
PCB_DRAW_PANEL_GAL * GetCanvas() const override
Return a pointer to GAL-based canvas of given EDA draw frame.
Definition: pcb_base_frame.cpp:716
ID_POPUP_PCB_SELECT_VIASIZE1
Definition: pcbnew_id.h:44
ratsnest_data.h
Class that computes missing connections on a PCB.
DRAWING_TOOL::m_mode
MODE m_mode
Definition: drawing_tool.h:271
PCB_ACTIONS::toggleLine45degMode
static TOOL_ACTION toggleLine45degMode
Toggle 45 degree line drawing mode.
Definition: pcb_actions.h:167
TOOL_MENU::GetMenu
CONDITIONAL_MENU & GetMenu()
Definition: tool_menu.cpp:46
DRAWING_TOOL::WIDTH_STEP
static const unsigned int WIDTH_STEP
Definition: drawing_tool.h:274
EDA_TEXT::SetItalic
void SetItalic(bool isItalic)
Definition: eda_text.h:186
KIGFX::PREVIEW::TWO_POINT_GEOMETRY_MANAGER::GetOrigin
VECTOR2I GetOrigin() const
Definition: two_point_geom_manager.h:52
TOOL_BASE::m_toolMgr
TOOL_MANAGER * m_toolMgr
Definition: tool_base.h:214
KIGFX::PREVIEW::TWO_POINT_GEOMETRY_MANAGER::IsReset
bool IsReset() const
Definition: two_point_geom_manager.h:91
PCB_BASE_EDIT_FRAME::OnEditItemRequest
virtual void OnEditItemRequest(BOARD_ITEM *aItem)=0
Install the corresponding dialog editor for the given item.
PCB_ACTIONS::drawAlignedDimension
static TOOL_ACTION drawAlignedDimension
Definition: pcb_actions.h:148
ACTIONS::cancelInteractive
static TOOL_ACTION cancelInteractive
Definition: actions.h:62
TOOLS_HOLDER::PushTool
virtual void PushTool(const std::string &actionName)
NB: the definition of "tool" is different at the user level.
Definition: tools_holder.cpp:44
KIGFX::VIEW::Remove
virtual void Remove(VIEW_ITEM *aItem)
Remove a VIEW_ITEM from the view.
Definition: view.cpp:352
EDA_TEXT::SetTextPos
void SetTextPos(const wxPoint &aPoint)
Definition: eda_text.h:253
PCB_ACTIONS::properties
static TOOL_ACTION properties
Activation of the edit tool.
Definition: pcb_actions.h:117
In1_Cu
Definition: layers_id_colors_and_visibility.h:76
PCB_ACTIONS::drawOrthogonalDimension
static TOOL_ACTION drawOrthogonalDimension
Definition: pcb_actions.h:150
PCB_DIMENSION_BASE::SetText
void SetText(const wxString &aNewText)
Set the override text - has no effect if m_overrideValue == false.
Definition: pcb_dimension.cpp:200
BITMAPS::via
EDA_ITEM::SetFlags
void SetFlags(EDA_ITEM_FLAGS aMask)
Definition: eda_item.h:153
ROUTER_TOOL
Definition: router_tool.h:28
PCB_TEXT_T
class PCB_TEXT, text on a layer
Definition: typeinfo.h:91
PCB_VIA
Definition: pcb_track.h:324
ZONE_CREATE_HELPER::PARAMS::m_layer
PCB_LAYER_ID m_layer
The zone mode to operate in.
Definition: zone_create_helper.h:54
VIATYPE::BLIND_BURIED
TOOL_MANAGER::RunAction
bool RunAction(const std::string &aActionName, bool aNow=false, T aParam=NULL)
Run the specified action.
Definition: tool_manager.h:143
B_Cu
Definition: layers_id_colors_and_visibility.h:106
PCB_ACTIONS::drawPolygon
static TOOL_ACTION drawPolygon
Definition: pcb_actions.h:143
RAD2DECIDEG
double RAD2DECIDEG(double rad)
Definition: trigo.h:236
KIGFX::PREVIEW::ARC_GEOM_MANAGER::GetStartRadiusEnd
VECTOR2I GetStartRadiusEnd() const
Get the coordinates of the arc end point.
Definition: arc_geom_manager.cpp:74
TOOL_MANAGER::PrimeTool
void PrimeTool(const VECTOR2D &aPosition)
"Prime" a tool by sending a cursor left-click event with the mouse position set to the passed in posi...
Definition: tool_manager.cpp:351
PCB_ACTIONS::trackViaSizeChanged
static TOOL_ACTION trackViaSizeChanged
Definition: pcb_actions.h:302
PCB_TRACK
Definition: pcb_track.h:75
PCB_VIA::GetLayerSet
virtual LSET GetLayerSet() const override
Return a std::bitset of all layers on which the item physically resides.
Definition: pcb_track.cpp:402
KIGFX::PREVIEW::MULTISTEP_GEOM_MANAGER::RemoveLastPoint
void RemoveLastPoint()
Undo the last point, and move the manager back to the previous step.
Definition: multistep_geom_manager.h:78
DIALOG_IMPORT_GFX
Definition: dialog_import_gfx.h:35
PCB_FP_SHAPE_T
class FP_SHAPE, a footprint edge
Definition: typeinfo.h:93
PCB_PAD_T
class PAD, a pad in a footprint
Definition: typeinfo.h:89
KI_FALLTHROUGH
#define KI_FALLTHROUGH
The KI_FALLTHROUGH macro is to be used when switch statement cases should purposely fallthrough from ...
Definition: macros.h:83
PCB_DIMENSION_BASE
Abstract dimension API.
Definition: pcb_dimension.h:95
EDA_TEXT::SetTextSize
void SetTextSize(const wxSize &aNewSize)
Definition: eda_text.h:244
PCB_TRACK::GetWidth
int GetWidth() const
Definition: pcb_track.h:102
KIGFX::PREVIEW::TWO_POINT_GEOMETRY_MANAGER::Reset
void Reset()
Reset the manager to the initial state.
Definition: two_point_geom_manager.h:99
PCB_SHAPE_TYPE
PCB_SHAPE_TYPE
The set of shapes for PCB graphics and tracks and footprint graphics in the .m_Shape member.
Definition: board_item.h:46
PCB_BASE_FRAME::GetMagneticItemsSettings
virtual MAGNETIC_SETTINGS * GetMagneticItemsSettings()
Definition: pcb_base_frame.cpp:681
PCB_SHAPE_TYPE::CIRCLE
ring
MINOPTMAX::Min
T Min() const
Definition: minoptmax.h:33
DRAWING_TOOL::MODE::NONE
ZONE_CREATE_HELPER::PARAMS
Parameters used to fully describe a zone creation process.
Definition: zone_create_helper.h:48
POLYGON_GEOM_MANAGER::NewPointClosesOutline
bool NewPointClosesOutline(const VECTOR2I &aPt) const
Definition: polygon_geom_manager.cpp:116
pcb_actions.h
BOARD_DESIGN_SETTINGS::GetTextThickness
int GetTextThickness(PCB_LAYER_ID aLayer) const
Return the default text thickness from the layer class for the given layer.
Definition: board_design_settings.cpp:1133
DRC_ENGINE::IsNetTie
static bool IsNetTie(BOARD_ITEM *aItem)
Definition: drc_engine.cpp:1311
VECTOR2I
VECTOR2< int > VECTOR2I
Definition: vector2d.h:623
BOARD_DESIGN_SETTINGS::m_CurrentViaType
VIATYPE m_CurrentViaType
(VIA_BLIND_BURIED, VIA_THROUGH, VIA_MICROVIA)
Definition: board_design_settings.h:680
LSET::Seq
LSEQ Seq(const PCB_LAYER_ID *aWishListSequence, unsigned aCount) const
Return an LSEQ from the union of this LSET and a desired sequence.
Definition: lset.cpp:411
POLYGON_GEOM_MANAGER::SetLeaderMode
void SetLeaderMode(LEADER_MODE aMode)
Set the leader mode to use when calculating the leader/returner lines.
Definition: polygon_geom_manager.cpp:78
PCB_BASE_EDIT_FRAME::GetAppearancePanel
APPEARANCE_CONTROLS * GetAppearancePanel()
Definition: pcb_base_edit_frame.h:207
POLYGON_GEOM_MANAGER::GetLeaderMode
LEADER_MODE GetLeaderMode() const
Definition: polygon_geom_manager.h:100
PCB_DIMENSION_BASE::SetExtensionOffset
void SetExtensionOffset(int aOffset)
Definition: pcb_dimension.h:184
BOARD_CONNECTED_ITEM
A base class derived from BOARD_ITEM for items that can be connected and have a net,...
Definition: board_connected_item.h:39
PNS::ROUTING_SETTINGS::AllowDRCViolations
bool AllowDRCViolations() const
Definition: pns_routing_settings.h:126
PCB_ACTIONS::setAnchor
static TOOL_ACTION setAnchor
Definition: pcb_actions.h:162
BOARD::GetDesignSettings
BOARD_DESIGN_SETTINGS & GetDesignSettings() const
Definition: board.cpp:588
TOOL_INTERACTIVE::Go
void Go(int(T::*aStateFunc)(const TOOL_EVENT &), const TOOL_EVENT_LIST &aConditions=TOOL_EVENT(TC_ANY, TA_ANY))
Define which state (aStateFunc) to go when a certain event arrives (aConditions).
Definition: tool_interactive.h:128
PCB_DIM_ORTHOGONAL
An orthogonal dimension is like an aligned dimension, but the extension lines are locked to the X or ...
Definition: pcb_dimension.h:422
PCB_ACTIONS::placeText
static TOOL_ACTION placeText
Definition: pcb_actions.h:147
BOARD_DESIGN_SETTINGS::m_UseConnectedTrackWidth
bool m_UseConnectedTrackWidth
Definition: board_design_settings.h:682
pcb_text.h
zone_create_helper.h
updateSegmentFromGeometryMgr
static void updateSegmentFromGeometryMgr(const KIGFX::PREVIEW::TWO_POINT_GEOMETRY_MANAGER &aMgr, PCB_SHAPE *aGraphic)
Update an PCB_SHAPE from the current state of a TWO_POINT_GEOMETRY_MANAGER.
Definition: drawing_tool.cpp:1330
KIGFX::PREVIEW::ARC_GEOM_MANAGER::GetSubtended
double GetSubtended() const
Definition: arc_geom_manager.cpp:103
KIGFX::PREVIEW::MULTISTEP_GEOM_MANAGER::HasGeometryChanged
bool HasGeometryChanged() const
Definition: multistep_geom_manager.h:127
ID_POPUP_PCB_SELECT_VIASIZE16
Definition: pcbnew_id.h:59
KIGFX::PREVIEW::MULTISTEP_GEOM_MANAGER::AddPoint
void AddPoint(const VECTOR2I &aPt, bool aLockIn)
Add a point to the construction manager.
Definition: multistep_geom_manager.h:60
FOOTPRINT::Pads
PADS & Pads()
Definition: footprint.h:159
PCB_BASE_EDIT_FRAME::ShowTextPropertiesDialog
void ShowTextPropertiesDialog(BOARD_ITEM *aText)
Definition: dialog_text_properties.cpp:177
PCB_ACTIONS::decWidth
static TOOL_ACTION decWidth
Decrease width of currently drawn line.
Definition: pcb_actions.h:173
macros.h
This file contains miscellaneous commonly used macros and functions.
VIA_SIZE_MENU
Definition: drawing_tool.cpp:68
TOOL_EVENT::IsAction
bool IsAction(const TOOL_ACTION *aAction) const
Test if the event contains an action issued upon activation of the given TOOL_ACTION.
Definition: tool_event.cpp:88
PCB_DIMENSION_BASE::SetLineThickness
void SetLineThickness(int aWidth)
Definition: pcb_dimension.h:188
DRAWING_TOOL::m_view
KIGFX::VIEW * m_view
Definition: drawing_tool.h:267
PCB_DIM_ALIGNED
For better understanding of the points that make a dimension:
Definition: pcb_dimension.h:341
KIGFX::PREVIEW::TWO_POINT_GEOMETRY_MANAGER::SetAngleSnap
void SetAngleSnap(bool aSnap)
Definition: two_point_geom_manager.h:78
NoPrintableChars
bool NoPrintableChars(const wxString &aString)
Return true if the string is empty or contains only whitespace.
Definition: string.cpp:449
TestSegmentHit
bool TestSegmentHit(const wxPoint &aRefPoint, wxPoint aStart, wxPoint aEnd, int aDist)
Test if aRefPoint is with aDistance on the line defined by aStart and aEnd.
Definition: trigo.cpp:129
BOARD_DESIGN_SETTINGS::GetTextUpright
bool GetTextUpright(PCB_LAYER_ID aLayer) const
Definition: board_design_settings.cpp:1145
BUT_RIGHT
Definition: tool_event.h:127
PCB_TOOL_BASE::frame
PCB_BASE_EDIT_FRAME * frame() const
Definition: pcb_tool_base.h:154
BOARD_DESIGN_SETTINGS::GetTextItalic
bool GetTextItalic(PCB_LAYER_ID aLayer) const
Definition: board_design_settings.cpp:1139
PCB_BASE_FRAME::GetActiveLayer
virtual PCB_LAYER_ID GetActiveLayer() const
Definition: pcb_base_frame.h:354
BOARD_DESIGN_SETTINGS::GetLineThickness
int GetLineThickness(PCB_LAYER_ID aLayer) const
Return the default graphic segment thickness from the layer class for the given layer.
Definition: board_design_settings.cpp:1121
PCB_DIMENSION_BASE::SetLayer
void SetLayer(PCB_LAYER_ID aLayer) override
Set the layer this item is on.
Definition: pcb_dimension.cpp:213
BOARD_DESIGN_SETTINGS::SetViaSizeIndex
void SetViaSizeIndex(unsigned aIndex)
Set the current via size list index to aIndex.
Definition: board_design_settings.cpp:930
DRAWING_TOOL::MODE::KEEPOUT
PCBNEW_SETTINGS::m_Use45DegreeGraphicSegments
bool m_Use45DegreeGraphicSegments
Definition: pcbnew_settings.h:278
PCB_SELECTION_TOOL::GetSelection
PCB_SELECTION & GetSelection()
Return the set of currently selected items.
Definition: pcb_selection_tool.cpp:517
KIID
Definition: kiid.h:44
PCB_DIMENSION_BASE::GetStart
virtual const wxPoint & GetStart() const
The dimension's origin is the first feature point for the dimension.
Definition: pcb_dimension.h:121
SELECTION::SetReferencePoint
void SetReferencePoint(const VECTOR2I &aP)
Definition: selection.h:186
KIGFX::VIEW_CONTROLS::WarpCursor
virtual void WarpCursor(const VECTOR2D &aPosition, bool aWorldCoordinates=false, bool aWarpView=false)=0
If enabled (.
DRAWING_TOOL::PlaceImportedGraphics
int PlaceImportedGraphics(const TOOL_EVENT &aEvent)
Place a drawing imported from a DXF or SVG file in footprint editor.
Definition: drawing_tool.cpp:1087
ID_POPUP_PCB_SELECT_CUSTOM_WIDTH
Definition: pcbnew_id.h:25
DRAWING_TOOL::drawSegment
bool drawSegment(const std::string &aTool, PCB_SHAPE **aGraphic, OPT< VECTOR2D > aStartingPoint)
Start drawing a selected shape (i.e.
Definition: drawing_tool.cpp:1341
PCB_LAYER_ID
PCB_LAYER_ID
A quick note on layer IDs:
Definition: layers_id_colors_and_visibility.h:69
DRAWING_TOOL::PlaceText
int PlaceText(const TOOL_EVENT &aEvent)
Display a dialog that allows one to input text and its settings and then lets the user decide where t...
Definition: drawing_tool.cpp:423
DIALOG_IMPORT_GFX::IsPlacementInteractive
bool IsPlacementInteractive()
Definition: dialog_import_gfx.h:54
WX_INFOBAR::Dismiss
void Dismiss() override
Dismisses the infobar and updates the containing layout and AUI manager (if one is provided).
Definition: infobar.cpp:176
POLYGON_GEOM_MANAGER::LEADER_MODE::DEG45
45 Degree only
LSET
LSET is a set of PCB_LAYER_IDs.
Definition: layers_id_colors_and_visibility.h:506
SCOPED_SET_RESET
RAII class that sets an value at construction and resets it to the original value at destruction.
Definition: scoped_set_reset.h:44
PCB_TOOL_BASE::selection
const PCB_SELECTION & selection() const
Definition: pcb_tool_base.cpp:305
BOARD::GetFirstFootprint
FOOTPRINT * GetFirstFootprint() const
Get the first footprint on the board or nullptr.
Definition: board.h:317
NULLOPT
const auto NULLOPT
Definition: optional.h:9
BITMAPS::grid
VIA_SIZE_MENU::update
void update() override
Update menu state stub.
Definition: drawing_tool.cpp:84
NULL
#define NULL
VECTOR2D
VECTOR2< double > VECTOR2D
Definition: vector2d.h:622
EDA_DRAW_FRAME::SetMsgPanel
void SetMsgPanel(const std::vector< MSG_PANEL_ITEM > &aList)
Clear the message panel and populates it with the contents of aList.
Definition: eda_draw_frame.cpp:656
KIGFX::PREVIEW::ARC_GEOM_MANAGER::SET_START
Waiting to lock in the arc start point.
Definition: arc_geom_manager.h:50
PCB_TOOL_BASE::IPO_REPEAT
Allow repeat placement of the item.
Definition: pcb_tool_base.h:122
BOARD_DESIGN_SETTINGS::GetViaSizeIndex
unsigned GetViaSizeIndex() const
Definition: board_design_settings.h:369
TOOLS_HOLDER::PopTool
virtual void PopTool(const std::string &actionName)
Definition: tools_holder.cpp:61
KIGFX::VIEW_CONTROLS::CaptureCursor
virtual void CaptureCursor(bool aEnabled)
Force the cursor to stay within the drawing panel area.
Definition: view_controls.h:306
DRAWING_TOOL::MODE::DXF
DIALOG_TEXT_PROPERTIES
Definition: dialog_text_properties.h:40
DRAWING_TOOL::MODE::GRAPHIC_POLYGON
PCB_DIMENSION_BASE::SetEnd
virtual void SetEnd(const wxPoint &aPoint)
Definition: pcb_dimension.h:125
pcb_grid_helper.h
ZONE::GetLayer
virtual PCB_LAYER_ID GetLayer() const override
Return the primary layer this item is on.
Definition: zone.cpp:218
TOOL_EVENT::Parameter
T Parameter() const
Return a non-standard parameter assigned to the event.
Definition: tool_event.h:427
pcb_group.h
DRAWING_TOOL::Reset
void Reset(RESET_REASON aReason) override
Bring the tool to a known, initial state.
Definition: drawing_tool.cpp:228
BOX2::GetWidth
coord_type GetWidth() const
Definition: box2.h:187
KIGFX::PREVIEW::ARC_GEOM_MANAGER::GetOrigin
VECTOR2I GetOrigin() const
< Get the center point of the arc (valid when state > SET_ORIGIN)
Definition: arc_geom_manager.cpp:68
PCB_DIMENSION_BASE::GetPosition
wxPoint GetPosition() const override
Definition: pcb_dimension.h:127
PCB_SHAPE_TYPE::RECT
segment with non rounded ends
router_tool.h
DRAWING_TOOL::Init
bool Init() override
Init() is called once upon a registration of the tool.
Definition: drawing_tool.cpp:170
BOARD::Footprints
FOOTPRINTS & Footprints()
Definition: board.h:233
DRAWING_TOOL::MODE::VIA
TOOL_EVENT
Generic, UI-independent tool event.
Definition: tool_event.h:152
NETCLASS
A collection of nets and the parameters used to route or test these nets.
Definition: netclass.h:46
CLEARANCE_CONSTRAINT
Definition: drc_rule.h:44
PCB_DIM_CENTER
Mark the center of a circle or arc with a cross shape.
Definition: pcb_dimension.h:526
DRAWING_TOOL::m_lineWidth
unsigned int m_lineWidth
Definition: drawing_tool.h:273
PCB_TOOL_BASE::footprint
FOOTPRINT * footprint() const
Definition: pcb_tool_base.h:161
KIGFX::PREVIEW::TWO_POINT_GEOMETRY_MANAGER::SetOrigin
void SetOrigin(const VECTOR2I &aOrigin)
< Set the origin of the ruler (the fixed end)
Definition: two_point_geom_manager.h:45
PCB_TOOL_BASE::view
KIGFX::PCB_VIEW * view() const
Definition: pcb_tool_base.h:144
BITMAPS::text
PCB_DIMENSION_BASE::SetArrowLength
void SetArrowLength(int aLength)
Definition: pcb_dimension.h:182
PCB_ACTIONS::drawRectangle
static TOOL_ACTION drawRectangle
Definition: pcb_actions.h:144
PCB_TRACK::SetStart
void SetStart(const wxPoint &aStart)
Definition: pcb_track.h:107
PCB_SHAPE
Definition: pcb_shape.h:42
PCB_SCREEN::m_Route_Layer_BOTTOM
PCB_LAYER_ID m_Route_Layer_BOTTOM
Definition: pcb_screen.h:44
appearance_controls.h
_
#define _(s)
Definition: eda_3d_actions.cpp:33
ZONE_MODE::ADD
Add a new zone/keepout with fresh settings.
DRAWING_TOOL::PlaceCharacteristics
int PlaceCharacteristics(const TOOL_EVENT &aEvent)
Function PlaceCharacteristics()
Definition: drawing_stackup_table_tool.cpp:653
DRAWING_TOOL::drawArc
bool drawArc(const std::string &aTool, PCB_SHAPE **aGraphic, bool aImmediateMode)
Start drawing an arc.
Definition: drawing_tool.cpp:1680
POLYGON_GEOM_MANAGER::IsSelfIntersecting
bool IsSelfIntersecting(bool aIncludeLeaderPts) const
Check whether the locked points constitute a self-intersecting outline.
Definition: polygon_geom_manager.cpp:84
KIGFX::VIEW_CONTROLS::ForceCursorPosition
virtual void ForceCursorPosition(bool aEnabled, const VECTOR2D &aPosition=VECTOR2D(0, 0))
Place the cursor immediately at a given point.
Definition: view_controls.h:251
fp_shape.h
FOOTPRINT::MoveAnchorPosition
void MoveAnchorPosition(const wxPoint &aMoveVector)
Move the reference point of the footprint.
Definition: footprint.cpp:1488
geometry_utils.h
a few functions useful in geometry calculations.
LSET::AllLayersMask
static LSET AllLayersMask()
Definition: lset.cpp:787
POLYGON_GEOM_MANAGER::IsPolygonInProgress
bool IsPolygonInProgress() const
Definition: polygon_geom_manager.cpp:110
PCB_ACTIONS::drawVia
static TOOL_ACTION drawVia
Definition: pcb_actions.h:153
ZONE
Handle a list of polygons defining a copper zone.
Definition: zone.h:57
DRAWING_TOOL::m_controls
KIGFX::VIEW_CONTROLS * m_controls
Definition: drawing_tool.h:268
PCB_ZONE_T
class ZONE, a copper pour area
Definition: typeinfo.h:105
PCB_TOOL_BASE::IPO_SINGLE_CLICK
Create an item immediately on placement starting, otherwise show the pencil cursor until the item is ...
Definition: pcb_tool_base.h:119
TOOL_EVENT::DisableGridSnapping
bool DisableGridSnapping() const
Definition: tool_event.h:336
NETCLASS::GetuViaDiameter
int GetuViaDiameter() const
Definition: netclass.h:140
PCB_SHAPE::SetCenter
void SetCenter(const wxPoint &aCenterPoint)
Definition: pcb_shape.h:199
POLYGON_GEOM_MANAGER::LEADER_MODE::DIRECT
Unconstrained point-to-point.
F_Cu
Definition: layers_id_colors_and_visibility.h:75
arc_assistant.h
pcb_edit_frame.h
DRAWING_TOOL::MODE::ANCHOR
PCB_ACTIONS::drawZoneCutout
static TOOL_ACTION drawZoneCutout
Definition: pcb_actions.h:155
PCB_TOOL_BASE::m_isFootprintEditor
bool m_isFootprintEditor
Definition: pcb_tool_base.h:175
ZONE::GetHV45
bool GetHV45() const
Definition: zone.h:799
drawing_tool.h
PCB_DRAW_PANEL_GAL::GetView
virtual KIGFX::PCB_VIEW * GetView() const override
Return a pointer to the #VIEW instance used in the panel.
Definition: pcb_draw_panel_gal.cpp:627
DRAWING_TOOL::getSegmentWidth
int getSegmentWidth(PCB_LAYER_ID aLayer) const
Definition: drawing_tool.cpp:2621
ZONE_MODE
ZONE_MODE
Definition: pcb_actions.h:33
TOOL_BASE::getView
KIGFX::VIEW * getView() const
Returns the instance of #VIEW object used in the application.
Definition: tool_base.cpp:36
KIGFX::VIEW_CONTROLS::SetAutoPan
virtual void SetAutoPan(bool aEnabled)
Turn on/off auto panning (this feature is used when there is a tool active (eg.
Definition: view_controls.h:156
pcbnew_id.h
EDA_DRAW_PANEL_GAL::Refresh
virtual void Refresh(bool aEraseBackground=true, const wxRect *aRect=NULL) override
Update the board display after modifying it by a python script (note: it is automatically called by a...
Definition: draw_panel_gal.cpp:304
board_design_settings.h
SELECTION::Empty
bool Empty() const
Checks if there is anything selected.
Definition: selection.h:97
KIGFX::PREVIEW::MULTISTEP_GEOM_MANAGER::IsComplete
bool IsComplete() const
Definition: multistep_geom_manager.h:108
DRAWING_TOOL::setTransitions
void setTransitions() override
This method is meant to be overridden in order to specify handlers for events.
Definition: drawing_tool.cpp:2631
PCB_TEXT
Definition: pcb_text.h:36
tool_manager.h
PCB_FOOTPRINT_T
class FOOTPRINT, a footprint
Definition: typeinfo.h:88
DRAWING_TOOL::m_frame
PCB_BASE_EDIT_FRAME * m_frame
Definition: drawing_tool.h:270
GRID_HELPER::SetSnap
void SetSnap(bool aSnap)
Definition: grid_helper.h:64
POLYGON_GEOM_MANAGER::DeleteLastCorner
void DeleteLastCorner()
Remove the last-added point from the polygon.
Definition: polygon_geom_manager.cpp:122
EDA_ITEM::m_Uuid
const KIID m_Uuid
Definition: eda_item.h:475
PCB_BASE_FRAME::GetModel
virtual BOARD_ITEM_CONTAINER * GetModel() const =0
PCB_ACTIONS::placeCharacteristics
static TOOL_ACTION placeCharacteristics
Definition: pcb_actions.h:157
PCB_ACTIONS::drawCircle
static TOOL_ACTION drawCircle
Definition: pcb_actions.h:145
UNDEFINED_LAYER
Definition: layers_id_colors_and_visibility.h:71
DRAWING_TOOL::constrainDimension
void constrainDimension(PCB_DIMENSION_BASE *aDim)
Force the dimension lime to be drawn on multiple of 45 degrees.
Definition: drawing_tool.cpp:646
DRAWING_TOOL::MODE::ZONE
SEG
Definition: seg.h:40
EDA_UNITS
EDA_UNITS
Definition: eda_units.h:38
KIGFX::NONE
No updates are required.
Definition: view_item.h:51
TOOL_EVENT::GetCommandStr
OPT< std::string > GetCommandStr() const
Definition: tool_event.h:455
TOOL_MANAGER::GetToolHolder
TOOLS_HOLDER * GetToolHolder() const
Definition: tool_manager.h:294
two_point_assistant.h
FP_TEXT::SetKeepUpright
void SetKeepUpright(bool aKeepUpright)
Definition: fp_text.h:115
PCB_SELECTION
Definition: pcb_selection.h:31
MD_SHIFT
Definition: tool_event.h:135
DRAWING_TOOL::MODE
MODE
Definition: drawing_tool.h:63
BITMAPS::width_track_via
ZONE_CREATE_HELPER::OnGeometryChange
void OnGeometryChange(const POLYGON_GEOM_MANAGER &aMgr) override
Called when the polygon is complete.
Definition: zone_create_helper.cpp:287
BOARD_DESIGN_SETTINGS::GetCurrentViaSize
int GetCurrentViaSize() const
Definition: board_design_settings.cpp:937
TOOL_MANAGER::GetTool
T * GetTool()
Definition: tool_manager.h:221
PCB_ACTIONS::arcPosture
static TOOL_ACTION arcPosture
Switch posture when drawing arc.
Definition: pcb_actions.h:176
BOX2::Inflate
BOX2< Vec > & Inflate(coord_type dx, coord_type dy)
Function Inflate inflates the rectangle horizontally by dx and vertically by dy.
Definition: box2.h:292
BOARD::IsLayerVisible
bool IsLayerVisible(PCB_LAYER_ID aLayer) const
A proxy function that calls the correspondent function in m_BoardSettings tests whether a given layer...
Definition: board.cpp:471
PCB_ACTIONS::layerChanged
static TOOL_ACTION layerChanged
Definition: pcb_actions.h:292
DRAWING_TOOL::getSourceZoneForAction
bool getSourceZoneForAction(ZONE_MODE aMode, ZONE **aZone)
Draw a polygon, that is added as a zone or a keepout area.
Definition: drawing_tool.cpp:1928
VIA_SIZE_MENU::create
ACTION_MENU * create() const override
< Return an instance of this class. It has to be overridden in inheriting classes.
Definition: drawing_tool.cpp:79
PCB_ACTIONS::drawLeader
static TOOL_ACTION drawLeader
Definition: pcb_actions.h:151
PARSE_ERROR
A filename or source description, a problem input line, a line number, a byte offset,...
Definition: ki_exception.h:118
ACTIONS::updateUnits
static TOOL_ACTION updateUnits
Definition: actions.h:147
DRAWING_TOOL::SetAnchor
int SetAnchor(const TOOL_EVENT &aEvent)
Place the footprint anchor (only in footprint editor).
Definition: drawing_tool.cpp:1244
PCB_ACTIONS::drawRuleArea
static TOOL_ACTION drawRuleArea
Definition: pcb_actions.h:154
ACTION_MENU::SetTitle
void SetTitle(const wxString &aTitle) override
Set title for the menu.
Definition: action_menu.cpp:91
BOARD_DESIGN_SETTINGS::GetDRCEpsilon
int GetDRCEpsilon() const
Definition: board_design_settings.cpp:1109
KIGFX::PREVIEW::ARC_GEOM_MANAGER::SET_ANGLE
Waiting to lock in the arc end point.
Definition: arc_geom_manager.h:51
PCB_TOOL_BASE::controls
KIGFX::VIEW_CONTROLS * controls() const
Definition: pcb_tool_base.h:149
DRC_CONSTRAINT::GetValue
const MINOPTMAX< int > & GetValue() const
Definition: drc_rule.h:122
PCB_BASE_EDIT_FRAME
Common, abstract interface for edit frames.
Definition: pcb_base_edit_frame.h:39
DRAWING_TOOL::MODE::RECTANGLE
KIGFX::PREVIEW::ARC_GEOM_MANAGER::ToggleClockwise
void ToggleClockwise()
Set angle snapping (for the next point)
Definition: arc_geom_manager.cpp:60
PCB_SHAPE::SetStart
void SetStart(const wxPoint &aStart)
Definition: pcb_shape.h:127
DRAWING_TOOL::PlaceStackup
int PlaceStackup(const TOOL_EVENT &aEvent)
Function PlaceStackup()
Definition: drawing_stackup_table_tool.cpp:726
pcb_selection_tool.h
ACTION_MENU::getToolManager
TOOL_MANAGER * getToolManager() const
Definition: action_menu.cpp:327
KIGFX::PREVIEW::ARC_GEOM_MANAGER::GetStep
ARC_STEPS GetStep() const
Get the current step the manager is on (useful when drawing something depends on the current state)
Definition: arc_geom_manager.h:64
PCB_ACTIONS::placeStackup
static TOOL_ACTION placeStackup
Definition: pcb_actions.h:159
TOOL_MENU::AddSubMenu
void AddSubMenu(std::shared_ptr< ACTION_MENU > aSubMenu)
Store a submenu of this menu model.
Definition: tool_menu.cpp:52
PNS::angle
static DIRECTION_45::AngleType angle(const VECTOR2I &a, const VECTOR2I &b)
Definition: pns_diff_pair.cpp:168
SELECTION::Remove
virtual void Remove(EDA_ITEM *aItem)
Definition: selection.cpp:43
BOARD::GetCopperLayerCount
int GetCopperLayerCount() const
Definition: board.cpp:453
PCB_DIM_ORTHOGONAL::DIR::VERTICAL
PCB_ACTIONS::selectItem
static TOOL_ACTION selectItem
Select an item (specified as the event parameter).
Definition: pcb_actions.h:62
PCB_FP_ZONE_T
class ZONE, managed by a footprint
Definition: typeinfo.h:94
PCB_DIMENSION_BASE::SetStart
virtual void SetStart(const wxPoint &aPoint)
Definition: pcb_dimension.h:122
ZONE_CREATE_HELPER
An adjunct helper to the DRAWING_TOOL interactive tool, which handles incoming geometry changes from ...
Definition: zone_create_helper.h:42
PCB_EDIT_FRAME
The main frame for Pcbnew.
Definition: pcb_edit_frame.h:69
ACTION_MENU::Clear
void Clear()
Remove all the entries from the menu (as well as its title).
Definition: action_menu.cpp:236
PCB_BASE_FRAME::Settings
PCBNEW_SETTINGS & Settings()
Definition: pcb_base_frame.h:171
PCB_SHAPE_TYPE::SEGMENT
usual segment : line with rounded ends
SELECTION::Size
int Size() const
Returns the number of selected parts.
Definition: selection.h:103
PCB_SHAPE::SetWidth
void SetWidth(int aWidth)
Definition: pcb_shape.h:96
PCB_SELECTION_TOOL
The selection tool: currently supports:
Definition: pcb_selection_tool.h:63
KIGFX::PREVIEW::ARC_ASSISTANT
Represents an assistant draw when interactively drawing an arc on a canvas.
Definition: arc_assistant.h:38
ACTIONS::resetLocalCoords
static TOOL_ACTION resetLocalCoords
Definition: actions.h:150
POLYGON_GEOM_MANAGER::Reset
void Reset()
Clear the manager state and start again.
Definition: polygon_geom_manager.cpp:136
BOARD_COMMIT::Push
virtual void Push(const wxString &aMessage=wxT("A commit"), bool aCreateUndoEntry=true, bool aSetDirtyBit=true) override
Revert the commit by restoring the modified items state.
Definition: board_commit.cpp:90
FOOTPRINT::GetPosition
wxPoint GetPosition() const override
Definition: footprint.h:177
PCB_BASE_FRAME::GetScreen
PCB_SCREEN * GetScreen() const override
Return a pointer to a BASE_SCREEN or one of its derivatives.
Definition: pcb_base_frame.h:227
EDA_BASE_FRAME::ShowInfoBarError
void ShowInfoBarError(const wxString &aErrorMsg, bool aShowCloseButton=false)
Show the WX_INFOBAR displayed on the top of the canvas with a message and an error icon on the left o...
Definition: eda_base_frame.cpp:844
TOOL_BASE::RESET_REASON
RESET_REASON
Determine the reason of reset for a tool.
Definition: tool_base.h:77
DRAWING_TOOL::MODE::CIRCLE
PCB_GRID_HELPER
Definition: pcb_grid_helper.h:34
BOARD_DESIGN_SETTINGS::m_ViasDimensionsList
std::vector< VIA_DIMENSION > m_ViasDimensionsList
Definition: board_design_settings.h:675
PCB_ACTIONS::deleteLastPoint
static TOOL_ACTION deleteLastPoint
Definition: pcb_actions.h:163
PCB_SHAPE::SetArcEnd
void SetArcEnd(const wxPoint &aArcEndPoint)
Initialize the end arc point.
Definition: pcb_shape.h:194
DRAWING_TOOL::ToggleLine45degMode
int ToggleLine45degMode(const TOOL_EVENT &aEvent)
Toggle the 45 degree angle constraint for graphic lines.
Definition: drawing_tool.cpp:1319
OPT
boost::optional< T > OPT
Definition: optional.h:7
TOOL_EVENT::IsReactivate
bool IsReactivate() const
Definition: tool_event.h:252
IsCopperLayer
bool IsCopperLayer(LAYER_NUM aLayerId)
Tests whether a layer is a copper layer.
Definition: layers_id_colors_and_visibility.h:791
TOOL_INTERACTIVE::Activate
void Activate()
Run the tool.
Definition: tool_interactive.cpp:51
ZONE_CREATE_HELPER::GetZone
ZONE * GetZone() const
Definition: zone_create_helper.h:74
EDA_TEXT::GetTextPos
const wxPoint & GetTextPos() const
Definition: eda_text.h:254
EDA_BASE_FRAME::GetInfoBar
WX_INFOBAR * GetInfoBar()
Definition: eda_base_frame.h:234
PCB_DIM_LEADER
A leader is a dimension-like object pointing to a specific point.
Definition: pcb_dimension.h:486
NETCLASS::GetuViaDrill
int GetuViaDrill() const
Definition: netclass.h:144
DIALOG_TRACK_VIA_SIZE
Implementing DIALOG_TRACK_VIA_SIZE_BASE.
Definition: dialog_track_via_size.h:35
KIGFX::PREVIEW::ARC_GEOM_MANAGER::SetAngleSnap
void SetAngleSnap(bool aSnap)
Definition: arc_geom_manager.h:78
two_point_geom_manager.h
PCB_DIM_ORTHOGONAL_T
class PCB_DIM_ORTHOGONAL, a linear dimension constrained to x/y
Definition: typeinfo.h:103
PCB_VIA_T
class PCB_VIA, a via (like a track segment on a copper layer)
Definition: typeinfo.h:96
EDA_TEXT::SetTextThickness
void SetTextThickness(int aWidth)
The TextThickness is that set by the user.
Definition: eda_text.h:166
KIGFX::PREVIEW::TWO_POINT_GEOMETRY_MANAGER::GetEnd
VECTOR2I GetEnd() const
Definition: two_point_geom_manager.h:73
APPEARANCE_CONTROLS::SetLayerVisible
void SetLayerVisible(LAYER_NUM aLayer, bool isVisible)
Definition: appearance_controls.cpp:1101
TOOL_EVENT::HasPosition
bool HasPosition() const
Definition: tool_event.h:240
PCB_DIMENSION_BASE::GetEnd
virtual const wxPoint & GetEnd() const
Definition: pcb_dimension.h:124
KIGFX::VIEW::Add
virtual void Add(VIEW_ITEM *aItem, int aDrawPriority=-1)
Add a VIEW_ITEM to the view.
Definition: view.cpp:322
TOOLS_HOLDER::GetToolManager
TOOL_MANAGER * GetToolManager() const
Return the MVC controller.
Definition: tools_holder.h:54
status_popup.h
KIGFX::VIEW::Query
virtual int Query(const BOX2I &aRect, std::vector< LAYER_ITEM_PAIR > &aResult) const
Find all visible items that touch or are within the rectangle aRect.
Definition: view.cpp:428
PCB_TOOL_BASE::doInteractiveItemPlacement
void doInteractiveItemPlacement(const std::string &aTool, INTERACTIVE_PLACER_BASE *aPlacer, const wxString &aCommitMessage, int aOptions=IPO_ROTATE|IPO_FLIP|IPO_REPEAT)
Helper function for performing a common interactive idiom: wait for a left click, place an item there...
Definition: pcb_tool_base.cpp:35
PCB_BASE_FRAME::GetBoard
BOARD * GetBoard() const
Definition: pcb_base_frame.h:206
TOOL_BASE::getViewControls
KIGFX::VIEW_CONTROLS * getViewControls() const
Return the instance of VIEW_CONTROLS object used in the application.
Definition: tool_base.cpp:42
scoped_set_reset.h
DRAWING_TOOL::MODE::TEXT
PNS::TOOL_BASE::Router
ROUTER * Router() const
Definition: pns_tool_base.cpp:349
ZONE_CREATE_HELPER::PARAMS::m_keepout
bool m_keepout
< Should create a keepout zone?
Definition: zone_create_helper.h:51
PAD
Definition: pad.h:57
SHAPE_SEGMENT
Definition: shape_segment.h:35
DRAWING_TOOL::GetDrawingMode
MODE GetDrawingMode() const
Return the current drawing mode of the DRAWING_TOOL or #MODE::NONE if not currently in any drawing mo...
Definition: drawing_tool.cpp:238
kicad_string.h
PCB_SHAPE::SetShape
void SetShape(PCB_SHAPE_TYPE aShape)
Definition: pcb_shape.h:109
PCB_SHAPE_TYPE::ARC
Arcs (with rounded ends)
PCB_DIM_ORTHOGONAL::DIR::HORIZONTAL
POLYGON_GEOM_MANAGER::AddPoint
bool AddPoint(const VECTOR2I &aPt)
Lock in a polygon point.
Definition: polygon_geom_manager.cpp:39
POLYGON_GEOM_MANAGER::SetCursorPosition
void SetCursorPosition(const VECTOR2I &aPos)
Set the current cursor position.
Definition: polygon_geom_manager.cpp:104
DRAWING_TOOL::MODE::DIMENSION
PCB_SHAPE::SetAngle
virtual void SetAngle(double aAngle, bool aUpdateEnd=true)
Set the angle for arcs, and normalizes it within the range 0 - 360 degrees.
Definition: pcb_shape.cpp:477
PCB_SHAPE_T
class PCB_SHAPE, a segment not on copper layers
Definition: typeinfo.h:90
Millimeter2iu
static constexpr int Millimeter2iu(double mm)
Definition: test_shape_poly_set_distance.cpp:39
CONDITIONAL_MENU::AddItem
void AddItem(const TOOL_ACTION &aAction, const SELECTION_CONDITION &aCondition, int aOrder=ANY_ORDER)
Add a menu entry to run a TOOL_ACTION on selected items.
Definition: conditional_menu.cpp:47
POLYGON_GEOM_MANAGER::SetFinished
void SetFinished()
Mark the polygon finished and update the client.
Definition: polygon_geom_manager.cpp:71
DRAWING_TOOL::DrawArc
int DrawArc(const TOOL_EVENT &aEvent)
Start interactively drawing an arc.
Definition: drawing_tool.cpp:382
TOOL_MENU::ShowContextMenu
void ShowContextMenu(SELECTION &aSelection)
Helper function to set and immediately show a CONDITIONAL_MENU in concert with the given SELECTION.
Definition: tool_menu.cpp:59
DIM_UNITS_MODE::AUTOMATIC
PNS::ROUTER::Settings
ROUTING_SETTINGS & Settings()
Definition: pns_router.h:184
EDA_TEXT::GetText
virtual const wxString & GetText() const
Return the string associated with the text object.
Definition: eda_text.h:133
ToLAYER_ID
PCB_LAYER_ID ToLAYER_ID(int aLayer)
Definition: lset.cpp:905
PCB_DIMENSION_BASE::GetLineThickness
int GetLineThickness() const
Definition: pcb_dimension.h:187
BOARD_DESIGN_SETTINGS::GetTextSize
wxSize GetTextSize(PCB_LAYER_ID aLayer) const
Return the default text size from the layer class for the given layer.
Definition: board_design_settings.cpp:1127
PCB_ACTIONS::drawZone
static TOOL_ACTION drawZone
Definition: pcb_actions.h:152
PCB_GRID_HELPER::AlignToSegment
VECTOR2I AlignToSegment(const VECTOR2I &aPoint, const SEG &aSeg)
Definition: pcb_grid_helper.cpp:80
POLYGON_GEOM_MANAGER
Class that handles the drawing of a polygon, including management of last corner deletion and drawing...
Definition: polygon_geom_manager.h:35
BOARD_DESIGN_SETTINGS::m_DRCEngine
std::shared_ptr< DRC_ENGINE > m_DRCEngine
Definition: board_design_settings.h:696
TOOL_EVENT::Position
const VECTOR2D Position() const
Returns the point where dragging has started.
Definition: tool_event.h:263
PCB_ACTIONS::selectionCursor
static TOOL_ACTION selectionCursor
Select a single item under the cursor position.
Definition: pcb_actions.h:56
EDA_BASE_FRAME::GetUserUnits
EDA_UNITS GetUserUnits() const
Return the user units currently in use.
Definition: eda_base_frame.h:126
KIGFX::PREVIEW::TWO_POINT_ASSISTANT::SetUnits
void SetUnits(EDA_UNITS aUnits)
Definition: two_point_assistant.h:85
ZONE_CREATE_HELPER::PARAMS::m_mode
ZONE_MODE m_mode
Zone settings source (for similar and cutout zones)
Definition: zone_create_helper.h:57
DRAWING_TOOL::MODE::ARC
PCB_SCREEN::m_Route_Layer_TOP
PCB_LAYER_ID m_Route_Layer_TOP
Definition: pcb_screen.h:43
PCB_TRACK::GetStart
const wxPoint & GetStart() const
Definition: pcb_track.h:108
pcb_dimension.h
VIA_SIZE_MENU::VIA_SIZE_MENU
VIA_SIZE_MENU()
Definition: drawing_tool.cpp:71
ACTIONS::refreshPreview
static TOOL_ACTION refreshPreview
Definition: actions.h:106
BOARD_DESIGN_SETTINGS::UseCustomTrackViaSize
void UseCustomTrackViaSize(bool aEnabled)
Enables/disables custom track/via size settings.
Definition: board_design_settings.h:445
PCB_SHAPE::SetEnd
void SetEnd(const wxPoint &aEnd)
Definition: pcb_shape.h:137
shape_segment.h
BOARD_ITEM::GetLayerSet
virtual LSET GetLayerSet() const
Return a std::bitset of all layers on which the item physically resides.
Definition: board_item.h:176
KIGFX::VIEW_CONTROLS::GetCursorPosition
VECTOR2D GetCursorPosition() const
Return the current cursor position in world coordinates.
Definition: view_controls.h:221
SELECTION::Front
EDA_ITEM * Front() const
Definition: selection.h:144
ACTIONS::cursorClick
static TOOL_ACTION cursorClick
Definition: actions.h:123
KIGFX::VIEW::Update
virtual void Update(const VIEW_ITEM *aItem, int aUpdateFlags) const
For dynamic VIEWs, inform the associated VIEW that the graphical representation of this item has chan...
Definition: view.cpp:1504
BASE_SCREEN::m_LocalOrigin
VECTOR2D m_LocalOrigin
Relative Screen cursor coordinate (on grid) in user units.
Definition: base_screen.h:90
PCB_SHAPE::SetArcStart
void SetArcStart(const wxPoint &aArcStartPoint)
Initialize the start arc point.
Definition: pcb_shape.h:184
BITMAPS::group
KIGFX::PREVIEW::TWO_POINT_GEOMETRY_MANAGER::SetEnd
void SetEnd(const VECTOR2I &aEnd)
Set the current end of the rectangle (the end that moves with the cursor.
Definition: two_point_geom_manager.h:60
OPT_TOOL_EVENT
OPT< TOOL_EVENT > OPT_TOOL_EVENT
Definition: tool_event.h:543
EDA_ITEM::Type
KICAD_T Type() const
Returns the type of object.
Definition: eda_item.h:113
DRAWING_TOOL::DrawDimension
int DrawDimension(const TOOL_EVENT &aEvent)
Start interactively drawing a dimension.
Definition: drawing_tool.cpp:655
BOARD_DESIGN_SETTINGS
Container for design settings for a BOARD object.
Definition: board_design_settings.h:220
KIGFX::VIEW::IsLayerVisible
bool IsLayerVisible(int aLayer) const
Return information about visibility of a particular layer.
Definition: view.h:404
PCB_ACTIONS::closeOutline
static TOOL_ACTION closeOutline
Definition: pcb_actions.h:164
PCB_DIMENSION_BASE::Update
void Update()
Update the dimension's cached text and geometry.
Definition: pcb_dimension.h:146