pidgin  2.13.0
About: Pidgin is a chat program (multi-protocol instant messaging client) which lets you log in to accounts on multiple chat networks simultaneously (old name "gaim").
  Fossies Dox: pidgin-2.13.0.tar.gz  ("inofficial" and yet experimental doxygen-generated source code documentation)  

gntbindable.c
Go to the documentation of this file.
1 
23 #include <string.h>
24 
25 #include "gntinternal.h"
26 #undef GNT_LOG_DOMAIN
27 #define GNT_LOG_DOMAIN "Bindable"
28 
29 #include "gntbindable.h"
30 #include "gntstyle.h"
31 #include "gnt.h"
32 #include "gntutils.h"
33 #include "gnttextview.h"
34 #include "gnttree.h"
35 #include "gntbox.h"
36 #include "gntbutton.h"
37 #include "gntwindow.h"
38 #include "gntlabel.h"
39 
40 static GObjectClass *parent_class = NULL;
41 
42 static struct
43 {
44  char * okeys; /* Old keystrokes */
45  char * keys; /* New Keystrokes being bound to the action */
46  GntBindableClass * klass; /* Class of the object that's getting keys rebound */
47  char * name; /* The name of the action */
48  GList * params; /* The list of paramaters */
49 } rebind_info;
50 
51 static void
53 {
54  g_free(rebind_info.name);
55  g_free(rebind_info.keys);
56  g_free(rebind_info.okeys);
57 }
58 
59 static void
61 {
64 }
65 
66 static void
68 {
69  if (rebind_info.keys) {
71  NULL,
72  rebind_info.okeys,
73  rebind_info.params);
75  rebind_info.name,
76  rebind_info.keys,
77  rebind_info.params);
78  }
81 }
82 
83 static gboolean
84 gnt_bindable_rebinding_grab_key(GntBindable *bindable, const char *text, gpointer data)
85 {
86  GntTextView *textview = GNT_TEXT_VIEW(data);
87  char *new_text;
88  const char *tmp;
89 
90  if (text && *text) {
91  /* Rebinding tab or enter for something is probably not that great an idea */
92  if (!strcmp(text, GNT_KEY_CTRL_I) || !strcmp(text, GNT_KEY_ENTER)) {
93  return FALSE;
94  }
95 
96  tmp = gnt_key_lookup(text);
97  new_text = g_strdup_printf("KEY: \"%s\"", tmp);
98  gnt_text_view_clear(textview);
100  g_free(new_text);
101 
102  g_free(rebind_info.keys);
103  rebind_info.keys = g_strdup(text);
104 
105  return TRUE;
106  }
107  return FALSE;
108 }
109 static void
111 {
112  const char *widget_name = g_type_name(G_OBJECT_TYPE(bindable));
113  char *keys;
114  GntWidget *key_textview;
115  GntWidget *label;
116  GntWidget *bind_button, *cancel_button;
117  GntWidget *button_box;
118  GList *current_row_data;
119  char *tmp;
120  GntWidget *win = gnt_window_new();
122  GntWidget *vbox = gnt_box_new(FALSE, TRUE);
123 
124  rebind_info.klass = GNT_BINDABLE_GET_CLASS(bindable);
125 
126  current_row_data = gnt_tree_get_selection_text_list(tree);
127  rebind_info.name = g_strdup(g_list_nth_data(current_row_data, 1));
128 
130  rebind_info.okeys = g_strdup(gnt_key_translate(keys));
131 
132  rebind_info.params = NULL;
133 
134  g_list_foreach(current_row_data, (GFunc)g_free, NULL);
135  g_list_free(current_row_data);
136 
138 
139  gnt_box_set_title(GNT_BOX(win), "Key Capture");
140 
141  tmp = g_strdup_printf("Type the new bindings for %s in a %s.", rebind_info.name, widget_name);
142  label = gnt_label_new(tmp);
143  g_free(tmp);
145 
146  tmp = g_strdup_printf("KEY: \"%s\"", keys);
147  key_textview = gnt_text_view_new();
148  gnt_widget_set_size(key_textview, key_textview->priv.x, 2);
150  g_free(tmp);
151  gnt_widget_set_name(key_textview, "keystroke");
152  gnt_box_add_widget(GNT_BOX(vbox), key_textview);
153 
154  g_signal_connect(G_OBJECT(win), "key_pressed", G_CALLBACK(gnt_bindable_rebinding_grab_key), key_textview);
155 
156  button_box = gnt_box_new(FALSE, FALSE);
157 
158  bind_button = gnt_button_new("BIND");
159  gnt_widget_set_name(bind_button, "bind");
160  gnt_box_add_widget(GNT_BOX(button_box), bind_button);
161 
162  cancel_button = gnt_button_new("Cancel");
163  gnt_widget_set_name(cancel_button, "cancel");
164  gnt_box_add_widget(GNT_BOX(button_box), cancel_button);
165 
166  g_signal_connect(G_OBJECT(bind_button), "activate", G_CALLBACK(gnt_bindable_rebinding_rebind), win);
167  g_signal_connect(G_OBJECT(cancel_button), "activate", G_CALLBACK(gnt_bindable_rebinding_cancel), win);
168 
169  gnt_box_add_widget(GNT_BOX(vbox), button_box);
170 
171  gnt_box_add_widget(GNT_BOX(win), vbox);
172  gnt_widget_show(win);
173 }
174 
175 typedef struct
176 {
177  GHashTable *hash;
179 } BindingView;
180 
181 static void
182 add_binding(gpointer key, gpointer value, gpointer data)
183 {
184  BindingView *bv = data;
186  const char *name = g_hash_table_lookup(bv->hash, act->action);
187  if (name && *name) {
188  const char *k = gnt_key_lookup(key);
189  if (!k)
190  k = key;
191  gnt_tree_add_row_after(bv->tree, (gpointer)k,
192  gnt_tree_create_row(bv->tree, k, name), NULL, NULL);
193  }
194 }
195 
196 static void
197 add_action(gpointer key, gpointer value, gpointer data)
198 {
199  BindingView *bv = data;
200  g_hash_table_insert(bv->hash, value, key);
201 }
202 
203 static void
205 {
206  parent_class = g_type_class_peek_parent(klass);
207 
208  klass->actions = g_hash_table_new_full(g_str_hash, g_str_equal, g_free,
209  (GDestroyNotify)gnt_bindable_action_free);
210  klass->bindings = g_hash_table_new_full(g_str_hash, g_str_equal, g_free,
211  (GDestroyNotify)gnt_bindable_action_param_free);
212 
213  gnt_style_read_actions(G_OBJECT_CLASS_TYPE(klass), GNT_BINDABLE_CLASS(klass));
214  GNTDEBUG;
215 }
216 
217 static gpointer
219 {
220  GntBindableAction *ret = g_new0(GntBindableAction, 1);
221  ret->name = g_strdup(action->name);
222  ret->u = action->u;
223  return ret;
224 }
225 
226 static gpointer
228 {
230  p->list = g_list_copy(param->list);
231  p->action = param->action;
232  return p;
233 }
234 
235 static void
237 {
238  /* Duplicate the bindings from parent class */
239  if (klass->actions) {
241  g_str_equal, g_free, (GDestroyNotify)gnt_bindable_action_free,
242  (GDupFunc)g_strdup, (GDupFunc)bindable_clone);
244  g_str_equal, g_free, (GDestroyNotify)gnt_bindable_action_param_free,
245  (GDupFunc)g_strdup, (GDupFunc)binding_clone);
246  } else {
247  klass->actions = g_hash_table_new_full(g_str_hash, g_str_equal, g_free,
248  (GDestroyNotify)gnt_bindable_action_free);
249  klass->bindings = g_hash_table_new_full(g_str_hash, g_str_equal, g_free,
250  (GDestroyNotify)gnt_bindable_action_param_free);
251  }
252 
253  GNTDEBUG;
254 }
255 
256 /******************************************************************************
257  * GntBindable API
258  *****************************************************************************/
259 GType
261 {
262  static GType type = 0;
263 
264  if (type == 0) {
265  static const GTypeInfo info = {
266  sizeof(GntBindableClass),
267  (GBaseInitFunc)duplicate_hashes, /* base_init */
268  NULL, /* base_finalize */
269  (GClassInitFunc)gnt_bindable_class_init,
270  NULL,
271  NULL, /* class_data */
272  sizeof(GntBindable),
273  0, /* n_preallocs */
274  NULL, /* instance_init */
275  NULL /* value_table */
276  };
277 
278  type = g_type_register_static(G_TYPE_OBJECT,
279  "GntBindable",
280  &info, G_TYPE_FLAG_ABSTRACT);
281  }
282 
283  return type;
284 }
285 
289 const char *
290 gnt_bindable_remap_keys(GntBindable *bindable, const char *text)
291 {
292  const char *remap = NULL;
293  GType type = G_OBJECT_TYPE(bindable);
295 
296  if (klass->remaps == NULL)
297  {
298  klass->remaps = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
300  }
301 
302  remap = g_hash_table_lookup(klass->remaps, text);
303 
304  return (remap ? remap : text);
305 }
306 
310 gboolean
311 gnt_bindable_perform_action_named(GntBindable *bindable, const char *name, ...)
312 {
314  GList *list = NULL;
315  va_list args;
316  GntBindableAction *action;
317  void *p;
318 
319  va_start(args, name);
320  while ((p = va_arg(args, void *)) != NULL)
321  list = g_list_append(list, p);
322  va_end(args);
323 
324  action = g_hash_table_lookup(klass->actions, name);
325  if (action && action->u.action) {
326  return action->u.action(bindable, list);
327  }
328  return FALSE;
329 }
330 
331 gboolean
332 gnt_bindable_perform_action_key(GntBindable *bindable, const char *keys)
333 {
335  GntBindableActionParam *param = g_hash_table_lookup(klass->bindings, keys);
336 
337  if (param && param->action) {
338  if (param->list)
339  return param->action->u.action(bindable, param->list);
340  else
341  return param->action->u.action_noparam(bindable);
342  }
343  return FALSE;
344 }
345 
346 gboolean
347 gnt_bindable_check_key(GntBindable *bindable, const char *keys) {
349  GntBindableActionParam *param = g_hash_table_lookup(klass->bindings, keys);
350  return (param && param->action);
351 }
352 
353 static void
354 register_binding(GntBindableClass *klass, const char *name, const char *trigger, GList *list)
355 {
356  GntBindableActionParam *param;
357  GntBindableAction *action;
358 
359  if (name == NULL || *name == '\0') {
360  g_hash_table_remove(klass->bindings, (char*)trigger);
361  gnt_keys_del_combination(trigger);
362  return;
363  }
364 
365  action = g_hash_table_lookup(klass->actions, name);
366  if (!action) {
367  gnt_warning("Invalid action name %s for %s",
368  name, g_type_name(G_OBJECT_CLASS_TYPE(klass)));
369  if (list)
370  g_list_free(list);
371  return;
372  }
373 
374  param = g_new0(GntBindableActionParam, 1);
375  param->action = action;
376  param->list = list;
377  g_hash_table_replace(klass->bindings, g_strdup(trigger), param);
378  gnt_keys_add_combination(trigger);
379 }
380 
382  const char *trigger, ...)
383 {
384  GList *list = NULL;
385  va_list args;
386  void *data;
387 
388  va_start(args, trigger);
389  while ((data = va_arg(args, void *))) {
390  list = g_list_append(list, data);
391  }
392  va_end(args);
393 
394  register_binding(klass, name, trigger, list);
395 }
396 
398  GntBindableActionCallback callback, const char *trigger, ...)
399 {
400  void *data;
401  va_list args;
402  GntBindableAction *action = g_new0(GntBindableAction, 1);
403  GList *list;
404 
405  action->name = g_strdup(name);
406  action->u.action = callback;
407 
408  g_hash_table_replace(klass->actions, g_strdup(name), action);
409 
410  if (trigger && *trigger) {
411  list = NULL;
412  va_start(args, trigger);
413  while ((data = va_arg(args, void *))) {
414  list = g_list_append(list, data);
415  }
416  va_end(args);
417 
418  register_binding(klass, name, trigger, list);
419  }
420 }
421 
423 {
424  g_free(action->name);
425  g_free(action);
426 }
427 
429 {
430  g_list_free(param->list); /* XXX: There may be a leak here for string parameters */
431  g_free(param);
432 }
433 
435 {
438  GHashTable *hash = g_hash_table_new(g_direct_hash, g_direct_equal);
439  BindingView bv = {hash, GNT_TREE(tree)};
440 
441  gnt_tree_set_compare_func(bv.tree, (GCompareFunc)g_utf8_collate);
442  g_hash_table_foreach(klass->actions, add_action, &bv);
443  g_hash_table_foreach(klass->bindings, add_binding, &bv);
444  if (GNT_TREE(tree)->list == NULL) {
446  tree = NULL;
447  } else
449  g_hash_table_destroy(hash);
450 
451  return tree;
452 }
453 
454 static void
456 {
459 }
460 
461 gboolean
463 {
464  GntWidget *tree;
466  char *title;
467 
469 
471  title = g_strdup_printf("Bindings for %s", g_type_name(G_OBJECT_TYPE(bindable)));
473  if (tree) {
474  g_signal_connect(G_OBJECT(tree), "activate", G_CALLBACK(gnt_bindable_rebinding_activate), bindable);
476  } else
477  gnt_box_add_widget(GNT_BOX(klass->help_window), gnt_label_new("This widget has no customizable bindings."));
478 
479  g_signal_connect(G_OBJECT(klass->help_window), "destroy", G_CALLBACK(reset_binding_window), klass);
481  g_free(title);
482 
483  return TRUE;
484 }
485 
dbus-analyze-signals.args
args
Definition: dbus-analyze-signals.py:37
gnt_widget_set_size
gboolean gnt_widget_set_size(GntWidget *widget, int width, int height)
Definition: gntwidget.c:515
info
static PurplePluginInfo info
Definition: gntclipboard.c:147
name
char * name
Definition: gntbindable.c:47
_GntBindableActionParam::list
GList * list
Definition: gntbindable.h:102
_GntBindableClass::help_window
GntBindable * help_window
Definition: gntbindable.h:60
gnt_bindable_rebinding_grab_key
static gboolean gnt_bindable_rebinding_grab_key(GntBindable *bindable, const char *text, gpointer data)
Definition: gntbindable.c:84
gnt_widget_show
void gnt_widget_show(GntWidget *widget)
Definition: gntwidget.c:326
register_binding
static void register_binding(GntBindableClass *klass, const char *name, const char *trigger, GList *list)
Definition: gntbindable.c:353
gntbox.h
_GntBindableAction
Definition: gntbindable.h:90
_GntWidgetPriv::x
int x
Definition: gntwidget.h:90
add_action
static void add_action(gpointer key, gpointer value, gpointer data)
Definition: gntbindable.c:197
gnt_window_new
GntWidget * gnt_window_new()
Definition: gntwindow.c:160
gnt_label_new
GntWidget * gnt_label_new(const char *text)
Definition: gntlabel.c:186
gnt_bindable_get_gtype
GType gnt_bindable_get_gtype(void)
Definition: gntbindable.c:259
_GntWidget
Definition: gntwidget.h:98
gnt.h
gnt_tree_set_compare_func
void gnt_tree_set_compare_func(GntTree *tree, GCompareFunc func)
Definition: gnttree.c:1783
gnt_bindable_action_free
void gnt_bindable_action_free(GntBindableAction *action)
Definition: gntbindable.c:421
GNT_KEY_CTRL_I
#define GNT_KEY_CTRL_I
Definition: gntkeys.h:77
window
GntWidget * window
Definition: gntcertmgr.c:45
add_binding
static void add_binding(gpointer key, gpointer value, gpointer data)
Definition: gntbindable.c:182
GDupFunc
gpointer(* GDupFunc)(gconstpointer data)
Definition: gntutils.h:33
gnt_bindable_perform_action_named
gboolean gnt_bindable_perform_action_named(GntBindable *bindable, const char *name,...)
Definition: gntbindable.c:310
gntutils.h
GNT_BINDABLE_GET_CLASS
#define GNT_BINDABLE_GET_CLASS(obj)
Definition: gntbindable.h:40
gnt_bindable_build_help_window
gboolean gnt_bindable_build_help_window(GntBindable *bindable)
Definition: gntbindable.c:461
BindingView
Definition: gntbindable.c:175
gnt_key_lookup
const char * gnt_key_lookup(const char *key)
Definition: gntkeys.c:197
gnt_bindable_class_init
static void gnt_bindable_class_init(GntBindableClass *klass)
Definition: gntbindable.c:204
GNT_BOX
#define GNT_BOX(obj)
Definition: gntbox.h:34
gnt_box_add_widget
void gnt_box_add_widget(GntBox *b, GntWidget *widget)
Definition: gntbox.c:674
gnt_keys_del_combination
void gnt_keys_del_combination(const char *path)
Definition: gntkeys.c:266
gnt_button_new
GntWidget * gnt_button_new(const char *text)
Definition: gntbutton.c:170
gnt_text_view_new
GntWidget * gnt_text_view_new()
Definition: gnttextview.c:499
gnt_bindable_free_rebind_info
static void gnt_bindable_free_rebind_info(void)
Definition: gntbindable.c:52
GntBindableClass
struct _GntBindableClass GntBindableClass
Definition: gntbindable.h:45
gnt_bindable_remap_keys
const char * gnt_bindable_remap_keys(GntBindable *bindable, const char *text)
Definition: gntbindable.c:289
GNT_ALIGN_MID
Definition: gntbox.h:49
_GntTextView
Definition: gnttextview.h:57
keys
char * keys
Definition: gntbindable.c:45
gnt_keys_add_combination
void gnt_keys_add_combination(const char *path)
Definition: gntkeys.c:244
gnt_bindable_register_binding
void gnt_bindable_register_binding(GntBindableClass *klass, const char *name, const char *trigger,...)
Definition: gntbindable.c:380
parent_class
static GObjectClass * parent_class
Definition: gntbindable.c:40
bindable_clone
static gpointer bindable_clone(GntBindableAction *action)
Definition: gntbindable.c:218
GNTDEBUG
#define GNTDEBUG
Definition: gntbindable.h:42
gntinternal.h
gnt_widget_set_name
void gnt_widget_set_name(GntWidget *widget, const char *name)
Definition: gntwidget.c:589
bind
#define bind(socket, addr, length)
Definition: libc_interface.h:62
gntlabel.h
GNT_TEXT_FLAG_NORMAL
Definition: gnttextview.h:70
klass
GntBindableClass * klass
Definition: gntbindable.c:46
data
gpointer data
Definition: gntwm.c:1781
gnt_tree_get_selection_text_list
GList * gnt_tree_get_selection_text_list(GntTree *tree)
Definition: gnttree.c:1474
gnt_warning
#define gnt_warning
Definition: gntinternal.h:32
gnt_tree_add_row_after
GntTreeRow * gnt_tree_add_row_after(GntTree *tree, void *key, GntTreeRow *row, void *parent, void *bigbro)
Definition: gnttree.c:1344
NULL
#define NULL
Definition: getopt1.c:52
gnt_bindable_rebinding_rebind
static void gnt_bindable_rebinding_rebind(GntWidget *button, gpointer data)
Definition: gntbindable.c:67
_GntTree
Definition: gnttree.h:57
gnt_bindable_perform_action_key
gboolean gnt_bindable_perform_action_key(GntBindable *bindable, const char *keys)
Definition: gntbindable.c:331
GNT_TREE
#define GNT_TREE(obj)
Definition: gnttree.h:37
GNT_TEXT_VIEW
#define GNT_TEXT_VIEW(obj)
Definition: gnttextview.h:36
_GntBindableClass::actions
GHashTable * actions
Definition: gntbindable.h:57
BindingView::tree
GntTree * tree
Definition: gntbindable.c:178
gnt_bindable_bindings_view
GntBindable * gnt_bindable_bindings_view(GntBindable *bind)
Definition: gntbindable.c:433
gntbutton.h
gnt_text_view_append_text_with_flags
void gnt_text_view_append_text_with_flags(GntTextView *view, const char *text, GntTextFormatFlags flags)
Definition: gnttextview.c:506
GNT_WIDGET
#define GNT_WIDGET(obj)
Definition: gntwidget.h:37
TRUE
#define TRUE
Definition: protobuf-c.c:56
_GntBindableClass::bindings
GHashTable * bindings
Definition: gntbindable.h:58
dbus-analyze-signals.type
string type
Definition: dbus-analyze-signals.py:42
gnttextview.h
gnt_box_new
GntWidget * gnt_box_new(gboolean homo, gboolean vert)
Definition: gntbox.c:662
FALSE
#define FALSE
Definition: protobuf-c.c:57
binding_clone
static gpointer binding_clone(GntBindableActionParam *param)
Definition: gntbindable.c:227
GNT_KEY_ENTER
#define GNT_KEY_ENTER
Definition: gntkeys.h:63
_GntBindableAction::action_noparam
gboolean(* action_noparam)(GntBindable *bindable)
Definition: gntbindable.h:95
gnt_box_set_title
void gnt_box_set_title(GntBox *b, const char *title)
Definition: gntbox.c:680
hash
static GHashTable * hash
Definition: gntconn.c:53
text
static char * text[]
Definition: zephyr_err.c:10
label
const char * label
Definition: jabber.c:1321
_GntBindableClass
Definition: gntbindable.h:52
gnt_styles_get_keyremaps
void gnt_styles_get_keyremaps(GType type, GHashTable *hash)
Definition: gntstyle.c:329
gnt_style_read_actions
void gnt_style_read_actions(GType type, GntBindableClass *klass)
Definition: gntstyle.c:217
_GntBindableActionParam
Definition: gntbindable.h:99
g_hash_table_duplicate
GHashTable * g_hash_table_duplicate(GHashTable *src, GHashFunc hash, GEqualFunc equal, GDestroyNotify key_d, GDestroyNotify value_d, GDupFunc key_dup, GDupFunc value_dup)
Definition: gntutils.c:164
BindingView::hash
GHashTable * hash
Definition: gntbindable.c:177
gntbindable.h
gntstyle.h
gnt_tree_new_with_columns
GntWidget * gnt_tree_new_with_columns(int col)
Definition: gnttree.c:1694
tree
GntWidget * tree
Definition: gntcertmgr.c:46
gnt_widget_destroy
void gnt_widget_destroy(GntWidget *obj)
Definition: gntwidget.c:312
gnt_bindable_check_key
gboolean gnt_bindable_check_key(GntBindable *bindable, const char *keys)
Definition: gntbindable.c:346
gnt_bindable_rebinding_cancel
static void gnt_bindable_rebinding_cancel(GntWidget *button, gpointer data)
Definition: gntbindable.c:60
duplicate_hashes
static void duplicate_hashes(GntBindableClass *klass)
Definition: gntbindable.c:236
gnt_tree_adjust_columns
void gnt_tree_adjust_columns(GntTree *tree)
Definition: gnttree.c:1804
gnt_text_view_clear
void gnt_text_view_clear(GntTextView *view)
Definition: gnttextview.c:690
act
static GList * act
Definition: gntwm.c:111
GntBindableActionCallback
gboolean(* GntBindableActionCallback)(GntBindable *bindable, GList *params)
Definition: gntbindable.h:84
gnt_bindable_rebinding_activate
static void gnt_bindable_rebinding_activate(GntBindable *data, gpointer bindable)
Definition: gntbindable.c:110
_GntBindableClass::remaps
GHashTable * remaps
Definition: gntbindable.h:56
gnt_bindable_action_param_free
void gnt_bindable_action_param_free(GntBindableActionParam *param)
Definition: gntbindable.c:427
gnt_bindable_class_register_action
void gnt_bindable_class_register_action(GntBindableClass *klass, const char *name, GntBindableActionCallback callback, const char *trigger,...)
Definition: gntbindable.c:396
_GntBindableActionParam::action
GntBindableAction * action
Definition: gntbindable.h:101
_GntBindable
Definition: gntbindable.h:47
_GntBindableAction::u
union _GntBindableAction::@11 u
params
GList * params
Definition: gntbindable.c:48
value
gpointer value
Definition: gntwm.c:1782
GNT_BINDABLE
#define GNT_BINDABLE(obj)
Definition: gntbindable.h:36
gnttree.h
gnt_tree_create_row
GntTreeRow * gnt_tree_create_row(GntTree *tree,...)
Definition: gnttree.c:1728
GNT_BINDABLE_CLASS
#define GNT_BINDABLE_CLASS(klass)
Definition: gntbindable.h:37
_GntWidget::priv
GntWidgetPriv priv
Definition: gntwidget.h:104
gnt_tree_get_selection_data
gpointer gnt_tree_get_selection_data(GntTree *tree)
Definition: gnttree.c:1441
gntwindow.h
rebind_info
static struct @10 rebind_info
gnt_box_set_alignment
void gnt_box_set_alignment(GntBox *box, GntAlignment alignment)
Definition: gntbox.c:775
okeys
char * okeys
Definition: gntbindable.c:44
reset_binding_window
static void reset_binding_window(GntBindableClass *window, gpointer k)
Definition: gntbindable.c:454
_GntBindableAction::name
char * name
Definition: gntbindable.h:92
gnt_key_translate
const char * gnt_key_translate(const char *name)
Definition: gntkeys.c:177
_GntBindableAction::action
gboolean(* action)(GntBindable *bindable, GList *params)
Definition: gntbindable.h:94