// 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::Accessible;
use crate::Buildable;
use crate::ConstraintTarget;
use crate::Widget;
use glib::object::Cast;
use glib::object::IsA;
use glib::signal::connect_raw;
use glib::signal::SignalHandlerId;
use glib::translate::*;
use std::boxed::Box as Box_;
use std::fmt;
use std::mem::transmute;

glib::wrapper! {
    /// The [`Actionable`][crate::Actionable] interface provides a convenient way of asscociating
    /// widgets with actions.
    ///
    /// It primarily consists of two properties: `property::Actionable::action-name`
    /// and `property::Actionable::action-target`. There are also some convenience
    /// APIs for setting these properties.
    ///
    /// The action will be looked up in action groups that are found among
    /// the widgets ancestors. Most commonly, these will be the actions with
    /// the “win.” or “app.” prefix that are associated with the
    /// [`ApplicationWindow`][crate::ApplicationWindow] or [`Application`][crate::Application], but other action groups that
    /// are added with [`WidgetExt::insert_action_group()`][crate::prelude::WidgetExt::insert_action_group()] will be consulted
    /// as well.
    ///
    /// # Implements
    ///
    /// [`ActionableExt`][trait@crate::prelude::ActionableExt], [`WidgetExt`][trait@crate::prelude::WidgetExt], [`trait@glib::ObjectExt`], [`AccessibleExt`][trait@crate::prelude::AccessibleExt], [`BuildableExt`][trait@crate::prelude::BuildableExt], [`ConstraintTargetExt`][trait@crate::prelude::ConstraintTargetExt], [`ActionableExtManual`][trait@crate::prelude::ActionableExtManual], [`WidgetExtManual`][trait@crate::prelude::WidgetExtManual], [`AccessibleExtManual`][trait@crate::prelude::AccessibleExtManual]
    #[doc(alias = "GtkActionable")]
    pub struct Actionable(Interface<ffi::GtkActionable, ffi::GtkActionableInterface>) @requires Widget, Accessible, Buildable, ConstraintTarget;

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

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

/// Trait containing all [`struct@Actionable`] methods.
///
/// # Implementors
///
/// [`Actionable`][struct@crate::Actionable], [`Button`][struct@crate::Button], [`CheckButton`][struct@crate::CheckButton], [`LinkButton`][struct@crate::LinkButton], [`ListBoxRow`][struct@crate::ListBoxRow], [`LockButton`][struct@crate::LockButton], [`Switch`][struct@crate::Switch], [`ToggleButton`][struct@crate::ToggleButton]
pub trait ActionableExt: 'static {
    /// Gets the action name for @self.
    ///
    /// # Returns
    ///
    /// the action name
    #[doc(alias = "gtk_actionable_get_action_name")]
    #[doc(alias = "get_action_name")]
    fn action_name(&self) -> Option<glib::GString>;

    /// Gets the current target value of @self.
    ///
    /// # Returns
    ///
    /// the current target value
    #[doc(alias = "gtk_actionable_get_action_target_value")]
    #[doc(alias = "get_action_target_value")]
    fn action_target_value(&self) -> Option<glib::Variant>;

    /// Specifies the name of the action with which this widget should be
    /// associated.
    ///
    /// If @action_name is [`None`] then the widget will be unassociated from
    /// any previous action.
    ///
    /// Usually this function is used when the widget is located (or will be
    /// located) within the hierarchy of a [`ApplicationWindow`][crate::ApplicationWindow].
    ///
    /// Names are of the form “win.save” or “app.quit” for actions on the
    /// containing [`ApplicationWindow`][crate::ApplicationWindow] or its associated [`Application`][crate::Application],
    /// respectively. This is the same form used for actions in the [`gio::Menu`][crate::gio::Menu]
    /// associated with the window.
    /// ## `action_name`
    /// an action name
    #[doc(alias = "gtk_actionable_set_action_name")]
    fn set_action_name(&self, action_name: Option<&str>);

    /// Sets the target value of an actionable widget.
    ///
    /// If @target_value is [`None`] then the target value is unset.
    ///
    /// The target value has two purposes. First, it is used as the parameter
    /// to activation of the action associated with the [`Actionable`][crate::Actionable] widget.
    /// Second, it is used to determine if the widget should be rendered as
    /// “active” — the widget is active if the state is equal to the given target.
    ///
    /// Consider the example of associating a set of buttons with a [`gio::Action`][crate::gio::Action]
    /// with string state in a typical “radio button” situation. Each button
    /// will be associated with the same action, but with a different target
    /// value for that action. Clicking on a particular button will activate
    /// the action with the target of that button, which will typically cause
    /// the action’s state to change to that value. Since the action’s state
    /// is now equal to the target value of the button, the button will now
    /// be rendered as active (and the other buttons, with different targets,
    /// rendered inactive).
    /// ## `target_value`
    /// a [`glib::Variant`][struct@crate::glib::Variant] to set as the target value
    #[doc(alias = "gtk_actionable_set_action_target_value")]
    fn set_action_target_value(&self, target_value: Option<&glib::Variant>);

    /// Sets the action-name and associated string target value of an
    /// actionable widget.
    ///
    /// @detailed_action_name is a string in the format accepted by
    /// [`gio::Action::parse_detailed_name()`][crate::gio::Action::parse_detailed_name()].
    /// ## `detailed_action_name`
    /// the detailed action name
    #[doc(alias = "gtk_actionable_set_detailed_action_name")]
    fn set_detailed_action_name(&self, detailed_action_name: &str);

    #[doc(alias = "action-name")]
    fn connect_action_name_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;

    #[doc(alias = "action-target")]
    fn connect_action_target_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
}

impl<O: IsA<Actionable>> ActionableExt for O {
    fn action_name(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_none(ffi::gtk_actionable_get_action_name(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn action_target_value(&self) -> Option<glib::Variant> {
        unsafe {
            from_glib_none(ffi::gtk_actionable_get_action_target_value(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn set_action_name(&self, action_name: Option<&str>) {
        unsafe {
            ffi::gtk_actionable_set_action_name(
                self.as_ref().to_glib_none().0,
                action_name.to_glib_none().0,
            );
        }
    }

    fn set_action_target_value(&self, target_value: Option<&glib::Variant>) {
        unsafe {
            ffi::gtk_actionable_set_action_target_value(
                self.as_ref().to_glib_none().0,
                target_value.to_glib_none().0,
            );
        }
    }

    fn set_detailed_action_name(&self, detailed_action_name: &str) {
        unsafe {
            ffi::gtk_actionable_set_detailed_action_name(
                self.as_ref().to_glib_none().0,
                detailed_action_name.to_glib_none().0,
            );
        }
    }

    fn connect_action_name_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_action_name_trampoline<
            P: IsA<Actionable>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkActionable,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Actionable::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::action-name\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_action_name_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn connect_action_target_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_action_target_trampoline<
            P: IsA<Actionable>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkActionable,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Actionable::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::action-target\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_action_target_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

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