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

   1 /* GTK - The GIMP Toolkit
   2  * Copyright (C) 2001 Red Hat, Inc.
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser 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  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser 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 /*
  21  * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS
  22  * file for a list of people on the GTK+ Team.  See the ChangeLog
  23  * files for a list of changes.  These files are distributed with
  24  * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
  25  */
  26
  27 #include "config.h"
  28
  29 #include "gtkimagemenuitem.h"
  30
  31 #include "gtkaccellabel.h"
  32 #include "gtkstock.h"
  33 #include "gtkiconfactory.h"
  34 #include "gtkimage.h"
  35 #include "gtkmenubar.h"
  36 #include "gtkcontainer.h"
  37 #include "gtkwindow.h"
  38 #include "gtkactivatable.h"
  39 #include "gtksizerequest.h"
  40
  41 #include "gtkintl.h"
  42 #include "gtkprivate.h"
  43
  44
  45
  46 struct _GtkImageMenuItemPrivate
  47 {
  48   GtkWidget     *image;
  49
  50   gchar         *label;
  51   guint          use_stock         : 1;
  52   guint          always_show_image : 1;
  53 };
  54
  55 enum {
  56   PROP_0,
  57   PROP_IMAGE,
  58   PROP_USE_STOCK,
  59   PROP_ACCEL_GROUP,
  60   PROP_ALWAYS_SHOW_IMAGE
  61 };
  62
  63 static GtkActivatableIface *parent_activatable_iface;
  64
  65 static void gtk_image_menu_item_destroy              (GtkObject        *object);
  66 static void gtk_image_menu_item_size_request         (GtkWidget        *widget,
  67                                                       GtkRequisition   *requisition);
  68 static void gtk_image_menu_item_size_allocate        (GtkWidget        *widget,
  69                                                       GtkAllocation    *allocation);
  70 static void gtk_image_menu_item_map                  (GtkWidget        *widget);
  71 static void gtk_image_menu_item_remove               (GtkContainer     *container,
  72                                                       GtkWidget        *child);
  73 static void gtk_image_menu_item_toggle_size_request  (GtkMenuItem      *menu_item,
  74                                                       gint             *requisition);
  75 static void gtk_image_menu_item_set_label            (GtkMenuItem      *menu_item,
  76                                                       const gchar      *label);
  77 static G_CONST_RETURN gchar *gtk_image_menu_item_get_label (GtkMenuItem *menu_item);
  78
  79 static void gtk_image_menu_item_forall               (GtkContainer    *container,
  80                                                       gboolean         include_internals,
  81                                                       GtkCallback      callback,
  82                                                       gpointer         callback_data);
  83
  84 static void gtk_image_menu_item_finalize             (GObject         *object);
  85 static void gtk_image_menu_item_set_property         (GObject         *object,
  86                                                       guint            prop_id,
  87                                                       const GValue    *value,
  88                                                       GParamSpec      *pspec);
  89 static void gtk_image_menu_item_get_property         (GObject         *object,
  90                                                       guint            prop_id,
  91                                                       GValue          *value,
  92                                                       GParamSpec      *pspec);
  93 static void gtk_image_menu_item_screen_changed       (GtkWidget        *widget,
  94                                                       GdkScreen        *previous_screen);
  95
  96 static void gtk_image_menu_item_recalculate          (GtkImageMenuItem *image_menu_item);
  97
  98 static void gtk_image_menu_item_activatable_interface_init (GtkActivatableIface  *iface);
  99 static void gtk_image_menu_item_update                     (GtkActivatable       *activatable,
 100                                                             GtkAction            *action,
 101                                                             const gchar          *property_name);
 102 static void gtk_image_menu_item_sync_action_properties     (GtkActivatable       *activatable,
 103                                                             GtkAction            *action);
 104
 105
 106 G_DEFINE_TYPE_WITH_CODE (GtkImageMenuItem, gtk_image_menu_item, GTK_TYPE_MENU_ITEM,
 107                          G_IMPLEMENT_INTERFACE (GTK_TYPE_ACTIVATABLE,
 108                                                 gtk_image_menu_item_activatable_interface_init))
 109
 110
 111 static void
 112 gtk_image_menu_item_class_init (GtkImageMenuItemClass *klass)
 113 {
 114   GObjectClass *gobject_class = (GObjectClass*) klass;
 115   GtkObjectClass *object_class = (GtkObjectClass*) klass;
 116   GtkWidgetClass *widget_class = (GtkWidgetClass*) klass;
 117   GtkMenuItemClass *menu_item_class = (GtkMenuItemClass*) klass;
 118   GtkContainerClass *container_class = (GtkContainerClass*) klass;
 119
 120   object_class->destroy = gtk_image_menu_item_destroy;
 121
 122   widget_class->screen_changed = gtk_image_menu_item_screen_changed;
 123   widget_class->size_request = gtk_image_menu_item_size_request;
 124   widget_class->size_allocate = gtk_image_menu_item_size_allocate;
 125   widget_class->map = gtk_image_menu_item_map;
 126
 127   container_class->forall = gtk_image_menu_item_forall;
 128   container_class->remove = gtk_image_menu_item_remove;
 129
 130   menu_item_class->toggle_size_request = gtk_image_menu_item_toggle_size_request;
 131   menu_item_class->set_label           = gtk_image_menu_item_set_label;
 132   menu_item_class->get_label           = gtk_image_menu_item_get_label;
 133
 134   gobject_class->finalize     = gtk_image_menu_item_finalize;
 135   gobject_class->set_property = gtk_image_menu_item_set_property;
 136   gobject_class->get_property = gtk_image_menu_item_get_property;
 137
 138   g_object_class_install_property (gobject_class,
 139                                    PROP_IMAGE,
 140                                    g_param_spec_object ("image",
 141                                                         P_("Image widget"),
 142                                                         P_("Child widget to appear next to the menu text"),
 143                                                         GTK_TYPE_WIDGET,
 144                                                         GTK_PARAM_READWRITE));
 145   /**
 146    * GtkImageMenuItem:use-stock:
 147    *
 148    * If %TRUE, the label set in the menuitem is used as a
 149    * stock id to select the stock item for the item.
 150    *
 151    * Since: 2.16
 152    **/
 153   g_object_class_install_property (gobject_class,
 154                                    PROP_USE_STOCK,
 155                                    g_param_spec_boolean ("use-stock",
 156                                                          P_("Use stock"),
 157                                                          P_("Whether to use the label text to create a stock menu item"),
 158                                                          FALSE,
 159                                                          GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT));
 160
 161   /**
 162    * GtkImageMenuItem:always-show-image:
 163    *
 164    * If %TRUE, the menu item will ignore the #GtkSettings:gtk-menu-images
 165    * setting and always show the image, if available.
 166    *
 167    * Use this property if the menuitem would be useless or hard to use
 168    * without the image.
 169    *
 170    * Since: 2.16
 171    **/
 172   g_object_class_install_property (gobject_class,
 173                                    PROP_ALWAYS_SHOW_IMAGE,
 174                                    g_param_spec_boolean ("always-show-image",
 175                                                          P_("Always show image"),
 176                                                          P_("Whether the image will always be shown"),
 177                                                          FALSE,
 178                                                          GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT));
 179
 180   /**
 181    * GtkImageMenuItem:accel-group:
 182    *
 183    * The Accel Group to use for stock accelerator keys
 184    *
 185    * Since: 2.16
 186    **/
 187   g_object_class_install_property (gobject_class,
 188                                    PROP_ACCEL_GROUP,
 189                                    g_param_spec_object ("accel-group",
 190                                                         P_("Accel Group"),
 191                                                         P_("The Accel Group to use for stock accelerator keys"),
 192                                                         GTK_TYPE_ACCEL_GROUP,
 193                                                         GTK_PARAM_WRITABLE));
 194
 195   gtk_settings_install_property (g_param_spec_boolean ("gtk-menu-images",
 196                                                        P_("Show menu images"),
 197                                                        P_("Whether images should be shown in menus"),
 198                                                        TRUE,
 199                                                        GTK_PARAM_READWRITE));
 200
 201   g_type_class_add_private (object_class, sizeof (GtkImageMenuItemPrivate));
 202 }
 203
 204 static void
 205 gtk_image_menu_item_init (GtkImageMenuItem *image_menu_item)
 206 {
 207   GtkImageMenuItemPrivate *priv;
 208
 209   image_menu_item->priv = G_TYPE_INSTANCE_GET_PRIVATE (image_menu_item,
 210                                                        GTK_TYPE_IMAGE_MENU_ITEM,
 211                                                        GtkImageMenuItemPrivate);
 212   priv = image_menu_item->priv;
 213
 214   priv->image = NULL;
 215   priv->use_stock = FALSE;
 216   priv->label  = NULL;
 217 }
 218
 219 static void
 220 gtk_image_menu_item_finalize (GObject *object)
 221 {
 222   GtkImageMenuItemPrivate *priv = GTK_IMAGE_MENU_ITEM (object)->priv;
 223
 224   g_free (priv->label);
 225   priv->label  = NULL;
 226
 227   G_OBJECT_CLASS (gtk_image_menu_item_parent_class)->finalize (object);
 228 }
 229
 230 static void
 231 gtk_image_menu_item_set_property (GObject         *object,
 232                                   guint            prop_id,
 233                                   const GValue    *value,
 234                                   GParamSpec      *pspec)
 235 {
 236   GtkImageMenuItem *image_menu_item = GTK_IMAGE_MENU_ITEM (object);
 237
 238   switch (prop_id)
 239     {
 240     case PROP_IMAGE:
 241       gtk_image_menu_item_set_image (image_menu_item, (GtkWidget *) g_value_get_object (value));
 242       break;
 243     case PROP_USE_STOCK:
 244       gtk_image_menu_item_set_use_stock (image_menu_item, g_value_get_boolean (value));
 245       break;
 246     case PROP_ALWAYS_SHOW_IMAGE:
 247       gtk_image_menu_item_set_always_show_image (image_menu_item, g_value_get_boolean (value));
 248       break;
 249     case PROP_ACCEL_GROUP:
 250       gtk_image_menu_item_set_accel_group (image_menu_item, g_value_get_object (value));
 251       break;
 252     default:
 253       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 254       break;
 255     }
 256 }
 257
 258 static void
 259 gtk_image_menu_item_get_property (GObject         *object,
 260                                   guint            prop_id,
 261                                   GValue          *value,
 262                                   GParamSpec      *pspec)
 263 {
 264   GtkImageMenuItem *image_menu_item = GTK_IMAGE_MENU_ITEM (object);
 265
 266   switch (prop_id)
 267     {
 268     case PROP_IMAGE:
 269       g_value_set_object (value, gtk_image_menu_item_get_image (image_menu_item));
 270       break;
 271     case PROP_USE_STOCK:
 272       g_value_set_boolean (value, gtk_image_menu_item_get_use_stock (image_menu_item));
 273       break;
 274     case PROP_ALWAYS_SHOW_IMAGE:
 275       g_value_set_boolean (value, gtk_image_menu_item_get_always_show_image (image_menu_item));
 276       break;
 277     default:
 278       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 279       break;
 280     }
 281 }
 282
 283 static gboolean
 284 show_image (GtkImageMenuItem *image_menu_item)
 285 {
 286   GtkImageMenuItemPrivate *priv = image_menu_item->priv;
 287   GtkSettings *settings = gtk_widget_get_settings (GTK_WIDGET (image_menu_item));
 288   gboolean show;
 289
 290   if (priv->always_show_image)
 291     show = TRUE;
 292   else
 293     g_object_get (settings, "gtk-menu-images", &show, NULL);
 294
 295   return show;
 296 }
 297
 298 static void
 299 gtk_image_menu_item_map (GtkWidget *widget)
 300 {
 301   GtkImageMenuItem *image_menu_item = GTK_IMAGE_MENU_ITEM (widget);
 302   GtkImageMenuItemPrivate *priv = image_menu_item->priv;
 303
 304   GTK_WIDGET_CLASS (gtk_image_menu_item_parent_class)->map (widget);
 305
 306   if (priv->image)
 307     g_object_set (priv->image,
 308                   "visible", show_image (image_menu_item),
 309                   NULL);
 310 }
 311
 312 static void
 313 gtk_image_menu_item_destroy (GtkObject *object)
 314 {
 315   GtkImageMenuItem *image_menu_item = GTK_IMAGE_MENU_ITEM (object);
 316   GtkImageMenuItemPrivate *priv = image_menu_item->priv;
 317
 318   if (priv->image)
 319     gtk_container_remove (GTK_CONTAINER (image_menu_item),
 320                           priv->image);
 321
 322   GTK_OBJECT_CLASS (gtk_image_menu_item_parent_class)->destroy (object);
 323 }
 324
 325 static void
 326 gtk_image_menu_item_toggle_size_request (GtkMenuItem *menu_item,
 327                                          gint        *requisition)
 328 {
 329   GtkImageMenuItem *image_menu_item = GTK_IMAGE_MENU_ITEM (menu_item);
 330   GtkImageMenuItemPrivate *priv = image_menu_item->priv;
 331   GtkPackDirection pack_dir;
 332   GtkWidget *parent;
 333   GtkWidget *widget = GTK_WIDGET (menu_item);
 334
 335   parent = gtk_widget_get_parent (widget);
 336
 337   if (GTK_IS_MENU_BAR (parent))
 338     pack_dir = gtk_menu_bar_get_child_pack_direction (GTK_MENU_BAR (parent));
 339   else
 340     pack_dir = GTK_PACK_DIRECTION_LTR;
 341
 342   *requisition = 0;
 343
 344   if (priv->image && gtk_widget_get_visible (priv->image))
 345     {
 346       GtkRequisition image_requisition;
 347       guint toggle_spacing;
 348
 349       gtk_size_request_get_size (GTK_SIZE_REQUEST (priv->image),
 350                                  &image_requisition, NULL);
 351
 352       gtk_widget_style_get (GTK_WIDGET (menu_item),
 353                             "toggle-spacing", &toggle_spacing,
 354                             NULL);
 355
 356       if (pack_dir == GTK_PACK_DIRECTION_LTR || pack_dir == GTK_PACK_DIRECTION_RTL)
 357         {
 358           if (image_requisition.width > 0)
 359             *requisition = image_requisition.width + toggle_spacing;
 360         }
 361       else
 362         {
 363           if (image_requisition.height > 0)
 364             *requisition = image_requisition.height + toggle_spacing;
 365         }
 366     }
 367 }
 368
 369 static void
 370 gtk_image_menu_item_recalculate (GtkImageMenuItem *image_menu_item)
 371 {
 372   GtkImageMenuItemPrivate    *priv = image_menu_item->priv;
 373   GtkStockItem             stock_item;
 374   GtkWidget               *image;
 375   const gchar             *resolved_label = priv->label;
 376
 377   if (priv->use_stock && priv->label)
 378     {
 379
 380       if (!priv->image)
 381         {
 382           image = gtk_image_new_from_stock (priv->label, GTK_ICON_SIZE_MENU);
 383           gtk_image_menu_item_set_image (image_menu_item, image);
 384         }
 385
 386       if (gtk_stock_lookup (priv->label, &stock_item))
 387           resolved_label = stock_item.label;
 388
 389         gtk_menu_item_set_use_underline (GTK_MENU_ITEM (image_menu_item), TRUE);
 390     }
 391
 392   GTK_MENU_ITEM_CLASS
 393     (gtk_image_menu_item_parent_class)->set_label (GTK_MENU_ITEM (image_menu_item), resolved_label);
 394
 395 }
 396
 397 static void
 398 gtk_image_menu_item_set_label (GtkMenuItem      *menu_item,
 399                                const gchar      *label)
 400 {
 401   GtkImageMenuItemPrivate *priv = GTK_IMAGE_MENU_ITEM (menu_item)->priv;
 402
 403   if (priv->label != label)
 404     {
 405       g_free (priv->label);
 406       priv->label = g_strdup (label);
 407
 408       gtk_image_menu_item_recalculate (GTK_IMAGE_MENU_ITEM (menu_item));
 409
 410       g_object_notify (G_OBJECT (menu_item), "label");
 411
 412     }
 413 }
 414
 415 static G_CONST_RETURN gchar *
 416 gtk_image_menu_item_get_label (GtkMenuItem *menu_item)
 417 {
 418   GtkImageMenuItemPrivate *priv = GTK_IMAGE_MENU_ITEM (menu_item)->priv;
 419
 420   return priv->label;
 421 }
 422
 423 static void
 424 gtk_image_menu_item_size_request (GtkWidget      *widget,
 425                                   GtkRequisition *requisition)
 426 {
 427   GtkImageMenuItem *image_menu_item = GTK_IMAGE_MENU_ITEM (widget);
 428   GtkImageMenuItemPrivate *priv = image_menu_item->priv;
 429   gint child_width = 0;
 430   gint child_height = 0;
 431   GtkPackDirection pack_dir;
 432   GtkWidget *parent;
 433
 434   parent = gtk_widget_get_parent (widget);
 435
 436   if (GTK_IS_MENU_BAR (parent))
 437     pack_dir = gtk_menu_bar_get_child_pack_direction (GTK_MENU_BAR (parent));
 438   else
 439     pack_dir = GTK_PACK_DIRECTION_LTR;
 440
 441   if (priv->image && gtk_widget_get_visible (priv->image))
 442     {
 443       GtkRequisition child_requisition;
 444
 445       gtk_size_request_get_size (GTK_SIZE_REQUEST (priv->image),
 446                                  &child_requisition, NULL);
 447
 448       child_width = child_requisition.width;
 449       child_height = child_requisition.height;
 450     }
 451
 452   GTK_WIDGET_CLASS (gtk_image_menu_item_parent_class)->size_request (widget, requisition);
 453
 454   /* not done with height since that happens via the
 455    * toggle_size_request
 456    */
 457   if (pack_dir == GTK_PACK_DIRECTION_LTR || pack_dir == GTK_PACK_DIRECTION_RTL)
 458     requisition->height = MAX (requisition->height, child_height);
 459   else
 460     requisition->width = MAX (requisition->width, child_width);
 461
 462
 463   /* Note that GtkMenuShell always size requests before
 464    * toggle_size_request, so toggle_size_request will be able to use
 465    * priv->image->requisition
 466    */
 467 }
 468
 469 static void
 470 gtk_image_menu_item_size_allocate (GtkWidget     *widget,
 471                                    GtkAllocation *allocation)
 472 {
 473   GtkImageMenuItem *image_menu_item = GTK_IMAGE_MENU_ITEM (widget);
 474   GtkImageMenuItemPrivate *priv = image_menu_item->priv;
 475   GtkAllocation widget_allocation;
 476   GtkPackDirection pack_dir;
 477   GtkWidget *parent;
 478
 479   parent = gtk_widget_get_parent (widget);
 480
 481   if (GTK_IS_MENU_BAR (parent))
 482     pack_dir = gtk_menu_bar_get_child_pack_direction (GTK_MENU_BAR (parent));
 483   else
 484     pack_dir = GTK_PACK_DIRECTION_LTR;
 485
 486   GTK_WIDGET_CLASS (gtk_image_menu_item_parent_class)->size_allocate (widget, allocation);
 487
 488   if (priv->image && gtk_widget_get_visible (priv->image))
 489     {
 490       gint x, y, offset;
 491       GtkRequisition child_requisition;
 492       GtkAllocation child_allocation;
 493       guint horizontal_padding, toggle_spacing;
 494
 495       gtk_widget_style_get (widget,
 496                             "horizontal-padding", &horizontal_padding,
 497                             "toggle-spacing", &toggle_spacing,
 498                             NULL);
 499
 500       /* Man this is lame hardcoding action, but I can't
 501        * come up with a solution that's really better.
 502        */
 503
 504       gtk_size_request_get_size (GTK_SIZE_REQUEST (priv->image),
 505                                  &child_requisition, NULL);
 506
 507       gtk_widget_get_allocation (widget, &widget_allocation);
 508
 509       if (pack_dir == GTK_PACK_DIRECTION_LTR ||
 510           pack_dir == GTK_PACK_DIRECTION_RTL)
 511         {
 512           offset = gtk_container_get_border_width (GTK_CONTAINER (image_menu_item)) +
 513                    gtk_widget_get_style (widget)->xthickness;
 514
 515           if ((gtk_widget_get_direction (widget) == GTK_TEXT_DIR_LTR) ==
 516               (pack_dir == GTK_PACK_DIRECTION_LTR))
 517             x = offset + horizontal_padding +
 518               (GTK_MENU_ITEM (image_menu_item)->toggle_size -
 519                toggle_spacing - child_requisition.width) / 2;
 520           else
 521             x = widget_allocation.width - offset - horizontal_padding -
 522               GTK_MENU_ITEM (image_menu_item)->toggle_size + toggle_spacing +
 523               (GTK_MENU_ITEM (image_menu_item)->toggle_size -
 524                toggle_spacing - child_requisition.width) / 2;
 525
 526           y = (widget_allocation.height - child_requisition.height) / 2;
 527         }
 528       else
 529         {
 530           offset = gtk_container_get_border_width (GTK_CONTAINER (image_menu_item)) +
 531                    gtk_widget_get_style (widget)->ythickness;
 532
 533           if ((gtk_widget_get_direction (widget) == GTK_TEXT_DIR_LTR) ==
 534               (pack_dir == GTK_PACK_DIRECTION_TTB))
 535             y = offset + horizontal_padding +
 536               (GTK_MENU_ITEM (image_menu_item)->toggle_size -
 537                toggle_spacing - child_requisition.height) / 2;
 538           else
 539             y = widget_allocation.height - offset - horizontal_padding -
 540               GTK_MENU_ITEM (image_menu_item)->toggle_size + toggle_spacing +
 541               (GTK_MENU_ITEM (image_menu_item)->toggle_size -
 542                toggle_spacing - child_requisition.height) / 2;
 543
 544           x = (widget_allocation.width - child_requisition.width) / 2;
 545         }
 546
 547       child_allocation.width = child_requisition.width;
 548       child_allocation.height = child_requisition.height;
 549       child_allocation.x = widget_allocation.x + MAX (x, 0);
 550       child_allocation.y = widget_allocation.y + MAX (y, 0);
 551
 552       gtk_widget_size_allocate (priv->image, &child_allocation);
 553     }
 554 }
 555
 556 static void
 557 gtk_image_menu_item_forall (GtkContainer   *container,
 558                             gboolean        include_internals,
 559                             GtkCallback     callback,
 560                             gpointer        callback_data)
 561 {
 562   GtkImageMenuItem *image_menu_item = GTK_IMAGE_MENU_ITEM (container);
 563   GtkImageMenuItemPrivate *priv = image_menu_item->priv;
 564
 565   GTK_CONTAINER_CLASS (gtk_image_menu_item_parent_class)->forall (container,
 566                                                                   include_internals,
 567                                                                   callback,
 568                                                                   callback_data);
 569
 570   if (include_internals && priv->image)
 571     (* callback) (priv->image, callback_data);
 572 }
 573
 574
 575 static void
 576 gtk_image_menu_item_activatable_interface_init (GtkActivatableIface  *iface)
 577 {
 578   parent_activatable_iface = g_type_interface_peek_parent (iface);
 579   iface->update = gtk_image_menu_item_update;
 580   iface->sync_action_properties = gtk_image_menu_item_sync_action_properties;
 581 }
 582
 583 static gboolean
 584 activatable_update_stock_id (GtkImageMenuItem *image_menu_item, GtkAction *action)
 585 {
 586   GtkWidget   *image;
 587   const gchar *stock_id  = gtk_action_get_stock_id (action);
 588
 589   image = gtk_image_menu_item_get_image (image_menu_item);
 590
 591   if (GTK_IS_IMAGE (image) &&
 592       stock_id && gtk_icon_factory_lookup_default (stock_id))
 593     {
 594       gtk_image_set_from_stock (GTK_IMAGE (image), stock_id, GTK_ICON_SIZE_MENU);
 595       return TRUE;
 596     }
 597
 598   return FALSE;
 599 }
 600
 601 static gboolean
 602 activatable_update_gicon (GtkImageMenuItem *image_menu_item, GtkAction *action)
 603 {
 604   GtkWidget   *image;
 605   GIcon       *icon = gtk_action_get_gicon (action);
 606   const gchar *stock_id = gtk_action_get_stock_id (action);
 607
 608   image = gtk_image_menu_item_get_image (image_menu_item);
 609
 610   if (icon && GTK_IS_IMAGE (image) &&
 611       !(stock_id && gtk_icon_factory_lookup_default (stock_id)))
 612     {
 613       gtk_image_set_from_gicon (GTK_IMAGE (image), icon, GTK_ICON_SIZE_MENU);
 614       return TRUE;
 615     }
 616
 617   return FALSE;
 618 }
 619
 620 static void
 621 activatable_update_icon_name (GtkImageMenuItem *image_menu_item, GtkAction *action)
 622 {
 623   GtkWidget   *image;
 624   const gchar *icon_name = gtk_action_get_icon_name (action);
 625
 626   image = gtk_image_menu_item_get_image (image_menu_item);
 627
 628   if (GTK_IS_IMAGE (image) &&
 629       (gtk_image_get_storage_type (GTK_IMAGE (image)) == GTK_IMAGE_EMPTY ||
 630        gtk_image_get_storage_type (GTK_IMAGE (image)) == GTK_IMAGE_ICON_NAME))
 631     {
 632       gtk_image_set_from_icon_name (GTK_IMAGE (image), icon_name, GTK_ICON_SIZE_MENU);
 633     }
 634 }
 635
 636 static void
 637 gtk_image_menu_item_update (GtkActivatable *activatable,
 638                             GtkAction      *action,
 639                             const gchar    *property_name)
 640 {
 641   GtkImageMenuItem *image_menu_item;
 642   gboolean   use_appearance;
 643
 644   image_menu_item = GTK_IMAGE_MENU_ITEM (activatable);
 645
 646   parent_activatable_iface->update (activatable, action, property_name);
 647
 648   use_appearance = gtk_activatable_get_use_action_appearance (activatable);
 649   if (!use_appearance)
 650     return;
 651
 652   if (strcmp (property_name, "stock-id") == 0)
 653     activatable_update_stock_id (image_menu_item, action);
 654   else if (strcmp (property_name, "gicon") == 0)
 655     activatable_update_gicon (image_menu_item, action);
 656   else if (strcmp (property_name, "icon-name") == 0)
 657     activatable_update_icon_name (image_menu_item, action);
 658 }
 659
 660 static void
 661 gtk_image_menu_item_sync_action_properties (GtkActivatable *activatable,
 662                                             GtkAction      *action)
 663 {
 664   GtkImageMenuItem *image_menu_item;
 665   GtkWidget *image;
 666   gboolean   use_appearance;
 667
 668   image_menu_item = GTK_IMAGE_MENU_ITEM (activatable);
 669
 670   parent_activatable_iface->sync_action_properties (activatable, action);
 671
 672   if (!action)
 673     return;
 674
 675   use_appearance = gtk_activatable_get_use_action_appearance (activatable);
 676   if (!use_appearance)
 677     return;
 678
 679   image = gtk_image_menu_item_get_image (image_menu_item);
 680   if (image && !GTK_IS_IMAGE (image))
 681     {
 682       gtk_image_menu_item_set_image (image_menu_item, NULL);
 683       image = NULL;
 684     }
 685
 686   if (!image)
 687     {
 688       image = gtk_image_new ();
 689       gtk_widget_show (image);
 690       gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (activatable),
 691                                      image);
 692     }
 693
 694   if (!activatable_update_stock_id (image_menu_item, action) &&
 695       !activatable_update_gicon (image_menu_item, action))
 696     activatable_update_icon_name (image_menu_item, action);
 697
 698   gtk_image_menu_item_set_always_show_image (image_menu_item,
 699                                              gtk_action_get_always_show_image (action));
 700 }
 701
 702
 703 /**
 704  * gtk_image_menu_item_new:
 705  * @returns: a new #GtkImageMenuItem.
 706  *
 707  * Creates a new #GtkImageMenuItem with an empty label.
 708  **/
 709 GtkWidget*
 710 gtk_image_menu_item_new (void)
 711 {
 712   return g_object_new (GTK_TYPE_IMAGE_MENU_ITEM, NULL);
 713 }
 714
 715 /**
 716  * gtk_image_menu_item_new_with_label:
 717  * @label: the text of the menu item.
 718  * @returns: a new #GtkImageMenuItem.
 719  *
 720  * Creates a new #GtkImageMenuItem containing a label.
 721  **/
 722 GtkWidget*
 723 gtk_image_menu_item_new_with_label (const gchar *label)
 724 {
 725   return g_object_new (GTK_TYPE_IMAGE_MENU_ITEM,
 726                        "label", label,
 727                        NULL);
 728 }
 729
 730
 731 /**
 732  * gtk_image_menu_item_new_with_mnemonic:
 733  * @label: the text of the menu item, with an underscore in front of the
 734  *         mnemonic character
 735  * @returns: a new #GtkImageMenuItem
 736  *
 737  * Creates a new #GtkImageMenuItem containing a label. The label
 738  * will be created using gtk_label_new_with_mnemonic(), so underscores
 739  * in @label indicate the mnemonic for the menu item.
 740  **/
 741 GtkWidget*
 742 gtk_image_menu_item_new_with_mnemonic (const gchar *label)
 743 {
 744   return g_object_new (GTK_TYPE_IMAGE_MENU_ITEM,
 745                        "use-underline", TRUE,
 746                        "label", label,
 747                        NULL);
 748 }
 749
 750 /**
 751  * gtk_image_menu_item_new_from_stock:
 752  * @stock_id: the name of the stock item.
 753  * @accel_group: (allow-none): the #GtkAccelGroup to add the menu items
 754  *   accelerator to, or %NULL.
 755  * @returns: a new #GtkImageMenuItem.
 756  *
 757  * Creates a new #GtkImageMenuItem containing the image and text from a
 758  * stock item. Some stock ids have preprocessor macros like #GTK_STOCK_OK
 759  * and #GTK_STOCK_APPLY.
 760  *
 761  * If you want this menu item to have changeable accelerators, then pass in
 762  * %NULL for accel_group. Next call gtk_menu_item_set_accel_path() with an
 763  * appropriate path for the menu item, use gtk_stock_lookup() to look up the
 764  * standard accelerator for the stock item, and if one is found, call
 765  * gtk_accel_map_add_entry() to register it.
 766  **/
 767 GtkWidget*
 768 gtk_image_menu_item_new_from_stock (const gchar      *stock_id,
 769                                     GtkAccelGroup    *accel_group)
 770 {
 771   return g_object_new (GTK_TYPE_IMAGE_MENU_ITEM,
 772                        "label", stock_id,
 773                        "use-stock", TRUE,
 774                        "accel-group", accel_group,
 775                        NULL);
 776 }
 777
 778 /**
 779  * gtk_image_menu_item_set_use_stock:
 780  * @image_menu_item: a #GtkImageMenuItem
 781  * @use_stock: %TRUE if the menuitem should use a stock item
 782  *
 783  * If %TRUE, the label set in the menuitem is used as a
 784  * stock id to select the stock item for the item.
 785  *
 786  * Since: 2.16
 787  */
 788 void
 789 gtk_image_menu_item_set_use_stock (GtkImageMenuItem *image_menu_item,
 790                                    gboolean          use_stock)
 791 {
 792   GtkImageMenuItemPrivate *priv;
 793
 794   g_return_if_fail (GTK_IS_IMAGE_MENU_ITEM (image_menu_item));
 795
 796   priv = image_menu_item->priv;
 797
 798   if (priv->use_stock != use_stock)
 799     {
 800       priv->use_stock = use_stock;
 801
 802       gtk_image_menu_item_recalculate (image_menu_item);
 803
 804       g_object_notify (G_OBJECT (image_menu_item), "use-stock");
 805     }
 806 }
 807
 808 /**
 809  * gtk_image_menu_item_get_use_stock:
 810  * @image_menu_item: a #GtkImageMenuItem
 811  *
 812  * Checks whether the label set in the menuitem is used as a
 813  * stock id to select the stock item for the item.
 814  *
 815  * Returns: %TRUE if the label set in the menuitem is used as a
 816  *     stock id to select the stock item for the item
 817  *
 818  * Since: 2.16
 819  */
 820 gboolean
 821 gtk_image_menu_item_get_use_stock (GtkImageMenuItem *image_menu_item)
 822 {
 823   g_return_val_if_fail (GTK_IS_IMAGE_MENU_ITEM (image_menu_item), FALSE);
 824
 825   return image_menu_item->priv->use_stock;
 826 }
 827
 828 /**
 829  * gtk_image_menu_item_set_always_show_image:
 830  * @image_menu_item: a #GtkImageMenuItem
 831  * @always_show: %TRUE if the menuitem should always show the image
 832  *
 833  * If %TRUE, the menu item will ignore the #GtkSettings:gtk-menu-images
 834  * setting and always show the image, if available.
 835  *
 836  * Use this property if the menuitem would be useless or hard to use
 837  * without the image.
 838  *
 839  * Since: 2.16
 840  */
 841 void
 842 gtk_image_menu_item_set_always_show_image (GtkImageMenuItem *image_menu_item,
 843                                            gboolean          always_show)
 844 {
 845   GtkImageMenuItemPrivate *priv;
 846
 847   g_return_if_fail (GTK_IS_IMAGE_MENU_ITEM (image_menu_item));
 848
 849   priv = image_menu_item->priv;
 850
 851   if (priv->always_show_image != always_show)
 852     {
 853       priv->always_show_image = always_show;
 854
 855       if (priv->image)
 856         {
 857           if (show_image (image_menu_item))
 858             gtk_widget_show (priv->image);
 859           else
 860             gtk_widget_hide (priv->image);
 861         }
 862
 863       g_object_notify (G_OBJECT (image_menu_item), "always-show-image");
 864     }
 865 }
 866
 867 /**
 868  * gtk_image_menu_item_get_always_show_image:
 869  * @image_menu_item: a #GtkImageMenuItem
 870  *
 871  * Returns whether the menu item will ignore the #GtkSettings:gtk-menu-images
 872  * setting and always show the image, if available.
 873  *
 874  * Returns: %TRUE if the menu item will always show the image
 875  *
 876  * Since: 2.16
 877  */
 878 gboolean
 879 gtk_image_menu_item_get_always_show_image (GtkImageMenuItem *image_menu_item)
 880 {
 881   g_return_val_if_fail (GTK_IS_IMAGE_MENU_ITEM (image_menu_item), FALSE);
 882
 883   return image_menu_item->priv->always_show_image;
 884 }
 885
 886
 887 /**
 888  * gtk_image_menu_item_set_accel_group:
 889  * @image_menu_item: a #GtkImageMenuItem
 890  * @accel_group: the #GtkAccelGroup
 891  *
 892  * Specifies an @accel_group to add the menu items accelerator to
 893  * (this only applies to stock items so a stock item must already
 894  * be set, make sure to call gtk_image_menu_item_set_use_stock()
 895  * and gtk_menu_item_set_label() with a valid stock item first).
 896  *
 897  * If you want this menu item to have changeable accelerators then
 898  * you shouldnt need this (see gtk_image_menu_item_new_from_stock()).
 899  *
 900  * Since: 2.16
 901  */
 902 void
 903 gtk_image_menu_item_set_accel_group (GtkImageMenuItem *image_menu_item,
 904                                      GtkAccelGroup    *accel_group)
 905 {
 906   GtkImageMenuItemPrivate    *priv;
 907   GtkStockItem             stock_item;
 908
 909   /* Silent return for the constructor */
 910   if (!accel_group)
 911     return;
 912
 913   g_return_if_fail (GTK_IS_IMAGE_MENU_ITEM (image_menu_item));
 914   g_return_if_fail (GTK_IS_ACCEL_GROUP (accel_group));
 915
 916   priv = image_menu_item->priv;
 917
 918   if (priv->use_stock && priv->label && gtk_stock_lookup (priv->label, &stock_item))
 919     if (stock_item.keyval)
 920       {
 921         gtk_widget_add_accelerator (GTK_WIDGET (image_menu_item),
 922                                     "activate",
 923                                     accel_group,
 924                                     stock_item.keyval,
 925                                     stock_item.modifier,
 926                                     GTK_ACCEL_VISIBLE);
 927
 928         g_object_notify (G_OBJECT (image_menu_item), "accel-group");
 929       }
 930 }
 931
 932 /**
 933  * gtk_image_menu_item_set_image:
 934  * @image_menu_item: a #GtkImageMenuItem.
 935  * @image: (allow-none): a widget to set as the image for the menu item.
 936  *
 937  * Sets the image of @image_menu_item to the given widget.
 938  * Note that it depends on the show-menu-images setting whether
 939  * the image will be displayed or not.
 940  **/
 941 void
 942 gtk_image_menu_item_set_image (GtkImageMenuItem *image_menu_item,
 943                                GtkWidget        *image)
 944 {
 945   GtkImageMenuItemPrivate *priv;
 946
 947   g_return_if_fail (GTK_IS_IMAGE_MENU_ITEM (image_menu_item));
 948
 949   priv = image_menu_item->priv;
 950
 951   if (image == priv->image)
 952     return;
 953
 954   if (priv->image)
 955     gtk_container_remove (GTK_CONTAINER (image_menu_item),
 956                           priv->image);
 957
 958   priv->image = image;
 959
 960   if (image == NULL)
 961     return;
 962
 963   gtk_widget_set_parent (image, GTK_WIDGET (image_menu_item));
 964   g_object_set (image,
 965                 "visible", show_image (image_menu_item),
 966                 "no-show-all", TRUE,
 967                 NULL);
 968
 969   g_object_notify (G_OBJECT (image_menu_item), "image");
 970 }
 971
 972 /**
 973  * gtk_image_menu_item_get_image:
 974  * @image_menu_item: a #GtkImageMenuItem
 975  *
 976  * Gets the widget that is currently set as the image of @image_menu_item.
 977  * See gtk_image_menu_item_set_image().
 978  *
 979  * Return value: (transfer none): the widget set as image of @image_menu_item
 980  **/
 981 GtkWidget*
 982 gtk_image_menu_item_get_image (GtkImageMenuItem *image_menu_item)
 983 {
 984   g_return_val_if_fail (GTK_IS_IMAGE_MENU_ITEM (image_menu_item), NULL);
 985
 986   return image_menu_item->priv->image;
 987 }
 988
 989 static void
 990 gtk_image_menu_item_remove (GtkContainer *container,
 991                             GtkWidget    *child)
 992 {
 993   GtkImageMenuItem *image_menu_item = GTK_IMAGE_MENU_ITEM (container);
 994   GtkImageMenuItemPrivate *priv = image_menu_item->priv;
 995
 996   if (child == priv->image)
 997     {
 998       gboolean widget_was_visible;
 999
1000       widget_was_visible = gtk_widget_get_visible (child);
1001
1002       gtk_widget_unparent (child);
1003       priv->image = NULL;
1004
1005       if (widget_was_visible &&
1006           gtk_widget_get_visible (GTK_WIDGET (container)))
1007         gtk_widget_queue_resize (GTK_WIDGET (container));
1008
1009       g_object_notify (G_OBJECT (image_menu_item), "image");
1010     }
1011   else
1012     {
1013       GTK_CONTAINER_CLASS (gtk_image_menu_item_parent_class)->remove (container, child);
1014     }
1015 }
1016
1017 static void
1018 show_image_change_notify (GtkImageMenuItem *image_menu_item)
1019 {
1020   GtkImageMenuItemPrivate *priv = image_menu_item->priv;
1021
1022   if (priv->image)
1023     {
1024       if (show_image (image_menu_item))
1025         gtk_widget_show (priv->image);
1026       else
1027         gtk_widget_hide (priv->image);
1028     }
1029 }
1030
1031 static void
1032 traverse_container (GtkWidget *widget,
1033                     gpointer   data)
1034 {
1035   if (GTK_IS_IMAGE_MENU_ITEM (widget))
1036     show_image_change_notify (GTK_IMAGE_MENU_ITEM (widget));
1037   else if (GTK_IS_CONTAINER (widget))
1038     gtk_container_forall (GTK_CONTAINER (widget), traverse_container, NULL);
1039 }
1040
1041 static void
1042 gtk_image_menu_item_setting_changed (GtkSettings *settings)
1043 {
1044   GList *list, *l;
1045
1046   list = gtk_window_list_toplevels ();
1047
1048   for (l = list; l; l = l->next)
1049     gtk_container_forall (GTK_CONTAINER (l->data),
1050                           traverse_container, NULL);
1051
1052   g_list_free (list);
1053 }
1054
1055 static void
1056 gtk_image_menu_item_screen_changed (GtkWidget *widget,
1057                                     GdkScreen *previous_screen)
1058 {
1059   GtkSettings *settings;
1060   guint show_image_connection;
1061
1062   if (!gtk_widget_has_screen (widget))
1063     return;
1064
1065   settings = gtk_widget_get_settings (widget);
1066
1067   show_image_connection =
1068     GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (settings),
1069                                          "gtk-image-menu-item-connection"));
1070
1071   if (show_image_connection)
1072     return;
1073
1074   show_image_connection =
1075     g_signal_connect (settings, "notify::gtk-menu-images",
1076                       G_CALLBACK (gtk_image_menu_item_setting_changed), NULL);
1077   g_object_set_data (G_OBJECT (settings),
1078                      I_("gtk-image-menu-item-connection"),
1079                      GUINT_TO_POINTER (show_image_connection));
1080
1081   show_image_change_notify (GTK_IMAGE_MENU_ITEM (widget));
1082 }