gio/auto/

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

glib::wrapper! {
    ///  are actually implemented with
    /// calls to `Gio::ActionGroup::query_action()`.
    ///
    /// ## Signals
    ///
    ///
    /// #### `action-added`
    ///  Signals that a new action was just added to the group.
    ///
    /// This signal is emitted after the action has been added
    /// and is now visible.
    ///
    /// Detailed
    ///
    ///
    /// #### `action-enabled-changed`
    ///  Signals that the enabled status of the named action has changed.
    ///
    /// Detailed
    ///
    ///
    /// #### `action-removed`
    ///  Signals that an action is just about to be removed from the group.
    ///
    /// This signal is emitted before the action is removed, so the action
    /// is still visible and can be queried from the signal handler.
    ///
    /// Detailed
    ///
    ///
    /// #### `action-state-changed`
    ///  Signals that the state of the named action has changed.
    ///
    /// Detailed
    ///
    /// # Implements
    ///
    /// [`ActionGroupExt`][trait@crate::prelude::ActionGroupExt]
    #[doc(alias = "GActionGroup")]
    pub struct ActionGroup(Interface<ffi::GActionGroup, ffi::GActionGroupInterface>);

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

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

/// Trait containing all [`struct@ActionGroup`] methods.
///
/// # Implementors
///
/// [`ActionGroup`][struct@crate::ActionGroup], [`Application`][struct@crate::Application], [`DBusActionGroup`][struct@crate::DBusActionGroup], [`RemoteActionGroup`][struct@crate::RemoteActionGroup], [`SimpleActionGroup`][struct@crate::SimpleActionGroup]
pub trait ActionGroupExt: IsA<ActionGroup> + 'static {
    /// Emits the [`action-added`][struct@crate::ActionGroup#action-added] signal on @self.
    ///
    /// This function should only be called by [type@Gio.ActionGroup] implementations.
    /// ## `action_name`
    /// the name of an action in the group
    #[doc(alias = "g_action_group_action_added")]
    fn action_added(&self, action_name: &str) {
        unsafe {
            ffi::g_action_group_action_added(
                self.as_ref().to_glib_none().0,
                action_name.to_glib_none().0,
            );
        }
    }

    /// Emits the [`action-enabled-changed`][struct@crate::ActionGroup#action-enabled-changed] signal on @self.
    ///
    /// This function should only be called by [type@Gio.ActionGroup] implementations.
    /// ## `action_name`
    /// the name of an action in the group
    /// ## `enabled`
    /// whether the action is now enabled
    #[doc(alias = "g_action_group_action_enabled_changed")]
    fn action_enabled_changed(&self, action_name: &str, enabled: bool) {
        unsafe {
            ffi::g_action_group_action_enabled_changed(
                self.as_ref().to_glib_none().0,
                action_name.to_glib_none().0,
                enabled.into_glib(),
            );
        }
    }

    /// Emits the [`action-removed`][struct@crate::ActionGroup#action-removed] signal on @self.
    ///
    /// This function should only be called by [type@Gio.ActionGroup] implementations.
    /// ## `action_name`
    /// the name of an action in the group
    #[doc(alias = "g_action_group_action_removed")]
    fn action_removed(&self, action_name: &str) {
        unsafe {
            ffi::g_action_group_action_removed(
                self.as_ref().to_glib_none().0,
                action_name.to_glib_none().0,
            );
        }
    }

    /// Emits the [`action-state-changed`][struct@crate::ActionGroup#action-state-changed] signal on @self.
    ///
    /// This function should only be called by [type@Gio.ActionGroup] implementations.
    /// ## `action_name`
    /// the name of an action in the group
    /// ## `state`
    /// the new state of the named action
    #[doc(alias = "g_action_group_action_state_changed")]
    fn action_state_changed(&self, action_name: &str, state: &glib::Variant) {
        unsafe {
            ffi::g_action_group_action_state_changed(
                self.as_ref().to_glib_none().0,
                action_name.to_glib_none().0,
                state.to_glib_none().0,
            );
        }
    }

    /// );
    ///
    /// g_debug ("Application has been terminated. Exiting.");
    ///
    /// exit (0);
    /// ```text
    ///
    /// ## `action_name`
    /// the name of the action to activate
    /// ## `parameter`
    /// parameters to the activation
    #[doc(alias = "g_action_group_activate_action")]
    fn activate_action(&self, action_name: &str, parameter: Option<&glib::Variant>) {
        unsafe {
            ffi::g_action_group_activate_action(
                self.as_ref().to_glib_none().0,
                action_name.to_glib_none().0,
                parameter.to_glib_none().0,
            );
        }
    }

    /// Request for the state of the named action within @self to be
    /// changed to @value.
    ///
    /// The action must be stateful and @value must be of the correct type.
    /// See [`action_state_type()`][Self::action_state_type()].
    ///
    /// This call merely requests a change.  The action may refuse to change
    /// its state or may change its state to something other than @value.
    /// See [`action_state_hint()`][Self::action_state_hint()].
    ///
    /// If the @value GVariant is floating, it is consumed.
    /// ## `action_name`
    /// the name of the action to request the change on
    /// ## `value`
    /// the new state
    #[doc(alias = "g_action_group_change_action_state")]
    fn change_action_state(&self, action_name: &str, value: &glib::Variant) {
        unsafe {
            ffi::g_action_group_change_action_state(
                self.as_ref().to_glib_none().0,
                action_name.to_glib_none().0,
                value.to_glib_none().0,
            );
        }
    }

    /// Checks if the named action within @self is currently enabled.
    ///
    /// An action must be enabled in order to be activated or in order to
    /// have its state changed from outside callers.
    /// ## `action_name`
    /// the name of the action to query
    ///
    /// # Returns
    ///
    /// whether the action is currently enabled
    #[doc(alias = "g_action_group_get_action_enabled")]
    #[doc(alias = "get_action_enabled")]
    fn is_action_enabled(&self, action_name: &str) -> bool {
        unsafe {
            from_glib(ffi::g_action_group_get_action_enabled(
                self.as_ref().to_glib_none().0,
                action_name.to_glib_none().0,
            ))
        }
    }

    /// Queries the type of the parameter that must be given when activating
    /// the named action within @self.
    ///
    /// When activating the action using [`activate_action()`][Self::activate_action()],
    /// the [type@GLib.Variant] given to that function must be of the type returned
    /// by this function.
    ///
    /// In the case that this function returns `NULL`, you must not give any
    /// [type@GLib.Variant], but `NULL` instead.
    ///
    /// The parameter type of a particular action will never change but it is
    /// possible for an action to be removed and for a new action to be added
    /// with the same name but a different parameter type.
    /// ## `action_name`
    /// the name of the action to query
    ///
    /// # Returns
    ///
    /// the parameter type
    #[doc(alias = "g_action_group_get_action_parameter_type")]
    #[doc(alias = "get_action_parameter_type")]
    fn action_parameter_type(&self, action_name: &str) -> Option<glib::VariantType> {
        unsafe {
            from_glib_none(ffi::g_action_group_get_action_parameter_type(
                self.as_ref().to_glib_none().0,
                action_name.to_glib_none().0,
            ))
        }
    }

    /// Queries the current state of the named action within @self.
    ///
    /// If the action is not stateful then `NULL` will be returned.  If the
    /// action is stateful then the type of the return value is the type
    /// given by [`action_state_type()`][Self::action_state_type()].
    ///
    /// The return value (if non-`NULL`) should be freed with
    /// `GLib::Variant::unref()` when it is no longer required.
    /// ## `action_name`
    /// the name of the action to query
    ///
    /// # Returns
    ///
    /// the current state of the action
    #[doc(alias = "g_action_group_get_action_state")]
    #[doc(alias = "get_action_state")]
    fn action_state(&self, action_name: &str) -> Option<glib::Variant> {
        unsafe {
            from_glib_full(ffi::g_action_group_get_action_state(
                self.as_ref().to_glib_none().0,
                action_name.to_glib_none().0,
            ))
        }
    }

    /// Requests a hint about the valid range of values for the state of the
    /// named action within @self.
    ///
    /// If `NULL` is returned it either means that the action is not stateful
    /// or that there is no hint about the valid range of values for the
    /// state of the action.
    ///
    /// If a [type@GLib.Variant] array is returned then each item in the array is a
    /// possible value for the state.  If a [type@GLib.Variant] pair (ie: two-tuple) is
    /// returned then the tuple specifies the inclusive lower and upper bound
    /// of valid values for the state.
    ///
    /// In any case, the information is merely a hint.  It may be possible to
    /// have a state value outside of the hinted range and setting a value
    /// within the range may fail.
    ///
    /// The return value (if non-`NULL`) should be freed with
    /// `GLib::Variant::unref()` when it is no longer required.
    /// ## `action_name`
    /// the name of the action to query
    ///
    /// # Returns
    ///
    /// the state range hint
    #[doc(alias = "g_action_group_get_action_state_hint")]
    #[doc(alias = "get_action_state_hint")]
    fn action_state_hint(&self, action_name: &str) -> Option<glib::Variant> {
        unsafe {
            from_glib_full(ffi::g_action_group_get_action_state_hint(
                self.as_ref().to_glib_none().0,
                action_name.to_glib_none().0,
            ))
        }
    }

    /// Queries the type of the state of the named action within
    /// @self.
    ///
    /// If the action is stateful then this function returns the
    /// [type@GLib.VariantType] of the state.  All calls to
    /// [`change_action_state()`][Self::change_action_state()] must give a [type@GLib.Variant] of this
    /// type and [`action_state()`][Self::action_state()] will return a [type@GLib.Variant]
    /// of the same type.
    ///
    /// If the action is not stateful then this function will return `NULL`.
    /// In that case, [`action_state()`][Self::action_state()] will return `NULL`
    /// and you must not call [`change_action_state()`][Self::change_action_state()].
    ///
    /// The state type of a particular action will never change but it is
    /// possible for an action to be removed and for a new action to be added
    /// with the same name but a different state type.
    /// ## `action_name`
    /// the name of the action to query
    ///
    /// # Returns
    ///
    /// the state type, if the action is stateful
    #[doc(alias = "g_action_group_get_action_state_type")]
    #[doc(alias = "get_action_state_type")]
    fn action_state_type(&self, action_name: &str) -> Option<glib::VariantType> {
        unsafe {
            from_glib_none(ffi::g_action_group_get_action_state_type(
                self.as_ref().to_glib_none().0,
                action_name.to_glib_none().0,
            ))
        }
    }

    /// Checks if the named action exists within @self.
    /// ## `action_name`
    /// the name of the action to check for
    ///
    /// # Returns
    ///
    /// whether the named action exists
    #[doc(alias = "g_action_group_has_action")]
    fn has_action(&self, action_name: &str) -> bool {
        unsafe {
            from_glib(ffi::g_action_group_has_action(
                self.as_ref().to_glib_none().0,
                action_name.to_glib_none().0,
            ))
        }
    }

    /// Lists the actions contained within @self.
    ///
    /// The caller is responsible for freeing the list with `strfreev()` when
    /// it is no longer required.
    ///
    /// # Returns
    ///
    /// a `NULL`-terminated array
    ///   of the names of the actions in the group
    #[doc(alias = "g_action_group_list_actions")]
    fn list_actions(&self) -> Vec<glib::GString> {
        unsafe {
            FromGlibPtrContainer::from_glib_full(ffi::g_action_group_list_actions(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Signals that a new action was just added to the group.
    ///
    /// This signal is emitted after the action has been added
    /// and is now visible.
    /// ## `action_name`
    /// the name of the action in @action_group
    #[doc(alias = "action-added")]
    fn connect_action_added<F: Fn(&Self, &str) + 'static>(
        &self,
        detail: Option<&str>,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn action_added_trampoline<
            P: IsA<ActionGroup>,
            F: Fn(&P, &str) + 'static,
        >(
            this: *mut ffi::GActionGroup,
            action_name: *mut std::ffi::c_char,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(
                    ActionGroup::from_glib_borrow(this).unsafe_cast_ref(),
                    &glib::GString::from_glib_borrow(action_name),
                )
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            let detailed_signal_name = detail.map(|name| format!("action-added::{name}\0"));
            let signal_name = detailed_signal_name.as_ref().map_or(c"action-added", |n| {
                std::ffi::CStr::from_bytes_with_nul_unchecked(n.as_bytes())
            });
            connect_raw(
                self.as_ptr() as *mut _,
                signal_name.as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    action_added_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Signals that the enabled status of the named action has changed.
    /// ## `action_name`
    /// the name of the action in @action_group
    /// ## `enabled`
    /// whether the action is enabled
    #[doc(alias = "action-enabled-changed")]
    fn connect_action_enabled_changed<F: Fn(&Self, &str, bool) + 'static>(
        &self,
        detail: Option<&str>,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn action_enabled_changed_trampoline<
            P: IsA<ActionGroup>,
            F: Fn(&P, &str, bool) + 'static,
        >(
            this: *mut ffi::GActionGroup,
            action_name: *mut std::ffi::c_char,
            enabled: glib::ffi::gboolean,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(
                    ActionGroup::from_glib_borrow(this).unsafe_cast_ref(),
                    &glib::GString::from_glib_borrow(action_name),
                    from_glib(enabled),
                )
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            let detailed_signal_name =
                detail.map(|name| format!("action-enabled-changed::{name}\0"));
            let signal_name = detailed_signal_name
                .as_ref()
                .map_or(c"action-enabled-changed", |n| {
                    std::ffi::CStr::from_bytes_with_nul_unchecked(n.as_bytes())
                });
            connect_raw(
                self.as_ptr() as *mut _,
                signal_name.as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    action_enabled_changed_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Signals that an action is just about to be removed from the group.
    ///
    /// This signal is emitted before the action is removed, so the action
    /// is still visible and can be queried from the signal handler.
    /// ## `action_name`
    /// the name of the action in @action_group
    #[doc(alias = "action-removed")]
    fn connect_action_removed<F: Fn(&Self, &str) + 'static>(
        &self,
        detail: Option<&str>,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn action_removed_trampoline<
            P: IsA<ActionGroup>,
            F: Fn(&P, &str) + 'static,
        >(
            this: *mut ffi::GActionGroup,
            action_name: *mut std::ffi::c_char,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(
                    ActionGroup::from_glib_borrow(this).unsafe_cast_ref(),
                    &glib::GString::from_glib_borrow(action_name),
                )
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            let detailed_signal_name = detail.map(|name| format!("action-removed::{name}\0"));
            let signal_name = detailed_signal_name
                .as_ref()
                .map_or(c"action-removed", |n| {
                    std::ffi::CStr::from_bytes_with_nul_unchecked(n.as_bytes())
                });
            connect_raw(
                self.as_ptr() as *mut _,
                signal_name.as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    action_removed_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Signals that the state of the named action has changed.
    /// ## `action_name`
    /// the name of the action in @action_group
    /// ## `value`
    /// the new value of the state
    #[doc(alias = "action-state-changed")]
    fn connect_action_state_changed<F: Fn(&Self, &str, &glib::Variant) + 'static>(
        &self,
        detail: Option<&str>,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn action_state_changed_trampoline<
            P: IsA<ActionGroup>,
            F: Fn(&P, &str, &glib::Variant) + 'static,
        >(
            this: *mut ffi::GActionGroup,
            action_name: *mut std::ffi::c_char,
            value: *mut glib::ffi::GVariant,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(
                    ActionGroup::from_glib_borrow(this).unsafe_cast_ref(),
                    &glib::GString::from_glib_borrow(action_name),
                    &from_glib_borrow(value),
                )
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            let detailed_signal_name = detail.map(|name| format!("action-state-changed::{name}\0"));
            let signal_name = detailed_signal_name
                .as_ref()
                .map_or(c"action-state-changed", |n| {
                    std::ffi::CStr::from_bytes_with_nul_unchecked(n.as_bytes())
                });
            connect_raw(
                self.as_ptr() as *mut _,
                signal_name.as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    action_state_changed_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

impl<O: IsA<ActionGroup>> ActionGroupExt for O {}