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

   1 /* gtkcellrendereraccel.h
   2  * Copyright (C) 2000  Red Hat, Inc.,  Jonathan Blandford <jrb@redhat.com>
   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 #include "config.h"
  21 #include "gtkintl.h"
  22 #include "gtkaccelgroup.h"
  23 #include "gtkmarshalers.h"
  24 #include "gtkcellrendereraccel.h"
  25 #include "gtklabel.h"
  26 #include "gtkeventbox.h"
  27 #include "gtkmain.h"
  28 #include "gtkprivate.h"
  29 #include "gdk/gdkkeysyms.h"
  30
  31
  32 static void gtk_cell_renderer_accel_get_property (GObject         *object,
  33                                                   guint            param_id,
  34                                                   GValue          *value,
  35                                                   GParamSpec      *pspec);
  36 static void gtk_cell_renderer_accel_set_property (GObject         *object,
  37                                                   guint            param_id,
  38                                                   const GValue    *value,
  39                                                   GParamSpec      *pspec);
  40 static void gtk_cell_renderer_accel_get_size     (GtkCellRenderer *cell,
  41                                                   GtkWidget       *widget,
  42                                                   GdkRectangle    *cell_area,
  43                                                   gint            *x_offset,
  44                                                   gint            *y_offset,
  45                                                   gint            *width,
  46                                                   gint            *height);
  47 static GtkCellEditable *
  48            gtk_cell_renderer_accel_start_editing (GtkCellRenderer *cell,
  49                                                   GdkEvent        *event,
  50                                                   GtkWidget       *widget,
  51                                                   const gchar     *path,
  52                                                   GdkRectangle    *background_area,
  53                                                   GdkRectangle    *cell_area,
  54                                                   GtkCellRendererState flags);
  55 static gchar *convert_keysym_state_to_string     (GtkCellRendererAccel *accel,
  56                                                   guint                 keysym,
  57                                                   GdkModifierType       mask,
  58                                                   guint                 keycode);
  59
  60 enum {
  61   ACCEL_EDITED,
  62   ACCEL_CLEARED,
  63   LAST_SIGNAL
  64 };
  65
  66 enum {
  67   PROP_0,
  68   PROP_ACCEL_KEY,
  69   PROP_ACCEL_MODS,
  70   PROP_KEYCODE,
  71   PROP_ACCEL_MODE
  72 };
  73
  74 struct _GtkCellRendererAccelPriv
  75 {
  76   GtkCellRendererAccelMode accel_mode;
  77
  78   GtkWidget *edit_widget;
  79   GtkWidget *grab_widget;
  80   GtkWidget *sizing_label;
  81
  82   GdkDevice *grab_keyboard;
  83   GdkDevice *grab_pointer;
  84
  85   GdkModifierType accel_mods;
  86
  87   guint accel_key;
  88   guint keycode;
  89 };
  90
  91 static guint signals[LAST_SIGNAL] = { 0 };
  92
  93 G_DEFINE_TYPE (GtkCellRendererAccel, gtk_cell_renderer_accel, GTK_TYPE_CELL_RENDERER_TEXT)
  94
  95 static void
  96 gtk_cell_renderer_accel_init (GtkCellRendererAccel *cell_accel)
  97 {
  98   gchar *text;
  99
 100   cell_accel->priv = G_TYPE_INSTANCE_GET_PRIVATE (cell_accel,
 101                                                   GTK_TYPE_CELL_RENDERER_ACCEL,
 102                                                   GtkCellRendererAccelPriv);
 103
 104   text = convert_keysym_state_to_string (cell_accel, 0, 0, 0);
 105   g_object_set (cell_accel, "text", text, NULL);
 106   g_free (text);
 107 }
 108
 109 static void
 110 gtk_cell_renderer_accel_class_init (GtkCellRendererAccelClass *cell_accel_class)
 111 {
 112   GObjectClass *object_class;
 113   GtkCellRendererClass *cell_renderer_class;
 114
 115   object_class = G_OBJECT_CLASS (cell_accel_class);
 116   cell_renderer_class = GTK_CELL_RENDERER_CLASS (cell_accel_class);
 117
 118   object_class->set_property = gtk_cell_renderer_accel_set_property;
 119   object_class->get_property = gtk_cell_renderer_accel_get_property;
 120
 121   cell_renderer_class->get_size      = gtk_cell_renderer_accel_get_size;
 122   cell_renderer_class->start_editing = gtk_cell_renderer_accel_start_editing;
 123
 124   /**
 125    * GtkCellRendererAccel:accel-key:
 126    *
 127    * The keyval of the accelerator.
 128    *
 129    * Since: 2.10
 130    */
 131   g_object_class_install_property (object_class,
 132                                    PROP_ACCEL_KEY,
 133                                    g_param_spec_uint ("accel-key",
 134                                                      P_("Accelerator key"),
 135                                                      P_("The keyval of the accelerator"),
 136                                                       0,
 137                                                       G_MAXINT,
 138                                                       0,
 139                                                       GTK_PARAM_READWRITE));
 140
 141   /**
 142    * GtkCellRendererAccel:accel-mods:
 143    *
 144    * The modifier mask of the accelerator.
 145    *
 146    * Since: 2.10
 147    */
 148   g_object_class_install_property (object_class,
 149                                    PROP_ACCEL_MODS,
 150                                    g_param_spec_flags ("accel-mods",
 151                                                        P_("Accelerator modifiers"),
 152                                                        P_("The modifier mask of the accelerator"),
 153                                                        GDK_TYPE_MODIFIER_TYPE,
 154                                                        0,
 155                                                        GTK_PARAM_READWRITE));
 156
 157   /**
 158    * GtkCellRendererAccel:keycode:
 159    *
 160    * The hardware keycode of the accelerator. Note that the hardware keycode is
 161    * only relevant if the key does not have a keyval. Normally, the keyboard
 162    * configuration should assign keyvals to all keys.
 163    *
 164    * Since: 2.10
 165    */
 166   g_object_class_install_property (object_class,
 167                                    PROP_KEYCODE,
 168                                    g_param_spec_uint ("keycode",
 169                                                       P_("Accelerator keycode"),
 170                                                       P_("The hardware keycode of the accelerator"),
 171                                                       0,
 172                                                       G_MAXINT,
 173                                                       0,
 174                                                       GTK_PARAM_READWRITE));
 175
 176   /**
 177    * GtkCellRendererAccel:accel-mode:
 178    *
 179    * Determines if the edited accelerators are GTK+ accelerators. If
 180    * they are, consumed modifiers are suppressed, only accelerators
 181    * accepted by GTK+ are allowed, and the accelerators are rendered
 182    * in the same way as they are in menus.
 183    *
 184    * Since: 2.10
 185    */
 186   g_object_class_install_property (object_class,
 187                                    PROP_ACCEL_MODE,
 188                                    g_param_spec_enum ("accel-mode",
 189                                                       P_("Accelerator Mode"),
 190                                                       P_("The type of accelerators"),
 191                                                       GTK_TYPE_CELL_RENDERER_ACCEL_MODE,
 192                                                       GTK_CELL_RENDERER_ACCEL_MODE_GTK,
 193                                                       GTK_PARAM_READWRITE));
 194
 195   /**
 196    * GtkCellRendererAccel::accel-edited:
 197    * @accel: the object reveiving the signal
 198    * @path_string: the path identifying the row of the edited cell
 199    * @accel_key: the new accelerator keyval
 200    * @accel_mods: the new acclerator modifier mask
 201    * @hardware_keycode: the keycode of the new accelerator
 202    *
 203    * Gets emitted when the user has selected a new accelerator.
 204    *
 205    * Since: 2.10
 206    */
 207   signals[ACCEL_EDITED] = g_signal_new (I_("accel-edited"),
 208                                         GTK_TYPE_CELL_RENDERER_ACCEL,
 209                                         G_SIGNAL_RUN_LAST,
 210                                         G_STRUCT_OFFSET (GtkCellRendererAccelClass, accel_edited),
 211                                         NULL, NULL,
 212                                         _gtk_marshal_VOID__STRING_UINT_FLAGS_UINT,
 213                                         G_TYPE_NONE, 4,
 214                                         G_TYPE_STRING,
 215                                         G_TYPE_UINT,
 216                                         GDK_TYPE_MODIFIER_TYPE,
 217                                         G_TYPE_UINT);
 218
 219   /**
 220    * GtkCellRendererAccel::accel-cleared:
 221    * @accel: the object reveiving the signal
 222    * @path_string: the path identifying the row of the edited cell
 223    *
 224    * Gets emitted when the user has removed the accelerator.
 225    *
 226    * Since: 2.10
 227    */
 228   signals[ACCEL_CLEARED] = g_signal_new (I_("accel-cleared"),
 229                                          GTK_TYPE_CELL_RENDERER_ACCEL,
 230                                          G_SIGNAL_RUN_LAST,
 231                                          G_STRUCT_OFFSET (GtkCellRendererAccelClass, accel_cleared),
 232                                          NULL, NULL,
 233                                          g_cclosure_marshal_VOID__STRING,
 234                                          G_TYPE_NONE, 1,
 235                                          G_TYPE_STRING);
 236
 237   g_type_class_add_private (cell_accel_class, sizeof (GtkCellRendererAccelPriv));
 238 }
 239
 240
 241 /**
 242  * gtk_cell_renderer_accel_new:
 243  *
 244  * Creates a new #GtkCellRendererAccel.
 245  *
 246  * Returns: the new cell renderer
 247  *
 248  * Since: 2.10
 249  */
 250 GtkCellRenderer *
 251 gtk_cell_renderer_accel_new (void)
 252 {
 253   return g_object_new (GTK_TYPE_CELL_RENDERER_ACCEL, NULL);
 254 }
 255
 256 static gchar *
 257 convert_keysym_state_to_string (GtkCellRendererAccel *accel,
 258                                 guint                 keysym,
 259                                 GdkModifierType       mask,
 260                                 guint                 keycode)
 261 {
 262   GtkCellRendererAccelPriv *priv = accel->priv;
 263
 264   if (keysym == 0 && keycode == 0)
 265     /* This label is displayed in a treeview cell displaying
 266      * a disabled accelerator key combination.
 267      */
 268     return g_strdup (C_("Accelerator", "Disabled"));
 269   else
 270     {
 271       if (priv->accel_mode == GTK_CELL_RENDERER_ACCEL_MODE_GTK)
 272         {
 273           if (!gtk_accelerator_valid (keysym, mask))
 274             /* This label is displayed in a treeview cell displaying
 275              * an accelerator key combination that is not valid according
 276              * to gtk_accelerator_valid().
 277              */
 278             return g_strdup (C_("Accelerator", "Invalid"));
 279
 280           return gtk_accelerator_get_label (keysym, mask);
 281         }
 282       else
 283         {
 284           gchar *name;
 285
 286           name = gtk_accelerator_get_label (keysym, mask);
 287           if (name == NULL)
 288             name = gtk_accelerator_name (keysym, mask);
 289
 290           if (keysym == 0)
 291             {
 292               gchar *tmp;
 293
 294               tmp = name;
 295               name = g_strdup_printf ("%s0x%02x", tmp, keycode);
 296               g_free (tmp);
 297             }
 298
 299           return name;
 300         }
 301     }
 302 }
 303
 304 static void
 305 gtk_cell_renderer_accel_get_property  (GObject    *object,
 306                                        guint       param_id,
 307                                        GValue     *value,
 308                                        GParamSpec *pspec)
 309 {
 310   GtkCellRendererAccelPriv *priv = GTK_CELL_RENDERER_ACCEL (object)->priv;
 311
 312   switch (param_id)
 313     {
 314     case PROP_ACCEL_KEY:
 315       g_value_set_uint (value, priv->accel_key);
 316       break;
 317
 318     case PROP_ACCEL_MODS:
 319       g_value_set_flags (value, priv->accel_mods);
 320       break;
 321
 322     case PROP_KEYCODE:
 323       g_value_set_uint (value, priv->keycode);
 324       break;
 325
 326     case PROP_ACCEL_MODE:
 327       g_value_set_enum (value, priv->accel_mode);
 328       break;
 329
 330     default:
 331       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
 332     }
 333 }
 334
 335 static void
 336 gtk_cell_renderer_accel_set_property  (GObject      *object,
 337                                        guint         param_id,
 338                                        const GValue *value,
 339                                        GParamSpec   *pspec)
 340 {
 341   GtkCellRendererAccel *accel = GTK_CELL_RENDERER_ACCEL (object);
 342   GtkCellRendererAccelPriv *priv = accel->priv;
 343   gboolean changed = FALSE;
 344
 345   switch (param_id)
 346     {
 347     case PROP_ACCEL_KEY:
 348       {
 349         guint accel_key = g_value_get_uint (value);
 350
 351         if (priv->accel_key != accel_key)
 352           {
 353             priv->accel_key = accel_key;
 354             changed = TRUE;
 355           }
 356       }
 357       break;
 358
 359     case PROP_ACCEL_MODS:
 360       {
 361         guint accel_mods = g_value_get_flags (value);
 362
 363         if (priv->accel_mods != accel_mods)
 364           {
 365             priv->accel_mods = accel_mods;
 366             changed = TRUE;
 367           }
 368       }
 369       break;
 370     case PROP_KEYCODE:
 371       {
 372         guint keycode = g_value_get_uint (value);
 373
 374         if (priv->keycode != keycode)
 375           {
 376             priv->keycode = keycode;
 377             changed = TRUE;
 378           }
 379       }
 380       break;
 381
 382     case PROP_ACCEL_MODE:
 383       priv->accel_mode = g_value_get_enum (value);
 384       break;
 385
 386     default:
 387       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
 388     }
 389
 390   if (changed)
 391     {
 392       gchar *text;
 393
 394       text = convert_keysym_state_to_string (accel, priv->accel_key, priv->accel_mods, priv->keycode);
 395       g_object_set (accel, "text", text, NULL);
 396       g_free (text);
 397     }
 398 }
 399
 400 static void
 401 gtk_cell_renderer_accel_get_size (GtkCellRenderer *cell,
 402                                   GtkWidget       *widget,
 403                                   GdkRectangle    *cell_area,
 404                                   gint            *x_offset,
 405                                   gint            *y_offset,
 406                                   gint            *width,
 407                                   gint            *height)
 408
 409 {
 410   GtkCellRendererAccelPriv *priv = GTK_CELL_RENDERER_ACCEL (cell)->priv;
 411   GtkRequisition requisition;
 412
 413   if (priv->sizing_label == NULL)
 414     priv->sizing_label = gtk_label_new (_("New accelerator..."));
 415
 416   gtk_widget_size_request (priv->sizing_label, &requisition);
 417
 418   GTK_CELL_RENDERER_CLASS (gtk_cell_renderer_accel_parent_class)->get_size (cell, widget, cell_area,
 419                                                                             x_offset, y_offset, width, height);
 420
 421   /* FIXME: need to take the cell_area et al. into account */
 422   if (width)
 423     *width = MAX (*width, requisition.width);
 424   if (height)
 425     *height = MAX (*height, requisition.height);
 426 }
 427
 428 static gboolean
 429 grab_key_callback (GtkWidget            *widget,
 430                    GdkEventKey          *event,
 431                    GtkCellRendererAccel *accel)
 432 {
 433   GtkCellRendererAccelPriv *priv = accel->priv;
 434   GdkModifierType accel_mods = 0;
 435   guint accel_key;
 436   gchar *path;
 437   gboolean edited;
 438   gboolean cleared;
 439   GdkModifierType consumed_modifiers;
 440   GdkDisplay *display;
 441
 442   display = gtk_widget_get_display (widget);
 443
 444   if (event->is_modifier)
 445     return TRUE;
 446
 447   edited = FALSE;
 448   cleared = FALSE;
 449
 450   gdk_keymap_translate_keyboard_state (gdk_keymap_get_for_display (display),
 451                                        event->hardware_keycode,
 452                                        event->state,
 453                                        event->group,
 454                                        NULL, NULL, NULL, &consumed_modifiers);
 455
 456   accel_key = gdk_keyval_to_lower (event->keyval);
 457   if (accel_key == GDK_ISO_Left_Tab)
 458     accel_key = GDK_Tab;
 459
 460   accel_mods = event->state & gtk_accelerator_get_default_mod_mask ();
 461
 462   /* Filter consumed modifiers
 463    */
 464   if (priv->accel_mode == GTK_CELL_RENDERER_ACCEL_MODE_GTK)
 465     accel_mods &= ~consumed_modifiers;
 466
 467   /* Put shift back if it changed the case of the key, not otherwise.
 468    */
 469   if (accel_key != event->keyval)
 470     accel_mods |= GDK_SHIFT_MASK;
 471
 472   if (accel_mods == 0)
 473     {
 474       switch (event->keyval)
 475         {
 476         case GDK_Escape:
 477           goto out; /* cancel */
 478         case GDK_BackSpace:
 479           /* clear the accelerator on Backspace */
 480           cleared = TRUE;
 481           goto out;
 482         default:
 483           break;
 484         }
 485     }
 486
 487   if (priv->accel_mode == GTK_CELL_RENDERER_ACCEL_MODE_GTK)
 488     {
 489       if (!gtk_accelerator_valid (accel_key, accel_mods))
 490         {
 491           gtk_widget_error_bell (widget);
 492
 493           return TRUE;
 494         }
 495     }
 496
 497   edited = TRUE;
 498
 499  out:
 500   gtk_device_grab_remove (priv->grab_widget, priv->grab_pointer);
 501   gdk_device_ungrab (priv->grab_keyboard, event->time);
 502   gdk_device_ungrab (priv->grab_pointer, event->time);
 503
 504   path = g_strdup (g_object_get_data (G_OBJECT (priv->edit_widget), "gtk-cell-renderer-text"));
 505
 506   gtk_cell_editable_editing_done (GTK_CELL_EDITABLE (priv->edit_widget));
 507   gtk_cell_editable_remove_widget (GTK_CELL_EDITABLE (priv->edit_widget));
 508   priv->edit_widget = NULL;
 509   priv->grab_widget = NULL;
 510   priv->grab_keyboard = NULL;
 511   priv->grab_pointer = NULL;
 512
 513   if (edited)
 514     g_signal_emit (accel, signals[ACCEL_EDITED], 0, path,
 515                    accel_key, accel_mods, event->hardware_keycode);
 516   else if (cleared)
 517     g_signal_emit (accel, signals[ACCEL_CLEARED], 0, path);
 518
 519   g_free (path);
 520
 521   return TRUE;
 522 }
 523
 524 static void
 525 ungrab_stuff (GtkWidget            *widget,
 526               GtkCellRendererAccel *accel)
 527 {
 528   GtkCellRendererAccelPriv *priv = accel->priv;
 529
 530   gtk_device_grab_remove (priv->grab_widget, priv->grab_pointer);
 531   gdk_device_ungrab (priv->grab_keyboard, GDK_CURRENT_TIME);
 532   gdk_device_ungrab (priv->grab_pointer, GDK_CURRENT_TIME);
 533
 534   priv->grab_keyboard = NULL;
 535   priv->grab_pointer = NULL;
 536
 537   g_signal_handlers_disconnect_by_func (priv->grab_widget,
 538                                         G_CALLBACK (grab_key_callback),
 539                                         accel);
 540 }
 541
 542 static void
 543 _gtk_cell_editable_event_box_start_editing (GtkCellEditable *cell_editable,
 544                                             GdkEvent        *event)
 545 {
 546   /* do nothing, because we are pointless */
 547 }
 548
 549 static void
 550 _gtk_cell_editable_event_box_cell_editable_init (GtkCellEditableIface *iface)
 551 {
 552   iface->start_editing = _gtk_cell_editable_event_box_start_editing;
 553 }
 554
 555 typedef GtkEventBox      GtkCellEditableEventBox;
 556 typedef GtkEventBoxClass GtkCellEditableEventBoxClass;
 557
 558 G_DEFINE_TYPE_WITH_CODE (GtkCellEditableEventBox, _gtk_cell_editable_event_box, GTK_TYPE_EVENT_BOX, { \
 559     G_IMPLEMENT_INTERFACE (GTK_TYPE_CELL_EDITABLE, _gtk_cell_editable_event_box_cell_editable_init)   \
 560       })
 561
 562
 563 static void
 564 _gtk_cell_editable_event_box_class_init (GtkCellEditableEventBoxClass *class)
 565 {
 566 }
 567
 568 static void
 569 _gtk_cell_editable_event_box_init (GtkCellEditableEventBox *box)
 570 {
 571 }
 572
 573 static GtkCellEditable *
 574 gtk_cell_renderer_accel_start_editing (GtkCellRenderer      *cell,
 575                                        GdkEvent             *event,
 576                                        GtkWidget            *widget,
 577                                        const gchar          *path,
 578                                        GdkRectangle         *background_area,
 579                                        GdkRectangle         *cell_area,
 580                                        GtkCellRendererState  flags)
 581 {
 582   GtkCellRendererAccelPriv *priv;
 583   GtkCellRendererText *celltext;
 584   GtkCellRendererAccel *accel;
 585   GtkWidget *label;
 586   GtkWidget *eventbox;
 587   GdkDevice *device, *keyb, *pointer;
 588   gboolean editable;
 589   guint32 time;
 590
 591   celltext = GTK_CELL_RENDERER_TEXT (cell);
 592   accel = GTK_CELL_RENDERER_ACCEL (cell);
 593   priv = accel->priv;
 594
 595   /* If the cell isn't editable we return NULL. */
 596   g_object_get (celltext, "editable", &editable, NULL);
 597   if (editable == FALSE)
 598     return NULL;
 599
 600   g_return_val_if_fail (widget->window != NULL, NULL);
 601
 602   if (event)
 603     device = gdk_event_get_device (event);
 604   else
 605     device = gtk_get_current_event_device ();
 606
 607   if (!device)
 608     return NULL;
 609
 610   if (device->source == GDK_SOURCE_KEYBOARD)
 611     {
 612       keyb = device;
 613       pointer = gdk_device_get_associated_device (device);
 614     }
 615   else
 616     {
 617       pointer = device;
 618       keyb = gdk_device_get_associated_device (device);
 619     }
 620
 621   time = gdk_event_get_time (event);
 622
 623   if (gdk_device_grab (keyb, widget->window,
 624                        GDK_OWNERSHIP_WINDOW, FALSE,
 625                        GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK,
 626                        NULL, time) != GDK_GRAB_SUCCESS)
 627     return NULL;
 628
 629   if (gdk_device_grab (pointer, widget->window,
 630                        GDK_OWNERSHIP_WINDOW, FALSE,
 631                        GDK_BUTTON_PRESS_MASK,
 632                        NULL, time) != GDK_GRAB_SUCCESS)
 633     {
 634       gdk_device_ungrab (keyb, time);
 635       return NULL;
 636     }
 637
 638   priv->grab_keyboard = keyb;
 639   priv->grab_pointer = pointer;
 640   priv->grab_widget = widget;
 641
 642   g_signal_connect (G_OBJECT (widget), "key-press-event",
 643                     G_CALLBACK (grab_key_callback),
 644                     accel);
 645
 646   eventbox = g_object_new (_gtk_cell_editable_event_box_get_type (), NULL);
 647   priv->edit_widget = eventbox;
 648   g_object_add_weak_pointer (G_OBJECT (priv->edit_widget),
 649                              (gpointer) &priv->edit_widget);
 650
 651   label = gtk_label_new (NULL);
 652   gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
 653
 654   gtk_widget_modify_bg (eventbox, GTK_STATE_NORMAL,
 655                         &widget->style->bg[GTK_STATE_SELECTED]);
 656
 657   gtk_widget_modify_fg (label, GTK_STATE_NORMAL,
 658                         &widget->style->fg[GTK_STATE_SELECTED]);
 659
 660   /* This label is displayed in a treeview cell displaying
 661    * an accelerator when the cell is clicked to change the
 662    * acelerator.
 663    */
 664   gtk_label_set_text (GTK_LABEL (label), _("New accelerator..."));
 665
 666   gtk_container_add (GTK_CONTAINER (eventbox), label);
 667
 668   g_object_set_data_full (G_OBJECT (priv->edit_widget), "gtk-cell-renderer-text",
 669                           g_strdup (path), g_free);
 670
 671   gtk_widget_show_all (priv->edit_widget);
 672
 673   gtk_device_grab_add (priv->grab_widget, pointer, TRUE);
 674
 675   g_signal_connect (priv->edit_widget, "unrealize",
 676                     G_CALLBACK (ungrab_stuff), accel);
 677
 678   return GTK_CELL_EDITABLE (priv->edit_widget);
 679 }