// 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 gdk_sys;
use glib::object::ObjectType as ObjectType_;
use glib::signal::connect_raw;
use glib::signal::SignalHandlerId;
use glib::translate::*;
use glib_sys;
use pango;
use std::boxed::Box as Box_;
use std::fmt;
use std::mem;
use std::mem::transmute;
use Display;
use KeymapKey;
use ModifierIntent;
use ModifierType;

glib_wrapper! {
    /// A `Keymap` defines the translation from keyboard state
    /// (including a hardware key, a modifier mask, and active keyboard group)
    /// to a keyval. This translation has two phases. The first phase is
    /// to determine the effective keyboard group and level for the keyboard
    /// state; the second phase is to look up the keycode/group/level triplet
    /// in the keymap and see what keyval it corresponds to.
    pub struct Keymap(Object<gdk_sys::GdkKeymap, KeymapClass>);

    match fn {
        get_type => || gdk_sys::gdk_keymap_get_type(),
    }
}

impl Keymap {
    /// Returns whether the Caps Lock modifer is locked.
    ///
    /// # Returns
    ///
    /// `true` if Caps Lock is on
    pub fn get_caps_lock_state(&self) -> bool {
        unsafe {
            from_glib(gdk_sys::gdk_keymap_get_caps_lock_state(
                self.to_glib_none().0,
            ))
        }
    }

    /// Returns the direction of effective layout of the keymap.
    ///
    /// # Returns
    ///
    /// `pango::Direction::Ltr` or `pango::Direction::Rtl`
    ///  if it can determine the direction. `pango::Direction::Neutral`
    ///  otherwise.
    pub fn get_direction(&self) -> pango::Direction {
        unsafe { from_glib(gdk_sys::gdk_keymap_get_direction(self.to_glib_none().0)) }
    }

    /// Returns the modifier mask the `self`’s windowing system backend
    /// uses for a particular purpose.
    ///
    /// Note that this function always returns real hardware modifiers, not
    /// virtual ones (e.g. it will return `ModifierType::Mod1Mask` rather than
    /// `ModifierType::MetaMask` if the backend maps MOD1 to META), so there are use
    /// cases where the return value of this function has to be transformed
    /// by `Keymap::add_virtual_modifiers` in order to contain the
    /// expected result.
    /// ## `intent`
    /// the use case for the modifier mask
    ///
    /// # Returns
    ///
    /// the modifier mask used for `intent`.
    pub fn get_modifier_mask(&self, intent: ModifierIntent) -> ModifierType {
        unsafe {
            from_glib(gdk_sys::gdk_keymap_get_modifier_mask(
                self.to_glib_none().0,
                intent.to_glib(),
            ))
        }
    }

    /// Returns the current modifier state.
    ///
    /// # Returns
    ///
    /// the current modifier state.
    pub fn get_modifier_state(&self) -> u32 {
        unsafe { gdk_sys::gdk_keymap_get_modifier_state(self.to_glib_none().0) }
    }

    /// Returns whether the Num Lock modifer is locked.
    ///
    /// # Returns
    ///
    /// `true` if Num Lock is on
    pub fn get_num_lock_state(&self) -> bool {
        unsafe {
            from_glib(gdk_sys::gdk_keymap_get_num_lock_state(
                self.to_glib_none().0,
            ))
        }
    }

    /// Returns whether the Scroll Lock modifer is locked.
    ///
    /// Feature: `v3_18`
    ///
    ///
    /// # Returns
    ///
    /// `true` if Scroll Lock is on
    #[cfg(any(feature = "v3_18", feature = "dox"))]
    pub fn get_scroll_lock_state(&self) -> bool {
        unsafe {
            from_glib(gdk_sys::gdk_keymap_get_scroll_lock_state(
                self.to_glib_none().0,
            ))
        }
    }

    /// Determines if keyboard layouts for both right-to-left and left-to-right
    /// languages are in use.
    ///
    /// # Returns
    ///
    /// `true` if there are layouts in both directions, `false` otherwise
    pub fn have_bidi_layouts(&self) -> bool {
        unsafe { from_glib(gdk_sys::gdk_keymap_have_bidi_layouts(self.to_glib_none().0)) }
    }

    /// Looks up the keyval mapped to a keycode/group/level triplet.
    /// If no keyval is bound to `key`, returns 0. For normal user input,
    /// you want to use `Keymap::translate_keyboard_state` instead of
    /// this function, since the effective group/level may not be
    /// the same as the current keyboard state.
    /// ## `key`
    /// a `KeymapKey` with keycode, group, and level initialized
    ///
    /// # Returns
    ///
    /// a keyval, or 0 if none was mapped to the given `key`
    pub fn lookup_key(&self, key: &KeymapKey) -> u32 {
        unsafe { gdk_sys::gdk_keymap_lookup_key(self.to_glib_none().0, key.to_glib_none().0) }
    }

    /// Translates the contents of a `EventKey` into a keyval, effective
    /// group, and level. Modifiers that affected the translation and
    /// are thus unavailable for application use are returned in
    /// `consumed_modifiers`.
    /// See [Groups][key-group-explanation] for an explanation of
    /// groups and levels. The `effective_group` is the group that was
    /// actually used for the translation; some keys such as Enter are not
    /// affected by the active keyboard group. The `level` is derived from
    /// `state`. For convenience, `EventKey` already contains the translated
    /// keyval, so this function isn’t as useful as you might think.
    ///
    /// `consumed_modifiers` gives modifiers that should be masked outfrom `state`
    /// when comparing this key press to a hot key. For instance, on a US keyboard,
    /// the `plus` symbol is shifted, so when comparing a key press to a
    /// `<Control>plus` accelerator `<Shift>` should be masked out.
    ///
    ///
    /// ```C
    /// // We want to ignore irrelevant modifiers like ScrollLock
    /// #define ALL_ACCELS_MASK (GDK_CONTROL_MASK | GDK_SHIFT_MASK | GDK_MOD1_MASK)
    /// gdk_keymap_translate_keyboard_state (keymap, event->hardware_keycode,
    ///                                      event->state, event->group,
    ///                                      &keyval, NULL, NULL, &consumed);
    /// if (keyval == GDK_PLUS &&
    ///     (event->state & ~consumed & ALL_ACCELS_MASK) == GDK_CONTROL_MASK)
    ///   // Control was pressed
    /// ```
    ///
    /// An older interpretation `consumed_modifiers` was that it contained
    /// all modifiers that might affect the translation of the key;
    /// this allowed accelerators to be stored with irrelevant consumed
    /// modifiers, by doing:
    ///
    /// ```C
    /// // XXX Don’t do this XXX
    /// if (keyval == accel_keyval &&
    ///     (event->state & ~consumed & ALL_ACCELS_MASK) == (accel_mods & ~consumed))
    ///   // Accelerator was pressed
    /// ```
    ///
    /// However, this did not work if multi-modifier combinations were
    /// used in the keymap, since, for instance, `<Control>` would be
    /// masked out even if only `<Control><Alt>` was used in the keymap.
    /// To support this usage as well as well as possible, all single
    /// modifier combinations that could affect the key for any combination
    /// of modifiers will be returned in `consumed_modifiers`; multi-modifier
    /// combinations are returned only when actually found in `state`. When
    /// you store accelerators, you should always store them with consumed
    /// modifiers removed. Store `<Control>plus`, not `<Control><Shift>plus`,
    /// ## `hardware_keycode`
    /// a keycode
    /// ## `state`
    /// a modifier state
    /// ## `group`
    /// active keyboard group
    /// ## `keyval`
    /// return location for keyval, or `None`
    /// ## `effective_group`
    /// return location for effective
    ///  group, or `None`
    /// ## `level`
    /// return location for level, or `None`
    /// ## `consumed_modifiers`
    /// return location for modifiers
    ///  that were used to determine the group or level, or `None`
    ///
    /// # Returns
    ///
    /// `true` if there was a keyval bound to the keycode/state/group
    pub fn translate_keyboard_state(
        &self,
        hardware_keycode: u32,
        state: ModifierType,
        group: i32,
    ) -> Option<(u32, i32, i32, ModifierType)> {
        unsafe {
            let mut keyval = mem::MaybeUninit::uninit();
            let mut effective_group = mem::MaybeUninit::uninit();
            let mut level = mem::MaybeUninit::uninit();
            let mut consumed_modifiers = mem::MaybeUninit::uninit();
            let ret = from_glib(gdk_sys::gdk_keymap_translate_keyboard_state(
                self.to_glib_none().0,
                hardware_keycode,
                state.to_glib(),
                group,
                keyval.as_mut_ptr(),
                effective_group.as_mut_ptr(),
                level.as_mut_ptr(),
                consumed_modifiers.as_mut_ptr(),
            ));
            let keyval = keyval.assume_init();
            let effective_group = effective_group.assume_init();
            let level = level.assume_init();
            let consumed_modifiers = consumed_modifiers.assume_init();
            if ret {
                Some((
                    keyval,
                    effective_group,
                    level,
                    from_glib(consumed_modifiers),
                ))
            } else {
                None
            }
        }
    }

    /// Returns the `Keymap` attached to the default display.
    ///
    /// # Deprecated since 3.22
    ///
    /// Use `Keymap::get_for_display` instead
    ///
    /// # Returns
    ///
    /// the `Keymap` attached to the default display.
    #[cfg_attr(feature = "v3_22", deprecated)]
    pub fn get_default() -> Option<Keymap> {
        assert_initialized_main_thread!();
        unsafe { from_glib_none(gdk_sys::gdk_keymap_get_default()) }
    }

    /// Returns the `Keymap` attached to `display`.
    /// ## `display`
    /// the `Display`.
    ///
    /// # Returns
    ///
    /// the `Keymap` attached to `display`.
    pub fn get_for_display(display: &Display) -> Option<Keymap> {
        skip_assert_initialized!();
        unsafe {
            from_glib_none(gdk_sys::gdk_keymap_get_for_display(
                display.to_glib_none().0,
            ))
        }
    }

    /// The ::direction-changed signal gets emitted when the direction of
    /// the keymap changes.
    pub fn connect_direction_changed<F: Fn(&Keymap) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn direction_changed_trampoline<F: Fn(&Keymap) + 'static>(
            this: *mut gdk_sys::GdkKeymap,
            f: glib_sys::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"direction-changed\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    direction_changed_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// The ::keys-changed signal is emitted when the mapping represented by
    /// `keymap` changes.
    pub fn connect_keys_changed<F: Fn(&Keymap) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn keys_changed_trampoline<F: Fn(&Keymap) + 'static>(
            this: *mut gdk_sys::GdkKeymap,
            f: glib_sys::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"keys-changed\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    keys_changed_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// The ::state-changed signal is emitted when the state of the
    /// keyboard changes, e.g when Caps Lock is turned on or off.
    /// See `Keymap::get_caps_lock_state`.
    pub fn connect_state_changed<F: Fn(&Keymap) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn state_changed_trampoline<F: Fn(&Keymap) + 'static>(
            this: *mut gdk_sys::GdkKeymap,
            f: glib_sys::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"state-changed\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    state_changed_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

impl fmt::Display for Keymap {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "Keymap")
    }
}