GTK_STYLE_ATTACHED()

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

Returns whether the style is attached to a window.

gtk_style_new ()

GtkStyle *
gtk_style_new (void);

Creates a new GtkStyle.

gtk_style_copy ()

GtkStyle *
gtk_style_copy (GtkStyle *style);

Creates a copy of the passed in GtkStyle object.

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. 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 visual.

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

gtk_style_detach ()

void
gtk_style_detach (GtkStyle *style);

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

gtk_style_has_context ()

gboolean
gtk_style_has_context (GtkStyle *style);

Returns whether style has an associated GtkStyleContext.

Since 3.0

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,
                                    cairo_t *cr,
                                    GdkWindow *window,
                                    GtkStateType state_type,
                                    gint x,
                                    gint y,
                                    gint width,
                                    gint height);

gtk_style_lookup_color ()

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

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

Since 2.10

gtk_style_lookup_icon_set ()

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

Looks up stock_id in the icon factories associated with style and the default icon factory, returning an icon set if found, otherwise NULL.

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

void
gtk_style_get_style_property (GtkStyle *style,
                              GType widget_type,
                              const gchar *property_name,
                              GValue *value);

Queries the value of a style property corresponding to a widget class is in the given style.

Since 2.16

gtk_style_get_valist ()

void
gtk_style_get_valist (GtkStyle *style,
                      GType widget_type,
                      const gchar *first_property_name,
                      va_list var_args);

Non-vararg variant of gtk_style_get(). Used primarily by language bindings.

Since 2.16

gtk_style_get ()

void
gtk_style_get (GtkStyle *style,
               GType widget_type,
               const gchar *first_property_name,
               ...);

Gets the values of a multiple style properties for widget_type from style .

Since 2.16

gtk_paint_arrow ()

void
gtk_paint_arrow (GtkStyle *style,
                 cairo_t *cr,
                 GtkStateType state_type,
                 GtkShadowType shadow_type,
                 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 cr using the given parameters. arrow_type determines the direction of the arrow.

gtk_paint_box ()

void
gtk_paint_box (GtkStyle *style,
               cairo_t *cr,
               GtkStateType state_type,
               GtkShadowType shadow_type,
               GtkWidget *widget,
               const gchar *detail,
               gint x,
               gint y,
               gint width,
               gint height);

Draws a box on cr with the given parameters.

gtk_paint_box_gap ()

void
gtk_paint_box_gap (GtkStyle *style,
                   cairo_t *cr,
                   GtkStateType state_type,
                   GtkShadowType shadow_type,
                   GtkWidget *widget,
                   const gchar *detail,
                   gint x,
                   gint y,
                   gint width,
                   gint height,
                   GtkPositionType gap_side,
                   gint gap_x,
                   gint gap_width);

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

gtk_paint_check ()

void
gtk_paint_check (GtkStyle *style,
                 cairo_t *cr,
                 GtkStateType state_type,
                 GtkShadowType shadow_type,
                 GtkWidget *widget,
                 const gchar *detail,
                 gint x,
                 gint y,
                 gint width,
                 gint height);

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

gtk_paint_diamond ()

void
gtk_paint_diamond (GtkStyle *style,
                   cairo_t *cr,
                   GtkStateType state_type,
                   GtkShadowType shadow_type,
                   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,
                     cairo_t *cr,
                     GtkStateType state_type,
                     GtkShadowType shadow_type,
                     GtkWidget *widget,
                     const 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,
                    cairo_t *cr,
                    GtkStateType state_type,
                    GtkShadowType shadow_type,
                    GtkWidget *widget,
                    const gchar *detail,
                    gint x,
                    gint y,
                    gint width,
                    gint height);

Draws a flat box on cr with the given parameters.

gtk_paint_focus ()

void
gtk_paint_focus (GtkStyle *style,
                 cairo_t *cr,
                 GtkStateType state_type,
                 GtkWidget *widget,
                 const gchar *detail,
                 gint x,
                 gint y,
                 gint width,
                 gint height);

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

gtk_paint_handle ()

void
gtk_paint_handle (GtkStyle *style,
                  cairo_t *cr,
                  GtkStateType state_type,
                  GtkShadowType shadow_type,
                  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,
                 cairo_t *cr,
                 GtkStateType state_type,
                 GtkWidget *widget,
                 const gchar *detail,
                 gint x1,
                 gint x2,
                 gint y);

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

gtk_paint_option ()

void
gtk_paint_option (GtkStyle *style,
                  cairo_t *cr,
                  GtkStateType state_type,
                  GtkShadowType shadow_type,
                  GtkWidget *widget,
                  const gchar *detail,
                  gint x,
                  gint y,
                  gint width,
                  gint height);

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

gtk_paint_shadow ()

void
gtk_paint_shadow (GtkStyle *style,
                  cairo_t *cr,
                  GtkStateType state_type,
                  GtkShadowType shadow_type,
                  GtkWidget *widget,
                  const gchar *detail,
                  gint x,
                  gint y,
                  gint width,
                  gint height);

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

gtk_paint_shadow_gap ()

void
gtk_paint_shadow_gap (GtkStyle *style,
                      cairo_t *cr,
                      GtkStateType state_type,
                      GtkShadowType shadow_type,
                      GtkWidget *widget,
                      const 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 cr using the given style and state and shadow type, leaving a gap in one side.

gtk_paint_slider ()

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

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

gtk_paint_spinner ()

void
gtk_paint_spinner (GtkStyle *style,
                   cairo_t *cr,
                   GtkStateType state_type,
                   GtkWidget *widget,
                   const gchar *detail,
                   guint step,
                   gint x,
                   gint y,
                   gint width,
                   gint height);

Draws a spinner on window using the given parameters.

gtk_paint_tab ()

void
gtk_paint_tab (GtkStyle *style,
               cairo_t *cr,
               GtkStateType state_type,
               GtkShadowType shadow_type,
               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 cr using the given parameters.

gtk_paint_vline ()

void
gtk_paint_vline (GtkStyle *style,
                 cairo_t *cr,
                 GtkStateType state_type,
                 GtkWidget *widget,
                 const gchar *detail,
                 gint y1_,
                 gint y2_,
                 gint x);

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

gtk_paint_expander ()

void
gtk_paint_expander (GtkStyle *style,
                    cairo_t *cr,
                    GtkStateType state_type,
                    GtkWidget *widget,
                    const gchar *detail,
                    gint x,
                    gint y,
                    GtkExpanderStyle expander_style);

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

gtk_paint_layout ()

void
gtk_paint_layout (GtkStyle *style,
                  cairo_t *cr,
                  GtkStateType state_type,
                  gboolean use_text,
                  GtkWidget *widget,
                  const gchar *detail,
                  gint x,
                  gint y,
                  PangoLayout *layout);

Draws a layout on cr using the given parameters.

gtk_paint_resize_grip ()

void
gtk_paint_resize_grip (GtkStyle *style,
                       cairo_t *cr,
                       GtkStateType state_type,
                       GtkWidget *widget,
                       const gchar *detail,
                       GdkWindowEdge edge,
                       gint x,
                       gint y,
                       gint width,
                       gint height);

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

gtk_draw_insertion_cursor ()

void
gtk_draw_insertion_cursor (GtkWidget *widget,
                           cairo_t *cr,
                           const GdkRectangle *location,
                           gboolean is_primary,
                           GtkTextDirection direction,
                           gboolean draw_arrow);

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

Since 3.0

GtkRcPropertyParser ()

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

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;

  cairo_pattern_t *background[5];
} GtkStyle;

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;

The “context” property

  “context”                  GtkStyleContext *

GtkStyleContext to get style from.

Flags: Read / Write / Construct Only

The “realize” signal

void
user_function (GtkStyle *style,
               gpointer  user_data)

Emitted when the style has been initialized for a particular visual. 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.

Flags: Run First

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 visual is being cleaned up. A connection to this signal can be useful if a widget wants to cache objects as object data on GtkStyle. This signal provides a convenient place to free such cached objects.

Flags: Run First

Since 2.4