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:
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...
 
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 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...
 
void FilterCollectorForGroups (GENERAL_COLLECTOR &aCollector) const
 
PCB_GROUPGetEnteredGroup ()
 Apply the SELECTION_FILTER_OPTIONS to a collection of items. More...
 
void FilterCollectedItems (GENERAL_COLLECTOR &aCollector)
 
void SetIsFootprintEditor (bool aEnabled)
 Function SetIsFootprintEditor() More...
 
bool IsFootprintEditor () const
 
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 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_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=NULL, CLIENT_SELECTION_FILTER aClientFilter=NULL)
 Select an item pointed by the parameter aWhere. More...
 
bool selectCursor (bool aForceSelect=false, CLIENT_SELECTION_FILTER aClientFilter=NULL)
 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...
 
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)
 Find dialog callback. More...
 
void findCallback (BOARD_ITEM *aItem)
 Find an item. More...
 
int find (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
 
bool m_additive
 
bool m_subtractive
 
bool m_exclusive_or
 
bool m_multiple
 
bool m_skip_heuristics
 
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 63 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 111 of file pcb_tool_base.h.

111  {
113  IPO_ROTATE = 0x01,
114 
116  IPO_FLIP = 0x02,
117 
120  IPO_SINGLE_CLICK = 0x04,
121 
123  IPO_REPEAT = 0x08
124  };
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 78 of file tool_base.h.

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

◆ 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 252 of file pcb_selection_tool.h.

253  {
262  STOP_AT_PAD,
264  STOP_NEVER
265  };
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 99 of file pcb_selection_tool.cpp.

99  :
100  PCB_TOOL_BASE( "pcbnew.InteractiveSelection" ),
101  m_frame( NULL ),
102  m_additive( false ),
103  m_subtractive( false ),
104  m_exclusive_or( false ),
105  m_multiple( false ),
106  m_skip_heuristics( false ),
107  m_enteredGroup( nullptr ),
108  m_priv( std::make_unique<PRIV>() )
109 {
110  m_filter.lockedItems = false;
111  m_filter.footprints = true;
112  m_filter.text = true;
113  m_filter.tracks = true;
114  m_filter.vias = true;
115  m_filter.pads = true;
116  m_filter.graphics = true;
117  m_filter.zones = true;
118  m_filter.keepouts = true;
119  m_filter.dimensions = true;
120  m_filter.otherItems = true;
121 }
bool otherItems
Anything not fitting one of the above categories.
PCB_BASE_FRAME * m_frame
bool text
Text (free or attached to a footprint)
#define NULL
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:78
std::unique_ptr< PRIV > m_priv
bool lockedItems
Allow selecting locked items.

References 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 124 of file pcb_selection_tool.cpp.

125 {
126  getView()->Remove( &m_selection );
128 }
virtual void Remove(VIEW_ITEM *aItem)
Remove a VIEW_ITEM from the view.
Definition: view.cpp:351
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, 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:215
TOOL_ID m_toolId
Name of the tool.
Definition: tool_base.h:210
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(), BOARD_INSPECTION_TOOL::HighlightNetTool(), ROUTER_TOOL::InlineBreakTrack(), ROUTER_TOOL::InlineDrag(), BOARD_INSPECTION_TOOL::LocalRatsnestTool(), 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(), 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(), SCH_DRAWING_TOOLS::PlaceComponent(), BOARD_EDITOR_CONTROL::PlaceFootprint(), SCH_DRAWING_TOOLS::PlaceImage(), DRAWING_TOOL::PlaceImportedGraphics(), PL_DRAWING_TOOLS::PlaceItem(), 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 988 of file pcb_selection_tool.cpp.

989 {
990  if( aItem )
991  {
992  select( aItem );
993 
994  // Inform other potentially interested tools
995  if( !aQuietMode )
997  }
998 }
static const TOOL_EVENT SelectedEvent
Definition: actions.h:209
void select(BOARD_ITEM *aItem)
Take necessary action mark an item as selected.
TOOL_MANAGER * m_toolMgr
Definition: tool_base.h:215
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:215

References TOOL_BASE::m_toolMgr.

Referenced by TOOL_MANAGER::RegisterTool().

◆ board()

BOARD* PCB_TOOL_BASE::board ( ) const
inlineprotectedinherited

Definition at line 160 of file pcb_tool_base.h.

160 { 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(), ZONE_FILLER_TOOL::FillAllZones(), EDIT_TOOL::FilletTracks(), filterSelection(), PCB_TOOL_BASE::footprint(), GetBoard(), getCollectorsGuide(), GROUP_TOOL::Group(), ROUTER_TOOL::handleLayerSwitch(), BOARD_INSPECTION_TOOL::highlightNet(), 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(), EDIT_TOOL::Remove(), BOARD_EDITOR_CONTROL::RepairBoard(), PNS::TOOL_BASE::Reset(), PCB_CONTROL::Reset(), Selectable(), selectAllItemsOnNet(), selectAllItemsOnSheet(), selectConnectedTracks(), selectionContains(), selectPoint(), PCB_CONTROL::TrackDisplayMode(), GROUP_TOOL::Ungroup(), 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 1037 of file pcb_selection_tool.cpp.

1038 {
1039  highlight( aItem, BRIGHTENED );
1040 }
void highlight(BOARD_ITEM *aItem, int aHighlightMode, PCB_SELECTION *aGroup=nullptr)
Highlight the item visually.
#define BRIGHTENED
item is drawn with a bright contour
Definition: eda_item.h:130

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 1684 of file pcb_selection_tool.cpp.

1685 {
1686  if( m_selection.Empty() )
1687  return;
1688 
1689  while( m_selection.GetSize() )
1690  unhighlight( static_cast<BOARD_ITEM*>( m_selection.Front() ), SELECTED, &m_selection );
1691 
1692  view()->Update( &m_selection );
1693 
1694  m_selection.SetIsHover( false );
1696 
1697  // Inform other potentially interested tools
1698  if( !aQuietMode )
1699  {
1702  }
1703 }
void ClearReferencePoint()
Definition: selection.h:269
TOOL_MANAGER * m_toolMgr
Definition: tool_base.h:215
bool RunAction(const std::string &aActionName, bool aNow=false, T aParam=NULL)
Run the specified action.
Definition: tool_manager.h:141
void SetIsHover(bool aIsHover)
Definition: selection.h:67
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).
#define SELECTED
Definition: eda_item.h:113
KIGFX::PCB_VIEW * view() const
static const TOOL_EVENT ClearedEvent
Selected item had a property changed (except movement)
Definition: actions.h:211
PCB_SELECTION m_selection
static TOOL_ACTION hideDynamicRatsnest
Definition: pcb_actions.h:456
bool Empty() const
Checks if there is anything selected.
Definition: selection.h:122
virtual unsigned int GetSize() const override
Return the number of stored items.
Definition: selection.h:101
void unhighlight(BOARD_ITEM *aItem, int aHighlightMode, PCB_SELECTION *aGroup=nullptr)
Unhighlight the item visually.
EDA_ITEM * Front() const
Definition: selection.h:203

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 917 of file pcb_selection_tool.cpp.

918 {
920 
921  selectCursor( false, aClientFilter );
922 
923  return 0;
924 }
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:443
bool selectCursor(bool aForceSelect=false, CLIENT_SELECTION_FILTER aClientFilter=NULL)
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().

◆ displayOptions()

const PCB_DISPLAY_OPTIONS & PCB_TOOL_BASE::displayOptions ( ) const
protectedinherited

Definition at line 290 of file pcb_tool_base.cpp.

291 {
292  return frame()->GetDisplayOptions();
293 }
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 35 of file pcb_tool_base.cpp.

38 {
39  using namespace std::placeholders;
40  std::unique_ptr<BOARD_ITEM> newItem;
41 
42  frame()->PushTool( aTool );
43  Activate();
44 
45  BOARD_COMMIT commit( frame() );
46 
48 
49  // do not capture or auto-pan until we start placing an item
50  controls()->ShowCursor( true );
51 
52  // Add a VIEW_GROUP that serves as a preview for the new item
53  PCB_SELECTION preview;
54  view()->Add( &preview );
55 
56  aPlacer->m_board = board();
57  aPlacer->m_frame = frame();
58  aPlacer->m_modifiers = 0;
59 
60  auto makeNewItem =
61  [&]( VECTOR2I aPosition )
62  {
63  if( frame()->GetModel() )
64  newItem = aPlacer->CreateItem();
65 
66  if( newItem )
67  {
68  newItem->SetPosition( (wxPoint) aPosition );
69  preview.Add( newItem.get() );
70 
71  if( newItem->Type() == PCB_FOOTPRINT_T )
72  {
73  FOOTPRINT* fp = dyn_cast<FOOTPRINT*>( newItem.get() );
74 
75  // footprints have more drawable parts
76  fp->RunOnChildren( std::bind( &KIGFX::VIEW_GROUP::Add, &preview, _1 ) );
77  }
78  }
79  };
80 
81  if( aOptions & IPO_SINGLE_CLICK )
82  makeNewItem( controls()->GetCursorPosition() );
83 
84  auto setCursor =
85  [&]()
86  {
87  if( !newItem )
89  else
91  };
92 
93  // Set initial cursor
94  setCursor();
95 
96  // Main loop: keep receiving events
97  while( TOOL_EVENT* evt = Wait() )
98  {
99  setCursor();
100 
101  VECTOR2I cursorPos = controls()->GetCursorPosition();
102  aPlacer->m_modifiers = evt->Modifier();
103 
104  auto cleanup =
105  [&] ()
106  {
107  newItem = nullptr;
108  preview.Clear();
109  view()->Update( &preview );
110  controls()->SetAutoPan( false );
111  controls()->CaptureCursor( false );
112  controls()->ShowCursor( true );
113  };
114 
115  if( evt->IsCancelInteractive() )
116  {
117  if( aOptions & IPO_SINGLE_CLICK )
118  {
119  cleanup();
120  frame()->PopTool( aTool );
121  break;
122  }
123  else if( newItem )
124  cleanup();
125  else
126  {
127  frame()->PopTool( aTool );
128  break;
129  }
130  }
131  else if( evt->IsActivate() )
132  {
133  if( newItem )
134  cleanup();
135 
136  if( evt->IsPointEditor() )
137  {
138  // don't exit (the point editor runs in the background)
139  }
140  else if( evt->IsMoveTool() )
141  {
142  // leave ourselves on the stack so we come back after the move
143  break;
144  }
145  else
146  {
147  frame()->PopTool( aTool );
148  break;
149  }
150  }
151  else if( evt->IsClick( BUT_LEFT ) || evt->IsDblClick( BUT_LEFT ) )
152  {
153  if( !newItem )
154  {
155  // create the item if possible
156  makeNewItem( cursorPos );
157 
158  // no item created, so wait for another click
159  if( !newItem )
160  continue;
161 
162  controls()->CaptureCursor( true );
163  controls()->SetAutoPan( true );
164  }
165  else
166  {
167  auto oldFlags = newItem->GetFlags();
168  newItem->ClearFlags();
169 
170  if( !aPlacer->PlaceItem( newItem.get(), commit ) )
171  {
172  newItem->SetFlags( oldFlags );
173  continue;
174  }
175 
176  preview.Clear();
177  newItem.release();
178  commit.Push( aCommitMessage );
179 
180  controls()->CaptureCursor( false );
181  controls()->SetAutoPan( false );
182  controls()->ShowCursor( true );
183 
184  if( !( aOptions & IPO_REPEAT ) )
185  break;
186 
187  if( aOptions & IPO_SINGLE_CLICK )
188  makeNewItem( controls()->GetCursorPosition() );
189 
190  setCursor();
191  }
192  }
193  else if( evt->IsClick( BUT_RIGHT ) )
194  {
196  }
197  else if( evt->IsAction( &PCB_ACTIONS::trackViaSizeChanged ) )
198  {
200  }
201  else if( newItem && evt->Category() == TC_COMMAND )
202  {
203  /*
204  * Handle any events that can affect the item as we move it around
205  */
206  if( TOOL_EVT_UTILS::IsRotateToolEvt( *evt ) && ( aOptions & IPO_ROTATE ) )
207  {
208  const int rotationAngle = TOOL_EVT_UTILS::GetEventRotationAngle( *frame(), *evt );
209  newItem->Rotate( newItem->GetPosition(), rotationAngle );
210  view()->Update( &preview );
211  }
212  else if( evt->IsAction( &PCB_ACTIONS::flip ) && ( aOptions & IPO_FLIP ) )
213  {
214  newItem->Flip( newItem->GetPosition(), frame()->Settings().m_FlipLeftRight );
215  view()->Update( &preview );
216  }
217  else if( evt->IsAction( &PCB_ACTIONS::viaSizeInc )
218  || evt->IsAction( &PCB_ACTIONS::viaSizeDec ) )
219  {
220  // Refresh preview after event runs
222  }
223  else if( evt->IsAction( &PCB_ACTIONS::properties ) )
224  {
225  frame()->OnEditItemRequest( newItem.get() );
226 
227  // Notify other tools of the changes
229  }
230  else if( evt->IsAction( &ACTIONS::refreshPreview ) )
231  {
232  preview.Clear();
233  newItem.release();
234 
235  makeNewItem( (wxPoint) cursorPos );
236  aPlacer->SnapItem( newItem.get() );
237  view()->Update( &preview );
238  }
239  else
240  {
241  evt->SetPassEvent();
242  }
243  }
244  else if( newItem && evt->IsMotion() )
245  {
246  // track the cursor
247  newItem->SetPosition( (wxPoint) cursorPos );
248  aPlacer->SnapItem( newItem.get() );
249 
250  // Show a preview of the item
251  view()->Update( &preview );
252  }
253  else
254  {
255  evt->SetPassEvent();
256  }
257  }
258 
259  view()->Remove( &preview );
261 }
static TOOL_ACTION selectionClear
Clear the current selection.
Definition: pcb_actions.h:63
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:96
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
static TOOL_ACTION viaSizeInc
Definition: pcb_actions.h:300
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:215
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:121
bool RunAction(const std::string &aActionName, bool aNow=false, T aParam=NULL)
Run the specified action.
Definition: tool_manager.h:141
static TOOL_ACTION trackViaSizeChanged
Definition: pcb_actions.h:303
bool IsRotateToolEvt(const TOOL_EVENT &aEvt)
Function isRotateToolEvt()
void SetCurrentCursor(KICURSOR cursor)
Set the current cursor shape for this panel.
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:214
virtual void Add(EDA_ITEM *aItem)
Definition: selection.h:77
TOOL_MANAGER * GetManager() const
Return the instance of TOOL_MANAGER that takes care of the tool.
Definition: tool_base.h:144
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:173
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
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:109
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:1174
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:65
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:301
static TOOL_ACTION refreshPreview
Definition: actions.h:109
VECTOR2D GetCursorPosition() const
Return the current cursor position in world coordinates.

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(), KIGFX::VIEW_CONTROLS::GetCursorPosition(), TOOL_EVT_UTILS::GetEventRotationAngle(), TOOL_BASE::GetManager(), PCB_BASE_FRAME::GetModel(), 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 1760 of file pcb_selection_tool.cpp.

1761 {
1762  BOARD_ITEM* current = nullptr;
1763  PCB_SELECTION highlightGroup;
1764  bool selectAll = false;
1765  bool expandSelection = false;
1766 
1767  highlightGroup.SetLayer( LAYER_SELECT_OVERLAY );
1768  getView()->Add( &highlightGroup );
1769 
1770  do
1771  {
1773  if( expandSelection )
1774  aCollector->Combine();
1775 
1776  expandSelection = false;
1777 
1778  int limit = std::min( 9, aCollector->GetCount() );
1779  ACTION_MENU menu( true );
1780 
1781  for( int i = 0; i < limit; ++i )
1782  {
1783  wxString text;
1784  BOARD_ITEM* item = ( *aCollector )[i];
1785  text = item->GetSelectMenuText( m_frame->GetUserUnits() );
1786 
1787  wxString menuText = wxString::Format( "&%d. %s\t%d", i + 1, text, i + 1 );
1788  menu.Add( menuText, i + 1, item->GetMenuImage() );
1789  }
1790 
1791  menu.AppendSeparator();
1792  menu.Add( _( "Select &All\tA" ), limit + 1, nullptr );
1793 
1794  if( !expandSelection && aCollector->HasAdditionalItems() )
1795  menu.Add( _( "&Expand Selection\tE" ), limit + 2, nullptr );
1796 
1797  if( aCollector->m_MenuTitle.Length() )
1798  {
1799  menu.SetTitle( aCollector->m_MenuTitle );
1800  menu.SetIcon( info_xpm );
1801  menu.DisplayTitle( true );
1802  }
1803  else
1804  {
1805  menu.DisplayTitle( false );
1806  }
1807 
1808  SetContextMenu( &menu, CMENU_NOW );
1809 
1810  while( TOOL_EVENT* evt = Wait() )
1811  {
1812  if( evt->Action() == TA_CHOICE_MENU_UPDATE )
1813  {
1814  if( selectAll )
1815  {
1816  for( int i = 0; i < aCollector->GetCount(); ++i )
1817  unhighlight( ( *aCollector )[i], BRIGHTENED, &highlightGroup );
1818  }
1819  else if( current )
1820  unhighlight( current, BRIGHTENED, &highlightGroup );
1821 
1822  int id = *evt->GetCommandId();
1823 
1824  // User has pointed an item, so show it in a different way
1825  if( id > 0 && id <= limit )
1826  {
1827  current = ( *aCollector )[id - 1];
1828  highlight( current, BRIGHTENED, &highlightGroup );
1829  }
1830  else
1831  current = nullptr;
1832 
1833  // User has pointed on the "Select All" option
1834  if( id == limit + 1 )
1835  {
1836  for( int i = 0; i < aCollector->GetCount(); ++i )
1837  highlight( ( *aCollector )[i], BRIGHTENED, &highlightGroup );
1838  selectAll = true;
1839  }
1840  else
1841  selectAll = false;
1842  }
1843  else if( evt->Action() == TA_CHOICE_MENU_CHOICE )
1844  {
1845  if( selectAll )
1846  {
1847  for( int i = 0; i < aCollector->GetCount(); ++i )
1848  unhighlight( ( *aCollector )[i], BRIGHTENED, &highlightGroup );
1849  }
1850  else if( current )
1851  unhighlight( current, BRIGHTENED, &highlightGroup );
1852 
1853  OPT<int> id = evt->GetCommandId();
1854 
1855  // User has selected the "Select All" option
1856  if( id == limit + 1 )
1857  {
1858  selectAll = true;
1859  current = nullptr;
1860  }
1861  else if( id == limit + 2 )
1862  {
1863  expandSelection = true;
1864  selectAll = false;
1865  current = nullptr;
1866  }
1867  // User has selected an item, so this one will be returned
1868  else if( id && ( *id > 0 ) && ( *id <= limit ) )
1869  {
1870  selectAll = false;
1871  current = ( *aCollector )[*id - 1];
1872  }
1873  else
1874  {
1875  selectAll = false;
1876  current = nullptr;
1877  }
1878  }
1879  else if( evt->Action() == TA_CHOICE_MENU_CLOSED )
1880  {
1881  break;
1882  }
1883  }
1884  } while( expandSelection );
1885 
1886  getView()->Remove( &highlightGroup );
1887 
1888  if( selectAll )
1889  return true;
1890  else if( current )
1891  {
1892  aCollector->Empty();
1893  aCollector->Append( current );
1894  return true;
1895  }
1896 
1897  return false;
1898 }
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:45
A base class for any item which can be embedded within the BOARD container class, and therefore insta...
Definition: board_item.h:82
virtual void Remove(VIEW_ITEM *aItem)
Remove a VIEW_ITEM from the view.
Definition: view.cpp:351
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
#define BRIGHTENED
item is drawn with a bright contour
Definition: eda_item.h:130
Generic, UI-independent tool event.
Definition: tool_event.h:173
const BITMAP_OPAQUE info_xpm[1]
Definition: info.cpp:36
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
#define _(s)
Definition: 3d_actions.cpp:33
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:123
currently selected items overlay
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:321
virtual BITMAP_DEF GetMenuImage() const
Return a pointer to an image to be used in menus.
Definition: eda_item.cpp:222
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.

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_xpm, 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, unhighlight(), and TOOL_INTERACTIVE::Wait().

Referenced by SelectionMenu(), and selectPoint().

◆ EnterGroup()

void PCB_SELECTION_TOOL::EnterGroup ( )

Definition at line 475 of file pcb_selection_tool.cpp.

476 {
477  wxCHECK_RET( m_selection.GetSize() == 1 && m_selection[0]->Type() == PCB_GROUP_T,
478  "EnterGroup called when selection is not a single group" );
479  PCB_GROUP* aGroup = static_cast<PCB_GROUP*>( m_selection[0] );
480 
481  if( m_enteredGroup != NULL )
482  ExitGroup();
483 
484  ClearSelection();
485  m_enteredGroup = aGroup;
487  m_enteredGroup->RunOnChildren( [&]( BOARD_ITEM* titem )
488  {
489  select( titem );
490  } );
491 
493 }
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:82
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(STATUS_FLAGS aMask)
Definition: eda_item.h:202
#define NULL
KIGFX::VIEW_GROUP m_enteredGroupOverlay
#define ENTERED
indicates a group has been entered
Definition: eda_item.h:137
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:101
void RunOnChildren(const std::function< void(BOARD_ITEM *)> &aFunction) const
Invoke a function on all members of the group.
Definition: pcb_group.cpp:310
int ClearSelection(const TOOL_EVENT &aEvent)

References KIGFX::VIEW_GROUP::Add(), ClearSelection(), ENTERED, ExitGroup(), SELECTION::GetSize(), m_enteredGroup, m_enteredGroupOverlay, m_selection, NULL, 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 496 of file pcb_selection_tool.cpp.

497 {
498  // Only continue if there is a group entered
499  if( m_enteredGroup == nullptr )
500  return;
501 
503  ClearSelection();
504 
505  if( aSelectGroup )
507 
509  m_enteredGroup = nullptr;
510 }
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
#define ENTERED
indicates a group has been entered
Definition: eda_item.h:137
void ClearFlags(STATUS_FLAGS aMask=EDA_ITEM_ALL_FLAGS)
Definition: eda_item.h:203
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 1069 of file pcb_selection_tool.cpp.

1070 {
1071  unsigned initialCount = 0;
1072 
1073  for( auto item : m_selection.GetItems() )
1074  {
1075  if( dynamic_cast<BOARD_CONNECTED_ITEM*>( item ) )
1076  initialCount++;
1077  }
1078 
1079  if( initialCount == 0 )
1081 
1082  for( STOP_CONDITION stopCondition : { STOP_AT_JUNCTION, STOP_AT_PAD, STOP_NEVER } )
1083  {
1084  // copy the selection, since we're going to iterate and modify
1085  std::deque<EDA_ITEM*> selectedItems = m_selection.GetItems();
1086 
1087  for( EDA_ITEM* item : selectedItems )
1088  item->ClearTempFlags();
1089 
1090  for( EDA_ITEM* item : selectedItems )
1091  {
1092  TRACK* trackItem = dynamic_cast<TRACK*>( item );
1093 
1094  // Track items marked SKIP_STRUCT have already been visited
1095  if( trackItem && !( trackItem->GetFlags() & SKIP_STRUCT ) )
1096  selectConnectedTracks( *trackItem, stopCondition );
1097  }
1098 
1099  if( m_selection.GetItems().size() > initialCount )
1100  break;
1101  }
1102 
1103  // Inform other potentially interested tools
1104  if( m_selection.Size() > 0 )
1106 
1107  return 0;
1108 }
static const TOOL_EVENT SelectedEvent
Definition: actions.h:209
Stop at any place where more than two traces meet.
TOOL_MANAGER * m_toolMgr
Definition: tool_base.h:215
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:133
PCB_SELECTION m_selection
bool selectCursor(bool aForceSelect=false, CLIENT_SELECTION_FILTER aClientFilter=NULL)
Select an item under the cursor unless there is something already selected or aSelectAlways is true.
int Size() const
Returns the number of selected parts.
Definition: selection.h:128
A base class for most all the KiCad significant classes used in schematics and boards.
Definition: eda_item.h:149
#define SKIP_STRUCT
flag indicating that the structure should be ignored
Definition: eda_item.h:117
STATUS_FLAGS GetFlags() const
Definition: eda_item.h:204
Definition: track.h:83

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 1586 of file pcb_selection_tool.cpp.

1587 {
1588  if( aCollector.GetCount() == 0 )
1589  return;
1590 
1591  std::set<BOARD_ITEM*> rejected;
1592 
1593  for( EDA_ITEM* i : aCollector )
1594  {
1595  BOARD_ITEM* item = static_cast<BOARD_ITEM*>( i );
1596 
1597  if( !itemPassesFilter( item ) )
1598  rejected.insert( item );
1599  }
1600 
1601  for( BOARD_ITEM* item : rejected )
1602  aCollector.Remove( item );
1603 }
A base class for any item which can be embedded within the BOARD container class, and therefore insta...
Definition: board_item.h:82
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:149
bool itemPassesFilter(BOARD_ITEM *aItem)

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

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

◆ FilterCollectorForGroups()

void PCB_SELECTION_TOOL::FilterCollectorForGroups ( GENERAL_COLLECTOR aCollector) const

Definition at line 2491 of file pcb_selection_tool.cpp.

2492 {
2493  std::unordered_set<BOARD_ITEM*> toAdd;
2494 
2495  // If any element is a member of a group, replace those elements with the top containing group.
2496  for( int j = 0; j < aCollector.GetCount(); )
2497  {
2498  BOARD_ITEM* item = aCollector[j];
2499  BOARD_ITEM* parent = item->GetParent();
2500 
2501  // Ignore footprint groups in board editor
2502  if( !m_isFootprintEditor && parent && parent->Type() == PCB_FOOTPRINT_T )
2503  {
2504  ++j;
2505  continue;
2506  }
2507 
2509 
2510  if( aTop )
2511  {
2512  if( aTop != item )
2513  {
2514  toAdd.insert( aTop );
2515  aCollector.Remove( item );
2516  continue;
2517  }
2518  }
2519  else if( m_enteredGroup && !PCB_GROUP::WithinScope( item, m_enteredGroup ) )
2520  {
2521  // If a group is entered, disallow selections of objects outside the group.
2522  aCollector.Remove( item );
2523  continue;
2524  }
2525 
2526  ++j;
2527  }
2528 
2529  for( BOARD_ITEM* item : toAdd )
2530  {
2531  if( !aCollector.HasItem( item ) )
2532  aCollector.Append( item );
2533  }
2534 }
static bool WithinScope(BOARD_ITEM *item, PCB_GROUP *scope)
Definition: pcb_group.cpp:93
A base class for any item which can be embedded within the BOARD container class, and therefore insta...
Definition: board_item.h:82
A set of BOARD_ITEMs (i.e., without duplicates).
Definition: pcb_group.h:50
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
static PCB_GROUP * TopLevelGroup(BOARD_ITEM *aItem, PCB_GROUP *aScope, bool aFootprintEditor)
Definition: pcb_group.cpp:72
bool HasItem(const EDA_ITEM *aItem) const
Tests if aItem has already been collected.
Definition: collector.h:203
bool m_isFootprintEditor
class FOOTPRINT, a footprint
Definition: typeinfo.h:88
BOARD_ITEM_CONTAINER * GetParent() const
Definition: board_item.h:168
KICAD_T Type() const
Returns the type of object.
Definition: eda_item.h:162

References COLLECTOR::Append(), COLLECTOR::GetCount(), BOARD_ITEM::GetParent(), COLLECTOR::HasItem(), m_enteredGroup, PCB_TOOL_BASE::m_isFootprintEditor, PCB_FOOTPRINT_T, COLLECTOR::Remove(), 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(), 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 1554 of file pcb_selection_tool.cpp.

1555 {
1556  const BOARD& board = *getModel<BOARD>();
1557  DIALOG_FILTER_SELECTION::OPTIONS& opts = m_priv->m_filterOpts;
1558  DIALOG_FILTER_SELECTION dlg( m_frame, opts );
1559 
1560  const int cmd = dlg.ShowModal();
1561 
1562  if( cmd != wxID_OK )
1563  return 0;
1564 
1565  // copy current selection
1566  std::deque<EDA_ITEM*> selection = m_selection.GetItems();
1567 
1568  ClearSelection( true /*quiet mode*/ );
1569 
1570  // re-select items from the saved selection according to the dialog options
1571  for( EDA_ITEM* i : selection )
1572  {
1573  BOARD_ITEM* item = static_cast<BOARD_ITEM*>( i );
1574  bool include = itemIsIncludedByFilter( *item, board, opts );
1575 
1576  if( include )
1577  select( item );
1578  }
1579 
1581 
1582  return 0;
1583 }
static const TOOL_EVENT SelectedEvent
Definition: actions.h:209
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:82
TOOL_MANAGER * m_toolMgr
Definition: tool_base.h:215
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)
Function itemIsIncludedByFilter()
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:133
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:149
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().

◆ find()

int PCB_SELECTION_TOOL::find ( const TOOL_EVENT aEvent)
private

Invoke filter dialog and modify current selection.

Definition at line 1476 of file pcb_selection_tool.cpp.

1477 {
1478  DIALOG_FIND dlg( m_frame );
1479  dlg.SetCallback( std::bind( &PCB_SELECTION_TOOL::findCallback, this, _1 ) );
1480  dlg.ShowModal();
1481 
1482  return 0;
1483 }
PCB_BASE_FRAME * m_frame
void findCallback(BOARD_ITEM *aItem)
Find an item.

References findCallback(), m_frame, and DIALOG_FIND::SetCallback().

Referenced by setTransitions().

◆ findCallback()

void PCB_SELECTION_TOOL::findCallback ( BOARD_ITEM aItem)
private

Find an item.

Definition at line 1447 of file pcb_selection_tool.cpp.

1448 {
1449  bool cleared = false;
1450 
1451  if( m_selection.GetSize() > 0 )
1452  {
1453  // Don't fire an event now; most of the time it will be redundant as we're about to
1454  // fire a SelectedEvent.
1455  cleared = true;
1456  ClearSelection( true /*quiet mode*/ );
1457  }
1458 
1459  if( aItem )
1460  {
1461  select( aItem );
1462  m_frame->FocusOnLocation( aItem->GetPosition() );
1463 
1464  // Inform other potentially interested tools
1466  }
1467  else if( cleared )
1468  {
1470  }
1471 
1473 }
static const TOOL_EVENT SelectedEvent
Definition: actions.h:209
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:215
virtual wxPoint GetPosition() const
Definition: eda_item.h:301
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:211
PCB_SELECTION m_selection
virtual unsigned int GetSize() const override
Return the number of stored items.
Definition: selection.h:101
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 find().

◆ footprint()

◆ frame()

PCB_BASE_EDIT_FRAME* PCB_TOOL_BASE::frame ( ) const
inlineprotectedinherited

Definition at line 155 of file pcb_tool_base.h.

156  {
157  return getEditFrame<PCB_BASE_EDIT_FRAME>();
158  }

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(), ROUTER_TOOL::CustomTrackWidthDialog(), FOOTPRINT_EDITOR_CONTROL::DeleteFootprint(), PCB_TOOL_BASE::displayOptions(), PCB_TOOL_BASE::doInteractiveItemPlacement(), ROUTER_TOOL::DpDimensionsDialog(), 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(), FOOTPRINT_EDITOR_CONTROL::ImportFootprint(), BOARD_EDITOR_CONTROL::ImportSpecctraSession(), ROUTER_TOOL::Init(), Init(), EDIT_TOOL::Init(), ROUTER_TOOL::InlineBreakTrack(), ROUTER_TOOL::InlineDrag(), 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(), 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(), BOARD_EDITOR_CONTROL::UpdateSchematicFromPCB(), ZONE_FILLER_TOOL::ZoneFill(), and ZONE_FILLER_TOOL::ZoneFillAll().

◆ GetBoard()

BOARD* PCB_SELECTION_TOOL::GetBoard ( ) const
inline

Definition at line 173 of file pcb_selection_tool.h.

174  {
175  return board();
176  }
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 646 of file pcb_selection_tool.cpp.

647 {
648  GENERAL_COLLECTORS_GUIDE guide( board()->GetVisibleLayers(),
649  (PCB_LAYER_ID) view()->GetTopLayer(), view() );
650 
651  bool padsDisabled = !board()->IsElementVisible( LAYER_PADS );
652 
653  // account for the globals
654  guide.SetIgnoreMTextsMarkedNoShow( ! board()->IsElementVisible( LAYER_MOD_TEXT_INVISIBLE ) );
655  guide.SetIgnoreMTextsOnBack( ! board()->IsElementVisible( LAYER_MOD_TEXT_BK ) );
656  guide.SetIgnoreMTextsOnFront( ! board()->IsElementVisible( LAYER_MOD_TEXT_FR ) );
657  guide.SetIgnoreModulesOnBack( ! board()->IsElementVisible( LAYER_MOD_BK ) );
658  guide.SetIgnoreModulesOnFront( ! board()->IsElementVisible( LAYER_MOD_FR ) );
659  guide.SetIgnorePadsOnBack( padsDisabled || ! board()->IsElementVisible( LAYER_PAD_BK ) );
660  guide.SetIgnorePadsOnFront( padsDisabled || ! board()->IsElementVisible( LAYER_PAD_FR ) );
661  guide.SetIgnoreThroughHolePads( padsDisabled || ! board()->IsElementVisible( LAYER_PADS_TH ) );
662  guide.SetIgnoreModulesVals( ! board()->IsElementVisible( LAYER_MOD_VALUES ) );
663  guide.SetIgnoreModulesRefs( ! board()->IsElementVisible( LAYER_MOD_REFERENCES ) );
664  guide.SetIgnoreThroughVias( ! board()->IsElementVisible( LAYER_VIAS ) );
665  guide.SetIgnoreBlindBuriedVias( ! board()->IsElementVisible( LAYER_VIAS ) );
666  guide.SetIgnoreMicroVias( ! board()->IsElementVisible( LAYER_VIAS ) );
667  guide.SetIgnoreTracks( ! board()->IsElementVisible( LAYER_TRACKS ) );
668 
669  return guide;
670 }
BOARD * board() const
multilayer pads, usually with holes
show footprints on back
show footprints values (when texts are visibles)
show footprints on front
PCB_LAYER_ID
A quick note on layer IDs:
Meta control for all pads opacity/visibility (color ignored)
KIGFX::PCB_VIEW * view() const
bool IsElementVisible(GAL_LAYER_ID aLayer) const
Test whether a given element category is visible.
Definition: board.cpp:507
smd pads, front layer
Meta control for all vias opacity/visibility.
A general implementation of a COLLECTORS_GUIDE.
Definition: collectors.h:381
show footprints references (when texts are visibles)

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 185 of file tool_base.h.

186  {
187 #if !defined( QA_TEST ) // Dynamic casts give the linker a siezure in the test framework
188  wxASSERT( dynamic_cast<T*>( getToolHolderInt() ) );
189 #endif
190  return static_cast<T*>( getToolHolderInt() );
191  }
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

Apply the SELECTION_FILTER_OPTIONS to a collection of items.

Definition at line 189 of file pcb_selection_tool.h.

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 121 of file tool_base.h.

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

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 144 of file tool_base.h.

145  {
146  return m_toolMgr;
147  }
TOOL_MANAGER * m_toolMgr
Definition: tool_base.h:215

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 197 of file tool_base.h.

References TOOL_BASE::getModelInt().

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

◆ 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 134 of file tool_base.h.

135  {
136  return m_toolName;
137  }
std::string m_toolName
Definition: tool_base.h:214

References TOOL_BASE::m_toolName.

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

◆ 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 109 of file tool_base.h.

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

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:289
TOOL_MANAGER * m_toolMgr
Definition: tool_base.h:215

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(), 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(), 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::FindComponentAndItem(), 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(), 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(), PL_EDIT_TOOL::Paste(), SYMBOL_EDITOR_EDIT_TOOL::Paste(), SCH_EDITOR_CONTROL::Paste(), PNS::TOOL_BASE::pickSingleItem(), BOARD_EDITOR_CONTROL::PlaceFootprint(), PL_DRAWING_TOOLS::PlaceItem(), BOARD_EDITOR_CONTROL::PlaceTarget(), 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:215
KIGFX::VIEW_CONTROLS * GetViewControls() const
Definition: tool_manager.h:291

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(), BOARD_INSPECTION_TOOL::HighlightNet(), SCH_EDITOR_CONTROL::HighlightNet(), BOARD_INSPECTION_TOOL::HighlightNetTool(), FOOTPRINT_EDITOR_CONTROL::ImportFootprint(), 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(), SCH_DRAWING_TOOLS::PlaceComponent(), BOARD_EDITOR_CONTROL::PlaceFootprint(), SCH_DRAWING_TOOLS::PlaceImage(), PL_DRAWING_TOOLS::PlaceItem(), 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(), 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 128 of file tool_interactive.h.

130 {
131  TOOL_STATE_FUNC sptr = std::bind( aStateFunc, static_cast<T*>( this ), std::placeholders::_1 );
132 
133  goInternal( sptr, aConditions );
134 }
std::function< int(const TOOL_EVENT &)> TOOL_STATE_FUNC
Definition: tool_base.h:59
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(), COMMON_CONTROL::setTransitions(), KICAD_MANAGER_CONTROL::setTransitions(), ZONE_FILLER_TOOL::setTransitions(), CONVERT_TOOL::setTransitions(), SYMBOL_EDITOR_DRAWING_TOOLS::setTransitions(), MICROWAVE_TOOL::setTransitions(), PCB_VIEWER_TOOLS::setTransitions(), PAD_TOOL::setTransitions(), EE_INSPECTION_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_DRAWING_TOOLS::setTransitions(), SCH_MOVE_TOOL::setTransitions(), PL_EDIT_TOOL::setTransitions(), POSITION_RELATIVE_TOOL::setTransitions(), GERBVIEW_SELECTION_TOOL::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_EDITOR_CONTROL::setTransitions(), BOARD_INSPECTION_TOOL::setTransitions(), PICKER_TOOL::setTransitions(), EDIT_TOOL::setTransitions(), setTransitions(), DRAWING_TOOL::setTransitions(), PL_SELECTION_TOOL::setTransitions(), SCH_EDITOR_CONTROL::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 2344 of file pcb_selection_tool.cpp.

2346 {
2347  std::set<BOARD_ITEM*> preferred;
2348  std::set<BOARD_ITEM*> rejected;
2349  wxPoint where( aWhere.x, aWhere.y );
2350 
2351  PCB_LAYER_ID activeLayer = (PCB_LAYER_ID) view()->GetTopLayer();
2352  LSET silkLayers( 2, B_SilkS, F_SilkS );
2353 
2354  if( silkLayers[activeLayer] )
2355  {
2356  for( int i = 0; i < aCollector.GetCount(); ++i )
2357  {
2358  BOARD_ITEM* item = aCollector[i];
2359  KICAD_T type = item->Type();
2360 
2361  if( ( type == PCB_FP_TEXT_T || type == PCB_TEXT_T || type == PCB_SHAPE_T )
2362  && silkLayers[item->GetLayer()] )
2363  {
2364  preferred.insert( item );
2365  }
2366  }
2367 
2368  if( preferred.size() > 0 )
2369  {
2370  aCollector.Empty();
2371 
2372  for( BOARD_ITEM* item : preferred )
2373  aCollector.Append( item );
2374 
2375  return;
2376  }
2377  }
2378 
2379  // Prefer exact hits to sloppy ones
2380 
2381  constexpr int MAX_SLOP = 5;
2382 
2383  int pixel = (int) aCollector.GetGuide()->OnePixelInIU();
2384  int minSlop = INT_MAX;
2385 
2386  std::map<BOARD_ITEM*, int> itemsBySloppiness;
2387 
2388  for( int i = 0; i < aCollector.GetCount(); ++i )
2389  {
2390  BOARD_ITEM* item = aCollector[i];
2391  int itemSlop = hitTestDistance( where, item, MAX_SLOP * pixel );
2392 
2393  itemsBySloppiness[ item ] = itemSlop;
2394 
2395  if( itemSlop < minSlop )
2396  minSlop = itemSlop;
2397  }
2398 
2399  // Prune sloppier items
2400 
2401  if( minSlop < INT_MAX )
2402  {
2403  for( std::pair<BOARD_ITEM*, int> pair : itemsBySloppiness )
2404  {
2405  if( pair.second > minSlop + pixel )
2406  aCollector.Transfer( pair.first );
2407  }
2408  }
2409 
2410  // If the user clicked on a small item within a much larger one then it's pretty clear
2411  // they're trying to select the smaller one.
2412 
2413  constexpr double sizeRatio = 1.3;
2414 
2415  std::vector<std::pair<BOARD_ITEM*, double>> itemsByArea;
2416 
2417  for( int i = 0; i < aCollector.GetCount(); ++i )
2418  {
2419  BOARD_ITEM* item = aCollector[i];
2420  double area;
2421 
2422  if( item->Type() == PCB_ZONE_T
2423  && static_cast<ZONE*>( item )->HitTestForEdge( where, MAX_SLOP * pixel / 2 ) )
2424  {
2425  // Zone borders are very specific, so make them "small"
2426  area = MAX_SLOP * SEG::Square( pixel );
2427  }
2428  else if( item->Type() == PCB_VIA_T )
2429  {
2430  // Vias rarely hide other things, and we don't want them deferring to short track
2431  // segments -- so make them artificially small by dropping the π from πr².
2432  area = SEG::Square( static_cast<VIA*>( item )->GetDrill() / 2 );
2433  }
2434  else
2435  {
2436  try
2437  {
2438  area = FOOTPRINT::GetCoverageArea( item, aCollector );
2439  }
2440  catch( const ClipperLib::clipperException& e )
2441  {
2442  wxLogError( "A clipper exception %s was detected.", e.what() );
2443  }
2444  }
2445 
2446  itemsByArea.emplace_back( item, area );
2447  }
2448 
2449  std::sort( itemsByArea.begin(), itemsByArea.end(),
2450  []( const std::pair<BOARD_ITEM*, double>& lhs,
2451  const std::pair<BOARD_ITEM*, double>& rhs ) -> bool
2452  {
2453  return lhs.second < rhs.second;
2454  } );
2455 
2456  bool rejecting = false;
2457 
2458  for( int i = 1; i < (int) itemsByArea.size(); ++i )
2459  {
2460  if( itemsByArea[i].second > itemsByArea[i-1].second * sizeRatio )
2461  rejecting = true;
2462 
2463  if( rejecting )
2464  rejected.insert( itemsByArea[i].first );
2465  }
2466 
2467  // Special case: if a footprint is completely covered with other features then there's no
2468  // way to select it -- so we need to leave it in the list for user disambiguation.
2469 
2470  constexpr double maxCoverRatio = 0.70;
2471 
2472  for( int i = 0; i < aCollector.GetCount(); ++i )
2473  {
2474  if( FOOTPRINT* footprint = dynamic_cast<FOOTPRINT*>( aCollector[i] ) )
2475  {
2476  if( footprint->CoverageRatio( aCollector ) > maxCoverRatio )
2477  rejected.erase( footprint );
2478  }
2479  }
2480 
2481  // Hopefully we've now got what the user wanted.
2482 
2483  if( (unsigned) aCollector.GetCount() > rejected.size() ) // do not remove everything
2484  {
2485  for( BOARD_ITEM* item : rejected )
2486  aCollector.Transfer( item );
2487  }
2488 }
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:1733
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:82
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:1781
static SEG::ecoord Square(int a)
Definition: seg.h:123
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
PCB_LAYER_ID
A quick note on layer IDs:
const COLLECTORS_GUIDE * GetGuide() const
Definition: collectors.h:343
LSET is a set of PCB_LAYER_IDs.
virtual int GetTopLayer() const
Definition: view.cpp:823
FOOTPRINT * footprint() const
KIGFX::PCB_VIEW * view() const
class ZONE, a copper pour area
Definition: typeinfo.h:105
int hitTestDistance(const wxPoint &aWhere, BOARD_ITEM *aItem, int aMaxDistance) const
class 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:173
KICAD_T Type() const
Returns the type of object.
Definition: eda_item.h:162

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_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 2137 of file pcb_selection_tool.cpp.

2138 {
2139  if( aGroup )
2140  aGroup->Add( aItem );
2141 
2142  highlightInternal( aItem, aMode, aGroup != nullptr );
2143  view()->Update( aItem, KIGFX::REPAINT );
2144 
2145  // Many selections are very temporal and updating the display each time just
2146  // creates noise.
2147  if( aMode == BRIGHTENED )
2149 }
void highlightInternal(BOARD_ITEM *aItem, int aHighlightMode, bool aUsingOverlay)
virtual void Add(EDA_ITEM *aItem)
Definition: selection.h:77
#define BRIGHTENED
item is drawn with a bright contour
Definition: eda_item.h:130
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:574
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

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 2152 of file pcb_selection_tool.cpp.

2153 {
2154  if( aMode == SELECTED )
2155  aItem->SetSelected();
2156  else if( aMode == BRIGHTENED )
2157  aItem->SetBrightened();
2158 
2159  if( aUsingOverlay )
2160  view()->Hide( aItem, true ); // Hide the original item, so it is shown only on overlay
2161 
2162  if( aItem->Type() == PCB_FOOTPRINT_T )
2163  {
2164  static_cast<FOOTPRINT*>( aItem )->RunOnChildren(
2165  [&]( BOARD_ITEM* aChild )
2166  {
2167  highlightInternal( aChild, aMode, aUsingOverlay );
2168  } );
2169  }
2170  else if( aItem->Type() == PCB_GROUP_T )
2171  {
2172  static_cast<PCB_GROUP*>( aItem )->RunOnChildren(
2173  [&]( BOARD_ITEM* aChild )
2174  {
2175  highlightInternal( aChild, aMode, aUsingOverlay );
2176  } );
2177  }
2178 }
void Hide(VIEW_ITEM *aItem, bool aHide=true)
Temporarily hide the item in the view (e.g.
Definition: view.cpp:1475
A base class for any item which can be embedded within the BOARD container class, and therefore insta...
Definition: board_item.h:82
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:179
#define BRIGHTENED
item is drawn with a bright contour
Definition: eda_item.h:130
void SetSelected()
Definition: eda_item.h:178
#define SELECTED
Definition: eda_item.h:113
KIGFX::PCB_VIEW * view() const
class FOOTPRINT, a footprint
Definition: typeinfo.h:88
KICAD_T Type() const
Returns the type of object.
Definition: eda_item.h:162

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 2251 of file pcb_selection_tool.cpp.

2253 {
2254  BOX2D viewportD = getView()->GetViewport();
2255  BOX2I viewport( VECTOR2I( viewportD.GetPosition() ), VECTOR2I( viewportD.GetSize() ) );
2256  int distance = INT_MAX;
2257  SEG loc( aWhere, aWhere );
2258 
2259  switch( aItem->Type() )
2260  {
2261  case PCB_TEXT_T:
2262  {
2263  PCB_TEXT* text = static_cast<PCB_TEXT*>( aItem );
2264  text->GetEffectiveTextShape()->Collide( loc, aMaxDistance, &distance );
2265  }
2266  break;
2267 
2268  case PCB_FP_TEXT_T:
2269  {
2270  FP_TEXT* text = static_cast<FP_TEXT*>( aItem );
2271  text->GetEffectiveTextShape()->Collide( loc, aMaxDistance, &distance );
2272  }
2273  break;
2274 
2275  case PCB_ZONE_T:
2276  {
2277  ZONE* zone = static_cast<ZONE*>( aItem );
2278 
2279  // Zone borders are very specific
2280  if( zone->HitTestForEdge( aWhere, aMaxDistance / 2 ) )
2281  distance = 0;
2282  else if( zone->HitTestForEdge( aWhere, aMaxDistance ) )
2283  distance = aMaxDistance / 2;
2284  else
2285  aItem->GetEffectiveShape()->Collide( loc, aMaxDistance, &distance );
2286  }
2287  break;
2288 
2289  case PCB_FOOTPRINT_T:
2290  {
2291  FOOTPRINT* footprint = static_cast<FOOTPRINT*>( aItem );
2292  EDA_RECT bbox = footprint->GetBoundingBox( false, false );
2293 
2294  footprint->GetBoundingHull().Collide( loc, aMaxDistance, &distance );
2295 
2296  // Consider footprints larger than the viewport only as a last resort
2297  if( bbox.GetHeight() > viewport.GetHeight() || bbox.GetWidth() > viewport.GetWidth() )
2298  distance = INT_MAX / 2;
2299  }
2300  break;
2301 
2302  case PCB_MARKER_T:
2303  {
2304  PCB_MARKER* marker = static_cast<PCB_MARKER*>( aItem );
2305  SHAPE_LINE_CHAIN polygon;
2306 
2307  marker->ShapeToPolygon( polygon );
2308  polygon.Move( marker->GetPos() );
2309  polygon.Collide( loc, aMaxDistance, &distance );
2310  }
2311  break;
2312 
2313  case PCB_GROUP_T:
2314  {
2315  PCB_GROUP* group = static_cast<PCB_GROUP*>( aItem );
2316 
2317  for( BOARD_ITEM* member : group->GetItems() )
2318  distance = std::min( distance, hitTestDistance( aWhere, member, aMaxDistance ) );
2319  }
2320  break;
2321 
2322  default:
2323  aItem->GetEffectiveShape()->Collide( loc, aMaxDistance, &distance );
2324  break;
2325  }
2326 
2327  return distance;
2328 }
const wxPoint & GetPos() const
Definition: marker_base.h:84
BOX2D GetViewport() const
Return the current viewport visible area rectangle.
Definition: view.cpp:513
SHAPE_POLY_SET GetBoundingHull() const
Return a bounding polygon for the shapes and pads in the footprint.
Definition: footprint.cpp:738
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:82
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:114
class PCB_TEXT, text on a layer
Definition: typeinfo.h:91
VECTOR2< int > VECTOR2I
Definition: vector2d.h:623
std::unordered_set< BOARD_ITEM * > & GetItems()
Definition: pcb_group.h:68
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
ZONE handles a list of polygons defining a copper zone.
Definition: zone.h:57
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:115
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:194
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:41
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 MARKER_PCB, a marker used to show something
Definition: typeinfo.h:98
bool HitTestForEdge(const wxPoint &refPos, int aAccuracy, SHAPE_POLY_SET::VERTEX_INDEX &aCornerHit) const
Function HitTestForEdge tests if the given wxPoint is near a segment defined by 2 corners.
Definition: zone.cpp:436
std::shared_ptr< SHAPE_COMPOUND > GetEffectiveTextShape() const
Definition: eda_text.cpp:624
SHAPE_LINE_CHAIN.
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:630
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:153
const Vec & GetSize() const
Definition: box2.h:189
KICAD_T Type() const
Returns the type of object.
Definition: eda_item.h:162

References SHAPE_LINE_CHAIN_BASE::Collide(), SHAPE_POLY_SET::Collide(), distance(), PCB_TOOL_BASE::footprint(), FOOTPRINT::GetBoundingBox(), FOOTPRINT::GetBoundingHull(), BOARD_ITEM::GetEffectiveShape(), EDA_TEXT::GetEffectiveTextShape(), EDA_RECT::GetHeight(), BOX2< Vec >::GetHeight(), PCB_GROUP::GetItems(), MARKER_BASE::GetPos(), BOX2< Vec >::GetPosition(), BOX2< Vec >::GetSize(), TOOL_BASE::getView(), KIGFX::VIEW::GetViewport(), EDA_RECT::GetWidth(), BOX2< Vec >::GetWidth(), 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(), 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 131 of file pcb_selection_tool.cpp.

132 {
133  auto frame = getEditFrame<PCB_BASE_FRAME>();
134 
137  {
139  return true;
140  }
141 
142  auto selectMenu = std::make_shared<SELECT_MENU>();
143  selectMenu->SetTool( this );
144  m_menu.AddSubMenu( selectMenu );
145 
146  auto& menu = m_menu.GetMenu();
147 
148  auto activeToolCondition =
149  [ frame ] ( const SELECTION& aSel )
150  {
151  return !frame->ToolStackIsEmpty();
152  };
153 
154  auto inGroupCondition =
155  [this] ( const SELECTION& )
156  {
157  return m_enteredGroup != nullptr;
158  };
159 
160  if( frame && frame->IsType( FRAME_PCB_EDITOR ) )
161  {
162  menu.AddMenu( selectMenu.get(), SELECTION_CONDITIONS::NotEmpty );
163  menu.AddSeparator( 1000 );
164  }
165 
166  // "Cancel" goes at the top of the context menu when a tool is active
167  menu.AddItem( ACTIONS::cancelInteractive, activeToolCondition, 1 );
168  menu.AddItem( PCB_ACTIONS::groupLeave, inGroupCondition, 1 );
169  menu.AddSeparator( 1 );
170 
171  if( frame )
173 
174  return true;
175 }
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:427
CONDITIONAL_MENU & GetMenu()
Definition: tool_menu.cpp:46
static TOOL_ACTION cancelInteractive
Definition: actions.h:65
static bool NotEmpty(const SELECTION &aSelection)
Test if there are any items selected.
PCB_BASE_EDIT_FRAME * frame() const
bool ToolStackIsEmpty()
Definition: tools_holder.h:117
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(), m_enteredGroup, TOOL_INTERACTIVE::m_menu, SELECTION_CONDITIONS::NotEmpty(), and TOOLS_HOLDER::ToolStackIsEmpty().

◆ 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:215
TOOL_ID m_toolId
Name of the tool.
Definition: tool_base.h:210
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 1606 of file pcb_selection_tool.cpp.

1607 {
1608  if( aItem->IsLocked() && !m_filter.lockedItems && aItem->Type() != PCB_PAD_T )
1609  return false;
1610 
1611  switch( aItem->Type() )
1612  {
1613  case PCB_FOOTPRINT_T:
1614  if( !m_filter.footprints )
1615  return false;
1616 
1617  break;
1618 
1619  case PCB_PAD_T:
1620  if( !m_filter.pads )
1621  return false;
1622 
1623  break;
1624 
1625  case PCB_TRACE_T:
1626  case PCB_ARC_T:
1627  if( !m_filter.tracks )
1628  return false;
1629 
1630  break;
1631 
1632  case PCB_VIA_T:
1633  if( !m_filter.vias )
1634  return false;
1635 
1636  break;
1637 
1638  case PCB_FP_ZONE_T:
1639  case PCB_ZONE_T:
1640  {
1641  ZONE* zone = static_cast<ZONE*>( aItem );
1642 
1643  if( ( !m_filter.zones && !zone->GetIsRuleArea() )
1644  || ( !m_filter.keepouts && zone->GetIsRuleArea() ) )
1645  {
1646  return false;
1647  }
1648  }
1649  break;
1650 
1651  case PCB_FP_SHAPE_T:
1652  case PCB_SHAPE_T:
1653  case PCB_TARGET_T:
1654  if( !m_filter.graphics )
1655  return false;
1656 
1657  break;
1658 
1659  case PCB_FP_TEXT_T:
1660  case PCB_TEXT_T:
1661  if( !m_filter.text )
1662  return false;
1663 
1664  break;
1665 
1666  case PCB_DIM_ALIGNED_T:
1667  case PCB_DIM_CENTER_T:
1668  case PCB_DIM_ORTHOGONAL_T:
1669  case PCB_DIM_LEADER_T:
1670  if( !m_filter.dimensions )
1671  return false;
1672 
1673  break;
1674 
1675  default:
1676  if( !m_filter.otherItems )
1677  return false;
1678  }
1679 
1680  return true;
1681 }
class ALIGNED_DIMENSION, a linear dimension (graphic item)
Definition: typeinfo.h:100
class 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:755
class CENTER_DIMENSION, a center point marking (graphic item)
Definition: typeinfo.h:102
class PCB_TEXT, text on a layer
Definition: typeinfo.h:91
class 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
class 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.
ZONE handles a list of polygons defining a copper zone.
Definition: zone.h:57
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
virtual bool IsLocked() const
Definition: board_item.h:249
bool lockedItems
Allow selecting locked items.
class ZONE, managed by a footprint
Definition: typeinfo.h:94
class ORTHOGONAL_DIMENSION, a linear dimension constrained to x/y
Definition: typeinfo.h:103
class 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:162

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 210 of file pcb_selection_tool.cpp.

211 {
212  // Main loop: keep receiving events
213  while( TOOL_EVENT* evt = Wait() )
214  {
215  MOUSE_DRAG_ACTION dragAction = m_frame->GetDragAction();
217 
218  // on left click, a selection is made, depending on modifiers ALT, SHIFT, CTRL:
219  // Due to the fact ALT key modifier cannot be useed freely on Winows and Linux,
220  // actions are different on OSX and others OS
221  // Especially, ALT key cannot be used to force showing the full selection choice
222  // context menu (the menu is immediately closed on Windows )
223  //
224  // No modifier = select items and deselect previous selection
225  // ALT (on OSX) = skip heuristic and show full selection choice
226  // ALT (on others) = exclusive OR of selected items (inverse selection)
227  //
228  // CTRL (on OSX) = exclusive OR of selected items (inverse selection)
229  // CTRL (on others) = skip heuristic and show full selection choice
230  //
231  // SHIFT = add selected items to the current selection
232  //
233  // CTRL+SHIFT (on OSX) = remove selected items to the current selection
234  // CTRL+SHIFT (on others) = highlight net
235  //
236  // CTRL+ALT (on OSX) = highlight net
237  // CTRL+ALT (on others) = do nothing (same as no modifier)
238  //
239  // SHIFT+ALT (on OSX) = do nothing (same as no modifier)
240  // SHIFT+ALT (on others) = remove selected items to the current selection
241 
242 #ifdef __WXOSX_MAC__
243  m_subtractive = evt->Modifier( MD_CTRL ) &&
244  evt->Modifier( MD_SHIFT ) &&
245  !evt->Modifier( MD_ALT );
246 
247  m_additive = evt->Modifier( MD_SHIFT ) &&
248  !evt->Modifier( MD_CTRL ) &&
249  !evt->Modifier( MD_ALT );
250 
251  m_exclusive_or = evt->Modifier( MD_CTRL ) &&
252  !evt->Modifier( MD_SHIFT ) &&
253  !evt->Modifier( MD_ALT );
254 
255  m_skip_heuristics = evt->Modifier( MD_ALT ) &&
256  !evt->Modifier( MD_SHIFT ) &&
257  !evt->Modifier( MD_CTRL );
258 
259  bool highlight_modifier = evt->Modifier( MD_CTRL )
260  && evt->Modifier( MD_ALT )
261  && !evt->Modifier( MD_SHIFT );
262 #else
263  m_subtractive = evt->Modifier( MD_ALT ) &&
264  evt->Modifier( MD_SHIFT ) &&
265  !evt->Modifier( MD_CTRL );
266 
267  m_additive = evt->Modifier( MD_SHIFT ) &&
268  !evt->Modifier( MD_ALT ) &&
269  !evt->Modifier( MD_CTRL );
270 
271  m_exclusive_or = evt->Modifier( MD_ALT ) &&
272  !evt->Modifier( MD_SHIFT ) &&
273  !evt->Modifier( MD_CTRL );
274 
275  // Cannot use the Alt key on windows or the disambiguation context menu is immediately
276  // dismissed rendering it useless.
277  m_skip_heuristics = evt->Modifier( MD_CTRL ) &&
278  !evt->Modifier( MD_SHIFT ) &&
279  !evt->Modifier( MD_ALT );
280 
281  bool highlight_modifier = evt->Modifier( MD_CTRL )
282  && evt->Modifier( MD_SHIFT )
283  && !evt->Modifier( MD_ALT );
284 #endif
285 
286  bool modifier_enabled = m_subtractive || m_additive || m_exclusive_or;
287  PCB_BASE_FRAME* frame = getEditFrame<PCB_BASE_FRAME>();
288  bool brd_editor = frame && frame->IsType( FRAME_PCB_EDITOR );
290 
291  // If the router tool is active, don't override
292  if( router && router->IsToolActive() )
293  {
294  evt->SetPassEvent();
295  }
296  // Single click? Select single object
297  else if( evt->IsClick( BUT_LEFT ) )
298  {
299  if( highlight_modifier && brd_editor )
301  else
302  {
303  m_frame->FocusOnItem( nullptr );
304  selectPoint( evt->Position() );
305  }
306  }
307  else if( evt->IsClick( BUT_RIGHT ) )
308  {
309  // Right click? if there is any object - show the context menu
310  bool selectionCancelled = false;
311 
312  if( m_selection.Empty() )
313  {
314  selectPoint( evt->Position(), false, &selectionCancelled );
315  m_selection.SetIsHover( true );
316  }
317 
318  if( !selectionCancelled )
320  }
321  else if( evt->IsDblClick( BUT_LEFT ) )
322  {
323  // Double click? Display the properties window
324  m_frame->FocusOnItem( nullptr );
325 
326  if( m_selection.Empty() )
327  selectPoint( evt->Position() );
328 
329  if( m_selection.GetSize() == 1 && m_selection[0]->Type() == PCB_GROUP_T )
330  {
331  EnterGroup();
332  }
333  else
334  {
336  }
337  }
338  else if( evt->IsDblClick( BUT_MIDDLE ) )
339  {
340  // Middle double click? Do zoom to fit or zoom to objects
341  if( evt->Modifier( MD_CTRL ) ) // Is CTRL key down?
343  else
345  }
346  else if( evt->IsDrag( BUT_LEFT ) )
347  {
348  // Is another tool already moving a new object? Don't allow a drag start
349  if( !m_selection.Empty() && m_selection[0]->HasFlag( IS_NEW | IS_MOVED ) )
350  {
351  evt->SetPassEvent();
352  continue;
353  }
354 
355  // Drag with LMB? Select multiple objects (or at least draw a selection box)
356  // or drag them
357  m_frame->FocusOnItem( nullptr );
359 
360  if( modifier_enabled || dragAction == MOUSE_DRAG_ACTION::SELECT )
361  {
362  selectMultiple();
363  }
364  else if( m_selection.Empty() && dragAction != MOUSE_DRAG_ACTION::DRAG_ANY )
365  {
366  selectMultiple();
367  }
368  else
369  {
370  // Don't allow starting a drag from a zone filled area that isn't already selected
371  auto zoneFilledAreaFilter =
372  []( const VECTOR2I& aWhere, GENERAL_COLLECTOR& aCollector,
373  PCB_SELECTION_TOOL* aTool )
374  {
375  wxPoint location = wxPoint( aWhere );
376  int accuracy = KiROUND( 5 * aCollector.GetGuide()->OnePixelInIU() );
377  std::set<EDA_ITEM*> remove;
378 
379  for( EDA_ITEM* item : aCollector )
380  {
381  if( item->Type() == PCB_ZONE_T )
382  {
383  ZONE* zone = static_cast<ZONE*>( item );
384 
385  if( !zone->HitTestForCorner( location, accuracy * 2 ) &&
386  !zone->HitTestForEdge( location, accuracy ) )
387  remove.insert( zone );
388  }
389  }
390 
391  for( EDA_ITEM* item : remove )
392  aCollector.Remove( item );
393  };
394 
395  // Selection is empty? try to start dragging the item under the point where drag
396  // started
397  if( m_selection.Empty() && selectCursor( false, zoneFilledAreaFilter ) )
398  m_selection.SetIsHover( true );
399 
400  // Check if dragging has started within any of selected items bounding box.
401  // We verify "HasPosition()" first to protect against edge case involving
402  // moving off menus that causes problems (issue #5250)
403  if( evt->HasPosition() && selectionContains( evt->Position() ) )
404  {
405  // Yes -> run the move tool and wait till it finishes
406  TRACK* track = dynamic_cast<TRACK*>( m_selection.GetItem( 0 ) );
407 
408  // If there is only item in the selection and it's a track, then we need to route it
409  bool doRouting = ( track && ( 1 == m_selection.GetSize() ) );
410 
411  if( doRouting && trackDragAction == TRACK_DRAG_ACTION::DRAG )
413  else if( doRouting && trackDragAction == TRACK_DRAG_ACTION::DRAG_FREE_ANGLE )
415  else
417  }
418  else
419  {
420  // No -> drag a selection box
421  selectMultiple();
422  }
423  }
424  }
425  else if( evt->IsCancel() )
426  {
427  m_frame->FocusOnItem( nullptr );
428 
429  if( m_enteredGroup )
430  ExitGroup();
431 
432  ClearSelection();
433 
434  if( evt->FirstResponder() == this )
436  }
437  else
438  {
439  evt->SetPassEvent();
440  }
441 
442 
443  if( m_frame->ToolStackIsEmpty() )
444  {
445  //move cursor prediction
446  if( !modifier_enabled
447  && dragAction == MOUSE_DRAG_ACTION::DRAG_SELECTED
448  && !m_selection.Empty()
449  && evt->HasPosition()
450  && selectionContains( evt->Position() ) )
451  {
453  }
454  else
455  {
456  if( m_additive )
458  else if( m_subtractive )
460  else if( m_exclusive_or )
462  else
464  }
465  }
466  }
467 
468  // Shutting down; clear the selection
469  m_selection.Clear();
470 
471  return 0;
472 }
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:96
virtual void Clear() override
Remove all the stored items from the group.
Definition: selection.h:96
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.
class PCB_GROUP, a set of BOARD_ITEMs
Definition: typeinfo.h:108
PCB_DRAW_PANEL_GAL * GetCanvas() const override
Return a pointer to GAL-based canvas of given EDA draw frame.
static TOOL_ACTION dragFreeAngle
Definition: pcb_actions.h:142
TOOL_MANAGER * m_toolMgr
Definition: tool_base.h:215
static TOOL_ACTION properties
Activation of the edit tool.
Definition: pcb_actions.h:121
static TOOL_ACTION zoomFitScreen
Definition: actions.h:99
bool RunAction(const std::string &aActionName, bool aNow=false, T aParam=NULL)
Run the specified action.
Definition: tool_manager.h:141
bool selectPoint(const VECTOR2I &aWhere, bool aOnDrag=false, bool *aSelectionCancelledFlag=NULL, CLIENT_SELECTION_FILTER aClientFilter=NULL)
Select an item pointed by the parameter aWhere.
static TOOL_ACTION drag45Degree
Definition: pcb_actions.h:141
static TOOL_ACTION zoomFitObjects
Definition: actions.h:100
void SetCurrentCursor(KICURSOR cursor)
Set the current cursor shape for this panel.
TRACK_DRAG_ACTION
bool HitTestForCorner(const wxPoint &refPos, int aAccuracy, SHAPE_POLY_SET::VERTEX_INDEX &aCornerHit) const
Function HitTestForCorner tests if the given wxPoint is near a corner.
Definition: zone.cpp:422
void SetIsHover(bool aIsHover)
Definition: selection.h:67
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:134
bool selectMultiple()
Handle drawing a selection box that allows one to select many items at the same time.
TRACK_DRAG_ACTION m_TrackDragAction
bool ProcessEvent(const TOOL_EVENT &aEvent)
Propagate an event to tools that requested events of matching type(s).
Generic, UI-independent tool event.
Definition: tool_event.h:173
bool ToolStackIsEmpty()
Definition: tools_holder.h:117
ZONE handles a list of polygons defining a copper zone.
Definition: zone.h:57
class ZONE, a copper pour area
Definition: typeinfo.h:105
PCB_SELECTION m_selection
virtual KIGFX::VIEW_ITEM * GetItem(unsigned int aIdx) const override
Definition: selection.h:106
void ExitGroup(bool aSelectGroup=false)
Leave the currently entered group.
#define IS_MOVED
Item being moved.
Definition: eda_item.h:105
bool Empty() const
Checks if there is anything selected.
Definition: selection.h:122
static TOOL_ACTION clearHighlight
Definition: pcb_actions.h:445
virtual unsigned int GetSize() const override
Return the number of stored items.
Definition: selection.h:101
bool selectCursor(bool aForceSelect=false, CLIENT_SELECTION_FILTER aClientFilter=NULL)
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
Function HitTestForEdge tests if the given wxPoint is near a segment defined by 2 corners.
Definition: zone.cpp:436
static TOOL_ACTION highlightNet
Definition: pcb_actions.h:446
bool IsType(FRAME_T aType) const
Used when the right click button is pressed, or when the select tool is in effect.
Definition: collectors.h:241
bool IsToolActive() const
Definition: tool_base.cpp:31
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:68
A base class for most all the KiCad significant classes used in schematics and boards.
Definition: eda_item.h:149
static const TOOL_EVENT InhibitSelectionEditing
Definition: actions.h:220
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)
#define IS_NEW
New item, just created.
Definition: eda_item.h:106
Base PCB main window class for Pcbnew, Gerbview, and CvPcb footprint viewer.
Definition: track.h:83

References ADD, ARROW, BUT_LEFT, BUT_MIDDLE, BUT_RIGHT, SELECTION::Clear(), PCB_ACTIONS::clearHighlight, 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, PCB_BASE_FRAME::GetCanvas(), TOOLS_HOLDER::GetDragAction(), SELECTION::GetItem(), SELECTION::GetSize(), TOOL_MANAGER::GetTool(), PCB_ACTIONS::highlightNet, ZONE::HitTestForCorner(), ZONE::HitTestForEdge(), EVENTS::InhibitSelectionEditing, IS_MOVED, IS_NEW, TOOL_BASE::IsToolActive(), EDA_BASE_FRAME::IsType(), KiROUND(), m_additive, m_enteredGroup, m_exclusive_or, m_frame, TOOL_INTERACTIVE::m_menu, m_selection, m_skip_heuristics, m_subtractive, TOOL_BASE::m_toolMgr, PCBNEW_SETTINGS::m_TrackDragAction, MD_ALT, MD_CTRL, MD_SHIFT, PCB_ACTIONS::move, MOVING, PCB_GROUP_T, PCB_ZONE_T, TOOL_MANAGER::ProcessEvent(), PCB_ACTIONS::properties, TOOL_MANAGER::RunAction(), SELECT, selectCursor(), selectionContains(), selectMultiple(), selectPoint(), EDA_DRAW_PANEL_GAL::SetCurrentCursor(), SELECTION::SetIsHover(), PCB_BASE_FRAME::Settings(), TOOL_MENU::ShowContextMenu(), SUBTRACT, TOOLS_HOLDER::ToolStackIsEmpty(), TOOL_INTERACTIVE::Wait(), XOR, ACTIONS::zoomFitObjects, and ACTIONS::zoomFitScreen.

Referenced by setTransitions().

◆ 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 1706 of file pcb_selection_tool.cpp.

1707 {
1708  m_selection.Clear();
1709 
1710  bool enteredGroupFound = false;
1711 
1712  INSPECTOR_FUNC inspector =
1713  [&]( EDA_ITEM* item, void* testData )
1714  {
1715  if( item->IsSelected() )
1716  {
1717  EDA_ITEM* parent = item->GetParent();
1718 
1719  // Let selected parents handle their children.
1720  if( parent && parent->IsSelected() )
1721  return SEARCH_RESULT::CONTINUE;
1722 
1723  highlight( (BOARD_ITEM*) item, SELECTED, &m_selection );
1724  }
1725 
1726  if( item == m_enteredGroup )
1727  {
1728  item->SetFlags( ENTERED );
1729  enteredGroupFound = true;
1730  }
1731  else
1732  {
1733  item->ClearFlags( ENTERED );
1734  }
1735 
1736  return SEARCH_RESULT::CONTINUE;
1737  };
1738 
1741 
1742  if( !enteredGroupFound )
1743  {
1745  m_enteredGroup = nullptr;
1746  }
1747 }
static const KICAD_T FootprintItems[]
A scan list for primary footprint items.
Definition: collectors.h:294
virtual void Clear() override
Remove all the stored items from the group.
Definition: selection.h:96
static const KICAD_T AllBoardItems[]
A scan list for all editable board items.
Definition: collectors.h:268
BOARD * board() const
bool IsSelected() const
Definition: eda_item.h:172
A base class for any item which can be embedded within the BOARD container class, and therefore insta...
Definition: board_item.h:82
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:1124
void SetFlags(STATUS_FLAGS aMask)
Definition: eda_item.h:202
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
#define ENTERED
indicates a group has been entered
Definition: eda_item.h:137
#define SELECTED
Definition: eda_item.h:113
EDA_ITEM * GetParent() const
Definition: eda_item.h:164
PCB_SELECTION m_selection
bool m_isFootprintEditor
A base class for most all the KiCad significant classes used in schematics and boards.
Definition: eda_item.h:149
void ClearFlags(STATUS_FLAGS aMask=EDA_ITEM_ALL_FLAGS)
Definition: eda_item.h:203

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 1025 of file pcb_selection_tool.cpp.

1026 {
1027  if( aItem )
1028  {
1029  unselect( aItem );
1030 
1031  // Inform other potentially interested tools
1033  }
1034 }
static const TOOL_EVENT UnselectedEvent
Definition: actions.h:210
TOOL_MANAGER * m_toolMgr
Definition: tool_base.h:215
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(), DIALOG_FOOTPRINT_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 519 of file pcb_selection_tool.cpp.

521 {
522  bool selectionEmpty = m_selection.Empty();
523  m_selection.SetIsHover( selectionEmpty );
524 
525  if( selectionEmpty )
526  {
527  m_toolMgr->RunAction( PCB_ACTIONS::selectionCursor, true, aClientFilter );
529  }
530 
531  if( aClientFilter )
532  {
533  enum DISPOSITION { BEFORE = 1, AFTER, BOTH };
534 
535  std::map<EDA_ITEM*, DISPOSITION> itemDispositions;
536  GENERAL_COLLECTOR collector;
537 
538  for( EDA_ITEM* item : m_selection )
539  {
540  collector.Append( item );
541  itemDispositions[ item ] = BEFORE;
542  }
543 
544  aClientFilter( VECTOR2I(), collector, this );
545 
546  for( EDA_ITEM* item : collector )
547  {
548  if( itemDispositions.count( item ) )
549  itemDispositions[ item ] = BOTH;
550  else
551  itemDispositions[ item ] = AFTER;
552  }
553 
554  // Unhighlight the BEFORE items before highlighting the AFTER items.
555  // This is so that in the case of groups, if aClientFilter replaces a selection
556  // with the enclosing group, the unhighlight of the element doesn't undo the
557  // recursive highlighting of that elemetn by the group.
558 
559  for( std::pair<EDA_ITEM* const, DISPOSITION> itemDisposition : itemDispositions )
560  {
561  BOARD_ITEM* item = static_cast<BOARD_ITEM*>( itemDisposition.first );
562  DISPOSITION disposition = itemDisposition.second;
563 
564  if( disposition == BEFORE )
565  {
566  unhighlight( item, SELECTED, &m_selection );
567  }
568  }
569 
570  for( std::pair<EDA_ITEM* const, DISPOSITION> itemDisposition : itemDispositions )
571  {
572  BOARD_ITEM* item = static_cast<BOARD_ITEM*>( itemDisposition.first );
573  DISPOSITION disposition = itemDisposition.second;
574 
575  if( disposition == AFTER )
576  {
577  highlight( item, SELECTED, &m_selection );
578  }
579  else if( disposition == BOTH )
580  {
581  // nothing to do
582  }
583  }
584 
586  }
587 
588  if( aConfirmLockedItems )
589  {
590  std::vector<BOARD_ITEM*> lockedItems;
591 
592  for( EDA_ITEM* item : m_selection )
593  {
594  BOARD_ITEM* boardItem = static_cast<BOARD_ITEM*>( item );
595 
596  if( boardItem->Type() == PCB_GROUP_T )
597  {
598  PCB_GROUP* group = static_cast<PCB_GROUP*>( boardItem );
599  bool lockedDescendant = false;
600 
601  group->RunOnDescendants(
602  [&lockedDescendant]( BOARD_ITEM* child )
603  {
604  if( child->IsLocked() )
605  lockedDescendant = true;
606  } );
607 
608  if( lockedDescendant )
609  lockedItems.push_back( group );
610  }
611  else if( boardItem->IsLocked() )
612  {
613  lockedItems.push_back( boardItem );
614  }
615  }
616 
617  if( !lockedItems.empty() )
618  {
619  DIALOG_LOCKED_ITEMS_QUERY dlg( frame(), lockedItems.size() );
620 
621  switch( dlg.ShowModal() )
622  {
623  case wxID_OK:
624  // remove locked items from selection
625  for( BOARD_ITEM* item : lockedItems )
626  unselect( item );
627 
628  break;
629 
630  case wxID_CANCEL:
631  // cancel operation
632  ClearSelection();
633  break;
634 
635  case wxID_APPLY:
636  // continue with operation with current selection
637  break;
638  }
639  }
640  }
641 
642  return m_selection;
643 }
void ClearReferencePoint()
Definition: selection.h:269
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:82
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:215
bool RunAction(const std::string &aActionName, bool aNow=false, T aParam=NULL)
Run the specified action.
Definition: tool_manager.h:141
void highlight(BOARD_ITEM *aItem, int aHighlightMode, PCB_SELECTION *aGroup=nullptr)
Highlight the item visually.
VECTOR2< int > VECTOR2I
Definition: vector2d.h:623
void SetIsHover(bool aIsHover)
Definition: selection.h:67
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
Definition: eda_item.h:113
void RunOnDescendants(const std::function< void(BOARD_ITEM *)> &aFunction) const
Invoke a function on all descendants of the group.
Definition: pcb_group.cpp:324
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:122
virtual bool IsLocked() const
Definition: board_item.h:249
Used when the right click button is pressed, or when the select tool is in effect.
Definition: collectors.h:241
A base class for most all the KiCad significant classes used in schematics and boards.
Definition: eda_item.h:149
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:60
KICAD_T Type() const
Returns the type of object.
Definition: eda_item.h:162

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

Referenced by EDIT_TOOL::ChangeTrackWidth(), EDIT_TOOL::copyToClipboard(), EDIT_TOOL::CreateArray(), 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(), CONVERT_TOOL::LinesToPoly(), EDIT_TOOL::Mirror(), EDIT_TOOL::MoveExact(), GROUP_TOOL::PickNewMember(), CONVERT_TOOL::PolyToLines(), 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 178 of file pcb_selection_tool.cpp.

179 {
180  m_frame = getEditFrame<PCB_BASE_FRAME>();
181 
182  if( m_enteredGroup )
183  ExitGroup();
184 
185  if( aReason == TOOL_BASE::MODEL_RELOAD )
186  {
187  // Deselect any item being currently in edit, to avoid unexpected behavior
188  // and remove pointers to the selected items from containers
189  // without changing their properties (as they are already deleted
190  // while a new board is loaded)
191  ClearSelection( true );
192 
193  getView()->GetPainter()->GetSettings()->SetHighlight( false );
194  }
195  else
196  {
197  // Restore previous properties of selected items and remove them from containers
198  ClearSelection( true );
199  }
200 
201  // Reinsert the VIEW_GROUP, in case it was removed from the VIEW
202  view()->Remove( &m_selection );
203  view()->Add( &m_selection );
204 
207 }
Model changes (required full reload)
Definition: tool_base.h:81
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:207
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:215
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 2114 of file pcb_selection_tool.cpp.

2115 {
2116  if( aItem->IsSelected() )
2117  return;
2118 
2119  if( aItem->Type() == PCB_PAD_T )
2120  {
2121  FOOTPRINT* footprint = static_cast<FOOTPRINT*>( aItem->GetParent() );
2122 
2123  if( m_selection.Contains( footprint ) )
2124  return;
2125  }
2126 
2127  highlight( aItem, SELECTED, &m_selection );
2128 }
bool IsSelected() const
Definition: eda_item.h:172
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
#define SELECTED
Definition: eda_item.h:113
bool Contains(EDA_ITEM *aItem) const
Definition: selection.h:114
FOOTPRINT * footprint() const
PCB_SELECTION m_selection
BOARD_ITEM_CONTAINER * GetParent() const
Definition: board_item.h:168
KICAD_T Type() const
Returns the type of object.
Definition: eda_item.h:162

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(), findCallback(), 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 1901 of file pcb_selection_tool.cpp.

1902 {
1903  const RENDER_SETTINGS* settings = getView()->GetPainter()->GetSettings();
1904 
1905  if( settings->GetHighContrast() )
1906  {
1907  std::set<unsigned int> activeLayers = settings->GetHighContrastLayers();
1908  bool onActiveLayer = false;
1909 
1910  for( unsigned int layer : activeLayers )
1911  {
1912  // NOTE: Only checking the regular layers (not GAL meta-layers)
1913  if( layer < PCB_LAYER_ID_COUNT && aItem->IsOnLayer( ToLAYER_ID( layer ) ) )
1914  {
1915  onActiveLayer = true;
1916  break;
1917  }
1918  }
1919 
1920  if( !onActiveLayer ) // We do not want to select items that are in the background
1921  return false;
1922  }
1923 
1924  if( aItem->Type() == PCB_FOOTPRINT_T )
1925  {
1926  // In footprint editor, we do not want to select the footprint itself.
1927  if( m_isFootprintEditor )
1928  return false;
1929 
1930  // Allow selection of footprints if some part of the footprint is visible.
1931 
1932  const FOOTPRINT* footprint = static_cast<const FOOTPRINT*>( aItem );
1933 
1934  for( const BOARD_ITEM* item : footprint->GraphicalItems() )
1935  {
1936  if( Selectable( item, true ) )
1937  return true;
1938  }
1939 
1940  for( const PAD* pad : footprint->Pads() )
1941  {
1942  if( Selectable( pad, true ) )
1943  return true;
1944  }
1945 
1946  for( const ZONE* zone : footprint->Zones() )
1947  {
1948  if( Selectable( zone, true ) )
1949  return true;
1950  }
1951 
1952  return false;
1953  }
1954  else if( aItem->Type() == PCB_GROUP_T )
1955  {
1956  PCB_GROUP* group = const_cast<PCB_GROUP*>( static_cast<const PCB_GROUP*>( aItem ) );
1957 
1958  // Similar to logic for footprint, a group is selectable if any of its members are.
1959  // (This recurses.)
1960  for( BOARD_ITEM* item : group->GetItems() )
1961  {
1962  if( Selectable( item, true ) )
1963  return true;
1964  }
1965 
1966  return false;
1967  }
1968 
1969  const ZONE* zone = nullptr;
1970  const VIA* via = nullptr;
1971  const PAD* pad = nullptr;
1972 
1973  switch( aItem->Type() )
1974  {
1975  case PCB_ZONE_T:
1976  case PCB_FP_ZONE_T:
1977  if( !board()->IsElementVisible( LAYER_ZONES ) )
1978  return false;
1979 
1980  zone = static_cast<const ZONE*>( aItem );
1981 
1982  // A footprint zone is only selectable within the footprint editor
1983  if( zone->GetParent()
1984  && zone->GetParent()->Type() == PCB_FOOTPRINT_T
1986  && !checkVisibilityOnly )
1987  {
1988  return false;
1989  }
1990 
1991  // zones can exist on multiple layers!
1992  if( !( zone->GetLayerSet() & board()->GetVisibleLayers() ).any() )
1993  return false;
1994 
1995  break;
1996 
1997  case PCB_TRACE_T:
1998  case PCB_ARC_T:
1999  if( !board()->IsElementVisible( LAYER_TRACKS ) )
2000  return false;
2001 
2002  if( m_isFootprintEditor )
2003  {
2004  if( !view()->IsLayerVisible( aItem->GetLayer() ) )
2005  return false;
2006  }
2007  else
2008  {
2009  if( !board()->IsLayerVisible( aItem->GetLayer() ) )
2010  return false;
2011  }
2012 
2013  break;
2014 
2015  case PCB_VIA_T:
2016  if( !board()->IsElementVisible( LAYER_VIAS ) )
2017  return false;
2018 
2019  via = static_cast<const VIA*>( aItem );
2020 
2021  // For vias it is enough if only one of its layers is visible
2022  if( !( board()->GetVisibleLayers() & via->GetLayerSet() ).any() )
2023  return false;
2024 
2025  break;
2026 
2027  case PCB_FP_TEXT_T:
2028  if( m_isFootprintEditor )
2029  {
2030  if( !view()->IsLayerVisible( aItem->GetLayer() ) )
2031  return false;
2032  }
2033  else
2034  {
2035  if( !view()->IsVisible( aItem ) )
2036  return false;
2037 
2038  if( !board()->IsLayerVisible( aItem->GetLayer() ) )
2039  return false;
2040  }
2041 
2042  break;
2043 
2044  case PCB_FP_SHAPE_T:
2045  if( m_isFootprintEditor )
2046  {
2047  if( !view()->IsLayerVisible( aItem->GetLayer() ) )
2048  return false;
2049  }
2050  else
2051  {
2052  // Footprint shape selections are only allowed in footprint editor mode.
2053  if( !checkVisibilityOnly )
2054  return false;
2055 
2056  if( !board()->IsLayerVisible( aItem->GetLayer() ) )
2057  return false;
2058  }
2059 
2060  break;
2061 
2062  case PCB_PAD_T:
2063  // Multiple selection is only allowed in footprint editor mode. In pcbnew, you have to
2064  // select footprint subparts one by one, rather than with a drag selection. This is so
2065  // you can pick up items under an (unlocked) footprint without also moving the
2066  // footprint's sub-parts.
2067  if( !m_isFootprintEditor && !checkVisibilityOnly )
2068  {
2069  if( m_multiple )
2070  return false;
2071  }
2072 
2073  pad = static_cast<const PAD*>( aItem );
2074 
2075  if( pad->GetAttribute() == PAD_ATTRIB_PTH || pad->GetAttribute() == PAD_ATTRIB_NPTH )
2076  {
2077  // Check render mode (from the Items tab) first
2078  if( !board()->IsElementVisible( LAYER_PADS_TH ) )
2079  return false;
2080 
2081  // A pad's hole is visible on every layer the pad is visible on plus many layers the
2082  // pad is not visible on -- so we only need to check for any visible hole layers.
2083  if( !( board()->GetVisibleLayers() & LSET::PhysicalLayersMask() ).any() )
2084  return false;
2085  }
2086  else
2087  {
2088  // Check render mode (from the Items tab) first
2089  if( pad->IsOnLayer( F_Cu ) && !board()->IsElementVisible( LAYER_PAD_FR ) )
2090  return false;
2091  else if( pad->IsOnLayer( B_Cu ) && !board()->IsElementVisible( LAYER_PAD_BK ) )
2092  return false;
2093 
2094  if( !( pad->GetLayerSet() & board()->GetVisibleLayers() ).any() )
2095  return false;
2096  }
2097 
2098  break;
2099 
2100  // These are not selectable
2101  case PCB_NETINFO_T:
2102  case NOT_USED:
2103  case TYPE_NOT_INIT:
2104  return false;
2105 
2106  default: // Suppress warnings
2107  break;
2108  }
2109 
2110  return aItem->ViewGetLOD( aItem->GetLayer(), view() ) < view()->GetScale();
2111 }
const std::set< unsigned int > GetHighContrastLayers() const
Returns the set of currently high-contrast layers.
Definition: track.h:343
class FP_TEXT, text in a footprint
Definition: typeinfo.h:92
virtual LSET GetLayerSet() const override
Return a std::bitset of all layers on which the item physically resides.
Definition: track.cpp:376
BOARD * board() const
Container for all the knowledge about how graphical objects are drawn on any output surface/device.
multilayer pads, usually with holes
A base class for any item which can be embedded within the BOARD container class, and therefore insta...
Definition: board_item.h:82
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
Control for copper zone opacity/visibility (color ignored)
the 3d code uses this value
Definition: typeinfo.h:79
virtual LSET GetLayerSet() const override
Return a std::bitset of all layers on which the item physically resides.
Definition: zone.cpp:288
LSET GetVisibleLayers() const
A proxy function that calls the correspondent function in m_BoardSettings Returns a bit-mask of all t...
Definition: board.cpp:461
class ARC, an arc track segment on a copper layer
Definition: typeinfo.h:97
bool IsOnLayer(PCB_LAYER_ID aLayer) const override
Test to see if this object is on the given layer.
Definition: pad.h:559
class FP_SHAPE, a footprint edge
Definition: typeinfo.h:93
class PAD, a pad in a footprint
Definition: typeinfo.h:89
like PAD_PTH, but not plated mechanical use only, no connection allowed
Definition: pad_shapes.h:85
std::unordered_set< BOARD_ITEM * > & GetItems()
Definition: pcb_group.h:68
PAINTER * GetPainter() const
Return the painter object used by the view for drawing #VIEW_ITEMS.
Definition: view.h:207
class TRACK, a track segment (segment on a copper layer)
Definition: typeinfo.h:95
PADS & Pads()
Definition: footprint.h:164
PAD_ATTR_T GetAttribute() const
Definition: pad.h:363
FP_ZONES & Zones()
Definition: footprint.h:170
bool IsVisible(const VIEW_ITEM *aItem) const
Return information if the item is visible (or not).
Definition: view.cpp:1494
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:167
ZONE handles a list of polygons defining a copper zone.
Definition: zone.h:57
LSET GetLayerSet() const override
Return a std::bitset of all layers on which the item physically resides.
Definition: pad.h:360
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:507
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:453
smd pads, front layer
Meta control for all vias opacity/visibility.
class NETINFO_ITEM, a description of a net
Definition: typeinfo.h:107
class ZONE, managed by a footprint
Definition: typeinfo.h:94
Plated through hole pad.
Definition: pad_shapes.h:80
class VIA, a via (like a track segment on a copper layer)
Definition: typeinfo.h:96
Definition: pad.h:60
double GetScale() const
Definition: view.h:263
BOARD_ITEM_CONTAINER * GetParent() const
Definition: board_item.h:168
virtual PCB_LAYER_ID GetLayer() const
Return the primary layer this item is on.
Definition: board_item.h:173
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:162
bool IsLayerVisible(int aLayer) const
Return information about visibility of a particular layer.
Definition: view.h:404

References B_Cu, PCB_TOOL_BASE::board(), F_Cu, PCB_TOOL_BASE::footprint(), PAD::GetAttribute(), KIGFX::RENDER_SETTINGS::GetHighContrast(), KIGFX::RENDER_SETTINGS::GetHighContrastLayers(), PCB_GROUP::GetItems(), BOARD_ITEM::GetLayer(), ZONE::GetLayerSet(), PAD::GetLayerSet(), VIA::GetLayerSet(), KIGFX::VIEW::GetPainter(), BOARD_ITEM::GetParent(), KIGFX::VIEW::GetScale(), KIGFX::PAINTER::GetSettings(), TOOL_BASE::getView(), BOARD::GetVisibleLayers(), FOOTPRINT::GraphicalItems(), BOARD::IsElementVisible(), KIGFX::VIEW::IsLayerVisible(), BOARD::IsLayerVisible(), PAD::IsOnLayer(), KIGFX::VIEW::IsVisible(), LAYER_PAD_BK, LAYER_PAD_FR, LAYER_PADS_TH, LAYER_TRACKS, LAYER_VIAS, LAYER_ZONES, PCB_TOOL_BASE::m_isFootprintEditor, m_multiple, NOT_USED, PAD_ATTRIB_NPTH, PAD_ATTRIB_PTH, 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(), ToLAYER_ID(), EDA_ITEM::Type(), TYPE_NOT_INIT, 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 959 of file pcb_selection_tool.cpp.

960 {
961  KIGFX::VIEW* view = getView();
962 
963  // hold all visible items
964  std::vector<KIGFX::VIEW::LAYER_ITEM_PAIR> selectedItems;
965 
966  // Filter the view items based on the selection box
967  BOX2I selectionBox;
968 
969  selectionBox.SetMaximum();
970  view->Query( selectionBox, selectedItems ); // Get the list of selected items
971 
972  for( const KIGFX::VIEW::LAYER_ITEM_PAIR& item_pair : selectedItems )
973  {
974  BOARD_ITEM* item = static_cast<BOARD_ITEM*>( item_pair.first );
975 
976  if( !item || !Selectable( item ) || !itemPassesFilter( item ) )
977  continue;
978 
979  select( item );
980  }
981 
983 
984  return 0;
985 }
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:82
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 SetMaximum()
Definition: box2.h:73
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
std::pair< VIEW_ITEM *, int > LAYER_ITEM_PAIR
Definition: view.h:72
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:427
Hold a (potentially large) number of VIEW_ITEMs and renders them on a graphics device provided by the...
Definition: view.h:67

References 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 1230 of file pcb_selection_tool.cpp.

1231 {
1232  constexpr KICAD_T types[] = { PCB_TRACE_T, PCB_ARC_T, PCB_VIA_T, EOT };
1233  auto connectivity = board()->GetConnectivity();
1234 
1235  for( BOARD_CONNECTED_ITEM* item : connectivity->GetNetItems( aNetCode, types ) )
1236  if( itemPassesFilter( item ) )
1237  aSelect ? select( item ) : unselect( item );
1238 }
void select(BOARD_ITEM *aItem)
Take necessary action mark an item as selected.
BOARD * board() const
class 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 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:414
void unselect(BOARD_ITEM *aItem)
Take necessary action mark an item as unselected.
bool itemPassesFilter(BOARD_ITEM *aItem)
class 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 1276 of file pcb_selection_tool.cpp.

1277 {
1278  std::list<FOOTPRINT*> footprintList;
1279 
1280  // store all footprints that are on that sheet path
1281  for( FOOTPRINT* footprint : board()->Footprints() )
1282  {
1283  if( footprint == nullptr )
1284  continue;
1285 
1286  wxString footprint_path = footprint->GetPath().AsString().BeforeLast('/');
1287 
1288  if( aSheetPath.IsEmpty() )
1289  aSheetPath += '/';
1290 
1291  if( footprint_path == aSheetPath )
1292  footprintList.push_back( footprint );
1293  }
1294 
1295  //Generate a list of all pads, and of all nets they belong to.
1296  std::list<int> netcodeList;
1297  std::list<PAD*> padList;
1298 
1299  for( FOOTPRINT* footprint : footprintList )
1300  {
1301  for( PAD* pad : footprint->Pads() )
1302  {
1303  if( pad->IsConnected() )
1304  {
1305  netcodeList.push_back( pad->GetNetCode() );
1306  padList.push_back( pad );
1307  }
1308  }
1309  }
1310  // remove all duplicates
1311  netcodeList.sort();
1312  netcodeList.unique();
1313 
1314  for( PAD* pad : padList )
1316 
1317  // now we need to find all footprints that are connected to each of these nets then we need
1318  // to determine if these footprints are in the list of footprints belonging to this sheet
1319  std::list<int> removeCodeList;
1320  constexpr KICAD_T padType[] = { PCB_PAD_T, EOT };
1321 
1322  for( int netCode : netcodeList )
1323  {
1324  for( BOARD_CONNECTED_ITEM* mitem : board()->GetConnectivity()->GetNetItems( netCode, padType ) )
1325  {
1326  if( mitem->Type() == PCB_PAD_T && !alg::contains( footprintList, mitem->GetParent() ) )
1327  {
1328  // if we cannot find the footprint of the pad in the footprintList then we can
1329  // assume that that footprint is not located in the same schematic, therefore
1330  // invalidate this netcode.
1331  removeCodeList.push_back( netCode );
1332  break;
1333  }
1334  }
1335  }
1336 
1337  // remove all duplicates
1338  removeCodeList.sort();
1339  removeCodeList.unique();
1340 
1341  for( int removeCode : removeCodeList )
1342  {
1343  netcodeList.remove( removeCode );
1344  }
1345 
1346  std::list<BOARD_CONNECTED_ITEM*> localConnectionList;
1347  constexpr KICAD_T trackViaType[] = { PCB_TRACE_T, PCB_ARC_T, PCB_VIA_T, EOT };
1348 
1349  for( int netCode : netcodeList )
1350  {
1351  for( BOARD_CONNECTED_ITEM* item : board()->GetConnectivity()->GetNetItems( netCode, trackViaType ) )
1352  localConnectionList.push_back( item );
1353  }
1354 
1355  for( BOARD_ITEM* i : footprintList )
1356  {
1357  if( i != NULL )
1358  select( i );
1359  }
1360 
1361  for( BOARD_CONNECTED_ITEM* i : localConnectionList )
1362  {
1363  if( i != NULL )
1364  select( i );
1365  }
1366 }
void select(BOARD_ITEM *aItem)
Take necessary action mark an item as selected.
BOARD * board() const
const KIID_PATH & GetPath() const
Definition: footprint.h:199
A base class for any item which can be embedded within the BOARD container class, and therefore insta...
Definition: board_item.h:82
class 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 TRACK, a track segment (segment on a copper layer)
Definition: typeinfo.h:95
PADS & Pads()
Definition: footprint.h:164
#define NULL
FOOTPRINT * footprint() const
bool contains(const _Container &__container, _Value __value)
Returns true if the container contains the given value.
Definition: kicad_algo.h:81
wxString AsString() const
Definition: kiid.cpp:245
class VIA, a via (like a track segment on a copper layer)
Definition: typeinfo.h:96
Definition: pad.h:60

References KIID_PATH::AsString(), PCB_TOOL_BASE::board(), alg::contains(), EOT, PCB_TOOL_BASE::footprint(), FOOTPRINT::GetPath(), NULL, 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 1111 of file pcb_selection_tool.cpp.

1113 {
1114  constexpr KICAD_T types[] = { PCB_TRACE_T, PCB_ARC_T, PCB_VIA_T, PCB_PAD_T, EOT };
1115 
1116  auto connectivity = board()->GetConnectivity();
1117  auto connectedItems = connectivity->GetConnectedItems( &aStartItem, types, true );
1118 
1119  std::map<wxPoint, std::vector<TRACK*>> trackMap;
1120  std::map<wxPoint, VIA*> viaMap;
1121  std::map<wxPoint, PAD*> padMap;
1122 
1123  // Build maps of connected items
1124  for( BOARD_CONNECTED_ITEM* item : connectedItems )
1125  {
1126  switch( item->Type() )
1127  {
1128  case PCB_ARC_T:
1129  case PCB_TRACE_T:
1130  {
1131  TRACK* track = static_cast<TRACK*>( item );
1132  trackMap[ track->GetStart() ].push_back( track );
1133  trackMap[ track->GetEnd() ].push_back( track );
1134  }
1135  break;
1136 
1137  case PCB_VIA_T:
1138  {
1139  VIA* via = static_cast<VIA*>( item );
1140  viaMap[ via->GetStart() ] = via;
1141  }
1142  break;
1143 
1144  case PCB_PAD_T:
1145  {
1146  PAD* pad = static_cast<PAD*>( item );
1147  padMap[ pad->GetPosition() ] = pad;
1148  }
1149  break;
1150 
1151  default:
1152  break;
1153  }
1154 
1155  item->SetState( SKIP_STRUCT, false );
1156  }
1157 
1158  std::vector<wxPoint> activePts;
1159 
1160  // Set up the initial active points
1161  switch( aStartItem.Type() )
1162  {
1163  case PCB_ARC_T:
1164  case PCB_TRACE_T:
1165  activePts.push_back( static_cast<TRACK*>( &aStartItem )->GetStart() );
1166  activePts.push_back( static_cast<TRACK*>( &aStartItem )->GetEnd() );
1167  break;
1168 
1169  case PCB_VIA_T:
1170  activePts.push_back( static_cast<TRACK*>( &aStartItem )->GetStart() );
1171  break;
1172 
1173  case PCB_PAD_T:
1174  activePts.push_back( aStartItem.GetPosition() );
1175  break;
1176 
1177  default:
1178  break;
1179  }
1180 
1181  bool expand = true;
1182 
1183  // Iterative push from all active points
1184  while( expand )
1185  {
1186  expand = false;
1187 
1188  for( int i = activePts.size() - 1; i >= 0; --i )
1189  {
1190  wxPoint pt = activePts[i];
1191  size_t pt_count = trackMap[ pt ].size() + viaMap.count( pt );
1192 
1193  if( pt_count > 2 && aStopCondition == STOP_AT_JUNCTION )
1194  {
1195  activePts.erase( activePts.begin() + i );
1196  continue;
1197  }
1198 
1199  if( padMap.count( pt ) && aStopCondition != STOP_NEVER )
1200  {
1201  activePts.erase( activePts.begin() + i );
1202  continue;
1203  }
1204 
1205  for( TRACK* track : trackMap[ pt ] )
1206  {
1207  if( track->GetState( SKIP_STRUCT ) )
1208  continue;
1209 
1210  track->SetState( SKIP_STRUCT, true );
1211  select( track );
1212 
1213  if( track->GetStart() == pt )
1214  activePts.push_back( track->GetEnd() );
1215  else
1216  activePts.push_back( track->GetStart() );
1217 
1218  expand = true;
1219  }
1220 
1221  if( viaMap.count( pt ) && !viaMap[ pt ]->IsSelected() && aStopCondition != STOP_AT_JUNCTION )
1222  select( viaMap[ pt ] );
1223 
1224  activePts.erase( activePts.begin() + i );
1225  }
1226  }
1227 }
Definition: track.h:343
void select(BOARD_ITEM *aItem)
Take necessary action mark an item as selected.
BOARD * board() const
const wxPoint & GetStart() const
Definition: track.h:116
Stop at any place where more than two traces meet.
class 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 TRACK, a track segment (segment on a copper layer)
Definition: typeinfo.h:95
void SetState(int type, bool state)
Definition: eda_item.h:191
std::shared_ptr< CONNECTIVITY_DATA > GetConnectivity() const
Return a list of missing connections between components/tracks.
Definition: board.h:414
wxPoint GetPosition() const override
Definition: pad.h:177
const wxPoint & GetEnd() const
Definition: track.h:113
class VIA, a via (like a track segment on a copper layer)
Definition: typeinfo.h:96
#define SKIP_STRUCT
flag indicating that the structure should be ignored
Definition: eda_item.h:117
Definition: pad.h:60
int GetState(int type) const
Definition: eda_item.h:186
Definition: track.h:83

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

Referenced by expandConnection(), and selectAllItemsOnSheet().

◆ selectCursor()

bool PCB_SELECTION_TOOL::selectCursor ( bool  aForceSelect = false,
CLIENT_SELECTION_FILTER  aClientFilter = NULL 
)
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 772 of file pcb_selection_tool.cpp.

773 {
774  if( aForceSelect || m_selection.Empty() )
775  {
776  ClearSelection( true /*quiet mode*/ );
777  selectPoint( getViewControls()->GetCursorPosition( false ), false, NULL, aClientFilter );
778  }
779 
780  return !m_selection.Empty();
781 }
bool selectPoint(const VECTOR2I &aWhere, bool aOnDrag=false, bool *aSelectionCancelledFlag=NULL, CLIENT_SELECTION_FILTER aClientFilter=NULL)
Select an item pointed by the parameter aWhere.
#define NULL
PCB_SELECTION m_selection
bool Empty() const
Checks if there is anything selected.
Definition: selection.h:122
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, NULL, 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 301 of file pcb_tool_base.cpp.

302 {
304 
305  return selTool->GetSelection();
306 }
TOOL_MANAGER * m_toolMgr
Definition: tool_base.h:215
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(), 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(), 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 309 of file pcb_tool_base.cpp.

310 {
312 
313  return selTool->GetSelection();
314 }
TOOL_MANAGER * m_toolMgr
Definition: tool_base.h:215
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 2225 of file pcb_selection_tool.cpp.

2226 {
2228  GENERAL_COLLECTOR collector;
2229 
2230  // Since we're just double-checking, we want a considerably sloppier check than the initial
2231  // selection (for which most tools use 5 pixels). So we increase this to an effective 20
2232  // pixels by artificially inflating the value of a pixel by 4X.
2233  guide.SetOnePixelInIU( guide.OnePixelInIU() * 4 );
2234 
2237  (wxPoint) aPoint, guide );
2238 
2239  for( int i = collector.GetCount() - 1; i >= 0; --i )
2240  {
2241  BOARD_ITEM* item = collector[i];
2242 
2243  if( item->IsSelected() && item->HitTest( (wxPoint) aPoint, 5 * guide.OnePixelInIU() ) )
2244  return true;
2245  }
2246 
2247  return false;
2248 }
const GENERAL_COLLECTORS_GUIDE getCollectorsGuide() const
static const KICAD_T FootprintItems[]
A scan list for primary footprint items.
Definition: collectors.h:294
void SetOnePixelInIU(double aValue)
Definition: collectors.h:609
static const KICAD_T AllBoardItems[]
A scan list for all editable board items.
Definition: collectors.h:268
BOARD * board() const
bool IsSelected() const
Definition: eda_item.h:172
A base class for any item which can be embedded within the BOARD container class, and therefore insta...
Definition: board_item.h:82
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:567
double OnePixelInIU() const override
Definition: collectors.h:608
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:274
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:241
A general implementation of a COLLECTORS_GUIDE.
Definition: collectors.h:381

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 1750 of file pcb_selection_tool.cpp.

1751 {
1752  GENERAL_COLLECTOR* collector = aEvent.Parameter<GENERAL_COLLECTOR*>();
1753 
1754  doSelectionMenu( collector );
1755 
1756  return 0;
1757 }
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:443
Used when the right click button is pressed, or when the select tool is in effect.
Definition: collectors.h:241

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

Referenced by setTransitions().

◆ SelectItem()

int PCB_SELECTION_TOOL::SelectItem ( const TOOL_EVENT aEvent)

Definition at line 952 of file pcb_selection_tool.cpp.

953 {
954  AddItemToSel( aEvent.Parameter<BOARD_ITEM*>() );
955  return 0;
956 }
A base class for any item which can be embedded within the BOARD container class, and therefore insta...
Definition: board_item.h:82
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:443

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 935 of file pcb_selection_tool.cpp.

936 {
937  std::vector<BOARD_ITEM*>* items = aEvent.Parameter<std::vector<BOARD_ITEM*>*>();
938 
939  if( items )
940  {
941  // Perform individual selection of each item before processing the event.
942  for( BOARD_ITEM* item : *items )
943  select( item );
944 
946  }
947 
948  return 0;
949 }
static const TOOL_EVENT SelectedEvent
Definition: actions.h:209
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:82
TOOL_MANAGER * m_toolMgr
Definition: tool_base.h:215
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:443

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 784 of file pcb_selection_tool.cpp.

785 {
786  bool cancelled = false; // Was the tool cancelled while it was running?
787  m_multiple = true; // Multiple selection mode is active
788  KIGFX::VIEW* view = getView();
789 
791  view->Add( &area );
792 
793  bool anyAdded = false;
794  bool anySubtracted = false;
795 
796  while( TOOL_EVENT* evt = Wait() )
797  {
798  int width = area.GetEnd().x - area.GetOrigin().x;
799 
800  /* Selection mode depends on direction of drag-selection:
801  * Left > Right : Select objects that are fully enclosed by selection
802  * Right > Left : Select objects that are crossed by selection
803  */
804  bool windowSelection = width >= 0 ? true : false;
805 
806  if( view->IsMirroredX() )
807  windowSelection = !windowSelection;
808 
810  windowSelection ? KICURSOR::SELECT_WINDOW : KICURSOR::SELECT_LASSO );
811 
812  if( evt->IsCancelInteractive() || evt->IsActivate() )
813  {
814  cancelled = true;
815  break;
816  }
817 
818  if( evt->IsDrag( BUT_LEFT ) )
819  {
821  {
822  if( m_selection.GetSize() > 0 )
823  {
824  anySubtracted = true;
825  ClearSelection( true /*quiet mode*/ );
826  }
827  }
828 
829  // Start drawing a selection box
830  area.SetOrigin( evt->DragOrigin() );
831  area.SetEnd( evt->Position() );
832  area.SetAdditive( m_additive );
835 
836  view->SetVisible( &area, true );
837  view->Update( &area );
838  getViewControls()->SetAutoPan( true );
839  }
840 
841  if( evt->IsMouseUp( BUT_LEFT ) )
842  {
843  getViewControls()->SetAutoPan( false );
844 
845  // End drawing the selection box
846  view->SetVisible( &area, false );
847 
848  std::vector<KIGFX::VIEW::LAYER_ITEM_PAIR> candidates;
849  BOX2I selectionBox = area.ViewBBox();
850  view->Query( selectionBox, candidates ); // Get the list of nearby items
851 
852  int height = area.GetEnd().y - area.GetOrigin().y;
853 
854  // Construct an EDA_RECT to determine BOARD_ITEM selection
855  EDA_RECT selectionRect( (wxPoint) area.GetOrigin(), wxSize( width, height ) );
856 
857  selectionRect.Normalize();
858 
859  GENERAL_COLLECTOR collector;
860 
861  for( auto it = candidates.begin(), it_end = candidates.end(); it != it_end; ++it )
862  {
863  BOARD_ITEM* item = static_cast<BOARD_ITEM*>( it->first );
864 
865  if( item && Selectable( item ) && item->HitTest( selectionRect, windowSelection ) )
866  collector.Append( item );
867  }
868 
869  // Apply the stateful filter
870  FilterCollectedItems( collector );
871 
872  FilterCollectorForGroups( collector );
873 
874  for( EDA_ITEM* i : collector )
875  {
876  BOARD_ITEM* item = static_cast<BOARD_ITEM*>( i );
877 
878  if( m_subtractive || ( m_exclusive_or && item->IsSelected() ) )
879  {
880  unselect( item );
881  anySubtracted = true;
882  }
883  else
884  {
885  select( item );
886  anyAdded = true;
887  }
888  }
889 
890  m_selection.SetIsHover( false );
891 
892  // Inform other potentially interested tools
893  if( anyAdded )
895  else if( anySubtracted )
897 
898  break; // Stop waiting for events
899  }
900  }
901 
902  getViewControls()->SetAutoPan( false );
903 
904  // Stop drawing the selection box
905  view->Remove( &area );
906  m_multiple = false; // Multiple selection mode is inactive
907 
908  if( !cancelled )
910 
912 
913  return cancelled;
914 }
void ClearReferencePoint()
Definition: selection.h:269
static const TOOL_EVENT SelectedEvent
Definition: actions.h:209
void SetEnd(VECTOR2I aEnd)
Set the current end of the rectangle (the corner that moves with the cursor.
void select(BOARD_ITEM *aItem)
Take necessary action mark an item as selected.
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.
bool IsSelected() const
Definition: eda_item.h:172
static const TOOL_EVENT UnselectedEvent
Definition: actions.h:210
A base class for any item which can be embedded within the BOARD container class, and therefore insta...
Definition: board_item.h:82
void SetOrigin(VECTOR2I aOrigin)
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:215
void SetExclusiveOr(bool aExclusiveOr)
void SetCurrentCursor(KICURSOR cursor)
Set the current cursor shape for this panel.
virtual void Remove(VIEW_ITEM *aItem) override
Remove a VIEW_ITEM from the view.
Definition: pcb_view.cpp:75
void SetIsHover(bool aIsHover)
Definition: selection.h:67
PCB_BASE_FRAME * m_frame
void Append(EDA_ITEM *item)
Add an item to the end of the list.
Definition: collector.h:105
void SetAdditive(bool aAdditive)
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:274
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).
Generic, UI-independent tool event.
Definition: tool_event.h:173
const BOX2I ViewBBox() const override
Set the origin of the rectangle (the fixed corner)
KIGFX::PCB_VIEW * view() const
static const TOOL_EVENT UninhibitSelectionEditing
Definition: actions.h:221
bool Selectable(const BOARD_ITEM *aItem, bool checkVisibilityOnly=false) const
Check conditions for an item to be selected.
PCB_SELECTION m_selection
void unselect(BOARD_ITEM *aItem)
Take necessary action mark an item as unselected.
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.
bool IsMirroredX() const
Return true if view is flipped across the X axis.
Definition: view.h:237
void SetSubtractive(bool aSubtractive)
virtual unsigned int GetSize() const override
Return the number of stored items.
Definition: selection.h:101
void Normalize()
Ensures that the height ant width are positive.
Definition: eda_rect.cpp:35
Used when the right click button is pressed, or when the select tool is in effect.
Definition: collectors.h:241
Handle the component boundary box.
Definition: eda_rect.h:42
A base class for most all the KiCad significant classes used in schematics and boards.
Definition: eda_item.h:149
void SetVisible(VIEW_ITEM *aItem, bool aIsVisible=true)
Set the item visibility.
Definition: view.cpp:1454
Represent a selection area (currently a rectangle) in a VIEW, drawn corner-to-corner between two poin...
virtual void Add(VIEW_ITEM *aItem, int aDrawPriority=-1) override
Add a VIEW_ITEM to the view.
Definition: pcb_view.cpp:58
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:427
KIGFX::VIEW_CONTROLS * getViewControls() const
Return the instance of VIEW_CONTROLS object used in the application.
Definition: tool_base.cpp:42
Hold a (potentially large) number of VIEW_ITEMs and renders them on a graphics device provided by the...
Definition: view.h:67
void FilterCollectorForGroups(GENERAL_COLLECTOR &aCollector) const
int ClearSelection(const TOOL_EVENT &aEvent)
void FilterCollectedItems(GENERAL_COLLECTOR &aCollector)

References KIGFX::PCB_VIEW::Add(), COLLECTOR::Append(), BUT_LEFT, SELECTION::ClearReferencePoint(), ClearSelection(), FilterCollectedItems(), FilterCollectorForGroups(), PCB_BASE_FRAME::GetCanvas(), KIGFX::PREVIEW::SELECTION_AREA::GetEnd(), KIGFX::PREVIEW::SELECTION_AREA::GetOrigin(), SELECTION::GetSize(), TOOL_BASE::getView(), TOOL_BASE::getViewControls(), EDA_ITEM::HitTest(), KIGFX::VIEW::IsMirroredX(), EDA_ITEM::IsSelected(), m_additive, m_exclusive_or, m_frame, m_multiple, m_selection, m_subtractive, TOOL_BASE::m_toolMgr, EDA_RECT::Normalize(), TOOL_MANAGER::ProcessEvent(), KIGFX::VIEW::Query(), KIGFX::PCB_VIEW::Remove(), select(), SELECT_LASSO, SELECT_WINDOW, Selectable(), EVENTS::SelectedEvent, KIGFX::PREVIEW::SELECTION_AREA::SetAdditive(), KIGFX::VIEW_CONTROLS::SetAutoPan(), EDA_DRAW_PANEL_GAL::SetCurrentCursor(), KIGFX::PREVIEW::SELECTION_AREA::SetEnd(), KIGFX::PREVIEW::SELECTION_AREA::SetExclusiveOr(), SELECTION::SetIsHover(), KIGFX::PREVIEW::SELECTION_AREA::SetOrigin(), KIGFX::PREVIEW::SELECTION_AREA::SetSubtractive(), KIGFX::VIEW::SetVisible(), EVENTS::UninhibitSelectionEditing, unselect(), EVENTS::UnselectedEvent, KIGFX::PCB_VIEW::Update(), PCB_TOOL_BASE::view(), KIGFX::PREVIEW::SELECTION_AREA::ViewBBox(), TOOL_INTERACTIVE::Wait(), VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by Main().

◆ selectNet()

int PCB_SELECTION_TOOL::selectNet ( const TOOL_EVENT aEvent)
private

Select all copper connections belonging to the same net(s) as the items in the selection.

Definition at line 1241 of file pcb_selection_tool.cpp.

1242 {
1243  bool select = aEvent.IsAction( &PCB_ACTIONS::selectNet );
1244 
1245  // If we've been passed an argument, just select that netcode1
1246  int netcode = aEvent.Parameter<intptr_t>();
1247 
1248  if( netcode > 0 )
1249  {
1250  selectAllItemsOnNet( netcode, select );
1251  return 0;
1252  }
1253 
1254  if( !selectCursor() )
1255  return 0;
1256 
1257  // copy the selection, since we're going to iterate and modify
1258  auto selection = m_selection.GetItems();
1259 
1260  for( EDA_ITEM* i : selection )
1261  {
1262  BOARD_CONNECTED_ITEM* connItem = dynamic_cast<BOARD_CONNECTED_ITEM*>( i );
1263 
1264  if( connItem )
1265  selectAllItemsOnNet( connItem->GetNetCode(), select );
1266  }
1267 
1268  // Inform other potentially interested tools
1269  if( m_selection.Size() > 0 )
1271 
1272  return 0;
1273 }
static const TOOL_EVENT SelectedEvent
Definition: actions.h:209
void select(BOARD_ITEM *aItem)
Take necessary action mark an item as selected.
static TOOL_ACTION selectNet
Select all connections belonging to a single net.
Definition: pcb_actions.h:81
TOOL_MANAGER * m_toolMgr
Definition: tool_base.h:215
A base class derived from BOARD_ITEM for items that can be connected and have a net,...
bool IsAction(const TOOL_ACTION *aAction) const
Test if the event contains an action issued upon activation of the given TOOL_ACTION.
Definition: tool_event.cpp:70
const PCB_SELECTION & selection() const
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:443
const std::deque< EDA_ITEM * > GetItems() const
Definition: selection.h:133
PCB_SELECTION m_selection
Definition: