// 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 glib::{
    prelude::*,
    signal::{connect_raw, SignalHandlerId},
    translate::*,
};
use std::{boxed::Box as Box_, fmt, mem::transmute};

glib::wrapper! {
    ///
    ///
    /// ## Properties
    ///
    ///
    /// #### `child`
    ///  Readable
    ///
    ///
    /// #### `child-property-name`
    ///  Readable
    ///
    ///
    /// #### `container`
    ///  Readable
    /// <details><summary><h4>Action</h4></summary>
    ///
    ///
    /// #### `enabled`
    ///  If `action` is currently enabled.
    ///
    /// If the action is disabled then calls to [`ActionExtManual::activate()`][crate::gio::prelude::ActionExtManual::activate()] and
    /// [`ActionExtManual::change_state()`][crate::gio::prelude::ActionExtManual::change_state()] have no effect.
    ///
    /// Readable
    ///
    ///
    /// #### `name`
    ///  The name of the action. This is mostly meaningful for identifying
    /// the action once it has been added to a [`gio::ActionGroup`][crate::gio::ActionGroup]. It is immutable.
    ///
    /// Readable
    ///
    ///
    /// #### `parameter-type`
    ///  The type of the parameter that must be given when activating the
    /// action. This is immutable, and may be [`None`] if no parameter is needed when
    /// activating the action.
    ///
    /// Readable
    ///
    ///
    /// #### `state`
    ///  The state of the action, or [`None`] if the action is stateless.
    ///
    /// Readable
    ///
    ///
    /// #### `state-type`
    ///  The [`glib::VariantType`][crate::glib::VariantType] of the state that the action has, or [`None`] if the
    /// action is stateless. This is immutable.
    ///
    /// Readable
    /// </details>
    ///
    /// # Implements
    ///
    /// [`trait@glib::ObjectExt`], [`trait@gio::prelude::ActionExt`]
    #[doc(alias = "DzlChildPropertyAction")]
    pub struct ChildPropertyAction(Object<ffi::DzlChildPropertyAction, ffi::DzlChildPropertyActionClass>) @implements gio::Action;

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

impl ChildPropertyAction {
    pub fn child(&self) -> Option<gtk::Widget> {
        ObjectExt::property(self, "child")
    }

    #[doc(alias = "child-property-name")]
    pub fn child_property_name(&self) -> Option<glib::GString> {
        ObjectExt::property(self, "child-property-name")
    }

    pub fn container(&self) -> Option<gtk::Container> {
        ObjectExt::property(self, "container")
    }

    /// This creates a new [`gio::Action`][crate::gio::Action] that will change when the underlying child
    /// property of `container` changes for `child`.
    /// ## `name`
    /// the name of the action
    /// ## `container`
    /// the container of the widget
    /// ## `child`
    /// the widget for the child property
    /// ## `child_property_name`
    /// the name of the child property
    ///
    /// # Returns
    ///
    /// A new [`ChildPropertyAction`][crate::ChildPropertyAction].
    #[doc(alias = "dzl_child_property_action_new")]
    pub fn new(
        name: &str,
        container: &impl IsA<gtk::Container>,
        child: &impl IsA<gtk::Widget>,
        child_property_name: &str,
    ) -> Option<gio::Action> {
        assert_initialized_main_thread!();
        unsafe {
            from_glib_full(ffi::dzl_child_property_action_new(
                name.to_glib_none().0,
                container.as_ref().to_glib_none().0,
                child.as_ref().to_glib_none().0,
                child_property_name.to_glib_none().0,
            ))
        }
    }

    #[doc(alias = "child")]
    pub fn connect_child_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_child_trampoline<F: Fn(&ChildPropertyAction) + 'static>(
            this: *mut ffi::DzlChildPropertyAction,
            _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::child\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_child_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "child-property-name")]
    pub fn connect_child_property_name_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_child_property_name_trampoline<
            F: Fn(&ChildPropertyAction) + 'static,
        >(
            this: *mut ffi::DzlChildPropertyAction,
            _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::child-property-name\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_child_property_name_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "container")]
    pub fn connect_container_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_container_trampoline<F: Fn(&ChildPropertyAction) + 'static>(
            this: *mut ffi::DzlChildPropertyAction,
            _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::container\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_container_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

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