Installer un raccourci clavier

Un fichier ressource de raccourci consiste en une définition de 'raccourci' et des états associés pour appliquer le raccourci a des types spécifiques de widgets. Les détails sur le mécanisme de l'association sont d'écrit dans  noms de chemins et modèles. Dans la définition du raccourci les combinaisons de touches sont liées aux émissions de signaux spécifiques sur un widget cible. Les combinaisons de touches sont des chaînes composées d'une nom opionel  GdkModifierType et de noms de touches comme ceux qui sont définis dans <gdk/gdkkeysyms.h> ou retournés par gdk_keyval_name(), ils sont analysés par gtk_accelerator_parse(). Les caractèristiques des émissions de signaux consistent en une chaîne qui identitfie le nom du signal, et en une liste d'arguments spécifiques au signal entre parenthèses. For example for binding Control and the left or right cursor keys of a GtkEntry widget to the GtkEntry::move-cursor signal,ainsi le mouvement se produit en 3 étapes, le raccourci suivant peut être utilisé :

binding "MoveCursor3" {
  bind "<Control>Right" {
    "move-cursor" (visual-positions, 3, 0)
  }
  bind "<Control>Left" {
    "move-cursor" (visual-positions, -3, 0)
  }
}
class "GtkEntry" binding "MoveCursor3"

Détachement d'un raccourci clavier existant

Gtk+ définit déjà un nombre de raccourcis utiles pour les widgets qu'il propose. Parce que les raccourcis créés définis dans les fichiers RC ont la priorité sur les raccourcis par défaut inclus avec GTK+, les raccourcis existant sont remplacés comme cela est démontré dans Installer un raccourci clavier et fonctionnent comme prévu. Le même mécanisme ne peut pas être utilisé pour "détache" des raccourcis existants :

binding "MoveCursor3" {
  bind "<Control>Right" { }
  bind "<Control>Left" { }
}
class "GtkEntry" binding "MoveCursor3"

L'exemple ci-dessus n'a pas l'effet désiré parce que les touches "<Control>Right" et "<Control>Left" pressent pour être ignorées par  Gtk+. A la place, cela provoque juste la suppression de toute attache existante dans la configuration des raccourcis   "MoveCursor3", ainsi quand "<Control>Right" ou "<Control>Left" sont pressées, aucune attache n'est trouvée pour ces touches dans la configuration du raccourci "MoveCursor3".Gtk+ continue alors à rechercher les raccourcis clavier associés  et eventuellement cherche et trouve les raccourcis par défaut de Gtk+ pour les entrées qui  s'appliquent (au mouvement du mot)??. Pour empêcher Gtk+ d'activer ses raccourcis par défaut, le mot-clé "unbind" peut être utilisé ainis:

binding "MoveCursor3" {
  unbind "<Control>Right"
  unbind "<Control>Left"
}
class "GtkEntry" binding "MoveCursor3"

Maintenant, Gtk+  trouvera une association quand il recherchera la pression des touches  "<Control>Right"et "<Control>Left" avant  qu'il n'ait recourt à ses raccourcis  par défaut, et l'association lui demande d'arrêter ("unbind") la recherche, de tel sort que les pressions de touches ne sont pas prises en compte par le widget  Comme d'habitude, d'autres traitement de pression de touche, par exemple un widget d'entrées parent, est maintenant possible. 

GtkBindingSet

typedef struct {
  gchar *set_name;
  gint priority;
  GSList *widget_path_pspecs;
  GSList *widget_class_pspecs;
  GSList *class_branch_pspecs;
  GtkBindingEntry *entries;
  GtkBindingEntry *current;
  guint parsed : 1; /* From RC content */
} GtkBindingSet;

GtkBindingEntry

typedef struct {
/* key portion
 */
  guint keyval;
  GdkModifierType modifiers;
  GtkBindingSet *binding_set;
  guint destroyed : 1;
  guint in_emission : 1;
  guint marks_unbound : 1;
  GtkBindingEntry *set_next;
  GtkBindingEntry *hash_next;
  GtkBindingSignal *signals;
} GtkBindingEntry;

Chaque élément raccourci clavier d'une liste de configurations de raccourcis  est réprésenté par un  GtkBindingEntry.

GtkBindingSignal

typedef struct {
  GtkBindingSignal *next;
  gchar *signal_name;
  guint n_args;
  GtkBindingArg *args;
} GtkBindingSignal;

GtkBindingArg

typedef struct {
  GType arg_type;
  union {
         glong long_data;
         gdouble double_data;
         gchar *string_data;
} d;
} GtkBindingArg;

Un GtkBindingArg contient les données associées avec un argument pour l'émission de signal de raccourci clavier comme ceux stockés dans GtkBindingSignal.

gtk_binding_entry_add

#define gtk_binding_entry_add gtk_binding_entry_clear

Déprécié.

gtk_binding_entry_add_signall ()

void 		gtk_binding_entry_add_signall		 (GtkBindingSet *binding_set,
							  guint keyval,
							  GdkModifierType modifiers,
							  const gchar *signal_name,
							  GSList *binding_args);

gtk_binding_entry_clear ()

void 		gtk_binding_entry_clear 	(GtkBindingSet *binding_set,
						 guint keyval,
						 GdkModifierType modifiers);

L'utilisation de cette fonction est dépréciée.

gtk_binding_parse_binding ()

guint 		gtk_binding_parse_binding 		(GScanner *scanner);

Dépréciée pour l'API public, utilisé uniquement en interne.

gtk_binding_set_new ()

GtkBindingSet* 		gtk_binding_set_new 		(const gchar *set_name);

Gtk+ maintient une listeglobale de configurations de raccourcis. Chaque configuration de raccourcis a un nom unique qui doit être spécifié pendant la création.

gtk_binding_set_by_class ()

GtkBindingSet* 		gtk_binding_set_by_class 		(gpointer object_class);

Cette fonction retourne la configuration de raccourcis nommée après le nom du type passé dans la structure de classe. Les nouvelles configuration de raccourcis sont créées à la demande par cette fonction.

gtk_binding_set_find ()

GtkBindingSet* gtk_binding_set_find (const gchar *set_name);

Trouve une configuration de raccourcis par son nom global unique. le set_name peut soit être un nom utilisé pour gtk_binding_set_new() ou un nom de type de classe utilisé dans  gtk_binding_set_by_class().

gtk_bindings_activate ()

gboolean 		gtk_bindings_activate 		(GtkObject *object,
							 guint keyval,
							 GdkModifierType modifiers);

Trouve une touche de raccourcis associant  keyval et modifiers et qui active le raccouris sur object.

gtk_bindings_activate_event ()

gboolean 			gtk_bindings_activate_event 		(GtkObject *object,
									 GdkEventKey *event);

Recherche la touche de raccourci pour  object pour trouver un event associé, et si la fonction en trouve une, elle l'active.

gtk_binding_set_activate ()

gboolean 		gtk_binding_set_activate 		(GtkBindingSet *binding_set,
								 guint keyval,
								 GdkModifierType modifiers,
								 GtkObject *object);

gtk_binding_entry_add_signal ()

void gtk_binding_entry_add_signal (GtkBindingSet *binding_set,
guint keyval,
GdkModifierType modifiers,
const gchar *signal_name,
guint n_args,
...);

Override or install a new key binding for keyval with modifiers on binding_set. When the binding is activated, signal_name will be emitted on the target widget, with n_args Varargs used as arguments.

gtk_binding_entry_skip ()

void 		gtk_binding_entry_skip 		(GtkBindingSet *binding_set,
						 guint keyval,
						 GdkModifierType modifiers);

Depuis  2.12 Installe un raccourci sur  @binding_set ce qui fait que la touche cherche à être abandonnée, pour empêcher les configurations de raccourcis de faible priorité d'être activés.

gtk_binding_entry_remove ()

void 		gtk_binding_entry_remove 		(GtkBindingSet *binding_set,
							 guint keyval,
							 GdkModifierType modifiers);

Supprime un raccourcis installé préalablement via gtk_binding_entry_add_signal() sur binding_set.

gtk_binding_set_add_path ()

void 		gtk_binding_set_add_path 		(GtkBindingSet *binding_set,
							 GtkPathType path_type,
							 const gchar *path_pattern,
							 GtkPathPriorityType priority);

La fonction est utilisée de façon interne par GtkRC en analysant le mécanisme pour assigner des modèles associés à des structures  GtkBindingSet .