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

   1 /* GTK - The GIMP Toolkit
   2  * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
   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 <math.h>
  30 #include <string.h>
  31
  32 #include "gtkcontainer.h"
  33 #include "gtkiconhelperprivate.h"
  34 #include "gtkimageprivate.h"
  35 #include "gtkiconfactory.h"
  36 #include "gtkstock.h"
  37 #include "gtkicontheme.h"
  38 #include "gtksizerequest.h"
  39 #include "gtkintl.h"
  40 #include "gtkprivate.h"
  41 #include "gtktypebuiltins.h"
  42
  43 #include "a11y/gtkimageaccessible.h"
  44
  45 /**
  46  * SECTION:gtkimage
  47  * @Short_description: A widget displaying an image
  48  * @Title: GtkImage
  49  * @See_also:#GdkPixbuf
  50  *
  51  * The #GtkImage widget displays an image. Various kinds of object
  52  * can be displayed as an image; most typically, you would load a
  53  * #GdkPixbuf ("pixel buffer") from a file, and then display that.
  54  * There's a convenience function to do this, gtk_image_new_from_file(),
  55  * used as follows:
  56  * <informalexample><programlisting>
  57  *   GtkWidget *image;
  58  *   image = gtk_image_new_from_file ("myfile.png");
  59  * </programlisting></informalexample>
  60  * If the file isn't loaded successfully, the image will contain a
  61  * "broken image" icon similar to that used in many web browsers.
  62  * If you want to handle errors in loading the file yourself,
  63  * for example by displaying an error message, then load the image with
  64  * gdk_pixbuf_new_from_file(), then create the #GtkImage with
  65  * gtk_image_new_from_pixbuf().
  66  *
  67  * The image file may contain an animation, if so the #GtkImage will
  68  * display an animation (#GdkPixbufAnimation) instead of a static image.
  69  *
  70  * #GtkImage is a subclass of #GtkMisc, which implies that you can
  71  * align it (center, left, right) and add padding to it, using
  72  * #GtkMisc methods.
  73  *
  74  * #GtkImage is a "no window" widget (has no #GdkWindow of its own),
  75  * so by default does not receive events. If you want to receive events
  76  * on the image, such as button clicks, place the image inside a
  77  * #GtkEventBox, then connect to the event signals on the event box.
  78  * <example>
  79  * <title>Handling button press events on a
  80  * <structname>GtkImage</structname>.</title>
  81  * <programlisting>
  82  *   static gboolean
  83  *   button_press_callback (GtkWidget      *event_box,
  84  *                          GdkEventButton *event,
  85  *                          gpointer        data)
  86  *   {
  87  *     g_print ("Event box clicked at coordinates &percnt;f,&percnt;f\n",
  88  *              event->x, event->y);
  89  *
  90  *     /<!---->* Returning TRUE means we handled the event, so the signal
  91  *      * emission should be stopped (don't call any further
  92  *      * callbacks that may be connected). Return FALSE
  93  *      * to continue invoking callbacks.
  94  *      *<!---->/
  95  *     return TRUE;
  96  *   }
  97  *
  98  *   static GtkWidget*
  99  *   create_image (void)
 100  *   {
 101  *     GtkWidget *image;
 102  *     GtkWidget *event_box;
 103  *
 104  *     image = gtk_image_new_from_file ("myfile.png");
 105  *
 106  *     event_box = gtk_event_box_new (<!-- -->);
 107  *
 108  *     gtk_container_add (GTK_CONTAINER (event_box), image);
 109  *
 110  *     g_signal_connect (G_OBJECT (event_box),
 111  *                       "button_press_event",
 112  *                       G_CALLBACK (button_press_callback),
 113  *                       image);
 114  *
 115  *     return image;
 116  *   }
 117  * </programlisting>
 118  * </example>
 119  *
 120  * When handling events on the event box, keep in mind that coordinates
 121  * in the image may be different from event box coordinates due to
 122  * the alignment and padding settings on the image (see #GtkMisc).
 123  * The simplest way to solve this is to set the alignment to 0.0
 124  * (left/top), and set the padding to zero. Then the origin of
 125  * the image will be the same as the origin of the event box.
 126  *
 127  * Sometimes an application will want to avoid depending on external data
 128  * files, such as image files. GTK+ comes with a program to avoid this,
 129  * called <application>gdk-pixbuf-csource</application>. This program
 130  * allows you to convert an image into a C variable declaration, which
 131  * can then be loaded into a #GdkPixbuf using
 132  * gdk_pixbuf_new_from_inline().
 133  */
 134
 135
 136 struct _GtkImagePrivate
 137 {
 138   GtkIconHelper *icon_helper;
 139
 140   gint animation_timeout;
 141   GdkPixbufAnimationIter *animation_iter;
 142
 143   gchar                *filename;       /* Only used with GTK_IMAGE_ANIMATION, GTK_IMAGE_PIXBUF */
 144 };
 145
 146
 147 #define DEFAULT_ICON_SIZE GTK_ICON_SIZE_BUTTON
 148 static gint gtk_image_draw                 (GtkWidget    *widget,
 149                                             cairo_t      *cr);
 150 static void gtk_image_unmap                (GtkWidget    *widget);
 151 static void gtk_image_unrealize            (GtkWidget    *widget);
 152 static void gtk_image_get_preferred_width  (GtkWidget    *widget,
 153                                             gint         *minimum,
 154                                             gint         *natural);
 155 static void gtk_image_get_preferred_height (GtkWidget    *widget,
 156                                             gint         *minimum,
 157                                             gint         *natural);
 158
 159 static void gtk_image_style_updated        (GtkWidget    *widget);
 160 static void gtk_image_screen_changed       (GtkWidget    *widget,
 161                                             GdkScreen    *prev_screen);
 162 static void gtk_image_destroy              (GtkWidget    *widget);
 163 static void gtk_image_reset                (GtkImage     *image);
 164
 165 static void gtk_image_set_property         (GObject      *object,
 166                                             guint         prop_id,
 167                                             const GValue *value,
 168                                             GParamSpec   *pspec);
 169 static void gtk_image_get_property         (GObject      *object,
 170                                             guint         prop_id,
 171                                             GValue       *value,
 172                                             GParamSpec   *pspec);
 173
 174 static void icon_theme_changed             (GtkImage     *image);
 175
 176 enum
 177 {
 178   PROP_0,
 179   PROP_PIXBUF,
 180   PROP_FILE,
 181   PROP_STOCK,
 182   PROP_ICON_SET,
 183   PROP_ICON_SIZE,
 184   PROP_PIXEL_SIZE,
 185   PROP_PIXBUF_ANIMATION,
 186   PROP_ICON_NAME,
 187   PROP_STORAGE_TYPE,
 188   PROP_GICON,
 189   PROP_USE_FALLBACK
 190 };
 191
 192 G_DEFINE_TYPE (GtkImage, gtk_image, GTK_TYPE_MISC)
 193
 194 static void
 195 gtk_image_class_init (GtkImageClass *class)
 196 {
 197   GObjectClass *gobject_class;
 198   GtkWidgetClass *widget_class;
 199
 200   gobject_class = G_OBJECT_CLASS (class);
 201
 202   gobject_class->set_property = gtk_image_set_property;
 203   gobject_class->get_property = gtk_image_get_property;
 204
 205   widget_class = GTK_WIDGET_CLASS (class);
 206   widget_class->draw = gtk_image_draw;
 207   widget_class->destroy = gtk_image_destroy;
 208   widget_class->get_preferred_width = gtk_image_get_preferred_width;
 209   widget_class->get_preferred_height = gtk_image_get_preferred_height;
 210   widget_class->unmap = gtk_image_unmap;
 211   widget_class->unrealize = gtk_image_unrealize;
 212   widget_class->style_updated = gtk_image_style_updated;
 213   widget_class->screen_changed = gtk_image_screen_changed;
 214
 215   g_object_class_install_property (gobject_class,
 216                                    PROP_PIXBUF,
 217                                    g_param_spec_object ("pixbuf",
 218                                                         P_("Pixbuf"),
 219                                                         P_("A GdkPixbuf to display"),
 220                                                         GDK_TYPE_PIXBUF,
 221                                                         GTK_PARAM_READWRITE));
 222
 223   g_object_class_install_property (gobject_class,
 224                                    PROP_FILE,
 225                                    g_param_spec_string ("file",
 226                                                         P_("Filename"),
 227                                                         P_("Filename to load and display"),
 228                                                         NULL,
 229                                                         GTK_PARAM_READWRITE));
 230
 231
 232   g_object_class_install_property (gobject_class,
 233                                    PROP_STOCK,
 234                                    g_param_spec_string ("stock",
 235                                                         P_("Stock ID"),
 236                                                         P_("Stock ID for a stock image to display"),
 237                                                         NULL,
 238                                                         GTK_PARAM_READWRITE));
 239
 240   g_object_class_install_property (gobject_class,
 241                                    PROP_ICON_SET,
 242                                    g_param_spec_boxed ("icon-set",
 243                                                        P_("Icon set"),
 244                                                        P_("Icon set to display"),
 245                                                        GTK_TYPE_ICON_SET,
 246                                                        GTK_PARAM_READWRITE));
 247
 248   g_object_class_install_property (gobject_class,
 249                                    PROP_ICON_SIZE,
 250                                    g_param_spec_int ("icon-size",
 251                                                      P_("Icon size"),
 252                                                      P_("Symbolic size to use for stock icon, icon set or named icon"),
 253                                                      0, G_MAXINT,
 254                                                      DEFAULT_ICON_SIZE,
 255                                                      GTK_PARAM_READWRITE));
 256   /**
 257    * GtkImage:pixel-size:
 258    *
 259    * The "pixel-size" property can be used to specify a fixed size
 260    * overriding the #GtkImage:icon-size property for images of type
 261    * %GTK_IMAGE_ICON_NAME.
 262    *
 263    * Since: 2.6
 264    */
 265   g_object_class_install_property (gobject_class,
 266                                    PROP_PIXEL_SIZE,
 267                                    g_param_spec_int ("pixel-size",
 268                                                      P_("Pixel size"),
 269                                                      P_("Pixel size to use for named icon"),
 270                                                      -1, G_MAXINT,
 271                                                      -1,
 272                                                      GTK_PARAM_READWRITE));
 273
 274   g_object_class_install_property (gobject_class,
 275                                    PROP_PIXBUF_ANIMATION,
 276                                    g_param_spec_object ("pixbuf-animation",
 277                                                         P_("Animation"),
 278                                                         P_("GdkPixbufAnimation to display"),
 279                                                         GDK_TYPE_PIXBUF_ANIMATION,
 280                                                         GTK_PARAM_READWRITE));
 281
 282   /**
 283    * GtkImage:icon-name:
 284    *
 285    * The name of the icon in the icon theme. If the icon theme is
 286    * changed, the image will be updated automatically.
 287    *
 288    * Since: 2.6
 289    */
 290   g_object_class_install_property (gobject_class,
 291                                    PROP_ICON_NAME,
 292                                    g_param_spec_string ("icon-name",
 293                                                         P_("Icon Name"),
 294                                                         P_("The name of the icon from the icon theme"),
 295                                                         NULL,
 296                                                         GTK_PARAM_READWRITE));
 297
 298   /**
 299    * GtkImage:gicon:
 300    *
 301    * The GIcon displayed in the GtkImage. For themed icons,
 302    * If the icon theme is changed, the image will be updated
 303    * automatically.
 304    *
 305    * Since: 2.14
 306    */
 307   g_object_class_install_property (gobject_class,
 308                                    PROP_GICON,
 309                                    g_param_spec_object ("gicon",
 310                                                         P_("Icon"),
 311                                                         P_("The GIcon being displayed"),
 312                                                         G_TYPE_ICON,
 313                                                         GTK_PARAM_READWRITE));
 314
 315   g_object_class_install_property (gobject_class,
 316                                    PROP_STORAGE_TYPE,
 317                                    g_param_spec_enum ("storage-type",
 318                                                       P_("Storage type"),
 319                                                       P_("The representation being used for image data"),
 320                                                       GTK_TYPE_IMAGE_TYPE,
 321                                                       GTK_IMAGE_EMPTY,
 322                                                       GTK_PARAM_READABLE));
 323
 324   /**
 325    * GtkImage:use-fallback:
 326    *
 327    * Whether the icon displayed in the GtkImage will use
 328    * standard icon names fallback. The value of this property
 329    * is only relevant for images of type %GTK_IMAGE_ICON_NAME
 330    * and %GTK_IMAGE_GICON.
 331    *
 332    * Since: 3.0
 333    */
 334   g_object_class_install_property (gobject_class,
 335                                    PROP_USE_FALLBACK,
 336                                    g_param_spec_boolean ("use-fallback",
 337                                                          P_("Use Fallback"),
 338                                                          P_("Whether to use icon names fallback"),
 339                                                          FALSE,
 340                                                          GTK_PARAM_READWRITE));
 341
 342   g_type_class_add_private (class, sizeof (GtkImagePrivate));
 343
 344   gtk_widget_class_set_accessible_type (widget_class, GTK_TYPE_IMAGE_ACCESSIBLE);
 345 }
 346
 347 static void
 348 gtk_image_init (GtkImage *image)
 349 {
 350   GtkImagePrivate *priv;
 351
 352   image->priv = G_TYPE_INSTANCE_GET_PRIVATE (image,
 353                                              GTK_TYPE_IMAGE,
 354                                              GtkImagePrivate);
 355   priv = image->priv;
 356
 357   gtk_widget_set_has_window (GTK_WIDGET (image), FALSE);
 358   priv->icon_helper = _gtk_icon_helper_new ();
 359
 360   priv->filename = NULL;
 361 }
 362
 363 static void
 364 gtk_image_destroy (GtkWidget *widget)
 365 {
 366   GtkImage *image = GTK_IMAGE (widget);
 367
 368   g_clear_object (&image->priv->icon_helper);
 369
 370   GTK_WIDGET_CLASS (gtk_image_parent_class)->destroy (widget);
 371 }
 372
 373 static void
 374 gtk_image_set_property (GObject      *object,
 375                         guint         prop_id,
 376                         const GValue *value,
 377                         GParamSpec   *pspec)
 378 {
 379   GtkImage *image = GTK_IMAGE (object);
 380   GtkImagePrivate *priv = image->priv;
 381   GtkIconSize icon_size = _gtk_icon_helper_get_icon_size (priv->icon_helper);
 382
 383   if (icon_size == GTK_ICON_SIZE_INVALID)
 384     icon_size = DEFAULT_ICON_SIZE;
 385
 386   switch (prop_id)
 387     {
 388     case PROP_PIXBUF:
 389       gtk_image_set_from_pixbuf (image,
 390                                  g_value_get_object (value));
 391       break;
 392     case PROP_FILE:
 393       gtk_image_set_from_file (image, g_value_get_string (value));
 394       break;
 395     case PROP_STOCK:
 396       gtk_image_set_from_stock (image, g_value_get_string (value),
 397                                 icon_size);
 398       break;
 399     case PROP_ICON_SET:
 400       gtk_image_set_from_icon_set (image, g_value_get_boxed (value),
 401                                    icon_size);
 402       break;
 403     case PROP_ICON_SIZE:
 404       _gtk_icon_helper_set_icon_size (priv->icon_helper, g_value_get_int (value));
 405       break;
 406     case PROP_PIXEL_SIZE:
 407       gtk_image_set_pixel_size (image, g_value_get_int (value));
 408       break;
 409     case PROP_PIXBUF_ANIMATION:
 410       gtk_image_set_from_animation (image,
 411                                     g_value_get_object (value));
 412       break;
 413     case PROP_ICON_NAME:
 414       gtk_image_set_from_icon_name (image, g_value_get_string (value),
 415                                     icon_size);
 416       break;
 417     case PROP_GICON:
 418       gtk_image_set_from_gicon (image, g_value_get_object (value),
 419                                 icon_size);
 420       break;
 421
 422     case PROP_USE_FALLBACK:
 423       _gtk_icon_helper_set_use_fallback (priv->icon_helper, g_value_get_boolean (value));
 424       break;
 425
 426     default:
 427       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 428       break;
 429     }
 430 }
 431
 432 static void
 433 gtk_image_get_property (GObject     *object,
 434                         guint        prop_id,
 435                         GValue      *value,
 436                         GParamSpec  *pspec)
 437 {
 438   GtkImage *image = GTK_IMAGE (object);
 439   GtkImagePrivate *priv = image->priv;
 440
 441   switch (prop_id)
 442     {
 443     case PROP_PIXBUF:
 444       g_value_set_object (value, _gtk_icon_helper_peek_pixbuf (priv->icon_helper));
 445       break;
 446     case PROP_FILE:
 447       g_value_set_string (value, priv->filename);
 448       break;
 449     case PROP_STOCK:
 450       g_value_set_string (value, _gtk_icon_helper_get_icon_name (priv->icon_helper));
 451       break;
 452     case PROP_ICON_SET:
 453       g_value_set_boxed (value, _gtk_icon_helper_peek_icon_set (priv->icon_helper));
 454       break;
 455     case PROP_ICON_SIZE:
 456       g_value_set_int (value, _gtk_icon_helper_get_icon_size (priv->icon_helper));
 457       break;
 458     case PROP_PIXEL_SIZE:
 459       g_value_set_int (value, _gtk_icon_helper_get_pixel_size (priv->icon_helper));
 460       break;
 461     case PROP_PIXBUF_ANIMATION:
 462       g_value_set_object (value, _gtk_icon_helper_peek_animation (priv->icon_helper));
 463       break;
 464     case PROP_ICON_NAME:
 465       g_value_set_string (value, _gtk_icon_helper_get_icon_name (priv->icon_helper));
 466       break;
 467     case PROP_GICON:
 468       g_value_set_object (value, _gtk_icon_helper_peek_gicon (priv->icon_helper));
 469       break;
 470     case PROP_USE_FALLBACK:
 471       g_value_set_boolean (value, _gtk_icon_helper_get_use_fallback (priv->icon_helper));
 472       break;
 473     default:
 474       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 475       break;
 476     }
 477 }
 478
 479
 480 /**
 481  * gtk_image_new_from_file:
 482  * @filename: (type filename): a filename
 483  *
 484  * Creates a new #GtkImage displaying the file @filename. If the file
 485  * isn't found or can't be loaded, the resulting #GtkImage will
 486  * display a "broken image" icon. This function never returns %NULL,
 487  * it always returns a valid #GtkImage widget.
 488  *
 489  * If the file contains an animation, the image will contain an
 490  * animation.
 491  *
 492  * If you need to detect failures to load the file, use
 493  * gdk_pixbuf_new_from_file() to load the file yourself, then create
 494  * the #GtkImage from the pixbuf. (Or for animations, use
 495  * gdk_pixbuf_animation_new_from_file()).
 496  *
 497  * The storage type (gtk_image_get_storage_type()) of the returned
 498  * image is not defined, it will be whatever is appropriate for
 499  * displaying the file.
 500  *
 501  * Return value: a new #GtkImage
 502  **/
 503 GtkWidget*
 504 gtk_image_new_from_file   (const gchar *filename)
 505 {
 506   GtkImage *image;
 507
 508   image = g_object_new (GTK_TYPE_IMAGE, NULL);
 509
 510   gtk_image_set_from_file (image, filename);
 511
 512   return GTK_WIDGET (image);
 513 }
 514
 515 /**
 516  * gtk_image_new_from_pixbuf:
 517  * @pixbuf: (allow-none): a #GdkPixbuf, or %NULL
 518  *
 519  * Creates a new #GtkImage displaying @pixbuf.
 520  * The #GtkImage does not assume a reference to the
 521  * pixbuf; you still need to unref it if you own references.
 522  * #GtkImage will add its own reference rather than adopting yours.
 523  *
 524  * Note that this function just creates an #GtkImage from the pixbuf. The
 525  * #GtkImage created will not react to state changes. Should you want that,
 526  * you should use gtk_image_new_from_icon_set().
 527  *
 528  * Return value: a new #GtkImage
 529  **/
 530 GtkWidget*
 531 gtk_image_new_from_pixbuf (GdkPixbuf *pixbuf)
 532 {
 533   GtkImage *image;
 534
 535   image = g_object_new (GTK_TYPE_IMAGE, NULL);
 536
 537   gtk_image_set_from_pixbuf (image, pixbuf);
 538
 539   return GTK_WIDGET (image);
 540 }
 541
 542 /**
 543  * gtk_image_new_from_stock:
 544  * @stock_id: a stock icon name
 545  * @size: (type int): a stock icon size
 546  *
 547  * Creates a #GtkImage displaying a stock icon. Sample stock icon
 548  * names are #GTK_STOCK_OPEN, #GTK_STOCK_QUIT. Sample stock sizes
 549  * are #GTK_ICON_SIZE_MENU, #GTK_ICON_SIZE_SMALL_TOOLBAR. If the stock
 550  * icon name isn't known, the image will be empty.
 551  * You can register your own stock icon names, see
 552  * gtk_icon_factory_add_default() and gtk_icon_factory_add().
 553  *
 554  * Return value: a new #GtkImage displaying the stock icon
 555  **/
 556 GtkWidget*
 557 gtk_image_new_from_stock (const gchar    *stock_id,
 558                           GtkIconSize     size)
 559 {
 560   GtkImage *image;
 561
 562   image = g_object_new (GTK_TYPE_IMAGE, NULL);
 563
 564   gtk_image_set_from_stock (image, stock_id, size);
 565
 566   return GTK_WIDGET (image);
 567 }
 568
 569 /**
 570  * gtk_image_new_from_icon_set:
 571  * @icon_set: a #GtkIconSet
 572  * @size: (type int): a stock icon size
 573  *
 574  * Creates a #GtkImage displaying an icon set. Sample stock sizes are
 575  * #GTK_ICON_SIZE_MENU, #GTK_ICON_SIZE_SMALL_TOOLBAR. Instead of using
 576  * this function, usually it's better to create a #GtkIconFactory, put
 577  * your icon sets in the icon factory, add the icon factory to the
 578  * list of default factories with gtk_icon_factory_add_default(), and
 579  * then use gtk_image_new_from_stock(). This will allow themes to
 580  * override the icon you ship with your application.
 581  *
 582  * The #GtkImage does not assume a reference to the
 583  * icon set; you still need to unref it if you own references.
 584  * #GtkImage will add its own reference rather than adopting yours.
 585  *
 586  * Return value: a new #GtkImage
 587  **/
 588 GtkWidget*
 589 gtk_image_new_from_icon_set (GtkIconSet     *icon_set,
 590                              GtkIconSize     size)
 591 {
 592   GtkImage *image;
 593
 594   image = g_object_new (GTK_TYPE_IMAGE, NULL);
 595
 596   gtk_image_set_from_icon_set (image, icon_set, size);
 597
 598   return GTK_WIDGET (image);
 599 }
 600
 601 /**
 602  * gtk_image_new_from_animation:
 603  * @animation: an animation
 604  *
 605  * Creates a #GtkImage displaying the given animation.
 606  * The #GtkImage does not assume a reference to the
 607  * animation; you still need to unref it if you own references.
 608  * #GtkImage will add its own reference rather than adopting yours.
 609  *
 610  * Note that the animation frames are shown using a timeout with
 611  * #G_PRIORITY_DEFAULT. When using animations to indicate busyness,
 612  * keep in mind that the animation will only be shown if the main loop
 613  * is not busy with something that has a higher priority.
 614  *
 615  * Return value: a new #GtkImage widget
 616  **/
 617 GtkWidget*
 618 gtk_image_new_from_animation (GdkPixbufAnimation *animation)
 619 {
 620   GtkImage *image;
 621
 622   g_return_val_if_fail (GDK_IS_PIXBUF_ANIMATION (animation), NULL);
 623
 624   image = g_object_new (GTK_TYPE_IMAGE, NULL);
 625
 626   gtk_image_set_from_animation (image, animation);
 627
 628   return GTK_WIDGET (image);
 629 }
 630
 631 /**
 632  * gtk_image_new_from_icon_name:
 633  * @icon_name: an icon name
 634  * @size: (type int): a stock icon size
 635  *
 636  * Creates a #GtkImage displaying an icon from the current icon theme.
 637  * If the icon name isn't known, a "broken image" icon will be
 638  * displayed instead.  If the current icon theme is changed, the icon
 639  * will be updated appropriately.
 640  *
 641  * Return value: a new #GtkImage displaying the themed icon
 642  *
 643  * Since: 2.6
 644  **/
 645 GtkWidget*
 646 gtk_image_new_from_icon_name (const gchar    *icon_name,
 647                               GtkIconSize     size)
 648 {
 649   GtkImage *image;
 650
 651   image = g_object_new (GTK_TYPE_IMAGE, NULL);
 652
 653   gtk_image_set_from_icon_name (image, icon_name, size);
 654
 655   return GTK_WIDGET (image);
 656 }
 657
 658 /**
 659  * gtk_image_new_from_gicon:
 660  * @icon: an icon
 661  * @size: (type int): a stock icon size
 662  *
 663  * Creates a #GtkImage displaying an icon from the current icon theme.
 664  * If the icon name isn't known, a "broken image" icon will be
 665  * displayed instead.  If the current icon theme is changed, the icon
 666  * will be updated appropriately.
 667  *
 668  * Return value: a new #GtkImage displaying the themed icon
 669  *
 670  * Since: 2.14
 671  **/
 672 GtkWidget*
 673 gtk_image_new_from_gicon (GIcon *icon,
 674                           GtkIconSize     size)
 675 {
 676   GtkImage *image;
 677
 678   image = g_object_new (GTK_TYPE_IMAGE, NULL);
 679
 680   gtk_image_set_from_gicon (image, icon, size);
 681
 682   return GTK_WIDGET (image);
 683 }
 684
 685 /**
 686  * gtk_image_set_from_file:
 687  * @image: a #GtkImage
 688  * @filename: (type filename) (allow-none): a filename or %NULL
 689  *
 690  * See gtk_image_new_from_file() for details.
 691  **/
 692 void
 693 gtk_image_set_from_file   (GtkImage    *image,
 694                            const gchar *filename)
 695 {
 696   GtkImagePrivate *priv;
 697   GdkPixbufAnimation *anim;
 698
 699   g_return_if_fail (GTK_IS_IMAGE (image));
 700
 701   priv = image->priv;
 702
 703   g_object_freeze_notify (G_OBJECT (image));
 704
 705   gtk_image_clear (image);
 706
 707   if (filename == NULL)
 708     {
 709       priv->filename = NULL;
 710       g_object_thaw_notify (G_OBJECT (image));
 711       return;
 712     }
 713
 714   anim = gdk_pixbuf_animation_new_from_file (filename, NULL);
 715
 716   if (anim == NULL)
 717     {
 718       gtk_image_set_from_stock (image,
 719                                 GTK_STOCK_MISSING_IMAGE,
 720                                 DEFAULT_ICON_SIZE);
 721       g_object_thaw_notify (G_OBJECT (image));
 722       return;
 723     }
 724
 725   /* We could just unconditionally set_from_animation,
 726    * but it's nicer for memory if we toss the animation
 727    * if it's just a single pixbuf
 728    */
 729
 730   if (gdk_pixbuf_animation_is_static_image (anim))
 731     gtk_image_set_from_pixbuf (image,
 732                                gdk_pixbuf_animation_get_static_image (anim));
 733   else
 734     gtk_image_set_from_animation (image, anim);
 735
 736   g_object_unref (anim);
 737
 738   priv->filename = g_strdup (filename);
 739
 740   g_object_thaw_notify (G_OBJECT (image));
 741 }
 742
 743 /**
 744  * gtk_image_set_from_pixbuf:
 745  * @image: a #GtkImage
 746  * @pixbuf: (allow-none): a #GdkPixbuf or %NULL
 747  *
 748  * See gtk_image_new_from_pixbuf() for details.
 749  **/
 750 void
 751 gtk_image_set_from_pixbuf (GtkImage  *image,
 752                            GdkPixbuf *pixbuf)
 753 {
 754   GtkImagePrivate *priv;
 755
 756   g_return_if_fail (GTK_IS_IMAGE (image));
 757   g_return_if_fail (pixbuf == NULL ||
 758                     GDK_IS_PIXBUF (pixbuf));
 759
 760   priv = image->priv;
 761
 762   g_object_freeze_notify (G_OBJECT (image));
 763
 764   gtk_image_clear (image);
 765
 766   if (pixbuf != NULL)
 767     _gtk_icon_helper_set_pixbuf (priv->icon_helper, pixbuf);
 768
 769   g_object_notify (G_OBJECT (image), "pixbuf");
 770
 771   g_object_thaw_notify (G_OBJECT (image));
 772 }
 773
 774 /**
 775  * gtk_image_set_from_stock:
 776  * @image: a #GtkImage
 777  * @stock_id: a stock icon name
 778  * @size: (type int): a stock icon size
 779  *
 780  * See gtk_image_new_from_stock() for details.
 781  **/
 782 void
 783 gtk_image_set_from_stock  (GtkImage       *image,
 784                            const gchar    *stock_id,
 785                            GtkIconSize     size)
 786 {
 787   GtkImagePrivate *priv;
 788   gchar *new_id;
 789
 790   g_return_if_fail (GTK_IS_IMAGE (image));
 791
 792   priv = image->priv;
 793
 794   g_object_freeze_notify (G_OBJECT (image));
 795
 796   new_id = g_strdup (stock_id);
 797   gtk_image_clear (image);
 798
 799   if (new_id)
 800     {
 801       _gtk_icon_helper_set_stock_id (priv->icon_helper, new_id, size);
 802       g_free (new_id);
 803     }
 804
 805   g_object_notify (G_OBJECT (image), "stock");
 806   g_object_notify (G_OBJECT (image), "icon-size");
 807
 808   g_object_thaw_notify (G_OBJECT (image));
 809 }
 810
 811 /**
 812  * gtk_image_set_from_icon_set:
 813  * @image: a #GtkImage
 814  * @icon_set: a #GtkIconSet
 815  * @size: (type int): a stock icon size
 816  *
 817  * See gtk_image_new_from_icon_set() for details.
 818  **/
 819 void
 820 gtk_image_set_from_icon_set  (GtkImage       *image,
 821                               GtkIconSet     *icon_set,
 822                               GtkIconSize     size)
 823 {
 824   GtkImagePrivate *priv;
 825
 826   g_return_if_fail (GTK_IS_IMAGE (image));
 827
 828   priv = image->priv;
 829
 830   g_object_freeze_notify (G_OBJECT (image));
 831
 832   if (icon_set)
 833     gtk_icon_set_ref (icon_set);
 834
 835   gtk_image_clear (image);
 836
 837   if (icon_set)
 838     {
 839       _gtk_icon_helper_set_icon_set (priv->icon_helper, icon_set, size);
 840       gtk_icon_set_unref (icon_set);
 841     }
 842
 843   g_object_notify (G_OBJECT (image), "icon-set");
 844   g_object_notify (G_OBJECT (image), "icon-size");
 845
 846   g_object_thaw_notify (G_OBJECT (image));
 847 }
 848
 849 /**
 850  * gtk_image_set_from_animation:
 851  * @image: a #GtkImage
 852  * @animation: the #GdkPixbufAnimation
 853  *
 854  * Causes the #GtkImage to display the given animation (or display
 855  * nothing, if you set the animation to %NULL).
 856  **/
 857 void
 858 gtk_image_set_from_animation (GtkImage           *image,
 859                               GdkPixbufAnimation *animation)
 860 {
 861   GtkImagePrivate *priv;
 862
 863   g_return_if_fail (GTK_IS_IMAGE (image));
 864   g_return_if_fail (animation == NULL ||
 865                     GDK_IS_PIXBUF_ANIMATION (animation));
 866
 867   priv = image->priv;
 868
 869   g_object_freeze_notify (G_OBJECT (image));
 870
 871   if (animation)
 872     g_object_ref (animation);
 873
 874   gtk_image_clear (image);
 875
 876   if (animation != NULL)
 877     {
 878       _gtk_icon_helper_set_animation (priv->icon_helper, animation);
 879       g_object_unref (animation);
 880     }
 881
 882   g_object_notify (G_OBJECT (image), "pixbuf-animation");
 883
 884   g_object_thaw_notify (G_OBJECT (image));
 885 }
 886
 887 /**
 888  * gtk_image_set_from_icon_name:
 889  * @image: a #GtkImage
 890  * @icon_name: an icon name
 891  * @size: (type int): an icon size
 892  *
 893  * See gtk_image_new_from_icon_name() for details.
 894  *
 895  * Since: 2.6
 896  **/
 897 void
 898 gtk_image_set_from_icon_name  (GtkImage       *image,
 899                                const gchar    *icon_name,
 900                                GtkIconSize     size)
 901 {
 902   GtkImagePrivate *priv;
 903   gchar *new_name;
 904
 905   g_return_if_fail (GTK_IS_IMAGE (image));
 906
 907   priv = image->priv;
 908
 909   g_object_freeze_notify (G_OBJECT (image));
 910
 911   new_name = g_strdup (icon_name);
 912   gtk_image_clear (image);
 913
 914   if (new_name)
 915     {
 916       _gtk_icon_helper_set_icon_name (priv->icon_helper, new_name, size);
 917       g_free (new_name);
 918     }
 919
 920   g_object_notify (G_OBJECT (image), "icon-name");
 921   g_object_notify (G_OBJECT (image), "icon-size");
 922
 923   g_object_thaw_notify (G_OBJECT (image));
 924 }
 925
 926 /**
 927  * gtk_image_set_from_gicon:
 928  * @image: a #GtkImage
 929  * @icon: an icon
 930  * @size: (type int): an icon size
 931  *
 932  * See gtk_image_new_from_gicon() for details.
 933  *
 934  * Since: 2.14
 935  **/
 936 void
 937 gtk_image_set_from_gicon  (GtkImage       *image,
 938                            GIcon          *icon,
 939                            GtkIconSize     size)
 940 {
 941   GtkImagePrivate *priv;
 942
 943   g_return_if_fail (GTK_IS_IMAGE (image));
 944
 945   priv = image->priv;
 946
 947   g_object_freeze_notify (G_OBJECT (image));
 948
 949   if (icon)
 950     g_object_ref (icon);
 951
 952   gtk_image_clear (image);
 953
 954   if (icon)
 955     {
 956       _gtk_icon_helper_set_gicon (priv->icon_helper, icon, size);
 957       g_object_unref (icon);
 958     }
 959
 960   g_object_notify (G_OBJECT (image), "gicon");
 961   g_object_notify (G_OBJECT (image), "icon-size");
 962
 963   g_object_thaw_notify (G_OBJECT (image));
 964 }
 965
 966 /**
 967  * gtk_image_get_storage_type:
 968  * @image: a #GtkImage
 969  *
 970  * Gets the type of representation being used by the #GtkImage
 971  * to store image data. If the #GtkImage has no image data,
 972  * the return value will be %GTK_IMAGE_EMPTY.
 973  *
 974  * Return value: image representation being used
 975  **/
 976 GtkImageType
 977 gtk_image_get_storage_type (GtkImage *image)
 978 {
 979   g_return_val_if_fail (GTK_IS_IMAGE (image), GTK_IMAGE_EMPTY);
 980
 981   return _gtk_icon_helper_get_storage_type (image->priv->icon_helper);
 982 }
 983
 984 /**
 985  * gtk_image_get_pixbuf:
 986  * @image: a #GtkImage
 987  *
 988  * Gets the #GdkPixbuf being displayed by the #GtkImage.
 989  * The storage type of the image must be %GTK_IMAGE_EMPTY or
 990  * %GTK_IMAGE_PIXBUF (see gtk_image_get_storage_type()).
 991  * The caller of this function does not own a reference to the
 992  * returned pixbuf.
 993  *
 994  * Return value: (transfer none): the displayed pixbuf, or %NULL if
 995  * the image is empty
 996  **/
 997 GdkPixbuf*
 998 gtk_image_get_pixbuf (GtkImage *image)
 999 {
1000   g_return_val_if_fail (GTK_IS_IMAGE (image), NULL);
1001
1002   return _gtk_icon_helper_peek_pixbuf (image->priv->icon_helper);
1003 }
1004
1005 /**
1006  * gtk_image_get_stock:
1007  * @image: a #GtkImage
1008  * @stock_id: (out) (transfer none) (allow-none): place to store a
1009  *     stock icon name, or %NULL
1010  * @size: (out) (allow-none) (type int): place to store a stock icon
1011  *     size, or %NULL
1012  *
1013  * Gets the stock icon name and size being displayed by the #GtkImage.
1014  * The storage type of the image must be %GTK_IMAGE_EMPTY or
1015  * %GTK_IMAGE_STOCK (see gtk_image_get_storage_type()).
1016  * The returned string is owned by the #GtkImage and should not
1017  * be freed.
1018  **/
1019 void
1020 gtk_image_get_stock  (GtkImage        *image,
1021                       gchar          **stock_id,
1022                       GtkIconSize     *size)
1023 {
1024   GtkImagePrivate *priv;
1025
1026   g_return_if_fail (GTK_IS_IMAGE (image));
1027
1028   priv = image->priv;
1029
1030   if (stock_id)
1031     *stock_id = (gchar *) _gtk_icon_helper_get_stock_id (priv->icon_helper);
1032
1033   if (size)
1034     *size = _gtk_icon_helper_get_icon_size (priv->icon_helper);
1035 }
1036
1037 /**
1038  * gtk_image_get_icon_set:
1039  * @image: a #GtkImage
1040  * @icon_set: (out) (transfer none) (allow-none): location to store a
1041  *     #GtkIconSet, or %NULL
1042  * @size: (out) (allow-none) (type int): location to store a stock
1043  *     icon size, or %NULL
1044  *
1045  * Gets the icon set and size being displayed by the #GtkImage.
1046  * The storage type of the image must be %GTK_IMAGE_EMPTY or
1047  * %GTK_IMAGE_ICON_SET (see gtk_image_get_storage_type()).
1048  **/
1049 void
1050 gtk_image_get_icon_set  (GtkImage        *image,
1051                          GtkIconSet     **icon_set,
1052                          GtkIconSize     *size)
1053 {
1054   GtkImagePrivate *priv;
1055
1056   g_return_if_fail (GTK_IS_IMAGE (image));
1057
1058   priv = image->priv;
1059
1060   if (icon_set)
1061     *icon_set = _gtk_icon_helper_peek_icon_set (priv->icon_helper);
1062
1063   if (size)
1064     *size = _gtk_icon_helper_get_icon_size (priv->icon_helper);
1065 }
1066
1067 /**
1068  * gtk_image_get_animation:
1069  * @image: a #GtkImage
1070  *
1071  * Gets the #GdkPixbufAnimation being displayed by the #GtkImage.
1072  * The storage type of the image must be %GTK_IMAGE_EMPTY or
1073  * %GTK_IMAGE_ANIMATION (see gtk_image_get_storage_type()).
1074  * The caller of this function does not own a reference to the
1075  * returned animation.
1076  *
1077  * Return value: (transfer none): the displayed animation, or %NULL if
1078  * the image is empty
1079  **/
1080 GdkPixbufAnimation*
1081 gtk_image_get_animation (GtkImage *image)
1082 {
1083   GtkImagePrivate *priv;
1084
1085   g_return_val_if_fail (GTK_IS_IMAGE (image), NULL);
1086
1087   priv = image->priv;
1088
1089   return _gtk_icon_helper_peek_animation (priv->icon_helper);
1090 }
1091
1092 /**
1093  * gtk_image_get_icon_name:
1094  * @image: a #GtkImage
1095  * @icon_name: (out) (transfer none) (allow-none): place to store an
1096  *     icon name, or %NULL
1097  * @size: (out) (allow-none) (type int): place to store an icon size,
1098  *     or %NULL
1099  *
1100  * Gets the icon name and size being displayed by the #GtkImage.
1101  * The storage type of the image must be %GTK_IMAGE_EMPTY or
1102  * %GTK_IMAGE_ICON_NAME (see gtk_image_get_storage_type()).
1103  * The returned string is owned by the #GtkImage and should not
1104  * be freed.
1105  *
1106  * Since: 2.6
1107  **/
1108 void
1109 gtk_image_get_icon_name  (GtkImage     *image,
1110                           const gchar **icon_name,
1111                           GtkIconSize  *size)
1112 {
1113   GtkImagePrivate *priv;
1114
1115   g_return_if_fail (GTK_IS_IMAGE (image));
1116
1117   priv = image->priv;
1118
1119   if (icon_name)
1120     *icon_name = _gtk_icon_helper_get_icon_name (priv->icon_helper);
1121
1122   if (size)
1123     *size = _gtk_icon_helper_get_icon_size (priv->icon_helper);
1124 }
1125
1126 /**
1127  * gtk_image_get_gicon:
1128  * @image: a #GtkImage
1129  * @gicon: (out) (transfer none) (allow-none): place to store a
1130  *     #GIcon, or %NULL
1131  * @size: (out) (allow-none) (type int): place to store an icon size,
1132  *     or %NULL
1133  *
1134  * Gets the #GIcon and size being displayed by the #GtkImage.
1135  * The storage type of the image must be %GTK_IMAGE_EMPTY or
1136  * %GTK_IMAGE_GICON (see gtk_image_get_storage_type()).
1137  * The caller of this function does not own a reference to the
1138  * returned #GIcon.
1139  *
1140  * Since: 2.14
1141  **/
1142 void
1143 gtk_image_get_gicon (GtkImage     *image,
1144                      GIcon       **gicon,
1145                      GtkIconSize  *size)
1146 {
1147   GtkImagePrivate *priv;
1148
1149   g_return_if_fail (GTK_IS_IMAGE (image));
1150
1151   priv = image->priv;
1152
1153   if (gicon)
1154     *gicon = _gtk_icon_helper_peek_gicon (priv->icon_helper);
1155
1156   if (size)
1157     *size = _gtk_icon_helper_get_icon_size (priv->icon_helper);
1158 }
1159
1160 /**
1161  * gtk_image_new:
1162  *
1163  * Creates a new empty #GtkImage widget.
1164  *
1165  * Return value: a newly created #GtkImage widget.
1166  **/
1167 GtkWidget*
1168 gtk_image_new (void)
1169 {
1170   return g_object_new (GTK_TYPE_IMAGE, NULL);
1171 }
1172
1173 static void
1174 gtk_image_reset_anim_iter (GtkImage *image)
1175 {
1176   GtkImagePrivate *priv = image->priv;
1177
1178   if (gtk_image_get_storage_type (image) == GTK_IMAGE_ANIMATION)
1179     {
1180       /* Reset the animation */
1181       if (priv->animation_timeout)
1182         {
1183           g_source_remove (priv->animation_timeout);
1184           priv->animation_timeout = 0;
1185         }
1186
1187       g_clear_object (&priv->animation_iter);
1188     }
1189 }
1190
1191 static void
1192 gtk_image_unmap (GtkWidget *widget)
1193 {
1194   gtk_image_reset_anim_iter (GTK_IMAGE (widget));
1195
1196   GTK_WIDGET_CLASS (gtk_image_parent_class)->unmap (widget);
1197 }
1198
1199 static void
1200 gtk_image_unrealize (GtkWidget *widget)
1201 {
1202   gtk_image_reset_anim_iter (GTK_IMAGE (widget));
1203
1204   GTK_WIDGET_CLASS (gtk_image_parent_class)->unrealize (widget);
1205 }
1206
1207 static gint
1208 animation_timeout (gpointer data)
1209 {
1210   GtkImage *image = GTK_IMAGE (data);
1211   GtkImagePrivate *priv = image->priv;
1212   int delay;
1213
1214   priv->animation_timeout = 0;
1215
1216   gdk_pixbuf_animation_iter_advance (priv->animation_iter, NULL);
1217
1218   delay = gdk_pixbuf_animation_iter_get_delay_time (priv->animation_iter);
1219   if (delay >= 0)
1220     {
1221       GtkWidget *widget = GTK_WIDGET (image);
1222
1223       priv->animation_timeout =
1224         gdk_threads_add_timeout (delay, animation_timeout, image);
1225
1226       gtk_widget_queue_draw (widget);
1227
1228       if (gtk_widget_is_drawable (widget))
1229         gdk_window_process_updates (gtk_widget_get_window (widget), TRUE);
1230     }
1231
1232   return FALSE;
1233 }
1234
1235 static GdkPixbuf *
1236 get_animation_frame (GtkImage *image)
1237 {
1238   GtkImagePrivate *priv = image->priv;
1239
1240   if (priv->animation_iter == NULL)
1241     {
1242       int delay;
1243
1244       priv->animation_iter =
1245         gdk_pixbuf_animation_get_iter (_gtk_icon_helper_peek_animation (priv->icon_helper), NULL);
1246
1247       delay = gdk_pixbuf_animation_iter_get_delay_time (priv->animation_iter);
1248       if (delay >= 0)
1249         priv->animation_timeout =
1250           gdk_threads_add_timeout (delay, animation_timeout, image);
1251     }
1252
1253   /* don't advance the anim iter here, or we could get frame changes between two
1254    * exposes of different areas.
1255    */
1256   return g_object_ref (gdk_pixbuf_animation_iter_get_pixbuf (priv->animation_iter));
1257 }
1258
1259 static void
1260 gtk_image_get_preferred_size (GtkImage *image,
1261                               gint     *width_out,
1262                               gint     *height_out)
1263 {
1264   GtkImagePrivate *priv = image->priv;
1265   gint xpad, ypad, width, height;
1266   GtkStyleContext *context;
1267
1268   context = gtk_widget_get_style_context (GTK_WIDGET (image));
1269   gtk_misc_get_padding (GTK_MISC (image), &xpad, &ypad);
1270   _gtk_icon_helper_get_size (priv->icon_helper, context, &width, &height);
1271
1272   width += 2 * xpad;
1273   height += 2 * ypad;
1274
1275   if (width_out)
1276     *width_out = width;
1277   if (height_out)
1278     *height_out = height;
1279 }
1280
1281 static gint
1282 gtk_image_draw (GtkWidget *widget,
1283                 cairo_t   *cr)
1284 {
1285   GtkImage *image;
1286   GtkImagePrivate *priv;
1287   GtkMisc *misc;
1288   GtkStyleContext *context;
1289   gint x, y, width, height;
1290   gint xpad, ypad;
1291   gfloat xalign, yalign;
1292
1293   g_return_val_if_fail (GTK_IS_IMAGE (widget), FALSE);
1294
1295   image = GTK_IMAGE (widget);
1296   misc = GTK_MISC (image);
1297   priv = image->priv;
1298
1299   context = gtk_widget_get_style_context (widget);
1300
1301   gtk_misc_get_alignment (misc, &xalign, &yalign);
1302   gtk_misc_get_padding (misc, &xpad, &ypad);
1303   gtk_image_get_preferred_size (image, &width, &height);
1304
1305   if (gtk_widget_get_direction (widget) != GTK_TEXT_DIR_LTR)
1306     xalign = 1.0 - xalign;
1307
1308   x = floor (xpad + ((gtk_widget_get_allocated_width (widget) - width) * xalign));
1309   y = floor (ypad + ((gtk_widget_get_allocated_height (widget) - height) * yalign));
1310
1311   if (gtk_image_get_storage_type (image) == GTK_IMAGE_ANIMATION)
1312     {
1313       GdkPixbuf *pixbuf = get_animation_frame (image);
1314       gtk_render_icon (context, cr,
1315                        pixbuf,
1316                        x, y);
1317       g_object_unref (pixbuf);
1318     }
1319   else
1320     {
1321       _gtk_icon_helper_draw (priv->icon_helper,
1322                              context, cr,
1323                              x, y);
1324     }
1325
1326   return FALSE;
1327 }
1328
1329 static void
1330 gtk_image_reset (GtkImage *image)
1331 {
1332   GtkImagePrivate *priv = image->priv;
1333   GtkImageType storage_type;
1334
1335   g_object_freeze_notify (G_OBJECT (image));
1336   storage_type = gtk_image_get_storage_type (image);
1337
1338   if (storage_type != GTK_IMAGE_EMPTY)
1339     g_object_notify (G_OBJECT (image), "storage-type");
1340
1341   g_object_notify (G_OBJECT (image), "icon-size");
1342
1343   switch (storage_type)
1344     {
1345     case GTK_IMAGE_PIXBUF:
1346       g_object_notify (G_OBJECT (image), "pixbuf");
1347       break;
1348     case GTK_IMAGE_STOCK:
1349       g_object_notify (G_OBJECT (image), "stock");
1350       break;
1351     case GTK_IMAGE_ICON_SET:
1352       g_object_notify (G_OBJECT (image), "icon-set");
1353       break;
1354     case GTK_IMAGE_ANIMATION:
1355       gtk_image_reset_anim_iter (image);
1356       g_object_notify (G_OBJECT (image), "pixbuf-animation");
1357       break;
1358     case GTK_IMAGE_ICON_NAME:
1359       g_object_notify (G_OBJECT (image), "icon-name");
1360       break;
1361     case GTK_IMAGE_GICON:
1362       g_object_notify (G_OBJECT (image), "gicon");
1363       break;
1364     case GTK_IMAGE_EMPTY:
1365     default:
1366       break;
1367     }
1368
1369   if (priv->filename)
1370     {
1371       g_free (priv->filename);
1372       priv->filename = NULL;
1373       g_object_notify (G_OBJECT (image), "file");
1374     }
1375
1376   _gtk_icon_helper_clear (priv->icon_helper);
1377
1378   g_object_thaw_notify (G_OBJECT (image));
1379 }
1380
1381 /**
1382  * gtk_image_clear:
1383  * @image: a #GtkImage
1384  *
1385  * Resets the image to be empty.
1386  *
1387  * Since: 2.8
1388  */
1389 void
1390 gtk_image_clear (GtkImage *image)
1391 {
1392   gtk_image_reset (image);
1393
1394   if (gtk_widget_get_visible (GTK_WIDGET (image)))
1395       gtk_widget_queue_resize (GTK_WIDGET (image));
1396 }
1397
1398 static void
1399 gtk_image_get_preferred_width (GtkWidget *widget,
1400                                gint      *minimum,
1401                                gint      *natural)
1402 {
1403   gint width;
1404
1405   gtk_image_get_preferred_size (GTK_IMAGE (widget), &width, NULL);
1406   *minimum = *natural = width;
1407 }
1408
1409 static void
1410 gtk_image_get_preferred_height (GtkWidget *widget,
1411                                 gint      *minimum,
1412                                 gint      *natural)
1413 {
1414   gint height;
1415
1416   gtk_image_get_preferred_size (GTK_IMAGE (widget), NULL, &height);
1417   *minimum = *natural = height;
1418 }
1419
1420 static void
1421 icon_theme_changed (GtkImage *image)
1422 {
1423   GtkImagePrivate *priv = image->priv;
1424
1425   _gtk_icon_helper_invalidate (priv->icon_helper);
1426   gtk_widget_queue_draw (GTK_WIDGET (image));
1427 }
1428
1429 static void
1430 gtk_image_style_updated (GtkWidget *widget)
1431 {
1432   GTK_WIDGET_CLASS (gtk_image_parent_class)->style_updated (widget);
1433
1434   icon_theme_changed (GTK_IMAGE (widget));
1435 }
1436
1437 static void
1438 gtk_image_screen_changed (GtkWidget *widget,
1439                           GdkScreen *prev_screen)
1440 {
1441   GtkImage *image;
1442
1443   image = GTK_IMAGE (widget);
1444
1445   if (GTK_WIDGET_CLASS (gtk_image_parent_class)->screen_changed)
1446     GTK_WIDGET_CLASS (gtk_image_parent_class)->screen_changed (widget, prev_screen);
1447
1448   icon_theme_changed (image);
1449 }
1450
1451 void
1452 _gtk_image_gicon_data_clear (GtkImageGIconData *data)
1453 {
1454   if (data->pixbuf)
1455     {
1456       g_object_unref (data->pixbuf);
1457       data->pixbuf = NULL;
1458     }
1459   if (data->icon)
1460     {
1461       g_object_unref (data->icon);
1462       data->icon = NULL;
1463     }
1464 }
1465
1466 /**
1467  * gtk_image_set_pixel_size:
1468  * @image: a #GtkImage
1469  * @pixel_size: the new pixel size
1470  *
1471  * Sets the pixel size to use for named icons. If the pixel size is set
1472  * to a value != -1, it is used instead of the icon size set by
1473  * gtk_image_set_from_icon_name().
1474  *
1475  * Since: 2.6
1476  */
1477 void
1478 gtk_image_set_pixel_size (GtkImage *image,
1479                           gint      pixel_size)
1480 {
1481   GtkImagePrivate *priv;
1482   gint old_pixel_size;
1483
1484   g_return_if_fail (GTK_IS_IMAGE (image));
1485
1486   priv = image->priv;
1487   old_pixel_size = gtk_image_get_pixel_size (image);
1488
1489   if (pixel_size != old_pixel_size)
1490     {
1491       _gtk_icon_helper_set_pixel_size (priv->icon_helper, pixel_size);
1492
1493       if (gtk_widget_get_visible (GTK_WIDGET (image)))
1494         gtk_widget_queue_resize (GTK_WIDGET (image));
1495
1496       g_object_notify (G_OBJECT (image), "pixel-size");
1497     }
1498 }
1499
1500 /**
1501  * gtk_image_get_pixel_size:
1502  * @image: a #GtkImage
1503  *
1504  * Gets the pixel size used for named icons.
1505  *
1506  * Returns: the pixel size used for named icons.
1507  *
1508  * Since: 2.6
1509  */
1510 gint
1511 gtk_image_get_pixel_size (GtkImage *image)
1512 {
1513   g_return_val_if_fail (GTK_IS_IMAGE (image), -1);
1514
1515   return _gtk_icon_helper_get_pixel_size (image->priv->icon_helper);
1516 }