## Styles Styles — Functions for drawing widget parts |

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

## Object Hierarchy

      GObject
       +----GtkStyle

## Signals

    "realize"   void        user_function      (GtkStyle *style,
                                                gpointer  user_data)      : Run first
    "unrealize" void        user_function      (GtkStyle *style,
                                                gpointer  user_data)      : Run first

## Description

## Details

### GTK_STYLE_ATTACHED()

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

Returns whether the style is attached to a window.

`style` : | a 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];		/* Halfway between text/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);

Creates a new GtkStyle.

Returns : | a new GtkStyle.

### gtk_style_copy ()

    GtkStyle*   gtk_style_copy                  (GtkStyle *style);

`style` : |
Returns : |

### gtk_style_attach ()

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

Attaches a style to a window; this process allocates the colors and creates the GC's for the style - it specializes it to a particular visual and colormap. The process may involve the creation of a new style if the style has already been attached to a window with a different style and colormap.

Since this function may return a new object, you have to use it in the following way: `style = gtk_style_attach (style, window)`

`style` : | a GtkStyle.
`window` : | a GdkWindow.
Returns : | Either `style`, or a newly-created GtkStyle. If the style is newly created, the style parameter will be dereferenced, and the new style will have a reference count belonging to the caller.

### gtk_style_detach ()

    void        gtk_style_detach                (GtkStyle *style);

Detaches a style from a window. If the style is not attached to any windows anymore, it is unrealized. See `gtk_style_attach()`.

`style` : | a GtkStyle

### gtk_style_ref ()

    GtkStyle*   gtk_style_ref                   (GtkStyle *style);

### Warning

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

Deprecated equivalent of `g_object_ref()`.

`style` : | a GtkStyle.
Returns : | `style`.

### gtk_style_unref ()

    void        gtk_style_unref                 (GtkStyle *style);

### Warning

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

Deprecated equivalent of `g_object_unref()`.

`style` : | a GtkStyle.

### gtk_style_set_background ()

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

Sets the background of `window` to the background color or pixmap specified by `style` for the given state.

`style` : | a GtkStyle
`window` : | a GdkWindow
`state_type` : | a state

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

### Warning

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

Deprecated alias for `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);

Looks up `color_name` in the style's logical color mappings, filling in `color` and returning `TRUE` if found, otherwise returning `FALSE`. Do not cache the found mapping, because it depends on the GtkStyle and might change when a theme switch occurs.

`style` : | a GtkStyle
`color_name` : | the name of the logical color to look up
`color` : | the GdkColor to fill in
Returns : | `TRUE` if the mapping was found.

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

Renders the icon specified by `source` at the given `size` according to the given parameters and returns the result in a pixbuf.

`style` : | a GtkStyle
`source` : | the GtkIconSource specifying the icon to render
`direction` : | a text direction
`state` : | a state
`size` : | the size to render the icon at. A size of (GtkIconSize)-1 means render at the size of the source and don't scale.
`widget` : | the widget
`detail` : | a style detail
Returns : | a newly-created GdkPixbuf containing the rendered icon

### gtk_style_get_font ()

    GdkFont*    gtk_style_get_font              (GtkStyle *style);

### Warning

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

Gets the GdkFont to use for the given style. This is meant only as a replacement for direct access to `style->font` and should not be used in new code. New code should use `style->font_desc` instead.

`style` : | a GtkStyle
Returns : | the GdkFont for the style. This font is owned by the style; if you want to keep around a copy, you must call `gdk_font_ref()`.

### gtk_style_set_font ()

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

### Warning

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

Sets the GdkFont to use for a given style. This is meant only as a replacement for direct access to style->font and should not be used in new code. New code should use style->font_desc instead.

`style` : | a GtkStyle.
`font` : | a GdkFont, or `NULL` to use the GdkFont corresponding to style->font_desc.

### gtk_draw_hline ()

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

### Warning

`gtk_draw_hline` is deprecated and should not be used in newly-written code. Use `gtk_paint_hline()` instead.

Draws a horizontal line from (`x1`, `y`) to (`x2`, `y`) in `window` using the given style and state.

`style` : | a GtkStyle
`window` : | a GdkWindow
`state_type` : | a state
`x1` : | the starting x coordinate
`x2` : | the ending x coordinate
`y` : | the y coordinate

### gtk_draw_vline ()

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

### Warning

`gtk_draw_vline` is deprecated and should not be used in newly-written code. Use `gtk_paint_vline()` instead.

Draws a vertical line from (`x`, `y1_`) to (`x`, `y2_`) in `window` using the given style and state.

`style` : | a GtkStyle
`window` : | a GdkWindow
`state_type` : | a state
`y1_` : | the starting y coordinate
`y2_` : | the ending y coordinate
`x` : | the x coordinate

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

### Warning

`gtk_draw_shadow` is deprecated and should not be used in newly-written code. Use `gtk_paint_shadow()` instead.

Draws a shadow around the given rectangle in `window` using the given style and state and shadow type.

`style` : | a GtkStyle
`window` : | a GdkWindow
`state_type` : | a state
`shadow_type` : | type of shadow to draw
`x` : | x origin of the rectangle
`y` : | y origin of the rectangle
`width` : | width of the rectangle
`height` : | width of the rectangle

### gtk_draw_polygon ()

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

### Warning

`gtk_draw_polygon` is deprecated and should not be used in newly-written code. Use `gtk_paint_polygon()` instead.

Draws a polygon on `window` with the given parameters.

`style` : | a GtkStyle
`window` : | a GdkWindow
`state_type` : | a state
`shadow_type` : | type of shadow to draw
`points` : | an array of GdkPoints
`npoints` : | length of `points`
`fill` : | `TRUE` if the polygon should be filled

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

### Warning

`gtk_draw_arrow` is deprecated and should not be used in newly-written code. Use `gtk_paint_arrow()` instead.

Draws an arrow in the given rectangle on `window` using the given parameters. `arrow_type` determines the direction of the arrow.

`style` : | a GtkStyle
`window` : | a GdkWindow
`state_type` : | a state
`shadow_type` : | the type of shadow to draw
`arrow_type` : | the type of arrow to draw
`fill` : | `TRUE` if the arrow tip should be filled
`x` : | x origin of the rectangle to draw the arrow in
`y` : | y origin of the rectangle to draw the arrow in
`width` : | width of the rectangle to draw the arrow in
`height` : | height of the rectangle to draw the arrow in

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

### Warning

`gtk_draw_diamond` is deprecated and should not be used in newly-written code. Use `gtk_paint_diamond()` instead.

Draws a diamond in the given rectangle on `window` using the given parameters.

`style` : | a GtkStyle
`window` : | a GdkWindow
`state_type` : | a state
`shadow_type` : | the type of shadow to draw
`x` : | x origin of the rectangle to draw the diamond in
`y` : | y origin of the rectangle to draw the diamond in
`width` : | width of the rectangle to draw the diamond in
`height` : | height of the rectangle to draw the diamond in

### 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` is deprecated and should not be used in newly-written code. Use `gtk_paint_layout()` instead.

Draws a text string on `window` with the given parameters.

`style` : | a GtkStyle
`window` : | a GdkWindow
`state_type` : | a state
`x` : | x origin
`y` : | y origin
`string` : | the string to draw

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

### Warning

`gtk_draw_box` is deprecated and should not be used in newly-written code. Use `gtk_paint_box()` instead.

Draws a box on `window` with the given parameters.

`style` : | a GtkStyle
`window` : | a GdkWindow
`state_type` : | a state
`shadow_type` : | the type of shadow to draw
`x` : | x origin of the box
`y` : | y origin of the box
`width` : | the width of the box
`height` : | the height of the box

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

### Warning

`gtk_draw_box_gap` is deprecated and should not be used in newly-written code. Use `gtk_paint_box_gap()` instead.

Draws a box in `window` using the given style and state and shadow type, leaving a gap in one side.

`style` : | a GtkStyle
`window` : | a GdkWindow
`state_type` : | a state
`shadow_type` : | type of shadow to draw
`x` : | x origin of the rectangle
`y` : | y origin of the rectangle
`width` : | width of the rectangle
`height` : | width of the rectangle
`gap_side` : | side in which to leave the gap
`gap_x` : | starting position of the gap
`gap_width` : | width of the gap

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

### Warning

`gtk_draw_check` is deprecated and should not be used in newly-written code. Use `gtk_paint_check()` instead.

Draws a check button indicator in the given rectangle on `window` with the given parameters.

`style` : | a GtkStyle
`window` : | a GdkWindow
`state_type` : | a state
`shadow_type` : | the type of shadow to draw
`x` : | x origin of the rectangle to draw the check in
`y` : | y origin of the rectangle to draw the check in
`width` : | the width of the rectangle to draw the check in
`height` : | the height of the rectangle to draw the check in

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

### Warning

`gtk_draw_extension` is deprecated and should not be used in newly-written code. Use `gtk_paint_extension()` instead.

Draws an extension, i.e. a notebook tab.

`style` : | a GtkStyle
`window` : | a GdkWindow
`state_type` : | a state
`shadow_type` : | type of shadow to draw
`x` : | x origin of the extension
`y` : | y origin of the extension
`width` : | width of the extension
`height` : | width of the extension
`gap_side` : | the side on to which the extension is attached

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

### Warning

`gtk_draw_flat_box` is deprecated and should not be used in newly-written code. Use `gtk_paint_flat_box()` instead.

Draws a flat box on `window` with the given parameters.

`style` : | a GtkStyle
`window` : | a GdkWindow
`state_type` : | a state
`shadow_type` : | the type of shadow to draw
`x` : | x origin of the box
`y` : | y origin of the box
`width` : | the width of the box
`height` : | the height of the box

### gtk_draw_focus ()

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

### Warning

`gtk_draw_focus` is deprecated and should not be used in newly-written code. Use `gtk_paint_focus()` instead.

Draws a focus indicator around the given rectangle on `window` using the given style.

`style` : | a GtkStyle
`window` : | a GdkWindow
`x` : | the x origin of the rectangle around which to draw a focus indicator
`y` : | the y origin of the rectangle around which to draw a focus indicator
`width` : | the width of the rectangle around which to draw a focus indicator
`height` : | the height of the rectangle around which to draw a focus indicator

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

### Warning

`gtk_draw_handle` is deprecated and should not be used in newly-written code. Use `gtk_paint_handle()` instead.

Draws a handle as used in GtkHandleBox and GtkPaned.

`style` : | a GtkStyle
`window` : | a GdkWindow
`state_type` : | a state
`shadow_type` : | type of shadow to draw
`x` : | x origin of the handle
`y` : | y origin of the handle
`width` : | with of the handle
`height` : | height of the handle
`orientation` : | the orientation of the handle

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

### Warning

`gtk_draw_option` is deprecated and should not be used in newly-written code. Use `gtk_paint_option()` instead.

Draws a radio button indicator in the given rectangle on `window` with the given parameters.

`style` : | a GtkStyle
`window` : | a GdkWindow
`state_type` : | a state
`shadow_type` : | the type of shadow to draw
`x` : | x origin of the rectangle to draw the option in
`y` : | y origin of the rectangle to draw the option in
`width` : | the width of the rectangle to draw the option in
`height` : | the height of the rectangle to draw the option in

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

### Warning

`gtk_draw_shadow_gap` is deprecated and should not be used in newly-written code. Use `gtk_paint_shadow_gap()` instead.

Draws a shadow around the given rectangle in `window` using the given style and state and shadow type, leaving a gap in one side.

`style` : | a GtkStyle
`window` : | a GdkWindow
`state_type` : | a state
`shadow_type` : | type of shadow to draw
`x` : | x origin of the rectangle
`y` : | y origin of the rectangle
`width` : | width of the rectangle
`height` : | width of the rectangle
`gap_side` : | side in which to leave the gap
`gap_x` : | starting position of the gap
`gap_width` : | width of the gap

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

### Warning

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

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

### Warning

`gtk_draw_tab` is deprecated and should not be used in newly-written code. Use `gtk_paint_tab()` instead.

Draws an option menu tab (i.e. the up and down pointing arrows) in the given rectangle on `window` using the given parameters.

`style` : | a GtkStyle
`window` : | a GdkWindow
`state_type` : | a state
`shadow_type` : | the type of shadow to draw
`x` : | x origin of the rectangle to draw the tab in
`y` : | y origin of the rectangle to draw the tab in
`width` : | the width of the rectangle to draw the tab in
`height` : | the height of the rectangle to draw the tab in

### gtk_draw_expander ()

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

### Warning

`gtk_draw_expander` is deprecated and should not be used in newly-written code. Use `gtk_paint_expander()` instead.

Draws an expander as used in GtkTreeView.

`style` : | a GtkStyle
`window` : | a GdkWindow
`state_type` : | a state
`x` : | the x position to draw the expander at
`y` : | the y position to draw the expander at
`expander_style` : | the style to draw the expander in

### gtk_draw_layout ()

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

### Warning

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

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

### Warning

`gtk_draw_resize_grip` is deprecated and should not be used in newly-written code. Use `gtk_paint_resize_grip()` instead.

Draws a resize grip in the given rectangle on `window` using the given parameters.

`style` : | a GtkStyle
`window` : | a GdkWindow
`state_type` : | a state
`edge` : | the edge in which to draw the resize grip
`x` : | the x origin of the rectangle in which to draw the resize grip
`y` : | the y origin of the rectangle in which to draw the resize grip
`width` : | the width of the rectangle in which to draw the resize grip
`height` : | the height 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);

Draws an arrow in the given rectangle on `window` using the given parameters. `arrow_type` determines the direction of the arrow.

`style` : | a GtkStyle
`window` : | a GdkWindow
`state_type` : | a state
`shadow_type` : | the type of shadow to draw
`area` : | clip rectangle, or `NULL` if the output should not be clipped
`widget` : | the widget (may be `NULL`)
`detail` : | a style detail (may be `NULL`)
`arrow_type` : | the type of arrow to draw
`fill` : | `TRUE` if the arrow tip should be filled
`x` : | x origin of the rectangle to draw the arrow in
`y` : | y origin of the rectangle to draw the arrow in
`width` : | width of the rectangle to draw the arrow in
`height` : | height of the rectangle to draw the arrow in

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

Draws a box on `window` with the given parameters.

`style` : | a GtkStyle
`window` : | a GdkWindow
`state_type` : | a state
`shadow_type` : | the type of shadow to draw
`area` : | clip rectangle, or `NULL` if the output should not be clipped
`widget` : | the widget (may be `NULL`)
`detail` : | a style detail (may be `NULL`)
`x` : | x origin of the box
`y` : | y origin of the box
`width` : | the width of the box
`height` : | the height of the box

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

Draws a box in `window` using the given style and state and shadow type, leaving a gap in one side.

`style` : | a GtkStyle
`window` : | a GdkWindow
`state_type` : | a state
`shadow_type` : | type of shadow to draw
`area` : | clip rectangle, or `NULL` if the output should not be clipped
`widget` : | the widget (may be `NULL`)
`detail` : | a style detail (may be `NULL`)
`x` : | x origin of the rectangle
`y` : | y origin of the rectangle
`width` : | width of the rectangle
`height` : | width of the rectangle
`gap_side` : | side in which to leave the gap
`gap_x` : | starting position of the gap
`gap_width` : | width of the gap

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

Draws a check button indicator in the given rectangle on `window` with the given parameters.

`style` : | a GtkStyle
`window` : | a GdkWindow
`state_type` : | a state
`shadow_type` : | the type of shadow to draw
`area` : | clip rectangle, or `NULL` if the output should not be clipped
`widget` : | the widget (may be `NULL`)
`detail` : | a style detail (may be `NULL`)
`x` : | x origin of the rectangle to draw the check in
`y` : | y origin of the rectangle to draw the check in
`width` : | the width of the rectangle to draw the check in
`height` : | the height of the rectangle to draw the check in

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

Draws a diamond in the given rectangle on `window` using the given parameters.

`style` : | a GtkStyle
`window` : | a GdkWindow
`state_type` : | a state
`shadow_type` : | the type of shadow to draw
`area` : | clip rectangle, or `NULL` if the output should not be clipped
`widget` : | the widget (may be `NULL`)
`detail` : | a style detail (may be `NULL`)
`x` : | x origin of the rectangle to draw the diamond in
`y` : | y origin of the rectangle to draw the diamond in
`width` : | width of the rectangle to draw the diamond in
`height` : | height of the rectangle to draw the diamond in

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

Draws an extension, i.e. a notebook tab.

`style` : | a GtkStyle
`window` : | a GdkWindow
`state_type` : | a state
`shadow_type` : | type of shadow to draw
`area` : | clip rectangle, or `NULL` if the output should not be clipped
`widget` : | the widget (may be `NULL`)
`detail` : | a style detail (may be `NULL`)
`x` : | x origin of the extension
`y` : | y origin of the extension
`width` : | width of the extension
`height` : | width of the extension
`gap_side` : | the side on to which the extension is attached

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

Draws a flat box on `window` with the given parameters.

`style` : | a GtkStyle
`window` : | a GdkWindow
`state_type` : | a state
`shadow_type` : | the type of shadow to draw
`area` : | clip rectangle, or `NULL` if the output should not be clipped
`widget` : | the widget (may be `NULL`)
`detail` : | a style detail (may be `NULL`)
`x` : | x origin of the box
`y` : | y origin of the box
`width` : | the width of the box
`height` : | the height of the box

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

Draws a focus indicator around the given rectangle on `window` using the given style.

`style` : | a GtkStyle
`window` : | a GdkWindow
`state_type` : | a state
`area` : | clip rectangle, or `NULL` if the output should not be clipped
`widget` : | the widget (may be `NULL`)
`detail` : | a style detail (may be `NULL`)
`x` : | the x origin of the rectangle around which to draw a focus indicator
`y` : | the y origin of the rectangle around which to draw a focus indicator
`width` : | the width of the rectangle around which to draw a focus indicator
`height` : | the height of the rectangle around which to draw a focus indicator

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

Draws a handle as used in GtkHandleBox and GtkPaned.

`style` : | a GtkStyle
`window` : | a GdkWindow
`state_type` : | a state
`shadow_type` : | type of shadow to draw
`area` : | clip rectangle, or `NULL` if the output should not be clipped
`widget` : | the widget (may be `NULL`)
`detail` : | a style detail (may be `NULL`)
`x` : | x origin of the handle
`y` : | y origin of the handle
`width` : | with of the handle
`height` : | height of the handle
`orientation` : | the orientation of the handle

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

Draws a horizontal line from (`x1`, `y`) to (`x2`, `y`) in `window` using the given style and state.

`style` : | a GtkStyle
`window` : | a GdkWindow
`state_type` : | a state
`area` : | rectangle to which the output is clipped, or `NULL` if the output should not be clipped
`widget` : | the widget (may be `NULL`)
`detail` : | a style detail (may be `NULL`)
`x1` : | the starting x coordinate
`x2` : | the ending x coordinate
`y` : | the y coordinate

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

Draws a radio button indicator in the given rectangle on `window` with the given parameters.

`style` : | a GtkStyle
`window` : | a GdkWindow
`state_type` : | a state
`shadow_type` : | the type of shadow to draw
`area` : | clip rectangle, or `NULL` if the output should not be clipped
`widget` : | the widget (may be `NULL`)
`detail` : | a style detail (may be `NULL`)
`x` : | x origin of the rectangle to draw the option in
`y` : | y origin of the rectangle to draw the option in
`width` : | the width of the rectangle to draw the option in
`height` : | the height of the rectangle to draw the option in

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

Draws a polygon on `window` with the given parameters.

`style` : | a GtkStyle
`window` : | a GdkWindow
`state_type` : | a state
`shadow_type` : | type of shadow to draw
`area` : | clip rectangle, or `NULL` if the output should not be clipped
`widget` : | the widget (may be `NULL`)
`detail` : | a style detail (may be `NULL`)
`points` : | an array of GdkPoints
`npoints` : | length of `points`
`fill` : | `TRUE` if the polygon should be filled

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

Draws a shadow around the given rectangle in `window` using the given style and state and shadow type.

`style` : | a GtkStyle
`window` : | a GdkWindow
`state_type` : | a state
`shadow_type` : | type of shadow to draw
`area` : | clip rectangle or `NULL` if the output should not be clipped
`widget` : | the widget (may be `NULL`)
`detail` : | a style detail (may be `NULL`)
`x` : | x origin of the rectangle
`y` : | y origin of the rectangle
`width` : | width of the rectangle
`height` : | width of the rectangle

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

Draws a shadow around the given rectangle in `window` using the given style and state and shadow type, leaving a gap in one side.

`style` : | a GtkStyle
`window` : | a GdkWindow
`state_type` : | a state
`shadow_type` : | type of shadow to draw
`area` : | clip rectangle, or `NULL` if the output should not be clipped
`widget` : | the widget (may be `NULL`)
`detail` : | a style detail (may be `NULL`)
`x` : | x origin of the rectangle
`y` : | y origin of the rectangle
`width` : | width of the rectangle
`height` : | width of the rectangle
`gap_side` : | side in which to leave the gap
`gap_x` : | starting position of the gap
`gap_width` : | width of the gap

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

Draws a slider in the given rectangle on `window` using the given style and orientation.

`style` : | a GtkStyle
`window` : | a GdkWindow
`state_type` : | a state
`shadow_type` : | a shadow
`area` : | clip rectangle, or `NULL` if the output should not be clipped
`widget` : | the widget (may be `NULL`)
`detail` : | a style detail (may be `NULL`)
`x` : | the x origin of the rectangle in which to draw a slider
`y` : | the y origin of the rectangle in which to draw a slider
`width` : | the width of the rectangle in which to draw a slider
`height` : | the height of the rectangle in which to draw a slider
`orientation` : | the orientation to be used

### 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,
                                                 const gchar *string);

### Warning

`gtk_paint_string` is deprecated and should not be used in newly-written code. Use `gtk_paint_layout()` instead.

Draws a text string on `window` with the given parameters.

`style` : | a GtkStyle
`window` : | a GdkWindow
`state_type` : | a state
`area` : | clip rectangle, or `NULL` if the output should not be clipped
`widget` : | the widget (may be `NULL`)
`detail` : | a style detail (may be `NULL`)
`x` : | x origin
`y` : | y origin
`string` : | the string to draw

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

Draws an option menu tab (i.e. the up and down pointing arrows) in the given rectangle on `window` using the given parameters.

`style` : | a GtkStyle
`window` : | a GdkWindow
`state_type` : | a state
`shadow_type` : | the type of shadow to draw
`area` : | clip rectangle, or `NULL` if the output should not be clipped
`widget` : | the widget (may be `NULL`)
`detail` : | a style detail (may be `NULL`)
`x` : | x origin of the rectangle to draw the tab in
`y` : | y origin of the rectangle to draw the tab in
`width` : | the width of the rectangle to draw the tab in
`height` : | the height of the rectangle to draw the tab in

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

Draws a vertical line from (`x`, `y1_`) to (`x`, `y2_`) in `window` using the given style and state.

`style` : | a GtkStyle
`window` : | a GdkWindow
`state_type` : | a state
`area` : | rectangle to which the output is clipped, or `NULL` if the output should not be clipped
`widget` : | the widget (may be `NULL`)
`detail` : | a style detail (may be `NULL`)
`y1_` : | the starting y coordinate
`y2_` : | the ending y coordinate
`x` : | the x coordinate

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

Draws an expander as used in GtkTreeView. `x` and `y` specify the center the expander. The size of the expander is determined by the "expander-size" style property of `widget`. (If widget is not specified or doesn't have an "expander-size" property, an unspecified default size will be used, since the caller doesn't have sufficient information to position the expander, this is likely not useful.) The expander is expander_size pixels tall in the collapsed position and expander_size pixels wide in the expanded position.

`style` : | a GtkStyle
`window` : | a GdkWindow
`state_type` : | a state
`area` : | clip rectangle, or `NULL` if the output should not be clipped
`widget` : | the widget (may be `NULL`)
`detail` : | a style detail (may be `NULL`)
`x` : | the x position to draw the expander at
`y` : | the y position to draw the expander at
`expander_style` : | the style to draw the expander in; determines whether the expander is collapsed, expanded, or in an intermediate state.

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

Draws a layout on `window` using the given parameters.

`style` : | a GtkStyle
`window` : | a GdkWindow
`state_type` : | a state
`use_text` : | whether to use the text or foreground graphics context of `style`
`area` : | clip rectangle, or `NULL` if the output should not be clipped
`widget` : | the widget (may be `NULL`)
`detail` : | a style detail (may be `NULL`)
`x` : | x origin
`y` : | y origin
`layout` : | the layout to draw

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

Draws a resize grip in the given rectangle on `window` using the given parameters.

`style` : | a GtkStyle
`window` : | a GdkWindow
`state_type` : | a state
`area` : | clip rectangle, or `NULL` if the output should not be clipped
`widget` : | the widget (may be `NULL`)
`detail` : | a style detail (may be `NULL`)
`edge` : | the edge in which to draw the resize grip
`x` : | the x origin of the rectangle in which to draw the resize grip
`y` : | the y origin of the rectangle in which to draw the resize grip
`width` : | the width of the rectangle in which to draw the resize grip
`height` : | the height of the rectangle in which to draw the resize grip

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

Draws a text caret on `drawable` at `location`. This is not a style function but merely a convenience function for drawing the standard cursor shape.

`widget` : | a GtkWidget
`drawable` : | a GdkDrawable
`area` : | rectangle to which the output is clipped, or `NULL` if the output should not be clipped
`location` : | location where to draw the cursor (`location->width` is ignored)
`is_primary` : | if the cursor should be the primary cursor color.
`direction` : | whether the cursor is left-to-right or right-to-left. Should never be GTK_TEXT_DIR_NONE
`draw_arrow` : | `TRUE` to draw a directional arrow on the cursor. Should be `FALSE` unless the cursor is split.

Since 2.4

### GtkBorder

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

### gtk_border_copy ()

    GtkBorder*  gtk_border_copy                 (const GtkBorder *border_);

Copies a GtkBorder structure.

`border_` : | a GtkBorder.
Returns : | a copy of `border_`.

### gtk_border_free ()

    void        gtk_border_free                 (GtkBorder *border_);

Frees a GtkBorder structure.

`border_` : | a 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` : |
Returns : |

## Signal Details

### The "realize" signal

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

Emitted when the style has been initialized for a particular colormap and depth. Connecting to this signal is probably seldom useful since most of the time applications and widgets only deal with styles that have been already realized.

`style` : | the object which received the signal
`user_data` : | user data set when the signal handler was connected.

Since 2.4

### The "unrealize" signal

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

Emitted when the aspects of the style specific to a particular colormap and depth are being cleaned up. A connection to this signal can be useful if a widget wants to cache objects like a GdkGC as object data on GtkStyle. This signal provides a convenient place to free such cached objects.

`style` : | the object which received the signal
`user_data` : | user data set when the signal handler was connected.

Since 2.4