Tiré de GTK+ Reference Manual
acryline 2007 Boosteur de petits projets

GtkImage

GtkImage —Widget qui affiche une image.

Synopsis

#include <gtk/gtk.h>


                    GtkImage;
enum                GtkImageType;
void                gtk_image_get_icon_set              (GtkImage *image,
                                                         GtkIconSet **icon_set,
                                                         GtkIconSize *size);
void                gtk_image_get_image                 (GtkImage *image,
                                                         GdkImage **gdk_image,
                                                         GdkBitmap **mask);
GdkPixbuf*          gtk_image_get_pixbuf                (GtkImage *image);
void                gtk_image_get_pixmap                (GtkImage *image,
                                                         GdkPixmap **pixmap,
                                                         GdkBitmap **mask);
void                gtk_image_get_stock                 (GtkImage *image,
                                                         gchar **stock_id,
                                                         GtkIconSize *size);
GdkPixbufAnimation* gtk_image_get_animation             (GtkImage *image);
void                gtk_image_get_icon_name             (GtkImage *image,
                                                         G_CONST_RETURN gchar **icon_name,
                                                         GtkIconSize *size);
GtkImageType        gtk_image_get_storage_type          (GtkImage *image);
GtkWidget*          gtk_image_new_from_file             (const gchar *filename);
GtkWidget*          gtk_image_new_from_icon_set         (GtkIconSet *icon_set,
                                                         GtkIconSize size);
GtkWidget*          gtk_image_new_from_image            (GdkImage *image,
                                                         GdkBitmap *mask);
GtkWidget*          gtk_image_new_from_pixbuf           (GdkPixbuf *pixbuf);
GtkWidget*          gtk_image_new_from_pixmap           (GdkPixmap *pixmap,
                                                         GdkBitmap *mask);
GtkWidget*          gtk_image_new_from_stock            (const gchar *stock_id,
                                                         GtkIconSize size);
GtkWidget*          gtk_image_new_from_animation        (GdkPixbufAnimation *animation);
GtkWidget*          gtk_image_new_from_icon_name        (const gchar *icon_name,
                                                         GtkIconSize size);
void                gtk_image_set_from_file             (GtkImage *image,
                                                         const gchar *filename);
void                gtk_image_set_from_icon_set         (GtkImage *image,
                                                         GtkIconSet *icon_set,
                                                         GtkIconSize size);
void                gtk_image_set_from_image            (GtkImage *image,
                                                         GdkImage *gdk_image,
                                                         GdkBitmap *mask);
void                gtk_image_set_from_pixbuf           (GtkImage *image,
                                                         GdkPixbuf *pixbuf);
void                gtk_image_set_from_pixmap           (GtkImage *image,
                                                         GdkPixmap *pixmap,
                                                         GdkBitmap *mask);
void                gtk_image_set_from_stock            (GtkImage *image,
                                                         const gchar *stock_id,
                                                         GtkIconSize size);
void                gtk_image_set_from_animation        (GtkImage *image,
                                                         GdkPixbufAnimation *animation);
void                gtk_image_set_from_icon_name        (GtkImage *image,
                                                         const gchar *icon_name,
                                                         GtkIconSize size);
void                gtk_image_clear                     (GtkImage *image);
GtkWidget*          gtk_image_new                       (void);
void                gtk_image_set                       (GtkImage *image,
                                                         GdkImage *val,
                                                         GdkBitmap *mask);
void                gtk_image_get                       (GtkImage *image,
                                                         GdkImage **val,
                                                         GdkBitmap **mask);
void                gtk_image_set_pixel_size            (GtkImage *image,
                                                         gint pixel_size);
gint                gtk_image_get_pixel_size            (GtkImage *image);

Héirarchie de l'objet

  GObject
   +----GInitiallyUnowned
         +----GtkObject
               +----GtkWidget
                     +----GtkMisc
                           +----GtkImage

Implemented Interfaces

GtkImage implémente AtkImplementorIface.

Propriétés

  "file"                     gchararray            : Lire / Ecrire
  "icon-name"                gchararray            : Lire / Ecrire
  "icon-set"                 GtkIconSet            : Lire / Ecrire
  "icon-size"                gint                  : Lire / Ecrire
  "image"                    GdkImage              : Lire / Ecrire
  "mask"                     GdkPixmap             : Lire / Ecrire
  "pixbuf"                   GdkPixbuf             : Lire / Ecrire
  "pixbuf-animation"         GdkPixbufAnimation    : Lire / Ecrire
  "pixel-size"               gint                  : Lire / Ecrire
  "pixmap"                   GdkPixmap             : Lire / Ecrire
  "stock"                    gchararray            : Lire / Ecrire
  "storage-type"             GtkImageType          : Lire

Description

Le widget  GtkImage affiche une image. Plusieurs sortes d'objets peuvent afficher une image; plus particulièrement  vous devez charger un  GdkPixbuf ("pixel buffer") depuis un fichier puis l'afficher. Il existe une fonction pratique  pour faire cela,  gtk_image_new_from_file(), que l'on utilise ainsi : 

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

Si le fichier n'est pas chargé avec succès, l'image contiendra une icône "d'image manquante" semblable à celle utilisée dans de nombreux explorateurs web.  Si vous voulez contrôler les erreurs de chargement de fichier vous-même, par exemple pour afficher un message d'erreur, alors chargez l'image avec gdk_pixbuf_new_from_file(), puis créez le  GtkImage avec  gtk_image_new_from_pixbuf().

Le fichier image peut contenir un animation, si c'est le cas le  GtkImage affichera une animation (GdkPixbufAnimation) à la place d'une image statique.

GtkImage est une sous-classe de  GtkMisc que qui implique que vous pouvez l'aligner (centre, gauche, droite) et lui ajouter un format en utilisant les méthodes GtkMisc.

GtkImage est un widget "non fenêtre" (il n'a pas de GdkWindow of its own), aussi, par défaut, il ne recoit pas d'événement. Si vous voulez recevoir des événements dans l'image, comme des clics sur un bouton, placez l'image dans une  GtkEventBox, puis connectez les signaux d'événement sur la boîte d'événement.

Exemple 2. Contrôle des événement de bouton pressé dans un GtkImage.

  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);

    /* Le retour TRUE signifie que nous manipulons l'événement, aussi l'émission
     * du signal doit être arrêtée ( n'appellez pas d'autre 
     * callbacks qui peuvent être connecté). Retourne FALSE
     * pour continuer à appeler les 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;
  }

Quand les événements sont traîtés dans la boîte d'événements, il faut savoir que les coordonnées de l'image peuvent  être différentes des coordonnées de la boîte d'événements à cause de l'alignement et du formatage de l'image ( voir GtkMisc). La façon le plus simple de résoudre cela est de définir l'alignement à  0.0 (gauche/ haut), et de définir le formatage à zéro. Alors l'origine de l'image sera la même que celle de la boîte d'événements.

Quelques fois l'application aura besoin de ne pas dépendre d'un fichier de données externe, comme des fichiers image.  GTK+ apporte un programme pour cela appelé gdk-pixbuf-csource. Ce programme vous permet de convertir une image dans une variable C qui peut alors être chargée dans un  GdkPixbuf en utilisant gdk_pixbuf_new_from_inline().

Détails

GtkImage

typedef struct _GtkImage GtkImage;

Cette structure  contient seulement des données privées, on doit y accéder en utilisant la fonction présentée plus bas.

enum GtkImageType


typedef enum
{
  GTK_IMAGE_EMPTY,
  GTK_IMAGE_PIXMAP,
  GTK_IMAGE_IMAGE,
  GTK_IMAGE_PIXBUF,
  GTK_IMAGE_STOCK,
  GTK_IMAGE_ICON_SET,
  GTK_IMAGE_ANIMATION,
  GTK_IMAGE_ICON_NAME
} GtkImageType;

Décrit la représentation de données d'image  utilisées par un GtkImage. Si vous voulez obtenir l'image d'un widget, vous pouvez simplement obtenir la représentation courante stockée, par exemple si  gtk_image_get_storage_type() retourne  GTK_IMAGE_PIXBUF alors vous pouvez appeler  gtk_image_get_pixbuf() mais pas  gtk_image_get_stock(). Pour des images vides, vous pouvez demander n'importe quel type de stockage (appelez n'importe quelle fonction "get"), mais elles retourneront toutes des valeurs NULL .

GTK_IMAGE_EMPTY pas d'image affichée par le widget
GTK_IMAGE_PIXMAP le widget contient un  GdkPixmap
GTK_IMAGE_IMAGE le widget contient un  GdkImage
GTK_IMAGE_PIXBUF le widget contient un   GdkPixbuf
GTK_IMAGE_STOCK le widget contient un nom d'icône de stock (voir  Stock Items(3))
GTK_IMAGE_ICON_SET le widget contient un   GtkIconSet
GTK_IMAGE_ANIMATION le widget contient un   GdkPixbufAnimation
GTK_IMAGE_ICON_NAME le widget contient une icône nommée. Ce type d'image a été ajouté dans  GTK+ 2.6

gtk_image_get_icon_set ()


void                gtk_image_get_icon_set              (GtkImage *image,
                                                         GtkIconSet **icon_set,
                                                         GtkIconSize *size);

Renvoie la définition d'icône et la taille affichée par  GtkImage. Le type de stockage de l'image doit être  GTK_IMAGE_EMPTY ou GTK_IMAGE_ICON_SET (voir  gtk_image_get_storage_type()).

image : un GtkImage
icon_set : localisation pour stocker un  GtkIconSet
size : localisation pour stocker un  la taille de l'icône

gtk_image_get_image ()


void                gtk_image_get_image                 (GtkImage *image,
                                                         GdkImage **gdk_image,
                                                         GdkBitmap **mask);

Renvoie le GdkImage et le masque affiché par GtkImage. Le type de stockage de l'image doit être  GTK_IMAGE_EMPTY ou GTK_IMAGE_IMAGE (voir  gtk_image_get_storage_type()). L'appelant de la fonction ne possède pas de référence pour l'image et le masque retournés.

image : un GtkImage
gdk_image : localisation du retour pour une GtkImage
mask : localisation du retour pour une  GdkBitmap

gtk_image_get_pixbuf ()


GdkPixbuf*          gtk_image_get_pixbuf                (GtkImage *image);

Renoie le GdkPixbuf qui est affiché par le  GtkImage. Le type de stockage de l'image doit être GTK_IMAGE_EMPTY ou GTK_IMAGE_PIXBUF (voir gtk_image_get_storage_type()). L'appelant de la fonction ne possède pas de référence pour le pixbuf retourné.

image : un GtkImage
Retourne : le pixbuf affiché, ou  or NULL si l'image est vide.

gtk_image_get_pixmap ()


void                gtk_image_get_pixmap                (GtkImage *image,
                                                         GdkPixmap **pixmap,
                                                         GdkBitmap **mask);

Renvoie le pimap et le masque qui sont affichés par le  GtkImage. Le type de stockage de l'image doit être  GTK_IMAGE_EMPTY ou GTK_IMAGE_PIXMAP (voir gtk_image_get_storage_type()).  L'appelant de la fonction ne possède pas de référence pour le pixmap et le masque retournés.

image : une GtkImage
pixmap : localisation où stocker le pixmap, ou NULL
mask : localisation où stocker le masque, ou NULL

gtk_image_get_stock ()


void                gtk_image_get_stock                 (GtkImage *image,
                                                         gchar **stock_id,
                                                         GtkIconSize *size);

Renvoie le nom de la stock icône et la taille affichés par le  GtkImage. Le type de stockage de l'image doit être  GTK_IMAGE_EMPTY ou GTK_IMAGE_STOCK (voir gtk_image_get_storage_type()). La chaîne retournée appartient à  GtkImage et ne doit as être libérée.

image : un GtkImage
stock_id : endroit où stocker le nom de la stock icône
size : endroit où stocker la taille de la stock icône

gtk_image_get_animation ()


GdkPixbufAnimation* gtk_image_get_animation             (GtkImage *image);

Renvoie le  GdkPixbufAnimation affiché par le GtkImage. Le type de stockage de l'image doit être GTK_IMAGE_EMPTY ou GTK_IMAGE_ANIMATION (voir gtk_image_get_storage_type()).  L'appelant de la fonction ne possède pas de référence pour l'animation retournée.

image : un GtkImage
Retourne : l'animation affichée, ou  NULL si l'image est vide

gtk_image_get_icon_name ()


void                gtk_image_get_icon_name             (GtkImage *image,
                                                         G_CONST_RETURN gchar **icon_name,
                                                         GtkIconSize *size);

Renvoie le nom de l'icône et la taille affichée par le  GtkImage. Le type de stockage de l'image doit être GTK_IMAGE_EMPTY ou GTK_IMAGE_ICON_NAME (voir  gtk_image_get_storage_type()). La chaîne retournée appartient à GtkImage et ne doit pas être linérée.

image : un GtkImage
icon_name : endroit où stocker le nom de l'icône
size : endroit où stocker la taille de l'icône

Depuis 2.6

gtk_image_get_storage_type ()


GtkImageType        gtk_image_get_storage_type          (GtkImage *image);

Renvoie le type de représentation utilisée par le GtkImage pour stocker l'image. Si le  GtkImage ne contient pas de données images, la valeur retournée sera  GTK_IMAGE_EMPTY.

image : une GtkImage
Retourne : représentation de l'image utilisée

gtk_image_new_from_file ()


GtkWidget*          gtk_image_new_from_file             (const gchar *filename);

Crée un nouveau GtkImage qui affiche le fichier  filename. Si le ichier n'est pas trouvé ou ne peut pas être chargé, le  GtkImage résultant affichera une icône d'image manquante. Cette fonction ne retourne jamais NULL, elle retourne toujours un widget GtkImage valide.

Si le fichier contient une  animation, l'image contiendra une animation.

Si vous avez besoin de détecter les échecs de chargement du fihcier, utilisez  gdk_pixbuf_new_from_file() pour charger le fichier vous-même puis créez le  GtkImage à partir du pixbuf. (Ou pour une animation, utilisez  gdk_pixbuf_animation_new_from_file()).

Le type de stockage  (gtk_image_get_storage_type()) de l'image retournée n'est pas défini, il sera quoi qu'il arrive adapté à l'affichage du fichier.

filename : un nom de fichier 
Retourne : un nouveau GtkImage 

gtk_image_new_from_icon_set ()


GtkWidget*          gtk_image_new_from_icon_set         (GtkIconSet *icon_set,
                                                         GtkIconSize size);

Créé un  GtkImage qui affiche un ensemble d'icône.Les tailles sont GTK_ICON_SIZE_MENU, GTK_ICON_SIZE_SMALL_TOOLBAR. Au lieu  d'utiliser cette fonction, généralement il faut créer un  GtkIconFactory, puis mettre vos ensembles d'icônes dans une "usine d'icône", ajouter cette "usine d'icône" à la liste "d'usines d'icône" par défaut avec gtk_icon_factory_add_default(), et enfin utiliser  gtk_image_new_from_stock(). Cela permettra aux thèmes d'être prioritaires sur les icônes contenues dans l'application.

Le GtkImage n'admet  pas de référence pour l'ensemble d'icône; vous devrez supprimer les références si vous en avez. GtkImage ajoutera ses propres références plutôt que d'utiliser les votres.

icon_set : un GtkIconSet
size : taille de la stock icône
Retourne : un nouveau GtkImage

gtk_image_new_from_image ()


GtkWidget*          gtk_image_new_from_image            (GdkImage *image,
                                                         GdkBitmap *mask);

Créé un widget  GtkImage qui affiche une  image avec un  mask. Un GdkImage est un buffer d'image au format en pixel de l'affichage courant. Le GtkImage , n'admet pas de référence pour l'image ou le masque; vous devez supprimer vos propres références. GtkImage ajoutera ses références plutôt que d'utiliser les votre.

image : un GdkImage, ou NULL
mask : un GdkBitmap, ou NULL
Retourne : un nouveau GtkImage

gtk_image_new_from_pixbuf ()



GtkWidget*          gtk_image_new_from_pixbuf           (GdkPixbuf *pixbuf);

Crée un nouveau  GtkImage qui affiche un pixbuf. Le GtkImage n'admet pas de référence pour le pixbuf; vous devez supprimer vots propres références. GtkImage ajoutera les siennes plutôt que d'utiliser les votres. 

Notez que cette fonction crée uniquement un GtkImage pour le pixbuf. Le GtkImage crée ne réagira pas aux changements d'état. Si vous voulez qu'il le fasse vous devez utiliser  gtk_image_new_from_icon_set().

pixbuf : un GdkPixbuf, ou NULL
Retourne : un nouveau GtkImage

gtk_image_new_from_pixmap ()



GtkWidget*          gtk_image_new_from_pixmap           (GdkPixmap *pixmap,
                                                         GdkBitmap *mask);

Crée un widget  GtkImage qui affiche un  pixmap avec un  mask. Un GdkPixmap est un buffer d'image côté serveur au format de l'affichage courant en pixel (??????). Le GtkImage n'admet pas de référence pour le pixbuf; vous devez supprimer vots propres références. GtkImage ajoutera les siennes plutôt que d'utiliser les votres. 

pixmap : un GdkPixmap, ou NULL
mask : un GdkBitmap, ou NULL
Retourne : un nouveau GtkImage

gtk_image_new_from_stock ()


GtkWidget*          gtk_image_new_from_stock            (const gchar *stock_id,
                                                         GtkIconSize size);

Crée un  GtkImage qui affiche une stock icône. L'échantillonage de noms des stock icônes sont  GTK_STOCK_OPEN, GTK_STOCK_QUIT. l'échantillonage des tailles est  GTK_ICON_SIZE_MENU, GTK_ICON_SIZE_SMALL_TOOLBAR. Si le nom de la stock icône n'est pas connu, l'image sera vide. Vous pouvez enregistrer vos  propres noms de stock icône, voir  gtk_icon_factory_add_default() et gtk_icon_factory_add().

stock_id : un nom de stock icône
size : une taille de stock icône
Retourne : un nouveau GtkImage qui affiche la stock icône

gtk_image_new_from_animation ()


GtkWidget*          gtk_image_new_from_animation        (GdkPixbufAnimation *animation);

Crée un  GtkImage qui affiche une animation donnée.  GtkImage n'admet pas de référence pour le pixbuf; vous devez supprimer vots propres références. GtkImage ajoutera les siennes plutôt que d'utiliser les votres. 

Notez que les images de l'animation sont montrées en utilisant un timeout avec  G_PRIORITY_DEFAULT. Quand les animations sont utilisées pour  indiquer une activité, sachez que l'animation sera montrée si la boucle principale n'est pas occupée par un appel qui a une priorité plus élevée.

animation : une animation
Retourne : un nouveau widget  GtkImage 

gtk_image_new_from_icon_name ()


GtkWidget*          gtk_image_new_from_icon_name        (const gchar *icon_name,
                                                         GtkIconSize size);

Crée un  GtkImage qui affiche une icône du thème courant. Si le nom de l'icône n'est pas connu, une icône d'image manquante sera affichée à la place. Si le thème courant d'icône change, l'icône sera mise à jour de façon appropriée.

icon_name : un nom d'icône
size : un taille de stock icône
Retourne : un nouveau GtkImage qui affiche une icône d'un thème

Depuis 2.6

gtk_image_set_from_file ()


void                gtk_image_set_from_file             (GtkImage *image,
                                                         const gchar *filename);

Voir gtk_image_new_from_file() pour plus de détails.

image : un GtkImage
filename : un nom de fichier ou NULL

gtk_image_set_from_icon_set ()


void                gtk_image_set_from_icon_set         (GtkImage *image,
                                                         GtkIconSet *icon_set,
                                                         GtkIconSize size);

Voir gtk_image_new_from_icon_set() pour plus de détails.

image : un GtkImage
icon_set : un  GtkIconSet
size : une taille de stock icône

gtk_image_set_from_image ()


void                gtk_image_set_from_image            (GtkImage *image,
                                                         GdkImage *gdk_image,
                                                         GdkBitmap *mask);

Voir gtk_image_new_from_image() pour plus de détails.

image : un GtkImage
gdk_image : ub GdkImage ou NULL
mask : un GdkBitmap ou NULL

gtk_image_set_from_pixbuf ()


void                gtk_image_set_from_pixbuf           (GtkImage *image,
                                                         GdkPixbuf *pixbuf);

Voir gtk_image_new_from_pixbuf() pour plus de détails.

image : un GtkImage
pixbuf : un GdkPixbuf ou NULL

gtk_image_set_from_pixmap ()


void                gtk_image_set_from_pixmap           (GtkImage *image,
                                                         GdkPixmap *pixmap,
                                                         GdkBitmap *mask);

Voir gtk_image_new_from_pixmap() pour plus de détails.

image : un GtkImage
pixmap : un GdkPixmap ou NULL
mask : un GdkBitmap ou NULL

gtk_image_set_from_stock ()


void                gtk_image_set_from_stock            (GtkImage *image,
                                                         const gchar *stock_id,
                                                         GtkIconSize size);

Voir gtk_image_new_from_stock() pour plus de détails.

image : un GtkImage
stock_id : un nom de stock icône
size : une taille de stock icône

gtk_image_set_from_animation ()


void                gtk_image_set_from_animation        (GtkImage *image,
                                                         GdkPixbufAnimation *animation);

Fait en sort que  GtkImage affiche l'animation donnée (ou n'affiche rien si l'animation est définie à  NULL).

image : une GtkImage
animation : la GdkPixbufAnimation

gtk_image_set_from_icon_name ()


void                gtk_image_set_from_icon_name        (GtkImage *image,
                                                         const gchar *icon_name,
                                                         GtkIconSize size);

Voir gtk_image_new_from_icon_name() pour plus de détails.

image : une GtkImage
icon_name : un nom d'icône
size : une taille d'icône

Depuis 2.6

gtk_image_clear ()


void                gtk_image_clear                     (GtkImage *image);

Remet à zéro l'image pour la vider.

image : un GtkImage

Depuis 2.8

gtk_image_new ()


GtkWidget*          gtk_image_new                       (void);

Crée un nouveau widget GtkImage vide.

Retourne : un nouveau widget GtkImage vide

gtk_image_set ()


void                gtk_image_set                       (GtkImage *image,
                                                         GdkImage *val,
                                                         GdkBitmap *mask);

Warning

gtk_image_set is deprecated and should not be used in newly-written code.

Sets the GtkImage.

image : a GtkImage
val : a GdkImage
mask : a GdkBitmap that indicates which parts of the image should be transparent.

gtk_image_get ()


void                gtk_image_get                       (GtkImage *image,
                                                         GdkImage **val,
                                                         GdkBitmap **mask);

Attention

gtk_image_get est dépréciée et ne doit plus être utilisé pour un nouveau code.

Renvoie  GtkImage.

image : un GtkImage
val : localisation retournée pour un  GdkImage
mask : un GdkBitmap qui indique quelles parties de l'image doivent être transparentes.

gtk_image_set_pixel_size ()


void                gtk_image_set_pixel_size            (GtkImage *image,
                                                         gint pixel_size);

Définit la taille en pixels à utiliser pour des icônes nommées. Si la taille en pixels est défini à une valeur != -1, elle sera utilisée à la place de la taille de l'icône définie par  gtk_image_set_from_icon_name().

image : une GtkImage
pixel_size : la nouvelle taille en pixels

Depuis 2.6

gtk_image_get_pixel_size ()


gint                gtk_image_get_pixel_size            (GtkImage *image);

Renvoie ma taille en pixels utilisée par les icônes nommées.

image : un GtkImage
Retourne : taille en pixels utilisée par les icônes nommées.

Depuis 2.6

Détails des propriétés

La propriété  "file" 


  "file"                     gchararray            : Lire / Ecrire

Nom de fichier à charger et à afficher.

Valeur par défaut : NULL

La propriété  "icon-name" 


  "icon-name"                gchararray            : Lire / Ecrire

Le nom de l'icône dans le thème d'icônes. Si le thème d'icônes change l'image sera mise à jour automatiquement.

Valeur par défaut : NULL

Depuis 2.6

La propriété  "icon-set" 


  "icon-set"                 GtkIconSet            : Lire / Ecrire

Icône définie pour être affichée.

La propriété  "icon-size" 


  "icon-size"                gint                  : Lire / Ecrire

Taille symbolique à utiliser pour les stock icônes, les icônes définie et les icônes nommées.

Valeurs permises : >= 0

Valeur par défaut : 4

La propriété  "image" 


  "image"                    GdkImage              : Lire / Ecrire

Un GdkImage à afficher.

La propriété  "mask" 


  "mask"                     GdkPixmap             : Lire / Ecrire

Masque  bitmap à utiliser avec  GdkImage ou GdkPixmap.

La propriété  "pixbuf" 


  "pixbuf"                   GdkPixbuf             : Lire / Ecrire

Un GdkPixbuf à afficher.

La propriété  "pixbuf-animation" 


  "pixbuf-animation"         GdkPixbufAnimation    : Lire / Ecrire

GdkPixbufAnimation à afficher.

La propriété  "pixel-size" 


  "pixel-size"               gint                  : Lire / Ecrire

La propriété  :pixel-size  peut être utilisée pour spécifier une taille fixe en prenant la priorité sur la propriété :icon-size pour des images de type  GTK_IMAGE_ICON_NAME.

Valeurs permises : >= -1

Valeur par défaut : -1

Depuis 2.6

La propriété  "pixmap" 


  "pixmap"                   GdkPixmap             : Lire / Ecrire

Un GdkPixmap à afficher.

La propriété  "stock" 


 "stock"                    gchararray            : Lire / Ecrire

Stock ID pour une  stock image  à afficher.

Valeur par défaut : NULL

La propriété  "storage-type" 


  "storage-type"             GtkImageType          : Lire

La représentation est utilisée pour des données image.

Valeur par défaut : GTK_IMAGE_EMPTY

Voir Aussi

GdkPixbuf