KiCad PCB EDA Suite
Loading...
Searching...
No Matches
tool_manager.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) 2013-2023 CERN
5 * Copyright The KiCad Developers, see AUTHORS.txt for contributors.
6 * @author Tomasz Wlostowski <[email protected]>
7 * @author Maciej Suminski <[email protected]>
8 *
9 * This program is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU General Public License
11 * as published by the Free Software Foundation; either version 2
12 * of the License, or (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, you may find one here:
21 * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
22 * or you may search the http://www.gnu.org website for the version 2 license,
23 * or you may write to the Free Software Foundation, Inc.,
24 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
25 */
26
27#include <core/kicad_algo.h>
28#include <optional>
29#include <map>
30#include <stack>
31#include <trace_helpers.h>
32#include <kiplatform/ui.h>
33#include <app_monitor.h>
34
35#include <wx/event.h>
36#include <wx/clipbrd.h>
37#include <wx/app.h>
38
39#include <math/vector2wx.h>
40
41#include <view/view.h>
42#include <view/view_controls.h>
43#include <eda_base_frame.h>
44#include <tool/tool_base.h>
46#include <tool/tool_manager.h>
47#include <tool/action_menu.h>
48#include <tool/coroutine.h>
49#include <tool/action_manager.h>
50
52
55{
57 theTool( aTool )
58 {
59 clear();
60 }
61
62 TOOL_STATE( const TOOL_STATE& aState )
63 {
64 theTool = aState.theTool;
65 idle = aState.idle;
66 shutdown = aState.shutdown;
67 pendingWait = aState.pendingWait;
69 contextMenu = aState.contextMenu;
71 cofunc = aState.cofunc;
73 wakeupEvent = aState.wakeupEvent;
74 waitEvents = aState.waitEvents;
75 transitions = aState.transitions;
76 vcSettings = aState.vcSettings;
77 // do not copy stateStack
78 }
79
81 {
82 wxASSERT_MSG( stateStack.empty(), wxT( "StateStack not empty!" ) );
83 }
84
87
89 bool idle;
90
93
97
100
103
106
109
112
115
118
121 std::vector<TRANSITION> transitions;
122
125
127 {
128 theTool = aState.theTool;
129 idle = aState.idle;
130 shutdown = aState.shutdown;
131 pendingWait = aState.pendingWait;
133 contextMenu = aState.contextMenu;
135 cofunc = aState.cofunc;
136 initialEvent = aState.initialEvent;
137 wakeupEvent = aState.wakeupEvent;
138 waitEvents = aState.waitEvents;
139 transitions = aState.transitions;
140 vcSettings = aState.vcSettings;
141
142 // do not copy stateStack
143 return *this;
144 }
145
146 bool operator==( const TOOL_MANAGER::TOOL_STATE& aRhs ) const
147 {
148 return aRhs.theTool == theTool;
149 }
150
151 bool operator!=( const TOOL_MANAGER::TOOL_STATE& aRhs ) const
152 {
153 return aRhs.theTool != theTool;
154 }
155
160 void Push()
161 {
162 auto state = std::make_unique<TOOL_STATE>( *this );
163 stateStack.push( std::move( state ) );
164 clear();
165 }
166
173 bool Pop()
174 {
175 delete cofunc;
176
177 if( !stateStack.empty() )
178 {
179 *this = *stateStack.top().get();
180 stateStack.pop();
181 return true;
182 }
183 else
184 {
185 cofunc = nullptr;
186 return false;
187 }
188 }
189
190private:
192 std::stack<std::unique_ptr<TOOL_STATE>> stateStack;
193
195 void clear()
196 {
197 idle = true;
198 shutdown = false;
199 pendingWait = false;
200 pendingContextMenu = false;
201 cofunc = nullptr;
202 contextMenu = nullptr;
204 vcSettings.Reset();
205 transitions.clear();
206 }
207};
208
209
211 m_model( nullptr ),
212 m_view( nullptr ),
213 m_viewControls( nullptr ),
214 m_frame( nullptr ),
215 m_settings( nullptr ),
217 m_menuActive( false ),
218 m_menuOwner( -1 ),
219 m_activeState( nullptr ),
220 m_shuttingDown( false )
221{
222 m_actionMgr = new ACTION_MANAGER( this );
223}
224
225
227{
228 std::map<TOOL_BASE*, TOOL_STATE*>::iterator it, it_end;
229
230 for( it = m_toolState.begin(), it_end = m_toolState.end(); it != it_end; ++it )
231 {
232 delete it->second->cofunc; // delete cofunction
233 delete it->second; // delete TOOL_STATE
234 delete it->first; // delete the tool itself
235 }
236
237 delete m_actionMgr;
238}
239
240
242{
243 wxASSERT_MSG( m_toolNameIndex.find( aTool->GetName() ) == m_toolNameIndex.end(),
244 wxT( "Adding two tools with the same name may result in unexpected behavior.") );
245 wxASSERT_MSG( m_toolIdIndex.find( aTool->GetId() ) == m_toolIdIndex.end(),
246 wxT( "Adding two tools with the same ID may result in unexpected behavior.") );
247 wxASSERT_MSG( m_toolTypes.find( typeid( *aTool ).name() ) == m_toolTypes.end(),
248 wxT( "Adding two tools of the same type may result in unexpected behavior.") );
249
250 wxLogTrace( kicadTraceToolStack,
251 wxS( "TOOL_MANAGER::RegisterTool: Registering tool %s with ID %d" ),
252 aTool->GetName(), aTool->GetId() );
253
254 m_toolOrder.push_back( aTool );
255
256 TOOL_STATE* st = new TOOL_STATE( aTool );
257
258 m_toolState[aTool] = st;
259 m_toolNameIndex[aTool->GetName()] = st;
260 m_toolIdIndex[aTool->GetId()] = st;
261 m_toolTypes[typeid( *aTool ).name()] = st->theTool;
262
263 aTool->attachManager( this );
264}
265
266
268{
269 TOOL_BASE* tool = FindTool( aToolId );
270
271 if( tool && tool->GetType() == INTERACTIVE )
272 return invokeTool( tool );
273
274 wxLogTrace( kicadTraceToolStack, wxS( "TOOL_MANAGER::InvokeTool - no tool with ID %d" ),
275 aToolId );
276
277 return false; // there is no tool with the given id
278}
279
280
281bool TOOL_MANAGER::InvokeTool( const std::string& aToolName )
282{
283 TOOL_BASE* tool = FindTool( aToolName );
284
285 if( tool && tool->GetType() == INTERACTIVE )
286 return invokeTool( tool );
287
288 wxLogTrace( kicadTraceToolStack, wxS( "TOOL_MANAGER::InvokeTool - no tool with name %s" ),
289 aToolName );
290
291 return false; // there is no tool with the given name
292}
293
294
295bool TOOL_MANAGER::doRunAction( const std::string& aActionName, bool aNow, const ki::any& aParam,
296 COMMIT* aCommit )
297{
298 TOOL_ACTION* action = m_actionMgr->FindAction( aActionName );
299
300 if( !action )
301 {
302 wxASSERT_MSG( false, wxString::Format( "Could not find action %s.", aActionName ) );
303 return false;
304 }
305
306 doRunAction( *action, aNow, aParam, aCommit );
307
308 return true;
309}
310
311
313{
314 if( m_viewControls )
315 return m_viewControls->GetMousePosition();
316 else
318}
319
320
322{
323 if( m_viewControls )
324 return m_viewControls->GetCursorPosition();
325 else
327}
328
329
330bool TOOL_MANAGER::doRunAction( const TOOL_ACTION& aAction, bool aNow, const ki::any& aParam,
331 COMMIT* aCommit, bool aFromAPI )
332{
333 if( m_shuttingDown )
334 return true;
335
336 bool retVal = false;
337 TOOL_EVENT event = aAction.MakeEvent();
338
339 if( event.Category() == TC_COMMAND )
341
342 // Allow to override the action parameter
343 if( aParam.has_value() )
344 event.SetParameter( aParam );
345
346 if( aNow )
347 {
348 TOOL_STATE* current = m_activeState;
349
350 // An event with a commit must be run synchronously
351 if( aCommit )
352 {
353 // We initialize the SYNCHRONOUS state to finished so that tools that don't have an
354 // event loop won't hang if someone forgets to set the state.
355 std::atomic<SYNCRONOUS_TOOL_STATE> synchronousControl = STS_FINISHED;
356
357 event.SetSynchronous( &synchronousControl );
358 event.SetCommit( aCommit );
359
360 processEvent( event );
361
362 while( synchronousControl == STS_RUNNING )
363 {
364 wxYield(); // Needed to honor mouse (and other) events during editing
365 wxMilliSleep( 1 ); // Needed to avoid 100% use of one cpu core.
366 // The sleeping time must be must be small to avoid
367 // noticeable lag in mouse and editing events
368 // (1 to 5 ms is a good value)
369 }
370
371 retVal = synchronousControl != STS_CANCELLED;
372 }
373 else
374 {
375 retVal = processEvent( event );
376 }
377
378 setActiveState( current );
379 UpdateUI( event );
380 }
381 else
382 {
383 // It is really dangerous to pass a commit (whose lifetime we can't guarantee) to
384 // deferred event processing. There is a possibility that user actions will get run
385 // in between, which might either affect the lifetime of the commit or push or pop
386 // other commits. However, we don't currently have a better solution for the API.
387 if( aCommit )
388 {
389 wxASSERT_MSG( aFromAPI, wxT( "Deferred actions have no way of guaranteeing the "
390 "lifetime of the COMMIT object" ) );
391 event.SetCommit( aCommit );
392 }
393
394 PostEvent( event );
395 }
396
397 return retVal;
398}
399
400
402{
404
405 processEvent( evt );
406}
407
408
409void TOOL_MANAGER::PrimeTool( const VECTOR2D& aPosition )
410{
411 int modifiers = 0;
412
413 /*
414 * Don't include any modifiers. They're part of the hotkey, not part of the resulting
415 * click.
416 *
417 * modifiers |= wxGetKeyState( WXK_SHIFT ) ? MD_SHIFT : 0;
418 * modifiers |= wxGetKeyState( WXK_CONTROL ) ? MD_CTRL : 0;
419 * modifiers |= wxGetKeyState( WXK_ALT ) ? MD_ALT : 0;
420 */
421
422 TOOL_EVENT evt( TC_MOUSE, TA_PRIME, BUT_LEFT | modifiers );
423 evt.SetMousePosition( aPosition );
424
425 PostEvent( evt );
426}
427
428
430{
431 // Horrific hack, but it's a crash bug. Don't let inter-frame commands stack up
432 // waiting to be processed.
433 if( aEvent.IsSimulator() && m_eventQueue.size() > 0 && m_eventQueue.back().IsSimulator() )
434 m_eventQueue.pop_back();
435
436 m_eventQueue.push_back( aEvent );
437}
438
439
440int TOOL_MANAGER::GetHotKey( const TOOL_ACTION& aAction ) const
441{
442 return m_actionMgr->GetHotKey( aAction );
443}
444
445
447{
448 wxASSERT( aTool != nullptr );
449
450 TOOL_EVENT evt( TC_COMMAND, TA_ACTIVATE, aTool->GetName() );
452 processEvent( evt );
453
454 if( TOOL_STATE* active = GetCurrentToolState() )
455 setActiveState( active );
456
457 return true;
458}
459
460
462{
463 wxASSERT( aTool != nullptr );
464
465 wxString msg = wxString::Format( wxS( "TOOL_MANAGER::runTool - running tool %s" ), aTool->GetName() );
466 APP_MONITOR::AddTransactionBreadcrumb( msg, "tool.run" );
467
468 if( !isRegistered( aTool ) )
469 {
470 wxASSERT_MSG( false, wxT( "You cannot run unregistered tools" ) );
471 return false;
472 }
473
474 TOOL_ID id = aTool->GetId();
475
476 wxLogTrace( kicadTraceToolStack, msg,
477 aTool->GetName() );
478
479 if( aTool->GetType() == INTERACTIVE )
480 static_cast<TOOL_INTERACTIVE*>( aTool )->resetTransitions();
481
482 // If the tool is already active, bring it to the top of the active tools stack
483 if( isActive( aTool ) && m_activeTools.size() > 1 )
484 {
485 auto it = std::find( m_activeTools.begin(), m_activeTools.end(), id );
486
487 if( it != m_activeTools.end() )
488 {
489 if( it != m_activeTools.begin() )
490 {
491 m_activeTools.erase( it );
492 m_activeTools.push_front( id );
493 }
494
495 return false;
496 }
497 }
498
501
502 // Add the tool on the front of the processing queue (it gets events first)
503 m_activeTools.push_front( id );
504
505 return true;
506}
507
508
510{
511 m_shuttingDown = true;
512
513 // Create a temporary list of tools to iterate over since when the tools shutdown
514 // they remove themselves from the list automatically (invalidating the iterator)
515 ID_LIST tmpList = m_activeTools;
516
517 // Make sure each tool knows that it is shutting down, so that loops get shut down
518 // at the dispatcher
519 for( auto id : tmpList )
520 {
521 if( m_toolIdIndex.count( id ) == 0 )
522 continue;
523
524 m_toolIdIndex[id]->shutdown = true;
525 }
526
527 for( auto id : tmpList )
528 {
529 ShutdownTool( id );
530 }
531}
532
533
535{
536 TOOL_BASE* tool = FindTool( aToolId );
537
538 if( tool && tool->GetType() == INTERACTIVE )
539 ShutdownTool( tool );
540
541 wxLogTrace( kicadTraceToolStack, wxS( "TOOL_MANAGER::ShutdownTool - no tool with ID %d" ),
542 aToolId );
543}
544
545
546void TOOL_MANAGER::ShutdownTool( const std::string& aToolName )
547{
548 TOOL_BASE* tool = FindTool( aToolName );
549
550 if( tool && tool->GetType() == INTERACTIVE )
551 ShutdownTool( tool );
552
553 wxLogTrace( kicadTraceToolStack, wxS( "TOOL_MANAGER::ShutdownTool - no tool with name %s" ),
554 aToolName );
555}
556
557
559{
560 wxASSERT( aTool != nullptr );
561
562 TOOL_ID id = aTool->GetId();
563
564 if( isActive( aTool ) )
565 {
566 TOOL_MANAGER::ID_LIST::iterator it = std::find( m_activeTools.begin(),
567 m_activeTools.end(), id );
568
569 TOOL_STATE* st = m_toolIdIndex[*it];
570
571 // the tool state handler is waiting for events (i.e. called Wait() method)
572 if( st && st->pendingWait )
573 {
574 // Wake up the tool and tell it to shutdown
575 st->shutdown = true;
576 st->pendingWait = false;
577 st->waitEvents.clear();
578
579 if( st->cofunc )
580 {
581 wxLogTrace( kicadTraceToolStack,
582 wxS( "TOOL_MANAGER::ShutdownTool - Shutting down tool %s" ),
583 st->theTool->GetName() );
584
585 setActiveState( st );
586 bool end = !st->cofunc->Resume();
587
588 if( end )
589 finishTool( st );
590 }
591 }
592 }
593}
594
595
597{
598 std::map<TOOL_ID, TOOL_STATE*>::const_iterator it = m_toolIdIndex.find( aId );
599
600 if( it != m_toolIdIndex.end() )
601 return it->second->theTool;
602
603 return nullptr;
604}
605
606
607TOOL_BASE* TOOL_MANAGER::FindTool( const std::string& aName ) const
608{
609 std::map<std::string, TOOL_STATE*>::const_iterator it = m_toolNameIndex.find( aName );
610
611 if( it != m_toolNameIndex.end() )
612 return it->second->theTool;
613
614 return nullptr;
615}
616
617
619{
620 // Deactivate the active tool, but do not run anything new
622 processEvent( evt );
623}
624
625
627{
628 if( aReason != TOOL_BASE::REDRAW )
630
631 for( auto& state : m_toolState )
632 {
633 TOOL_BASE* tool = state.first;
634
635 wxLogTrace( kicadTraceToolStack, wxS( "TOOL_MANAGER::ResetTools: Resetting tool '%s'" ),
636 tool->GetName() );
637
638 setActiveState( state.second );
639 tool->Reset( aReason );
640
641 if( tool->GetType() == INTERACTIVE )
642 static_cast<TOOL_INTERACTIVE*>( tool )->resetTransitions();
643 }
644}
645
646
648{
649 for( auto it = m_toolOrder.begin(); it != m_toolOrder.end(); /* iter inside */ )
650 {
651 TOOL_BASE* tool = *it;
652 wxASSERT( m_toolState.count( tool ) );
653 TOOL_STATE* state = m_toolState[tool];
654 setActiveState( state );
655 ++it; // keep the iterator valid if the element is going to be erased
656
657 if( !tool->Init() )
658 {
659 wxLogTrace( kicadTraceToolStack,
660 wxS( "TOOL_MANAGER initialization of tool '%s' failed" ),
661 tool->GetName() );
662
663 // Unregister the tool
664 setActiveState( nullptr );
665 m_toolState.erase( tool );
666 m_toolNameIndex.erase( tool->GetName() );
667 m_toolIdIndex.erase( tool->GetId() );
668 m_toolTypes.erase( typeid( *tool ).name() );
669
670 delete state;
671 delete tool;
672 }
673 }
674
675 m_actionMgr->UpdateHotKeys( true );
676
678}
679
680
681int TOOL_MANAGER::GetPriority( int aToolId ) const
682{
683 int priority = 0;
684
685 for( TOOL_ID tool : m_activeTools )
686 {
687 if( tool == aToolId )
688 return priority;
689
690 ++priority;
691 }
692
693 return -1;
694}
695
696
698 const TOOL_EVENT_LIST& aConditions )
699{
700 TOOL_STATE* st = m_toolState[aTool];
701
702 st->transitions.emplace_back( TRANSITION( aConditions, aHandler ) );
703}
704
705
707{
708 m_toolState[aTool]->transitions.clear();
709}
710
711
712void TOOL_MANAGER::RunMainStack( TOOL_BASE* aTool, std::function<void()> aFunc )
713{
714 TOOL_STATE* st = m_toolState[aTool];
715 setActiveState( st );
716 wxCHECK( st->cofunc, /* void */ );
717 st->cofunc->RunMainStack( std::move( aFunc ) );
718}
719
720
722{
723 TOOL_STATE* st = m_toolState[aTool];
724
725 wxCHECK( !st->pendingWait, nullptr ); // everything collapses on two KiYield() in a row
726
727 // indicate to the manager that we are going to sleep and we shall be
728 // woken up when an event matching aConditions arrive
729 st->pendingWait = true;
730 st->waitEvents = aConditions;
731
732 wxCHECK( st->cofunc, nullptr );
733
734 // switch context back to event dispatcher loop
735 st->cofunc->KiYield();
736
737 // If the tool should shutdown, it gets a null event to break the loop
738 if( st->shutdown )
739 return nullptr;
740 else
741 return &st->wakeupEvent;
742}
743
744
746{
747 bool handled = false;
748
749 wxLogTrace( kicadTraceToolStack, wxS( "TOOL_MANAGER::dispatchInternal - received event: %s" ),
750 aEvent.Format() );
751
752 auto it = m_activeTools.begin();
753
754 // iterate over active tool stack
755 while( it != m_activeTools.end() )
756 {
757 TOOL_STATE* st = m_toolIdIndex[*it];
758 bool increment = true;
759
760 // forward context menu events to the tool that created the menu
761 if( aEvent.IsChoiceMenu() )
762 {
763 if( *it != m_menuOwner )
764 {
765 ++it;
766 continue;
767 }
768 }
769
770 // If we're pendingWait then we had better have a cofunc to process the wait.
771 wxASSERT( !st || !st->pendingWait || st->cofunc );
772
773 // the tool state handler is waiting for events (i.e. called Wait() method)
774 if( st && st->cofunc && st->pendingWait && st->waitEvents.Matches( aEvent ) )
775 {
776 if( !aEvent.FirstResponder() )
777 aEvent.SetFirstResponder( st->theTool );
778
779 // got matching event? clear wait list and wake up the coroutine
780 st->wakeupEvent = aEvent;
781 st->pendingWait = false;
782 st->waitEvents.clear();
783
784 wxLogTrace( kicadTraceToolStack,
785 wxS( "TOOL_MANAGER::dispatchInternal - Waking tool %s for event: %s" ),
786 st->theTool->GetName(), aEvent.Format() );
787
788 setActiveState( st );
789 bool end = !st->cofunc->Resume();
790
791 if( end )
792 {
793 it = finishTool( st );
794 increment = false;
795 }
796
797 // If the tool did not request the event be passed to other tools, we're done
798 if( !st->wakeupEvent.PassEvent() )
799 {
800 wxLogTrace( kicadTraceToolStack,
801 wxS( "TOOL_MANAGER::dispatchInternal - tool %s stopped passing "
802 "event: %s" ),
803 st->theTool->GetName(), aEvent.Format() );
804
805 return true;
806 }
807 }
808
809 if( increment )
810 ++it;
811 }
812
813 for( const auto& state : m_toolState )
814 {
815 TOOL_STATE* st = state.second;
816 bool finished = false;
817
818 // no state handler in progress - check if there are any transitions (defined by
819 // Go() method that match the event.
820 if( !st->transitions.empty() )
821 {
822 for( const TRANSITION& tr : st->transitions )
823 {
824 if( tr.first.Matches( aEvent ) )
825 {
826 auto func_copy = tr.second;
827
828 if( !aEvent.FirstResponder() )
829 aEvent.SetFirstResponder( st->theTool );
830
831 // if there is already a context, then push it on the stack
832 // and transfer the previous view control settings to the new context
833 if( st->cofunc )
834 {
835 KIGFX::VC_SETTINGS viewControlSettings = st->vcSettings;
836 st->Push();
837 st->vcSettings = std::move( viewControlSettings );
838 }
839
840 st->cofunc = new COROUTINE<int, const TOOL_EVENT&>( std::move( func_copy ) );
841
842 wxLogTrace( kicadTraceToolStack,
843 wxS( "TOOL_MANAGER::dispatchInternal - Running tool %s for "
844 "event: %s" ),
845 st->theTool->GetName(), aEvent.Format() );
846
847 // got match? Run the handler.
848 setActiveState( st );
849 st->idle = false;
850 st->initialEvent = aEvent;
851 st->cofunc->Call( st->initialEvent );
852 handled = true;
853
854 if( !st->cofunc->Running() )
855 finishTool( st ); // The coroutine has finished immediately?
856
857 // if it is a message, continue processing
858 finished = !( aEvent.Category() == TC_MESSAGE );
859
860 // there is no point in further checking, as transitions got cleared
861 break;
862 }
863 }
864 }
865
866 if( finished )
867 break; // only the first tool gets the event
868 }
869
870 wxLogTrace( kicadTraceToolStack, wxS( "TOOL_MANAGER::dispatchInternal - %s handle event: %s" ),
871 ( handled ? wxS( "Did" ) : wxS( "Did not" ) ), aEvent.Format() );
872
873 return handled;
874}
875
876
878{
879 if( aEvent.Action() == TA_KEY_PRESSED )
880 return m_actionMgr->RunHotKey( aEvent.Modifier() | aEvent.KeyCode() );
881
882 return false;
883}
884
885
887{
888 wxLogTrace( kicadTraceToolStack, wxS( "TOOL_MANAGER::dispatchActivation - Received event: %s" ),
889 aEvent.Format() );
890
891 if( aEvent.IsActivate() )
892 {
893 auto tool = m_toolNameIndex.find( aEvent.getCommandStr() );
894
895 if( tool != m_toolNameIndex.end() )
896 {
897 wxLogTrace( kicadTraceToolStack,
898 wxS( "TOOL_MANAGER::dispatchActivation - Running tool %s for event: %s" ),
899 tool->second->theTool->GetName(), aEvent.Format() );
900
901 runTool( tool->second->theTool );
902 return true;
903 }
904 }
905
906 return false;
907}
908
909
911{
912 for( TOOL_ID toolId : m_activeTools )
913 {
914 TOOL_STATE* st = m_toolIdIndex[toolId];
915
916 // the tool requested a context menu. The menu is activated on RMB click (CMENU_BUTTON mode)
917 // or immediately (CMENU_NOW) mode. The latter is used for clarification lists.
918 if( st->contextMenuTrigger == CMENU_OFF )
919 continue;
920
921 if( st->contextMenuTrigger == CMENU_BUTTON && !aEvent.IsClick( BUT_RIGHT ) )
922 break;
923
924 if( st->cofunc )
925 {
926 st->pendingWait = true;
928 }
929
930 // Store the menu pointer in case it is changed by the TOOL when handling menu events
931 ACTION_MENU* m = st->contextMenu;
932
933 if( st->contextMenuTrigger == CMENU_NOW )
935
936 // Store the cursor position, so the tools could execute actions
937 // using the point where the user has invoked a context menu
938 if( m_viewControls )
939 m_menuCursor = m_viewControls->GetCursorPosition();
940
941 // Save all tools cursor settings, as they will be overridden
942 for( const std::pair<const TOOL_ID, TOOL_STATE*>& idState : m_toolIdIndex )
943 {
944 TOOL_STATE* s = idState.second;
945 const auto& vc = s->vcSettings;
946
947 if( vc.m_forceCursorPosition )
948 m_cursorSettings[idState.first] = vc.m_forcedPosition;
949 else
950 m_cursorSettings[idState.first] = std::nullopt;
951 }
952
953 if( m_viewControls )
954 m_viewControls->ForceCursorPosition( true, m_menuCursor );
955
956 // Display a copy of menu
957 std::unique_ptr<ACTION_MENU> menu( m->Clone() );
958
959 m_menuOwner = toolId;
960 m_menuActive = true;
961
962 if( wxWindow* frame = dynamic_cast<wxWindow*>( m_frame ) )
963 frame->PopupMenu( menu.get() );
964
965 // Warp the cursor if a menu item was selected
966 if( menu->GetSelected() >= 0 )
967 {
969 m_viewControls->WarpMouseCursor( m_menuCursor, true, false );
970 }
971 // Otherwise notify the tool of a canceled menu
972 else
973 {
975 evt.SetHasPosition( false );
976 evt.SetParameter( m );
977 dispatchInternal( evt );
978 }
979
980 // Restore setting in case it was vetoed
982
983 // Notify the tools that menu has been closed
985 evt.SetHasPosition( false );
986 evt.SetParameter( m );
987 dispatchInternal( evt );
988
989 m_menuActive = false;
990 m_menuOwner = -1;
991
992 // Restore cursor settings
993 for( const std::pair<const TOOL_ID,
994 std::optional<VECTOR2D>>& cursorSetting : m_cursorSettings )
995 {
996 auto it = m_toolIdIndex.find( cursorSetting.first );
997 wxASSERT( it != m_toolIdIndex.end() );
998
999 if( it == m_toolIdIndex.end() )
1000 continue;
1001
1002 KIGFX::VC_SETTINGS& vc = it->second->vcSettings;
1003 vc.m_forceCursorPosition = (bool) cursorSetting.second;
1004 vc.m_forcedPosition = cursorSetting.second ? *cursorSetting.second : VECTOR2D( 0, 0 );
1005 }
1006
1007 m_cursorSettings.clear();
1008 break;
1009 }
1010}
1011
1012
1014{
1016 m_viewControls->WarpMouseCursor( m_menuCursor, true, false );
1017
1018 // Don't warp again when the menu is closed
1020}
1021
1022
1023TOOL_MANAGER::ID_LIST::iterator TOOL_MANAGER::finishTool( TOOL_STATE* aState )
1024{
1025 auto it = std::find( m_activeTools.begin(), m_activeTools.end(), aState->theTool->GetId() );
1026
1027 if( !aState->Pop() )
1028 {
1029 // Deactivate the tool if there are no other contexts saved on the stack
1030 if( it != m_activeTools.end() )
1031 it = m_activeTools.erase( it );
1032
1033 aState->idle = true;
1034 }
1035
1036 if( aState == m_activeState )
1037 setActiveState( nullptr );
1038
1039 return it;
1040}
1041
1042
1044{
1045 // Once the tool manager is shutting down, don't start
1046 // activating more tools
1047 if( m_shuttingDown )
1048 return true;
1049
1050 bool handled = processEvent( aEvent );
1051
1052 TOOL_STATE* activeTool = GetCurrentToolState();
1053
1054 if( activeTool )
1055 setActiveState( activeTool );
1056
1057 if( m_view && m_view->IsDirty() )
1058 {
1059#if defined( __WXMAC__ )
1060 wxTheApp->ProcessPendingEvents(); // required for updating brightening behind a popup menu
1061#endif
1062 }
1063
1064 UpdateUI( aEvent );
1065
1066 return handled;
1067}
1068
1069
1071 CONTEXT_MENU_TRIGGER aTrigger )
1072{
1073 TOOL_STATE* st = m_toolState[aTool];
1074
1075 st->contextMenu = aMenu;
1076 st->contextMenuTrigger = aTrigger;
1077}
1078
1079
1081{
1082 if( TOOL_STATE* active = GetCurrentToolState() )
1083 return active->vcSettings;
1084
1085 return m_viewControls->GetSettings();
1086}
1087
1088
1089TOOL_ID TOOL_MANAGER::MakeToolId( const std::string& aToolName )
1090{
1091 static int currentId;
1092
1093 return currentId++;
1094}
1095
1096
1098 KIGFX::VIEW_CONTROLS* aViewControls,
1099 APP_SETTINGS_BASE* aSettings, TOOLS_HOLDER* aFrame )
1100{
1101 m_model = aModel;
1102 m_view = aView;
1103 m_viewControls = aViewControls;
1104 m_frame = aFrame;
1105 m_settings = aSettings;
1106}
1107
1108
1110{
1111 if( !isRegistered( aTool ) )
1112 return false;
1113
1114 // Just check if the tool is on the active tools stack
1115 return alg::contains( m_activeTools, aTool->GetId() );
1116}
1117
1118
1120{
1121 aState->vcSettings = m_viewControls->GetSettings();
1122
1123 if( m_menuActive )
1124 {
1125 // Context menu is active, so the cursor settings are overridden (see DispatchContextMenu())
1126 auto it = m_cursorSettings.find( aState->theTool->GetId() );
1127
1128 if( it != m_cursorSettings.end() )
1129 {
1130 const KIGFX::VC_SETTINGS& curr = m_viewControls->GetSettings();
1131
1132 // Tool has overridden the cursor position, so store the new settings
1134 {
1135 if( !curr.m_forceCursorPosition )
1136 it->second = std::nullopt;
1137 else
1138 it->second = curr.m_forcedPosition;
1139 }
1140 else
1141 {
1142 std::optional<VECTOR2D> cursor = it->second;
1143
1144 if( cursor )
1145 {
1146 aState->vcSettings.m_forceCursorPosition = true;
1148 }
1149 else
1150 {
1151 aState->vcSettings.m_forceCursorPosition = false;
1152 }
1153 }
1154 }
1155 }
1156}
1157
1158
1160{
1161 m_viewControls->ApplySettings( aState->vcSettings );
1162}
1163
1164
1166{
1167 wxLogTrace( kicadTraceToolStack, wxS( "TOOL_MANAGER::processEvent - %s" ), aEvent.Format() );
1168
1169 // First try to dispatch the action associated with the event if it is a key press event
1170 bool handled = DispatchHotKey( aEvent );
1171
1172 if( !handled )
1173 {
1174 TOOL_EVENT mod_event( aEvent );
1175
1176 // Only immediate actions get the position. Otherwise clear for tool activation
1177 if( GetToolHolder() && !GetToolHolder()->GetDoImmediateActions() )
1178 {
1179 // An tool-selection-event has no position
1180 if( !mod_event.getCommandStr().empty()
1181 && mod_event.getCommandStr() != GetToolHolder()->CurrentToolName()
1182 && !mod_event.ForceImmediate() )
1183 {
1184 mod_event.SetHasPosition( false );
1185 }
1186 }
1187
1188 // If the event is not handled through a hotkey activation, pass it to the currently
1189 // running tool loops
1190 handled |= dispatchInternal( mod_event );
1191 handled |= dispatchActivation( mod_event );
1192
1193 // Open the context menu if requested by a tool
1194 DispatchContextMenu( mod_event );
1195
1196 // Dispatch any remaining events in the event queue
1197 while( !m_eventQueue.empty() )
1198 {
1199 TOOL_EVENT event = m_eventQueue.front();
1200 m_eventQueue.pop_front();
1201 processEvent( event );
1202 }
1203 }
1204
1205 wxLogTrace( kicadTraceToolStack, wxS( "TOOL_MANAGER::processEvent - %s handle event: %s" ),
1206 ( handled ? "Did" : "Did not" ), aEvent.Format() );
1207
1208 return handled;
1209}
1210
1211
1213{
1216
1217 m_activeState = aState;
1218
1220 applyViewControls( aState );
1221}
1222
1223
1225{
1226 auto it = m_toolIdIndex.find( aId );
1227
1228 if( it == m_toolIdIndex.end() )
1229 return false;
1230
1231 return !it->second->idle;
1232}
1233
1234
1236{
1237 EDA_BASE_FRAME* frame = dynamic_cast<EDA_BASE_FRAME*>( GetToolHolder() );
1238
1239 if( frame )
1240 frame->UpdateStatusBar();
1241}
Manage TOOL_ACTION objects.
Define the structure of a menu based on ACTIONs.
Definition action_menu.h:47
ACTION_MENU * Clone() const
Create a deep, recursive copy of this ACTION_MENU.
APP_SETTINGS_BASE is a settings class that should be derived for each standalone KiCad application.
Represent a set of changes (additions, deletions or modifications) of a data model (e....
Definition commit.h:72
Implement a coroutine.
Definition coroutine.h:84
bool Call(ArgType aArg)
Start execution of a coroutine, passing args as its arguments.
Definition coroutine.h:274
void KiYield()
Stop execution of the coroutine and returns control to the caller.
Definition coroutine.h:237
bool Resume()
Resume execution of a previously yielded coroutine.
Definition coroutine.h:320
bool Running() const
Definition coroutine.h:369
void RunMainStack(std::function< void()> func)
Run a functor inside the application main stack context.
Definition coroutine.h:260
The base frame for deriving all KiCad main window classes.
virtual void UpdateStatusBar()
Update the status bar information.
A base class for most all the KiCad significant classes used in schematics and boards.
Definition eda_item.h:98
An interface for classes handling user events controlling the view behavior such as zooming,...
Hold a (potentially large) number of VIEW_ITEMs and renders them on a graphics device provided by the...
Definition view.h:66
Represent a single user action.
TOOL_EVENT MakeEvent() const
Return the event associated with the action (i.e.
Base abstract interface for all kinds of tools.
Definition tool_base.h:66
virtual void Reset(RESET_REASON aReason)=0
Bring the tool to a known, initial state.
virtual bool Init()
Init() is called once upon a registration of the tool.
Definition tool_base.h:92
const std::string & GetName() const
Return the name of the tool.
Definition tool_base.h:136
TOOL_TYPE GetType() const
Return the type of the tool.
Definition tool_base.h:111
RESET_REASON
Determine the reason of reset for a tool.
Definition tool_base.h:78
@ REDRAW
Full drawing refresh.
Definition tool_base.h:83
@ RUN
Tool is invoked after being inactive.
Definition tool_base.h:79
TOOL_ID GetId() const
Return the unique identifier of the tool.
Definition tool_base.h:123
void attachManager(TOOL_MANAGER *aManager)
Set the TOOL_MANAGER the tool will belong to.
Definition tool_base.cpp:62
A list of TOOL_EVENTs, with overloaded || operators allowing for concatenating TOOL_EVENTs with littl...
Definition tool_event.h:648
OPT_TOOL_EVENT Matches(const TOOL_EVENT &aEvent) const
Definition tool_event.h:687
Generic, UI-independent tool event.
Definition tool_event.h:171
bool PassEvent() const
These give a tool a method of informing the TOOL_MANAGER that a particular event should be passed on ...
Definition tool_event.h:255
TOOL_ACTIONS Action() const
Returns more specific information about the type of an event.
Definition tool_event.h:250
void SetMousePosition(const VECTOR2D &aP)
Definition tool_event.h:538
int KeyCode() const
Definition tool_event.h:376
TOOL_BASE * FirstResponder() const
Definition tool_event.h:268
bool IsActivate() const
Definition tool_event.h:345
void SetFirstResponder(TOOL_BASE *aTool)
Definition tool_event.h:269
bool IsSimulator() const
Indicate if the event is from the simulator.
void SetParameter(T aParam)
Set a non-standard parameter assigned to the event.
Definition tool_event.h:528
bool ForceImmediate() const
Returns if the action associated with this event should be treated as immediate regardless of the cur...
Definition tool_event.h:265
bool IsClick(int aButtonMask=BUT_ANY) const
TOOL_EVENT_CATEGORY Category() const
Return the category (eg. mouse/keyboard/action) of an event.
Definition tool_event.h:247
int Modifier(int aMask=MD_MODIFIER_MASK) const
Return information about key modifiers state (Ctrl, Alt, etc.).
Definition tool_event.h:366
void SetHasPosition(bool aHasPosition)
Definition tool_event.h:261
const std::string & getCommandStr() const
Definition tool_event.h:558
bool IsChoiceMenu() const
Definition tool_event.h:355
const std::string Format() const
Return information about event in form of a human-readable string.
void applyViewControls(const TOOL_STATE *aState)
Apply #VIEW_CONTROLS settings stored in a TOOL_STATE object.
int GetPriority(int aToolId) const
Return priority of a given tool.
bool ProcessEvent(const TOOL_EVENT &aEvent)
Propagate an event to tools that requested events of matching type(s).
TOOL_STATE * m_activeState
Pointer to the state object corresponding to the currently executed tool.
void UpdateUI(const TOOL_EVENT &aEvent)
Update the status bar and synchronizes toolbars.
std::map< TOOL_ID, std::optional< VECTOR2D > > m_cursorSettings
Original cursor position, if overridden by the context menu handler.
void PostEvent(const TOOL_EVENT &aEvent)
Put an event to the event queue to be processed at the end of event processing cycle.
void ScheduleNextState(TOOL_BASE *aTool, TOOL_STATE_FUNC &aHandler, const TOOL_EVENT_LIST &aConditions)
Define a state transition.
std::map< const char *, TOOL_BASE * > m_toolTypes
Index of the registered tools to easily lookup by their type.
bool isRegistered(TOOL_BASE *aTool) const
Return information about a tool registration status.
APP_SETTINGS_BASE * m_settings
TOOL_STATE * GetCurrentToolState() const
Return the TOOL_STATE object representing the state of the active tool.
VECTOR2D GetCursorPosition() const
std::list< TOOL_EVENT > m_eventQueue
Queue that stores events to be processed at the end of the event processing cycle.
std::pair< TOOL_EVENT_LIST, TOOL_STATE_FUNC > TRANSITION
void setActiveState(TOOL_STATE *aState)
Save the previous active state and sets a new one.
void DeactivateTool()
Deactivate the currently active tool.
bool dispatchInternal(TOOL_EVENT &aEvent)
Pass an event at first to the active tools, then to all others.
void PrimeTool(const VECTOR2D &aPosition)
"Prime" a tool by sending a cursor left-click event with the mouse position set to the passed in posi...
bool runTool(TOOL_BASE *aTool)
Make a tool active, so it can receive events and react to them.
bool InvokeTool(TOOL_ID aToolId)
Call a tool by sending a tool activation event to tool of given ID.
NAME_STATE_MAP m_toolNameIndex
Index of the registered tools current states, associated by tools' names.
TOOLS_HOLDER * m_frame
void CancelTool()
Send a cancel event to the tool currently at the top of the tool stack.
bool m_warpMouseAfterContextMenu
KIGFX::VIEW_CONTROLS * m_viewControls
void WarpAfterContextMenu()
Normally we warp the mouse after the context menu action runs.
ACTION_MANAGER * m_actionMgr
Instance of ACTION_MANAGER that handles TOOL_ACTIONs.
const KIGFX::VC_SETTINGS & GetCurrentToolVC() const
Return the view controls settings for the current tool or the general settings if there is no active ...
void RunMainStack(TOOL_BASE *aTool, std::function< void()> aFunc)
TOOLS_HOLDER * GetToolHolder() const
VECTOR2D GetMousePosition() const
bool processEvent(const TOOL_EVENT &aEvent)
Main function for event processing.
std::list< TOOL_ID > ID_LIST
ID_LIST::iterator finishTool(TOOL_STATE *aState)
Deactivate a tool and does the necessary clean up.
bool doRunAction(const TOOL_ACTION &aAction, bool aNow, const ki::any &aParam, COMMIT *aCommit, bool aFromAPI=false)
Helper function to actually run an action.
bool dispatchActivation(const TOOL_EVENT &aEvent)
Check if it is a valid activation event and invokes a proper tool.
ID_STATE_MAP m_toolIdIndex
Index of the registered tools current states, associated by tools' ID numbers.
TOOL_ID m_menuOwner
Tool currently displaying a popup menu. It is negative when there is no menu displayed.
KIGFX::VIEW * m_view
void ClearTransitions(TOOL_BASE *aTool)
Clear the state transition map for a tool.
bool m_shuttingDown
True if the tool manager is shutting down (don't process additional events)
void saveViewControls(TOOL_STATE *aState)
Save the #VIEW_CONTROLS settings to the tool state object.
int GetHotKey(const TOOL_ACTION &aAction) const
Return the hot key associated with a given action or 0 if there is none.
bool m_menuActive
Flag indicating whether a context menu is currently displayed.
TOOL_STATE_MAP m_toolState
Index of registered tools current states, associated by tools' objects.
void ShutdownTool(TOOL_BASE *aTool)
Shutdown the specified tool by waking it up with a null event to terminate the processing loop.
ID_LIST m_activeTools
Stack of the active tools.
void ResetTools(TOOL_BASE::RESET_REASON aReason)
Reset all tools (i.e.
EDA_ITEM * m_model
bool DispatchHotKey(const TOOL_EVENT &aEvent)
Handle specific events, that are intended for TOOL_MANAGER rather than tools.
static TOOL_ID MakeToolId(const std::string &aToolName)
Generate a unique ID from for a tool with given name.
bool invokeTool(TOOL_BASE *aTool)
Invoke a tool by sending a proper event (in contrary to runTool, which makes the tool run for real).
void DispatchContextMenu(const TOOL_EVENT &aEvent)
Handle context menu related events.
std::vector< TOOL_BASE * > m_toolOrder
List of tools in the order they were registered.
TOOL_BASE * FindTool(int aId) const
Search for a tool with given ID.
void ScheduleContextMenu(TOOL_BASE *aTool, ACTION_MENU *aMenu, CONTEXT_MENU_TRIGGER aTrigger)
Set behavior of the tool's context popup menu.
TOOL_EVENT * ScheduleWait(TOOL_BASE *aTool, const TOOL_EVENT_LIST &aConditions)
Pause execution of a given tool until one or more events matching aConditions arrives.
bool IsToolActive(TOOL_ID aId) const
Return true if a tool with given id is active (executing)
bool isActive(TOOL_BASE *aTool) const
Return information about a tool activation status.
void RegisterTool(TOOL_BASE *aTool)
Add a tool to the manager set and sets it up.
void SetEnvironment(EDA_ITEM *aModel, KIGFX::VIEW *aView, KIGFX::VIEW_CONTROLS *aViewControls, APP_SETTINGS_BASE *aSettings, TOOLS_HOLDER *aFrame)
Set the work environment (model, view, view controls and the parent window).
void InitTools()
Initialize all registered tools.
VECTOR2D m_menuCursor
Right click context menu position.
void ShutdownAllTools()
Shutdown all tools with a currently registered event loop in this tool manager by waking them up with...
A type-safe container of any type.
Definition ki_any.h:93
bool has_value() const noexcept
Report whether there is a contained object or not.
Definition ki_any.h:312
Base window classes and related definitions.
const wxChar *const kicadTraceToolStack
Flag to enable tracing of the tool handling stack.
void AddTransactionBreadcrumb(const wxString &aMsg, const wxString &aCategory)
Add a transaction breadcrumb.
wxPoint GetMousePosition()
Returns the mouse position in screen coordinates.
Definition wxgtk/ui.cpp:689
bool contains(const _Container &__container, _Value __value)
Returns true if the container contains the given value.
Definition kicad_algo.h:100
Structure to keep VIEW_CONTROLS settings for easy store/restore operations.
VECTOR2D m_forcedPosition
Forced cursor position (world coordinates).
bool m_forceCursorPosition
Is the forced cursor position enabled.
Struct describing the current execution state of a TOOL.
bool operator!=(const TOOL_MANAGER::TOOL_STATE &aRhs) const
bool Pop()
Restore state of the tool from stack.
bool pendingWait
Flag defining if the tool is waiting for any event (i.e.
bool pendingContextMenu
Is there a context menu being displayed.
void Push()
Store the current state of the tool on stack.
CONTEXT_MENU_TRIGGER contextMenuTrigger
Defines when the context menu is opened.
TOOL_EVENT initialEvent
The first event that triggered activation of the tool.
KIGFX::VC_SETTINGS vcSettings
VIEW_CONTROLS settings to preserve settings when the tools are switched.
TOOL_STATE(const TOOL_STATE &aState)
TOOL_STATE(TOOL_BASE *aTool)
ACTION_MENU * contextMenu
Context menu currently used by the tool.
bool idle
Is the tool active (pending execution) or disabled at the moment.
std::vector< TRANSITION > transitions
List of possible transitions (ie.
void clear()
Restores the initial state.
TOOL_EVENT_LIST waitEvents
List of events the tool is currently waiting for.
COROUTINE< int, const TOOL_EVENT & > * cofunc
Tool execution context.
bool shutdown
Should the tool shutdown during next execution.
std::stack< std::unique_ptr< TOOL_STATE > > stateStack
Stack preserving previous states of a TOOL.
TOOL_BASE * theTool
The tool itself.
TOOL_EVENT wakeupEvent
The event that triggered the execution/wakeup of the tool after Wait() call.
TOOL_STATE & operator=(const TOOL_STATE &aState)
bool operator==(const TOOL_MANAGER::TOOL_STATE &aRhs) const
VECTOR2I end
std::function< int(const TOOL_EVENT &)> TOOL_STATE_FUNC
Definition tool_base.h:58
int TOOL_ID
Unique identifier for tools.
Definition tool_base.h:56
@ INTERACTIVE
Tool that interacts with the user.
Definition tool_base.h:49
CONTEXT_MENU_TRIGGER
Defines when a context menu is opened.
Definition tool_event.h:154
@ CMENU_NOW
Right now (after TOOL_INTERACTIVE::SetContextMenu).
Definition tool_event.h:156
@ CMENU_OFF
Never.
Definition tool_event.h:157
@ CMENU_BUTTON
On the right button.
Definition tool_event.h:155
@ TA_ANY
Definition tool_event.h:126
@ TA_CHOICE_MENU_CHOICE
Context menu choice.
Definition tool_event.h:98
@ TA_ACTIVATE
Tool activation event.
Definition tool_event.h:115
@ TA_CHOICE_MENU_CLOSED
Context menu is closed, no matter whether anything has been chosen or not.
Definition tool_event.h:101
@ TA_PRIME
Tool priming event (a special mouse click).
Definition tool_event.h:124
@ TA_KEY_PRESSED
Definition tool_event.h:76
@ TA_CANCEL_TOOL
Tool cancel event.
Definition tool_event.h:90
@ TC_ANY
Definition tool_event.h:60
@ TC_COMMAND
Definition tool_event.h:57
@ TC_MOUSE
Definition tool_event.h:55
@ TC_MESSAGE
Definition tool_event.h:58
@ STS_CANCELLED
Definition tool_event.h:164
@ STS_FINISHED
Definition tool_event.h:163
@ STS_RUNNING
Definition tool_event.h:162
@ BUT_LEFT
Definition tool_event.h:132
@ BUT_RIGHT
Definition tool_event.h:133
wxLogTrace helper definitions.
VECTOR2< double > VECTOR2D
Definition vector2d.h:694
VECTOR2D ToVECTOR2D(const wxPoint &aPoint)
Definition vector2wx.h:40