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