Struct genie_hki::Hotkey

pub struct Hotkey {
    pub key: i32,
    pub string_id: i32,
    pub ctrl: bool,
    pub alt: bool,
    pub shift: bool,
    // some fields omitted
}

The information about a single hotkey.

Fields

key: i32

Keycode that activates this hotkey.

You can use a crate like keycodes to compare this to named virtual keys like keycodes::KEY_RETURN.

If string_id is -1, this key must be 0.

string_id: i32

The string ID for this hotkey's label. -1 if this hotkey is unused.

ctrl: bool

Whether the Ctrl key needs to be held to activate this hotkey.

alt: bool

Whether the Alt key needs to be held to activate this hotkey.

shift: bool

Whether the Shift key needs to be held to activate this hotkey.

Implementations

impl Hotkey

pub fn key(self, key: i32) -> Self

Returns a hotkey equivalent to this one but with the key set to key.

Examples

use genie_hki::Hotkey;

let hki = Hotkey::default();
let hki2 = hki.key(5);
assert_eq!(0, hki.key);
assert_eq!(5, hki2.key);

pub fn string_id(self, string_id: i32) -> Self

Returns a hotkey equivalent to this one but with the string key set to string_id. If the id is -1, the returned key also has a key field set to 0.

Examples

use genie_hki::Hotkey;

let hki = Hotkey::default();
let hki2 = hki.string_id(5);
assert_eq!(-1, hki.string_id);
assert_eq!(5, hki2.string_id);

let hki3 = hki2.key(5);
let hki4 = hki3.string_id(-1);
assert_eq!(5, hki3.key);
assert_eq!(0, hki4.key);

pub fn ctrl(self, ctrl: bool) -> Self

Returns a hotkey equivalent to this one but with ctrl determining whether control must be held when pressing the key.

Examples

use genie_hki::Hotkey;

let hki = Hotkey::default();
let hki2 = hki.ctrl(true);
assert!(!hki.ctrl);
assert!(hki2.ctrl);

pub fn alt(self, alt: bool) -> Self

Returns a hotkey equivalent to this one but with alt determining whether alt must be held when pressing the key.

Examples

use genie_hki::Hotkey;

let hki = Hotkey::default();
let hki2 = hki.alt(true);
assert!(!hki.alt);
assert!(hki2.alt);

pub fn shift(self, shift: bool) -> Self

Returns a hotkey equivalent to this one but with shift determining whether shift must be held when pressing the key.

Examples

use genie_hki::Hotkey;

let hki = Hotkey::default();
let hki2 = hki.shift(true);
assert!(!hki.shift);
assert!(hki2.shift);

pub fn to_string_lang(&self, lang_file: &LangFile) -> String

Returns a string representation of this hotkey, using the strings from lang_file.

Examples

use genie_hki::Hotkey;
use genie_lang::{LangFile, StringKey};

let mut lang_file = LangFile::new();
lang_file.insert(StringKey::from(5u32), String::from("A"));
let hotkey = Hotkey::default().key(65).string_id(5).ctrl(true);
assert_eq!("A (5): ctrl-65", hotkey.to_string_lang(&lang_file));

let default = Hotkey::default();
assert_eq!("-1: 0", default.to_string_lang(&lang_file));

Trait Implementations

impl Clone for Hotkey

fn clone(&self) -> Hotkey

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for Hotkey

impl Debug for Hotkey

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl Default for Hotkey

fn default() -> Self

Returns the "default value" for a type.

impl Display for Hotkey

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl Eq for Hotkey

impl Hash for Hotkey

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given [Hasher].

impl PartialEq<Hotkey> for Hotkey

fn eq(&self, other: &Hotkey) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Hotkey) -> bool

This method tests for !=.

impl StructuralEq for Hotkey

impl StructuralPartialEq for Hotkey