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, EDA_BASE_FRAME *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
 
EDA_BASE_FRAMEGetEditFrame () 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...
 

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 dispatchHotKey (const TOOL_EVENT &aEvent)
 Function dispatchStandardEvents() Handles specific events, that are intended for TOOL_MANAGER rather than tools. 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_ID aToolId)
 Function runTool() Makes a tool active, so it can receive events and react to them. More...
 
bool runTool (const std::string &aName)
 Function runTool() Makes a tool active, so it can receive events and react to them. More...
 
bool runTool (TOOL_BASE *aTool)
 Function runTool() Makes a tool active, so it can receive events and react to them. More...
 
template<class Parameters >
void invokeTool (const std::string &aName, const Parameters &aToolParams)
 
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
 
EDA_BASE_FRAMEm_frame
 
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 50 of file tool_manager.h.

Member Typedef Documentation

◆ ID_LIST

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

Definition at line 64 of file tool_manager.h.

◆ ID_STATE_MAP

Definition at line 63 of file tool_manager.h.

◆ NAME_STATE_MAP

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

Definition at line 62 of file tool_manager.h.

◆ TOOL_STATE_MAP

Definition at line 61 of file tool_manager.h.

◆ TRANSITION

Definition at line 426 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:578
ACTION_MANAGER * m_actionMgr
Instance of ACTION_MANAGER that handles TOOL_ACTIONs.
Definition: tool_manager.h:559
ACTION_MANAGER.
EDA_BASE_FRAME * m_frame
Definition: tool_manager.h:567
EDA_ITEM * m_model
Definition: tool_manager.h:564
TOOL_ID m_menuOwner
Tool currently displaying a popup menu. It is negative when there is no menu displayed.
Definition: tool_manager.h:581
#define NULL
KIGFX::VIEW_CONTROLS * m_viewControls
Definition: tool_manager.h:566
KIGFX::VIEW * m_view
Definition: tool_manager.h:565
bool m_warpMouseAfterContextMenu
Definition: tool_manager.h:575
TOOL_STATE * m_activeState
Pointer to the state object corresponding to the currently executed tool.
Definition: tool_manager.h:584

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:559
TOOL_STATE_MAP m_toolState
Index of registered tools current states, associated by tools' objects.
Definition: tool_manager.h:544

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

1080 {
1081  m_viewControls->ApplySettings( aState->vcSettings );
1082 }
void ApplySettings(const VC_SETTINGS &aSettings)
Applies VIEW_CONTROLS settings from an object
KIGFX::VIEW_CONTROLS * m_viewControls
Definition: tool_manager.h:566

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

610 {
611  m_toolState[aTool]->transitions.clear();
612 }
TOOL_STATE_MAP m_toolState
Index of registered tools current states, associated by tools' objects.
Definition: tool_manager.h:544

References m_toolState.

Referenced by TOOL_INTERACTIVE::resetTransitions().

◆ DeactivateTool()

void TOOL_MANAGER::DeactivateTool ( )

Function DeactivateTool() Deactivates the currently active tool.

Definition at line 528 of file tool_manager.cpp.

529 {
530  // Deactivate the active tool, but do not run anything new
532  processEvent( evt );
533 }
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(), 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 777 of file tool_manager.cpp.

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

801 {
802  for( TOOL_ID toolId : m_activeTools )
803  {
804  TOOL_STATE* st = m_toolIdIndex[toolId];
805 
806  // the tool requested a context menu. The menu is activated on RMB click (CMENU_BUTTON mode)
807  // or immediately (CMENU_NOW) mode. The latter is used for clarification lists.
808  if( st->contextMenuTrigger == CMENU_OFF )
809  continue;
810 
811  if( st->contextMenuTrigger == CMENU_BUTTON && !aEvent.IsClick( BUT_RIGHT ) )
812  break;
813 
814  st->pendingWait = true;
815  st->waitEvents = TOOL_EVENT( TC_ANY, TA_ANY );
816 
817  // Store the menu pointer in case it is changed by the TOOL when handling menu events
818  ACTION_MENU* m = st->contextMenu;
819 
820  if( st->contextMenuTrigger == CMENU_NOW )
821  st->contextMenuTrigger = CMENU_OFF;
822 
823  // Store the cursor position, so the tools could execute actions
824  // using the point where the user has invoked a context menu
825  if( m_viewControls )
827 
828  // Save all tools cursor settings, as they will be overridden
829  for( auto idState : m_toolIdIndex )
830  {
831  TOOL_STATE* s = idState.second;
832  const auto& vc = s->vcSettings;
833 
834  if( vc.m_forceCursorPosition )
835  m_cursorSettings[idState.first] = vc.m_forcedPosition;
836  else
837  m_cursorSettings[idState.first] = NULLOPT;
838  }
839 
840  if( m_viewControls )
842 
843  // Display a copy of menu
844  std::unique_ptr<ACTION_MENU> menu( m->Clone() );
845 
846  m_menuOwner = toolId;
847  m_menuActive = true;
848 
849  if( auto frame = dynamic_cast<wxFrame*>( m_frame ) )
850  frame->PopupMenu( menu.get() );
851 
852  // Warp the cursor if a menu item was selected
853  if( menu->GetSelected() >= 0 )
854  {
856  m_viewControls->WarpCursor( m_menuCursor, true, false );
857  }
858  // Otherwise notify the tool of a cancelled menu
859  else
860  {
862  evt.SetHasPosition( false );
863  evt.SetParameter( m );
864  dispatchInternal( evt );
865  }
866 
867  // Restore setting in case it was vetoed
869 
870  // Notify the tools that menu has been closed
872  evt.SetHasPosition( false );
873  evt.SetParameter( m );
874  dispatchInternal( evt );
875 
876  m_menuActive = false;
877  m_menuOwner = -1;
878 
879  // Restore cursor settings
880  for( auto cursorSetting : m_cursorSettings )
881  {
882  auto it = m_toolIdIndex.find( cursorSetting.first );
883  wxASSERT( it != m_toolIdIndex.end() );
884 
885  if( it == m_toolIdIndex.end() )
886  continue;
887 
888  KIGFX::VC_SETTINGS& vc = it->second->vcSettings;
889  vc.m_forceCursorPosition = (bool) cursorSetting.second;
890  vc.m_forcedPosition = cursorSetting.second ? *cursorSetting.second : VECTOR2D( 0, 0 );
891  }
892 
893  m_cursorSettings.clear();
894  break;
895  }
896 }
bool m_menuActive
Flag indicating whether a context menu is currently displayed.
Definition: tool_manager.h:578
VECTOR2D m_menuCursor
Right click context menu position.
Definition: tool_manager.h:573
ACTION_MENU.
Definition: action_menu.h:43
ID_STATE_MAP m_toolIdIndex
Index of the registered tools current states, associated by tools' ID numbers.
Definition: tool_manager.h:550
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:562
VECTOR2D m_forcedPosition
Forced cursor position (world coordinates)
Definition: view_controls.h:58
EDA_BASE_FRAME * m_frame
Definition: tool_manager.h:567
int TOOL_ID
Unique identifier for tools.
Definition: tool_base.h:55
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:61
TOOL_ID m_menuOwner
Tool currently displaying a popup menu. It is negative when there is no menu displayed.
Definition: tool_manager.h:581
TOOL_EVENT.
Definition: tool_event.h:171
Structure to keep VIEW_CONTROLS settings for easy store/restore operations
Definition: view_controls.h:44
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:566
bool m_warpMouseAfterContextMenu
Definition: tool_manager.h:575
ID_LIST m_activeTools
Stack of the active tools.
Definition: tool_manager.h:556
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)
private

Function dispatchStandardEvents() 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 768 of file tool_manager.cpp.

769 {
770  if( aEvent.Action() == TA_KEY_PRESSED )
771  return m_actionMgr->RunHotKey( aEvent.Modifier() | aEvent.KeyCode() );
772 
773  return false;
774 }
ACTION_MANAGER * m_actionMgr
Instance of ACTION_MANAGER that handles TOOL_ACTIONs.
Definition: tool_manager.h:559
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 645 of file tool_manager.cpp.

646 {
647  bool handled = false;
648 
649  wxLogTrace( kicadTraceToolStack, "TOOL_MANAGER::dispatchInternal %s", aEvent.Format() );
650 
651  // iterate over active tool stack
652  for( auto it = m_activeTools.begin(); it != m_activeTools.end(); ++it )
653  {
654  TOOL_STATE* st = m_toolIdIndex[*it];
655 
656  // forward context menu events to the tool that created the menu
657  if( aEvent.IsChoiceMenu() )
658  {
659  if( *it != m_menuOwner )
660  continue;
661  }
662 
663  // the tool state handler is waiting for events (i.e. called Wait() method)
664  if( st && st->pendingWait )
665  {
666  if( st->waitEvents.Matches( aEvent ) )
667  {
668  if( !aEvent.FirstResponder() )
669  const_cast<TOOL_EVENT*>( &aEvent )->SetFirstResponder( st->theTool );
670 
671  // got matching event? clear wait list and wake up the coroutine
672  st->wakeupEvent = aEvent;
673  st->pendingWait = false;
674  st->waitEvents.clear();
675 
676  if( st->cofunc )
677  {
678  wxLogTrace( kicadTraceToolStack,
679  "TOOL_MANAGER::dispatchInternal Waking tool %s for event: %s",
680  st->theTool->GetName(), aEvent.Format() );
681 
682  setActiveState( st );
683  bool end = !st->cofunc->Resume();
684 
685  if( end )
686  it = finishTool( st );
687  }
688 
689  // If the tool did not request the event be passed to other tools, we're done
690  if( !st->wakeupEvent.PassEvent() )
691  {
692  wxLogTrace( kicadTraceToolStack,
693  "TOOL_MANAGER::dispatchInternal %s stopped passing event: %s",
694  st->theTool->GetName(), aEvent.Format() );
695 
696  handled = true;
697  break;
698  }
699  }
700  }
701  }
702 
703  for( auto& state : m_toolState )
704  {
705  TOOL_STATE* st = state.second;
706  bool finished = false;
707 
708  // no state handler in progress - check if there are any transitions (defined by
709  // Go() method that match the event.
710  if( !st->transitions.empty() )
711  {
712  for( TRANSITION& tr : st->transitions )
713  {
714  if( tr.first.Matches( aEvent ) )
715  {
716  auto func_copy = tr.second;
717 
718  if( !aEvent.FirstResponder() )
719  const_cast<TOOL_EVENT*>( &aEvent )->SetFirstResponder( st->theTool );
720 
721  // if there is already a context, then push it on the stack
722  // and transfer the previous view control settings to the new context
723  if( st->cofunc )
724  {
725  auto vc = st->vcSettings;
726  st->Push();
727  st->vcSettings = vc;
728  }
729 
730  st->cofunc = new COROUTINE<int, const TOOL_EVENT&>( std::move( func_copy ) );
731 
732  // as the state changes, the transition table has to be set up again
733  st->transitions.clear();
734 
735  wxLogTrace( kicadTraceToolStack,
736  "TOOL_MANAGER::dispatchInternal Running tool %s for event: %s",
737  st->theTool->GetName(), aEvent.Format() );
738 
739  // got match? Run the handler.
740  setActiveState( st );
741  st->idle = false;
742  st->cofunc->Call( aEvent );
743  handled = true;
744 
745  if( !st->cofunc->Running() )
746  finishTool( st ); // The couroutine has finished immediately?
747 
748  // if it is a message, continue processing
749  finished = !( aEvent.Category() == TC_MESSAGE );
750 
751  // there is no point in further checking, as transitions got cleared
752  break;
753  }
754  }
755  }
756 
757  if( finished )
758  break; // only the first tool gets the event
759  }
760 
761  wxLogTrace( kicadTraceToolStack, "TOOL_MANAGER::dispatchInternal handled: %s %s",
762  ( handled ? "true" : "false" ), aEvent.Format() );
763 
764  return handled;
765 }
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:550
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:581
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:556
TOOL_STATE_MAP m_toolState
Index of registered tools current states, associated by tools' objects.
Definition: tool_manager.h:544
std::pair< TOOL_EVENT_LIST, TOOL_STATE_FUNC > TRANSITION
Definition: tool_manager.h:426

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

507 {
508  std::map<TOOL_ID, TOOL_STATE*>::const_iterator it = m_toolIdIndex.find( aId );
509 
510  if( it != m_toolIdIndex.end() )
511  return it->second->theTool;
512 
513  return NULL;
514 }
ID_STATE_MAP m_toolIdIndex
Index of the registered tools current states, associated by tools' ID numbers.
Definition: tool_manager.h:550
#define NULL

References m_toolIdIndex, and NULL.

Referenced by GetCurrentTool(), GLOBAL_EDIT_TOOL::Init(), EDIT_TOOL::Init(), InvokeTool(), EDIT_TOOL::isInteractiveDragEnabled(), ACTION_MANAGER::RunHotKey(), runTool(), 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 517 of file tool_manager.cpp.

518 {
519  std::map<std::string, TOOL_STATE*>::const_iterator it = m_toolNameIndex.find( aName );
520 
521  if( it != m_toolNameIndex.end() )
522  return it->second->theTool;
523 
524  return NULL;
525 }
NAME_STATE_MAP m_toolNameIndex
Index of the registered tools current states, associated by tools' names.
Definition: tool_manager.h:547
#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 899 of file tool_manager.cpp.

900 {
901  auto it = std::find( m_activeTools.begin(), m_activeTools.end(), aState->theTool->GetId() );
902 
903  if( !aState->Pop() )
904  {
905  // Deactivate the tool if there are no other contexts saved on the stack
906  if( it != m_activeTools.end() )
907  it = m_activeTools.erase( it );
908 
909  aState->idle = true;
910  }
911 
912  if( aState == m_activeState )
913  setActiveState( nullptr );
914 
915  // Set transitions to be ready for future TOOL_EVENTs
916  TOOL_BASE* tool = aState->theTool;
917 
918  if( tool->GetType() == INTERACTIVE )
919  static_cast<TOOL_INTERACTIVE*>( tool )->resetTransitions();
920 
921  // Don't move the iterator past the stack beginning
922  if( it == m_activeTools.begin() )
923  return it;
924 
925  return --it;
926 }
TOOL_TYPE GetType() const
Function GetType() Returns the type of the tool.
Definition: tool_base.h:109
Tool that interacts with the user
Definition: tool_base.h:48
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:584
TOOL_BASE.
Definition: tool_base.h:66
ID_LIST m_activeTools
Stack of the active tools.
Definition: tool_manager.h:556

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

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

References m_actionMgr.

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

◆ GetActions()

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

Definition at line 347 of file tool_manager.cpp.

348 {
349  return m_actionMgr->GetActions();
350 }
ACTION_MANAGER * m_actionMgr
Instance of ACTION_MANAGER that handles TOOL_ACTIONs.
Definition: tool_manager.h:559
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 981 of file tool_manager.cpp.

982 {
983  std::string result;
984 
985  if( wxTheClipboard->Open() )
986  {
987  if( wxTheClipboard->IsSupported( wxDF_TEXT ) )
988  {
989  wxTextDataObject data;
990  wxTheClipboard->GetData( data );
991 
992  result = data.GetText().mb_str();
993  }
994 
995  wxTheClipboard->Close();
996  }
997 
998  return result;
999 }

Referenced by LIB_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 318 of file tool_manager.h.

319  {
320  return FindTool( GetCurrentToolId() );
321  }
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:308

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

309  {
310  return m_activeTools.empty() ? -1 : m_activeTools.front();
311  }
ID_LIST m_activeTools
Stack of the active tools.
Definition: tool_manager.h:556

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

328  {
329  auto it = m_toolIdIndex.find( GetCurrentToolId() );
330  return ( it != m_toolIdIndex.end() ) ? it->second : nullptr;
331  }
ID_STATE_MAP m_toolIdIndex
Index of the registered tools current states, associated by tools' ID numbers.
Definition: tool_manager.h:550
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:308

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

1003 {
1004  if( TOOL_STATE* active = GetCurrentToolState() )
1005  return active->vcSettings;
1006 
1007  return m_viewControls->GetSettings();
1008 }
const VC_SETTINGS & GetSettings() const
Returns the current VIEW_CONTROLS settings
KIGFX::VIEW_CONTROLS * m_viewControls
Definition: tool_manager.h:566
TOOL_STATE * GetCurrentToolState() const
Returns the TOOL_STATE object representing the state of the active tool.
Definition: tool_manager.h:327

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

Referenced by COMMON_TOOLS::ResetLocalCoords().

◆ GetCursorPosition()

VECTOR2D TOOL_MANAGER::GetCursorPosition ( )

Definition at line 296 of file tool_manager.cpp.

297 {
298  if( m_viewControls )
300  else
301  return wxGetMousePosition();
302 }
KIGFX::VIEW_CONTROLS * m_viewControls
Definition: tool_manager.h:566
VECTOR2D GetCursorPosition() const
Returns the current cursor position in world coordinates.

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

Referenced by invokeTool(), and RunAction().

◆ GetEditFrame()

◆ GetHotKey()

int TOOL_MANAGER::GetHotKey ( const TOOL_ACTION aAction)

Definition at line 353 of file tool_manager.cpp.

354 {
355  return m_actionMgr->GetHotKey( aAction );
356 }
ACTION_MANAGER * m_actionMgr
Instance of ACTION_MANAGER that handles TOOL_ACTIONs.
Definition: tool_manager.h:559
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 287 of file tool_manager.cpp.

288 {
289  if( m_viewControls )
291  else
292  return wxGetMousePosition();
293 }
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:566

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

585 {
586  int priority = 0;
587 
588  for( TOOL_ID tool : m_activeTools )
589  {
590  if( tool == aToolId )
591  return priority;
592 
593  ++priority;
594  }
595 
596  return -1;
597 }
int TOOL_ID
Unique identifier for tools.
Definition: tool_base.h:55
ID_LIST m_activeTools
Stack of the active tools.
Definition: tool_manager.h:556

References m_activeTools.

Referenced by ACTION_MANAGER::RunHotKey().

◆ GetTool()

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

Definition at line 218 of file tool_manager.h.

219  {
220  std::map<const char*, TOOL_BASE*>::iterator tool = m_toolTypes.find( typeid( T ).name() );
221 
222  if( tool != m_toolTypes.end() )
223  return static_cast<T*>( tool->second );
224 
225  return NULL;
226  }
#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:553

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(), MODULE_EDITOR_TOOLS::CreatePadFromShapes(), PCB_INSPECTION_TOOL::CrossProbePcbToSch(), LIB_EDIT_TOOL::DeleteItemCursor(), SCH_EDIT_TOOL::DeleteItemCursor(), PCBNEW_CONTROL::DeleteItemCursor(), SCH_EDIT_FRAME::DeleteJunction(), SCH_EDIT_FRAME::DisplayCurrentSheet(), SCH_EDITOR_CONTROL::doCopy(), SCH_EDITOR_CONTROL::doCrossProbeSchToPcb(), SCH_LINE_WIRE_BUS_TOOL::doDrawSegments(), DRAWING_TOOL::DrawDimension(), DRAWING_TOOL::drawSegment(), LIB_DRAWING_TOOLS::DrawShape(), SCH_DRAWING_TOOLS::DrawSheet(), PCB_EDITOR_CONTROL::DrillOrigin(), SCH_EDITOR_CONTROL::EditWithLibEdit(), SCH_EDITOR_CONTROL::EnterSheet(), SCH_EDIT_FRAME::ExecuteRemoteCommand(), MODULE_EDITOR_TOOLS::ExplodePadToShapes(), EDIT_TOOL::GetAndPlace(), FP_TREE_SYNCHRONIZING_ADAPTER::GetContextMenuTool(), SYMBOL_TREE_SYNCHRONIZING_ADAPTER::GetContextMenuTool(), DRAWING_TOOL::getSourceZoneForAction(), PCBNEW_CONTROL::GridSetOrigin(), GERBVIEW_CONTROL::HighlightControl(), PCB_INSPECTION_TOOL::highlightNet(), highlightNet(), SCH_EDITOR_CONTROL::HighlightNetCursor(), PCB_INSPECTION_TOOL::HighlightNetTool(), LIB_EDIT_TOOL::Init(), SCH_EDIT_TOOL::Init(), PAD_TOOL::Init(), ALIGN_DISTRIBUTE_TOOL::Init(), LIB_CONTROL::Init(), POINT_EDITOR::Init(), PCB_EDITOR_CONTROL::Init(), POSITION_RELATIVE_TOOL::Init(), EE_TOOL_BASE< SCH_BASE_FRAME >::Init(), ROUTER_TOOL::InlineBreakTrack(), ROUTER_TOOL::InlineDrag(), EDIT_TOOL::invokeInlineRouter(), SCH_EDIT_FRAME::KiwayMailIn(), LIB_EDIT_FRAME::LoadOneSymbol(), PCB_INSPECTION_TOOL::LocalRatsnestTool(), LIB_MOVE_TOOL::Main(), PCB_EDITOR_CONTROL::modifyLockSelected(), DIALOG_POSITION_RELATIVE::OnClear(), DIALOG_POSITION_RELATIVE::OnOkClick(), DIALOG_PLOT::onRunDRC(), DIALOG_POSITION_RELATIVE::OnSelectItemClick(), DIALOG_FIELDS_EDITOR_GLOBAL::OnTableCellClick(), 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(), KICAD_MANAGER_FRAME::ReCreateMenuBar(), LIB_VIEW_FRAME::ReCreateMenuBar(), FOOTPRINT_VIEWER_FRAME::ReCreateMenuBar(), FOOTPRINT_EDIT_FRAME::ReCreateMenuBar(), LIB_EDIT_FRAME::ReCreateMenuBar(), CVPCB_MAINFRAME::ReCreateMenuBar(), GERBVIEW_FRAME::ReCreateMenuBar(), SCH_EDIT_FRAME::ReCreateMenuBar(), PCB_EDIT_FRAME::ReCreateMenuBar(), LIB_EDIT_TOOL::Redo(), SCH_EDITOR_CONTROL::Redo(), SCH_BASE_FRAME::RefreshSelection(), EDIT_TOOL::Remove(), LIB_DRAWING_TOOLS::RepeatDrawItem(), 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_FIELDS_EDITOR_GLOBAL::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(), PCBNEW_CONTROL::UpdateMessagePanel(), PCB_INSPECTION_TOOL::UpdateSelectionRatsnest(), PCB_EDITOR_CONTROL::ViaSizeDec(), PCB_EDITOR_CONTROL::ViaSizeInc(), PCB_EDITOR_CONTROL::ZoneDuplicate(), and PCB_EDITOR_CONTROL::ZoneMerge().

◆ GetView()

◆ GetViewControls()

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

Definition at line 285 of file tool_manager.h.

286  {
287  return m_viewControls;
288  }
KIGFX::VIEW_CONTROLS * m_viewControls
Definition: tool_manager.h:566

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

553 {
554  for( auto it = m_toolState.begin(); it != m_toolState.end(); /* iteration in the loop */ )
555  {
556  TOOL_BASE* tool = it->first;
557  TOOL_STATE* state = it->second;
558  setActiveState( state );
559  ++it; // keep the iterator valid if the element is going to be erased
560 
561  if( !tool->Init() )
562  {
563  wxMessageBox( wxString::Format( "Initialization of tool \"%s\" failed",
564  tool->GetName() ) );
565 
566  // Unregister the tool
567  setActiveState( nullptr );
568  m_toolState.erase( tool );
569  m_toolNameIndex.erase( tool->GetName() );
570  m_toolIdIndex.erase( tool->GetId() );
571  m_toolTypes.erase( typeid( *tool ).name() );
572 
573  delete state;
574  delete tool;
575  }
576  }
577 
578  m_actionMgr->UpdateHotKeys( true );
579 
581 }
virtual bool Init()
Function Init() Init() is called once upon a registration of the tool.
Definition: tool_base.h:91
ACTION_MANAGER * m_actionMgr
Instance of ACTION_MANAGER that handles TOOL_ACTIONs.
Definition: tool_manager.h:559
ID_STATE_MAP m_toolIdIndex
Index of the registered tools current states, associated by tools' ID numbers.
Definition: tool_manager.h:550
TOOL_ID GetId() const
Function GetId() Returns the unique identifier of the tool.
Definition: tool_base.h:120
Tool is invoked after being inactive.
Definition: tool_base.h:80
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:547
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:66
const std::string & GetName() const
Function GetName() Returns the name of the tool.
Definition: tool_base.h:131
TOOL_STATE_MAP m_toolState
Index of registered tools current states, associated by tools' objects.
Definition: tool_manager.h:544
std::map< const char *, TOOL_BASE * > m_toolTypes
Index of the registered tools to easily lookup by their type.
Definition: tool_manager.h:553

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(), 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  return false; // there is no tool with the given id
257 }
TOOL_TYPE GetType() const
Function GetType() Returns the type of the tool.
Definition: tool_base.h:109
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:48
TOOL_BASE.
Definition: tool_base.h:66
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, and invokeTool().

Referenced by TOOL_INTERACTIVE::Activate(), CVPCB_MAINFRAME::CVPCB_MAINFRAME(), FOOTPRINT_VIEWER_FRAME::FOOTPRINT_VIEWER_FRAME(), EE_SELECTION_TOOL::Main(), 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 260 of file tool_manager.cpp.

261 {
262  TOOL_BASE* tool = FindTool( aToolName );
263 
264  if( tool && tool->GetType() == INTERACTIVE )
265  return invokeTool( tool );
266 
267  return false; // there is no tool with the given name
268 }
TOOL_TYPE GetType() const
Function GetType() Returns the type of the tool.
Definition: tool_base.h:109
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:48
TOOL_BASE.
Definition: tool_base.h:66
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, and invokeTool().

◆ invokeTool() [1/2]

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

360 {
361  wxASSERT( aTool != NULL );
362 
363  TOOL_EVENT evt( TC_COMMAND, TA_ACTIVATE, aTool->GetName() );
365  processEvent( evt );
366 
367  if( TOOL_STATE* active = GetCurrentToolState() )
368  setActiveState( active );
369 
370  return true;
371 }
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:327
const std::string & GetName() const
Function GetName() Returns the name of the tool.
Definition: tool_base.h:131

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

Referenced by InvokeTool().

◆ invokeTool() [2/2]

template<class Parameters >
void TOOL_MANAGER::invokeTool ( const std::string &  aName,
const Parameters &  aToolParams 
)
private

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

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

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

405  {
406  return m_menuActive;
407  }
bool m_menuActive
Flag indicating whether a context menu is currently displayed.
Definition: tool_manager.h:578

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

506  {
507  return m_toolState.count( aTool ) > 0;
508  }
TOOL_STATE_MAP m_toolState
Index of registered tools current states, associated by tools' objects.
Definition: tool_manager.h:544

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

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

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

1012 {
1013  static int currentId;
1014 
1015  return currentId++;
1016 }

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

268  {
269  m_eventQueue.push_back( aEvent );
270  }
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:570

References m_eventQueue.

Referenced by SCH_EDIT_FRAME::AddJunction(), SCH_EDIT_TOOL::editFieldText(), SCH_LINE_WIRE_BUS_TOOL::finishSegments(), SCH_MOVE_TOOL::Main(), LIB_MOVE_TOOL::Main(), LIB_EDIT_TOOL::Mirror(), SCH_EDIT_TOOL::Mirror(), PCB_EDITOR_CONTROL::modifyLockSelected(), EDIT_TOOL::Move(), EDA_BASE_FRAME::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 333 of file tool_manager.cpp.

334 {
335  int modifiers = 0;
336  modifiers |= wxGetKeyState( WXK_SHIFT ) ? MD_SHIFT : 0;
337  modifiers |= wxGetKeyState( WXK_CONTROL ) ? MD_CTRL : 0;
338  modifiers |= wxGetKeyState( WXK_ALT ) ? MD_ALT : 0;
339 
340  TOOL_EVENT evt( TC_MOUSE, TA_PRIME, BUT_LEFT | modifiers );
341  evt.SetMousePosition( aPosition );
342 
343  PostEvent( evt );
344 }
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:267

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

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

◆ ProcessEvent()

bool TOOL_MANAGER::ProcessEvent ( const TOOL_EVENT aEvent)

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

930 {
931  bool handled = processEvent( aEvent );
932 
933  TOOL_STATE* activeTool = GetCurrentToolState();
934 
935  if( activeTool )
936  setActiveState( activeTool );
937 
938  if( m_view && m_view->IsDirty() )
939  {
940  auto frame = GetEditFrame();
941  if( frame )
942  {
943  frame->RefreshCanvas();
944  }
945 
946 #if defined( __WXMAC__ ) || defined( __WINDOWS__ )
947  wxTheApp->ProcessPendingEvents(); // required for updating brightening behind a popup menu
948 #endif
949  }
950 
951  UpdateUI( aEvent );
952 
953  return handled;
954 }
void UpdateUI(const TOOL_EVENT &aEvent)
Updates the status bar and synchronizes toolbars.
EDA_BASE_FRAME * GetEditFrame() const
Definition: tool_manager.h:298
bool processEvent(const TOOL_EVENT &aEvent)
Main function for event processing.
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:327
KIGFX::VIEW * m_view
Definition: tool_manager.h:565
bool IsDirty() const
Function IsDirty() Returns true if any of the VIEW layers needs to be refreshened.
Definition: view.h:557

References GetCurrentToolState(), GetEditFrame(), KIGFX::VIEW::IsDirty(), m_view, processEvent(), setActiveState(), and UpdateUI().

Referenced by EE_SELECTION_TOOL::AddItemsToSel(), EE_SELECTION_TOOL::AddItemToSel(), SELECTION_TOOL::AddItemToSel(), EDIT_TOOL::ChangeTrackWidth(), SELECTION_TOOL::ClearSelection(), GERBVIEW_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(), EE_SELECTION_TOOL::RemoveItemFromSel(), SELECTION_TOOL::RemoveItemFromSel(), 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(), EE_SELECTION_TOOL::selectMultiple(), SELECTION_TOOL::selectMultiple(), SELECTION_TOOL::selectNet(), 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 1085 of file tool_manager.cpp.

1086 {
1087  wxLogTrace( kicadTraceToolStack, "TOOL_MANAGER::processEvent %s", aEvent.Format() );
1088 
1089  // First try to dispatch the action associated with the event if it is a key press event
1090  bool handled = dispatchHotKey( aEvent );
1091 
1092  if( !handled )
1093  {
1094  TOOL_EVENT mod_event( aEvent );
1095 
1096  // Only immediate actions get the position. Otherwise clear for tool activation
1097  if( GetEditFrame() && !GetEditFrame()->GetDoImmediateActions() )
1098  {
1099  // An tool-selection-event has no position
1100  if( mod_event.GetCommandStr().is_initialized()
1101  && mod_event.GetCommandStr().get() != GetEditFrame()->CurrentToolName() )
1102  {
1103  mod_event.SetHasPosition( false );
1104  }
1105  }
1106 
1107  // If the event is not handled through a hotkey activation, pass it to the currently
1108  // running tool loops
1109  handled |= dispatchInternal( mod_event );
1110  handled |= dispatchActivation( mod_event );
1111 
1112  // Open the context menu if requested by a tool
1113  DispatchContextMenu( mod_event );
1114 
1115  // Dispatch any remaining events in the event queue
1116  while( !m_eventQueue.empty() )
1117  {
1118  TOOL_EVENT event = m_eventQueue.front();
1119  m_eventQueue.pop_front();
1120  processEvent( event );
1121  }
1122  }
1123 
1124  wxLogTrace( kicadTraceToolStack, "TOOL_MANAGER::processEvent handled: %s %s",
1125  ( handled ? "true" : "false" ), aEvent.Format() );
1126 
1127  return handled;
1128 }
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
EDA_BASE_FRAME * GetEditFrame() const
Definition: tool_manager.h:298
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 dispatchStandardEvents() Handles specific events, that are intended for TOOL_MANAGER rather ...
TOOL_EVENT.
Definition: tool_event.h:171
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:570
const wxChar *const kicadTraceToolStack
Flag to enable tracing of the tool handling stack.
std::string CurrentToolName() const
bool dispatchInternal(const TOOL_EVENT &aEvent)
Function dispatchInternal Passes an event at first to the active tools, then to all others.

References EDA_BASE_FRAME::CurrentToolName(), dispatchActivation(), DispatchContextMenu(), dispatchHotKey(), dispatchInternal(), TOOL_EVENT::Format(), TOOL_EVENT::GetCommandStr(), GetEditFrame(), 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:550
TOOL_ID GetId() const
Function GetId() Returns the unique identifier of the tool.
Definition: tool_base.h:120
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:547
const std::string & GetName() const
Function GetName() Returns the name of the tool.
Definition: tool_base.h:131
TOOL_STATE_MAP m_toolState
Index of registered tools current states, associated by tools' objects.
Definition: tool_manager.h:544
std::map< const char *, TOOL_BASE * > m_toolTypes
Index of the registered tools to easily lookup by their type.
Definition: tool_manager.h:553

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(), 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 536 of file tool_manager.cpp.

537 {
538  DeactivateTool();
539 
540  for( auto& state : m_toolState )
541  {
542  TOOL_BASE* tool = state.first;
543  setActiveState( state.second );
544  tool->Reset( aReason );
545 
546  if( tool->GetType() == INTERACTIVE )
547  static_cast<TOOL_INTERACTIVE*>( tool )->resetTransitions();
548  }
549 }
TOOL_TYPE GetType() const
Function GetType() Returns the type of the tool.
Definition: tool_base.h:109
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:48
void setActiveState(TOOL_STATE *aState)
Saves the previous active state and sets a new one.
TOOL_BASE.
Definition: tool_base.h:66
TOOL_STATE_MAP m_toolState
Index of registered tools current states, associated by tools' objects.
Definition: tool_manager.h:544

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(), 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 139 of file tool_manager.h.

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

Referenced by DIALOG_GLOBAL_DELETION::AcceptPcbDelete(), TREEPROJECT_ITEM::Activate(), FOOTPRINT_VIEWER_FRAME::AddFootprintToPCB(), LIB_CONTROL::AddSymbolToSchematic(), SCH_EDIT_FRAME::AppendSchematic(), CVPCB_ASSOCIATION_TOOL::Associate(), ROUTER_TOOL::CanInlineDrag(), EDIT_TOOL::ChangeTrackWidth(), SELECTION_TOOL::ClearSelection(), ZONE_CREATE_HELPER::commitZone(), SCH_EDIT_TOOL::ConvertDeMorgan(), SCH_EDIT_FRAME::ConvertPart(), SCH_EDIT_FRAME::ConvertTextType(), MICROWAVE_TOOL::createInductorBetween(), LIB_EDIT_FRAME::CreateNewPart(), MODULE_EDITOR_TOOLS::CreatePadFromShapes(), COMMON_TOOLS::CursorControl(), ROUTER_TOOL::CustomTrackWidthDialog(), SCH_EDITOR_CONTROL::Cut(), LIB_VIEW_FRAME::DClickOnCmpList(), DIALOG_ERC::deleteAllMarkers(), DIALOG_DRC::deleteAllMarkers(), LIB_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(), 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::drawSegment(), LIB_DRAWING_TOOLS::DrawShape(), SCH_DRAWING_TOOLS::DrawSheet(), PCB_EDITOR_CONTROL::DrillOrigin(), LIB_EDIT_TOOL::Duplicate(), SCH_EDIT_TOOL::Duplicate(), EDIT_TOOL::Duplicate(), EDIT_TOOL::EditFpInFpEditor(), 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(), PCB_EDIT_FRAME::ExecuteRemoteCommand(), SCH_EDIT_FRAME::ExecuteRemoteCommand(), MODULE_EDITOR_TOOLS::ExplodePadToShapes(), 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(), MODULE_EDITOR_TOOLS::ImportFootprint(), ROUTER_TOOL::InlineBreakTrack(), ROUTER_TOOL::InlineDrag(), EDIT_TOOL::invokeInlineRouter(), PCB_EDIT_FRAME::KiwayMailIn(), SCH_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(), SCH_MOVE_TOOL::Main(), CVPCB_CONTROL::Main(), LIB_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(), 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(), 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(), 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(), 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(), EE_SELECTION_TOOL::SelectPoint(), POSITION_RELATIVE_TOOL::SelectPositionRelativeItem(), GERBVIEW_FRAME::SetActiveLayer(), DRAWING_TOOL::SetAnchor(), LIB_EDIT_FRAME::SetCurPart(), PCB_BASE_FRAME::SetFastGrid1(), PCB_BASE_FRAME::SetFastGrid2(), 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(), LIB_DRAWING_TOOLS::TwoClickPlace(), SCH_DRAWING_TOOLS::TwoClickPlace(), PCB_BASE_EDIT_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 271 of file tool_manager.cpp.

272 {
273  TOOL_ACTION* action = m_actionMgr->FindAction( aActionName );
274 
275  if( !action )
276  {
277  wxASSERT_MSG( false, wxString::Format( wxT( "Could not find action %s." ), aActionName ) );
278  return false;
279  }
280 
281  RunAction( *action, aNow, aParam );
282 
283  return false;
284 }
ACTION_MANAGER * m_actionMgr
Instance of ACTION_MANAGER that handles TOOL_ACTIONs.
Definition: tool_manager.h:559
bool RunAction(const std::string &aActionName, bool aNow=false, T aParam=NULL)
Function RunAction() Runs the specified action.
Definition: tool_manager.h:139
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 146 of file tool_manager.h.

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

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

References RunAction().

◆ RunAction() [5/6]

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

Definition at line 305 of file tool_manager.cpp.

306 {
307  bool handled = false;
308  TOOL_EVENT event = aAction.MakeEvent();
309 
310  if( event.Category() == TC_COMMAND )
312 
313  // Allow to override the action parameter
314  if( aParam )
315  event.SetParameter( aParam );
316 
317  if( aNow )
318  {
319  TOOL_STATE* current = m_activeState;
320  handled = processEvent( event );
321  setActiveState( current );
322  UpdateUI( event );
323  }
324  else
325  {
326  PostEvent( event );
327  }
328 
329  return handled;
330 }
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:584
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:267

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

◆ RunAction() [6/6]

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

Definition at line 174 of file tool_manager.h.

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

References NULL, and RunAction().

◆ RunMainStack()

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

Definition at line 615 of file tool_manager.cpp.

616 {
617  TOOL_STATE* st = m_toolState[aTool];
618  setActiveState( st );
619  st->cofunc->RunMainStack( std::move( aFunc ) );
620 }
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:544

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

Referenced by TOOL_INTERACTIVE::RunMainStack().

◆ runTool() [1/3]

bool TOOL_MANAGER::runTool ( TOOL_ID  aToolId)
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
aToolIdis the ID number of tool to be run.

Definition at line 374 of file tool_manager.cpp.

375 {
376  TOOL_BASE* tool = FindTool( aToolId );
377 
378  if( tool && tool->GetType() == INTERACTIVE )
379  return runTool( tool );
380 
381  return false; // there is no tool with the given id
382 }
TOOL_TYPE GetType() const
Function GetType() Returns the type of the tool.
Definition: tool_base.h:109
TOOL_BASE * FindTool(int aId) const
Function FindTool() Searches for a tool with given ID.
bool runTool(TOOL_ID aToolId)
Function runTool() Makes a tool active, so it can receive events and react to them.
Tool that interacts with the user
Definition: tool_base.h:48
TOOL_BASE.
Definition: tool_base.h:66

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

Referenced by dispatchActivation(), and runTool().

◆ runTool() [2/3]

bool TOOL_MANAGER::runTool ( const std::string &  aName)
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
aNameis the name of tool to be run.

Definition at line 385 of file tool_manager.cpp.

386 {
387  TOOL_BASE* tool = FindTool( aToolName );
388 
389  if( tool && tool->GetType() == INTERACTIVE )
390  return runTool( tool );
391 
392  return false; // there is no tool with the given name
393 }
TOOL_TYPE GetType() const
Function GetType() Returns the type of the tool.
Definition: tool_base.h:109
TOOL_BASE * FindTool(int aId) const
Function FindTool() Searches for a tool with given ID.
bool runTool(TOOL_ID aToolId)
Function runTool() Makes a tool active, so it can receive events and react to them.
Tool that interacts with the user
Definition: tool_base.h:48
TOOL_BASE.
Definition: tool_base.h:66

References FindTool(), TOOL_BASE::GetType(), INTERACTIVE, and runTool().

◆ runTool() [3/3]

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

397 {
398  wxASSERT( aTool != NULL );
399 
400  if( !isRegistered( aTool ) )
401  {
402  wxASSERT_MSG( false, wxT( "You cannot run unregistered tools" ) );
403  return false;
404  }
405 
406  TOOL_ID id = aTool->GetId();
407 
408  if( aTool->GetType() == INTERACTIVE )
409  static_cast<TOOL_INTERACTIVE*>( aTool )->resetTransitions();
410 
411  // If the tool is already active, bring it to the top of the active tools stack
412  if( isActive( aTool ) && m_activeTools.size() > 1 )
413  {
414  auto it = std::find( m_activeTools.begin(), m_activeTools.end(), id );
415 
416  if( it != m_activeTools.end() )
417  {
418  if( it != m_activeTools.begin() )
419  {
420  m_activeTools.erase( it );
421  m_activeTools.push_front( id );
422  }
423 
424  return false;
425  }
426  }
427 
429  aTool->Reset( TOOL_INTERACTIVE::RUN );
430 
431  // Add the tool on the front of the processing queue (it gets events first)
432  m_activeTools.push_front( id );
433 
434  return true;
435 }
TOOL_TYPE GetType() const
Function GetType() Returns the type of the tool.
Definition: tool_base.h:109
ID_STATE_MAP m_toolIdIndex
Index of the registered tools current states, associated by tools' ID numbers.
Definition: tool_manager.h:550
TOOL_ID GetId() const
Function GetId() Returns the unique identifier of the tool.
Definition: tool_base.h:120
Tool is invoked after being inactive.
Definition: tool_base.h:80
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:55
Tool that interacts with the user
Definition: tool_base.h:48
#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:505
ID_LIST m_activeTools
Stack of the active tools.
Definition: tool_manager.h:556

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

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

968 {
969  if( wxTheClipboard->Open() )
970  {
971  wxTheClipboard->SetData( new wxTextDataObject( wxString( aText.c_str(), wxConvUTF8 ) ) );
972  wxTheClipboard->Close();
973 
974  return true;
975  }
976 
977  return false;
978 }

Referenced by LIB_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 1039 of file tool_manager.cpp.

1040 {
1041  aState->vcSettings = m_viewControls->GetSettings();
1042 
1043  if( m_menuActive )
1044  {
1045  // Context menu is active, so the cursor settings are overridden (see DispatchContextMenu())
1046  auto it = m_cursorSettings.find( aState->theTool->GetId() );
1047 
1048  if( it != m_cursorSettings.end() )
1049  {
1051 
1052  // Tool has overridden the cursor position, so store the new settings
1053  if( !curr.m_forceCursorPosition || curr.m_forcedPosition != m_menuCursor )
1054  {
1055  if( !curr.m_forceCursorPosition )
1056  it->second = NULLOPT;
1057  else
1058  it->second = curr.m_forcedPosition;
1059  }
1060  else
1061  {
1062  OPT<VECTOR2D> cursor = it->second;
1063 
1064  if( cursor )
1065  {
1066  aState->vcSettings.m_forceCursorPosition = true;
1067  aState->vcSettings.m_forcedPosition = *cursor;
1068  }
1069  else
1070  {
1071  aState->vcSettings.m_forceCursorPosition = false;
1072  }
1073  }
1074  }
1075  }
1076 }
bool m_menuActive
Flag indicating whether a context menu is currently displayed.
Definition: tool_manager.h:578
VECTOR2D m_menuCursor
Right click context menu position.
Definition: tool_manager.h:573
std::map< TOOL_ID, OPT< VECTOR2D > > m_cursorSettings
Original cursor position, if overridden by the context menu handler.
Definition: tool_manager.h:562
VECTOR2D m_forcedPosition
Forced cursor position (world coordinates)
Definition: view_controls.h:58
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:61
Structure to keep VIEW_CONTROLS settings for easy store/restore operations
Definition: view_controls.h:44
KIGFX::VIEW_CONTROLS * m_viewControls
Definition: tool_manager.h:566
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 957 of file tool_manager.cpp.

959 {
960  TOOL_STATE* st = m_toolState[aTool];
961 
962  st->contextMenu = aMenu;
963  st->contextMenuTrigger = aTrigger;
964 }
TOOL_STATE_MAP m_toolState
Index of registered tools current states, associated by tools' objects.
Definition: tool_manager.h:544

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

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

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

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

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

1132 {
1133  if( m_activeState && m_viewControls )
1135 
1136  m_activeState = aState;
1137 
1138  if( m_activeState && m_viewControls )
1139  applyViewControls( aState );
1140 }
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:566
TOOL_STATE * m_activeState
Pointer to the state object corresponding to the currently executed tool.
Definition: tool_manager.h:584
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,
EDA_BASE_FRAME 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 1019 of file tool_manager.cpp.

1021 {
1022  m_model = aModel;
1023  m_view = aView;
1024  m_viewControls = aViewControls;
1025  m_frame = aFrame;
1026 }
EDA_BASE_FRAME * m_frame
Definition: tool_manager.h:567
EDA_ITEM * m_model
Definition: tool_manager.h:564
KIGFX::VIEW_CONTROLS * m_viewControls
Definition: tool_manager.h:566
KIGFX::VIEW * m_view
Definition: tool_manager.h:565

References m_frame, m_model, 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(), PCB_BASE_EDIT_FRAME::SetBoard(), SCH_BASE_FRAME::SetScreen(), FOOTPRINT_EDIT_FRAME::setupTools(), PCB_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 438 of file tool_manager.cpp.

439 {
440  // Create a temporary list of tools to iterate over since when the tools shutdown
441  // they remove themselves from the list automatically (invalidating the iterator)
442  ID_LIST tmpList = m_activeTools;
443 
444  for( auto id : tmpList )
445  {
446  ShutdownTool( id );
447  }
448 }
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:556
std::list< TOOL_ID > ID_LIST
Definition: tool_manager.h:64

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(), 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 469 of file tool_manager.cpp.

470 {
471  wxASSERT( aTool != NULL );
472 
473  TOOL_ID id = aTool->GetId();
474 
475  if( isActive( aTool ) )
476  {
477  auto it = std::find( m_activeTools.begin(), m_activeTools.end(), id );
478 
479  TOOL_STATE* st = m_toolIdIndex[*it];
480 
481  // the tool state handler is waiting for events (i.e. called Wait() method)
482  if( st && st->pendingWait )
483  {
484  // Wake up the tool and tell it to shutdown
485  st->shutdown = true;
486  st->pendingWait = false;
487  st->waitEvents.clear();
488 
489  if( st->cofunc )
490  {
491  wxLogTrace( kicadTraceToolStack,
492  "TOOL_MANAGER::ShutdownTool is shutting down tool %s",
493  st->theTool->GetName() );
494 
495  setActiveState( st );
496  bool end = !st->cofunc->Resume();
497 
498  if( end )
499  it = finishTool( st );
500  }
501  }
502  }
503 }
ID_STATE_MAP m_toolIdIndex
Index of the registered tools current states, associated by tools' ID numbers.
Definition: tool_manager.h:550
TOOL_ID GetId() const
Function GetId() Returns the unique identifier of the tool.
Definition: tool_base.h:120
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:55
#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:556

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

452 {
453  TOOL_BASE* tool = FindTool( aToolId );
454 
455  if( tool && tool->GetType() == INTERACTIVE )
456  ShutdownTool( tool );
457 }
TOOL_TYPE GetType() const
Function GetType() Returns the type of the tool.
Definition: tool_base.h:109
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:48
TOOL_BASE.
Definition: tool_base.h:66

References FindTool(), TOOL_BASE::GetType(), INTERACTIVE, 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 460 of file tool_manager.cpp.

461 {
462  TOOL_BASE* tool = FindTool( aToolName );
463 
464  if( tool && tool->GetType() == INTERACTIVE )
465  ShutdownTool( tool );
466 }
TOOL_TYPE GetType() const
Function GetType() Returns the type of the tool.
Definition: tool_base.h:109
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:48
TOOL_BASE.
Definition: tool_base.h:66

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

◆ UpdateUI()

void TOOL_MANAGER::UpdateUI ( const TOOL_EVENT aEvent)

Updates the status bar and synchronizes toolbars.

Definition at line 1150 of file tool_manager.cpp.

1151 {
1152  EDA_BASE_FRAME* frame = GetEditFrame();
1153 
1154  if( frame )
1155  {
1156  frame->UpdateStatusBar();
1157 
1158  if( !aEvent.IsMotion() && !aEvent.IsDrag() )
1159  frame->SyncToolbars();
1160  }
1161 }
EDA_BASE_FRAME * GetEditFrame() const
Definition: tool_manager.h:298
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
The base frame for deriving all KiCad main window classes.

References GetEditFrame(), 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 414 of file tool_manager.h.

415  {
417  }
bool m_warpMouseAfterContextMenu
Definition: tool_manager.h:575

References m_warpMouseAfterContextMenu.

Referenced by DIALOG_SHIM::DIALOG_SHIM(), SCH_LINE_WIRE_BUS_TOOL::doDrawSegments(), LIB_DRAWING_TOOLS::DrawShape(), SCH_DRAWING_TOOLS::DrawSheet(), LIB_TREE::onContextMenu(), SCH_DRAWING_TOOLS::PlaceComponent(), SCH_DRAWING_TOOLS::PlaceImage(), 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 559 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 584 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 562 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 570 of file tool_manager.h.

Referenced by PostEvent(), and processEvent().

◆ m_frame

EDA_BASE_FRAME* TOOL_MANAGER::m_frame
private

Definition at line 567 of file tool_manager.h.

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

◆ m_menuActive

bool TOOL_MANAGER::m_menuActive
private

Flag indicating whether a context menu is currently displayed.

Definition at line 578 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 573 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 581 of file tool_manager.h.

Referenced by DispatchContextMenu(), and dispatchInternal().

◆ m_model

EDA_ITEM* TOOL_MANAGER::m_model
private

Definition at line 564 of file tool_manager.h.

Referenced by GetModel(), 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 550 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 547 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 544 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 553 of file tool_manager.h.

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

◆ m_view

KIGFX::VIEW* TOOL_MANAGER::m_view
private

Definition at line 565 of file tool_manager.h.

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

◆ m_viewControls

◆ m_warpMouseAfterContextMenu

bool TOOL_MANAGER::m_warpMouseAfterContextMenu
private

Definition at line 575 of file tool_manager.h.

Referenced by DispatchContextMenu(), and VetoContextMenuMouseWarp().


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