KiCad PCB EDA Suite
ACTION_MANAGER Class Reference

Class ACTION_MANAGER. More...

#include <action_manager.h>

Public Member Functions

 ACTION_MANAGER (TOOL_MANAGER *aToolManager)
 Constructor. More...
 
 ~ACTION_MANAGER ()
 Destructor. More...
 
void RegisterAction (TOOL_ACTION *aAction)
 Function RegisterAction() Adds a tool action to the manager and sets it up. More...
 
void UnregisterAction (TOOL_ACTION *aAction)
 Function UnregisterAction() Removes a tool action from the manager and makes it unavailable for further usage. More...
 
TOOL_ACTIONFindAction (const std::string &aActionName) const
 Function FindAction() Finds an action with a given name (if there is one available). More...
 
bool RunHotKey (int aHotKey) const
 Function RunHotKey() Runs an action associated with a hotkey (if there is one available). More...
 
int GetHotKey (const TOOL_ACTION &aAction) const
 Function GetHotKey() Returns the hot key associated with a given action or 0 if there is none. More...
 
void UpdateHotKeys ()
 Function UpdateHotKeys() Updates TOOL_ACTIONs hot key assignment according to the current frame's Hot Key Editor settings. More...
 

Static Public Member Functions

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

Private Types

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

Map for indexing actions by their hotkeys

More...
 

Private Member Functions

int processHotKey (TOOL_ACTION *aAction)
 

Resolves a reference to legacy hot key settings to a particular hot key.

More...
 

Private Attributes

TOOL_MANAGERm_toolMgr
 

Tool manager needed to run actions

More...
 
std::map< std::string, TOOL_ACTION * > m_actionNameIndex
 

Map for indexing actions by their names

More...
 
HOTKEY_LIST m_actionHotKeys
 
std::map< int, int > m_hotkeys
 

Quick action<->hot key lookup

More...
 

Detailed Description

Class ACTION_MANAGER.

Takes care of TOOL_ACTION objects. Registers them and allows to run them using associated hot keys, names or ids.

Definition at line 42 of file action_manager.h.

Member Typedef Documentation

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

Map for indexing actions by their hotkeys

Definition at line 131 of file action_manager.h.

Constructor & Destructor Documentation

ACTION_MANAGER::ACTION_MANAGER ( TOOL_MANAGER aToolManager)

Constructor.

Parameters
aToolManageris a tool manager instance that is used to pass events to tools.

Definition at line 33 of file action_manager.cpp.

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

33  :
34  m_toolMgr( aToolManager )
35 {
36  // Register known actions
37  std::list<TOOL_ACTION*>& actionList = GetActionList();
38 
39  for( TOOL_ACTION* action : actionList )
40  {
41  if( action->m_id == -1 )
42  action->m_id = MakeActionId( action->m_name );
43 
44  RegisterAction( new TOOL_ACTION( *action ) );
45  }
46 }
static int MakeActionId(const std::string &aActionName)
Generates an unique ID from for an action with given name.
static std::list< TOOL_ACTION * > & GetActionList()
Function GetActionList() Returns list of TOOL_ACTIONs.
TOOL_MANAGER * m_toolMgr
Tool manager needed to run actions
void RegisterAction(TOOL_ACTION *aAction)
Function RegisterAction() Adds a tool action to the manager and sets it up.
Class TOOL_ACTION.
Definition: tool_action.h:46
ACTION_MANAGER::~ACTION_MANAGER ( )

Destructor.

Unregisters every registered action.

Definition at line 49 of file action_manager.cpp.

References m_actionNameIndex, and UnregisterAction().

50 {
51  while( !m_actionNameIndex.empty() )
52  {
53  TOOL_ACTION* action = m_actionNameIndex.begin()->second;
54  UnregisterAction( action );
55  delete action;
56  }
57 }
void UnregisterAction(TOOL_ACTION *aAction)
Function UnregisterAction() Removes a tool action from the manager and makes it unavailable for furth...
std::map< std::string, TOOL_ACTION * > m_actionNameIndex
Map for indexing actions by their names
Class TOOL_ACTION.
Definition: tool_action.h:46

Member Function Documentation

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

Function FindAction() Finds 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 99 of file action_manager.cpp.

References m_actionNameIndex.

Referenced by TOOL_MANAGER::RunAction().

100 {
101  std::map<std::string, TOOL_ACTION*>::const_iterator it = m_actionNameIndex.find( aActionName );
102 
103  if( it != m_actionNameIndex.end() )
104  return it->second;
105 
106  return NULL;
107 }
std::map< std::string, TOOL_ACTION * > m_actionNameIndex
Map for indexing actions by their names
static std::list<TOOL_ACTION*>& ACTION_MANAGER::GetActionList ( )
inlinestatic

Function GetActionList() Returns list of TOOL_ACTIONs.

TOOL_ACTIONs add themselves to the list upon their creation.

Returns
List of TOOL_ACTIONs.

Definition at line 112 of file action_manager.h.

References processHotKey().

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

113  {
114  static std::list<TOOL_ACTION*> actionList;
115 
116  return actionList;
117  }
int ACTION_MANAGER::GetHotKey ( const TOOL_ACTION aAction) const

Function GetHotKey() Returns the hot key associated with a given action or 0 if there is none.

Parameters
aActionis the queried action.

Definition at line 182 of file action_manager.cpp.

References TOOL_ACTION::GetId(), and m_hotkeys.

Referenced by TOOL_MANAGER::GetHotKey(), and UnregisterAction().

183 {
184  std::map<int, int>::const_iterator it = m_hotkeys.find( aAction.GetId() );
185 
186  if( it == m_hotkeys.end() )
187  return 0;
188 
189  return it->second;
190 }
std::map< int, int > m_hotkeys
Quick action<->hot key lookup
int GetId() const
Function GetId() Returns the unique id of the TOOL_ACTION object.
Definition: tool_action.h:85
int ACTION_MANAGER::MakeActionId ( const std::string &  aActionName)
static

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

Definition at line 91 of file action_manager.cpp.

Referenced by ACTION_MANAGER().

92 {
93  static int currentActionId = 1;
94 
95  return currentActionId++;
96 }
int ACTION_MANAGER::processHotKey ( TOOL_ACTION aAction)
private

Resolves a reference to legacy hot key settings to a particular hot key.

Parameters
aActionis the action to be resolved.

Definition at line 228 of file action_manager.cpp.

References TOOL_ACTION::getDefaultHotKey(), TOOL_MANAGER::GetEditFrame(), GR_KB_ALT, GR_KB_CTRL, GR_KB_SHIFT, TOOL_ACTION::LEGACY_HK, EDA_HOTKEY::m_KeyCode, m_toolMgr, MD_ALT, MD_CTRL, and MD_SHIFT.

Referenced by GetActionList(), and UpdateHotKeys().

229 {
230  int hotkey = aAction->getDefaultHotKey();
231 
232  if( ( hotkey & TOOL_ACTION::LEGACY_HK ) )
233  {
234  hotkey = hotkey & ~TOOL_ACTION::LEGACY_HK; // it leaves only HK_xxx identifier
235 
236  auto frame = dynamic_cast<EDA_DRAW_FRAME*>( m_toolMgr->GetEditFrame() );
237  EDA_HOTKEY* hk_desc = nullptr;
238 
239  if( frame )
240  hk_desc = frame->GetHotKeyDescription( hotkey );
241 
242  if( hk_desc )
243  {
244  hotkey = hk_desc->m_KeyCode;
245 
246  // Convert modifiers to the ones used by the Tool Framework
247  if( hotkey & GR_KB_CTRL )
248  {
249  hotkey &= ~GR_KB_CTRL;
250  hotkey |= MD_CTRL;
251  }
252 
253  if( hotkey & GR_KB_ALT )
254  {
255  hotkey &= ~GR_KB_ALT;
256  hotkey |= MD_ALT;
257  }
258 
259  if( hotkey & GR_KB_SHIFT )
260  {
261  hotkey &= ~GR_KB_SHIFT;
262  hotkey |= MD_SHIFT;
263  }
264  }
265  else
266  {
267  hotkey = 0;
268  }
269  }
270 
271  return hotkey;
272 }
wxWindow * GetEditFrame() const
Definition: tool_manager.h:267
Class EDA_DRAW_FRAME is the base class for create windows for drawing purpose.
Definition: draw_frame.h:63
#define GR_KB_ALT
Definition: common.h:65
#define GR_KB_SHIFT
Definition: common.h:66
static const int LEGACY_HK
Flag to determine the hot key settings is not a particular key, but a reference to legacy hot key set...
Definition: tool_action.h:220
TOOL_MANAGER * m_toolMgr
Tool manager needed to run actions
class EDA_HOTKEY is a class to handle hot key commands.
Definition: hotkeys_basic.h:59
Class TOOL_ACTION.
Definition: tool_action.h:46
int getDefaultHotKey()
Returns the hot key assigned in the object definition.
Definition: tool_action.h:186
#define GR_KB_CTRL
Definition: common.h:64
void ACTION_MANAGER::RegisterAction ( TOOL_ACTION aAction)

Function RegisterAction() Adds a tool action to the manager and sets it up.

After that is 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 60 of file action_manager.cpp.

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

Referenced by ACTION_MANAGER(), and TOOL_MANAGER::RegisterAction().

61 {
62  // TOOL_ACTIONs are supposed to be named [appName.]toolName.actionName (with dots between)
63  // action name without specifying at least toolName is not valid
64  wxASSERT( aAction->GetName().find( '.', 0 ) != std::string::npos );
65 
66  // TOOL_ACTIONs must have unique names & ids
67  wxASSERT( m_actionNameIndex.find( aAction->m_name ) == m_actionNameIndex.end() );
68 
69  m_actionNameIndex[aAction->m_name] = aAction;
70 }
std::string m_name
Name of the action (convention is: app.[tool.]action.name)
Definition: tool_action.h:192
std::map< std::string, TOOL_ACTION * > m_actionNameIndex
Map for indexing actions by their names
const std::string & GetName() const
Function GetName() Returns name of the action.
Definition: tool_action.h:73
bool ACTION_MANAGER::RunHotKey ( int  aHotKey) const

Function RunHotKey() Runs 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 110 of file action_manager.cpp.

References AS_GLOBAL, TOOL_MANAGER::FindTool(), TOOL_BASE::GetId(), TOOL_MANAGER::GetPriority(), m_actionHotKeys, m_toolMgr, MD_MODIFIER_MASK, MD_SHIFT, mod, and TOOL_MANAGER::RunAction().

Referenced by TOOL_MANAGER::dispatchStandardEvents().

111 {
112  int key = aHotKey & ~MD_MODIFIER_MASK;
113  int mod = aHotKey & MD_MODIFIER_MASK;
114 
115  if( key >= 'a' && key <= 'z' )
116  key = std::toupper( key );
117 
118  HOTKEY_LIST::const_iterator it = m_actionHotKeys.find( key | mod );
119 
120  // If no luck, try without Shift, to handle keys that require it
121  // e.g. to get ? you need to press Shift+/ without US keyboard layout
122  // Hardcoding ? as Shift+/ is a bad idea, as on another layout you may need to press a
123  // different combination
124  if( it == m_actionHotKeys.end() )
125  {
126  it = m_actionHotKeys.find( key | ( mod & ~MD_SHIFT ) );
127 
128  if( it == m_actionHotKeys.end() )
129  return false; // no appropriate action found for the hotkey
130  }
131 
132  const std::list<TOOL_ACTION*>& actions = it->second;
133 
134  // Choose the action that has the highest priority on the active tools stack
135  // If there is none, run the global action associated with the hot key
136  int highestPriority = -1, priority = -1;
137  const TOOL_ACTION* context = NULL; // pointer to context action of the highest priority tool
138  const TOOL_ACTION* global = NULL; // pointer to global action, if there is no context action
139 
140  for( const TOOL_ACTION* action : actions )
141  {
142  if( action->GetScope() == AS_GLOBAL )
143  {
144  // Store the global action for the hot key in case there was no possible
145  // context actions to run
146  wxASSERT( global == NULL ); // there should be only one global action per hot key
147  global = action;
148  continue;
149  }
150 
151  TOOL_BASE* tool = m_toolMgr->FindTool( action->GetToolName() );
152 
153  if( tool )
154  {
155  // Choose the action that goes to the tool with highest priority
156  // (i.e. is on the top of active tools stack)
157  priority = m_toolMgr->GetPriority( tool->GetId() );
158 
159  if( priority >= 0 && priority > highestPriority )
160  {
161  highestPriority = priority;
162  context = action;
163  }
164  }
165  }
166 
167  if( context )
168  {
169  m_toolMgr->RunAction( *context, true );
170  return true;
171  }
172  else if( global )
173  {
174  m_toolMgr->RunAction( *global, true );
175  return true;
176  }
177 
178  return false;
179 }
TOOL_BASE * FindTool(int aId) const
Function FindTool() Searches for a tool with given ID.
bool RunAction(const std::string &aActionName, bool aNow=false, T aParam=NULL)
Function RunAction() Runs the specified action.
Definition: tool_manager.h:125
int GetPriority(int aToolId) const
Returns priority of a given tool.
TOOL_ID GetId() const
Function GetId() Returns the unique identifier of the tool.
Definition: tool_base.h:122
All active tools
Definition: tool_event.h:138
HOTKEY_LIST m_actionHotKeys
TOOL_MANAGER * m_toolMgr
Tool manager needed to run actions
Class TOOL_BASE.
Definition: tool_base.h:68
Class TOOL_ACTION.
Definition: tool_action.h:46
#define mod(a, n)
Definition: greymap.cpp:24
void ACTION_MANAGER::UnregisterAction ( TOOL_ACTION aAction)

Function UnregisterAction() Removes a tool action from the manager and makes it unavailable for further usage.

Parameters
aActionaction to be removed.

Definition at line 73 of file action_manager.cpp.

References GetHotKey(), m_actionHotKeys, m_actionNameIndex, and TOOL_ACTION::m_name.

Referenced by TOOL_MANAGER::UnregisterAction(), and ~ACTION_MANAGER().

74 {
75  m_actionNameIndex.erase( aAction->m_name );
76  int hotkey = GetHotKey( *aAction );
77 
78  if( hotkey )
79  {
80  std::list<TOOL_ACTION*>& actions = m_actionHotKeys[hotkey];
81  std::list<TOOL_ACTION*>::iterator action = std::find( actions.begin(), actions.end(), aAction );
82 
83  if( action != actions.end() )
84  actions.erase( action );
85  else
86  wxASSERT( false );
87  }
88 }
std::string m_name
Name of the action (convention is: app.[tool.]action.name)
Definition: tool_action.h:192
int GetHotKey(const TOOL_ACTION &aAction) const
Function GetHotKey() Returns the hot key associated with a given action or 0 if there is none...
std::map< std::string, TOOL_ACTION * > m_actionNameIndex
Map for indexing actions by their names
HOTKEY_LIST m_actionHotKeys
void ACTION_MANAGER::UpdateHotKeys ( )

Function UpdateHotKeys() Updates TOOL_ACTIONs hot key assignment according to the current frame's Hot Key Editor settings.

Definition at line 193 of file action_manager.cpp.

References AS_GLOBAL, TOOL_ACTION::GetId(), TOOL_ACTION::GetScope(), m_actionHotKeys, m_actionNameIndex, m_hotkeys, and processHotKey().

Referenced by TOOL_MANAGER::SetEnvironment(), and TOOL_MANAGER::UpdateHotKeys().

194 {
195  m_actionHotKeys.clear();
196  m_hotkeys.clear();
197 
198  for( const auto& actionName : m_actionNameIndex )
199  {
200  TOOL_ACTION* action = actionName.second;
201  int hotkey = processHotKey( action );
202 
203  if( hotkey > 0 )
204  {
205  m_actionHotKeys[hotkey].push_back( action );
206  m_hotkeys[action->GetId()] = hotkey;
207  }
208  }
209 
210 #ifdef DEBUG
211  // Check if there are two global actions assigned to the same hotkey
212  for( const auto& action_list : m_actionHotKeys )
213  {
214  int global_actions_cnt = 0;
215 
216  for( const TOOL_ACTION* action : action_list.second )
217  {
218  if( action->GetScope() == AS_GLOBAL )
219  ++global_actions_cnt;
220  }
221 
222  wxASSERT( global_actions_cnt <= 1 );
223  }
224 #endif /* not NDEBUG */
225 }
std::map< int, int > m_hotkeys
Quick action<->hot key lookup
TOOL_ACTION_SCOPE GetScope() const
Definition: tool_action.h:134
All active tools
Definition: tool_event.h:138
std::map< std::string, TOOL_ACTION * > m_actionNameIndex
Map for indexing actions by their names
int processHotKey(TOOL_ACTION *aAction)
Resolves a reference to legacy hot key settings to a particular hot key.
HOTKEY_LIST m_actionHotKeys
Class TOOL_ACTION.
Definition: tool_action.h:46
int GetId() const
Function GetId() Returns the unique id of the TOOL_ACTION object.
Definition: tool_action.h:85

Member Data Documentation

HOTKEY_LIST ACTION_MANAGER::m_actionHotKeys
private

Definition at line 132 of file action_manager.h.

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

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

Map for indexing actions by their names

Definition at line 128 of file action_manager.h.

Referenced by FindAction(), RegisterAction(), UnregisterAction(), UpdateHotKeys(), and ~ACTION_MANAGER().

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

Quick action<->hot key lookup

Definition at line 135 of file action_manager.h.

Referenced by GetHotKey(), and UpdateHotKeys().

TOOL_MANAGER* ACTION_MANAGER::m_toolMgr
private

Tool manager needed to run actions

Definition at line 125 of file action_manager.h.

Referenced by processHotKey(), and RunHotKey().


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