// 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

use crate::Action;
use glib::object::IsA;
use glib::object::ObjectType as ObjectType_;
use glib::signal::connect_raw;
use glib::signal::SignalHandlerId;
use glib::translate::*;
use glib::StaticType;
use std::boxed::Box as Box_;
use std::fmt;
use std::mem::transmute;

glib::wrapper! {
    /// A [`PropertyAction`][crate::PropertyAction] is a way to get a [`Action`][crate::Action] with a state value
    /// reflecting and controlling the value of a [`glib::Object`][crate::glib::Object] property.
    ///
    /// The state of the action will correspond to the value of the property.
    /// Changing it will change the property (assuming the requested value
    /// matches the requirements as specified in the `GParamSpec`).
    ///
    /// Only the most common types are presently supported. Booleans are
    /// mapped to booleans, strings to strings, signed/unsigned integers to
    /// int32/uint32 and floats and doubles to doubles.
    ///
    /// If the property is an enum then the state will be string-typed and
    /// conversion will automatically be performed between the enum value and
    /// "nick" string as per the `GEnumValue` table.
    ///
    /// Flags types are not currently supported.
    ///
    /// Properties of object types, boxed types and pointer types are not
    /// supported and probably never will be.
    ///
    /// Properties of [`glib::Variant`][struct@crate::glib::Variant] types are not currently supported.
    ///
    /// If the property is boolean-valued then the action will have a NULL
    /// parameter type, and activating the action (with no parameter) will
    /// toggle the value of the property.
    ///
    /// In all other cases, the parameter type will correspond to the type of
    /// the property.
    ///
    /// The general idea here is to reduce the number of locations where a
    /// particular piece of state is kept (and therefore has to be synchronised
    /// between). [`PropertyAction`][crate::PropertyAction] does not have a separate state that is kept
    /// in sync with the property value -- its state is the property value.
    ///
    /// For example, it might be useful to create a [`Action`][crate::Action] corresponding to
    /// the "visible-child-name" property of a `GtkStack` so that the current
    /// page can be switched from a menu. The active radio indication in the
    /// menu is then directly determined from the active page of the
    /// `GtkStack`.
    ///
    /// An anti-example would be binding the "active-id" property on a
    /// `GtkComboBox`. This is because the state of the combobox itself is
    /// probably uninteresting and is actually being used to control
    /// something else.
    ///
    /// Another anti-example would be to bind to the "visible-child-name"
    /// property of a `GtkStack` if this value is actually stored in
    /// [`Settings`][crate::Settings]. In that case, the real source of the value is
    /// [`Settings`][crate::Settings]. If you want a [`Action`][crate::Action] to control a setting stored in
    /// [`Settings`][crate::Settings], see [`SettingsExt::create_action()`][crate::prelude::SettingsExt::create_action()] instead, and possibly
    /// combine its use with [`SettingsExtManual::bind()`][crate::prelude::SettingsExtManual::bind()].
    ///
    /// # Implements
    ///
    /// [`trait@glib::ObjectExt`], [`ActionExt`][trait@crate::prelude::ActionExt]
    #[doc(alias = "GPropertyAction")]
    pub struct PropertyAction(Object<ffi::GPropertyAction>) @implements Action;

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

impl PropertyAction {
    /// Creates a [`Action`][crate::Action] corresponding to the value of property
    /// `property_name` on `object`.
    ///
    /// The property must be existent and readable and writable (and not
    /// construct-only).
    ///
    /// This function takes a reference on `object` and doesn't release it
    /// until the action is destroyed.
    /// ## `name`
    /// the name of the action to create
    /// ## `object`
    /// the object that has the property
    ///  to wrap
    /// ## `property_name`
    /// the name of the property
    ///
    /// # Returns
    ///
    /// a new [`PropertyAction`][crate::PropertyAction]
    #[doc(alias = "g_property_action_new")]
    pub fn new(name: &str, object: &impl IsA<glib::Object>, property_name: &str) -> PropertyAction {
        unsafe {
            from_glib_full(ffi::g_property_action_new(
                name.to_glib_none().0,
                object.as_ref().to_glib_none().0,
                property_name.to_glib_none().0,
            ))
        }
    }

    /// If [`true`], the state of the action will be the negation of the
    /// property value, provided the property is boolean.
    #[doc(alias = "invert-boolean")]
    pub fn inverts_boolean(&self) -> bool {
        glib::ObjectExt::property(self, "invert-boolean")
    }

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

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

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

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

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