<< Back to man.ChinaUnix.net

<< Back to man.ChinaUnix.net

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

Signal Prototypes


"realize"   void        user_function      (GtkStyle *style,
                                            gpointer user_data);
"unrealize" void        user_function      (GtkStyle *style,
                                            gpointer user_data);

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.

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

style :

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_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
widget : the widget
detail : a style detail
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
widget : the widget
detail : a style detail
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
widget : the widget
detail : a style detail
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
widget : the widget
detail : a style detail
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
widget : the widget
detail : a style detail
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
widget : the widget
detail : a style detail
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
widget : the widget
detail : a style detail
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
widget : the widget
detail : a style detail
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
widget : the widget
detail : a style detail
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
widget : the widget
detail : a style detail
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
widget : the widget
detail : a style detail
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
widget : the widget
detail : a style detail
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
widget : the widget
detail : a style detail
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
widget : the widget
detail : a style detail
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);

style :
window :
state_type :
shadow_type :
area :
widget :
detail :
x :
y :
width :
height :
orientation :

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
widget : the widget
detail : a style detail
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
widget : the widget
detail : a style detail
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
widget : the widget
detail : a style detail
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.

style : a GtkStyle
window : a GdkWindow
state_type : a state
area : clip rectangle
widget : the widget
detail : a style detail
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_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);

style :
window :
state_type :
use_text :
area :
widget :
detail :
x :
y :
layout :

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
widget : the widget
detail : a style detail
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 :

Signals

The "realize" signal

void        user_function                  (GtkStyle *style,
                                            gpointer user_data);

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

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