← Back to branch summary

~ubuntu-branches/ubuntu/maverick/guake/maverick

« back to all changes in this revision

Viewing changes to src/eggcellrendererkeys/eggcellrendererkeys.c

  • Committer: Bazaar Package Importer
  • Author(s): Sylvestre Ledru
  • Date: 2009-04-16 01:38:48 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20090416013848-lmsozbtwjzwofj0w
Tags: 0.4.0-4
Bad place for 0.4.0-3

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/eggcellrendererkeys/eggcellrendererkeys.c
1
 
#include <config.h>
2
 
#include <libintl.h>
3
 
#include <gtk/gtk.h>
4
 
#include <gdk/gdkx.h>
5
 
#include <gdk/gdkkeysyms.h>
6
 
#include "eggcellrendererkeys.h"
7
 
#include "eggaccelerators.h"
8
 
 
9
 
#ifndef EGG_COMPILATION
10
 
#ifndef _
11
 
#define _(x) dgettext (GETTEXT_PACKAGE, x)
12
 
#define N_(x) x
13
 
#endif
14
 
#else
15
 
#define _(x) x
16
 
#define N_(x) x
17
 
#endif
18
 
 
19
 
#define EGG_CELL_RENDERER_TEXT_PATH "egg-cell-renderer-text"
20
 
 
21
 
#define TOOLTIP_TEXT _("New accelerator...")
22
 
 
23
 
static void             egg_cell_renderer_keys_finalize      (GObject             *object);
24
 
static void             egg_cell_renderer_keys_init          (EggCellRendererKeys *cell_keys);
25
 
static void             egg_cell_renderer_keys_class_init    (EggCellRendererKeysClass *cell_keys_class);
26
 
static GtkCellEditable *egg_cell_renderer_keys_start_editing (GtkCellRenderer          *cell,
27
 
                                                              GdkEvent                 *event,
28
 
                                                              GtkWidget                *widget,
29
 
                                                              const gchar              *path,
30
 
                                                              GdkRectangle             *background_area,
31
 
                                                              GdkRectangle             *cell_area,
32
 
                                                              GtkCellRendererState      flags);
33
 
 
34
 
 
35
 
static void egg_cell_renderer_keys_get_property (GObject         *object,
36
 
                                                 guint            param_id,
37
 
                                                 GValue          *value,
38
 
                                                 GParamSpec      *pspec);
39
 
static void egg_cell_renderer_keys_set_property (GObject         *object,
40
 
                                                 guint            param_id,
41
 
                                                 const GValue    *value,
42
 
                                                 GParamSpec      *pspec);
43
 
static void egg_cell_renderer_keys_get_size     (GtkCellRenderer *cell,
44
 
                                                 GtkWidget       *widget,
45
 
                                                 GdkRectangle    *cell_area,
46
 
                                                 gint            *x_offset,
47
 
                                                 gint            *y_offset,
48
 
                                                 gint            *width,
49
 
                                                 gint            *height);
50
 
 
51
 
 
52
 
enum {
53
 
  PROP_0,
54
 
 
55
 
  PROP_ACCEL_KEY,
56
 
  PROP_ACCEL_MASK,
57
 
  PROP_KEYCODE,
58
 
  PROP_ACCEL_MODE
59
 
};
60
 
 
61
 
static GtkCellRendererTextClass *parent_class = NULL;
62
 
 
63
 
GType
64
 
egg_cell_renderer_keys_get_type (void)
65
 
{
66
 
  static GType cell_keys_type = 0;
67
 
 
68
 
  if (!cell_keys_type)
69
 
    {
70
 
      static const GTypeInfo cell_keys_info =
71
 
      {
72
 
        sizeof (EggCellRendererKeysClass),
73
 
        NULL,           /* base_init */
74
 
        NULL,           /* base_finalize */
75
 
        (GClassInitFunc)egg_cell_renderer_keys_class_init,
76
 
        NULL,           /* class_finalize */
77
 
        NULL,           /* class_data */
78
 
        sizeof (EggCellRendererKeys),
79
 
        0,              /* n_preallocs */
80
 
        (GInstanceInitFunc) egg_cell_renderer_keys_init
81
 
      };
82
 
 
83
 
      cell_keys_type = g_type_register_static (GTK_TYPE_CELL_RENDERER_TEXT, "EggCellRendererKeys", &cell_keys_info, 0);
84
 
    }
85
 
 
86
 
  return cell_keys_type;
87
 
}
88
 
 
89
 
static void
90
 
egg_cell_renderer_keys_init (EggCellRendererKeys *cell_keys)
91
 
{
92
 
  cell_keys->accel_mode = EGG_CELL_RENDERER_KEYS_MODE_GTK;
93
 
}
94
 
 
95
 
/* FIXME setup stuff to generate this */
96
 
/* VOID:STRING,UINT,FLAGS,UINT */
97
 
static void
98
 
marshal_VOID__STRING_UINT_FLAGS_UINT (GClosure     *closure,
99
 
                                      GValue       *return_value,
100
 
                                      guint         n_param_values,
101
 
                                      const GValue *param_values,
102
 
                                      gpointer      invocation_hint,
103
 
                                      gpointer      marshal_data)
104
 
{
105
 
  typedef void (*GMarshalFunc_VOID__STRING_UINT_FLAGS_UINT) (gpointer     data1,
106
 
                                                             const char  *arg_1,
107
 
                                                             guint        arg_2,
108
 
                                                             int          arg_3,
109
 
                                                             guint        arg_4,
110
 
                                                             gpointer     data2);
111
 
  register GMarshalFunc_VOID__STRING_UINT_FLAGS_UINT callback;
112
 
  register GCClosure *cc = (GCClosure*) closure;
113
 
  register gpointer data1, data2;
114
 
 
115
 
  g_return_if_fail (n_param_values == 5);
116
 
 
117
 
  if (G_CCLOSURE_SWAP_DATA (closure))
118
 
    {
119
 
      data1 = closure->data;
120
 
      data2 = g_value_peek_pointer (param_values + 0);
121
 
    }
122
 
  else
123
 
    {
124
 
      data1 = g_value_peek_pointer (param_values + 0);
125
 
      data2 = closure->data;
126
 
    }
127
 
  
128
 
  callback = (GMarshalFunc_VOID__STRING_UINT_FLAGS_UINT) (marshal_data ? marshal_data : cc->callback);
129
 
 
130
 
  callback (data1,
131
 
            g_value_get_string (param_values + 1),
132
 
            g_value_get_uint (param_values + 2),
133
 
            g_value_get_flags (param_values + 3),
134
 
            g_value_get_uint (param_values + 4),
135
 
            data2);
136
 
}
137
 
 
138
 
static void
139
 
egg_cell_renderer_keys_class_init (EggCellRendererKeysClass *cell_keys_class)
140
 
{
141
 
  GObjectClass *object_class;
142
 
  GtkCellRendererClass *cell_renderer_class;
143
 
 
144
 
  object_class = G_OBJECT_CLASS (cell_keys_class);
145
 
  cell_renderer_class = GTK_CELL_RENDERER_CLASS (cell_keys_class);
146
 
  parent_class = g_type_class_peek_parent (object_class);
147
 
  
148
 
  GTK_CELL_RENDERER_CLASS (cell_keys_class)->start_editing = egg_cell_renderer_keys_start_editing;
149
 
 
150
 
  object_class->set_property = egg_cell_renderer_keys_set_property;
151
 
  object_class->get_property = egg_cell_renderer_keys_get_property;
152
 
  cell_renderer_class->get_size = egg_cell_renderer_keys_get_size;
153
 
 
154
 
  object_class->finalize = egg_cell_renderer_keys_finalize;
155
 
  
156
 
  /* FIXME if this gets moved to a real library, rename the properties
157
 
   * to match whatever the GTK convention is
158
 
   */
159
 
  
160
 
  g_object_class_install_property (object_class,
161
 
                                   PROP_ACCEL_KEY,
162
 
                                   g_param_spec_uint ("accel_key",
163
 
                                                     _("Accelerator key"),
164
 
                                                     _("Accelerator key"),
165
 
                                                      0,
166
 
                                                      G_MAXINT,
167
 
                                                      0,
168
 
                                                      G_PARAM_READABLE | G_PARAM_WRITABLE));
169
 
 
170
 
  g_object_class_install_property (object_class,
171
 
                                   PROP_ACCEL_MASK,
172
 
                                   g_param_spec_flags ("accel_mask",
173
 
                                                       _("Accelerator modifiers"),
174
 
                                                       _("Accelerator modifiers"),
175
 
                                                       GDK_TYPE_MODIFIER_TYPE,
176
 
                                                       0,
177
 
                                                       G_PARAM_READABLE | G_PARAM_WRITABLE));
178
 
 
179
 
  g_object_class_install_property (object_class,
180
 
                                   PROP_KEYCODE,
181
 
                                   g_param_spec_uint ("keycode",
182
 
                                                      _("Accelerator keycode"),
183
 
                                                      _("Accelerator keycode"),
184
 
                                                      0,
185
 
                                                      G_MAXINT,
186
 
                                                      0,
187
 
                                                      G_PARAM_READABLE | G_PARAM_WRITABLE));
188
 
  
189
 
  /* FIXME: Register the enum when moving to GTK+ */
190
 
  g_object_class_install_property (object_class,
191
 
                                   PROP_ACCEL_MODE,
192
 
                                   g_param_spec_int ("accel_mode",
193
 
                                                     _("Accel Mode"),
194
 
                                                     _("The type of accelerator."),
195
 
                                                     0,
196
 
                                                     2,
197
 
                                                     0,
198
 
                                                     G_PARAM_READABLE | G_PARAM_WRITABLE));
199
 
  
200
 
  g_signal_new ("accel_edited",
201
 
                EGG_TYPE_CELL_RENDERER_KEYS,
202
 
                G_SIGNAL_RUN_LAST,
203
 
                G_STRUCT_OFFSET (EggCellRendererKeysClass, accel_edited),
204
 
                NULL, NULL,
205
 
                marshal_VOID__STRING_UINT_FLAGS_UINT,
206
 
                G_TYPE_NONE, 4,
207
 
                G_TYPE_STRING,
208
 
                G_TYPE_UINT,
209
 
                GDK_TYPE_MODIFIER_TYPE,
210
 
                G_TYPE_UINT);
211
 
 
212
 
  g_signal_new ("accel_cleared",
213
 
                EGG_TYPE_CELL_RENDERER_KEYS,
214
 
                G_SIGNAL_RUN_LAST,
215
 
                G_STRUCT_OFFSET (EggCellRendererKeysClass, accel_cleared),
216
 
                NULL, NULL,
217
 
                gtk_marshal_VOID__STRING,
218
 
                G_TYPE_NONE, 1,
219
 
                G_TYPE_STRING);
220
 
}
221
 
 
222
 
 
223
 
GtkCellRenderer *
224
 
egg_cell_renderer_keys_new (void)
225
 
{
226
 
  return GTK_CELL_RENDERER (g_object_new (EGG_TYPE_CELL_RENDERER_KEYS, NULL));
227
 
}
228
 
 
229
 
static void
230
 
egg_cell_renderer_keys_finalize (GObject *object)
231
 
{
232
 
  
233
 
  (* G_OBJECT_CLASS (parent_class)->finalize) (object);
234
 
}
235
 
 
236
 
static gchar *
237
 
convert_keysym_state_to_string (guint                  keysym,
238
 
                                guint                  keycode,
239
 
                                EggVirtualModifierType mask)
240
 
{
241
 
  if (keysym == 0 && keycode == 0)
242
 
    return g_strdup (_("Disabled"));
243
 
  else
244
 
    return egg_virtual_accelerator_label (keysym, keycode, mask);
245
 
}
246
 
 
247
 
static void
248
 
egg_cell_renderer_keys_get_property  (GObject                  *object,
249
 
                                      guint                     param_id,
250
 
                                      GValue                   *value,
251
 
                                      GParamSpec               *pspec)
252
 
{
253
 
  EggCellRendererKeys *keys;
254
 
 
255
 
  g_return_if_fail (EGG_IS_CELL_RENDERER_KEYS (object));
256
 
 
257
 
  keys = EGG_CELL_RENDERER_KEYS (object);
258
 
  
259
 
  switch (param_id)
260
 
    {
261
 
    case PROP_ACCEL_KEY:
262
 
      g_value_set_uint (value, keys->accel_key);
263
 
      break;
264
 
 
265
 
    case PROP_ACCEL_MASK:
266
 
      g_value_set_flags (value, keys->accel_mask);
267
 
      break;
268
 
 
269
 
    case PROP_ACCEL_MODE:
270
 
      g_value_set_int (value, keys->accel_mode);
271
 
      break;
272
 
 
273
 
    default:
274
 
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
275
 
    }
276
 
}
277
 
 
278
 
static void
279
 
egg_cell_renderer_keys_set_property  (GObject                  *object,
280
 
                                      guint                     param_id,
281
 
                                      const GValue             *value,
282
 
                                      GParamSpec               *pspec)
283
 
{
284
 
  EggCellRendererKeys *keys;
285
 
 
286
 
  g_return_if_fail (EGG_IS_CELL_RENDERER_KEYS (object));
287
 
 
288
 
  keys = EGG_CELL_RENDERER_KEYS (object);
289
 
  
290
 
  switch (param_id)
291
 
    {
292
 
    case PROP_ACCEL_KEY:
293
 
      egg_cell_renderer_keys_set_accelerator (keys,
294
 
                                              g_value_get_uint (value),
295
 
                                              keys->keycode,
296
 
                                              keys->accel_mask);
297
 
      break;
298
 
 
299
 
    case PROP_ACCEL_MASK:
300
 
      egg_cell_renderer_keys_set_accelerator (keys,
301
 
                                              keys->accel_key,
302
 
                                              keys->keycode,
303
 
                                              g_value_get_flags (value));
304
 
      break;
305
 
    case PROP_KEYCODE:
306
 
      egg_cell_renderer_keys_set_accelerator (keys,
307
 
                                              keys->accel_key,
308
 
                                              g_value_get_uint (value),
309
 
                                              keys->accel_mask);
310
 
      break;
311
 
 
312
 
    case PROP_ACCEL_MODE:
313
 
      egg_cell_renderer_keys_set_accel_mode (keys, g_value_get_int (value));
314
 
      break;
315
 
      
316
 
    default:
317
 
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
318
 
    }
319
 
}
320
 
 
321
 
static gboolean 
322
 
is_modifier (guint keycode)
323
 
{
324
 
  gint i;
325
 
  gint map_size;
326
 
  XModifierKeymap *mod_keymap;
327
 
  gboolean retval = FALSE;
328
 
 
329
 
  mod_keymap = XGetModifierMapping (gdk_display);
330
 
 
331
 
  map_size = 8 * mod_keymap->max_keypermod;
332
 
  i = 0;
333
 
  while (i < map_size)
334
 
    {
335
 
      if (keycode == mod_keymap->modifiermap[i])
336
 
        {
337
 
          retval = TRUE;
338
 
          break;
339
 
        }
340
 
      ++i;
341
 
    }
342
 
 
343
 
  XFreeModifiermap (mod_keymap);
344
 
 
345
 
  return retval;
346
 
}
347
 
 
348
 
static void
349
 
egg_cell_renderer_keys_get_size (GtkCellRenderer *cell,
350
 
                                 GtkWidget       *widget,
351
 
                                 GdkRectangle    *cell_area,
352
 
                                 gint            *x_offset,
353
 
                                 gint            *y_offset,
354
 
                                 gint            *width,
355
 
                                 gint            *height)
356
 
 
357
 
{
358
 
  EggCellRendererKeys *keys = (EggCellRendererKeys *) cell;
359
 
  GtkRequisition requisition;
360
 
 
361
 
  if (keys->sizing_label == NULL)
362
 
    keys->sizing_label = gtk_label_new (TOOLTIP_TEXT);
363
 
 
364
 
  gtk_widget_size_request (keys->sizing_label, &requisition);
365
 
  (* GTK_CELL_RENDERER_CLASS (parent_class)->get_size) (cell, widget, cell_area, x_offset, y_offset, width, height);
366
 
  /* FIXME: need to take the cell_area et al. into account */
367
 
  if (width)
368
 
    *width = MAX (*width, requisition.width);
369
 
  if (height)
370
 
    *height = MAX (*height, requisition.height);
371
 
}
372
 
 
373
 
/* FIXME: Currently we don't differentiate between a 'bogus' key (like tab in
374
 
 * GTK mode) and a removed key.
375
 
 */
376
 
   
377
 
static gboolean
378
 
grab_key_callback (GtkWidget    *widget,
379
 
                   GdkEventKey  *event,
380
 
                   void         *data)
381
 
{
382
 
  GdkModifierType accel_mods = 0;
383
 
  guint accel_keyval;
384
 
  EggCellRendererKeys *keys;
385
 
  char *path;
386
 
  gboolean edited;
387
 
  gboolean cleared;
388
 
  GdkModifierType consumed_modifiers;  
389
 
  guint upper;
390
 
  GdkModifierType ignored_modifiers;
391
 
  
392
 
  keys = EGG_CELL_RENDERER_KEYS (data);
393
 
 
394
 
  if (is_modifier (event->hardware_keycode))
395
 
    return TRUE;
396
 
 
397
 
  edited = FALSE;
398
 
  cleared = FALSE;
399
 
 
400
 
  consumed_modifiers = 0;
401
 
  gdk_keymap_translate_keyboard_state (gdk_keymap_get_default (),
402
 
                                       event->hardware_keycode,
403
 
                                       event->state,
404
 
                                       event->group,
405
 
                                       NULL, NULL, NULL, &consumed_modifiers);
406
 
 
407
 
  upper = event->keyval;
408
 
  accel_keyval = gdk_keyval_to_lower (upper);
409
 
  if (accel_keyval == GDK_ISO_Left_Tab) 
410
 
    accel_keyval = GDK_Tab;
411
 
 
412
 
 
413
 
  
414
 
  /* Put shift back if it changed the case of the key, not otherwise.
415
 
   */
416
 
  if (upper != accel_keyval &&
417
 
      (consumed_modifiers & GDK_SHIFT_MASK))
418
 
    {
419
 
      consumed_modifiers &= ~(GDK_SHIFT_MASK);
420
 
    }
421
 
 
422
 
  egg_keymap_resolve_virtual_modifiers (gdk_keymap_get_default (),
423
 
                                        EGG_VIRTUAL_NUM_LOCK_MASK |
424
 
                                        EGG_VIRTUAL_SCROLL_LOCK_MASK |
425
 
                                        EGG_VIRTUAL_LOCK_MASK,
426
 
                                        &ignored_modifiers);
427
 
  
428
 
  /* http://bugzilla.gnome.org/show_bug.cgi?id=139605
429
 
   * mouse keys should effect keybindings */
430
 
  ignored_modifiers |=  GDK_BUTTON1_MASK |
431
 
                        GDK_BUTTON2_MASK |
432
 
                        GDK_BUTTON3_MASK |
433
 
                        GDK_BUTTON4_MASK |
434
 
                        GDK_BUTTON5_MASK;
435
 
 
436
 
  /* filter consumed/ignored modifiers */
437
 
 
438
 
  if (keys->accel_mode == EGG_CELL_RENDERER_KEYS_MODE_GTK)
439
 
    accel_mods = event->state & GDK_MODIFIER_MASK & ~(consumed_modifiers | ignored_modifiers);
440
 
  else if (keys->accel_mode == EGG_CELL_RENDERER_KEYS_MODE_X)
441
 
    accel_mods = event->state & GDK_MODIFIER_MASK & ~(ignored_modifiers);
442
 
  else
443
 
    g_assert_not_reached ();
444
 
    
445
 
  if (accel_mods == 0 && accel_keyval == GDK_Escape)
446
 
    goto out; /* cancel */
447
 
 
448
 
  /* clear the accelerator on Backspace */
449
 
  if (accel_mods == 0 && accel_keyval == GDK_BackSpace)
450
 
    {
451
 
      cleared = TRUE;
452
 
      goto out;
453
 
    }
454
 
 
455
 
  if (keys->accel_mode == EGG_CELL_RENDERER_KEYS_MODE_GTK)
456
 
    {
457
 
      if (!gtk_accelerator_valid (accel_keyval, accel_mods))
458
 
        {
459
 
          accel_keyval = 0;
460
 
          accel_mods = 0;
461
 
        }
462
 
    }
463
 
  
464
 
  edited = TRUE;
465
 
 out:
466
 
  gdk_keyboard_ungrab (event->time);
467
 
  gdk_pointer_ungrab (event->time);
468
 
  
469
 
  path = g_strdup (g_object_get_data (G_OBJECT (keys->edit_widget), EGG_CELL_RENDERER_TEXT_PATH));
470
 
 
471
 
  gtk_cell_editable_editing_done (GTK_CELL_EDITABLE (keys->edit_widget));
472
 
  gtk_cell_editable_remove_widget (GTK_CELL_EDITABLE (keys->edit_widget));
473
 
  keys->edit_widget = NULL;
474
 
  keys->grab_widget = NULL;
475
 
  
476
 
  if (edited)
477
 
    {
478
 
      g_signal_emit_by_name (G_OBJECT (keys), "accel_edited", path,
479
 
                             accel_keyval, accel_mods, event->hardware_keycode);
480
 
    }
481
 
  else if (cleared)
482
 
    {
483
 
      g_signal_emit_by_name (G_OBJECT (keys), "accel_cleared", path);
484
 
    }
485
 
 
486
 
  g_free (path);
487
 
  return TRUE;
488
 
}
489
 
 
490
 
static void
491
 
ungrab_stuff (GtkWidget *widget, gpointer data)
492
 
{
493
 
  EggCellRendererKeys *keys = EGG_CELL_RENDERER_KEYS (data);
494
 
 
495
 
  gdk_keyboard_ungrab (GDK_CURRENT_TIME);
496
 
  gdk_pointer_ungrab (GDK_CURRENT_TIME);
497
 
 
498
 
  g_signal_handlers_disconnect_by_func (G_OBJECT (keys->grab_widget),
499
 
                                        G_CALLBACK (grab_key_callback), data);
500
 
}
501
 
 
502
 
static void
503
 
pointless_eventbox_start_editing (GtkCellEditable *cell_editable,
504
 
                                  GdkEvent        *event)
505
 
{
506
 
  /* do nothing, because we are pointless */
507
 
}
508
 
 
509
 
static void
510
 
pointless_eventbox_cell_editable_init (GtkCellEditableIface *iface)
511
 
{
512
 
  iface->start_editing = pointless_eventbox_start_editing;
513
 
}
514
 
 
515
 
static GType
516
 
pointless_eventbox_subclass_get_type (void)
517
 
{
518
 
  static GType eventbox_type = 0;
519
 
 
520
 
  if (!eventbox_type)
521
 
    {
522
 
      static const GTypeInfo eventbox_info =
523
 
      {
524
 
        sizeof (GtkEventBoxClass),
525
 
        NULL,           /* base_init */
526
 
        NULL,           /* base_finalize */
527
 
        NULL,
528
 
        NULL,           /* class_finalize */
529
 
        NULL,           /* class_data */
530
 
        sizeof (GtkEventBox),
531
 
        0,              /* n_preallocs */
532
 
        (GInstanceInitFunc) NULL,
533
 
      };
534
 
 
535
 
      static const GInterfaceInfo cell_editable_info = {
536
 
        (GInterfaceInitFunc) pointless_eventbox_cell_editable_init,
537
 
        NULL, NULL };
538
 
 
539
 
      eventbox_type = g_type_register_static (GTK_TYPE_EVENT_BOX, "EggCellEditableEventBox", &eventbox_info, 0);
540
 
      
541
 
      g_type_add_interface_static (eventbox_type,
542
 
                                   GTK_TYPE_CELL_EDITABLE,
543
 
                                   &cell_editable_info);
544
 
    }
545
 
 
546
 
  return eventbox_type;
547
 
}
548
 
 
549
 
static GtkCellEditable *
550
 
egg_cell_renderer_keys_start_editing (GtkCellRenderer      *cell,
551
 
                                      GdkEvent             *event,
552
 
                                      GtkWidget            *widget,
553
 
                                      const gchar          *path,
554
 
                                      GdkRectangle         *background_area,
555
 
                                      GdkRectangle         *cell_area,
556
 
                                      GtkCellRendererState  flags)
557
 
{
558
 
  GtkCellRendererText *celltext;
559
 
  EggCellRendererKeys *keys;
560
 
  GtkWidget *label;
561
 
  GtkWidget *eventbox;
562
 
  
563
 
  celltext = GTK_CELL_RENDERER_TEXT (cell);
564
 
  keys = EGG_CELL_RENDERER_KEYS (cell);
565
 
  
566
 
  /* If the cell isn't editable we return NULL. */
567
 
  if (celltext->editable == FALSE)
568
 
    return NULL;
569
 
 
570
 
  g_return_val_if_fail (widget->window != NULL, NULL);
571
 
  
572
 
  if (gdk_keyboard_grab (widget->window, FALSE,
573
 
                         gdk_event_get_time (event)) != GDK_GRAB_SUCCESS)
574
 
    return NULL;
575
 
 
576
 
  if (gdk_pointer_grab (widget->window, FALSE,
577
 
                        GDK_BUTTON_PRESS_MASK,
578
 
                        NULL, NULL,
579
 
                        gdk_event_get_time (event)) != GDK_GRAB_SUCCESS)
580
 
    {
581
 
      gdk_keyboard_ungrab (gdk_event_get_time (event));
582
 
      return NULL;
583
 
    }
584
 
  
585
 
  keys->grab_widget = widget;
586
 
 
587
 
  g_signal_connect (G_OBJECT (widget), "key_press_event",
588
 
                    G_CALLBACK (grab_key_callback),
589
 
                    keys);
590
 
 
591
 
  eventbox = g_object_new (pointless_eventbox_subclass_get_type (),
592
 
                           NULL);
593
 
  keys->edit_widget = eventbox;
594
 
  g_object_add_weak_pointer (G_OBJECT (keys->edit_widget),
595
 
                             (void**) &keys->edit_widget);
596
 
  
597
 
  label = gtk_label_new (NULL);
598
 
  gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
599
 
  
600
 
  gtk_widget_modify_bg (eventbox, GTK_STATE_NORMAL,
601
 
                        &widget->style->bg[GTK_STATE_SELECTED]);
602
 
 
603
 
  gtk_widget_modify_fg (label, GTK_STATE_NORMAL,
604
 
                        &widget->style->fg[GTK_STATE_SELECTED]);
605
 
  
606
 
  gtk_label_set_text (GTK_LABEL (label),
607
 
                  TOOLTIP_TEXT);
608
 
 
609
 
  gtk_container_add (GTK_CONTAINER (eventbox), label);
610
 
  
611
 
  g_object_set_data_full (G_OBJECT (keys->edit_widget), EGG_CELL_RENDERER_TEXT_PATH,
612
 
                          g_strdup (path), g_free);
613
 
  
614
 
  gtk_widget_show_all (keys->edit_widget);
615
 
 
616
 
  g_signal_connect (G_OBJECT (keys->edit_widget), "unrealize",
617
 
                    G_CALLBACK (ungrab_stuff), keys);
618
 
  
619
 
  keys->edit_key = keys->accel_key;
620
 
  
621
 
  return GTK_CELL_EDITABLE (keys->edit_widget);
622
 
}
623
 
 
624
 
void
625
 
egg_cell_renderer_keys_set_accelerator (EggCellRendererKeys *keys,
626
 
                                        guint                keyval,
627
 
                                        guint                keycode,
628
 
                                        EggVirtualModifierType  mask)
629
 
{
630
 
  char *text;
631
 
  gboolean changed;
632
 
 
633
 
  g_return_if_fail (EGG_IS_CELL_RENDERER_KEYS (keys));
634
 
 
635
 
  g_object_freeze_notify (G_OBJECT (keys));
636
 
 
637
 
  changed = FALSE;
638
 
  
639
 
  if (keyval != keys->accel_key)
640
 
    {
641
 
      keys->accel_key = keyval;
642
 
      g_object_notify (G_OBJECT (keys), "accel_key");
643
 
      changed = TRUE;
644
 
    }
645
 
 
646
 
  if (mask != keys->accel_mask)
647
 
    {
648
 
      keys->accel_mask = mask;
649
 
 
650
 
      g_object_notify (G_OBJECT (keys), "accel_mask");
651
 
      changed = TRUE;
652
 
    }  
653
 
 
654
 
  if (keycode != keys->keycode)
655
 
    {
656
 
      keys->keycode = keycode;
657
 
 
658
 
      g_object_notify (G_OBJECT (keys), "keycode");
659
 
      changed = TRUE;
660
 
    }
661
 
  g_object_thaw_notify (G_OBJECT (keys));
662
 
 
663
 
  if (changed)
664
 
    {
665
 
      /* sync string to the key values */
666
 
      text = convert_keysym_state_to_string (keys->accel_key, keys->keycode, keys->accel_mask);
667
 
      g_object_set (keys, "text", text, NULL);
668
 
      g_free (text);
669
 
    }
670
 
}
671
 
 
672
 
void
673
 
egg_cell_renderer_keys_get_accelerator (EggCellRendererKeys     *keys,
674
 
                                        guint                   *keyval,
675
 
                                        EggVirtualModifierType  *mask)
676
 
{
677
 
  g_return_if_fail (EGG_IS_CELL_RENDERER_KEYS (keys));
678
 
 
679
 
  if (keyval)
680
 
    *keyval = keys->accel_key;
681
 
 
682
 
  if (mask)
683
 
    *mask = keys->accel_mask;
684
 
}
685
 
 
686
 
void
687
 
egg_cell_renderer_keys_set_accel_mode (EggCellRendererKeys     *keys,
688
 
                                       EggCellRendererKeysMode  accel_mode)
689
 
{
690
 
  g_return_if_fail (EGG_IS_CELL_RENDERER_KEYS (keys));
691
 
  keys->accel_mode = accel_mode;
692
 
  g_object_notify (G_OBJECT (keys), "accel_mode");
693
 
}