gtk/auto/

style_context.rs

// This file was generated by gir (https://github.com/gtk-rs/gir)
// from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT

use crate::{
    Border, CssSection, JunctionSides, StateFlags, StyleContextPrintFlags, StyleProvider,
    TextDirection, WidgetPath, ffi,
};
use glib::{
    object::ObjectType as _,
    prelude::*,
    signal::{SignalHandlerId, connect_raw},
    translate::*,
};
use std::boxed::Box as Box_;

glib::wrapper! {
    /// [`StyleContext`][crate::StyleContext] is an object that stores styling information affecting
    /// a widget defined by [`WidgetPath`][crate::WidgetPath].
    ///
    /// In order to construct the final style information, [`StyleContext`][crate::StyleContext]
    /// queries information from all attached `GtkStyleProviders`. Style providers
    /// can be either attached explicitly to the context through
    /// [`StyleContextExt::add_provider()`][crate::prelude::StyleContextExt::add_provider()], or to the screen through
    /// [`add_provider_for_screen()`][Self::add_provider_for_screen()]. The resulting style is a
    /// combination of all providers’ information in priority order.
    ///
    /// For GTK+ widgets, any [`StyleContext`][crate::StyleContext] returned by
    /// [`WidgetExt::style_context()`][crate::prelude::WidgetExt::style_context()] will already have a [`WidgetPath`][crate::WidgetPath], a
    /// [`gdk::Screen`][crate::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
    /// [`StyleContextExt::set_path()`][crate::prelude::StyleContextExt::set_path()] and possibly [`StyleContextExt::set_screen()`][crate::prelude::StyleContextExt::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 `GtkWidgets` that
    /// render differently than standard components, you may need to add a
    /// [`StyleProvider`][crate::StyleProvider] yourself with the `GTK_STYLE_PROVIDER_PRIORITY_FALLBACK`
    /// priority, either a [`CssProvider`][crate::CssProvider] or a custom object implementing the
    /// [`StyleProvider`][crate::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 [`StyleProvider`][crate::StyleProvider] 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.
    ///
    /// ## Properties
    ///
    ///
    /// #### `direction`
    ///  Readable | Writable
    ///
    ///
    /// #### `paint-clock`
    ///  Readable | Writable
    ///
    ///
    /// #### `parent`
    ///  Sets or gets the style context’s parent. See [`StyleContextExt::set_parent()`][crate::prelude::StyleContextExt::set_parent()]
    /// for details.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `screen`
    ///  Readable | Writable
    ///
    /// ## Signals
    ///
    ///
    /// #### `changed`
    ///  The ::changed signal is emitted when there is a change in the
    /// [`StyleContext`][crate::StyleContext].
    ///
    /// For a [`StyleContext`][crate::StyleContext] returned by [`WidgetExt::style_context()`][crate::prelude::WidgetExt::style_context()], the
    /// [`style-updated`][struct@crate::Widget#style-updated] signal/vfunc might be more convenient to use.
    ///
    /// This signal is useful when using the theming layer standalone.
    ///
    ///
    ///
    /// # Implements
    ///
    /// [`StyleContextExt`][trait@crate::prelude::StyleContextExt], [`trait@glib::ObjectExt`], [`StyleContextExtManual`][trait@crate::prelude::StyleContextExtManual]
    #[doc(alias = "GtkStyleContext")]
    pub struct StyleContext(Object<ffi::GtkStyleContext, ffi::GtkStyleContextClass>);

    match fn {
        type_ => || ffi::gtk_style_context_get_type(),
    }
}

impl StyleContext {
    pub const NONE: Option<&'static StyleContext> = None;

    /// Creates a standalone [`StyleContext`][crate::StyleContext], this style context
    /// won’t be attached to any widget, so you may want
    /// to call [`StyleContextExt::set_path()`][crate::prelude::StyleContextExt::set_path()] yourself.
    ///
    /// This function is only useful when using the theming layer
    /// separated from GTK+, if you are using [`StyleContext`][crate::StyleContext] to
    /// theme `GtkWidgets`, use [`WidgetExt::style_context()`][crate::prelude::WidgetExt::style_context()]
    /// in order to get a style context ready to theme the widget.
    ///
    /// # Returns
    ///
    /// A newly created [`StyleContext`][crate::StyleContext].
    #[doc(alias = "gtk_style_context_new")]
    pub fn new() -> StyleContext {
        assert_initialized_main_thread!();
        unsafe { from_glib_full(ffi::gtk_style_context_new()) }
    }

    // rustdoc-stripper-ignore-next
    /// Creates a new builder-pattern struct instance to construct [`StyleContext`] objects.
    ///
    /// This method returns an instance of [`StyleContextBuilder`](crate::builders::StyleContextBuilder) which can be used to create [`StyleContext`] objects.
    pub fn builder() -> StyleContextBuilder {
        StyleContextBuilder::new()
    }

    /// 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 [`Settings`][crate::Settings]
    /// available.
    ///
    /// Note: If both priorities are the same, A [`StyleProvider`][crate::StyleProvider]
    /// added through [`StyleContextExt::add_provider()`][crate::prelude::StyleContextExt::add_provider()] takes precedence
    /// over another added through this function.
    /// ## `screen`
    /// a [`gdk::Screen`][crate::gdk::Screen]
    /// ## `provider`
    /// a [`StyleProvider`][crate::StyleProvider]
    /// ## `priority`
    /// 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`
    #[doc(alias = "gtk_style_context_add_provider_for_screen")]
    pub fn add_provider_for_screen(
        screen: &gdk::Screen,
        provider: &impl IsA<StyleProvider>,
        priority: u32,
    ) {
        skip_assert_initialized!();
        unsafe {
            ffi::gtk_style_context_add_provider_for_screen(
                screen.to_glib_none().0,
                provider.as_ref().to_glib_none().0,
                priority,
            );
        }
    }

    /// Removes `provider` from the global style providers list in `screen`.
    /// ## `screen`
    /// a [`gdk::Screen`][crate::gdk::Screen]
    /// ## `provider`
    /// a [`StyleProvider`][crate::StyleProvider]
    #[doc(alias = "gtk_style_context_remove_provider_for_screen")]
    pub fn remove_provider_for_screen(screen: &gdk::Screen, provider: &impl IsA<StyleProvider>) {
        skip_assert_initialized!();
        unsafe {
            ffi::gtk_style_context_remove_provider_for_screen(
                screen.to_glib_none().0,
                provider.as_ref().to_glib_none().0,
            );
        }
    }

    /// This function recomputes the styles for all widgets under a particular
    /// [`gdk::Screen`][crate::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 [`Settings`][crate::Settings] object.
    /// ## `screen`
    /// a [`gdk::Screen`][crate::gdk::Screen]
    #[doc(alias = "gtk_style_context_reset_widgets")]
    pub fn reset_widgets(screen: &gdk::Screen) {
        assert_initialized_main_thread!();
        unsafe {
            ffi::gtk_style_context_reset_widgets(screen.to_glib_none().0);
        }
    }
}

impl Default for StyleContext {
    fn default() -> Self {
        Self::new()
    }
}

// rustdoc-stripper-ignore-next
/// A [builder-pattern] type to construct [`StyleContext`] objects.
///
/// [builder-pattern]: https://doc.rust-lang.org/1.0.0/style/ownership/builders.html
#[must_use = "The builder must be built to be used"]
pub struct StyleContextBuilder {
    builder: glib::object::ObjectBuilder<'static, StyleContext>,
}

impl StyleContextBuilder {
    fn new() -> Self {
        Self {
            builder: glib::object::Object::builder(),
        }
    }

    pub fn direction(self, direction: TextDirection) -> Self {
        Self {
            builder: self.builder.property("direction", direction),
        }
    }

    pub fn paint_clock(self, paint_clock: &gdk::FrameClock) -> Self {
        Self {
            builder: self.builder.property("paint-clock", paint_clock.clone()),
        }
    }

    /// Sets or gets the style context’s parent. See [`StyleContextExt::set_parent()`][crate::prelude::StyleContextExt::set_parent()]
    /// for details.
    pub fn parent(self, parent: &impl IsA<StyleContext>) -> Self {
        Self {
            builder: self.builder.property("parent", parent.clone().upcast()),
        }
    }

    pub fn screen(self, screen: &gdk::Screen) -> Self {
        Self {
            builder: self.builder.property("screen", screen.clone()),
        }
    }

    // rustdoc-stripper-ignore-next
    /// Build the [`StyleContext`].
    #[must_use = "Building the object from the builder is usually expensive and is not expected to have side effects"]
    pub fn build(self) -> StyleContext {
        assert_initialized_main_thread!();
        self.builder.build()
    }
}

/// Trait containing all [`struct@StyleContext`] methods.
///
/// # Implementors
///
/// [`StyleContext`][struct@crate::StyleContext]
pub trait StyleContextExt: IsA<StyleContext> + 'static {
    ///
    /// .search { ... }
    /// ]|
    /// ## `class_name`
    /// class name to use in styling
    #[doc(alias = "gtk_style_context_add_class")]
    fn add_class(&self, class_name: &str) {
        unsafe {
            ffi::gtk_style_context_add_class(
                self.as_ref().to_glib_none().0,
                class_name.to_glib_none().0,
            );
        }
    }

    /// Adds a style provider to `self`, to be used in style construction.
    /// Note that a style provider added by this function only affects
    /// the style of the widget to which `self` belongs. If you want
    /// to affect the style of all widgets, use
    /// [`StyleContext::add_provider_for_screen()`][crate::StyleContext::add_provider_for_screen()].
    ///
    /// Note: If both priorities are the same, a [`StyleProvider`][crate::StyleProvider]
    /// added through this function takes precedence over another added
    /// through [`StyleContext::add_provider_for_screen()`][crate::StyleContext::add_provider_for_screen()].
    /// ## `provider`
    /// a [`StyleProvider`][crate::StyleProvider]
    /// ## `priority`
    /// 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`
    #[doc(alias = "gtk_style_context_add_provider")]
    fn add_provider(&self, provider: &impl IsA<StyleProvider>, priority: u32) {
        unsafe {
            ffi::gtk_style_context_add_provider(
                self.as_ref().to_glib_none().0,
                provider.as_ref().to_glib_none().0,
                priority,
            );
        }
    }

    /// Gets the border for a given state as a [`Border`][crate::Border].
    ///
    /// See [`style_property_for_state()`][Self::style_property_for_state()] and
    /// [`STYLE_PROPERTY_BORDER_WIDTH`][crate::STYLE_PROPERTY_BORDER_WIDTH] for details.
    /// ## `state`
    /// state to retrieve the border for
    ///
    /// # Returns
    ///
    ///
    /// ## `border`
    /// return value for the border settings
    #[doc(alias = "gtk_style_context_get_border")]
    #[doc(alias = "get_border")]
    fn border(&self, state: StateFlags) -> Border {
        unsafe {
            let mut border = Border::uninitialized();
            ffi::gtk_style_context_get_border(
                self.as_ref().to_glib_none().0,
                state.into_glib(),
                border.to_glib_none_mut().0,
            );
            border
        }
    }

    /// Gets the foreground color for a given state.
    ///
    /// See [`style_property_for_state()`][Self::style_property_for_state()] and
    /// [`STYLE_PROPERTY_COLOR`][crate::STYLE_PROPERTY_COLOR] for details.
    /// ## `state`
    /// state to retrieve the color for
    ///
    /// # Returns
    ///
    ///
    /// ## `color`
    /// return value for the foreground color
    #[doc(alias = "gtk_style_context_get_color")]
    #[doc(alias = "get_color")]
    fn color(&self, state: StateFlags) -> gdk::RGBA {
        unsafe {
            let mut color = gdk::RGBA::uninitialized();
            ffi::gtk_style_context_get_color(
                self.as_ref().to_glib_none().0,
                state.into_glib(),
                color.to_glib_none_mut().0,
            );
            color
        }
    }

    /// Returns the [`gdk::FrameClock`][crate::gdk::FrameClock] to which `self` is attached.
    ///
    /// # Returns
    ///
    /// a [`gdk::FrameClock`][crate::gdk::FrameClock], or [`None`]
    ///  if `self` does not have an attached frame clock.
    #[doc(alias = "gtk_style_context_get_frame_clock")]
    #[doc(alias = "get_frame_clock")]
    fn frame_clock(&self) -> Option<gdk::FrameClock> {
        unsafe {
            from_glib_none(ffi::gtk_style_context_get_frame_clock(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Returns the sides where rendered elements connect visually with others.
    ///
    /// # Returns
    ///
    /// the junction sides
    #[doc(alias = "gtk_style_context_get_junction_sides")]
    #[doc(alias = "get_junction_sides")]
    fn junction_sides(&self) -> JunctionSides {
        unsafe {
            from_glib(ffi::gtk_style_context_get_junction_sides(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the margin for a given state as a [`Border`][crate::Border].
    /// See `gtk_style_property_get()` and [`STYLE_PROPERTY_MARGIN`][crate::STYLE_PROPERTY_MARGIN]
    /// for details.
    /// ## `state`
    /// state to retrieve the border for
    ///
    /// # Returns
    ///
    ///
    /// ## `margin`
    /// return value for the margin settings
    #[doc(alias = "gtk_style_context_get_margin")]
    #[doc(alias = "get_margin")]
    fn margin(&self, state: StateFlags) -> Border {
        unsafe {
            let mut margin = Border::uninitialized();
            ffi::gtk_style_context_get_margin(
                self.as_ref().to_glib_none().0,
                state.into_glib(),
                margin.to_glib_none_mut().0,
            );
            margin
        }
    }

    /// Gets the padding for a given state as a [`Border`][crate::Border].
    /// See `gtk_style_context_get()` and [`STYLE_PROPERTY_PADDING`][crate::STYLE_PROPERTY_PADDING]
    /// for details.
    /// ## `state`
    /// state to retrieve the padding for
    ///
    /// # Returns
    ///
    ///
    /// ## `padding`
    /// return value for the padding settings
    #[doc(alias = "gtk_style_context_get_padding")]
    #[doc(alias = "get_padding")]
    fn padding(&self, state: StateFlags) -> Border {
        unsafe {
            let mut padding = Border::uninitialized();
            ffi::gtk_style_context_get_padding(
                self.as_ref().to_glib_none().0,
                state.into_glib(),
                padding.to_glib_none_mut().0,
            );
            padding
        }
    }

    /// Gets the parent context set via [`set_parent()`][Self::set_parent()].
    /// See that function for details.
    ///
    /// # Returns
    ///
    /// the parent context or [`None`]
    #[doc(alias = "gtk_style_context_get_parent")]
    #[doc(alias = "get_parent")]
    #[must_use]
    fn parent(&self) -> Option<StyleContext> {
        unsafe {
            from_glib_none(ffi::gtk_style_context_get_parent(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Returns the widget path used for style matching.
    ///
    /// # Returns
    ///
    /// A [`WidgetPath`][crate::WidgetPath]
    #[doc(alias = "gtk_style_context_get_path")]
    #[doc(alias = "get_path")]
    fn path(&self) -> Option<WidgetPath> {
        unsafe {
            from_glib_none(ffi::gtk_style_context_get_path(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets a style property from `self` 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 [`glib::Value`][crate::glib::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 `self`
    /// is not recommended unless the style context has been saved with
    /// [`save()`][Self::save()].
    ///
    /// When `value` is no longer needed, [`glib::Value::unset()`][crate::glib::Value::unset()] must be called
    /// to free any allocated memory.
    /// ## `property`
    /// style property name
    /// ## `state`
    /// state to retrieve the property value for
    ///
    /// # Returns
    ///
    ///
    /// ## `value`
    /// return location for the style property value
    #[doc(alias = "gtk_style_context_get_property")]
    #[doc(alias = "get_property")]
    fn style_property_for_state(&self, property: &str, state: StateFlags) -> glib::Value {
        unsafe {
            let mut value = glib::Value::uninitialized();
            ffi::gtk_style_context_get_property(
                self.as_ref().to_glib_none().0,
                property.to_glib_none().0,
                state.into_glib(),
                value.to_glib_none_mut().0,
            );
            value
        }
    }

    /// Returns the scale used for assets.
    ///
    /// # Returns
    ///
    /// the scale
    #[doc(alias = "gtk_style_context_get_scale")]
    #[doc(alias = "get_scale")]
    fn scale(&self) -> i32 {
        unsafe { ffi::gtk_style_context_get_scale(self.as_ref().to_glib_none().0) }
    }

    /// Returns the [`gdk::Screen`][crate::gdk::Screen] to which `self` is attached.
    ///
    /// # Returns
    ///
    /// a [`gdk::Screen`][crate::gdk::Screen].
    #[doc(alias = "gtk_style_context_get_screen")]
    #[doc(alias = "get_screen")]
    fn screen(&self) -> Option<gdk::Screen> {
        unsafe {
            from_glib_none(ffi::gtk_style_context_get_screen(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Queries the location in the CSS where `property` was defined for the
    /// current `self`. Note that the state to be queried is taken from
    /// [`state()`][Self::state()].
    ///
    /// If the location is not available, [`None`] 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 [`None`].
    /// ## `property`
    /// style property name
    ///
    /// # Returns
    ///
    /// [`None`] or the section where a value
    /// for `property` was defined
    #[doc(alias = "gtk_style_context_get_section")]
    #[doc(alias = "get_section")]
    fn section(&self, property: &str) -> Option<CssSection> {
        unsafe {
            from_glib_none(ffi::gtk_style_context_get_section(
                self.as_ref().to_glib_none().0,
                property.to_glib_none().0,
            ))
        }
    }

    /// Returns the state used for style matching.
    ///
    /// This method should only be used to retrieve the [`StateFlags`][crate::StateFlags]
    /// to pass to [`StyleContext`][crate::StyleContext] methods, like [`padding()`][Self::padding()].
    /// If you need to retrieve the current state of a [`Widget`][crate::Widget], use
    /// [`WidgetExt::state_flags()`][crate::prelude::WidgetExt::state_flags()].
    ///
    /// # Returns
    ///
    /// the state flags
    #[doc(alias = "gtk_style_context_get_state")]
    #[doc(alias = "get_state")]
    fn state(&self) -> StateFlags {
        unsafe {
            from_glib(ffi::gtk_style_context_get_state(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    //#[doc(alias = "gtk_style_context_get_style")]
    //#[doc(alias = "get_style")]
    //fn style(&self, : /*Unknown conversion*//*Unimplemented*/Basic: VarArgs) {
    //    unsafe { TODO: call ffi:gtk_style_context_get_style() }
    //}

    /// Gets the value for a widget style property.
    ///
    /// When `value` is no longer needed, [`glib::Value::unset()`][crate::glib::Value::unset()] must be called
    /// to free any allocated memory.
    /// ## `property_name`
    /// the name of the widget style property
    ///
    /// # Returns
    ///
    ///
    /// ## `value`
    /// Return location for the property value
    #[doc(alias = "gtk_style_context_get_style_property")]
    #[doc(alias = "get_style_property")]
    fn style_property(&self, property_name: &str) -> glib::Value {
        unsafe {
            let mut value = glib::Value::uninitialized();
            ffi::gtk_style_context_get_style_property(
                self.as_ref().to_glib_none().0,
                property_name.to_glib_none().0,
                value.to_glib_none_mut().0,
            );
            value
        }
    }

    //#[doc(alias = "gtk_style_context_get_style_valist")]
    //#[doc(alias = "get_style_valist")]
    //fn style_valist(&self, args: /*Unknown conversion*//*Unimplemented*/Unsupported) {
    //    unsafe { TODO: call ffi:gtk_style_context_get_style_valist() }
    //}

    //#[doc(alias = "gtk_style_context_get_valist")]
    //#[doc(alias = "get_valist")]
    //fn valist(&self, state: StateFlags, args: /*Unknown conversion*//*Unimplemented*/Unsupported) {
    //    unsafe { TODO: call ffi:gtk_style_context_get_valist() }
    //}

    /// Returns [`true`] if `self` currently has defined the
    /// given class name.
    /// ## `class_name`
    /// a class name
    ///
    /// # Returns
    ///
    /// [`true`] if `self` has `class_name` defined
    #[doc(alias = "gtk_style_context_has_class")]
    fn has_class(&self, class_name: &str) -> bool {
        unsafe {
            from_glib(ffi::gtk_style_context_has_class(
                self.as_ref().to_glib_none().0,
                class_name.to_glib_none().0,
            ))
        }
    }

    /// Returns the list of classes currently defined in `self`.
    ///
    /// # Returns
    ///
    /// a `GList` 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.
    #[doc(alias = "gtk_style_context_list_classes")]
    fn list_classes(&self) -> Vec<glib::GString> {
        unsafe {
            FromGlibPtrContainer::from_glib_container(ffi::gtk_style_context_list_classes(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Looks up and resolves a color name in the `self` color map.
    /// ## `color_name`
    /// color name to lookup
    ///
    /// # Returns
    ///
    /// [`true`] if `color_name` was found and resolved, [`false`] otherwise
    ///
    /// ## `color`
    /// Return location for the looked up color
    #[doc(alias = "gtk_style_context_lookup_color")]
    fn lookup_color(&self, color_name: &str) -> Option<gdk::RGBA> {
        unsafe {
            let mut color = gdk::RGBA::uninitialized();
            let ret = from_glib(ffi::gtk_style_context_lookup_color(
                self.as_ref().to_glib_none().0,
                color_name.to_glib_none().0,
                color.to_glib_none_mut().0,
            ));
            if ret { Some(color) } else { None }
        }
    }

    /// Removes `class_name` from `self`.
    /// ## `class_name`
    /// class name to remove
    #[doc(alias = "gtk_style_context_remove_class")]
    fn remove_class(&self, class_name: &str) {
        unsafe {
            ffi::gtk_style_context_remove_class(
                self.as_ref().to_glib_none().0,
                class_name.to_glib_none().0,
            );
        }
    }

    /// Removes `provider` from the style providers list in `self`.
    /// ## `provider`
    /// a [`StyleProvider`][crate::StyleProvider]
    #[doc(alias = "gtk_style_context_remove_provider")]
    fn remove_provider(&self, provider: &impl IsA<StyleProvider>) {
        unsafe {
            ffi::gtk_style_context_remove_provider(
                self.as_ref().to_glib_none().0,
                provider.as_ref().to_glib_none().0,
            );
        }
    }

    /// Restores `self` state to a previous stage.
    /// See [`save()`][Self::save()].
    #[doc(alias = "gtk_style_context_restore")]
    fn restore(&self) {
        unsafe {
            ffi::gtk_style_context_restore(self.as_ref().to_glib_none().0);
        }
    }

    /// Saves the `self` state, so temporary modifications done through
    /// [`add_class()`][Self::add_class()], [`remove_class()`][Self::remove_class()],
    /// [`set_state()`][Self::set_state()], etc. can quickly be reverted
    /// in one go through [`restore()`][Self::restore()].
    ///
    /// The matching call to [`restore()`][Self::restore()] must be done
    /// before GTK returns to the main loop.
    #[doc(alias = "gtk_style_context_save")]
    fn save(&self) {
        unsafe {
            ffi::gtk_style_context_save(self.as_ref().to_glib_none().0);
        }
    }

    /// Attaches `self` to the given frame clock.
    ///
    /// The frame clock is used for the timing of animations.
    ///
    /// If you are using a [`StyleContext`][crate::StyleContext] returned from
    /// [`WidgetExt::style_context()`][crate::prelude::WidgetExt::style_context()], you do not need to
    /// call this yourself.
    /// ## `frame_clock`
    /// a [`gdk::FrameClock`][crate::gdk::FrameClock]
    #[doc(alias = "gtk_style_context_set_frame_clock")]
    fn set_frame_clock(&self, frame_clock: &gdk::FrameClock) {
        unsafe {
            ffi::gtk_style_context_set_frame_clock(
                self.as_ref().to_glib_none().0,
                frame_clock.to_glib_none().0,
            );
        }
    }

    /// Sets the sides where rendered elements (mostly through
    /// [`render_frame()`][crate::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`
    /// sides where rendered elements are visually connected to
    ///  other elements
    #[doc(alias = "gtk_style_context_set_junction_sides")]
    fn set_junction_sides(&self, sides: JunctionSides) {
        unsafe {
            ffi::gtk_style_context_set_junction_sides(
                self.as_ref().to_glib_none().0,
                sides.into_glib(),
            );
        }
    }

    /// Sets the parent style context for `self`. The parent style
    /// context is used to implement
    /// [inheritance](http://www.w3.org/TR/css3-cascade/`inheritance`)
    /// of properties.
    ///
    /// If you are using a [`StyleContext`][crate::StyleContext] returned from
    /// [`WidgetExt::style_context()`][crate::prelude::WidgetExt::style_context()], the parent will be set for you.
    /// ## `parent`
    /// the new parent or [`None`]
    #[doc(alias = "gtk_style_context_set_parent")]
    #[doc(alias = "parent")]
    fn set_parent(&self, parent: Option<&impl IsA<StyleContext>>) {
        unsafe {
            ffi::gtk_style_context_set_parent(
                self.as_ref().to_glib_none().0,
                parent.map(|p| p.as_ref()).to_glib_none().0,
            );
        }
    }

    /// Sets the [`WidgetPath`][crate::WidgetPath] used for style matching. As a
    /// consequence, the style will be regenerated to match
    /// the new given path.
    ///
    /// If you are using a [`StyleContext`][crate::StyleContext] returned from
    /// [`WidgetExt::style_context()`][crate::prelude::WidgetExt::style_context()], you do not need to call
    /// this yourself.
    /// ## `path`
    /// a [`WidgetPath`][crate::WidgetPath]
    #[doc(alias = "gtk_style_context_set_path")]
    fn set_path(&self, path: &WidgetPath) {
        unsafe {
            ffi::gtk_style_context_set_path(self.as_ref().to_glib_none().0, path.to_glib_none().0);
        }
    }

    /// Sets the scale to use when getting image assets for the style.
    /// ## `scale`
    /// scale
    #[doc(alias = "gtk_style_context_set_scale")]
    fn set_scale(&self, scale: i32) {
        unsafe {
            ffi::gtk_style_context_set_scale(self.as_ref().to_glib_none().0, scale);
        }
    }

    /// Attaches `self` to the given screen.
    ///
    /// The screen is used to add style information from “global” style
    /// providers, such as the screen’s [`Settings`][crate::Settings] instance.
    ///
    /// If you are using a [`StyleContext`][crate::StyleContext] returned from
    /// [`WidgetExt::style_context()`][crate::prelude::WidgetExt::style_context()], you do not need to
    /// call this yourself.
    /// ## `screen`
    /// a [`gdk::Screen`][crate::gdk::Screen]
    #[doc(alias = "gtk_style_context_set_screen")]
    #[doc(alias = "screen")]
    fn set_screen(&self, screen: &gdk::Screen) {
        unsafe {
            ffi::gtk_style_context_set_screen(
                self.as_ref().to_glib_none().0,
                screen.to_glib_none().0,
            );
        }
    }

    /// Sets the state to be used for style matching.
    /// ## `flags`
    /// state to represent
    #[doc(alias = "gtk_style_context_set_state")]
    fn set_state(&self, flags: StateFlags) {
        unsafe {
            ffi::gtk_style_context_set_state(self.as_ref().to_glib_none().0, flags.into_glib());
        }
    }

    /// 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 `self`. 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`
    /// Flags that determine what to print
    ///
    /// # Returns
    ///
    /// a newly allocated string representing `self`
    #[doc(alias = "gtk_style_context_to_string")]
    fn to_string(&self, flags: StyleContextPrintFlags) -> Option<glib::GString> {
        unsafe {
            from_glib_full(ffi::gtk_style_context_to_string(
                self.as_ref().to_glib_none().0,
                flags.into_glib(),
            ))
        }
    }

    fn direction(&self) -> TextDirection {
        ObjectExt::property(self.as_ref(), "direction")
    }

    fn set_direction(&self, direction: TextDirection) {
        ObjectExt::set_property(self.as_ref(), "direction", direction)
    }

    #[doc(alias = "paint-clock")]
    fn paint_clock(&self) -> Option<gdk::FrameClock> {
        ObjectExt::property(self.as_ref(), "paint-clock")
    }

    #[doc(alias = "paint-clock")]
    fn set_paint_clock(&self, paint_clock: Option<&gdk::FrameClock>) {
        ObjectExt::set_property(self.as_ref(), "paint-clock", paint_clock)
    }

    /// The ::changed signal is emitted when there is a change in the
    /// [`StyleContext`][crate::StyleContext].
    ///
    /// For a [`StyleContext`][crate::StyleContext] returned by [`WidgetExt::style_context()`][crate::prelude::WidgetExt::style_context()], the
    /// [`style-updated`][struct@crate::Widget#style-updated] signal/vfunc might be more convenient to use.
    ///
    /// This signal is useful when using the theming layer standalone.
    #[doc(alias = "changed")]
    fn connect_changed<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn changed_trampoline<P: IsA<StyleContext>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkStyleContext,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(StyleContext::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"changed".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    changed_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "direction")]
    fn connect_direction_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_direction_trampoline<
            P: IsA<StyleContext>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkStyleContext,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(StyleContext::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::direction".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_direction_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "paint-clock")]
    fn connect_paint_clock_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_paint_clock_trampoline<
            P: IsA<StyleContext>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkStyleContext,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(StyleContext::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::paint-clock".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_paint_clock_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "parent")]
    fn connect_parent_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_parent_trampoline<P: IsA<StyleContext>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkStyleContext,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(StyleContext::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::parent".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_parent_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "screen")]
    fn connect_screen_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_screen_trampoline<P: IsA<StyleContext>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkStyleContext,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(StyleContext::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::screen".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_screen_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

impl<O: IsA<StyleContext>> StyleContextExt for O {}