gtk/auto/

css_provider.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
#![allow(deprecated)]

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

glib::wrapper! {
    /// GtkCssProvider is an object implementing the [`StyleProvider`][crate::StyleProvider] interface.
    /// It is able to parse [CSS-like][css-overview] input in order to style widgets.
    ///
    /// An application can make GTK+ parse a specific CSS style sheet by calling
    /// [`CssProviderExt::load_from_file()`][crate::prelude::CssProviderExt::load_from_file()] or [`CssProviderExt::load_from_resource()`][crate::prelude::CssProviderExt::load_from_resource()]
    /// and adding the provider with [`StyleContextExt::add_provider()`][crate::prelude::StyleContextExt::add_provider()] or
    /// [`StyleContext::add_provider_for_screen()`][crate::StyleContext::add_provider_for_screen()].
    ///
    /// In addition, certain files will be read when GTK+ is initialized. First, the
    /// file `$XDG_CONFIG_HOME/gtk-3.0/gtk.css` is loaded if it exists. Then, GTK+
    /// loads the first existing file among
    /// `XDG_DATA_HOME/themes/THEME/gtk-VERSION/gtk.css`,
    /// `$HOME/.themes/THEME/gtk-VERSION/gtk.css`,
    /// `$XDG_DATA_DIRS/themes/THEME/gtk-VERSION/gtk.css` and
    /// `DATADIR/share/themes/THEME/gtk-VERSION/gtk.css`, where `THEME` is the name of
    /// the current theme (see the [`gtk-theme-name`][struct@crate::Settings#gtk-theme-name] setting), `DATADIR`
    /// is the prefix configured when GTK+ was compiled (unless overridden by the
    /// `GTK_DATA_PREFIX` environment variable), and `VERSION` is the GTK+ version number.
    /// If no file is found for the current version, GTK+ tries older versions all the
    /// way back to 3.0.
    ///
    /// In the same way, GTK+ tries to load a gtk-keys.css file for the current
    /// key theme, as defined by [`gtk-key-theme-name`][struct@crate::Settings#gtk-key-theme-name].
    ///
    /// ## Signals
    ///
    ///
    /// #### `parsing-error`
    ///  Signals that a parsing error occurred. the `path`, `line` and `position`
    /// describe the actual location of the error as accurately as possible.
    ///
    /// Parsing errors are never fatal, so the parsing will resume after
    /// the error. Errors may however cause parts of the given
    /// data or even all of it to not be parsed at all. So it is a useful idea
    /// to check that the parsing succeeds by connecting to this signal.
    ///
    /// Note that this signal may be emitted at any time as the css provider
    /// may opt to defer parsing parts or all of the input to a later time
    /// than when a loading function was called.
    ///
    ///
    ///
    /// # Implements
    ///
    /// [`CssProviderExt`][trait@crate::prelude::CssProviderExt], [`trait@glib::ObjectExt`], [`StyleProviderExt`][trait@crate::prelude::StyleProviderExt]
    #[doc(alias = "GtkCssProvider")]
    pub struct CssProvider(Object<ffi::GtkCssProvider, ffi::GtkCssProviderClass>) @implements StyleProvider;

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

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

    /// Returns a newly created [`CssProvider`][crate::CssProvider].
    ///
    /// # Returns
    ///
    /// A new [`CssProvider`][crate::CssProvider]
    #[doc(alias = "gtk_css_provider_new")]
    pub fn new() -> CssProvider {
        assert_initialized_main_thread!();
        unsafe { from_glib_full(ffi::gtk_css_provider_new()) }
    }

    /// Returns the provider containing the style settings used as a
    /// fallback for all widgets.
    ///
    /// # Deprecated since 3.24
    ///
    /// Use [`new()`][Self::new()] instead.
    ///
    /// # Returns
    ///
    /// The provider used for fallback styling.
    ///  This memory is owned by GTK+, and you must not free it.
    #[cfg_attr(feature = "v3_24", deprecated = "Since 3.24")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_css_provider_get_default")]
    #[doc(alias = "get_default")]
    #[allow(clippy::should_implement_trait)]
    pub fn default() -> Option<CssProvider> {
        assert_initialized_main_thread!();
        unsafe { from_glib_none(ffi::gtk_css_provider_get_default()) }
    }

    /// Loads a theme from the usual theme paths
    /// ## `name`
    /// A theme name
    /// ## `variant`
    /// variant to load, for example, "dark", or
    ///  [`None`] for the default
    ///
    /// # Returns
    ///
    /// a [`CssProvider`][crate::CssProvider] with the theme loaded.
    ///  This memory is owned by GTK+, and you must not free it.
    #[doc(alias = "gtk_css_provider_get_named")]
    #[doc(alias = "get_named")]
    pub fn named(name: &str, variant: Option<&str>) -> Option<CssProvider> {
        assert_initialized_main_thread!();
        unsafe {
            from_glib_none(ffi::gtk_css_provider_get_named(
                name.to_glib_none().0,
                variant.to_glib_none().0,
            ))
        }
    }
}

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

impl std::fmt::Display for CssProvider {
    #[inline]
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.write_str(&CssProviderExt::to_str(self))
    }
}

/// Trait containing all [`struct@CssProvider`] methods.
///
/// # Implementors
///
/// [`CssProvider`][struct@crate::CssProvider]
pub trait CssProviderExt: IsA<CssProvider> + 'static {
    /// Loads `data` into `self`, and by doing so clears any previously loaded
    /// information.
    /// ## `data`
    /// CSS data loaded in memory
    ///
    /// # Returns
    ///
    /// [`true`]. The return value is deprecated and [`false`] will only be
    ///  returned for backwards compatibility reasons if an `error` is not
    ///  [`None`] and a loading error occurred. To track errors while loading
    ///  CSS, connect to the [`parsing-error`][struct@crate::CssProvider#parsing-error] signal.
    #[doc(alias = "gtk_css_provider_load_from_data")]
    fn load_from_data(&self, data: &[u8]) -> Result<(), glib::Error> {
        let length = data.len() as _;
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::gtk_css_provider_load_from_data(
                self.as_ref().to_glib_none().0,
                data.to_glib_none().0,
                length,
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Loads the data contained in `file` into `self`, making it
    /// clear any previously loaded information.
    /// ## `file`
    /// [`gio::File`][crate::gio::File] pointing to a file to load
    ///
    /// # Returns
    ///
    /// [`true`]. The return value is deprecated and [`false`] will only be
    ///  returned for backwards compatibility reasons if an `error` is not
    ///  [`None`] and a loading error occurred. To track errors while loading
    ///  CSS, connect to the [`parsing-error`][struct@crate::CssProvider#parsing-error] signal.
    #[doc(alias = "gtk_css_provider_load_from_file")]
    fn load_from_file(&self, file: &impl IsA<gio::File>) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::gtk_css_provider_load_from_file(
                self.as_ref().to_glib_none().0,
                file.as_ref().to_glib_none().0,
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Loads the data contained in `path` into `self`, making it clear
    /// any previously loaded information.
    /// ## `path`
    /// the path of a filename to load, in the GLib filename encoding
    ///
    /// # Returns
    ///
    /// [`true`]. The return value is deprecated and [`false`] will only be
    ///  returned for backwards compatibility reasons if an `error` is not
    ///  [`None`] and a loading error occurred. To track errors while loading
    ///  CSS, connect to the [`parsing-error`][struct@crate::CssProvider#parsing-error] signal.
    #[doc(alias = "gtk_css_provider_load_from_path")]
    fn load_from_path(&self, path: &str) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::gtk_css_provider_load_from_path(
                self.as_ref().to_glib_none().0,
                path.to_glib_none().0,
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Loads the data contained in the resource at `resource_path` into
    /// the [`CssProvider`][crate::CssProvider], clearing any previously loaded information.
    ///
    /// To track errors while loading CSS, connect to the
    /// [`parsing-error`][struct@crate::CssProvider#parsing-error] signal.
    /// ## `resource_path`
    /// a `GResource` resource path
    #[doc(alias = "gtk_css_provider_load_from_resource")]
    fn load_from_resource(&self, resource_path: &str) {
        unsafe {
            ffi::gtk_css_provider_load_from_resource(
                self.as_ref().to_glib_none().0,
                resource_path.to_glib_none().0,
            );
        }
    }

    /// Converts the `self` into a string representation in CSS
    /// format.
    ///
    /// Using [`load_from_data()`][Self::load_from_data()] with the return value
    /// from this function on a new provider created with
    /// [`CssProvider::new()`][crate::CssProvider::new()] will basically create a duplicate of
    /// this `self`.
    ///
    /// # Returns
    ///
    /// a new string representing the `self`.
    #[doc(alias = "gtk_css_provider_to_string")]
    #[doc(alias = "to_string")]
    fn to_str(&self) -> glib::GString {
        unsafe {
            from_glib_full(ffi::gtk_css_provider_to_string(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Signals that a parsing error occurred. the `path`, `line` and `position`
    /// describe the actual location of the error as accurately as possible.
    ///
    /// Parsing errors are never fatal, so the parsing will resume after
    /// the error. Errors may however cause parts of the given
    /// data or even all of it to not be parsed at all. So it is a useful idea
    /// to check that the parsing succeeds by connecting to this signal.
    ///
    /// Note that this signal may be emitted at any time as the css provider
    /// may opt to defer parsing parts or all of the input to a later time
    /// than when a loading function was called.
    /// ## `section`
    /// section the error happened in
    /// ## `error`
    /// The parsing error
    #[doc(alias = "parsing-error")]
    fn connect_parsing_error<F: Fn(&Self, &CssSection, &glib::Error) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn parsing_error_trampoline<
            P: IsA<CssProvider>,
            F: Fn(&P, &CssSection, &glib::Error) + 'static,
        >(
            this: *mut ffi::GtkCssProvider,
            section: *mut ffi::GtkCssSection,
            error: *mut glib::ffi::GError,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(
                    CssProvider::from_glib_borrow(this).unsafe_cast_ref(),
                    &from_glib_borrow(section),
                    &from_glib_borrow(error),
                )
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"parsing-error".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    parsing_error_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

impl<O: IsA<CssProvider>> CssProviderExt for O {}