GTK_STYLE_ATTACHED()

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

Returns whether the style is attached to a window.

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.

gtk_style_copy ()

GtkStyle*   gtk_style_copy                  (GtkStyle *style);

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.

gtk_style_detach ()

void        gtk_style_detach                (GtkStyle *style);

gtk_style_ref ()

GtkStyle*   gtk_style_ref                   (GtkStyle *style);

Deprecated equivalent of g_object_ref().

gtk_style_unref ()

void        gtk_style_unref                 (GtkStyle *style);

Deprecated equivalent of g_object_unref().

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.

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

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)

Deprecated alias for gtk_style_apply_default_background().

gtk_style_lookup_icon_set ()

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

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.

gtk_style_get_font ()

GdkFont*    gtk_style_get_font              (GtkStyle *style);

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.

gtk_style_set_font ()

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

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.

gtk_draw_hline ()

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

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

gtk_draw_vline ()

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

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

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

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

gtk_draw_polygon ()

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

Draws a polygon on window with the given parameters.

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

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

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

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

gtk_draw_string ()

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

Draws a text string on window with the given parameters.

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

Draws a box on window with the given parameters.

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

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

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

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

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

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

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

Draws a flat box on window with the given parameters.

gtk_draw_focus ()

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

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

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

Draws a handle as used in GtkHandleBox and GtkPaned.

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

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

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

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

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

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

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

gtk_draw_expander ()

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

Draws an expander as used in GtkTreeView.

gtk_draw_layout ()

void        gtk_draw_layout                 (GtkStyle *style,
                                             GdkWindow *window,
                                             GtkStateType state_type,
                                             gboolean use_text,
                                             gint x,
                                             gint y,
                                             PangoLayout *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);

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

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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

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

Draws a text string on window with the given parameters.

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.

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.

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.

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

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.

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.

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.

gtk_border_free ()

void        gtk_border_free                 (GtkBorder *border_);

Frees a GtkBorder structure.

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

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.

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.

Since 2.4