| Top |
Accelerator GroupsAccelerator Groups — Groups of global keyboard accelerators for an entire GtkWindow |
| struct | GtkAccelGroup |
| struct | GtkAccelGroupClass |
| enum | GtkAccelFlags |
| struct | GtkAccelKey |
A GtkAccelGroup represents a group of keyboard accelerators,
typically attached to a toplevel GtkWindow (with
gtk_window_add_accel_group()
). Usually you won’t need to create a
GtkAccelGroup directly; instead, when using GtkUIManager, GTK+
automatically sets up the accelerators for your menus in the ui
manager’s GtkAccelGroup.
Note that “accelerators” are different from
“mnemonics”. Accelerators are shortcuts for
activating a menu item; they appear alongside the menu item they’re a
shortcut for. For example “Ctrl+Q” might appear alongside the “Quit”
menu item. Mnemonics are shortcuts for GUI elements such as text
entries or buttons; they appear as underlined characters. See
gtk_label_new_with_mnemonic()
. Menu items can have both accelerators
and mnemonics, of course.
void gtk_accel_group_connect (GtkAccelGroup *accel_group
,guint accel_key
,GdkModifierType accel_mods
,GtkAccelFlags accel_flags
,GClosure *closure
);
Installs an accelerator in this group. When accel_group
is being
activated in response to a call to gtk_accel_groups_activate()
,
closure
will be invoked if the accel_key
and accel_mods
from
gtk_accel_groups_activate()
match those of this connection.
The signature used for the closure
is that of GtkAccelGroupActivate.
Note that, due to implementation details, a single closure can only be connected to one accelerator group.
void gtk_accel_group_connect_by_path (GtkAccelGroup *accel_group
,const gchar *accel_path
,GClosure *closure
);
Installs an accelerator in this group, using an accelerator path
to look up the appropriate key and modifiers (see
gtk_accel_map_add_entry()
). When accel_group
is being activated
in response to a call to gtk_accel_groups_activate()
, closure
will
be invoked if the accel_key
and accel_mods
from
gtk_accel_groups_activate()
match the key and modifiers for the path.
The signature used for the closure
is that of GtkAccelGroupActivate.
Note that accel_path
string will be stored in a GQuark. Therefore,
if you pass a static string, you can save some memory by interning it
first with g_intern_static_string()
.
gboolean (*GtkAccelGroupActivate) (GtkAccelGroup *accel_group
,GObject *acceleratable
,guint keyval
,GdkModifierType modifier
);
gboolean (*GtkAccelGroupFindFunc) (GtkAccelKey *key
,GClosure *closure
,gpointer data
);
Since: 2.2
gboolean gtk_accel_group_disconnect (GtkAccelGroup *accel_group
,GClosure *closure
);
Removes an accelerator previously installed through
gtk_accel_group_connect()
.
Since 2.20 closure
can be NULL
.
accel_group |
the accelerator group to remove an accelerator from |
|
closure |
the closure to remove from this accelerator
group, or |
[allow-none] |
gboolean gtk_accel_group_disconnect_key (GtkAccelGroup *accel_group
,guint accel_key
,GdkModifierType accel_mods
);
Removes an accelerator previously installed through
gtk_accel_group_connect()
.
gboolean gtk_accel_group_activate (GtkAccelGroup *accel_group
,GQuark accel_quark
,GObject *acceleratable
,guint accel_key
,GdkModifierType accel_mods
);
Finds the first accelerator in accel_group
that matches
accel_key
and accel_mods
, and activates it.
void
gtk_accel_group_lock (GtkAccelGroup *accel_group
);
Locks the given accelerator group.
Locking an acelerator group prevents the accelerators contained
within it to be changed during runtime. Refer to
gtk_accel_map_change_entry()
about runtime accelerator changes.
If called more than once, accel_group
remains locked until
gtk_accel_group_unlock()
has been called an equivalent number
of times.
void
gtk_accel_group_unlock (GtkAccelGroup *accel_group
);
Undoes the last call to gtk_accel_group_lock()
on this accel_group
.
gboolean
gtk_accel_group_get_is_locked (GtkAccelGroup *accel_group
);
Locks are added and removed using gtk_accel_group_lock()
and
gtk_accel_group_unlock()
.
Since: 2.14
GtkAccelGroup *
gtk_accel_group_from_accel_closure (GClosure *closure
);
Finds the GtkAccelGroup to which closure
is connected;
see gtk_accel_group_connect()
.
GdkModifierType
gtk_accel_group_get_modifier_mask (GtkAccelGroup *accel_group
);
Gets a GdkModifierType representing the mask for this
accel_group
. For example, GDK_CONTROL_MASK, GDK_SHIFT_MASK, etc.
Since: 2.14
gboolean gtk_accel_groups_activate (GObject *object
,guint accel_key
,GdkModifierType accel_mods
);
Finds the first accelerator in any GtkAccelGroup attached
to object
that matches accel_key
and accel_mods
, and
activates that accelerator.
GSList *
gtk_accel_groups_from_object (GObject *object
);
Gets a list of all accel groups which are attached to object
.
GtkAccelKey * gtk_accel_group_find (GtkAccelGroup *accel_group
,GtkAccelGroupFindFunc find_func
,gpointer data
);
Finds the first entry in an accelerator group for which
find_func
returns TRUE
and returns its GtkAccelKey.
gboolean gtk_accelerator_valid (guint keyval
,GdkModifierType modifiers
);
Determines whether a given keyval and modifier mask constitute a valid keyboard accelerator. For example, the GDK_KEY_a keyval plus GDK_CONTROL_MASK is valid - this is a “Ctrl+a” accelerator. But, you can't, for instance, use the GDK_KEY_Control_L keyval as an accelerator.
void gtk_accelerator_parse (const gchar *accelerator
,guint *accelerator_key
,GdkModifierType *accelerator_mods
);
Parses a string representing an accelerator. The format looks like “<Control>a” or “<Shift><Alt>F1” or “<Release>z” (the last one is for key release).
The parser is fairly liberal and allows lower or upper case, and also
abbreviations such as “<Ctl>” and “<Ctrl>”. Key names are parsed using
gdk_keyval_from_name()
. For character keys the name is not the symbol,
but the lowercase name, e.g. one would use “<Ctrl>minus” instead of
“<Ctrl>-”.
If the parse fails, accelerator_key
and accelerator_mods
will
be set to 0 (zero).
gchar * gtk_accelerator_name (guint accelerator_key
,GdkModifierType accelerator_mods
);
Converts an accelerator keyval and modifier mask into a string
parseable by gtk_accelerator_parse()
. For example, if you pass in
GDK_KEY_q and GDK_CONTROL_MASK, this function returns “<Control>q”.
If you need to display accelerators in the user interface,
see gtk_accelerator_get_label()
.
gchar * gtk_accelerator_get_label (guint accelerator_key
,GdkModifierType accelerator_mods
);
Converts an accelerator keyval and modifier mask into a string which can be used to represent the accelerator to the user.
Since: 2.6
void gtk_accelerator_parse_with_keycode (const gchar *accelerator
,guint *accelerator_key
,guint **accelerator_codes
,GdkModifierType *accelerator_mods
);
Parses a string representing an accelerator, similarly to
gtk_accelerator_parse()
but handles keycodes as well. This is only
useful for system-level components, applications should use
gtk_accelerator_parse()
instead.
If accelerator_codes
is given and the result stored in it is non-NULL
,
the result must be freed with g_free()
.
If a keycode is present in the accelerator and no accelerator_codes
is given, the parse will fail.
If the parse fails, accelerator_key
, accelerator_mods
and
accelerator_codes
will be set to 0 (zero).
accelerator |
string representing an accelerator |
|
accelerator_key |
return location for accelerator
keyval, or |
[out][allow-none] |
accelerator_codes |
return location for accelerator keycodes, or |
[out][array zero-terminated=1][transfer full][allow-none] |
accelerator_mods |
return location for accelerator
modifier mask, |
[out][allow-none] |
Since: 3.4
gchar * gtk_accelerator_name_with_keycode (GdkDisplay *display
,guint accelerator_key
,guint keycode
,GdkModifierType accelerator_mods
);
Converts an accelerator keyval and modifier mask
into a string parseable by gtk_accelerator_parse_with_keycode()
,
similarly to gtk_accelerator_name()
but handling keycodes.
This is only useful for system-level components, applications
should use gtk_accelerator_parse()
instead.
display |
a GdkDisplay or |
[allow-none] |
accelerator_key |
accelerator keyval |
|
keycode |
accelerator keycode |
|
accelerator_mods |
accelerator modifier mask |
Since: 3.4
gchar * gtk_accelerator_get_label_with_keycode (GdkDisplay *display
,guint accelerator_key
,guint keycode
,GdkModifierType accelerator_mods
);
Converts an accelerator keyval and modifier mask
into a (possibly translated) string that can be displayed to
a user, similarly to gtk_accelerator_get_label()
, but handling
keycodes.
This is only useful for system-level components, applications
should use gtk_accelerator_parse()
instead.
display |
a GdkDisplay or |
[allow-none] |
accelerator_key |
accelerator keyval |
|
keycode |
accelerator keycode |
|
accelerator_mods |
accelerator modifier mask |
Since: 3.4
void
gtk_accelerator_set_default_mod_mask (GdkModifierType default_mod_mask
);
Sets the modifiers that will be considered significant for keyboard accelerators. The default mod mask depends on the GDK backend in use, but will typically include GDK_CONTROL_MASK | GDK_SHIFT_MASK | GDK_MOD1_MASK | GDK_SUPER_MASK | GDK_HYPER_MASK | GDK_META_MASK. In other words, Control, Shift, Alt, Super, Hyper and Meta. Other modifiers will by default be ignored by GtkAccelGroup.
You must include at least the three modifiers Control, Shift and Alt in any value you pass to this function.
The default mod mask should be changed on application startup, before using any accelerator groups.
GdkModifierType
gtk_accelerator_get_default_mod_mask (void
);
Gets the modifier mask.
The modifier mask determines which modifiers are considered significant
for keyboard accelerators. See gtk_accelerator_set_default_mod_mask()
.
struct GtkAccelGroup;
An object representing and maintaining a group of accelerators.
struct GtkAccelGroupClass { GObjectClass parent_class; void (*accel_changed) (GtkAccelGroup *accel_group, guint keyval, GdkModifierType modifier, GClosure *accel_closure); };
struct GtkAccelKey { guint accel_key; GdkModifierType accel_mods; guint accel_flags : 16; };
guint |
The accelerator keyval |
|
GdkModifierType |
The accelerator modifiers |
|
guint |
The accelerator flags |
“is-locked”
property“is-locked” gboolean
Is the accel group locked.
Flags: Read
Default value: FALSE
“accel-activate”
signalgboolean user_function (GtkAccelGroup *accel_group, GObject *acceleratable, guint keyval, GdkModifierType modifier, gpointer user_data)
The accel-activate signal is an implementation detail of GtkAccelGroup and not meant to be used by applications.
accel_group |
the GtkAccelGroup which received the signal |
|
acceleratable |
the object on which the accelerator was activated |
|
keyval |
the accelerator keyval |
|
modifier |
the modifier combination of the accelerator |
|
user_data |
user data set when the signal handler was connected. |
Flags: Has Details
“accel-changed”
signalvoid user_function (GtkAccelGroup *accel_group, guint keyval, GdkModifierType modifier, GClosure *accel_closure, gpointer user_data)
The accel-changed signal is emitted when an entry is added to or removed from the accel group.
Widgets like GtkAccelLabel which display an associated
accelerator should connect to this signal, and rebuild
their visual representation if the accel_closure
is theirs.
accel_group |
the GtkAccelGroup which received the signal |
|
keyval |
the accelerator keyval |
|
modifier |
the modifier combination of the accelerator |
|
accel_closure |
the GClosure of the accelerator |
|
user_data |
user data set when the signal handler was connected. |
Flags: Has Details
gtk_window_add_accel_group(), gtk_accel_map_change_entry()
,
gtk_item_factory_new()
, gtk_label_new_with_mnemonic()


--- layout: page title: Outreach and Teaching permalink: /outreach-teaching feature-img: "assets/img/header_image.png" order: 3 ---
Oceanus magazine article
Presentation and demonstration for Oceanos: WHOI in Spanish and Portuguese
Treasurer
Outreach chair and session chair of a graduate student-led conference
Coordinator of a program to lower the barrier to applying to graduate school
Participatory action research project


React Gallery
React - Form based on React Hooks
React - Pretty React Switch Component
React - Styled Components
React - GBA (GoBang Ai)
React - Meact (Minimal React Implementation)
React - Medux (Minimal Redux Implementation)
React - Mooks (Minimal Hooks Implementation)


--- layout: post title: "My Week in Review" date: 2018-06-03 07:35:00 +0000 tags: image: https://s3.amazonaws.com/audreywatters/2018-06-03-pigeon.jpg imagecredits: https://www.flickr.com/photos/philfiddyment/25836002385 ---
Icon credits: The Noun Project