KiCad PCB EDA Suite
Loading...
Searching...
No Matches
selection_tool.cpp
Go to the documentation of this file.
1/*
2 * This program source code file is part of KiCad, a free EDA CAD application.
3 *
4 * Copyright (C) 2021-2022 KiCad Developers, see AUTHORS.TXT for contributors.
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version 3
9 * of the License, or (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, you may find one here:
18 * http://www.gnu.org/licenses/gpl-3.0.html
19 * or you may search the http://www.gnu.org website for the version 3 license,
20 * or you may write to the Free Software Foundation, Inc.,
21 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
22 */
23
24#include <bitmaps.h>
25#include <widgets/ui_common.h>
26#include <collector.h>
27#include <tool/tool_manager.h>
28#include <tool/actions.h>
29#include <tool/selection_tool.h>
30#include <view/view.h>
31#include <eda_draw_frame.h>
32
33
34SELECTION_TOOL::SELECTION_TOOL( const std::string& aName ) :
35 TOOL_INTERACTIVE( aName ),
36 m_additive( false ),
37 m_subtractive( false ),
38 m_exclusive_or( false ),
39 m_multiple( false ),
40 m_skip_heuristics( false ),
41 m_highlight_modifier( false ),
42 m_drag_additive( false ),
43 m_drag_subtractive( false ),
44 m_canceledMenu( false )
45{
46}
47
48void SELECTION_TOOL::setModifiersState( bool aShiftState, bool aCtrlState, bool aAltState )
49{
50 // Set the configuration of m_additive, m_subtractive, m_exclusive_or from the state of
51 // modifier keys SHIFT and CTRL
52
53 // ALT key cannot be used on MSW because of a conflict with the system menu
54
55 m_subtractive = aCtrlState && aShiftState;
56 m_additive = !aCtrlState && aShiftState;
57
59 {
60 m_exclusive_or = false;
61 m_highlight_modifier = aCtrlState && !aShiftState;
62 }
63 else
64 {
65 m_exclusive_or = aCtrlState && !aShiftState;
67 }
68
69 // Drag is more forgiving and allows either Ctrl+Drag or Shift+Drag to add to the selection
70 // Note, however that we cannot provide disambiguation at the same time as the box selection
71 m_drag_additive = ( aCtrlState || aShiftState ) && !aAltState;
72 m_drag_subtractive = aCtrlState && aShiftState && !aAltState;
73
74 // While the ALT key has some conflicts under MSW (and some flavors of Linux WMs), it remains
75 // useful for users who only use tap-click rather than holding the button. We disable it for
76 // windows because it flashes the disambiguation menu without showing data
77#ifndef __WINDOWS__
78 m_skip_heuristics = aAltState;
79#else
80 m_skip_heuristics = false;
81#endif
82
83}
84
85
87{
89}
90
91
93{
94 ACTION_MENU* actionMenu = aEvent.Parameter<ACTION_MENU*>();
95 CONDITIONAL_MENU* conditionalMenu = dynamic_cast<CONDITIONAL_MENU*>( actionMenu );
96
97 if( conditionalMenu )
98 conditionalMenu->Evaluate( selection() );
99
100 if( actionMenu )
101 actionMenu->UpdateAll();
102
103 return 0;
104}
105
106
108{
109 AddItemToSel( aEvent.Parameter<EDA_ITEM*>() );
110 selection().SetIsHover( false );
111 return 0;
112}
113
114
115void SELECTION_TOOL::AddItemToSel( EDA_ITEM* aItem, bool aQuietMode )
116{
117 if( aItem )
118 {
119 select( aItem );
120
121 // Inform other potentially interested tools
122 if( !aQuietMode )
124 }
125}
126
127
129{
130 AddItemsToSel( aEvent.Parameter<EDA_ITEMS*>(), false );
131 selection().SetIsHover( false );
132 return 0;
133}
134
135
136void SELECTION_TOOL::AddItemsToSel( EDA_ITEMS* aList, bool aQuietMode )
137{
138 if( aList )
139 {
140 for( EDA_ITEM* item : *aList )
141 select( item );
142
143 // Inform other potentially interested tools
144 if( !aQuietMode )
146 }
147}
148
149
151{
153 selection().SetIsHover( false );
154 return 0;
155}
156
157
158void SELECTION_TOOL::RemoveItemFromSel( EDA_ITEM* aItem, bool aQuietMode )
159{
160 if( aItem )
161 {
162 unselect( aItem );
163
164 // Inform other potentially interested tools
165 if( !aQuietMode )
167 }
168}
169
170
172{
173 RemoveItemsFromSel( aEvent.Parameter<EDA_ITEMS*>(), false );
174 selection().SetIsHover( false );
175 return 0;
176}
177
178
179void SELECTION_TOOL::RemoveItemsFromSel( EDA_ITEMS* aList, bool aQuietMode )
180{
181 if( aList )
182 {
183 for( EDA_ITEM* item : *aList )
184 unselect( item );
185
186 // Inform other potentially interested tools
187 if( !aQuietMode )
189 }
190}
191
192
193void SELECTION_TOOL::RemoveItemsFromSel( std::vector<KIID>* aList, bool aQuietMode )
194{
195 EDA_ITEMS removeItems;
196
197 for( EDA_ITEM* item : selection() )
198 {
199 if( alg::contains( *aList, item->m_Uuid ) )
200 removeItems.push_back( item );
201 }
202
203 RemoveItemsFromSel( &removeItems, aQuietMode );
204}
205
206
208{
209 highlight( aItem, BRIGHTENED );
210}
211
212
214{
215 unhighlight( aItem, BRIGHTENED );
216}
217
218
219void SELECTION_TOOL::onDisambiguationExpire( wxTimerEvent& aEvent )
220{
221 // If there is a multiple selection then it's more likely that we're seeing a paused drag
222 // than a long-click.
223 if( selection().GetSize() >= 2 && !hasModifier() )
224 return;
225
226 // If another tool has since started running then we don't want to interrupt
227 if( !getEditFrame<EDA_DRAW_FRAME>()->ToolStackIsEmpty() )
228 return;
229
231}
232
233
235{
236 COLLECTOR* collector = aEvent.Parameter<COLLECTOR*>();
237
238 if( !doSelectionMenu( collector ) )
239 collector->m_MenuCancelled = true;
240
241 return 0;
242}
243
244
246{
247 UNITS_PROVIDER* unitsProvider = getEditFrame<EDA_DRAW_FRAME>();
248 EDA_ITEM* current = nullptr;
249 SELECTION highlightGroup;
250 bool selectAll = false;
251 bool expandSelection = false;
252
253 highlightGroup.SetLayer( LAYER_SELECT_OVERLAY );
254 getView()->Add( &highlightGroup );
255
256 do
257 {
259 if( expandSelection )
260 aCollector->Combine();
261
262 expandSelection = false;
263
264 int limit = std::min( 100, aCollector->GetCount() );
265 ACTION_MENU menu( true );
266
267 for( int i = 0; i < limit; ++i )
268 {
269 EDA_ITEM* item = ( *aCollector )[i];
270 wxString menuText;
271
272 if( i < 9 )
273 {
274#ifdef __WXMAC__
275 menuText = wxString::Format( "%s\t%d",
276 item->GetItemDescription( unitsProvider ),
277 i + 1 );
278#else
279 menuText = wxString::Format( "&%d %s\t%d",
280 i + 1,
281 item->GetItemDescription( unitsProvider ),
282 i + 1 );
283#endif
284 }
285 else
286 {
287 menuText = item->GetItemDescription( unitsProvider );
288 }
289
290 menu.Add( menuText, i + 1, item->GetMenuImage() );
291 }
292
293 menu.AppendSeparator();
294 menu.Add( _( "Select &All\tA" ), limit + 1, BITMAPS::INVALID_BITMAP );
295
296 if( !expandSelection && aCollector->HasAdditionalItems() )
297 menu.Add( _( "&Expand Selection\tE" ), limit + 2, BITMAPS::INVALID_BITMAP );
298
299 if( aCollector->m_MenuTitle.Length() )
300 {
301 menu.SetTitle( aCollector->m_MenuTitle );
302 menu.SetIcon( BITMAPS::info );
303 menu.DisplayTitle( true );
304 }
305 else
306 {
307 menu.DisplayTitle( false );
308 }
309
310 SetContextMenu( &menu, CMENU_NOW );
311
312 while( TOOL_EVENT* evt = Wait() )
313 {
314 if( evt->Action() == TA_CHOICE_MENU_UPDATE )
315 {
316 if( selectAll )
317 {
318 for( int i = 0; i < aCollector->GetCount(); ++i )
319 unhighlight( ( *aCollector )[i], BRIGHTENED, &highlightGroup );
320 }
321 else if( current )
322 {
323 unhighlight( current, BRIGHTENED, &highlightGroup );
324 }
325
326 int id = *evt->GetCommandId();
327
328 // User has pointed an item, so show it in a different way
329 if( id > 0 && id <= limit )
330 {
331 current = ( *aCollector )[id - 1];
332 highlight( current, BRIGHTENED, &highlightGroup );
333 }
334 else
335 {
336 current = nullptr;
337 }
338
339 // User has pointed on the "Select All" option
340 if( id == limit + 1 )
341 {
342 for( int i = 0; i < aCollector->GetCount(); ++i )
343 highlight( ( *aCollector )[i], BRIGHTENED, &highlightGroup );
344
345 selectAll = true;
346 }
347 else
348 {
349 selectAll = false;
350 }
351 }
352 else if( evt->Action() == TA_CHOICE_MENU_CHOICE )
353 {
354 if( selectAll )
355 {
356 for( int i = 0; i < aCollector->GetCount(); ++i )
357 unhighlight( ( *aCollector )[i], BRIGHTENED, &highlightGroup );
358 }
359 else if( current )
360 {
361 unhighlight( current, BRIGHTENED, &highlightGroup );
362 }
363
364 std::optional<int> id = evt->GetCommandId();
365
366 // User has selected the "Select All" option
367 if( id == limit + 1 )
368 {
369 selectAll = true;
370 current = nullptr;
371 }
372 // User has selected the "Expand Selection" option
373 else if( id == limit + 2 )
374 {
375 selectAll = false;
376 current = nullptr;
377 expandSelection = true;
378 }
379 // User has selected an item, so this one will be returned
380 else if( id && ( *id > 0 ) && ( *id <= limit ) )
381 {
382 selectAll = false;
383 current = ( *aCollector )[*id - 1];
384 }
385 // User has cancelled the menu (either by <esc> or clicking out of it)
386 else
387 {
388 selectAll = false;
389 current = nullptr;
390 }
391 }
392 else if( evt->Action() == TA_CHOICE_MENU_CLOSED )
393 {
394 break;
395 }
396
397 getView()->UpdateItems();
398 getEditFrame<EDA_DRAW_FRAME>()->GetCanvas()->Refresh();
399 }
400 } while( expandSelection );
401
402 getView()->Remove( &highlightGroup );
403
404 if( selectAll )
405 {
406 return true;
407 }
408 else if( current )
409 {
410 aCollector->Empty();
411 aCollector->Append( current );
412 return true;
413 }
414
415 return false;
416}
417
418
Defines the structure of a menu based on ACTIONs.
Definition: action_menu.h:49
void DisplayTitle(bool aDisplay=true)
Decide whether a title for a pop up menu should be displayed.
Definition: action_menu.cpp:98
void UpdateAll()
Run update handlers for the menu and its submenus.
void SetTitle(const wxString &aTitle) override
Set title for the menu.
Definition: action_menu.cpp:87
void SetIcon(BITMAPS aIcon)
Assign an icon for the entry.
Definition: action_menu.cpp:73
wxMenuItem * Add(const wxString &aLabel, int aId, BITMAPS aIcon)
Add a wxWidgets-style entry to the menu.
An abstract class that will find and hold all the objects according to an inspection done by the Insp...
Definition: collector.h:48
bool m_MenuCancelled
Definition: collector.h:237
void Empty()
Clear the list.
Definition: collector.h:89
int GetCount() const
Return the number of objects in the list.
Definition: collector.h:81
wxString m_MenuTitle
Definition: collector.h:236
bool HasAdditionalItems()
Test if the collector has heuristic backup items.
Definition: collector.h:132
void Combine()
Re-combine the backup list into the main list of the collector.
Definition: collector.h:140
void Append(EDA_ITEM *item)
Add an item to the end of the list.
Definition: collector.h:99
void Evaluate(SELECTION &aSelection)
Update the contents of the menu based on the supplied conditions.
A base class for most all the KiCad significant classes used in schematics and boards.
Definition: eda_item.h:85
virtual wxString GetItemDescription(UNITS_PROVIDER *aUnitsProvider) const
Return a user-visible description string of this item.
Definition: eda_item.cpp:108
virtual BITMAPS GetMenuImage() const
Return a pointer to an image to be used in menus.
Definition: eda_item.cpp:288
static const TOOL_EVENT DisambiguatePoint
Used for hotkey feedback.
Definition: actions.h:246
static const TOOL_EVENT SelectedEvent
Definition: actions.h:229
static const TOOL_EVENT UnselectedEvent
Definition: actions.h:230
virtual void SetLayer(int aLayer)
Set layer used to draw the group.
Definition: view_group.h:98
virtual void Add(VIEW_ITEM *aItem, int aDrawPriority=-1)
Add a VIEW_ITEM to the view.
Definition: view.cpp:314
virtual void Remove(VIEW_ITEM *aItem)
Remove a VIEW_ITEM from the view.
Definition: view.cpp:351
void UpdateItems()
Iterate through the list of items that asked for updating and updates them.
Definition: view.cpp:1418
int RemoveItemFromSel(const TOOL_EVENT &aEvent)
bool doSelectionMenu(COLLECTOR *aCollector)
int AddItemsToSel(const TOOL_EVENT &aEvent)
void BrightenItem(EDA_ITEM *aItem)
virtual void unselect(EDA_ITEM *aItem)=0
Take necessary action mark an item as unselected.
int AddItemToSel(const TOOL_EVENT &aEvent)
int UpdateMenu(const TOOL_EVENT &aEvent)
Update a menu's state based on the current selection.
void setModifiersState(bool aShiftState, bool aCtrlState, bool aAltState)
Set the configuration of m_additive, m_subtractive, m_exclusive_or, m_skip_heuristics from the state ...
void UnbrightenItem(EDA_ITEM *aItem)
virtual void select(EDA_ITEM *aItem)=0
Take necessary action mark an item as selected.
int SelectionMenu(const TOOL_EVENT &aEvent)
Show a popup menu to trim the COLLECTOR passed as aEvent's parameter down to a single item.
int RemoveItemsFromSel(const TOOL_EVENT &aEvent)
SELECTION_TOOL(const std::string &aName)
virtual void unhighlight(EDA_ITEM *aItem, int aHighlightMode, SELECTION *aGroup=nullptr)=0
Unhighlight the item visually.
virtual void highlight(EDA_ITEM *aItem, int aHighlightMode, SELECTION *aGroup=nullptr)=0
Highlight the item visually.
virtual SELECTION & selection()=0
Return a reference to the selection.
bool hasModifier()
True if a selection modifier is enabled, false otherwise.
virtual bool ctrlClickHighlights()
Determines if ctrl-click is highlight net or XOR selection.
void onDisambiguationExpire(wxTimerEvent &aEvent)
Start the process to show our disambiguation menu once the user has kept the mouse down for the minim...
void SetIsHover(bool aIsHover)
Definition: selection.h:78
TOOL_MANAGER * m_toolMgr
Definition: tool_base.h:216
KIGFX::VIEW * getView() const
Returns the instance of #VIEW object used in the application.
Definition: tool_base.cpp:36
Generic, UI-independent tool event.
Definition: tool_event.h:167
T Parameter() const
Return a parameter assigned to the event.
Definition: tool_event.h:461
void SetContextMenu(ACTION_MENU *aMenu, CONTEXT_MENU_TRIGGER aTrigger=CMENU_BUTTON)
Assign a context menu and tells when it should be activated.
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 ProcessEvent(const TOOL_EVENT &aEvent)
Propagate an event to tools that requested events of matching type(s).
#define _(s)
std::vector< EDA_ITEM * > EDA_ITEMS
Define list of drawing items for screens.
Definition: eda_item.h:513
#define BRIGHTENED
item is drawn with a bright contour
@ LAYER_SELECT_OVERLAY
currently selected items overlay
Definition: layer_ids.h:220
bool contains(const _Container &__container, _Value __value)
Returns true if the container contains the given value.
Definition: kicad_algo.h:99
@ CMENU_NOW
Definition: tool_event.h:152
@ TA_CHOICE_MENU_CHOICE
Definition: tool_event.h:97
@ TA_CHOICE_MENU_UPDATE
Definition: tool_event.h:93
@ TA_CHOICE_MENU_CLOSED
Definition: tool_event.h:100
Functions to provide common constants and other functions to assist in making a consistent UI.