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

glib::wrapper! {
    /// A [`SimpleAction`][crate::SimpleAction] is the obvious simple implementation of the [`Action`][crate::Action]
    /// interface. This is the easiest way to create an action for purposes of
    /// adding it to a [`SimpleActionGroup`][crate::SimpleActionGroup].
    ///
    /// See also `GtkAction`.
    ///
    /// ## Properties
    ///
    ///
    /// #### `enabled`
    ///  If `action` is currently enabled.
    ///
    /// If the action is disabled then calls to [`ActionExt::activate()`][crate::prelude::ActionExt::activate()] and
    /// [`ActionExt::change_state()`][crate::prelude::ActionExt::change_state()] have no effect.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `name`
    ///  The name of the action. This is mostly meaningful for identifying
    /// the action once it has been added to a [`SimpleActionGroup`][crate::SimpleActionGroup].
    ///
    /// Readable | Writeable | Construct Only
    ///
    ///
    /// #### `parameter-type`
    ///  The type of the parameter that must be given when activating the
    /// action.
    ///
    /// Readable | Writeable | Construct Only
    ///
    ///
    /// #### `state`
    ///  The state of the action, or [`None`] if the action is stateless.
    ///
    /// Readable | Writeable | Construct
    ///
    ///
    /// #### `state-type`
    ///  The [`glib::VariantType`][crate::glib::VariantType] of the state that the action has, or [`None`] if the
    /// action is stateless.
    ///
    /// Readable
    /// <details><summary><h4>Action</h4></summary>
    ///
    ///
    /// #### `enabled`
    ///  If `action` is currently enabled.
    ///
    /// If the action is disabled then calls to [`ActionExt::activate()`][crate::prelude::ActionExt::activate()] and
    /// [`ActionExt::change_state()`][crate::prelude::ActionExt::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 [`ActionGroup`][crate::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>
    ///
    /// ## Signals
    ///
    ///
    /// #### `activate`
    ///  Indicates that the action was just activated.
    ///
    /// `parameter` will always be of the expected type, i.e. the parameter type
    /// specified when the action was created. If an incorrect type is given when
    /// activating the action, this signal is not emitted.
    ///
    /// Since GLib 2.40, if no handler is connected to this signal then the
    /// default behaviour for boolean-stated actions with a [`None`] parameter
    /// type is to toggle them via the [`change-state`][struct@crate::SimpleAction#change-state] signal.
    /// For stateful actions where the state type is equal to the parameter
    /// type, the default is to forward them directly to
    /// [`change-state`][struct@crate::SimpleAction#change-state]. This should allow almost all users
    /// of [`SimpleAction`][crate::SimpleAction] to connect only one handler or the other.
    ///
    ///
    ///
    ///
    /// #### `change-state`
    ///  Indicates that the action just received a request to change its
    /// state.
    ///
    /// `value` will always be of the correct state type, i.e. the type of the
    /// initial state passed to [`SimpleAction::new_stateful()`][crate::SimpleAction::new_stateful()]. If an incorrect
    /// type is given when requesting to change the state, this signal is not
    /// emitted.
    ///
    /// If no handler is connected to this signal then the default
    /// behaviour is to call [`SimpleAction::set_state()`][crate::SimpleAction::set_state()] to set the state
    /// to the requested value. If you connect a signal handler then no
    /// default action is taken. If the state should change then you must
    /// call [`SimpleAction::set_state()`][crate::SimpleAction::set_state()] from the handler.
    ///
    /// An example of a 'change-state' handler:
    ///
    ///
    /// **⚠️ The following code is in C ⚠️**
    ///
    /// ```C
    /// static void
    /// change_volume_state (GSimpleAction *action,
    ///                      GVariant      *value,
    ///                      gpointer       user_data)
    /// {
    ///   gint requested;
    ///
    ///   requested = g_variant_get_int32 (value);
    ///
    ///   // Volume only goes from 0 to 10
    ///   if (0 <= requested && requested <= 10)
    ///     g_simple_action_set_state (action, value);
    /// }
    /// ```
    ///
    /// The handler need not set the state to the requested value.
    /// It could set it to any value at all, or take some other action.
    ///
    ///
    ///
    /// # Implements
    ///
    /// [`trait@glib::ObjectExt`], [`ActionExt`][trait@crate::prelude::ActionExt]
    #[doc(alias = "GSimpleAction")]
    pub struct SimpleAction(Object<ffi::GSimpleAction>) @implements Action;

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

impl SimpleAction {
    /// Creates a new action.
    ///
    /// The created action is stateless. See [`new_stateful()`][Self::new_stateful()] to create
    /// an action that has state.
    /// ## `name`
    /// the name of the action
    /// ## `parameter_type`
    /// the type of parameter that will be passed to
    ///  handlers for the [`activate`][struct@crate::SimpleAction#activate] signal, or [`None`] for no parameter
    ///
    /// # Returns
    ///
    /// a new [`SimpleAction`][crate::SimpleAction]
    #[doc(alias = "g_simple_action_new")]
    pub fn new(name: &str, parameter_type: Option<&glib::VariantTy>) -> SimpleAction {
        unsafe {
            from_glib_full(ffi::g_simple_action_new(
                name.to_glib_none().0,
                parameter_type.to_glib_none().0,
            ))
        }
    }

    /// Sets the action as enabled or not.
    ///
    /// An action must be enabled in order to be activated or in order to
    /// have its state changed from outside callers.
    ///
    /// This should only be called by the implementor of the action. Users
    /// of the action should not attempt to modify its enabled flag.
    /// ## `enabled`
    /// whether the action is enabled
    #[doc(alias = "g_simple_action_set_enabled")]
    pub fn set_enabled(&self, enabled: bool) {
        unsafe {
            ffi::g_simple_action_set_enabled(self.to_glib_none().0, enabled.into_glib());
        }
    }

    /// Indicates that the action was just activated.
    ///
    /// `parameter` will always be of the expected type, i.e. the parameter type
    /// specified when the action was created. If an incorrect type is given when
    /// activating the action, this signal is not emitted.
    ///
    /// Since GLib 2.40, if no handler is connected to this signal then the
    /// default behaviour for boolean-stated actions with a [`None`] parameter
    /// type is to toggle them via the [`change-state`][struct@crate::SimpleAction#change-state] signal.
    /// For stateful actions where the state type is equal to the parameter
    /// type, the default is to forward them directly to
    /// [`change-state`][struct@crate::SimpleAction#change-state]. This should allow almost all users
    /// of [`SimpleAction`][crate::SimpleAction] to connect only one handler or the other.
    /// ## `parameter`
    /// the parameter to the activation, or [`None`] if it has
    ///  no parameter
    #[doc(alias = "activate")]
    pub fn connect_activate<F: Fn(&Self, Option<&glib::Variant>) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn activate_trampoline<
            F: Fn(&SimpleAction, Option<&glib::Variant>) + 'static,
        >(
            this: *mut ffi::GSimpleAction,
            parameter: *mut glib::ffi::GVariant,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(
                &from_glib_borrow(this),
                Option::<glib::Variant>::from_glib_borrow(parameter)
                    .as_ref()
                    .as_ref(),
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"activate\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    activate_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Indicates that the action just received a request to change its
    /// state.
    ///
    /// `value` will always be of the correct state type, i.e. the type of the
    /// initial state passed to [`new_stateful()`][Self::new_stateful()]. If an incorrect
    /// type is given when requesting to change the state, this signal is not
    /// emitted.
    ///
    /// If no handler is connected to this signal then the default
    /// behaviour is to call [`set_state()`][Self::set_state()] to set the state
    /// to the requested value. If you connect a signal handler then no
    /// default action is taken. If the state should change then you must
    /// call [`set_state()`][Self::set_state()] from the handler.
    ///
    /// An example of a 'change-state' handler:
    ///
    ///
    /// **⚠️ The following code is in C ⚠️**
    ///
    /// ```C
    /// static void
    /// change_volume_state (GSimpleAction *action,
    ///                      GVariant      *value,
    ///                      gpointer       user_data)
    /// {
    ///   gint requested;
    ///
    ///   requested = g_variant_get_int32 (value);
    ///
    ///   // Volume only goes from 0 to 10
    ///   if (0 <= requested && requested <= 10)
    ///     g_simple_action_set_state (action, value);
    /// }
    /// ```
    ///
    /// The handler need not set the state to the requested value.
    /// It could set it to any value at all, or take some other action.
    /// ## `value`
    /// the requested value for the state
    #[doc(alias = "change-state")]
    pub fn connect_change_state<F: Fn(&Self, Option<&glib::Variant>) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn change_state_trampoline<
            F: Fn(&SimpleAction, Option<&glib::Variant>) + 'static,
        >(
            this: *mut ffi::GSimpleAction,
            value: *mut glib::ffi::GVariant,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(
                &from_glib_borrow(this),
                Option::<glib::Variant>::from_glib_borrow(value)
                    .as_ref()
                    .as_ref(),
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"change-state\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    change_state_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

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