KiCad PCB EDA Suite
TOOL_MANAGER Class Reference

Master controller class: More...

#include <tool_manager.h>

Classes

struct  TOOL_STATE
 Struct describing the current execution state of a TOOL. More...
 

Public Types

typedef std::map< TOOL_BASE *, TOOL_STATE * > TOOL_STATE_MAP
 
typedef std::map< std::string, TOOL_STATE * > NAME_STATE_MAP
 
typedef std::map< TOOL_ID, TOOL_STATE * > ID_STATE_MAP
 
typedef std::list< TOOL_IDID_LIST
 
typedef std::vector< TOOL_BASE * > TOOL_VEC
 

Public Member Functions

 TOOL_MANAGER ()
 
 ~TOOL_MANAGER ()
 
void RegisterTool (TOOL_BASE *aTool)
 Add a tool to the manager set and sets it up. More...
 
bool InvokeTool (TOOL_ID aToolId)
 Call a tool by sending a tool activation event to tool of given ID. More...
 
bool InvokeTool (const std::string &aToolName)
 Call a tool by sending a tool activation event to tool of given name. More...
 
void ShutdownAllTools ()
 Shutdown all tools with a currently registered event loop in this tool manager by waking them up with a null event. More...
 
void ShutdownTool (TOOL_BASE *aTool)
 Shutdown the specified tool by waking it up with a null event to terminate the processing loop. More...
 
void ShutdownTool (TOOL_ID aToolId)
 Shutdown the specified tool by waking it up with a null event to terminate the processing loop. More...
 
void ShutdownTool (const std::string &aToolName)
 Shutdown the specified tool by waking it up with a null event to terminate the processing loop. More...
 
template<typename T >
bool RunAction (const std::string &aActionName, bool aNow=false, T aParam=NULL)
 Run the specified action. More...
 
bool RunAction (const std::string &aActionName, bool aNow, void *aParam)
 
bool RunAction (const std::string &aActionName, bool aNow=false)
 
template<typename T >
bool RunAction (const TOOL_ACTION &aAction, bool aNow=false, T aParam=NULL)
 Run the specified action. More...
 
bool RunAction (const TOOL_ACTION &aAction, bool aNow, void *aParam)
 
bool RunAction (const TOOL_ACTION &aAction, bool aNow=false)
 
const std::map< std::string, TOOL_ACTION * > & GetActions ()
 
void CancelTool ()
 Send a cancel event to the tool currently at the top of the tool stack. More...
 
void PrimeTool (const VECTOR2D &aPosition)
 "Prime" a tool by sending a cursor left-click event with the mouse position set to the passed in position. More...
 
int GetHotKey (const TOOL_ACTION &aAction)
 
ACTION_MANAGERGetActionManager ()
 
TOOL_BASEFindTool (int aId) const
 Search for a tool with given ID. More...
 
TOOL_BASEFindTool (const std::string &aName) const
 Search for a tool with given name. More...
 
template<typename T >
T * GetTool ()
 
void DeactivateTool ()
 Deactivate the currently active tool. More...
 
bool IsToolActive (TOOL_ID aId) const
 Return true if a tool with given id is active (executing) More...
 
void ResetTools (TOOL_BASE::RESET_REASON aReason)
 Reset all tools (i.e. More...
 
void InitTools ()
 Initializes all registered tools. More...
 
bool ProcessEvent (const TOOL_EVENT &aEvent)
 Propagate an event to tools that requested events of matching type(s). More...
 
void PostEvent (const TOOL_EVENT &aEvent)
 Put an event to the event queue to be processed at the end of event processing cycle. More...
 
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). More...
 
KIGFX::VIEWGetView () const
 
KIGFX::VIEW_CONTROLSGetViewControls () const
 
VECTOR2D GetMousePosition ()
 
VECTOR2D GetCursorPosition ()
 
EDA_ITEMGetModel () const
 
APP_SETTINGS_BASEGetSettings () const
 
TOOLS_HOLDERGetToolHolder () const
 
int GetCurrentToolId () const
 Return id of the tool that is on the top of the active tools stack (was invoked the most recently). More...
 
TOOL_BASEGetCurrentTool () const
 Return the tool that is on the top of the active tools stack (was invoked the most recently). More...
 
TOOL_STATEGetCurrentToolState () const
 Return the #TOOL_STATE object representing the state of the active tool. More...
 
int GetPriority (int aToolId) const
 Return priority of a given tool. More...
 
void ScheduleNextState (TOOL_BASE *aTool, TOOL_STATE_FUNC &aHandler, const TOOL_EVENT_LIST &aConditions)
 Define a state transition. More...
 
void ClearTransitions (TOOL_BASE *aTool)
 Clear the state transition map for a tool. More...
 
void RunMainStack (TOOL_BASE *aTool, std::function< void()> aFunc)
 
void UpdateUI (const TOOL_EVENT &aEvent)
 Update the status bar and synchronizes toolbars. More...
 
TOOL_EVENTScheduleWait (TOOL_BASE *aTool, const TOOL_EVENT_LIST &aConditions)
 Pause execution of a given tool until one or more events matching aConditions arrives. More...
 
void ScheduleContextMenu (TOOL_BASE *aTool, ACTION_MENU *aMenu, CONTEXT_MENU_TRIGGER aTrigger)
 Set behavior of the tool's context popup menu. More...
 
bool SaveClipboard (const std::string &aTextUTF8)
 Store information to the system clipboard. More...
 
std::string GetClipboardUTF8 () const
 Return the information currently stored in the system clipboard. More...
 
const KIGFX::VC_SETTINGSGetCurrentToolVC () const
 Return the view controls settings for the current tool or the general settings if there is no active tool. More...
 
bool IsContextMenuActive ()
 True while processing a context menu. More...
 
void VetoContextMenuMouseWarp ()
 Disable mouse warping after the current context menu is closed. More...
 
void DispatchContextMenu (const TOOL_EVENT &aEvent)
 Handle context menu related events. More...
 
bool DispatchHotKey (const TOOL_EVENT &aEvent)
 Handle specific events, that are intended for TOOL_MANAGER rather than tools. More...
 
VECTOR2D GetMenuCursorPos ()
 

Static Public Member Functions

static TOOL_ID MakeToolId (const std::string &aToolName)
 Generates a unique ID from for a tool with given name. More...
 

Private Types

typedef std::pair< TOOL_EVENT_LIST, TOOL_STATE_FUNCTRANSITION
 

Private Member Functions

bool dispatchInternal (const TOOL_EVENT &aEvent)
 Passe an event at first to the active tools, then to all others. More...
 
bool dispatchActivation (const TOOL_EVENT &aEvent)
 Check if it is a valid activation event and invokes a proper tool. More...
 
bool invokeTool (TOOL_BASE *aTool)
 Invoke a tool by sending a proper event (in contrary to runTool, which makes the tool run for real). More...
 
bool runTool (TOOL_BASE *aTool)
 Make a tool active, so it can receive events and react to them. More...
 
ID_LIST::iterator finishTool (TOOL_STATE *aState)
 Deactivate a tool and does the necessary clean up. More...
 
bool isRegistered (TOOL_BASE *aTool) const
 Return information about a tool registration status. More...
 
bool isActive (TOOL_BASE *aTool)
 Return information about a tool activation status. More...
 
void saveViewControls (TOOL_STATE *aState)
 Save the #VIEW_CONTROLS settings to the tool state object. More...
 
void applyViewControls (TOOL_STATE *aState)
 Apply #VIEW_CONTROLS settings stored in a #TOOL_STATE object. More...
 
bool processEvent (const TOOL_EVENT &aEvent)
 Main function for event processing. More...
 
void setActiveState (TOOL_STATE *aState)
 Save the previous active state and sets a new one. More...
 

Private Attributes

TOOL_VEC m_toolOrder
 Index of registered tools current states, associated by tools' objects. More...
 
TOOL_STATE_MAP m_toolState
 Index of the registered tools current states, associated by tools' names. More...
 
NAME_STATE_MAP m_toolNameIndex
 Index of the registered tools current states, associated by tools' ID numbers. More...
 
ID_STATE_MAP m_toolIdIndex
 Index of the registered tools to easily lookup by their type. More...
 
std::map< const char *, TOOL_BASE * > m_toolTypes
 Stack of the active tools. More...
 
ID_LIST m_activeTools
 Instance of ACTION_MANAGER that handles TOOL_ACTIONs. More...
 
ACTION_MANAGERm_actionMgr
 Original cursor position, if overridden by the context menu handler. More...
 
std::map< TOOL_ID, OPT< VECTOR2D > > m_cursorSettings
 
EDA_ITEMm_model
 
KIGFX::VIEWm_view
 
KIGFX::VIEW_CONTROLSm_viewControls
 
TOOLS_HOLDERm_frame
 
APP_SETTINGS_BASEm_settings
 Queue that stores events to be processed at the end of the event processing cycle. More...
 
std::list< TOOL_EVENTm_eventQueue
 Right click context menu position. More...
 
VECTOR2D m_menuCursor
 
bool m_warpMouseAfterContextMenu
 Flag indicating whether a context menu is currently displayed. More...
 
bool m_menuActive
 Tool currently displaying a popup menu. It is negative when there is no menu displayed. More...
 
TOOL_ID m_menuOwner
 Pointer to the state object corresponding to the currently executed tool. More...
 
TOOL_STATEm_activeState
 

Detailed Description

Master controller class:

  • registers editing tools
  • pumps UI events to tools requesting them
  • manages tool state machines (transitions and wait requests)

Definition at line 52 of file tool_manager.h.

Member Typedef Documentation

◆ ID_LIST

typedef std::list<TOOL_ID> TOOL_MANAGER::ID_LIST

Definition at line 66 of file tool_manager.h.

◆ ID_STATE_MAP

Definition at line 65 of file tool_manager.h.

◆ NAME_STATE_MAP

typedef std::map<std::string, TOOL_STATE*> TOOL_MANAGER::NAME_STATE_MAP

Definition at line 64 of file tool_manager.h.

◆ TOOL_STATE_MAP

Definition at line 63 of file tool_manager.h.

◆ TOOL_VEC

typedef std::vector<TOOL_BASE*> TOOL_MANAGER::TOOL_VEC

Definition at line 67 of file tool_manager.h.

◆ TRANSITION

Definition at line 452 of file tool_manager.h.

Constructor & Destructor Documentation

◆ TOOL_MANAGER()

TOOL_MANAGER::TOOL_MANAGER ( )

Definition at line 200 of file tool_manager.cpp.

200  :
201  m_model( nullptr ),
202  m_view( nullptr ),
203  m_viewControls( nullptr ),
204  m_frame( nullptr ),
205  m_settings( nullptr ),
207  m_menuActive( false ),
208  m_menuOwner( -1 ),
209  m_activeState( nullptr )
210 {
211  m_actionMgr = new ACTION_MANAGER( this );
212 }
bool m_menuActive
Tool currently displaying a popup menu. It is negative when there is no menu displayed.
Definition: tool_manager.h:580
ACTION_MANAGER * m_actionMgr
Original cursor position, if overridden by the context menu handler.
Definition: tool_manager.h:560
Manage TOOL_ACTION objects.
TOOLS_HOLDER * m_frame
Definition: tool_manager.h:568
EDA_ITEM * m_model
Definition: tool_manager.h:565
TOOL_ID m_menuOwner
Pointer to the state object corresponding to the currently executed tool.
Definition: tool_manager.h:583
KIGFX::VIEW_CONTROLS * m_viewControls
Definition: tool_manager.h:567
KIGFX::VIEW * m_view
Definition: tool_manager.h:566
bool m_warpMouseAfterContextMenu
Flag indicating whether a context menu is currently displayed.
Definition: tool_manager.h:577
TOOL_STATE * m_activeState
Definition: tool_manager.h:586
APP_SETTINGS_BASE * m_settings
Queue that stores events to be processed at the end of the event processing cycle.
Definition: tool_manager.h:569

References m_actionMgr.

◆ ~TOOL_MANAGER()

TOOL_MANAGER::~TOOL_MANAGER ( )

Definition at line 215 of file tool_manager.cpp.

216 {
217  std::map<TOOL_BASE*, TOOL_STATE*>::iterator it, it_end;
218 
219  for( it = m_toolState.begin(), it_end = m_toolState.end(); it != it_end; ++it )
220  {
221  delete it->second->cofunc; // delete cofunction
222  delete it->second; // delete TOOL_STATE
223  delete it->first; // delete the tool itself
224  }
225 
226  delete m_actionMgr;
227 }
ACTION_MANAGER * m_actionMgr
Original cursor position, if overridden by the context menu handler.
Definition: tool_manager.h:560
TOOL_STATE_MAP m_toolState
Index of the registered tools current states, associated by tools' names.
Definition: tool_manager.h:545

References m_actionMgr, and m_toolState.

Member Function Documentation

◆ applyViewControls()

void TOOL_MANAGER::applyViewControls ( TOOL_STATE aState)
private

Apply #VIEW_CONTROLS settings stored in a #TOOL_STATE object.

Definition at line 1093 of file tool_manager.cpp.

1094 {
1095  m_viewControls->ApplySettings( aState->vcSettings );
1096 }
void ApplySettings(const VC_SETTINGS &aSettings)
Load new settings from program common settings.
KIGFX::VIEW_CONTROLS * m_viewControls
Definition: tool_manager.h:567

References KIGFX::VIEW_CONTROLS::ApplySettings(), m_viewControls, and TOOL_MANAGER::TOOL_STATE::vcSettings.

Referenced by setActiveState().

◆ CancelTool()

void TOOL_MANAGER::CancelTool ( )

Send a cancel event to the tool currently at the top of the tool stack.

Definition at line 342 of file tool_manager.cpp.

343 {
345 
346  processEvent( evt );
347 }
bool processEvent(const TOOL_EVENT &aEvent)
Main function for event processing.
Generic, UI-independent tool event.
Definition: tool_event.h:173

References processEvent(), TA_CANCEL_TOOL, and TC_COMMAND.

Referenced by ACTION_TOOLBAR::onToolEvent().

◆ ClearTransitions()

void TOOL_MANAGER::ClearTransitions ( TOOL_BASE aTool)

Clear the state transition map for a tool.

Parameters
aToolis the tool that should have the transition map cleared.

Definition at line 611 of file tool_manager.cpp.

612 {
613  m_toolState[aTool]->transitions.clear();
614 }
TOOL_STATE_MAP m_toolState
Index of the registered tools current states, associated by tools' names.
Definition: tool_manager.h:545

References m_toolState.

Referenced by TOOL_INTERACTIVE::resetTransitions().

◆ DeactivateTool()

void TOOL_MANAGER::DeactivateTool ( )

Deactivate the currently active tool.

Definition at line 529 of file tool_manager.cpp.

530 {
531  // Deactivate the active tool, but do not run anything new
533  processEvent( evt );
534 }
bool processEvent(const TOOL_EVENT &aEvent)
Main function for event processing.
Generic, UI-independent tool event.
Definition: tool_event.h:173

References processEvent(), TA_CANCEL_TOOL, and TC_COMMAND.

Referenced by GERBVIEW_FRAME::doCloseWindow(), SYMBOL_EDITOR_DRAWING_TOOLS::DrawShape(), PL_DRAWING_TOOLS::DrawShape(), ResetTools(), and FOOTPRINT_WIZARD_FRAME::~FOOTPRINT_WIZARD_FRAME().

◆ dispatchActivation()

bool TOOL_MANAGER::dispatchActivation ( const TOOL_EVENT aEvent)
private

Check if it is a valid activation event and invokes a proper tool.

Parameters
aEventis an event to be tested.
Returns
True if a tool was invoked, false otherwise.

Definition at line 788 of file tool_manager.cpp.

789 {
790  wxLogTrace( kicadTraceToolStack, "TOOL_MANAGER::dispatchActivation - Received event: %s",
791  aEvent.Format() );
792 
793  if( aEvent.IsActivate() )
794  {
795  wxString cmdStr( *aEvent.GetCommandStr() );
796 
797  auto tool = m_toolNameIndex.find( *aEvent.GetCommandStr() );
798 
799  if( tool != m_toolNameIndex.end() )
800  {
801  wxLogTrace( kicadTraceToolStack,
802  "TOOL_MANAGER::dispatchActivation - Running tool %s for event: %s",
803  tool->second->theTool->GetName(), aEvent.Format() );
804 
805  runTool( tool->second->theTool );
806  return true;
807  }
808  }
809 
810  return false;
811 }
const std::string Format() const
Return information about event in form of a human-readable string.
Definition: tool_event.cpp:76
NAME_STATE_MAP m_toolNameIndex
Index of the registered tools current states, associated by tools' ID numbers.
Definition: tool_manager.h:548
bool runTool(TOOL_BASE *aTool)
Make a tool active, so it can receive events and react to them.
OPT< std::string > GetCommandStr() const
Definition: tool_event.h:471
bool IsActivate() const
Definition: tool_event.h:331
const wxChar *const kicadTraceToolStack
Flag to enable tracing of the tool handling stack.

References TOOL_EVENT::Format(), TOOL_EVENT::GetCommandStr(), TOOL_EVENT::IsActivate(), kicadTraceToolStack, m_toolNameIndex, and runTool().

Referenced by processEvent().

◆ DispatchContextMenu()

void TOOL_MANAGER::DispatchContextMenu ( const TOOL_EVENT aEvent)

Handle context menu related events.

Definition at line 813 of file tool_manager.cpp.

814 {
815  for( TOOL_ID toolId : m_activeTools )
816  {
817  TOOL_STATE* st = m_toolIdIndex[toolId];
818 
819  // the tool requested a context menu. The menu is activated on RMB click (CMENU_BUTTON mode)
820  // or immediately (CMENU_NOW) mode. The latter is used for clarification lists.
821  if( st->contextMenuTrigger == CMENU_OFF )
822  continue;
823 
824  if( st->contextMenuTrigger == CMENU_BUTTON && !aEvent.IsClick( BUT_RIGHT ) )
825  break;
826 
827  if( st->cofunc )
828  {
829  st->pendingWait = true;
830  st->waitEvents = TOOL_EVENT( TC_ANY, TA_ANY );
831  }
832 
833  // Store the menu pointer in case it is changed by the TOOL when handling menu events
834  ACTION_MENU* m = st->contextMenu;
835 
836  if( st->contextMenuTrigger == CMENU_NOW )
837  st->contextMenuTrigger = CMENU_OFF;
838 
839  // Store the cursor position, so the tools could execute actions
840  // using the point where the user has invoked a context menu
841  if( m_viewControls )
843 
844  // Save all tools cursor settings, as they will be overridden
845  for( auto idState : m_toolIdIndex )
846  {
847  TOOL_STATE* s = idState.second;
848  const auto& vc = s->vcSettings;
849 
850  if( vc.m_forceCursorPosition )
851  m_cursorSettings[idState.first] = vc.m_forcedPosition;
852  else
853  m_cursorSettings[idState.first] = NULLOPT;
854  }
855 
856  if( m_viewControls )
858 
859  // Display a copy of menu
860  std::unique_ptr<ACTION_MENU> menu( m->Clone() );
861 
862  m_menuOwner = toolId;
863  m_menuActive = true;
864 
865  if( wxWindow* frame = dynamic_cast<wxWindow*>( m_frame ) )
866  frame->PopupMenu( menu.get() );
867 
868  // If a menu is cancelled then notify tool
869  if( menu->GetSelected() < 0 )
870  {
872  evt.SetHasPosition( false );
873  evt.SetParameter( m );
874  dispatchInternal( evt );
875  }
876 
877  // Restore setting in case it was vetoed
879 
880  // Notify the tools that menu has been closed
882  evt.SetHasPosition( false );
883  evt.SetParameter( m );
884  dispatchInternal( evt );
885 
886  m_menuActive = false;
887  m_menuOwner = -1;
888 
889  // Restore cursor settings
890  for( auto cursorSetting : m_cursorSettings )
891  {
892  auto it = m_toolIdIndex.find( cursorSetting.first );
893  wxASSERT( it != m_toolIdIndex.end() );
894 
895  if( it == m_toolIdIndex.end() )
896  continue;
897 
898  KIGFX::VC_SETTINGS& vc = it->second->vcSettings;
899  vc.m_forceCursorPosition = (bool) cursorSetting.second;
900  vc.m_forcedPosition = cursorSetting.second ? *cursorSetting.second : VECTOR2D( 0, 0 );
901  }
902 
903  m_cursorSettings.clear();
904  break;
905  }
906 }
bool m_menuActive
Tool currently displaying a popup menu. It is negative when there is no menu displayed.
Definition: tool_manager.h:580
VECTOR2D m_menuCursor
Definition: tool_manager.h:575
Defines the structure of a menu based on ACTIONs.
Definition: action_menu.h:45
ID_STATE_MAP m_toolIdIndex
Index of the registered tools to easily lookup by their type.
Definition: tool_manager.h:551
bool IsClick(int aButtonMask=BUT_ANY) const
Definition: tool_event.cpp:181
std::map< TOOL_ID, OPT< VECTOR2D > > m_cursorSettings
Definition: tool_manager.h:563
VECTOR2D m_forcedPosition
Is the forced cursor position enabled.
Definition: view_controls.h:55
TOOLS_HOLDER * m_frame
Definition: tool_manager.h:568
int TOOL_ID
Unique identifier for tools.
Definition: tool_base.h:57
const auto NULLOPT
Definition: optional.h:9
bool m_forceCursorPosition
Should the cursor be locked within the parent window area.
Definition: view_controls.h:58
TOOL_ID m_menuOwner
Pointer to the state object corresponding to the currently executed tool.
Definition: tool_manager.h:583
Generic, UI-independent tool event.
Definition: tool_event.h:173
Structure to keep VIEW_CONTROLS settings for easy store/restore operations.
Definition: view_controls.h:41
ACTION_MENU * Clone() const
Create a deep, recursive copy of this ACTION_MENU.
virtual void ForceCursorPosition(bool aEnabled, const VECTOR2D &aPosition=VECTOR2D(0, 0))
Place the cursor immediately at a given point.
KIGFX::VIEW_CONTROLS * m_viewControls
Definition: tool_manager.h:567
bool m_warpMouseAfterContextMenu
Flag indicating whether a context menu is currently displayed.
Definition: tool_manager.h:577
ID_LIST m_activeTools
Instance of ACTION_MANAGER that handles TOOL_ACTIONs.
Definition: tool_manager.h:557
VECTOR2D GetCursorPosition() const
Return the current cursor position in world coordinates.
bool dispatchInternal(const TOOL_EVENT &aEvent)
Passe an event at first to the active tools, then to all others.

References BUT_RIGHT, ACTION_MENU::Clone(), CMENU_BUTTON, CMENU_NOW, CMENU_OFF, TOOL_MANAGER::TOOL_STATE::cofunc, TOOL_MANAGER::TOOL_STATE::contextMenu, TOOL_MANAGER::TOOL_STATE::contextMenuTrigger, dispatchInternal(), KIGFX::VIEW_CONTROLS::ForceCursorPosition(), KIGFX::VIEW_CONTROLS::GetCursorPosition(), TOOL_EVENT::IsClick(), m_activeTools, m_cursorSettings, KIGFX::VC_SETTINGS::m_forceCursorPosition, KIGFX::VC_SETTINGS::m_forcedPosition, m_frame, m_menuActive, m_menuCursor, m_menuOwner, m_toolIdIndex, m_viewControls, m_warpMouseAfterContextMenu, NULLOPT, TOOL_MANAGER::TOOL_STATE::pendingWait, TOOL_EVENT::SetHasPosition(), TOOL_EVENT::SetParameter(), TA_ANY, TA_CHOICE_MENU_CHOICE, TA_CHOICE_MENU_CLOSED, TC_ANY, TC_COMMAND, TOOL_MANAGER::TOOL_STATE::vcSettings, and TOOL_MANAGER::TOOL_STATE::waitEvents.

Referenced by LIB_TREE::onContextMenu(), and processEvent().

◆ DispatchHotKey()

bool TOOL_MANAGER::DispatchHotKey ( const TOOL_EVENT aEvent)

Handle specific events, that are intended for TOOL_MANAGER rather than tools.

Parameters
aEventis the event to be processed.
Returns
true if the event was processed and should not go any further.

Definition at line 779 of file tool_manager.cpp.

780 {
781  if( aEvent.Action() == TA_KEY_PRESSED )
782  return m_actionMgr->RunHotKey( aEvent.Modifier() | aEvent.KeyCode() );
783 
784  return false;
785 }
ACTION_MANAGER * m_actionMgr
Original cursor position, if overridden by the context menu handler.
Definition: tool_manager.h:560
TOOL_ACTIONS Action() const
These give a tool a method of informing the TOOL_MANAGER that a particular event should be passed on ...
Definition: tool_event.h:251
bool RunHotKey(int aHotKey) const
Run an action associated with a hotkey (if there is one available).
int Modifier(int aMask=MD_MODIFIER_MASK) const
Definition: tool_event.h:352
int KeyCode() const
Definition: tool_event.h:357

References TOOL_EVENT::Action(), TOOL_EVENT::KeyCode(), m_actionMgr, TOOL_EVENT::Modifier(), ACTION_MANAGER::RunHotKey(), and TA_KEY_PRESSED.

Referenced by processEvent().

◆ dispatchInternal()

bool TOOL_MANAGER::dispatchInternal ( const TOOL_EVENT aEvent)
private

Passe an event at first to the active tools, then to all others.

Definition at line 647 of file tool_manager.cpp.

648 {
649  bool handled = false;
650 
651  wxLogTrace( kicadTraceToolStack, "TOOL_MANAGER::dispatchInternal - received event: %s",
652  aEvent.Format() );
653 
654  auto it = m_activeTools.begin();
655 
656  // iterate over active tool stack
657  while( it != m_activeTools.end() )
658  {
659  TOOL_STATE* st = m_toolIdIndex[*it];
660  bool increment = true;
661 
662  // forward context menu events to the tool that created the menu
663  if( aEvent.IsChoiceMenu() )
664  {
665  if( *it != m_menuOwner )
666  {
667  ++it;
668  continue;
669  }
670  }
671 
672  // If we're pendingWait then we had better have a cofunc to process the wait.
673  wxASSERT( !st || !st->pendingWait || st->cofunc );
674 
675  // the tool state handler is waiting for events (i.e. called Wait() method)
676  if( st && st->cofunc && st->pendingWait && st->waitEvents.Matches( aEvent ) )
677  {
678  if( !aEvent.FirstResponder() )
679  const_cast<TOOL_EVENT*>( &aEvent )->SetFirstResponder( st->theTool );
680 
681  // got matching event? clear wait list and wake up the coroutine
682  st->wakeupEvent = aEvent;
683  st->pendingWait = false;
684  st->waitEvents.clear();
685 
686  wxLogTrace( kicadTraceToolStack,
687  "TOOL_MANAGER::dispatchInternal - Waking tool %s for event: %s",
688  st->theTool->GetName(), aEvent.Format() );
689 
690  setActiveState( st );
691  bool end = !st->cofunc->Resume();
692 
693  if( end )
694  {
695  it = finishTool( st );
696  increment = false;
697  }
698 
699  // If the tool did not request the event be passed to other tools, we're done
700  if( !st->wakeupEvent.PassEvent() )
701  {
702  wxLogTrace( kicadTraceToolStack,
703  "TOOL_MANAGER::dispatchInternal - tool %s stopped passing event: %s",
704  st->theTool->GetName(), aEvent.Format() );
705 
706  return true;
707  }
708  }
709 
710  if( increment )
711  ++it;
712  }
713 
714  for( auto& state : m_toolState )
715  {
716  TOOL_STATE* st = state.second;
717  bool finished = false;
718 
719  // no state handler in progress - check if there are any transitions (defined by
720  // Go() method that match the event.
721  if( !st->transitions.empty() )
722  {
723  for( TRANSITION& tr : st->transitions )
724  {
725  if( tr.first.Matches( aEvent ) )
726  {
727  auto func_copy = tr.second;
728 
729  if( !aEvent.FirstResponder() )
730  const_cast<TOOL_EVENT*>( &aEvent )->SetFirstResponder( st->theTool );
731 
732  // if there is already a context, then push it on the stack
733  // and transfer the previous view control settings to the new context
734  if( st->cofunc )
735  {
736  auto vc = st->vcSettings;
737  st->Push();
738  st->vcSettings = vc;
739  }
740 
741  st->cofunc = new COROUTINE<int, const TOOL_EVENT&>( std::move( func_copy ) );
742 
743  // as the state changes, the transition table has to be set up again
744  st->transitions.clear();
745 
746  wxLogTrace( kicadTraceToolStack,
747  "TOOL_MANAGER::dispatchInternal - Running tool %s for event: %s",
748  st->theTool->GetName(), aEvent.Format() );
749 
750  // got match? Run the handler.
751  setActiveState( st );
752  st->idle = false;
753  st->cofunc->Call( aEvent );
754  handled = true;
755 
756  if( !st->cofunc->Running() )
757  finishTool( st ); // The couroutine has finished immediately?
758 
759  // if it is a message, continue processing
760  finished = !( aEvent.Category() == TC_MESSAGE );
761 
762  // there is no point in further checking, as transitions got cleared
763  break;
764  }
765  }
766  }
767 
768  if( finished )
769  break; // only the first tool gets the event
770  }
771 
772  wxLogTrace( kicadTraceToolStack, "TOOL_MANAGER::dispatchInternal - %s handle event: %s",
773  ( handled ? "Did" : "Did not" ), aEvent.Format() );
774 
775  return handled;
776 }
const std::string Format() const
Return information about event in form of a human-readable string.
Definition: tool_event.cpp:76
ID_STATE_MAP m_toolIdIndex
Index of the registered tools to easily lookup by their type.
Definition: tool_manager.h:551
ID_LIST::iterator finishTool(TOOL_STATE *aState)
Deactivate a tool and does the necessary clean up.
TOOL_EVENT_CATEGORY Category() const
Returns more specific information about the type of an event.
Definition: tool_event.h:248
TOOL_ID m_menuOwner
Pointer to the state object corresponding to the currently executed tool.
Definition: tool_manager.h:583
void setActiveState(TOOL_STATE *aState)
Save the previous active state and sets a new one.
bool IsChoiceMenu() const
Definition: tool_event.h:341
const wxChar *const kicadTraceToolStack
Flag to enable tracing of the tool handling stack.
TOOL_BASE * FirstResponder() const
Definition: tool_event.h:269
ID_LIST m_activeTools
Instance of ACTION_MANAGER that handles TOOL_ACTIONs.
Definition: tool_manager.h:557
TOOL_STATE_MAP m_toolState
Index of the registered tools current states, associated by tools' names.
Definition: tool_manager.h:545
std::pair< TOOL_EVENT_LIST, TOOL_STATE_FUNC > TRANSITION
Definition: tool_manager.h:452

References COROUTINE< ReturnType, ArgType >::Call(), TOOL_EVENT::Category(), TOOL_EVENT_LIST::clear(), TOOL_MANAGER::TOOL_STATE::cofunc, finishTool(), TOOL_EVENT::FirstResponder(), TOOL_EVENT::Format(), TOOL_BASE::GetName(), TOOL_MANAGER::TOOL_STATE::idle, TOOL_EVENT::IsChoiceMenu(), kicadTraceToolStack, m_activeTools, m_menuOwner, m_toolIdIndex, m_toolState, TOOL_EVENT_LIST::Matches(), TOOL_EVENT::PassEvent(), TOOL_MANAGER::TOOL_STATE::pendingWait, TOOL_MANAGER::TOOL_STATE::Push(), COROUTINE< ReturnType, ArgType >::Resume(), COROUTINE< ReturnType, ArgType >::Running(), setActiveState(), TC_MESSAGE, TOOL_MANAGER::TOOL_STATE::theTool, TOOL_MANAGER::TOOL_STATE::transitions, TOOL_MANAGER::TOOL_STATE::vcSettings, TOOL_MANAGER::TOOL_STATE::waitEvents, and TOOL_MANAGER::TOOL_STATE::wakeupEvent.

Referenced by DispatchContextMenu(), and processEvent().

◆ FindTool() [1/2]

TOOL_BASE * TOOL_MANAGER::FindTool ( int  aId) const

Search for a tool with given ID.

Parameters
aIdis the ID number of the requested tool.
Returns
Pointer to the requested tool or NULL in case of failure.

Definition at line 507 of file tool_manager.cpp.

508 {
509  std::map<TOOL_ID, TOOL_STATE*>::const_iterator it = m_toolIdIndex.find( aId );
510 
511  if( it != m_toolIdIndex.end() )
512  return it->second->theTool;
513 
514  return NULL;
515 }
ID_STATE_MAP m_toolIdIndex
Index of the registered tools to easily lookup by their type.
Definition: tool_manager.h:551
#define NULL

References m_toolIdIndex, and NULL.

Referenced by GetCurrentTool(), InvokeTool(), ACTION_MANAGER::RunHotKey(), and ShutdownTool().

◆ FindTool() [2/2]

TOOL_BASE * TOOL_MANAGER::FindTool ( const std::string &  aName) const

Search for a tool with given name.

Parameters
aNameis the name of the requested tool.
Returns
Pointer to the requested tool or NULL in case of failure.

Definition at line 518 of file tool_manager.cpp.

519 {
520  std::map<std::string, TOOL_STATE*>::const_iterator it = m_toolNameIndex.find( aName );
521 
522  if( it != m_toolNameIndex.end() )
523  return it->second->theTool;
524 
525  return NULL;
526 }
NAME_STATE_MAP m_toolNameIndex
Index of the registered tools current states, associated by tools' ID numbers.
Definition: tool_manager.h:548
#define NULL

References m_toolNameIndex, and NULL.

◆ finishTool()

TOOL_MANAGER::ID_LIST::iterator TOOL_MANAGER::finishTool ( TOOL_STATE aState)
private

Deactivate a tool and does the necessary clean up.

Parameters
aStateis the state variable of the tool to be stopped.
Returns
m_activeTools iterator. If the tool has been completely deactivated, it points to the next active tool on the list. Otherwise it is an iterator pointing to aState.

Definition at line 909 of file tool_manager.cpp.

910 {
911  auto it = std::find( m_activeTools.begin(), m_activeTools.end(), aState->theTool->GetId() );
912 
913  if( !aState->Pop() )
914  {
915  // Deactivate the tool if there are no other contexts saved on the stack
916  if( it != m_activeTools.end() )
917  it = m_activeTools.erase( it );
918 
919  aState->idle = true;
920  }
921 
922  if( aState == m_activeState )
923  setActiveState( nullptr );
924 
925  // Set transitions to be ready for future TOOL_EVENTs
926  TOOL_BASE* tool = aState->theTool;
927 
928  if( tool->GetType() == INTERACTIVE )
929  static_cast<TOOL_INTERACTIVE*>( tool )->resetTransitions();
930 
931  return it;
932 }
TOOL_TYPE GetType() const
Return the type of the tool.
Definition: tool_base.h:109
Tool that interacts with the user.
Definition: tool_base.h:50
void setActiveState(TOOL_STATE *aState)
Save the previous active state and sets a new one.
TOOL_STATE * m_activeState
Definition: tool_manager.h:586
Base abstract interface for all kinds of tools.
Definition: tool_base.h:66
ID_LIST m_activeTools
Instance of ACTION_MANAGER that handles TOOL_ACTIONs.
Definition: tool_manager.h:557

References TOOL_BASE::GetId(), TOOL_BASE::GetType(), TOOL_MANAGER::TOOL_STATE::idle, INTERACTIVE, m_activeState, m_activeTools, TOOL_MANAGER::TOOL_STATE::Pop(), setActiveState(), and TOOL_MANAGER::TOOL_STATE::theTool.

Referenced by dispatchInternal(), and ShutdownTool().

◆ GetActionManager()

◆ GetActions()

const std::map< std::string, TOOL_ACTION * > & TOOL_MANAGER::GetActions ( )

Definition at line 364 of file tool_manager.cpp.

365 {
366  return m_actionMgr->GetActions();
367 }
ACTION_MANAGER * m_actionMgr
Original cursor position, if overridden by the context menu handler.
Definition: tool_manager.h:560
const std::map< std::string, TOOL_ACTION * > & GetActions() const
Get a list of currently-registered actions mapped by their name.

References ACTION_MANAGER::GetActions(), and m_actionMgr.

◆ GetClipboardUTF8()

std::string TOOL_MANAGER::GetClipboardUTF8 ( ) const

Return the information currently stored in the system clipboard.

If data stored in the clipboard is in non-text format, empty string is returned.

Note
The clipboard is expected containing Unicode chars, not only ASCII7 chars. The returned string is UTF8 encoded

Definition at line 988 of file tool_manager.cpp.

989 {
990  std::string result;
991 
992  wxLogNull doNotLog; // disable logging of failed clipboard actions
993 
994  if( wxTheClipboard->Open() )
995  {
996  if( wxTheClipboard->IsSupported( wxDF_TEXT )
997  || wxTheClipboard->IsSupported( wxDF_UNICODETEXT ) )
998  {
999  wxTextDataObject data;
1000  wxTheClipboard->GetData( data );
1001 
1002  // The clipboard is expected containing a unicode string, so return it
1003  // as UTF8 string
1004  result = data.GetText().utf8_str();
1005  }
1006 
1007  wxTheClipboard->Close();
1008  }
1009 
1010  return result;
1011 }

Referenced by PL_EDIT_TOOL::Paste(), SYMBOL_EDITOR_EDIT_TOOL::Paste(), and SCH_EDITOR_CONTROL::Paste().

◆ GetCurrentTool()

TOOL_BASE* TOOL_MANAGER::GetCurrentTool ( ) const
inline

Return the tool that is on the top of the active tools stack (was invoked the most recently).

Returns
Pointer to the currently used tool.

Definition at line 319 of file tool_manager.h.

320  {
321  return FindTool( GetCurrentToolId() );
322  }
TOOL_BASE * FindTool(int aId) const
Search for a tool with given ID.
int GetCurrentToolId() const
Return id of the tool that is on the top of the active tools stack (was invoked the most recently).
Definition: tool_manager.h:308

References FindTool(), and GetCurrentToolId().

Referenced by PCB_GRID_HELPER::queryVisible().

◆ GetCurrentToolId()

int TOOL_MANAGER::GetCurrentToolId ( ) const
inline

Return id of the tool that is on the top of the active tools stack (was invoked the most recently).

Returns
Id of the currently used tool.

Definition at line 308 of file tool_manager.h.

309  {
310  return m_activeTools.empty() ? -1 : m_activeTools.front();
311  }
ID_LIST m_activeTools
Instance of ACTION_MANAGER that handles TOOL_ACTIONs.
Definition: tool_manager.h:557

References m_activeTools.

Referenced by GetCurrentTool(), and GetCurrentToolState().

◆ GetCurrentToolState()

TOOL_STATE* TOOL_MANAGER::GetCurrentToolState ( ) const
inline

Return the #TOOL_STATE object representing the state of the active tool.

If there are no tools active, it returns nullptr.

Definition at line 328 of file tool_manager.h.

329  {
330  auto it = m_toolIdIndex.find( GetCurrentToolId() );
331  return ( it != m_toolIdIndex.end() ) ? it->second : nullptr;
332  }
ID_STATE_MAP m_toolIdIndex
Index of the registered tools to easily lookup by their type.
Definition: tool_manager.h:551
int GetCurrentToolId() const
Return id of the tool that is on the top of the active tools stack (was invoked the most recently).
Definition: tool_manager.h:308

References GetCurrentToolId(), and m_toolIdIndex.

Referenced by GetCurrentToolVC(), invokeTool(), and ProcessEvent().

◆ GetCurrentToolVC()

const KIGFX::VC_SETTINGS & TOOL_MANAGER::GetCurrentToolVC ( ) const

Return the view controls settings for the current tool or the general settings if there is no active tool.

Definition at line 1014 of file tool_manager.cpp.

1015 {
1016  if( TOOL_STATE* active = GetCurrentToolState() )
1017  return active->vcSettings;
1018 
1019  return m_viewControls->GetSettings();
1020 }
const VC_SETTINGS & GetSettings() const
Apply VIEW_CONTROLS settings from an object.
KIGFX::VIEW_CONTROLS * m_viewControls
Definition: tool_manager.h:567
TOOL_STATE * GetCurrentToolState() const
Return the #TOOL_STATE object representing the state of the active tool.
Definition: tool_manager.h:328

References GetCurrentToolState(), KIGFX::VIEW_CONTROLS::GetSettings(), and m_viewControls.

Referenced by COMMON_TOOLS::ResetLocalCoords().

◆ GetCursorPosition()

VECTOR2D TOOL_MANAGER::GetCursorPosition ( )

Definition at line 305 of file tool_manager.cpp.

306 {
307  if( m_viewControls )
309  else
310  return wxGetMousePosition();
311 }
KIGFX::VIEW_CONTROLS * m_viewControls
Definition: tool_manager.h:567
VECTOR2D GetCursorPosition() const
Return the current cursor position in world coordinates.

References KIGFX::VIEW_CONTROLS::GetCursorPosition(), and m_viewControls.

Referenced by invokeTool(), and RunAction().

◆ GetHotKey()

int TOOL_MANAGER::GetHotKey ( const TOOL_ACTION aAction)

Definition at line 370 of file tool_manager.cpp.

371 {
372  return m_actionMgr->GetHotKey( aAction );
373 }
ACTION_MANAGER * m_actionMgr
Original cursor position, if overridden by the context menu handler.
Definition: tool_manager.h:560
int GetHotKey(const TOOL_ACTION &aAction) const
Return the hot key associated with a given action or 0 if there is none.

References ACTION_MANAGER::GetHotKey(), and m_actionMgr.

Referenced by ACTION_MENU::updateHotKeys().

◆ GetMenuCursorPos()

VECTOR2D TOOL_MANAGER::GetMenuCursorPos ( )
inline

Definition at line 446 of file tool_manager.h.

447  {
448  return m_menuCursor;
449  }
VECTOR2D m_menuCursor
Definition: tool_manager.h:575

References m_menuCursor.

Referenced by ROUTER_TOOL::InlineBreakTrack().

◆ GetModel()

EDA_ITEM* TOOL_MANAGER::GetModel ( ) const
inline

◆ GetMousePosition()

VECTOR2D TOOL_MANAGER::GetMousePosition ( )

Definition at line 296 of file tool_manager.cpp.

297 {
298  if( m_viewControls )
300  else
301  return wxGetMousePosition();
302 }
virtual VECTOR2D GetMousePosition(bool aWorldCoordinates=true) const =0
Return the current mouse pointer position.
KIGFX::VIEW_CONTROLS * m_viewControls
Definition: tool_manager.h:567

References KIGFX::VIEW_CONTROLS::GetMousePosition(), and m_viewControls.

Referenced by ACTION_MENU::OnMenuEvent().

◆ GetPriority()

int TOOL_MANAGER::GetPriority ( int  aToolId) const

Return priority of a given tool.

Higher number means that the tool is closer to the beginning of the active tools queue (i.e. receives events earlier, tools with lower priority receive events later).

Parameters
aToolIdis the id of queried tool.
Returns
The priority of a given tool. If returned number is negative, then it means that the tool id is invalid or the tool is not active.

Definition at line 586 of file tool_manager.cpp.

587 {
588  int priority = 0;
589 
590  for( TOOL_ID tool : m_activeTools )
591  {
592  if( tool == aToolId )
593  return priority;
594 
595  ++priority;
596  }
597 
598  return -1;
599 }
int TOOL_ID
Unique identifier for tools.
Definition: tool_base.h:57
ID_LIST m_activeTools
Instance of ACTION_MANAGER that handles TOOL_ACTIONs.
Definition: tool_manager.h:557

References m_activeTools.

Referenced by ACTION_MANAGER::RunHotKey().

◆ GetSettings()

APP_SETTINGS_BASE* TOOL_MANAGER::GetSettings ( ) const
inline

Definition at line 298 of file tool_manager.h.

298 { return m_settings; }
APP_SETTINGS_BASE * m_settings
Queue that stores events to be processed at the end of the event processing cycle.
Definition: tool_manager.h:569

References m_settings.

Referenced by COMMON_TOOLS::doZoomInOut(), COMMON_TOOLS::doZoomToPreset(), COMMON_TOOLS::GridNext(), COMMON_TOOLS::GridPreset(), COMMON_TOOLS::GridPrev(), COMMON_TOOLS::OnGridChanged(), and COMMON_TOOLS::Reset().

◆ GetTool()

template<typename T >
T* TOOL_MANAGER::GetTool ( )
inline

Definition at line 219 of file tool_manager.h.

220  {
221  std::map<const char*, TOOL_BASE*>::iterator tool = m_toolTypes.find( typeid( T ).name() );
222 
223  if( tool != m_toolTypes.end() )
224  return static_cast<T*>( tool->second );
225 
226  return NULL;
227  }
#define NULL
const char * name
Definition: DXF_plotter.cpp:59
std::map< const char *, TOOL_BASE * > m_toolTypes
Stack of the active tools.
Definition: tool_manager.h:554

References m_toolTypes, name, and NULL.

Referenced by EDA_BASE_FRAME::AddStandardHelpMenu(), EDA_DRAW_FRAME::AddStandardSubMenus(), SCH_EDITOR_CONTROL::AssignNetclass(), BOARD_INSPECTION_TOOL::calculateSelectionRatsnest(), ROUTER_TOOL::CanInlineDrag(), PAD_TOOL::copyPadSettings(), EDA_3D_VIEWER::CreateMenuBar(), ZONE_CREATE_HELPER::createNewZone(), BOARD_INSPECTION_TOOL::CrossProbePcbToSch(), SYMBOL_EDITOR_EDIT_TOOL::DeleteItemCursor(), PL_EDIT_TOOL::DeleteItemCursor(), SCH_EDIT_TOOL::DeleteItemCursor(), PCB_CONTROL::DeleteItemCursor(), SCH_EDIT_FRAME::DeleteJunction(), DIALOG_BOARD_REANNOTATE::DIALOG_BOARD_REANNOTATE(), SCH_EDIT_FRAME::DisplayCurrentSheet(), PL_DRAW_PANEL_GAL::DisplayWorksheet(), DIALOG_CLEANUP_TRACKS_AND_VIAS::doCleanup(), SCH_EDITOR_CONTROL::doCopy(), SCH_EDITOR_CONTROL::doCrossProbeSchToPcb(), BOARD_INSPECTION_TOOL::doHideNet(), DRAWING_TOOL::DrawVia(), BOARD_EDITOR_CONTROL::DrillOrigin(), EDIT_TOOL::Duplicate(), BOARD_EDITOR_CONTROL::EditFpInFpEditor(), SYMBOL_EDITOR_EDIT_TOOL::editGraphicProperties(), PAD_TOOL::EditPad(), SYMBOL_EDITOR_EDIT_TOOL::editSymbolProperties(), SCH_EDITOR_CONTROL::EditWithSymbolEditor(), GROUP_TOOL::EnterGroup(), SCH_NAVIGATE_TOOL::EnterSheet(), SCH_EDITOR_CONTROL::EnterSheet(), EE_INSPECTION_TOOL::ExcludeMarker(), SCH_EDIT_FRAME::ExecuteRemoteCommand(), FOOTPRINT_VIEWER_FRAME::FOOTPRINT_VIEWER_FRAME(), EDIT_TOOL::GetAndPlace(), FP_TREE_SYNCHRONIZING_ADAPTER::GetContextMenuTool(), SYMBOL_TREE_SYNCHRONIZING_ADAPTER::GetContextMenuTool(), FOOTPRINT_EDIT_FRAME::GetCurrentSelection(), FOOTPRINT_VIEWER_FRAME::GetCurrentSelection(), SYMBOL_EDIT_FRAME::GetCurrentSelection(), DISPLAY_FOOTPRINTS_FRAME::GetCurrentSelection(), PL_EDITOR_FRAME::GetCurrentSelection(), SYMBOL_VIEWER_FRAME::GetCurrentSelection(), SCH_EDIT_FRAME::GetCurrentSelection(), GERBVIEW_FRAME::GetCurrentSelection(), PL_EDITOR_FRAME::GetLayoutFromRedoList(), PL_EDITOR_FRAME::GetLayoutFromUndoList(), DRAWING_TOOL::getSourceZoneForAction(), EDA_DRAW_FRAME::GetUnitPair(), PCB_CONTROL::GridSetOrigin(), GROUP_TOOL::Group(), PL_EDITOR_FRAME::HardRedraw(), SYMBOL_EDIT_FRAME::HardRedraw(), GERBVIEW_CONTROL::HighlightControl(), BOARD_INSPECTION_TOOL::highlightNet(), highlightNet(), SCH_EDITOR_CONTROL::HighlightNetCursor(), BOARD_INSPECTION_TOOL::HighlightNetTool(), SYMBOL_EDITOR_EDIT_TOOL::Init(), SCH_EDIT_TOOL::Init(), PL_EDIT_TOOL::Init(), GROUP_TOOL::Init(), PAD_TOOL::Init(), CONVERT_TOOL::Init(), SYMBOL_EDITOR_CONTROL::Init(), GLOBAL_EDIT_TOOL::Init(), PL_DRAWING_TOOLS::Init(), PL_POINT_EDITOR::Init(), ALIGN_DISTRIBUTE_TOOL::Init(), BOARD_EDITOR_CONTROL::Init(), PCB_POINT_EDITOR::Init(), POSITION_RELATIVE_TOOL::Init(), BOARD_INSPECTION_TOOL::Init(), EE_TOOL_BASE< SCH_BASE_FRAME >::Init(), EDIT_TOOL::Init(), ROUTER_TOOL::InlineBreakTrack(), ROUTER_TOOL::InlineDrag(), BOARD_INSPECTION_TOOL::InspectClearance(), BOARD_INSPECTION_TOOL::InspectConstraints(), EDIT_TOOL::invokeInlineRouter(), EDIT_TOOL::isInteractiveDragEnabled(), EDIT_TOOL::isRouterActive(), SCH_EDIT_FRAME::KiwayMailIn(), GROUP_TOOL::LeaveGroup(), SYMBOL_EDIT_FRAME::LoadPart(), PCB_EDIT_FRAME::LoadProjectSettings(), FOOTPRINT_EDIT_FRAME::LoadSettings(), BOARD_INSPECTION_TOOL::LocalRatsnestTool(), SYMBOL_EDITOR_MOVE_TOOL::Main(), PCB_SELECTION_TOOL::Main(), BOARD_EDITOR_CONTROL::modifyLockSelected(), PROPERTIES_FRAME::OnAcceptPrms(), DIALOG_DRC::OnActivateDlg(), DIALOG_FOOTPRINT_CHECKER::OnCancelClick(), DIALOG_DRC::OnCancelClick(), DIALOG_INSPECTOR::onCellClicked(), DIALOG_POSITION_RELATIVE::OnClear(), DIALOG_ERC::OnCloseErcDialog(), DIALOG_POSITION_RELATIVE::OnOkClick(), DIALOG_PLOT::onRunDRC(), DIALOG_DRC::OnRunDRCClick(), DIALOG_POSITION_RELATIVE::OnSelectItemClick(), DIALOG_FIELDS_EDITOR_GLOBAL::OnTableCellClick(), SCH_EDIT_FRAME::OpenProjectFiles(), PANEL_SELECTION_FILTER::PANEL_SELECTION_FILTER(), SCH_EDITOR_CONTROL::Paste(), PAD_TOOL::pastePadProperties(), GROUP_TOOL::PickNewMember(), EDIT_TOOL::pickReferencePoint(), PCB_CONTROL::placeBoardItems(), DIALOG_PLOT::Plot(), SYMBOL_EDITOR_EDIT_TOOL::Properties(), PAD_TOOL::pushPadSettings(), SCH_EDIT_FRAME::PutDataInPreviousState(), KICAD_MANAGER_FRAME::ReCreateMenuBar(), GERBVIEW_FRAME::ReCreateMenuBar(), SYMBOL_VIEWER_FRAME::ReCreateMenuBar(), SYMBOL_EDIT_FRAME::ReCreateMenuBar(), FOOTPRINT_EDIT_FRAME::ReCreateMenuBar(), FOOTPRINT_VIEWER_FRAME::ReCreateMenuBar(), PL_EDITOR_FRAME::ReCreateMenuBar(), CVPCB_MAINFRAME::ReCreateMenuBar(), SCH_EDIT_FRAME::ReCreateMenuBar(), PCB_EDIT_FRAME::ReCreateMenuBar(), FOOTPRINT_EDIT_FRAME::ReCreateOptToolbar(), SYMBOL_EDIT_FRAME::ReCreateOptToolbar(), SCH_EDIT_FRAME::ReCreateOptToolbar(), PCB_EDIT_FRAME::ReCreateOptToolbar(), PCB_EDIT_FRAME::ReCreateVToolbar(), SYMBOL_EDITOR_EDIT_TOOL::Redo(), SCH_EDITOR_CONTROL::Redo(), SCH_BASE_FRAME::RefreshSelection(), GROUP_TOOL::RemoveFromGroup(), SYMBOL_EDITOR_DRAWING_TOOLS::RepeatDrawItem(), PL_EDITOR_FRAME::RollbackFromUndo(), SYMBOL_EDIT_FRAME::RollbackSymbolFromUndo(), DRC_TOOL::RunTests(), PCB_EDIT_FRAME::SaveProjectSettings(), FOOTPRINT_EDIT_FRAME::SaveSettings(), EDA_DRAW_FRAME::SaveSettings(), SCH_BASE_FRAME::SCH_BASE_FRAME(), SCH_EDIT_FRAME::SchematicCleanUp(), PCB_TOOL_BASE::selection(), POSITION_RELATIVE_TOOL::SelectPositionRelativeItem(), FOOTPRINT_EDIT_FRAME::setupTools(), CVPCB_MAINFRAME::setupTools(), EDA_DRAW_FRAME::setupUnits(), PCB_BASE_FRAME::ShowPadPropertiesDialog(), BOARD_EDITOR_CONTROL::TrackWidthDec(), BOARD_EDITOR_CONTROL::TrackWidthInc(), DIALOG_3D_VIEW_OPTIONS::TransferDataFromWindow(), DIALOG_LIB_EDIT_TEXT::TransferDataFromWindow(), DIALOG_FOOTPRINT_FP_EDITOR::TransferDataFromWindow(), DIALOG_FIELDS_EDITOR_GLOBAL::TransferDataToWindow(), DIALOG_3D_VIEW_OPTIONS::TransferDataToWindow(), DIALOG_LIB_EDIT_TEXT::TransferDataToWindow(), DIALOG_GLOBAL_EDIT_TRACKS_AND_VIAS::TransferDataToWindow(), DIALOG_GLOBAL_EDIT_TEXT_AND_GRAPHICS::TransferDataToWindow(), SYMBOL_EDITOR_DRAWING_TOOLS::TwoClickPlace(), SYMBOL_EDITOR_EDIT_TOOL::Undo(), SCH_EDITOR_CONTROL::Undo(), GROUP_TOOL::Ungroup(), GROUP_CONTEXT_MENU::update(), SYMBOL_UNIT_MENU::update(), BUS_UNFOLD_MENU::update(), EE_INSPECTION_TOOL::UpdateMessagePanel(), GERBVIEW_CONTROL::UpdateMessagePanel(), PL_EDITOR_CONTROL::UpdateMessagePanel(), PCB_CONTROL::UpdateMessagePanel(), BOARD_INSPECTION_TOOL::UpdateSelectionRatsnest(), SCH_EDIT_FRAME::UpdateSymbolFromEditor(), PCB_EDIT_FRAME::UpdateViaSizeSelectBox(), BOARD_EDITOR_CONTROL::ViaSizeDec(), BOARD_EDITOR_CONTROL::ViaSizeInc(), BOARD_EDITOR_CONTROL::ZoneDuplicate(), and BOARD_EDITOR_CONTROL::ZoneMerge().

◆ GetToolHolder()

◆ GetView()

◆ GetViewControls()

KIGFX::VIEW_CONTROLS* TOOL_MANAGER::GetViewControls ( ) const
inline

Definition at line 291 of file tool_manager.h.

291 { return m_viewControls; }
KIGFX::VIEW_CONTROLS * m_viewControls
Definition: tool_manager.h:567

References m_viewControls.

Referenced by ZONE_CREATE_HELPER::createNewZone(), TOOL_DISPATCHER::DispatchWxEvent(), and TOOL_BASE::getViewControls().

◆ InitTools()

void TOOL_MANAGER::InitTools ( )

Initializes all registered tools.

If a tool fails during the initialization, it is deactivated and becomes unavailable for further use. Initialization should be done only once.

Definition at line 553 of file tool_manager.cpp.

554 {
555  for( TOOL_VEC::iterator it = m_toolOrder.begin(); it != m_toolOrder.end(); /* iter inside */ )
556  {
557  TOOL_BASE* tool = *it;
558  wxASSERT( m_toolState.count( tool ) );
559  TOOL_STATE* state = m_toolState[tool];
560  setActiveState( state );
561  ++it; // keep the iterator valid if the element is going to be erased
562 
563  if( !tool->Init() )
564  {
565  wxLogTrace( kicadTraceToolStack, "TOOL_MANAGER initialization of tool '%s' failed",
566  tool->GetName() );
567 
568  // Unregister the tool
569  setActiveState( nullptr );
570  m_toolState.erase( tool );
571  m_toolNameIndex.erase( tool->GetName() );
572  m_toolIdIndex.erase( tool->GetId() );
573  m_toolTypes.erase( typeid( *tool ).name() );
574 
575  delete state;
576  delete tool;
577  }
578  }
579 
580  m_actionMgr->UpdateHotKeys( true );
581 
583 }
virtual bool Init()
Init() is called once upon a registration of the tool.
Definition: tool_base.h:90
ACTION_MANAGER * m_actionMgr
Original cursor position, if overridden by the context menu handler.
Definition: tool_manager.h:560
TOOL_VEC m_toolOrder
Index of registered tools current states, associated by tools' objects.
Definition: tool_manager.h:542
ID_STATE_MAP m_toolIdIndex
Index of the registered tools to easily lookup by their type.
Definition: tool_manager.h:551
TOOL_ID GetId() const
Return the unique identifier of the tool.
Definition: tool_base.h:121
Tool is invoked after being inactive.
Definition: tool_base.h:80
void UpdateHotKeys(bool aFullUpdate)
Optionally read the hotkey config files and then rebuilds the internal hotkey maps.
NAME_STATE_MAP m_toolNameIndex
Index of the registered tools current states, associated by tools' ID numbers.
Definition: tool_manager.h:548
void setActiveState(TOOL_STATE *aState)
Save the previous active state and sets a new one.
void ResetTools(TOOL_BASE::RESET_REASON aReason)
Reset all tools (i.e.
Base abstract interface for all kinds of tools.
Definition: tool_base.h:66
const wxChar *const kicadTraceToolStack
Flag to enable tracing of the tool handling stack.
const std::string & GetName() const
Return the name of the tool.
Definition: tool_base.h:134
TOOL_STATE_MAP m_toolState
Index of the registered tools current states, associated by tools' names.
Definition: tool_manager.h:545
std::map< const char *, TOOL_BASE * > m_toolTypes
Stack of the active tools.
Definition: tool_manager.h:554

References TOOL_BASE::GetId(), TOOL_BASE::GetName(), TOOL_BASE::Init(), kicadTraceToolStack, m_actionMgr, m_toolIdIndex, m_toolNameIndex, m_toolOrder, m_toolState, m_toolTypes, ResetTools(), TOOL_BASE::RUN, setActiveState(), and ACTION_MANAGER::UpdateHotKeys().

Referenced by FOOTPRINT_VIEWER_FRAME::FOOTPRINT_VIEWER_FRAME(), PANEL_PREV_3D::PANEL_PREV_3D(), PL_EDITOR_FRAME::setupTools(), FOOTPRINT_EDIT_FRAME::setupTools(), SYMBOL_VIEWER_FRAME::setupTools(), KICAD_MANAGER_FRAME::setupTools(), SYMBOL_EDIT_FRAME::setupTools(), CVPCB_MAINFRAME::setupTools(), GERBVIEW_FRAME::setupTools(), and SCH_EDIT_FRAME::setupTools().

◆ InvokeTool() [1/2]

bool TOOL_MANAGER::InvokeTool ( TOOL_ID  aToolId)

Call a tool by sending a tool activation event to tool of given ID.

Parameters
aToolIdis the ID number of the requested tool.
Returns
True if the requested tool was invoked successfully.

Definition at line 252 of file tool_manager.cpp.

253 {
254  TOOL_BASE* tool = FindTool( aToolId );
255 
256  if( tool && tool->GetType() == INTERACTIVE )
257  return invokeTool( tool );
258 
259  wxLogTrace( kicadTraceToolStack, "TOOL_MANAGER::InvokeTool - no tool with ID %d",
260  aToolId );
261 
262  return false; // there is no tool with the given id
263 }
TOOL_TYPE GetType() const
Return the type of the tool.
Definition: tool_base.h:109
TOOL_BASE * FindTool(int aId) const
Search for a tool with given ID.
Tool that interacts with the user.
Definition: tool_base.h:50
Base abstract interface for all kinds of tools.
Definition: tool_base.h:66
const wxChar *const kicadTraceToolStack
Flag to enable tracing of the tool handling stack.
bool invokeTool(TOOL_BASE *aTool)
Invoke a tool by sending a proper event (in contrary to runTool, which makes the tool run for real).

References FindTool(), TOOL_BASE::GetType(), INTERACTIVE, invokeTool(), and kicadTraceToolStack.

Referenced by TOOL_INTERACTIVE::Activate(), CVPCB_MAINFRAME::CVPCB_MAINFRAME(), FOOTPRINT_VIEWER_FRAME::FOOTPRINT_VIEWER_FRAME(), EE_SELECTION_TOOL::Main(), PANEL_PREV_3D::PANEL_PREV_3D(), PL_EDITOR_FRAME::setupTools(), FOOTPRINT_EDIT_FRAME::setupTools(), SYMBOL_VIEWER_FRAME::setupTools(), SYMBOL_EDIT_FRAME::setupTools(), and GERBVIEW_FRAME::setupTools().

◆ InvokeTool() [2/2]

bool TOOL_MANAGER::InvokeTool ( const std::string &  aToolName)

Call a tool by sending a tool activation event to tool of given name.

Parameters
aToolNameis the name of the requested tool.
Returns
True if the requested tool was invoked successfully.

Definition at line 266 of file tool_manager.cpp.

267 {
268  TOOL_BASE* tool = FindTool( aToolName );
269 
270  if( tool && tool->GetType() == INTERACTIVE )
271  return invokeTool( tool );
272 
273  wxLogTrace( kicadTraceToolStack, "TOOL_MANAGER::InvokeTool - no tool with name %s",
274  aToolName );
275 
276  return false; // there is no tool with the given name
277 }
TOOL_TYPE GetType() const
Return the type of the tool.
Definition: tool_base.h:109
TOOL_BASE * FindTool(int aId) const
Search for a tool with given ID.
Tool that interacts with the user.
Definition: tool_base.h:50
Base abstract interface for all kinds of tools.
Definition: tool_base.h:66
const wxChar *const kicadTraceToolStack
Flag to enable tracing of the tool handling stack.
bool invokeTool(TOOL_BASE *aTool)
Invoke a tool by sending a proper event (in contrary to runTool, which makes the tool run for real).

References FindTool(), TOOL_BASE::GetType(), INTERACTIVE, invokeTool(), and kicadTraceToolStack.

◆ invokeTool()

bool TOOL_MANAGER::invokeTool ( TOOL_BASE aTool)
private

Invoke a tool by sending a proper event (in contrary to runTool, which makes the tool run for real).

Parameters
aToolis the tool to be invoked.

Definition at line 376 of file tool_manager.cpp.

377 {
378  wxASSERT( aTool != NULL );
379 
380  TOOL_EVENT evt( TC_COMMAND, TA_ACTIVATE, aTool->GetName() );
382  processEvent( evt );
383 
384  if( TOOL_STATE* active = GetCurrentToolState() )
385  setActiveState( active );
386 
387  return true;
388 }
VECTOR2D GetCursorPosition()
bool processEvent(const TOOL_EVENT &aEvent)
Main function for event processing.
void SetMousePosition(const VECTOR2D &aP)
Definition: tool_event.h:476
#define NULL
void setActiveState(TOOL_STATE *aState)
Save the previous active state and sets a new one.
Generic, UI-independent tool event.
Definition: tool_event.h:173
TOOL_STATE * GetCurrentToolState() const
Return the #TOOL_STATE object representing the state of the active tool.
Definition: tool_manager.h:328
const std::string & GetName() const
Return the name of the tool.
Definition: tool_base.h:134

References GetCurrentToolState(), GetCursorPosition(), TOOL_BASE::GetName(), NULL, processEvent(), setActiveState(), TOOL_EVENT::SetMousePosition(), TA_ACTIVATE, and TC_COMMAND.

Referenced by InvokeTool().

◆ isActive()

bool TOOL_MANAGER::isActive ( TOOL_BASE aTool)
private

Return information about a tool activation status.

Parameters
aToolis the tool to be checked.
Returns
True if the tool is on the active tools stack, false otherwise.

Definition at line 1043 of file tool_manager.cpp.

1044 {
1045  if( !isRegistered( aTool ) )
1046  return false;
1047 
1048  // Just check if the tool is on the active tools stack
1049  return alg::contains( m_activeTools, aTool->GetId() );
1050 }
TOOL_ID GetId() const
Return the unique identifier of the tool.
Definition: tool_base.h:121
bool contains(const _Container &__container, _Value __value)
Returns true if the container contains the given value.
Definition: kicad_algo.h:81
bool isRegistered(TOOL_BASE *aTool) const
Return information about a tool registration status.
Definition: tool_manager.h:501
ID_LIST m_activeTools
Instance of ACTION_MANAGER that handles TOOL_ACTIONs.
Definition: tool_manager.h:557

References alg::contains(), TOOL_BASE::GetId(), isRegistered(), and m_activeTools.

Referenced by runTool(), and ShutdownTool().

◆ IsContextMenuActive()

bool TOOL_MANAGER::IsContextMenuActive ( )
inline

True while processing a context menu.

Definition at line 417 of file tool_manager.h.

418  {
419  return m_menuActive;
420  }
bool m_menuActive
Tool currently displaying a popup menu. It is negative when there is no menu displayed.
Definition: tool_manager.h:580

References m_menuActive.

Referenced by DIALOG_SHIM::DIALOG_SHIM(), and ROUTER_TOOL::InlineBreakTrack().

◆ isRegistered()

bool TOOL_MANAGER::isRegistered ( TOOL_BASE aTool) const
inlineprivate

Return information about a tool registration status.

Parameters
aToolis the tool to be checked.
Returns
true if the tool is in the registered tools list, false otherwise.

Definition at line 501 of file tool_manager.h.

502  {
503  return m_toolState.count( aTool ) > 0;
504  }
TOOL_STATE_MAP m_toolState
Index of the registered tools current states, associated by tools' names.
Definition: tool_manager.h:545

References m_toolState.

Referenced by isActive(), and runTool().

◆ IsToolActive()

bool TOOL_MANAGER::IsToolActive ( TOOL_ID  aId) const

Return true if a tool with given id is active (executing)

Definition at line 1158 of file tool_manager.cpp.

1159 {
1160  auto it = m_toolIdIndex.find( aId );
1161  return !it->second->idle;
1162 }
ID_STATE_MAP m_toolIdIndex
Index of the registered tools to easily lookup by their type.
Definition: tool_manager.h:551

References m_toolIdIndex.

Referenced by TOOL_BASE::IsToolActive().

◆ MakeToolId()

TOOL_ID TOOL_MANAGER::MakeToolId ( const std::string &  aToolName)
static

Generates a unique ID from for a tool with given name.

Definition at line 1023 of file tool_manager.cpp.

1024 {
1025  static int currentId;
1026 
1027  return currentId++;
1028 }

◆ PostEvent()

void TOOL_MANAGER::PostEvent ( const TOOL_EVENT aEvent)
inline

Put an event to the event queue to be processed at the end of event processing cycle.

Parameters
aEventis the event to be put into the queue.

Definition at line 267 of file tool_manager.h.

268  {
269  // Horrific hack, but it's a crash bug. Don't let inter-frame commands stack up
270  // waiting to be processed.
271  if( aEvent.IsSimulator() && m_eventQueue.size() > 0 && m_eventQueue.back().IsSimulator() )
272  m_eventQueue.pop_back();
273 
274  m_eventQueue.push_back( aEvent );
275  }
bool IsSimulator() const
Indicate if the event is from the simulator.
Definition: tool_event.cpp:227
std::list< TOOL_EVENT > m_eventQueue
Right click context menu position.
Definition: tool_manager.h:572

References TOOL_EVENT::IsSimulator(), and m_eventQueue.

Referenced by SCH_EDIT_FRAME::AddJunction(), SCH_MOVE_TOOL::AlignElements(), EDIT_TOOL::doMoveSelection(), SCH_EDIT_TOOL::editFieldText(), SCH_LINE_WIRE_BUS_TOOL::finishSegments(), GROUP_TOOL::Group(), PL_EDIT_TOOL::Main(), SYMBOL_EDITOR_MOVE_TOOL::Main(), SCH_MOVE_TOOL::Main(), SYMBOL_EDITOR_EDIT_TOOL::Mirror(), SCH_EDIT_TOOL::Mirror(), BOARD_EDITOR_CONTROL::modifyLockSelected(), TOOLS_HOLDER::PopTool(), PrimeTool(), SYMBOL_EDITOR_EDIT_TOOL::Properties(), SCH_EDIT_TOOL::Properties(), GROUP_TOOL::RemoveFromGroup(), SYMBOL_EDITOR_EDIT_TOOL::Rotate(), SCH_EDIT_TOOL::Rotate(), RunAction(), SCH_DRAWING_TOOLS::SingleClickPlace(), DIALOG_SYMBOL_PROPERTIES::TransferDataFromWindow(), GROUP_TOOL::Ungroup(), and EDA_DRAW_FRAME::UpdateMsgPanel().

◆ PrimeTool()

void TOOL_MANAGER::PrimeTool ( const VECTOR2D aPosition)

"Prime" a tool by sending a cursor left-click event with the mouse position set to the passed in position.

Parameters
aPositionis the mouse position to use in the eventReturn the hot key associated with a given action or 0 if there is none.
aActionis the queried action.

Definition at line 350 of file tool_manager.cpp.

351 {
352  int modifiers = 0;
353  modifiers |= wxGetKeyState( WXK_SHIFT ) ? MD_SHIFT : 0;
354  modifiers |= wxGetKeyState( WXK_CONTROL ) ? MD_CTRL : 0;
355  modifiers |= wxGetKeyState( WXK_ALT ) ? MD_ALT : 0;
356 
357  TOOL_EVENT evt( TC_MOUSE, TA_PRIME, BUT_LEFT | modifiers );
358  evt.SetMousePosition( aPosition );
359 
360  PostEvent( evt );
361 }
Generic, UI-independent tool event.
Definition: tool_event.h:173
void PostEvent(const TOOL_EVENT &aEvent)
Put an event to the event queue to be processed at the end of event processing cycle.
Definition: tool_manager.h:267

References BUT_LEFT, MD_ALT, MD_CTRL, MD_SHIFT, PostEvent(), TOOL_EVENT::SetMousePosition(), TA_PRIME, and TC_MOUSE.

Referenced by DRAWING_TOOL::DrawDimension(), DRAWING_TOOL::DrawZone(), and ROUTER_TOOL::MainLoop().

◆ ProcessEvent()

bool TOOL_MANAGER::ProcessEvent ( const TOOL_EVENT aEvent)

Propagate an event to tools that requested events of matching type(s).

Parameters
aEventis the event to be processed.
Returns
true if the event is a managed hotkey

Definition at line 935 of file tool_manager.cpp.

936 {
937  bool handled = processEvent( aEvent );
938 
939  TOOL_STATE* activeTool = GetCurrentToolState();
940 
941  if( activeTool )
942  setActiveState( activeTool );
943 
944  if( m_view && m_view->IsDirty() )
945  {
946  if( GetToolHolder() )
948 
949 #if defined( __WXMAC__ )
950  wxTheApp->ProcessPendingEvents(); // required for updating brightening behind a popup menu
951 #endif
952  }
953 
954  UpdateUI( aEvent );
955 
956  return handled;
957 }
void UpdateUI(const TOOL_EVENT &aEvent)
Update the status bar and synchronizes toolbars.
bool processEvent(const TOOL_EVENT &aEvent)
Main function for event processing.
virtual void RefreshCanvas()
Definition: tools_holder.h:152
void setActiveState(TOOL_STATE *aState)
Save the previous active state and sets a new one.
TOOL_STATE * GetCurrentToolState() const
Return the #TOOL_STATE object representing the state of the active tool.
Definition: tool_manager.h:328
KIGFX::VIEW * m_view
Definition: tool_manager.h:566
TOOLS_HOLDER * GetToolHolder() const
Definition: tool_manager.h:300
bool IsDirty() const
Return true if any of the VIEW layers needs to be refreshened.
Definition: view.h:546

References GetCurrentToolState(), GetToolHolder(), KIGFX::VIEW::IsDirty(), m_view, processEvent(), TOOLS_HOLDER::RefreshCanvas(), setActiveState(), and UpdateUI().

Referenced by PL_SELECTION_TOOL::AddItemsToSel(), EE_SELECTION_TOOL::AddItemsToSel(), PL_SELECTION_TOOL::AddItemToSel(), PCB_SELECTION_TOOL::AddItemToSel(), EE_SELECTION_TOOL::AddItemToSel(), EDIT_TOOL::ChangeTrackWidth(), PL_SELECTION_TOOL::ClearSelection(), PCB_SELECTION_TOOL::ClearSelection(), GERBVIEW_SELECTION_TOOL::clearSelection(), EE_SELECTION_TOOL::ClearSelection(), PANEL_KICAD_LAUNCHER::CreateLaunchers(), COMMON_TOOLS::CursorControl(), TOOL_DISPATCHER::DispatchWxCommand(), TOOL_DISPATCHER::DispatchWxEvent(), PCB_TOOL_BASE::doInteractiveItemPlacement(), PCB_SELECTION_TOOL::expandConnection(), PCB_SELECTION_TOOL::filterSelection(), PCB_SELECTION_TOOL::findCallback(), EDIT_TOOL::Flip(), TOOL_DISPATCHER::handleMouseButton(), SYMBOL_EDITOR_MOVE_TOOL::Main(), EE_SELECTION_TOOL::Main(), PCB_SELECTION_TOOL::Main(), EDIT_TOOL::Mirror(), EDIT_TOOL::MoveExact(), ACTION_MENU::OnMenuEvent(), ACTION_TOOLBAR::onPaletteEvent(), ACTION_TOOLBAR::onToolEvent(), PAD_TOOL::pastePadProperties(), PCB_CONTROL::placeBoardItems(), EDIT_TOOL::Properties(), PAD_TOOL::pushPadSettings(), EE_SELECTION_TOOL::RebuildSelection(), SCH_EDITOR_CONTROL::Redo(), POSITION_RELATIVE_TOOL::RelativeItemSelectionMove(), PL_SELECTION_TOOL::RemoveItemFromSel(), EE_SELECTION_TOOL::RemoveItemFromSel(), PCB_SELECTION_TOOL::RemoveItemFromSel(), PL_SELECTION_TOOL::RemoveItemsFromSel(), EE_SELECTION_TOOL::RemoveItemsFromSel(), EE_SELECTION_TOOL::RequestSelection(), EDIT_TOOL::Rotate(), EE_SELECTION_TOOL::SelectConnection(), COMMON_TOOLS::SelectionTool(), GERBVIEW_SELECTION_TOOL::SelectItem(), GERBVIEW_SELECTION_TOOL::SelectItems(), PCB_SELECTION_TOOL::SelectItems(), PL_SELECTION_TOOL::selectMultiple(), EE_SELECTION_TOOL::selectMultiple(), PCB_SELECTION_TOOL::selectMultiple(), PCB_SELECTION_TOOL::selectNet(), PL_SELECTION_TOOL::SelectPoint(), GERBVIEW_SELECTION_TOOL::selectPoint(), EE_SELECTION_TOOL::selectPoint(), PCB_SELECTION_TOOL::selectPoint(), PCB_SELECTION_TOOL::selectSameSheet(), PCB_SELECTION_TOOL::selectSheetContents(), SCH_EDITOR_CONTROL::Undo(), GERBVIEW_SELECTION_TOOL::UnselectItem(), GERBVIEW_SELECTION_TOOL::UnselectItems(), and PCB_SELECTION_TOOL::UnselectItems().

◆ processEvent()

bool TOOL_MANAGER::processEvent ( const TOOL_EVENT aEvent)
private

Main function for event processing.

Returns
true if a hotkey was handled.

Definition at line 1099 of file tool_manager.cpp.

1100 {
1101  wxLogTrace( kicadTraceToolStack, "TOOL_MANAGER::processEvent - %s", aEvent.Format() );
1102 
1103  // First try to dispatch the action associated with the event if it is a key press event
1104  bool handled = DispatchHotKey( aEvent );
1105 
1106  if( !handled )
1107  {
1108  TOOL_EVENT mod_event( aEvent );
1109 
1110  // Only immediate actions get the position. Otherwise clear for tool activation
1111  if( GetToolHolder() && !GetToolHolder()->GetDoImmediateActions() )
1112  {
1113  // An tool-selection-event has no position
1114  if( mod_event.GetCommandStr().is_initialized()
1115  && mod_event.GetCommandStr().get() != GetToolHolder()->CurrentToolName()
1116  && !mod_event.ForceImmediate() )
1117  {
1118  mod_event.SetHasPosition( false );
1119  }
1120  }
1121 
1122  // If the event is not handled through a hotkey activation, pass it to the currently
1123  // running tool loops
1124  handled |= dispatchInternal( mod_event );
1125  handled |= dispatchActivation( mod_event );
1126 
1127  // Open the context menu if requested by a tool
1128  DispatchContextMenu( mod_event );
1129 
1130  // Dispatch any remaining events in the event queue
1131  while( !m_eventQueue.empty() )
1132  {
1133  TOOL_EVENT event = m_eventQueue.front();
1134  m_eventQueue.pop_front();
1135  processEvent( event );
1136  }
1137  }
1138 
1139  wxLogTrace( kicadTraceToolStack, "TOOL_MANAGER::processEvent - %s handle event: %s",
1140  ( handled ? "Did" : "Did not" ), aEvent.Format() );
1141 
1142  return handled;
1143 }
void DispatchContextMenu(const TOOL_EVENT &aEvent)
Handle context menu related events.
const std::string Format() const
Return information about event in form of a human-readable string.
Definition: tool_event.cpp:76
bool processEvent(const TOOL_EVENT &aEvent)
Main function for event processing.
bool dispatchActivation(const TOOL_EVENT &aEvent)
Check if it is a valid activation event and invokes a proper tool.
bool DispatchHotKey(const TOOL_EVENT &aEvent)
Handle specific events, that are intended for TOOL_MANAGER rather than tools.
Generic, UI-independent tool event.
Definition: tool_event.h:173
std::string CurrentToolName() const
TOOLS_HOLDER * GetToolHolder() const
Definition: tool_manager.h:300
std::list< TOOL_EVENT > m_eventQueue
Right click context menu position.
Definition: tool_manager.h:572
const wxChar *const kicadTraceToolStack
Flag to enable tracing of the tool handling stack.
bool dispatchInternal(const TOOL_EVENT &aEvent)
Passe an event at first to the active tools, then to all others.

References TOOLS_HOLDER::CurrentToolName(), dispatchActivation(), DispatchContextMenu(), DispatchHotKey(), dispatchInternal(), TOOL_EVENT::ForceImmediate(), TOOL_EVENT::Format(), TOOL_EVENT::GetCommandStr(), GetToolHolder(), kicadTraceToolStack, m_eventQueue, and TOOL_EVENT::SetHasPosition().

Referenced by CancelTool(), DeactivateTool(), invokeTool(), ProcessEvent(), and RunAction().

◆ RegisterTool()

void TOOL_MANAGER::RegisterTool ( TOOL_BASE aTool)

Add a tool to the manager set and sets it up.

Called once for each tool during application initialization.

Parameters
aTooltool to be added. Ownership is transferred.

Definition at line 230 of file tool_manager.cpp.

231 {
232  wxASSERT_MSG( m_toolNameIndex.find( aTool->GetName() ) == m_toolNameIndex.end(),
233  wxT( "Adding two tools with the same name may result in unexpected behaviour.") );
234  wxASSERT_MSG( m_toolIdIndex.find( aTool->GetId() ) == m_toolIdIndex.end(),
235  wxT( "Adding two tools with the same ID may result in unexpected behaviour.") );
236  wxASSERT_MSG( m_toolTypes.find( typeid( *aTool ).name() ) == m_toolTypes.end(),
237  wxT( "Adding two tools of the same type may result in unexpected behaviour.") );
238 
239  m_toolOrder.push_back( aTool );
240 
241  TOOL_STATE* st = new TOOL_STATE( aTool );
242 
243  m_toolState[aTool] = st;
244  m_toolNameIndex[aTool->GetName()] = st;
245  m_toolIdIndex[aTool->GetId()] = st;
246  m_toolTypes[typeid( *aTool ).name()] = st->theTool;
247 
248  aTool->attachManager( this );
249 }
TOOL_VEC m_toolOrder
Index of registered tools current states, associated by tools' objects.
Definition: tool_manager.h:542
ID_STATE_MAP m_toolIdIndex
Index of the registered tools to easily lookup by their type.
Definition: tool_manager.h:551
TOOL_ID GetId() const
Return the unique identifier of the tool.
Definition: tool_base.h:121
void attachManager(TOOL_MANAGER *aManager)
Set the TOOL_MANAGER the tool will belong to.
Definition: tool_base.cpp:60
NAME_STATE_MAP m_toolNameIndex
Index of the registered tools current states, associated by tools' ID numbers.
Definition: tool_manager.h:548
const std::string & GetName() const
Return the name of the tool.
Definition: tool_base.h:134
TOOL_STATE_MAP m_toolState
Index of the registered tools current states, associated by tools' names.
Definition: tool_manager.h:545
std::map< const char *, TOOL_BASE * > m_toolTypes
Stack of the active tools.
Definition: tool_manager.h:554

References TOOL_BASE::attachManager(), TOOL_BASE::GetId(), TOOL_BASE::GetName(), m_toolIdIndex, m_toolNameIndex, m_toolOrder, m_toolState, m_toolTypes, and TOOL_MANAGER::TOOL_STATE::theTool.

Referenced by FOOTPRINT_VIEWER_FRAME::FOOTPRINT_VIEWER_FRAME(), PANEL_PREV_3D::PANEL_PREV_3D(), PL_EDITOR_FRAME::setupTools(), FOOTPRINT_EDIT_FRAME::setupTools(), SYMBOL_VIEWER_FRAME::setupTools(), KICAD_MANAGER_FRAME::setupTools(), SYMBOL_EDIT_FRAME::setupTools(), CVPCB_MAINFRAME::setupTools(), GERBVIEW_FRAME::setupTools(), and SCH_EDIT_FRAME::setupTools().

◆ ResetTools()

void TOOL_MANAGER::ResetTools ( TOOL_BASE::RESET_REASON  aReason)

Reset all tools (i.e.

calls their Reset() method).

Definition at line 537 of file tool_manager.cpp.

538 {
539  DeactivateTool();
540 
541  for( auto& state : m_toolState )
542  {
543  TOOL_BASE* tool = state.first;
544  setActiveState( state.second );
545  tool->Reset( aReason );
546 
547  if( tool->GetType() == INTERACTIVE )
548  static_cast<TOOL_INTERACTIVE*>( tool )->resetTransitions();
549  }
550 }
TOOL_TYPE GetType() const
Return the type of the tool.
Definition: tool_base.h:109
void DeactivateTool()
Deactivate the currently active tool.
virtual void Reset(RESET_REASON aReason)=0
Bring the tool to a known, initial state.
Tool that interacts with the user.
Definition: tool_base.h:50
void setActiveState(TOOL_STATE *aState)
Save the previous active state and sets a new one.
Base abstract interface for all kinds of tools.
Definition: tool_base.h:66
TOOL_STATE_MAP m_toolState
Index of the registered tools current states, associated by tools' names.
Definition: tool_manager.h:545

References DeactivateTool(), TOOL_BASE::GetType(), INTERACTIVE, m_toolState, TOOL_BASE::Reset(), and setActiveState().

Referenced by GERBVIEW_FRAME::ActivateGalCanvas(), PCB_BASE_FRAME::ActivateGalCanvas(), GERBVIEW_FRAME::Clear_DrawLayers(), FOOTPRINT_VIEWER_FRAME::ClickOnFootprintList(), GERBVIEW_FRAME::Erase_Current_DrawLayer(), InitTools(), SYMBOL_EDITOR_CONTROL::OnDeMorgan(), SYMBOL_EDIT_FRAME::OnSelectUnit(), FOOTPRINT_WIZARD_FRAME::ReloadFootprint(), PCB_BASE_EDIT_FRAME::SetBoard(), SYMBOL_EDIT_FRAME::SetCurPart(), DIALOG_GRID_SETTINGS::TransferDataFromWindow(), DISPLAY_FOOTPRINTS_FRAME::updateView(), FOOTPRINT_WIZARD_FRAME::updateView(), FOOTPRINT_VIEWER_FRAME::updateView(), and FOOTPRINT_EDIT_FRAME::UpdateView().

◆ RunAction() [1/6]

template<typename T >
bool TOOL_MANAGER::RunAction ( const std::string &  aActionName,
bool  aNow = false,
aParam = NULL 
)
inline

Run the specified action.

The common format for action names is "application.ToolName.Action".

Parameters
aActionNameis the name of action to be invoked.
aNowdecides if the action has to be run immediately or after the current coroutine is preemptied.
aParamis an optional parameter that might be used by the invoked action. Its meaning depends on the action.
Returns
False if the action was not found.

Definition at line 141 of file tool_manager.h.

142  {
143  return RunAction( aActionName, aNow, reinterpret_cast<void*>( aParam ) );
144  }
bool RunAction(const std::string &aActionName, bool aNow=false, T aParam=NULL)
Run the specified action.
Definition: tool_manager.h:141

Referenced by DIALOG_GLOBAL_DELETION::acceptPcbDelete(), PROJECT_TREE_ITEM::Activate(), FOOTPRINT_VIEWER_FRAME::AddFootprintToPCB(), SYMBOL_EDITOR_CONTROL::AddSymbolToSchematic(), SCH_MOVE_TOOL::AlignElements(), APPEARANCE_CONTROLS::APPEARANCE_CONTROLS(), CVPCB_ASSOCIATION_TOOL::Associate(), SCH_EDIT_TOOL::AutoplaceFields(), SCH_EDIT_TOOL::BreakWire(), SCH_EDIT_FRAME::canCloseWindow(), ROUTER_TOOL::CanInlineDrag(), SCH_EDIT_TOOL::ChangeTextType(), EDIT_TOOL::ChangeTrackWidth(), SCH_EDIT_TOOL::CleanupSheetPins(), GERBVIEW_CONTROL::ClearAllLayers(), PCB_SELECTION_TOOL::ClearSelection(), ZONE_CREATE_HELPER::commitZone(), SCH_EDIT_TOOL::ConvertDeMorgan(), SCH_EDIT_FRAME::ConvertPart(), MICROWAVE_TOOL::createInductorBetween(), SYMBOL_EDIT_FRAME::CreateNewPart(), COMMON_TOOLS::CursorControl(), SCH_EDITOR_CONTROL::Cut(), SYMBOL_VIEWER_FRAME::DClickOnCmpList(), DIALOG_FOOTPRINT_CHECKER::deleteAllMarkers(), DIALOG_ERC::deleteAllMarkers(), DIALOG_DRC::deleteAllMarkers(), SYMBOL_EDITOR_EDIT_TOOL::DeleteItemCursor(), PL_EDIT_TOOL::DeleteItemCursor(), SCH_EDIT_TOOL::DeleteItemCursor(), PCB_CONTROL::DeleteItemCursor(), DIALOG_MIGRATE_BUSES::DIALOG_MIGRATE_BUSES(), SCH_EDIT_FRAME::DisplayCurrentSheet(), DIALOG_CLEANUP_TRACKS_AND_VIAS::doCleanup(), DIALOG_CLEANUP_GRAPHICS::doCleanup(), SIM_PLOT_FRAME::doCloseWindow(), SYMBOL_EDITOR_EDIT_TOOL::DoDelete(), SCH_EDIT_TOOL::DoDelete(), SCH_LINE_WIRE_BUS_TOOL::doDrawSegments(), SCH_FIELD::DoHypertextMenu(), PCB_TOOL_BASE::doInteractiveItemPlacement(), EDIT_TOOL::doMoveSelection(), SCH_LINE_WIRE_BUS_TOOL::doUnfoldBus(), DRAWING_TOOL::DrawArc(), DRAWING_TOOL::drawArc(), DRAWING_TOOL::DrawCircle(), DRAWING_TOOL::DrawDimension(), DRAWING_TOOL::DrawRectangle(), DRAWING_TOOL::drawSegment(), SCH_LINE_WIRE_BUS_TOOL::DrawSegments(), SYMBOL_EDITOR_DRAWING_TOOLS::DrawShape(), PL_DRAWING_TOOLS::DrawShape(), SCH_DRAWING_TOOLS::DrawSheet(), BOARD_EDITOR_CONTROL::DrillOrigin(), SYMBOL_EDITOR_EDIT_TOOL::Duplicate(), SCH_EDIT_TOOL::Duplicate(), EDIT_TOOL::Duplicate(), SCH_EDIT_TOOL::EditField(), BOARD_EDITOR_CONTROL::EditFpInFpEditor(), PAD_TOOL::EditPad(), SYMBOL_EDITOR_EDIT_TOOL::editSymbolProperties(), SCH_EDITOR_CONTROL::EditWithSymbolEditor(), SYMBOL_EDIT_FRAME::emptyScreen(), SCH_NAVIGATE_TOOL::EnterSheet(), SCH_EDITOR_CONTROL::EnterSheet(), PAD_TOOL::EnumeratePads(), TRACK_WIDTH_MENU::eventHandler(), DIFF_PAIR_MENU::eventHandler(), GLOBAL_EDIT_TOOL::ExchangeFootprints(), SCH_EDIT_FRAME::ExecuteRemoteCommand(), PCB_EDIT_FRAME::ExecuteRemoteCommand(), PAD_TOOL::explodePad(), SCH_EDITOR_CONTROL::FindComponentAndItem(), PCB_POINT_EDITOR::finishItem(), SCH_LINE_WIRE_BUS_TOOL::finishSegments(), EDIT_TOOL::Flip(), GERBVIEW_FRAME::GERBVIEW_FRAME(), EDIT_TOOL::GetAndPlace(), DRAWING_TOOL::getSourceZoneForAction(), SYMBOL_EDIT_FRAME::GetSymbolFromRedoList(), SYMBOL_EDIT_FRAME::GetSymbolFromUndoList(), PCB_CONTROL::GridSetOrigin(), BOARD_INSPECTION_TOOL::HighlightItem(), SCH_EDITOR_CONTROL::HighlightNetCursor(), BOARD_INSPECTION_TOOL::HighlightNetTool(), SCH_NAVIGATE_TOOL::HypertextCommand(), SCH_EDIT_FRAME::importFile(), FOOTPRINT_EDITOR_CONTROL::ImportFootprint(), PL_EDIT_TOOL::ImportWorksheetContent(), SCH_EDIT_FRAME::initScreenZoom(), ROUTER_TOOL::InlineBreakTrack(), ROUTER_TOOL::InlineDrag(), EDIT_TOOL::invokeInlineRouter(), SCH_EDIT_FRAME::KiwayMailIn(), PCB_EDIT_FRAME::KiwayMailIn(), SCH_NAVIGATE_TOOL::LeaveSheet(), SCH_EDITOR_CONTROL::LeaveSheet(), SYMBOL_EDIT_FRAME::LoadOneLibraryPartAux(), SYMBOL_EDIT_FRAME::LoadSymbolFromCurrentLib(), BOARD_INSPECTION_TOOL::LocalRatsnestTool(), PL_EDIT_TOOL::Main(), CVPCB_FOOTPRINT_VIEWER_SELECTION_TOOL::Main(), SYMBOL_EDITOR_MOVE_TOOL::Main(), CVPCB_CONTROL::Main(), SCH_MOVE_TOOL::Main(), PL_SELECTION_TOOL::Main(), GERBVIEW_SELECTION_TOOL::Main(), EE_SELECTION_TOOL::Main(), PCB_SELECTION_TOOL::Main(), ROUTER_TOOL::MainLoop(), LENGTH_TUNER_TOOL::MainLoop(), SYMBOL_EDITOR_EDIT_TOOL::Mirror(), SCH_EDIT_TOOL::Mirror(), EDIT_TOOL::Mirror(), BOARD_EDITOR_CONTROL::modifyLockSelected(), EDIT_TOOL::MoveExact(), DIALOG_GROUP_PROPERTIES::OnAddMember(), SYMBOL_TREE_PANE::onComponentSelected(), DIALOG_DRC::OnDeleteOneClick(), SYMBOL_EDITOR_CONTROL::OnDeMorgan(), PCB_EDIT_FRAME::OnEditItemRequest(), DIALOG_ERC::OnERCItemSelected(), DIALOG_CONSTRAINTS_REPORTER::OnErrorLinkClicked(), DIALOG_INSPECTION_REPORTER::OnErrorLinkClicked(), SCH_EDIT_FRAME::OnFindDialogClose(), ZONE_CREATE_HELPER::OnFirstPoint(), KICAD_MANAGER_FRAME::OnIdle(), FOOTPRINTS_LISTBOX::OnLeftDClick(), ACTION_MENU::OnMenuEvent(), APPEARANCE_CONTROLS::onNetclassContextMenu(), APPEARANCE_CONTROLS::onNetContextMenu(), PL_EDITOR_FRAME::OnNewPageLayout(), KICAD_MANAGER_FRAME::OnOpenFileInTextEditor(), SIM_PLOT_FRAME::onProbe(), EDA_DRAW_FRAME::OnSelectGrid(), DIALOG_POSITION_RELATIVE::OnSelectItemClick(), HIERARCHY_NAVIG_DLG::onSelectSheetPath(), SYMBOL_EDIT_FRAME::OnSelectUnit(), EDA_DRAW_FRAME::OnSelectZoom(), SCH_EDIT_FRAME::onSize(), SIM_PLOT_FRAME::onTune(), SCH_EDIT_FRAME::OpenProjectFiles(), SYMBOL_EDITOR_EDIT_TOOL::Paste(), PL_EDIT_TOOL::Paste(), SCH_EDITOR_CONTROL::Paste(), ROUTER_TOOL::performRouting(), ZONE_CREATE_HELPER::performZoneCutout(), GROUP_TOOL::PickNewMember(), EDIT_TOOL::pickReferencePoint(), SYMBOL_EDITOR_EDIT_TOOL::PinTable(), PCB_CONTROL::placeBoardItems(), 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(), PCB_CONTROL::Print(), GERBVIEW_CONTROL::Print(), SYMBOL_EDITOR_EDIT_TOOL::Properties(), SCH_EDIT_TOOL::Properties(), EDIT_TOOL::Properties(), SCH_EDIT_FRAME::PutDataInPreviousState(), CVPCB_MAINFRAME::refreshAfterComponentSearch(), POSITION_RELATIVE_TOOL::RelativeItemSelectionMove(), EDIT_TOOL::Remove(), PCB_POINT_EDITOR::removeCorner(), GROUP_TOOL::RemoveFromGroup(), SCH_EDIT_TOOL::RepeatDrawItem(), SYMBOL_EDITOR_DRAWING_TOOLS::RepeatDrawItem(), PCB_SELECTION_TOOL::RequestSelection(), PL_EDITOR_FRAME::RollbackFromUndo(), SYMBOL_EDIT_FRAME::RollbackSymbolFromUndo(), SYMBOL_EDITOR_EDIT_TOOL::Rotate(), SCH_EDIT_TOOL::Rotate(), EDIT_TOOL::Rotate(), RunAction(), ACTION_MANAGER::RunHotKey(), FOOTPRINT_EDIT_FRAME::SaveFootprintToBoard(), SYMBOL_EDIT_FRAME::saveLibrary(), DIALOG_FIND::search(), PL_SELECTION_TOOL::SelectPoint(), EE_SELECTION_TOOL::selectPoint(), POSITION_RELATIVE_TOOL::SelectPositionRelativeItem(), GERBVIEW_FRAME::SetActiveLayer(), DRAWING_TOOL::SetAnchor(), SYMBOL_EDIT_FRAME::SetCurPart(), SCH_EDIT_FRAME::SetScreen(), SYMBOL_VIEWER_FRAME::SetSelectedComponent(), CVPCB_MAINFRAME::setupEventHandlers(), SCH_EDIT_FRAME::setupTools(), EDA_DRAW_FRAME::setupUnits(), DRC_TOOL::ShowDRCDialog(), APPEARANCE_CONTROLS::showNetclass(), SCH_DRAWING_TOOLS::SingleClickPlace(), SYMBOL_VIEWER_FRAME::SYMBOL_VIEWER_FRAME(), PCB_EDIT_FRAME::Tracks_and_Vias_Size_Event(), BOARD_EDITOR_CONTROL::TrackWidthDec(), BOARD_EDITOR_CONTROL::TrackWidthInc(), DIALOG_GRID_SETTINGS::TransferDataFromWindow(), DIALOG_GROUP_PROPERTIES::TransferDataFromWindow(), SYMBOL_EDITOR_DRAWING_TOOLS::TwoClickPlace(), SCH_DRAWING_TOOLS::TwoClickPlace(), GROUP_TOOL::Ungroup(), EDA_DRAW_FRAME::unitsChangeRefresh(), NET_GRID_TABLE::updateNetVisibility(), SCH_EDIT_FRAME::UpdateSymbolFromEditor(), DISPLAY_FOOTPRINTS_FRAME::updateView(), FOOTPRINT_WIZARD_FRAME::updateView(), FOOTPRINT_VIEWER_FRAME::updateView(), BOARD_EDITOR_CONTROL::ViaSizeDec(), BOARD_EDITOR_CONTROL::ViaSizeInc(), BOARD_EDITOR_CONTROL::ZoneMerge(), EDA_DRAW_FRAME::Zoom_Automatique(), DIALOG_NETLIST::~DIALOG_NETLIST(), and DIALOG_UPDATE_PCB::~DIALOG_UPDATE_PCB().

◆ RunAction() [2/6]

bool TOOL_MANAGER::RunAction ( const std::string &  aActionName,
bool  aNow,
void *  aParam 
)

Definition at line 280 of file tool_manager.cpp.

281 {
282  TOOL_ACTION* action = m_actionMgr->FindAction( aActionName );
283 
284  if( !action )
285  {
286  wxASSERT_MSG( false, wxString::Format( "Could not find action %s.", aActionName ) );
287  return false;
288  }
289 
290  RunAction( *action, aNow, aParam );
291 
292  return false;
293 }
ACTION_MANAGER * m_actionMgr
Original cursor position, if overridden by the context menu handler.
Definition: tool_manager.h:560
bool RunAction(const std::string &aActionName, bool aNow=false, T aParam=NULL)
Run the specified action.
Definition: tool_manager.h:141
TOOL_ACTION * FindAction(const std::string &aActionName) const
Find an action with a given name (if there is one available).
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
Represent a single user action.
Definition: tool_action.h:49

References ACTION_MANAGER::FindAction(), Format(), m_actionMgr, and RunAction().

◆ RunAction() [3/6]

bool TOOL_MANAGER::RunAction ( const std::string &  aActionName,
bool  aNow = false 
)
inline

Definition at line 148 of file tool_manager.h.

149  {
150  return RunAction( aActionName, aNow, (void*) NULL );
151  }
bool RunAction(const std::string &aActionName, bool aNow=false, T aParam=NULL)
Run the specified action.
Definition: tool_manager.h:141
#define NULL

References NULL, and RunAction().

◆ RunAction() [4/6]

template<typename T >
bool TOOL_MANAGER::RunAction ( const TOOL_ACTION aAction,
bool  aNow = false,
aParam = NULL 
)
inline

Run the specified action.

This function will only return if the action has been handled when the action is run immediately (aNow = true), otherwise it will always return false.

Parameters
aActionis the action to be invoked.
aNowdecides if the action has to be run immediately or after the current coroutine is preemptied.
aParamis an optional parameter that might be used by the invoked action. Its meaning depends on the action.
Returns
True if the action was handled immediately

Definition at line 167 of file tool_manager.h.

168  {
169  return RunAction( aAction, aNow, reinterpret_cast<void*>( aParam ) );
170  }
bool RunAction(const std::string &aActionName, bool aNow=false, T aParam=NULL)
Run the specified action.
Definition: tool_manager.h:141

References RunAction().

◆ RunAction() [5/6]

bool TOOL_MANAGER::RunAction ( const TOOL_ACTION aAction,
bool  aNow,
void *  aParam 
)

Definition at line 314 of file tool_manager.cpp.

315 {
316  bool handled = false;
317  TOOL_EVENT event = aAction.MakeEvent();
318 
319  if( event.Category() == TC_COMMAND )
321 
322  // Allow to override the action parameter
323  if( aParam )
324  event.SetParameter( aParam );
325 
326  if( aNow )
327  {
328  TOOL_STATE* current = m_activeState;
329  handled = processEvent( event );
330  setActiveState( current );
331  UpdateUI( event );
332  }
333  else
334  {
335  PostEvent( event );
336  }
337 
338  return handled;
339 }
VECTOR2D GetCursorPosition()
void UpdateUI(const TOOL_EVENT &aEvent)
Update the status bar and synchronizes toolbars.
bool processEvent(const TOOL_EVENT &aEvent)
Main function for event processing.
void SetMousePosition(const VECTOR2D &aP)
Definition: tool_event.h:476
void setActiveState(TOOL_STATE *aState)
Save the previous active state and sets a new one.
Generic, UI-independent tool event.
Definition: tool_event.h:173
TOOL_STATE * m_activeState
Definition: tool_manager.h:586
TOOL_EVENT MakeEvent() const
Return the event associated with the action (i.e.
Definition: tool_action.h:123
void PostEvent(const TOOL_EVENT &aEvent)
Put an event to the event queue to be processed at the end of event processing cycle.
Definition: tool_manager.h:267

References GetCursorPosition(), m_activeState, TOOL_ACTION::MakeEvent(), PostEvent(), processEvent(), setActiveState(), TOOL_EVENT::SetMousePosition(), TC_COMMAND, and UpdateUI().

◆ RunAction() [6/6]

bool TOOL_MANAGER::RunAction ( const TOOL_ACTION aAction,
bool  aNow = false 
)
inline

Definition at line 174 of file tool_manager.h.

175  {
176  return RunAction( aAction, aNow, (void*) NULL );
177  }
bool RunAction(const std::string &aActionName, bool aNow=false, T aParam=NULL)
Run the specified action.
Definition: tool_manager.h:141
#define NULL

References NULL, and RunAction().

◆ RunMainStack()

void TOOL_MANAGER::RunMainStack ( TOOL_BASE aTool,
std::function< void()>  aFunc 
)

Definition at line 617 of file tool_manager.cpp.

618 {
619  TOOL_STATE* st = m_toolState[aTool];
620  setActiveState( st );
621  st->cofunc->RunMainStack( std::move( aFunc ) );
622 }
void setActiveState(TOOL_STATE *aState)
Save the previous active state and sets a new one.
TOOL_STATE_MAP m_toolState
Index of the registered tools current states, associated by tools' names.
Definition: tool_manager.h:545

References TOOL_MANAGER::TOOL_STATE::cofunc, m_toolState, COROUTINE< ReturnType, ArgType >::RunMainStack(), and setActiveState().

Referenced by TOOL_INTERACTIVE::RunMainStack().

◆ runTool()

bool TOOL_MANAGER::runTool ( TOOL_BASE aTool)
private

Make a tool active, so it can receive events and react to them.

The activated tool is pushed on the active tools stack, so the last activated tool receives events first.

Parameters
aToolis the tool to be run.

Definition at line 391 of file tool_manager.cpp.

392 {
393  wxASSERT( aTool != NULL );
394 
395  if( !isRegistered( aTool ) )
396  {
397  wxASSERT_MSG( false, wxT( "You cannot run unregistered tools" ) );
398  return false;
399  }
400 
401  TOOL_ID id = aTool->GetId();
402 
403  if( aTool->GetType() == INTERACTIVE )
404  static_cast<TOOL_INTERACTIVE*>( aTool )->resetTransitions();
405 
406  // If the tool is already active, bring it to the top of the active tools stack
407  if( isActive( aTool ) && m_activeTools.size() > 1 )
408  {
409  auto it = std::find( m_activeTools.begin(), m_activeTools.end(), id );
410 
411  if( it != m_activeTools.end() )
412  {
413  if( it != m_activeTools.begin() )
414  {
415  m_activeTools.erase( it );
416  m_activeTools.push_front( id );
417  }
418 
419  return false;
420  }
421  }
422 
424  aTool->Reset( TOOL_INTERACTIVE::RUN );
425 
426  // Add the tool on the front of the processing queue (it gets events first)
427  m_activeTools.push_front( id );
428 
429  return true;
430 }
TOOL_TYPE GetType() const
Return the type of the tool.
Definition: tool_base.h:109
ID_STATE_MAP m_toolIdIndex
Index of the registered tools to easily lookup by their type.
Definition: tool_manager.h:551
TOOL_ID GetId() const
Return the unique identifier of the tool.
Definition: tool_base.h:121
Tool is invoked after being inactive.
Definition: tool_base.h:80
virtual void Reset(RESET_REASON aReason)=0
Bring the tool to a known, initial state.
int TOOL_ID
Unique identifier for tools.
Definition: tool_base.h:57
Tool that interacts with the user.
Definition: tool_base.h:50
#define NULL
void setActiveState(TOOL_STATE *aState)
Save the previous active state and sets a new one.
bool isActive(TOOL_BASE *aTool)
Return information about a tool activation status.
bool isRegistered(TOOL_BASE *aTool) const
Return information about a tool registration status.
Definition: tool_manager.h:501
ID_LIST m_activeTools
Instance of ACTION_MANAGER that handles TOOL_ACTIONs.
Definition: tool_manager.h:557

References TOOL_BASE::GetId(), TOOL_BASE::GetType(), INTERACTIVE, isActive(), isRegistered(), m_activeTools, m_toolIdIndex, NULL, TOOL_BASE::Reset(), TOOL_BASE::RUN, and setActiveState().

Referenced by dispatchActivation().

◆ SaveClipboard()

bool TOOL_MANAGER::SaveClipboard ( const std::string &  aTextUTF8)

Store information to the system clipboard.

Parameters
aTextis the information to be stored, expected UTF8 encoding. The text will be stored as Unicode string (not stored as UTF8 string).
Returns
False if error occurred.

Definition at line 970 of file tool_manager.cpp.

971 {
972  wxLogNull doNotLog; // disable logging of failed clipboard actions
973 
974  if( wxTheClipboard->Open() )
975  {
976  // Store the UTF8 string as unicode string in clipboard:
977  wxTheClipboard->SetData( new wxTextDataObject( wxString( aTextUTF8.c_str(),
978  wxConvUTF8 ) ) );
979  wxTheClipboard->Close();
980 
981  return true;
982  }
983 
984  return false;
985 }

Referenced by PL_EDIT_TOOL::Copy(), SYMBOL_EDITOR_EDIT_TOOL::Copy(), and SCH_EDITOR_CONTROL::doCopy().

◆ saveViewControls()

void TOOL_MANAGER::saveViewControls ( TOOL_STATE aState)
private

Save the #VIEW_CONTROLS settings to the tool state object.

If #VIEW_CONTROLS settings are affected by TOOL_MANAGER, the original settings are saved.

Definition at line 1053 of file tool_manager.cpp.

1054 {
1055  aState->vcSettings = m_viewControls->GetSettings();
1056 
1057  if( m_menuActive )
1058  {
1059  // Context menu is active, so the cursor settings are overridden (see DispatchContextMenu())
1060  auto it = m_cursorSettings.find( aState->theTool->GetId() );
1061 
1062  if( it != m_cursorSettings.end() )
1063  {
1065 
1066  // Tool has overridden the cursor position, so store the new settings
1067  if( !curr.m_forceCursorPosition || curr.m_forcedPosition != m_menuCursor )
1068  {
1069  if( !curr.m_forceCursorPosition )
1070  it->second = NULLOPT;
1071  else
1072  it->second = curr.m_forcedPosition;
1073  }
1074  else
1075  {
1076  OPT<VECTOR2D> cursor = it->second;
1077 
1078  if( cursor )
1079  {
1080  aState->vcSettings.m_forceCursorPosition = true;
1081  aState->vcSettings.m_forcedPosition = *cursor;
1082  }
1083  else
1084  {
1085  aState->vcSettings.m_forceCursorPosition = false;
1086  }
1087  }
1088  }
1089  }
1090 }
bool m_menuActive
Tool currently displaying a popup menu. It is negative when there is no menu displayed.
Definition: tool_manager.h:580
VECTOR2D m_menuCursor
Definition: tool_manager.h:575
std::map< TOOL_ID, OPT< VECTOR2D > > m_cursorSettings
Definition: tool_manager.h:563
VECTOR2D m_forcedPosition
Is the forced cursor position enabled.
Definition: view_controls.h:55
const VC_SETTINGS & GetSettings() const
Apply VIEW_CONTROLS settings from an object.
const auto NULLOPT
Definition: optional.h:9
bool m_forceCursorPosition
Should the cursor be locked within the parent window area.
Definition: view_controls.h:58
Structure to keep VIEW_CONTROLS settings for easy store/restore operations.
Definition: view_controls.h:41
KIGFX::VIEW_CONTROLS * m_viewControls
Definition: tool_manager.h:567
boost::optional< T > OPT
Definition: optional.h:7

References TOOL_BASE::GetId(), KIGFX::VIEW_CONTROLS::GetSettings(), m_cursorSettings, KIGFX::VC_SETTINGS::m_forceCursorPosition, KIGFX::VC_SETTINGS::m_forcedPosition, m_menuActive, m_menuCursor, m_viewControls, NULLOPT, TOOL_MANAGER::TOOL_STATE::theTool, and TOOL_MANAGER::TOOL_STATE::vcSettings.

Referenced by setActiveState().

◆ ScheduleContextMenu()

void TOOL_MANAGER::ScheduleContextMenu ( TOOL_BASE aTool,
ACTION_MENU aMenu,
CONTEXT_MENU_TRIGGER  aTrigger 
)

Set behavior of the tool's context popup menu.

Parameters
aToolis the parent tool.
aMenuis the menu structure, defined by the tool.
aTriggerdetermines when the menu is activated: CMENU_NOW: opens the menu right now CMENU_BUTTON: opens the menu when RMB is pressed CMENU_OFF: menu is disabled. May be called from a coroutine context.

Definition at line 960 of file tool_manager.cpp.

962 {
963  TOOL_STATE* st = m_toolState[aTool];
964 
965  st->contextMenu = aMenu;
966  st->contextMenuTrigger = aTrigger;
967 }
TOOL_STATE_MAP m_toolState
Index of the registered tools current states, associated by tools' names.
Definition: tool_manager.h:545

References TOOL_MANAGER::TOOL_STATE::contextMenu, TOOL_MANAGER::TOOL_STATE::contextMenuTrigger, and m_toolState.

Referenced by TOOL_INTERACTIVE::SetContextMenu().

◆ ScheduleNextState()

void TOOL_MANAGER::ScheduleNextState ( TOOL_BASE aTool,
TOOL_STATE_FUNC aHandler,
const TOOL_EVENT_LIST aConditions 
)

Define a state transition.

The events that cause a given handler method in the tool to be called. Called by TOOL_INTERACTIVE::Go(). May be called from a coroutine context.

Definition at line 602 of file tool_manager.cpp.

604 {
605  TOOL_STATE* st = m_toolState[aTool];
606 
607  st->transitions.emplace_back( TRANSITION( aConditions, aHandler ) );
608 }
TOOL_STATE_MAP m_toolState
Index of the registered tools current states, associated by tools' names.
Definition: tool_manager.h:545
std::pair< TOOL_EVENT_LIST, TOOL_STATE_FUNC > TRANSITION
Definition: tool_manager.h:452

References m_toolState, and TOOL_MANAGER::TOOL_STATE::transitions.

Referenced by TOOL_INTERACTIVE::goInternal().

◆ ScheduleWait()

TOOL_EVENT * TOOL_MANAGER::ScheduleWait ( TOOL_BASE aTool,
const TOOL_EVENT_LIST aConditions 
)

Pause execution of a given tool until one or more events matching aConditions arrives.

The pause/resume operation is done through COROUTINE object. Called only from coroutines.

Definition at line 625 of file tool_manager.cpp.

626 {
627  TOOL_STATE* st = m_toolState[aTool];
628 
629  wxASSERT( !st->pendingWait ); // everything collapses on two KiYield() in a row
630 
631  // indicate to the manager that we are going to sleep and we shall be
632  // woken up when an event matching aConditions arrive
633  st->pendingWait = true;
634  st->waitEvents = aConditions;
635 
636  // switch context back to event dispatcher loop
637  st->cofunc->KiYield();
638 
639  // If the tool should shutdown, it gets a null event to break the loop
640  if( st->shutdown )
641  return nullptr;
642  else
643  return &st->wakeupEvent;
644 }
TOOL_STATE_MAP m_toolState
Index of the registered tools current states, associated by tools' names.
Definition: tool_manager.h:545

References TOOL_MANAGER::TOOL_STATE::cofunc, COROUTINE< ReturnType, ArgType >::KiYield(), m_toolState, TOOL_MANAGER::TOOL_STATE::pendingWait, TOOL_MANAGER::TOOL_STATE::shutdown, TOOL_MANAGER::TOOL_STATE::waitEvents, and TOOL_MANAGER::TOOL_STATE::wakeupEvent.

Referenced by TOOL_INTERACTIVE::Wait().

◆ setActiveState()

void TOOL_MANAGER::setActiveState ( TOOL_STATE aState)
private

Save the previous active state and sets a new one.

Parameters
aStateis the new active state. Might be null to indicate there is no new active state.List of tools in the order they were registered

Definition at line 1146 of file tool_manager.cpp.

1147 {
1148  if( m_activeState && m_viewControls )
1150 
1151  m_activeState = aState;
1152 
1153  if( m_activeState && m_viewControls )
1154  applyViewControls( aState );
1155 }
void applyViewControls(TOOL_STATE *aState)
Apply #VIEW_CONTROLS settings stored in a #TOOL_STATE object.
KIGFX::VIEW_CONTROLS * m_viewControls
Definition: tool_manager.h:567
TOOL_STATE * m_activeState
Definition: tool_manager.h:586
void saveViewControls(TOOL_STATE *aState)
Save the #VIEW_CONTROLS settings to the tool state object.

References applyViewControls(), m_activeState, m_viewControls, and saveViewControls().

Referenced by dispatchInternal(), finishTool(), InitTools(), invokeTool(), ProcessEvent(), ResetTools(), RunAction(), RunMainStack(), runTool(), and ShutdownTool().

◆ SetEnvironment()

void TOOL_MANAGER::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).

These are made available to the tool. Called by the parent frame when it is set up.

Definition at line 1031 of file tool_manager.cpp.

1034 {
1035  m_model = aModel;
1036  m_view = aView;
1037  m_viewControls = aViewControls;
1038  m_frame = aFrame;
1039  m_settings = aSettings;
1040 }
TOOLS_HOLDER * m_frame
Definition: tool_manager.h:568
EDA_ITEM * m_model
Definition: tool_manager.h:565
KIGFX::VIEW_CONTROLS * m_viewControls
Definition: tool_manager.h:567
KIGFX::VIEW * m_view
Definition: tool_manager.h:566
APP_SETTINGS_BASE * m_settings
Queue that stores events to be processed at the end of the event processing cycle.
Definition: tool_manager.h:569

References m_frame, m_model, m_settings, m_view, and m_viewControls.

Referenced by GERBVIEW_FRAME::ActivateGalCanvas(), PCB_BASE_FRAME::ActivateGalCanvas(), DISPLAY_FOOTPRINTS_FRAME::DISPLAY_FOOTPRINTS_FRAME(), EVT_GRID_CMD_CELL_CHANGED(), EVT_TOOL_RANGE(), FOOTPRINT_VIEWER_FRAME::FOOTPRINT_VIEWER_FRAME(), PANEL_PREV_3D::PANEL_PREV_3D(), PCB_BASE_EDIT_FRAME::SetBoard(), PCB_EDIT_FRAME::setupTools(), PL_EDITOR_FRAME::setupTools(), FOOTPRINT_EDIT_FRAME::setupTools(), SYMBOL_VIEWER_FRAME::setupTools(), KICAD_MANAGER_FRAME::setupTools(), SYMBOL_EDIT_FRAME::setupTools(), CVPCB_MAINFRAME::setupTools(), GERBVIEW_FRAME::setupTools(), and SCH_EDIT_FRAME::setupTools().

◆ ShutdownAllTools()

void TOOL_MANAGER::ShutdownAllTools ( )

Shutdown all tools with a currently registered event loop in this tool manager by waking them up with a null event.

Definition at line 433 of file tool_manager.cpp.

434 {
435  // Create a temporary list of tools to iterate over since when the tools shutdown
436  // they remove themselves from the list automatically (invalidating the iterator)
437  ID_LIST tmpList = m_activeTools;
438 
439  for( auto id : tmpList )
440  {
441  ShutdownTool( id );
442  }
443 }
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
Instance of ACTION_MANAGER that handles TOOL_ACTIONs.
Definition: tool_manager.h:557
std::list< TOOL_ID > ID_LIST
Definition: tool_manager.h:66

References m_activeTools, and ShutdownTool().

Referenced by SCH_EDIT_FRAME::doCloseWindow(), CVPCB_MAINFRAME::~CVPCB_MAINFRAME(), DISPLAY_FOOTPRINTS_FRAME::~DISPLAY_FOOTPRINTS_FRAME(), FOOTPRINT_EDIT_FRAME::~FOOTPRINT_EDIT_FRAME(), FOOTPRINT_VIEWER_FRAME::~FOOTPRINT_VIEWER_FRAME(), GERBVIEW_FRAME::~GERBVIEW_FRAME(), KICAD_MANAGER_FRAME::~KICAD_MANAGER_FRAME(), PL_EDITOR_FRAME::~PL_EDITOR_FRAME(), SCH_EDIT_FRAME::~SCH_EDIT_FRAME(), SYMBOL_EDIT_FRAME::~SYMBOL_EDIT_FRAME(), and SYMBOL_VIEWER_FRAME::~SYMBOL_VIEWER_FRAME().

◆ ShutdownTool() [1/3]

void TOOL_MANAGER::ShutdownTool ( TOOL_BASE aTool)

Shutdown the specified tool by waking it up with a null event to terminate the processing loop.

Parameters
aToolis the tool to shutdown

Definition at line 470 of file tool_manager.cpp.

471 {
472  wxASSERT( aTool != NULL );
473 
474  TOOL_ID id = aTool->GetId();
475 
476  if( isActive( aTool ) )
477  {
478  auto it = std::find( m_activeTools.begin(), m_activeTools.end(), id );
479 
480  TOOL_STATE* st = m_toolIdIndex[*it];
481 
482  // the tool state handler is waiting for events (i.e. called Wait() method)
483  if( st && st->pendingWait )
484  {
485  // Wake up the tool and tell it to shutdown
486  st->shutdown = true;
487  st->pendingWait = false;
488  st->waitEvents.clear();
489 
490  if( st->cofunc )
491  {
492  wxLogTrace( kicadTraceToolStack,
493  "TOOL_MANAGER::ShutdownTool - Shutting down tool %s",
494  st->theTool->GetName() );
495 
496  setActiveState( st );
497  bool end = !st->cofunc->Resume();
498 
499  if( end )
500  finishTool( st );
501  }
502  }
503  }
504 }
ID_STATE_MAP m_toolIdIndex
Index of the registered tools to easily lookup by their type.
Definition: tool_manager.h:551
TOOL_ID GetId() const
Return the unique identifier of the tool.
Definition: tool_base.h:121
ID_LIST::iterator finishTool(TOOL_STATE *aState)
Deactivate a tool and does the necessary clean up.
int TOOL_ID
Unique identifier for tools.
Definition: tool_base.h:57
#define NULL
void setActiveState(TOOL_STATE *aState)
Save the previous active state and sets a new one.
bool isActive(TOOL_BASE *aTool)
Return information about a tool activation status.
const wxChar *const kicadTraceToolStack
Flag to enable tracing of the tool handling stack.
ID_LIST m_activeTools
Instance of ACTION_MANAGER that handles TOOL_ACTIONs.
Definition: tool_manager.h:557

References finishTool(), TOOL_BASE::GetId(), isActive(), kicadTraceToolStack, m_activeTools, m_toolIdIndex, NULL, and setActiveState().

Referenced by ShutdownAllTools(), and ShutdownTool().

◆ ShutdownTool() [2/3]

void TOOL_MANAGER::ShutdownTool ( TOOL_ID  aToolId)

Shutdown the specified tool by waking it up with a null event to terminate the processing loop.

Parameters
aToolIdis the ID of the tool to shutdown

Definition at line 446 of file tool_manager.cpp.

447 {
448  TOOL_BASE* tool = FindTool( aToolId );
449 
450  if( tool && tool->GetType() == INTERACTIVE )
451  ShutdownTool( tool );
452 
453  wxLogTrace( kicadTraceToolStack, "TOOL_MANAGER::ShutdownTool - no tool with ID %d",
454  aToolId );
455 }
TOOL_TYPE GetType() const
Return the type of the tool.
Definition: tool_base.h:109
TOOL_BASE * FindTool(int aId) const
Search for a tool with given ID.
void ShutdownTool(TOOL_BASE *aTool)
Shutdown the specified tool by waking it up with a null event to terminate the processing loop.
Tool that interacts with the user.
Definition: tool_base.h:50
Base abstract interface for all kinds of tools.
Definition: tool_base.h:66
const wxChar *const kicadTraceToolStack
Flag to enable tracing of the tool handling stack.

References FindTool(), TOOL_BASE::GetType(), INTERACTIVE, kicadTraceToolStack, and ShutdownTool().

◆ ShutdownTool() [3/3]

void TOOL_MANAGER::ShutdownTool ( const std::string &  aToolName)

Shutdown the specified tool by waking it up with a null event to terminate the processing loop.

Parameters
aToolNameis name of the tool to shutdown

Definition at line 458 of file tool_manager.cpp.

459 {
460  TOOL_BASE* tool = FindTool( aToolName );
461 
462  if( tool && tool->GetType() == INTERACTIVE )
463  ShutdownTool( tool );
464 
465  wxLogTrace( kicadTraceToolStack, "TOOL_MANAGER::ShutdownTool - no tool with name %s",
466  aToolName );
467 }
TOOL_TYPE GetType() const
Return the type of the tool.
Definition: tool_base.h:109
TOOL_BASE * FindTool(int aId) const
Search for a tool with given ID.
void ShutdownTool(TOOL_BASE *aTool)
Shutdown the specified tool by waking it up with a null event to terminate the processing loop.
Tool that interacts with the user.
Definition: tool_base.h:50
Base abstract interface for all kinds of tools.
Definition: tool_base.h:66
const wxChar *const kicadTraceToolStack
Flag to enable tracing of the tool handling stack.

References FindTool(), TOOL_BASE::GetType(), INTERACTIVE, kicadTraceToolStack, and ShutdownTool().

◆ UpdateUI()

void TOOL_MANAGER::UpdateUI ( const TOOL_EVENT aEvent)

Update the status bar and synchronizes toolbars.

Definition at line 1165 of file tool_manager.cpp.

1166 {
1167  EDA_BASE_FRAME* frame = dynamic_cast<EDA_BASE_FRAME*>( GetToolHolder() );
1168 
1169  if( frame )
1170  frame->UpdateStatusBar();
1171 }
virtual void UpdateStatusBar()
Update the status bar information.
TOOLS_HOLDER * GetToolHolder() const
Definition: tool_manager.h:300
The base frame for deriving all KiCad main window classes.

References GetToolHolder(), and EDA_BASE_FRAME::UpdateStatusBar().

Referenced by ProcessEvent(), and RunAction().

◆ VetoContextMenuMouseWarp()

void TOOL_MANAGER::VetoContextMenuMouseWarp ( )
inline

Disable mouse warping after the current context menu is closed.

This must be called before invoking each context menu. It's a good idea to call this from non-modal dialogs (e.g. DRC window).

Definition at line 428 of file tool_manager.h.

429  {
431  }
bool m_warpMouseAfterContextMenu
Flag indicating whether a context menu is currently displayed.
Definition: tool_manager.h:577

References m_warpMouseAfterContextMenu.

Referenced by DIALOG_SHIM::DIALOG_SHIM(), SCH_LINE_WIRE_BUS_TOOL::doDrawSegments(), SYMBOL_EDITOR_DRAWING_TOOLS::DrawShape(), PL_DRAWING_TOOLS::DrawShape(), SCH_DRAWING_TOOLS::DrawSheet(), LIB_TREE::onContextMenu(), SCH_DRAWING_TOOLS::PlaceComponent(), SCH_DRAWING_TOOLS::PlaceImage(), PL_DRAWING_TOOLS::PlaceItem(), SYMBOL_EDITOR_DRAWING_TOOLS::TwoClickPlace(), and SCH_DRAWING_TOOLS::TwoClickPlace().

Member Data Documentation

◆ m_actionMgr

ACTION_MANAGER* TOOL_MANAGER::m_actionMgr
private

Original cursor position, if overridden by the context menu handler.

Definition at line 560 of file tool_manager.h.

Referenced by DispatchHotKey(), GetActionManager(), GetActions(), GetHotKey(), InitTools(), RunAction(), TOOL_MANAGER(), and ~TOOL_MANAGER().

◆ m_activeState

TOOL_STATE* TOOL_MANAGER::m_activeState
private

Definition at line 586 of file tool_manager.h.

Referenced by finishTool(), RunAction(), and setActiveState().

◆ m_activeTools

ID_LIST TOOL_MANAGER::m_activeTools
private

◆ m_cursorSettings

std::map<TOOL_ID, OPT<VECTOR2D> > TOOL_MANAGER::m_cursorSettings
private

Definition at line 563 of file tool_manager.h.

Referenced by DispatchContextMenu(), and saveViewControls().

◆ m_eventQueue

std::list<TOOL_EVENT> TOOL_MANAGER::m_eventQueue
private

Right click context menu position.

Definition at line 572 of file tool_manager.h.

Referenced by PostEvent(), and processEvent().

◆ m_frame

TOOLS_HOLDER* TOOL_MANAGER::m_frame
private

Definition at line 568 of file tool_manager.h.

Referenced by DispatchContextMenu(), GetToolHolder(), and SetEnvironment().

◆ m_menuActive

bool TOOL_MANAGER::m_menuActive
private

Tool currently displaying a popup menu. It is negative when there is no menu displayed.

Definition at line 580 of file tool_manager.h.

Referenced by DispatchContextMenu(), IsContextMenuActive(), and saveViewControls().

◆ m_menuCursor

VECTOR2D TOOL_MANAGER::m_menuCursor
private

Definition at line 575 of file tool_manager.h.

Referenced by DispatchContextMenu(), GetMenuCursorPos(), and saveViewControls().

◆ m_menuOwner

TOOL_ID TOOL_MANAGER::m_menuOwner
private

Pointer to the state object corresponding to the currently executed tool.

Definition at line 583 of file tool_manager.h.

Referenced by DispatchContextMenu(), and dispatchInternal().

◆ m_model

EDA_ITEM* TOOL_MANAGER::m_model
private

Definition at line 565 of file tool_manager.h.

Referenced by GetModel(), and SetEnvironment().

◆ m_settings

APP_SETTINGS_BASE* TOOL_MANAGER::m_settings
private

Queue that stores events to be processed at the end of the event processing cycle.

Definition at line 569 of file tool_manager.h.

Referenced by GetSettings(), and SetEnvironment().

◆ m_toolIdIndex

ID_STATE_MAP TOOL_MANAGER::m_toolIdIndex
private

Index of the registered tools to easily lookup by their type.

Definition at line 551 of file tool_manager.h.

Referenced by DispatchContextMenu(), dispatchInternal(), FindTool(), GetCurrentToolState(), InitTools(), IsToolActive(), RegisterTool(), runTool(), and ShutdownTool().

◆ m_toolNameIndex

NAME_STATE_MAP TOOL_MANAGER::m_toolNameIndex
private

Index of the registered tools current states, associated by tools' ID numbers.

Definition at line 548 of file tool_manager.h.

Referenced by dispatchActivation(), FindTool(), InitTools(), and RegisterTool().

◆ m_toolOrder

TOOL_VEC TOOL_MANAGER::m_toolOrder
private

Index of registered tools current states, associated by tools' objects.

Definition at line 542 of file tool_manager.h.

Referenced by InitTools(), and RegisterTool().

◆ m_toolState

TOOL_STATE_MAP TOOL_MANAGER::m_toolState
private

Index of the registered tools current states, associated by tools' names.

Definition at line 545 of file tool_manager.h.

Referenced by ClearTransitions(), dispatchInternal(), InitTools(), isRegistered(), RegisterTool(), ResetTools(), RunMainStack(), ScheduleContextMenu(), ScheduleNextState(), ScheduleWait(), and ~TOOL_MANAGER().

◆ m_toolTypes

std::map<const char*, TOOL_BASE*> TOOL_MANAGER::m_toolTypes
private

Stack of the active tools.

Definition at line 554 of file tool_manager.h.

Referenced by GetTool(), InitTools(), and RegisterTool().

◆ m_view

KIGFX::VIEW* TOOL_MANAGER::m_view
private

Definition at line 566 of file tool_manager.h.

Referenced by GetView(), ProcessEvent(), and SetEnvironment().

◆ m_viewControls

◆ m_warpMouseAfterContextMenu

bool TOOL_MANAGER::m_warpMouseAfterContextMenu
private

Flag indicating whether a context menu is currently displayed.

Definition at line 577 of file tool_manager.h.

Referenced by DispatchContextMenu(), and VetoContextMenuMouseWarp().


The documentation for this class was generated from the following files: