KiCad PCB EDA Suite
ee_selection_tool.cpp
Go to the documentation of this file.
1 /*
2  * This program source code file is part of KiCad, a free EDA CAD application.
3  *
4  * Copyright (C) 2019 CERN
5  * Copyright (C) 2019 KiCad Developers, see AUTHORS.txt for contributors.
6  *
7  * This program is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU General Public License
9  * as published by the Free Software Foundation; either version 2
10  * of the License, or (at your option) any later version.
11  *
12  * This program is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, you may find one here:
19  * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
20  * or you may search the http://www.gnu.org website for the version 2 license,
21  * or you may write to the Free Software Foundation, Inc.,
22  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
23  */
24 
25 
26 #include <ee_actions.h>
27 #include <core/typeinfo.h>
28 #include <sch_item.h>
29 #include <ee_selection_tool.h>
30 #include <sch_base_frame.h>
31 #include <sch_edit_frame.h>
32 #include <lib_edit_frame.h>
33 #include <viewlib_frame.h>
34 #include <sch_component.h>
35 #include <sch_sheet.h>
36 #include <sch_field.h>
37 #include <sch_line.h>
38 #include <view/view.h>
39 #include <view/view_controls.h>
40 #include <view/view_group.h>
42 #include <tool/tool_event.h>
43 #include <tool/tool_manager.h>
45 #include <ee_collectors.h>
46 #include <painter.h>
47 #include <eeschema_id.h>
48 #include <menus_helpers.h>
49 
50 
51 SELECTION_CONDITION EE_CONDITIONS::Empty = [] (const SELECTION& aSelection )
52 {
53  return aSelection.Empty();
54 };
55 
56 
57 SELECTION_CONDITION EE_CONDITIONS::Idle = [] (const SELECTION& aSelection )
58 {
59  return ( !aSelection.Front() || aSelection.Front()->GetEditFlags() == 0 );
60 };
61 
62 
64 {
65  return ( aSelection.Front() && aSelection.Front()->GetEditFlags() == 0 );
66 };
67 
68 
70 {
71  if( aSel.GetSize() == 1 )
72  {
73  SCH_COMPONENT* comp = dynamic_cast<SCH_COMPONENT*>( aSel.Front() );
74 
75  if( comp )
76  {
77  auto partRef = comp->GetPartRef().lock();
78  return !partRef || !partRef->IsPower();
79  }
80  }
81 
82  return false;
83 };
84 
85 
87 {
88  if( aSel.GetSize() == 1 )
89  {
90  SCH_COMPONENT* comp = dynamic_cast<SCH_COMPONENT*>( aSel.Front() );
91 
92  if( comp )
93  {
94  auto partRef = comp->GetPartRef().lock();
95  return partRef && partRef->HasConversion();
96  }
97  }
98 
99  return false;
100 };
101 
102 
104 {
105  if( aSel.GetSize() == 1 )
106  {
107  SCH_COMPONENT* comp = dynamic_cast<SCH_COMPONENT*>( aSel.Front() );
108 
109  if( comp )
110  {
111  auto partRef = comp->GetPartRef().lock();
112  return partRef && partRef->GetUnitCount() >= 2;
113  }
114  }
115 
116  return false;
117 };
118 
119 
120 #define HITTEST_THRESHOLD_PIXELS 5
121 
122 
124  TOOL_INTERACTIVE( "eeschema.InteractiveSelection" ),
125  m_frame( nullptr ),
126  m_additive( false ),
127  m_subtractive( false ),
128  m_exclusive_or( false ),
129  m_multiple( false ),
130  m_skip_heuristics( false ),
131  m_isLibEdit( false ),
132  m_isLibView( false ),
133  m_unit( 0 ),
134  m_convert( 0 )
135 {
136 }
137 
138 
140 {
141  getView()->Remove( &m_selection );
142 }
143 
145 
147 {
148  m_frame = getEditFrame<SCH_BASE_FRAME>();
149 
150  LIB_VIEW_FRAME* libViewFrame = dynamic_cast<LIB_VIEW_FRAME*>( m_frame );
151  LIB_EDIT_FRAME* libEditFrame = dynamic_cast<LIB_EDIT_FRAME*>( m_frame );
152 
153  if( libEditFrame )
154  {
155  m_isLibEdit = true;
156  m_unit = libEditFrame->GetUnit();
157  m_convert = libEditFrame->GetConvert();
158  }
159  else
160  m_isLibView = libViewFrame != nullptr;
161 
162 
163  static KICAD_T wireOrBusTypes[] = { SCH_LINE_LOCATE_WIRE_T, SCH_LINE_LOCATE_BUS_T, EOT };
164 
165  auto wireSelection = E_C::MoreThan( 0 ) && E_C::OnlyType( SCH_LINE_LOCATE_WIRE_T );
166  auto busSelection = E_C::MoreThan( 0 ) && E_C::OnlyType( SCH_LINE_LOCATE_BUS_T );
167  auto wireOrBusSelection = E_C::MoreThan( 0 ) && E_C::OnlyTypes( wireOrBusTypes );
168  auto sheetSelection = E_C::Count( 1 ) && E_C::OnlyType( SCH_SHEET_T );
169  auto schEditCondition = [this] ( const SELECTION& aSel ) {
170  return !m_isLibEdit && !m_isLibView;
171  };
172  auto belowRootSheetCondition = [this] ( const SELECTION& aSel ) {
174  };
175  auto havePartCondition = [ this ] ( const SELECTION& sel ) {
176  return m_isLibEdit && ( (LIB_EDIT_FRAME*) m_frame )->GetCurPart();
177  };
178 
179  auto& menu = m_menu.GetMenu();
180 
181  menu.AddItem( EE_ACTIONS::enterSheet, sheetSelection && EE_CONDITIONS::Idle, 1 );
182  menu.AddItem( EE_ACTIONS::explicitCrossProbe, sheetSelection && EE_CONDITIONS::Idle, 1 );
183  menu.AddItem( EE_ACTIONS::leaveSheet, belowRootSheetCondition, 1 );
184 
185  menu.AddSeparator( 100 );
186  menu.AddItem( EE_ACTIONS::drawWire, schEditCondition && EE_CONDITIONS::Empty, 100 );
187  menu.AddItem( EE_ACTIONS::drawBus, schEditCondition && EE_CONDITIONS::Empty, 100 );
188 
189  menu.AddSeparator( 100 );
191 
192  menu.AddSeparator( 100 );
194 
195  menu.AddSeparator( 200 );
196  menu.AddItem( EE_ACTIONS::selectConnection, wireOrBusSelection && EE_CONDITIONS::Idle, 250 );
197  menu.AddItem( EE_ACTIONS::placeJunction, wireOrBusSelection && EE_CONDITIONS::Idle, 250 );
198  menu.AddItem( EE_ACTIONS::placeLabel, wireOrBusSelection && EE_CONDITIONS::Idle, 250 );
199  menu.AddItem( EE_ACTIONS::placeGlobalLabel, wireOrBusSelection && EE_CONDITIONS::Idle, 250 );
200  menu.AddItem( EE_ACTIONS::placeHierLabel, wireOrBusSelection && EE_CONDITIONS::Idle, 250 );
201  menu.AddItem( EE_ACTIONS::breakWire, wireSelection && EE_CONDITIONS::Idle, 250 );
202  menu.AddItem( EE_ACTIONS::breakBus, busSelection && EE_CONDITIONS::Idle, 250 );
203  menu.AddItem( EE_ACTIONS::placeSheetPin, sheetSelection && EE_CONDITIONS::Idle, 250 );
204  menu.AddItem( EE_ACTIONS::importSheetPin, sheetSelection && EE_CONDITIONS::Idle, 250 );
205 
206  menu.AddSeparator( 400 );
207  menu.AddItem( EE_ACTIONS::symbolProperties, havePartCondition && EE_CONDITIONS::Empty, 400 );
208  menu.AddItem( EE_ACTIONS::pinTable, havePartCondition && EE_CONDITIONS::Empty, 400 );
209 
210  menu.AddSeparator( 1000 );
212 
213  return true;
214 }
215 
216 
218 {
219  m_frame = getEditFrame<SCH_BASE_FRAME>();
220 
221  if( aReason == TOOL_BASE::MODEL_RELOAD )
222  {
223  // Remove pointers to the selected items from containers without changing their
224  // properties (as they are already deleted while a new sheet is loaded)
225  m_selection.Clear();
226  getView()->GetPainter()->GetSettings()->SetHighlight( false );
227 
228  LIB_EDIT_FRAME* libEditFrame = dynamic_cast<LIB_EDIT_FRAME*>( m_frame );
229  LIB_VIEW_FRAME* libViewFrame = dynamic_cast<LIB_VIEW_FRAME*>( m_frame );
230 
231  if( libEditFrame )
232  {
233  m_isLibEdit = true;
234  m_unit = libEditFrame->GetUnit();
235  m_convert = libEditFrame->GetConvert();
236  }
237  else
238  m_isLibView = libViewFrame != nullptr;
239  }
240  else
241  // Restore previous properties of selected items and remove them from containers
242  ClearSelection();
243 
244  // Reinsert the VIEW_GROUP, in case it was removed from the VIEW
245  getView()->Remove( &m_selection );
246  getView()->Add( &m_selection );
247 }
248 
249 
251 {
252  ACTION_MENU* actionMenu = aEvent.Parameter<ACTION_MENU*>();
253  CONDITIONAL_MENU* conditionalMenu = dynamic_cast<CONDITIONAL_MENU*>( actionMenu );
254 
255  if( conditionalMenu )
256  conditionalMenu->Evaluate( m_selection );
257 
258  if( actionMenu )
259  actionMenu->UpdateAll();
260 
261  return 0;
262 }
263 
264 
266 {
267  const KICAD_T movableItems[] =
268  {
269  SCH_MARKER_T,
274  SCH_LINE_T,
275  SCH_BITMAP_T,
276  SCH_TEXT_T,
277  SCH_LABEL_T,
280  SCH_FIELD_T,
283  SCH_SHEET_T,
284  EOT
285  };
286 
287  // Main loop: keep receiving events
288  while( TOOL_EVENT* evt = Wait() )
289  {
290  if( m_frame->ToolStackIsEmpty() )
291  m_frame->GetCanvas()->SetCurrentCursor( wxCURSOR_ARROW );
292 
294 
295  if( evt->Modifier( MD_SHIFT ) && evt->Modifier( MD_CTRL ) )
296  m_subtractive = true;
297  else if( evt->Modifier( MD_SHIFT ) )
298  m_additive = true;
299  else if( evt->Modifier( MD_CTRL ) )
300  m_exclusive_or = true;
301 
302  // Is the user requesting that the selection list include all possible
303  // items without removing less likely selection candidates
304  m_skip_heuristics = !!evt->Modifier( MD_ALT );
305 
306  // Single click? Select single object
307  if( evt->IsClick( BUT_LEFT ) )
308  {
309  SelectPoint( evt->Position(), EE_COLLECTOR::AllItems, nullptr, false,
311  }
312 
313  // right click? if there is any object - show the context menu
314  else if( evt->IsClick( BUT_RIGHT ) )
315  {
316  bool selectionCancelled = false;
317 
318  if( m_selection.Empty() )
319  {
320  SelectPoint( evt->Position(), EE_COLLECTOR::AllItems, &selectionCancelled );
321  m_selection.SetIsHover( true );
322  }
323 
324  if( !selectionCancelled )
326  }
327 
328  // double click? Display the properties window
329  else if( evt->IsDblClick( BUT_LEFT ) )
330  {
331  if( m_selection.Empty() )
332  SelectPoint( evt->Position());
333 
334  EDA_ITEM* item = m_selection.Front();
335 
336  if( item && item->Type() == SCH_SHEET_T )
338  else
340  }
341 
342  // drag with LMB? Select multiple objects (or at least draw a selection box) or drag them
343  else if( evt->IsDrag( BUT_LEFT ) )
344  {
346  {
347  selectMultiple();
348  }
349  else
350  {
351  // selection is empty? try to start dragging the item under the point where drag
352  // started
353  if( m_selection.Empty() )
354  m_selection = RequestSelection( movableItems );
355 
356  // Check if dragging has started within any of selected items bounding box
357  if( selectionContains( evt->Position() ) )
358  {
359  // Yes -> run the move tool and wait till it finishes
360  m_toolMgr->InvokeTool( "eeschema.InteractiveMove" );
361  }
362  else
363  {
364  // No -> drag a selection box
365  selectMultiple();
366  }
367  }
368  }
369 
370  // context sub-menu selection? Handle unit selection or bus unfolding
371  else if( evt->Category() == TC_COMMAND && evt->Action() == TA_CHOICE_MENU_CHOICE )
372  {
373  if( evt->GetCommandId().get() >= ID_POPUP_SCH_SELECT_UNIT_CMP
374  && evt->GetCommandId().get() <= ID_POPUP_SCH_SELECT_UNIT_CMP_MAX )
375  {
376  SCH_COMPONENT* component = dynamic_cast<SCH_COMPONENT*>( m_selection.Front() );
377  int unit = evt->GetCommandId().get() - ID_POPUP_SCH_SELECT_UNIT_CMP;
378 
379  if( component )
380  static_cast<SCH_EDIT_FRAME*>( m_frame )->SelectUnit( component, unit );
381  }
382  else if( evt->GetCommandId().get() >= ID_POPUP_SCH_UNFOLD_BUS
383  && evt->GetCommandId().get() <= ID_POPUP_SCH_UNFOLD_BUS_END )
384  {
385  wxString* net = new wxString( *evt->Parameter<wxString*>() );
387  }
388 
389  }
390 
391  else if( evt->IsCancelInteractive() )
392  {
393  ClearSelection();
394  }
395 
396  else if( evt->Action() == TA_UNDO_REDO_PRE )
397  {
398  ClearSelection();
399  }
400 
401  else
402  evt->SetPassEvent();
403  }
404 
405  // This tool is supposed to be active forever
406  assert( false );
407 
408  return 0;
409 }
410 
411 
413 {
414  return m_selection;
415 }
416 
417 
418 EDA_ITEM* EE_SELECTION_TOOL::SelectPoint( const VECTOR2I& aWhere, const KICAD_T* aFilterList,
419  bool* aSelectionCancelledFlag, bool aCheckLocked,
420  bool aAdd, bool aSubtract, bool aExclusiveOr )
421 {
422  EDA_ITEM* start;
423  EE_COLLECTOR collector;
424 
425  if( m_isLibEdit )
426  start = static_cast<LIB_EDIT_FRAME*>( m_frame )->GetCurPart();
427  else
428  start = m_frame->GetScreen()->GetDrawItems();
429 
430  // Empty schematics have no draw items
431  if( !start )
432  return nullptr;
433 
434  collector.m_Threshold = KiROUND( getView()->ToWorld( HITTEST_THRESHOLD_PIXELS ) );
435  collector.Collect( start, aFilterList, (wxPoint) aWhere, m_unit, m_convert );
436 
437  // Post-process collected items
438  for( int i = collector.GetCount() - 1; i >= 0; --i )
439  {
440  if( !Selectable( collector[ i ] ) )
441  {
442  collector.Remove( i );
443  continue;
444  }
445 
446  if( aCheckLocked && collector[ i ]->IsLocked() )
447  {
448  collector.Remove( i );
449  continue;
450  }
451 
452  // SelectPoint, unlike other selection routines, can select line ends
453  if( collector[ i ]->Type() == SCH_LINE_T )
454  {
455  SCH_LINE* line = (SCH_LINE*) collector[ i ];
456  line->ClearFlags( STARTPOINT | ENDPOINT );
457 
458  if( HitTestPoints( line->GetStartPoint(), (wxPoint) aWhere, collector.m_Threshold ) )
459  line->SetFlags( STARTPOINT );
460  else if (HitTestPoints( line->GetEndPoint(), (wxPoint) aWhere, collector.m_Threshold ) )
461  line->SetFlags( ENDPOINT );
462  else
463  line->SetFlags( STARTPOINT | ENDPOINT );
464  }
465  }
466 
468 
469  // Apply some ugly heuristics to avoid disambiguation menus whenever possible
470  if( collector.GetCount() > 1 && !m_skip_heuristics )
471  {
472  GuessSelectionCandidates( collector, aWhere );
473  }
474 
475  // If still more than one item we're going to have to ask the user.
476  if( collector.GetCount() > 1 )
477  {
478  collector.m_MenuTitle = _( "Clarify Selection" );
479  // Must call selectionMenu via RunAction() to avoid event-loop contention
480  m_toolMgr->RunAction( EE_ACTIONS::selectionMenu, true, &collector );
481 
482  if( collector.m_MenuCancelled )
483  {
484  if( aSelectionCancelledFlag )
485  *aSelectionCancelledFlag = true;
486 
487  return nullptr;
488  }
489  }
490 
491  if( !aAdd && !aSubtract && !aExclusiveOr )
492  ClearSelection();
493 
494  if( collector.GetCount() == 1 )
495  {
496  EDA_ITEM* item = collector[ 0 ];
497 
498  if( aSubtract || ( aExclusiveOr && item->IsSelected() ) )
499  {
500  unselect( item );
502  return nullptr;
503  }
504  else
505  {
506  select( item );
508  return item;
509  }
510  }
511 
512  return nullptr;
513 }
514 
515 
517 {
518  // There are certain parent/child and enclosure combinations that can be handled
519  // automatically.
520 
521  // Prefer exact hits to sloppy ones
522  int exactHits = 0;
523 
524  for( int i = collector.GetCount() - 1; i >= 0; --i )
525  {
526  EDA_ITEM* item = collector[ i ];
527 
528  if( item->HitTest( (wxPoint) aPos, 0 ) )
529  exactHits++;
530  }
531 
532  if( exactHits > 0 && exactHits < collector.GetCount() )
533  {
534  for( int i = collector.GetCount() - 1; i >= 0; --i )
535  {
536  EDA_ITEM* item = collector[ i ];
537 
538  if( !item->HitTest( (wxPoint) aPos, 0 ) )
539  collector.Remove( item );
540  }
541  }
542 
543  // Prefer a non-sheet to a sheet
544  for( int i = 0; collector.GetCount() == 2 && i < 2; ++i )
545  {
546  EDA_ITEM* item = collector[ i ];
547  EDA_ITEM* other = collector[ ( i + 1 ) % 2 ];
548 
549  if( item->Type() != SCH_SHEET_T && other->Type() == SCH_SHEET_T )
550  collector.Remove( other );
551  }
552 
553  // Prefer a symbol to a pin
554  for( int i = 0; collector.GetCount() == 2 && i < 2; ++i )
555  {
556  EDA_ITEM* item = collector[ i ];
557  EDA_ITEM* other = collector[ ( i + 1 ) % 2 ];
558 
559  if( item->Type() == SCH_COMPONENT_T && other->Type() == SCH_PIN_T )
560  collector.Remove( other );
561  }
562 
563  // Prefer a field to a symbol
564  for( int i = 0; collector.GetCount() == 2 && i < 2; ++i )
565  {
566  EDA_ITEM* item = collector[ i ];
567  EDA_ITEM* other = collector[ ( i + 1 ) % 2 ];
568 
569  if( item->Type() == SCH_FIELD_T && other->Type() == SCH_COMPONENT_T )
570  collector.Remove( other );
571  }
572 
573  // No need for multiple wires at a single point; if there's a junction select that;
574  // otherwise any of the wires will do
575  bool junction = false;
576  bool wiresOnly = true;
577 
578  for( EDA_ITEM* item : collector )
579  {
580  if( item->Type() == SCH_JUNCTION_T )
581  junction = true;
582  else if( item->Type() != SCH_LINE_T )
583  wiresOnly = false;
584  }
585 
586  if( wiresOnly )
587  {
588  for( int j = collector.GetCount() - 1; j >= 0; --j )
589  {
590  if( junction && collector[ j ]->Type() != SCH_JUNCTION_T )
591  collector.Remove( j );
592  else if( !junction && j > 0 )
593  collector.Remove( j );
594  }
595  }
596 }
597 
598 
600 {
601  // Filter an existing selection
602  if( !m_selection.Empty() )
603  {
604  for( int i = m_selection.GetSize() - 1; i >= 0; --i )
605  {
606  EDA_ITEM* item = (EDA_ITEM*) m_selection.GetItem( i );
607 
608  if( !item->IsType( aFilterList ) )
609  {
610  unselect( item );
612  }
613  }
614 
615  }
616 
617  // If nothing was selected, or we filtered everything out, do a hover selection
618  if( m_selection.Empty() )
619  {
620  VECTOR2D cursorPos = getViewControls()->GetCursorPosition( true );
621 
622  ClearSelection();
623  SelectPoint( cursorPos, aFilterList );
624  m_selection.SetIsHover( true );
626  }
627 
629 
630  return m_selection;
631 }
632 
633 
635 {
636  VECTOR2I refP( 0, 0 );
637 
638  if( m_selection.Size() > 0 )
639  {
640  if( m_isLibEdit )
641  refP = static_cast<LIB_ITEM*>( m_selection.GetTopLeftItem() )->GetPosition();
642  else
643  refP = static_cast<SCH_ITEM*>( m_selection.GetTopLeftItem() )->GetPosition();
644  }
645 
647 }
648 
649 
651 {
652  bool cancelled = false; // Was the tool cancelled while it was running?
653  m_multiple = true; // Multiple selection mode is active
654  KIGFX::VIEW* view = getView();
655 
657  view->Add( &area );
658 
659  while( TOOL_EVENT* evt = Wait() )
660  {
661  if( evt->IsCancelInteractive() || evt->IsActivate() )
662  {
663  cancelled = true;
664  break;
665  }
666 
667  if( evt->IsDrag( BUT_LEFT ) )
668  {
670  ClearSelection();
671 
672  // Start drawing a selection box
673  area.SetOrigin( evt->DragOrigin() );
674  area.SetEnd( evt->Position() );
675  area.SetAdditive( m_additive );
678 
679  view->SetVisible( &area, true );
680  view->Update( &area );
681  getViewControls()->SetAutoPan( true );
682  }
683 
684  if( evt->IsMouseUp( BUT_LEFT ) )
685  {
686  getViewControls()->SetAutoPan( false );
687 
688  // End drawing the selection box
689  view->SetVisible( &area, false );
690 
691  // Mark items within the selection box as selected
692  std::vector<KIGFX::VIEW::LAYER_ITEM_PAIR> selectedItems;
693 
694  // Filter the view items based on the selection box
695  BOX2I selectionBox = area.ViewBBox();
696  view->Query( selectionBox, selectedItems ); // Get the list of selected items
697 
698  std::vector<KIGFX::VIEW::LAYER_ITEM_PAIR>::iterator it, it_end;
699 
700  int width = area.GetEnd().x - area.GetOrigin().x;
701  int height = area.GetEnd().y - area.GetOrigin().y;
702 
703  /* Selection mode depends on direction of drag-selection:
704  * Left > Right : Select objects that are fully enclosed by selection
705  * Right > Left : Select objects that are crossed by selection
706  */
707  bool windowSelection = width >= 0;
708  bool anyAdded = false;
709  bool anySubtracted = false;
710 
711  if( view->IsMirroredX() )
712  windowSelection = !windowSelection;
713 
714  // Construct an EDA_RECT to determine EDA_ITEM selection
715  EDA_RECT selectionRect( (wxPoint) area.GetOrigin(), wxSize( width, height ) );
716 
717  selectionRect.Normalize();
718 
719  for( it = selectedItems.begin(), it_end = selectedItems.end(); it != it_end; ++it )
720  {
721  EDA_ITEM* item = static_cast<EDA_ITEM*>( it->first );
722 
723  if( !item || !Selectable( item ) )
724  continue;
725 
726  if( item->HitTest( selectionRect, windowSelection ) )
727  {
728  if( m_subtractive || ( m_exclusive_or && item->IsSelected() ) )
729  {
730  unselect( item );
731  anySubtracted = true;
732  }
733  else
734  {
735  select( item );
736  item->SetFlags( STARTPOINT | ENDPOINT );
737  anyAdded = true;
738  }
739  }
740  }
741 
742  m_selection.SetIsHover( false );
743 
744  // Inform other potentially interested tools
745  if( anyAdded )
747 
748  if( anySubtracted )
750 
751  break; // Stop waiting for events
752  }
753  }
754 
755  getViewControls()->SetAutoPan( false );
756 
757  // Stop drawing the selection box
758  view->Remove( &area );
759  m_multiple = false; // Multiple selection mode is inactive
760 
761  if( !cancelled )
763 
764  return cancelled;
765 }
766 
767 
768 static KICAD_T nodeTypes[] =
769 {
774  SCH_LABEL_T,
779  EOT
780 };
781 
782 
784 {
785  if( m_frame->GetScreen()->GetDrawItems() == nullptr ) // Empty schematics
786  return nullptr;
787 
788  EE_COLLECTOR collector;
789 
790  int thresholdMax = KiROUND( getView()->ToWorld( HITTEST_THRESHOLD_PIXELS ) );
791 
792  for( int threshold : { 0, thresholdMax/2, thresholdMax } )
793  {
794  collector.m_Threshold = threshold;
795  collector.Collect( m_frame->GetScreen()->GetDrawItems(), nodeTypes, (wxPoint) aPosition );
796 
797  if( collector.GetCount() > 0 )
798  break;
799  }
800 
801  return collector.GetCount() ? collector[ 0 ] : nullptr;
802 }
803 
804 
806 {
807  VECTOR2I cursorPos = getViewControls()->GetCursorPosition( !aEvent.Modifier( MD_ALT ) );
808 
809  SelectPoint( cursorPos, nodeTypes );
810 
811  return 0;
812 }
813 
814 
816 {
817  static KICAD_T wiresAndBusses[] = { SCH_LINE_LOCATE_WIRE_T, SCH_LINE_LOCATE_BUS_T, EOT };
818 
819  RequestSelection( wiresAndBusses );
820 
821  if( m_selection.Empty() )
822  return 0;
823 
824  SCH_LINE* line = (SCH_LINE*) m_selection.Front();
825  EDA_ITEMS items;
826 
828  m_frame->GetScreen()->MarkConnections( line );
829 
830  for( EDA_ITEM* item = m_frame->GetScreen()->GetDrawItems(); item; item = item->Next() )
831  {
832  if( item->GetFlags() & CANDIDATE )
833  select( item );
834  }
835 
836  if( m_selection.GetSize() > 1 )
838 
839  return 0;
840 }
841 
842 
844 {
845  AddItemToSel( aEvent.Parameter<EDA_ITEM*>() );
846  m_selection.SetIsHover( false );
847  return 0;
848 }
849 
850 
851 void EE_SELECTION_TOOL::AddItemToSel( EDA_ITEM* aItem, bool aQuietMode )
852 {
853  if( aItem )
854  {
855  select( aItem );
856 
857  // Inform other potentially interested tools
858  if( !aQuietMode )
860  }
861 }
862 
863 
865 {
866  AddItemsToSel( aEvent.Parameter<EDA_ITEMS*>(), false );
867  m_selection.SetIsHover( false );
868  return 0;
869 }
870 
871 
872 void EE_SELECTION_TOOL::AddItemsToSel( EDA_ITEMS* aList, bool aQuietMode )
873 {
874  if( aList )
875  {
876  for( EDA_ITEM* item : *aList )
877  select( item );
878 
879  // Inform other potentially interested tools
880  if( !aQuietMode )
882  }
883 }
884 
885 
887 {
888  RemoveItemFromSel( aEvent.Parameter<EDA_ITEM*>() );
889  m_selection.SetIsHover( false );
890  return 0;
891 }
892 
893 
894 void EE_SELECTION_TOOL::RemoveItemFromSel( EDA_ITEM* aItem, bool aQuietMode )
895 {
896  if( aItem )
897  {
898  unselect( aItem );
899 
900  // Inform other potentially interested tools
901  if( !aQuietMode )
903  }
904 }
905 
906 
908 {
909  RemoveItemsFromSel( aEvent.Parameter<EDA_ITEMS*>(), false );
910  m_selection.SetIsHover( false );
911  return 0;
912 }
913 
914 
915 void EE_SELECTION_TOOL::RemoveItemsFromSel( EDA_ITEMS* aList, bool aQuietMode )
916 {
917  if( aList )
918  {
919  for( EDA_ITEM* item : *aList )
920  unselect( item );
921 
922  // Inform other potentially interested tools
923  if( !aQuietMode )
925  }
926 }
927 
928 
930 {
931  highlight( aItem, BRIGHTENED );
932 }
933 
934 
936 {
937  unhighlight( aItem, BRIGHTENED );
938 }
939 
940 
942 {
943  ClearSelection();
944 
945  return 0;
946 }
947 
948 
950 {
951  m_selection.Clear();
952 
953  EDA_ITEM* start = nullptr;
954 
955  if( m_isLibEdit )
956  start = static_cast<LIB_EDIT_FRAME*>( m_frame )->GetCurPart();
957  else
958  start = m_frame->GetScreen()->GetDrawItems();
959 
960  INSPECTOR_FUNC inspector = [&] ( EDA_ITEM* item, void* testData )
961  {
962  if( item->IsSelected() )
963  select( item );
964 
965  return SEARCH_CONTINUE;
966  };
967 
968  EDA_ITEM::IterateForward( start, inspector, nullptr, EE_COLLECTOR::AllItems );
969 
971 
972  // Inform other potentially interested tools
974 }
975 
976 
978 {
979  EE_COLLECTOR* collector = aEvent.Parameter<EE_COLLECTOR*>();
980 
981  if( !doSelectionMenu( collector ) )
982  collector->m_MenuCancelled = true;
983 
984  return 0;
985 }
986 
987 
989 {
990  EDA_ITEM* current = nullptr;
991  ACTION_MENU menu( true );
992 
993  int limit = std::min( MAX_SELECT_ITEM_IDS, aCollector->GetCount() );
994 
995  for( int i = 0; i < limit; ++i )
996  {
997  wxString text;
998  EDA_ITEM* item = ( *aCollector )[i];
999  text = item->GetSelectMenuText( m_frame->GetUserUnits() );
1000 
1001  wxString menuText = wxString::Format("&%d. %s", i + 1, text );
1002  menu.Add( menuText, i + 1, item->GetMenuImage() );
1003  }
1004 
1005  if( aCollector->m_MenuTitle.Length() )
1006  menu.SetTitle( aCollector->m_MenuTitle );
1007 
1008  menu.SetIcon( info_xpm );
1009  menu.DisplayTitle( true );
1010  SetContextMenu( &menu, CMENU_NOW );
1011 
1012  while( TOOL_EVENT* evt = Wait() )
1013  {
1014  if( evt->Action() == TA_CHOICE_MENU_UPDATE )
1015  {
1016  if( current )
1017  unhighlight( current, BRIGHTENED );
1018 
1019  int id = *evt->GetCommandId();
1020 
1021  // User has pointed an item, so show it in a different way
1022  if( id > 0 && id <= limit )
1023  {
1024  current = ( *aCollector )[id - 1];
1025  highlight( current, BRIGHTENED );
1026  }
1027  else
1028  {
1029  current = nullptr;
1030  }
1031  }
1032  else if( evt->Action() == TA_CHOICE_MENU_CHOICE )
1033  {
1034  if( current )
1035  unhighlight( current, BRIGHTENED );
1036 
1037  OPT<int> id = evt->GetCommandId();
1038 
1039  // User has selected an item, so this one will be returned
1040  if( id && ( *id > 0 ) )
1041  current = ( *aCollector )[*id - 1];
1042  else
1043  current = nullptr;
1044 
1045  break;
1046  }
1047 
1048  getView()->UpdateItems();
1049  m_frame->GetCanvas()->Refresh();
1050  }
1051 
1052  if( current )
1053  {
1054  unhighlight( current, BRIGHTENED );
1055 
1056  getView()->UpdateItems();
1057  m_frame->GetCanvas()->Refresh();
1058 
1059  aCollector->Empty();
1060  aCollector->Append( current );
1061  return true;
1062  }
1063 
1064  return false;
1065 }
1066 
1067 
1068 bool EE_SELECTION_TOOL::Selectable( const EDA_ITEM* aItem, bool checkVisibilityOnly ) const
1069 {
1070  // NOTE: in the future this is where eeschema layer/itemtype visibility will be handled
1071 
1072  switch( aItem->Type() )
1073  {
1074  case SCH_PIN_T:
1075  if( !static_cast<const SCH_PIN*>( aItem )->IsVisible() && !m_frame->GetShowAllPins() )
1076  return false;
1077  break;
1078 
1079  case LIB_PART_T: // In libedit we do not want to select the symbol itself.
1080  return false;
1081 
1082  case LIB_ARC_T:
1083  case LIB_CIRCLE_T:
1084  case LIB_TEXT_T:
1085  case LIB_RECTANGLE_T:
1086  case LIB_POLYLINE_T:
1087  case LIB_BEZIER_T:
1088  case LIB_PIN_T:
1089  {
1090  LIB_EDIT_FRAME* editFrame = (LIB_EDIT_FRAME*) m_frame;
1091  LIB_ITEM* lib_item = (LIB_ITEM*) aItem;
1092 
1093  if( lib_item->GetUnit() && lib_item->GetUnit() != editFrame->GetUnit() )
1094  return false;
1095 
1096  if( lib_item->GetConvert() && lib_item->GetConvert() != editFrame->GetConvert() )
1097  return false;
1098 
1099  break;
1100  }
1101  case SCH_MARKER_T: // Always selectable
1102  return true;
1103 
1104  default: // Suppress warnings
1105  break;
1106  }
1107 
1108  return true;
1109 }
1110 
1111 
1113 {
1114  if( m_selection.Empty() )
1115  return;
1116 
1117  while( m_selection.GetSize() )
1119 
1120  getView()->Update( &m_selection );
1121 
1122  m_selection.SetIsHover( false );
1124 
1125  // Inform other potentially interested tools
1127 }
1128 
1129 
1131 {
1132  highlight( aItem, SELECTED, &m_selection );
1133 }
1134 
1135 
1137 {
1138  unhighlight( aItem, SELECTED, &m_selection );
1139 }
1140 
1141 
1142 void EE_SELECTION_TOOL::highlight( EDA_ITEM* aItem, int aMode, EE_SELECTION* aGroup )
1143 {
1144  KICAD_T itemType = aItem->Type();
1145 
1146  if( aMode == SELECTED )
1147  aItem->SetSelected();
1148  else if( aMode == BRIGHTENED )
1149  aItem->SetBrightened();
1150 
1151  if( aGroup )
1152  aGroup->Add( aItem );
1153 
1154  // Highlight pins and fields. (All the other component children are currently only
1155  // represented in the LIB_PART and will inherit the settings of the parent component.)
1156  if( itemType == SCH_COMPONENT_T )
1157  {
1158  SCH_PINS& pins = static_cast<SCH_COMPONENT*>( aItem )->GetPins();
1159 
1160  for( SCH_PIN& pin : pins )
1161  {
1162  if( aMode == SELECTED )
1163  pin.SetSelected();
1164  else if( aMode == BRIGHTENED )
1165  pin.SetBrightened();
1166  }
1167 
1168  std::vector<SCH_FIELD*> fields;
1169  static_cast<SCH_COMPONENT*>( aItem )->GetFields( fields, false );
1170 
1171  for( SCH_FIELD* field : fields )
1172  {
1173  if( aMode == SELECTED )
1174  field->SetSelected();
1175  else if( aMode == BRIGHTENED )
1176  field->SetBrightened();
1177  }
1178  }
1179  else if( itemType == SCH_SHEET_T )
1180  {
1181  SCH_SHEET_PINS& pins = static_cast<SCH_SHEET*>( aItem )->GetPins();
1182 
1183  for( SCH_SHEET_PIN& pin : pins )
1184  {
1185  if( aMode == SELECTED )
1186  pin.SetSelected();
1187  else if( aMode == BRIGHTENED )
1188  pin.SetBrightened();
1189  }
1190  }
1191 
1192  if( itemType == SCH_PIN_T || itemType == SCH_FIELD_T || itemType == SCH_SHEET_PIN_T )
1193  getView()->Update( aItem->GetParent() );
1194  else
1195  getView()->Update( aItem );
1196 }
1197 
1198 
1199 void EE_SELECTION_TOOL::unhighlight( EDA_ITEM* aItem, int aMode, EE_SELECTION* aGroup )
1200 {
1201  KICAD_T itemType = aItem->Type();
1202 
1203  if( aMode == SELECTED )
1204  aItem->ClearSelected();
1205  else if( aMode == BRIGHTENED )
1206  aItem->ClearBrightened();
1207 
1208  if( aGroup )
1209  aGroup->Remove( aItem );
1210 
1211  // Unhighlight pins and fields. (All the other component children are currently only
1212  // represented in the LIB_PART.)
1213  if( itemType == SCH_COMPONENT_T )
1214  {
1215  SCH_PINS& pins = static_cast<SCH_COMPONENT*>( aItem )->GetPins();
1216 
1217  for( SCH_PIN& pin : pins )
1218  {
1219  if( aMode == SELECTED )
1220  pin.ClearSelected();
1221  else if( aMode == BRIGHTENED )
1222  pin.ClearBrightened();
1223  }
1224 
1225  std::vector<SCH_FIELD*> fields;
1226  static_cast<SCH_COMPONENT*>( aItem )->GetFields( fields, false );
1227 
1228  for( SCH_FIELD* field : fields )
1229  {
1230  if( aMode == SELECTED )
1231  field->ClearSelected();
1232  else if( aMode == BRIGHTENED )
1233  field->ClearBrightened();
1234  }
1235  }
1236  else if( itemType == SCH_SHEET_T )
1237  {
1238  SCH_SHEET_PINS& pins = static_cast<SCH_SHEET*>( aItem )->GetPins();
1239 
1240  for( SCH_SHEET_PIN& pin : pins )
1241  {
1242  if( aMode == SELECTED )
1243  pin.ClearSelected();
1244  else if( aMode == BRIGHTENED )
1245  pin.ClearBrightened();
1246  }
1247  }
1248 
1249  if( itemType == SCH_PIN_T || itemType == SCH_FIELD_T || itemType == SCH_SHEET_PIN_T )
1250  getView()->Update( aItem->GetParent() );
1251  else
1252  getView()->Update( aItem );
1253 }
1254 
1255 
1257 {
1258  const unsigned GRIP_MARGIN = 20;
1259  VECTOR2I margin = getView()->ToWorld( VECTOR2I( GRIP_MARGIN, GRIP_MARGIN ), false );
1260 
1261  // Check if the point is located within any of the currently selected items bounding boxes
1262  for( auto item : m_selection )
1263  {
1264  BOX2I itemBox = item->ViewBBox();
1265  itemBox.Inflate( margin.x, margin.y ); // Give some margin for gripping an item
1266 
1267  if( itemBox.Contains( aPoint ) )
1268  return true;
1269  }
1270 
1271  return false;
1272 }
1273 
1274 
1276 {
1278 
1283 
1289 }
1290 
1291 
void Empty()
Function Empty sets the list to empty.
Definition: collector.h:122
void ClearReferencePoint()
Definition: selection.h:248
static TOOL_ACTION pinTable
Definition: ee_actions.h:150
static TOOL_ACTION properties
Definition: ee_actions.h:122
Class SCH_FIELD instances are attached to a component and provide a place for the component's value,...
Definition: sch_field.h:52
void AddStandardSubMenus(TOOL_MENU &aMenu)
Function CreateBasicMenu.
wxMenuItem * Add(const wxString &aLabel, int aId, const BITMAP_OPAQUE *aIcon)
Function Add() Adds a wxWidgets-style entry to the menu.
static const TOOL_EVENT SelectedEvent
Definition: actions.h:196
void SetEnd(VECTOR2I aEnd)
Set the current end of the rectangle (the corner that moves with the cursor.
TOOL_MENU m_menu
functions below are not yet implemented - their interface may change
bool selectionContains(const VECTOR2I &aPoint) const
Function selectionContains() Checks if the given point is placed within any of selected items' boundi...
int m_Threshold
Definition: collector.h:68
int UpdateMenu(const TOOL_EVENT &aEvent)
virtual void Clear() override
Function Clear() Removes all the stored items from the group.
Definition: selection.h:93
PART_REF & GetPartRef()
std::function< SEARCH_RESULT(EDA_ITEM *aItem, void *aTestData) > INSPECTOR_FUNC
Typedef INSPECTOR is used to inspect and possibly collect the (search) results of iterating over a li...
Definition: base_struct.h:83
static bool IsDrawingWire(const SELECTION &aSelection)
#define MAX_SELECT_ITEM_IDS
The maximum number of items in the clarify selection context menu.
Definition: eeschema_id.h:37
TOOL_EVENT * Wait(const TOOL_EVENT_LIST &aEventList=TOOL_EVENT(TC_ANY, TA_ANY))
Function Wait()
static TOOL_ACTION breakBus
Definition: ee_actions.h:138
static int KiROUND(double v)
Round a floating point number to an integer using "round halfway cases away from zero".
Definition: common.h:115
static SELECTION_CONDITION SingleSymbol
int GetConvert() const
wxPoint GetStartPoint() const
Definition: sch_line.h:90
bool IsSelected() const
Definition: base_struct.h:233
Model changes (required full reload)
Definition: tool_base.h:82
static const TOOL_EVENT UnselectedEvent
Definition: actions.h:197
SCH_SHEET * Last() const
Function Last returns a pointer to the last sheet of the list One can see the others sheet as the "pa...
Class ACTION_MENU.
Definition: action_menu.h:43
VECTOR2D ToWorld(const VECTOR2D &aCoord, bool aAbsolute=true) const
Function ToWorld() Converts a screen space point/vector to a point/vector in world space coordinates.
Definition: view.cpp:475
SCH_ITEM * Next() const
Definition: sch_item.h:153
std::vector< SCH_PIN > SCH_PINS
A container for several SCH_PIN items.
Definition: sch_component.h:51
void SetOrigin(VECTOR2I aOrigin)
Set the origin of the rectange (the fixed corner)
void ClearSelected()
Definition: base_struct.h:243
static SELECTION_CONDITION MoreThan(int aNumber)
Function MoreThan Creates a functor that tests if the number of selected items is greater than the va...
void SetCurrentCursor(wxStockCursor aStockCursorID)
Function SetCurrentCursor Set the current cursor shape for this panel.
static TOOL_ACTION addItemsToSel
Selects a list of items (specified as the event parameter)
Definition: ee_actions.h:65
VIEW_CONTROLS class definition.
static SELECTION_CONDITION OnlyTypes(const KICAD_T aTypes[])
Function OnlyTypes Creates a functor that tests if the selected items are only of given types.
CONDITIONAL_MENU & GetMenu()
Function GetMenu.
Definition: tool_menu.cpp:46
static TOOL_ACTION placeHierLabel
Definition: ee_actions.h:90
TOOL_MANAGER * m_toolMgr
Definition: tool_base.h:219
static TOOL_ACTION placeJunction
Definition: ee_actions.h:85
static TOOL_ACTION selectConnection
If current selection is a wire or bus, expand to entire connection.
Definition: ee_actions.h:55
SCH_SCREEN * GetScreen() const override
Return a pointer to a BASE_SCREEN or one of its derivatives.
virtual void Remove(VIEW_ITEM *aItem)
Function Remove() Removes a VIEW_ITEM from the view.
Definition: view.cpp:376
static SELECTION_CONDITION IdleSelection
bool selectMultiple()
Function selectMultiple() Handles drawing a selection box that allows one to select many items at the...
static TOOL_ACTION unfoldBus
Definition: ee_actions.h:83
void SetBrightened()
Definition: base_struct.h:241
#define HITTEST_THRESHOLD_PIXELS
bool RunAction(const std::string &aActionName, bool aNow=false, T aParam=NULL)
Function RunAction() Runs the specified action.
Definition: tool_manager.h:109
void SetExclusiveOr(bool aExclusiveOr)
Class EE_COLLECTOR.
Definition: ee_collectors.h:39
bool Selectable(const EDA_ITEM *aItem, bool checkVisibilityOnly=false) const
Function Selectable() Checks conditions for an item to be selected.
virtual bool IsType(const KICAD_T aScanTypes[])
Function IsType Checks whether the item is one of the listed types.
Definition: base_struct.h:293
int AddItemsToSel(const TOOL_EVENT &aEvent)
void select(EDA_ITEM *aItem)
Function select() Takes necessary action mark an item as selected.
void UpdateAll()
Function UpdateAll() Runs update handlers for the menu and its submenus.
#define CANDIDATE
flag indicating that the structure is connected
Definition: base_struct.h:130
static TOOL_ACTION removeItemsFromSel
Definition: ee_actions.h:66
static SELECTION_CONDITION Idle
static SELECTION_CONDITION Count(int aNumber)
Function Count Creates a functor that tests if the number of selected items is equal to the value giv...
void SetContextMenu(ACTION_MENU *aMenu, CONTEXT_MENU_TRIGGER aTrigger=CMENU_BUTTON)
Function SetContextMenu()
VECTOR2< int > VECTOR2I
Definition: vector2d.h:587
void Go(int(T::*aStateFunc)(const TOOL_EVENT &), const TOOL_EVENT_LIST &aConditions=TOOL_EVENT(TC_ANY, TA_ANY))
Function Go()
void Remove(int aIndex)
Function Remove removes the item at aIndex (first position is 0);.
Definition: collector.h:142
bool InvokeTool(TOOL_ID aToolId)
Function InvokeTool() Calls a tool by sending a tool activation event to tool of given ID.
Symbol library viewer main window.
Definition: viewlib_frame.h:43
search types array terminator (End Of Types)
Definition: typeinfo.h:82
KICAD_T
Enum KICAD_T is the set of class identification values, stored in EDA_ITEM::m_StructType.
Definition: typeinfo.h:78
PAINTER * GetPainter() const
Function GetPainter() Returns the painter object used by the view for drawing VIEW_ITEMS.
Definition: view.h:199
void GuessSelectionCandidates(EE_COLLECTOR &collector, const VECTOR2I &aPos)
Apply heuristics to try and determine a single object when multiple are found under the cursor.
The base class for drawable items used by schematic library components.
Definition: lib_item.h:61
static TOOL_ACTION breakWire
Definition: ee_actions.h:137
void SetIsHover(bool aIsHover)
Definition: selection.h:64
virtual void Add(EDA_ITEM *aItem)
Definition: selection.h:74
static TOOL_ACTION leaveSheet
Definition: ee_actions.h:177
void ClearBrightened()
Definition: base_struct.h:245
static TOOL_ACTION removeItemFromSel
Definition: ee_actions.h:62
void Append(EDA_ITEM *item)
Function Append adds an item to the end of the list.
Definition: collector.h:132
void SetAdditive(bool aAdditive)
bool m_MenuCancelled
Definition: collector.h:71
EE_SELECTION & GetSelection()
Function GetSelection()
EE_SELECTION & RequestSelection(const KICAD_T *aFilterList=EE_COLLECTOR::AllItems)
Function RequestSelection()
virtual bool HitTest(const wxPoint &aPosition, int aAccuracy=0) const
Function HitTest tests if aPosition is contained within or on the bounding box of an item.
Definition: base_struct.h:339
void updateReferencePoint()
Sets the reference point to the anchor of the top-left item.
static SELECTION_CONDITION SingleDeMorganSymbol
int GetCount() const
Function GetCount returns the number of objects in the list.
Definition: collector.h:113
void Reset(RESET_REASON aReason) override
Function Reset() Brings the tool to a known, initial state.
#define SELECTED
Definition: base_struct.h:127
int SelectNode(const TOOL_EVENT &aEvent)
Select node under cursor
void SetReferencePoint(const VECTOR2I &aP)
Definition: selection.h:243
int GetUnit() const
Definition: lib_item.h:301
bool Init() override
Function Init() Init() is called once upon a registration of the tool.
void BrightenItem(EDA_ITEM *aItem)
void highlight(EDA_ITEM *aItem, int aHighlightMode, EE_SELECTION *aGroup=nullptr)
Function highlight() Highlights the item visually.
int GetUnit() const
static SELECTION_CONDITION Empty
void SetFlags(STATUS_FLAGS aMask)
Definition: base_struct.h:265
SCH_SHEET * g_RootSheet
Definition: eeschema.cpp:47
static TOOL_ACTION addItemToSel
Selects an item (specified as the event parameter).
Definition: ee_actions.h:61
SCH_SHEET_PATH * g_CurrentSheet
With the new connectivity algorithm, many more places than before want to know what the current sheet...
void SetSelected()
Definition: base_struct.h:239
void SetHighlight(bool aEnabled, int aNetcode=-1, bool aHighlightItems=false)
Function SetHighlight Turns on/off highlighting - it may be done for the active layer,...
Definition: painter.h:141
static TOOL_ACTION drawWire
Definition: ee_actions.h:81
static TOOL_ACTION placeSheetPin
Definition: ee_actions.h:92
bool ProcessEvent(const TOOL_EVENT &aEvent)
Propagates an event to tools that requested events of matching type(s).
std::vector< EDA_ITEM * > EDA_ITEMS
Define list of drawing items for screens.
Definition: base_struct.h:622
static TOOL_ACTION explicitCrossProbe
Definition: ee_actions.h:186
void MarkConnections(SCH_LINE *aSegment)
Add all wires and junctions connected to aSegment which are not connected any component pin to aItemL...
Definition: sch_screen.cpp:305
T Parameter() const
Function Parameter() Returns a non-standard parameter assigned to the event.
Definition: tool_event.h:427
static TOOL_ACTION symbolProperties
Definition: ee_actions.h:149
SCH_DRAW_PANEL * GetCanvas() const override
Return a pointer to GAL-based canvas of given EDA draw frame.
void SetIcon(const BITMAP_OPAQUE *aIcon)
Function SetIcon() Assigns an icon for the entry.
Definition: action_menu.cpp:68
bool Contains(const Vec &aPoint) const
Function Contains.
Definition: box2.h:149
Class TOOL_EVENT.
Definition: tool_event.h:168
const BOX2I ViewBBox() const override
Function ViewBBox() returns the bounding box of the item covering all its layers.
void Collect(EDA_ITEM *aItem, const KICAD_T aFilterList[], const wxPoint &aPos, int aUnit=0, int aConvert=0)
Function Collect scans a EDA_ITEM using this class's Inspector method, which does the collection.
#define BRIGHTENED
item is drawn with a bright contour
Definition: base_struct.h:143
EDA_ITEM * GetParent() const
Definition: base_struct.h:220
static SEARCH_RESULT IterateForward(EDA_ITEM *listStart, INSPECTOR inspector, void *testData, const KICAD_T scanTypes[])
Function IterateForward walks through the object tree calling the inspector() on each object type req...
Definition: base_struct.h:417
VIEW_GROUP extends VIEW_ITEM by possibility of grouping items into a single object.
int SelectConnection(const TOOL_EVENT &aEvent)
If node selected then expand to connection, otherwise select connection under cursor
static const TOOL_EVENT ClearedEvent
Definition: actions.h:198
std::function< bool(const SELECTION &)> SELECTION_CONDITION
Functor type that checks a specific condition for selected items.
void UpdateItems()
Function UpdateItems() Iterates through the list of items that asked for updating and updates them.
Definition: view.cpp:1421
static TOOL_ACTION selectionActivate
Activation of the selection tool.
Definition: ee_actions.h:48
Define a sheet pin (label) used in sheets to create hierarchical schematics.
Definition: sch_sheet.h:75
static TOOL_ACTION importSheetPin
Definition: ee_actions.h:93
static TOOL_ACTION clearSelection
Clears the current selection.
Definition: ee_actions.h:58
static TOOL_ACTION updateMenu
Definition: actions.h:157
static SELECTION_CONDITION SingleMultiUnitSymbol
virtual KIGFX::VIEW_ITEM * GetItem(unsigned int aIdx) const override
Definition: selection.h:103
virtual void Update(VIEW_ITEM *aItem, int aUpdateFlags)
For dynamic VIEWs, informs the associated VIEW that the graphical representation of this item has cha...
Definition: view.cpp:1540
int GetConvert() const
Definition: lib_item.h:304
#define _(s)
void UnbrightenItem(EDA_ITEM *aItem)
EDA_ITEM * GetNode(VECTOR2I aPosition)
Find (but don't select) node under cursor
KIGFX::VIEW * getView() const
Function getView()
Definition: tool_base.cpp:36
virtual void SetAutoPan(bool aEnabled)
Function SetAutoPan Turns on/off auto panning (this feature is used when there is a tool active (eg.
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...
bool Empty() const
Checks if there is anything selected.
Definition: selection.h:119
static bool IsDrawingBus(const SELECTION &aSelection)
static TOOL_ACTION drawBus
Definition: ee_actions.h:82
wxString m_MenuTitle
Definition: collector.h:70
bool IsMirroredX() const
Function IsMirroredX() Returns true if view is flipped across the X axis.
Definition: view.h:230
void SetSubtractive(bool aSubtractive)
virtual unsigned int GetSize() const override
Function GetSize() Returns the number of stored items.
Definition: selection.h:98
int Modifier(int aMask=MD_MODIFIER_MASK) const
Returns information about key modifiers state (Ctrl, Alt, etc.)
Definition: tool_event.h:334
static TOOL_ACTION placeLabel
Definition: ee_actions.h:88
int RemoveItemFromSel(const TOOL_EVENT &aEvent)
void Normalize()
Function Normalize ensures that the height ant width are positive.
void unselect(EDA_ITEM *aItem)
Function unselect() Takes necessary action mark an item as unselected.
EDA_ITEM * GetTopLeftItem(bool onlyModules=false) const override
virtual RENDER_SETTINGS * GetSettings()=0
Function GetSettings Returns pointer to current settings that are going to be used when drawing items...
BOX2< Vec > & Inflate(coord_type dx, coord_type dy)
Function Inflate inflates the rectangle horizontally by dx and vertically by dy.
Definition: box2.h:300
static KICAD_T nodeTypes[]
The symbol library editor main window.
void SetTitle(const wxString &aTitle) override
Function SetTitle() Sets title for the menu.
Definition: action_menu.cpp:86
int AddItemToSel(const TOOL_EVENT &aEvent)
bool ToolStackIsEmpty()
boost::ptr_vector< SCH_SHEET_PIN > SCH_SHEET_PINS
Definition: sch_sheet.h:198
Segment description base class to describe items which have 2 end points (track, wire,...
Definition: sch_line.h:37
void Format(OUTPUTFORMATTER *out, int aNestLevel, int aCtl, CPTREE &aTree)
Function Format outputs a PTREE into s-expression format via an OUTPUTFORMATTER derivative.
Definition: ptree.cpp:205
virtual bool GetShowAllPins() const
Allow some frames to show/hide hidden pins.
EDA_UNITS_T GetUserUnits() const
Return the user units currently in use.
int SelectionMenu(const TOOL_EVENT &aEvent)
Function SelectionMenu() Shows a popup menu to trim the COLLECTOR passed as aEvent's parameter down t...
bool doSelectionMenu(EE_COLLECTOR *aItems)
Allows the selection of a single item from a list via pop-up menu.
SCH_BASE_FRAME * m_frame
bool HitTestPoints(const wxPoint &pointA, const wxPoint &pointB, double threshold)
Test, if two points are near each other.
Definition: trigo.h:161
static TOOL_ACTION selectionMenu
Runs a selection menu to select from a list of items.
Definition: ee_actions.h:69
size_t i
Definition: json11.cpp:597
#define ENDPOINT
ends. (Used to support dragging.)
Definition: base_struct.h:126
static SELECTION_CONDITION OnlyType(KICAD_T aType)
Function OnlyType Creates a functor that tests if the selected items are only of given type.
void RebuildSelection()
Rebuilds the selection from the EDA_ITEMs' selection flags.
Class EDA_RECT handles the component boundary box.
Definition: eda_rect.h:44
static const KICAD_T AllItems[]
Definition: ee_collectors.h:42
int Size() const
Returns the number of selected parts.
Definition: selection.h:125
Class SCH_COMPONENT describes a real schematic component.
Definition: sch_component.h:73
virtual wxString GetSelectMenuText(EDA_UNITS_T aUnits) const
Function GetSelectMenuText returns the text to display to be used in the selection clarification cont...
static TOOL_ACTION selectNode
Select the junction, wire or bus segment under the cursor.
Definition: ee_actions.h:51
Class EDA_ITEM is a base class for most all the KiCad significant classes, used in schematics and boa...
Definition: base_struct.h:163
RESET_REASON
Determines the reason of reset for a tool
Definition: tool_base.h:79
static TOOL_ACTION enterSheet
Definition: ee_actions.h:176
boost::optional< T > OPT
Definition: optional.h:7
void ClearFlags(STATUS_FLAGS aMask=EDA_ITEM_ALL_FLAGS)
Definition: base_struct.h:266
void SetVisible(VIEW_ITEM *aItem, bool aIsVisible=true)
Sets the item visibility.
Definition: view.cpp:1486
Class SELECTION_AREA.
virtual void Add(VIEW_ITEM *aItem, int aDrawPriority=-1)
Function Add() Adds a VIEW_ITEM to the view.
Definition: view.cpp:346
void setTransitions() override
Sets up handlers for various events.
void ClearDrawingState()
Clear the state flags of all the items in the screen.
Definition: sch_screen.cpp:613
virtual int Query(const BOX2I &aRect, std::vector< LAYER_ITEM_PAIR > &aResult) const
Function Query() Finds all visible items that touch or are within the rectangle aRect.
Definition: view.cpp:452
KIGFX::VIEW_CONTROLS * getViewControls() const
Function getViewControls()
Definition: tool_base.cpp:42
Class VIEW.
Definition: view.h:61
EDA_ITEM * SelectPoint(const VECTOR2I &aWhere, const KICAD_T *aFilterList=EE_COLLECTOR::AllItems, bool *aSelectionCancelledFlag=NULL, bool aCheckLocked=false, bool aAdd=false, bool aSubtract=false, bool aExclusiveOr=false)
Function selectPoint() Selects an item pointed by the parameter aWhere.
static TOOL_ACTION placeGlobalLabel
Definition: ee_actions.h:89
static TOOL_ACTION finishBus
Definition: ee_actions.h:99
int RemoveItemsFromSel(const TOOL_EVENT &aEvent)
virtual BITMAP_DEF GetMenuImage() const
Function GetMenuImage returns a pointer to an image to be used in menus.
void AddItem(const TOOL_ACTION &aAction, const SELECTION_CONDITION &aCondition, int aOrder=ANY_ORDER)
Function AddItem()
EE_SELECTION m_selection
void ShowContextMenu(SELECTION &aSelection)
Function ShowContextMenu.
Definition: tool_menu.cpp:59
bool GetDragSelects() const
Indicates that a drag should draw a selection rectangle, even when started over an item.
static TOOL_ACTION finishWire
Definition: ee_actions.h:98
void unhighlight(EDA_ITEM *aItem, int aHighlightMode, EE_SELECTION *aGroup=nullptr)
Function unhighlight() Unhighlights the item visually.
VECTOR2D GetCursorPosition() const
Returns the current cursor position in world coordinates.
EDA_ITEM * Front() const
Definition: selection.h:182
KICAD_T Type() const
Function Type()
Definition: base_struct.h:210
#define min(a, b)
Definition: auxiliary.h:85
int Main(const TOOL_EVENT &aEvent)
Function Main()
#define STARTPOINT
When a line is selected, these flags indicate which.
Definition: base_struct.h:125
void DisplayTitle(bool aDisplay=true)
Function DisplayTitle() Decides whether a title for a pop up menu should be displayed.
Definition: action_menu.cpp:97
SCH_ITEM * GetDrawItems() const
Definition: sch_screen.h:147
virtual void Remove(EDA_ITEM *aItem)
Definition: selection.h:85
wxPoint GetEndPoint() const
Definition: sch_line.h:93