Optionalproperties: Partial<Gtk.StyleContext.ConstructorProps>Internal$signalsCompile-time signal type information.
This instance property is generated only for TypeScript type checking. It is not defined at runtime and should not be accessed in JS code.
Static$gtypeSince 3.4parentSets or gets the style context’s parent. See gtk_style_context_set_parent()
for details.
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 Gtk.Entry defining a “search” class, would be matched by:
entry.search { ... }
While any widget defining a “search” class would be matched by:
.search { ... }
class name to use in styling
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 Gtk.StyleProvider
added through this function takes precedence over another added
through gtk_style_context_add_provider_for_screen().
the priority of the style provider. The lower it is, the earlier it will be used in the style construction. Typically this will be in the range between GTK_STYLE_PROVIDER_PRIORITY_FALLBACK and GTK_STYLE_PROVIDER_PRIORITY_USER
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 Gtk.TreeView defining a “row” region, would be matched by:
treeview row { ... }
Pseudo-classes are used for matching flags, so the two
following rules:
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.
region name to use in styling
flags that apply to the region
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 Gtk.StyleContext 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.
Optionalregion_id: anyanimatable region to stop, or null. See gtk_style_context_push_animatable_region()
SignalconnectSignalconnect_SignalemitGets 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.
state to retrieve the color for
Gets the border for a given state as a Gtk.Border.
See gtk_style_context_get_property() and
#GTK_STYLE_PROPERTY_BORDER_WIDTH for details.
state to retrieve the border for
Gets the border color for a given state.
state to retrieve the color for
Gets the foreground color for a given state.
See gtk_style_context_get_property() and
#GTK_STYLE_PROPERTY_COLOR for details.
state to retrieve the color for
Returns the font description for a given state. The returned object is const and will remain valid until the Gtk.StyleContext::changed signal happens.
state to retrieve the font for
the Pango.FontDescription for the given state. This object is owned by GTK+ and should not be freed.
Returns the Gdk.FrameClock to which context is attached.
a Gdk.FrameClock, or null if context does not have an attached frame clock.
Returns the sides where rendered elements connect visually with others.
the junction sides
Gets the margin for a given state as a Gtk.Border.
See gtk_style_property_get() and #GTK_STYLE_PROPERTY_MARGIN
for details.
state to retrieve the border for
Gets the padding for a given state as a Gtk.Border.
See gtk_style_context_get() and #GTK_STYLE_PROPERTY_PADDING
for details.
state to retrieve the padding for
Gets the parent context set via gtk_style_context_set_parent().
See that function for details.
the parent context or null
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 GObject.Value. 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.
style property name
state to retrieve the property value for
Returns the scale used for assets.
the scale
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.
style property name
null or the section where a value for property was defined
Returns the state used for style matching.
This method should only be used to retrieve the Gtk.StateFlags
to pass to Gtk.StyleContext methods, like gtk_style_context_get_padding().
If you need to retrieve the current state of a Gtk.Widget, use
gtk_widget_get_state_flags().
the 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.
the name of the widget style property
Return location for the property value
Returns true if context currently has defined the
given class name.
a class name
true if context has class_name defined
Returns true if context has the region defined.
If flags_return is not null, it is set to the flags
affecting the region.
a region name
true if region is defined
Invalidates context style information, so it will be reconstructed
again. It is useful if you modify the context and need the new
information immediately.
Returns the list of classes currently defined in context.
a GLib.List of strings with the currently defined classes. The contents of the list are owned by GTK+, but you must free the list itself with g_list_free() when you are done with it.
Returns the list of regions currently defined in context.
a GLib.List of strings with the currently defined regions. The contents of the list are owned by GTK+, but you must free the list itself with g_list_free() when you are done with it.
Looks up stock_id in the icon factories associated to context and
the default icon factory, returning an icon set if found, otherwise
null.
an icon name
The looked up %GtkIconSet, or null
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 Gtk.Button notifying a state transition on the prelight state:
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:
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.
Pops an animatable region from context.
See gtk_style_context_push_animatable_region().
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.
Optionalregion_id: anyunique identifier for the animatable region
Removes class_name from context.
class name to remove
Removes provider from the style providers list in context.
Removes a region from context.
region name to unset
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.
a Gdk.Window used previously in gtk_style_context_notify_state_change()
Amount to scroll in the X axis
Amount to scroll in the Y axis
Sets the reading direction for rendering purposes.
If you are using a Gtk.StyleContext returned from
gtk_widget_get_style_context(), you do not need to
call this yourself.
the new direction.
Attaches context to the given frame clock.
The frame clock is used for the timing of animations.
If you are using a Gtk.StyleContext 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.
sides where rendered elements are visually connected to other elements
Sets the parent style context for context. The parent style
context is used to implement
inheritance
of properties.
If you are using a Gtk.StyleContext returned from
gtk_widget_get_style_context(), the parent will be set for you.
Optionalparent: Gtk.StyleContextthe new parent or null
Sets the Gtk.WidgetPath used for style matching. As a consequence, the style will be regenerated to match the new given path.
If you are using a Gtk.StyleContext 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.
scale
Attaches context to the given screen.
The screen is used to add style information from “global” style providers, such as the screen’s Gtk.Settings instance.
If you are using a Gtk.StyleContext returned from
gtk_widget_get_style_context(), you do not need to
call this yourself.
Sets the state to be used for style matching.
state to represent
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.
true if there is a running transition animation for state.
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.
Flags that determine what to print
a newly allocated string representing context
Virtualvfunc_Staticadd_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 Gtk.Settings available.
Note: If both priorities are the same, A Gtk.StyleProvider
added through gtk_style_context_add_provider() takes precedence
over another added through this function.
the priority of the style provider. The lower it is, the earlier it will be used in the style construction. Typically this will be in the range between GTK_STYLE_PROVIDER_PRIORITY_FALLBACK and GTK_STYLE_PROVIDER_PRIORITY_USER
StaticnewStaticremove_Removes provider from the global style providers list in screen.
Staticreset_This function recomputes the styles for all widgets under a particular Gdk.Screen. 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 Gtk.Settings object.
Creates a binding between source_property on source and target_property
on target.
Whenever the source_property is changed the target_property is
updated using the same value. For instance:
g_object_bind_property (action, "active", widget, "sensitive", 0);
Will result in the "sensitive" property of the widget GObject.Object instance to be updated with the same value of the "active" property of the action GObject.Object instance.
If flags contains GObject.BindingFlags.BIDIRECTIONAL then the binding will be mutual:
if target_property on target changes then the source_property on source
will be updated as well.
The binding will automatically be removed when either the source or the
target instances are finalized. To remove the binding without affecting the
source and the target you can just call g_object_unref() on the returned
GObject.Binding instance.
Removing the binding by calling g_object_unref() on it must only be done if
the binding, source and target are only used from a single thread and it
is clear that both source and target outlive the binding. Especially it
is not safe to rely on this if the binding, source or target can be
finalized from different threads. Keep another reference to the binding and
use g_binding_unbind() instead to be on the safe side.
A GObject.Object can have multiple bindings.
the property on source to bind
the target GObject.Object
the property on target to bind
flags to pass to GObject.Binding
the GObject.Binding instance representing the binding between the two GObject.Object instances. The binding is released whenever the GObject.Binding reference count reaches zero.
Complete version of g_object_bind_property().
Creates a binding between source_property on source and target_property
on target, allowing you to set the transformation functions to be used by
the binding.
If flags contains GObject.BindingFlags.BIDIRECTIONAL then the binding will be mutual:
if target_property on target changes then the source_property on source
will be updated as well. The transform_from function is only used in case
of bidirectional bindings, otherwise it will be ignored
The binding will automatically be removed when either the source or the
target instances are finalized. This will release the reference that is
being held on the GObject.Binding instance; if you want to hold on to the
GObject.Binding instance, you will need to hold a reference to it.
To remove the binding, call g_binding_unbind().
A GObject.Object can have multiple bindings.
The same user_data parameter will be used for both transform_to
and transform_from transformation functions; the notify function will
be called once, when the binding is removed. If you need different data
for each transformation function, please use
g_object_bind_property_with_closures() instead.
the property on source to bind
the target GObject.Object
the property on target to bind
flags to pass to GObject.Binding
Optionaltransform_to: BindingTransformFuncthe transformation function from the source to the target, or null to use the default
Optionaltransform_from: BindingTransformFuncthe transformation function from the target to the source, or null to use the default
Optionalnotify: DestroyNotifya function to call when disposing the binding, to free resources used by the transformation functions, or null if not required
the GObject.Binding instance representing the binding between the two GObject.Object instances. The binding is released whenever the GObject.Binding reference count reaches zero.
Creates a binding between source_property on source and target_property
on target, allowing you to set the transformation functions to be used by
the binding.
This function is the language bindings friendly version of
g_object_bind_property_full(), using GClosures instead of
function pointers.
the property on source to bind
the target GObject.Object
the property on target to bind
flags to pass to GObject.Binding
a GObject.Closure wrapping the transformation function from the source to the target, or null to use the default
a GObject.Closure wrapping the transformation function from the target to the source, or null to use the default
the GObject.Binding instance representing the binding between the two GObject.Object instances. The binding is released whenever the GObject.Binding reference count reaches zero.
Blocks a handler of an instance so it will not be called during any signal emissions
Handler ID of the handler to be blocked
Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
Handler ID of the handler to be disconnected
This function is intended for GObject.Object implementations to re-enforce
a [floating][floating-ref] object reference. Doing this is seldom
required: all GInitiallyUnowneds are created with a floating reference
which usually just needs to be sunken by calling g_object_ref_sink().
Increases the freeze count on object. If the freeze count is
non-zero, the emission of "notify" signals on object is
stopped. The signals are queued until the freeze count is decreased
to zero. Duplicate notifications are squashed so that at most one
GObject.Object::notify signal is emitted for each property modified while the
object is frozen.
This is necessary for accessors that modify multiple properties to prevent premature notification while the object is still being modified.
Gets a named field from the objects table of associations (see g_object_set_data()).
name of the key for that association
the data if found, or null if no such data exists.
This function gets back user data pointers stored via
g_object_set_qdata().
A GLib.Quark, naming the user data pointer
The user data pointer set, or null
Gets n_properties properties for an object.
Obtained properties will be set to values. All properties must be valid.
Warnings will be emitted and undefined behaviour may result if invalid
properties are passed in.
the names of each property to get
the values of each property to get
Checks whether object has a [floating][floating-ref] reference.
true if object has a floating reference
Emits a "notify" signal for the property property_name on object.
When possible, eg. when signaling a property change from within the class
that registered the property, you should use g_object_notify_by_pspec()
instead.
Note that emission of the notify signal may be blocked with
g_object_freeze_notify(). In this case, the signal emissions are queued
and will be emitted (in reverse order) when g_object_thaw_notify() is
called.
the name of a property installed on the class of object.
Emits a "notify" signal for the property specified by pspec on object.
This function omits the property name lookup, hence it is faster than
g_object_notify().
One way to avoid using g_object_notify() from within the
class that registered the properties, and using g_object_notify_by_pspec()
instead, is to store the GParamSpec used with
g_object_class_install_property() inside a static array, e.g.:
typedef enum
{
PROP_FOO = 1,
PROP_LAST
} MyObjectProperty;
static GParamSpec *properties[PROP_LAST];
static void
my_object_class_init (MyObjectClass *klass)
{
properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
0, 100,
50,
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
g_object_class_install_property (gobject_class,
PROP_FOO,
properties[PROP_FOO]);
}
and then notify a change on the "foo" property with:
g_object_notify_by_pspec (self, properties[PROP_FOO]);
the GObject.ParamSpec of a property installed on the class of object.
Increases the reference count of object.
Since GLib 2.56, if GLIB_VERSION_MAX_ALLOWED is 2.56 or greater, the type
of object will be propagated to the return type (using the GCC typeof()
extension), so any casting the caller needs to do on the return type must be
explicit.
the same object
Increase the reference count of object, and possibly remove the
[floating][floating-ref] reference, if object has a floating reference.
In other words, if the object is floating, then this call "assumes ownership" of the floating reference, converting it to a normal reference by clearing the floating flag while leaving the reference count unchanged. If the object is not floating, then this call adds a new normal reference increasing the reference count by one.
Since GLib 2.56, the type of object will be propagated to the return type
under the same conditions as for g_object_ref().
object
Releases all references to other objects. This can be used to break reference cycles.
This function should only be called from object system implementations.
Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
Object containing the properties to set
Each object carries around a table of associations from strings to pointers. This function lets you set an association.
If the object already had an association with that name, the old association will be destroyed.
Internally, the key is converted to a GLib.Quark using g_quark_from_string().
This means a copy of key is kept permanently (even after object has been
finalized) — so it is recommended to only use a small, bounded set of values
for key in your program, to avoid the GLib.Quark storage growing unbounded.
name of the key
Optionaldata: anydata to associate with that key
Sets a property on an object.
The name of the property to set
The value to set the property to
Remove a specified datum from the object's data associations, without invoking the association's destroy handler.
name of the key
the data if found, or null if no such data exists.
This function gets back user data pointers stored via
g_object_set_qdata() and removes the data from object
without invoking its destroy() function (if any was
set).
Usually, calling this function is only required to update
user data pointers with a destroy notifier, for example:
void
object_add_to_user_list (GObject *object,
const gchar *new_string)
{
// the quark, naming the object data
GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
// retrieve the old string list
GList *list = g_object_steal_qdata (object, quark_string_list);
// prepend new string
list = g_list_prepend (list, g_strdup (new_string));
// this changed 'list', so we need to set it again
g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
}
static void
free_string_list (gpointer data)
{
GList *node, *list = data;
for (node = list; node; node = node->next)
g_free (node->data);
g_list_free (list);
}
Using g_object_get_qdata() in the above example, instead of
g_object_steal_qdata() would have left the destroy function set,
and thus the partial string list would have been freed upon
g_object_set_qdata_full().
A GLib.Quark, naming the user data pointer
The user data pointer set, or null
Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
Name of the signal to stop emission of
Reverts the effect of a previous call to
g_object_freeze_notify(). The freeze count is decreased on object
and when it reaches zero, queued "notify" signals are emitted.
Duplicate notifications for each property are squashed so that at most one GObject.Object::notify signal is emitted for each property, in the reverse order in which they have been queued.
It is an error to call this function when the freeze count is zero.
Unblocks a handler so it will be called again during any signal emissions
Handler ID of the handler to be unblocked
Decreases the reference count of object. When its reference count
drops to 0, the object is finalized (i.e. its memory is freed).
If the pointer to the GObject.Object may be reused in future (for example, if it is
an instance variable of another object), it is recommended to clear the
pointer to null rather than retain a dangling pointer to a potentially
invalid GObject.Object instance. Use g_clear_object() for this.
Virtualvfunc_the constructed function is called by g_object_new() as the
final step of the object creation process. At the point of the call, all
construction properties have been set on the object. The purpose of this
call is to allow for object initialisation steps that can only be performed
after construction properties have been set. constructed implementors
should chain up to the constructed call of their parent class to allow it
to complete its initialisation.
Virtualvfunc_Virtualvfunc_the dispose function is supposed to drop all references to other
objects, but keep the instance otherwise intact, so that client method
invocations still work. It may be run multiple times (due to reference
loops). Before returning, dispose should chain up to the dispose method
of the parent class.
Virtualvfunc_instance finalization function, should finish the finalization of
the instance begun in dispose and chain up to the finalize method of the
parent class.
Virtualvfunc_Virtualvfunc_Emits a "notify" signal for the property property_name on object.
When possible, eg. when signaling a property change from within the class
that registered the property, you should use g_object_notify_by_pspec()
instead.
Note that emission of the notify signal may be blocked with
g_object_freeze_notify(). In this case, the signal emissions are queued
and will be emitted (in reverse order) when g_object_thaw_notify() is
called.
Virtualvfunc_the generic setter for all properties of this type. Should be
overridden for every type with properties. If implementations of
set_property don't emit property change notification explicitly, this will
be done implicitly by the type system. However, if the notify signal is
emitted explicitly, the type system will not emit it a second time.
This function essentially limits the life time of the closure to
the life time of the object. That is, when the object is finalized,
the closure is invalidated by calling g_closure_invalidate() on
it, in order to prevent invocations of the closure with a finalized
(nonexisting) object. Also, g_object_ref() and g_object_unref() are
added as marshal guards to the closure, to ensure that an extra
reference count is held on object during invocation of the
closure. Usually, this function will be called on closures that
use this object as closure data.
GObject.Closure to watch
Static_Staticcompat_Optionaldata: anyStaticfind_Staticinstall_Staticinstall_the id for the new property
the GObject.ParamSpec for the new property
Staticinterface_Find the GObject.ParamSpec with the given name for an
interface. Generally, the interface vtable passed in as g_iface
will be the default vtable from g_type_default_interface_ref(), or,
if you know the interface has already been loaded,
g_type_default_interface_peek().
any interface vtable for the interface, or the default vtable for the interface
name of a property to look up.
Staticinterface_Add a property to an interface; this is only useful for interfaces
that are added to GObject-derived types. Adding a property to an
interface forces all objects classes with that interface to have a
compatible property. The compatible property could be a newly
created GObject.ParamSpec, but normally
g_object_class_override_property() will be used so that the object
class only needs to provide an implementation and inherits the
property description, default value, bounds, and so forth from the
interface property.
This function is meant to be called from the interface's default
vtable initialization function (the class_init member of
GObject.TypeInfo.) It must not be called after after class_init has
been called for any object types implementing this interface.
If pspec is a floating reference, it will be consumed.
any interface vtable for the interface, or the default vtable for the interface.
the GObject.ParamSpec for the new property
Staticinterface_Lists the properties of an interface.Generally, the interface
vtable passed in as g_iface will be the default vtable from
g_type_default_interface_ref(), or, if you know the interface has
already been loaded, g_type_default_interface_peek().
any interface vtable for the interface, or the default vtable for the interface
Staticlist_StaticnewvStaticoverride_the new property ID
the name of a property registered in a parent class or in an interface of this class.
Gtk.StyleContext is an object that stores styling information affecting a widget defined by Gtk.WidgetPath.
In order to construct the final style information, Gtk.StyleContext queries information from all attached
GtkStyleProviders. Style providers can be either attached explicitly to the context throughgtk_style_context_add_provider(), or to the screen throughgtk_style_context_add_provider_for_screen(). The resulting style is a combination of all providers’ information in priority order.For GTK+ widgets, any Gtk.StyleContext returned by
gtk_widget_get_style_context()will already have a Gtk.WidgetPath, a Gdk.Screen and RTL/LTR information set. The style context will also be updated automatically if any of these settings change on the widget.If you are using the theming layer standalone, you will need to set a widget path and a screen yourself to the created style context through
gtk_style_context_set_path()and possiblygtk_style_context_set_screen(). See the “Foreign drawing“ example in gtk3-demo.Style Classes # {#gtkstylecontext-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
GtkWidgetsthat render differently than standard components, you may need to add a Gtk.StyleProvider yourself with theGTK_STYLE_PROVIDER_PRIORITY_FALLBACKpriority, either a Gtk.CssProvider or a custom object implementing the Gtk.StyleProvider 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 Gtk.StyleProvider with the
GTK_STYLE_PROVIDER_PRIORITY_APPLICATIONpriority, keep in mind that the user settings inXDG_CONFIG_HOME/gtk-3.0/gtk.csswill still take precedence over your changes, as it uses theGTK_STYLE_PROVIDER_PRIORITY_USERpriority.