This chapter describes in detail how GTK uses actions to connect
activatable UI elements to callbacks. GTK inherits the underlying
GMenu for describing abstract actions
and menus from the GIO library.
GAction is essentially a way to tell the toolkit about a piece of
functionality in your program, and to give it a name.
Actions are purely functional. They do not contain any presentational information.
An action has four pieces of information associated with it:
- a name as an identifier (usually all-lowercase, untranslated English string)
- an enabled flag indicating if the action can be activated or not (like the “sensitive” property on widgets)
- an optional state value, for stateful actions (like a boolean for toggles)
- an optional parameter type, used when activating the action
An action supports two operations. You can activate it, which requires passing a parameter of the correct type And you can request to change the actions state (for stateful actions) to a new state value of the correct type.
Here are some rules about an action:
- the name is immutable (in the sense that it will never change) and
it is never
- the enabled flag can change
- the parameter type is immutable
- the parameter type is optional: it can be
- if the parameter type is
NULLthen action activation must be done without a parameter (ie: a
- if the parameter type is non-
NULLthen the parameter must have this type
- the state can change, but it cannot change type
- if the action was stateful when it was created, it will always have a state and it will always have exactly the same type (such as boolean or string)
- if the action was stateless when it was created, it can never have a state
- you can only request state changes on stateful actions and it is only possible to request that the state change to a value of the same type as the existing state
An action does not have any sort of presentational information such as a label, an icon or a way of creating a widget from it.
Most actions in your application will be stateless actions with no parameters. These typically appear as menu items with no special decoration. An example is “quit”.
Stateful actions are used to represent an action which has a closely-associated state of some kind. A good example is a “fullscreen” action. For this case, you would expect to see a checkmark next to the menu item when the fullscreen option is active. This is usually called a toggle action, and it has a boolean state. By convention, toggle actions have no parameter type for activation: activating the action always toggles the state.
Another common case is to have an action representing a enumeration of possible values of a given type (typically string). This is often called a radio action and is usually represented in the user interface with radio buttons or radio menu items, or sometimes a combobox. A good example is “text-justify” with possible values “left”, “center”, and “right”. By convention, these types of actions have a parameter type equal to their state type, and activating them with a particular parameter value is equivalent to changing their state to that value.
This approach to handling radio buttons is different than many other
action systems such as
GAction, there is only one action
for “text-justify” and “left”, “center” and “right” are possible states on
that action. There are not three separate “justify-left”, “justify-center”
and “justify-right” actions.
The final common type of action is a stateless action with a parameter. This is typically used for actions like “open-bookmark” where the parameter to the action would be the identifier of the bookmark to open.
Because some types of actions cannot be invoked without a parameter, it is often important to specify a parameter when referring to the action from a place where it will be invoked (such as from a radio button that sets the state to a particular value or from a menu item that opens a specific bookmark). In these contexts, the value used for the action parameter is typically called the target of the action.
Even though toggle actions have a state, they do not have a parameter. Therefore, a target value is not needed when referring to them — they will always be toggled on activation.
Most APIs that allow using a
GAction (such as
allow use of detailed action names. This is a convenient way of specifying
an action name and an action target with a single string.
In the case that the action target is a string with no unusual characters (ie: only alphanumeric, plus ‘-‘ and ‘.’) then you can use a detailed action name of the form “justify::left” to specify the justify action with a target of left.
In the case that the action target is not a string, or contains unusual characters, you can use the more general format “action-name(5)”, where the “5” here is any valid text-format GVariant (ie: a string that can be parsed by g_variant_parse()). Another example is “open-bookmark(‘http://gnome.org/’)”.
You can convert between detailed action names and split-out action names
and target values using
g_action_print_detailed_name() but usually you will not need to. Most APIs
will provide both ways of specifying actions with targets.
Actions are always scoped to a particular object on which they operate.
In GTK, actions are typically scoped to either an application or a window, but any widget can have actions associated with it.
Actions scoped to windows should be the actions that specifically impact that window. These are actions like “fullscreen” and “close”, or in the case that a window contains a document, “save” and “print”.
Actions that impact the application as a whole rather than one specific window are scoped to the application. These are actions like “about” and “preferences”.
If a particular action is scoped to a window then it is scoped to a specific window. Another way of saying this: if your application has a “fullscreen” action that applies to windows and it has three windows, then it will have three fullscreen actions: one for each window.
Having a separate action per-window allows for each window to have a separate state for each instance of the action as well as being able to control the enabled state of the action on a per-window basis.
Actions are added to their relevant scope (application, window or widget)
either using the
GActionMap interface, or by using
gtk_widget_insert_action_group(). Actions that will be the same for all
instances of a widget class can be added globally using gtk_widget_class_install_action().
Actions rarely occurs in isolation. It is common to have groups
of related actions, which are represented by instances of the
Action maps are a variant of action groups that allow to change the name of the action as it is looked up. In GTK, the convention is to add a prefix to the action name to indicate the scope of the actions, such as “app.” for the actions with application scope or “win.” for those with window scope.
When referring to actions on a GActionMap only the name of the
action itself is used (ie: “quit”, not “app.quit”). The
“app.quit” form is only used when referring to actions from
places like a
GtkActionable widget where the scope
of the action is not already known.
GtkApplicationWindow implement the
interface, so you can just add actions directly to them. For
other widgets, use
gtk_widget_insert_action_group() to add
actions to it.
If you want to insert several actions at the same time, it is
typically faster and easier to use
Any widget that implements the
GtkActionable interface can
be connected to an action just by setting the ::action-name
property. If the action has a parameter, you will also need
to set the ::action-target property. Widgets that implement
GtkButton, and their
Another way of obtaining widgets that are connected to actions
is to create a menu using a
GMenu menu model.
GMenu provides an
abstract way to describe typical menus: nested groups of items
where each item can have a label, and icon, and an action.
A typical use of
GMenu inside GTK is to set up an application
menubar with gtk_application_set_menubar(). Another, maybe more
common use is to create a popover for a menubutton, using gtk_menu_button_set_menu_model().
Unlike traditional menus, those created from menu models don’t
have keyboard accelerators associated with menu items. Instead,
GtkApplication offers the
API to associate keyboard shortcuts with actions.
When a widget with a connected action is activated, GTK finds
the action to activate by walking up the widget hierarchy,
looking for a matching action, ending up at the
GTK uses actions for its own purposes in a number places. These built-in actions can sometimes be activated by applications, and you should avoid naming conflicts with them when creating your own actions.
- Activates the default widget in a context (typically a
- clipboard.cut, clipboard.copy, clipboard.paste
- Clipboard operations on entries, text view and labels, typically used in the context menu
- selection.delete, selection.select-all
- Selection operations on entries, text view and labels
- color.select, color.customize:
- Operate on colors in a
GtkColorChooserWidget. These actions are unusual in that they have the non-trivial parameter type (dddd):