Pileus Git - ~andy/gtk/blob - gtk/gtkinputdialog.c

   1 /* GTK - The GIMP Toolkit
   2  * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Library General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19
  20 /*
  21  * gtkinputdialog.c
  22  *
  23  * Copyright 1997 Owen Taylor <owt1@cornell.edu>
  24  *
  25  */
  26
  27 #include <stdio.h>
  28 #include <stdlib.h>
  29 #include <ctype.h>
  30 #include "gdk/gdkkeysyms.h"
  31 #include "gtkbutton.h"
  32 #include "gtkentry.h"
  33 #include "gtkhbox.h"
  34 #include "gtkhseparator.h"
  35 #include "gtkinputdialog.h"
  36 #include "gtklabel.h"
  37 #include "gtklistitem.h"
  38 #include "gtkmain.h"
  39 #include "gtkmenu.h"
  40 #include "gtkmenuitem.h"
  41 #include "gtknotebook.h"
  42 #include "gtkoptionmenu.h"
  43 #include "gtkscrolledwindow.h"
  44 #include "gtksignal.h"
  45 #include "gtktable.h"
  46 #include "gtkvbox.h"
  47
  48 typedef void (*GtkInputDialogSignal1) (GtkObject *object,
  49                                   int   arg1,
  50                                   gpointer   data);
  51
  52 typedef struct {
  53   gint       index;
  54   GtkWidget *entry;
  55   GtkInputDialog *inputd;
  56 } GtkInputKeyInfo;
  57
  58 enum
  59 {
  60   ENABLE_DEVICE,
  61   DISABLE_DEVICE,
  62   LAST_SIGNAL
  63 };
  64
  65
  66 #define AXIS_LIST_WIDTH 160
  67 #define AXIS_LIST_HEIGHT 175
  68
  69 #define KEYS_LIST_WIDTH 200
  70 #define KEYS_LIST_HEIGHT 175
  71
  72 /* Forward declarations */
  73
  74 static void gtk_input_dialog_marshal_signal1 (GtkObject      *object,
  75                                               GtkSignalFunc   func,
  76                                               gpointer        func_data,
  77                                               GtkArg *args);
  78 static void gtk_input_dialog_class_init (GtkInputDialogClass *klass);
  79 static void gtk_input_dialog_init (GtkInputDialog *inputd);
  80 static GdkDeviceInfo *gtk_input_dialog_get_device_info(guint32 deviceid);
  81 static void gtk_input_dialog_set_device(GtkWidget *widget, gpointer data);
  82 static void gtk_input_dialog_finalize (GtkObject *object);
  83 static void gtk_input_dialog_set_mapping_mode(GtkWidget *w,
  84                                               gpointer data);
  85 static void gtk_input_dialog_set_axis(GtkWidget *widget, gpointer data);
  86 static void gtk_input_dialog_fill_axes (GtkInputDialog *inputd,
  87                                         GdkDeviceInfo *info);
  88 static void gtk_input_dialog_set_key (GtkInputKeyInfo *key,
  89                                       guint keyval,
  90                                       GdkModifierType modifiers);
  91 static gint gtk_input_dialog_key_press (GtkWidget *widget,
  92                                         GdkEventKey *event,
  93                                         GtkInputKeyInfo *key);
  94 static void gtk_input_dialog_clear_key (GtkWidget *widget,
  95                                         GtkInputKeyInfo *key);
  96 static void gtk_input_dialog_destroy_key (GtkWidget *widget,
  97                                           GtkInputKeyInfo *key);
  98 static void gtk_input_dialog_fill_keys (GtkInputDialog *inputd,
  99                                         GdkDeviceInfo *info);
 100
 101 static GtkObjectClass *parent_class = NULL;
 102 static guint input_dialog_signals[LAST_SIGNAL] = { 0 };
 103
 104 static void
 105 gtk_input_dialog_marshal_signal1 (GtkObject      *object,
 106                                   GtkSignalFunc   func,
 107                                   gpointer        func_data,
 108                                   GtkArg *args)
 109 {
 110   GtkInputDialogSignal1 rfunc;
 111
 112   rfunc = (GtkInputDialogSignal1) func;
 113   (* rfunc) (object, GTK_VALUE_INT(args[0]), func_data);
 114 }
 115
 116 static GdkDeviceInfo *
 117 gtk_input_dialog_get_device_info(guint32 deviceid)
 118 {
 119   GList *tmp_list = gdk_input_list_devices();
 120   while (tmp_list)
 121     {
 122       if (((GdkDeviceInfo *)tmp_list->data)->deviceid == deviceid)
 123         return (GdkDeviceInfo *)tmp_list->data;
 124       tmp_list = tmp_list->next;
 125     }
 126
 127   return NULL;
 128 }
 129
 130 guint
 131 gtk_input_dialog_get_type ()
 132 {
 133   static guint input_dialog_type = 0;
 134
 135   if (!input_dialog_type)
 136     {
 137       GtkTypeInfo input_dialog_info =
 138       {
 139         "GtkInputDialog",
 140         sizeof (GtkInputDialog),
 141         sizeof (GtkInputDialogClass),
 142         (GtkClassInitFunc) gtk_input_dialog_class_init,
 143         (GtkObjectInitFunc) gtk_input_dialog_init,
 144         (GtkArgSetFunc) NULL,
 145         (GtkArgGetFunc) NULL,
 146       };
 147
 148       input_dialog_type = gtk_type_unique (gtk_dialog_get_type (),
 149                                            &input_dialog_info);
 150     }
 151
 152   return input_dialog_type;
 153 }
 154
 155 static void
 156 gtk_input_dialog_class_init (GtkInputDialogClass *klass)
 157 {
 158   GtkObjectClass *object_class;
 159
 160   object_class = (GtkObjectClass*) klass;
 161
 162   parent_class = gtk_type_class (gtk_dialog_get_type ());
 163
 164   input_dialog_signals[ENABLE_DEVICE] =
 165     gtk_signal_new ("enable_device",
 166                     GTK_RUN_LAST,
 167                     object_class->type,
 168                     GTK_SIGNAL_OFFSET (GtkInputDialogClass, enable_device),
 169                     gtk_input_dialog_marshal_signal1,
 170                     GTK_TYPE_NONE, 1, GTK_TYPE_INT);
 171
 172   input_dialog_signals[DISABLE_DEVICE] =
 173     gtk_signal_new ("disable_device",
 174                     GTK_RUN_LAST,
 175                     object_class->type,
 176                     GTK_SIGNAL_OFFSET (GtkInputDialogClass, disable_device),
 177                     gtk_input_dialog_marshal_signal1,
 178                     GTK_TYPE_NONE, 1, GTK_TYPE_INT);
 179
 180   gtk_object_class_add_signals (object_class, input_dialog_signals,
 181                                 LAST_SIGNAL);
 182
 183
 184   object_class->finalize = gtk_input_dialog_finalize;
 185   klass->enable_device = NULL;
 186   klass->disable_device = NULL;
 187 }
 188
 189 static void
 190 gtk_input_dialog_init (GtkInputDialog *inputd)
 191 {
 192   GtkWidget *vbox;
 193   GtkWidget *util_box;
 194   GtkWidget *label;
 195   GtkWidget *device_menu;
 196   GtkWidget *mapping_menu;
 197   GtkWidget *menuitem;
 198   GtkWidget *optionmenu;
 199   GtkWidget *separator;
 200   GtkWidget *notebook;
 201
 202   GList *tmp_list;
 203   GList *device_info;
 204
 205   device_info = gdk_input_list_devices();
 206
 207   /* shell and main vbox */
 208
 209   gtk_window_set_title (GTK_WINDOW (inputd), "Input");
 210
 211   vbox = gtk_vbox_new (FALSE, 4);
 212   gtk_container_border_width(GTK_CONTAINER (vbox), 5);
 213   gtk_box_pack_start (GTK_BOX (GTK_DIALOG (inputd)->vbox), vbox, TRUE, TRUE, 0);
 214
 215   if (g_list_length(device_info) <= 1) /* only core device */
 216     {
 217       label = gtk_label_new ("No input devices");
 218       gtk_container_add (GTK_CONTAINER (vbox), label);
 219
 220       gtk_widget_show (label);
 221     }
 222   else
 223     {
 224       /* menu for selecting device */
 225
 226       device_menu = gtk_menu_new ();
 227
 228       for (tmp_list = device_info; tmp_list; tmp_list = tmp_list->next) {
 229         GdkDeviceInfo *info = (GdkDeviceInfo *)(tmp_list->data);
 230         if (info->deviceid != GDK_CORE_POINTER)
 231           {
 232             menuitem = gtk_menu_item_new_with_label(info->name);
 233
 234             gtk_menu_append(GTK_MENU(device_menu),menuitem);
 235             gtk_widget_show(menuitem);
 236             gtk_object_set_user_data (GTK_OBJECT (menuitem), inputd);
 237             gtk_signal_connect (GTK_OBJECT (menuitem), "activate",
 238                                 (GtkSignalFunc) gtk_input_dialog_set_device,
 239                                 (gpointer)((long)info->deviceid));
 240           }
 241       }
 242
 243       util_box = gtk_hbox_new (FALSE, 2);
 244       gtk_box_pack_start (GTK_BOX (vbox), util_box, FALSE, FALSE, 0);
 245
 246       label = gtk_label_new("Device:");
 247       gtk_box_pack_start (GTK_BOX (util_box), label, FALSE, FALSE, 2);
 248
 249       optionmenu = gtk_option_menu_new ();
 250       gtk_box_pack_start (GTK_BOX (util_box), optionmenu, TRUE, TRUE, 2);
 251       gtk_widget_show (optionmenu);
 252       gtk_option_menu_set_menu (GTK_OPTION_MENU (optionmenu), device_menu);
 253
 254       gtk_widget_show (label);
 255
 256       /* Device options */
 257
 258       /* mapping mode option menu */
 259
 260       mapping_menu = gtk_menu_new ();
 261
 262       menuitem = gtk_menu_item_new_with_label("Disabled");
 263       gtk_menu_append(GTK_MENU(mapping_menu),menuitem);
 264       gtk_object_set_user_data (GTK_OBJECT (menuitem), inputd);
 265       gtk_widget_show(menuitem);
 266       gtk_signal_connect (GTK_OBJECT (menuitem), "activate",
 267                           (GtkSignalFunc) gtk_input_dialog_set_mapping_mode,
 268                           (gpointer)((long)GDK_MODE_DISABLED));
 269
 270       menuitem = gtk_menu_item_new_with_label("Screen");
 271       gtk_menu_append(GTK_MENU(mapping_menu),menuitem);
 272       gtk_object_set_user_data (GTK_OBJECT (menuitem), inputd);
 273       gtk_widget_show(menuitem);
 274       gtk_signal_connect (GTK_OBJECT (menuitem), "activate",
 275                           (GtkSignalFunc) gtk_input_dialog_set_mapping_mode,
 276                           (gpointer)((long)GDK_MODE_SCREEN));
 277
 278       menuitem = gtk_menu_item_new_with_label("Window");
 279       gtk_menu_append(GTK_MENU(mapping_menu),menuitem);
 280       gtk_object_set_user_data (GTK_OBJECT (menuitem), inputd);
 281       gtk_widget_show(menuitem);
 282       gtk_signal_connect (GTK_OBJECT (menuitem), "activate",
 283                           (GtkSignalFunc) gtk_input_dialog_set_mapping_mode,
 284                           (gpointer)((long)GDK_MODE_WINDOW));
 285
 286       label = gtk_label_new("Mode: ");
 287       gtk_box_pack_start (GTK_BOX (util_box), label, FALSE, FALSE, 2);
 288
 289       inputd->mode_optionmenu = gtk_option_menu_new ();
 290       gtk_box_pack_start (GTK_BOX (util_box), inputd->mode_optionmenu, FALSE, FALSE, 2);
 291       gtk_widget_show (inputd->mode_optionmenu);
 292       gtk_option_menu_set_menu (GTK_OPTION_MENU (inputd->mode_optionmenu), mapping_menu);
 293
 294       gtk_widget_show(label);
 295
 296       gtk_widget_show (util_box);
 297
 298       util_box = gtk_hbox_new (FALSE, 2);
 299       gtk_box_pack_start (GTK_BOX(vbox), util_box, FALSE, FALSE, 0);
 300
 301       gtk_widget_show (label);
 302       gtk_widget_show (util_box);
 303
 304       separator = gtk_hseparator_new();
 305       gtk_box_pack_start (GTK_BOX (vbox), separator, FALSE, TRUE, 0);
 306       gtk_widget_show (separator);
 307
 308       /* Notebook */
 309
 310       notebook = gtk_notebook_new ();
 311       gtk_box_pack_start (GTK_BOX (vbox), notebook, TRUE, TRUE, 0);
 312       gtk_widget_show (notebook);
 313
 314       /*  The axis listbox  */
 315
 316       label = gtk_label_new ("Axes");
 317
 318       inputd->axis_listbox = gtk_scrolled_window_new (NULL, NULL);
 319       gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW(inputd->axis_listbox),
 320                                       GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
 321
 322       gtk_widget_set_usize (inputd->axis_listbox, AXIS_LIST_WIDTH, AXIS_LIST_HEIGHT);
 323       gtk_notebook_append_page (GTK_NOTEBOOK(notebook),
 324                                 inputd->axis_listbox, label);
 325
 326       gtk_widget_show (inputd->axis_listbox);
 327
 328       inputd->axis_list = 0;
 329
 330       /* Keys listbox */
 331
 332       label = gtk_label_new ("Keys");
 333
 334       inputd->keys_listbox = gtk_scrolled_window_new (NULL, NULL);
 335       gtk_widget_set_usize (inputd->keys_listbox, KEYS_LIST_WIDTH, KEYS_LIST_HEIGHT);
 336       gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW(inputd->keys_listbox),
 337                                       GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
 338       gtk_notebook_append_page (GTK_NOTEBOOK(notebook),
 339                                 inputd->keys_listbox, label);
 340
 341       gtk_widget_show (inputd->keys_listbox);
 342
 343       inputd->keys_list = 0;
 344
 345       /* ...set_device expects to get input dialog from widget user data */
 346       gtk_object_set_user_data (GTK_OBJECT (inputd), inputd);
 347       gtk_input_dialog_set_device(GTK_WIDGET(inputd), (gpointer)((long)
 348                               ((GdkDeviceInfo *)device_info->data)->deviceid));
 349
 350     }
 351
 352   /* We create the save button in any case, so that clients can
 353      connect to it, without paying attention to whether it exits */
 354   inputd->save_button = gtk_button_new_with_label ("Save");
 355   GTK_WIDGET_SET_FLAGS (inputd->save_button, GTK_CAN_DEFAULT);
 356   gtk_box_pack_start (GTK_BOX (GTK_DIALOG(inputd)->action_area),
 357                       inputd->save_button, TRUE, TRUE, 0);
 358   gtk_widget_show (inputd->save_button);
 359
 360   if (g_list_length(device_info) <= 1) /* only core device */
 361     gtk_widget_set_sensitive(inputd->save_button, FALSE);
 362
 363   inputd->close_button = gtk_button_new_with_label ("Close");
 364   GTK_WIDGET_SET_FLAGS (inputd->close_button, GTK_CAN_DEFAULT);
 365   gtk_box_pack_start (GTK_BOX (GTK_DIALOG(inputd)->action_area),
 366                       inputd->close_button, TRUE, TRUE, 0);
 367
 368   gtk_widget_show (inputd->close_button);
 369   gtk_widget_grab_default (inputd->close_button);
 370
 371   gtk_widget_show (vbox);
 372 }
 373
 374
 375 GtkWidget*
 376 gtk_input_dialog_new (void)
 377 {
 378   GtkInputDialog *inputd;
 379
 380   inputd = gtk_type_new (gtk_input_dialog_get_type ());
 381
 382   return GTK_WIDGET (inputd);
 383 }
 384
 385 static void
 386 gtk_input_dialog_set_device(GtkWidget *widget, gpointer data)
 387 {
 388   guint32 deviceid = (guint32)data;
 389   GdkDeviceInfo *info;
 390
 391   GtkInputDialog *inputd = GTK_INPUT_DIALOG(
 392                 gtk_object_get_user_data(GTK_OBJECT(widget)));
 393
 394   inputd->current_device = deviceid;
 395   info = gtk_input_dialog_get_device_info((guint32)data);
 396
 397   gtk_input_dialog_fill_axes(inputd, info);
 398   gtk_input_dialog_fill_keys(inputd, info);
 399
 400   gtk_option_menu_set_history(GTK_OPTION_MENU(inputd->mode_optionmenu),
 401                               info->mode);
 402 }
 403
 404 static void
 405 gtk_input_dialog_finalize (GtkObject *object)
 406 {
 407   /*  GtkInputDialog *inputd = GTK_INPUT_DIALOG (object); */
 408
 409   /* Clean up ? */
 410
 411   (* GTK_OBJECT_CLASS (parent_class)->finalize) (object);
 412 }
 413
 414 static void
 415 gtk_input_dialog_set_mapping_mode(GtkWidget *w,
 416                                   gpointer data)
 417 {
 418   GtkInputDialog *inputd = GTK_INPUT_DIALOG(
 419                 gtk_object_get_user_data(GTK_OBJECT(w)));
 420   GdkDeviceInfo *info = gtk_input_dialog_get_device_info (inputd->current_device);
 421   GdkInputMode old_mode = info->mode;
 422   GdkInputMode mode = (GdkInputMode)data;
 423
 424   if (mode != old_mode)
 425     {
 426       if (gdk_input_set_mode(inputd->current_device, mode))
 427         {
 428           if (mode == GDK_MODE_DISABLED)
 429             gtk_signal_emit (GTK_OBJECT (inputd),
 430                              input_dialog_signals[DISABLE_DEVICE],
 431                              info->deviceid);
 432           else
 433             gtk_signal_emit (GTK_OBJECT (inputd),
 434                              input_dialog_signals[ENABLE_DEVICE],
 435                              info->deviceid);
 436         }
 437       else
 438         gtk_option_menu_set_history (GTK_OPTION_MENU (inputd->mode_optionmenu),
 439                                      old_mode);
 440
 441       /* FIXME: error dialog ? */
 442     }
 443 }
 444
 445 static void
 446 gtk_input_dialog_set_axis(GtkWidget *widget, gpointer data)
 447 {
 448   GdkAxisUse use = (GdkAxisUse)data & 0xFFFF;
 449   GdkAxisUse old_use;
 450   GdkAxisUse *new_axes;
 451   GtkInputDialog *inputd = GTK_INPUT_DIALOG (gtk_object_get_user_data (GTK_OBJECT (widget)));
 452   GdkDeviceInfo *info = gtk_input_dialog_get_device_info (inputd->current_device);
 453
 454   gint axis = ((gint)data >> 16) - 1;
 455   gint old_axis;
 456   int i;
 457
 458   new_axes = g_new (GdkAxisUse, info->num_axes);
 459   old_axis = -1;
 460   for (i=0;i<info->num_axes;i++)
 461     {
 462       new_axes[i] = info->axes[i];
 463       if (info->axes[i] == use)
 464         old_axis = i;
 465     }
 466
 467   if (axis != -1)
 468     old_use = info->axes[axis];
 469   else
 470     old_use = GDK_AXIS_IGNORE;
 471
 472   if (axis == old_axis)
 473     return;
 474
 475   /* we must always have an x and a y axis */
 476   if ((axis == -1 && (use == GDK_AXIS_X || use == GDK_AXIS_Y)) ||
 477       (old_axis == -1 && (old_use == GDK_AXIS_X || old_use == GDK_AXIS_Y)))
 478     {
 479       gtk_option_menu_set_history (
 480                 GTK_OPTION_MENU (inputd->axis_items[use]),
 481                 old_axis + 1);
 482     }
 483   else
 484     {
 485       if (axis != -1)
 486         new_axes[axis] = use;
 487
 488       if (old_axis != -1)
 489         new_axes[old_axis] = old_use;
 490
 491       if (old_use != GDK_AXIS_IGNORE)
 492         {
 493           gtk_option_menu_set_history (
 494                 GTK_OPTION_MENU (inputd->axis_items[old_use]),
 495                 old_axis + 1);
 496         }
 497       gdk_input_set_axes (info->deviceid, new_axes);
 498     }
 499
 500   g_free (new_axes);
 501 }
 502
 503 static void
 504 gtk_input_dialog_fill_axes(GtkInputDialog *inputd, GdkDeviceInfo *info)
 505 {
 506   static char *axis_use_strings[GDK_AXIS_LAST] =
 507   {
 508     "",
 509     "X",
 510     "Y",
 511     "Pressure",
 512     "X Tilt",
 513     "Y Tilt"
 514   };
 515
 516   int i,j;
 517   GtkWidget *menu;
 518   GtkWidget *option_menu;
 519   GtkWidget *label;
 520
 521   /* remove all the old items */
 522   if (inputd->axis_list)
 523     {
 524       gtk_widget_hide (inputd->axis_list);      /* suppress resizes (or get warnings) */
 525       gtk_widget_destroy (inputd->axis_list);
 526     }
 527   inputd->axis_list = gtk_table_new (GDK_AXIS_LAST, 2, 0);
 528   gtk_container_add (GTK_CONTAINER (inputd->axis_listbox), inputd->axis_list);
 529   gtk_widget_show (inputd->axis_list);
 530
 531   gtk_widget_realize (inputd->axis_list);
 532   gdk_window_set_background (inputd->axis_list->window,
 533                              &inputd->axis_list->style->base[GTK_STATE_NORMAL]);
 534
 535   for (i=GDK_AXIS_X;i<GDK_AXIS_LAST;i++)
 536     {
 537       /* create the label */
 538
 539       label = gtk_label_new(axis_use_strings[i]);
 540       gtk_table_attach (GTK_TABLE (inputd->axis_list), label, 0, 1, i, i+1,
 541                         0, 0, 2, 2);
 542
 543       /* and the use option menu */
 544       menu = gtk_menu_new();
 545
 546       for (j = -1; j < info->num_axes; j++)
 547         {
 548           char buffer[16];
 549           GtkWidget *menu_item;
 550
 551           if (j == -1)
 552             menu_item = gtk_menu_item_new_with_label ("none");
 553           else
 554             {
 555               sprintf (buffer,"%d",j+1);
 556               menu_item = gtk_menu_item_new_with_label (buffer);
 557             }
 558           gtk_object_set_user_data (GTK_OBJECT (menu_item), inputd);
 559           gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
 560                               (GtkSignalFunc) gtk_input_dialog_set_axis,
 561                               (gpointer) ((long) (0x10000 * (j + 1) + i)));
 562           gtk_widget_show (menu_item);
 563           gtk_menu_append (GTK_MENU (menu), menu_item);
 564         }
 565
 566       inputd->axis_items[i] = option_menu = gtk_option_menu_new ();
 567       gtk_table_attach (GTK_TABLE (inputd->axis_list), option_menu,
 568                         1, 2, i, i+1, 0, 0, 2, 2);
 569
 570       gtk_widget_show (option_menu);
 571       gtk_option_menu_set_menu (GTK_OPTION_MENU (option_menu), menu);
 572       for (j = 0; j < info->num_axes; j++)
 573         if (info->axes[j] == (GdkAxisUse) i)
 574           {
 575             gtk_option_menu_set_history (GTK_OPTION_MENU (option_menu), j+1);
 576             break;
 577           }
 578
 579       gtk_widget_show (label);
 580     }
 581 }
 582
 583 static void
 584 gtk_input_dialog_clear_key (GtkWidget *widget, GtkInputKeyInfo *key)
 585 {
 586   gtk_entry_set_text (GTK_ENTRY(key->entry), "(disabled)");
 587   gdk_input_set_key (key->inputd->current_device, key->index, 0, 0);
 588 }
 589
 590 static void
 591 gtk_input_dialog_set_key (GtkInputKeyInfo *key,
 592                           guint keyval, GdkModifierType modifiers)
 593 {
 594   GString *str;
 595   gchar chars[2];
 596
 597   if (keyval)
 598     {
 599       str = g_string_new("");
 600
 601       if (modifiers & GDK_SHIFT_MASK)
 602         g_string_append (str, "Shft+");
 603       if (modifiers & GDK_CONTROL_MASK)
 604         g_string_append (str, "Ctl+");
 605       if (modifiers & GDK_MOD1_MASK)
 606         g_string_append (str, "Alt+");
 607
 608       if ((keyval >= 0x20) && (keyval <= 0xFF))
 609         {
 610           chars[0] = keyval;
 611           chars[1] = 0;
 612           g_string_append (str, chars);
 613         }
 614       else
 615         g_string_append (str, "(unknown)");
 616       gtk_entry_set_text (GTK_ENTRY(key->entry), str->str);
 617
 618       g_string_free (str, TRUE);
 619     }
 620   else
 621     {
 622       gtk_entry_set_text (GTK_ENTRY(key->entry), "(disabled)");
 623     }
 624 }
 625
 626 static gint
 627 gtk_input_dialog_key_press (GtkWidget *widget,
 628                             GdkEventKey *event,
 629                             GtkInputKeyInfo *key)
 630 {
 631   gtk_input_dialog_set_key (key, event->keyval, event->state & 0xFF);
 632   gdk_input_set_key (key->inputd->current_device, key->index,
 633                      event->keyval, event->state & 0xFF);
 634
 635   gtk_signal_emit_stop_by_name (GTK_OBJECT(widget), "key_press_event");
 636
 637   return TRUE;
 638 }
 639
 640 static void
 641 gtk_input_dialog_destroy_key (GtkWidget *widget, GtkInputKeyInfo *key)
 642 {
 643   g_free (key);
 644 }
 645
 646 static void
 647 gtk_input_dialog_fill_keys(GtkInputDialog *inputd, GdkDeviceInfo *info)
 648 {
 649   int i;
 650   GtkWidget *label;
 651   GtkWidget *button;
 652
 653   char buffer[16];
 654
 655   /* remove all the old items */
 656   if (inputd->keys_list)
 657     {
 658       gtk_widget_hide (inputd->keys_list);      /* suppress resizes (or get warnings) */
 659       gtk_widget_destroy (inputd->keys_list);
 660     }
 661
 662   inputd->keys_list = gtk_table_new (info->num_keys, 3, FALSE);
 663   gtk_container_add (GTK_CONTAINER (inputd->keys_listbox), inputd->keys_list);
 664   gtk_widget_show (inputd->keys_list);
 665
 666   gtk_widget_realize (inputd->keys_list);
 667   gdk_window_set_background (inputd->keys_list->window,
 668                              &inputd->keys_list->style->base[GTK_STATE_NORMAL]);
 669
 670   for (i=0;i<info->num_keys;i++)
 671     {
 672       GtkInputKeyInfo *key = g_new (GtkInputKeyInfo, 1);
 673       key->index = i;
 674       key->inputd = inputd;
 675
 676       /* create the label */
 677
 678       sprintf(buffer, "%d", i+1);
 679       label = gtk_label_new(buffer);
 680       gtk_table_attach (GTK_TABLE (inputd->keys_list), label, 0, 1, i, i+1,
 681                         0, 0, 2, 2);
 682       gtk_widget_show (label);
 683
 684       /* the entry */
 685
 686       key->entry = gtk_entry_new ();
 687       gtk_table_attach (GTK_TABLE (inputd->keys_list), key->entry, 1, 2, i, i+1,
 688                         GTK_EXPAND | GTK_FILL , 0, 2, 2);
 689       gtk_widget_show (key->entry);
 690
 691       gtk_signal_connect (GTK_OBJECT(key->entry), "key_press_event",
 692                           GTK_SIGNAL_FUNC (gtk_input_dialog_key_press), key);
 693       gtk_signal_connect (GTK_OBJECT(key->entry), "destroy",
 694                           GTK_SIGNAL_FUNC (gtk_input_dialog_destroy_key),
 695                           key);
 696
 697       /* and clear button */
 698
 699       button = gtk_button_new_with_label ("clear");
 700       gtk_table_attach (GTK_TABLE (inputd->keys_list), button, 2, 3, i, i+1,
 701                         0, 0, 2, 2);
 702       gtk_widget_show (button);
 703
 704       gtk_signal_connect (GTK_OBJECT(button), "clicked",
 705                           GTK_SIGNAL_FUNC (gtk_input_dialog_clear_key), key);
 706
 707       gtk_input_dialog_set_key (key, info->keys[i].keyval,
 708                                 info->keys[i].modifiers);
 709     }
 710 }