← Back to branch summary

~ubuntu-branches/ubuntu/jaunty/gimp/jaunty-security

« back to all changes in this revision

Viewing changes to app/widgets/gimpuimanager.c

  • Committer: Bazaar Package Importer
  • Author(s): Daniel Holbach
  • Date: 2007-05-02 16:33:03 UTC
  • mfrom: (1.1.4 upstream)
  • Revision ID: james.westby@ubuntu.com-20070502163303-bvzhjzbpw8qglc4y
Tags: 2.3.16-1ubuntu1
* Resynchronized with Debian, remaining Ubuntu changes:
  - debian/rules: i18n magic.
* debian/control.in:
  - Maintainer: Ubuntu Core Developers <ubuntu-devel@lists.ubuntu.com>
* debian/patches/02_help-message.patch,
  debian/patches/03_gimp.desktop.in.in.patch,
  debian/patches/10_dont_show_wizard.patch: updated.
* debian/patches/04_composite-signedness.patch,
  debian/patches/05_add-letter-spacing.patch: dropped, used upstream.

Show diffs side-by-side

added added

removed removed

Lines of Context:
app/widgets/gimpuimanager.c
1
 
/* The GIMP -- an image manipulation program
 
1
/* GIMP - The GNU Image Manipulation Program
2
2
 * Copyright (C) 1995 Spencer Kimball and Peter Mattis
3
3
 *
4
4
 * gimpuimanager.c
52
52
enum
53
53
{
54
54
  UPDATE,
 
55
  SHOW_TOOLTIP,
 
56
  HIDE_TOOLTIP,
55
57
  LAST_SIGNAL
56
58
};
57
59
 
58
60
 
59
 
static void     gimp_ui_manager_init           (GimpUIManager      *manager);
60
 
static void     gimp_ui_manager_class_init     (GimpUIManagerClass *klass);
61
 
 
62
 
static GObject * gimp_ui_manager_constructor   (GType               type,
63
 
                                                guint               n_params,
64
 
                                                GObjectConstructParam *params);
65
 
static void     gimp_ui_manager_dispose        (GObject            *object);
66
 
static void     gimp_ui_manager_finalize       (GObject            *object);
67
 
static void     gimp_ui_manager_set_property   (GObject            *object,
68
 
                                                guint               prop_id,
69
 
                                                const GValue       *value,
70
 
                                                GParamSpec         *pspec);
71
 
static void     gimp_ui_manager_get_property   (GObject            *object,
72
 
                                                guint               prop_id,
73
 
                                                GValue             *value,
74
 
                                                GParamSpec         *pspec);
75
 
static void     gimp_ui_manager_connect_proxy  (GtkUIManager       *manager,
76
 
                                                GtkAction          *action,
77
 
                                                GtkWidget          *proxy);
78
 
static void     gimp_ui_manager_real_update    (GimpUIManager      *manager,
79
 
                                                gpointer            update_data);
80
 
static GimpUIManagerUIEntry *
81
 
                gimp_ui_manager_entry_get      (GimpUIManager      *manager,
82
 
                                                const gchar        *ui_path);
83
 
static gboolean gimp_ui_manager_entry_load     (GimpUIManager      *manager,
84
 
                                                GimpUIManagerUIEntry *entry,
85
 
                                                GError            **error);
86
 
static void     gimp_ui_manager_menu_position  (GtkMenu            *menu,
87
 
                                                gint               *x,
88
 
                                                gint               *y,
89
 
                                                gpointer            data);
90
 
static void     gimp_ui_manager_menu_pos       (GtkMenu            *menu,
91
 
                                                gint               *x,
92
 
                                                gint               *y,
93
 
                                                gboolean           *push_in,
94
 
                                                gpointer            data);
 
61
static GObject * gimp_ui_manager_constructor    (GType               type,
 
62
                                                 guint               n_params,
 
63
                                                 GObjectConstructParam *params);
 
64
static void     gimp_ui_manager_dispose         (GObject            *object);
 
65
static void     gimp_ui_manager_finalize        (GObject            *object);
 
66
static void     gimp_ui_manager_set_property    (GObject            *object,
 
67
                                                 guint               prop_id,
 
68
                                                 const GValue       *value,
 
69
                                                 GParamSpec         *pspec);
 
70
static void     gimp_ui_manager_get_property    (GObject            *object,
 
71
                                                 guint               prop_id,
 
72
                                                 GValue             *value,
 
73
                                                 GParamSpec         *pspec);
 
74
static void     gimp_ui_manager_connect_proxy   (GtkUIManager       *manager,
 
75
                                                 GtkAction          *action,
 
76
                                                 GtkWidget          *proxy);
 
77
static GtkWidget * gimp_ui_manager_get_widget   (GtkUIManager       *manager,
 
78
                                                 const gchar        *path);
 
79
static GtkAction * gimp_ui_manager_get_action   (GtkUIManager       *manager,
 
80
                                                 const gchar        *path);
 
81
static void     gimp_ui_manager_real_update     (GimpUIManager      *manager,
 
82
                                                 gpointer            update_data);
 
83
static GimpUIManagerUIEntry *
 
84
                gimp_ui_manager_entry_get       (GimpUIManager      *manager,
 
85
                                                 const gchar        *ui_path);
 
86
static gboolean gimp_ui_manager_entry_load      (GimpUIManager      *manager,
 
87
                                                 GimpUIManagerUIEntry *entry,
 
88
                                                 GError            **error);
 
89
static GimpUIManagerUIEntry *
 
90
                gimp_ui_manager_entry_ensure    (GimpUIManager      *manager,
 
91
                                                 const gchar        *path);
 
92
static void     gimp_ui_manager_menu_position   (GtkMenu            *menu,
 
93
                                                 gint               *x,
 
94
                                                 gint               *y,
 
95
                                                 gpointer            data);
 
96
static void     gimp_ui_manager_menu_pos        (GtkMenu            *menu,
 
97
                                                 gint               *x,
 
98
                                                 gint               *y,
 
99
                                                 gboolean           *push_in,
 
100
                                                 gpointer            data);
95
101
static void
96
 
           gimp_ui_manager_delete_popdown_data (GtkObject          *object,
97
 
                                                GimpUIManager      *manager);
98
 
static void     gimp_ui_manager_item_realize   (GtkWidget          *widget,
99
 
                                                GimpUIManager      *manager);
100
 
static gboolean gimp_ui_manager_item_key_press (GtkWidget          *widget,
101
 
                                                GdkEventKey        *kevent,
102
 
                                                GimpUIManager      *manager);
103
 
 
 
102
            gimp_ui_manager_delete_popdown_data (GtkObject          *object,
 
103
                                                 GimpUIManager      *manager);
 
104
static void     gimp_ui_manager_item_realize    (GtkWidget          *widget,
 
105
                                                 GimpUIManager      *manager);
 
106
static void    gimp_ui_manager_menu_item_select (GtkWidget          *widget,
 
107
                                                 GimpUIManager      *manager);
 
108
static void  gimp_ui_manager_menu_item_deselect (GtkWidget          *widget,
 
109
                                                 GimpUIManager      *manager);
 
110
static gboolean gimp_ui_manager_item_key_press  (GtkWidget          *widget,
 
111
                                                 GdkEventKey        *kevent,
 
112
                                                 GimpUIManager      *manager);
 
113
 
 
114
 
 
115
G_DEFINE_TYPE (GimpUIManager, gimp_ui_manager, GTK_TYPE_UI_MANAGER)
 
116
 
 
117
#define parent_class gimp_ui_manager_parent_class
104
118
 
105
119
static guint manager_signals[LAST_SIGNAL] = { 0 };
106
120
 
107
 
static GtkUIManagerClass *parent_class = NULL;
108
 
 
109
 
 
110
 
GType
111
 
gimp_ui_manager_get_type (void)
112
 
{
113
 
  static GType type = 0;
114
 
 
115
 
  if (!type)
116
 
    {
117
 
      static const GTypeInfo type_info =
118
 
      {
119
 
        sizeof (GimpUIManagerClass),
120
 
        NULL,           /* base_init */
121
 
        NULL,           /* base_finalize */
122
 
        (GClassInitFunc) gimp_ui_manager_class_init,
123
 
        NULL,           /* class_finalize */
124
 
        NULL,           /* class_data */
125
 
        sizeof (GimpUIManager),
126
 
        0, /* n_preallocs */
127
 
        (GInstanceInitFunc) gimp_ui_manager_init,
128
 
      };
129
 
 
130
 
      type = g_type_register_static (GTK_TYPE_UI_MANAGER,
131
 
                                     "GimpUIManager",
132
 
                                     &type_info, 0);
133
 
    }
134
 
 
135
 
  return type;
136
 
}
137
121
 
138
122
static void
139
123
gimp_ui_manager_class_init (GimpUIManagerClass *klass)
141
125
  GObjectClass      *object_class  = G_OBJECT_CLASS (klass);
142
126
  GtkUIManagerClass *manager_class = GTK_UI_MANAGER_CLASS (klass);
143
127
 
144
 
  parent_class = g_type_class_peek_parent (klass);
145
 
 
146
128
  object_class->constructor    = gimp_ui_manager_constructor;
147
129
  object_class->dispose        = gimp_ui_manager_dispose;
148
130
  object_class->finalize       = gimp_ui_manager_finalize;
150
132
  object_class->get_property   = gimp_ui_manager_get_property;
151
133
 
152
134
  manager_class->connect_proxy = gimp_ui_manager_connect_proxy;
 
135
  manager_class->get_widget    = gimp_ui_manager_get_widget;
 
136
  manager_class->get_action    = gimp_ui_manager_get_action;
153
137
 
154
138
  klass->update                = gimp_ui_manager_real_update;
155
139
 
156
140
  manager_signals[UPDATE] =
157
141
    g_signal_new ("update",
158
 
                  G_TYPE_FROM_CLASS (klass),
159
 
                  G_SIGNAL_RUN_LAST,
160
 
                  G_STRUCT_OFFSET (GimpUIManagerClass, update),
161
 
                  NULL, NULL,
162
 
                  gimp_marshal_VOID__POINTER,
163
 
                  G_TYPE_NONE, 1,
 
142
                  G_TYPE_FROM_CLASS (klass),
 
143
                  G_SIGNAL_RUN_LAST,
 
144
                  G_STRUCT_OFFSET (GimpUIManagerClass, update),
 
145
                  NULL, NULL,
 
146
                  gimp_marshal_VOID__POINTER,
 
147
                  G_TYPE_NONE, 1,
164
148
                  G_TYPE_POINTER);
165
149
 
 
150
  manager_signals[SHOW_TOOLTIP] =
 
151
    g_signal_new ("show-tooltip",
 
152
                  G_TYPE_FROM_CLASS (klass),
 
153
                  G_SIGNAL_RUN_LAST,
 
154
                  G_STRUCT_OFFSET (GimpUIManagerClass, show_tooltip),
 
155
                  NULL, NULL,
 
156
                  gimp_marshal_VOID__STRING,
 
157
                  G_TYPE_NONE, 1,
 
158
                  G_TYPE_STRING);
 
159
 
 
160
  manager_signals[HIDE_TOOLTIP] =
 
161
    g_signal_new ("hide-tooltip",
 
162
                  G_TYPE_FROM_CLASS (klass),
 
163
                  G_SIGNAL_RUN_LAST,
 
164
                  G_STRUCT_OFFSET (GimpUIManagerClass, hide_tooltip),
 
165
                  NULL, NULL,
 
166
                  gimp_marshal_VOID__VOID,
 
167
                  G_TYPE_NONE, 0,
 
168
                  G_TYPE_NONE);
 
169
 
166
170
  g_object_class_install_property (object_class, PROP_NAME,
167
171
                                   g_param_spec_string ("name",
168
172
                                                        NULL, NULL,
169
173
                                                        NULL,
170
 
                                                        G_PARAM_READWRITE |
 
174
                                                        GIMP_PARAM_READWRITE |
171
175
                                                        G_PARAM_CONSTRUCT_ONLY));
172
176
 
173
177
  g_object_class_install_property (object_class, PROP_GIMP,
174
178
                                   g_param_spec_object ("gimp",
175
179
                                                        NULL, NULL,
176
180
                                                        GIMP_TYPE_GIMP,
177
 
                                                        G_PARAM_READWRITE |
 
181
                                                        GIMP_PARAM_READWRITE |
178
182
                                                        G_PARAM_CONSTRUCT_ONLY));
179
183
 
180
184
  klass->managers = g_hash_table_new_full (g_str_hash, g_str_equal,
333
337
                                          GIMP_HELP_ID));
334
338
 
335
339
  if (GTK_IS_MENU_ITEM (proxy))
336
 
    g_signal_connect_after (proxy, "realize",
337
 
                            G_CALLBACK (gimp_ui_manager_item_realize),
338
 
                            manager);
 
340
    {
 
341
      g_signal_connect (proxy, "select",
 
342
                        G_CALLBACK (gimp_ui_manager_menu_item_select),
 
343
                        manager);
 
344
      g_signal_connect (proxy, "deselect",
 
345
                        G_CALLBACK (gimp_ui_manager_menu_item_deselect),
 
346
                        manager);
 
347
 
 
348
      g_signal_connect_after (proxy, "realize",
 
349
                              G_CALLBACK (gimp_ui_manager_item_realize),
 
350
                              manager);
 
351
    }
 
352
}
 
353
 
 
354
static GtkWidget *
 
355
gimp_ui_manager_get_widget (GtkUIManager *manager,
 
356
                            const gchar  *path)
 
357
{
 
358
  GimpUIManagerUIEntry *entry;
 
359
 
 
360
  entry = gimp_ui_manager_entry_ensure (GIMP_UI_MANAGER (manager), path);
 
361
 
 
362
  if (entry)
 
363
    {
 
364
      if (! strcmp (entry->ui_path, path))
 
365
        return entry->widget;
 
366
 
 
367
      return GTK_UI_MANAGER_CLASS (parent_class)->get_widget (manager, path);
 
368
    }
 
369
 
 
370
  return NULL;
 
371
}
 
372
 
 
373
static GtkAction *
 
374
gimp_ui_manager_get_action (GtkUIManager *manager,
 
375
                            const gchar  *path)
 
376
{
 
377
  if (gimp_ui_manager_entry_ensure (GIMP_UI_MANAGER (manager), path))
 
378
    return GTK_UI_MANAGER_CLASS (parent_class)->get_action (manager, path);
 
379
 
 
380
  return NULL;
339
381
}
340
382
 
341
383
static void
404
446
}
405
447
 
406
448
GimpActionGroup *
407
 
gimp_ui_manager_get_action_group (GimpUIManager   *manager,
408
 
                                  const gchar     *name)
 
449
gimp_ui_manager_get_action_group (GimpUIManager *manager,
 
450
                                  const gchar   *name)
409
451
{
410
452
  GList *list;
411
453
 
413
455
  g_return_val_if_fail (name != NULL, NULL);
414
456
 
415
457
  for (list = gtk_ui_manager_get_action_groups (GTK_UI_MANAGER (manager));
416
 
           list;
417
 
           list = g_list_next (list))
 
458
       list;
 
459
       list = g_list_next (list))
418
460
    {
419
461
      GimpActionGroup *group = list->data;
420
462
 
421
 
      if (! strcmp (gtk_action_group_get_name (GTK_ACTION_GROUP (group)), name))
 
463
      if (! strcmp (name, gtk_action_group_get_name (GTK_ACTION_GROUP (group))))
422
464
        return group;
423
465
    }
424
466
 
431
473
                             const gchar   *action_name)
432
474
{
433
475
  GimpActionGroup *group;
 
476
  GtkAction       *action = NULL;
434
477
 
435
478
  g_return_val_if_fail (GIMP_IS_UI_MANAGER (manager), NULL);
436
 
  g_return_val_if_fail (group_name != NULL, NULL);
437
479
  g_return_val_if_fail (action_name != NULL, NULL);
438
480
 
439
 
  group = gimp_ui_manager_get_action_group (manager, group_name);
440
 
 
441
 
  if (group)
442
 
    return gtk_action_group_get_action (GTK_ACTION_GROUP (group), action_name);
443
 
 
444
 
  return NULL;
445
 
}
 
481
  if (group_name)
 
482
    {
 
483
      group = gimp_ui_manager_get_action_group (manager, group_name);
 
484
 
 
485
      if (group)
 
486
        action = gtk_action_group_get_action (GTK_ACTION_GROUP (group),
 
487
                                              action_name);
 
488
    }
 
489
  else
 
490
    {
 
491
      GList *list;
 
492
 
 
493
      for (list = gtk_ui_manager_get_action_groups (GTK_UI_MANAGER (manager));
 
494
           list;
 
495
           list = g_list_next (list))
 
496
        {
 
497
          group = list->data;
 
498
 
 
499
          action = gtk_action_group_get_action (GTK_ACTION_GROUP (group),
 
500
                                                action_name);
 
501
 
 
502
          if (action)
 
503
            break;
 
504
        }
 
505
    }
 
506
 
 
507
  return action;
 
508
}
 
509
 
 
510
gboolean
 
511
gimp_ui_manager_activate_action (GimpUIManager *manager,
 
512
                                 const gchar   *group_name,
 
513
                                 const gchar   *action_name)
 
514
{
 
515
  GtkAction *action;
 
516
 
 
517
  g_return_val_if_fail (GIMP_IS_UI_MANAGER (manager), FALSE);
 
518
  g_return_val_if_fail (action_name != NULL, FALSE);
 
519
 
 
520
  action = gimp_ui_manager_find_action (manager, group_name, action_name);
 
521
 
 
522
  if (action)
 
523
    gtk_action_activate (action);
 
524
 
 
525
  return (action != NULL);
 
526
}
 
527
 
446
528
 
447
529
void
448
530
gimp_ui_manager_ui_register (GimpUIManager          *manager,
468
550
  manager->registered_uis = g_list_prepend (manager->registered_uis, entry);
469
551
}
470
552
 
471
 
GtkWidget *
472
 
gimp_ui_manager_ui_get (GimpUIManager *manager,
473
 
                        const gchar   *ui_path)
474
 
{
475
 
  GimpUIManagerUIEntry *entry;
476
 
 
477
 
  g_return_val_if_fail (GIMP_IS_UI_MANAGER (manager), NULL);
478
 
  g_return_val_if_fail (ui_path != NULL, NULL);
479
 
 
480
 
  entry = gimp_ui_manager_entry_get (manager, ui_path);
481
 
 
482
 
  if (! entry)
483
 
    {
484
 
      g_warning ("%s: no entry registered for \"%s\"", G_STRFUNC, ui_path);
485
 
      return NULL;
486
 
    }
487
 
 
488
 
  if (! entry->merge_id)
489
 
    {
490
 
      GError *error = NULL;
491
 
 
492
 
      if (! gimp_ui_manager_entry_load (manager, entry, &error))
493
 
        {
494
 
          g_message ("%s\n\n%s\n\n%s",
495
 
                     _("Your GIMP installation is incomplete:"),
496
 
                     error->message,
497
 
                     _("Plase make sure the menu XML files are correctly "
498
 
                       "installed."));
499
 
          g_clear_error (&error);
500
 
          return NULL;
501
 
        }
502
 
    }
503
 
 
504
 
  if (! entry->widget)
505
 
    {
506
 
      entry->widget = gtk_ui_manager_get_widget (GTK_UI_MANAGER (manager),
507
 
                                                 entry->ui_path);
508
 
 
509
 
      if (entry->widget)
510
 
        {
511
 
          g_object_ref (entry->widget);
512
 
 
513
 
          /*  take ownership of popup menus  */
514
 
          if (GTK_IS_MENU (entry->widget))
515
 
            gtk_object_sink (GTK_OBJECT (entry->widget));
516
 
 
517
 
          if (entry->setup_func)
518
 
            entry->setup_func (manager, entry->ui_path);
519
 
        }
520
 
      else
521
 
        {
522
 
          g_warning ("%s: \"%s\" does not contain registered toplevel "
523
 
                     "widget \"%s\"",
524
 
                     G_STRFUNC, entry->basename, entry->ui_path);
525
 
          return NULL;
526
 
        }
527
 
    }
528
 
 
529
 
  if (! strcmp (entry->ui_path, ui_path))
530
 
    return entry->widget;
531
 
 
532
 
  return gtk_ui_manager_get_widget (GTK_UI_MANAGER (manager), ui_path);
533
 
}
534
 
 
535
553
typedef struct
536
554
{
537
555
  guint x;
558
576
  g_return_if_fail (ui_path != NULL);
559
577
  g_return_if_fail (parent == NULL || GTK_IS_WIDGET (parent));
560
578
 
561
 
  widget = gimp_ui_manager_ui_get (manager, ui_path);
 
579
  widget = gtk_ui_manager_get_widget (GTK_UI_MANAGER (manager), ui_path);
562
580
 
563
581
  if (GTK_IS_MENU_ITEM (widget))
564
582
    widget = gtk_menu_item_get_submenu (GTK_MENU_ITEM (widget));
588
606
      activate_time = 0;
589
607
    }
590
608
 
 
609
  if (current_event)
 
610
    gdk_event_free (current_event);
 
611
 
591
612
  menu_pos = g_object_get_data (G_OBJECT (widget), "menu-pos");
592
613
 
593
614
  if (! menu_pos)
676
697
  return TRUE;
677
698
}
678
699
 
 
700
static GimpUIManagerUIEntry *
 
701
gimp_ui_manager_entry_ensure (GimpUIManager *manager,
 
702
                              const gchar   *path)
 
703
{
 
704
  GimpUIManagerUIEntry *entry;
 
705
 
 
706
  entry = gimp_ui_manager_entry_get (manager, path);
 
707
 
 
708
  if (! entry)
 
709
    {
 
710
      g_warning ("%s: no entry registered for \"%s\"", G_STRFUNC, path);
 
711
      return NULL;
 
712
    }
 
713
 
 
714
  if (! entry->merge_id)
 
715
    {
 
716
      GError *error = NULL;
 
717
 
 
718
      if (! gimp_ui_manager_entry_load (manager, entry, &error))
 
719
        {
 
720
          if (error->domain == G_FILE_ERROR &&
 
721
              error->code == G_FILE_ERROR_EXIST)
 
722
            {
 
723
              gimp_message (manager->gimp, NULL, GIMP_MESSAGE_ERROR,
 
724
                            "%s\n\n%s\n\n%s",
 
725
                            _("Your GIMP installation is incomplete:"),
 
726
                            error->message,
 
727
                            _("Plase make sure the menu XML files are correctly "
 
728
                              "installed."));
 
729
            }
 
730
          else
 
731
            {
 
732
              gimp_message (manager->gimp, NULL, GIMP_MESSAGE_ERROR,
 
733
                            _("There was an error parsing the menu definition "
 
734
                              "from %s: %s"),
 
735
                            gimp_filename_to_utf8 (entry->basename),
 
736
                            error->message);
 
737
            }
 
738
 
 
739
          g_clear_error (&error);
 
740
          return NULL;
 
741
        }
 
742
    }
 
743
 
 
744
  if (! entry->widget)
 
745
    {
 
746
      GtkUIManager *gtk_manager = GTK_UI_MANAGER (manager);
 
747
 
 
748
      entry->widget =
 
749
        GTK_UI_MANAGER_CLASS (parent_class)->get_widget (gtk_manager,
 
750
                                                         entry->ui_path);
 
751
 
 
752
      if (entry->widget)
 
753
        {
 
754
          g_object_ref (entry->widget);
 
755
 
 
756
          /*  take ownership of popup menus  */
 
757
          if (GTK_IS_MENU (entry->widget))
 
758
            {
 
759
              g_object_ref_sink (entry->widget);
 
760
              g_object_unref (entry->widget);
 
761
            }
 
762
 
 
763
          if (entry->setup_func)
 
764
            entry->setup_func (manager, entry->ui_path);
 
765
        }
 
766
      else
 
767
        {
 
768
          g_warning ("%s: \"%s\" does not contain registered toplevel "
 
769
                     "widget \"%s\"",
 
770
                     G_STRFUNC, entry->basename, entry->ui_path);
 
771
          return NULL;
 
772
        }
 
773
    }
 
774
 
 
775
  return entry;
 
776
}
 
777
 
679
778
static void
680
779
gimp_ui_manager_menu_position (GtkMenu  *menu,
681
780
                               gint     *x,
772
871
      if (! GPOINTER_TO_INT (g_object_get_qdata (G_OBJECT (widget->parent),
773
872
                                                 quark_key_press_connected)))
774
873
        {
775
 
          g_signal_connect (widget->parent, "key_press_event",
 
874
          g_signal_connect (widget->parent, "key-press-event",
776
875
                            G_CALLBACK (gimp_ui_manager_item_key_press),
777
876
                            manager);
778
877
 
790
889
                                            GIMP_HELP_ID));
791
890
}
792
891
 
 
892
static void
 
893
gimp_ui_manager_menu_item_select (GtkWidget     *widget,
 
894
                                  GimpUIManager *manager)
 
895
{
 
896
  GtkAction *action = g_object_get_data (G_OBJECT (widget), "gtk-action");
 
897
 
 
898
  if (action)
 
899
    {
 
900
      gchar *tooltip;
 
901
 
 
902
      g_object_get (action, "tooltip", &tooltip, NULL);
 
903
 
 
904
      if (tooltip)
 
905
        {
 
906
          g_signal_emit (manager, manager_signals[SHOW_TOOLTIP], 0,
 
907
                         tooltip);
 
908
          g_free (tooltip);
 
909
        }
 
910
    }
 
911
}
 
912
 
 
913
static void
 
914
gimp_ui_manager_menu_item_deselect (GtkWidget     *widget,
 
915
                                    GimpUIManager *manager)
 
916
{
 
917
  g_signal_emit (manager, manager_signals[HIDE_TOOLTIP], 0);
 
918
}
 
919
 
793
920
static gboolean
794
921
gimp_ui_manager_item_key_press (GtkWidget     *widget,
795
922
                                GdkEventKey   *kevent,