A binding is a link between user input and the triggering of a particular command. The most common example of a binding is a keyboard shortcut, but there are also mouse and gesture bindings.
Bindings are linked to particular conditions within the application. Some of these conditions change infrequently (e.g., locale, scheme), while some will tend to change quite frequently (e.g., context). This allows the bindings to be tailored to particular situations. For example, a set of bindings may be appropriate only inside a text editor. Or, perhaps, a set of bindings might be appropriate only for a given locale, such as bindings that coexist with the Input Method Editor (IME) on Chinese locales.
It is also possible to remove a particular binding. This is typically done as part of user configuration (e.g., user changing keyboard shortcuts). However, it can also be helpful when trying to change a binding on a particular locale or platform. An "unbinding" is really just a binding with no command identifier. For it to unbind a particular binding, it must match that binding in its context identifier and scheme identifier. Subclasses (e.g., KeyBinding
) may require other properties to match (e.g., keySequence
). If these properties match, then this is an unbinding. Note: the locale and platform can be different.
For example, imagine you have a key binding that looks like this:
KeyBinding(command, scheme, context, "Ctrl+Shift+F")
On GTK+, the "Ctrl+Shift+F" interferes with some native behaviour. To change the binding, we first unbind the "Ctrl+Shift+F" key sequence by assigning it a null command on the gtk platform. We then create a new binding that maps the command to the "Esc Ctrl+F" key sequence.
KeyBinding("Ctrl+Shift+F",null,scheme,context,null,gtk,null,SYSTEM) KeyBinding("Esc Ctrl+F",parameterizedCommand,scheme,context,null,gtk,SYSTEM)
Bindings are intended to be immutable objects.
@since 3.1