// 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::Buildable;
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! {
    /// This interface provides a convenient way of associating widgets with
    /// actions on a [`ApplicationWindow`][crate::ApplicationWindow] or [`Application`][crate::Application].
    ///
    /// 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`], [`BuildableExt`][trait@crate::prelude::BuildableExt], [`WidgetExtManual`][trait@crate::prelude::WidgetExtManual], [`BuildableExtManual`][trait@crate::prelude::BuildableExtManual]
    #[doc(alias = "GtkActionable")]
    pub struct Actionable(Interface<ffi::GtkActionable, ffi::GtkActionableInterface>) @requires Widget, Buildable;

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

pub const NONE_ACTIONABLE: Option<&Actionable> = None;

/// Trait containing all [`struct@Actionable`] methods.
///
/// # Implementors
///
/// [`Actionable`][struct@crate::Actionable], [`Button`][struct@crate::Button], [`CheckButton`][struct@crate::CheckButton], [`CheckMenuItem`][struct@crate::CheckMenuItem], [`ColorButton`][struct@crate::ColorButton], [`FontButton`][struct@crate::FontButton], [`LinkButton`][struct@crate::LinkButton], [`ListBoxRow`][struct@crate::ListBoxRow], [`LockButton`][struct@crate::LockButton], [`MenuButton`][struct@crate::MenuButton], [`MenuItem`][struct@crate::MenuItem], [`MenuToolButton`][struct@crate::MenuToolButton], [`ModelButton`][struct@crate::ModelButton], [`RadioButton`][struct@crate::RadioButton], [`RadioMenuItem`][struct@crate::RadioMenuItem], [`RadioToolButton`][struct@crate::RadioToolButton], [`ScaleButton`][struct@crate::ScaleButton], [`SeparatorMenuItem`][struct@crate::SeparatorMenuItem], [`Switch`][struct@crate::Switch], [`ToggleButton`][struct@crate::ToggleButton], [`ToggleToolButton`][struct@crate::ToggleToolButton], [`ToolButton`][struct@crate::ToolButton], [`VolumeButton`][struct@crate::VolumeButton]
pub trait ActionableExt: 'static {
    /// Gets the action name for `self`.
    ///
    /// See [`set_action_name()`][Self::set_action_name()] for more information.
    ///
    /// # Returns
    ///
    /// the action name, or [`None`] if none is set
    #[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`.
    ///
    /// See [`set_action_target_value()`][Self::set_action_target_value()] for more information.
    ///
    /// # 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, or [`None`]
    #[doc(alias = "gtk_actionable_set_action_name")]
    fn set_action_name(&self, action_name: Option<&str>);

    //#[doc(alias = "gtk_actionable_set_action_target")]
    //fn set_action_target(&self, format_string: &str, : /*Unknown conversion*//*Unimplemented*/Fundamental: VarArgs);

    /// 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 `GAction`
    /// 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`][crate::glib::Variant] to set as the target value, or [`None`]
    #[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
    /// `g_action_parse_detailed_name()`.
    ///
    /// (Note that prior to version 3.22.25,
    /// this function is only usable for actions with a simple "s" target, and
    /// `detailed_action_name` must be of the form `"action::target"` where
    /// `action` is the action name and `target` is the string to use
    /// as the target.)
    /// ## `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(&self, format_string: &str, : /*Unknown conversion*//*Unimplemented*/Fundamental: VarArgs) {
    //    unsafe { TODO: call ffi:gtk_actionable_set_action_target() }
    //}

    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")
    }
}