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

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

glib::wrapper! {
    ///
    ///
    /// ## Properties
    ///
    ///
    /// #### `enable-matrix`
    ///  Whether the [`matrix`][struct@crate::SpaceDrawer#matrix] property is enabled.
    ///
    /// Readable | Writeable | Construct
    ///
    ///
    /// #### `matrix`
    ///  The :matrix property is a [`glib::Variant`][struct@crate::glib::Variant] property to specify where and
    /// what kind of white spaces to draw.
    ///
    /// The [`glib::Variant`][struct@crate::glib::Variant] is of type `"au"`, an array of unsigned integers. Each
    /// integer is a combination of [`SpaceTypeFlags`][crate::SpaceTypeFlags]. There is one
    /// integer for each [`SpaceLocationFlags`][crate::SpaceLocationFlags], in the same order as
    /// they are defined in the enum ([`SpaceLocationFlags::NONE`][crate::SpaceLocationFlags::NONE] and
    /// [`SpaceLocationFlags::ALL`][crate::SpaceLocationFlags::ALL] are not taken into account).
    ///
    /// If the array is shorter than the number of locations, then the value
    /// for the missing locations will be [`SpaceTypeFlags::NONE`][crate::SpaceTypeFlags::NONE].
    ///
    /// By default, [`SpaceTypeFlags::ALL`][crate::SpaceTypeFlags::ALL] is set for all locations.
    ///
    /// Readable | Writeable | Construct
    ///
    /// # Implements
    ///
    /// [`SpaceDrawerExt`][trait@crate::prelude::SpaceDrawerExt]
    #[doc(alias = "GtkSourceSpaceDrawer")]
    pub struct SpaceDrawer(Object<ffi::GtkSourceSpaceDrawer, ffi::GtkSourceSpaceDrawerClass>);

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

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

    /// Creates a new [`SpaceDrawer`][crate::SpaceDrawer] object. Useful for storing space drawing
    /// settings independently of a [`View`][crate::View].
    ///
    /// # Returns
    ///
    /// a new [`SpaceDrawer`][crate::SpaceDrawer].
    #[doc(alias = "gtk_source_space_drawer_new")]
    pub fn new() -> SpaceDrawer {
        assert_initialized_main_thread!();
        unsafe { from_glib_full(ffi::gtk_source_space_drawer_new()) }
    }

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

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

// rustdoc-stripper-ignore-next
/// A [builder-pattern] type to construct [`SpaceDrawer`] 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 SpaceDrawerBuilder {
    builder: glib::object::ObjectBuilder<'static, SpaceDrawer>,
}

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

    /// Whether the [`matrix`][struct@crate::SpaceDrawer#matrix] property is enabled.
    pub fn enable_matrix(self, enable_matrix: bool) -> Self {
        Self {
            builder: self.builder.property("enable-matrix", enable_matrix),
        }
    }

    /// The :matrix property is a [`glib::Variant`][struct@crate::glib::Variant] property to specify where and
    /// what kind of white spaces to draw.
    ///
    /// The [`glib::Variant`][struct@crate::glib::Variant] is of type `"au"`, an array of unsigned integers. Each
    /// integer is a combination of [`SpaceTypeFlags`][crate::SpaceTypeFlags]. There is one
    /// integer for each [`SpaceLocationFlags`][crate::SpaceLocationFlags], in the same order as
    /// they are defined in the enum ([`SpaceLocationFlags::NONE`][crate::SpaceLocationFlags::NONE] and
    /// [`SpaceLocationFlags::ALL`][crate::SpaceLocationFlags::ALL] are not taken into account).
    ///
    /// If the array is shorter than the number of locations, then the value
    /// for the missing locations will be [`SpaceTypeFlags::NONE`][crate::SpaceTypeFlags::NONE].
    ///
    /// By default, [`SpaceTypeFlags::ALL`][crate::SpaceTypeFlags::ALL] is set for all locations.
    pub fn matrix(self, matrix: &glib::Variant) -> Self {
        Self {
            builder: self.builder.property("matrix", matrix.clone()),
        }
    }

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

mod sealed {
    pub trait Sealed {}
    impl<T: super::IsA<super::SpaceDrawer>> Sealed for T {}
}

/// Trait containing all [`struct@SpaceDrawer`] methods.
///
/// # Implementors
///
/// [`SpaceDrawer`][struct@crate::SpaceDrawer]
pub trait SpaceDrawerExt: IsA<SpaceDrawer> + sealed::Sealed + 'static {
    /// Binds the [`matrix`][struct@crate::SpaceDrawer#matrix] property to a [`gio::Settings`][crate::gio::Settings] key.
    ///
    /// The [`gio::Settings`][crate::gio::Settings] key must be of the same type as the
    /// [`matrix`][struct@crate::SpaceDrawer#matrix] property, that is, `"au"`.
    ///
    /// The [`SettingsExtManual::bind()`][crate::gio::prelude::SettingsExtManual::bind()] function cannot be used, because the default GIO
    /// mapping functions don't support [`glib::Variant`][struct@crate::glib::Variant] properties (maybe it will be
    /// supported by a future GIO version, in which case this function can be
    /// deprecated).
    /// ## `settings`
    /// a [`gio::Settings`][crate::gio::Settings] object.
    /// ## `key`
    /// the `settings` key to bind.
    /// ## `flags`
    /// flags for the binding.
    #[doc(alias = "gtk_source_space_drawer_bind_matrix_setting")]
    fn bind_matrix_setting(
        &self,
        settings: &impl IsA<gio::Settings>,
        key: &str,
        flags: gio::SettingsBindFlags,
    ) {
        unsafe {
            ffi::gtk_source_space_drawer_bind_matrix_setting(
                self.as_ref().to_glib_none().0,
                settings.as_ref().to_glib_none().0,
                key.to_glib_none().0,
                flags.into_glib(),
            );
        }
    }

    ///
    /// # Returns
    ///
    /// whether the [`matrix`][struct@crate::SpaceDrawer#matrix] property is enabled.
    #[doc(alias = "gtk_source_space_drawer_get_enable_matrix")]
    #[doc(alias = "get_enable_matrix")]
    fn enables_matrix(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_source_space_drawer_get_enable_matrix(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the value of the [`matrix`][struct@crate::SpaceDrawer#matrix] property, as a [`glib::Variant`][struct@crate::glib::Variant].
    /// An empty array can be returned in case the matrix is a zero matrix.
    ///
    /// The [`types_for_locations()`][Self::types_for_locations()] function may be more
    /// convenient to use.
    ///
    /// # Returns
    ///
    /// the [`matrix`][struct@crate::SpaceDrawer#matrix] value as a new floating [`glib::Variant`][struct@crate::glib::Variant]
    ///  instance.
    #[doc(alias = "gtk_source_space_drawer_get_matrix")]
    #[doc(alias = "get_matrix")]
    fn matrix(&self) -> Option<glib::Variant> {
        unsafe {
            from_glib_full(ffi::gtk_source_space_drawer_get_matrix(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// If only one location is specified, this function returns what kind of
    /// white spaces are drawn at that location. The value is retrieved from the
    /// [`matrix`][struct@crate::SpaceDrawer#matrix] property.
    ///
    /// If several locations are specified, this function returns the logical AND for
    /// those locations. Which means that if a certain kind of white space is present
    /// in the return value, then that kind of white space is drawn at all the
    /// specified `locations`.
    /// ## `locations`
    /// one or several [`SpaceLocationFlags`][crate::SpaceLocationFlags].
    ///
    /// # Returns
    ///
    /// a combination of [`SpaceTypeFlags`][crate::SpaceTypeFlags].
    #[doc(alias = "gtk_source_space_drawer_get_types_for_locations")]
    #[doc(alias = "get_types_for_locations")]
    fn types_for_locations(&self, locations: SpaceLocationFlags) -> SpaceTypeFlags {
        unsafe {
            from_glib(ffi::gtk_source_space_drawer_get_types_for_locations(
                self.as_ref().to_glib_none().0,
                locations.into_glib(),
            ))
        }
    }

    /// Sets whether the [`matrix`][struct@crate::SpaceDrawer#matrix] property is enabled.
    /// ## `enable_matrix`
    /// the new value.
    #[doc(alias = "gtk_source_space_drawer_set_enable_matrix")]
    fn set_enable_matrix(&self, enable_matrix: bool) {
        unsafe {
            ffi::gtk_source_space_drawer_set_enable_matrix(
                self.as_ref().to_glib_none().0,
                enable_matrix.into_glib(),
            );
        }
    }

    /// Sets a new value to the [`matrix`][struct@crate::SpaceDrawer#matrix] property, as a
    /// [`glib::Variant`][struct@crate::glib::Variant]. If `matrix` is [`None`], then an empty array is set.
    ///
    /// If `matrix` is floating, it is consumed.
    ///
    /// The [`set_types_for_locations()`][Self::set_types_for_locations()] function may be more
    /// convenient to use.
    /// ## `matrix`
    /// the new matrix value, or [`None`].
    #[doc(alias = "gtk_source_space_drawer_set_matrix")]
    fn set_matrix(&self, matrix: Option<&glib::Variant>) {
        unsafe {
            ffi::gtk_source_space_drawer_set_matrix(
                self.as_ref().to_glib_none().0,
                matrix.to_glib_none().0,
            );
        }
    }

    /// Modifies the [`matrix`][struct@crate::SpaceDrawer#matrix] property at the specified
    /// `locations`.
    /// ## `locations`
    /// one or several [`SpaceLocationFlags`][crate::SpaceLocationFlags].
    /// ## `types`
    /// a combination of [`SpaceTypeFlags`][crate::SpaceTypeFlags].
    #[doc(alias = "gtk_source_space_drawer_set_types_for_locations")]
    fn set_types_for_locations(&self, locations: SpaceLocationFlags, types: SpaceTypeFlags) {
        unsafe {
            ffi::gtk_source_space_drawer_set_types_for_locations(
                self.as_ref().to_glib_none().0,
                locations.into_glib(),
                types.into_glib(),
            );
        }
    }

    #[doc(alias = "enable-matrix")]
    fn connect_enable_matrix_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_enable_matrix_trampoline<
            P: IsA<SpaceDrawer>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkSourceSpaceDrawer,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(SpaceDrawer::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::enable-matrix\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_enable_matrix_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "matrix")]
    fn connect_matrix_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_matrix_trampoline<P: IsA<SpaceDrawer>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkSourceSpaceDrawer,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(SpaceDrawer::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::matrix\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_matrix_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

impl<O: IsA<SpaceDrawer>> SpaceDrawerExt for O {}

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