// This file was generated by gir (https://github.com/gtk-rs/gir)
// from gir-files (https://github.com/gtk-rs/gir-files.git)
// DO NOT EDIT

use crate::ShortcutActionFlags;
use crate::Widget;
use glib::object::IsA;
use glib::translate::*;
use std::fmt;

glib::wrapper! {
    /// [`ShortcutAction`][crate::ShortcutAction] encodes an action that can be triggered by a
    /// keyboard shortcut.
    ///
    /// `GtkShortcutActions` contain functions that allow easy presentation
    /// to end users as well as being printed for debugging.
    ///
    /// All `GtkShortcutActions` are immutable, you can only specify their
    /// properties during construction. If you want to change a action, you
    /// have to replace it with a new one. If you need to pass arguments to
    /// an action, these are specified by the higher-level [`Shortcut`][crate::Shortcut] object.
    ///
    /// To activate a [`ShortcutAction`][crate::ShortcutAction] manually, [``ShortcutActionExt::activate()``][crate::prelude::`ShortcutActionExt::activate()`]
    /// can be called.
    ///
    /// GTK provides various actions:
    ///
    ///  - [`MnemonicAction`][crate::MnemonicAction]: a shortcut action that calls
    ///  [`WidgetExt::mnemonic_activate()`][crate::prelude::WidgetExt::mnemonic_activate()]
    ///  - [`CallbackAction`][crate::CallbackAction]: a shortcut action that invokes
    ///  a given callback
    ///  - [`SignalAction`][crate::SignalAction]: a shortcut action that emits a
    ///  given signal
    ///  - [`ActivateAction`][crate::ActivateAction]: a shortcut action that calls
    ///  [`WidgetExt::activate()`][crate::prelude::WidgetExt::activate()]
    ///  - [`NamedAction`][crate::NamedAction]: a shortcut action that calls
    ///  `gtk_widget_activate_action()`
    ///  - [`NothingAction`][crate::NothingAction]: a shortcut action that does nothing
    ///
    /// This is an Abstract Base Class, you cannot instantiate it.
    ///
    /// # Implements
    ///
    /// [`ShortcutActionExt`][trait@crate::prelude::ShortcutActionExt], [`trait@glib::ObjectExt`]
    #[doc(alias = "GtkShortcutAction")]
    pub struct ShortcutAction(Object<ffi::GtkShortcutAction, ffi::GtkShortcutActionClass>);

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

impl ShortcutAction {
    /// Tries to parse the given string into an action.
    ///
    /// On success, the parsed action is returned. When parsing
    /// failed, [`None`] is returned.
    ///
    /// The accepted strings are:
    ///
    /// - `nothing`, for [`NothingAction`][crate::NothingAction]
    /// - `activate`, for [`ActivateAction`][crate::ActivateAction]
    /// - `mnemonic-activate`, for [`MnemonicAction`][crate::MnemonicAction]
    /// - `action(NAME)`, for a [`NamedAction`][crate::NamedAction] for the action named `NAME`
    /// - `signal(NAME)`, for a [`SignalAction`][crate::SignalAction] for the signal `NAME`
    /// ## `string`
    /// the string to parse
    ///
    /// # Returns
    ///
    /// a new [`ShortcutAction`][crate::ShortcutAction]
    #[doc(alias = "gtk_shortcut_action_parse_string")]
    pub fn parse_string(string: &str) -> Option<ShortcutAction> {
        assert_initialized_main_thread!();
        unsafe {
            from_glib_full(ffi::gtk_shortcut_action_parse_string(
                string.to_glib_none().0,
            ))
        }
    }
}

impl fmt::Display for ShortcutAction {
    #[inline]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.write_str(&ShortcutActionExt::to_str(self))
    }
}

pub const NONE_SHORTCUT_ACTION: Option<&ShortcutAction> = None;

/// Trait containing all [`struct@ShortcutAction`] methods.
///
/// # Implementors
///
/// [`ActivateAction`][struct@crate::ActivateAction], [`CallbackAction`][struct@crate::CallbackAction], [`MnemonicAction`][struct@crate::MnemonicAction], [`NamedAction`][struct@crate::NamedAction], [`NothingAction`][struct@crate::NothingAction], [`ShortcutAction`][struct@crate::ShortcutAction], [`SignalAction`][struct@crate::SignalAction]
pub trait ShortcutActionExt: 'static {
    /// Activates the action on the `widget` with the given `args`.
    ///
    /// Note that some actions ignore the passed in `flags`, `widget` or `args`.
    ///
    /// Activation of an action can fail for various reasons. If the action
    /// is not supported by the `widget`, if the `args` don't match the action
    /// or if the activation otherwise had no effect, [`false`] will be returned.
    /// ## `flags`
    /// flags to activate with
    /// ## `widget`
    /// Target of the activation
    /// ## `args`
    /// arguments to pass
    ///
    /// # Returns
    ///
    /// [`true`] if this action was activated successfully
    #[doc(alias = "gtk_shortcut_action_activate")]
    fn activate<P: IsA<Widget>>(
        &self,
        flags: ShortcutActionFlags,
        widget: &P,
        args: Option<&glib::Variant>,
    ) -> bool;

    #[doc(alias = "gtk_shortcut_action_to_string")]
    #[doc(alias = "to_string")]
    fn to_str(&self) -> glib::GString;
}

impl<O: IsA<ShortcutAction>> ShortcutActionExt for O {
    fn activate<P: IsA<Widget>>(
        &self,
        flags: ShortcutActionFlags,
        widget: &P,
        args: Option<&glib::Variant>,
    ) -> bool {
        unsafe {
            from_glib(ffi::gtk_shortcut_action_activate(
                self.as_ref().to_glib_none().0,
                flags.into_glib(),
                widget.as_ref().to_glib_none().0,
                args.to_glib_none().0,
            ))
        }
    }

    fn to_str(&self) -> glib::GString {
        unsafe {
            from_glib_full(ffi::gtk_shortcut_action_to_string(
                self.as_ref().to_glib_none().0,
            ))
        }
    }
}