gntbindable.c

   1 /**
   2  * GNT - The GLib Ncurses Toolkit
   3  *
   4  * GNT is the legal property of its developers, whose names are too numerous
   5  * to list here.  Please refer to the COPYRIGHT file distributed with this
   6  * source distribution.
   7  *
   8  * This library is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  21  */
  22
  23 #include <string.h>
  24
  25 #include "gntbindable.h"
  26 #include "gntstyle.h"
  27 #include "gnt.h"
  28 #include "gntutils.h"
  29 #include "gnttextview.h"
  30 #include "gnttree.h"
  31 #include "gntbox.h"
  32 #include "gntbutton.h"
  33 #include "gntwindow.h"
  34 #include "gntlabel.h"
  35
  36 static GObjectClass *parent_class = NULL;
  37
  38 static struct
  39 {
  40         char * okeys;         /* Old keystrokes */
  41         char * keys;          /* New Keystrokes being bound to the action */
  42         GntBindableClass * klass; /* Class of the object that's getting keys rebound */
  43         char * name;          /* The name of the action */
  44         GList * params;       /* The list of paramaters */
  45 } rebind_info;
  46
  47 static void
  48 gnt_bindable_free_rebind_info()
  49 {
  50         g_free(rebind_info.name);
  51         g_free(rebind_info.keys);
  52         g_free(rebind_info.okeys);
  53 }
  54
  55 static void
  56 gnt_bindable_rebinding_cancel(GntWidget *button, gpointer data)
  57 {
  58         gnt_bindable_free_rebind_info();
  59         gnt_widget_destroy(GNT_WIDGET(data));
  60 }
  61
  62 static void
  63 gnt_bindable_rebinding_rebind(GntWidget *button, gpointer data)
  64 {
  65         if (rebind_info.keys) {
  66                 gnt_bindable_register_binding(rebind_info.klass,
  67                                 NULL,
  68                                 rebind_info.okeys,
  69                                 rebind_info.params);
  70                 gnt_bindable_register_binding(rebind_info.klass,
  71                                 rebind_info.name,
  72                                 rebind_info.keys,
  73                                 rebind_info.params);
  74         }
  75         gnt_bindable_free_rebind_info();
  76         gnt_widget_destroy(GNT_WIDGET(data));
  77 }
  78
  79 static gboolean
  80 gnt_bindable_rebinding_grab_key(GntBindable *bindable, const char *text, gpointer data)
  81 {
  82         GntTextView *textview = GNT_TEXT_VIEW(data);
  83         char *new_text;
  84         const char *tmp;
  85
  86         if (text && *text) {
  87                 /* Rebinding tab or enter for something is probably not that great an idea */
  88                 if (!strcmp(text, GNT_KEY_CTRL_I) || !strcmp(text, GNT_KEY_ENTER)) {
  89                         return FALSE;
  90                 }
  91
  92                 tmp = gnt_key_lookup(text);
  93                 new_text = g_strdup_printf("KEY: \"%s\"", tmp);
  94                 gnt_text_view_clear(textview);
  95                 gnt_text_view_append_text_with_flags(textview, new_text, GNT_TEXT_FLAG_NORMAL);
  96                 g_free(new_text);
  97
  98                 g_free(rebind_info.keys);
  99                 rebind_info.keys = g_strdup(text);
 100
 101                 return TRUE;
 102         }
 103         return FALSE;
 104 }
 105 static void
 106 gnt_bindable_rebinding_activate(GntBindable *data, gpointer bindable)
 107 {
 108         const char *widget_name = g_type_name(G_OBJECT_TYPE(bindable));
 109         char *keys;
 110         GntWidget *key_textview;
 111         GntWidget *label;
 112         GntWidget *bind_button, *cancel_button;
 113         GntWidget *button_box;
 114         GList *current_row_data;
 115         char *tmp;
 116         GntWidget *win = gnt_window_new();
 117         GntTree *tree = GNT_TREE(data);
 118         GntWidget *vbox = gnt_box_new(FALSE, TRUE);
 119
 120         rebind_info.klass = GNT_BINDABLE_GET_CLASS(bindable);
 121
 122         current_row_data = gnt_tree_get_selection_text_list(tree);
 123         rebind_info.name = g_strdup(g_list_nth_data(current_row_data, 1));
 124
 125         keys = gnt_tree_get_selection_data(tree);
 126         rebind_info.okeys = g_strdup(gnt_key_translate(keys));
 127
 128         rebind_info.params = NULL;
 129
 130         g_list_foreach(current_row_data, (GFunc)g_free, NULL);
 131         g_list_free(current_row_data);
 132
 133         gnt_box_set_alignment(GNT_BOX(vbox), GNT_ALIGN_MID);
 134
 135         gnt_box_set_title(GNT_BOX(win), "Key Capture");
 136
 137         tmp = g_strdup_printf("Type the new bindings for %s in a %s.", rebind_info.name, widget_name);
 138         label = gnt_label_new(tmp);
 139         g_free(tmp);
 140         gnt_box_add_widget(GNT_BOX(vbox), label);
 141
 142         tmp = g_strdup_printf("KEY: \"%s\"", keys);
 143         key_textview = gnt_text_view_new();
 144         gnt_widget_set_size(key_textview, key_textview->priv.x, 2);
 145         gnt_text_view_append_text_with_flags(GNT_TEXT_VIEW(key_textview), tmp, GNT_TEXT_FLAG_NORMAL);
 146         g_free(tmp);
 147         gnt_widget_set_name(key_textview, "keystroke");
 148         gnt_box_add_widget(GNT_BOX(vbox), key_textview);
 149
 150         g_signal_connect(G_OBJECT(win), "key_pressed", G_CALLBACK(gnt_bindable_rebinding_grab_key), key_textview);
 151
 152         button_box = gnt_box_new(FALSE, FALSE);
 153
 154         bind_button = gnt_button_new("BIND");
 155         gnt_widget_set_name(bind_button, "bind");
 156         gnt_box_add_widget(GNT_BOX(button_box), bind_button);
 157
 158         cancel_button = gnt_button_new("Cancel");
 159         gnt_widget_set_name(cancel_button, "cancel");
 160         gnt_box_add_widget(GNT_BOX(button_box), cancel_button);
 161
 162         g_signal_connect(G_OBJECT(bind_button), "activate", G_CALLBACK(gnt_bindable_rebinding_rebind), win);
 163         g_signal_connect(G_OBJECT(cancel_button), "activate", G_CALLBACK(gnt_bindable_rebinding_cancel), win);
 164
 165         gnt_box_add_widget(GNT_BOX(vbox), button_box);
 166
 167         gnt_box_add_widget(GNT_BOX(win), vbox);
 168         gnt_widget_show(win);
 169 }
 170
 171 typedef struct
 172 {
 173         GHashTable *hash;
 174         GntTree *tree;
 175 } BindingView;
 176
 177 static void
 178 add_binding(gpointer key, gpointer value, gpointer data)
 179 {
 180         BindingView *bv = data;
 181         GntBindableActionParam *act = value;
 182         const char *name = g_hash_table_lookup(bv->hash, act->action);
 183         if (name && *name) {
 184                 const char *k = gnt_key_lookup(key);
 185                 if (!k)
 186                         k = key;
 187                 gnt_tree_add_row_after(bv->tree, (gpointer)k,
 188                                 gnt_tree_create_row(bv->tree, k, name), NULL, NULL);
 189         }
 190 }
 191
 192 static void
 193 add_action(gpointer key, gpointer value, gpointer data)
 194 {
 195         BindingView *bv = data;
 196         g_hash_table_insert(bv->hash, value, key);
 197 }
 198
 199 static void
 200 gnt_bindable_class_init(GntBindableClass *klass)
 201 {
 202         parent_class = g_type_class_peek_parent(klass);
 203
 204         klass->actions = g_hash_table_new_full(g_str_hash, g_str_equal, g_free,
 205                                 (GDestroyNotify)gnt_bindable_action_free);
 206         klass->bindings = g_hash_table_new_full(g_str_hash, g_str_equal, g_free,
 207                                 (GDestroyNotify)gnt_bindable_action_param_free);
 208
 209         gnt_style_read_actions(G_OBJECT_CLASS_TYPE(klass), GNT_BINDABLE_CLASS(klass));
 210         GNTDEBUG;
 211 }
 212
 213 static gpointer
 214 bindable_clone(GntBindableAction *action)
 215 {
 216         GntBindableAction *ret = g_new0(GntBindableAction, 1);
 217         ret->name = g_strdup(action->name);
 218         ret->u = action->u;
 219         return ret;
 220 }
 221
 222 static gpointer
 223 binding_clone(GntBindableActionParam *param)
 224 {
 225         GntBindableActionParam *p = g_new0(GntBindableActionParam, 1);
 226         p->list = g_list_copy(param->list);
 227         p->action = param->action;
 228         return p;
 229 }
 230
 231 static void
 232 duplicate_hashes(GntBindableClass *klass)
 233 {
 234         /* Duplicate the bindings from parent class */
 235         if (klass->actions) {
 236                 klass->actions = g_hash_table_duplicate(klass->actions, g_str_hash,
 237                                         g_str_equal, g_free, (GDestroyNotify)gnt_bindable_action_free,
 238                                         (GDupFunc)g_strdup, (GDupFunc)bindable_clone);
 239                 klass->bindings = g_hash_table_duplicate(klass->bindings, g_str_hash,
 240                                         g_str_equal, g_free, (GDestroyNotify)gnt_bindable_action_param_free,
 241                                         (GDupFunc)g_strdup, (GDupFunc)binding_clone);
 242         } else {
 243                 klass->actions = g_hash_table_new_full(g_str_hash, g_str_equal, g_free,
 244                                         (GDestroyNotify)gnt_bindable_action_free);
 245                 klass->bindings = g_hash_table_new_full(g_str_hash, g_str_equal, g_free,
 246                                         (GDestroyNotify)gnt_bindable_action_param_free);
 247         }
 248
 249         GNTDEBUG;
 250 }
 251
 252 /******************************************************************************
 253  * GntBindable API
 254  *****************************************************************************/
 255 GType
 256 gnt_bindable_get_gtype(void)
 257 {
 258         static GType type = 0;
 259
 260         if (type == 0) {
 261                 static const GTypeInfo info = {
 262                         sizeof(GntBindableClass),
 263                         (GBaseInitFunc)duplicate_hashes,        /* base_init            */
 264                         NULL,                                   /* base_finalize        */
 265                         (GClassInitFunc)gnt_bindable_class_init,
 266                         NULL,
 267                         NULL,                                   /* class_data           */
 268                         sizeof(GntBindable),
 269                         0,                                              /* n_preallocs          */
 270                         NULL,                                   /* instance_init        */
 271                         NULL                                    /* value_table          */
 272                 };
 273
 274                 type = g_type_register_static(G_TYPE_OBJECT,
 275                                                                           "GntBindable",
 276                                                                           &info, G_TYPE_FLAG_ABSTRACT);
 277         }
 278
 279         return type;
 280 }
 281
 282 /**
 283  * Key Remaps
 284  */
 285 const char *
 286 gnt_bindable_remap_keys(GntBindable *bindable, const char *text)
 287 {
 288         const char *remap = NULL;
 289         GType type = G_OBJECT_TYPE(bindable);
 290         GntBindableClass *klass = GNT_BINDABLE_CLASS(GNT_BINDABLE_GET_CLASS(bindable));
 291
 292         if (klass->remaps == NULL)
 293         {
 294                 klass->remaps = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
 295                 gnt_styles_get_keyremaps(type, klass->remaps);
 296         }
 297
 298         remap = g_hash_table_lookup(klass->remaps, text);
 299
 300         return (remap ? remap : text);
 301 }
 302
 303 /**
 304  * Actions and Bindings
 305  */
 306 gboolean
 307 gnt_bindable_perform_action_named(GntBindable *bindable, const char *name, ...)
 308 {
 309         GntBindableClass *klass = GNT_BINDABLE_CLASS(GNT_BINDABLE_GET_CLASS(bindable));
 310         GList *list = NULL;
 311         va_list args;
 312         GntBindableAction *action;
 313         void *p;
 314
 315         va_start(args, name);
 316         while ((p = va_arg(args, void *)) != NULL)
 317                 list = g_list_append(list, p);
 318         va_end(args);
 319
 320         action = g_hash_table_lookup(klass->actions, name);
 321         if (action && action->u.action) {
 322                 return action->u.action(bindable, list);
 323         }
 324         return FALSE;
 325 }
 326
 327 gboolean
 328 gnt_bindable_perform_action_key(GntBindable *bindable, const char *keys)
 329 {
 330         GntBindableClass *klass = GNT_BINDABLE_CLASS(GNT_BINDABLE_GET_CLASS(bindable));
 331         GntBindableActionParam *param = g_hash_table_lookup(klass->bindings, keys);
 332
 333         if (param && param->action) {
 334                 if (param->list)
 335                         return param->action->u.action(bindable, param->list);
 336                 else
 337                         return param->action->u.action_noparam(bindable);
 338         }
 339         return FALSE;
 340 }
 341
 342 static void
 343 register_binding(GntBindableClass *klass, const char *name, const char *trigger, GList *list)
 344 {
 345         GntBindableActionParam *param;
 346         GntBindableAction *action;
 347
 348         if (name == NULL || *name == '\0') {
 349                 g_hash_table_remove(klass->bindings, (char*)trigger);
 350                 gnt_keys_del_combination(trigger);
 351                 return;
 352         }
 353
 354         action = g_hash_table_lookup(klass->actions, name);
 355         if (!action) {
 356                 g_printerr("GntBindable: Invalid action name %s for %s\n",
 357                                 name, g_type_name(G_OBJECT_CLASS_TYPE(klass)));
 358                 if (list)
 359                         g_list_free(list);
 360                 return;
 361         }
 362
 363         param = g_new0(GntBindableActionParam, 1);
 364         param->action = action;
 365         param->list = list;
 366         g_hash_table_replace(klass->bindings, g_strdup(trigger), param);
 367         gnt_keys_add_combination(trigger);
 368 }
 369
 370 void gnt_bindable_register_binding(GntBindableClass *klass, const char *name,
 371                         const char *trigger, ...)
 372 {
 373         GList *list = NULL;
 374         va_list args;
 375         void *data;
 376
 377         va_start(args, trigger);
 378         while ((data = va_arg(args, void *))) {
 379                 list = g_list_append(list, data);
 380         }
 381         va_end(args);
 382
 383         register_binding(klass, name, trigger, list);
 384 }
 385
 386 void gnt_bindable_class_register_action(GntBindableClass *klass, const char *name,
 387                         GntBindableActionCallback callback, const char *trigger, ...)
 388 {
 389         void *data;
 390         va_list args;
 391         GntBindableAction *action = g_new0(GntBindableAction, 1);
 392         GList *list;
 393
 394         action->name = g_strdup(name);
 395         action->u.action = callback;
 396
 397         g_hash_table_replace(klass->actions, g_strdup(name), action);
 398
 399         if (trigger && *trigger) {
 400                 list = NULL;
 401                 va_start(args, trigger);
 402                 while ((data = va_arg(args, void *))) {
 403                         list = g_list_append(list, data);
 404                 }
 405                 va_end(args);
 406
 407                 register_binding(klass, name, trigger, list);
 408         }
 409 }
 410
 411 void gnt_bindable_action_free(GntBindableAction *action)
 412 {
 413         g_free(action->name);
 414         g_free(action);
 415 }
 416
 417 void gnt_bindable_action_param_free(GntBindableActionParam *param)
 418 {
 419         g_list_free(param->list);   /* XXX: There may be a leak here for string parameters */
 420         g_free(param);
 421 }
 422
 423 GntBindable * gnt_bindable_bindings_view(GntBindable *bind)
 424 {
 425         GntBindable *tree = GNT_BINDABLE(gnt_tree_new_with_columns(2));
 426         GntBindableClass *klass = GNT_BINDABLE_CLASS(GNT_BINDABLE_GET_CLASS(bind));
 427         GHashTable *hash = g_hash_table_new(g_direct_hash, g_direct_equal);
 428         BindingView bv = {hash, GNT_TREE(tree)};
 429
 430         gnt_tree_set_compare_func(bv.tree, (GCompareFunc)g_utf8_collate);
 431         g_hash_table_foreach(klass->actions, add_action, &bv);
 432         g_hash_table_foreach(klass->bindings, add_binding, &bv);
 433         if (GNT_TREE(tree)->list == NULL) {
 434                 gnt_widget_destroy(GNT_WIDGET(tree));
 435                 tree = NULL;
 436         } else
 437                 gnt_tree_adjust_columns(bv.tree);
 438         g_hash_table_destroy(hash);
 439
 440         return tree;
 441 }
 442
 443 static void
 444 reset_binding_window(GntBindableClass *window, gpointer k)
 445 {
 446         GntBindableClass *klass = GNT_BINDABLE_CLASS(k);
 447         klass->help_window = NULL;
 448 }
 449
 450 gboolean
 451 gnt_bindable_build_help_window(GntBindable *bindable)
 452 {
 453         GntWidget *tree;
 454         GntBindableClass *klass = GNT_BINDABLE_GET_CLASS(bindable);
 455         char *title;
 456
 457         tree = GNT_WIDGET(gnt_bindable_bindings_view(bindable));
 458
 459         klass->help_window = GNT_BINDABLE(gnt_window_new());
 460         title = g_strdup_printf("Bindings for %s", g_type_name(G_OBJECT_TYPE(bindable)));
 461         gnt_box_set_title(GNT_BOX(klass->help_window), title);
 462         if (tree) {
 463                 g_signal_connect(G_OBJECT(tree), "activate", G_CALLBACK(gnt_bindable_rebinding_activate), bindable);
 464                 gnt_box_add_widget(GNT_BOX(klass->help_window), tree);
 465         } else
 466                 gnt_box_add_widget(GNT_BOX(klass->help_window), gnt_label_new("This widget has no customizable bindings."));
 467
 468         g_signal_connect(G_OBJECT(klass->help_window), "destroy", G_CALLBACK(reset_binding_window), klass);
 469         gnt_widget_show(GNT_WIDGET(klass->help_window));
 470         g_free(title);
 471
 472         return TRUE;
 473 }
 474