gio/auto/

simple_action.rs

// 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, ffi};
use glib::{
    object::ObjectType as _,
    prelude::*,
    signal::{SignalHandlerId, connect_raw},
    translate::*,
};
use std::boxed::Box as Box_;

glib::wrapper! {
    /// A `GSimpleAction` 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].
    ///
    /// ## Properties
    ///
    ///
    /// #### `enabled`
    ///  If @action is currently enabled.
    ///
    /// If the action is disabled then calls to g_action_activate() and
    /// g_action_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 #GSimpleActionGroup.
    ///
    /// 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 #GVariantType 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 [type@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 `NULL` if no parameter is needed when
    /// activating the action.
    ///
    /// Readable
    ///
    ///
    /// #### `state`
    ///  The state of the action, or `NULL` if the action is stateless.
    ///
    /// Readable
    ///
    ///
    /// #### `state-type`
    ///  The [type@GLib.VariantType] of the state that the action has, or `NULL` 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 #GSimpleAction::change-state signal.
    /// For stateful actions where the state type is equal to the parameter
    /// type, the default is to forward them directly to
    /// #GSimpleAction::change-state.  This should allow almost all users
    /// of #GSimpleAction 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 g_simple_action_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 g_simple_action_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 g_simple_action_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 g_simple_action_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 #GSimpleAction::activate signal, or [`None`] for no parameter
    ///
    /// # Returns
    ///
    /// a new #GSimpleAction
    #[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,
            ))
        }
    }

    /// Creates a new stateful action.
    ///
    /// All future state values must have the same #GVariantType as the initial
    /// @state.
    ///
    /// If the @state #GVariant is floating, it is consumed.
    /// ## `name`
    /// the name of the action
    /// ## `parameter_type`
    /// the type of the parameter that will be passed to
    ///   handlers for the #GSimpleAction::activate signal, or [`None`] for no parameter
    /// ## `state`
    /// the initial state of the action
    ///
    /// # Returns
    ///
    /// a new #GSimpleAction
    #[doc(alias = "g_simple_action_new_stateful")]
    pub fn new_stateful(
        name: &str,
        parameter_type: Option<&glib::VariantTy>,
        state: &glib::Variant,
    ) -> SimpleAction {
        unsafe {
            from_glib_full(ffi::g_simple_action_new_stateful(
                name.to_glib_none().0,
                parameter_type.to_glib_none().0,
                state.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")]
    #[doc(alias = "enabled")]
    pub fn set_enabled(&self, enabled: bool) {
        unsafe {
            ffi::g_simple_action_set_enabled(self.to_glib_none().0, enabled.into_glib());
        }
    }

    /// Sets the state of the action.
    ///
    /// This directly updates the 'state' property to the given value.
    ///
    /// This should only be called by the implementor of the action.  Users
    /// of the action should not attempt to directly modify the 'state'
    /// property.  Instead, they should call g_action_change_state() to
    /// request the change.
    ///
    /// If the @value GVariant is floating, it is consumed.
    /// ## `value`
    /// the new #GVariant for the state
    #[doc(alias = "g_simple_action_set_state")]
    #[doc(alias = "state")]
    pub fn set_state(&self, value: &glib::Variant) {
        unsafe {
            ffi::g_simple_action_set_state(self.to_glib_none().0, value.to_glib_none().0);
        }
    }

    /// Sets the state hint for the action.
    ///
    /// See g_action_get_state_hint() for more information about
    /// action state hints.
    /// ## `state_hint`
    /// a #GVariant representing the state hint
    #[doc(alias = "g_simple_action_set_state_hint")]
    pub fn set_state_hint(&self, state_hint: Option<&glib::Variant>) {
        unsafe {
            ffi::g_simple_action_set_state_hint(self.to_glib_none().0, state_hint.to_glib_none().0);
        }
    }

    /// 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 #GSimpleAction::change-state signal.
    /// For stateful actions where the state type is equal to the parameter
    /// type, the default is to forward them directly to
    /// #GSimpleAction::change-state.  This should allow almost all users
    /// of #GSimpleAction 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,
        ) {
            unsafe {
                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 _,
                c"activate".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), 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 g_simple_action_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 g_simple_action_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 g_simple_action_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,
        ) {
            unsafe {
                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 _,
                c"change-state".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    change_state_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}