Style Classes

Widgets can add style classes to their context, which can be used to associate different styles by class. The documentation for individual widgets lists which style classes it uses itself, and which style classes may be added by applications to affect their appearance.

GTK+ defines macros for a number of style classes.

Style Regions

Widgets can also add regions with flags to their context. This feature is deprecated and will be removed in a future GTK+ update. Please use style classes instead.

GTK+ defines macros for a number of style regions.

Custom styling in UI libraries and applications

If you are developing a library with custom GtkWidgets that render differently than standard components, you may need to add a GtkStyleProvider yourself with the GTK_STYLE_PROVIDER_PRIORITY_FALLBACK priority, either a GtkCssProvider or a custom object implementing the GtkStyleProvider interface. This way themes may still attempt to style your UI elements in a different way if needed so.

If you are using custom styling on an applications, you probably want then to make your style information prevail to the theme’s, so you must use a GtkStyleProvider with the GTK_STYLE_PROVIDER_PRIORITY_APPLICATION priority, keep in mind that the user settings in XDG_CONFIG_HOME/gtk-3.0/gtk.css will still take precedence over your changes, as it uses the GTK_STYLE_PROVIDER_PRIORITY_USER priority.

gtk_style_context_new ()

GtkStyleContext *
gtk_style_context_new (void);

Creates a standalone GtkStyleContext, this style context won’t be attached to any widget, so you may want to call gtk_style_context_set_path() yourself.

This function is only useful when using the theming layer separated from GTK+, if you are using GtkStyleContext to theme GtkWidgets, use gtk_widget_get_style_context() in order to get a style context ready to theme the widget.

gtk_style_context_add_provider ()

void
gtk_style_context_add_provider (GtkStyleContext *context,
                                GtkStyleProvider *provider,
                                guint priority);

Adds a style provider to context , to be used in style construction. Note that a style provider added by this function only affects the style of the widget to which context belongs. If you want to affect the style of all widgets, use gtk_style_context_add_provider_for_screen().

Note: If both priorities are the same, a GtkStyleProvider added through this function takes precedence over another added through gtk_style_context_add_provider_for_screen().

Since: 3.0

gtk_style_context_add_provider_for_screen ()

void
gtk_style_context_add_provider_for_screen
                               (GdkScreen *screen,
                                GtkStyleProvider *provider,
                                guint priority);

Adds a global style provider to screen , which will be used in style construction for all GtkStyleContexts under screen .

GTK+ uses this to make styling information from GtkSettings available.

Note: If both priorities are the same, A GtkStyleProvider added through gtk_style_context_add_provider() takes precedence over another added through this function.

Since: 3.0

gtk_style_context_get ()

void
gtk_style_context_get (GtkStyleContext *context,
                       GtkStateFlags state,
                       ...);

Retrieves several style property values from context for a given state.

See gtk_style_context_get_property() for details.

Since: 3.0

gtk_style_context_get_direction ()

GtkTextDirection
gtk_style_context_get_direction (GtkStyleContext *context);

Returns the widget direction used for rendering.

Since: 3.0

gtk_style_context_get_junction_sides ()

GtkJunctionSides
gtk_style_context_get_junction_sides (GtkStyleContext *context);

Returns the sides where rendered elements connect visually with others.

Since: 3.0

gtk_style_context_get_parent ()

GtkStyleContext *
gtk_style_context_get_parent (GtkStyleContext *context);

Gets the parent context set via gtk_style_context_set_parent(). See that function for details.

Since: 3.4

gtk_style_context_get_path ()

const GtkWidgetPath *
gtk_style_context_get_path (GtkStyleContext *context);

Returns the widget path used for style matching.

Since: 3.0

gtk_style_context_get_property ()

void
gtk_style_context_get_property (GtkStyleContext *context,
                                const gchar *property,
                                GtkStateFlags state,
                                GValue *value);

Gets a style property from context for the given state.

Note that not all CSS properties that are supported by GTK+ can be retrieved in this way, since they may not be representable as GValue. GTK+ defines macros for a number of properties that can be used with this function.

Note that passing a state other than the current state of context is not recommended unless the style context has been saved with gtk_style_context_save().

When value is no longer needed, g_value_unset() must be called to free any allocated memory.

Since: 3.0

gtk_style_context_get_screen ()

GdkScreen *
gtk_style_context_get_screen (GtkStyleContext *context);

Returns the GdkScreen to which context is attached.

gtk_style_context_get_frame_clock ()

GdkFrameClock *
gtk_style_context_get_frame_clock (GtkStyleContext *context);

Returns the GdkFrameClock to which context is attached.

Since: 3.8

gtk_style_context_get_state ()

GtkStateFlags
gtk_style_context_get_state (GtkStyleContext *context);

Returns the state used for style matching.

This method should only be used to retrieve the GtkStateFlags to pass to GtkStyleContext methods, like gtk_style_context_get_padding(). If you need to retrieve the current state of a GtkWidget, use gtk_widget_get_state_flags().

Since: 3.0

gtk_style_context_get_style ()

void
gtk_style_context_get_style (GtkStyleContext *context,
                             ...);

Retrieves several widget style properties from context according to the current style.

Since: 3.0

gtk_style_context_get_style_property ()

void
gtk_style_context_get_style_property (GtkStyleContext *context,
                                      const gchar *property_name,
                                      GValue *value);

Gets the value for a widget style property.

When value is no longer needed, g_value_unset() must be called to free any allocated memory.

gtk_style_context_get_style_valist ()

void
gtk_style_context_get_style_valist (GtkStyleContext *context,
                                    va_list args);

Retrieves several widget style properties from context according to the current style.

Since: 3.0

gtk_style_context_get_valist ()

void
gtk_style_context_get_valist (GtkStyleContext *context,
                              GtkStateFlags state,
                              va_list args);

Retrieves several style property values from context for a given state.

See gtk_style_context_get_property() for details.

Since: 3.0

gtk_style_context_get_section ()

GtkCssSection *
gtk_style_context_get_section (GtkStyleContext *context,
                               const gchar *property);

Queries the location in the CSS where property was defined for the current context . Note that the state to be queried is taken from gtk_style_context_get_state().

If the location is not available, NULL will be returned. The location might not be available for various reasons, such as the property being overridden, property not naming a supported CSS property or tracking of definitions being disabled for performance reasons.

Shorthand CSS properties cannot be queried for a location and will always return NULL.

gtk_style_context_get_color ()

void
gtk_style_context_get_color (GtkStyleContext *context,
                             GtkStateFlags state,
                             GdkRGBA *color);

Gets the foreground color for a given state.

See gtk_style_context_get_property() and GTK_STYLE_PROPERTY_COLOR for details.

Since: 3.0

gtk_style_context_get_background_color ()

void
gtk_style_context_get_background_color
                               (GtkStyleContext *context,
                                GtkStateFlags state,
                                GdkRGBA *color);

Gets the background color for a given state.

This function is far less useful than it seems, and it should not be used in newly written code. CSS has no concept of "background color", as a background can be an image, or a gradient, or any other pattern including solid colors.

The only reason why you would call gtk_style_context_get_background_color() is to use the returned value to draw the background with it; the correct way to achieve this result is to use gtk_render_background() instead, along with CSS style classes to modify the color to be rendered.

Since: 3.0

gtk_style_context_get_border_color ()

void
gtk_style_context_get_border_color (GtkStyleContext *context,
                                    GtkStateFlags state,
                                    GdkRGBA *color);

Gets the border color for a given state.

Since: 3.0

gtk_style_context_get_border ()

void
gtk_style_context_get_border (GtkStyleContext *context,
                              GtkStateFlags state,
                              GtkBorder *border);

Gets the border for a given state as a GtkBorder.

See gtk_style_context_get_property() and GTK_STYLE_PROPERTY_BORDER_WIDTH for details.

Since: 3.0

gtk_style_context_get_padding ()

void
gtk_style_context_get_padding (GtkStyleContext *context,
                               GtkStateFlags state,
                               GtkBorder *padding);

Gets the padding for a given state as a GtkBorder. See gtk_style_context_get() and GTK_STYLE_PROPERTY_PADDING for details.

Since: 3.0

gtk_style_context_get_margin ()

void
gtk_style_context_get_margin (GtkStyleContext *context,
                              GtkStateFlags state,
                              GtkBorder *margin);

Gets the margin for a given state as a GtkBorder. See gtk_style_property_get() and GTK_STYLE_PROPERTY_MARGIN for details.

Since: 3.0

gtk_style_context_get_font ()

const PangoFontDescription *
gtk_style_context_get_font (GtkStyleContext *context,
                            GtkStateFlags state);

Returns the font description for a given state. The returned object is const and will remain valid until the “changed” signal happens.

Since: 3.0

gtk_style_context_invalidate ()

void
gtk_style_context_invalidate (GtkStyleContext *context);

Invalidates context style information, so it will be reconstructed again. It is useful if you modify the context and need the new information immediately.

Since: 3.0

gtk_style_context_state_is_running ()

gboolean
gtk_style_context_state_is_running (GtkStyleContext *context,
                                    GtkStateType state,
                                    gdouble *progress);

Returns TRUE if there is a transition animation running for the current region (see gtk_style_context_push_animatable_region()).

If progress is not NULL, the animation progress will be returned there, 0.0 means the state is closest to being unset, while 1.0 means it’s closest to being set. This means transition animation will run from 0 to 1 when state is being set and from 1 to 0 when it’s being unset.

Since: 3.0

gtk_style_context_lookup_color ()

gboolean
gtk_style_context_lookup_color (GtkStyleContext *context,
                                const gchar *color_name,
                                GdkRGBA *color);

Looks up and resolves a color name in the context color map.

gtk_style_context_lookup_icon_set ()

GtkIconSet *
gtk_style_context_lookup_icon_set (GtkStyleContext *context,
                                   const gchar *stock_id);

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

gtk_style_context_notify_state_change ()

void
gtk_style_context_notify_state_change (GtkStyleContext *context,
                                       GdkWindow *window,
                                       gpointer region_id,
                                       GtkStateType state,
                                       gboolean state_value);

Notifies a state change on context , so if the current style makes use of transition animations, one will be started so all rendered elements under region_id are animated for state state being set to value state_value .

The window parameter is used in order to invalidate the rendered area as the animation runs, so make sure it is the same window that is being rendered on by the gtk_render_*() functions.

If region_id is NULL, all rendered elements using context will be affected by this state transition.

As a practical example, a GtkButton notifying a state transition on the prelight state:

1
2
3
4
5

gtk_style_context_notify_state_change (context,
                                       gtk_widget_get_window (widget),
                                       NULL,
                                       GTK_STATE_PRELIGHT,
                                       button->in_button);

Can be handled in the CSS file like this:

1
2
3
4
5
6
7
8

button {
    background-color: #f00
}

button:hover {
    background-color: #fff;
    transition: 200ms linear
}

This combination will animate the button background from red to white if a pointer enters the button, and back to red if the pointer leaves the button.

Note that state is used when finding the transition parameters, which is why the style places the transition under the :hover pseudo-class.

Since: 3.0

gtk_style_context_pop_animatable_region ()

void
gtk_style_context_pop_animatable_region
                               (GtkStyleContext *context);

Pops an animatable region from context . See gtk_style_context_push_animatable_region().

Since: 3.0

gtk_style_context_push_animatable_region ()

void
gtk_style_context_push_animatable_region
                               (GtkStyleContext *context,
                                gpointer region_id);

Pushes an animatable region, so all further gtk_render_*() calls between this call and the following gtk_style_context_pop_animatable_region() will potentially show transition animations for this region if gtk_style_context_notify_state_change() is called for a given state, and the current theme/style defines transition animations for state changes.

The region_id used must be unique in context so the themes can uniquely identify rendered elements subject to a state transition.

Since: 3.0

gtk_style_context_cancel_animations ()

void
gtk_style_context_cancel_animations (GtkStyleContext *context,
                                     gpointer region_id);

Stops all running animations for region_id and all animatable regions underneath.

A NULL region_id will stop all ongoing animations in context , when dealing with a GtkStyleContext obtained through gtk_widget_get_style_context(), this is normally done for you in all circumstances you would expect all widget to be stopped, so this should be only used in complex widgets with different animatable regions.

Since: 3.0

gtk_style_context_scroll_animations ()

void
gtk_style_context_scroll_animations (GtkStyleContext *context,
                                     GdkWindow *window,
                                     gint dx,
                                     gint dy);

This function is analogous to gdk_window_scroll(), and should be called together with it so the invalidation areas for any ongoing animation are scrolled together with it.

Since: 3.0

gtk_style_context_remove_provider ()

void
gtk_style_context_remove_provider (GtkStyleContext *context,
                                   GtkStyleProvider *provider);

Removes provider from the style providers list in context .

Since: 3.0

gtk_style_context_remove_provider_for_screen ()

void
gtk_style_context_remove_provider_for_screen
                               (GdkScreen *screen,
                                GtkStyleProvider *provider);

Removes provider from the global style providers list in screen .

Since: 3.0

gtk_style_context_reset_widgets ()

void
gtk_style_context_reset_widgets (GdkScreen *screen);

This function recomputes the styles for all widgets under a particular GdkScreen. This is useful when some global parameter has changed that affects the appearance of all widgets, because when a widget gets a new style, it will both redraw and recompute any cached information about its appearance. As an example, it is used when the color scheme changes in the related GtkSettings object.

Since: 3.0

gtk_style_context_set_background ()

void
gtk_style_context_set_background (GtkStyleContext *context,
                                  GdkWindow *window);

Sets the background of window to the background pattern or color specified in context for its current state.

Since: 3.0

gtk_style_context_restore ()

void
gtk_style_context_restore (GtkStyleContext *context);

Restores context state to a previous stage. See gtk_style_context_save().

Since: 3.0

gtk_style_context_save ()

void
gtk_style_context_save (GtkStyleContext *context);

Saves the context state, so temporary modifications done through gtk_style_context_add_class(), gtk_style_context_remove_class(), gtk_style_context_set_state(), etc. can quickly be reverted in one go through gtk_style_context_restore().

The matching call to gtk_style_context_restore() must be done before GTK returns to the main loop.

Since: 3.0

gtk_style_context_set_direction ()

void
gtk_style_context_set_direction (GtkStyleContext *context,
                                 GtkTextDirection direction);

Sets the reading direction for rendering purposes.

If you are using a GtkStyleContext returned from gtk_widget_get_style_context(), you do not need to call this yourself.

Since: 3.0

gtk_style_context_set_junction_sides ()

void
gtk_style_context_set_junction_sides (GtkStyleContext *context,
                                      GtkJunctionSides sides);

Sets the sides where rendered elements (mostly through gtk_render_frame()) will visually connect with other visual elements.

This is merely a hint that may or may not be honored by themes.

Container widgets are expected to set junction hints as appropriate for their children, so it should not normally be necessary to call this function manually.

Since: 3.0

gtk_style_context_set_parent ()

void
gtk_style_context_set_parent (GtkStyleContext *context,
                              GtkStyleContext *parent);

Sets the parent style context for context . The parent style context is used to implement inheritance of properties.

If you are using a GtkStyleContext returned from gtk_widget_get_style_context(), the parent will be set for you.

Since: 3.4

gtk_style_context_set_path ()

void
gtk_style_context_set_path (GtkStyleContext *context,
                            GtkWidgetPath *path);

Sets the GtkWidgetPath used for style matching. As a consequence, the style will be regenerated to match the new given path.

If you are using a GtkStyleContext returned from gtk_widget_get_style_context(), you do not need to call this yourself.

Since: 3.0

gtk_style_context_add_class ()

void
gtk_style_context_add_class (GtkStyleContext *context,
                             const gchar *class_name);

Adds a style class to context , so posterior calls to gtk_style_context_get() or any of the gtk_render_*() functions will make use of this new class for styling.

In the CSS file format, a GtkEntry defining a “search” class, would be matched by:

1

entry.search { ... }

While any widget defining a “search” class would be matched by:

1

.search { ... }

Since: 3.0

gtk_style_context_remove_class ()

void
gtk_style_context_remove_class (GtkStyleContext *context,
                                const gchar *class_name);

Removes class_name from context .

Since: 3.0

gtk_style_context_has_class ()

gboolean
gtk_style_context_has_class (GtkStyleContext *context,
                             const gchar *class_name);

Returns TRUE if context currently has defined the given class name.

Since: 3.0

gtk_style_context_list_classes ()

GList *
gtk_style_context_list_classes (GtkStyleContext *context);

Returns the list of classes currently defined in context .

Since: 3.0

gtk_style_context_add_region ()

void
gtk_style_context_add_region (GtkStyleContext *context,
                              const gchar *region_name,
                              GtkRegionFlags flags);

Adds a region to context , so posterior calls to gtk_style_context_get() or any of the gtk_render_*() functions will make use of this new region for styling.

In the CSS file format, a GtkTreeView defining a “row” region, would be matched by:

1

treeview row { ... }

Pseudo-classes are used for matching flags , so the two following rules:

1
2

treeview row:nth-child(even) { ... }
treeview row:nth-child(odd) { ... }

would apply to even and odd rows, respectively.

Region names must only contain lowercase letters and “-”, starting always with a lowercase letter.

Since: 3.0

gtk_style_context_remove_region ()

void
gtk_style_context_remove_region (GtkStyleContext *context,
                                 const gchar *region_name);

Removes a region from context .

Since: 3.0

gtk_style_context_has_region ()

gboolean
gtk_style_context_has_region (GtkStyleContext *context,
                              const gchar *region_name,
                              GtkRegionFlags *flags_return);

Returns TRUE if context has the region defined. If flags_return is not NULL, it is set to the flags affecting the region.

Since: 3.0

gtk_style_context_list_regions ()

GList *
gtk_style_context_list_regions (GtkStyleContext *context);

Returns the list of regions currently defined in context .

Since: 3.0

gtk_style_context_set_screen ()

void
gtk_style_context_set_screen (GtkStyleContext *context,
                              GdkScreen *screen);

Attaches context to the given screen.

The screen is used to add style information from “global” style providers, such as the screen’s GtkSettings instance.

If you are using a GtkStyleContext returned from gtk_widget_get_style_context(), you do not need to call this yourself.

Since: 3.0

gtk_style_context_set_frame_clock ()

void
gtk_style_context_set_frame_clock (GtkStyleContext *context,
                                   GdkFrameClock *frame_clock);

Attaches context to the given frame clock.

The frame clock is used for the timing of animations.

If you are using a GtkStyleContext returned from gtk_widget_get_style_context(), you do not need to call this yourself.

Since: 3.8

gtk_style_context_set_state ()

void
gtk_style_context_set_state (GtkStyleContext *context,
                             GtkStateFlags flags);

Sets the state to be used for style matching.

Since: 3.0

gtk_style_context_set_scale ()

void
gtk_style_context_set_scale (GtkStyleContext *context,
                             gint scale);

Sets the scale to use when getting image assets for the style.

Since: 3.10

gtk_style_context_get_scale ()

gint
gtk_style_context_get_scale (GtkStyleContext *context);

Returns the scale used for assets.

Since: 3.10

gtk_style_context_to_string ()

char *
gtk_style_context_to_string (GtkStyleContext *context,
                             GtkStyleContextPrintFlags flags);

Converts the style context into a string representation.

The string representation always includes information about the name, state, id, visibility and style classes of the CSS node that is backing context . Depending on the flags, more information may be included.

This function is intended for testing and debugging of the CSS implementation in GTK+. There are no guarantees about the format of the returned string, it may change.

Since: 3.20

gtk_border_new ()

GtkBorder *
gtk_border_new (void);

Allocates a new GtkBorder and initializes its elements to zero.

Since: 2.14

gtk_border_copy ()

GtkBorder *
gtk_border_copy (const GtkBorder *border_);

Copies a GtkBorder.

gtk_border_free ()

void
gtk_border_free (GtkBorder *border_);

Frees a GtkBorder.

gtk_render_arrow ()

void
gtk_render_arrow (GtkStyleContext *context,
                  cairo_t *cr,
                  gdouble angle,
                  gdouble x,
                  gdouble y,
                  gdouble size);

Renders an arrow pointing to angle .

Typical arrow rendering at 0, 1⁄2 π;, π; and 3⁄2 π:

Since: 3.0

gtk_render_background ()

void
gtk_render_background (GtkStyleContext *context,
                       cairo_t *cr,
                       gdouble x,
                       gdouble y,
                       gdouble width,
                       gdouble height);

Renders the background of an element.

Typical background rendering, showing the effect of background-image, border-width and border-radius:

Since: 3.0.

gtk_render_background_get_clip ()

void
gtk_render_background_get_clip (GtkStyleContext *context,
                                gdouble x,
                                gdouble y,
                                gdouble width,
                                gdouble height,
                                GdkRectangle *out_clip);

Returns the area that will be affected (i.e. drawn to) when calling gtk_render_background() for the given context and rectangle.

Since: 3.20

gtk_render_check ()

void
gtk_render_check (GtkStyleContext *context,
                  cairo_t *cr,
                  gdouble x,
                  gdouble y,
                  gdouble width,
                  gdouble height);

Renders a checkmark (as in a GtkCheckButton).

The GTK_STATE_FLAG_CHECKED state determines whether the check is on or off, and GTK_STATE_FLAG_INCONSISTENT determines whether it should be marked as undefined.

Typical checkmark rendering:

Since: 3.0

gtk_render_expander ()

void
gtk_render_expander (GtkStyleContext *context,
                     cairo_t *cr,
                     gdouble x,
                     gdouble y,
                     gdouble width,
                     gdouble height);

Renders an expander (as used in GtkTreeView and GtkExpander) in the area defined by x , y , width , height . The state GTK_STATE_FLAG_CHECKED determines whether the expander is collapsed or expanded.

Typical expander rendering:

Since: 3.0

gtk_render_extension ()

void
gtk_render_extension (GtkStyleContext *context,
                      cairo_t *cr,
                      gdouble x,
                      gdouble y,
                      gdouble width,
                      gdouble height,
                      GtkPositionType gap_side);

Renders a extension (as in a GtkNotebook tab) in the rectangle defined by x , y , width , height . The side where the extension connects to is defined by gap_side .

Typical extension rendering:

Since: 3.0

gtk_render_focus ()

void
gtk_render_focus (GtkStyleContext *context,
                  cairo_t *cr,
                  gdouble x,
                  gdouble y,
                  gdouble width,
                  gdouble height);

Renders a focus indicator on the rectangle determined by x , y , width , height .

Typical focus rendering:

Since: 3.0

gtk_render_frame ()

void
gtk_render_frame (GtkStyleContext *context,
                  cairo_t *cr,
                  gdouble x,
                  gdouble y,
                  gdouble width,
                  gdouble height);

Renders a frame around the rectangle defined by x , y , width , height .

Examples of frame rendering, showing the effect of border-image, border-color, border-width, border-radius and junctions:

Since: 3.0

gtk_render_frame_gap ()

void
gtk_render_frame_gap (GtkStyleContext *context,
                      cairo_t *cr,
                      gdouble x,
                      gdouble y,
                      gdouble width,
                      gdouble height,
                      GtkPositionType gap_side,
                      gdouble xy0_gap,
                      gdouble xy1_gap);

Renders a frame around the rectangle defined by (x , y , width , height ), leaving a gap on one side. xy0_gap and xy1_gap will mean X coordinates for GTK_POS_TOP and GTK_POS_BOTTOM gap sides, and Y coordinates for GTK_POS_LEFT and GTK_POS_RIGHT.

Typical rendering of a frame with a gap:

Since: 3.0

gtk_render_handle ()

void
gtk_render_handle (GtkStyleContext *context,
                   cairo_t *cr,
                   gdouble x,
                   gdouble y,
                   gdouble width,
                   gdouble height);

Renders a handle (as in GtkHandleBox, GtkPaned and GtkWindow’s resize grip), in the rectangle determined by x , y , width , height .

Handles rendered for the paned and grip classes:

Since: 3.0

gtk_render_layout ()

void
gtk_render_layout (GtkStyleContext *context,
                   cairo_t *cr,
                   gdouble x,
                   gdouble y,
                   PangoLayout *layout);

Renders layout on the coordinates x , y

Since: 3.0

gtk_render_line ()

void
gtk_render_line (GtkStyleContext *context,
                 cairo_t *cr,
                 gdouble x0,
                 gdouble y0,
                 gdouble x1,
                 gdouble y1);

Renders a line from (x0, y0) to (x1, y1).

Since: 3.0

gtk_render_option ()

void
gtk_render_option (GtkStyleContext *context,
                   cairo_t *cr,
                   gdouble x,
                   gdouble y,
                   gdouble width,
                   gdouble height);

Renders an option mark (as in a GtkRadioButton), the GTK_STATE_FLAG_CHECKED state will determine whether the option is on or off, and GTK_STATE_FLAG_INCONSISTENT whether it should be marked as undefined.

Typical option mark rendering:

Since: 3.0

gtk_render_slider ()

void
gtk_render_slider (GtkStyleContext *context,
                   cairo_t *cr,
                   gdouble x,
                   gdouble y,
                   gdouble width,
                   gdouble height,
                   GtkOrientation orientation);

Renders a slider (as in GtkScale) in the rectangle defined by x , y , width , height . orientation defines whether the slider is vertical or horizontal.

Typical slider rendering:

Since: 3.0

gtk_render_activity ()

void
gtk_render_activity (GtkStyleContext *context,
                     cairo_t *cr,
                     gdouble x,
                     gdouble y,
                     gdouble width,
                     gdouble height);

Renders an activity indicator (such as in GtkSpinner). The state GTK_STATE_FLAG_CHECKED determines whether there is activity going on.

Since: 3.0

gtk_render_icon_pixbuf ()

GdkPixbuf *
gtk_render_icon_pixbuf (GtkStyleContext *context,
                        const GtkIconSource *source,
                        GtkIconSize size);

Renders the icon specified by source at the given size , returning the result in a pixbuf.

Since: 3.0

gtk_render_icon_surface ()

void
gtk_render_icon_surface (GtkStyleContext *context,
                         cairo_t *cr,
                         cairo_surface_t *surface,
                         gdouble x,
                         gdouble y);

Renders the icon in surface at the specified x and y coordinates.

Since: 3.10

gtk_render_icon ()

void
gtk_render_icon (GtkStyleContext *context,
                 cairo_t *cr,
                 GdkPixbuf *pixbuf,
                 gdouble x,
                 gdouble y);

Renders the icon in pixbuf at the specified x and y coordinates.

This function will render the icon in pixbuf at exactly its size, regardless of scaling factors, which may not be appropriate when drawing on displays with high pixel densities.

You probably want to use gtk_render_icon_surface() instead, if you already have a Cairo surface.

Since: 3.2

gtk_render_insertion_cursor ()

void
gtk_render_insertion_cursor (GtkStyleContext *context,
                             cairo_t *cr,
                             gdouble x,
                             gdouble y,
                             PangoLayout *layout,
                             int index,
                             PangoDirection direction);

Draws a text caret on cr at the specified index of layout .

Since: 3.4

The “direction” property

  “direction”                GtkTextDirection

Text direction.

Owner: GtkStyleContext

Flags: Read / Write

Default value: GTK_TEXT_DIR_LTR

The “paint-clock” property

  “paint-clock”              GdkFrameClock *

The associated GdkFrameClock.

Owner: GtkStyleContext

Flags: Read / Write

The “parent” property

  “parent”                   GtkStyleContext *

Sets or gets the style context’s parent. See gtk_style_context_set_parent() for details.

Owner: GtkStyleContext

Flags: Read / Write

Since: 3.4

The “screen” property

  “screen”                   GdkScreen *

The associated GdkScreen.

Owner: GtkStyleContext

Flags: Read / Write

The “changed” signal

void
user_function (GtkStyleContext *stylecontext,
               gpointer         user_data)

The ::changed signal is emitted when there is a change in the GtkStyleContext.

For a GtkStyleContext returned by gtk_widget_get_style_context(), the “style-updated” signal/vfunc might be more convenient to use.

This signal is useful when using the theming layer standalone.

Flags: Run First

Since: 3.0