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