Styles

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

Styles

Styles — Fonctions pour dessiner les parties d'un widget

Synopsis

#include <gtk/gtk.h>


#define             GTK_STYLE_ATTACHED                  (style)
                    GtkStyle;
GtkStyle*           gtk_style_new                       (void);
GtkStyle*           gtk_style_copy                      (GtkStyle *style);
GtkStyle*           gtk_style_attach                    (GtkStyle *style,
                                                         GdkWindow *window);
void                gtk_style_detach                    (GtkStyle *style);
GtkStyle*           gtk_style_ref                       (GtkStyle *style);
void                gtk_style_unref                     (GtkStyle *style);
void                gtk_style_set_background            (GtkStyle *style,
                                                         GdkWindow *window,
                                                         GtkStateType state_type);
void                gtk_style_apply_default_background  (GtkStyle *style,
                                                         GdkWindow *window,
                                                         gboolean set_bg,
                                                         GtkStateType state_type,
                                                         GdkRectangle *area,
                                                         gint x,
                                                         gint y,
                                                         gint width,
                                                         gint height);
#define             gtk_style_apply_default_pixmap      (s,gw,st,a,x,y,w,h)
gboolean            gtk_style_lookup_color              (GtkStyle *style,
                                                         const gchar *color_name,
                                                         GdkColor *color);
GtkIconSet*         gtk_style_lookup_icon_set           (GtkStyle *style,
                                                         const gchar *stock_id);
GdkPixbuf*          gtk_style_render_icon               (GtkStyle *style,
                                                         const GtkIconSource *source,
                                                         GtkTextDirection direction,
                                                         GtkStateType state,
                                                         GtkIconSize size,
                                                         GtkWidget *widget,
                                                         const gchar *detail);
GdkFont*            gtk_style_get_font                  (GtkStyle *style);
void                gtk_style_set_font                  (GtkStyle *style,
                                                         GdkFont *font);
void                gtk_draw_hline                      (GtkStyle *style,
                                                         GdkWindow *window,
                                                         GtkStateType state_type,
                                                         gint x1,
                                                         gint x2,
                                                         gint y);
void                gtk_draw_vline                      (GtkStyle *style,
                                                         GdkWindow *window,
                                                         GtkStateType state_type,
                                                         gint y1_,
                                                         gint y2_,
                                                         gint x);
void                gtk_draw_shadow                     (GtkStyle *style,
                                                         GdkWindow *window,
                                                         GtkStateType state_type,
                                                         GtkShadowType shadow_type,
                                                         gint x,
                                                         gint y,
                                                         gint width,
                                                         gint height);
void                gtk_draw_polygon                    (GtkStyle *style,
                                                         GdkWindow *window,
                                                         GtkStateType state_type,
                                                         GtkShadowType shadow_type,
                                                         GdkPoint *points,
                                                         gint npoints,
                                                         gboolean fill);
void                gtk_draw_arrow                      (GtkStyle *style,
                                                         GdkWindow *window,
                                                         GtkStateType state_type,
                                                         GtkShadowType shadow_type,
                                                         GtkArrowType arrow_type,
                                                         gboolean fill,
                                                         gint x,
                                                         gint y,
                                                         gint width,
                                                         gint height);
void                gtk_draw_diamond                    (GtkStyle *style,
                                                         GdkWindow *window,
                                                         GtkStateType state_type,
                                                         GtkShadowType shadow_type,
                                                         gint x,
                                                         gint y,
                                                         gint width,
                                                         gint height);
void                gtk_draw_string                     (GtkStyle *style,
                                                         GdkWindow *window,
                                                         GtkStateType state_type,
                                                         gint x,
                                                         gint y,
                                                         const gchar *string);
void                gtk_draw_box                        (GtkStyle *style,
                                                         GdkWindow *window,
                                                         GtkStateType state_type,
                                                         GtkShadowType shadow_type,
                                                         gint x,
                                                         gint y,
                                                         gint width,
                                                         gint height);
void                gtk_draw_box_gap                    (GtkStyle *style,
                                                         GdkWindow *window,
                                                         GtkStateType state_type,
                                                         GtkShadowType shadow_type,
                                                         gint x,
                                                         gint y,
                                                         gint width,
                                                         gint height,
                                                         GtkPositionType gap_side,
                                                         gint gap_x,
                                                         gint gap_width);
void                gtk_draw_check                      (GtkStyle *style,
                                                         GdkWindow *window,
                                                         GtkStateType state_type,
                                                         GtkShadowType shadow_type,
                                                         gint x,
                                                         gint y,
                                                         gint width,
                                                         gint height);
void                gtk_draw_extension                  (GtkStyle *style,
                                                         GdkWindow *window,
                                                         GtkStateType state_type,
                                                         GtkShadowType shadow_type,
                                                         gint x,
                                                         gint y,
                                                         gint width,
                                                         gint height,
                                                         GtkPositionType gap_side);
void                gtk_draw_flat_box                   (GtkStyle *style,
                                                         GdkWindow *window,
                                                         GtkStateType state_type,
                                                         GtkShadowType shadow_type,
                                                         gint x,
                                                         gint y,
                                                         gint width,
                                                         gint height);
void                gtk_draw_focus                      (GtkStyle *style,
                                                         GdkWindow *window,
                                                         gint x,
                                                         gint y,
                                                         gint width,
                                                         gint height);
void                gtk_draw_handle                     (GtkStyle *style,
                                                         GdkWindow *window,
                                                         GtkStateType state_type,
                                                         GtkShadowType shadow_type,
                                                         gint x,
                                                         gint y,
                                                         gint width,
                                                         gint height,
                                                         GtkOrientation orientation);
void                gtk_draw_option                     (GtkStyle *style,
                                                         GdkWindow *window,
                                                         GtkStateType state_type,
                                                         GtkShadowType shadow_type,
                                                         gint x,
                                                         gint y,
                                                         gint width,
                                                         gint height);
void                gtk_draw_shadow_gap                 (GtkStyle *style,
                                                         GdkWindow *window,
                                                         GtkStateType state_type,
                                                         GtkShadowType shadow_type,
                                                         gint x,
                                                         gint y,
                                                         gint width,
                                                         gint height,
                                                         GtkPositionType gap_side,
                                                         gint gap_x,
                                                         gint gap_width);
void                gtk_draw_slider                     (GtkStyle *style,
                                                         GdkWindow *window,
                                                         GtkStateType state_type,
                                                         GtkShadowType shadow_type,
                                                         gint x,
                                                         gint y,
                                                         gint width,
                                                         gint height,
                                                         GtkOrientation orientation);
void                gtk_draw_tab                        (GtkStyle *style,
                                                         GdkWindow *window,
                                                         GtkStateType state_type,
                                                         GtkShadowType shadow_type,
                                                         gint x,
                                                         gint y,
                                                         gint width,
                                                         gint height);
void                gtk_draw_expander                   (GtkStyle *style,
                                                         GdkWindow *window,
                                                         GtkStateType state_type,
                                                         gint x,
                                                         gint y,
                                                         GtkExpanderStyle expander_style);
void                gtk_draw_layout                     (GtkStyle *style,
                                                         GdkWindow *window,
                                                         GtkStateType state_type,
                                                         gboolean use_text,
                                                         gint x,
                                                         gint y,
                                                         PangoLayout *layout);
void                gtk_draw_resize_grip                (GtkStyle *style,
                                                         GdkWindow *window,
                                                         GtkStateType state_type,
                                                         GdkWindowEdge edge,
                                                         gint x,
                                                         gint y,
                                                         gint width,
                                                         gint height);
void                gtk_paint_arrow                     (GtkStyle *style,
                                                         GdkWindow *window,
                                                         GtkStateType state_type,
                                                         GtkShadowType shadow_type,
                                                         GdkRectangle *area,
                                                         GtkWidget *widget,
                                                         const gchar *detail,
                                                         GtkArrowType arrow_type,
                                                         gboolean fill,
                                                         gint x,
                                                         gint y,
                                                         gint width,
                                                         gint height);
void                gtk_paint_box                       (GtkStyle *style,
                                                         GdkWindow *window,
                                                         GtkStateType state_type,
                                                         GtkShadowType shadow_type,
                                                         GdkRectangle *area,
                                                         GtkWidget *widget,
                                                         const gchar *detail,
                                                         gint x,
                                                         gint y,
                                                         gint width,
                                                         gint height);
void                gtk_paint_box_gap                   (GtkStyle *style,
                                                         GdkWindow *window,
                                                         GtkStateType state_type,
                                                         GtkShadowType shadow_type,
                                                         GdkRectangle *area,
                                                         GtkWidget *widget,
                                                         gchar *detail,
                                                         gint x,
                                                         gint y,
                                                         gint width,
                                                         gint height,
                                                         GtkPositionType gap_side,
                                                         gint gap_x,
                                                         gint gap_width);
void                gtk_paint_check                     (GtkStyle *style,
                                                         GdkWindow *window,
                                                         GtkStateType state_type,
                                                         GtkShadowType shadow_type,
                                                         GdkRectangle *area,
                                                         GtkWidget *widget,
                                                         const gchar *detail,
                                                         gint x,
                                                         gint y,
                                                         gint width,
                                                         gint height);
void                gtk_paint_diamond                   (GtkStyle *style,
                                                         GdkWindow *window,
                                                         GtkStateType state_type,
                                                         GtkShadowType shadow_type,
                                                         GdkRectangle *area,
                                                         GtkWidget *widget,
                                                         const gchar *detail,
                                                         gint x,
                                                         gint y,
                                                         gint width,
                                                         gint height);
void                gtk_paint_extension                 (GtkStyle *style,
                                                         GdkWindow *window,
                                                         GtkStateType state_type,
                                                         GtkShadowType shadow_type,
                                                         GdkRectangle *area,
                                                         GtkWidget *widget,
                                                         gchar *detail,
                                                         gint x,
                                                         gint y,
                                                         gint width,
                                                         gint height,
                                                         GtkPositionType gap_side);
void                gtk_paint_flat_box                  (GtkStyle *style,
                                                         GdkWindow *window,
                                                         GtkStateType state_type,
                                                         GtkShadowType shadow_type,
                                                         GdkRectangle *area,
                                                         GtkWidget *widget,
                                                         const gchar *detail,
                                                         gint x,
                                                         gint y,
                                                         gint width,
                                                         gint height);
void                gtk_paint_focus                     (GtkStyle *style,
                                                         GdkWindow *window,
                                                         GtkStateType state_type,
                                                         GdkRectangle *area,
                                                         GtkWidget *widget,
                                                         const gchar *detail,
                                                         gint x,
                                                         gint y,
                                                         gint width,
                                                         gint height);
void                gtk_paint_handle                    (GtkStyle *style,
                                                         GdkWindow *window,
                                                         GtkStateType state_type,
                                                         GtkShadowType shadow_type,
                                                         GdkRectangle *area,
                                                         GtkWidget *widget,
                                                         const gchar *detail,
                                                         gint x,
                                                         gint y,
                                                         gint width,
                                                         gint height,
                                                         GtkOrientation orientation);
void                gtk_paint_hline                     (GtkStyle *style,
                                                         GdkWindow *window,
                                                         GtkStateType state_type,
                                                         GdkRectangle *area,
                                                         GtkWidget *widget,
                                                         const gchar *detail,
                                                         gint x1,
                                                         gint x2,
                                                         gint y);
void                gtk_paint_option                    (GtkStyle *style,
                                                         GdkWindow *window,
                                                         GtkStateType state_type,
                                                         GtkShadowType shadow_type,
                                                         GdkRectangle *area,
                                                         GtkWidget *widget,
                                                         const gchar *detail,
                                                         gint x,
                                                         gint y,
                                                         gint width,
                                                         gint height);
void                gtk_paint_polygon                   (GtkStyle *style,
                                                         GdkWindow *window,
                                                         GtkStateType state_type,
                                                         GtkShadowType shadow_type,
                                                         GdkRectangle *area,
                                                         GtkWidget *widget,
                                                         const gchar *detail,
                                                         GdkPoint *points,
                                                         gint npoints,
                                                         gboolean fill);
void                gtk_paint_shadow                    (GtkStyle *style,
                                                         GdkWindow *window,
                                                         GtkStateType state_type,
                                                         GtkShadowType shadow_type,
                                                         GdkRectangle *area,
                                                         GtkWidget *widget,
                                                         const gchar *detail,
                                                         gint x,
                                                         gint y,
                                                         gint width,
                                                         gint height);
void                gtk_paint_shadow_gap                (GtkStyle *style,
                                                         GdkWindow *window,
                                                         GtkStateType state_type,
                                                         GtkShadowType shadow_type,
                                                         GdkRectangle *area,
                                                         GtkWidget *widget,
                                                         gchar *detail,
                                                         gint x,
                                                         gint y,
                                                         gint width,
                                                         gint height,
                                                         GtkPositionType gap_side,
                                                         gint gap_x,
                                                         gint gap_width);
void                gtk_paint_slider                    (GtkStyle *style,
                                                         GdkWindow *window,
                                                         GtkStateType state_type,
                                                         GtkShadowType shadow_type,
                                                         GdkRectangle *area,
                                                         GtkWidget *widget,
                                                         const gchar *detail,
                                                         gint x,
                                                         gint y,
                                                         gint width,
                                                         gint height,
                                                         GtkOrientation orientation);
void                gtk_paint_string                    (GtkStyle *style,
                                                         GdkWindow *window,
                                                         GtkStateType state_type,
                                                         GdkRectangle *area,
                                                         GtkWidget *widget,
                                                         const gchar *detail,
                                                         gint x,
                                                         gint y,
                                                         const gchar *string);
void                gtk_paint_tab                       (GtkStyle *style,
                                                         GdkWindow *window,
                                                         GtkStateType state_type,
                                                         GtkShadowType shadow_type,
                                                         GdkRectangle *area,
                                                         GtkWidget *widget,
                                                         const gchar *detail,
                                                         gint x,
                                                         gint y,
                                                         gint width,
                                                         gint height);
void                gtk_paint_vline                     (GtkStyle *style,
                                                         GdkWindow *window,
                                                         GtkStateType state_type,
                                                         GdkRectangle *area,
                                                         GtkWidget *widget,
                                                         const gchar *detail,
                                                         gint y1_,
                                                         gint y2_,
                                                         gint x);
void                gtk_paint_expander                  (GtkStyle *style,
                                                         GdkWindow *window,
                                                         GtkStateType state_type,
                                                         GdkRectangle *area,
                                                         GtkWidget *widget,
                                                         const gchar *detail,
                                                         gint x,
                                                         gint y,
                                                         GtkExpanderStyle expander_style);
void                gtk_paint_layout                    (GtkStyle *style,
                                                         GdkWindow *window,
                                                         GtkStateType state_type,
                                                         gboolean use_text,
                                                         GdkRectangle *area,
                                                         GtkWidget *widget,
                                                         const gchar *detail,
                                                         gint x,
                                                         gint y,
                                                         PangoLayout *layout);
void                gtk_paint_resize_grip               (GtkStyle *style,
                                                         GdkWindow *window,
                                                         GtkStateType state_type,
                                                         GdkRectangle *area,
                                                         GtkWidget *widget,
                                                         const gchar *detail,
                                                         GdkWindowEdge edge,
                                                         gint x,
                                                         gint y,
                                                         gint width,
                                                         gint height);
void                gtk_draw_insertion_cursor           (GtkWidget *widget,
                                                         GdkDrawable *drawable,
                                                         GdkRectangle *area,
                                                         GdkRectangle *location,
                                                         gboolean is_primary,
                                                         GtkTextDirection direction,
                                                         gboolean draw_arrow);

                    GtkBorder;
GtkBorder*          gtk_border_copy                     (const GtkBorder *border_);
void                gtk_border_free                     (GtkBorder *border_);

                    GtkRcProperty;
gboolean            (*GtkRcPropertyParser)              (const GParamSpec *pspec,
                                                         const GString *rc_string,
                                                         GValue *property_value);

Hiérarchie de l'Object

GObject
+----GtkStyle

Signaux

  "realize"                                        : Exécuter Premier
  "unrealize"                                      : Exécuter Premier

Description

Details

GTK_STYLE_ATTACHED()

#define GTK_STYLE_ATTACHED(style)	(GTK_STYLE (style)->attach_count > 0)

Retourne si le styme est attaché à la fenêtre.

style : un GtkStyle.

GtkStyle

typedef struct {
  GdkColor fg[5];
  GdkColor bg[5];
  GdkColor light[5];
  GdkColor dark[5];
  GdkColor mid[5];
  GdkColor text[5];
  GdkColor base[5];
  GdkColor text_aa[5];		/*A mi-chemin entre le texte/base */
  
  GdkColor black;
  GdkColor white;
  PangoFontDescription *font_desc;
  
  gint xthickness;
  gint ythickness;
  
  GdkGC *fg_gc[5];
  GdkGC *bg_gc[5];
  GdkGC *light_gc[5];
  GdkGC *dark_gc[5];
  GdkGC *mid_gc[5];
  GdkGC *text_gc[5];
  GdkGC *base_gc[5];
  GdkGC *text_aa_gc[5];
  GdkGC *black_gc;
  GdkGC *white_gc;
  
  GdkPixmap *bg_pixmap[5];
} GtkStyle;

gtk_style_new ()

GtkStyle*           gtk_style_new                       (void);

Créé un nouveau GtkStyle.

Retourne :

un nouveau GtkStyle.

gtk_style_copy ()

GtkStyle*           gtk_style_copy                      (GtkStyle *style);

`style` :
Retourne :

gtk_style_attach ()

GtkStyle*           gtk_style_attach                    (GtkStyle *style,
                                                         GdkWindow *window);

Attache un style à une fenêtre; ce processus affecte des couleurs et crée les GC's pour le style - il le spécialise pour un effet visuel particulier et une carte de couleur. Le processus peut impliquer la création d'un nouveau style si le style a déjà été attaché à une fenêtre d'un autre style ou carte de couleur.

Comme cette fonction peut retourner un nouvel objet, vous devez l'utiliser ainsi : style = gtk_style_attach (style, window)

`style` :	un GtkStyle.
`window` :	un GdkWindow.
Retourne:	Soit un `style`, soit un GtkStyle nouvellement créé. Si le style est nouvellement créé, le paramètre du style ne sera pas référencé, et le nouveau style aura un compteur de référence appartenant à l'appelant.

gtk_style_detach ()

void                gtk_style_detach                    (GtkStyle *style);

Détache un style d'une fenêtre. Si le style n'est attacher à aucune autre fanêtre, il est unrealized. Voir gtk_style_attach().

style : un GtkStyle

gtk_style_ref ()

GtkStyle*           gtk_style_ref                       (GtkStyle *style);

Attention

gtk_style_ref est déprécié et ne doit pas être utilisé dans un code nouvellement écrit.

Equivalent déprécié de g_object_ref().

`style` :	un GtkStyle.
Retourne :	`style`.

gtk_style_unref ()

void                gtk_style_unref                     (GtkStyle *style);

Attention

gtk_style_unref est déprécié et ne doit pas être utilisé dans un code nouvellement écrit.

Equivalent déprécié de g_object_unref().

style : un GtkStyle.

gtk_style_set_background ()

void                gtk_style_set_background            (GtkStyle *style,
                                                         GdkWindow *window,
                                                         GtkStateType state_type);

Définit le fond de window par une couleur de fond ou un pixmap spécifié par style pour l'état donné.

`style` :	un GtkStyle
`window` :	un GdkWindow
`state_type` :	un état

gtk_style_apply_default_background ()

void                gtk_style_apply_default_background  (GtkStyle *style,
                                                         GdkWindow *window,
                                                         gboolean set_bg,
                                                         GtkStateType state_type,
                                                         GdkRectangle *area,
                                                         gint x,
                                                         gint y,
                                                         gint width,
                                                         gint height);

`style` :
`window` :
`set_bg` :
`state_type` :
`area` :
`x` :
`y` :
`width` :
`height` :

gtk_style_apply_default_pixmap()

#define gtk_style_apply_default_pixmap(s,gw,st,a,x,y,w,h) gtk_style_apply_default_background (s,gw,1,st,a,x,y,w,h)

Attention

gtk_style_apply_default_pixmap est déprécié et ne doit pas être utilisé dans un code nouvellement écrit.

Alias déprécié pour gtk_style_apply_default_background().

`s` :
`gw` :
`st` :
`a` :
`x` :
`y` :
`w` :
`h` :

gtk_style_lookup_color ()

gboolean            gtk_style_lookup_color              (GtkStyle *style,
                                                         const gchar *color_name,
                                                         GdkColor *color);

Recherche une color_name dans la logique des systèmes de couleurs des styles, complète color et retourne TRUE si elle est trouvé, autrement FALSE est retourné. Ne mettez pas en cache la correspondance de type trouvée (mapping) parce qu'elle dépend de GtkStyle et elle peut changer quand une premutation de thème se produit.

`style` :	un GtkStyle
`color_name` :	le nom de la couleur logique à chercher
`color` :	le GdkColor à remplir
Retourne :	`TRUE` si la correspondance de type (mapping) est trouvée

Depuis 2.10

gtk_style_lookup_icon_set ()

GtkIconSet*         gtk_style_lookup_icon_set           (GtkStyle *style,
                                                         const gchar *stock_id);

`style` :
`stock_id` :
Returns :

gtk_style_render_icon ()

GdkPixbuf*          gtk_style_render_icon               (GtkStyle *style,
                                                         const GtkIconSource *source,
                                                         GtkTextDirection direction,
                                                         GtkStateType state,
                                                         GtkIconSize size,
                                                         GtkWidget *widget,
                                                         const gchar *detail);

Traduit l'icône spécifiée par source à la taille donnée size l'accordant aux paramètres données et retourne le résultat dans un pixbuf.

`style` :	un GtkStyle
`source` :	le GtkIconSource spécifiant l'icône à traduire.
`direction` :	une direction de texte
`state` :	un état
`size` :	taille à laquelle l'icône doit être traduite. Un taille de (GtkIconSize)-1 signifie que le rendu a la taille de la source et qu'il n'y a pas de dimensionnement.
`widget` :	le widget
`detail` :	un détail de style
Retourne:	un GdkPixbuf nouvellement créé contennat l'icône traduite.

gtk_style_get_font ()

GdkFont*            gtk_style_get_font                  (GtkStyle *style);

Attention

gtk_style_get_font est déprécié et ne doit pas être utilisé dans un code nouvellement écrit.

Obtient le GdkFont à utiliser pour le style donné. Ceci est valable seulement comme remplacement pour l'accès direct à style->font et ne doit pas être utilisé dans un code nouveau. Les nouveaux code doivent utiliser style->font_desc à la place.

`style` :	un GtkStyle
Retourne :	le GdkFont pour le style. Cette police est la propréité du style; si vous voulez en faire une copie, vous devez appeler `gdk_font_ref()`.

gtk_style_set_font ()

void                gtk_style_set_font                  (GtkStyle *style,
                                                         GdkFont *font);

Attention

gtk_style_set_font est déprécié et ne doit pas être utilisé dans un code nouvellement écrit.

Définit le GdkFont à utiliser pour un style donné.. Ceci est valable seulement comme remplacement pour l'accès direct à style->font et ne doit pas être utilisé dans un code nouveau. Les nouveaux code doivent utiliser style->font_desc à la place.

`style` :	un GtkStyle.
`font` :	un GdkFont, ou `NULL` pour utiliser le GdkFont correspondant à style->font_desc.

gtk_draw_hline ()

void                gtk_draw_hline                      (GtkStyle *style,
                                                         GdkWindow *window,
                                                         GtkStateType state_type,
                                                         gint x1,
                                                         gint x2,
                                                         gint y);

Attention

gtk_draw_hline est déprécié et ne doit pas être utilisé dans un code nouvellement écrit. Utilisez gtk_paint_hline() à la place.

Dessine une ligne horizontale de (x1, y) à (x2, y) dans window utilisant le style et l'état donnés.

`style` :	un GtkStyle
`window` :	un GdkWindow
`state_type` :	un état
`x1` :	la coordonnée x de départ
`x2` :	la coordonnée x d'arriver.
`y` :	la coordonnée y

gtk_draw_vline ()

void                gtk_draw_vline                      (GtkStyle *style,
                                                         GdkWindow *window,
                                                         GtkStateType state_type,
                                                         gint y1_,
                                                         gint y2_,
                                                         gint x);

Attention

gtk_draw_vline est déprécié et ne doit pas être utilisé dans un code nouvellement écrit. Utilisez gtk_paint_vline() à la place.

Dessine une ligne verticale de (x, y1) à (x, y2) dans window utilisant le style et l'état donnés.

`style` :	un GtkStyle
`window` :	un GdkWindow
`state_type` :	un état
`y1_` :	la coordonnée y de départ
`y2_` :	la coordonnée y d'arrivée
`x` :	la coordonnée x

gtk_draw_shadow ()

void                gtk_draw_shadow                     (GtkStyle *style,
                                                         GdkWindow *window,
                                                         GtkStateType state_type,
                                                         GtkShadowType shadow_type,
                                                         gint x,
                                                         gint y,
                                                         gint width,
                                                         gint height);

Attention

gtk_draw_shadow est déprécié et ne doit pas être utilisé dans un code nouvellement écrit. Utilisez gtk_paint_shadow() à la place.

Dessine une ombre autour d'un rectangle donné dans window utilisant le donné, l'état et le type d'ombre donnés.

`style` :	un GtkStyle
`window` :	un GdkWindow
`state_type` :	un état
`shadow_type` :	type d'ombre à dessiner
`x` :	x d'origine du rectangle
`y` :	y d'origin du rectangle
`width` :	largeur du rectangles
`height` :	hauteur du rectangle

gtk_draw_polygon ()

void                gtk_draw_polygon                    (GtkStyle *style,
                                                         GdkWindow *window,
                                                         GtkStateType state_type,
                                                         GtkShadowType shadow_type,
                                                         GdkPoint *points,
                                                         gint npoints,
                                                         gboolean fill);

Attention

gtk_draw_polygon est déprécié et ne doit pas être utilisé dans un code nouvellement écrit. Utilisez gtk_paint_polygon() à la place.

Dessine un polygone sur window avec les paramètres donnés.

`style` :	un GtkStyle
`window` :	un GdkWindow
`state_type` :	un état
`shadow_type` :	type d'ombre à dessiner
`points` :	un tableau de GdkPoints
`npoints` :	longueur de `points`
`fill` :	`TRUE` si le polygone doit être plein

gtk_draw_arrow ()

void                gtk_draw_arrow                      (GtkStyle *style,
                                                         GdkWindow *window,
                                                         GtkStateType state_type,
                                                         GtkShadowType shadow_type,
                                                         GtkArrowType arrow_type,
                                                         gboolean fill,
                                                         gint x,
                                                         gint y,
                                                         gint width,
                                                         gint height);

Attention

gtk_draw_arrow est déprécié et ne doit pas être utilisé dans un code nouvellement écrit. Utilisez gtk_paint_arrow() à la place.

Dessine une flèche dans le rectangle donné dans window utilisant les paramètres donnés. arrow_type détermine la direction de la flèche.

`style` :	un GtkStyle
`window` :	un GdkWindow
`state_type` :	un état
`shadow_type` :	type d'ombre à dessiner
`arrow_type` :	type de flèche ) dessiner
`fill` :	`TRUE` si le bout de la flèche est rempli
`x` :	origine x du rectangle dans lequel la flèche sera dessinée
`y` :	origine y du rectangle dans lequel la flèche sera dessinée
`width` :	largeur du rectangle dans lequel la flèche sera dessinée
`height` :	hauteur du rectangle dans lequel la flèche sera dessinée

gtk_draw_diamond ()

void                gtk_draw_diamond                    (GtkStyle *style,
                                                         GdkWindow *window,
                                                         GtkStateType state_type,
                                                         GtkShadowType shadow_type,
                                                         gint x,
                                                         gint y,
                                                         gint width,
                                                         gint height);

Attention

gtk_draw_diamond est déprécié et ne doit pas être utilisé dans un code nouvellement écrit. Utilisez gtk_paint_diamond() à la place.

Dessine un diamant dans un rectangle donnée dans window en utilisant les paramètres donnés.

`style` :	un GtkStyle
`window` :	un GdkWindow
`state_type` :	un état
`shadow_type` :	le type d'ombre à dessiner
`x` :	origine x du rectangle dans lequel le diamant sera dessinée
`y` :	origine y du rectangle dans lequel le diamant sera dessinée
`width` :	largeur du rectangle dans lequel le diamant sera dessinée
`height` :	hauteur du rectangle dans lequel le diamant sera dessinée

gtk_draw_string ()

void                gtk_draw_string                     (GtkStyle *style,
                                                         GdkWindow *window,
                                                         GtkStateType state_type,
                                                         gint x,
                                                         gint y,
                                                         const gchar *string);

Warning

gtk_draw_string est déprécié et ne doit pas être utilisé dans un code nouvellement écrit.Utilisez gtk_paint_layout() à la place.

Dessine une chaîne texte dans window avec les paramètres donnés.

`style` :	un GtkStyle
`window` :	un GdkWindow
`state_type` :	un état
`x` :	origine x
`y` :	origine y
`string` :	la chaîne à dessiner

gtk_draw_box ()

void                gtk_draw_box                        (GtkStyle *style,
                                                         GdkWindow *window,
                                                         GtkStateType state_type,
                                                         GtkShadowType shadow_type,
                                                         gint x,
                                                         gint y,
                                                         gint width,
                                                         gint height);

Attention

gtk_draw_boxest déprécié et ne doit pas être utilisé dans un code nouvellement écrit. Utilisez gtk_paint_box() à la place.

Dessine une boîte dans window avec mes paramètres donnés.

`style` :	un GtkStyle
`window` :	un GdkWindow
`state_type` :	un état
`shadow_type` :	le type d'ombre à dessiner
`x` :	origine x de la boîte
`y` :	origine y de la boîte
`width` :	largeur de la boîte
`height` :	hauteur de la boîte

gtk_draw_box_gap ()

void                gtk_draw_box_gap                    (GtkStyle *style,
                                                         GdkWindow *window,
                                                         GtkStateType state_type,
                                                         GtkShadowType shadow_type,
                                                         gint x,
                                                         gint y,
                                                         gint width,
                                                         gint height,
                                                         GtkPositionType gap_side,
                                                         gint gap_x,
                                                         gint gap_width);

Attention

gtk_draw_box_gapest déprécié et ne doit pas être utilisé dans un code nouvellement écrit.Utilisez gtk_paint_box_gap() à la place.

Dessine une boîte dans windowen utilisant le style, l'état et le type d'ombre sonnés, using the given style and state and shadow type, laissant un espace d'un côté.

`style` :	un GtkStyle
`window` :	un GdkWindow
`state_type` :	un état
`shadow_type` :	type d'ombre à dessiner
`x` :	x d'origine du rectangle
`y` :	y d'origine du rectangle
`width` :	largeur du rectangle
`height` :	hauteur du rectangle
`gap_side` :	côté où laisser un espace
`gap_x` :	position de départ de l'espace
`gap_width` :	largeur de l'espace

gtk_draw_check ()

void                gtk_draw_check                      (GtkStyle *style,
                                                         GdkWindow *window,
                                                         GtkStateType state_type,
                                                         GtkShadowType shadow_type,
                                                         gint x,
                                                         gint y,
                                                         gint width,
                                                         gint height);

Attention

gtk_draw_check est déprécié et ne doit pas être utilisé dans un code nouvellement écrit. Utilisez gtk_paint_check() à la place.

Dessine un indicateur de bouton à cocher dans un rectangle donné dans window avec les paramètres donnés.

`style` :	un GtkStyle
`window` :	un GdkWindow
`state_type` :	un état
`shadow_type` :	le type d'ombre à dessiner
`x` :	origine x du rectangles dans lequel dessiner l'indicateur
`y` :	origine y du rectangles dans lequel dessiner l'indicateur
`width` :	largeur du rectangles dans lequel dessiner l'indicateur
`height` :	hauteur du rectangles dans lequel dessiner l'indicateur

gtk_draw_extension ()

void                gtk_draw_extension                  (GtkStyle *style,
                                                         GdkWindow *window,
                                                         GtkStateType state_type,
                                                         GtkShadowType shadow_type,
                                                         gint x,
                                                         gint y,
                                                         gint width,
                                                         gint height,
                                                         GtkPositionType gap_side);

Attention

gtk_draw_extension est déprécié et ne doit pas être utilisé dans un code nouvellement écrit. Utiliser gtk_paint_extension() à la place.

Dessine une extension, c'est à dire un onglet de bmock-note.

`style` :	un GtkStyle
`window` :	un GdkWindow
`state_type` :	un état
`shadow_type` :	type d'ombre à dessiner
`x` :	origine x de l'extension
`y` :	origine y de l'extension
`width` :	largeur de l'extension
`height` :	hauteur de l'extension
`gap_side` :	côté auquel l'extension est attachée

gtk_draw_flat_box ()

void                gtk_draw_flat_box                   (GtkStyle *style,
                                                         GdkWindow *window,
                                                         GtkStateType state_type,
                                                         GtkShadowType shadow_type,
                                                         gint x,
                                                         gint y,
                                                         gint width,
                                                         gint height);

Attention

gtk_draw_flat_boxest déprécié et ne doit pas être utilisé dans un code nouvellement écrit. Utilisez gtk_paint_flat_box() à la place.

Dessine une boîte plate dans window avec les paramètres donnés.

`style` :	un GtkStyle
`window` :	un GdkWindow
`state_type` :	un état
`shadow_type` :	type d'ombre à dessiner.
`x` :	origine x de la boîte
`y` :	origine y de la boîte
`width` :	largeur de la boîte
`height` :	hauteur de la boîte

gtk_draw_focus ()

void                gtk_draw_focus                      (GtkStyle *style,
                                                         GdkWindow *window,
                                                         gint x,
                                                         gint y,
                                                         gint width,
                                                         gint height);

Attention

gtk_draw_focusest déprécié et ne doit pas être utilisé dans un code nouvellement écrit.Utilisez gtk_paint_focus() à la place.

Dessine un indicateur de focus autour d'un rectangle donné dans window en utilisant le syle donné.

`style` :	un GtkStyle
`window` :	un GdkWindow
`x` :	origine x du rectangle autour duquel dessiner l'indicateur de focus.
`y` :	origine y du rectangle autour duquel dessiner l'indicateur de focus.
`width` :	largeur du rectangle autour duquel dessiner l'indicateur de focus.
`height` :	hauteur du rectangle autour duquel dessiner l'indicateur de focus.

gtk_draw_handle ()

void                gtk_draw_handle                     (GtkStyle *style,
                                                         GdkWindow *window,
                                                         GtkStateType state_type,
                                                         GtkShadowType shadow_type,
                                                         gint x,
                                                         gint y,
                                                         gint width,
                                                         gint height,
                                                         GtkOrientation orientation);

Attention

gtk_draw_handle est déprécié et ne doit pas être utilisé dans un code nouvellement écrit. Utilisez gtk_paint_handle() à la place.

Dessine une poignée comme celle qui est utilisée dans GtkHandleBox et GtkPaned.

`style` :	un GtkStyle
`window` :	un GdkWindow
`state_type` :	un état
`shadow_type` :	type d'ombre à dessiner
`x` :	origine x de la poignée
`y` :	origine y de la poignée
`width` :	largeur de la poignée
`height` :	hauteur de la poignée
`orientation` :	orientation de la poignée

gtk_draw_option ()

void                gtk_draw_option                     (GtkStyle *style,
                                                         GdkWindow *window,
                                                         GtkStateType state_type,
                                                         GtkShadowType shadow_type,
                                                         gint x,
                                                         gint y,
                                                         gint width,
                                                         gint height);

Attention

gtk_draw_option est déprécié et ne doit pas être utilisé dans un code nouvellement écrit. Utilisez gtk_paint_option() à la place;

Dessine un indicateur de bouton radio dans un rectangle donné dans window avec les paramètres donnés.

`style` :	un GtkStyle
`window` :	un GdkWindow
`state_type` :	un état
`shadow_type` :	type d'ombre à dessiner
`x` :	origine x du rectangles dans lequel dessiner l'option
`y` :	origine y du rectangles dans lequel dessiner l'option
`width` :	largeur du rectangles dans lequel dessiner l'option
`height` :	hauteur du rectangles dans lequel dessiner l'option

gtk_draw_shadow_gap ()

void                gtk_draw_shadow_gap                 (GtkStyle *style,
                                                         GdkWindow *window,
                                                         GtkStateType state_type,
                                                         GtkShadowType shadow_type,
                                                         gint x,
                                                         gint y,
                                                         gint width,
                                                         gint height,
                                                         GtkPositionType gap_side,
                                                         gint gap_x,
                                                         gint gap_width);

Attention

gtk_draw_shadow_gap est déprécié et ne doit pas être utilisé dans un code nouvellement écrit. Utilisez gtk_paint_shadow_gap() à la place.

Dessine une ombre autour d'un rectangles donné dans window en utilisant un style, un état et un type d'ombre donnés, laissant un espace d'un côté.

`style` :	un GtkStyle
`window` :	un GdkWindow
`state_type` :	un état
`shadow_type` :	type d'ombre à dessiner
`x` :	origine x du rectangle
`y` :	origine y du rectangle
`width` :	largeur du rectangle
`height` :	hauteur du rectangle
`gap_side` :	côté sur lequel laisser un espace.
`gap_x` :	position de départ de l'espace
`gap_width` :	largeur d l'espace

gtk_draw_slider ()

void                gtk_draw_slider                     (GtkStyle *style,
                                                         GdkWindow *window,
                                                         GtkStateType state_type,
                                                         GtkShadowType shadow_type,
                                                         gint x,
                                                         gint y,
                                                         gint width,
                                                         gint height,
                                                         GtkOrientation orientation);

Attention

gtk_draw_slider est déprécié et ne doit pas être utilisé dans un code nouvellement écrit.

`style` :
`window` :
`state_type` :
`shadow_type` :
`x` :
`y` :
`width` :
`height` :
`orientation` :

gtk_draw_tab ()

void                gtk_draw_tab                        (GtkStyle *style,
                                                         GdkWindow *window,
                                                         GtkStateType state_type,
                                                         GtkShadowType shadow_type,
                                                         gint x,
                                                         gint y,
                                                         gint width,
                                                         gint height);

Attention

gtk_draw_tabest déprécié et ne doit pas être utilisé dans un code nouvellement écrit. Utilisez gtk_paint_tab() à la place.

Dessine un onglet de menu d'options (c'est à des flèches pointant en haut et en bas) dans un rectangle donné dans window en utilisant les paramètres données.

`style` :	un GtkStyle
`window` :	un GdkWindow
`state_type` :	un état
`shadow_type` :	le type d'ombre à dessiner
`x` :	origine x du rectangle dans lequel dessiner l'onglet
`y` :	origine y du rectangle dans lequel dessiner l'onglet
`width` :	largeur du rectangle dans lequel dessiner l'onglet
`height` :	hauteur du rectangle dans lequel dessiner l'onglet

gtk_draw_expander ()

void                gtk_draw_expander                   (GtkStyle *style,
                                                         GdkWindow *window,
                                                         GtkStateType state_type,
                                                         gint x,
                                                         gint y,
                                                         GtkExpanderStyle expander_style);

Attention

gtk_draw_expander est déprécié et ne doit pas être utilisé dans un code nouvellement écrit. Utilisez gtk_paint_expander() à la place.

Dessine un "extenseur" comme dans un GtkTreeView.

`style` :	un GtkStyle
`window` :	un GdkWindow
`state_type` :	un état
`x` :	la position x où dessiner l'extenseur
`y` :	la position y où dessiner l'extenseur
`expander_style` :	le style pour dessiner l'extenseur

gtk_draw_layout ()

void                gtk_draw_layout                     (GtkStyle *style,
                                                         GdkWindow *window,
                                                         GtkStateType state_type,
                                                         gboolean use_text,
                                                         gint x,
                                                         gint y,
                                                         PangoLayout *layout);

Attention

gtk_draw_layout est déprécié et ne doit pas être utilisé dans un code nouvellement écrit.

`style` :
`window` :
`state_type` :
`use_text` :
`x` :
`y` :
`layout` :

gtk_draw_resize_grip ()

void                gtk_draw_resize_grip                (GtkStyle *style,
                                                         GdkWindow *window,
                                                         GtkStateType state_type,
                                                         GdkWindowEdge edge,
                                                         gint x,
                                                         gint y,
                                                         gint width,
                                                         gint height);

Attention

gtk_draw_resize_grip est déprécié et ne doit pas être utilisé dans un code nouvellement écrit. Utilisez gtk_paint_resize_grip() à la place.

Dessine une poignée de redimensionnement dans un rectangle donné dans window en utilisant les paramètres donnés.

`style` :	un GtkStyle
`window` :	un GdkWindow
`state_type` :	un état
`edge` :	me côté sur lequel dessiner la poignée de redimensionnement.
`x` :	origine x du rectangle dans lequel dessiner la poignée de redimensionement.
`y` :	origine y du rectangle dans lequel dessiner la poignée de redimensionement.
`width` :	largeur du rectangle dans lequel dessiner la poignée de redimensionement.
`height` :	hauteur of the rectangle in which to draw the resize grip

gtk_paint_arrow ()

void                gtk_paint_arrow                     (GtkStyle *style,
                                                         GdkWindow *window,
                                                         GtkStateType state_type,
                                                         GtkShadowType shadow_type,
                                                         GdkRectangle *area,
                                                         GtkWidget *widget,
                                                         const gchar *detail,
                                                         GtkArrowType arrow_type,
                                                         gboolean fill,
                                                         gint x,
                                                         gint y,
                                                         gint width,
                                                         gint height);

Dessiner une flèche dans le rectangle donné dans window en utilisant les paramètres donnés. arrow_type détermine la direction de la flèche.

`style` :	un GtkStyle
`window` :	un GdkWindow
`state_type` :	un état
`shadow_type` :	le type d'ombre à dessiner
`area` :	rectangle à cliper, ou `NULL` si la sortie ne doit pas être attachée
`widget` :	le widget (peut être `NULL`)
`detail` :	détail du style (peut être `NULL`)
`arrow_type` :	type de flèche à dessiner
`fill` :	`TRUE` si le bout de la flèche doit être rempli
`x` :	origine x du rectangle dans lequel dessiner la flèche.
`y` :	origine y du rectangle dans lequel dessiner la flèche.
`width` :	largeur du rectangle dans lequel dessiner la flèche.
`height` :	hauteur du rectangle dans lequel dessiner la flèche.

gtk_paint_box ()

void                gtk_paint_box                       (GtkStyle *style,
                                                         GdkWindow *window,
                                                         GtkStateType state_type,
                                                         GtkShadowType shadow_type,
                                                         GdkRectangle *area,
                                                         GtkWidget *widget,
                                                         const gchar *detail,
                                                         gint x,
                                                         gint y,
                                                         gint width,
                                                         gint height);

Dessine une boîte dans window avec les paramètres donnés.

`style` :	un GtkStyle
`window` :	un GdkWindow
`state_type` :	un état
`shadow_type` :	type d'ombre à dessiner
`area` :	rectangle à cliper, ou `NULL` si la sortie ne doit pas être attachée
`widget` :	le widget (peut être `NULL`)
`detail` :	un détail de style (peut être `NULL`)
`x` :	origine x de la boîte
`y` :	origine y de la boîte
`width` :	largeur de la boîte
`height` :	hauteur de la boîte

gtk_paint_box_gap ()

void                gtk_paint_box_gap                   (GtkStyle *style,
                                                         GdkWindow *window,
                                                         GtkStateType state_type,
                                                         GtkShadowType shadow_type,
                                                         GdkRectangle *area,
                                                         GtkWidget *widget,
                                                         gchar *detail,
                                                         gint x,
                                                         gint y,
                                                         gint width,
                                                         gint height,
                                                         GtkPositionType gap_side,
                                                         gint gap_x,
                                                         gint gap_width);

Dessine une boîte dans window utilisant le style, l'état et le type d'ombre donnés, laissant un espace sur un côté.

`style` :	un GtkStyle
`window` :	un GdkWindow
`state_type` :	un état
`shadow_type` :	type d'ombre à dessiner
`area` :	rectangle à cliper, ou `NULL` si la sortie ne doit pas être attachée
`widget` :	le widget (peut être `NULL`)
`detail` :	un détail de style (peut être `NULL`)
`x` :	origine x du rectangle
`y` :	origine y du rectangle
`width` :	largeur du rectangle
`height` :	hauteur du rectangle
`gap_side` :	côté sur lequel laisser un espace
`gap_x` :	position de départ de l'espace
`gap_width` :	largeur de l'espace

gtk_paint_check ()

void                gtk_paint_check                     (GtkStyle *style,
                                                         GdkWindow *window,
                                                         GtkStateType state_type,
                                                         GtkShadowType shadow_type,
                                                         GdkRectangle *area,
                                                         GtkWidget *widget,
                                                         const gchar *detail,
                                                         gint x,
                                                         gint y,
                                                         gint width,
                                                         gint height);

Dessine un indicateur de bouton à cocher dans un rectangle donné dans window avec les paramètres données.

`style` :	un GtkStyle
`window` :	un GdkWindow
`state_type` :	un état
`shadow_type` :	type d'ombre à dessiner
`area` :	rectangle à cliper, ou `NULL` si la sortie ne doit pas être attachée
`widget` :	le widget (peut être `NULL`)
`detail` :	détail de style (peut être `NULL`)
`x` :	origine x du rectangle dans lequel dessiner l'indicateur
`y` :	origine y du rectangle dans lequel dessiner l'indicateur
`width` :	largeur du rectangle dans lequel dessiner l'indicateur
`height` :	hauteur du rectangle dans lequel dessiner l'indicateur

gtk_paint_diamond ()

void                gtk_paint_diamond                   (GtkStyle *style,
                                                         GdkWindow *window,
                                                         GtkStateType state_type,
                                                         GtkShadowType shadow_type,
                                                         GdkRectangle *area,
                                                         GtkWidget *widget,
                                                         const gchar *detail,
                                                         gint x,
                                                         gint y,
                                                         gint width,
                                                         gint height);

Dessine un diamant dans un rectangles donné dans window utilisant les paramètres donnés.

`style` :	un GtkStyle
`window` :	un GdkWindow
`state_type` :	un état
`shadow_type` :	type d'ombre à dessiner
`area` :	rectangle à cliper, ou `NULL` si la sortie ne doit pas être attachée
`widget` :	le widget (peut être `NULL`)
`detail` :	détail de style (peut être `NULL`)
`x` :	origine x du rectangle dans lequel dessiner le diamant
`y` :	origine y du rectangle dans lequel dessiner le diamant
`width` :	largeur du rectangle dans lequel dessiner le diamant
`height` :	hauteur du rectangle dans lequel dessiner le diamant

gtk_paint_extension ()

void                gtk_paint_extension                 (GtkStyle *style,
                                                         GdkWindow *window,
                                                         GtkStateType state_type,
                                                         GtkShadowType shadow_type,
                                                         GdkRectangle *area,
                                                         GtkWidget *widget,
                                                         gchar *detail,
                                                         gint x,
                                                         gint y,
                                                         gint width,
                                                         gint height,
                                                         GtkPositionType gap_side);

Dessiner une extension, c'est à dire un onglet de block-note.

`style` :	un GtkStyle
`window` :	un GdkWindow
`state_type` :	un état
`shadow_type` :	type d'ombre à dessiner
`area` :	rectangle à cliper, ou `NULL` si la sortie ne doit pas être attachée
`widget` :	le widget (peut être `NULL`)
`detail` :	détail de style (peut être `NULL`)
`x` :	origine x de l'extension
`y` :	origine y de l'extension
`width` :	largeur de l'extension
`height` :	hauteur de l'extension
`gap_side` :	côté sur laquelle l'extension est attachée.

gtk_paint_flat_box ()

void                gtk_paint_flat_box                  (GtkStyle *style,
                                                         GdkWindow *window,
                                                         GtkStateType state_type,
                                                         GtkShadowType shadow_type,
                                                         GdkRectangle *area,
                                                         GtkWidget *widget,
                                                         const gchar *detail,
                                                         gint x,
                                                         gint y,
                                                         gint width,
                                                         gint height);

Dessine une boîte plate dans window avec les paramètres donnés.

`style` :	un GtkStyle
`window` :	un GdkWindow
`state_type` :	un état
`shadow_type` :	type d'ombre à dessiner
`area` :	rectangle à cliper, ou `NULL` si la sortie ne doit pas être attachée
`widget` :	le widget (peut être `NULL`)
`detail` :	détail de style (peut être `NULL`)
`x` :	origibe x de la boîte
`y` :	origibe y de la boîte
`width` :	largeur de la boîte
`height` :	hauteur de la boîte

gtk_paint_focus ()

void                gtk_paint_focus                     (GtkStyle *style,
                                                         GdkWindow *window,
                                                         GtkStateType state_type,
                                                         GdkRectangle *area,
                                                         GtkWidget *widget,
                                                         const gchar *detail,
                                                         gint x,
                                                         gint y,
                                                         gint width,
                                                         gint height);

Dessine un indicateur de focus autour d'un rectangle donnédans window en utilisant un style donné.

`style` :	un GtkStyle
`window` :	un GdkWindow
`state_type` :	un état
`area` :	rectangle à cliper, ou `NULL` si la sortie ne doit pas être attachée
`widget` :	le widget (peut être `NULL`)
`detail` :	détail de style (peut être `NULL`)
`x` :	origin x du rectangle autour duquel l'indicateur de focus sera dessiné.
`y` :	origin y du rectangle autour duquel l'indicateur de focus sera dessiné.
`width` :	largeur du rectangle autour duquel l'indicateur de focus sera dessiné.
`height` :	hauteur du rectangle autour duquel l'indicateur de focus sera dessiné.

gtk_paint_handle ()

void                gtk_paint_handle                    (GtkStyle *style,
                                                         GdkWindow *window,
                                                         GtkStateType state_type,
                                                         GtkShadowType shadow_type,
                                                         GdkRectangle *area,
                                                         GtkWidget *widget,
                                                         const gchar *detail,
                                                         gint x,
                                                         gint y,
                                                         gint width,
                                                         gint height,
                                                         GtkOrientation orientation);

Dessine une poignée comme celle utilisée dans GtkHandleBox et GtkPaned.

`style` :	un GtkStyle
`window` :	un GdkWindow
`state_type` :	un état
`shadow_type` :	type d'ombre à dessiner
`area` :	rectangle à cliper, ou `NULL` si la sortie ne doit pas être attachée
`widget` :	le widget (peut être `NULL`)
`detail` :	détail de style (peut être `NULL`)
`x` :	origine x de la poignée
`y` :	origine y de la poignée
`width` :	largeur de la poignée
`height` :	hauteur of the handle
`orientation` :	orientation de la poignée

gtk_paint_hline ()

void                gtk_paint_hline                     (GtkStyle *style,
                                                         GdkWindow *window,
                                                         GtkStateType state_type,
                                                         GdkRectangle *area,
                                                         GtkWidget *widget,
                                                         const gchar *detail,
                                                         gint x1,
                                                         gint x2,
                                                         gint y);

Dessine une ligne horizontale de (x1, y) à (x2, y) dans window utilisant le style et l'état donnés.

`style` :	un GtkStyle
`window` :	un GdkWindow
`state_type` :	un état
`area` :	rectangle pour lequel la sortie est attachée, ou `NULL` si la sortie ne doit pas être attachée.
`widget` :	le widget (peut être `NULL`)
`detail` :	détail de style (peut être `NULL`)
`x1` :	la coordonnée x de départ
`x2` :	la coordonnée y de fin
`y` :	la coordonnée y

gtk_paint_option ()

void                gtk_paint_option                    (GtkStyle *style,
                                                         GdkWindow *window,
                                                         GtkStateType state_type,
                                                         GtkShadowType shadow_type,
                                                         GdkRectangle *area,
                                                         GtkWidget *widget,
                                                         const gchar *detail,
                                                         gint x,
                                                         gint y,
                                                         gint width,
                                                         gint height);

Dessine un indicateur de bouton radio dans un rectangle donné dans window avec les paramètres donnés.

`style` :	un GtkStyle
`window` :	un GdkWindow
`state_type` :	un état
`shadow_type` :	type d'ombre à dessiner
`area` :	rectangle pour lequel la sortie est attachée, ou `NULL` si la sortie ne doit pas être attachée.
`widget` :	le widget (peut être `NULL`)
`detail` :	détail de style (peut être `NULL`)
`x` :	origine x du rectangle dans lequel dessiner l'option
`y` :	origine y du rectangle dans lequel dessiner l'option
`width` :	largeur du rectangle dans lequel dessiner l'option
`height` :	hauteur du rectangle dans lequel dessiner l'option

gtk_paint_polygon ()

void                gtk_paint_polygon                   (GtkStyle *style,
                                                         GdkWindow *window,
                                                         GtkStateType state_type,
                                                         GtkShadowType shadow_type,
                                                         GdkRectangle *area,
                                                         GtkWidget *widget,
                                                         const gchar *detail,
                                                         GdkPoint *points,
                                                         gint npoints,
                                                         gboolean fill);

Dessine un polygone sur window avec les paramètres donnés.with the given parameters.

`style` :	un GtkStyle
`window` :	un GdkWindow
`state_type` :	un état
`shadow_type` :	type d'ombre à dessiner
`area` :	rectangle à cliper, ou `NULL` si la sortie ne doit pas être attachée
`widget` :	le widget (peut être `NULL`)
`detail` :	détail de style (peut être `NULL`)
`points` :	tableau de GdkPoints
`npoints` :	longueur de `points`
`fill` :	`TRUE` si le polygone doit être plein

gtk_paint_shadow ()

void                gtk_paint_shadow                    (GtkStyle *style,
                                                         GdkWindow *window,
                                                         GtkStateType state_type,
                                                         GtkShadowType shadow_type,
                                                         GdkRectangle *area,
                                                         GtkWidget *widget,
                                                         const gchar *detail,
                                                         gint x,
                                                         gint y,
                                                         gint width,
                                                         gint height);

Dessine une ombre autour d'un rectangle donné dans window en utilisant le style, l'état et le type d'ombre donnés.

`style` :	un GtkStyle
`window` :	un GdkWindow
`state_type` :	un état
`shadow_type` :	type d'ombre à dessiner
`area` :	rectangle à cliper, ou `NULL` si la sortie ne doit pas être attachée
`widget` :	le widget (peut être `NULL`)
`detail` :	détail de style (peut être `NULL`)
`x` :	origine x du rectangles
`y` :	origine y du rectangles
`width` :	largeur du rectangles
`height` :	hauteur du rectangles

gtk_paint_shadow_gap ()

void                gtk_paint_shadow_gap                (GtkStyle *style,
                                                         GdkWindow *window,
                                                         GtkStateType state_type,
                                                         GtkShadowType shadow_type,
                                                         GdkRectangle *area,
                                                         GtkWidget *widget,
                                                         gchar *detail,
                                                         gint x,
                                                         gint y,
                                                         gint width,
                                                         gint height,
                                                         GtkPositionType gap_side,
                                                         gint gap_x,
                                                         gint gap_width);

Dessine une ombre autour d'un rectangle donné dans window en utilisant un style, un état et un type d'ombre donnés, laissant un espace sur un des côtés.

`style` :	un GtkStyle
`window` :	un GdkWindow
`state_type` :	un état
`shadow_type` :	type d'ombre à dessiner
`area` :	rectangle à cliper, ou `NULL` si la sortie ne doit pas être attachée
`widget` :	le widget (peut être `NULL`)
`detail` :	détail de style (peut être `NULL`)
`x` :	origine x du rectangle
`y` :	origine y du rectangle
`width` :	largeur du rectangle
`height` :	hauteur du rectangle
`gap_side` :	côté sur lequel laisser l'espace
`gap_x` :	position de départ de l'espace
`gap_width` :	largeur de l'espace

gtk_paint_slider ()

void                gtk_paint_slider                    (GtkStyle *style,
                                                         GdkWindow *window,
                                                         GtkStateType state_type,
                                                         GtkShadowType shadow_type,
                                                         GdkRectangle *area,
                                                         GtkWidget *widget,
                                                         const gchar *detail,
                                                         gint x,
                                                         gint y,
                                                         gint width,
                                                         gint height,
                                                         GtkOrientation orientation);

Dessine un curseur dans un rectangle donné dans window en utilisant le style et l'orientation donnés.

`style` :	un GtkStyle
`window` :	un GdkWindow
`state_type` :	un état
`shadow_type` :	une ombre
`area` :	rectangle à cliper, ou `NULL` si la sortie ne doit pas être attachée
`widget` :	le widget (peut être `NULL`)
`detail` :	détail de style (peut être `NULL`)
`x` :	origine x du rectangle dans lequel dessiner un curseur
`y` :	origine y du rectangle dans lequel dessiner un curseur
`width` :	largeur du rectangle dans lequel dessiner un curseur
`height` :	hauteur du rectangle dans lequel dessiner un curseur
`orientation` :	orientation à utiliser

gtk_paint_string ()

void                gtk_paint_string                    (GtkStyle *style,
                                                         GdkWindow *window,
                                                         GtkStateType state_type,
                                                         GdkRectangle *area,
                                                         GtkWidget *widget,
                                                         const gchar *detail,
                                                         gint x,
                                                         gint y,
                type d'ombre à dessiner
                                         const gchar *string);

Attention

gtk_paint_string est déprécié et ne doit pas être utilisé dans un code nouvellement écrit. Utilisez gtk_paint_layout() à la place.

Dessiner une chaîne texte dans window avec les paramètres donnés.

`style` :	un GtkStyle
`window` :	un GdkWindow
`state_type` :	un état
`area` :	rectangle à cliper, ou `NULL` si la sortie ne doit pas être attachée
`widget` :	le widget (peut être `NULL`)
`detail` :	détail de style (peut être `NULL`)
`x` :	origine x
`y` :	origine y
`string` :	la chaîne à dessiner

gtk_paint_tab ()

void                gtk_paint_tab                       (GtkStyle *style,
                                                         GdkWindow *window,
                                                         GtkStateType state_type,
                                                         GtkShadowType shadow_type,
                                                         GdkRectangle *area,
                                                         GtkWidget *widget,
                                                         const gchar *detail,
                                                         gint x,
                                                         gint y,
                                                         gint width,
                                                         gint height);

Dessine un onglet de menu d'options (c'est à des flèches pointant en haut et en bas) dans un rectangle donné dans window en utilisant les paramètres données. (traduction douteuse, version anglaise : Draws an option menu tab (i.e. the up and down pointing arrows) in the given rectangle on window using the given parameters.)

`style` :	un GtkStyle
`window` :	un GdkWindow
`state_type` :	un état
`shadow_type` :	type d'ombre à dessiner
`area` :	rectangle à cliper, ou `NULL` si la sortie ne doit pas être attachée
`widget` :	le widget (peut être `NULL`)
`detail` :	détail de style (peut être `NULL`)
`x` :	origine x du rectangle dans lequel dessiner l'onglet
`y` :	origine y du rectangle dans lequel dessiner l'onglet
`width` :	largeur du rectangle dans lequel dessiner l'onglet
`height` :	hauteur du rectangle dans lequel dessiner l'onglet

gtk_paint_vline ()

void                gtk_paint_vline                     (GtkStyle *style,
                                                         GdkWindow *window,
                                                         GtkStateType state_type,
                                                         GdkRectangle *area,
                                                         GtkWidget *widget,
                                                         const gchar *detail,
                                                         gint y1_,
                                                         gint y2_,
                                                         gint x);

Dessine une ligne verticale de (x, y1_) et (x, y2_) dans window en utilisant le style et l'état donnés.

`style` :	un GtkStyle
`window` :	un GdkWindow
`state_type` :	un état
`area` :	rectangle pour lequel la sortie est attachée, ou `NULL` si la sortie ne doit pas être attachée.
`widget` :	le widget (peut être `NULL`)
`detail` :	détail de style (peut être `NULL`)
`y1_` :	coordonnée y de départ
`y2_` :	coordonnée y d'arrivée
`x` :	coordonnée x

gtk_paint_expander ()

void                gtk_paint_expander                  (GtkStyle *style,
                                                         GdkWindow *window,
                                                         GtkStateType state_type,
                                                         GdkRectangle *area,
                                                         GtkWidget *widget,
                                                         const gchar *detail,
                                                         gint x,
                                                         gint y,
                                                         GtkExpanderStyle expander_style);

Dessine un extenseur (expander ) comme dans GtkTreeView. x et y définissent le centre de l'extenseur. La taille de l'extenseur est déterminée par la propriété "expander-size" su style de widget. (Si le widget n'est pas défini ou n'a pas de propriété "expander-size", une taille par défaut non définie sera utilisée, et comme l'appelant n'a pas suffisamment d'informations pour positionner l'extenseur, cela ne sera probablement pas utile.) The expander is expander_size pixels tall in the collapsed position and expander_size pixels wide in the expanded position.

`style` :	un GtkStyle
`window` :	un GdkWindow
`state_type` :	un état
`area` :	rectangle à cliper, ou `NULL` si la sortie ne doit pas être attachée
`widget` :	le widget (peut être `NULL`)
`detail` :	détail de style (peut être `NULL`)
`x` :	position x à laquelle dessiner l'extenseur
`y` :	position y à laquelle dessiner l'extenseur
`expander_style` :	le style dans lequel dessiner l'extenseur the style; déterminé si l'extenseur est replié, déplié, ou dans un état intermédiaire.

gtk_paint_layout ()

void                gtk_paint_layout                    (GtkStyle *style,
                                                         GdkWindow *window,
                                                         GtkStateType state_type,
                                                         gboolean use_text,
                                                         GdkRectangle *area,
                                                         GtkWidget *widget,
                                                         const gchar *detail,
                                                         gint x,
                                                         gint y,
                                                         PangoLayout *layout);

Dessine un calque (layout) dans window en utilisant les paramètres donnés.

`style` :	un GtkStyle
`window` :	un GdkWindow
`state_type` :	un état
`use_text` :	si sont utilisé un texte ou un contexte de premier plan graphique de `style`
`area` :	rectangle à cliper, ou `NULL` si la sortie ne doit pas être attachée
`widget` :	le widget (peut être `NULL`)
`detail` :	détail de style (peut être `NULL`)
`x` :	origine x
`y` :	origine y
`layout` :	le calque à dessiner

gtk_paint_resize_grip ()

void                gtk_paint_resize_grip               (GtkStyle *style,
                                                         GdkWindow *window,
                                                         GtkStateType state_type,
                                                         GdkRectangle *area,
                                                         GtkWidget *widget,
                                                         const gchar *detail,
                                                         GdkWindowEdge edge,
                                                         gint x,
                                                         gint y,
                                                         gint width,
                                                         gint height);

Dessine une poignée de redimensionnement dans un rectangle dans window en utilisant les paramètres donnés.

`style` :	un GtkStyle
`window` :	un GdkWindow
`state_type` :	un état
`area` :	rectangle à cliper, ou `NULL` si la sortie ne doit pas être attachée
`widget` :	le widget (peut être `NULL`)
`detail` :	détail de style (peut être `NULL`)
`edge` :	le bord où dessiner la poignée de redimensionnement
`x` :	origine x du rectangle dans lequel est dessiné la poignée
`y` :	origine y du rectangle dans lequel est dessiné la poignée
`width` :	largeur du rectangle dans lequel est dessiné la poignée
`height` :	hauteur du rectangle dans lequel est dessiné la poignée

gtk_draw_insertion_cursor ()

void                gtk_draw_insertion_cursor           (GtkWidget *widget,
                                                         GdkDrawable *drawable,
                                                         GdkRectangle *area,
                                                         GdkRectangle *location,
                                                         gboolean is_primary,
                                                         GtkTextDirection direction,
                                                         gboolean draw_arrow);

Dessine un curseur de texte sur drawable à location. Ce n'est pas une fonction de style mais simplement une fonction pratique pour dessiner le curseur de forme standard.

`widget` :	un GtkWidget
`drawable` :	un GdkDrawable
`area` :	rectangle dans lequel les sortie sont attachées, ou `NULL` si la sortie ne doit pas être attachée
`location` :	endroit oùle curseur sera dessiné (`location->width` (largeur)est ignoré)
`is_primary` :	si le cuseur doit être de la couleur primaire du curseur
`direction` :	si le curseur est gauche à droite ou droite à gauche. Il ne doit jamais être GTK_TEXT_DIR_NONE
`draw_arrow` :	`TRUE` pour dessiner une flèche directionnelle sur le curseur. Doit être `FALSE` à moins que le curseur soit dédoublé.

Depuis 2.4

GtkBorder

typedef struct {
  gint left;
  gint right;
  gint top;
  gint bottom;
} GtkBorder;

gtk_border_copy ()

GtkBorder*          gtk_border_copy                     (const GtkBorder *border_);

Copie une structure GtkBorder .

`border_` :	un GtkBorder.
Retourne :	une copie `border_`.

gtk_border_free ()

void                gtk_border_free                     (GtkBorder *border_);

Libère une structure GtkBorder

border_ : un GtkBorder.

GtkRcProperty

typedef struct {
  /* quark-ified property identifier like "GtkScrollbar::spacing" */
  GQuark type_name;
  GQuark property_name;

  /* fields similar to GtkSettingsValue */
  gchar *origin;
  GValue value;
} GtkRcProperty;

GtkRcPropertyParser ()

gboolean            (*GtkRcPropertyParser)              (const GParamSpec *pspec,
                                                         const GString *rc_string,
                                                         GValue *property_value);

`pspec` :
`rc_string` :
`property_value` :
Retourne :

Signal Details

Le signal "realize"

void                user_function                      (GtkStyle *style,
                                                        gpointer  user_data)      : Run First

Emis quand le style a été initialisé pour une carte de couleur particulière et une profondeur. La connexion à ce signal est probablement rarelent utile puisque la plupart du temps les applications et les widgets fonctionnent avec des styles qui sont déjà réalisés.

`style` :	l'objet qui reçoit le signal.
`user_data` :	données utilisateur définies quand le gestionnaire de signal est connecté.

Depuis 2.4

Le signal "unrealize"

void                user_function                      (GtkStyle *style,
                                                        gpointer  user_data)      : Run First

Est émis quand l'aspect d'un style spécifique pour une carte de couleur particulière a été "nettoyé". Une connection à ce signal peut être utile si un widget veut mettre en cache des objet de type GdkGC comme les données d'un objet sur GtkStyle. Ce signal fournit une place pratique pour libérer de tels objets mis en cache.

`style` :	l'objet qui reçoit le signal
`user_data` :	données utilisateur définies quand le gestionnaire de signal (handler) a été connecté.

Depuis 2.4

			GTK+ Traduction Française du Manuel de référence
Haut de page \| Description \| Hiérarchie de l'Objet \| Signaux