gtk4/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::{ffi, CssSection, StyleProvider};
use glib::{
    prelude::*,
    signal::{connect_raw, SignalHandlerId},
    translate::*,
};
use std::boxed::Box as Box_;

glib::wrapper! {
    /// [`CssProvider`][crate::CssProvider] is an object implementing the [`StyleProvider`][crate::StyleProvider] interface
    /// for CSS.
    ///
    /// It is able to parse CSS-like input in order to style widgets.
    ///
    /// An application can make GTK parse a specific CSS style sheet by calling
    /// [`load_from_file()`][Self::load_from_file()] or
    /// [`load_from_resource()`][Self::load_from_resource()]
    /// and adding the provider with [`StyleContextExt::add_provider()`][crate::prelude::StyleContextExt::add_provider()] or
    /// [`StyleContext::add_provider_for_display()`][crate::StyleContext::add_provider_for_display()].
    ///
    /// In addition, certain files will be read when GTK is initialized.
    /// First, the file `$XDG_CONFIG_HOME/gtk-4.0/gtk.css` is loaded if it
    /// exists. Then, GTK loads the first existing file among
    /// `XDG_DATA_HOME/themes/THEME/gtk-VERSION/gtk-VARIANT.css`,
    /// `$HOME/.themes/THEME/gtk-VERSION/gtk-VARIANT.css`,
    /// `$XDG_DATA_DIRS/themes/THEME/gtk-VERSION/gtk-VARIANT.css` and
    /// `DATADIR/share/themes/THEME/gtk-VERSION/gtk-VARIANT.css`,
    /// where `THEME` is the name of the current theme (see the
    /// [`gtk-theme-name`][struct@crate::Settings#gtk-theme-name] setting), `VARIANT` is the
    /// variant to load (see the
    /// [`gtk-application-prefer-dark-theme`][struct@crate::Settings#gtk-application-prefer-dark-theme] 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 4.0.
    ///
    /// To track errors while loading CSS, connect to the
    /// [`parsing-error`][struct@crate::CssProvider#parsing-error] signal.
    ///
    /// ## Signals
    ///
    ///
    /// #### `parsing-error`
    ///  Signals that a parsing error occurred.
    ///
    /// The expected error values are in the [`CssParserError`][crate::CssParserError]
    /// and [`CssParserWarning`][crate::CssParserWarning] enumerations.
    ///
    /// 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.
    ///
    /// Errors in the [`CssParserWarning`][crate::CssParserWarning] enumeration should not
    /// be treated as fatal errors.
    ///
    /// 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.
    ///
    ///
    /// <details><summary><h4>StyleProvider</h4></summary>
    ///
    ///
    /// #### `gtk-private-changed`
    ///
    /// </details>
    ///
    /// # Implements
    ///
    /// [`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 {
    /// 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()) }
    }

    /// Loads @data into @self.
    ///
    /// This clears any previously loaded information.
    /// ## `data`
    /// `GBytes` containing the data to load
    #[cfg(feature = "v4_12")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
    #[doc(alias = "gtk_css_provider_load_from_bytes")]
    pub fn load_from_bytes(&self, data: &glib::Bytes) {
        unsafe {
            ffi::gtk_css_provider_load_from_bytes(self.to_glib_none().0, data.to_glib_none().0);
        }
    }

    /// Loads @data into @self.
    ///
    /// This clears any previously loaded information.
    ///
    /// # Deprecated since 4.12
    ///
    /// Use [`load_from_string()`][Self::load_from_string()]
    ///   or [`load_from_bytes()`][Self::load_from_bytes()] instead
    /// ## `data`
    /// CSS data to be parsed
    /// ## `length`
    /// the length of @data in bytes, or -1 for NUL terminated strings
    #[cfg_attr(feature = "v4_12", deprecated = "Since 4.12")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_css_provider_load_from_data")]
    pub fn load_from_data(&self, data: &str) {
        let length = data.len() as _;
        unsafe {
            ffi::gtk_css_provider_load_from_data(
                self.to_glib_none().0,
                data.to_glib_none().0,
                length,
            );
        }
    }

    /// Loads the data contained in @file into @self.
    ///
    /// This clears any previously loaded information.
    /// ## `file`
    /// `GFile` pointing to a file to load
    #[doc(alias = "gtk_css_provider_load_from_file")]
    pub fn load_from_file(&self, file: &impl IsA<gio::File>) {
        unsafe {
            ffi::gtk_css_provider_load_from_file(
                self.to_glib_none().0,
                file.as_ref().to_glib_none().0,
            );
        }
    }

    /// Loads the data contained in @path into @self.
    ///
    /// This clears any previously loaded information.
    /// ## `path`
    /// the path of a filename to load, in the GLib filename encoding
    #[doc(alias = "gtk_css_provider_load_from_path")]
    pub fn load_from_path(&self, path: impl AsRef<std::path::Path>) {
        unsafe {
            ffi::gtk_css_provider_load_from_path(
                self.to_glib_none().0,
                path.as_ref().to_glib_none().0,
            );
        }
    }

    /// Loads the data contained in the resource at @resource_path into
    /// the @self.
    ///
    /// This clears any previously loaded information.
    /// ## `resource_path`
    /// a `GResource` resource path
    #[doc(alias = "gtk_css_provider_load_from_resource")]
    pub fn load_from_resource(&self, resource_path: &str) {
        unsafe {
            ffi::gtk_css_provider_load_from_resource(
                self.to_glib_none().0,
                resource_path.to_glib_none().0,
            );
        }
    }

    /// Loads @string into @self.
    ///
    /// This clears any previously loaded information.
    /// ## `string`
    /// the CSS to load
    #[cfg(feature = "v4_12")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
    #[doc(alias = "gtk_css_provider_load_from_string")]
    pub fn load_from_string(&self, string: &str) {
        unsafe {
            ffi::gtk_css_provider_load_from_string(self.to_glib_none().0, string.to_glib_none().0);
        }
    }

    /// Loads a theme from the usual theme paths.
    ///
    /// The actual process of finding the theme might change between
    /// releases, but it is guaranteed that this function uses the same
    /// mechanism to load the theme that GTK uses for loading its own theme.
    /// ## `name`
    /// A theme name
    /// ## `variant`
    /// variant to load, for example, "dark", or
    ///   [`None`] for the default
    #[doc(alias = "gtk_css_provider_load_named")]
    pub fn load_named(&self, name: &str, variant: Option<&str>) {
        unsafe {
            ffi::gtk_css_provider_load_named(
                self.to_glib_none().0,
                name.to_glib_none().0,
                variant.to_glib_none().0,
            );
        }
    }

    /// Converts the @self into a string representation in CSS
    /// format.
    ///
    /// Using [`load_from_string()`][Self::load_from_string()] with the return
    /// value from this function on a new provider created with
    /// [`new()`][Self::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")]
    pub fn to_str(&self) -> glib::GString {
        unsafe { from_glib_full(ffi::gtk_css_provider_to_string(self.to_glib_none().0)) }
    }

    /// Signals that a parsing error occurred.
    ///
    /// The expected error values are in the [`CssParserError`][crate::CssParserError]
    /// and [`CssParserWarning`][crate::CssParserWarning] enumerations.
    ///
    /// 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.
    ///
    /// Errors in the [`CssParserWarning`][crate::CssParserWarning] enumeration should not
    /// be treated as fatal errors.
    ///
    /// 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")]
    pub fn connect_parsing_error<F: Fn(&Self, &CssSection, &glib::Error) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn parsing_error_trampoline<
            F: Fn(&CssProvider, &CssSection, &glib::Error) + 'static,
        >(
            this: *mut ffi::GtkCssProvider,
            section: *mut ffi::GtkCssSection,
            error: *mut glib::ffi::GError,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(
                &from_glib_borrow(this),
                &from_glib_borrow(section),
                &from_glib_borrow(error),
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"parsing-error\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    parsing_error_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

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(&self.to_str())
    }
}