/* GTK - The GIMP Toolkit

 * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with this library; if not, write to the

 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,

 * Boston, MA 02111-1307, USA.

 */

/*

 * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS

 * file for a list of people on the GTK+ Team.  See the ChangeLog

 * files for a list of changes.  These files are distributed with

 * GTK+ at ftp://ftp.gtk.org/pub/gtk/. 

 */

#include "config.h"

#include <math.h>

#include <string.h>

#undef GDK_DISABLE_DEPRECATED

#include "gtkcontainer.h"

#include "gtkimage.h"

#include "gtkiconfactory.h"

#include "gtkstock.h"

#include "gtkicontheme.h"

#include "gtkintl.h"

#include "gtkprivate.h"

#include "gtkalias.h"

/**

 * SECTION:gtkimage

 * @Short_description: A widget displaying an image

 * @Title: GtkImage

 * @See_also:#GdkPixbuf

 *

 * The #GtkImage widget displays an image. Various kinds of object

 * can be displayed as an image; most typically, you would load a

 * #GdkPixbuf ("pixel buffer") from a file, and then display that.

 * There's a convenience function to do this, gtk_image_new_from_file(),

 * used as follows:

 * <informalexample><programlisting>

 *   GtkWidget *image;

 *   image = gtk_image_new_from_file ("myfile.png");

 * </programlisting></informalexample>

 * If the file isn't loaded successfully, the image will contain a

 * "broken image" icon similar to that used in many web browsers.

 * If you want to handle errors in loading the file yourself,

 * for example by displaying an error message, then load the image with

 * gdk_pixbuf_new_from_file(), then create the #GtkImage with

 * gtk_image_new_from_pixbuf().

 *

 * The image file may contain an animation, if so the #GtkImage will

 * display an animation (#GdkPixbufAnimation) instead of a static image.

 *

 * #GtkImage is a subclass of #GtkMisc, which implies that you can

 * align it (center, left, right) and add padding to it, using

 * #GtkMisc methods.

 *

 * #GtkImage is a "no window" widget (has no #GdkWindow of its own),

 * so by default does not receive events. If you want to receive events

 * on the image, such as button clicks, place the image inside a

 * #GtkEventBox, then connect to the event signals on the event box.

 * <example>

 * <title>Handling button press events on a

 * <structname>GtkImage</structname>.</title>

 * <programlisting>

 *   static gboolean

 *   button_press_callback (GtkWidget      *event_box,

 *                          GdkEventButton *event,

 *                          gpointer        data)

 *   {

 *     g_print ("Event box clicked at coordinates %f,%f\n",

 *              event->x, event->y);

 *

 *     /* Returning TRUE means we handled the event, so the signal

 *      * emission should be stopped (don't call any further

 *      * callbacks that may be connected). Return FALSE

 *      * to continue invoking callbacks.

 *      */

 *     return TRUE;

 *   }

 *

 *   static GtkWidget*

 *   create_image (void)

 *   {

 *     GtkWidget *image;

 *     GtkWidget *event_box;

 *

 *     image = gtk_image_new_from_file ("myfile.png");

 *

 *     event_box = gtk_event_box_new ();

 *

 *     gtk_container_add (GTK_CONTAINER (event_box), image);

 *

 *     g_signal_connect (G_OBJECT (event_box),

 *                       "button_press_event",

 *                       G_CALLBACK (button_press_callback),

 *                       image);

 *

 *     return image;

 *   }

 * </programlisting>

 * </example>

 *

 * When handling events on the event box, keep in mind that coordinates

 * in the image may be different from event box coordinates due to

 * the alignment and padding settings on the image (see #GtkMisc).

 * The simplest way to solve this is to set the alignment to 0.0

 * (left/top), and set the padding to zero. Then the origin of

 * the image will be the same as the origin of the event box.

 *

 * Sometimes an application will want to avoid depending on external data

 * files, such as image files. GTK+ comes with a program to avoid this,

 * called <application>gdk-pixbuf-csource</application>. This program

 * allows you to convert an image into a C variable declaration, which

 * can then be loaded into a #GdkPixbuf using

 * gdk_pixbuf_new_from_inline().

 */

typedef struct _GtkImagePrivate GtkImagePrivate;

struct _GtkImagePrivate

{

  /* Only used with GTK_IMAGE_ANIMATION, GTK_IMAGE_PIXBUF */

  gchar *filename;

  gint pixel_size;

  guint need_calc_size : 1;

};

#define GTK_IMAGE_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GTK_TYPE_IMAGE, GtkImagePrivate))

#define DEFAULT_ICON_SIZE GTK_ICON_SIZE_BUTTON

static gint gtk_image_expose       (GtkWidget      *widget,

                                    GdkEventExpose *event);

static void gtk_image_unmap        (GtkWidget      *widget);

static void gtk_image_unrealize    (GtkWidget      *widget);

static void gtk_image_size_request (GtkWidget      *widget,

                                    GtkRequisition *requisition);

static void gtk_image_style_set    (GtkWidget      *widget,

				    GtkStyle       *prev_style);

static void gtk_image_screen_changed (GtkWidget    *widget,

				      GdkScreen    *prev_screen);

static void gtk_image_destroy      (GtkObject      *object);

static void gtk_image_reset        (GtkImage       *image);

static void gtk_image_calc_size    (GtkImage       *image);

static void gtk_image_update_size  (GtkImage       *image,

                                    gint            image_width,

                                    gint            image_height);

static void gtk_image_set_property      (GObject          *object,

					 guint             prop_id,

					 const GValue     *value,

					 GParamSpec       *pspec);

static void gtk_image_get_property      (GObject          *object,

					 guint             prop_id,

					 GValue           *value,

					 GParamSpec       *pspec);

static void icon_theme_changed          (GtkImage         *image);

enum

{

  PROP_0,

  PROP_PIXBUF,

  PROP_PIXMAP,

  PROP_IMAGE,

  PROP_MASK,

  PROP_FILE,

  PROP_STOCK,

  PROP_ICON_SET,

  PROP_ICON_SIZE,

  PROP_PIXEL_SIZE,

  PROP_PIXBUF_ANIMATION,

  PROP_ICON_NAME,

  PROP_STORAGE_TYPE,

  PROP_GICON

};

G_DEFINE_TYPE (GtkImage, gtk_image, GTK_TYPE_MISC)

static void

gtk_image_class_init (GtkImageClass *class)

{

  GObjectClass *gobject_class;

  GtkObjectClass *object_class;

  GtkWidgetClass *widget_class;

  gobject_class = G_OBJECT_CLASS (class);

  gobject_class->set_property = gtk_image_set_property;

  gobject_class->get_property = gtk_image_get_property;

  object_class = GTK_OBJECT_CLASS (class);

  object_class->destroy = gtk_image_destroy;

  widget_class = GTK_WIDGET_CLASS (class);

  widget_class->expose_event = gtk_image_expose;

  widget_class->size_request = gtk_image_size_request;

  widget_class->unmap = gtk_image_unmap;

  widget_class->unrealize = gtk_image_unrealize;

  widget_class->style_set = gtk_image_style_set;

  widget_class->screen_changed = gtk_image_screen_changed;

  g_object_class_install_property (gobject_class,

                                   PROP_PIXBUF,

                                   g_param_spec_object ("pixbuf",

                                                        P_("Pixbuf"),

                                                        P_("A GdkPixbuf to display"),

                                                        GDK_TYPE_PIXBUF,

                                                        GTK_PARAM_READWRITE));

  g_object_class_install_property (gobject_class,

                                   PROP_PIXMAP,

                                   g_param_spec_object ("pixmap",

                                                        P_("Pixmap"),

                                                        P_("A GdkPixmap to display"),

                                                        GDK_TYPE_PIXMAP,

                                                        GTK_PARAM_READWRITE));

  g_object_class_install_property (gobject_class,

                                   PROP_IMAGE,

                                   g_param_spec_object ("image",

                                                        P_("Image"),

                                                        P_("A GdkImage to display"),

                                                        GDK_TYPE_IMAGE,

                                                        GTK_PARAM_READWRITE));

  g_object_class_install_property (gobject_class,

                                   PROP_MASK,

                                   g_param_spec_object ("mask",

                                                        P_("Mask"),

                                                        P_("Mask bitmap to use with GdkImage or GdkPixmap"),

                                                        GDK_TYPE_PIXMAP,

                                                        GTK_PARAM_READWRITE));

  g_object_class_install_property (gobject_class,

                                   PROP_FILE,

                                   g_param_spec_string ("file",

                                                        P_("Filename"),

                                                        P_("Filename to load and display"),

                                                        NULL,

                                                        GTK_PARAM_READWRITE));

  g_object_class_install_property (gobject_class,

                                   PROP_STOCK,

                                   g_param_spec_string ("stock",

                                                        P_("Stock ID"),

                                                        P_("Stock ID for a stock image to display"),

                                                        NULL,

                                                        GTK_PARAM_READWRITE));

  g_object_class_install_property (gobject_class,

                                   PROP_ICON_SET,

                                   g_param_spec_boxed ("icon-set",

                                                       P_("Icon set"),

                                                       P_("Icon set to display"),

                                                       GTK_TYPE_ICON_SET,

                                                       GTK_PARAM_READWRITE));

  g_object_class_install_property (gobject_class,

                                   PROP_ICON_SIZE,

                                   g_param_spec_int ("icon-size",

                                                     P_("Icon size"),

                                                     P_("Symbolic size to use for stock icon, icon set or named icon"),

                                                     0, G_MAXINT,

                                                     DEFAULT_ICON_SIZE,

                                                     GTK_PARAM_READWRITE));

  /**

   * GtkImage:pixel-size:

   *

   * The "pixel-size" property can be used to specify a fixed size

   * overriding the #GtkImage:icon-size property for images of type 

   * %GTK_IMAGE_ICON_NAME. 

   *

   * Since: 2.6

   */

  g_object_class_install_property (gobject_class,

				   PROP_PIXEL_SIZE,

				   g_param_spec_int ("pixel-size",

						     P_("Pixel size"),

						     P_("Pixel size to use for named icon"),

						     -1, G_MAXINT,

						     -1,

						     GTK_PARAM_READWRITE));

  g_object_class_install_property (gobject_class,

                                   PROP_PIXBUF_ANIMATION,

                                   g_param_spec_object ("pixbuf-animation",

                                                        P_("Animation"),

                                                        P_("GdkPixbufAnimation to display"),

                                                        GDK_TYPE_PIXBUF_ANIMATION,

                                                        GTK_PARAM_READWRITE));

  /**

   * GtkImage:icon-name:

   *

   * The name of the icon in the icon theme. If the icon theme is

   * changed, the image will be updated automatically.

   *

   * Since: 2.6

   */

  g_object_class_install_property (gobject_class,

                                   PROP_ICON_NAME,

                                   g_param_spec_string ("icon-name",

                                                        P_("Icon Name"),

                                                        P_("The name of the icon from the icon theme"),

                                                        NULL,

                                                        GTK_PARAM_READWRITE));

  /**

   * GtkImage:gicon:

   *

   * The GIcon displayed in the GtkImage. For themed icons,

   * If the icon theme is changed, the image will be updated

   * automatically.

   *

   * Since: 2.14

   */

  g_object_class_install_property (gobject_class,

                                   PROP_GICON,

                                   g_param_spec_object ("gicon",

                                                        P_("Icon"),

                                                        P_("The GIcon being displayed"),

                                                        G_TYPE_ICON,

                                                        GTK_PARAM_READWRITE));

  g_object_class_install_property (gobject_class,

                                   PROP_STORAGE_TYPE,

                                   g_param_spec_enum ("storage-type",

                                                      P_("Storage type"),

                                                      P_("The representation being used for image data"),

                                                      GTK_TYPE_IMAGE_TYPE,

                                                      GTK_IMAGE_EMPTY,

                                                      GTK_PARAM_READABLE));

  g_type_class_add_private (object_class, sizeof (GtkImagePrivate));

}

static void

gtk_image_init (GtkImage *image)

{

  GtkImagePrivate *priv = GTK_IMAGE_GET_PRIVATE (image);

  gtk_widget_set_has_window (GTK_WIDGET (image), FALSE);

  image->storage_type = GTK_IMAGE_EMPTY;

  image->icon_size = DEFAULT_ICON_SIZE;

  image->mask = NULL;

  priv->pixel_size = -1;

  priv->filename = NULL;

}

static void

gtk_image_destroy (GtkObject *object)

{

  GtkImage *image = GTK_IMAGE (object);

  gtk_image_reset (image);

  GTK_OBJECT_CLASS (gtk_image_parent_class)->destroy (object);

}

static void 

gtk_image_set_property (GObject      *object,

			guint         prop_id,

			const GValue *value,

			GParamSpec   *pspec)

{

  GtkImage *image;

  image = GTK_IMAGE (object);

  switch (prop_id)

    {

    case PROP_PIXBUF:

      gtk_image_set_from_pixbuf (image,

                                 g_value_get_object (value));

      break;

    case PROP_PIXMAP:

      gtk_image_set_from_pixmap (image,

                                 g_value_get_object (value),

                                 image->mask);

      break;

    case PROP_IMAGE:

      gtk_image_set_from_image (image,

                                g_value_get_object (value),

                                image->mask);

      break;

    case PROP_MASK:

      if (image->storage_type == GTK_IMAGE_PIXMAP)

        gtk_image_set_from_pixmap (image,

                                   image->data.pixmap.pixmap,

                                   g_value_get_object (value));

      else if (image->storage_type == GTK_IMAGE_IMAGE)

        gtk_image_set_from_image (image,

                                  image->data.image.image,

                                  g_value_get_object (value));

      else

        {

          GdkBitmap *mask;

          mask = g_value_get_object (value);

          if (mask)

            g_object_ref (mask);

          gtk_image_clear (image);

          image->mask = mask;

        }

      break;

    case PROP_FILE:

      gtk_image_set_from_file (image, g_value_get_string (value));

      break;

    case PROP_STOCK:

      gtk_image_set_from_stock (image, g_value_get_string (value),

                                image->icon_size);

      break;

    case PROP_ICON_SET:

      gtk_image_set_from_icon_set (image, g_value_get_boxed (value),

                                   image->icon_size);

      break;

    case PROP_ICON_SIZE:

      if (image->storage_type == GTK_IMAGE_STOCK)

        gtk_image_set_from_stock (image,

                                  image->data.stock.stock_id,

                                  g_value_get_int (value));

      else if (image->storage_type == GTK_IMAGE_ICON_SET)

        gtk_image_set_from_icon_set (image,

                                     image->data.icon_set.icon_set,

                                     g_value_get_int (value));

      else if (image->storage_type == GTK_IMAGE_ICON_NAME)

        gtk_image_set_from_icon_name (image,

				      image->data.name.icon_name,

				      g_value_get_int (value));

      else if (image->storage_type == GTK_IMAGE_GICON)

        gtk_image_set_from_gicon (image,

                                  image->data.gicon.icon,

                                  g_value_get_int (value));

      else

        /* Save to be used when STOCK, ICON_SET, ICON_NAME or GICON property comes in */

        image->icon_size = g_value_get_int (value);

      break;

    case PROP_PIXEL_SIZE:

      gtk_image_set_pixel_size (image, g_value_get_int (value));

      break;

    case PROP_PIXBUF_ANIMATION:

      gtk_image_set_from_animation (image,

                                    g_value_get_object (value));

      break;

    case PROP_ICON_NAME:

      gtk_image_set_from_icon_name (image, g_value_get_string (value),

				    image->icon_size);

      break;

    case PROP_GICON:

      gtk_image_set_from_gicon (image, g_value_get_object (value),

				image->icon_size);

      break;

    default:

      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

      break;

    }

}

static void 

gtk_image_get_property (GObject     *object,

			guint        prop_id,

			GValue      *value,

			GParamSpec  *pspec)

{

  GtkImage *image;

  GtkImagePrivate *priv;

  image = GTK_IMAGE (object);

  priv = GTK_IMAGE_GET_PRIVATE (image);

  /* The "getter" functions whine if you try to get the wrong

   * storage type. This function is instead robust against that,

   * so that GUI builders don't have to jump through hoops

   * to avoid g_warning

   */

  switch (prop_id)

    {

    case PROP_PIXBUF:

      if (image->storage_type != GTK_IMAGE_PIXBUF)

        g_value_set_object (value, NULL);

      else

        g_value_set_object (value,

                            gtk_image_get_pixbuf (image));

      break;

    case PROP_PIXMAP:

      if (image->storage_type != GTK_IMAGE_PIXMAP)

        g_value_set_object (value, NULL);

      else

        g_value_set_object (value,

                            image->data.pixmap.pixmap);

      break;

    case PROP_MASK:

      g_value_set_object (value, image->mask);

      break;

    case PROP_IMAGE:

      if (image->storage_type != GTK_IMAGE_IMAGE)

        g_value_set_object (value, NULL);

      else

        g_value_set_object (value,

                            image->data.image.image);

      break;

    case PROP_FILE:

      g_value_set_string (value, priv->filename);

      break;

    case PROP_STOCK:

      if (image->storage_type != GTK_IMAGE_STOCK)

        g_value_set_string (value, NULL);

      else

        g_value_set_string (value,

                            image->data.stock.stock_id);

      break;

    case PROP_ICON_SET:

      if (image->storage_type != GTK_IMAGE_ICON_SET)

        g_value_set_boxed (value, NULL);

      else

        g_value_set_boxed (value,

                           image->data.icon_set.icon_set);

      break;      

    case PROP_ICON_SIZE:

      g_value_set_int (value, image->icon_size);

      break;

    case PROP_PIXEL_SIZE:

      g_value_set_int (value, priv->pixel_size);

      break;

    case PROP_PIXBUF_ANIMATION:

      if (image->storage_type != GTK_IMAGE_ANIMATION)

        g_value_set_object (value, NULL);

      else

        g_value_set_object (value,

                            image->data.anim.anim);

      break;

    case PROP_ICON_NAME:

      if (image->storage_type != GTK_IMAGE_ICON_NAME)

	g_value_set_string (value, NULL);

      else

	g_value_set_string (value,

			    image->data.name.icon_name);

      break;

    case PROP_GICON:

      if (image->storage_type != GTK_IMAGE_GICON)

	g_value_set_object (value, NULL);

      else

	g_value_set_object (value,

			    image->data.gicon.icon);

      break;

    case PROP_STORAGE_TYPE:

      g_value_set_enum (value, image->storage_type);

      break;

    default:

      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

      break;

    }

}

/**

 * gtk_image_new_from_pixmap:

 * @pixmap: (allow-none): a #GdkPixmap, or %NULL

 * @mask: (allow-none): a #GdkBitmap, or %NULL

 *

 * Creates a #GtkImage widget displaying @pixmap with a @mask.

 * A #GdkPixmap is a server-side image buffer in the pixel format of the

 * current display. The #GtkImage does not assume a reference to the

 * pixmap or mask; you still need to unref them if you own references.

 * #GtkImage will add its own reference rather than adopting yours.

 * 

 * Return value: a new #GtkImage

 **/

GtkWidget*

gtk_image_new_from_pixmap (GdkPixmap *pixmap,

                           GdkBitmap *mask)

{

  GtkImage *image;

  image = g_object_new (GTK_TYPE_IMAGE, NULL);

  gtk_image_set_from_pixmap (image, pixmap, mask);

  return GTK_WIDGET (image);

}

/**

 * gtk_image_new_from_image:

 * @image: (allow-none): a #GdkImage, or %NULL

 * @mask: (allow-none): a #GdkBitmap, or %NULL

 *

 * Creates a #GtkImage widget displaying a @image with a @mask.

 * A #GdkImage is a client-side image buffer in the pixel format of the

 * current display. The #GtkImage does not assume a reference to the

 * image or mask; you still need to unref them if you own references.

 * #GtkImage will add its own reference rather than adopting yours.

 * 

 * Return value: a new #GtkImage

 **/

GtkWidget*

gtk_image_new_from_image  (GdkImage  *gdk_image,

                           GdkBitmap *mask)

{

  GtkImage *image;

  image = g_object_new (GTK_TYPE_IMAGE, NULL);

  gtk_image_set_from_image (image, gdk_image, mask);

  return GTK_WIDGET (image);

}

/**

 * gtk_image_new_from_file:

 * @filename: a filename

 * 

 * Creates a new #GtkImage displaying the file @filename. If the file

 * isn't found or can't be loaded, the resulting #GtkImage will

 * display a "broken image" icon. This function never returns %NULL,

 * it always returns a valid #GtkImage widget.

 *

 * If the file contains an animation, the image will contain an

 * animation.

 *

 * If you need to detect failures to load the file, use

 * gdk_pixbuf_new_from_file() to load the file yourself, then create

 * the #GtkImage from the pixbuf. (Or for animations, use

 * gdk_pixbuf_animation_new_from_file()).

 *

 * The storage type (gtk_image_get_storage_type()) of the returned

 * image is not defined, it will be whatever is appropriate for

 * displaying the file.

 * 

 * Return value: a new #GtkImage

 **/

GtkWidget*

gtk_image_new_from_file   (const gchar *filename)

{

  GtkImage *image;

  image = g_object_new (GTK_TYPE_IMAGE, NULL);

  gtk_image_set_from_file (image, filename);

  return GTK_WIDGET (image);

}

/**

 * gtk_image_new_from_pixbuf:

 * @pixbuf: (allow-none): a #GdkPixbuf, or %NULL

 *

 * Creates a new #GtkImage displaying @pixbuf.

 * The #GtkImage does not assume a reference to the

 * pixbuf; you still need to unref it if you own references.

 * #GtkImage will add its own reference rather than adopting yours.

 * 

 * Note that this function just creates an #GtkImage from the pixbuf. The

 * #GtkImage created will not react to state changes. Should you want that, 

 * you should use gtk_image_new_from_icon_set().

 * 

 * Return value: a new #GtkImage

 **/

GtkWidget*

gtk_image_new_from_pixbuf (GdkPixbuf *pixbuf)

{

  GtkImage *image;

  image = g_object_new (GTK_TYPE_IMAGE, NULL);

  gtk_image_set_from_pixbuf (image, pixbuf);

  return GTK_WIDGET (image);  

}

/**

 * gtk_image_new_from_stock:

 * @stock_id: a stock icon name

 * @size: (type int): a stock icon size

 * 

 * Creates a #GtkImage displaying a stock icon. Sample stock icon

 * names are #GTK_STOCK_OPEN, #GTK_STOCK_QUIT. Sample stock sizes

 * are #GTK_ICON_SIZE_MENU, #GTK_ICON_SIZE_SMALL_TOOLBAR. If the stock

 * icon name isn't known, the image will be empty.

 * You can register your own stock icon names, see

 * gtk_icon_factory_add_default() and gtk_icon_factory_add().

 * 

 * Return value: a new #GtkImage displaying the stock icon

 **/

GtkWidget*

gtk_image_new_from_stock (const gchar    *stock_id,

                          GtkIconSize     size)

{

  GtkImage *image;

  image = g_object_new (GTK_TYPE_IMAGE, NULL);

  gtk_image_set_from_stock (image, stock_id, size);

  return GTK_WIDGET (image);

}

/**

 * gtk_image_new_from_icon_set:

 * @icon_set: a #GtkIconSet

 * @size: (type int): a stock icon size

 *

 * Creates a #GtkImage displaying an icon set. Sample stock sizes are

 * #GTK_ICON_SIZE_MENU, #GTK_ICON_SIZE_SMALL_TOOLBAR. Instead of using

 * this function, usually it's better to create a #GtkIconFactory, put

 * your icon sets in the icon factory, add the icon factory to the

 * list of default factories with gtk_icon_factory_add_default(), and

 * then use gtk_image_new_from_stock(). This will allow themes to

 * override the icon you ship with your application.

 *

 * The #GtkImage does not assume a reference to the

 * icon set; you still need to unref it if you own references.

 * #GtkImage will add its own reference rather than adopting yours.

 * 

 * Return value: a new #GtkImage

 **/

GtkWidget*

gtk_image_new_from_icon_set (GtkIconSet     *icon_set,

                             GtkIconSize     size)

{

  GtkImage *image;

  image = g_object_new (GTK_TYPE_IMAGE, NULL);

  gtk_image_set_from_icon_set (image, icon_set, size);

  return GTK_WIDGET (image);

}

/**

 * gtk_image_new_from_animation:

 * @animation: an animation

 * 

 * Creates a #GtkImage displaying the given animation.

 * The #GtkImage does not assume a reference to the

 * animation; you still need to unref it if you own references.

 * #GtkImage will add its own reference rather than adopting yours.

 *

 * Note that the animation frames are shown using a timeout with

 * #G_PRIORITY_DEFAULT. When using animations to indicate busyness,

 * keep in mind that the animation will only be shown if the main loop

 * is not busy with something that has a higher priority.

 *

 * Return value: a new #GtkImage widget

 **/

GtkWidget*

gtk_image_new_from_animation (GdkPixbufAnimation *animation)

{

  GtkImage *image;

  g_return_val_if_fail (GDK_IS_PIXBUF_ANIMATION (animation), NULL);

  image = g_object_new (GTK_TYPE_IMAGE, NULL);

  gtk_image_set_from_animation (image, animation);

  return GTK_WIDGET (image);

}

/**

 * gtk_image_new_from_icon_name:

 * @icon_name: an icon name

 * @size: (type int): a stock icon size

 * 

 * Creates a #GtkImage displaying an icon from the current icon theme.

 * If the icon name isn't known, a "broken image" icon will be

 * displayed instead.  If the current icon theme is changed, the icon

 * will be updated appropriately.

 * 

 * Return value: a new #GtkImage displaying the themed icon

 *

 * Since: 2.6

 **/

GtkWidget*

gtk_image_new_from_icon_name (const gchar    *icon_name,

			      GtkIconSize     size)

{

  GtkImage *image;

  image = g_object_new (GTK_TYPE_IMAGE, NULL);

  gtk_image_set_from_icon_name (image, icon_name, size);

  return GTK_WIDGET (image);

}

/**

 * gtk_image_new_from_gicon:

 * @icon: an icon

 * @size: (type int): a stock icon size

 * 

 * Creates a #GtkImage displaying an icon from the current icon theme.

 * If the icon name isn't known, a "broken image" icon will be

 * displayed instead.  If the current icon theme is changed, the icon

 * will be updated appropriately.

 * 

 * Return value: a new #GtkImage displaying the themed icon

 *

 * Since: 2.14

 **/

GtkWidget*

gtk_image_new_from_gicon (GIcon *icon,

			  GtkIconSize     size)

{

  GtkImage *image;

  image = g_object_new (GTK_TYPE_IMAGE, NULL);

  gtk_image_set_from_gicon (image, icon, size);

  return GTK_WIDGET (image);

}

/**

 * gtk_image_set_from_pixmap:

 * @image: a #GtkImage

 * @pixmap: (allow-none): a #GdkPixmap or %NULL

 * @mask: (allow-none): a #GdkBitmap or %NULL

 *

 * See gtk_image_new_from_pixmap() for details.

 **/

void

gtk_image_set_from_pixmap (GtkImage  *image,

                           GdkPixmap *pixmap,

                           GdkBitmap *mask)

{

  g_return_if_fail (GTK_IS_IMAGE (image));

  g_return_if_fail (pixmap == NULL ||

                    GDK_IS_PIXMAP (pixmap));

  g_return_if_fail (mask == NULL ||

                    GDK_IS_PIXMAP (mask));

  g_object_freeze_notify (G_OBJECT (image));

  if (pixmap)

    g_object_ref (pixmap);

  if (mask)

    g_object_ref (mask);

  gtk_image_clear (image);

  image->mask = mask;

  if (pixmap)

    {

      int width;

      int height;

      image->storage_type = GTK_IMAGE_PIXMAP;

      image->data.pixmap.pixmap = pixmap;