Untyped pointer to the underlying GtkStyleContext instance.

Typed pointer to the underlying GtkStyleContext instance.

Required Initialiser for types conforming to StyleContextProtocol

Bind a StyleContextPropertyName source property to a given target object.

Get the value of a StyleContext property

Set the value of a StyleContext property. Note that this will only have an effect on properties that are writable and not construct-only!

Connect a Swift signal handler to the given, typed StyleContextSignalName signal

Connect a C signal handler to the given, typed StyleContextSignalName signal

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

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

This signal is useful when using the theming layer standalone.

Typed changed signal for using the connect(signal:) methods

The notify signal is emitted on an object when one of its properties has its value set through g_object_set_property(), g_object_set(), et al.

Note that getting this signal doesn’t itself guarantee that the value of the property has actually changed. When it is emitted is determined by the derived GObject class. If the implementor did not create the property with G_PARAM_EXPLICIT_NOTIFY, then any call to g_object_set_property() results in notify being emitted, even if the new value is the same as the old. If they did pass G_PARAM_EXPLICIT_NOTIFY, then this signal is emitted only when they explicitly call g_object_notify() or g_object_notify_by_pspec(), and common practice is to do that only when the value has actually changed.

This signal is typically used to obtain change notification for a single property, by specifying the property name as a detail in the g_signal_connect() call, like this:

(C Language Example):

g_signal_connect (text_view->buffer, "notify::paste-target-list",
                  G_CALLBACK (gtk_text_view_target_list_notify),
                  text_view)

It is important to note that you must use canonical parameter names as detail strings for the notify signal.

Typed notify::direction signal for using the connect(signal:) methods

The notify signal is emitted on an object when one of its properties has its value set through g_object_set_property(), g_object_set(), et al.

Note that getting this signal doesn’t itself guarantee that the value of the property has actually changed. When it is emitted is determined by the derived GObject class. If the implementor did not create the property with G_PARAM_EXPLICIT_NOTIFY, then any call to g_object_set_property() results in notify being emitted, even if the new value is the same as the old. If they did pass G_PARAM_EXPLICIT_NOTIFY, then this signal is emitted only when they explicitly call g_object_notify() or g_object_notify_by_pspec(), and common practice is to do that only when the value has actually changed.

This signal is typically used to obtain change notification for a single property, by specifying the property name as a detail in the g_signal_connect() call, like this:

(C Language Example):

g_signal_connect (text_view->buffer, "notify::paste-target-list",
                  G_CALLBACK (gtk_text_view_target_list_notify),
                  text_view)

It is important to note that you must use canonical parameter names as detail strings for the notify signal.

Typed notify::paint-clock signal for using the connect(signal:) methods

The notify signal is emitted on an object when one of its properties has its value set through g_object_set_property(), g_object_set(), et al.

Note that getting this signal doesn’t itself guarantee that the value of the property has actually changed. When it is emitted is determined by the derived GObject class. If the implementor did not create the property with G_PARAM_EXPLICIT_NOTIFY, then any call to g_object_set_property() results in notify being emitted, even if the new value is the same as the old. If they did pass G_PARAM_EXPLICIT_NOTIFY, then this signal is emitted only when they explicitly call g_object_notify() or g_object_notify_by_pspec(), and common practice is to do that only when the value has actually changed.

This signal is typically used to obtain change notification for a single property, by specifying the property name as a detail in the g_signal_connect() call, like this:

(C Language Example):

g_signal_connect (text_view->buffer, "notify::paste-target-list",
                  G_CALLBACK (gtk_text_view_target_list_notify),
                  text_view)

It is important to note that you must use canonical parameter names as detail strings for the notify signal.

Typed notify::parent signal for using the connect(signal:) methods

The notify signal is emitted on an object when one of its properties has its value set through g_object_set_property(), g_object_set(), et al.

Note that getting this signal doesn’t itself guarantee that the value of the property has actually changed. When it is emitted is determined by the derived GObject class. If the implementor did not create the property with G_PARAM_EXPLICIT_NOTIFY, then any call to g_object_set_property() results in notify being emitted, even if the new value is the same as the old. If they did pass G_PARAM_EXPLICIT_NOTIFY, then this signal is emitted only when they explicitly call g_object_notify() or g_object_notify_by_pspec(), and common practice is to do that only when the value has actually changed.

This signal is typically used to obtain change notification for a single property, by specifying the property name as a detail in the g_signal_connect() call, like this:

(C Language Example):

g_signal_connect (text_view->buffer, "notify::paste-target-list",
                  G_CALLBACK (gtk_text_view_target_list_notify),
                  text_view)

It is important to note that you must use canonical parameter names as detail strings for the notify signal.

Typed notify::screen signal for using the connect(signal:) methods

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:

(CSS Language Example):

entry.search { ... }

While any widget defining a “search” class would be matched by: (CSS Language Example):

.search { ... }

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

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:

(CSS Language Example):

treeview row { ... }

Pseudo-classes are used for matching flags, so the two following rules: (CSS Language Example):

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.

add_region is deprecated: This method is deprecated.

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

A nil 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.

cancel_animations is deprecated: This function does nothing.

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.

get_background_color is deprecated: Use gtk_render_background() instead.

Gets the border for a given state as a GtkBorder.

See gtk_style_context_get_property() and GTK_STYLE_PROPERTY_BORDER_WIDTH for details.

Gets the border color for a given state.

get_border_color is deprecated: Use gtk_render_frame() instead.

Gets the foreground color for a given state.

See gtk_style_context_get_property() and GTK_STYLE_PROPERTY_COLOR for details.

Returns the widget direction used for rendering.

get_direction is deprecated: Use gtk_style_context_get_state() and check for #GTK_STATE_FLAG_DIR_LTR and #GTK_STATE_FLAG_DIR_RTL instead.

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

get_font is deprecated: Use gtk_style_context_get() for “font” or subproperties instead.

Returns the GdkFrameClock to which context is attached.

Returns the sides where rendered elements connect visually with others.

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

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

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

Returns the widget path used for style matching.

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.

Returns the scale used for assets.

Returns the GdkScreen to which context is attached.

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, nil 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 nil.

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

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.

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

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

See gtk_style_context_get_property() for details.

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

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

has_region is deprecated: This method is deprecated.

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

invalidate is deprecated: Style contexts are invalidated automatically.

Returns the list of classes currently defined in context.

Returns the list of regions currently defined in context.

list_regions is deprecated: This method is deprecated.

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

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

lookup_icon_set is deprecated: Use gtk_icon_theme_lookup_icon() instead.

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 nil, 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: (C Language Example):

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: (CSS Language Example):

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.

notify_state_change is deprecated: This function does nothing.

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

pop_animatable_region is deprecated: This function does nothing.

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.

push_animatable_region is deprecated: This function does nothing.

Removes class_name from context.

Removes provider from the style providers list in context.

Removes a region from context.

remove_region is deprecated: This method is deprecated.

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

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.

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.

scroll_animations is deprecated: This function does nothing.

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

set_background is deprecated: Use gtk_render_background() instead. Note that clients still using this function are now responsible for calling this function again whenever @context is invalidated.

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.

set_direction is deprecated: Use gtk_style_context_set_state() with #GTK_STATE_FLAG_DIR_LTR and #GTK_STATE_FLAG_DIR_RTL instead.

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.

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.

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.

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.

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.

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

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.

Sets the state to be used for style matching.

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

If progress is not nil, 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.

state_is_running is deprecated: This function always returns %FALSE

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.

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

Renders an arrow pointing to angle.

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

Renders the background of an element.

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

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

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:

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:

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:

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

Typical focus rendering:

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:

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:

render_frame_gap is deprecated: Use gtk_render_frame() instead. Themes can create gaps by omitting borders via CSS.

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:

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.

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

render_icon_pixbuf is deprecated: Use gtk_icon_theme_load_icon() instead.

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

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

Renders layout on the coordinates x, y

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

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:

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:

Undocumented

Returns the GdkFrameClock to which context is attached.

Returns the sides where rendered elements connect visually with others.

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

Returns the widget path used for style matching.

Returns the scale used for assets.

Undocumented

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

Undocumented