GtkAccelGroup

typedef struct _GtkAccelGroup GtkAccelGroup;

An object representing and maintaining a group of accelerators.

gtk_accel_group_new ()

GtkAccelGroup*      gtk_accel_group_new                 (void);

Creates a new GtkAccelGroup.

gtk_accel_group_ref

#define	gtk_accel_group_ref	g_object_ref

Deprecated equivalent of g_object_ref().

gtk_accel_group_unref

#define	gtk_accel_group_unref	g_object_unref

Deprecated equivalent of g_object_unref().

gtk_accel_group_connect ()

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.

gtk_accel_group_connect_by_path ()

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.

GtkAccelGroupActivate ()

gboolean            (*GtkAccelGroupActivate)            (GtkAccelGroup *accel_group,
                                                         GObject *acceleratable,
                                                         guint keyval,
                                                         GdkModifierType modifier);

GtkAccelGroupFindFunc ()

gboolean            (*GtkAccelGroupFindFunc)            (GtkAccelKey *key,
                                                         GClosure *closure,
                                                         gpointer data);

Since 2.2

gtk_accel_group_disconnect ()

gboolean            gtk_accel_group_disconnect          (GtkAccelGroup *accel_group,
                                                         GClosure *closure);

Removes an accelerator previously installed through gtk_accel_group_connect().

gtk_accel_group_disconnect_key ()

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().

gtk_accel_group_query ()

GtkAccelGroupEntry* gtk_accel_group_query               (GtkAccelGroup *accel_group,
                                                         guint accel_key,
                                                         GdkModifierType accel_mods,
                                                         guint *n_entries);

Queries an accelerator group for all entries matching accel_key and accel_mods.

gtk_accel_group_activate ()

gboolean            gtk_accel_group_activate            (GtkAccelGroup *accel_group,
                                                         GQuark accel_quark,
                                                         GObject *acceleratable,
                                                         guint accel_key,
                                                         GdkModifierType accel_mods);

gtk_accel_group_lock ()

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.

gtk_accel_group_unlock ()

void                gtk_accel_group_unlock              (GtkAccelGroup *accel_group);

Undoes the last call to gtk_accel_group_lock() on this accel_group.

gtk_accel_group_from_accel_closure ()

GtkAccelGroup*      gtk_accel_group_from_accel_closure  (GClosure *closure);

Finds the GtkAccelGroup to which closure is connected; see gtk_accel_group_connect().

gtk_accel_groups_activate ()

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. If an accelerator was activated and handled this keypress, TRUE is returned.

gtk_accel_groups_from_object ()

GSList*             gtk_accel_groups_from_object        (GObject *object);

Gets a list of all accel groups which are attached to object.

gtk_accel_group_find ()

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.

GtkAccelKey

typedef struct {
  guint           accel_key;
  GdkModifierType accel_mods;
  guint           accel_flags : 16;
} GtkAccelKey;

gtk_accelerator_valid ()

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_a keyval plus GDK_CONTROL_MASK is valid - this is a "Ctrl+a" accelerator. But, you can't, for instance, use the GDK_Control_L keyval as an accelerator.

gtk_accelerator_parse ()

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>".

If the parse fails, accelerator_key and accelerator_mods will be set to 0 (zero).

gtk_accelerator_name ()

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_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().

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

gtk_accelerator_set_default_mod_mask ()

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 is GDK_CONTROL_MASK | GDK_SHIFT_MASK | GDK_MOD1_MASK | GDK_SUPER_MASK | GDK_HYPER_MASK | GDK_META_MASK, that is, 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.

gtk_accelerator_get_default_mod_mask ()

guint               gtk_accelerator_get_default_mod_mask
                                                        (void);

Gets the value set by gtk_accelerator_set_default_mod_mask().

The "accel-activate" signal

gboolean            user_function                      (GtkAccelGroup  *accel_group,
                                                        GObject        *acceleratable,
                                                        guint           keyval,
                                                        GdkModifierType modifier,
                                                        gpointer        user_data)          : Has Details

The accel-activate signal is an implementation detail of GtkAccelGroup and not meant to be used by applications.

The "accel-changed" signal

void                user_function                      (GtkAccelGroup  *accel_group,
                                                        guint           keyval,
                                                        GdkModifierType modifier,
                                                        GClosure       *accel_closure,
                                                        gpointer        user_data)          : Run First / Has Details

The accel-changed signal is emitted when a GtkAccelGroupEntry 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.