One of these objects holds a list of all the commands your app can perform, and despatches these commands when needed. More...
|Creates an ApplicationCommandManager. |
|Clears the current list of all commands. |
|void||registerCommand (const ApplicationCommandInfo &newCommand)|
|Adds a command to the list of registered commands. |
|void||registerAllCommandsForTarget (ApplicationCommandTarget *target)|
|Adds all the commands that this target publishes to the manager's list. |
|void||removeCommand (CommandID commandID)|
|Removes the command with a specified ID. |
|This should be called to tell the manager that one of its registered commands may have changed its active status. |
|int||getNumCommands () const noexcept|
|Returns the number of commands that have been registered. |
|const ApplicationCommandInfo *||getCommandForIndex (int index) const noexcept|
|Returns the details about one of the registered commands. |
|const ApplicationCommandInfo *||getCommandForID (CommandID commandID) const noexcept|
|Returns the details about a given command ID. |
|String||getNameOfCommand (CommandID commandID) const noexcept|
|Returns the name field for a command. |
|String||getDescriptionOfCommand (CommandID commandID) const noexcept|
|Returns the description field for a command. |
|StringArray||getCommandCategories () const|
|Returns the list of categories. |
|Array< CommandID >||getCommandsInCategory (const String &categoryName) const|
|Returns a list of all the command UIDs in a particular category. |
|KeyPressMappingSet *||getKeyMappings () const noexcept|
|Returns the manager's internal set of key mappings. |
|bool||invokeDirectly (CommandID commandID, bool asynchronously)|
|Invokes the given command directly, sending it to the default target. |
|bool||invoke (const ApplicationCommandTarget::InvocationInfo &invocationInfo, bool asynchronously)|
|Sends a command to the default target. |
|virtual ApplicationCommandTarget *||getFirstCommandTarget (CommandID commandID)|
|Chooses the ApplicationCommandTarget to which a command should be sent. |
|void||setFirstCommandTarget (ApplicationCommandTarget *newTarget) noexcept|
|Sets a target to be returned by getFirstCommandTarget(). |
|ApplicationCommandTarget *||getTargetForCommand (CommandID commandID, ApplicationCommandInfo &upToDateInfo)|
|Tries to find the best target to use to perform a given command. |
|void||addListener (ApplicationCommandManagerListener *listener)|
|Registers a listener that will be called when various events occur. |
|void||removeListener (ApplicationCommandManagerListener *listener)|
|Deregisters a previously-added listener. |
|static ApplicationCommandTarget *||findDefaultComponentTarget ()|
|Looks for a suitable command target based on which Components have the keyboard focus. |
|static ApplicationCommandTarget *||findTargetForComponent (Component *)|
|Examines this component and all its parents in turn, looking for the first one which is an ApplicationCommandTarget. |
|Private Member Functions inherited from AsyncUpdater|
|Creates an AsyncUpdater object. |
|Causes the callback to be triggered at a later time. |
|void||cancelPendingUpdate () noexcept|
|This will stop any pending updates from happening. |
|If an update has been triggered and is pending, this will invoke it synchronously. |
|bool||isUpdatePending () const noexcept|
|Returns true if there's an update callback in the pipeline. |
|Private Member Functions inherited from FocusChangeListener|
One of these objects holds a list of all the commands your app can perform, and despatches these commands when needed.
Application commands are a good way to trigger actions in your app, e.g. "Quit", "Copy", "Paste", etc. Menus, buttons and keypresses can all be given commands to invoke automatically, which means you don't have to handle the result of a menu or button click manually. Commands are despatched to ApplicationCommandTarget objects which can choose which events they want to handle.
This architecture also allows for nested ApplicationCommandTargets, so that for example you could have two different objects, one inside the other, both of which can respond to a "delete" command. Depending on which one has focus, the command will be sent to the appropriate place, regardless of whether it was triggered by a menu, keypress or some other method.
To set up your app to use commands, you'll need to do the following:
When a command is invoked, the ApplicationCommandManager will try to choose the best ApplicationCommandTarget to receive the specified command. To do this it will use the current keyboard focus to see which component might be interested, and will search the component hierarchy for those that also implement the ApplicationCommandTarget interface. If an ApplicationCommandTarget isn't interested in the command that is being invoked, then the next one in line will be tried (see the ApplicationCommandTarget::getNextCommandTarget() method), and so on until ApplicationCommandTarget::getNextCommandTarget() returns nullptr. At this point if the command still hasn't been performed, it will be passed to the current JUCEApplication object (which is itself an ApplicationCommandTarget).
To exert some custom control over which ApplicationCommandTarget is chosen to invoke a command, you can override the ApplicationCommandManager::getFirstCommandTarget() method and choose the object yourself.
Creates an ApplicationCommandManager.
Once created, you'll need to register all your app's commands with it, using ApplicationCommandManager::registerAllCommandsForTarget() or ApplicationCommandManager::registerCommand().
Make sure that you don't delete this if pointers to it are still being used by objects such as PopupMenus or Buttons.
Clears the current list of all commands.
Note that this will also clear the contents of the KeyPressMappingSet.
|void ApplicationCommandManager::registerCommand||(||const ApplicationCommandInfo &||newCommand||)|
Adds a command to the list of registered commands.
|void ApplicationCommandManager::registerAllCommandsForTarget||(||ApplicationCommandTarget *||target||)|
Adds all the commands that this target publishes to the manager's list.
This will use ApplicationCommandTarget::getAllCommands() and ApplicationCommandTarget::getCommandInfo() to get details about all the commands that this target can do, and will call registerCommand() to add each one to the manger's list.
Removes the command with a specified ID.
Note that this will also remove any key mappings that are mapped to the command.
This should be called to tell the manager that one of its registered commands may have changed its active status.
Because the command manager only finds out whether a command is active or inactive by querying the current ApplicationCommandTarget, this is used to tell it that things may have changed. It allows things like buttons to update their enablement, etc.
This method will cause an asynchronous call to ApplicationCommandManagerListener::applicationCommandListChanged() for any registered listeners.
Returns the number of commands that have been registered.
Returns the details about one of the registered commands.
The index is between 0 and (getNumCommands() - 1).
Returns the details about a given command ID.
This will search the list of registered commands for one with the given command ID number, and return its associated info. If no matching command is found, this will return nullptr.
Returns the name field for a command.
An empty string is returned if no command with this ID has been registered.
Returns the description field for a command.
An empty string is returned if no command with this ID has been registered. If the command has no description, this will return its short name field instead.
|Array<CommandID> ApplicationCommandManager::getCommandsInCategory||(||const String &||categoryName||)||const|
Returns a list of all the command UIDs in a particular category.
Invokes the given command directly, sending it to the default target.
This is just an easy way to call invoke() without having to fill out the InvocationInfo structure.
|bool ApplicationCommandManager::invoke||(||const ApplicationCommandTarget::InvocationInfo &||invocationInfo,|
Sends a command to the default target.
This will choose a target using getFirstCommandTarget(), and send the specified command to it using the ApplicationCommandTarget::invoke() method. This means that if the first target can't handle the command, it will be passed on to targets further down the chain (see ApplicationCommandTarget::invoke() for more info).
|invocationInfo||this must be correctly filled-in, describing the context for the invocation.|
|asynchronously||if false, the command will be performed before this method returns. If true, a message will be posted so that the command will be performed later on the message thread, and this method will return immediately.|
Chooses the ApplicationCommandTarget to which a command should be sent.
Whenever the manager needs to know which target a command should be sent to, it calls this method to determine the first one to try.
If you need to make sure all commands go via your own custom target, then you can either use setFirstCommandTarget() to specify a single target, or override this method if you need more complex logic to choose one.
It may return nullptr if no targets are available.
Tries to find the best target to use to perform a given command.
This will call getFirstCommandTarget() to find the preferred target, and will check whether that target can handle the given command. If it can't, then it'll use ApplicationCommandTarget::getNextCommandTarget() to find the next one to try, and so on until no more are available.
If no targets are found that can perform the command, this method will return nullptr.
If a target is found, then it will get the target to fill-in the upToDateInfo structure with the latest info about that command, so that the caller can see whether the command is disabled, ticked, etc.
|void ApplicationCommandManager::addListener||(||ApplicationCommandManagerListener *||listener||)|
Registers a listener that will be called when various events occur.
|void ApplicationCommandManager::removeListener||(||ApplicationCommandManagerListener *||listener||)|
Deregisters a previously-added listener.
Looks for a suitable command target based on which Components have the keyboard focus.
This is used by the default implementation of ApplicationCommandTarget::getFirstCommandTarget(), but is exposed here in case it's useful.