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

use crate::ColorScheme;
use glib::{
    prelude::*,
    signal::{connect_raw, SignalHandlerId},
    translate::*,
};
use std::{boxed::Box as Box_, fmt, mem::transmute};

glib::wrapper! {
    /// A class for managing application-wide styling.
    ///
    /// [`StyleManager`][crate::StyleManager] provides a way to query and influence the application
    /// styles, such as whether to use dark or high contrast appearance.
    ///
    /// It allows to set the color scheme via the
    /// [`color-scheme`][struct@crate::StyleManager#color-scheme] property, and to query the current
    /// appearance, as well as whether a system-wide color scheme preference exists.
    ///
    /// Important: [`gtk-application-prefer-dark-theme`][struct@crate::Gtk::Settings#gtk-application-prefer-dark-theme] should
    /// not be used together with [`StyleManager`][crate::StyleManager] and will result in a warning.
    /// Color schemes should be used instead.
    ///
    /// ## Properties
    ///
    ///
    /// #### `color-scheme`
    ///  The requested application color scheme.
    ///
    /// The effective appearance will be decided based on the application color
    /// scheme and the system preferred color scheme. The
    /// [`dark`][struct@crate::StyleManager#dark] property can be used to query the current
    /// effective appearance.
    ///
    /// The `HDY_COLOR_SCHEME_PREFER_LIGHT` color scheme results in the application
    /// using light appearance unless the system prefers dark colors. This is the
    /// default value.
    ///
    /// The `HDY_COLOR_SCHEME_PREFER_DARK` color scheme results in the application
    /// using dark appearance, but can still switch to the light appearance if the
    /// system can prefers it, for example, when the high contrast preference is
    /// enabled.
    ///
    /// The `HDY_COLOR_SCHEME_FORCE_LIGHT` and `HDY_COLOR_SCHEME_FORCE_DARK` values
    /// ignore the system preference entirely, they are useful if the application
    /// wants to match its UI to its content or to provide a separate color scheme
    /// switcher.
    ///
    /// If a per-[`gdk::Display`][crate::gdk::Display] style manager has its color scheme set to
    /// `HDY_COLOR_SCHEME_DEFAULT`, it will inherit the color scheme from the
    /// default style manager.
    ///
    /// For the default style manager, `HDY_COLOR_SCHEME_DEFAULT` is equivalent to
    /// `HDY_COLOR_SCHEME_FORCE_LIGHT`.
    ///
    /// The [`system-supports-color-schemes`][struct@crate::StyleManager#system-supports-color-schemes] property can be
    /// used to check if the current environment provides a color scheme
    /// preference.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `dark`
    ///  Whether the application is using dark appearance.
    ///
    /// This property can be used to query the current appearance, as requested via
    /// [`color-scheme`][struct@crate::StyleManager#color-scheme].
    ///
    /// Readable
    ///
    ///
    /// #### `display`
    ///  The display the style manager is associated with.
    ///
    /// The display will be `NULL` for the style manager returned by
    /// `get_default()`.
    ///
    /// Readable | Writeable | Construct Only
    ///
    ///
    /// #### `high-contrast`
    ///  Whether the application is using high contrast appearance.
    ///
    /// This cannot be overridden by applications.
    ///
    /// Readable
    ///
    ///
    /// #### `system-supports-color-schemes`
    ///  Whether the system supports color schemes.
    ///
    /// This property can be used to check if the current environment provides a
    /// color scheme preference. For example, applications might want to show a
    /// separate appearance switcher if it's set to `FALSE`.
    ///
    /// It's only set at startup and cannot change its value later.
    ///
    /// See [`color-scheme`][struct@crate::StyleManager#color-scheme].
    ///
    /// Readable
    ///
    /// # Implements
    ///
    /// [`trait@glib::ObjectExt`]
    #[doc(alias = "HdyStyleManager")]
    pub struct StyleManager(Object<ffi::HdyStyleManager, ffi::HdyStyleManagerClass>);

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

impl StyleManager {
    /// Gets the requested application color scheme.
    ///
    /// # Returns
    ///
    /// the color scheme
    #[doc(alias = "hdy_style_manager_get_color_scheme")]
    #[doc(alias = "get_color_scheme")]
    pub fn color_scheme(&self) -> ColorScheme {
        unsafe {
            from_glib(ffi::hdy_style_manager_get_color_scheme(
                self.to_glib_none().0,
            ))
        }
    }

    /// Gets whether the application is using dark appearance.
    ///
    /// # Returns
    ///
    /// whether the application is using dark appearance
    #[doc(alias = "hdy_style_manager_get_dark")]
    #[doc(alias = "get_dark")]
    pub fn is_dark(&self) -> bool {
        unsafe { from_glib(ffi::hdy_style_manager_get_dark(self.to_glib_none().0)) }
    }

    /// Gets the display the style manager is associated with.
    ///
    /// The display will be `NULL` for the style manager returned by
    /// `get_default()`.
    ///
    /// # Returns
    ///
    /// (nullable): the display
    #[doc(alias = "hdy_style_manager_get_display")]
    #[doc(alias = "get_display")]
    pub fn display(&self) -> Option<gdk::Display> {
        unsafe { from_glib_none(ffi::hdy_style_manager_get_display(self.to_glib_none().0)) }
    }

    /// Gets whether the application is using high contrast appearance.
    ///
    /// # Returns
    ///
    /// whether the application is using high contrast appearance
    #[doc(alias = "hdy_style_manager_get_high_contrast")]
    #[doc(alias = "get_high_contrast")]
    pub fn is_high_contrast(&self) -> bool {
        unsafe {
            from_glib(ffi::hdy_style_manager_get_high_contrast(
                self.to_glib_none().0,
            ))
        }
    }

    /// Gets whether the system supports color schemes.
    ///
    /// # Returns
    ///
    /// whether the system supports color schemes
    #[doc(alias = "hdy_style_manager_get_system_supports_color_schemes")]
    #[doc(alias = "get_system_supports_color_schemes")]
    pub fn system_supports_color_schemes(&self) -> bool {
        unsafe {
            from_glib(ffi::hdy_style_manager_get_system_supports_color_schemes(
                self.to_glib_none().0,
            ))
        }
    }

    /// Sets the requested application color scheme.
    ///
    /// The effective appearance will be decided based on the application color
    /// scheme and the system preferred color scheme. The
    /// [`dark`][struct@crate::StyleManager#dark] property can be used to query the current
    /// effective appearance.
    /// ## `color_scheme`
    /// the color scheme
    #[doc(alias = "hdy_style_manager_set_color_scheme")]
    pub fn set_color_scheme(&self, color_scheme: ColorScheme) {
        unsafe {
            ffi::hdy_style_manager_set_color_scheme(
                self.to_glib_none().0,
                color_scheme.into_glib(),
            );
        }
    }

    /// Gets the default [`StyleManager`][crate::StyleManager] instance.
    ///
    /// It manages all [`gdk::Display`][crate::gdk::Display] instances unless the style manager for
    /// that display has an override.
    ///
    /// See `get_for_display()`.
    ///
    /// # Returns
    ///
    /// the default style manager
    #[doc(alias = "hdy_style_manager_get_default")]
    #[doc(alias = "get_default")]
    #[allow(clippy::should_implement_trait)]
    pub fn default() -> Option<StyleManager> {
        assert_initialized_main_thread!();
        unsafe { from_glib_none(ffi::hdy_style_manager_get_default()) }
    }

    /// Gets the [`StyleManager`][crate::StyleManager] instance managing @display.
    ///
    /// It can be used to override styles for that specific display instead of the
    /// whole application.
    ///
    /// Most applications should use `get_default()` instead.
    /// ## `display`
    /// a display
    ///
    /// # Returns
    ///
    /// the style manager for @display
    #[doc(alias = "hdy_style_manager_get_for_display")]
    #[doc(alias = "get_for_display")]
    pub fn for_display(display: &gdk::Display) -> Option<StyleManager> {
        assert_initialized_main_thread!();
        unsafe {
            from_glib_none(ffi::hdy_style_manager_get_for_display(
                display.to_glib_none().0,
            ))
        }
    }

    #[cfg(feature = "v1_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
    #[doc(alias = "color-scheme")]
    pub fn connect_color_scheme_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_color_scheme_trampoline<F: Fn(&StyleManager) + 'static>(
            this: *mut ffi::HdyStyleManager,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::color-scheme\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_color_scheme_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[cfg(feature = "v1_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
    #[doc(alias = "dark")]
    pub fn connect_dark_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_dark_trampoline<F: Fn(&StyleManager) + 'static>(
            this: *mut ffi::HdyStyleManager,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::dark\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_dark_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[cfg(feature = "v1_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
    #[doc(alias = "high-contrast")]
    pub fn connect_high_contrast_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_high_contrast_trampoline<F: Fn(&StyleManager) + 'static>(
            this: *mut ffi::HdyStyleManager,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::high-contrast\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_high_contrast_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[cfg(feature = "v1_6")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_6")))]
    #[doc(alias = "system-supports-color-schemes")]
    pub fn connect_system_supports_color_schemes_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_system_supports_color_schemes_trampoline<
            F: Fn(&StyleManager) + 'static,
        >(
            this: *mut ffi::HdyStyleManager,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::system-supports-color-schemes\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_system_supports_color_schemes_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

impl fmt::Display for StyleManager {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.write_str("StyleManager")
    }
}