KiCad PCB EDA Suite
ACTION_MANAGER Class Reference

Manage TOOL_ACTION objects. More...

#include <action_manager.h>

Public Member Functions

 ACTION_MANAGER (TOOL_MANAGER *aToolManager)
 
 ~ACTION_MANAGER ()
 Unregister every registered action. More...
 
void RegisterAction (TOOL_ACTION *aAction)
 Add a tool action to the manager and sets it up. More...
 
const std::map< std::string, TOOL_ACTION * > & GetActions () const
 Get a list of currently-registered actions mapped by their name. More...
 
TOOL_ACTIONFindAction (const std::string &aActionName) const
 Find an action with a given name (if there is one available). More...
 
bool RunHotKey (int aHotKey) const
 Run an action associated with a hotkey (if there is one available). More...
 
int GetHotKey (const TOOL_ACTION &aAction) const
 Return the hot key associated with a given action or 0 if there is none. More...
 
void UpdateHotKeys (bool aFullUpdate)
 Optionally read the hotkey config files and then rebuilds the internal hotkey maps. More...
 
void SetConditions (const TOOL_ACTION &aAction, const ACTION_CONDITIONS &aConditions)
 Set the conditions the UI elements for activating a specific tool action should use for determining the current UI state (e.g. More...
 
const ACTION_CONDITIONSGetCondition (const TOOL_ACTION &aAction) const
 Get the conditions to use for a specific tool action. More...
 

Static Public Member Functions

static int MakeActionId (const std::string &aActionName)
 Generate an unique ID from for an action with given name. More...
 
static std::list< TOOL_ACTION * > & GetActionList ()
 Return list of TOOL_ACTIONs. More...
 

Private Types

typedef std::map< int, std::list< TOOL_ACTION * > > HOTKEY_LIST
 

Private Member Functions

int processHotKey (TOOL_ACTION *aAction, std::map< std::string, int > aLegacyMap, std::map< std::string, int > aHotKeyMap)
 Tool manager needed to run actions. More...
 

Private Attributes

TOOL_MANAGERm_toolMgr
 Map for indexing actions by their names. More...
 
std::map< std::string, TOOL_ACTION * > m_actionNameIndex
 Map for indexing actions by their hotkeys. More...
 
HOTKEY_LIST m_actionHotKeys
 Quick action<->hot key lookup. More...
 
std::map< int, int > m_hotkeys
 
std::map< int, ACTION_CONDITIONSm_uiConditions
 Map the command ID that wx uses for the action to the UI conditions for the menu/toolbar items. More...
 

Detailed Description

Manage TOOL_ACTION objects.

Registering them and allows one to run them using associated hot keys, names or ids.

Definition at line 85 of file action_manager.h.

Member Typedef Documentation

◆ HOTKEY_LIST

typedef std::map<int, std::list<TOOL_ACTION*> > ACTION_MANAGER::HOTKEY_LIST
private

Definition at line 188 of file action_manager.h.

Constructor & Destructor Documentation

◆ ACTION_MANAGER()

ACTION_MANAGER::ACTION_MANAGER ( TOOL_MANAGER aToolManager)
Parameters
aToolManageris a tool manager instance that is used to pass events to tools.

Definition at line 36 of file action_manager.cpp.

36  :
37  m_toolMgr( aToolManager )
38 {
39  // Register known actions
40  std::list<TOOL_ACTION*>& actionList = GetActionList();
41 
42  for( TOOL_ACTION* action : actionList )
43  {
44  if( action->m_id == -1 )
45  action->m_id = MakeActionId( action->m_name );
46 
47  RegisterAction( action );
48  }
49 }
static int MakeActionId(const std::string &aActionName)
Generate an unique ID from for an action with given name.
static std::list< TOOL_ACTION * > & GetActionList()
Return list of TOOL_ACTIONs.
TOOL_MANAGER * m_toolMgr
Map for indexing actions by their names.
void RegisterAction(TOOL_ACTION *aAction)
Add a tool action to the manager and sets it up.
Represent a single user action.
Definition: tool_action.h:67

References GetActionList(), MakeActionId(), and RegisterAction().

◆ ~ACTION_MANAGER()

ACTION_MANAGER::~ACTION_MANAGER ( )

Unregister every registered action.

Definition at line 52 of file action_manager.cpp.

53 {
54 }

Member Function Documentation

◆ FindAction()

TOOL_ACTION * ACTION_MANAGER::FindAction ( const std::string &  aActionName) const

Find an action with a given name (if there is one available).

Parameters
aActionNameis the searched action.
Returns
Pointer to a TOOL_ACTION object or NULL if there is no such action.

Definition at line 110 of file action_manager.cpp.

111 {
112  std::map<std::string, TOOL_ACTION*>::const_iterator it = m_actionNameIndex.find( aActionName );
113 
114  if( it != m_actionNameIndex.end() )
115  return it->second;
116 
117  return nullptr;
118 }
std::map< std::string, TOOL_ACTION * > m_actionNameIndex
Map for indexing actions by their hotkeys.

References m_actionNameIndex.

Referenced by TOOLS_HOLDER::PopTool(), TOOLS_HOLDER::PushTool(), TOOL_MANAGER::RunAction(), and TOOLS_HOLDER::ShowChangedLanguage().

◆ GetActionList()

static std::list<TOOL_ACTION*>& ACTION_MANAGER::GetActionList ( )
inlinestatic

Return list of TOOL_ACTIONs.

#TOOL_ACTIONs add themselves to the list upon their creation.

Returns
List of TOOL_ACTIONs.

Definition at line 151 of file action_manager.h.

152  {
153  static std::list<TOOL_ACTION*> actionList;
154 
155  return actionList;
156  }

Referenced by ACTION_MANAGER(), TOOL_ACTION::TOOL_ACTION(), and TOOL_ACTION::~TOOL_ACTION().

◆ GetActions()

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

Get a list of currently-registered actions mapped by their name.

Definition at line 231 of file action_manager.cpp.

232 {
233  return m_actionNameIndex;
234 }
std::map< std::string, TOOL_ACTION * > m_actionNameIndex
Map for indexing actions by their hotkeys.

References m_actionNameIndex.

Referenced by TOOL_MANAGER::GetActions().

◆ GetCondition()

const ACTION_CONDITIONS * ACTION_MANAGER::GetCondition ( const TOOL_ACTION aAction) const

Get the conditions to use for a specific tool action.

Parameters
aActionis the tool action.
Returns
the action conditions, returns nullptr if no conditions are registered.

Definition at line 90 of file action_manager.cpp.

91 {
92  const auto it = m_uiConditions.find( aAction.GetId() );
93 
94  // If the action doesn't have something registered, then return null
95  if( it == m_uiConditions.end() )
96  return nullptr;
97  else
98  return &it->second;
99 }
int GetId() const
Return the unique id of the TOOL_ACTION object.
Definition: tool_action.h:121
std::map< int, ACTION_CONDITIONS > m_uiConditions
Map the command ID that wx uses for the action to the UI conditions for the menu/toolbar items.

References TOOL_ACTION::GetId(), and m_uiConditions.

Referenced by ACTION_TOOLBAR::doSelectAction(), and RunHotKey().

◆ GetHotKey()

int ACTION_MANAGER::GetHotKey ( const TOOL_ACTION aAction) const

Return the hot key associated with a given action or 0 if there is none.

Parameters
aActionis the queried action.

Definition at line 237 of file action_manager.cpp.

238 {
239  std::map<int, int>::const_iterator it = m_hotkeys.find( aAction.GetId() );
240 
241  if( it == m_hotkeys.end() )
242  return 0;
243 
244  return it->second;
245 }
std::map< int, int > m_hotkeys
int GetId() const
Return the unique id of the TOOL_ACTION object.
Definition: tool_action.h:121

References TOOL_ACTION::GetId(), and m_hotkeys.

Referenced by TOOL_MANAGER::GetHotKey().

◆ MakeActionId()

int ACTION_MANAGER::MakeActionId ( const std::string &  aActionName)
static

Generate an unique ID from for an action with given name.

Definition at line 102 of file action_manager.cpp.

103 {
104  static int currentActionId = 1;
105 
106  return currentActionId++;
107 }

Referenced by ACTION_GROUP::ACTION_GROUP(), and ACTION_MANAGER().

◆ processHotKey()

int ACTION_MANAGER::processHotKey ( TOOL_ACTION aAction,
std::map< std::string, int >  aLegacyMap,
std::map< std::string, int >  aHotKeyMap 
)
private

Tool manager needed to run actions.

Definition at line 280 of file action_manager.cpp.

282 {
283  aAction->m_hotKey = aAction->m_defaultHotKey;
284 
285  if( !aAction->m_legacyName.empty() && aLegacyMap.count( aAction->m_legacyName ) )
286  aAction->SetHotKey( aLegacyMap[ aAction->m_legacyName ] );
287 
288  if( aHotKeyMap.count( aAction->m_name ) )
289  aAction->SetHotKey( aHotKeyMap[ aAction->m_name ] );
290 
291  return aAction->m_hotKey;
292 }
std::string m_name
Definition: tool_action.h:193
const std::string m_legacyName
Definition: tool_action.h:198
void SetHotKey(int aKeycode)
const int m_defaultHotKey
Definition: tool_action.h:196

References TOOL_ACTION::m_defaultHotKey, TOOL_ACTION::m_hotKey, TOOL_ACTION::m_legacyName, TOOL_ACTION::m_name, and TOOL_ACTION::SetHotKey().

Referenced by UpdateHotKeys().

◆ RegisterAction()

void ACTION_MANAGER::RegisterAction ( TOOL_ACTION aAction)

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

After that it is possible to invoke the action using hotkeys or sending a command event with its name.

Parameters
aActionaction to be added. Ownership is not transferred.

Definition at line 57 of file action_manager.cpp.

58 {
59  // TOOL_ACTIONs are supposed to be named [appName.]toolName.actionName (with dots between)
60  // action name without specifying at least toolName is not valid
61  wxASSERT( aAction->GetName().find( '.', 0 ) != std::string::npos );
62 
63  // TOOL_ACTIONs must have unique names & ids
64  wxASSERT( m_actionNameIndex.find( aAction->m_name ) == m_actionNameIndex.end() );
65 
66  m_actionNameIndex[aAction->m_name] = aAction;
67 }
std::string m_name
Definition: tool_action.h:193
std::map< std::string, TOOL_ACTION * > m_actionNameIndex
Map for indexing actions by their hotkeys.
const std::string & GetName() const
Return name of the action.
Definition: tool_action.h:101

References TOOL_ACTION::GetName(), m_actionNameIndex, and TOOL_ACTION::m_name.

Referenced by ACTION_MANAGER().

◆ RunHotKey()

bool ACTION_MANAGER::RunHotKey ( int  aHotKey) const

Run an action associated with a hotkey (if there is one available).

Parameters
aHotKeyis the hotkey to be handled.
Returns
True if there was an action associated with the hotkey, false otherwise.

Definition at line 121 of file action_manager.cpp.

122 {
123  int key = aHotKey & ~MD_MODIFIER_MASK;
124  int mod = aHotKey & MD_MODIFIER_MASK;
125 
126  if( key >= 'a' && key <= 'z' )
127  key = std::toupper( key );
128 
129  wxLogTrace( kicadTraceToolStack, "ACTION_MANAGER::RunHotKey Key: %s",
130  KeyNameFromKeyCode( aHotKey ) );
131 
132  HOTKEY_LIST::const_iterator it = m_actionHotKeys.find( key | mod );
133 
134  // If no luck, try without Shift, to handle keys that require it
135  // e.g. to get ? you need to press Shift+/ without US keyboard layout
136  // Hardcoding ? as Shift+/ is a bad idea, as on another layout you may need to press a
137  // different combination
138  if( it == m_actionHotKeys.end() )
139  {
140  wxLogTrace( kicadTraceToolStack,
141  "ACTION_MANAGER::RunHotKey No actions found, searching with key: %s",
142  KeyNameFromKeyCode( key | ( mod & ~MD_SHIFT ) ) );
143 
144  it = m_actionHotKeys.find( key | ( mod & ~MD_SHIFT ) );
145 
146  if( it == m_actionHotKeys.end() )
147  return false; // no appropriate action found for the hotkey
148  }
149 
150  const std::list<TOOL_ACTION*>& actions = it->second;
151 
152  // Choose the action that has the highest priority on the active tools stack
153  // If there is none, run the global action associated with the hot key
154  int highestPriority = -1, priority = -1;
155  const TOOL_ACTION* context = nullptr; // pointer to context action of the highest priority tool
156  std::vector<const TOOL_ACTION*> global; // pointers to global actions
157  // if there is no context action
158 
159  for( const TOOL_ACTION* action : actions )
160  {
161  if( action->GetScope() == AS_GLOBAL )
162  {
163  // Store the global action in case there are no context actions to run
164  global.emplace_back( action );
165  continue;
166  }
167 
168  TOOL_BASE* tool = m_toolMgr->FindTool( action->GetToolName() );
169 
170  if( tool )
171  {
172  // Choose the action that goes to the tool with highest priority
173  // (i.e. is on the top of active tools stack)
174  priority = m_toolMgr->GetPriority( tool->GetId() );
175 
176  if( priority >= 0 && priority > highestPriority )
177  {
178  highestPriority = priority;
179  context = action;
180  }
181  }
182  }
183 
184  // Get the selection to use to test if the action is enabled
186 
187  if( context )
188  {
189  bool runAction = true;
190 
191  if( const ACTION_CONDITIONS* aCond = GetCondition( *context ) )
192  runAction = aCond->enableCondition( sel );
193 
194  wxLogTrace( kicadTraceToolStack,
195  "ACTION_MANAGER::RunHotKey %s context action: %s for hotkey %s",
196  runAction ? "Running" : "Not running",
197  context->GetName(),
198  KeyNameFromKeyCode( aHotKey ) );
199 
200  if( runAction )
201  return m_toolMgr->RunAction( *context, true );
202  }
203  else if( !global.empty() )
204  {
205  for( auto act : global )
206  {
207  bool runAction = true;
208 
209  if( const ACTION_CONDITIONS* aCond = GetCondition( *act ) )
210  runAction = aCond->enableCondition( sel );
211 
212  wxLogTrace( kicadTraceToolStack,
213  "ACTION_MANAGER::RunHotKey %s global action: %s for hotkey %s",
214  runAction ? "Running" : "Not running",
215  act->GetName(),
216  KeyNameFromKeyCode( aHotKey ) );
217 
218  if( runAction && m_toolMgr->RunAction( *act, true ) )
219  return true;
220  }
221  }
222 
223  wxLogTrace( kicadTraceToolStack,
224  "ACTION_MANAGER::RunHotKey No action found for key %s",
225  KeyNameFromKeyCode( aHotKey ) );
226 
227  return false;
228 }
int GetPriority(int aToolId) const
Return priority of a given tool.
TOOL_ID GetId() const
Return the unique identifier of the tool.
Definition: tool_base.h:120
bool RunAction(const std::string &aActionName, bool aNow=false, T aParam=NULL)
Run the specified action.
Definition: tool_manager.h:143
TOOL_BASE * FindTool(int aId) const
Search for a tool with given ID.
HOTKEY_LIST m_actionHotKeys
Quick action<->hot key lookup.
TOOL_MANAGER * m_toolMgr
Map for indexing actions by their names.
TOOLS_HOLDER * GetToolHolder() const
Definition: tool_manager.h:294
virtual SELECTION & GetCurrentSelection()
Get the current selection from the canvas area.
Definition: tools_holder.h:101
Global action (toolbar/main menu event, global shortcut)
Functors that can be used to figure out how the action controls should be displayed in the UI and if ...
Base abstract interface for all kinds of tools.
Definition: tool_base.h:65
Represent a single user action.
Definition: tool_action.h:67
const wxChar *const kicadTraceToolStack
Flag to enable tracing of the tool handling stack.
const ACTION_CONDITIONS * GetCondition(const TOOL_ACTION &aAction) const
Get the conditions to use for a specific tool action.
wxString KeyNameFromKeyCode(int aKeycode, bool *aIsFound)
Return the key name from the key code.
const std::string & GetName() const
Return name of the action.
Definition: tool_action.h:101

References AS_GLOBAL, TOOL_MANAGER::FindTool(), GetCondition(), TOOLS_HOLDER::GetCurrentSelection(), TOOL_BASE::GetId(), TOOL_ACTION::GetName(), TOOL_MANAGER::GetPriority(), TOOL_MANAGER::GetToolHolder(), KeyNameFromKeyCode(), kicadTraceToolStack, m_actionHotKeys, m_toolMgr, MD_MODIFIER_MASK, MD_SHIFT, and TOOL_MANAGER::RunAction().

Referenced by TOOL_MANAGER::DispatchHotKey().

◆ SetConditions()

void ACTION_MANAGER::SetConditions ( const TOOL_ACTION aAction,
const ACTION_CONDITIONS aConditions 
)

Set the conditions the UI elements for activating a specific tool action should use for determining the current UI state (e.g.

checked, enabled, shown)

Parameters
aActionis the tool action using these conditions.
aConditionsare the conditions to use for the action.

Definition at line 70 of file action_manager.cpp.

72 {
73  // Remove any existing handlers with the old conditions to ensure the UI layer doesn't have
74  // stale data.
75  if( m_toolMgr )
77 
78  m_uiConditions[aAction.GetId()] = aConditions;
79 
80  wxLogTrace( kicadTraceToolStack,
81  "ACTION_MANAGER::SetConditions: Registering conditions for ID %d - %s",
82  aAction.GetId(), aAction.GetName() );
83 
84  // Register a new handler with the new conditions
85  if( m_toolMgr )
86  m_toolMgr->GetToolHolder()->RegisterUIUpdateHandler( aAction, aConditions );
87 }
virtual void UnregisterUIUpdateHandler(const TOOL_ACTION &aAction)
Unregister a UI handler for an action that was registered using RegisterUIUpdateHandler.
Definition: tools_holder.h:83
TOOL_MANAGER * m_toolMgr
Map for indexing actions by their names.
TOOLS_HOLDER * GetToolHolder() const
Definition: tool_manager.h:294
int GetId() const
Return the unique id of the TOOL_ACTION object.
Definition: tool_action.h:121
std::map< int, ACTION_CONDITIONS > m_uiConditions
Map the command ID that wx uses for the action to the UI conditions for the menu/toolbar items.
const wxChar *const kicadTraceToolStack
Flag to enable tracing of the tool handling stack.
virtual void RegisterUIUpdateHandler(const TOOL_ACTION &aAction, const ACTION_CONDITIONS &aConditions)
Register an action's update conditions with the UI layer to allow the UI to appropriately display the...
Definition: tools_holder.h:63
const std::string & GetName() const
Return name of the action.
Definition: tool_action.h:101

References TOOL_ACTION::GetId(), TOOL_ACTION::GetName(), TOOL_MANAGER::GetToolHolder(), kicadTraceToolStack, m_toolMgr, m_uiConditions, TOOLS_HOLDER::RegisterUIUpdateHandler(), and TOOLS_HOLDER::UnregisterUIUpdateHandler().

Referenced by FOOTPRINT_VIEWER_FRAME::setupUIConditions(), DISPLAY_FOOTPRINTS_FRAME::setupUIConditions(), EDA_3D_VIEWER_FRAME::setupUIConditions(), SYMBOL_VIEWER_FRAME::setupUIConditions(), KICAD_MANAGER_FRAME::setupUIConditions(), SCH_EDIT_FRAME::setupUIConditions(), PL_EDITOR_FRAME::setupUIConditions(), FOOTPRINT_EDIT_FRAME::setupUIConditions(), CVPCB_MAINFRAME::setupUIConditions(), SYMBOL_EDIT_FRAME::setupUIConditions(), GERBVIEW_FRAME::setupUIConditions(), and PCB_EDIT_FRAME::setupUIConditions().

◆ UpdateHotKeys()

void ACTION_MANAGER::UpdateHotKeys ( bool  aFullUpdate)

Optionally read the hotkey config files and then rebuilds the internal hotkey maps.

Definition at line 248 of file action_manager.cpp.

249 {
250  std::map<std::string, int> legacyHotKeyMap;
251  std::map<std::string, int> userHotKeyMap;
252 
253  m_actionHotKeys.clear();
254  m_hotkeys.clear();
255 
256  if( aFullUpdate && m_toolMgr->GetToolHolder() )
257  {
259  ReadHotKeyConfig( wxEmptyString, userHotKeyMap );
260  }
261 
262  for( const auto& ii : m_actionNameIndex )
263  {
264  TOOL_ACTION* action = ii.second;
265  int hotkey = 0;
266 
267  if( aFullUpdate )
268  hotkey = processHotKey( action, legacyHotKeyMap, userHotKeyMap );
269  else
270  hotkey = action->GetHotKey();
271 
272  if( hotkey > 0 )
273  m_actionHotKeys[hotkey].push_back( action );
274 
275  m_hotkeys[action->GetId()] = hotkey;
276  }
277 }
std::map< int, int > m_hotkeys
virtual wxString ConfigBaseName()
Definition: tools_holder.h:155
void ReadHotKeyConfig(const wxString &aFileName, std::map< std::string, int > &aHotKeys)
Reads a hotkey config file into a map.
int ReadLegacyHotkeyConfig(const wxString &aAppname, std::map< std::string, int > &aMap)
Read configuration data and fill the current hotkey list with hotkeys.
std::map< std::string, TOOL_ACTION * > m_actionNameIndex
Map for indexing actions by their hotkeys.
HOTKEY_LIST m_actionHotKeys
Quick action<->hot key lookup.
TOOL_MANAGER * m_toolMgr
Map for indexing actions by their names.
TOOLS_HOLDER * GetToolHolder() const
Definition: tool_manager.h:294
int GetId() const
Return the unique id of the TOOL_ACTION object.
Definition: tool_action.h:121
int processHotKey(TOOL_ACTION *aAction, std::map< std::string, int > aLegacyMap, std::map< std::string, int > aHotKeyMap)
Tool manager needed to run actions.
Represent a single user action.
Definition: tool_action.h:67
int GetHotKey() const
Return the hotkey keycode which initiates the action.
Definition: tool_action.h:111

References TOOLS_HOLDER::ConfigBaseName(), TOOL_ACTION::GetHotKey(), TOOL_ACTION::GetId(), TOOL_MANAGER::GetToolHolder(), m_actionHotKeys, m_actionNameIndex, m_hotkeys, m_toolMgr, processHotKey(), ReadHotKeyConfig(), and ReadLegacyHotkeyConfig().

Referenced by TOOLS_HOLDER::CommonSettingsChanged(), and TOOL_MANAGER::InitTools().

Member Data Documentation

◆ m_actionHotKeys

HOTKEY_LIST ACTION_MANAGER::m_actionHotKeys
private

Quick action<->hot key lookup.

Definition at line 189 of file action_manager.h.

Referenced by RunHotKey(), and UpdateHotKeys().

◆ m_actionNameIndex

std::map<std::string, TOOL_ACTION*> ACTION_MANAGER::m_actionNameIndex
private

Map for indexing actions by their hotkeys.

Definition at line 185 of file action_manager.h.

Referenced by FindAction(), GetActions(), RegisterAction(), and UpdateHotKeys().

◆ m_hotkeys

std::map<int, int> ACTION_MANAGER::m_hotkeys
private

Definition at line 192 of file action_manager.h.

Referenced by GetHotKey(), and UpdateHotKeys().

◆ m_toolMgr

TOOL_MANAGER* ACTION_MANAGER::m_toolMgr
private

Map for indexing actions by their names.

Definition at line 182 of file action_manager.h.

Referenced by RunHotKey(), SetConditions(), and UpdateHotKeys().

◆ m_uiConditions

std::map<int, ACTION_CONDITIONS> ACTION_MANAGER::m_uiConditions
private

Map the command ID that wx uses for the action to the UI conditions for the menu/toolbar items.

Definition at line 196 of file action_manager.h.

Referenced by GetCondition(), and SetConditions().


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