KiCad PCB EDA Suite
TOOL_MANAGER Class Reference

TOOL_MANAGER. 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
 

Public Member Functions

 TOOL_MANAGER ()
 
 ~TOOL_MANAGER ()
 
void RegisterTool (TOOL_BASE *aTool)
 Function RegisterTool() Adds a tool to the manager set and sets it up. More...
 
bool InvokeTool (TOOL_ID aToolId)
 Function InvokeTool() Calls a tool by sending a tool activation event to tool of given ID. More...
 
bool InvokeTool (const std::string &aToolName)
 Function InvokeTool() Calls 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)
 Function RunAction() Runs 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)
 Function RunAction() Runs 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 PrimeTool (const VECTOR2D &aPosition)
 Function PrimeTool() "Primes" 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)
 

More...
 
ACTION_MANAGERGetActionManager ()
 
TOOL_BASEFindTool (int aId) const
 Function FindTool() Searches for a tool with given ID. More...
 
TOOL_BASEFindTool (const std::string &aName) const
 Function FindTool() Searches for a tool with given name. More...
 
template<typename T >
T * GetTool ()
 
void DeactivateTool ()
 Function DeactivateTool() Deactivates the currently active tool. More...
 
bool IsToolActive (TOOL_ID aId) const
 Function IsToolActive() Returns true if a tool with given id is active (executing) More...
 
void ResetTools (TOOL_BASE::RESET_REASON aReason)
 Function ResetTools() Resets all tools (i.e. More...
 
void InitTools ()
 Function InitTools() Initializes all registered tools. More...
 
bool ProcessEvent (const TOOL_EVENT &aEvent)
 Propagates an event to tools that requested events of matching type(s). More...
 
void PostEvent (const TOOL_EVENT &aEvent)
 Puts 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)
 Sets 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
 Returns id of the tool that is on the top of the active tools stack (was invoked the most recently). More...
 
TOOL_BASEGetCurrentTool () const
 Returns the tool that is on the top of the active tools stack (was invoked the most recently). More...
 
TOOL_STATEGetCurrentToolState () const
 Returns the TOOL_STATE object representing the state of the active tool. More...
 
int GetPriority (int aToolId) const
 Returns priority of a given tool. More...
 
void ScheduleNextState (TOOL_BASE *aTool, TOOL_STATE_FUNC &aHandler, const TOOL_EVENT_LIST &aConditions)
 Defines a state transition - the events that cause a given handler method in the tool to be called. More...
 
void ClearTransitions (TOOL_BASE *aTool)
 Clears the state transition map for a tool. More...
 
void RunMainStack (TOOL_BASE *aTool, std::function< void()> aFunc)
 
void UpdateUI (const TOOL_EVENT &aEvent)
 Updates the status bar and synchronizes toolbars. More...
 
TOOL_EVENTScheduleWait (TOOL_BASE *aTool, const TOOL_EVENT_LIST &aConditions)
 Pauses 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)
 Sets behaviour of the tool's context popup menu. More...
 
bool SaveClipboard (const std::string &aText)
 Stores an information to the system clipboard. More...
 
std::string GetClipboard () const
 Returns the information currently stored in the system clipboard. More...
 
const KIGFX::VC_SETTINGSGetCurrentToolVC () const
 Returns 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 ()
 Disables mouse warping after the current context menu is closed. More...
 
void DispatchContextMenu (const TOOL_EVENT &aEvent)
 Function DispatchContextMenu() Handles context menu related events. More...
 
bool DispatchHotKey (const TOOL_EVENT &aEvent)
 Function dispatchHotKey() Handles specific events, that are intended for TOOL_MANAGER rather than tools. More...
 

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)
 Function dispatchInternal Passes an event at first to the active tools, then to all others. More...
 
bool dispatchActivation (const TOOL_EVENT &aEvent)
 Function dispatchActivation() Checks if it is a valid activation event and invokes a proper tool. More...
 
bool invokeTool (TOOL_BASE *aTool)
 Function invokeTool() Invokes a tool by sending a proper event (in contrary to runTool, which makes the tool run for real). More...
 
bool runTool (TOOL_BASE *aTool)
 Function runTool() Makes a tool active, so it can receive events and react to them. More...
 
ID_LIST::iterator finishTool (TOOL_STATE *aState)
 Function finishTool() Deactivates a tool and does the necessary clean up. More...
 
bool isRegistered (TOOL_BASE *aTool) const
 Function isRegistered() Returns information about a tool registration status. More...
 
bool isActive (TOOL_BASE *aTool)
 Function isActive() Returns information about a tool activation status. More...
 
void saveViewControls (TOOL_STATE *aState)
 Function saveViewControls() Saves the VIEW_CONTROLS settings to the tool state object. More...
 
void applyViewControls (TOOL_STATE *aState)
 Function applyViewControls() Applies 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)
 Saves the previous active state and sets a new one. More...
 

Private Attributes

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

Detailed Description

TOOL_MANAGER.

Master controller class:

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

Definition at line 51 of file tool_manager.h.

Member Typedef Documentation

◆ ID_LIST

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

Definition at line 65 of file tool_manager.h.

◆ ID_STATE_MAP

Definition at line 64 of file tool_manager.h.

◆ NAME_STATE_MAP

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

Definition at line 63 of file tool_manager.h.

◆ TOOL_STATE_MAP

Definition at line 62 of file tool_manager.h.

◆ TRANSITION

Definition at line 428 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( NULL ),
202  m_view( NULL ),
203  m_viewControls( NULL ),
204  m_frame( NULL ),
206  m_menuActive( false ),
207  m_menuOwner( -1 ),
208  m_activeState( nullptr )
209 {
210  m_actionMgr = new ACTION_MANAGER( this );
211 }
bool m_menuActive
Flag indicating whether a context menu is currently displayed.
Definition: tool_manager.h:554
ACTION_MANAGER * m_actionMgr
Instance of ACTION_MANAGER that handles TOOL_ACTIONs.
Definition: tool_manager.h:534
ACTION_MANAGER.
TOOLS_HOLDER * m_frame
Definition: tool_manager.h:542
EDA_ITEM * m_model
Definition: tool_manager.h:539
TOOL_ID m_menuOwner
Tool currently displaying a popup menu. It is negative when there is no menu displayed.
Definition: tool_manager.h:557
#define NULL
KIGFX::VIEW_CONTROLS * m_viewControls
Definition: tool_manager.h:541
KIGFX::VIEW * m_view
Definition: tool_manager.h:540
bool m_warpMouseAfterContextMenu
Definition: tool_manager.h:551
TOOL_STATE * m_activeState
Pointer to the state object corresponding to the currently executed tool.
Definition: tool_manager.h:560

References m_actionMgr.

◆ ~TOOL_MANAGER()

TOOL_MANAGER::~TOOL_MANAGER ( )

Definition at line 214 of file tool_manager.cpp.

215 {
216  std::map<TOOL_BASE*, TOOL_STATE*>::iterator it, it_end;
217 
218  for( it = m_toolState.begin(), it_end = m_toolState.end(); it != it_end; ++it )
219  {
220  delete it->second->cofunc; // delete cofunction
221  delete it->second; // delete TOOL_STATE
222  delete it->first; // delete the tool itself
223  }
224 
225  delete m_actionMgr;
226 }
ACTION_MANAGER * m_actionMgr
Instance of ACTION_MANAGER that handles TOOL_ACTIONs.
Definition: tool_manager.h:534
TOOL_STATE_MAP m_toolState
Index of registered tools current states, associated by tools' objects.
Definition: tool_manager.h:519

References m_actionMgr, and m_toolState.

Member Function Documentation

◆ applyViewControls()

void TOOL_MANAGER::applyViewControls ( TOOL_STATE aState)
private

Function applyViewControls() Applies VIEW_CONTROLS settings stored in a TOOL_STATE object.

Definition at line 1076 of file tool_manager.cpp.

1077 {
1078  m_viewControls->ApplySettings( aState->vcSettings );
1079 }
void ApplySettings(const VC_SETTINGS &aSettings)
Applies VIEW_CONTROLS settings from an object
KIGFX::VIEW_CONTROLS * m_viewControls
Definition: tool_manager.h:541

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

Referenced by setActiveState().

◆ ClearTransitions()

void TOOL_MANAGER::ClearTransitions ( TOOL_BASE aTool)

Clears the state transition map for a tool.

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

Definition at line 599 of file tool_manager.cpp.

600 {
601  m_toolState[aTool]->transitions.clear();
602 }
TOOL_STATE_MAP m_toolState
Index of registered tools current states, associated by tools' objects.
Definition: tool_manager.h:519

References m_toolState.

Referenced by TOOL_INTERACTIVE::resetTransitions().

◆ DeactivateTool()

void TOOL_MANAGER::DeactivateTool ( )

Function DeactivateTool() Deactivates the currently active tool.

Definition at line 518 of file tool_manager.cpp.

519 {
520  // Deactivate the active tool, but do not run anything new
522  processEvent( evt );
523 }
bool processEvent(const TOOL_EVENT &aEvent)
Main function for event processing.
TOOL_EVENT.
Definition: tool_event.h:171

References processEvent(), TA_CANCEL_TOOL, and TC_COMMAND.

Referenced by LIB_DRAWING_TOOLS::DrawShape(), PL_DRAWING_TOOLS::DrawShape(), GERBVIEW_FRAME::OnCloseWindow(), LIB_EDIT_FRAME::OnExportBody(), LIB_EDIT_FRAME::OnImportBody(), ResetTools(), and FOOTPRINT_WIZARD_FRAME::~FOOTPRINT_WIZARD_FRAME().

◆ dispatchActivation()

bool TOOL_MANAGER::dispatchActivation ( const TOOL_EVENT aEvent)
private

Function dispatchActivation() Checks 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 779 of file tool_manager.cpp.

780 {
781  wxLogTrace( kicadTraceToolStack, "TOOL_MANAGER::dispatchActivation - %s", aEvent.Format() );
782  if( aEvent.IsActivate() )
783  {
784  wxString cmdStr( *aEvent.GetCommandStr() );
785 
786  auto tool = m_toolNameIndex.find( *aEvent.GetCommandStr() );
787 
788  if( tool != m_toolNameIndex.end() )
789  {
790  wxLogTrace( kicadTraceToolStack,
791  "TOOL_MANAGER::dispatchActivation - Running tool %s for event: %s",
792  tool->second->theTool->GetName(), aEvent.Format() );
793 
794  runTool( tool->second->theTool );
795  return true;
796  }
797  }
798 
799  return false;
800 }
const std::string Format() const
Function Format() Returns information about event in form of a human-readable string.
Definition: tool_event.cpp:73
NAME_STATE_MAP m_toolNameIndex
Index of the registered tools current states, associated by tools' names.
Definition: tool_manager.h:522
bool runTool(TOOL_BASE *aTool)
Function runTool() Makes a tool active, so it can receive events and react to them.
OPT< std::string > GetCommandStr() const
Definition: tool_event.h:463
bool IsActivate() const
Definition: tool_event.h:321
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)

Function DispatchContextMenu() Handles context menu related events.

Definition at line 802 of file tool_manager.cpp.

803 {
804  for( TOOL_ID toolId : m_activeTools )
805  {
806  TOOL_STATE* st = m_toolIdIndex[toolId];
807 
808  // the tool requested a context menu. The menu is activated on RMB click (CMENU_BUTTON mode)
809  // or immediately (CMENU_NOW) mode. The latter is used for clarification lists.
810  if( st->contextMenuTrigger == CMENU_OFF )
811  continue;
812 
813  if( st->contextMenuTrigger == CMENU_BUTTON && !aEvent.IsClick( BUT_RIGHT ) )
814  break;
815 
816  st->pendingWait = true;
817  st->waitEvents = TOOL_EVENT( TC_ANY, TA_ANY );
818 
819  // Store the menu pointer in case it is changed by the TOOL when handling menu events
820  ACTION_MENU* m = st->contextMenu;
821 
822  if( st->contextMenuTrigger == CMENU_NOW )
823  st->contextMenuTrigger = CMENU_OFF;
824 
825  // Store the cursor position, so the tools could execute actions
826  // using the point where the user has invoked a context menu
827  if( m_viewControls )
829 
830  // Save all tools cursor settings, as they will be overridden
831  for( auto idState : m_toolIdIndex )
832  {
833  TOOL_STATE* s = idState.second;
834  const auto& vc = s->vcSettings;
835 
836  if( vc.m_forceCursorPosition )
837  m_cursorSettings[idState.first] = vc.m_forcedPosition;
838  else
839  m_cursorSettings[idState.first] = NULLOPT;
840  }
841 
842  if( m_viewControls )
844 
845  // Display a copy of menu
846  std::unique_ptr<ACTION_MENU> menu( m->Clone() );
847 
848  m_menuOwner = toolId;
849  m_menuActive = true;
850 
851  if( wxWindow* frame = dynamic_cast<wxWindow*>( m_frame ) )
852  frame->PopupMenu( menu.get() );
853 
854  // Warp the cursor if a menu item was selected
855  if( menu->GetSelected() >= 0 )
856  {
858  m_viewControls->WarpCursor( m_menuCursor, true, false );
859  }
860  // Otherwise notify the tool of a cancelled menu
861  else
862  {
864  evt.SetHasPosition( false );
865  evt.SetParameter( m );
866  dispatchInternal( evt );
867  }
868 
869  // Restore setting in case it was vetoed
871 
872  // Notify the tools that menu has been closed
874  evt.SetHasPosition( false );
875  evt.SetParameter( m );
876  dispatchInternal( evt );
877 
878  m_menuActive = false;
879  m_menuOwner = -1;
880 
881  // Restore cursor settings
882  for( auto cursorSetting : m_cursorSettings )
883  {
884  auto it = m_toolIdIndex.find( cursorSetting.first );
885  wxASSERT( it != m_toolIdIndex.end() );
886 
887  if( it == m_toolIdIndex.end() )
888  continue;
889 
890  KIGFX::VC_SETTINGS& vc = it->second->vcSettings;
891  vc.m_forceCursorPosition = (bool) cursorSetting.second;
892  vc.m_forcedPosition = cursorSetting.second ? *cursorSetting.second : VECTOR2D( 0, 0 );
893  }
894 
895  m_cursorSettings.clear();
896  break;
897  }
898 }
bool m_menuActive
Flag indicating whether a context menu is currently displayed.
Definition: tool_manager.h:554
VECTOR2D m_menuCursor
Right click context menu position.
Definition: tool_manager.h:549
ACTION_MENU.
Definition: action_menu.h:44
ID_STATE_MAP m_toolIdIndex
Index of the registered tools current states, associated by tools' ID numbers.
Definition: tool_manager.h:525
bool IsClick(int aButtonMask=BUT_ANY) const
Definition: tool_event.cpp:178
std::map< TOOL_ID, OPT< VECTOR2D > > m_cursorSettings
Original cursor position, if overridden by the context menu handler.
Definition: tool_manager.h:537
VECTOR2D m_forcedPosition
Forced cursor position (world coordinates)
Definition: view_controls.h:69
TOOLS_HOLDER * m_frame
Definition: tool_manager.h:542
int TOOL_ID
Unique identifier for tools.
Definition: tool_base.h:56
virtual void WarpCursor(const VECTOR2D &aPosition, bool aWorldCoordinates=false, bool aWarpView=false)=0
Function WarpCursor() If enabled (.
const auto NULLOPT
Definition: optional.h:9
bool m_forceCursorPosition
Is the forced cursor position enabled
Definition: view_controls.h:72
TOOL_ID m_menuOwner
Tool currently displaying a popup menu. It is negative when there is no menu displayed.
Definition: tool_manager.h:557
TOOL_EVENT.
Definition: tool_event.h:171
Structure to keep VIEW_CONTROLS settings for easy store/restore operations
Definition: view_controls.h:55
ACTION_MENU * Clone() const
Creates a deep, recursive copy of this ACTION_MENU.
virtual void ForceCursorPosition(bool aEnabled, const VECTOR2D &aPosition=VECTOR2D(0, 0))
Function ForceCursorPosition() Places the cursor immediately at a given point.
KIGFX::VIEW_CONTROLS * m_viewControls
Definition: tool_manager.h:541
bool m_warpMouseAfterContextMenu
Definition: tool_manager.h:551
ID_LIST m_activeTools
Stack of the active tools.
Definition: tool_manager.h:531
VECTOR2D GetCursorPosition() const
Returns the current cursor position in world coordinates.
bool dispatchInternal(const TOOL_EVENT &aEvent)
Function dispatchInternal Passes 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::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, TOOL_MANAGER::TOOL_STATE::waitEvents, and KIGFX::VIEW_CONTROLS::WarpCursor().

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

◆ DispatchHotKey()

bool TOOL_MANAGER::DispatchHotKey ( const TOOL_EVENT aEvent)

Function dispatchHotKey() Handles 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 770 of file tool_manager.cpp.

771 {
772  if( aEvent.Action() == TA_KEY_PRESSED )
773  return m_actionMgr->RunHotKey( aEvent.Modifier() | aEvent.KeyCode() );
774 
775  return false;
776 }
ACTION_MANAGER * m_actionMgr
Instance of ACTION_MANAGER that handles TOOL_ACTIONs.
Definition: tool_manager.h:534
TOOL_ACTIONS Action() const
Returns more specific information about the type of an event.
Definition: tool_event.h:250
bool RunHotKey(int aHotKey) const
Function RunHotKey() Runs an action associated with a hotkey (if there is one available).
int Modifier(int aMask=MD_MODIFIER_MASK) const
Returns information about key modifiers state (Ctrl, Alt, etc.)
Definition: tool_event.h:342
int KeyCode() const
Definition: tool_event.h:347

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

Function dispatchInternal Passes an event at first to the active tools, then to all others.

Definition at line 635 of file tool_manager.cpp.

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

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

Function FindTool() Searches 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 496 of file tool_manager.cpp.

497 {
498  std::map<TOOL_ID, TOOL_STATE*>::const_iterator it = m_toolIdIndex.find( aId );
499 
500  if( it != m_toolIdIndex.end() )
501  return it->second->theTool;
502 
503  return NULL;
504 }
ID_STATE_MAP m_toolIdIndex
Index of the registered tools current states, associated by tools' ID numbers.
Definition: tool_manager.h:525
#define NULL

References m_toolIdIndex, and NULL.

Referenced by GetCurrentTool(), GLOBAL_EDIT_TOOL::Init(), EDIT_TOOL::Init(), InvokeTool(), EDIT_TOOL::isInteractiveDragEnabled(), ACTION_MANAGER::RunHotKey(), and ShutdownTool().

◆ FindTool() [2/2]

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

Function FindTool() Searches 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 507 of file tool_manager.cpp.

508 {
509  std::map<std::string, TOOL_STATE*>::const_iterator it = m_toolNameIndex.find( aName );
510 
511  if( it != m_toolNameIndex.end() )
512  return it->second->theTool;
513 
514  return NULL;
515 }
NAME_STATE_MAP m_toolNameIndex
Index of the registered tools current states, associated by tools' names.
Definition: tool_manager.h:522
#define NULL

References m_toolNameIndex, and NULL.

◆ finishTool()

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

Function finishTool() Deactivates 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 901 of file tool_manager.cpp.

902 {
903  auto it = std::find( m_activeTools.begin(), m_activeTools.end(), aState->theTool->GetId() );
904 
905  if( !aState->Pop() )
906  {
907  // Deactivate the tool if there are no other contexts saved on the stack
908  if( it != m_activeTools.end() )
909  it = m_activeTools.erase( it );
910 
911  aState->idle = true;
912  }
913 
914  if( aState == m_activeState )
915  setActiveState( nullptr );
916 
917  // Set transitions to be ready for future TOOL_EVENTs
918  TOOL_BASE* tool = aState->theTool;
919 
920  if( tool->GetType() == INTERACTIVE )
921  static_cast<TOOL_INTERACTIVE*>( tool )->resetTransitions();
922 
923  return it;
924 }
TOOL_TYPE GetType() const
Function GetType() Returns the type of the tool.
Definition: tool_base.h:110
Tool that interacts with the user
Definition: tool_base.h:49
void setActiveState(TOOL_STATE *aState)
Saves the previous active state and sets a new one.
TOOL_STATE * m_activeState
Pointer to the state object corresponding to the currently executed tool.
Definition: tool_manager.h:560
TOOL_BASE.
Definition: tool_base.h:67
ID_LIST m_activeTools
Stack of the active tools.
Definition: tool_manager.h:531

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()

ACTION_MANAGER* TOOL_MANAGER::GetActionManager ( )
inline

Definition at line 194 of file tool_manager.h.

194 { return m_actionMgr; }
ACTION_MANAGER * m_actionMgr
Instance of ACTION_MANAGER that handles TOOL_ACTIONs.
Definition: tool_manager.h:534

References m_actionMgr.

Referenced by TOOLS_HOLDER::CommonSettingsChanged(), TOOLS_HOLDER::PopTool(), and TOOLS_HOLDER::PushTool().

◆ GetActions()

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

Definition at line 353 of file tool_manager.cpp.

354 {
355  return m_actionMgr->GetActions();
356 }
ACTION_MANAGER * m_actionMgr
Instance of ACTION_MANAGER that handles TOOL_ACTIONs.
Definition: tool_manager.h:534
const std::map< std::string, TOOL_ACTION * > & GetActions()
Get a list of currently-registered actions mapped by their name.

References ACTION_MANAGER::GetActions(), and m_actionMgr.

◆ GetClipboard()

std::string TOOL_MANAGER::GetClipboard ( ) const

Returns the information currently stored in the system clipboard.

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

Definition at line 976 of file tool_manager.cpp.

977 {
978  std::string result;
979 
980  if( wxTheClipboard->Open() )
981  {
982  if( wxTheClipboard->IsSupported( wxDF_TEXT ) )
983  {
984  wxTextDataObject data;
985  wxTheClipboard->GetData( data );
986 
987  result = data.GetText().mb_str();
988  }
989 
990  wxTheClipboard->Close();
991  }
992 
993  return result;
994 }

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

◆ GetCurrentTool()

TOOL_BASE* TOOL_MANAGER::GetCurrentTool ( ) const
inline

Returns 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 312 of file tool_manager.h.

313  {
314  return FindTool( GetCurrentToolId() );
315  }
TOOL_BASE * FindTool(int aId) const
Function FindTool() Searches for a tool with given ID.
int GetCurrentToolId() const
Returns id of the tool that is on the top of the active tools stack (was invoked the most recently).
Definition: tool_manager.h:302

References FindTool(), and GetCurrentToolId().

◆ GetCurrentToolId()

int TOOL_MANAGER::GetCurrentToolId ( ) const
inline

Returns 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 302 of file tool_manager.h.

303  {
304  return m_activeTools.empty() ? -1 : m_activeTools.front();
305  }
ID_LIST m_activeTools
Stack of the active tools.
Definition: tool_manager.h:531

References m_activeTools.

Referenced by GetCurrentTool(), and GetCurrentToolState().

◆ GetCurrentToolState()

TOOL_STATE* TOOL_MANAGER::GetCurrentToolState ( ) const
inline

Returns the TOOL_STATE object representing the state of the active tool.

If there are no tools active, it returns nullptr.

Definition at line 321 of file tool_manager.h.

322  {
323  auto it = m_toolIdIndex.find( GetCurrentToolId() );
324  return ( it != m_toolIdIndex.end() ) ? it->second : nullptr;
325  }
ID_STATE_MAP m_toolIdIndex
Index of the registered tools current states, associated by tools' ID numbers.
Definition: tool_manager.h:525
int GetCurrentToolId() const
Returns id of the tool that is on the top of the active tools stack (was invoked the most recently).
Definition: tool_manager.h:302

References GetCurrentToolId(), and m_toolIdIndex.

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

◆ GetCurrentToolVC()

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

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

Definition at line 997 of file tool_manager.cpp.

998 {
999  if( TOOL_STATE* active = GetCurrentToolState() )
1000  return active->vcSettings;
1001 
1002  return m_viewControls->GetSettings();
1003 }
const VC_SETTINGS & GetSettings() const
Returns the current VIEW_CONTROLS settings
KIGFX::VIEW_CONTROLS * m_viewControls
Definition: tool_manager.h:541
TOOL_STATE * GetCurrentToolState() const
Returns the TOOL_STATE object representing the state of the active tool.
Definition: tool_manager.h:321

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

Referenced by COMMON_TOOLS::ResetLocalCoords().

◆ GetCursorPosition()

VECTOR2D TOOL_MANAGER::GetCursorPosition ( )

Definition at line 302 of file tool_manager.cpp.

303 {
304  if( m_viewControls )
306  else
307  return wxGetMousePosition();
308 }
KIGFX::VIEW_CONTROLS * m_viewControls
Definition: tool_manager.h:541
VECTOR2D GetCursorPosition() const
Returns 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 359 of file tool_manager.cpp.

360 {
361  return m_actionMgr->GetHotKey( aAction );
362 }
ACTION_MANAGER * m_actionMgr
Instance of ACTION_MANAGER that handles TOOL_ACTIONs.
Definition: tool_manager.h:534
int GetHotKey(const TOOL_ACTION &aAction) const
Function GetHotKey() Returns 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().

◆ GetModel()

EDA_ITEM* TOOL_MANAGER::GetModel ( ) const
inline

◆ GetMousePosition()

VECTOR2D TOOL_MANAGER::GetMousePosition ( )

Definition at line 293 of file tool_manager.cpp.

294 {
295  if( m_viewControls )
297  else
298  return wxGetMousePosition();
299 }
virtual VECTOR2D GetMousePosition(bool aWorldCoordinates=true) const =0
Function GetMousePosition() Returns the current mouse pointer position.
KIGFX::VIEW_CONTROLS * m_viewControls
Definition: tool_manager.h:541

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

Referenced by ACTION_MENU::OnMenuEvent().

◆ GetPriority()

int TOOL_MANAGER::GetPriority ( int  aToolId) const

Returns 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 574 of file tool_manager.cpp.

575 {
576  int priority = 0;
577 
578  for( TOOL_ID tool : m_activeTools )
579  {
580  if( tool == aToolId )
581  return priority;
582 
583  ++priority;
584  }
585 
586  return -1;
587 }
int TOOL_ID
Unique identifier for tools.
Definition: tool_base.h:56
ID_LIST m_activeTools
Stack of the active tools.
Definition: tool_manager.h:531

References m_activeTools.

Referenced by ACTION_MANAGER::RunHotKey().

◆ GetSettings()

◆ 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:60
std::map< const char *, TOOL_BASE * > m_toolTypes
Index of the registered tools to easily lookup by their type.
Definition: tool_manager.h:528

References m_toolTypes, name, and NULL.

Referenced by EDA_BASE_FRAME::AddStandardHelpMenu(), EDA_DRAW_FRAME::AddStandardSubMenus(), PCB_INSPECTION_TOOL::calculateSelectionRatsnest(), ROUTER_TOOL::CanInlineDrag(), PAD_TOOL::copyPadSettings(), EDA_3D_VIEWER::CreateMenuBar(), ZONE_CREATE_HELPER::createNewZone(), PCB_INSPECTION_TOOL::CrossProbePcbToSch(), LIB_EDIT_TOOL::DeleteItemCursor(), PL_EDIT_TOOL::DeleteItemCursor(), SCH_EDIT_TOOL::DeleteItemCursor(), PCBNEW_CONTROL::DeleteItemCursor(), SCH_EDIT_FRAME::DeleteJunction(), SCH_EDIT_FRAME::DisplayCurrentSheet(), PL_DRAW_PANEL_GAL::DisplayWorksheet(), SCH_EDITOR_CONTROL::doCopy(), SCH_EDITOR_CONTROL::doCrossProbeSchToPcb(), SCH_LINE_WIRE_BUS_TOOL::doDrawSegments(), DRAWING_TOOL::DrawDimension(), DRAWING_TOOL::drawSegment(), LIB_DRAWING_TOOLS::DrawShape(), PL_DRAWING_TOOLS::DrawShape(), SCH_DRAWING_TOOLS::DrawSheet(), PCB_EDITOR_CONTROL::DrillOrigin(), EDIT_TOOL::Duplicate(), PCB_EDITOR_CONTROL::EditFpInFpEditor(), LIB_EDIT_TOOL::editGraphicProperties(), PAD_TOOL::EditPad(), LIB_EDIT_TOOL::editSymbolProperties(), SCH_EDITOR_CONTROL::EditWithLibEdit(), SCH_EDITOR_CONTROL::EnterSheet(), SCH_EDIT_FRAME::ExecuteRemoteCommand(), FOOTPRINT_VIEWER_FRAME::FOOTPRINT_VIEWER_FRAME(), EDIT_TOOL::GetAndPlace(), FP_TREE_SYNCHRONIZING_ADAPTER::GetContextMenuTool(), SYMBOL_TREE_SYNCHRONIZING_ADAPTER::GetContextMenuTool(), PL_EDITOR_FRAME::GetLayoutFromRedoList(), PL_EDITOR_FRAME::GetLayoutFromUndoList(), DRAWING_TOOL::getSourceZoneForAction(), PCBNEW_CONTROL::GridSetOrigin(), PL_EDITOR_FRAME::HardRedraw(), LIB_EDIT_FRAME::HardRedraw(), GERBVIEW_CONTROL::HighlightControl(), PCB_INSPECTION_TOOL::highlightNet(), highlightNet(), SCH_EDITOR_CONTROL::HighlightNetCursor(), PCB_INSPECTION_TOOL::HighlightNetTool(), LIB_EDIT_TOOL::Init(), PL_EDIT_TOOL::Init(), SCH_EDIT_TOOL::Init(), PAD_TOOL::Init(), ALIGN_DISTRIBUTE_TOOL::Init(), LIB_CONTROL::Init(), PL_DRAWING_TOOLS::Init(), PL_POINT_EDITOR::Init(), PCB_EDITOR_CONTROL::Init(), POINT_EDITOR::Init(), POSITION_RELATIVE_TOOL::Init(), EE_TOOL_BASE< SCH_BASE_FRAME >::Init(), ROUTER_TOOL::InlineBreakTrack(), ROUTER_TOOL::InlineDrag(), PCB_BASE_FRAME::InstallPadOptionsFrame(), EDIT_TOOL::invokeInlineRouter(), SCH_EDIT_FRAME::KiwayMailIn(), LIB_EDIT_FRAME::LoadOneSymbol(), LIB_EDIT_FRAME::LoadPart(), PCB_INSPECTION_TOOL::LocalRatsnestTool(), LIB_MOVE_TOOL::Main(), PCB_EDITOR_CONTROL::modifyLockSelected(), PROPERTIES_FRAME::OnAcceptPrms(), DIALOG_INSPECTOR::onCellClicked(), DIALOG_POSITION_RELATIVE::OnClear(), DIALOG_POSITION_RELATIVE::OnOkClick(), DIALOG_PLOT::onRunDRC(), 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(), EDIT_TOOL::pickCopyReferencePoint(), PCBNEW_CONTROL::placeBoardItems(), DIALOG_PLOT::Plot(), LIB_EDIT_TOOL::Properties(), PAD_TOOL::pushPadSettings(), SCH_EDIT_FRAME::PutDataInPreviousState(), LIB_VIEW_FRAME::ReCreateMenuBar(), KICAD_MANAGER_FRAME::ReCreateMenuBar(), FOOTPRINT_EDIT_FRAME::ReCreateMenuBar(), FOOTPRINT_VIEWER_FRAME::ReCreateMenuBar(), LIB_EDIT_FRAME::ReCreateMenuBar(), PL_EDITOR_FRAME::ReCreateMenuBar(), CVPCB_MAINFRAME::ReCreateMenuBar(), GERBVIEW_FRAME::ReCreateMenuBar(), SCH_EDIT_FRAME::ReCreateMenuBar(), PCB_EDIT_FRAME::ReCreateMenuBar(), PCB_EDIT_FRAME::ReCreateVToolbar(), LIB_EDIT_TOOL::Redo(), SCH_EDITOR_CONTROL::Redo(), SCH_BASE_FRAME::RefreshSelection(), EDIT_TOOL::Remove(), LIB_DRAWING_TOOLS::RepeatDrawItem(), PL_EDITOR_FRAME::RollbackFromUndo(), LIB_EDIT_FRAME::RollbackPartFromUndo(), DRC::RunTests(), SCH_EDIT_FRAME::SchematicCleanUp(), PCB_TOOL_BASE::selection(), POSITION_RELATIVE_TOOL::SelectPositionRelativeItem(), FOOTPRINT_EDIT_FRAME::setupTools(), CVPCB_MAINFRAME::setupTools(), PCB_EDITOR_CONTROL::TrackWidthDec(), PCB_EDITOR_CONTROL::TrackWidthInc(), DIALOG_3D_VIEW_OPTIONS::TransferDataFromWindow(), DIALOG_LIB_EDIT_TEXT::TransferDataFromWindow(), PANEL_SETUP_RULES::TransferDataFromWindow(), DIALOG_FIELDS_EDITOR_GLOBAL::TransferDataToWindow(), DIALOG_LIB_EDIT_TEXT::TransferDataToWindow(), DIALOG_3D_VIEW_OPTIONS::TransferDataToWindow(), DIALOG_GLOBAL_EDIT_TRACKS_AND_VIAS::TransferDataToWindow(), DIALOG_GLOBAL_EDIT_TEXT_AND_GRAPHICS::TransferDataToWindow(), LIB_DRAWING_TOOLS::TwoClickPlace(), LIB_EDIT_TOOL::Undo(), SCH_EDITOR_CONTROL::Undo(), SYMBOL_UNIT_MENU::update(), BUS_UNFOLD_MENU::update(), EE_INSPECTION_TOOL::UpdateMessagePanel(), GERBVIEW_CONTROL::UpdateMessagePanel(), PL_EDITOR_CONTROL::UpdateMessagePanel(), PCBNEW_CONTROL::UpdateMessagePanel(), PCB_INSPECTION_TOOL::UpdateSelectionRatsnest(), PCB_EDITOR_CONTROL::ViaSizeDec(), PCB_EDITOR_CONTROL::ViaSizeInc(), PCB_EDITOR_CONTROL::ZoneDuplicate(), and PCB_EDITOR_CONTROL::ZoneMerge().

◆ GetToolHolder()

◆ GetView()

◆ GetViewControls()

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

Definition at line 286 of file tool_manager.h.

286 { return m_viewControls; }
KIGFX::VIEW_CONTROLS * m_viewControls
Definition: tool_manager.h:541

References m_viewControls.

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

◆ InitTools()

void TOOL_MANAGER::InitTools ( )

Function 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 542 of file tool_manager.cpp.

543 {
544  for( auto it = m_toolState.begin(); it != m_toolState.end(); /* iteration in the loop */ )
545  {
546  TOOL_BASE* tool = it->first;
547  TOOL_STATE* state = it->second;
548  setActiveState( state );
549  ++it; // keep the iterator valid if the element is going to be erased
550 
551  if( !tool->Init() )
552  {
553  wxMessageBox( wxString::Format( "Initialization of tool \"%s\" failed",
554  tool->GetName() ) );
555 
556  // Unregister the tool
557  setActiveState( nullptr );
558  m_toolState.erase( tool );
559  m_toolNameIndex.erase( tool->GetName() );
560  m_toolIdIndex.erase( tool->GetId() );
561  m_toolTypes.erase( typeid( *tool ).name() );
562 
563  delete state;
564  delete tool;
565  }
566  }
567 
568  m_actionMgr->UpdateHotKeys( true );
569 
571 }
virtual bool Init()
Function Init() Init() is called once upon a registration of the tool.
Definition: tool_base.h:92
ACTION_MANAGER * m_actionMgr
Instance of ACTION_MANAGER that handles TOOL_ACTIONs.
Definition: tool_manager.h:534
ID_STATE_MAP m_toolIdIndex
Index of the registered tools current states, associated by tools' ID numbers.
Definition: tool_manager.h:525
TOOL_ID GetId() const
Function GetId() Returns the unique identifier of the tool.
Definition: tool_base.h:121
Tool is invoked after being inactive.
Definition: tool_base.h:81
void UpdateHotKeys(bool aFullUpdate)
Function UpdateHotKeys() Optionally reads the hotkey config files and then rebuilds the internal hotk...
NAME_STATE_MAP m_toolNameIndex
Index of the registered tools current states, associated by tools' names.
Definition: tool_manager.h:522
void setActiveState(TOOL_STATE *aState)
Saves the previous active state and sets a new one.
void ResetTools(TOOL_BASE::RESET_REASON aReason)
Function ResetTools() Resets all tools (i.e.
void Format(OUTPUTFORMATTER *out, int aNestLevel, int aCtl, CPTREE &aTree)
Function Format outputs a PTREE into s-expression format via an OUTPUTFORMATTER derivative.
Definition: ptree.cpp:205
TOOL_BASE.
Definition: tool_base.h:67
const std::string & GetName() const
Function GetName() Returns the name of the tool.
Definition: tool_base.h:132
TOOL_STATE_MAP m_toolState
Index of registered tools current states, associated by tools' objects.
Definition: tool_manager.h:519
std::map< const char *, TOOL_BASE * > m_toolTypes
Index of the registered tools to easily lookup by their type.
Definition: tool_manager.h:528

References Format(), TOOL_BASE::GetId(), TOOL_BASE::GetName(), TOOL_BASE::Init(), m_actionMgr, m_toolIdIndex, m_toolNameIndex, 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(), LIB_VIEW_FRAME::setupTools(), GERBVIEW_FRAME::setupTools(), LIB_EDIT_FRAME::setupTools(), CVPCB_MAINFRAME::setupTools(), and SCH_EDIT_FRAME::setupTools().

◆ InvokeTool() [1/2]

bool TOOL_MANAGER::InvokeTool ( TOOL_ID  aToolId)

Function InvokeTool() Calls 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 249 of file tool_manager.cpp.

250 {
251  TOOL_BASE* tool = FindTool( aToolId );
252 
253  if( tool && tool->GetType() == INTERACTIVE )
254  return invokeTool( tool );
255 
256  wxLogTrace( kicadTraceToolStack,
257  "TOOL_MANAGER::InvokeTool - No interactive tool with ID %d", aToolId );
258 
259  return false; // there is no tool with the given id
260 }
TOOL_TYPE GetType() const
Function GetType() Returns the type of the tool.
Definition: tool_base.h:110
TOOL_BASE * FindTool(int aId) const
Function FindTool() Searches for a tool with given ID.
Tool that interacts with the user
Definition: tool_base.h:49
TOOL_BASE.
Definition: tool_base.h:67
const wxChar *const kicadTraceToolStack
Flag to enable tracing of the tool handling stack.
bool invokeTool(TOOL_BASE *aTool)
Function invokeTool() Invokes a tool by sending a proper event (in contrary to runTool,...

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

Referenced by TOOL_INTERACTIVE::Activate(), CVPCB_MAINFRAME::CVPCB_MAINFRAME(), FOOTPRINT_VIEWER_FRAME::FOOTPRINT_VIEWER_FRAME(), PL_SELECTION_TOOL::Main(), EE_SELECTION_TOOL::Main(), PANEL_PREV_3D::PANEL_PREV_3D(), PL_EDITOR_FRAME::setupTools(), FOOTPRINT_EDIT_FRAME::setupTools(), LIB_VIEW_FRAME::setupTools(), GERBVIEW_FRAME::setupTools(), and LIB_EDIT_FRAME::setupTools().

◆ InvokeTool() [2/2]

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

Function InvokeTool() Calls 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 263 of file tool_manager.cpp.

264 {
265  TOOL_BASE* tool = FindTool( aToolName );
266 
267  if( tool && tool->GetType() == INTERACTIVE )
268  return invokeTool( tool );
269 
270  wxLogTrace( kicadTraceToolStack,
271  "TOOL_MANAGER::InvokeTool - No interactive tool with name %s", aToolName );
272 
273  return false; // there is no tool with the given name
274 }
TOOL_TYPE GetType() const
Function GetType() Returns the type of the tool.
Definition: tool_base.h:110
TOOL_BASE * FindTool(int aId) const
Function FindTool() Searches for a tool with given ID.
Tool that interacts with the user
Definition: tool_base.h:49
TOOL_BASE.
Definition: tool_base.h:67
const wxChar *const kicadTraceToolStack
Flag to enable tracing of the tool handling stack.
bool invokeTool(TOOL_BASE *aTool)
Function invokeTool() Invokes a tool by sending a proper event (in contrary to runTool,...

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

◆ invokeTool()

bool TOOL_MANAGER::invokeTool ( TOOL_BASE aTool)
private

Function invokeTool() Invokes 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 365 of file tool_manager.cpp.

366 {
367  wxASSERT( aTool != NULL );
368 
369  TOOL_EVENT evt( TC_COMMAND, TA_ACTIVATE, aTool->GetName() );
371  processEvent( evt );
372 
373  if( TOOL_STATE* active = GetCurrentToolState() )
374  setActiveState( active );
375 
376  return true;
377 }
VECTOR2D GetCursorPosition()
bool processEvent(const TOOL_EVENT &aEvent)
Main function for event processing.
void SetMousePosition(const VECTOR2D &aP)
Definition: tool_event.h:468
#define NULL
void setActiveState(TOOL_STATE *aState)
Saves the previous active state and sets a new one.
TOOL_EVENT.
Definition: tool_event.h:171
TOOL_STATE * GetCurrentToolState() const
Returns the TOOL_STATE object representing the state of the active tool.
Definition: tool_manager.h:321
const std::string & GetName() const
Function GetName() Returns the name of the tool.
Definition: tool_base.h:132

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

Function isActive() Returns 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 1026 of file tool_manager.cpp.

1027 {
1028  if( !isRegistered( aTool ) )
1029  return false;
1030 
1031  // Just check if the tool is on the active tools stack
1032  return std::find( m_activeTools.begin(), m_activeTools.end(), aTool->GetId() ) != m_activeTools.end();
1033 }
TOOL_ID GetId() const
Function GetId() Returns the unique identifier of the tool.
Definition: tool_base.h:121
bool isRegistered(TOOL_BASE *aTool) const
Function isRegistered() Returns information about a tool registration status.
Definition: tool_manager.h:478
ID_LIST m_activeTools
Stack of the active tools.
Definition: tool_manager.h:531

References 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 398 of file tool_manager.h.

399  {
400  return m_menuActive;
401  }
bool m_menuActive
Flag indicating whether a context menu is currently displayed.
Definition: tool_manager.h:554

References m_menuActive.

Referenced by DIALOG_SHIM::DIALOG_SHIM().

◆ isRegistered()

bool TOOL_MANAGER::isRegistered ( TOOL_BASE aTool) const
inlineprivate

Function isRegistered() Returns 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 478 of file tool_manager.h.

479  {
480  return m_toolState.count( aTool ) > 0;
481  }
TOOL_STATE_MAP m_toolState
Index of registered tools current states, associated by tools' objects.
Definition: tool_manager.h:519

References m_toolState.

Referenced by isActive(), and runTool().

◆ IsToolActive()

bool TOOL_MANAGER::IsToolActive ( TOOL_ID  aId) const

Function IsToolActive() Returns true if a tool with given id is active (executing)

Definition at line 1140 of file tool_manager.cpp.

1141 {
1142  auto it = m_toolIdIndex.find( aId );
1143  return !it->second->idle;
1144 }
ID_STATE_MAP m_toolIdIndex
Index of the registered tools current states, associated by tools' ID numbers.
Definition: tool_manager.h:525

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 1006 of file tool_manager.cpp.

1007 {
1008  static int currentId;
1009 
1010  return currentId++;
1011 }

◆ PostEvent()

void TOOL_MANAGER::PostEvent ( const TOOL_EVENT aEvent)
inline

Puts 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 268 of file tool_manager.h.

269  {
270  m_eventQueue.push_back( aEvent );
271  }
std::list< TOOL_EVENT > m_eventQueue
Queue that stores events to be processed at the end of the event processing cycle.
Definition: tool_manager.h:546

References m_eventQueue.

Referenced by SCH_EDIT_FRAME::AddJunction(), SCH_EDIT_TOOL::editFieldText(), SCH_LINE_WIRE_BUS_TOOL::finishSegments(), PL_EDIT_TOOL::Main(), LIB_MOVE_TOOL::Main(), SCH_MOVE_TOOL::Main(), LIB_EDIT_TOOL::Mirror(), SCH_EDIT_TOOL::Mirror(), PCB_EDITOR_CONTROL::modifyLockSelected(), EDIT_TOOL::Move(), TOOLS_HOLDER::PopTool(), PrimeTool(), LIB_EDIT_TOOL::Properties(), SCH_EDIT_TOOL::Properties(), LIB_EDIT_TOOL::Rotate(), SCH_EDIT_TOOL::Rotate(), RunAction(), and EDA_DRAW_FRAME::UpdateMsgPanel().

◆ PrimeTool()

void TOOL_MANAGER::PrimeTool ( const VECTOR2D aPosition)

Function PrimeTool() "Primes" 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 event

Definition at line 339 of file tool_manager.cpp.

340 {
341  int modifiers = 0;
342  modifiers |= wxGetKeyState( WXK_SHIFT ) ? MD_SHIFT : 0;
343  modifiers |= wxGetKeyState( WXK_CONTROL ) ? MD_CTRL : 0;
344  modifiers |= wxGetKeyState( WXK_ALT ) ? MD_ALT : 0;
345 
346  TOOL_EVENT evt( TC_MOUSE, TA_PRIME, BUT_LEFT | modifiers );
347  evt.SetMousePosition( aPosition );
348 
349  PostEvent( evt );
350 }
TOOL_EVENT.
Definition: tool_event.h:171
void PostEvent(const TOOL_EVENT &aEvent)
Puts an event to the event queue to be processed at the end of event processing cycle.
Definition: tool_manager.h:268

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)

Propagates 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 927 of file tool_manager.cpp.

928 {
929  bool handled = processEvent( aEvent );
930 
931  TOOL_STATE* activeTool = GetCurrentToolState();
932 
933  if( activeTool )
934  setActiveState( activeTool );
935 
936  if( m_view && m_view->IsDirty() )
937  {
938  if( GetToolHolder() )
940 
941 #if defined( __WXMAC__ ) || defined( __WINDOWS__ )
942  wxTheApp->ProcessPendingEvents(); // required for updating brightening behind a popup menu
943 #endif
944  }
945 
946  UpdateUI( aEvent );
947 
948  return handled;
949 }
void UpdateUI(const TOOL_EVENT &aEvent)
Updates the status bar and synchronizes toolbars.
bool processEvent(const TOOL_EVENT &aEvent)
Main function for event processing.
virtual void RefreshCanvas()
Definition: tools_holder.h:119
void setActiveState(TOOL_STATE *aState)
Saves the previous active state and sets a new one.
TOOL_STATE * GetCurrentToolState() const
Returns the TOOL_STATE object representing the state of the active tool.
Definition: tool_manager.h:321
KIGFX::VIEW * m_view
Definition: tool_manager.h:540
TOOLS_HOLDER * GetToolHolder() const
Definition: tool_manager.h:295
bool IsDirty() const
Function IsDirty() Returns true if any of the VIEW layers needs to be refreshened.
Definition: view.h:557

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(), EE_SELECTION_TOOL::AddItemToSel(), SELECTION_TOOL::AddItemToSel(), EDIT_TOOL::ChangeTrackWidth(), PL_SELECTION_TOOL::ClearSelection(), GERBVIEW_SELECTION_TOOL::clearSelection(), SELECTION_TOOL::ClearSelection(), EE_SELECTION_TOOL::ClearSelection(), COMMON_TOOLS::CursorControl(), TOOL_DISPATCHER::DispatchWxCommand(), TOOL_DISPATCHER::DispatchWxEvent(), SELECTION_TOOL::expandConnection(), SELECTION_TOOL::filterSelection(), SELECTION_TOOL::findCallback(), EDIT_TOOL::Flip(), TOOL_DISPATCHER::handleMouseButton(), LIB_MOVE_TOOL::Main(), EDIT_TOOL::Mirror(), EDIT_TOOL::MoveExact(), ACTION_MENU::OnMenuEvent(), ACTION_TOOLBAR::onToolEvent(), PAD_TOOL::pastePadProperties(), PCBNEW_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(), 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(), SELECTION_TOOL::SelectItems(), PL_SELECTION_TOOL::selectMultiple(), EE_SELECTION_TOOL::selectMultiple(), SELECTION_TOOL::selectMultiple(), SELECTION_TOOL::selectNet(), PL_SELECTION_TOOL::SelectPoint(), GERBVIEW_SELECTION_TOOL::selectPoint(), EE_SELECTION_TOOL::SelectPoint(), SELECTION_TOOL::selectPoint(), SELECTION_TOOL::selectSameSheet(), SELECTION_TOOL::selectSheetContents(), SCH_EDITOR_CONTROL::Undo(), GERBVIEW_SELECTION_TOOL::UnselectItem(), GERBVIEW_SELECTION_TOOL::UnselectItems(), and 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 1082 of file tool_manager.cpp.

1083 {
1084  wxLogTrace( kicadTraceToolStack, "TOOL_MANAGER::processEvent - %s", aEvent.Format() );
1085 
1086  // First try to dispatch the action associated with the event if it is a key press event
1087  bool handled = DispatchHotKey( aEvent );
1088 
1089  if( !handled )
1090  {
1091  TOOL_EVENT mod_event( aEvent );
1092 
1093  // Only immediate actions get the position. Otherwise clear for tool activation
1094  if( GetToolHolder() && !GetToolHolder()->GetDoImmediateActions() )
1095  {
1096  // An tool-selection-event has no position
1097  if( mod_event.GetCommandStr().is_initialized()
1098  && mod_event.GetCommandStr().get() != GetToolHolder()->CurrentToolName() )
1099  {
1100  mod_event.SetHasPosition( false );
1101  }
1102  }
1103 
1104  // If the event is not handled through a hotkey activation, pass it to the currently
1105  // running tool loops
1106  handled |= dispatchInternal( mod_event );
1107  handled |= dispatchActivation( mod_event );
1108 
1109  // Open the context menu if requested by a tool
1110  DispatchContextMenu( mod_event );
1111 
1112  // Dispatch any remaining events in the event queue
1113  while( !m_eventQueue.empty() )
1114  {
1115  TOOL_EVENT event = m_eventQueue.front();
1116  m_eventQueue.pop_front();
1117  processEvent( event );
1118  }
1119  }
1120 
1121  wxLogTrace( kicadTraceToolStack, "TOOL_MANAGER::processEvent - Handled: %s %s",
1122  ( handled ? "true" : "false" ), aEvent.Format() );
1123 
1124  return handled;
1125 }
void DispatchContextMenu(const TOOL_EVENT &aEvent)
Function DispatchContextMenu() Handles context menu related events.
const std::string Format() const
Function Format() Returns information about event in form of a human-readable string.
Definition: tool_event.cpp:73
bool processEvent(const TOOL_EVENT &aEvent)
Main function for event processing.
bool dispatchActivation(const TOOL_EVENT &aEvent)
Function dispatchActivation() Checks if it is a valid activation event and invokes a proper tool.
bool DispatchHotKey(const TOOL_EVENT &aEvent)
Function dispatchHotKey() Handles specific events, that are intended for TOOL_MANAGER rather than too...
TOOL_EVENT.
Definition: tool_event.h:171
std::string CurrentToolName() const
TOOLS_HOLDER * GetToolHolder() const
Definition: tool_manager.h:295
std::list< TOOL_EVENT > m_eventQueue
Queue that stores events to be processed at the end of the event processing cycle.
Definition: tool_manager.h:546
const wxChar *const kicadTraceToolStack
Flag to enable tracing of the tool handling stack.
bool dispatchInternal(const TOOL_EVENT &aEvent)
Function dispatchInternal Passes an event at first to the active tools, then to all others.

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

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

◆ RegisterTool()

void TOOL_MANAGER::RegisterTool ( TOOL_BASE aTool)

Function RegisterTool() Adds 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 229 of file tool_manager.cpp.

230 {
231  wxASSERT_MSG( m_toolNameIndex.find( aTool->GetName() ) == m_toolNameIndex.end(),
232  wxT( "Adding two tools with the same name may result in unexpected behaviour.") );
233  wxASSERT_MSG( m_toolIdIndex.find( aTool->GetId() ) == m_toolIdIndex.end(),
234  wxT( "Adding two tools with the same ID may result in unexpected behaviour.") );
235  wxASSERT_MSG( m_toolTypes.find( typeid( *aTool ).name() ) == m_toolTypes.end(),
236  wxT( "Adding two tools of the same type may result in unexpected behaviour.") );
237 
238  TOOL_STATE* st = new TOOL_STATE( aTool );
239 
240  m_toolState[aTool] = st;
241  m_toolNameIndex[aTool->GetName()] = st;
242  m_toolIdIndex[aTool->GetId()] = st;
243  m_toolTypes[typeid( *aTool ).name()] = st->theTool;
244 
245  aTool->attachManager( this );
246 }
ID_STATE_MAP m_toolIdIndex
Index of the registered tools current states, associated by tools' ID numbers.
Definition: tool_manager.h:525
TOOL_ID GetId() const
Function GetId() Returns the unique identifier of the tool.
Definition: tool_base.h:121
void attachManager(TOOL_MANAGER *aManager)
Function attachManager()
Definition: tool_base.cpp:60
NAME_STATE_MAP m_toolNameIndex
Index of the registered tools current states, associated by tools' names.
Definition: tool_manager.h:522
const std::string & GetName() const
Function GetName() Returns the name of the tool.
Definition: tool_base.h:132
TOOL_STATE_MAP m_toolState
Index of registered tools current states, associated by tools' objects.
Definition: tool_manager.h:519
std::map< const char *, TOOL_BASE * > m_toolTypes
Index of the registered tools to easily lookup by their type.
Definition: tool_manager.h:528

References TOOL_BASE::attachManager(), TOOL_BASE::GetId(), TOOL_BASE::GetName(), m_toolIdIndex, m_toolNameIndex, m_toolState, and m_toolTypes.

Referenced by FOOTPRINT_VIEWER_FRAME::FOOTPRINT_VIEWER_FRAME(), PANEL_PREV_3D::PANEL_PREV_3D(), PL_EDITOR_FRAME::setupTools(), FOOTPRINT_EDIT_FRAME::setupTools(), LIB_VIEW_FRAME::setupTools(), GERBVIEW_FRAME::setupTools(), LIB_EDIT_FRAME::setupTools(), CVPCB_MAINFRAME::setupTools(), and SCH_EDIT_FRAME::setupTools().

◆ ResetTools()

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

Function ResetTools() Resets all tools (i.e.

calls their Reset() method).

Definition at line 526 of file tool_manager.cpp.

527 {
528  DeactivateTool();
529 
530  for( auto& state : m_toolState )
531  {
532  TOOL_BASE* tool = state.first;
533  setActiveState( state.second );
534  tool->Reset( aReason );
535 
536  if( tool->GetType() == INTERACTIVE )
537  static_cast<TOOL_INTERACTIVE*>( tool )->resetTransitions();
538  }
539 }
TOOL_TYPE GetType() const
Function GetType() Returns the type of the tool.
Definition: tool_base.h:110
void DeactivateTool()
Function DeactivateTool() Deactivates the currently active tool.
virtual void Reset(RESET_REASON aReason)=0
Function Reset() Brings the tool to a known, initial state.
Tool that interacts with the user
Definition: tool_base.h:49
void setActiveState(TOOL_STATE *aState)
Saves the previous active state and sets a new one.
TOOL_BASE.
Definition: tool_base.h:67
TOOL_STATE_MAP m_toolState
Index of registered tools current states, associated by tools' objects.
Definition: tool_manager.h:519

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

Referenced by PCB_BASE_FRAME::ActivateGalCanvas(), GERBVIEW_FRAME::ActivateGalCanvas(), GERBVIEW_FRAME::Clear_DrawLayers(), FOOTPRINT_VIEWER_FRAME::ClickOnFootprintList(), GERBVIEW_FRAME::Erase_Current_DrawLayer(), InitTools(), LIB_CONTROL::OnDeMorgan(), LIB_EDIT_FRAME::OnSelectUnit(), FOOTPRINT_WIZARD_FRAME::ReloadFootprint(), PCB_BASE_EDIT_FRAME::SetBoard(), LIB_EDIT_FRAME::SetCurPart(), DIALOG_GRID_SETTINGS::TransferDataFromWindow(), PANEL_SETUP_NETCLASSES::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

Function RunAction() Runs 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 140 of file tool_manager.h.

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

Referenced by DIALOG_GLOBAL_DELETION::AcceptPcbDelete(), TREEPROJECT_ITEM::Activate(), FOOTPRINT_VIEWER_FRAME::AddFootprintToPCB(), LIB_CONTROL::AddSymbolToSchematic(), SCH_EDIT_FRAME::AppendSchematic(), CVPCB_ASSOCIATION_TOOL::Associate(), SCH_EDIT_TOOL::AutoplaceFields(), ROUTER_TOOL::CanInlineDrag(), SCH_EDIT_TOOL::ChangeTextType(), EDIT_TOOL::ChangeTrackWidth(), SCH_EDIT_TOOL::CleanupSheetPins(), SELECTION_TOOL::ClearSelection(), ZONE_CREATE_HELPER::commitZone(), SCH_EDIT_TOOL::ConvertDeMorgan(), SCH_EDIT_FRAME::ConvertPart(), MICROWAVE_TOOL::createInductorBetween(), LIB_EDIT_FRAME::CreateNewPart(), COMMON_TOOLS::CursorControl(), ROUTER_TOOL::CustomTrackWidthDialog(), SCH_EDITOR_CONTROL::Cut(), LIB_VIEW_FRAME::DClickOnCmpList(), DIALOG_ERC::deleteAllMarkers(), DIALOG_DRC::deleteAllMarkers(), LIB_EDIT_TOOL::DeleteItemCursor(), PL_EDIT_TOOL::DeleteItemCursor(), SCH_EDIT_TOOL::DeleteItemCursor(), PCBNEW_CONTROL::DeleteItemCursor(), DIALOG_MIGRATE_BUSES::DIALOG_MIGRATE_BUSES(), SCH_EDIT_FRAME::DisplayCurrentSheet(), DIALOG_CLEANUP_TRACKS_AND_VIAS::doCleanup(), DIALOG_CLEANUP_GRAPHICS::doCleanup(), LIB_EDIT_TOOL::DoDelete(), SCH_EDIT_TOOL::DoDelete(), SCH_LINE_WIRE_BUS_TOOL::doDrawSegments(), PCB_TOOL_BASE::doInteractiveItemPlacement(), SCH_LINE_WIRE_BUS_TOOL::doUnfoldBus(), DRAWING_TOOL::DrawArc(), DRAWING_TOOL::drawArc(), DRAWING_TOOL::DrawCircle(), DRAWING_TOOL::DrawDimension(), DRAWING_TOOL::DrawRectangle(), DRAWING_TOOL::drawSegment(), LIB_DRAWING_TOOLS::DrawShape(), PL_DRAWING_TOOLS::DrawShape(), SCH_DRAWING_TOOLS::DrawSheet(), PCB_EDITOR_CONTROL::DrillOrigin(), LIB_EDIT_TOOL::Duplicate(), SCH_EDIT_TOOL::Duplicate(), EDIT_TOOL::Duplicate(), SCH_EDIT_TOOL::EditField(), PCB_EDITOR_CONTROL::EditFpInFpEditor(), PAD_TOOL::EditPad(), LIB_EDIT_TOOL::editSymbolProperties(), SCH_EDITOR_CONTROL::EditWithLibEdit(), LIB_EDIT_FRAME::emptyScreen(), 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(), POINT_EDITOR::finishItem(), SCH_LINE_WIRE_BUS_TOOL::finishSegments(), EDIT_TOOL::Flip(), GERBVIEW_FRAME::GERBVIEW_FRAME(), EDIT_TOOL::GetAndPlace(), LIB_EDIT_FRAME::GetComponentFromRedoList(), LIB_EDIT_FRAME::GetComponentFromUndoList(), DRAWING_TOOL::getSourceZoneForAction(), PCBNEW_CONTROL::GridSetOrigin(), PCB_INSPECTION_TOOL::HighlightItem(), SCH_EDITOR_CONTROL::HighlightNetCursor(), PCB_INSPECTION_TOOL::HighlightNetTool(), SCH_EDIT_FRAME::importFile(), FOOTPRINT_EDITOR_TOOLS::ImportFootprint(), PL_EDIT_TOOL::ImportWorksheetContent(), ROUTER_TOOL::InlineBreakTrack(), ROUTER_TOOL::InlineDrag(), EDIT_TOOL::invokeInlineRouter(), SCH_EDIT_FRAME::KiwayMailIn(), PCB_EDIT_FRAME::KiwayMailIn(), SCH_EDITOR_CONTROL::LeaveSheet(), LIB_VIEW_FRAME::LIB_VIEW_FRAME(), LIB_EDIT_FRAME::LoadComponentFromCurrentLib(), LIB_EDIT_FRAME::LoadOneLibraryPartAux(), PCB_INSPECTION_TOOL::LocalRatsnestTool(), PL_EDIT_TOOL::Main(), CVPCB_CONTROL::Main(), LIB_MOVE_TOOL::Main(), SCH_MOVE_TOOL::Main(), EE_SELECTION_TOOL::Main(), SELECTION_TOOL::Main(), ROUTER_TOOL::MainLoop(), LENGTH_TUNER_TOOL::MainLoop(), LIB_EDIT_TOOL::Mirror(), SCH_EDIT_TOOL::Mirror(), EDIT_TOOL::Mirror(), PCB_EDITOR_CONTROL::modifyLockSelected(), EDIT_TOOL::Move(), EDIT_TOOL::MoveExact(), SIM_PLOT_FRAME::onClose(), SYMBOL_TREE_PANE::onComponentSelected(), DIALOG_DRC::OnDeleteOneClick(), LIB_CONTROL::OnDeMorgan(), DIALOG_ERC::OnERCItemSelected(), ZONE_CREATE_HELPER::OnFirstPoint(), FOOTPRINTS_LISTBOX::OnLeftDClick(), ACTION_MENU::OnMenuEvent(), PL_EDITOR_FRAME::OnNewPageLayout(), KICAD_MANAGER_FRAME::OnOpenFileInTextEditor(), SIM_PLOT_FRAME::onProbe(), EDA_DRAW_FRAME::OnSelectGrid(), DIALOG_POSITION_RELATIVE::OnSelectItemClick(), HIERARCHY_NAVIG_DLG::onSelectSheetPath(), LIB_EDIT_FRAME::OnSelectUnit(), EDA_DRAW_FRAME::OnSelectZoom(), SIM_PLOT_FRAME::onTune(), SCH_EDIT_FRAME::OpenProjectFiles(), LIB_EDIT_TOOL::Paste(), PL_EDIT_TOOL::Paste(), SCH_EDITOR_CONTROL::Paste(), ZONE_CREATE_HELPER::performZoneCutout(), EDIT_TOOL::pickCopyReferencePoint(), LIB_EDIT_TOOL::PinTable(), PCBNEW_CONTROL::placeBoardItems(), SCH_DRAWING_TOOLS::PlaceComponent(), SCH_DRAWING_TOOLS::PlaceImage(), DRAWING_TOOL::PlaceImportedGraphics(), PL_DRAWING_TOOLS::PlaceItem(), PCB_EDITOR_CONTROL::PlaceModule(), PCB_EDITOR_CONTROL::PlaceTarget(), DRAWING_TOOL::PlaceText(), PCBNEW_CONTROL::Print(), GERBVIEW_CONTROL::Print(), SCH_EDIT_TOOL::Properties(), EDIT_TOOL::Properties(), SCH_EDIT_FRAME::PutDataInPreviousState(), CVPCB_MAINFRAME::refreshAfterComponentSearch(), POSITION_RELATIVE_TOOL::RelativeItemSelectionMove(), EDIT_TOOL::Remove(), POINT_EDITOR::removeCorner(), SCH_EDIT_TOOL::RepeatDrawItem(), LIB_DRAWING_TOOLS::RepeatDrawItem(), SELECTION_TOOL::RequestSelection(), PL_EDITOR_FRAME::RollbackFromUndo(), LIB_EDIT_FRAME::RollbackPartFromUndo(), LIB_EDIT_TOOL::Rotate(), SCH_EDIT_TOOL::Rotate(), EDIT_TOOL::Rotate(), RunAction(), ACTION_MANAGER::RunHotKey(), FOOTPRINT_EDIT_FRAME::SaveFootprintToBoard(), LIB_EDIT_FRAME::saveLibrary(), DIALOG_FIND::search(), PL_SELECTION_TOOL::SelectPoint(), EE_SELECTION_TOOL::SelectPoint(), POSITION_RELATIVE_TOOL::SelectPositionRelativeItem(), GERBVIEW_FRAME::SetActiveLayer(), DRAWING_TOOL::SetAnchor(), LIB_EDIT_FRAME::SetCurPart(), LIB_VIEW_FRAME::SetSelectedComponent(), CVPCB_MAINFRAME::setupEventHandlers(), SCH_EDIT_FRAME::setupTools(), DRC::ShowDRCDialog(), SCH_DRAWING_TOOLS::SingleClickPlace(), PCB_EDITOR_CONTROL::TrackWidthDec(), PCB_EDITOR_CONTROL::TrackWidthInc(), DIALOG_GRID_SETTINGS::TransferDataFromWindow(), LIB_DRAWING_TOOLS::TwoClickPlace(), SCH_DRAWING_TOOLS::TwoClickPlace(), PCB_BASE_FRAME::unitsChangeRefresh(), DISPLAY_FOOTPRINTS_FRAME::updateView(), FOOTPRINT_WIZARD_FRAME::updateView(), FOOTPRINT_VIEWER_FRAME::updateView(), FOOTPRINT_EDIT_FRAME::updateView(), PCB_EDITOR_CONTROL::ViaSizeDec(), PCB_EDITOR_CONTROL::ViaSizeInc(), PCB_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 277 of file tool_manager.cpp.

278 {
279  TOOL_ACTION* action = m_actionMgr->FindAction( aActionName );
280 
281  if( !action )
282  {
283  wxASSERT_MSG( false, wxString::Format( wxT( "Could not find action %s." ), aActionName ) );
284  return false;
285  }
286 
287  RunAction( *action, aNow, aParam );
288 
289  return false;
290 }
ACTION_MANAGER * m_actionMgr
Instance of ACTION_MANAGER that handles TOOL_ACTIONs.
Definition: tool_manager.h:534
bool RunAction(const std::string &aActionName, bool aNow=false, T aParam=NULL)
Function RunAction() Runs the specified action.
Definition: tool_manager.h:140
TOOL_ACTION * FindAction(const std::string &aActionName) const
Function FindAction() Finds an action with a given name (if there is one available).
void Format(OUTPUTFORMATTER *out, int aNestLevel, int aCtl, CPTREE &aTree)
Function Format outputs a PTREE into s-expression format via an OUTPUTFORMATTER derivative.
Definition: ptree.cpp:205
TOOL_ACTION.
Definition: tool_action.h:46

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 147 of file tool_manager.h.

148  {
149  return RunAction( aActionName, aNow, (void*) NULL );
150  }
bool RunAction(const std::string &aActionName, bool aNow=false, T aParam=NULL)
Function RunAction() Runs the specified action.
Definition: tool_manager.h:140
#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

Function RunAction() Runs 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 168 of file tool_manager.h.

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

References RunAction().

◆ RunAction() [5/6]

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

Definition at line 311 of file tool_manager.cpp.

312 {
313  bool handled = false;
314  TOOL_EVENT event = aAction.MakeEvent();
315 
316  if( event.Category() == TC_COMMAND )
318 
319  // Allow to override the action parameter
320  if( aParam )
321  event.SetParameter( aParam );
322 
323  if( aNow )
324  {
325  TOOL_STATE* current = m_activeState;
326  handled = processEvent( event );
327  setActiveState( current );
328  UpdateUI( event );
329  }
330  else
331  {
332  PostEvent( event );
333  }
334 
335  return handled;
336 }
VECTOR2D GetCursorPosition()
void UpdateUI(const TOOL_EVENT &aEvent)
Updates 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:468
void setActiveState(TOOL_STATE *aState)
Saves the previous active state and sets a new one.
TOOL_EVENT.
Definition: tool_event.h:171
TOOL_STATE * m_activeState
Pointer to the state object corresponding to the currently executed tool.
Definition: tool_manager.h:560
TOOL_EVENT MakeEvent() const
Function MakeEvent() Returns the event associated with the action (i.e.
Definition: tool_action.h:107
void PostEvent(const TOOL_EVENT &aEvent)
Puts an event to the event queue to be processed at the end of event processing cycle.
Definition: tool_manager.h:268

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 175 of file tool_manager.h.

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

References NULL, and RunAction().

◆ RunMainStack()

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

Definition at line 605 of file tool_manager.cpp.

606 {
607  TOOL_STATE* st = m_toolState[aTool];
608  setActiveState( st );
609  st->cofunc->RunMainStack( std::move( aFunc ) );
610 }
void setActiveState(TOOL_STATE *aState)
Saves the previous active state and sets a new one.
TOOL_STATE_MAP m_toolState
Index of registered tools current states, associated by tools' objects.
Definition: tool_manager.h:519

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

Function runTool() Makes a tool active, so it can receive events and react to them.

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 380 of file tool_manager.cpp.

381 {
382  wxASSERT( aTool != NULL );
383 
384  if( !isRegistered( aTool ) )
385  {
386  wxASSERT_MSG( false, wxT( "You cannot run unregistered tools" ) );
387  return false;
388  }
389 
390  TOOL_ID id = aTool->GetId();
391 
392  if( aTool->GetType() == INTERACTIVE )
393  static_cast<TOOL_INTERACTIVE*>( aTool )->resetTransitions();
394 
395  // If the tool is already active, bring it to the top of the active tools stack
396  if( isActive( aTool ) && m_activeTools.size() > 1 )
397  {
398  auto it = std::find( m_activeTools.begin(), m_activeTools.end(), id );
399 
400  if( it != m_activeTools.end() )
401  {
402  if( it != m_activeTools.begin() )
403  {
404  m_activeTools.erase( it );
405  m_activeTools.push_front( id );
406  }
407 
408  return false;
409  }
410  }
411 
413  aTool->Reset( TOOL_INTERACTIVE::RUN );
414 
415  // Add the tool on the front of the processing queue (it gets events first)
416  m_activeTools.push_front( id );
417 
418  return true;
419 }
TOOL_TYPE GetType() const
Function GetType() Returns the type of the tool.
Definition: tool_base.h:110
ID_STATE_MAP m_toolIdIndex
Index of the registered tools current states, associated by tools' ID numbers.
Definition: tool_manager.h:525
TOOL_ID GetId() const
Function GetId() Returns the unique identifier of the tool.
Definition: tool_base.h:121
Tool is invoked after being inactive.
Definition: tool_base.h:81
virtual void Reset(RESET_REASON aReason)=0
Function Reset() Brings the tool to a known, initial state.
int TOOL_ID
Unique identifier for tools.
Definition: tool_base.h:56
Tool that interacts with the user
Definition: tool_base.h:49
#define NULL
void setActiveState(TOOL_STATE *aState)
Saves the previous active state and sets a new one.
bool isActive(TOOL_BASE *aTool)
Function isActive() Returns information about a tool activation status.
bool isRegistered(TOOL_BASE *aTool) const
Function isRegistered() Returns information about a tool registration status.
Definition: tool_manager.h:478
ID_LIST m_activeTools
Stack of the active tools.
Definition: tool_manager.h:531

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 &  aText)

Stores an information to the system clipboard.

Parameters
aTextis the information to be stored.
Returns
False if error occurred.

Definition at line 962 of file tool_manager.cpp.

963 {
964  if( wxTheClipboard->Open() )
965  {
966  wxTheClipboard->SetData( new wxTextDataObject( wxString( aText.c_str(), wxConvUTF8 ) ) );
967  wxTheClipboard->Close();
968 
969  return true;
970  }
971 
972  return false;
973 }

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

◆ saveViewControls()

void TOOL_MANAGER::saveViewControls ( TOOL_STATE aState)
private

Function saveViewControls() Saves 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 1036 of file tool_manager.cpp.

1037 {
1038  aState->vcSettings = m_viewControls->GetSettings();
1039 
1040  if( m_menuActive )
1041  {
1042  // Context menu is active, so the cursor settings are overridden (see DispatchContextMenu())
1043  auto it = m_cursorSettings.find( aState->theTool->GetId() );
1044 
1045  if( it != m_cursorSettings.end() )
1046  {
1048 
1049  // Tool has overridden the cursor position, so store the new settings
1050  if( !curr.m_forceCursorPosition || curr.m_forcedPosition != m_menuCursor )
1051  {
1052  if( !curr.m_forceCursorPosition )
1053  it->second = NULLOPT;
1054  else
1055  it->second = curr.m_forcedPosition;
1056  }
1057  else
1058  {
1059  OPT<VECTOR2D> cursor = it->second;
1060 
1061  if( cursor )
1062  {
1063  aState->vcSettings.m_forceCursorPosition = true;
1064  aState->vcSettings.m_forcedPosition = *cursor;
1065  }
1066  else
1067  {
1068  aState->vcSettings.m_forceCursorPosition = false;
1069  }
1070  }
1071  }
1072  }
1073 }
bool m_menuActive
Flag indicating whether a context menu is currently displayed.
Definition: tool_manager.h:554
VECTOR2D m_menuCursor
Right click context menu position.
Definition: tool_manager.h:549
std::map< TOOL_ID, OPT< VECTOR2D > > m_cursorSettings
Original cursor position, if overridden by the context menu handler.
Definition: tool_manager.h:537
VECTOR2D m_forcedPosition
Forced cursor position (world coordinates)
Definition: view_controls.h:69
const VC_SETTINGS & GetSettings() const
Returns the current VIEW_CONTROLS settings
const auto NULLOPT
Definition: optional.h:9
bool m_forceCursorPosition
Is the forced cursor position enabled
Definition: view_controls.h:72
Structure to keep VIEW_CONTROLS settings for easy store/restore operations
Definition: view_controls.h:55
KIGFX::VIEW_CONTROLS * m_viewControls
Definition: tool_manager.h:541
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 
)

Sets behaviour of the tool's context popup menu.

Parameters
aTool- the parent tool
aMenu- the menu structure, defined by the tool
aTrigger- 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 952 of file tool_manager.cpp.

954 {
955  TOOL_STATE* st = m_toolState[aTool];
956 
957  st->contextMenu = aMenu;
958  st->contextMenuTrigger = aTrigger;
959 }
TOOL_STATE_MAP m_toolState
Index of registered tools current states, associated by tools' objects.
Definition: tool_manager.h:519

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 
)

Defines 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 590 of file tool_manager.cpp.

592 {
593  TOOL_STATE* st = m_toolState[aTool];
594 
595  st->transitions.emplace_back( TRANSITION( aConditions, aHandler ) );
596 }
TOOL_STATE_MAP m_toolState
Index of registered tools current states, associated by tools' objects.
Definition: tool_manager.h:519
std::pair< TOOL_EVENT_LIST, TOOL_STATE_FUNC > TRANSITION
Definition: tool_manager.h:428

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 
)

Pauses 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 613 of file tool_manager.cpp.

614 {
615  TOOL_STATE* st = m_toolState[aTool];
616 
617  wxASSERT( !st->pendingWait ); // everything collapses on two KiYield() in a row
618 
619  // indicate to the manager that we are going to sleep and we shall be
620  // woken up when an event matching aConditions arrive
621  st->pendingWait = true;
622  st->waitEvents = aConditions;
623 
624  // switch context back to event dispatcher loop
625  st->cofunc->KiYield();
626 
627  // If the tool should shutdown, it gets a null event to break the loop
628  if( st->shutdown )
629  return nullptr;
630  else
631  return &st->wakeupEvent;
632 }
TOOL_STATE_MAP m_toolState
Index of registered tools current states, associated by tools' objects.
Definition: tool_manager.h:519

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

Saves 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.

Definition at line 1128 of file tool_manager.cpp.

1129 {
1130  if( m_activeState && m_viewControls )
1132 
1133  m_activeState = aState;
1134 
1135  if( m_activeState && m_viewControls )
1136  applyViewControls( aState );
1137 }
void applyViewControls(TOOL_STATE *aState)
Function applyViewControls() Applies VIEW_CONTROLS settings stored in a TOOL_STATE object.
KIGFX::VIEW_CONTROLS * m_viewControls
Definition: tool_manager.h:541
TOOL_STATE * m_activeState
Pointer to the state object corresponding to the currently executed tool.
Definition: tool_manager.h:560
void saveViewControls(TOOL_STATE *aState)
Function saveViewControls() Saves 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 
)

Sets 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 1014 of file tool_manager.cpp.

1017 {
1018  m_model = aModel;
1019  m_view = aView;
1020  m_viewControls = aViewControls;
1021  m_frame = aFrame;
1022  m_settings = aSettings;
1023 }
TOOLS_HOLDER * m_frame
Definition: tool_manager.h:542
EDA_ITEM * m_model
Definition: tool_manager.h:539
KIGFX::VIEW_CONTROLS * m_viewControls
Definition: tool_manager.h:541
KIGFX::VIEW * m_view
Definition: tool_manager.h:540
APP_SETTINGS_BASE * m_settings
Definition: tool_manager.h:543

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

Referenced by PCB_BASE_FRAME::ActivateGalCanvas(), GERBVIEW_FRAME::ActivateGalCanvas(), DISPLAY_FOOTPRINTS_FRAME::DISPLAY_FOOTPRINTS_FRAME(), EDA_3D_VIEWER::EDA_3D_VIEWER(), EVT_GRID_CMD_CELL_CHANGED(), EVT_MENU_RANGE(), FOOTPRINT_VIEWER_FRAME::FOOTPRINT_VIEWER_FRAME(), PANEL_PREV_3D::PANEL_PREV_3D(), PCB_BASE_EDIT_FRAME::SetBoard(), PL_EDITOR_FRAME::setupTools(), PCB_EDIT_FRAME::setupTools(), FOOTPRINT_EDIT_FRAME::setupTools(), LIB_VIEW_FRAME::setupTools(), GERBVIEW_FRAME::setupTools(), LIB_EDIT_FRAME::setupTools(), CVPCB_MAINFRAME::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 422 of file tool_manager.cpp.

423 {
424  // Create a temporary list of tools to iterate over since when the tools shutdown
425  // they remove themselves from the list automatically (invalidating the iterator)
426  ID_LIST tmpList = m_activeTools;
427 
428  for( auto id : tmpList )
429  {
430  ShutdownTool( id );
431  }
432 }
void ShutdownTool(TOOL_BASE *aTool)
Shutdown the specified tool by waking it up with a null event to terminate the processing loop.
ID_LIST m_activeTools
Stack of the active tools.
Definition: tool_manager.h:531
std::list< TOOL_ID > ID_LIST
Definition: tool_manager.h:65

References m_activeTools, and ShutdownTool().

Referenced by SCH_EDIT_FRAME::OnCloseWindow(), 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(), LIB_EDIT_FRAME::~LIB_EDIT_FRAME(), LIB_VIEW_FRAME::~LIB_VIEW_FRAME(), PL_EDITOR_FRAME::~PL_EDITOR_FRAME(), and SCH_EDIT_FRAME::~SCH_EDIT_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 459 of file tool_manager.cpp.

460 {
461  wxASSERT( aTool != NULL );
462 
463  TOOL_ID id = aTool->GetId();
464 
465  if( isActive( aTool ) )
466  {
467  auto it = std::find( m_activeTools.begin(), m_activeTools.end(), id );
468 
469  TOOL_STATE* st = m_toolIdIndex[*it];
470 
471  // the tool state handler is waiting for events (i.e. called Wait() method)
472  if( st && st->pendingWait )
473  {
474  // Wake up the tool and tell it to shutdown
475  st->shutdown = true;
476  st->pendingWait = false;
477  st->waitEvents.clear();
478 
479  if( st->cofunc )
480  {
481  wxLogTrace( kicadTraceToolStack,
482  "TOOL_MANAGER::ShutdownTool - Shutting down tool %s",
483  st->theTool->GetName() );
484 
485  setActiveState( st );
486  bool end = !st->cofunc->Resume();
487 
488  if( end )
489  finishTool( st );
490  }
491  }
492  }
493 }
ID_STATE_MAP m_toolIdIndex
Index of the registered tools current states, associated by tools' ID numbers.
Definition: tool_manager.h:525
TOOL_ID GetId() const
Function GetId() Returns the unique identifier of the tool.
Definition: tool_base.h:121
ID_LIST::iterator finishTool(TOOL_STATE *aState)
Function finishTool() Deactivates a tool and does the necessary clean up.
int TOOL_ID
Unique identifier for tools.
Definition: tool_base.h:56
#define NULL
void setActiveState(TOOL_STATE *aState)
Saves the previous active state and sets a new one.
bool isActive(TOOL_BASE *aTool)
Function isActive() Returns information about a tool activation status.
const wxChar *const kicadTraceToolStack
Flag to enable tracing of the tool handling stack.
ID_LIST m_activeTools
Stack of the active tools.
Definition: tool_manager.h:531

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 435 of file tool_manager.cpp.

436 {
437  TOOL_BASE* tool = FindTool( aToolId );
438 
439  if( tool && tool->GetType() == INTERACTIVE )
440  ShutdownTool( tool );
441 
442  wxLogTrace( kicadTraceToolStack,
443  "TOOL_MANAGER::ShutdownTool - No interactive tool with ID %d", aToolId );
444 }
TOOL_TYPE GetType() const
Function GetType() Returns the type of the tool.
Definition: tool_base.h:110
TOOL_BASE * FindTool(int aId) const
Function FindTool() Searches 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:49
TOOL_BASE.
Definition: tool_base.h:67
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 447 of file tool_manager.cpp.

448 {
449  TOOL_BASE* tool = FindTool( aToolName );
450 
451  if( tool && tool->GetType() == INTERACTIVE )
452  ShutdownTool( tool );
453 
454  wxLogTrace( kicadTraceToolStack,
455  "TOOL_MANAGER::ShutdownTool - No interactive tool with name %s", aToolName );
456 }
TOOL_TYPE GetType() const
Function GetType() Returns the type of the tool.
Definition: tool_base.h:110
TOOL_BASE * FindTool(int aId) const
Function FindTool() Searches 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:49
TOOL_BASE.
Definition: tool_base.h:67
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)

Updates the status bar and synchronizes toolbars.

Definition at line 1147 of file tool_manager.cpp.

1148 {
1149  EDA_BASE_FRAME* frame = dynamic_cast<EDA_BASE_FRAME*>( GetToolHolder() );
1150 
1151  if( frame )
1152  {
1153  frame->UpdateStatusBar();
1154 
1155  if( !aEvent.IsMotion() && !aEvent.IsDrag() )
1156  frame->SyncToolbars();
1157  }
1158 }
bool IsMotion() const
Definition: tool_event.h:306
virtual void SyncToolbars()
Update the toolbars (mostly settings/check buttons/checkboxes) with the current controller state.
virtual void UpdateStatusBar()
Update the status bar information.
bool IsDrag(int aButtonMask=BUT_ANY) const
Definition: tool_event.h:296
TOOLS_HOLDER * GetToolHolder() const
Definition: tool_manager.h:295
The base frame for deriving all KiCad main window classes.

References GetToolHolder(), TOOL_EVENT::IsDrag(), TOOL_EVENT::IsMotion(), EDA_BASE_FRAME::SyncToolbars(), and EDA_BASE_FRAME::UpdateStatusBar().

Referenced by ProcessEvent(), and RunAction().

◆ VetoContextMenuMouseWarp()

void TOOL_MANAGER::VetoContextMenuMouseWarp ( )
inline

Disables mouse warping after the current context menu is closed.

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 408 of file tool_manager.h.

409  {
411  }
bool m_warpMouseAfterContextMenu
Definition: tool_manager.h:551

References m_warpMouseAfterContextMenu.

Referenced by DIALOG_SHIM::DIALOG_SHIM(), SCH_LINE_WIRE_BUS_TOOL::doDrawSegments(), LIB_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(), LIB_DRAWING_TOOLS::TwoClickPlace(), and SCH_DRAWING_TOOLS::TwoClickPlace().

Member Data Documentation

◆ m_actionMgr

ACTION_MANAGER* TOOL_MANAGER::m_actionMgr
private

Instance of ACTION_MANAGER that handles TOOL_ACTIONs.

Definition at line 534 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

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

Definition at line 560 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

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

Definition at line 537 of file tool_manager.h.

Referenced by DispatchContextMenu(), and saveViewControls().

◆ m_eventQueue

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

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

Definition at line 546 of file tool_manager.h.

Referenced by PostEvent(), and processEvent().

◆ m_frame

TOOLS_HOLDER* TOOL_MANAGER::m_frame
private

Definition at line 542 of file tool_manager.h.

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

◆ m_menuActive

bool TOOL_MANAGER::m_menuActive
private

Flag indicating whether a context menu is currently displayed.

Definition at line 554 of file tool_manager.h.

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

◆ m_menuCursor

VECTOR2D TOOL_MANAGER::m_menuCursor
private

Right click context menu position.

Definition at line 549 of file tool_manager.h.

Referenced by DispatchContextMenu(), and saveViewControls().

◆ m_menuOwner

TOOL_ID TOOL_MANAGER::m_menuOwner
private

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

Definition at line 557 of file tool_manager.h.

Referenced by DispatchContextMenu(), and dispatchInternal().

◆ m_model

EDA_ITEM* TOOL_MANAGER::m_model
private

Definition at line 539 of file tool_manager.h.

Referenced by GetModel(), and SetEnvironment().

◆ m_settings

APP_SETTINGS_BASE* TOOL_MANAGER::m_settings
private

Definition at line 543 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 current states, associated by tools' ID numbers.

Definition at line 525 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' names.

Definition at line 522 of file tool_manager.h.

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

◆ m_toolState

TOOL_STATE_MAP TOOL_MANAGER::m_toolState
private

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

Definition at line 519 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

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

Definition at line 528 of file tool_manager.h.

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

◆ m_view

KIGFX::VIEW* TOOL_MANAGER::m_view
private

Definition at line 540 of file tool_manager.h.

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

◆ m_viewControls

◆ m_warpMouseAfterContextMenu

bool TOOL_MANAGER::m_warpMouseAfterContextMenu
private

Definition at line 551 of file tool_manager.h.

Referenced by DispatchContextMenu(), and VetoContextMenuMouseWarp().


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