KiCad PCB EDA Suite
PCB_SELECTION_TOOL Class Reference

The selection tool: currently supports: More...

#include <pcb_selection_tool.h>

Inheritance diagram for PCB_SELECTION_TOOL:
SELECTION_TOOL PCB_TOOL_BASE TOOL_INTERACTIVE TOOL_BASE

Classes

class  PRIV
 Private implementation of firewalled private data. More...
 

Public Types

enum  RESET_REASON { RUN, MODEL_RELOAD, GAL_SWITCH }
 Determine the reason of reset for a tool. More...
 

Public Member Functions

 PCB_SELECTION_TOOL ()
 
 ~PCB_SELECTION_TOOL ()
 
bool Init () override
 Init() is called once upon a registration of the tool. More...
 
void Reset (RESET_REASON aReason) override
 Bring the tool to a known, initial state. More...
 
void OnIdle (wxIdleEvent &aEvent)
 
int Main (const TOOL_EVENT &aEvent)
 The main loop. More...
 
PCB_SELECTIONGetSelection ()
 Return the set of currently selected items. More...
 
PCB_SELECTIONRequestSelection (CLIENT_SELECTION_FILTER aClientFilter, bool aConfirmLockedItems=false)
 Return the current selection set, filtered according to aFlags and aClientFilter. More...
 
int CursorSelection (const TOOL_EVENT &aEvent)
 Clear current selection event handler. More...
 
int ClearSelection (const TOOL_EVENT &aEvent)
 
void ClearSelection (bool aQuietMode=false)
 Item selection event handler. More...
 
int SelectItem (const TOOL_EVENT &aEvent)
 
void AddItemToSel (BOARD_ITEM *aItem, bool aQuietMode=false)
 Select all items on the board. More...
 
int SelectAll (const TOOL_EVENT &aEvent)
 Multiple item selection event handler. More...
 
int SelectItems (const TOOL_EVENT &aEvent)
 Item unselection event handler. More...
 
int UnselectItem (const TOOL_EVENT &aEvent)
 
void RemoveItemFromSel (BOARD_ITEM *aItem, bool aQuietMode=false)
 Multiple item unselection event handler. More...
 
int UnselectItems (const TOOL_EVENT &aEvent)
 
void BrightenItem (BOARD_ITEM *aItem)
 
void UnbrightenItem (BOARD_ITEM *aItem)
 
void FindItem (BOARD_ITEM *aItem)
 Handle finding an item. More...
 
void select (BOARD_ITEM *aItem)
 Take necessary action mark an item as selected. More...
 
bool Selectable (const BOARD_ITEM *aItem, bool checkVisibilityOnly=false) const
 Check conditions for an item to be selected. More...
 
void GuessSelectionCandidates (GENERAL_COLLECTOR &aCollector, const VECTOR2I &aWhere) const
 Try to guess best selection candidates in case multiple items are clicked, by doing some brain-dead heuristics. More...
 
int SelectionMenu (const TOOL_EVENT &aEvent)
 Show a popup menu to trim the COLLECTOR passed as aEvent's parameter down to a single item. More...
 
void RebuildSelection ()
 Rebuild the selection from the EDA_ITEMs' selection flags. More...
 
SELECTION_FILTER_OPTIONSGetFilter ()
 Set up handlers for various events. More...
 
void setTransitions () override
 Zoom the screen to center and fit the current selection. More...
 
void zoomFitSelection ()
 
BOARDGetBoard () const
 
void EnterGroup ()
 
void ExitGroup (bool aSelectGroup=false)
 Leave the currently entered group. More...
 
PCB_GROUPGetEnteredGroup ()
 
void FilterCollectorForHierarchy (GENERAL_COLLECTOR &aCollector, bool aMultiselect) const
 In general we don't want to select both a parent and any of it's children. More...
 
void FilterCollectedItems (GENERAL_COLLECTOR &aCollector)
 
void SetIsFootprintEditor (bool aEnabled)
 Function SetIsFootprintEditor() More...
 
bool IsFootprintEditor () const
 
bool Is45Limited () const
 Should the tool use its 45° mode option? More...
 
void Activate ()
 Run the tool. More...
 
TOOL_MENUGetToolMenu ()
 
void SetContextMenu (ACTION_MENU *aMenu, CONTEXT_MENU_TRIGGER aTrigger=CMENU_BUTTON)
 Assign a context menu and tells when it should be activated. More...
 
void RunMainStack (std::function< void()> aFunc)
 Call a function using the main stack. More...
 
template<class T >
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). More...
 
TOOL_EVENTWait (const TOOL_EVENT_LIST &aEventList=TOOL_EVENT(TC_ANY, TA_ANY))
 Suspend execution of the tool until an event specified in aEventList arrives. More...
 
TOOL_TYPE GetType () const
 Return the type of the tool. More...
 
TOOL_ID GetId () const
 Return the unique identifier of the tool. More...
 
const std::string & GetName () const
 Return the name of the tool. More...
 
TOOL_MANAGERGetManager () const
 Return the instance of TOOL_MANAGER that takes care of the tool. More...
 
bool IsToolActive () const
 

Protected Types

enum  INTERACTIVE_PLACEMENT_OPTIONS { IPO_ROTATE = 0x01, IPO_FLIP = 0x02, IPO_SINGLE_CLICK = 0x04, IPO_REPEAT = 0x08 }
 Options for placing items interactively. More...
 

Protected Member Functions

void setModifiersState (bool aShiftState, bool aCtrlState, bool aAltState)
 Set the configuration of m_additive, m_subtractive, m_exclusive_or, m_skip_heuristics from the state of modifier keys SHIFT, CTRL, ALT and depending on the OS. More...
 
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 (perhaps with a dialog or other user interaction), then have it move with the mouse and respond to rotate/flip, etc. More...
 
KIGFX::PCB_VIEWview () const
 
KIGFX::VIEW_CONTROLScontrols () const
 
PCB_BASE_EDIT_FRAMEframe () const
 
BOARDboard () const
 
FOOTPRINTfootprint () const
 
const PCB_DISPLAY_OPTIONSdisplayOptions () const
 
PCB_DRAW_PANEL_GALcanvas () const
 
const PCB_SELECTIONselection () const
 
PCB_SELECTIONselection ()
 
void attachManager (TOOL_MANAGER *aManager)
 Set the TOOL_MANAGER the tool will belong to. More...
 
KIGFX::VIEWgetView () const
 Returns the instance of #VIEW object used in the application. More...
 
KIGFX::VIEW_CONTROLSgetViewControls () const
 Return the instance of VIEW_CONTROLS object used in the application. More...
 
template<typename T >
T * getEditFrame () const
 Return the application window object, casted to requested user type. More...
 
template<typename T >
T * getModel () const
 Return the model object if it matches the requested type. More...
 

Protected Attributes

bool m_additive
 
bool m_subtractive
 
bool m_exclusive_or
 
bool m_multiple
 
bool m_skip_heuristics
 
bool m_highlight_modifier
 
bool m_drag_additive
 
bool m_drag_subtractive
 
bool m_canceledMenu
 
wxTimer m_disambiguateTimer
 
VECTOR2I m_originalCursor
 
bool m_isFootprintEditor
 
TOOL_MENU m_menu
 The functions below are not yet implemented - their interface may change. More...
 
TOOL_TYPE m_type
 Unique identifier for the tool, assigned by a TOOL_MANAGER instance. More...
 
TOOL_ID m_toolId
 Name of the tool. More...
 
std::string m_toolName
 
TOOL_MANAGERm_toolMgr
 

Private Types

enum  STOP_CONDITION { STOP_AT_JUNCTION, STOP_AT_PAD, STOP_NEVER }
 

Private Member Functions

bool selectPoint (const VECTOR2I &aWhere, bool aOnDrag=false, bool *aSelectionCancelledFlag=nullptr, CLIENT_SELECTION_FILTER aClientFilter=nullptr)
 Select an item pointed by the parameter aWhere. More...
 
bool selectCursor (bool aForceSelect=false, CLIENT_SELECTION_FILTER aClientFilter=nullptr)
 Select an item under the cursor unless there is something already selected or aSelectAlways is true. More...
 
bool selectMultiple ()
 Handle drawing a selection box that allows one to select many items at the same time. More...
 
bool doSelectionMenu (GENERAL_COLLECTOR *aItems)
 Allow the selection of a single item from a list via pop-up menu. More...
 
void onDisambiguationExpire (wxTimerEvent &aEvent)
 Start the process to show our disambiguation menu once the user has kept the mouse down for the minimum time. More...
 
int disambiguateCursor (const TOOL_EVENT &aEvent)
 Handle disambiguation actions including displaying the menu. More...
 
int expandConnection (const TOOL_EVENT &aEvent)
 Expand the current track selection to the next boundary (junctions, pads, or all) More...
 
int selectNet (const TOOL_EVENT &aEvent)
 Select all copper connections belonging to the same net(s) as the items in the selection. More...
 
void selectConnectedTracks (BOARD_CONNECTED_ITEM &aSourceItem, STOP_CONDITION aStopCondition)
 Select connected tracks and vias. More...
 
void selectAllItemsOnNet (int aNetCode, bool aSelect=true)
 Select all items with the given net code. More...
 
void selectAllItemsOnSheet (wxString &aSheetPath)
 Select all items with the given sheet timestamp/UUID name (the sheet path). More...
 
int selectSheetContents (const TOOL_EVENT &aEvent)
 Select all footprints belonging to same hierarchical sheet as the selected footprint (same sheet path). More...
 
int selectSameSheet (const TOOL_EVENT &aEvent)
 Invoke filter dialog and modify current selection. More...
 
int filterSelection (const TOOL_EVENT &aEvent)
 Return true if the given item passes the current SELECTION_FILTER_OPTIONS. More...
 
bool itemPassesFilter (BOARD_ITEM *aItem)
 
void unselect (BOARD_ITEM *aItem)
 Take necessary action mark an item as unselected. More...
 
void highlight (BOARD_ITEM *aItem, int aHighlightMode, PCB_SELECTION *aGroup=nullptr)
 Highlight the item visually. More...
 
void unhighlight (BOARD_ITEM *aItem, int aHighlightMode, PCB_SELECTION *aGroup=nullptr)
 Unhighlight the item visually. More...
 
bool selectionContains (const VECTOR2I &aPoint) const
 
int hitTestDistance (const wxPoint &aWhere, BOARD_ITEM *aItem, int aMaxDistance) const
 
int updateSelection (const TOOL_EVENT &aEvent)
 Event handler to update the selection VIEW_ITEM. More...
 
int UpdateMenu (const TOOL_EVENT &aEvent)
 Pass the selection to a conditional menu for updating. More...
 
const GENERAL_COLLECTORS_GUIDE getCollectorsGuide () const
 
void highlightInternal (BOARD_ITEM *aItem, int aHighlightMode, bool aUsingOverlay)
 
void unhighlightInternal (BOARD_ITEM *aItem, int aHighlightMode, bool aUsingOverlay)
 

Private Attributes

PCB_BASE_FRAMEm_frame
 
PCB_SELECTION m_selection
 
SELECTION_FILTER_OPTIONS m_filter
 
KICURSOR m_nonModifiedCursor
 
PCB_GROUPm_enteredGroup
 
KIGFX::VIEW_GROUP m_enteredGroupOverlay
 
std::unique_ptr< PRIVm_priv
 

Detailed Description

The selection tool: currently supports:

  • pick single objects (click LMB)
  • add objects to existing selection (Shift+LMB)
  • draw selection box (drag LMB)
  • handles FOOTPRINTs properly (i.e. selects either FOOTPRINT or its PADs, TEXTs, etc.)
  • takes into account high-contrast & layer visibility settings
  • invokes InteractiveEdit tool when user starts to drag selected items

Definition at line 64 of file pcb_selection_tool.h.

Member Enumeration Documentation

◆ INTERACTIVE_PLACEMENT_OPTIONS

Options for placing items interactively.

Enumerator
IPO_ROTATE 

Handle the rotate action in the loop by calling the item's rotate method.

IPO_FLIP 

Handle flip action in the loop by calling the item's flip method.

IPO_SINGLE_CLICK 

Create an item immediately on placement starting, otherwise show the pencil cursor until the item is created.

IPO_REPEAT 

Allow repeat placement of the item.

Definition at line 116 of file pcb_tool_base.h.

116  {
118  IPO_ROTATE = 0x01,
119 
121  IPO_FLIP = 0x02,
122 
125  IPO_SINGLE_CLICK = 0x04,
126 
128  IPO_REPEAT = 0x08
129  };
Handle flip action in the loop by calling the item's flip method.
Allow repeat placement of the item.
Create an item immediately on placement starting, otherwise show the pencil cursor until the item is ...
Handle the rotate action in the loop by calling the item's rotate method.

◆ RESET_REASON

enum TOOL_BASE::RESET_REASON
inherited

Determine the reason of reset for a tool.

Enumerator
RUN 

Tool is invoked after being inactive.

MODEL_RELOAD 

Model changes (required full reload)

GAL_SWITCH 

Rendering engine changes.

Definition at line 77 of file tool_base.h.

78  {
79  RUN,
80  MODEL_RELOAD,
81  GAL_SWITCH
82  };
Model changes (required full reload)
Definition: tool_base.h:80
Tool is invoked after being inactive.
Definition: tool_base.h:79
Rendering engine changes.
Definition: tool_base.h:81

◆ STOP_CONDITION

Enumerator
STOP_AT_JUNCTION 

Stop at any place where more than two traces meet.

Because vias are also traces, this makes selection stop at a via if there is a trace on another layer as well, but a via with only one connection will be selected.

STOP_AT_PAD 

Stop when reaching a pad.

STOP_NEVER 

Select the entire net.

Definition at line 279 of file pcb_selection_tool.h.

280  {
289  STOP_AT_PAD,
291  STOP_NEVER
292  };
Stop at any place where more than two traces meet.
Stop when reaching a pad.

Constructor & Destructor Documentation

◆ PCB_SELECTION_TOOL()

PCB_SELECTION_TOOL::PCB_SELECTION_TOOL ( )

Definition at line 104 of file pcb_selection_tool.cpp.

104  :
105  PCB_TOOL_BASE( "pcbnew.InteractiveSelection" ),
106  m_frame( nullptr ),
108  m_enteredGroup( nullptr ),
109  m_priv( std::make_unique<PRIV>() )
110 {
111  m_filter.lockedItems = false;
112  m_filter.footprints = true;
113  m_filter.text = true;
114  m_filter.tracks = true;
115  m_filter.vias = true;
116  m_filter.pads = true;
117  m_filter.graphics = true;
118  m_filter.zones = true;
119  m_filter.keepouts = true;
120  m_filter.dimensions = true;
121  m_filter.otherItems = true;
122 }
bool otherItems
Anything not fitting one of the above categories.
PCB_BASE_FRAME * m_frame
bool text
Text (free or attached to a footprint)
bool dimensions
Dimension items.
SELECTION_FILTER_OPTIONS m_filter
bool graphics
Graphic lines, shapes, polygons.
bool footprints
Allow selecting entire footprints.
PCB_TOOL_BASE(TOOL_ID aId, const std::string &aName)
Constructor.
Definition: pcb_tool_base.h:77
std::unique_ptr< PRIV > m_priv
bool lockedItems
Allow selecting locked items.

References ARROW, SELECTION_FILTER_OPTIONS::dimensions, SELECTION_FILTER_OPTIONS::footprints, SELECTION_FILTER_OPTIONS::graphics, SELECTION_FILTER_OPTIONS::keepouts, SELECTION_FILTER_OPTIONS::lockedItems, m_filter, SELECTION_FILTER_OPTIONS::otherItems, SELECTION_FILTER_OPTIONS::pads, SELECTION_FILTER_OPTIONS::text, SELECTION_FILTER_OPTIONS::tracks, SELECTION_FILTER_OPTIONS::vias, and SELECTION_FILTER_OPTIONS::zones.

◆ ~PCB_SELECTION_TOOL()

PCB_SELECTION_TOOL::~PCB_SELECTION_TOOL ( )

Definition at line 125 of file pcb_selection_tool.cpp.

126 {
127  getView()->Remove( &m_selection );
129 
130  Disconnect( wxEVT_TIMER, wxTimerEventHandler( PCB_SELECTION_TOOL::onDisambiguationExpire ), nullptr, this );
131 }
virtual void Remove(VIEW_ITEM *aItem)
Remove a VIEW_ITEM from the view.
Definition: view.cpp:353
void onDisambiguationExpire(wxTimerEvent &aEvent)
Start the process to show our disambiguation menu once the user has kept the mouse down for the minim...
KIGFX::VIEW_GROUP m_enteredGroupOverlay
PCB_SELECTION m_selection
KIGFX::VIEW * getView() const
Returns the instance of #VIEW object used in the application.
Definition: tool_base.cpp:36

References TOOL_BASE::getView(), m_enteredGroupOverlay, m_selection, onDisambiguationExpire(), and KIGFX::VIEW::Remove().

Member Function Documentation

◆ Activate()

void TOOL_INTERACTIVE::Activate ( )
inherited

Run the tool.

After activation, the tool starts receiving events until it is finished.

Definition at line 51 of file tool_interactive.cpp.

52 {
54 }
TOOL_MANAGER * m_toolMgr
Definition: tool_base.h:214
TOOL_ID m_toolId
Name of the tool.
Definition: tool_base.h:209
bool InvokeTool(TOOL_ID aToolId)
Call a tool by sending a tool activation event to tool of given ID.

References TOOL_MANAGER::InvokeTool(), TOOL_BASE::m_toolId, and TOOL_BASE::m_toolMgr.

Referenced by AUTOPLACE_TOOL::autoplace(), EDIT_TOOL::copyToClipboard(), SYMBOL_EDITOR_EDIT_TOOL::DeleteItemCursor(), PL_EDIT_TOOL::DeleteItemCursor(), SCH_EDIT_TOOL::DeleteItemCursor(), PCB_CONTROL::DeleteItemCursor(), SCH_LINE_WIRE_BUS_TOOL::doDrawSegments(), PCB_TOOL_BASE::doInteractiveItemPlacement(), EDIT_TOOL::doMoveSelection(), EDIT_TOOL::DragArcTrack(), DRAWING_TOOL::DrawArc(), DRAWING_TOOL::DrawCircle(), DRAWING_TOOL::DrawDimension(), DRAWING_TOOL::DrawLine(), MICROWAVE_TOOL::drawMicrowaveInductor(), DRAWING_TOOL::DrawRectangle(), SYMBOL_EDITOR_DRAWING_TOOLS::DrawShape(), PL_DRAWING_TOOLS::DrawShape(), SCH_DRAWING_TOOLS::DrawSheet(), DRAWING_TOOL::DrawZone(), BOARD_EDITOR_CONTROL::DrillOrigin(), PAD_TOOL::EnumeratePads(), PCB_CONTROL::GridSetOrigin(), SCH_EDITOR_CONTROL::HighlightNetCursor(), ROUTER_TOOL::InlineBreakTrack(), ROUTER_TOOL::InlineDrag(), DRAWING_TOOL::InteractivePlaceWithPreview(), BOARD_INSPECTION_TOOL::LocalRatsnestTool(), PCB_PICKER_TOOL::Main(), PL_EDIT_TOOL::Main(), EE_POINT_EDITOR::Main(), SYMBOL_EDITOR_MOVE_TOOL::Main(), PL_POINT_EDITOR::Main(), SCH_MOVE_TOOL::Main(), PICKER_TOOL::Main(), ROUTER_TOOL::MainLoop(), LENGTH_TUNER_TOOL::MainLoop(), GERBVIEW_INSPECTION_TOOL::MeasureTool(), PCB_VIEWER_TOOLS::MeasureTool(), LIB_TREE::onContextMenu(), PCB_POINT_EDITOR::OnSelectionChange(), GROUP_TOOL::PickNewMember(), SYMBOL_EDITOR_DRAWING_TOOLS::PlaceAnchor(), BOARD_EDITOR_CONTROL::PlaceFootprint(), SCH_DRAWING_TOOLS::PlaceImage(), DRAWING_TOOL::PlaceImportedGraphics(), PL_DRAWING_TOOLS::PlaceItem(), SCH_DRAWING_TOOLS::PlaceSymbol(), BOARD_EDITOR_CONTROL::PlaceTarget(), DRAWING_TOOL::PlaceText(), EDIT_TOOL::Remove(), POSITION_RELATIVE_TOOL::SelectPositionRelativeItem(), DRAWING_TOOL::SetAnchor(), DRC_TOOL::ShowDRCDialog(), SCH_DRAWING_TOOLS::SingleClickPlace(), SYMBOL_EDITOR_DRAWING_TOOLS::TwoClickPlace(), SCH_DRAWING_TOOLS::TwoClickPlace(), and SCH_LINE_WIRE_BUS_TOOL::UnfoldBus().

◆ AddItemToSel()

void PCB_SELECTION_TOOL::AddItemToSel ( BOARD_ITEM aItem,
bool  aQuietMode = false 
)

Select all items on the board.

Definition at line 998 of file pcb_selection_tool.cpp.

999 {
1000  if( aItem )
1001  {
1002  select( aItem );
1003 
1004  // Inform other potentially interested tools
1005  if( !aQuietMode )
1007  }
1008 }
static const TOOL_EVENT SelectedEvent
Definition: actions.h:199
void select(BOARD_ITEM *aItem)
Take necessary action mark an item as selected.
TOOL_MANAGER * m_toolMgr
Definition: tool_base.h:214
bool ProcessEvent(const TOOL_EVENT &aEvent)
Propagate an event to tools that requested events of matching type(s).

References TOOL_BASE::m_toolMgr, TOOL_MANAGER::ProcessEvent(), select(), and EVENTS::SelectedEvent.

Referenced by PCB_CONTROL::DeleteItemCursor(), EDIT_TOOL::FilletTracks(), and SelectItem().

◆ attachManager()

void TOOL_BASE::attachManager ( TOOL_MANAGER aManager)
protectedinherited

Set the TOOL_MANAGER the tool will belong to.

Called by TOOL_MANAGER::RegisterTool()

Definition at line 60 of file tool_base.cpp.

61 {
62  m_toolMgr = aManager;
63 }
TOOL_MANAGER * m_toolMgr
Definition: tool_base.h:214

References TOOL_BASE::m_toolMgr.

Referenced by TOOL_MANAGER::RegisterTool().

◆ board()

BOARD* PCB_TOOL_BASE::board ( ) const
inlineprotectedinherited

Definition at line 165 of file pcb_tool_base.h.

165 { return getModel<BOARD>(); }

Referenced by PCB_CONTROL::AppendBoard(), AUTOPLACE_TOOL::autoplace(), BOARD_INSPECTION_TOOL::calculateSelectionRatsnest(), EDIT_TOOL::ChangeTrackWidth(), ZONE_FILLER_TOOL::CheckAllZones(), BOARD_INSPECTION_TOOL::ClearHighlight(), EDIT_TOOL::copyToClipboard(), FOOTPRINT_EDITOR_CONTROL::CreateFootprint(), MICROWAVE_TOOL::createInductorBetween(), ROUTER_TOOL::CustomTrackWidthDialog(), PCB_CONTROL::DeleteItemCursor(), PCB_TOOL_BASE::doInteractiveItemPlacement(), EDIT_TOOL::DragArcTrack(), DRAWING_TOOL::drawArc(), DRAWING_TOOL::DrawDimension(), DRAWING_TOOL::drawSegment(), PAD_TOOL::EnumeratePads(), PAD_TOOL::explodePad(), BOARD_EDITOR_CONTROL::ExportNetlist(), ZONE_FILLER_TOOL::FillAllZones(), EDIT_TOOL::FilletTracks(), filterSelection(), PCB_TOOL_BASE::footprint(), GetBoard(), getCollectorsGuide(), GROUP_TOOL::Group(), ROUTER_TOOL::handleLayerSwitch(), BOARD_INSPECTION_TOOL::highlightNet(), DRAWING_TOOL::InteractivePlaceWithPreview(), PCB_CONTROL::LayerNext(), PCB_CONTROL::LayerPrev(), BOARD_INSPECTION_TOOL::LocalRatsnestTool(), EDIT_TOOL::MoveExact(), FOOTPRINT_EDITOR_CONTROL::NewFootprint(), PCB_CONTROL::Paste(), PCB_CONTROL::placeBoardItems(), BOARD_EDITOR_CONTROL::PlaceFootprint(), PAD_TOOL::PlacePad(), BOARD_EDITOR_CONTROL::PlaceTarget(), DRAWING_TOOL::PlaceText(), RebuildSelection(), PAD_TOOL::recombinePad(), BOARD_EDITOR_CONTROL::RepairBoard(), FOOTPRINT_EDITOR_CONTROL::RepairFootprint(), PNS::TOOL_BASE::Reset(), PCB_CONTROL::Reset(), Selectable(), selectAllItemsOnNet(), selectAllItemsOnSheet(), selectConnectedTracks(), selectionContains(), selectPoint(), PCB_CONTROL::TrackDisplayMode(), PCB_CONTROL::unfilledZoneCheck(), GROUP_TOOL::Ungroup(), ROUTER_TOOL::updateMessagePanel(), PCB_CONTROL::ViaDisplayMode(), PCB_CONTROL::ZoneDisplayMode(), ZONE_FILLER_TOOL::ZoneFill(), BOARD_EDITOR_CONTROL::ZoneMerge(), and ZONE_FILLER_TOOL::ZoneUnfillAll().

◆ BrightenItem()

void PCB_SELECTION_TOOL::BrightenItem ( BOARD_ITEM aItem)

Definition at line 1050 of file pcb_selection_tool.cpp.

1051 {
1052  highlight( aItem, BRIGHTENED );
1053 }
void highlight(BOARD_ITEM *aItem, int aHighlightMode, PCB_SELECTION *aGroup=nullptr)
Highlight the item visually.
#define BRIGHTENED
item is drawn with a bright contour

References BRIGHTENED, and highlight().

Referenced by PCB_CONTROL::DeleteItemCursor().

◆ canvas()

◆ ClearSelection() [1/2]

int PCB_SELECTION_TOOL::ClearSelection ( const TOOL_EVENT aEvent)

◆ ClearSelection() [2/2]

void PCB_SELECTION_TOOL::ClearSelection ( bool  aQuietMode = false)

Item selection event handler.

Definition at line 1693 of file pcb_selection_tool.cpp.

1694 {
1695  if( m_selection.Empty() )
1696  return;
1697 
1698  while( m_selection.GetSize() )
1699  unhighlight( static_cast<BOARD_ITEM*>( m_selection.Front() ), SELECTED, &m_selection );
1700 
1701  view()->Update( &m_selection );
1702 
1703  m_selection.SetIsHover( false );
1705 
1706  // Inform other potentially interested tools
1707  if( !aQuietMode )
1708  {
1711  }
1712 }
void ClearReferencePoint()
Definition: selection.h:191
TOOL_MANAGER * m_toolMgr
Definition: tool_base.h:214
bool RunAction(const std::string &aActionName, bool aNow=false, T aParam=NULL)
Run the specified action.
Definition: tool_manager.h:143
void SetIsHover(bool aIsHover)
Definition: selection.h:68
virtual void Update(const VIEW_ITEM *aItem, int aUpdateFlags) const override
For dynamic VIEWs, inform the associated VIEW that the graphical representation of this item has chan...
Definition: pcb_view.cpp:92
bool ProcessEvent(const TOOL_EVENT &aEvent)
Propagate an event to tools that requested events of matching type(s).
KIGFX::PCB_VIEW * view() const
static const TOOL_EVENT ClearedEvent
Selected item had a property changed (except movement)
Definition: actions.h:201
#define SELECTED
PCB_SELECTION m_selection
static TOOL_ACTION hideDynamicRatsnest
Definition: pcb_actions.h:459
bool Empty() const
Checks if there is anything selected.
Definition: selection.h:97
virtual unsigned int GetSize() const override
Return the number of stored items.
Definition: selection.h:87
void unhighlight(BOARD_ITEM *aItem, int aHighlightMode, PCB_SELECTION *aGroup=nullptr)
Unhighlight the item visually.
EDA_ITEM * Front() const
Definition: selection.h:144

References EVENTS::ClearedEvent, SELECTION::ClearReferencePoint(), SELECTION::Empty(), SELECTION::Front(), SELECTION::GetSize(), PCB_ACTIONS::hideDynamicRatsnest, m_selection, TOOL_BASE::m_toolMgr, TOOL_MANAGER::ProcessEvent(), TOOL_MANAGER::RunAction(), SELECTED, SELECTION::SetIsHover(), unhighlight(), KIGFX::PCB_VIEW::Update(), and PCB_TOOL_BASE::view().

◆ controls()

◆ CursorSelection()

int PCB_SELECTION_TOOL::CursorSelection ( const TOOL_EVENT aEvent)

Clear current selection event handler.

Definition at line 919 of file pcb_selection_tool.cpp.

920 {
922 
923  selectCursor( false, aClientFilter );
924 
925  return 0;
926 }
void(* CLIENT_SELECTION_FILTER)(const VECTOR2I &, GENERAL_COLLECTOR &, PCB_SELECTION_TOOL *)
T Parameter() const
Return a non-standard parameter assigned to the event.
Definition: tool_event.h:432
bool selectCursor(bool aForceSelect=false, CLIENT_SELECTION_FILTER aClientFilter=nullptr)
Select an item under the cursor unless there is something already selected or aSelectAlways is true.

References TOOL_EVENT::Parameter(), and selectCursor().

Referenced by setTransitions().

◆ disambiguateCursor()

int PCB_SELECTION_TOOL::disambiguateCursor ( const TOOL_EVENT aEvent)
private

Handle disambiguation actions including displaying the menu.

Definition at line 903 of file pcb_selection_tool.cpp.

904 {
906 
907  if( pos != m_originalCursor )
908  return 0;
909 
910  m_skip_heuristics = true;
911  selectPoint( pos, false, &m_canceledMenu );
912  m_skip_heuristics = false;
913 
914  return 0;
915 }
VECTOR2D GetMousePosition() const
TOOL_MANAGER * m_toolMgr
Definition: tool_base.h:214
bool selectPoint(const VECTOR2I &aWhere, bool aOnDrag=false, bool *aSelectionCancelledFlag=nullptr, CLIENT_SELECTION_FILTER aClientFilter=nullptr)
Select an item pointed by the parameter aWhere.
VECTOR2I m_originalCursor

References TOOL_MANAGER::GetMousePosition(), SELECTION_TOOL::m_canceledMenu, SELECTION_TOOL::m_originalCursor, SELECTION_TOOL::m_skip_heuristics, TOOL_BASE::m_toolMgr, and selectPoint().

Referenced by setTransitions().

◆ displayOptions()

const PCB_DISPLAY_OPTIONS & PCB_TOOL_BASE::displayOptions ( ) const
protectedinherited

Definition at line 302 of file pcb_tool_base.cpp.

303 {
304  return frame()->GetDisplayOptions();
305 }
const PCB_DISPLAY_OPTIONS & GetDisplayOptions() const
Display options control the way tracks, vias, outlines and other things are shown (for instance solid...
PCB_BASE_EDIT_FRAME * frame() const

References PCB_TOOL_BASE::frame(), and PCB_BASE_FRAME::GetDisplayOptions().

Referenced by BOARD_INSPECTION_TOOL::calculateSelectionRatsnest(), PCB_CONTROL::HighContrastMode(), PCB_CONTROL::HighContrastModeCycle(), BOARD_INSPECTION_TOOL::LocalRatsnestTool(), PNS::TOOL_BASE::pickSingleItem(), PCB_CONTROL::ToggleRatsnest(), PCB_CONTROL::TrackDisplayMode(), PCB_CONTROL::ViaDisplayMode(), and PCB_CONTROL::ZoneDisplayMode().

◆ doInteractiveItemPlacement()

void PCB_TOOL_BASE::doInteractiveItemPlacement ( const std::string &  aTool,
INTERACTIVE_PLACER_BASE aPlacer,
const wxString &  aCommitMessage,
int  aOptions = IPO_ROTATE | IPO_FLIP | IPO_REPEAT 
)
protectedinherited

Helper function for performing a common interactive idiom: wait for a left click, place an item there (perhaps with a dialog or other user interaction), then have it move with the mouse and respond to rotate/flip, etc.

More complex interactive processes are not supported here, you should implement a customised event loop for those.

Parameters
aItemCreatorthe callable that will attempt to create the item
aCommitMessagethe message used on a successful commit

Definition at line 37 of file pcb_tool_base.cpp.

40 {
41  using namespace std::placeholders;
42  std::unique_ptr<BOARD_ITEM> newItem;
43 
44  frame()->PushTool( aTool );
45 
46  BOARD_COMMIT commit( frame() );
47 
49 
50  Activate();
51  // Must be done after Activate() so that it gets set into the correct context
52  controls()->ShowCursor( true );
53  // do not capture or auto-pan until we start placing an item
54 
55  PCB_GRID_HELPER grid( m_toolMgr, frame()->GetMagneticItemsSettings() );
56 
57  // Add a VIEW_GROUP that serves as a preview for the new item
58  PCB_SELECTION preview;
59  view()->Add( &preview );
60 
61  aPlacer->m_board = board();
62  aPlacer->m_frame = frame();
63  aPlacer->m_modifiers = 0;
64 
65  auto makeNewItem =
66  [&]( VECTOR2I aPosition )
67  {
68  if( frame()->GetModel() )
69  newItem = aPlacer->CreateItem();
70 
71  if( newItem )
72  {
73  newItem->SetPosition( (wxPoint) aPosition );
74  preview.Add( newItem.get() );
75 
76  if( newItem->Type() == PCB_FOOTPRINT_T )
77  {
78  FOOTPRINT* fp = dyn_cast<FOOTPRINT*>( newItem.get() );
79 
80  // footprints have more drawable parts
81  fp->RunOnChildren( std::bind( &KIGFX::VIEW_GROUP::Add, &preview, _1 ) );
82  }
83  }
84  };
85 
86  if( aOptions & IPO_SINGLE_CLICK )
87  makeNewItem( controls()->GetCursorPosition() );
88 
89  auto setCursor =
90  [&]()
91  {
92  if( !newItem )
94  else
96  };
97 
98  // Set initial cursor
99  setCursor();
100 
101  // Main loop: keep receiving events
102  while( TOOL_EVENT* evt = Wait() )
103  {
104  setCursor();
105 
106  grid.SetSnap( false ); // Interactive placement tools need to set their own item snaps
107  grid.SetUseGrid( getView()->GetGAL()->GetGridSnapping() && !evt->DisableGridSnapping() );
108  VECTOR2I cursorPos = grid.BestSnapAnchor( controls()->GetMousePosition(), nullptr );
109 
110  aPlacer->m_modifiers = evt->Modifier();
111 
112  auto cleanup =
113  [&] ()
114  {
115  newItem = nullptr;
116  preview.Clear();
117  view()->Update( &preview );
118  controls()->SetAutoPan( false );
119  controls()->CaptureCursor( false );
120  controls()->ShowCursor( true );
121  };
122 
123  if( evt->IsCancelInteractive() )
124  {
125  if( aOptions & IPO_SINGLE_CLICK )
126  {
127  cleanup();
128  frame()->PopTool( aTool );
129  break;
130  }
131  else if( newItem )
132  {
133  cleanup();
134  }
135  else
136  {
137  frame()->PopTool( aTool );
138  break;
139  }
140  }
141  else if( evt->IsActivate() )
142  {
143  if( newItem )
144  cleanup();
145 
146  if( evt->IsPointEditor() )
147  {
148  // don't exit (the point editor runs in the background)
149  }
150  else if( evt->IsMoveTool() )
151  {
152  // leave ourselves on the stack so we come back after the move
153  break;
154  }
155  else
156  {
157  frame()->PopTool( aTool );
158  break;
159  }
160  }
161  else if( evt->IsClick( BUT_LEFT ) || evt->IsDblClick( BUT_LEFT ) )
162  {
163  if( !newItem )
164  {
165  // create the item if possible
166  makeNewItem( cursorPos );
167 
168  // no item created, so wait for another click
169  if( !newItem )
170  continue;
171 
172  controls()->CaptureCursor( true );
173  controls()->SetAutoPan( true );
174  }
175  else
176  {
177  auto oldFlags = newItem->GetFlags();
178  newItem->ClearFlags();
179 
180  if( !aPlacer->PlaceItem( newItem.get(), commit ) )
181  {
182  newItem->SetFlags( oldFlags );
183  continue;
184  }
185 
186  preview.Clear();
187  newItem.release();
188  commit.Push( aCommitMessage );
189 
190  controls()->CaptureCursor( false );
191  controls()->SetAutoPan( false );
192  controls()->ShowCursor( true );
193 
194  if( !( aOptions & IPO_REPEAT ) )
195  break;
196 
197  if( aOptions & IPO_SINGLE_CLICK )
198  makeNewItem( controls()->GetCursorPosition() );
199 
200  setCursor();
201  }
202  }
203  else if( evt->IsClick( BUT_RIGHT ) )
204  {
206  }
207  else if( evt->IsAction( &PCB_ACTIONS::trackViaSizeChanged ) )
208  {
210  }
211  else if( newItem && evt->Category() == TC_COMMAND )
212  {
213  /*
214  * Handle any events that can affect the item as we move it around
215  */
216  if( TOOL_EVT_UTILS::IsRotateToolEvt( *evt ) && ( aOptions & IPO_ROTATE ) )
217  {
218  const int rotationAngle = TOOL_EVT_UTILS::GetEventRotationAngle( *frame(), *evt );
219  newItem->Rotate( newItem->GetPosition(), rotationAngle );
220  view()->Update( &preview );
221  }
222  else if( evt->IsAction( &PCB_ACTIONS::flip ) && ( aOptions & IPO_FLIP ) )
223  {
224  newItem->Flip( newItem->GetPosition(), frame()->Settings().m_FlipLeftRight );
225  view()->Update( &preview );
226  }
227  else if( evt->IsAction( &PCB_ACTIONS::viaSizeInc )
228  || evt->IsAction( &PCB_ACTIONS::viaSizeDec ) )
229  {
230  // Refresh preview after event runs
232  }
233  else if( evt->IsAction( &PCB_ACTIONS::properties ) )
234  {
235  frame()->OnEditItemRequest( newItem.get() );
236 
237  // Notify other tools of the changes
239  }
240  else if( evt->IsAction( &ACTIONS::refreshPreview ) )
241  {
242  preview.Clear();
243  newItem.release();
244 
245  makeNewItem( (wxPoint) cursorPos );
246  aPlacer->SnapItem( newItem.get() );
247  view()->Update( &preview );
248  }
249  else
250  {
251  evt->SetPassEvent();
252  }
253  }
254  else if( newItem && evt->IsMotion() )
255  {
256  // track the cursor
257  newItem->SetPosition( (wxPoint) cursorPos );
258  aPlacer->SnapItem( newItem.get() );
259 
260  // Show a preview of the item
261  view()->Update( &preview );
262  }
263  else
264  {
265  evt->SetPassEvent();
266  }
267  }
268 
269  view()->Remove( &preview );
271  controls()->SetAutoPan( false );
272  controls()->CaptureCursor( false );
273 }
static TOOL_ACTION selectionClear
Clear the current selection.
Definition: pcb_actions.h:59
virtual void ShowCursor(bool aEnabled)
Enable or disables display of cursor.
TOOL_MENU m_menu
The functions below are not yet implemented - their interface may change.
virtual void Clear() override
Remove all the stored items from the group.
Definition: selection.h:82
void SetCurrentCursor(KICURSOR aCursor)
Set the current cursor shape for this panel.
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.
virtual bool PlaceItem(BOARD_ITEM *aItem, BOARD_COMMIT &aCommit)
Handle flip action in the loop by calling the item's flip method.
BOARD * board() const
virtual void Add(EDA_ITEM *aItem)
Definition: selection.cpp:31
static TOOL_ACTION viaSizeInc
Definition: pcb_actions.h:296
virtual std::unique_ptr< BOARD_ITEM > CreateItem()=0
PCB_DRAW_PANEL_GAL * GetCanvas() const override
Return a pointer to GAL-based canvas of given EDA draw frame.
TOOL_MANAGER * m_toolMgr
Definition: tool_base.h:214
virtual void OnEditItemRequest(BOARD_ITEM *aItem)=0
Install the corresponding dialog editor for the given item.
virtual void PushTool(const std::string &actionName)
NB: the definition of "tool" is different at the user level.
static TOOL_ACTION properties
Activation of the edit tool.
Definition: pcb_actions.h:117
bool RunAction(const std::string &aActionName, bool aNow=false, T aParam=NULL)
Run the specified action.
Definition: tool_manager.h:143
static TOOL_ACTION trackViaSizeChanged
Definition: pcb_actions.h:299
bool IsRotateToolEvt(const TOOL_EVENT &aEvt)
Function isRotateToolEvt()
virtual void Remove(VIEW_ITEM *aItem) override
Remove a VIEW_ITEM from the view.
Definition: pcb_view.cpp:75
static const TOOL_EVENT SelectedItemsModified
Selected items were moved, this can be very high frequency on the canvas, use with care.
Definition: actions.h:204
TOOL_MANAGER * GetManager() const
Return the instance of TOOL_MANAGER that takes care of the tool.
Definition: tool_base.h:143
PCB_BASE_EDIT_FRAME * frame() const
virtual void SnapItem(BOARD_ITEM *aItem)
virtual void Update(const VIEW_ITEM *aItem, int aUpdateFlags) const override
For dynamic VIEWs, inform the associated VIEW that the graphical representation of this item has chan...
Definition: pcb_view.cpp:92
const PCB_SELECTION & selection() const
Allow repeat placement of the item.
bool ProcessEvent(const TOOL_EVENT &aEvent)
Propagate an event to tools that requested events of matching type(s).
virtual void PopTool(const std::string &actionName)
virtual void CaptureCursor(bool aEnabled)
Force the cursor to stay within the drawing panel area.
Generic, UI-independent tool event.
Definition: tool_event.h:152
KIGFX::PCB_VIEW * view() const
Create an item immediately on placement starting, otherwise show the pencil cursor until the item is ...
virtual void Add(VIEW_ITEM *aItem)
Add an item to the group.
Definition: view_group.cpp:56
KIGFX::VIEW * getView() const
Returns the instance of #VIEW object used in the application.
Definition: tool_base.cpp:36
virtual void SetAutoPan(bool aEnabled)
Turn on/off auto panning (this feature is used when there is a tool active (eg.
class FOOTPRINT, a footprint
Definition: typeinfo.h:88
virtual BOARD_ITEM_CONTAINER * GetModel() const =0
static TOOL_ACTION flip
Flipping of selected objects.
Definition: pcb_actions.h:105
Handle the rotate action in the loop by calling the item's rotate method.
KIGFX::VIEW_CONTROLS * controls() const
PCBNEW_SETTINGS & Settings()
void Activate()
Run the tool.
void RunOnChildren(const std::function< void(BOARD_ITEM *)> &aFunction) const
Invoke a function on all BOARD_ITEMs that belong to the footprint (pads, drawings,...
Definition: footprint.cpp:1236
virtual void Add(VIEW_ITEM *aItem, int aDrawPriority=-1) override
Add a VIEW_ITEM to the view.
Definition: pcb_view.cpp:58
PCB_BASE_EDIT_FRAME * m_frame
Definition: pcb_tool_base.h:64
int GetEventRotationAngle(const PCB_BASE_EDIT_FRAME &aFrame, const TOOL_EVENT &aEvt)
Function getEventRotationAngle()
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
static TOOL_ACTION viaSizeDec
Definition: pcb_actions.h:297
static TOOL_ACTION refreshPreview
Definition: actions.h:106

References TOOL_INTERACTIVE::Activate(), KIGFX::PCB_VIEW::Add(), KIGFX::VIEW_GROUP::Add(), SELECTION::Add(), ARROW, PCB_TOOL_BASE::board(), BUT_LEFT, BUT_RIGHT, KIGFX::VIEW_CONTROLS::CaptureCursor(), SELECTION::Clear(), PCB_TOOL_BASE::controls(), INTERACTIVE_PLACER_BASE::CreateItem(), PCB_ACTIONS::flip, PCB_TOOL_BASE::frame(), PCB_BASE_FRAME::GetCanvas(), TOOL_EVT_UTILS::GetEventRotationAngle(), TOOL_BASE::GetManager(), PCB_BASE_FRAME::GetModel(), TOOL_BASE::getView(), grid, PCB_TOOL_BASE::IPO_FLIP, PCB_TOOL_BASE::IPO_REPEAT, PCB_TOOL_BASE::IPO_ROTATE, PCB_TOOL_BASE::IPO_SINGLE_CLICK, TOOL_EVT_UTILS::IsRotateToolEvt(), INTERACTIVE_PLACER_BASE::m_board, PCBNEW_SETTINGS::m_FlipLeftRight, INTERACTIVE_PLACER_BASE::m_frame, TOOL_INTERACTIVE::m_menu, INTERACTIVE_PLACER_BASE::m_modifiers, TOOL_BASE::m_toolMgr, PCB_BASE_EDIT_FRAME::OnEditItemRequest(), PCB_FOOTPRINT_T, PENCIL, PLACE, INTERACTIVE_PLACER_BASE::PlaceItem(), TOOLS_HOLDER::PopTool(), TOOL_MANAGER::ProcessEvent(), PCB_ACTIONS::properties, BOARD_COMMIT::Push(), TOOLS_HOLDER::PushTool(), ACTIONS::refreshPreview, KIGFX::PCB_VIEW::Remove(), TOOL_MANAGER::RunAction(), FOOTPRINT::RunOnChildren(), EVENTS::SelectedItemsModified, PCB_TOOL_BASE::selection(), PCB_ACTIONS::selectionClear, KIGFX::VIEW_CONTROLS::SetAutoPan(), EDA_DRAW_PANEL_GAL::SetCurrentCursor(), PCB_BASE_FRAME::Settings(), TOOL_MENU::ShowContextMenu(), KIGFX::VIEW_CONTROLS::ShowCursor(), INTERACTIVE_PLACER_BASE::SnapItem(), TC_COMMAND, PCB_ACTIONS::trackViaSizeChanged, KIGFX::PCB_VIEW::Update(), PCB_ACTIONS::viaSizeDec, PCB_ACTIONS::viaSizeInc, PCB_TOOL_BASE::view(), and TOOL_INTERACTIVE::Wait().

Referenced by MICROWAVE_TOOL::addMicrowaveFootprint(), DRAWING_TOOL::DrawVia(), and PAD_TOOL::PlacePad().

◆ doSelectionMenu()

bool PCB_SELECTION_TOOL::doSelectionMenu ( GENERAL_COLLECTOR aItems)
private

Allow the selection of a single item from a list via pop-up menu.

The items are highlighted on the canvas when hovered in the menu. The collector is trimmed to the picked item.

Returns
true if an item was picked

The user has requested the full, non-limited list of selection items

Definition at line 1769 of file pcb_selection_tool.cpp.

1770 {
1771  BOARD_ITEM* current = nullptr;
1772  PCB_SELECTION highlightGroup;
1773  bool selectAll = false;
1774  bool expandSelection = false;
1775 
1776  highlightGroup.SetLayer( LAYER_SELECT_OVERLAY );
1777  getView()->Add( &highlightGroup );
1778 
1779  do
1780  {
1782  if( expandSelection )
1783  aCollector->Combine();
1784 
1785  expandSelection = false;
1786 
1787  int limit = std::min( 9, aCollector->GetCount() );
1788  ACTION_MENU menu( true );
1789 
1790  for( int i = 0; i < limit; ++i )
1791  {
1792  wxString text;
1793  BOARD_ITEM* item = ( *aCollector )[i];
1795 
1796  wxString menuText = wxString::Format( "&%d. %s\t%d", i + 1, text, i + 1 );
1797  menu.Add( menuText, i + 1, item->GetMenuImage() );
1798  }
1799 
1800  menu.AppendSeparator();
1801  menu.Add( _( "Select &All\tA" ), limit + 1, BITMAPS::INVALID_BITMAP );
1802 
1803  if( !expandSelection && aCollector->HasAdditionalItems() )
1804  menu.Add( _( "&Expand Selection\tE" ), limit + 2, BITMAPS::INVALID_BITMAP );
1805 
1806  if( aCollector->m_MenuTitle.Length() )
1807  {
1808  menu.SetTitle( aCollector->m_MenuTitle );
1809  menu.SetIcon( BITMAPS::info );
1810  menu.DisplayTitle( true );
1811  }
1812  else
1813  {
1814  menu.DisplayTitle( false );
1815  }
1816 
1817  SetContextMenu( &menu, CMENU_NOW );
1818 
1819  while( TOOL_EVENT* evt = Wait() )
1820  {
1821  if( evt->Action() == TA_CHOICE_MENU_UPDATE )
1822  {
1823  if( selectAll )
1824  {
1825  for( int i = 0; i < aCollector->GetCount(); ++i )
1826  unhighlight( ( *aCollector )[i], BRIGHTENED, &highlightGroup );
1827  }
1828  else if( current )
1829  {
1830  unhighlight( current, BRIGHTENED, &highlightGroup );
1831  }
1832 
1833  int id = *evt->GetCommandId();
1834 
1835  // User has pointed an item, so show it in a different way
1836  if( id > 0 && id <= limit )
1837  {
1838  current = ( *aCollector )[id - 1];
1839  highlight( current, BRIGHTENED, &highlightGroup );
1840  }
1841  else
1842  {
1843  current = nullptr;
1844  }
1845 
1846  // User has pointed on the "Select All" option
1847  if( id == limit + 1 )
1848  {
1849  for( int i = 0; i < aCollector->GetCount(); ++i )
1850  highlight( ( *aCollector )[i], BRIGHTENED, &highlightGroup );
1851  selectAll = true;
1852  }
1853  else
1854  {
1855  selectAll = false;
1856  }
1857  }
1858  else if( evt->Action() == TA_CHOICE_MENU_CHOICE )
1859  {
1860  if( selectAll )
1861  {
1862  for( int i = 0; i < aCollector->GetCount(); ++i )
1863  unhighlight( ( *aCollector )[i], BRIGHTENED, &highlightGroup );
1864  }
1865  else if( current )
1866  {
1867  unhighlight( current, BRIGHTENED, &highlightGroup );
1868  }
1869 
1870  OPT<int> id = evt->GetCommandId();
1871 
1872  // User has selected the "Select All" option
1873  if( id == limit + 1 )
1874  {
1875  selectAll = true;
1876  current = nullptr;
1877  }
1878  else if( id == limit + 2 )
1879  {
1880  expandSelection = true;
1881  selectAll = false;
1882  current = nullptr;
1883  }
1884  // User has selected an item, so this one will be returned
1885  else if( id && ( *id > 0 ) && ( *id <= limit ) )
1886  {
1887  selectAll = false;
1888  current = ( *aCollector )[*id - 1];
1889  }
1890  else
1891  {
1892  selectAll = false;
1893  current = nullptr;
1894  }
1895  }
1896  else if( evt->Action() == TA_CHOICE_MENU_CLOSED )
1897  {
1898  break;
1899  }
1900  }
1901  } while( expandSelection );
1902 
1903  getView()->Remove( &highlightGroup );
1904 
1905  if( selectAll )
1906  {
1907  return true;
1908  }
1909  else if( current )
1910  {
1911  aCollector->Empty();
1912  aCollector->Append( current );
1913  return true;
1914  }
1915 
1916  return false;
1917 }
currently selected items overlay
Definition: layer_ids.h:214
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.
Defines the structure of a menu based on ACTIONs.
Definition: action_menu.h:48
A base class for any item which can be embedded within the BOARD container class, and therefore insta...
Definition: board_item.h:80
virtual void Remove(VIEW_ITEM *aItem)
Remove a VIEW_ITEM from the view.
Definition: view.cpp:353
void highlight(BOARD_ITEM *aItem, int aHighlightMode, PCB_SELECTION *aGroup=nullptr)
Highlight the item visually.
void SetContextMenu(ACTION_MENU *aMenu, CONTEXT_MENU_TRIGGER aTrigger=CMENU_BUTTON)
Assign a context menu and tells when it should be activated.
PCB_BASE_FRAME * m_frame
Generic, UI-independent tool event.
Definition: tool_event.h:152
#define _(s)
virtual void SetLayer(int aLayer)
Set layer used to draw the group.
Definition: view_group.h:108
KIGFX::VIEW * getView() const
Returns the instance of #VIEW object used in the application.
Definition: tool_base.cpp:36
void Format(OUTPUTFORMATTER *out, int aNestLevel, int aCtl, const CPTREE &aTree)
Output a PTREE into s-expression format via an OUTPUTFORMATTER derivative.
Definition: ptree.cpp:200
virtual wxString GetSelectMenuText(EDA_UNITS aUnits) const
Return the text to display to be used in the selection clarification context menu when multiple items...
Definition: eda_item.cpp:109
virtual BITMAPS GetMenuImage() const
Return a pointer to an image to be used in menus.
Definition: eda_item.cpp:211
boost::optional< T > OPT
Definition: optional.h:7
virtual void Add(VIEW_ITEM *aItem, int aDrawPriority=-1)
Add a VIEW_ITEM to the view.
Definition: view.cpp:323
void unhighlight(BOARD_ITEM *aItem, int aHighlightMode, PCB_SELECTION *aGroup=nullptr)
Unhighlight the item visually.
EDA_UNITS GetUserUnits() const
Return the user units currently in use.
#define BRIGHTENED
item is drawn with a bright contour

References _, KIGFX::VIEW::Add(), COLLECTOR::Append(), BRIGHTENED, CMENU_NOW, COLLECTOR::Combine(), COLLECTOR::Empty(), Format(), COLLECTOR::GetCount(), EDA_ITEM::GetMenuImage(), EDA_ITEM::GetSelectMenuText(), EDA_BASE_FRAME::GetUserUnits(), TOOL_BASE::getView(), COLLECTOR::HasAdditionalItems(), highlight(), info, INVALID_BITMAP, LAYER_SELECT_OVERLAY, m_frame, COLLECTOR::m_MenuTitle, KIGFX::VIEW::Remove(), TOOL_INTERACTIVE::SetContextMenu(), KIGFX::VIEW_GROUP::SetLayer(), TA_CHOICE_MENU_CHOICE, TA_CHOICE_MENU_CLOSED, TA_CHOICE_MENU_UPDATE, text, unhighlight(), and TOOL_INTERACTIVE::Wait().

Referenced by SelectionMenu(), and selectPoint().

◆ EnterGroup()

void PCB_SELECTION_TOOL::EnterGroup ( )

Definition at line 461 of file pcb_selection_tool.cpp.

462 {
463  wxCHECK_RET( m_selection.GetSize() == 1 && m_selection[0]->Type() == PCB_GROUP_T,
464  "EnterGroup called when selection is not a single group" );
465  PCB_GROUP* aGroup = static_cast<PCB_GROUP*>( m_selection[0] );
466 
467  if( m_enteredGroup != nullptr )
468  ExitGroup();
469 
470  ClearSelection();
471  m_enteredGroup = aGroup;
473  m_enteredGroup->RunOnChildren( [&]( BOARD_ITEM* titem )
474  {
475  select( titem );
476  } );
477 
479 }
void select(BOARD_ITEM *aItem)
Take necessary action mark an item as selected.
A base class for any item which can be embedded within the BOARD container class, and therefore insta...
Definition: board_item.h:80
class PCB_GROUP, a set of BOARD_ITEMs
Definition: typeinfo.h:108
A set of BOARD_ITEMs (i.e., without duplicates).
Definition: pcb_group.h:50
void SetFlags(EDA_ITEM_FLAGS aMask)
Definition: eda_item.h:153
KIGFX::VIEW_GROUP m_enteredGroupOverlay
PCB_SELECTION m_selection
virtual void Add(VIEW_ITEM *aItem)
Add an item to the group.
Definition: view_group.cpp:56
void ExitGroup(bool aSelectGroup=false)
Leave the currently entered group.
virtual unsigned int GetSize() const override
Return the number of stored items.
Definition: selection.h:87
#define ENTERED
indicates a group has been entered
void RunOnChildren(const std::function< void(BOARD_ITEM *)> &aFunction) const
Invoke a function on all members of the group.
Definition: pcb_group.cpp:330
int ClearSelection(const TOOL_EVENT &aEvent)

References KIGFX::VIEW_GROUP::Add(), ClearSelection(), ENTERED, ExitGroup(), SELECTION::GetSize(), m_enteredGroup, m_enteredGroupOverlay, m_selection, PCB_GROUP_T, PCB_GROUP::RunOnChildren(), select(), and EDA_ITEM::SetFlags().

Referenced by GROUP_TOOL::EnterGroup(), and Main().

◆ ExitGroup()

void PCB_SELECTION_TOOL::ExitGroup ( bool  aSelectGroup = false)

Leave the currently entered group.

Parameters
aSelectGroupwhen true will select the group after leaving

Definition at line 482 of file pcb_selection_tool.cpp.

483 {
484  // Only continue if there is a group entered
485  if( m_enteredGroup == nullptr )
486  return;
487 
489  ClearSelection();
490 
491  if( aSelectGroup )
493 
495  m_enteredGroup = nullptr;
496 }
void select(BOARD_ITEM *aItem)
Take necessary action mark an item as selected.
virtual void Clear()
Remove all the stored items from the group.
Definition: view_group.cpp:75
KIGFX::VIEW_GROUP m_enteredGroupOverlay
void ClearFlags(EDA_ITEM_FLAGS aMask=EDA_ITEM_ALL_FLAGS)
Definition: eda_item.h:154
#define ENTERED
indicates a group has been entered
int ClearSelection(const TOOL_EVENT &aEvent)

References KIGFX::VIEW_GROUP::Clear(), EDA_ITEM::ClearFlags(), ClearSelection(), ENTERED, m_enteredGroup, m_enteredGroupOverlay, and select().

Referenced by EnterGroup(), Main(), EDIT_TOOL::Remove(), Reset(), and selectPoint().

◆ expandConnection()

int PCB_SELECTION_TOOL::expandConnection ( const TOOL_EVENT aEvent)
private

Expand the current track selection to the next boundary (junctions, pads, or all)

Definition at line 1082 of file pcb_selection_tool.cpp.

1083 {
1084  unsigned initialCount = 0;
1085 
1086  for( auto item : m_selection.GetItems() )
1087  {
1088  if( dynamic_cast<BOARD_CONNECTED_ITEM*>( item ) )
1089  initialCount++;
1090  }
1091 
1092  if( initialCount == 0 )
1094 
1095  for( STOP_CONDITION stopCondition : { STOP_AT_JUNCTION, STOP_AT_PAD, STOP_NEVER } )
1096  {
1097  // copy the selection, since we're going to iterate and modify
1098  std::deque<EDA_ITEM*> selectedItems = m_selection.GetItems();
1099 
1100  for( EDA_ITEM* item : selectedItems )
1101  item->ClearTempFlags();
1102 
1103  for( EDA_ITEM* item : selectedItems )
1104  {
1105  PCB_TRACK* trackItem = dynamic_cast<PCB_TRACK*>( item );
1106 
1107  // Track items marked SKIP_STRUCT have already been visited
1108  if( trackItem && !( trackItem->GetFlags() & SKIP_STRUCT ) )
1109  selectConnectedTracks( *trackItem, stopCondition );
1110  }
1111 
1112  if( m_selection.GetItems().size() > initialCount )
1113  break;
1114  }
1115 
1116  // Inform other potentially interested tools
1117  if( m_selection.Size() > 0 )
1119 
1120  return 0;
1121 }
static const TOOL_EVENT SelectedEvent
Definition: actions.h:199
Stop at any place where more than two traces meet.
TOOL_MANAGER * m_toolMgr
Definition: tool_base.h:214
Stop when reaching a pad.
void selectConnectedTracks(BOARD_CONNECTED_ITEM &aSourceItem, STOP_CONDITION aStopCondition)
Select connected tracks and vias.
bool ProcessEvent(const TOOL_EVENT &aEvent)
Propagate an event to tools that requested events of matching type(s).
void connectedItemFilter(const VECTOR2I &, GENERAL_COLLECTOR &aCollector, PCB_SELECTION_TOOL *sTool)
const std::deque< EDA_ITEM * > GetItems() const
Definition: selection.h:108
PCB_SELECTION m_selection
EDA_ITEM_FLAGS GetFlags() const
Definition: eda_item.h:155
bool selectCursor(bool aForceSelect=false, CLIENT_SELECTION_FILTER aClientFilter=nullptr)
Select an item under the cursor unless there is something already selected or aSelectAlways is true.
#define SKIP_STRUCT
flag indicating that the structure should be ignored
int Size() const
Returns the number of selected parts.
Definition: selection.h:103
A base class for most all the KiCad significant classes used in schematics and boards.
Definition: eda_item.h:100

References connectedItemFilter(), EDA_ITEM::GetFlags(), SELECTION::GetItems(), m_selection, TOOL_BASE::m_toolMgr, TOOL_MANAGER::ProcessEvent(), selectConnectedTracks(), selectCursor(), EVENTS::SelectedEvent, SELECTION::Size(), SKIP_STRUCT, STOP_AT_JUNCTION, STOP_AT_PAD, and STOP_NEVER.

Referenced by setTransitions().

◆ FilterCollectedItems()

void PCB_SELECTION_TOOL::FilterCollectedItems ( GENERAL_COLLECTOR aCollector)

Definition at line 1594 of file pcb_selection_tool.cpp.

1595 {
1596  if( aCollector.GetCount() == 0 )
1597  return;
1598 
1599  std::set<BOARD_ITEM*> rejected;
1600 
1601  for( EDA_ITEM* i : aCollector )
1602  {
1603  BOARD_ITEM* item = static_cast<BOARD_ITEM*>( i );
1604 
1605  if( !itemPassesFilter( item ) )
1606  rejected.insert( item );
1607  }
1608 
1609  for( BOARD_ITEM* item : rejected )
1610  aCollector.Remove( item );
1611 }
A base class for any item which can be embedded within the BOARD container class, and therefore insta...
Definition: board_item.h:80
int GetCount() const
Return the number of objects in the list.
Definition: collector.h:87
A base class for most all the KiCad significant classes used in schematics and boards.
Definition: eda_item.h:100
bool itemPassesFilter(BOARD_ITEM *aItem)

References COLLECTOR::GetCount(), and itemPassesFilter().

Referenced by BOARD_INSPECTION_TOOL::highlightNet(), selectMultiple(), and selectPoint().

◆ FilterCollectorForHierarchy()

void PCB_SELECTION_TOOL::FilterCollectorForHierarchy ( GENERAL_COLLECTOR aCollector,
bool  aMultiselect 
) const

In general we don't want to select both a parent and any of it's children.

This includes both footprints and their items, and groups and their members.Apply the SELECTION_FILTER_OPTIONS to a collection of items

Definition at line 2535 of file pcb_selection_tool.cpp.

2537 {
2538  std::unordered_set<BOARD_ITEM*> toAdd;
2539 
2540  // Set TEMP_SELECTED on all parents which are included in the GENERAL_COLLECTOR. This
2541  // algorithm is O3n, whereas checking for the parent inclusion could potentially be On^2.
2542  for( int j = 0; j < aCollector.GetCount(); j++ )
2543  {
2544  if( aCollector[j]->GetParent() )
2545  aCollector[j]->GetParent()->ClearFlags( TEMP_SELECTED );
2546  }
2547 
2548  if( aMultiselect )
2549  {
2550  for( int j = 0; j < aCollector.GetCount(); j++ )
2551  aCollector[j]->SetFlags( TEMP_SELECTED );
2552  }
2553 
2554  for( int j = 0; j < aCollector.GetCount(); )
2555  {
2556  BOARD_ITEM* item = aCollector[j];
2557  BOARD_ITEM* parent = item->GetParent();
2558  BOARD_ITEM* start = item;
2559 
2560  if( !m_isFootprintEditor && parent && parent->Type() == PCB_FOOTPRINT_T )
2561  start = parent;
2562 
2563  // If any element is a member of a group, replace those elements with the top containing
2564  // group.
2566 
2567  if( aTop )
2568  {
2569  if( aTop != item )
2570  {
2571  toAdd.insert( aTop );
2572  aTop->SetFlags( TEMP_SELECTED );
2573 
2574  aCollector.Remove( item );
2575  continue;
2576  }
2577  }
2578  else if( m_enteredGroup
2580  {
2581  // If a group is entered, disallow selections of objects outside the group.
2582  aCollector.Remove( item );
2583  continue;
2584  }
2585 
2586  // Footprints are a bit easier as they can't be nested.
2587  if( parent && ( parent->GetFlags() & TEMP_SELECTED ) )
2588  {
2589  // Remove children of selected items
2590  aCollector.Remove( item );
2591  continue;
2592  }
2593 
2594  ++j;
2595  }
2596 
2597  for( BOARD_ITEM* item : toAdd )
2598  {
2599  if( !aCollector.HasItem( item ) )
2600  aCollector.Append( item );
2601  }
2602 }
A base class for any item which can be embedded within the BOARD container class, and therefore insta...
Definition: board_item.h:80
A set of BOARD_ITEMs (i.e., without duplicates).
Definition: pcb_group.h:50
void SetFlags(EDA_ITEM_FLAGS aMask)
Definition: eda_item.h:153
static PCB_GROUP * TopLevelGroup(BOARD_ITEM *aItem, PCB_GROUP *aScope, bool isFootprintEditor)
Definition: pcb_group.cpp:99
void Remove(int aIndex)
Remove the item at aIndex (first position is 0).
Definition: collector.h:115
void Append(EDA_ITEM *item)
Add an item to the end of the list.
Definition: collector.h:105
int GetCount() const
Return the number of objects in the list.
Definition: collector.h:87
bool HasItem(const EDA_ITEM *aItem) const
Tests if aItem has already been collected.
Definition: collector.h:203
static bool WithinScope(BOARD_ITEM *aItem, PCB_GROUP *aScope, bool isFootprintEditor)
Definition: pcb_group.cpp:107
bool m_isFootprintEditor
EDA_ITEM_FLAGS GetFlags() const
Definition: eda_item.h:155
class FOOTPRINT, a footprint
Definition: typeinfo.h:88
#define TEMP_SELECTED
flag indicating that the structure has already selected
BOARD_ITEM_CONTAINER * GetParent() const
Definition: board_item.h:166
KICAD_T Type() const
Returns the type of object.
Definition: eda_item.h:113

References COLLECTOR::Append(), COLLECTOR::GetCount(), EDA_ITEM::GetFlags(), BOARD_ITEM::GetParent(), COLLECTOR::HasItem(), m_enteredGroup, PCB_TOOL_BASE::m_isFootprintEditor, PCB_FOOTPRINT_T, COLLECTOR::Remove(), EDA_ITEM::SetFlags(), TEMP_SELECTED, PCB_GROUP::TopLevelGroup(), EDA_ITEM::Type(), and PCB_GROUP::WithinScope().

Referenced by EDIT_TOOL::CreateArray(), EDIT_TOOL::Drag(), EDIT_TOOL::Duplicate(), EDIT_TOOL::Flip(), EDIT_TOOL::Mirror(), EDIT_TOOL::MoveExact(), GLOBAL_EDIT_TOOL::RemoveUnusedPads(), EDIT_TOOL::Rotate(), SelectAll(), selectMultiple(), and selectPoint().

◆ filterSelection()

int PCB_SELECTION_TOOL::filterSelection ( const TOOL_EVENT aEvent)
private

Return true if the given item passes the current SELECTION_FILTER_OPTIONS.

Definition at line 1562 of file pcb_selection_tool.cpp.

1563 {
1564  const BOARD& board = *getModel<BOARD>();
1565  DIALOG_FILTER_SELECTION::OPTIONS& opts = m_priv->m_filterOpts;
1566  DIALOG_FILTER_SELECTION dlg( m_frame, opts );
1567 
1568  const int cmd = dlg.ShowModal();
1569 
1570  if( cmd != wxID_OK )
1571  return 0;
1572 
1573  // copy current selection
1574  std::deque<EDA_ITEM*> selection = m_selection.GetItems();
1575 
1576  ClearSelection( true /*quiet mode*/ );
1577 
1578  // re-select items from the saved selection according to the dialog options
1579  for( EDA_ITEM* i : selection )
1580  {
1581  BOARD_ITEM* item = static_cast<BOARD_ITEM*>( i );
1582  bool include = itemIsIncludedByFilter( *item, board, opts );
1583 
1584  if( include )
1585  select( item );
1586  }
1587 
1589 
1590  return 0;
1591 }
static const TOOL_EVENT SelectedEvent
Definition: actions.h:199
void select(BOARD_ITEM *aItem)
Take necessary action mark an item as selected.
BOARD * board() const
A base class for any item which can be embedded within the BOARD container class, and therefore insta...
Definition: board_item.h:80
TOOL_MANAGER * m_toolMgr
Definition: tool_base.h:214
Struct that will be set with the result of the user choices in the dialog.
static bool itemIsIncludedByFilter(const BOARD_ITEM &aItem, const BOARD &aBoard, const DIALOG_FILTER_SELECTION::OPTIONS &aFilterOptions)
Determine if an item is included by the filter specified.
PCB_BASE_FRAME * m_frame
const PCB_SELECTION & selection() const
bool ProcessEvent(const TOOL_EVENT &aEvent)
Propagate an event to tools that requested events of matching type(s).
const std::deque< EDA_ITEM * > GetItems() const
Definition: selection.h:108
PCB_SELECTION m_selection
std::unique_ptr< PRIV > m_priv
Information pertinent to a Pcbnew printed circuit board.
Definition: board.h:190
A base class for most all the KiCad significant classes used in schematics and boards.
Definition: eda_item.h:100
int ClearSelection(const TOOL_EVENT &aEvent)

References PCB_TOOL_BASE::board(), ClearSelection(), SELECTION::GetItems(), itemIsIncludedByFilter(), m_frame, m_priv, m_selection, TOOL_BASE::m_toolMgr, TOOL_MANAGER::ProcessEvent(), select(), EVENTS::SelectedEvent, and PCB_TOOL_BASE::selection().

Referenced by setTransitions().

◆ FindItem()

void PCB_SELECTION_TOOL::FindItem ( BOARD_ITEM aItem)

Handle finding an item.

Does not do the actual searching, is called by the find dialog.

Parameters
aItemItem that was found and needs to be handled.

Definition at line 1465 of file pcb_selection_tool.cpp.

1466 {
1467  bool cleared = false;
1468 
1469  if( m_selection.GetSize() > 0 )
1470  {
1471  // Don't fire an event now; most of the time it will be redundant as we're about to
1472  // fire a SelectedEvent.
1473  cleared = true;
1474  ClearSelection( true /*quiet mode*/ );
1475  }
1476 
1477  if( aItem )
1478  {
1479  select( aItem );
1480  m_frame->FocusOnLocation( aItem->GetPosition() );
1481 
1482  // Inform other potentially interested tools
1484  }
1485  else if( cleared )
1486  {
1488  }
1489 
1491 }
static const TOOL_EVENT SelectedEvent
Definition: actions.h:199
void ForceRefresh()
Force a redraw.
void select(BOARD_ITEM *aItem)
Take necessary action mark an item as selected.
PCB_DRAW_PANEL_GAL * GetCanvas() const override
Return a pointer to GAL-based canvas of given EDA draw frame.
TOOL_MANAGER * m_toolMgr
Definition: tool_base.h:214
virtual wxPoint GetPosition() const
Definition: eda_item.h:252
PCB_BASE_FRAME * m_frame
bool ProcessEvent(const TOOL_EVENT &aEvent)
Propagate an event to tools that requested events of matching type(s).
static const TOOL_EVENT ClearedEvent
Selected item had a property changed (except movement)
Definition: actions.h:201
PCB_SELECTION m_selection
virtual unsigned int GetSize() const override
Return the number of stored items.
Definition: selection.h:87
int ClearSelection(const TOOL_EVENT &aEvent)
void FocusOnLocation(const wxPoint &aPos)
Useful to focus on a particular location, in find functions.

References EVENTS::ClearedEvent, ClearSelection(), EDA_DRAW_FRAME::FocusOnLocation(), EDA_DRAW_PANEL_GAL::ForceRefresh(), PCB_BASE_FRAME::GetCanvas(), EDA_ITEM::GetPosition(), SELECTION::GetSize(), m_frame, m_selection, TOOL_BASE::m_toolMgr, TOOL_MANAGER::ProcessEvent(), select(), and EVENTS::SelectedEvent.

Referenced by PCB_EDIT_FRAME::FindNext(), and PCB_EDIT_FRAME::ShowFindDialog().

◆ footprint()

◆ frame()

PCB_BASE_EDIT_FRAME* PCB_TOOL_BASE::frame ( ) const
inlineprotectedinherited

Definition at line 160 of file pcb_tool_base.h.

161  {
162  return getEditFrame<PCB_BASE_EDIT_FRAME>();
163  }

Referenced by PCB_POINT_EDITOR::addCorner(), AUTOPLACE_TOOL::autoplace(), PCB_TOOL_BASE::canvas(), ZONE_FILLER_TOOL::CheckAllZones(), PNS::TOOL_BASE::checkSnap(), PAD_TOOL::copyPadSettings(), EDIT_TOOL::copyToClipboard(), BOARD_INSPECTION_TOOL::CrossProbePcbToSch(), ROUTER_TOOL::CustomTrackWidthDialog(), FOOTPRINT_EDITOR_CONTROL::DeleteFootprint(), PCB_TOOL_BASE::displayOptions(), PCB_TOOL_BASE::doInteractiveItemPlacement(), EDIT_TOOL::doMoveSelection(), ROUTER_TOOL::DpDimensionsDialog(), EDIT_TOOL::DragArcTrack(), DRAWING_TOOL::drawArc(), DRAWING_TOOL::DrawDimension(), MICROWAVE_TOOL::drawMicrowaveInductor(), DRAWING_TOOL::drawSegment(), DRAWING_TOOL::DrawVia(), DRAWING_TOOL::DrawZone(), PAD_TOOL::EditPad(), PAD_TOOL::EnumeratePads(), PAD_TOOL::explodePad(), BOARD_EDITOR_CONTROL::ExportSpecctraDSN(), ZONE_FILLER_TOOL::FillAllZones(), EDIT_TOOL::FilletTracks(), ROUTER_TOOL::finishInteractive(), EDIT_TOOL::Flip(), PCB_CONTROL::FlipPcbView(), GLOBAL_EDIT_TOOL::GlobalDeletions(), ROUTER_TOOL::handleLayerSwitch(), BOARD_INSPECTION_TOOL::HighlightItem(), FOOTPRINT_EDITOR_CONTROL::ImportFootprint(), BOARD_EDITOR_CONTROL::ImportSpecctraSession(), ROUTER_TOOL::Init(), SCRIPTING_TOOL::Init(), Init(), EDIT_TOOL::Init(), ROUTER_TOOL::InlineBreakTrack(), ROUTER_TOOL::InlineDrag(), DRAWING_TOOL::InteractivePlaceWithPreview(), PCB_TOOL_BASE::Is45Limited(), PCB_PICKER_TOOL::Main(), Main(), ROUTER_TOOL::MainLoop(), LENGTH_TUNER_TOOL::MainLoop(), LENGTH_TUNER_TOOL::meanderSettingsDialog(), EDIT_TOOL::MoveExact(), PCB_POINT_EDITOR::OnSelectionChange(), PCB_CONTROL::Paste(), PAD_TOOL::pastePadProperties(), ROUTER_TOOL::performDragging(), ROUTER_TOOL::performRouting(), LENGTH_TUNER_TOOL::performTuning(), GROUP_TOOL::PickNewMember(), PCB_CONTROL::placeBoardItems(), BOARD_EDITOR_CONTROL::PlaceFootprint(), BOARD_EDITOR_CONTROL::PlaceTarget(), DRAWING_TOOL::PlaceText(), ROUTER_TOOL::prepareInteractive(), PAD_TOOL::pushPadSettings(), PAD_TOOL::recombinePad(), POSITION_RELATIVE_TOOL::RelativeItemSelectionMove(), SCRIPTING_TOOL::reloadPlugins(), EDIT_TOOL::Remove(), PCB_POINT_EDITOR::removeCorner(), RequestSelection(), PNS::TOOL_BASE::Reset(), ROUTER_TOOL::SelectCopperLayerPair(), POSITION_RELATIVE_TOOL::SelectPositionRelativeItem(), PCB_POINT_EDITOR::setEditedPoint(), ROUTER_TOOL::SettingsDialog(), GLOBAL_EDIT_TOOL::swapBoardItem(), GLOBAL_EDIT_TOOL::SwapLayers(), ROUTER_TOOL::switchLayerOnViaPlacement(), PCB_CONTROL::unfilledZoneCheck(), ROUTER_TOOL::updateMessagePanel(), EDIT_TOOL::updateModificationPoint(), BOARD_EDITOR_CONTROL::UpdateSchematicFromPCB(), ZONE_FILLER_TOOL::ZoneFill(), and ZONE_FILLER_TOOL::ZoneFillAll().

◆ GetBoard()

BOARD* PCB_SELECTION_TOOL::GetBoard ( ) const
inline

Definition at line 184 of file pcb_selection_tool.h.

185  {
186  return board();
187  }
BOARD * board() const

References PCB_TOOL_BASE::board().

Referenced by GROUP_CONTEXT_MENU::update().

◆ getCollectorsGuide()

const GENERAL_COLLECTORS_GUIDE PCB_SELECTION_TOOL::getCollectorsGuide ( ) const
private

Definition at line 632 of file pcb_selection_tool.cpp.

633 {
634  GENERAL_COLLECTORS_GUIDE guide( board()->GetVisibleLayers(),
635  (PCB_LAYER_ID) view()->GetTopLayer(), view() );
636 
637  bool padsDisabled = !board()->IsElementVisible( LAYER_PADS );
638 
639  // account for the globals
640  guide.SetIgnoreMTextsMarkedNoShow( ! board()->IsElementVisible( LAYER_MOD_TEXT_INVISIBLE ) );
641  guide.SetIgnoreMTextsOnBack( ! board()->IsElementVisible( LAYER_MOD_TEXT_BK ) );
642  guide.SetIgnoreMTextsOnFront( ! board()->IsElementVisible( LAYER_MOD_TEXT_FR ) );
643  guide.SetIgnoreModulesOnBack( ! board()->IsElementVisible( LAYER_MOD_BK ) );
644  guide.SetIgnoreModulesOnFront( ! board()->IsElementVisible( LAYER_MOD_FR ) );
645  guide.SetIgnorePadsOnBack( padsDisabled || ! board()->IsElementVisible( LAYER_PAD_BK ) );
646  guide.SetIgnorePadsOnFront( padsDisabled || ! board()->IsElementVisible( LAYER_PAD_FR ) );
647  guide.SetIgnoreThroughHolePads( padsDisabled || ! board()->IsElementVisible( LAYER_PADS_TH ) );
648  guide.SetIgnoreModulesVals( ! board()->IsElementVisible( LAYER_MOD_VALUES ) );
649  guide.SetIgnoreModulesRefs( ! board()->IsElementVisible( LAYER_MOD_REFERENCES ) );
650  guide.SetIgnoreThroughVias( ! board()->IsElementVisible( LAYER_VIAS ) );
651  guide.SetIgnoreBlindBuriedVias( ! board()->IsElementVisible( LAYER_VIAS ) );
652  guide.SetIgnoreMicroVias( ! board()->IsElementVisible( LAYER_VIAS ) );
653  guide.SetIgnoreTracks( ! board()->IsElementVisible( LAYER_TRACKS ) );
654 
655  return guide;
656 }
smd pads, front layer
Definition: layer_ids.h:197
BOARD * board() const
Meta control for all pads opacity/visibility (color ignored)
Definition: layer_ids.h:225
show footprints values (when texts are visible)
Definition: layer_ids.h:205
smd pads, back layer
Definition: layer_ids.h:198
show footprints on back
Definition: layer_ids.h:204
Meta control for all vias opacity/visibility.
Definition: layer_ids.h:188
text marked as invisible
Definition: layer_ids.h:195
show footprints on front
Definition: layer_ids.h:203
KIGFX::PCB_VIEW * view() const
bool IsElementVisible(GAL_LAYER_ID aLayer) const
Test whether a given element category is visible.
Definition: board.cpp:532
show footprints references (when texts are visible)
Definition: layer_ids.h:206
multilayer pads, usually with holes
Definition: layer_ids.h:208
PCB_LAYER_ID
A quick note on layer IDs:
Definition: layer_ids.h:64
A general implementation of a COLLECTORS_GUIDE.
Definition: collectors.h:377

References PCB_TOOL_BASE::board(), BOARD::IsElementVisible(), LAYER_MOD_BK, LAYER_MOD_FR, LAYER_MOD_REFERENCES, LAYER_MOD_TEXT_BK, LAYER_MOD_TEXT_FR, LAYER_MOD_TEXT_INVISIBLE, LAYER_MOD_VALUES, LAYER_PAD_BK, LAYER_PAD_FR, LAYER_PADS, LAYER_PADS_TH, LAYER_TRACKS, LAYER_VIAS, GENERAL_COLLECTORS_GUIDE::SetIgnoreBlindBuriedVias(), GENERAL_COLLECTORS_GUIDE::SetIgnoreMicroVias(), GENERAL_COLLECTORS_GUIDE::SetIgnoreModulesOnBack(), GENERAL_COLLECTORS_GUIDE::SetIgnoreModulesOnFront(), GENERAL_COLLECTORS_GUIDE::SetIgnoreModulesRefs(), GENERAL_COLLECTORS_GUIDE::SetIgnoreModulesVals(), GENERAL_COLLECTORS_GUIDE::SetIgnoreMTextsMarkedNoShow(), GENERAL_COLLECTORS_GUIDE::SetIgnoreMTextsOnBack(), GENERAL_COLLECTORS_GUIDE::SetIgnoreMTextsOnFront(), GENERAL_COLLECTORS_GUIDE::SetIgnorePadsOnBack(), GENERAL_COLLECTORS_GUIDE::SetIgnorePadsOnFront(), GENERAL_COLLECTORS_GUIDE::SetIgnoreThroughHolePads(), GENERAL_COLLECTORS_GUIDE::SetIgnoreThroughVias(), GENERAL_COLLECTORS_GUIDE::SetIgnoreTracks(), and PCB_TOOL_BASE::view().

Referenced by selectionContains(), and selectPoint().

◆ getEditFrame()

template<typename T >
T* TOOL_BASE::getEditFrame ( ) const
inlineprotectedinherited

Return the application window object, casted to requested user type.

Definition at line 184 of file tool_base.h.

185  {
186 #if !defined( QA_TEST ) // Dynamic casts give the linker a seizure in the test framework
187  wxASSERT( dynamic_cast<T*>( getToolHolderInt() ) );
188 #endif
189  return static_cast<T*>( getToolHolderInt() );
190  }
TOOLS_HOLDER * getToolHolderInt() const
Definition: tool_base.cpp:48

References TOOL_BASE::getToolHolderInt().

Referenced by ZONE_CREATE_HELPER::createNewZone().

◆ GetEnteredGroup()

PCB_GROUP* PCB_SELECTION_TOOL::GetEnteredGroup ( )
inline

Definition at line 198 of file pcb_selection_tool.h.

198 { return m_enteredGroup; }

References m_enteredGroup.

Referenced by PCB_CONTROL::placeBoardItems(), and EDIT_TOOL::Remove().

◆ GetFilter()

◆ GetId()

TOOL_ID TOOL_BASE::GetId ( ) const
inlineinherited

Return the unique identifier of the tool.

The identifier is set by an instance of TOOL_MANAGER.

Returns
Identifier of the tool.

Definition at line 120 of file tool_base.h.

121  {
122  return m_toolId;
123  }
TOOL_ID m_toolId
Name of the tool.
Definition: tool_base.h:209

References TOOL_BASE::m_toolId.

Referenced by TOOL_MANAGER::finishTool(), TOOL_MANAGER::InitTools(), TOOL_MANAGER::isActive(), TOOL_MANAGER::RegisterTool(), ACTION_MANAGER::RunHotKey(), TOOL_MANAGER::runTool(), TOOL_MANAGER::saveViewControls(), and TOOL_MANAGER::ShutdownTool().

◆ GetManager()

TOOL_MANAGER* TOOL_BASE::GetManager ( ) const
inlineinherited

Return the instance of TOOL_MANAGER that takes care of the tool.

Returns
Instance of the TOOL_MANAGER or NULL if there is no associated tool manager.

Definition at line 143 of file tool_base.h.

144  {
145  return m_toolMgr;
146  }
TOOL_MANAGER * m_toolMgr
Definition: tool_base.h:214

References TOOL_BASE::m_toolMgr.

Referenced by BOARD_COMMIT::BOARD_COMMIT(), ZONE_CREATE_HELPER::commitZone(), ZONE_CREATE_HELPER::createNewZone(), PCB_TOOL_BASE::doInteractiveItemPlacement(), ACTION_MENU::getToolManager(), LIB_TREE::onContextMenu(), ZONE_CREATE_HELPER::OnFirstPoint(), ACTION_MENU::OnMenuEvent(), and ZONE_CREATE_HELPER::performZoneCutout().

◆ getModel()

template<typename T >
T* TOOL_BASE::getModel ( ) const
inlineprotectedinherited

Return the model object if it matches the requested type.

Store the type of the tool.

Definition at line 196 of file tool_base.h.

References TOOL_BASE::getModelInt().

Referenced by ZONE_CREATE_HELPER::commitZone(), and ZONE_CREATE_HELPER::createZoneFromExisting().

◆ GetName()

const std::string& TOOL_BASE::GetName ( void  ) const
inlineinherited

Return the name of the tool.

Tool names are expected to obey the format: application.ToolName (eg. pcbnew.InteractiveSelection).

Returns
The name of the tool.

Definition at line 133 of file tool_base.h.

134  {
135  return m_toolName;
136  }
std::string m_toolName
Definition: tool_base.h:213

References TOOL_BASE::m_toolName.

Referenced by TOOL_MANAGER::dispatchInternal(), TOOL_MANAGER::InitTools(), TOOL_MANAGER::invokeTool(), TOOL_MANAGER::RegisterTool(), and TOOL_MANAGER::runTool().

◆ GetSelection()

◆ GetToolMenu()

◆ GetType()

TOOL_TYPE TOOL_BASE::GetType ( ) const
inlineinherited

Return the type of the tool.

Returns
The type of the tool.

Definition at line 108 of file tool_base.h.

109  {
110  return m_type;
111  }
TOOL_TYPE m_type
Unique identifier for the tool, assigned by a TOOL_MANAGER instance.
Definition: tool_base.h:206

References TOOL_BASE::m_type.

Referenced by TOOL_MANAGER::finishTool(), TOOL_MANAGER::InvokeTool(), TOOL_MANAGER::ResetTools(), TOOL_MANAGER::runTool(), and TOOL_MANAGER::ShutdownTool().

◆ getView()

KIGFX::VIEW * TOOL_BASE::getView ( ) const
protectedinherited

Returns the instance of #VIEW object used in the application.

It allows tools to draw.

Returns
The instance of VIEW.

Definition at line 36 of file tool_base.cpp.

37 {
38  return m_toolMgr->GetView();
39 }
KIGFX::VIEW * GetView() const
Definition: tool_manager.h:283
TOOL_MANAGER * m_toolMgr
Definition: tool_base.h:214

References TOOL_MANAGER::GetView(), and TOOL_BASE::m_toolMgr.

Referenced by EE_POINT_EDITOR::addCornerCondition(), ALIGN_DISTRIBUTE_TOOL::AlignLeft(), ALIGN_DISTRIBUTE_TOOL::AlignRight(), COMMON_TOOLS::CenterContents(), SCH_EDIT_TOOL::ChangeTextType(), EE_INSPECTION_TOOL::CheckSymbol(), GERBVIEW_CONTROL::ClearAllLayers(), PL_SELECTION_TOOL::ClearSelection(), EE_SELECTION_TOOL::ClearSelection(), EE_SELECTION_TOOL::CollectHits(), SCH_LINE_WIRE_BUS_TOOL::computeBreakPoint(), COMMON_TOOLS::CursorControl(), PL_EDIT_TOOL::DeleteItemCursor(), SCH_EDIT_TOOL::DeleteItemCursor(), PCB_CONTROL::DeleteItemCursor(), GERBVIEW_SELECTION_TOOL::disambiguationMenu(), PL_EDIT_TOOL::DoDelete(), SCH_LINE_WIRE_BUS_TOOL::doDrawSegments(), PCB_TOOL_BASE::doInteractiveItemPlacement(), EDIT_TOOL::doMoveSelection(), PL_SELECTION_TOOL::doSelectionMenu(), EE_SELECTION_TOOL::doSelectionMenu(), doSelectionMenu(), COMMON_TOOLS::doZoomFit(), COMMON_TOOLS::doZoomInOut(), COMMON_TOOLS::doZoomToPreset(), EDIT_TOOL::DragArcTrack(), DRAWING_TOOL::drawArc(), DRAWING_TOOL::DrawDimension(), MICROWAVE_TOOL::drawMicrowaveInductor(), DRAWING_TOOL::drawSegment(), SCH_LINE_WIRE_BUS_TOOL::DrawSegments(), PL_DRAWING_TOOLS::DrawShape(), DRAWING_TOOL::DrawZone(), BOARD_EDITOR_CONTROL::DrillOrigin(), SYMBOL_EDITOR_EDIT_TOOL::Duplicate(), PAD_TOOL::EnumeratePads(), SCH_EDITOR_CONTROL::FindSymbolAndItem(), EE_SELECTION_TOOL::GetNode(), ROUTER_TOOL::getStartLayer(), PCB_CONTROL::GridResetOrigin(), PCB_CONTROL::GridSetOrigin(), ROUTER_TOOL::handleCommonEvents(), PL_SELECTION_TOOL::highlight(), EE_SELECTION_TOOL::highlight(), highlight(), GERBVIEW_CONTROL::HighlightControl(), PNS::TOOL_BASE::highlightNet(), BOARD_INSPECTION_TOOL::highlightNet(), hitTestDistance(), SCH_EDIT_TOOL::Init(), EDIT_TOOL::Init(), ROUTER_TOOL::InlineDrag(), PCB_PICKER_TOOL::Main(), EE_POINT_EDITOR::Main(), PL_POINT_EDITOR::Main(), SCH_MOVE_TOOL::Main(), GERBVIEW_INSPECTION_TOOL::MeasureTool(), PCB_VIEWER_TOOLS::MeasureTool(), SCH_EDIT_TOOL::Mirror(), EDIT_TOOL::MoveExact(), SCH_MOVE_TOOL::moveItem(), PL_EDIT_TOOL::moveItem(), COMMON_TOOLS::OnGridChanged(), PCB_POINT_EDITOR::OnSelectionChange(), COMMON_TOOLS::PanControl(), SYMBOL_EDITOR_EDIT_TOOL::Paste(), PL_EDIT_TOOL::Paste(), SCH_EDITOR_CONTROL::Paste(), ROUTER_TOOL::performRouting(), PNS::TOOL_BASE::pickSingleItem(), BOARD_EDITOR_CONTROL::PlaceFootprint(), PL_DRAWING_TOOLS::PlaceItem(), BOARD_EDITOR_CONTROL::PlaceTarget(), ROUTER_TOOL::prepareInteractive(), SCH_EDIT_TOOL::Properties(), EDIT_TOOL::Properties(), EDIT_TOOL::Remove(), BOARD_EDITOR_CONTROL::Reset(), PNS::TOOL_BASE::Reset(), PCB_CONTROL::Reset(), GERBVIEW_SELECTION_TOOL::Reset(), DRAWING_TOOL::Reset(), EE_SELECTION_TOOL::Reset(), Reset(), EE_TOOL_BASE< SCH_BASE_FRAME >::Reset(), SCH_EDIT_TOOL::Rotate(), GERBVIEW_SELECTION_TOOL::select(), GERBVIEW_SELECTION_TOOL::selectable(), Selectable(), SelectAll(), EE_SELECTION_TOOL::SelectAll(), PL_SELECTION_TOOL::selectionContains(), EE_SELECTION_TOOL::selectionContains(), PL_SELECTION_TOOL::selectMultiple(), EE_SELECTION_TOOL::selectMultiple(), selectMultiple(), PL_SELECTION_TOOL::SelectPoint(), ZOOM_TOOL::selectRegion(), GERBVIEW_SELECTION_TOOL::selectVisually(), DRAWING_TOOL::SetAnchor(), SCH_DRAWING_TOOLS::SingleClickPlace(), SCH_EDITOR_CONTROL::ToggleHiddenFields(), SCH_EDITOR_CONTROL::ToggleHiddenPins(), SCH_DRAWING_TOOLS::TwoClickPlace(), PL_SELECTION_TOOL::unhighlight(), EE_SELECTION_TOOL::unhighlight(), unhighlight(), GERBVIEW_SELECTION_TOOL::unselect(), GERBVIEW_SELECTION_TOOL::unselectVisually(), EE_POINT_EDITOR::updateEditedPoint(), PL_POINT_EDITOR::updateEditedPoint(), PCB_POINT_EDITOR::updateEditedPoint(), SCH_EDITOR_CONTROL::UpdateFind(), PL_POINT_EDITOR::updateItem(), PCB_POINT_EDITOR::updateItem(), EE_TOOL_BASE< SCH_BASE_FRAME >::updateItem(), SCH_EDITOR_CONTROL::UpdateNetHighlighting(), EE_POINT_EDITOR::updateParentItem(), EE_POINT_EDITOR::updatePoints(), PL_POINT_EDITOR::updatePoints(), PCB_POINT_EDITOR::updatePoints(), updateSelection(), PNS::TOOL_BASE::updateStartItem(), PCB_VIEWER_TOOLS::view(), PCB_TOOL_BASE::view(), zoomFitSelection(), EE_SELECTION_TOOL::~EE_SELECTION_TOOL(), GERBVIEW_SELECTION_TOOL::~GERBVIEW_SELECTION_TOOL(), and ~PCB_SELECTION_TOOL().

◆ getViewControls()

KIGFX::VIEW_CONTROLS * TOOL_BASE::getViewControls ( ) const
protectedinherited

Return the instance of VIEW_CONTROLS object used in the application.

It allows tools to read & modify user input and its settings (eg. show cursor, enable snapping to grid, etc.).

Returns
The instance of VIEW_CONTROLS.

Definition at line 42 of file tool_base.cpp.

43 {
44  return m_toolMgr->GetViewControls();
45 }
TOOL_MANAGER * m_toolMgr
Definition: tool_base.h:214
KIGFX::VIEW_CONTROLS * GetViewControls() const
Definition: tool_manager.h:285

References TOOL_MANAGER::GetViewControls(), and TOOL_BASE::m_toolMgr.

Referenced by EE_POINT_EDITOR::addCorner(), PCB_POINT_EDITOR::addCorner(), EE_POINT_EDITOR::addCornerCondition(), SCH_EDITOR_CONTROL::AssignNetclass(), SCH_EDIT_TOOL::BreakWire(), PCB_TOOL_BASE::controls(), EDIT_TOOL::copyToClipboard(), SCH_DRAWING_TOOLS::createSheetPin(), COMMON_TOOLS::CursorControl(), SCH_LINE_WIRE_BUS_TOOL::doDrawSegments(), EDIT_TOOL::doMoveSelection(), SCH_LINE_WIRE_BUS_TOOL::doUnfoldBus(), COMMON_TOOLS::doZoomToPreset(), EDIT_TOOL::DragArcTrack(), DRAWING_TOOL::DrawCircle(), DRAWING_TOOL::DrawLine(), MICROWAVE_TOOL::drawMicrowaveInductor(), DRAWING_TOOL::DrawRectangle(), SYMBOL_EDITOR_DRAWING_TOOLS::DrawShape(), PL_DRAWING_TOOLS::DrawShape(), SCH_DRAWING_TOOLS::DrawSheet(), SYMBOL_EDITOR_EDIT_TOOL::Duplicate(), PAD_TOOL::EnumeratePads(), SCH_LINE_WIRE_BUS_TOOL::finishSegments(), SCH_DRAWING_TOOLS::GetCanvasFreeAreaPixels(), BOARD_INSPECTION_TOOL::HighlightNet(), SCH_EDITOR_CONTROL::HighlightNet(), FOOTPRINT_EDITOR_CONTROL::ImportFootprint(), SCH_EDIT_TOOL::Init(), EDIT_TOOL::Init(), PCB_PICKER_TOOL::Main(), EE_POINT_EDITOR::Main(), PL_EDIT_TOOL::Main(), SYMBOL_EDITOR_MOVE_TOOL::Main(), PL_POINT_EDITOR::Main(), SCH_MOVE_TOOL::Main(), EE_SELECTION_TOOL::Main(), PICKER_TOOL::Main(), ROUTER_TOOL::MainLoop(), GERBVIEW_INSPECTION_TOOL::MeasureTool(), PCB_VIEWER_TOOLS::MeasureTool(), COMMON_TOOLS::OnGridChanged(), PCB_POINT_EDITOR::OnSelectionChange(), SYMBOL_EDITOR_EDIT_TOOL::Paste(), ROUTER_TOOL::performDragging(), LENGTH_TUNER_TOOL::performTuning(), SYMBOL_EDITOR_DRAWING_TOOLS::PlaceAnchor(), PCB_CONTROL::placeBoardItems(), BOARD_EDITOR_CONTROL::PlaceFootprint(), SCH_DRAWING_TOOLS::PlaceImage(), PL_DRAWING_TOOLS::PlaceItem(), SCH_DRAWING_TOOLS::PlaceSymbol(), BOARD_EDITOR_CONTROL::PlaceTarget(), SCH_EDIT_TOOL::Properties(), EDIT_TOOL::Properties(), EDIT_TOOL::Remove(), SCH_EDIT_TOOL::RepeatDrawItem(), PL_SELECTION_TOOL::RequestSelection(), EE_SELECTION_TOOL::RequestSelection(), PCB_POINT_EDITOR::Reset(), DRAWING_TOOL::Reset(), COMMON_TOOLS::ResetLocalCoords(), GERBVIEW_SELECTION_TOOL::selectCursor(), selectCursor(), PL_SELECTION_TOOL::selectMultiple(), EE_SELECTION_TOOL::selectMultiple(), selectMultiple(), EE_SELECTION_TOOL::SelectNode(), ZOOM_TOOL::selectRegion(), ALIGN_DISTRIBUTE_TOOL::selectTarget(), PCB_PICKER_TOOL::setControls(), PICKER_TOOL::setControls(), EE_POINT_EDITOR::setEditedPoint(), PL_POINT_EDITOR::setEditedPoint(), PCB_POINT_EDITOR::setEditedPoint(), SCH_DRAWING_TOOLS::SingleClickPlace(), SYMBOL_EDITOR_DRAWING_TOOLS::TwoClickPlace(), SCH_DRAWING_TOOLS::TwoClickPlace(), EE_POINT_EDITOR::updateEditedPoint(), PL_POINT_EDITOR::updateEditedPoint(), PCB_POINT_EDITOR::updateEditedPoint(), PCB_POINT_EDITOR::updateItem(), PL_EDIT_TOOL::updateModificationPoint(), and COMMON_TOOLS::ZoomCenter().

◆ Go()

template<class T >
void TOOL_INTERACTIVE::Go ( int(T::*)(const TOOL_EVENT &)  aStateFunc,
const TOOL_EVENT_LIST aConditions = TOOL_EVENTTC_ANYTA_ANY ) 
)
inherited

Define which state (aStateFunc) to go when a certain event arrives (aConditions).

No conditions means any event.

Definition at line 147 of file tool_interactive.h.

149 {
150  TOOL_STATE_FUNC sptr = std::bind( aStateFunc, static_cast<T*>( this ), std::placeholders::_1 );
151 
152  goInternal( sptr, aConditions );
153 }
std::function< int(const TOOL_EVENT &)> TOOL_STATE_FUNC
Definition: tool_base.h:58
void goInternal(TOOL_STATE_FUNC &aState, const TOOL_EVENT_LIST &aConditions)

References TOOL_INTERACTIVE::goInternal().

Referenced by AUTOPLACE_TOOL::setTransitions(), ZOOM_TOOL::setTransitions(), LENGTH_TUNER_TOOL::setTransitions(), BOARD_REANNOTATE_TOOL::setTransitions(), GERBVIEW_INSPECTION_TOOL::setTransitions(), ROUTER_TOOL::setTransitions(), PCB_PICKER_TOOL::setTransitions(), SCH_NAVIGATE_TOOL::setTransitions(), SYMBOL_EDITOR_PIN_TOOL::setTransitions(), SYMBOL_EDITOR_MOVE_TOOL::setTransitions(), PL_DRAWING_TOOLS::setTransitions(), EE_POINT_EDITOR::setTransitions(), PL_POINT_EDITOR::setTransitions(), SCRIPTING_TOOL::setTransitions(), COMMON_CONTROL::setTransitions(), KICAD_MANAGER_CONTROL::setTransitions(), CONVERT_TOOL::setTransitions(), SYMBOL_EDITOR_DRAWING_TOOLS::setTransitions(), ZONE_FILLER_TOOL::setTransitions(), PCB_VIEWER_TOOLS::setTransitions(), MICROWAVE_TOOL::setTransitions(), EE_INSPECTION_TOOL::setTransitions(), PAD_TOOL::setTransitions(), PCB_POINT_EDITOR::setTransitions(), GERBVIEW_CONTROL::setTransitions(), CVPCB_FOOTPRINT_VIEWER_SELECTION_TOOL::setTransitions(), GLOBAL_EDIT_TOOL::setTransitions(), GROUP_TOOL::setTransitions(), PL_EDITOR_CONTROL::setTransitions(), SYMBOL_EDITOR_EDIT_TOOL::setTransitions(), SYMBOL_EDITOR_CONTROL::setTransitions(), SCH_MOVE_TOOL::setTransitions(), PL_EDIT_TOOL::setTransitions(), POSITION_RELATIVE_TOOL::setTransitions(), GERBVIEW_SELECTION_TOOL::setTransitions(), SCH_DRAWING_TOOLS::setTransitions(), FOOTPRINT_EDITOR_CONTROL::setTransitions(), SCH_EDIT_TOOL::setTransitions(), ALIGN_DISTRIBUTE_TOOL::setTransitions(), COMMON_TOOLS::setTransitions(), PCB_CONTROL::setTransitions(), EDA_3D_CONTROLLER::setTransitions(), DRC_TOOL::setTransitions(), CVPCB_CONTROL::setTransitions(), SCH_LINE_WIRE_BUS_TOOL::setTransitions(), CVPCB_ASSOCIATION_TOOL::setTransitions(), BOARD_INSPECTION_TOOL::setTransitions(), BOARD_EDITOR_CONTROL::setTransitions(), PICKER_TOOL::setTransitions(), EDIT_TOOL::setTransitions(), setTransitions(), PL_SELECTION_TOOL::setTransitions(), SCH_EDITOR_CONTROL::setTransitions(), DRAWING_TOOL::setTransitions(), and EE_SELECTION_TOOL::setTransitions().

◆ GuessSelectionCandidates()

void PCB_SELECTION_TOOL::GuessSelectionCandidates ( GENERAL_COLLECTOR aCollector,
const VECTOR2I aWhere 
) const

Try to guess best selection candidates in case multiple items are clicked, by doing some brain-dead heuristics.

Parameters
aCollectoris the collector that has a list of items to be queried.
aWhereis the selection point to consider

Definition at line 2371 of file pcb_selection_tool.cpp.

2373 {
2374  std::set<BOARD_ITEM*> preferred;
2375  std::set<BOARD_ITEM*> rejected;
2376  wxPoint where( aWhere.x, aWhere.y );
2377 
2378  PCB_LAYER_ID activeLayer = (PCB_LAYER_ID) view()->GetTopLayer();
2379  LSET silkLayers( 2, B_SilkS, F_SilkS );
2380 
2381  if( silkLayers[activeLayer] )
2382  {
2383  for( int i = 0; i < aCollector.GetCount(); ++i )
2384  {
2385  BOARD_ITEM* item = aCollector[i];
2386  KICAD_T type = item->Type();
2387 
2388  if( ( type == PCB_FP_TEXT_T || type == PCB_TEXT_T || type == PCB_SHAPE_T )
2389  && silkLayers[item->GetLayer()] )
2390  {
2391  preferred.insert( item );
2392  }
2393  }
2394 
2395  if( preferred.size() > 0 )
2396  {
2397  aCollector.Empty();
2398 
2399  for( BOARD_ITEM* item : preferred )
2400  aCollector.Append( item );
2401 
2402  return;
2403  }
2404  }
2405 
2406  // Prefer exact hits to sloppy ones
2407  constexpr int MAX_SLOP = 5;
2408 
2409  int pixel = (int) aCollector.GetGuide()->OnePixelInIU();
2410  int minSlop = INT_MAX;
2411 
2412  std::map<BOARD_ITEM*, int> itemsBySloppiness;
2413 
2414  for( int i = 0; i < aCollector.GetCount(); ++i )
2415  {
2416  BOARD_ITEM* item = aCollector[i];
2417  int itemSlop = hitTestDistance( where, item, MAX_SLOP * pixel );
2418 
2419  itemsBySloppiness[ item ] = itemSlop;
2420 
2421  if( itemSlop < minSlop )
2422  minSlop = itemSlop;
2423  }
2424 
2425  // Prune sloppier items
2426  if( minSlop < INT_MAX )
2427  {
2428  for( std::pair<BOARD_ITEM*, int> pair : itemsBySloppiness )
2429  {
2430  if( pair.second > minSlop + pixel )
2431  aCollector.Transfer( pair.first );
2432  }
2433  }
2434 
2435  // If the user clicked on a small item within a much larger one then it's pretty clear
2436  // they're trying to select the smaller one.
2437  constexpr double sizeRatio = 1.5;
2438 
2439  std::vector<std::pair<BOARD_ITEM*, double>> itemsByArea;
2440 
2441  for( int i = 0; i < aCollector.GetCount(); ++i )
2442  {
2443  BOARD_ITEM* item = aCollector[i];
2444  double area;
2445 
2446  if( ( item->Type() == PCB_ZONE_T || item->Type() == PCB_FP_ZONE_T )
2447  && static_cast<ZONE*>( item )->HitTestForEdge( where, MAX_SLOP * pixel / 2 ) )
2448  {
2449  // Zone borders are very specific, so make them "small"
2450  area = MAX_SLOP * SEG::Square( pixel );
2451  }
2452  else if( item->Type() == PCB_VIA_T )
2453  {
2454  // Vias rarely hide other things, and we don't want them deferring to short track
2455  // segments -- so make them artificially small by dropping the π from πr².
2456  area = SEG::Square( static_cast<PCB_VIA*>( item )->GetDrill() / 2 );
2457  }
2458  else
2459  {
2460  try
2461  {
2462  area = FOOTPRINT::GetCoverageArea( item, aCollector );
2463  }
2464  catch( const ClipperLib::clipperException& e )
2465  {
2466  wxLogError( "A clipper exception %s was detected.", e.what() );
2467  }
2468  }
2469 
2470  itemsByArea.emplace_back( item, area );
2471  }
2472 
2473  std::sort( itemsByArea.begin(), itemsByArea.end(),
2474  []( const std::pair<BOARD_ITEM*, double>& lhs,
2475  const std::pair<BOARD_ITEM*, double>& rhs ) -> bool
2476  {
2477  return lhs.second < rhs.second;
2478  } );
2479 
2480  bool rejecting = false;
2481 
2482  for( int i = 1; i < (int) itemsByArea.size(); ++i )
2483  {
2484  if( itemsByArea[i].second > itemsByArea[i-1].second * sizeRatio )
2485  rejecting = true;
2486 
2487  if( rejecting )
2488  rejected.insert( itemsByArea[i].first );
2489  }
2490 
2491  // Special case: if a footprint is completely covered with other features then there's no
2492  // way to select it -- so we need to leave it in the list for user disambiguation.
2493  constexpr double maxCoverRatio = 0.70;
2494 
2495  for( int i = 0; i < aCollector.GetCount(); ++i )
2496  {
2497  if( FOOTPRINT* footprint = dynamic_cast<FOOTPRINT*>( aCollector[i] ) )
2498  {
2499  if( footprint->CoverageRatio( aCollector ) > maxCoverRatio )
2500  rejected.erase( footprint );
2501  }
2502  }
2503 
2504  // Hopefully we've now got what the user wanted.
2505  if( (unsigned) aCollector.GetCount() > rejected.size() ) // do not remove everything
2506  {
2507  for( BOARD_ITEM* item : rejected )
2508  aCollector.Transfer( item );
2509  }
2510 
2511  // Finally, what we are left with is a set of items of similar coverage area. We now reject
2512  // any that are not on the active layer, to reduce the number of disambiguation menus shown.
2513  // If the user wants to force-disambiguate, they can either switch layers or use the modifier
2514  // key to force the menu.
2515  if( aCollector.GetCount() > 1 )
2516  {
2517  bool haveItemOnActive = false;
2518  rejected.clear();
2519 
2520  for( int i = 0; i < aCollector.GetCount(); ++i )
2521  {
2522  if( !aCollector[i]->IsOnLayer( activeLayer ) )
2523  rejected.insert( aCollector[i] );
2524  else
2525  haveItemOnActive = true;
2526  }
2527 
2528  if( haveItemOnActive )
2529  for( BOARD_ITEM* item : rejected )
2530  aCollector.Transfer( item );
2531  }
2532 }
void Empty()
Clear the list.
Definition: collector.h:95
static double GetCoverageArea(const BOARD_ITEM *aItem, const GENERAL_COLLECTOR &aCollector)
Return the initial comments block or NULL if none, without transfer of ownership.
Definition: footprint.cpp:1808
class FP_TEXT, text in a footprint
Definition: typeinfo.h:92
A base class for any item which can be embedded within the BOARD container class, and therefore insta...
Definition: board_item.h:80
virtual double OnePixelInIU() const =0
class PCB_TEXT, text on a layer
Definition: typeinfo.h:91
double CoverageRatio(const GENERAL_COLLECTOR &aCollector) const
Calculate the ratio of total area of the footprint pads and graphical items to the area of the footpr...
Definition: footprint.cpp:1888
static SEG::ecoord Square(int a)
Definition: seg.h:122
KICAD_T
The set of class identification values stored in EDA_ITEM::m_structType.
Definition: typeinfo.h:77
void Append(EDA_ITEM *item)
Add an item to the end of the list.
Definition: collector.h:105
int GetCount() const
Return the number of objects in the list.
Definition: collector.h:87
void Transfer(int aIndex)
Move the item at aIndex (first position is 0) to the backup list.
Definition: collector.h:159
const COLLECTORS_GUIDE * GetGuide() const
Definition: collectors.h:339
LSET is a set of PCB_LAYER_IDs.
Definition: layer_ids.h:502
virtual int GetTopLayer() const
Definition: view.cpp:830
FOOTPRINT * footprint() const
KIGFX::PCB_VIEW * view() const
class ZONE, a copper pour area
Definition: typeinfo.h:105
PCB_LAYER_ID
A quick note on layer IDs:
Definition: layer_ids.h:64
int hitTestDistance(const wxPoint &aWhere, BOARD_ITEM *aItem, int aMaxDistance) const
class ZONE, managed by a footprint
Definition: typeinfo.h:94
class PCB_VIA, a via (like a track segment on a copper layer)
Definition: typeinfo.h:96
class PCB_SHAPE, a segment not on copper layers
Definition: typeinfo.h:90
virtual PCB_LAYER_ID GetLayer() const
Return the primary layer this item is on.
Definition: board_item.h:171
KICAD_T Type() const
Returns the type of object.
Definition: eda_item.h:113

References COLLECTOR::Append(), B_SilkS, FOOTPRINT::CoverageRatio(), COLLECTOR::Empty(), F_SilkS, PCB_TOOL_BASE::footprint(), COLLECTOR::GetCount(), FOOTPRINT::GetCoverageArea(), GENERAL_COLLECTOR::GetGuide(), BOARD_ITEM::GetLayer(), KIGFX::VIEW::GetTopLayer(), hitTestDistance(), COLLECTORS_GUIDE::OnePixelInIU(), PCB_FP_TEXT_T, PCB_FP_ZONE_T, PCB_SHAPE_T, PCB_TEXT_T, PCB_VIA_T, PCB_ZONE_T, SEG::Square(), COLLECTOR::Transfer(), EDA_ITEM::Type(), PCB_TOOL_BASE::view(), VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by PCB_CONTROL::DeleteItemCursor(), and selectPoint().

◆ highlight()

void PCB_SELECTION_TOOL::highlight ( BOARD_ITEM aItem,
int  aHighlightMode,
PCB_SELECTION aGroup = nullptr 
)
private

Highlight the item visually.

Parameters
aItemis an item to be be highlighted.
aHighlightModeshould be either SELECTED or BRIGHTENED
aGroupis the group to add the item to in the BRIGHTENED mode.

Definition at line 2162 of file pcb_selection_tool.cpp.

2163 {
2164  if( aGroup )
2165  aGroup->Add( aItem );
2166 
2167  highlightInternal( aItem, aMode, aGroup != nullptr );
2168  view()->Update( aItem, KIGFX::REPAINT );
2169 
2170  // Many selections are very temporal and updating the display each time just
2171  // creates noise.
2172  if( aMode == BRIGHTENED )
2174 }
virtual void Add(EDA_ITEM *aItem)
Definition: selection.cpp:31
void highlightInternal(BOARD_ITEM *aItem, int aHighlightMode, bool aUsingOverlay)
virtual void Update(const VIEW_ITEM *aItem, int aUpdateFlags) const override
For dynamic VIEWs, inform the associated VIEW that the graphical representation of this item has chan...
Definition: pcb_view.cpp:92
Item needs to be redrawn.
Definition: view_item.h:57
void MarkTargetDirty(int aTarget)
Set or clear target 'dirty' flag.
Definition: view.h:609
KIGFX::PCB_VIEW * view() const
Items that may change while the view stays the same (noncached)
Definition: definitions.h:50
KIGFX::VIEW * getView() const
Returns the instance of #VIEW object used in the application.
Definition: tool_base.cpp:36
#define BRIGHTENED
item is drawn with a bright contour

References SELECTION::Add(), BRIGHTENED, TOOL_BASE::getView(), highlightInternal(), KIGFX::VIEW::MarkTargetDirty(), KIGFX::REPAINT, KIGFX::TARGET_OVERLAY, KIGFX::PCB_VIEW::Update(), and PCB_TOOL_BASE::view().

Referenced by BrightenItem(), doSelectionMenu(), RebuildSelection(), RequestSelection(), and select().

◆ highlightInternal()

void PCB_SELECTION_TOOL::highlightInternal ( BOARD_ITEM aItem,
int  aHighlightMode,
bool  aUsingOverlay 
)
private

Definition at line 2177 of file pcb_selection_tool.cpp.

2178 {
2179  if( aMode == SELECTED )
2180  aItem->SetSelected();
2181  else if( aMode == BRIGHTENED )
2182  aItem->SetBrightened();
2183 
2184  if( aUsingOverlay )
2185  view()->Hide( aItem, true ); // Hide the original item, so it is shown only on overlay
2186 
2187  if( aItem->Type() == PCB_FOOTPRINT_T )
2188  {
2189  static_cast<FOOTPRINT*>( aItem )->RunOnChildren(
2190  [&]( BOARD_ITEM* aChild )
2191  {
2192  highlightInternal( aChild, aMode, aUsingOverlay );
2193  } );
2194  }
2195  else if( aItem->Type() == PCB_GROUP_T )
2196  {
2197  static_cast<PCB_GROUP*>( aItem )->RunOnChildren(
2198  [&]( BOARD_ITEM* aChild )
2199  {
2200  highlightInternal( aChild, aMode, aUsingOverlay );
2201  } );
2202  }
2203 }
void Hide(VIEW_ITEM *aItem, bool aHide=true)
Temporarily hide the item in the view (e.g.
Definition: view.cpp:1485
A base class for any item which can be embedded within the BOARD container class, and therefore insta...
Definition: board_item.h:80
class PCB_GROUP, a set of BOARD_ITEMs
Definition: typeinfo.h:108
void highlightInternal(BOARD_ITEM *aItem, int aHighlightMode, bool aUsingOverlay)
void SetBrightened()
Definition: eda_item.h:130
void SetSelected()
Definition: eda_item.h:129
KIGFX::PCB_VIEW * view() const
#define SELECTED
class FOOTPRINT, a footprint
Definition: typeinfo.h:88
KICAD_T Type() const
Returns the type of object.
Definition: eda_item.h:113
#define BRIGHTENED
item is drawn with a bright contour

References BRIGHTENED, KIGFX::VIEW::Hide(), PCB_FOOTPRINT_T, PCB_GROUP_T, SELECTED, EDA_ITEM::SetBrightened(), EDA_ITEM::SetSelected(), EDA_ITEM::Type(), and PCB_TOOL_BASE::view().

Referenced by highlight().

◆ hitTestDistance()

int PCB_SELECTION_TOOL::hitTestDistance ( const wxPoint &  aWhere,
BOARD_ITEM aItem,
int  aMaxDistance 
) const
private

Definition at line 2275 of file pcb_selection_tool.cpp.

2277 {
2278  BOX2D viewportD = getView()->GetViewport();
2279  BOX2I viewport( VECTOR2I( viewportD.GetPosition() ), VECTOR2I( viewportD.GetSize() ) );
2280  int distance = INT_MAX;
2281  SEG loc( aWhere, aWhere );
2282 
2283  switch( aItem->Type() )
2284  {
2285  case PCB_TEXT_T:
2286  {
2287  PCB_TEXT* text = static_cast<PCB_TEXT*>( aItem );
2288  text->GetEffectiveTextShape()->Collide( loc, aMaxDistance, &distance );
2289  break;
2290  }
2291 
2292  case PCB_FP_TEXT_T:
2293  {
2294  FP_TEXT* text = static_cast<FP_TEXT*>( aItem );
2295  text->GetEffectiveTextShape()->Collide( loc, aMaxDistance, &distance );
2296  break;
2297  }
2298 
2299  case PCB_ZONE_T:
2300  {
2301  ZONE* zone = static_cast<ZONE*>( aItem );
2302 
2303  // Zone borders are very specific
2304  if( zone->HitTestForEdge( aWhere, aMaxDistance / 2 ) )
2305  distance = 0;
2306  else if( zone->HitTestForEdge( aWhere, aMaxDistance ) )
2307  distance = aMaxDistance / 2;
2308  else
2309  aItem->GetEffectiveShape()->Collide( loc, aMaxDistance, &distance );
2310 
2311  break;
2312  }
2313 
2314  case PCB_FOOTPRINT_T:
2315  {
2316  FOOTPRINT* footprint = static_cast<FOOTPRINT*>( aItem );
2317  EDA_RECT bbox = footprint->GetBoundingBox( false, false );
2318 
2319  footprint->GetBoundingHull().Collide( loc, aMaxDistance, &distance );
2320 
2321  // Consider footprints larger than the viewport only as a last resort
2322  if( bbox.GetHeight() > viewport.GetHeight() || bbox.GetWidth() > viewport.GetWidth() )
2323  distance = INT_MAX / 2;
2324 
2325  break;
2326  }
2327 
2328  case PCB_MARKER_T:
2329  {
2330  PCB_MARKER* marker = static_cast<PCB_MARKER*>( aItem );
2331  SHAPE_LINE_CHAIN polygon;
2332 
2333  marker->ShapeToPolygon( polygon );
2334  polygon.Move( marker->GetPos() );
2335  polygon.Collide( loc, aMaxDistance, &distance );
2336  break;
2337  }
2338 
2339  case PCB_GROUP_T:
2340  {
2341  PCB_GROUP* group = static_cast<PCB_GROUP*>( aItem );
2342 
2343  for( BOARD_ITEM* member : group->GetItems() )
2344  distance = std::min( distance, hitTestDistance( aWhere, member, aMaxDistance ) );
2345 
2346  break;
2347  }
2348 
2349  default:
2350  aItem->GetEffectiveShape()->Collide( loc, aMaxDistance, &distance );
2351  break;
2352  }
2353 
2354  return distance;
2355 }
const wxPoint & GetPos() const
Definition: marker_base.h:84
BOX2D GetViewport() const
Return the current viewport visible area rectangle.
Definition: view.cpp:515
SHAPE_POLY_SET GetBoundingHull() const
Return a bounding polygon for the shapes and pads in the footprint.
Definition: footprint.cpp:787
class FP_TEXT, text in a footprint
Definition: typeinfo.h:92
A base class for any item which can be embedded within the BOARD container class, and therefore insta...
Definition: board_item.h:80
class PCB_GROUP, a set of BOARD_ITEMs
Definition: typeinfo.h:108
A set of BOARD_ITEMs (i.e., without duplicates).
Definition: pcb_group.h:50
void Move(const VECTOR2I &aVector) override
int GetWidth() const
Definition: eda_rect.h:109
class PCB_TEXT, text on a layer
Definition: typeinfo.h:91
VECTOR2< int > VECTOR2I
Definition: vector2d.h:623
virtual bool Collide(const VECTOR2I &aP, int aClearance=0, int *aActual=nullptr, VECTOR2I *aLocation=nullptr) const override
Check if point aP lies closer to us than aClearance.
FOOTPRINT * footprint() const
Handle a list of polygons defining a copper zone.
Definition: zone.h:56
class ZONE, a copper pour area
Definition: typeinfo.h:105
static float distance(const SFVEC2UI &a, const SFVEC2UI &b)
int GetHeight() const
Definition: eda_rect.h:110
KIGFX::VIEW * getView() const
Returns the instance of #VIEW object used in the application.
Definition: tool_base.cpp:36
class FOOTPRINT, a footprint
Definition: typeinfo.h:88
const Vec & GetPosition() const
Definition: box2.h:177
void ShapeToPolygon(SHAPE_LINE_CHAIN &aPolygon, int aScale=-1) const
Return the shape polygon in internal units in a SHAPE_LINE_CHAIN the coordinates are relatives to the...
Definition: seg.h:40
bool Collide(const SHAPE *aShape, int aClearance=0, int *aActual=nullptr, VECTOR2I *aLocation=nullptr) const override
Check if the boundary of shape (this) lies closer to the shape aShape than aClearance,...
class PCB_MARKER, a marker used to show something
Definition: typeinfo.h:98
bool HitTestForEdge(const wxPoint &refPos, int aAccuracy, SHAPE_POLY_SET::VERTEX_INDEX &aCornerHit) const
Test if the given wxPoint is near a segment defined by 2 corners.
Definition: zone.cpp:439
Represent a polyline (an zero-thickness chain of connected line segments).
int hitTestDistance(const wxPoint &aWhere, BOARD_ITEM *aItem, int aMaxDistance) const
const EDA_RECT GetBoundingBox() const override
Return the orthogonal bounding box of this object for display purposes.
Definition: footprint.cpp:676
Handle the component boundary box.
Definition: eda_rect.h:42
virtual std::shared_ptr< SHAPE > GetEffectiveShape(PCB_LAYER_ID aLayer=UNDEFINED_LAYER) const
Some pad shapes can be complex (rounded/chamfered rectangle), even without considering custom shapes.
Definition: board_item.cpp:181
const Vec & GetSize() const
Definition: box2.h:172
KICAD_T Type() const
Returns the type of object.
Definition: eda_item.h:113

References SHAPE_LINE_CHAIN_BASE::Collide(), SHAPE_POLY_SET::Collide(), distance(), PCB_TOOL_BASE::footprint(), FOOTPRINT::GetBoundingBox(), FOOTPRINT::GetBoundingHull(), BOARD_ITEM::GetEffectiveShape(), EDA_RECT::GetHeight(), BOX2< Vec >::GetHeight(), MARKER_BASE::GetPos(), BOX2< Vec >::GetPosition(), BOX2< Vec >::GetSize(), TOOL_BASE::getView(), KIGFX::VIEW::GetViewport(), EDA_RECT::GetWidth(), BOX2< Vec >::GetWidth(), group, ZONE::HitTestForEdge(), SHAPE_LINE_CHAIN::Move(), PCB_FOOTPRINT_T, PCB_FP_TEXT_T, PCB_GROUP_T, PCB_MARKER_T, PCB_TEXT_T, PCB_ZONE_T, MARKER_BASE::ShapeToPolygon(), text, and EDA_ITEM::Type().

Referenced by GuessSelectionCandidates().

◆ Init()

bool PCB_SELECTION_TOOL::Init ( void  )
overridevirtual

Init() is called once upon a registration of the tool.

Returns
True if the initialization went fine, false - otherwise.

Reimplemented from PCB_TOOL_BASE.

Definition at line 134 of file pcb_selection_tool.cpp.

135 {
136  auto frame = getEditFrame<PCB_BASE_FRAME>();
137 
140  {
142  return true;
143  }
144 
145  auto selectMenu = std::make_shared<SELECT_MENU>();
146  selectMenu->SetTool( this );
147  m_menu.AddSubMenu( selectMenu );
148 
149  auto& menu = m_menu.GetMenu();
150 
151  auto activeToolCondition =
152  [ frame ] ( const SELECTION& aSel )
153  {
154  return !frame->ToolStackIsEmpty();
155  };
156 
157  auto inGroupCondition =
158  [this] ( const SELECTION& )
159  {
160  return m_enteredGroup != nullptr;
161  };
162 
163  if( frame && frame->IsType( FRAME_PCB_EDITOR ) )
164  {
165  menu.AddMenu( selectMenu.get(), SELECTION_CONDITIONS::NotEmpty );
166  menu.AddSeparator( 1000 );
167  }
168 
169  // "Cancel" goes at the top of the context menu when a tool is active
170  menu.AddItem( ACTIONS::cancelInteractive, activeToolCondition, 1 );
171  menu.AddItem( PCB_ACTIONS::groupLeave, inGroupCondition, 1 );
172  menu.AddSeparator( 1 );
173 
174  if( frame )
176 
177  m_disambiguateTimer.SetOwner( this );
178  Connect( wxEVT_TIMER, wxTimerEventHandler( PCB_SELECTION_TOOL::onDisambiguationExpire ), nullptr, this );
179 
180  return true;
181 }
void AddStandardSubMenus(TOOL_MENU &aMenu)
Construct a "basic" menu for a tool, containing only items that apply to all tools (e....
bool AddItem(BOARD_ITEM *aItem)
Add item to group.
Definition: pcb_group.cpp:38
TOOL_MENU m_menu
The functions below are not yet implemented - their interface may change.
static TOOL_ACTION groupLeave
Definition: pcb_actions.h:430
CONDITIONAL_MENU & GetMenu()
Definition: tool_menu.cpp:46
static TOOL_ACTION cancelInteractive
Definition: actions.h:62
static bool NotEmpty(const SELECTION &aSelection)
Test if there are any items selected.
void onDisambiguationExpire(wxTimerEvent &aEvent)
Start the process to show our disambiguation menu once the user has kept the mouse down for the minim...
PCB_BASE_EDIT_FRAME * frame() const
bool ToolStackIsEmpty()
Definition: tools_holder.h:116
wxTimer m_disambiguateTimer
bool IsType(FRAME_T aType) const
void AddSubMenu(std::shared_ptr< ACTION_MENU > aSubMenu)
Store a submenu of this menu model.
Definition: tool_menu.cpp:52

References PCB_GROUP::AddItem(), EDA_DRAW_FRAME::AddStandardSubMenus(), TOOL_MENU::AddSubMenu(), ACTIONS::cancelInteractive, PCB_TOOL_BASE::frame(), FRAME_FOOTPRINT_VIEWER, FRAME_FOOTPRINT_VIEWER_MODAL, FRAME_PCB_EDITOR, TOOL_MENU::GetMenu(), PCB_ACTIONS::groupLeave, EDA_BASE_FRAME::IsType(), SELECTION_TOOL::m_disambiguateTimer, m_enteredGroup, TOOL_INTERACTIVE::m_menu, SELECTION_CONDITIONS::NotEmpty(), onDisambiguationExpire(), and TOOLS_HOLDER::ToolStackIsEmpty().

◆ Is45Limited()

bool PCB_TOOL_BASE::Is45Limited ( ) const
inherited

◆ IsFootprintEditor()

◆ IsToolActive()

bool TOOL_BASE::IsToolActive ( ) const
inherited

Definition at line 31 of file tool_base.cpp.

32 {
33  return m_toolMgr->IsToolActive( m_toolId );
34 }
TOOL_MANAGER * m_toolMgr
Definition: tool_base.h:214
TOOL_ID m_toolId
Name of the tool.
Definition: tool_base.h:209
bool IsToolActive(TOOL_ID aId) const
Return true if a tool with given id is active (executing)

References TOOL_MANAGER::IsToolActive(), TOOL_BASE::m_toolId, and TOOL_BASE::m_toolMgr.

Referenced by ROUTER_TOOL::handleLayerSwitch(), EDIT_TOOL::isRouterActive(), Main(), BOARD_EDITOR_CONTROL::TrackWidthDec(), and BOARD_EDITOR_CONTROL::TrackWidthInc().

◆ itemPassesFilter()

bool PCB_SELECTION_TOOL::itemPassesFilter ( BOARD_ITEM aItem)
private

Definition at line 1614 of file pcb_selection_tool.cpp.

1615 {
1616  if( aItem->IsLocked() && !m_filter.lockedItems && aItem->Type() != PCB_PAD_T )
1617  return false;
1618 
1619  switch( aItem->Type() )
1620  {
1621  case PCB_FOOTPRINT_T:
1622  if( !m_filter.footprints )
1623  return false;
1624 
1625  break;
1626 
1627  case PCB_PAD_T:
1628  if( !m_filter.pads )
1629  return false;
1630 
1631  break;
1632 
1633  case PCB_TRACE_T:
1634  case PCB_ARC_T:
1635  if( !m_filter.tracks )
1636  return false;
1637 
1638  break;
1639 
1640  case PCB_VIA_T:
1641  if( !m_filter.vias )
1642  return false;
1643 
1644  break;
1645 
1646  case PCB_FP_ZONE_T:
1647  case PCB_ZONE_T:
1648  {
1649  ZONE* zone = static_cast<ZONE*>( aItem );
1650 
1651  if( ( !m_filter.zones && !zone->GetIsRuleArea() )
1652  || ( !m_filter.keepouts && zone->GetIsRuleArea() ) )
1653  {
1654  return false;
1655  }
1656 
1657  break;
1658  }
1659 
1660  case PCB_FP_SHAPE_T:
1661  case PCB_SHAPE_T:
1662  case PCB_TARGET_T:
1663  if( !m_filter.graphics )
1664  return false;
1665 
1666  break;
1667 
1668  case PCB_FP_TEXT_T:
1669  case PCB_TEXT_T:
1670  if( !m_filter.text )
1671  return false;
1672 
1673  break;
1674 
1675  case PCB_DIM_ALIGNED_T:
1676  case PCB_DIM_CENTER_T:
1677  case PCB_DIM_ORTHOGONAL_T:
1678  case PCB_DIM_LEADER_T:
1679  if( !m_filter.dimensions )
1680  return false;
1681 
1682  break;
1683 
1684  default:
1685  if( !m_filter.otherItems )
1686  return false;
1687  }
1688 
1689  return true;
1690 }
class PCB_DIM_ALIGNED, a linear dimension (graphic item)
Definition: typeinfo.h:100
class PCB_DIM_LEADER, a leader dimension (graphic item)
Definition: typeinfo.h:101
bool otherItems
Anything not fitting one of the above categories.
class FP_TEXT, text in a footprint
Definition: typeinfo.h:92
bool GetIsRuleArea() const
Accessors to parameters used in Rule Area zones:
Definition: zone.h:733
class PCB_DIM_CENTER, a center point marking (graphic item)
Definition: typeinfo.h:102
class PCB_TEXT, text on a layer
Definition: typeinfo.h:91
class PCB_ARC, an arc track segment on a copper layer
Definition: typeinfo.h:97
class FP_SHAPE, a footprint edge
Definition: typeinfo.h:93
class PAD, a pad in a footprint
Definition: typeinfo.h:89
virtual bool IsLocked() const
Definition: board_item.cpp:78
class PCB_TRACK, a track segment (segment on a copper layer)
Definition: typeinfo.h:95
bool text
Text (free or attached to a footprint)
bool dimensions
Dimension items.
SELECTION_FILTER_OPTIONS m_filter
bool graphics
Graphic lines, shapes, polygons.
Handle a list of polygons defining a copper zone.
Definition: zone.h:56
class ZONE, a copper pour area
Definition: typeinfo.h:105
bool footprints
Allow selecting entire footprints.
class PCB_TARGET, a target (graphic item)
Definition: typeinfo.h:104
class FOOTPRINT, a footprint
Definition: typeinfo.h:88
bool lockedItems
Allow selecting locked items.
class ZONE, managed by a footprint
Definition: typeinfo.h:94
class PCB_DIM_ORTHOGONAL, a linear dimension constrained to x/y
Definition: typeinfo.h:103
class PCB_VIA, a via (like a track segment on a copper layer)
Definition: typeinfo.h:96
class PCB_SHAPE, a segment not on copper layers
Definition: typeinfo.h:90
KICAD_T Type() const
Returns the type of object.
Definition: eda_item.h:113

References SELECTION_FILTER_OPTIONS::dimensions, SELECTION_FILTER_OPTIONS::footprints, ZONE::GetIsRuleArea(), SELECTION_FILTER_OPTIONS::graphics, BOARD_ITEM::IsLocked(), SELECTION_FILTER_OPTIONS::keepouts, SELECTION_FILTER_OPTIONS::lockedItems, m_filter, SELECTION_FILTER_OPTIONS::otherItems, SELECTION_FILTER_OPTIONS::pads, PCB_ARC_T, PCB_DIM_ALIGNED_T, PCB_DIM_CENTER_T, PCB_DIM_LEADER_T, PCB_DIM_ORTHOGONAL_T, PCB_FOOTPRINT_T, PCB_FP_SHAPE_T, PCB_FP_TEXT_T, PCB_FP_ZONE_T, PCB_PAD_T, PCB_SHAPE_T, PCB_TARGET_T, PCB_TEXT_T, PCB_TRACE_T, PCB_VIA_T, PCB_ZONE_T, SELECTION_FILTER_OPTIONS::text, SELECTION_FILTER_OPTIONS::tracks, EDA_ITEM::Type(), SELECTION_FILTER_OPTIONS::vias, and SELECTION_FILTER_OPTIONS::zones.

Referenced by FilterCollectedItems(), SelectAll(), and selectAllItemsOnNet().

◆ Main()

int PCB_SELECTION_TOOL::Main ( const TOOL_EVENT aEvent)

The main loop.

Definition at line 243 of file pcb_selection_tool.cpp.

244 {
245  // Main loop: keep receiving events
246  while( TOOL_EVENT* evt = Wait() )
247  {
248  MOUSE_DRAG_ACTION dragAction = m_frame->GetDragAction();
250 
251  // on left click, a selection is made, depending on modifiers ALT, SHIFT, CTRL:
252  setModifiersState( evt->Modifier( MD_SHIFT ), evt->Modifier( MD_CTRL ),
253  evt->Modifier( MD_ALT ) );
254 
255  bool modifier_enabled = m_subtractive || m_additive || m_exclusive_or;
256  PCB_BASE_FRAME* frame = getEditFrame<PCB_BASE_FRAME>();
257  bool brd_editor = frame && frame->IsType( FRAME_PCB_EDITOR );
259 
260  // If the router tool is active, don't override
261  if( router && router->IsToolActive() )
262  {
263  evt->SetPassEvent();
264  }
265  else if( evt->IsMouseDown( BUT_LEFT ) )
266  {
267  // Avoid triggering when running under other tools
268  if( m_frame->ToolStackIsEmpty() )
269  {
271  m_disambiguateTimer.StartOnce( 500 );
272  }
273  }
274  else if( evt->IsClick( BUT_LEFT ) )
275  {
276  // If there is no disambiguation, this routine is still running and will
277  // register a `click` event when released
278  if( m_disambiguateTimer.IsRunning() )
279  {
280  m_disambiguateTimer.Stop();
281 
282  // Single click? Select single object
283  if( m_highlight_modifier && brd_editor )
285  else
286  {
287  m_frame->FocusOnItem( nullptr );
288  selectPoint( evt->Position() );
289  }
290  }
291 
292  m_canceledMenu = false;
293  }
294  else if( evt->IsClick( BUT_RIGHT ) )
295  {
296  m_disambiguateTimer.Stop();
297 
298  // Right click? if there is any object - show the context menu
299  bool selectionCancelled = false;
300 
301  if( m_selection.Empty() )
302  {
303  selectPoint( evt->Position(), false, &selectionCancelled );
304  m_selection.SetIsHover( true );
305  }
306 
307  if( !selectionCancelled )
309  }
310  else if( evt->IsDblClick( BUT_LEFT ) )
311  {
312  m_disambiguateTimer.Stop();
313 
314  // Double click? Display the properties window
315  m_frame->FocusOnItem( nullptr );
316 
317  if( m_selection.Empty() )
318  selectPoint( evt->Position() );
319 
320  if( m_selection.GetSize() == 1 && m_selection[0]->Type() == PCB_GROUP_T )
321  {
322  EnterGroup();
323  }
324  else
325  {
327  }
328  }
329  else if( evt->IsDblClick( BUT_MIDDLE ) )
330  {
331  // Middle double click? Do zoom to fit or zoom to objects
332  if( evt->Modifier( MD_CTRL ) ) // Is CTRL key down?
334  else
336  }
337  else if( evt->IsDrag( BUT_LEFT ) )
338  {
339  m_disambiguateTimer.Stop();
340 
341  // Is another tool already moving a new object? Don't allow a drag start
342  if( !m_selection.Empty() && m_selection[0]->HasFlag( IS_NEW | IS_MOVING ) )
343  {
344  evt->SetPassEvent();
345  continue;
346  }
347 
348  // Drag with LMB? Select multiple objects (or at least draw a selection box)
349  // or drag them
350  m_frame->FocusOnItem( nullptr );
352 
353  if( modifier_enabled || dragAction == MOUSE_DRAG_ACTION::SELECT )
354  {
355  selectMultiple();
356  }
357  else if( m_selection.Empty() && dragAction != MOUSE_DRAG_ACTION::DRAG_ANY )
358  {
359  selectMultiple();
360  }
361  else
362  {
363  // Don't allow starting a drag from a zone filled area that isn't already selected
364  auto zoneFilledAreaFilter =
365  []( const VECTOR2I& aWhere, GENERAL_COLLECTOR& aCollector,
366  PCB_SELECTION_TOOL* aTool )
367  {
368  wxPoint location = wxPoint( aWhere );
369  int accuracy = KiROUND( 5 * aCollector.GetGuide()->OnePixelInIU() );
370  std::set<EDA_ITEM*> remove;
371 
372  for( EDA_ITEM* item : aCollector )
373  {
374  if( item->Type() == PCB_ZONE_T || item->Type() == PCB_FP_ZONE_T )
375  {
376  ZONE* zone = static_cast<ZONE*>( item );
377 
378  if( !zone->HitTestForCorner( location, accuracy * 2 ) &&
379  !zone->HitTestForEdge( location, accuracy ) )
380  remove.insert( zone );
381  }
382  }
383 
384  for( EDA_ITEM* item : remove )
385  aCollector.Remove( item );
386  };
387 
388  // Selection is empty? try to start dragging the item under the point where drag
389  // started
390  if( m_selection.Empty() && selectCursor( false, zoneFilledAreaFilter ) )
391  m_selection.SetIsHover( true );
392 
393  // Check if dragging has started within any of selected items bounding box.
394  // We verify "HasPosition()" first to protect against edge case involving
395  // moving off menus that causes problems (issue #5250)
396  if( evt->HasPosition() && selectionContains( evt->Position() ) )
397  {
398  // Yes -> run the move tool and wait till it finishes
399  PCB_TRACK* track = dynamic_cast<PCB_TRACK*>( m_selection.GetItem( 0 ) );
400 
401  // If there is only item in the selection and it's a track, then we need
402  // to route it.
403  bool doRouting = ( track && ( 1 == m_selection.GetSize() ) );
404 
405  if( doRouting && trackDragAction == TRACK_DRAG_ACTION::DRAG )
407  else if( doRouting && trackDragAction == TRACK_DRAG_ACTION::DRAG_FREE_ANGLE )
409  else
411  }
412  else
413  {
414  // No -> drag a selection box
415  selectMultiple();
416  }
417  }
418  }
419  else if( evt->IsCancel() )
420  {
421  m_disambiguateTimer.Stop();
422  m_frame->FocusOnItem( nullptr );
423 
424  if( m_enteredGroup )
425  ExitGroup();
426 
427  ClearSelection();
428  }
429  else
430  {
431  evt->SetPassEvent();
432  }
433 
434 
435  if( m_frame->ToolStackIsEmpty() )
436  {
437  // move cursor prediction
438  if( !modifier_enabled
439  && dragAction == MOUSE_DRAG_ACTION::DRAG_SELECTED
440  && !m_selection.Empty()
441  && evt->HasPosition()
442  && selectionContains( evt->Position() ) )
443  {
445  }
446  else
447  {
449  }
450  }
451  }
452 
453  // Shutting down; clear the selection
454  m_selection.Clear();
455  m_disambiguateTimer.Stop();
456 
457  return 0;
458 }
TOOL_MENU m_menu
The functions below are not yet implemented - their interface may change.
static TOOL_ACTION move
move or drag an item
Definition: pcb_actions.h:92
virtual void Clear() override
Remove all the stored items from the group.
Definition: selection.h:82
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.
#define IS_NEW
New item, just created.
class PCB_GROUP, a set of BOARD_ITEMs
Definition: typeinfo.h:108
VECTOR2D GetMousePosition() const
static TOOL_ACTION dragFreeAngle
Definition: pcb_actions.h:138
TOOL_MANAGER * m_toolMgr
Definition: tool_base.h:214
static TOOL_ACTION properties
Activation of the edit tool.
Definition: pcb_actions.h:117
bool m_highlight_modifier
static TOOL_ACTION zoomFitScreen
Definition: actions.h:96
bool RunAction(const std::string &aActionName, bool aNow=false, T aParam=NULL)
Run the specified action.
Definition: tool_manager.h:143
static TOOL_ACTION drag45Degree
Definition: pcb_actions.h:137
static TOOL_ACTION zoomFitObjects
Definition: actions.h:97
TRACK_DRAG_ACTION
bool HitTestForCorner(const wxPoint &refPos, int aAccuracy, SHAPE_POLY_SET::VERTEX_INDEX &aCornerHit) const
Test if the given wxPoint is near a corner.
Definition: zone.cpp:425
void SetIsHover(bool aIsHover)
Definition: selection.h:68
void setModifiersState(bool aShiftState, bool aCtrlState, bool aAltState)
Set the configuration of m_additive, m_subtractive, m_exclusive_or, m_skip_heuristics from the state ...
PCB_BASE_FRAME * m_frame
PCB_BASE_EDIT_FRAME * frame() const
MOUSE_DRAG_ACTION
MOUSE_DRAG_ACTION GetDragAction() const
Indicates whether a drag should draw a selection rectangle or drag selected (or unselected) objects.
Definition: tools_holder.h:135
bool selectMultiple()
Handle drawing a selection box that allows one to select many items at the same time.
#define IS_MOVING
Item being moved.
TRACK_DRAG_ACTION m_TrackDragAction
bool ProcessEvent(const TOOL_EVENT &aEvent)
Propagate an event to tools that requested events of matching type(s).
bool selectPoint(const VECTOR2I &aWhere, bool aOnDrag=false, bool *aSelectionCancelledFlag=nullptr, CLIENT_SELECTION_FILTER aClientFilter=nullptr)
Select an item pointed by the parameter aWhere.
Generic, UI-independent tool event.
Definition: tool_event.h:152
bool ToolStackIsEmpty()
Definition: tools_holder.h:116
Handle a list of polygons defining a copper zone.
Definition: zone.h:56
class ZONE, a copper pour area
Definition: typeinfo.h:105
PCB_SELECTION m_selection
wxTimer m_disambiguateTimer
void ExitGroup(bool aSelectGroup=false)
Leave the currently entered group.
bool Empty() const
Checks if there is anything selected.
Definition: selection.h:97
virtual unsigned int GetSize() const override
Return the number of stored items.
Definition: selection.h:87
bool selectCursor(bool aForceSelect=false, CLIENT_SELECTION_FILTER aClientFilter=nullptr)
Select an item under the cursor unless there is something already selected or aSelectAlways is true.
bool HitTestForEdge(const wxPoint &refPos, int aAccuracy, SHAPE_POLY_SET::VERTEX_INDEX &aCornerHit) const
Test if the given wxPoint is near a segment defined by 2 corners.
Definition: zone.cpp:439
static TOOL_ACTION highlightNet
Definition: pcb_actions.h:449
bool IsType(FRAME_T aType) const
virtual KIGFX::VIEW_ITEM * GetItem(unsigned int aIdx) const override
Definition: selection.cpp:52
Used when the right click button is pressed, or when the select tool is in effect.
Definition: collectors.h:240
bool IsToolActive() const
Definition: tool_base.cpp:31
class ZONE, managed by a footprint
Definition: typeinfo.h:94
PCBNEW_SETTINGS & Settings()
The selection tool: currently supports:
constexpr ret_type KiROUND(fp_type v)
Round a floating point number to an integer using "round halfway cases away from zero".
Definition: util.h:73
A base class for most all the KiCad significant classes used in schematics and boards.
Definition: eda_item.h:100
static const TOOL_EVENT InhibitSelectionEditing
Definition: actions.h:210
VECTOR2I m_originalCursor
bool selectionContains(const VECTOR2I &aPoint) const
int ClearSelection(const TOOL_EVENT &aEvent)
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
void FocusOnItem(BOARD_ITEM *aItem)
Base PCB main window class for Pcbnew, Gerbview, and CvPcb footprint viewer.

References ARROW, BUT_LEFT, BUT_MIDDLE, BUT_RIGHT, SELECTION::Clear(), ClearSelection(), DRAG, PCB_ACTIONS::drag45Degree, DRAG_ANY, DRAG_FREE_ANGLE, DRAG_SELECTED, PCB_ACTIONS::dragFreeAngle, SELECTION::Empty(), EnterGroup(), ExitGroup(), PCB_BASE_FRAME::FocusOnItem(), PCB_TOOL_BASE::frame(), FRAME_PCB_EDITOR, TOOLS_HOLDER::GetDragAction(), SELECTION::GetItem(), TOOL_MANAGER::GetMousePosition(), SELECTION::GetSize(), TOOL_MANAGER::GetTool(), PCB_ACTIONS::highlightNet, ZONE::HitTestForCorner(), ZONE::HitTestForEdge(), EVENTS::InhibitSelectionEditing, IS_MOVING, IS_NEW, TOOL_BASE::IsToolActive(), EDA_BASE_FRAME::IsType(), KiROUND(), SELECTION_TOOL::m_additive, SELECTION_TOOL::m_canceledMenu, SELECTION_TOOL::m_disambiguateTimer, m_enteredGroup, SELECTION_TOOL::m_exclusive_or, m_frame, SELECTION_TOOL::m_highlight_modifier, TOOL_INTERACTIVE::m_menu, m_nonModifiedCursor, SELECTION_TOOL::m_originalCursor, m_selection, SELECTION_TOOL::m_subtractive, TOOL_BASE::m_toolMgr, PCBNEW_SETTINGS::m_TrackDragAction, MD_ALT, MD_CTRL, MD_SHIFT, PCB_ACTIONS::move, MOVING, PCB_FP_ZONE_T, PCB_GROUP_T, PCB_ZONE_T, TOOL_MANAGER::ProcessEvent(), PCB_ACTIONS::properties, TOOL_MANAGER::RunAction(), SELECT, selectCursor(), selectionContains(), selectMultiple(), selectPoint(), SELECTION::SetIsHover(), SELECTION_TOOL::setModifiersState(), PCB_BASE_FRAME::Settings(), TOOL_MENU::ShowContextMenu(), TOOLS_HOLDER::ToolStackIsEmpty(), TOOL_INTERACTIVE::Wait(), ACTIONS::zoomFitObjects, and ACTIONS::zoomFitScreen.

Referenced by setTransitions().

◆ onDisambiguationExpire()

void PCB_SELECTION_TOOL::onDisambiguationExpire ( wxTimerEvent &  aEvent)
private

Start the process to show our disambiguation menu once the user has kept the mouse down for the minimum time.

Parameters
aEvent

Definition at line 216 of file pcb_selection_tool.cpp.

217 {
219 }
static const TOOL_EVENT DisambiguatePoint
Definition: actions.h:214
TOOL_MANAGER * m_toolMgr
Definition: tool_base.h:214
bool ProcessEvent(const TOOL_EVENT &aEvent)
Propagate an event to tools that requested events of matching type(s).

References EVENTS::DisambiguatePoint, TOOL_BASE::m_toolMgr, and TOOL_MANAGER::ProcessEvent().

Referenced by Init(), and ~PCB_SELECTION_TOOL().

◆ OnIdle()

void PCB_SELECTION_TOOL::OnIdle ( wxIdleEvent &  aEvent)

Definition at line 222 of file pcb_selection_tool.cpp.

223 {
224  if( m_frame->ToolStackIsEmpty() && !m_multiple )
225  {
226  wxMouseState keyboardState = wxGetMouseState();
227 
228  setModifiersState( keyboardState.ShiftDown(), keyboardState.ControlDown(),
229  keyboardState.AltDown() );
230 
231  if( m_additive )
233  else if( m_subtractive )
235  else if( m_exclusive_or )
237  else
239  }
240 }
void SetCurrentCursor(KICURSOR aCursor)
Set the current cursor shape for this panel.
PCB_DRAW_PANEL_GAL * GetCanvas() const override
Return a pointer to GAL-based canvas of given EDA draw frame.
void setModifiersState(bool aShiftState, bool aCtrlState, bool aAltState)
Set the configuration of m_additive, m_subtractive, m_exclusive_or, m_skip_heuristics from the state ...
PCB_BASE_FRAME * m_frame
bool ToolStackIsEmpty()
Definition: tools_holder.h:116

References ADD, PCB_BASE_FRAME::GetCanvas(), SELECTION_TOOL::m_additive, SELECTION_TOOL::m_exclusive_or, m_frame, SELECTION_TOOL::m_multiple, m_nonModifiedCursor, SELECTION_TOOL::m_subtractive, EDA_DRAW_PANEL_GAL::SetCurrentCursor(), SELECTION_TOOL::setModifiersState(), SUBTRACT, TOOLS_HOLDER::ToolStackIsEmpty(), and XOR.

Referenced by PCB_BASE_EDIT_FRAME::PCB_BASE_EDIT_FRAME().

◆ RebuildSelection()

void PCB_SELECTION_TOOL::RebuildSelection ( )

Rebuild the selection from the EDA_ITEMs' selection flags.

Commonly called after rolling back an undo state to make sure there aren't any stale pointers.

Definition at line 1715 of file pcb_selection_tool.cpp.

1716 {
1717  m_selection.Clear();
1718 
1719  bool enteredGroupFound = false;
1720 
1721  INSPECTOR_FUNC inspector =
1722  [&]( EDA_ITEM* item, void* testData )
1723  {
1724  if( item->IsSelected() )
1725  {
1726  EDA_ITEM* parent = item->GetParent();
1727 
1728  // Let selected parents handle their children.
1729  if( parent && parent->IsSelected() )
1730  return SEARCH_RESULT::CONTINUE;
1731 
1732  highlight( (BOARD_ITEM*) item, SELECTED, &m_selection );
1733  }
1734 
1735  if( item == m_enteredGroup )
1736  {
1737  item->SetFlags( ENTERED );
1738  enteredGroupFound = true;
1739  }
1740  else
1741  {
1742  item->ClearFlags( ENTERED );
1743  }
1744 
1745  return SEARCH_RESULT::CONTINUE;
1746  };
1747 
1750 
1751  if( !enteredGroupFound )
1752  {
1754  m_enteredGroup = nullptr;
1755  }
1756 }
static const KICAD_T FootprintItems[]
A scan list for primary footprint items.
Definition: collectors.h:293
virtual void Clear() override
Remove all the stored items from the group.
Definition: selection.h:82
static const KICAD_T AllBoardItems[]
A scan list for all editable board items.
Definition: collectors.h:267
BOARD * board() const
bool IsSelected() const
Definition: eda_item.h:123
A base class for any item which can be embedded within the BOARD container class, and therefore insta...
Definition: board_item.h:80
void SetFlags(EDA_ITEM_FLAGS aMask)
Definition: eda_item.h:153
void highlight(BOARD_ITEM *aItem, int aHighlightMode, PCB_SELECTION *aGroup=nullptr)
Highlight the item visually.
virtual void Clear()
Remove all the stored items from the group.
Definition: view_group.cpp:75
SEARCH_RESULT Visit(INSPECTOR inspector, void *testData, const KICAD_T scanTypes[]) override
May be re-implemented for each derived class in order to handle all the types given by its member dat...
Definition: board.cpp:1200
std::function< SEARCH_RESULT(EDA_ITEM *aItem, void *aTestData) > INSPECTOR_FUNC
Used to inspect and possibly collect the (search) results of iterating over a list or tree of KICAD_T...
Definition: eda_item.h:69
KIGFX::VIEW_GROUP m_enteredGroupOverlay
EDA_ITEM * GetParent() const
Definition: eda_item.h:115
void ClearFlags(EDA_ITEM_FLAGS aMask=EDA_ITEM_ALL_FLAGS)
Definition: eda_item.h:154
#define SELECTED
PCB_SELECTION m_selection
bool m_isFootprintEditor
#define ENTERED
indicates a group has been entered
A base class for most all the KiCad significant classes used in schematics and boards.
Definition: eda_item.h:100

References GENERAL_COLLECTOR::AllBoardItems, PCB_TOOL_BASE::board(), KIGFX::VIEW_GROUP::Clear(), SELECTION::Clear(), EDA_ITEM::ClearFlags(), CONTINUE, ENTERED, GENERAL_COLLECTOR::FootprintItems, EDA_ITEM::GetParent(), highlight(), EDA_ITEM::IsSelected(), m_enteredGroup, m_enteredGroupOverlay, PCB_TOOL_BASE::m_isFootprintEditor, m_selection, SELECTED, EDA_ITEM::SetFlags(), and BOARD::Visit().

Referenced by PCB_BASE_EDIT_FRAME::PutDataInPreviousState(), and BOARD_COMMIT::Revert().

◆ RemoveItemFromSel()

void PCB_SELECTION_TOOL::RemoveItemFromSel ( BOARD_ITEM aItem,
bool  aQuietMode = false 
)

Multiple item unselection event handler.

Definition at line 1035 of file pcb_selection_tool.cpp.

1036 {
1037  if( aItem )
1038  {
1039  unselect( aItem );
1040 
1041  if( !aQuietMode )
1042  {
1043  // Inform other potentially interested tools
1045  }
1046  }
1047 }
static const TOOL_EVENT UnselectedEvent
Definition: actions.h:200
TOOL_MANAGER * m_toolMgr
Definition: tool_base.h:214
bool ProcessEvent(const TOOL_EVENT &aEvent)
Propagate an event to tools that requested events of matching type(s).
void unselect(BOARD_ITEM *aItem)
Take necessary action mark an item as unselected.

References TOOL_BASE::m_toolMgr, TOOL_MANAGER::ProcessEvent(), unselect(), and EVENTS::UnselectedEvent.

Referenced by BOARD_COMMIT::Push(), EDIT_TOOL::Remove(), DIALOG_FOOTPRINT_PROPERTIES_FP_EDITOR::TransferDataFromWindow(), and UnselectItem().

◆ RequestSelection()

PCB_SELECTION & PCB_SELECTION_TOOL::RequestSelection ( CLIENT_SELECTION_FILTER  aClientFilter,
bool  aConfirmLockedItems = false 
)

Return the current selection set, filtered according to aFlags and aClientFilter.

If the set is empty, performs the legacy-style hover selection.

Parameters
aConfirmLockedItemsif true the user will be prompted if they want to drop locked items from the selection or override the locks.Select a single item under cursor event handler.

Definition at line 505 of file pcb_selection_tool.cpp.

507 {
508  bool selectionEmpty = m_selection.Empty();
509  m_selection.SetIsHover( selectionEmpty );
510 
511  if( selectionEmpty )
512  {
513  m_toolMgr->RunAction( PCB_ACTIONS::selectionCursor, true, aClientFilter );
515  }
516 
517  if( aClientFilter )
518  {
519  enum DISPOSITION { BEFORE = 1, AFTER, BOTH };
520 
521  std::map<EDA_ITEM*, DISPOSITION> itemDispositions;
522  GENERAL_COLLECTOR collector;
523 
524  for( EDA_ITEM* item : m_selection )
525  {
526  collector.Append( item );
527  itemDispositions[ item ] = BEFORE;
528  }
529 
530  aClientFilter( VECTOR2I(), collector, this );
531 
532  for( EDA_ITEM* item : collector )
533  {
534  if( itemDispositions.count( item ) )
535  itemDispositions[ item ] = BOTH;
536  else
537  itemDispositions[ item ] = AFTER;
538  }
539 
540  // Unhighlight the BEFORE items before highlighting the AFTER items.
541  // This is so that in the case of groups, if aClientFilter replaces a selection
542  // with the enclosing group, the unhighlight of the element doesn't undo the
543  // recursive highlighting of that element by the group.
544 
545  for( std::pair<EDA_ITEM* const, DISPOSITION> itemDisposition : itemDispositions )
546  {
547  BOARD_ITEM* item = static_cast<BOARD_ITEM*>( itemDisposition.first );
548  DISPOSITION disposition = itemDisposition.second;
549 
550  if( disposition == BEFORE )
551  {
552  unhighlight( item, SELECTED, &m_selection );
553  }
554  }
555 
556  for( std::pair<EDA_ITEM* const, DISPOSITION> itemDisposition : itemDispositions )
557  {
558  BOARD_ITEM* item = static_cast<BOARD_ITEM*>( itemDisposition.first );
559  DISPOSITION disposition = itemDisposition.second;
560 
561  if( disposition == AFTER )
562  {
563  highlight( item, SELECTED, &m_selection );
564  }
565  else if( disposition == BOTH )
566  {
567  // nothing to do
568  }
569  }
570 
572  }
573 
574  if( aConfirmLockedItems )
575  {
576  std::vector<BOARD_ITEM*> lockedItems;
577 
578  for( EDA_ITEM* item : m_selection )
579  {
580  BOARD_ITEM* boardItem = static_cast<BOARD_ITEM*>( item );
581 
582  if( boardItem->Type() == PCB_GROUP_T )
583  {
584  PCB_GROUP* group = static_cast<PCB_GROUP*>( boardItem );
585  bool lockedDescendant = false;
586 
587  group->RunOnDescendants(
588  [&lockedDescendant]( BOARD_ITEM* child )
589  {
590  if( child->IsLocked() )
591  lockedDescendant = true;
592  } );
593 
594  if( lockedDescendant )
595  lockedItems.push_back( group );
596  }
597  else if( boardItem->IsLocked() )
598  {
599  lockedItems.push_back( boardItem );
600  }
601  }
602 
603  if( !lockedItems.empty() )
604  {
605  DIALOG_LOCKED_ITEMS_QUERY dlg( frame(), lockedItems.size() );
606 
607  switch( dlg.ShowModal() )
608  {
609  case wxID_OK:
610  // remove locked items from selection
611  for( BOARD_ITEM* item : lockedItems )
612  unselect( item );
613 
614  break;
615 
616  case wxID_CANCEL:
617  // cancel operation
618  ClearSelection();
619  break;
620 
621  case wxID_APPLY:
622  // continue with operation with current selection
623  break;
624  }
625  }
626  }
627 
628  return m_selection;
629 }
void ClearReferencePoint()
Definition: selection.h:191
void ForceRefresh()
Force a redraw.
A base class for any item which can be embedded within the BOARD container class, and therefore insta...
Definition: board_item.h:80
class PCB_GROUP, a set of BOARD_ITEMs
Definition: typeinfo.h:108
A set of BOARD_ITEMs (i.e., without duplicates).
Definition: pcb_group.h:50
PCB_DRAW_PANEL_GAL * GetCanvas() const override
Return a pointer to GAL-based canvas of given EDA draw frame.
TOOL_MANAGER * m_toolMgr
Definition: tool_base.h:214
bool RunAction(const std::string &aActionName, bool aNow=false, T aParam=NULL)
Run the specified action.
Definition: tool_manager.h:143
void highlight(BOARD_ITEM *aItem, int aHighlightMode, PCB_SELECTION *aGroup=nullptr)
Highlight the item visually.
VECTOR2< int > VECTOR2I
Definition: vector2d.h:623
virtual bool IsLocked() const
Definition: board_item.cpp:78
void SetIsHover(bool aIsHover)
Definition: selection.h:68
PCB_BASE_FRAME * m_frame
void Append(EDA_ITEM *item)
Add an item to the end of the list.
Definition: collector.h:105
PCB_BASE_EDIT_FRAME * frame() const
#define SELECTED
PCB_SELECTION m_selection
void unselect(BOARD_ITEM *aItem)
Take necessary action mark an item as unselected.
bool Empty() const
Checks if there is anything selected.
Definition: selection.h:97
Used when the right click button is pressed, or when the select tool is in effect.
Definition: collectors.h:240
A base class for most all the KiCad significant classes used in schematics and boards.
Definition: eda_item.h:100
int ClearSelection(const TOOL_EVENT &aEvent)
void unhighlight(BOARD_ITEM *aItem, int aHighlightMode, PCB_SELECTION *aGroup=nullptr)
Unhighlight the item visually.
static TOOL_ACTION selectionCursor
Select a single item under the cursor position.
Definition: pcb_actions.h:56
KICAD_T Type() const
Returns the type of object.
Definition: eda_item.h:113

References COLLECTOR::Append(), SELECTION::ClearReferencePoint(), ClearSelection(), SELECTION::Empty(), EDA_DRAW_PANEL_GAL::ForceRefresh(), PCB_TOOL_BASE::frame(), PCB_BASE_FRAME::GetCanvas(), group, highlight(), BOARD_ITEM::IsLocked(), m_frame, m_selection, TOOL_BASE::m_toolMgr, PCB_GROUP_T, TOOL_MANAGER::RunAction(), SELECTED, PCB_ACTIONS::selectionCursor, SELECTION::SetIsHover(), EDA_ITEM::Type(), unhighlight(), and unselect().

Referenced by EDIT_TOOL::ChangeTrackWidth(), EDIT_TOOL::copyToClipboard(), EDIT_TOOL::CreateArray(), CONVERT_TOOL::CreateLines(), CONVERT_TOOL::CreatePolys(), ALIGN_DISTRIBUTE_TOOL::DistributeHorizontally(), ALIGN_DISTRIBUTE_TOOL::DistributeVertically(), EDIT_TOOL::doMoveSelection(), EDIT_TOOL::Drag(), EDIT_TOOL::Duplicate(), BOARD_EDITOR_CONTROL::EditFpInFpEditor(), GLOBAL_EDIT_TOOL::ExchangeFootprints(), EDIT_TOOL::FilletTracks(), EDIT_TOOL::Flip(), ALIGN_DISTRIBUTE_TOOL::GetSelections(), GROUP_TOOL::Group(), EDIT_TOOL::Mirror(), EDIT_TOOL::MoveExact(), GROUP_TOOL::PickNewMember(), POSITION_RELATIVE_TOOL::PositionRelative(), EDIT_TOOL::Properties(), EDIT_TOOL::Remove(), GLOBAL_EDIT_TOOL::RemoveUnusedPads(), EDIT_TOOL::Rotate(), CONVERT_TOOL::SegmentToArc(), and POSITION_RELATIVE_TOOL::SelectPositionRelativeItem().

◆ Reset()

void PCB_SELECTION_TOOL::Reset ( RESET_REASON  aReason)
overridevirtual

Bring the tool to a known, initial state.

If the tool claimed anything from the model or the view, it must release it when its reset.

Parameters
aReasoncontains information about the reason of tool reset.

Reimplemented from PCB_TOOL_BASE.

Definition at line 184 of file pcb_selection_tool.cpp.

185 {
186  m_frame = getEditFrame<PCB_BASE_FRAME>();
187 
188  if( m_enteredGroup )
189  ExitGroup();
190 
191  if( aReason == TOOL_BASE::MODEL_RELOAD )
192  {
193  // Deselect any item being currently in edit, to avoid unexpected behavior
194  // and remove pointers to the selected items from containers
195  // without changing their properties (as they are already deleted
196  // while a new board is loaded)
197  ClearSelection( true );
198 
199  getView()->GetPainter()->GetSettings()->SetHighlight( false );
200  }
201  else
202  {
203  // Restore previous properties of selected items and remove them from containers
204  ClearSelection( true );
205  }
206 
207  // Reinsert the VIEW_GROUP, in case it was removed from the VIEW
208  view()->Remove( &m_selection );
209  view()->Add( &m_selection );
210 
213 }
Model changes (required full reload)
Definition: tool_base.h:80
virtual void Remove(VIEW_ITEM *aItem) override
Remove a VIEW_ITEM from the view.
Definition: pcb_view.cpp:75
PAINTER * GetPainter() const
Return the painter object used by the view for drawing #VIEW_ITEMS.
Definition: view.h:208
PCB_BASE_FRAME * m_frame
KIGFX::VIEW_GROUP m_enteredGroupOverlay
KIGFX::PCB_VIEW * view() const
PCB_SELECTION m_selection
void ExitGroup(bool aSelectGroup=false)
Leave the currently entered group.
KIGFX::VIEW * getView() const
Returns the instance of #VIEW object used in the application.
Definition: tool_base.cpp:36
virtual RENDER_SETTINGS * GetSettings()=0
Return a pointer to current settings that are going to be used when drawing items.
void SetHighlight(bool aEnabled, int aNetcode=-1, bool aMulti=false)
Turns on/off highlighting.
virtual void Add(VIEW_ITEM *aItem, int aDrawPriority=-1) override
Add a VIEW_ITEM to the view.
Definition: pcb_view.cpp:58
int ClearSelection(const TOOL_EVENT &aEvent)

References KIGFX::PCB_VIEW::Add(), ClearSelection(), ExitGroup(), KIGFX::VIEW::GetPainter(), KIGFX::PAINTER::GetSettings(), TOOL_BASE::getView(), m_enteredGroup, m_enteredGroupOverlay, m_frame, m_selection, TOOL_BASE::MODEL_RELOAD, KIGFX::PCB_VIEW::Remove(), KIGFX::RENDER_SETTINGS::SetHighlight(), and PCB_TOOL_BASE::view().

◆ RunMainStack()

void TOOL_INTERACTIVE::RunMainStack ( std::function< void()>  aFunc)
inherited

Call a function using the main stack.

Parameters
aFuncis the function to be calls.

Definition at line 87 of file tool_interactive.cpp.

88 {
89  m_toolMgr->RunMainStack( this, std::move( aFunc ) );
90 }
TOOL_MANAGER * m_toolMgr
Definition: tool_base.h:214
void RunMainStack(TOOL_BASE *aTool, std::function< void()> aFunc)

References TOOL_BASE::m_toolMgr, and TOOL_MANAGER::RunMainStack().

Referenced by DRAWING_TOOL::PlaceText().

◆ select()

void PCB_SELECTION_TOOL::select ( BOARD_ITEM aItem)

Take necessary action mark an item as selected.

Parameters
aItemis an item to be selected.

Definition at line 2139 of file pcb_selection_tool.cpp.

2140 {
2141  if( aItem->IsSelected() )
2142  return;
2143 
2144  if( aItem->Type() == PCB_PAD_T )
2145  {
2146  FOOTPRINT* footprint = static_cast<FOOTPRINT*>( aItem->GetParent() );
2147 
2148  if( m_selection.Contains( footprint ) )
2149  return;
2150  }
2151 
2152  highlight( aItem, SELECTED, &m_selection );
2153 }
bool IsSelected() const
Definition: eda_item.h:123
void highlight(BOARD_ITEM *aItem, int aHighlightMode, PCB_SELECTION *aGroup=nullptr)
Highlight the item visually.
class PAD, a pad in a footprint
Definition: typeinfo.h:89
bool Contains(EDA_ITEM *aItem) const
Definition: selection.cpp:61
FOOTPRINT * footprint() const
#define SELECTED
PCB_SELECTION m_selection
BOARD_ITEM_CONTAINER * GetParent() const
Definition: board_item.h:166
KICAD_T Type() const
Returns the type of object.
Definition: eda_item.h:113

References SELECTION::Contains(), PCB_TOOL_BASE::footprint(), BOARD_ITEM::GetParent(), highlight(), EDA_ITEM::IsSelected(), m_selection, PCB_PAD_T, SELECTED, and EDA_ITEM::Type().

Referenced by AddItemToSel(), EnterGroup(), ExitGroup(), filterSelection(), FindItem(), GROUP_TOOL::Group(), SelectAll(), selectAllItemsOnNet(), selectAllItemsOnSheet(), selectConnectedTracks(), SelectItems(), selectMultiple(), selectNet(), and selectPoint().

◆ Selectable()

bool PCB_SELECTION_TOOL::Selectable ( const BOARD_ITEM aItem,
bool  checkVisibilityOnly = false 
) const

Check conditions for an item to be selected.

Returns
True if the item fulfills conditions to be selected.

Definition at line 1920 of file pcb_selection_tool.cpp.

1921 {
1922  const RENDER_SETTINGS* settings = getView()->GetPainter()->GetSettings();
1923 
1924  if( settings->GetHighContrast() )
1925  {
1926  std::set<unsigned int> activeLayers = settings->GetHighContrastLayers();
1927  bool onActiveLayer = false;
1928 
1929  for( unsigned int layer : activeLayers )
1930  {
1931  // NOTE: Only checking the regular layers (not GAL meta-layers)
1932  if( layer < PCB_LAYER_ID_COUNT && aItem->IsOnLayer( ToLAYER_ID( layer ) ) )
1933  {
1934  onActiveLayer = true;
1935  break;
1936  }
1937  }
1938 
1939  if( !onActiveLayer ) // We do not want to select items that are in the background
1940  return false;
1941  }
1942 
1943  if( aItem->Type() == PCB_FOOTPRINT_T )
1944  {
1945  // In footprint editor, we do not want to select the footprint itself.
1946  if( m_isFootprintEditor )
1947  return false;
1948 
1949  // Allow selection of footprints if some part of the footprint is visible.
1950  const FOOTPRINT* footprint = static_cast<const FOOTPRINT*>( aItem );
1951 
1952  // If the footprint has no items except the reference and value fields, include the
1953  // footprint in the selections.
1954  if( footprint->GraphicalItems().empty()
1955  && footprint->Pads().empty()
1956  && footprint->Zones().empty() )
1957  return true;
1958 
1959  for( const BOARD_ITEM* item : footprint->GraphicalItems() )
1960  {
1961  if( Selectable( item, true ) )
1962  return true;
1963  }
1964 
1965  for( const PAD* pad : footprint->Pads() )
1966  {
1967  if( Selectable( pad, true ) )
1968  return true;
1969  }
1970 
1971  for( const ZONE* zone : footprint->Zones() )
1972  {
1973  if( Selectable( zone, true ) )
1974  return true;
1975  }
1976 
1977  return false;
1978  }
1979  else if( aItem->Type() == PCB_GROUP_T )
1980  {
1981  PCB_GROUP* group = const_cast<PCB_GROUP*>( static_cast<const PCB_GROUP*>( aItem ) );
1982 
1983  // Similar to logic for footprint, a group is selectable if any of its members are.
1984  // (This recurses.)
1985  for( BOARD_ITEM* item : group->GetItems() )
1986  {
1987  if( Selectable( item, true ) )
1988  return true;
1989  }
1990 
1991  return false;
1992  }
1993 
1994  const ZONE* zone = nullptr;
1995  const PCB_VIA* via = nullptr;
1996  const PAD* pad = nullptr;
1997 
1998  switch( aItem->Type() )
1999  {
2000  case PCB_ZONE_T:
2001  case PCB_FP_ZONE_T:
2002  if( !board()->IsElementVisible( LAYER_ZONES ) )
2003  return false;
2004 
2005  zone = static_cast<const ZONE*>( aItem );
2006 
2007  // A footprint zone is only selectable within the footprint editor
2008  if( zone->GetParent()
2009  && zone->GetParent()->Type() == PCB_FOOTPRINT_T
2011  && !checkVisibilityOnly )
2012  {
2013  return false;
2014  }
2015 
2016  // zones can exist on multiple layers!
2017  if( !( zone->GetLayerSet() & board()->GetVisibleLayers() ).any() )
2018  return false;
2019 
2020  break;
2021 
2022  case PCB_TRACE_T:
2023  case PCB_ARC_T:
2024  if( !board()->IsElementVisible( LAYER_TRACKS ) )
2025  return false;
2026 
2027  if( m_isFootprintEditor )
2028  {
2029  if( !view()->IsLayerVisible( aItem->GetLayer() ) )
2030  return false;
2031  }
2032  else
2033  {
2034  if( !board()->IsLayerVisible( aItem->GetLayer() ) )
2035  return false;
2036  }
2037 
2038  break;
2039 
2040  case PCB_VIA_T:
2041  if( !board()->IsElementVisible( LAYER_VIAS ) )
2042  return false;
2043 
2044  via = static_cast<const PCB_VIA*>( aItem );
2045 
2046  // For vias it is enough if only one of its layers is visible
2047  if( !( board()->GetVisibleLayers() & via->GetLayerSet() ).any() )
2048  return false;
2049 
2050  break;
2051 
2052  case PCB_FP_TEXT_T:
2053  if( m_isFootprintEditor )
2054  {
2055  if( !view()->IsLayerVisible( aItem->GetLayer() ) )
2056  return false;
2057  }
2058  else
2059  {
2060  if( !view()->IsVisible( aItem ) )
2061  return false;
2062 
2063  if( !board()->IsLayerVisible( aItem->GetLayer() ) )
2064  return false;
2065  }
2066 
2067  break;
2068 
2069  case PCB_FP_SHAPE_T:
2070  if( m_isFootprintEditor )
2071  {
2072  if( !view()->IsLayerVisible( aItem->GetLayer() ) )
2073  return false;
2074  }
2075  else
2076  {
2077  // Footprint shape selections are only allowed in footprint editor mode.
2078  if( !checkVisibilityOnly )
2079  return false;
2080 
2081  if( !board()->IsLayerVisible( aItem->GetLayer() ) )
2082  return false;
2083  }
2084 
2085  break;
2086 
2087  case PCB_PAD_T:
2088  // Multiple selection is only allowed in footprint editor mode. In pcbnew, you have to
2089  // select footprint subparts one by one, rather than with a drag selection. This is so
2090  // you can pick up items under an (unlocked) footprint without also moving the
2091  // footprint's sub-parts.
2092  if( !m_isFootprintEditor && !checkVisibilityOnly )
2093  {
2094  if( m_multiple )
2095  return false;
2096  }
2097 
2098  pad = static_cast<const PAD*>( aItem );
2099 
2100  if( pad->GetAttribute() == PAD_ATTRIB::PTH || pad->GetAttribute() == PAD_ATTRIB::NPTH )
2101  {
2102  // Check render mode (from the Items tab) first
2103  if( !board()->IsElementVisible( LAYER_PADS_TH ) )
2104  return false;
2105 
2106  // A pad's hole is visible on every layer the pad is visible on plus many layers the
2107  // pad is not visible on -- so we only need to check for any visible hole layers.
2108  if( !( board()->GetVisibleLayers() & LSET::PhysicalLayersMask() ).any() )
2109  return false;
2110  }
2111  else
2112  {
2113  // Check render mode (from the Items tab) first
2114  if( pad->IsOnLayer( F_Cu ) && !board()->IsElementVisible( LAYER_PAD_FR ) )
2115  return false;
2116  else if( pad->IsOnLayer( B_Cu ) && !board()->IsElementVisible( LAYER_PAD_BK ) )
2117  return false;
2118 
2119  if( !( pad->GetLayerSet() & board()->GetVisibleLayers() ).any() )
2120  return false;
2121  }
2122 
2123  break;
2124 
2125  // These are not selectable
2126  case PCB_NETINFO_T:
2127  case NOT_USED:
2128  case TYPE_NOT_INIT:
2129  return false;
2130 
2131  default: // Suppress warnings
2132  break;
2133  }
2134 
2135  return aItem->ViewGetLOD( aItem->GetLayer(), view() ) < view()->GetScale();
2136 }
const std::set< unsigned int > GetHighContrastLayers() const
Returns the set of currently high-contrast layers.
smd pads, front layer
Definition: layer_ids.h:197
class FP_TEXT, text in a footprint
Definition: typeinfo.h:92
BOARD * board() const
Container for all the knowledge about how graphical objects are drawn on any output surface/device.
A base class for any item which can be embedded within the BOARD container class, and therefore insta...
Definition: board_item.h:80
class PCB_GROUP, a set of BOARD_ITEMs
Definition: typeinfo.h:108
A set of BOARD_ITEMs (i.e., without duplicates).
Definition: pcb_group.h:50
the 3d code uses this value
Definition: typeinfo.h:79
smd pads, back layer
Definition: layer_ids.h:198
virtual LSET GetLayerSet() const override
Return a std::bitset of all layers on which the item physically resides.
Definition: zone.cpp:291
LSET GetVisibleLayers() const
A proxy function that calls the correspondent function in m_BoardSettings.
Definition: board.cpp:480
class PCB_ARC, an arc track segment on a copper layer
Definition: typeinfo.h:97
class FP_SHAPE, a footprint edge
Definition: typeinfo.h:93
class PAD, a pad in a footprint
Definition: typeinfo.h:89
PAINTER * GetPainter() const
Return the painter object used by the view for drawing #VIEW_ITEMS.
Definition: view.h:208
class PCB_TRACK, a track segment (segment on a copper layer)
Definition: typeinfo.h:95
PADS & Pads()
Definition: footprint.h:168
Control for copper zone opacity/visibility (color ignored)
Definition: layer_ids.h:226
Plated through hole pad.
FP_ZONES & Zones()
Definition: footprint.h:174
like PAD_PTH, but not plated
Meta control for all vias opacity/visibility.
Definition: layer_ids.h:188
bool IsVisible(const VIEW_ITEM *aItem) const
Return information if the item is visible (or not).
Definition: view.cpp:1504
FOOTPRINT * footprint() const
KIGFX::PCB_VIEW * view() const
bool Selectable(const BOARD_ITEM *aItem, bool checkVisibilityOnly=false) const
Check conditions for an item to be selected.
DRAWINGS & GraphicalItems()
Definition: footprint.h:171
Handle a list of polygons defining a copper zone.
Definition: zone.h:56
class ZONE, a copper pour area
Definition: typeinfo.h:105
bool m_isFootprintEditor
KIGFX::VIEW * getView() const
Returns the instance of #VIEW object used in the application.
Definition: tool_base.cpp:36
class FOOTPRINT, a footprint
Definition: typeinfo.h:88
bool IsElementVisible(GAL_LAYER_ID aLayer) const
Test whether a given element category is visible.
Definition: board.cpp:532
bool GetHighContrast() const
static LSET PhysicalLayersMask()
Return a mask holding all layers which are physically realized.
Definition: lset.cpp:849
virtual RENDER_SETTINGS * GetSettings()=0
Return a pointer to current settings that are going to be used when drawing items.
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:472
multilayer pads, usually with holes
Definition: layer_ids.h:208
Definition: layer_ids.h:70
class NETINFO_ITEM, a description of a net
Definition: typeinfo.h:107
class ZONE, managed by a footprint
Definition: typeinfo.h:94
class PCB_VIA, a via (like a track segment on a copper layer)
Definition: typeinfo.h:96
Definition: pad.h:57
double GetScale() const
Definition: view.h:264
BOARD_ITEM_CONTAINER * GetParent() const
Definition: board_item.h:166
virtual PCB_LAYER_ID GetLayer() const
Return the primary layer this item is on.
Definition: board_item.h:171
PCB_LAYER_ID ToLAYER_ID(int aLayer)
Definition: lset.cpp:905
virtual double ViewGetLOD(int aLayer, VIEW *aView) const
Return the level of detail (LOD) of the item.
Definition: view_item.h:137
KICAD_T Type() const
Returns the type of object.
Definition: eda_item.h:113
bool IsLayerVisible(int aLayer) const
Return information about visibility of a particular layer.
Definition: view.h:405

References B_Cu, PCB_TOOL_BASE::board(), F_Cu, PCB_TOOL_BASE::footprint(), KIGFX::RENDER_SETTINGS::GetHighContrast(), KIGFX::RENDER_SETTINGS::GetHighContrastLayers(), BOARD_ITEM::GetLayer(), ZONE::GetLayerSet(), KIGFX::VIEW::GetPainter(), BOARD_ITEM::GetParent(), KIGFX::VIEW::GetScale(), KIGFX::PAINTER::GetSettings(), TOOL_BASE::getView(), BOARD::GetVisibleLayers(), FOOTPRINT::GraphicalItems(), group, BOARD::IsElementVisible(), KIGFX::VIEW::IsLayerVisible(), BOARD::IsLayerVisible(), KIGFX::VIEW::IsVisible(), LAYER_PAD_BK, LAYER_PAD_FR, LAYER_PADS_TH, LAYER_TRACKS, LAYER_VIAS, LAYER_ZONES, PCB_TOOL_BASE::m_isFootprintEditor, SELECTION_TOOL::m_multiple, NOT_USED, NPTH, pad, FOOTPRINT::Pads(), PCB_ARC_T, PCB_FOOTPRINT_T, PCB_FP_SHAPE_T, PCB_FP_TEXT_T, PCB_FP_ZONE_T, PCB_GROUP_T, PCB_NETINFO_T, PCB_PAD_T, PCB_TRACE_T, PCB_VIA_T, PCB_ZONE_T, LSET::PhysicalLayersMask(), PTH, ToLAYER_ID(), EDA_ITEM::Type(), TYPE_NOT_INIT, via, PCB_TOOL_BASE::view(), KIGFX::VIEW_ITEM::ViewGetLOD(), and FOOTPRINT::Zones().

Referenced by PCB_CONTROL::DeleteItemCursor(), SelectAll(), selectMultiple(), and selectPoint().

◆ SelectAll()

int PCB_SELECTION_TOOL::SelectAll ( const TOOL_EVENT aEvent)

Multiple item selection event handler.

Definition at line 961 of file pcb_selection_tool.cpp.

962 {
963  KIGFX::VIEW* view = getView();
964 
965  // hold all visible items
966  std::vector<KIGFX::VIEW::LAYER_ITEM_PAIR> selectedItems;
967 
968  // Filter the view items based on the selection box
969  BOX2I selectionBox;
970 
971  // Intermediate step to allow filtering against hierarchy
972  GENERAL_COLLECTOR collection;
973 
974  selectionBox.SetMaximum();
975  view->Query( selectionBox, selectedItems ); // Get the list of selected items
976 
977  for( const KIGFX::VIEW::LAYER_ITEM_PAIR& item_pair : selectedItems )
978  {
979  BOARD_ITEM* item = static_cast<BOARD_ITEM*>( item_pair.first );
980 
981  if( !item || !Selectable( item ) || !itemPassesFilter( item ) )
982  continue;
983 
984  collection.Append( item );
985  }
986 
987  FilterCollectorForHierarchy( collection, true );
988 
989  for( EDA_ITEM* item : collection )
990  select( static_cast<BOARD_ITEM*>( item ) );
991 
993 
994  return 0;
995 }
void ForceRefresh()
Force a redraw.
void select(BOARD_ITEM *aItem)
Take necessary action mark an item as selected.
A base class for any item which can be embedded within the BOARD container class, and therefore insta...
Definition: board_item.h:80
PCB_DRAW_PANEL_GAL * GetCanvas() const override
Return a pointer to GAL-based canvas of given EDA draw frame.
PCB_BASE_FRAME * m_frame
void Append(EDA_ITEM *item)
Add an item to the end of the list.
Definition: collector.h:105
void SetMaximum()
Definition: box2.h:57
KIGFX::PCB_VIEW * view() const
bool Selectable(const BOARD_ITEM *aItem, bool checkVisibilityOnly=false) const
Check conditions for an item to be selected.
KIGFX::VIEW * getView() const
Returns the instance of #VIEW object used in the application.
Definition: tool_base.cpp:36
void FilterCollectorForHierarchy(GENERAL_COLLECTOR &aCollector, bool aMultiselect) const
In general we don't want to select both a parent and any of it's children.
Used when the right click button is pressed, or when the select tool is in effect.
Definition: collectors.h:240
std::pair< VIEW_ITEM *, int > LAYER_ITEM_PAIR
Definition: view.h:73
A base class for most all the KiCad significant classes used in schematics and boards.
Definition: eda_item.h:100
bool itemPassesFilter(BOARD_ITEM *aItem)
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:429
Hold a (potentially large) number of VIEW_ITEMs and renders them on a graphics device provided by the...
Definition: view.h:68

References COLLECTOR::Append(), FilterCollectorForHierarchy(), EDA_DRAW_PANEL_GAL::ForceRefresh(), PCB_BASE_FRAME::GetCanvas(), TOOL_BASE::getView(), itemPassesFilter(), m_frame, KIGFX::VIEW::Query(), select(), Selectable(), BOX2< Vec >::SetMaximum(), and PCB_TOOL_BASE::view().

Referenced by setTransitions().

◆ selectAllItemsOnNet()

void PCB_SELECTION_TOOL::selectAllItemsOnNet ( int  aNetCode,
bool  aSelect = true 
)
private

Select all items with the given net code.

Parameters
aNetCodeis the target net to select
aSelectis true to add the items to the selection, false to remove them (deselect)

Definition at line 1244 of file pcb_selection_tool.cpp.

1245 {
1246  constexpr KICAD_T types[] = { PCB_TRACE_T, PCB_ARC_T, PCB_VIA_T, EOT };
1247  auto connectivity = board()->GetConnectivity();
1248 
1249  for( BOARD_CONNECTED_ITEM* item : connectivity->GetNetItems( aNetCode, types ) )
1250  {
1251  if( itemPassesFilter( item ) )
1252  aSelect ? select( item ) : unselect( item );
1253  }
1254 }
void select(BOARD_ITEM *aItem)
Take necessary action mark an item as selected.
BOARD * board() const
class PCB_ARC, an arc track segment on a copper layer
Definition: typeinfo.h:97
A base class derived from BOARD_ITEM for items that can be connected and have a net,...
search types array terminator (End Of Types)
Definition: typeinfo.h:81
KICAD_T
The set of class identification values stored in EDA_ITEM::m_structType.
Definition: typeinfo.h:77
class PCB_TRACK, a track segment (segment on a copper layer)
Definition: typeinfo.h:95
std::shared_ptr< CONNECTIVITY_DATA > GetConnectivity() const
Return a list of missing connections between components/tracks.
Definition: board.h:344
void unselect(BOARD_ITEM *aItem)
Take necessary action mark an item as unselected.
bool itemPassesFilter(BOARD_ITEM *aItem)
class PCB_VIA, a via (like a track segment on a copper layer)
Definition: typeinfo.h:96

References PCB_TOOL_BASE::board(), EOT, BOARD::GetConnectivity(), itemPassesFilter(), PCB_ARC_T, PCB_TRACE_T, PCB_VIA_T, select(), and unselect().

Referenced by selectNet().

◆ selectAllItemsOnSheet()

void PCB_SELECTION_TOOL::selectAllItemsOnSheet ( wxString &  aSheetPath)
private

Select all items with the given sheet timestamp/UUID name (the sheet path).

The path of the root sheet is "/".Select all footprints belonging to same sheet, from Eeschema using cross-probing.

Definition at line 1292 of file pcb_selection_tool.cpp.

1293 {
1294  std::list<FOOTPRINT*> footprintList;
1295 
1296  // store all footprints that are on that sheet path
1297  for( FOOTPRINT* footprint : board()->Footprints() )
1298  {
1299  if( footprint == nullptr )
1300  continue;
1301 
1302  wxString footprint_path = footprint->GetPath().AsString().BeforeLast('/');
1303 
1304  if( aSheetPath.IsEmpty() )
1305  aSheetPath += '/';
1306 
1307  if( footprint_path == aSheetPath )
1308  footprintList.push_back( footprint );
1309  }
1310 
1311  // Generate a list of all pads, and of all nets they belong to.
1312  std::list<int> netcodeList;
1313  std::list<PAD*> padList;
1314 
1315  for( FOOTPRINT* footprint : footprintList )
1316  {
1317  for( PAD* pad : footprint->Pads() )
1318  {
1319  if( pad->IsConnected() )
1320  {
1321  netcodeList.push_back( pad->GetNetCode() );
1322  padList.push_back( pad );
1323  }
1324  }
1325  }
1326 
1327  // remove all duplicates
1328  netcodeList.sort();
1329  netcodeList.unique();
1330 
1331  for( PAD* pad : padList )
1333 
1334  // now we need to find all footprints that are connected to each of these nets then we need
1335  // to determine if these footprints are in the list of footprints belonging to this sheet
1336  std::list<int> removeCodeList;
1337  constexpr KICAD_T padType[] = { PCB_PAD_T, EOT };
1338 
1339  for( int netCode : netcodeList )
1340  {
1341  for( BOARD_CONNECTED_ITEM* mitem : board()->GetConnectivity()->GetNetItems( netCode,
1342  padType ) )
1343  {
1344  if( mitem->Type() == PCB_PAD_T && !alg::contains( footprintList, mitem->GetParent() ) )
1345  {
1346  // if we cannot find the footprint of the pad in the footprintList then we can
1347  // assume that that footprint is not located in the same schematic, therefore
1348  // invalidate this netcode.
1349  removeCodeList.push_back( netCode );
1350  break;
1351  }
1352  }
1353  }
1354 
1355  // remove all duplicates
1356  removeCodeList.sort();
1357  removeCodeList.unique();
1358 
1359  for( int removeCode : removeCodeList )
1360  {
1361  netcodeList.remove( removeCode );
1362  }
1363 
1364  std::list<BOARD_CONNECTED_ITEM*> localConnectionList;
1365  constexpr KICAD_T trackViaType[] = { PCB_TRACE_T, PCB_ARC_T, PCB_VIA_T, EOT };
1366 
1367  for( int netCode : netcodeList )
1368  {
1369  for( BOARD_CONNECTED_ITEM* item : board()->GetConnectivity()->GetNetItems( netCode,
1370  trackViaType ) )
1371  localConnectionList.push_back( item );
1372  }
1373 
1374  for( BOARD_ITEM* i : footprintList )
1375  {
1376  if( i != nullptr )
1377  select( i );
1378  }
1379 
1380  for( BOARD_CONNECTED_ITEM* i : localConnectionList )
1381  {
1382  if( i != nullptr )
1383  select( i );
1384  }
1385 }
void select(BOARD_ITEM *aItem)
Take necessary action mark an item as selected.
BOARD * board() const
const KIID_PATH & GetPath() const
Definition: footprint.h:203
A base class for any item which can be embedded within the BOARD container class, and therefore insta...
Definition: board_item.h:80
class PCB_ARC, an arc track segment on a copper layer
Definition: typeinfo.h:97
class PAD, a pad in a footprint
Definition: typeinfo.h:89
void selectConnectedTracks(BOARD_CONNECTED_ITEM &aSourceItem, STOP_CONDITION aStopCondition)
Select connected tracks and vias.
A base class derived from BOARD_ITEM for items that can be connected and have a net,...
search types array terminator (End Of Types)
Definition: typeinfo.h:81
KICAD_T
The set of class identification values stored in EDA_ITEM::m_structType.
Definition: typeinfo.h:77
class PCB_TRACK, a track segment (segment on a copper layer)
Definition: typeinfo.h:95
PADS & Pads()
Definition: footprint.h:168
FOOTPRINT * footprint() const
bool contains(const _Container &__container, _Value __value)
Returns true if the container contains the given value.
Definition: kicad_algo.h:99
wxString AsString() const
Definition: kiid.cpp:277
class PCB_VIA, a via (like a track segment on a copper layer)
Definition: typeinfo.h:96
Definition: pad.h:57

References KIID_PATH::AsString(), PCB_TOOL_BASE::board(), alg::contains(), EOT, PCB_TOOL_BASE::footprint(), FOOTPRINT::GetPath(), pad, FOOTPRINT::Pads(), PCB_ARC_T, PCB_PAD_T, PCB_TRACE_T, PCB_VIA_T, select(), selectConnectedTracks(), and STOP_NEVER.

Referenced by selectSameSheet(), and selectSheetContents().

◆ selectConnectedTracks()

void PCB_SELECTION_TOOL::selectConnectedTracks ( BOARD_CONNECTED_ITEM aSourceItem,
STOP_CONDITION  aStopCondition 
)
private

Select connected tracks and vias.

Parameters
aStopConditionwhere to stop selecting more items

Definition at line 1124 of file pcb_selection_tool.cpp.

1126 {
1127  constexpr KICAD_T types[] = { PCB_TRACE_T, PCB_ARC_T, PCB_VIA_T, PCB_PAD_T, EOT };
1128 
1129  auto connectivity = board()->GetConnectivity();
1130  auto connectedItems = connectivity->GetConnectedItems( &aStartItem, types, true );
1131 
1132  std::map<wxPoint, std::vector<PCB_TRACK*>> trackMap;
1133  std::map<wxPoint, PCB_VIA*> viaMap;
1134  std::map<wxPoint, PAD*> padMap;
1135 
1136  // Build maps of connected items
1137  for( BOARD_CONNECTED_ITEM* item : connectedItems )
1138  {
1139  switch( item->Type() )
1140  {
1141  case PCB_ARC_T:
1142  case PCB_TRACE_T:
1143  {
1144  PCB_TRACK* track = static_cast<PCB_TRACK*>( item );
1145  trackMap[ track->GetStart() ].push_back( track );
1146  trackMap[ track->GetEnd() ].push_back( track );
1147  break;
1148  }
1149 
1150  case PCB_VIA_T:
1151  {
1152  PCB_VIA* via = static_cast<PCB_VIA*>( item );
1153  viaMap[ via->GetStart() ] = via;
1154  break;
1155  }
1156 
1157  case PCB_PAD_T:
1158  {
1159  PAD* pad = static_cast<PAD*>( item );
1160  padMap[ pad->GetPosition() ] = pad;
1161  break;
1162  }
1163 
1164  default:
1165  break;
1166  }
1167 
1168  item->SetState( SKIP_STRUCT, false );
1169  }
1170 
1171  std::vector<wxPoint> activePts;
1172 
1173  // Set up the initial active points
1174  switch( aStartItem.Type() )
1175  {
1176  case PCB_ARC_T:
1177  case PCB_TRACE_T:
1178  activePts.push_back( static_cast<PCB_TRACK*>( &aStartItem )->GetStart() );
1179  activePts.push_back( static_cast<PCB_TRACK*>( &aStartItem )->GetEnd() );
1180  break;
1181 
1182  case PCB_VIA_T:
1183  activePts.push_back( static_cast<PCB_TRACK*>( &aStartItem )->GetStart() );
1184  break;
1185 
1186  case PCB_PAD_T:
1187  activePts.push_back( aStartItem.GetPosition() );
1188  break;
1189 
1190  default:
1191  break;
1192  }
1193 
1194  bool expand = true;
1195 
1196  // Iterative push from all active points
1197  while( expand )
1198  {
1199  expand = false;
1200 
1201  for( int i = activePts.size() - 1; i >= 0; --i )
1202  {
1203  wxPoint pt = activePts[i];
1204  size_t pt_count = trackMap[ pt ].size() + viaMap.count( pt );
1205 
1206  if( pt_count > 2 && aStopCondition == STOP_AT_JUNCTION )
1207  {
1208  activePts.erase( activePts.begin() + i );
1209  continue;
1210  }
1211 
1212  if( padMap.count( pt ) && aStopCondition != STOP_NEVER )
1213  {
1214  activePts.erase( activePts.begin() + i );
1215  continue;
1216  }
1217 
1218  for( PCB_TRACK* track : trackMap[ pt ] )
1219  {
1220  if( track->GetState( SKIP_STRUCT ) )
1221  continue;
1222 
1223  track->SetState( SKIP_STRUCT, true );
1224  select( track );
1225 
1226  if( track->GetStart() == pt )
1227  activePts.push_back( track->GetEnd() );
1228  else
1229  activePts.push_back( track->GetStart() );
1230 
1231  expand = true;
1232  }
1233 
1234  if( viaMap.count( pt ) && !viaMap[ pt ]->IsSelected()
1235  && aStopCondition != STOP_AT_JUNCTION )
1236  select( viaMap[ pt ] );
1237 
1238  activePts.erase( activePts.begin() + i );
1239  }
1240  }
1241 }
void select(BOARD_ITEM *aItem)
Take necessary action mark an item as selected.
BOARD * board() const
const wxPoint & GetEnd() const
Definition: pcb_track.h:105
Stop at any place where more than two traces meet.
class PCB_ARC, an arc track segment on a copper layer
Definition: typeinfo.h:97
class PAD, a pad in a footprint
Definition: typeinfo.h:89
A base class derived from BOARD_ITEM for items that can be connected and have a net,...
search types array terminator (End Of Types)
Definition: typeinfo.h:81
KICAD_T
The set of class identification values stored in EDA_ITEM::m_structType.
Definition: typeinfo.h:77
class PCB_TRACK, a track segment (segment on a copper layer)
Definition: typeinfo.h:95
void SetState(EDA_ITEM_FLAGS type, bool state)
Definition: eda_item.h:142
std::shared_ptr< CONNECTIVITY_DATA > GetConnectivity() const
Return a list of missing connections between components/tracks.
Definition: board.h:344
int GetState(EDA_ITEM_FLAGS type) const
Definition: eda_item.h:137
#define SKIP_STRUCT
flag indicating that the structure should be ignored
class PCB_VIA, a via (like a track segment on a copper layer)
Definition: typeinfo.h:96
Definition: pad.h:57
const wxPoint & GetStart() const
Definition: pcb_track.h:108

References PCB_TOOL_BASE::board(), EOT, BOARD::GetConnectivity(), PCB_TRACK::GetEnd(), EDA_ITEM::GetPosition(), PCB_TRACK::GetStart(), pad, PCB_ARC_T, PCB_PAD_T, PCB_TRACE_T, PCB_VIA_T, select(), SKIP_STRUCT, STOP_AT_JUNCTION, STOP_NEVER, EDA_ITEM::Type(), and via.

Referenced by expandConnection(), and selectAllItemsOnSheet().

◆ selectCursor()

bool PCB_SELECTION_TOOL::selectCursor ( bool  aForceSelect = false,
CLIENT_SELECTION_FILTER  aClientFilter = nullptr 
)
private

Select an item under the cursor unless there is something already selected or aSelectAlways is true.

Parameters
aForceSelectforces to select an item even if there is an item already selected.
aClientFilterallows the client to perform tool- or action-specific filtering.
Returns
true if eventually there is an item selected, false otherwise.

Definition at line 758 of file pcb_selection_tool.cpp.

759 {
760  if( aForceSelect || m_selection.Empty() )
761  {
762  ClearSelection( true /*quiet mode*/ );
763  selectPoint( getViewControls()->GetCursorPosition( false ), false, nullptr, aClientFilter );
764  }
765 
766  return !m_selection.Empty();
767 }
bool selectPoint(const VECTOR2I &aWhere, bool aOnDrag=false, bool *aSelectionCancelledFlag=nullptr, CLIENT_SELECTION_FILTER aClientFilter=nullptr)
Select an item pointed by the parameter aWhere.
PCB_SELECTION m_selection
bool Empty() const
Checks if there is anything selected.
Definition: selection.h:97
KIGFX::VIEW_CONTROLS * getViewControls() const
Return the instance of VIEW_CONTROLS object used in the application.
Definition: tool_base.cpp:42
int ClearSelection(const TOOL_EVENT &aEvent)

References ClearSelection(), SELECTION::Empty(), TOOL_BASE::getViewControls(), m_selection, and selectPoint().

Referenced by CursorSelection(), expandConnection(), Main(), selectNet(), and selectSameSheet().

◆ selection() [1/2]

const PCB_SELECTION & PCB_TOOL_BASE::selection ( ) const
protectedinherited

Definition at line 313 of file pcb_tool_base.cpp.

314 {
316 
317  return selTool->GetSelection();
318 }
TOOL_MANAGER * m_toolMgr
Definition: tool_base.h:214
PCB_SELECTION & GetSelection()
Return the set of currently selected items.
The selection tool: currently supports:

References GetSelection(), TOOL_MANAGER::GetTool(), and TOOL_BASE::m_toolMgr.

Referenced by AUTOPLACE_TOOL::autoplaceSelected(), BOARD_INSPECTION_TOOL::calculateSelectionRatsnest(), ROUTER_TOOL::CanInlineDrag(), EDIT_TOOL::ChangeTrackWidth(), PAD_TOOL::copyPadSettings(), EDIT_TOOL::copyToClipboard(), EDIT_TOOL::CreateArray(), BOARD_INSPECTION_TOOL::CrossProbePcbToSch(), BOARD_INSPECTION_TOOL::doHideNet(), PCB_TOOL_BASE::doInteractiveItemPlacement(), EDIT_TOOL::doMoveSelection(), EDIT_TOOL::Drag(), EDIT_TOOL::DragArcTrack(), DRAWING_TOOL::drawArc(), DRAWING_TOOL::DrawDimension(), MICROWAVE_TOOL::drawMicrowaveInductor(), DRAWING_TOOL::drawSegment(), DRAWING_TOOL::DrawZone(), EDIT_TOOL::Duplicate(), BOARD_EDITOR_CONTROL::EditFpInFpEditor(), PAD_TOOL::EditPad(), GROUP_TOOL::EnterGroup(), PAD_TOOL::EnumeratePads(), GLOBAL_EDIT_TOOL::ExchangeFootprints(), EDIT_TOOL::FilletTracks(), filterSelection(), EDIT_TOOL::Flip(), DRAWING_TOOL::getSourceZoneForAction(), GROUP_TOOL::Group(), BOARD_INSPECTION_TOOL::highlightNet(), ROUTER_TOOL::InlineBreakTrack(), ROUTER_TOOL::InlineDrag(), BOARD_INSPECTION_TOOL::InspectClearance(), BOARD_INSPECTION_TOOL::InspectConstraints(), DRAWING_TOOL::InteractivePlaceWithPreview(), BOARD_INSPECTION_TOOL::LocalRatsnestTool(), ROUTER_TOOL::MainLoop(), LENGTH_TUNER_TOOL::MainLoop(), EDIT_TOOL::Mirror(), BOARD_EDITOR_CONTROL::modifyLockSelected(), EDIT_TOOL::MoveExact(), PCB_POINT_EDITOR::OnSelectionChange(), PAD_TOOL::pastePadProperties(), ROUTER_TOOL::performDragging(), ROUTER_TOOL::performRouting(), LENGTH_TUNER_TOOL::performTuning(), PCB_CONTROL::placeBoardItems(), BOARD_EDITOR_CONTROL::PlaceFootprint(), DRAWING_TOOL::PlaceImportedGraphics(), BOARD_EDITOR_CONTROL::PlaceTarget(), DRAWING_TOOL::PlaceText(), POSITION_RELATIVE_TOOL::PositionRelative(), EDIT_TOOL::Properties(), PAD_TOOL::pushPadSettings(), BOARD_REANNOTATE_TOOL::ReannotateDuplicatesInSelection(), GROUP_TOOL::RemoveFromGroup(), GLOBAL_EDIT_TOOL::RemoveUnusedPads(), EDIT_TOOL::Rotate(), selectNet(), DRAWING_TOOL::SetAnchor(), BOARD_EDITOR_CONTROL::TrackWidthDec(), BOARD_EDITOR_CONTROL::TrackWidthInc(), GROUP_TOOL::Ungroup(), PCB_CONTROL::UpdateMessagePanel(), BOARD_INSPECTION_TOOL::UpdateSelectionRatsnest(), BOARD_EDITOR_CONTROL::ViaSizeDec(), BOARD_EDITOR_CONTROL::ViaSizeInc(), BOARD_EDITOR_CONTROL::ZoneDuplicate(), ZONE_FILLER_TOOL::ZoneFill(), BOARD_EDITOR_CONTROL::ZoneMerge(), and ZONE_FILLER_TOOL::ZoneUnfill().

◆ selection() [2/2]

PCB_SELECTION & PCB_TOOL_BASE::selection ( )
protectedinherited

Definition at line 321 of file pcb_tool_base.cpp.

322 {
324 
325  return selTool->GetSelection();
326 }
TOOL_MANAGER * m_toolMgr
Definition: tool_base.h:214
PCB_SELECTION & GetSelection()
Return the set of currently selected items.
The selection tool: currently supports:

References GetSelection(), TOOL_MANAGER::GetTool(), and TOOL_BASE::m_toolMgr.

◆ selectionContains()

bool PCB_SELECTION_TOOL::selectionContains ( const VECTOR2I aPoint) const
private
Returns
True if the given point is contained in any of selected items' bounding box.

Definition at line 2249 of file pcb_selection_tool.cpp.

2250 {
2252  GENERAL_COLLECTOR collector;
2253 
2254  // Since we're just double-checking, we want a considerably sloppier check than the initial
2255  // selection (for which most tools use 5 pixels). So we increase this to an effective 20
2256  // pixels by artificially inflating the value of a pixel by 4X.
2257  guide.SetOnePixelInIU( guide.OnePixelInIU() * 4 );
2258 
2261  (wxPoint) aPoint, guide );
2262 
2263  for( int i = collector.GetCount() - 1; i >= 0; --i )
2264  {
2265  BOARD_ITEM* item = collector[i];
2266 
2267  if( item->IsSelected() && item->HitTest( (wxPoint) aPoint, 5 * guide.OnePixelInIU() ) )
2268  return true;
2269  }
2270 
2271  return false;
2272 }
const GENERAL_COLLECTORS_GUIDE getCollectorsGuide() const
static const KICAD_T FootprintItems[]
A scan list for primary footprint items.
Definition: collectors.h:293
void SetOnePixelInIU(double aValue)
Definition: collectors.h:571
static const KICAD_T AllBoardItems[]
A scan list for all editable board items.
Definition: collectors.h:267
BOARD * board() const
bool IsSelected() const
Definition: eda_item.h:123
A base class for any item which can be embedded within the BOARD container class, and therefore insta...
Definition: board_item.h:80
void Collect(BOARD_ITEM *aItem, const KICAD_T aScanList[], const wxPoint &aRefPos, const COLLECTORS_GUIDE &aGuide)
Scan a BOARD_ITEM using this class's Inspector method, which does the collection.
Definition: collectors.cpp:571
double OnePixelInIU() const override
Definition: collectors.h:570
virtual bool HitTest(const wxPoint &aPosition, int aAccuracy=0) const
Test if aPosition is contained within or on the bounding box of an item.
Definition: eda_item.h:225
int GetCount() const
Return the number of objects in the list.
Definition: collector.h:87
bool m_isFootprintEditor
Used when the right click button is pressed, or when the select tool is in effect.
Definition: collectors.h:240
A general implementation of a COLLECTORS_GUIDE.
Definition: collectors.h:377

References GENERAL_COLLECTOR::AllBoardItems, PCB_TOOL_BASE::board(), GENERAL_COLLECTOR::Collect(), GENERAL_COLLECTOR::FootprintItems, getCollectorsGuide(), COLLECTOR::GetCount(), EDA_ITEM::HitTest(), EDA_ITEM::IsSelected(), PCB_TOOL_BASE::m_isFootprintEditor, GENERAL_COLLECTORS_GUIDE::OnePixelInIU(), and GENERAL_COLLECTORS_GUIDE::SetOnePixelInIU().

Referenced by Main().

◆ SelectionMenu()

int PCB_SELECTION_TOOL::SelectionMenu ( const TOOL_EVENT aEvent)

Show a popup menu to trim the COLLECTOR passed as aEvent's parameter down to a single item.

Note
This routine does not modify the selection.

Definition at line 1759 of file pcb_selection_tool.cpp.

1760 {
1761  GENERAL_COLLECTOR* collector = aEvent.Parameter<GENERAL_COLLECTOR*>();
1762 
1763  doSelectionMenu( collector );
1764 
1765  return 0;
1766 }
bool doSelectionMenu(GENERAL_COLLECTOR *aItems)
Allow the selection of a single item from a list via pop-up menu.
T Parameter() const
Return a non-standard parameter assigned to the event.
Definition: tool_event.h:432
Used when the right click button is pressed, or when the select tool is in effect.
Definition: collectors.h:240

References doSelectionMenu(), and TOOL_EVENT::Parameter().

Referenced by setTransitions().

◆ SelectItem()

int PCB_SELECTION_TOOL::SelectItem ( const TOOL_EVENT aEvent)

Definition at line 954 of file pcb_selection_tool.cpp.

955 {
956  AddItemToSel( aEvent.Parameter<BOARD_ITEM*>() );
957  return 0;
958 }
A base class for any item which can be embedded within the BOARD container class, and therefore insta...
Definition: board_item.h:80
void AddItemToSel(BOARD_ITEM *aItem, bool aQuietMode=false)
Select all items on the board.
T Parameter() const
Return a non-standard parameter assigned to the event.
Definition: tool_event.h:432

References AddItemToSel(), and TOOL_EVENT::Parameter().

Referenced by setTransitions().

◆ SelectItems()

int PCB_SELECTION_TOOL::SelectItems ( const TOOL_EVENT aEvent)

Item unselection event handler.

Definition at line 937 of file pcb_selection_tool.cpp.

938 {
939  std::vector<BOARD_ITEM*>* items = aEvent.Parameter<std::vector<BOARD_ITEM*>*>();
940 
941  if( items )
942  {
943  // Perform individual selection of each item before processing the event.
944  for( BOARD_ITEM* item : *items )
945  select( item );
946 
948  }
949 
950  return 0;
951 }
static const TOOL_EVENT SelectedEvent
Definition: actions.h:199
void select(BOARD_ITEM *aItem)
Take necessary action mark an item as selected.
A base class for any item which can be embedded within the BOARD container class, and therefore insta...
Definition: board_item.h:80
TOOL_MANAGER * m_toolMgr
Definition: tool_base.h:214
bool ProcessEvent(const TOOL_EVENT &aEvent)
Propagate an event to tools that requested events of matching type(s).
T Parameter() const
Return a non-standard parameter assigned to the event.
Definition: tool_event.h:432

References TOOL_BASE::m_toolMgr, TOOL_EVENT::Parameter(), TOOL_MANAGER::ProcessEvent(), select(), and EVENTS::SelectedEvent.

Referenced by setTransitions().

◆ selectMultiple()

bool PCB_SELECTION_TOOL::selectMultiple ( )
private

Handle drawing a selection box that allows one to select many items at the same time.

Returns
true if the function was canceled (i.e. CancelEvent was received).

Definition at line 770 of file pcb_selection_tool.cpp.

771 {
772  bool cancelled = false; // Was the tool cancelled while it was running?
773  m_multiple = true; // Multiple selection mode is active
774  KIGFX::VIEW* view = getView();
775 
777  view->Add( &area );
778 
779  bool anyAdded = false;
780  bool anySubtracted = false;
781 
782  while( TOOL_EVENT* evt = Wait() )
783  {
784  int width = area.GetEnd().x - area.GetOrigin().x;
785 
786  /* Selection mode depends on direction of drag-selection:
787  * Left > Right : Select objects that are fully enclosed by selection
788  * Right > Left : Select objects that are crossed by selection
789  */
790  bool windowSelection = width >= 0 ? true : false;
791 
792  if( view->IsMirroredX() )
793  windowSelection = !windowSelection;
794 
797 
798  if( evt->IsCancelInteractive() || evt->IsActivate() )
799  {
800  cancelled = true;
801  break;
802  }
803 
804  if( evt->IsDrag( BUT_LEFT ) )
805  {
807  {
808  if( m_selection.GetSize() > 0 )
809  {
810  anySubtracted = true;
811  ClearSelection( true /*quiet mode*/ );
812  }
813  }
814 
815  // Start drawing a selection box
816  area.SetOrigin( evt->DragOrigin() );
817  area.SetEnd( evt->Position() );
820  area.SetExclusiveOr( false );
821 
822  view->SetVisible( &area, true );
823  view->Update( &area );
824  getViewControls()->SetAutoPan( true );
825  }
826 
827  if( evt->IsMouseUp( BUT_LEFT ) )
828  {
829  getViewControls()->SetAutoPan( false );
830 
831  // End drawing the selection box
832  view->SetVisible( &area, false );
833 
834  std::vector<KIGFX::VIEW::LAYER_ITEM_PAIR> candidates;
835  BOX2I selectionBox = area.ViewBBox();
836  view->Query( selectionBox, candidates ); // Get the list of nearby items
837 
838  int height = area.GetEnd().y - area.GetOrigin().y;
839 
840  // Construct an EDA_RECT to determine BOARD_ITEM selection
841  EDA_RECT selectionRect( (wxPoint) area.GetOrigin(), wxSize( width, height ) );
842 
843  selectionRect.Normalize();
844 
845  GENERAL_COLLECTOR collector;
846 
847  for( auto it = candidates.begin(), it_end = candidates.end(); it != it_end; ++it )
848  {
849  BOARD_ITEM* item = static_cast<BOARD_ITEM*>( it->first );
850 
851  if( item && Selectable( item ) && item->HitTest( selectionRect, windowSelection ) )
852  collector.Append( item );
853  }
854 
855  // Apply the stateful filter
856  FilterCollectedItems( collector );
857 
858  FilterCollectorForHierarchy( collector, true );
859 
860  for( EDA_ITEM* i : collector )
861  {
862  BOARD_ITEM* item = static_cast<BOARD_ITEM*>( i );
863 
864  if( m_subtractive || ( m_exclusive_or && item->IsSelected() ) )
865  {
866  unselect( item );
867  anySubtracted = true;
868  }
869  else
870  {
871  select( item );
872  anyAdded = true;
873  }
874  }
875 
876  m_selection.SetIsHover( false );
877 
878  // Inform other potentially interested tools
879  if( anyAdded )
881  else if( anySubtracted )
883 
884  break; // Stop waiting for events
885  }
886  }
887 
888  getViewControls()->SetAutoPan( false );
889 
890  // Stop drawing the selection box
891  view->Remove( &area );
892  m_multiple = false; // Multiple selection mode is inactive
893 
894  if( !cancelled )
896 
898 
899  return cancelled;
900 }
void SetEnd(const VECTOR2I &aEnd)
Set the current end of the rectangle (the corner that moves with the cursor.