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