module Glint::Input::Keyboard

Defined in:

glint/input/key.cr

Class Method Summary

Class Method Detail

def self.a_down? : Bool #

Returns whether Key::A is in the down state.

def self.a_down? : Bool
  Key::A.is_down?
end

[View source]
def self.a_pressed? : Bool #

Returns whether Key::A is in the pressed state.

def self.a_pressed? : Bool
  Key::A.is_pressed?
end

[View source]
def self.a_released? : Bool #

Returns whether Key::A is in the released state.

def self.a_released? : Bool
  Key::A.is_released?
end

[View source]
def self.a_up? : Bool #

Returns whether Key::A is in the up state.

def self.a_up? : Bool
  Key::A.is_up?
end

[View source]
def self.apostrophe_down? : Bool #

Returns whether Key::Apostrophe is in the down state.

def self.apostrophe_down? : Bool
  Key::Apostrophe.is_down?
end

[View source]
def self.apostrophe_pressed? : Bool #

Returns whether Key::Apostrophe is in the pressed state.

def self.apostrophe_pressed? : Bool
  Key::Apostrophe.is_pressed?
end

[View source]
def self.apostrophe_released? : Bool #

Returns whether Key::Apostrophe is in the released state.

def self.apostrophe_released? : Bool
  Key::Apostrophe.is_released?
end

[View source]
def self.apostrophe_up? : Bool #

Returns whether Key::Apostrophe is in the up state.

def self.apostrophe_up? : Bool
  Key::Apostrophe.is_up?
end

[View source]
def self.b_down? : Bool #

Returns whether Key::B is in the down state.

def self.b_down? : Bool
  Key::B.is_down?
end

[View source]
def self.b_pressed? : Bool #

Returns whether Key::B is in the pressed state.

def self.b_pressed? : Bool
  Key::B.is_pressed?
end

[View source]
def self.b_released? : Bool #

Returns whether Key::B is in the released state.

def self.b_released? : Bool
  Key::B.is_released?
end

[View source]
def self.b_up? : Bool #

Returns whether Key::B is in the up state.

def self.b_up? : Bool
  Key::B.is_up?
end

[View source]
def self.back_down? : Bool #

Returns whether Key::Back is in the down state.

def self.back_down? : Bool
  Key::Back.is_down?
end

[View source]
def self.back_pressed? : Bool #

Returns whether Key::Back is in the pressed state.

def self.back_pressed? : Bool
  Key::Back.is_pressed?
end

[View source]
def self.back_released? : Bool #

Returns whether Key::Back is in the released state.

def self.back_released? : Bool
  Key::Back.is_released?
end

[View source]
def self.back_up? : Bool #

Returns whether Key::Back is in the up state.

def self.back_up? : Bool
  Key::Back.is_up?
end

[View source]
def self.backslash_down? : Bool #

Returns whether Key::Backslash is in the down state.

def self.backslash_down? : Bool
  Key::Backslash.is_down?
end

[View source]
def self.backslash_pressed? : Bool #

Returns whether Key::Backslash is in the pressed state.

def self.backslash_pressed? : Bool
  Key::Backslash.is_pressed?
end

[View source]
def self.backslash_released? : Bool #

Returns whether Key::Backslash is in the released state.

def self.backslash_released? : Bool
  Key::Backslash.is_released?
end

[View source]
def self.backslash_up? : Bool #

Returns whether Key::Backslash is in the up state.

def self.backslash_up? : Bool
  Key::Backslash.is_up?
end

[View source]
def self.backspace_down? : Bool #

Returns whether Key::Backspace is in the down state.

def self.backspace_down? : Bool
  Key::Backspace.is_down?
end

[View source]
def self.backspace_pressed? : Bool #

Returns whether Key::Backspace is in the pressed state.

def self.backspace_pressed? : Bool
  Key::Backspace.is_pressed?
end

[View source]
def self.backspace_released? : Bool #

Returns whether Key::Backspace is in the released state.

def self.backspace_released? : Bool
  Key::Backspace.is_released?
end

[View source]
def self.backspace_up? : Bool #

Returns whether Key::Backspace is in the up state.

def self.backspace_up? : Bool
  Key::Backspace.is_up?
end

[View source]
def self.c_down? : Bool #

Returns whether Key::C is in the down state.

def self.c_down? : Bool
  Key::C.is_down?
end

[View source]
def self.c_pressed? : Bool #

Returns whether Key::C is in the pressed state.

def self.c_pressed? : Bool
  Key::C.is_pressed?
end

[View source]
def self.c_released? : Bool #

Returns whether Key::C is in the released state.

def self.c_released? : Bool
  Key::C.is_released?
end

[View source]
def self.c_up? : Bool #

Returns whether Key::C is in the up state.

def self.c_up? : Bool
  Key::C.is_up?
end

[View source]
def self.caps_lock_down? : Bool #

Returns whether Key::CapsLock is in the down state.

def self.caps_lock_down? : Bool
  Key::CapsLock.is_down?
end

[View source]
def self.caps_lock_pressed? : Bool #

Returns whether Key::CapsLock is in the pressed state.

def self.caps_lock_pressed? : Bool
  Key::CapsLock.is_pressed?
end

[View source]
def self.caps_lock_released? : Bool #

Returns whether Key::CapsLock is in the released state.

def self.caps_lock_released? : Bool
  Key::CapsLock.is_released?
end

[View source]
def self.caps_lock_up? : Bool #

Returns whether Key::CapsLock is in the up state.

def self.caps_lock_up? : Bool
  Key::CapsLock.is_up?
end

[View source]
def self.comma_down? : Bool #

Returns whether Key::Comma is in the down state.

def self.comma_down? : Bool
  Key::Comma.is_down?
end

[View source]
def self.comma_pressed? : Bool #

Returns whether Key::Comma is in the pressed state.

def self.comma_pressed? : Bool
  Key::Comma.is_pressed?
end

[View source]
def self.comma_released? : Bool #

Returns whether Key::Comma is in the released state.

def self.comma_released? : Bool
  Key::Comma.is_released?
end

[View source]
def self.comma_up? : Bool #

Returns whether Key::Comma is in the up state.

def self.comma_up? : Bool
  Key::Comma.is_up?
end

[View source]
def self.d_down? : Bool #

Returns whether Key::D is in the down state.

def self.d_down? : Bool
  Key::D.is_down?
end

[View source]
def self.d_pressed? : Bool #

Returns whether Key::D is in the pressed state.

def self.d_pressed? : Bool
  Key::D.is_pressed?
end

[View source]
def self.d_released? : Bool #

Returns whether Key::D is in the released state.

def self.d_released? : Bool
  Key::D.is_released?
end

[View source]
def self.d_up? : Bool #

Returns whether Key::D is in the up state.

def self.d_up? : Bool
  Key::D.is_up?
end

[View source]
def self.delete_down? : Bool #

Returns whether Key::Delete is in the down state.

def self.delete_down? : Bool
  Key::Delete.is_down?
end

[View source]
def self.delete_pressed? : Bool #

Returns whether Key::Delete is in the pressed state.

def self.delete_pressed? : Bool
  Key::Delete.is_pressed?
end

[View source]
def self.delete_released? : Bool #

Returns whether Key::Delete is in the released state.

def self.delete_released? : Bool
  Key::Delete.is_released?
end

[View source]
def self.delete_up? : Bool #

Returns whether Key::Delete is in the up state.

def self.delete_up? : Bool
  Key::Delete.is_up?
end

[View source]
def self.down?(key : Key) : Bool #

Returns whether mouse_button is in the down state.

def self.down?(key : Key) : Bool
  key.is_down?
end

[View source]
def self.down_down? : Bool #

Returns whether Key::Down is in the down state.

def self.down_down? : Bool
  Key::Down.is_down?
end

[View source]
def self.down_pressed? : Bool #

Returns whether Key::Down is in the pressed state.

def self.down_pressed? : Bool
  Key::Down.is_pressed?
end

[View source]
def self.down_released? : Bool #

Returns whether Key::Down is in the released state.

def self.down_released? : Bool
  Key::Down.is_released?
end

[View source]
def self.down_up? : Bool #

Returns whether Key::Down is in the up state.

def self.down_up? : Bool
  Key::Down.is_up?
end

[View source]
def self.e_down? : Bool #

Returns whether Key::E is in the down state.

def self.e_down? : Bool
  Key::E.is_down?
end

[View source]
def self.e_pressed? : Bool #

Returns whether Key::E is in the pressed state.

def self.e_pressed? : Bool
  Key::E.is_pressed?
end

[View source]
def self.e_released? : Bool #

Returns whether Key::E is in the released state.

def self.e_released? : Bool
  Key::E.is_released?
end

[View source]
def self.e_up? : Bool #

Returns whether Key::E is in the up state.

def self.e_up? : Bool
  Key::E.is_up?
end

[View source]
def self.eight_down? : Bool #

Returns whether Key::Eight is in the down state.

def self.eight_down? : Bool
  Key::Eight.is_down?
end

[View source]
def self.eight_pressed? : Bool #

Returns whether Key::Eight is in the pressed state.

def self.eight_pressed? : Bool
  Key::Eight.is_pressed?
end

[View source]
def self.eight_released? : Bool #

Returns whether Key::Eight is in the released state.

def self.eight_released? : Bool
  Key::Eight.is_released?
end

[View source]
def self.eight_up? : Bool #

Returns whether Key::Eight is in the up state.

def self.eight_up? : Bool
  Key::Eight.is_up?
end

[View source]
def self.end_down? : Bool #

Returns whether Key::End is in the down state.

def self.end_down? : Bool
  Key::End.is_down?
end

[View source]
def self.end_pressed? : Bool #

Returns whether Key::End is in the pressed state.

def self.end_pressed? : Bool
  Key::End.is_pressed?
end

[View source]
def self.end_released? : Bool #

Returns whether Key::End is in the released state.

def self.end_released? : Bool
  Key::End.is_released?
end

[View source]
def self.end_up? : Bool #

Returns whether Key::End is in the up state.

def self.end_up? : Bool
  Key::End.is_up?
end

[View source]
def self.enter_down? : Bool #

Returns whether Key::Enter is in the down state.

def self.enter_down? : Bool
  Key::Enter.is_down?
end

[View source]
def self.enter_pressed? : Bool #

Returns whether Key::Enter is in the pressed state.

def self.enter_pressed? : Bool
  Key::Enter.is_pressed?
end

[View source]
def self.enter_released? : Bool #

Returns whether Key::Enter is in the released state.

def self.enter_released? : Bool
  Key::Enter.is_released?
end

[View source]
def self.enter_up? : Bool #

Returns whether Key::Enter is in the up state.

def self.enter_up? : Bool
  Key::Enter.is_up?
end

[View source]
def self.equal_down? : Bool #

Returns whether Key::Equal is in the down state.

def self.equal_down? : Bool
  Key::Equal.is_down?
end

[View source]
def self.equal_pressed? : Bool #

Returns whether Key::Equal is in the pressed state.

def self.equal_pressed? : Bool
  Key::Equal.is_pressed?
end

[View source]
def self.equal_released? : Bool #

Returns whether Key::Equal is in the released state.

def self.equal_released? : Bool
  Key::Equal.is_released?
end

[View source]
def self.equal_up? : Bool #

Returns whether Key::Equal is in the up state.

def self.equal_up? : Bool
  Key::Equal.is_up?
end

[View source]
def self.f10_down? : Bool #

Returns whether Key::F10 is in the down state.

def self.f10_down? : Bool
  Key::F10.is_down?
end

[View source]
def self.f10_pressed? : Bool #

Returns whether Key::F10 is in the pressed state.

def self.f10_pressed? : Bool
  Key::F10.is_pressed?
end

[View source]
def self.f10_released? : Bool #

Returns whether Key::F10 is in the released state.

def self.f10_released? : Bool
  Key::F10.is_released?
end

[View source]
def self.f10_up? : Bool #

Returns whether Key::F10 is in the up state.

def self.f10_up? : Bool
  Key::F10.is_up?
end

[View source]
def self.f11_down? : Bool #

Returns whether Key::F11 is in the down state.

def self.f11_down? : Bool
  Key::F11.is_down?
end

[View source]
def self.f11_pressed? : Bool #

Returns whether Key::F11 is in the pressed state.

def self.f11_pressed? : Bool
  Key::F11.is_pressed?
end

[View source]
def self.f11_released? : Bool #

Returns whether Key::F11 is in the released state.

def self.f11_released? : Bool
  Key::F11.is_released?
end

[View source]
def self.f11_up? : Bool #

Returns whether Key::F11 is in the up state.

def self.f11_up? : Bool
  Key::F11.is_up?
end

[View source]
def self.f12_down? : Bool #

Returns whether Key::F12 is in the down state.

def self.f12_down? : Bool
  Key::F12.is_down?
end

[View source]
def self.f12_pressed? : Bool #

Returns whether Key::F12 is in the pressed state.

def self.f12_pressed? : Bool
  Key::F12.is_pressed?
end

[View source]
def self.f12_released? : Bool #

Returns whether Key::F12 is in the released state.

def self.f12_released? : Bool
  Key::F12.is_released?
end

[View source]
def self.f12_up? : Bool #

Returns whether Key::F12 is in the up state.

def self.f12_up? : Bool
  Key::F12.is_up?
end

[View source]
def self.f1_down? : Bool #

Returns whether Key::F1 is in the down state.

def self.f1_down? : Bool
  Key::F1.is_down?
end

[View source]
def self.f1_pressed? : Bool #

Returns whether Key::F1 is in the pressed state.

def self.f1_pressed? : Bool
  Key::F1.is_pressed?
end

[View source]
def self.f1_released? : Bool #

Returns whether Key::F1 is in the released state.

def self.f1_released? : Bool
  Key::F1.is_released?
end

[View source]
def self.f1_up? : Bool #

Returns whether Key::F1 is in the up state.

def self.f1_up? : Bool
  Key::F1.is_up?
end

[View source]
def self.f2_down? : Bool #

Returns whether Key::F2 is in the down state.

def self.f2_down? : Bool
  Key::F2.is_down?
end

[View source]
def self.f2_pressed? : Bool #

Returns whether Key::F2 is in the pressed state.

def self.f2_pressed? : Bool
  Key::F2.is_pressed?
end

[View source]
def self.f2_released? : Bool #

Returns whether Key::F2 is in the released state.

def self.f2_released? : Bool
  Key::F2.is_released?
end

[View source]
def self.f2_up? : Bool #

Returns whether Key::F2 is in the up state.

def self.f2_up? : Bool
  Key::F2.is_up?
end

[View source]
def self.f3_down? : Bool #

Returns whether Key::F3 is in the down state.

def self.f3_down? : Bool
  Key::F3.is_down?
end

[View source]
def self.f3_pressed? : Bool #

Returns whether Key::F3 is in the pressed state.

def self.f3_pressed? : Bool
  Key::F3.is_pressed?
end

[View source]
def self.f3_released? : Bool #

Returns whether Key::F3 is in the released state.

def self.f3_released? : Bool
  Key::F3.is_released?
end

[View source]
def self.f3_up? : Bool #

Returns whether Key::F3 is in the up state.

def self.f3_up? : Bool
  Key::F3.is_up?
end

[View source]
def self.f4_down? : Bool #

Returns whether Key::F4 is in the down state.

def self.f4_down? : Bool
  Key::F4.is_down?
end

[View source]
def self.f4_pressed? : Bool #

Returns whether Key::F4 is in the pressed state.

def self.f4_pressed? : Bool
  Key::F4.is_pressed?
end

[View source]
def self.f4_released? : Bool #

Returns whether Key::F4 is in the released state.

def self.f4_released? : Bool
  Key::F4.is_released?
end

[View source]
def self.f4_up? : Bool #

Returns whether Key::F4 is in the up state.

def self.f4_up? : Bool
  Key::F4.is_up?
end

[View source]
def self.f5_down? : Bool #

Returns whether Key::F5 is in the down state.

def self.f5_down? : Bool
  Key::F5.is_down?
end

[View source]
def self.f5_pressed? : Bool #

Returns whether Key::F5 is in the pressed state.

def self.f5_pressed? : Bool
  Key::F5.is_pressed?
end

[View source]
def self.f5_released? : Bool #

Returns whether Key::F5 is in the released state.

def self.f5_released? : Bool
  Key::F5.is_released?
end

[View source]
def self.f5_up? : Bool #

Returns whether Key::F5 is in the up state.

def self.f5_up? : Bool
  Key::F5.is_up?
end

[View source]
def self.f6_down? : Bool #

Returns whether Key::F6 is in the down state.

def self.f6_down? : Bool
  Key::F6.is_down?
end

[View source]
def self.f6_pressed? : Bool #

Returns whether Key::F6 is in the pressed state.

def self.f6_pressed? : Bool
  Key::F6.is_pressed?
end

[View source]
def self.f6_released? : Bool #

Returns whether Key::F6 is in the released state.

def self.f6_released? : Bool
  Key::F6.is_released?
end

[View source]
def self.f6_up? : Bool #

Returns whether Key::F6 is in the up state.

def self.f6_up? : Bool
  Key::F6.is_up?
end

[View source]
def self.f7_down? : Bool #

Returns whether Key::F7 is in the down state.

def self.f7_down? : Bool
  Key::F7.is_down?
end

[View source]
def self.f7_pressed? : Bool #

Returns whether Key::F7 is in the pressed state.

def self.f7_pressed? : Bool
  Key::F7.is_pressed?
end

[View source]
def self.f7_released? : Bool #

Returns whether Key::F7 is in the released state.

def self.f7_released? : Bool
  Key::F7.is_released?
end

[View source]
def self.f7_up? : Bool #

Returns whether Key::F7 is in the up state.

def self.f7_up? : Bool
  Key::F7.is_up?
end

[View source]
def self.f8_down? : Bool #

Returns whether Key::F8 is in the down state.

def self.f8_down? : Bool
  Key::F8.is_down?
end

[View source]
def self.f8_pressed? : Bool #

Returns whether Key::F8 is in the pressed state.

def self.f8_pressed? : Bool
  Key::F8.is_pressed?
end

[View source]
def self.f8_released? : Bool #

Returns whether Key::F8 is in the released state.

def self.f8_released? : Bool
  Key::F8.is_released?
end

[View source]
def self.f8_up? : Bool #

Returns whether Key::F8 is in the up state.

def self.f8_up? : Bool
  Key::F8.is_up?
end

[View source]
def self.f9_down? : Bool #

Returns whether Key::F9 is in the down state.

def self.f9_down? : Bool
  Key::F9.is_down?
end

[View source]
def self.f9_pressed? : Bool #

Returns whether Key::F9 is in the pressed state.

def self.f9_pressed? : Bool
  Key::F9.is_pressed?
end

[View source]
def self.f9_released? : Bool #

Returns whether Key::F9 is in the released state.

def self.f9_released? : Bool
  Key::F9.is_released?
end

[View source]
def self.f9_up? : Bool #

Returns whether Key::F9 is in the up state.

def self.f9_up? : Bool
  Key::F9.is_up?
end

[View source]
def self.f_down? : Bool #

Returns whether Key::F is in the down state.

def self.f_down? : Bool
  Key::F.is_down?
end

[View source]
def self.f_pressed? : Bool #

Returns whether Key::F is in the pressed state.

def self.f_pressed? : Bool
  Key::F.is_pressed?
end

[View source]
def self.f_released? : Bool #

Returns whether Key::F is in the released state.

def self.f_released? : Bool
  Key::F.is_released?
end

[View source]
def self.f_up? : Bool #

Returns whether Key::F is in the up state.

def self.f_up? : Bool
  Key::F.is_up?
end

[View source]
def self.five_down? : Bool #

Returns whether Key::Five is in the down state.

def self.five_down? : Bool
  Key::Five.is_down?
end

[View source]
def self.five_pressed? : Bool #

Returns whether Key::Five is in the pressed state.

def self.five_pressed? : Bool
  Key::Five.is_pressed?
end

[View source]
def self.five_released? : Bool #

Returns whether Key::Five is in the released state.

def self.five_released? : Bool
  Key::Five.is_released?
end

[View source]
def self.five_up? : Bool #

Returns whether Key::Five is in the up state.

def self.five_up? : Bool
  Key::Five.is_up?
end

[View source]
def self.four_down? : Bool #

Returns whether Key::Four is in the down state.

def self.four_down? : Bool
  Key::Four.is_down?
end

[View source]
def self.four_pressed? : Bool #

Returns whether Key::Four is in the pressed state.

def self.four_pressed? : Bool
  Key::Four.is_pressed?
end

[View source]
def self.four_released? : Bool #

Returns whether Key::Four is in the released state.

def self.four_released? : Bool
  Key::Four.is_released?
end

[View source]
def self.four_up? : Bool #

Returns whether Key::Four is in the up state.

def self.four_up? : Bool
  Key::Four.is_up?
end

[View source]
def self.g_down? : Bool #

Returns whether Key::G is in the down state.

def self.g_down? : Bool
  Key::G.is_down?
end

[View source]
def self.g_pressed? : Bool #

Returns whether Key::G is in the pressed state.

def self.g_pressed? : Bool
  Key::G.is_pressed?
end

[View source]
def self.g_released? : Bool #

Returns whether Key::G is in the released state.

def self.g_released? : Bool
  Key::G.is_released?
end

[View source]
def self.g_up? : Bool #

Returns whether Key::G is in the up state.

def self.g_up? : Bool
  Key::G.is_up?
end

[View source]
def self.grave_down? : Bool #

Returns whether Key::Grave is in the down state.

def self.grave_down? : Bool
  Key::Grave.is_down?
end

[View source]
def self.grave_pressed? : Bool #

Returns whether Key::Grave is in the pressed state.

def self.grave_pressed? : Bool
  Key::Grave.is_pressed?
end

[View source]
def self.grave_released? : Bool #

Returns whether Key::Grave is in the released state.

def self.grave_released? : Bool
  Key::Grave.is_released?
end

[View source]
def self.grave_up? : Bool #

Returns whether Key::Grave is in the up state.

def self.grave_up? : Bool
  Key::Grave.is_up?
end

[View source]
def self.h_down? : Bool #

Returns whether Key::H is in the down state.

def self.h_down? : Bool
  Key::H.is_down?
end

[View source]
def self.h_pressed? : Bool #

Returns whether Key::H is in the pressed state.

def self.h_pressed? : Bool
  Key::H.is_pressed?
end

[View source]
def self.h_released? : Bool #

Returns whether Key::H is in the released state.

def self.h_released? : Bool
  Key::H.is_released?
end

[View source]
def self.h_up? : Bool #

Returns whether Key::H is in the up state.

def self.h_up? : Bool
  Key::H.is_up?
end

[View source]
def self.home_down? : Bool #

Returns whether Key::Home is in the down state.

def self.home_down? : Bool
  Key::Home.is_down?
end

[View source]
def self.home_pressed? : Bool #

Returns whether Key::Home is in the pressed state.

def self.home_pressed? : Bool
  Key::Home.is_pressed?
end

[View source]
def self.home_released? : Bool #

Returns whether Key::Home is in the released state.

def self.home_released? : Bool
  Key::Home.is_released?
end

[View source]
def self.home_up? : Bool #

Returns whether Key::Home is in the up state.

def self.home_up? : Bool
  Key::Home.is_up?
end

[View source]
def self.i_down? : Bool #

Returns whether Key::I is in the down state.

def self.i_down? : Bool
  Key::I.is_down?
end

[View source]
def self.i_pressed? : Bool #

Returns whether Key::I is in the pressed state.

def self.i_pressed? : Bool
  Key::I.is_pressed?
end

[View source]
def self.i_released? : Bool #

Returns whether Key::I is in the released state.

def self.i_released? : Bool
  Key::I.is_released?
end

[View source]
def self.i_up? : Bool #

Returns whether Key::I is in the up state.

def self.i_up? : Bool
  Key::I.is_up?
end

[View source]
def self.insert_down? : Bool #

Returns whether Key::Insert is in the down state.

def self.insert_down? : Bool
  Key::Insert.is_down?
end

[View source]
def self.insert_pressed? : Bool #

Returns whether Key::Insert is in the pressed state.

def self.insert_pressed? : Bool
  Key::Insert.is_pressed?
end

[View source]
def self.insert_released? : Bool #

Returns whether Key::Insert is in the released state.

def self.insert_released? : Bool
  Key::Insert.is_released?
end

[View source]
def self.insert_up? : Bool #

Returns whether Key::Insert is in the up state.

def self.insert_up? : Bool
  Key::Insert.is_up?
end

[View source]
def self.j_down? : Bool #

Returns whether Key::J is in the down state.

def self.j_down? : Bool
  Key::J.is_down?
end

[View source]
def self.j_pressed? : Bool #

Returns whether Key::J is in the pressed state.

def self.j_pressed? : Bool
  Key::J.is_pressed?
end

[View source]
def self.j_released? : Bool #

Returns whether Key::J is in the released state.

def self.j_released? : Bool
  Key::J.is_released?
end

[View source]
def self.j_up? : Bool #

Returns whether Key::J is in the up state.

def self.j_up? : Bool
  Key::J.is_up?
end

[View source]
def self.k_down? : Bool #

Returns whether Key::K is in the down state.

def self.k_down? : Bool
  Key::K.is_down?
end

[View source]
def self.k_pressed? : Bool #

Returns whether Key::K is in the pressed state.

def self.k_pressed? : Bool
  Key::K.is_pressed?
end

[View source]
def self.k_released? : Bool #

Returns whether Key::K is in the released state.

def self.k_released? : Bool
  Key::K.is_released?
end

[View source]
def self.k_up? : Bool #

Returns whether Key::K is in the up state.

def self.k_up? : Bool
  Key::K.is_up?
end

[View source]
def self.kb_menu_down? : Bool #

Returns whether Key::KbMenu is in the down state.

def self.kb_menu_down? : Bool
  Key::KbMenu.is_down?
end

[View source]
def self.kb_menu_pressed? : Bool #

Returns whether Key::KbMenu is in the pressed state.

def self.kb_menu_pressed? : Bool
  Key::KbMenu.is_pressed?
end

[View source]
def self.kb_menu_released? : Bool #

Returns whether Key::KbMenu is in the released state.

def self.kb_menu_released? : Bool
  Key::KbMenu.is_released?
end

[View source]
def self.kb_menu_up? : Bool #

Returns whether Key::KbMenu is in the up state.

def self.kb_menu_up? : Bool
  Key::KbMenu.is_up?
end

[View source]
def self.kp0_down? : Bool #

Returns whether Key::Kp0 is in the down state.

def self.kp0_down? : Bool
  Key::Kp0.is_down?
end

[View source]
def self.kp0_pressed? : Bool #

Returns whether Key::Kp0 is in the pressed state.

def self.kp0_pressed? : Bool
  Key::Kp0.is_pressed?
end

[View source]
def self.kp0_released? : Bool #

Returns whether Key::Kp0 is in the released state.

def self.kp0_released? : Bool
  Key::Kp0.is_released?
end

[View source]
def self.kp0_up? : Bool #

Returns whether Key::Kp0 is in the up state.

def self.kp0_up? : Bool
  Key::Kp0.is_up?
end

[View source]
def self.kp1_down? : Bool #

Returns whether Key::Kp1 is in the down state.

def self.kp1_down? : Bool
  Key::Kp1.is_down?
end

[View source]
def self.kp1_pressed? : Bool #

Returns whether Key::Kp1 is in the pressed state.

def self.kp1_pressed? : Bool
  Key::Kp1.is_pressed?
end

[View source]
def self.kp1_released? : Bool #

Returns whether Key::Kp1 is in the released state.

def self.kp1_released? : Bool
  Key::Kp1.is_released?
end

[View source]
def self.kp1_up? : Bool #

Returns whether Key::Kp1 is in the up state.

def self.kp1_up? : Bool
  Key::Kp1.is_up?
end

[View source]
def self.kp2_down? : Bool #

Returns whether Key::Kp2 is in the down state.

def self.kp2_down? : Bool
  Key::Kp2.is_down?
end

[View source]
def self.kp2_pressed? : Bool #

Returns whether Key::Kp2 is in the pressed state.

def self.kp2_pressed? : Bool
  Key::Kp2.is_pressed?
end

[View source]
def self.kp2_released? : Bool #

Returns whether Key::Kp2 is in the released state.

def self.kp2_released? : Bool
  Key::Kp2.is_released?
end

[View source]
def self.kp2_up? : Bool #

Returns whether Key::Kp2 is in the up state.

def self.kp2_up? : Bool
  Key::Kp2.is_up?
end

[View source]
def self.kp3_down? : Bool #

Returns whether Key::Kp3 is in the down state.

def self.kp3_down? : Bool
  Key::Kp3.is_down?
end

[View source]
def self.kp3_pressed? : Bool #

Returns whether Key::Kp3 is in the pressed state.

def self.kp3_pressed? : Bool
  Key::Kp3.is_pressed?
end

[View source]
def self.kp3_released? : Bool #

Returns whether Key::Kp3 is in the released state.

def self.kp3_released? : Bool
  Key::Kp3.is_released?
end

[View source]
def self.kp3_up? : Bool #

Returns whether Key::Kp3 is in the up state.

def self.kp3_up? : Bool
  Key::Kp3.is_up?
end

[View source]
def self.kp4_down? : Bool #

Returns whether Key::Kp4 is in the down state.

def self.kp4_down? : Bool
  Key::Kp4.is_down?
end

[View source]
def self.kp4_pressed? : Bool #

Returns whether Key::Kp4 is in the pressed state.

def self.kp4_pressed? : Bool
  Key::Kp4.is_pressed?
end

[View source]
def self.kp4_released? : Bool #

Returns whether Key::Kp4 is in the released state.

def self.kp4_released? : Bool
  Key::Kp4.is_released?
end

[View source]
def self.kp4_up? : Bool #

Returns whether Key::Kp4 is in the up state.

def self.kp4_up? : Bool
  Key::Kp4.is_up?
end

[View source]
def self.kp5_down? : Bool #

Returns whether Key::Kp5 is in the down state.

def self.kp5_down? : Bool
  Key::Kp5.is_down?
end

[View source]
def self.kp5_pressed? : Bool #

Returns whether Key::Kp5 is in the pressed state.

def self.kp5_pressed? : Bool
  Key::Kp5.is_pressed?
end

[View source]
def self.kp5_released? : Bool #

Returns whether Key::Kp5 is in the released state.

def self.kp5_released? : Bool
  Key::Kp5.is_released?
end

[View source]
def self.kp5_up? : Bool #

Returns whether Key::Kp5 is in the up state.

def self.kp5_up? : Bool
  Key::Kp5.is_up?
end

[View source]
def self.kp6_down? : Bool #

Returns whether Key::Kp6 is in the down state.

def self.kp6_down? : Bool
  Key::Kp6.is_down?
end

[View source]
def self.kp6_pressed? : Bool #

Returns whether Key::Kp6 is in the pressed state.

def self.kp6_pressed? : Bool
  Key::Kp6.is_pressed?
end

[View source]
def self.kp6_released? : Bool #

Returns whether Key::Kp6 is in the released state.

def self.kp6_released? : Bool
  Key::Kp6.is_released?
end

[View source]
def self.kp6_up? : Bool #

Returns whether Key::Kp6 is in the up state.

def self.kp6_up? : Bool
  Key::Kp6.is_up?
end

[View source]
def self.kp7_down? : Bool #

Returns whether Key::Kp7 is in the down state.

def self.kp7_down? : Bool
  Key::Kp7.is_down?
end

[View source]
def self.kp7_pressed? : Bool #

Returns whether Key::Kp7 is in the pressed state.

def self.kp7_pressed? : Bool
  Key::Kp7.is_pressed?
end

[View source]
def self.kp7_released? : Bool #

Returns whether Key::Kp7 is in the released state.

def self.kp7_released? : Bool
  Key::Kp7.is_released?
end

[View source]
def self.kp7_up? : Bool #

Returns whether Key::Kp7 is in the up state.

def self.kp7_up? : Bool
  Key::Kp7.is_up?
end

[View source]
def self.kp8_down? : Bool #

Returns whether Key::Kp8 is in the down state.

def self.kp8_down? : Bool
  Key::Kp8.is_down?
end

[View source]
def self.kp8_pressed? : Bool #

Returns whether Key::Kp8 is in the pressed state.

def self.kp8_pressed? : Bool
  Key::Kp8.is_pressed?
end

[View source]
def self.kp8_released? : Bool #

Returns whether Key::Kp8 is in the released state.

def self.kp8_released? : Bool
  Key::Kp8.is_released?
end

[View source]
def self.kp8_up? : Bool #

Returns whether Key::Kp8 is in the up state.

def self.kp8_up? : Bool
  Key::Kp8.is_up?
end

[View source]
def self.kp9_down? : Bool #

Returns whether Key::Kp9 is in the down state.

def self.kp9_down? : Bool
  Key::Kp9.is_down?
end

[View source]
def self.kp9_pressed? : Bool #

Returns whether Key::Kp9 is in the pressed state.

def self.kp9_pressed? : Bool
  Key::Kp9.is_pressed?
end

[View source]
def self.kp9_released? : Bool #

Returns whether Key::Kp9 is in the released state.

def self.kp9_released? : Bool
  Key::Kp9.is_released?
end

[View source]
def self.kp9_up? : Bool #

Returns whether Key::Kp9 is in the up state.

def self.kp9_up? : Bool
  Key::Kp9.is_up?
end

[View source]
def self.kp_add_down? : Bool #

Returns whether Key::KpAdd is in the down state.

def self.kp_add_down? : Bool
  Key::KpAdd.is_down?
end

[View source]
def self.kp_add_pressed? : Bool #

Returns whether Key::KpAdd is in the pressed state.

def self.kp_add_pressed? : Bool
  Key::KpAdd.is_pressed?
end

[View source]
def self.kp_add_released? : Bool #

Returns whether Key::KpAdd is in the released state.

def self.kp_add_released? : Bool
  Key::KpAdd.is_released?
end

[View source]
def self.kp_add_up? : Bool #

Returns whether Key::KpAdd is in the up state.

def self.kp_add_up? : Bool
  Key::KpAdd.is_up?
end

[View source]
def self.kp_decimal_down? : Bool #

Returns whether Key::KpDecimal is in the down state.

def self.kp_decimal_down? : Bool
  Key::KpDecimal.is_down?
end

[View source]
def self.kp_decimal_pressed? : Bool #

Returns whether Key::KpDecimal is in the pressed state.

def self.kp_decimal_pressed? : Bool
  Key::KpDecimal.is_pressed?
end

[View source]
def self.kp_decimal_released? : Bool #

Returns whether Key::KpDecimal is in the released state.

def self.kp_decimal_released? : Bool
  Key::KpDecimal.is_released?
end

[View source]
def self.kp_decimal_up? : Bool #

Returns whether Key::KpDecimal is in the up state.

def self.kp_decimal_up? : Bool
  Key::KpDecimal.is_up?
end

[View source]
def self.kp_divide_down? : Bool #

Returns whether Key::KpDivide is in the down state.

def self.kp_divide_down? : Bool
  Key::KpDivide.is_down?
end

[View source]
def self.kp_divide_pressed? : Bool #

Returns whether Key::KpDivide is in the pressed state.

def self.kp_divide_pressed? : Bool
  Key::KpDivide.is_pressed?
end

[View source]
def self.kp_divide_released? : Bool #

Returns whether Key::KpDivide is in the released state.

def self.kp_divide_released? : Bool
  Key::KpDivide.is_released?
end

[View source]
def self.kp_divide_up? : Bool #

Returns whether Key::KpDivide is in the up state.

def self.kp_divide_up? : Bool
  Key::KpDivide.is_up?
end

[View source]
def self.kp_enter_down? : Bool #

Returns whether Key::KpEnter is in the down state.

def self.kp_enter_down? : Bool
  Key::KpEnter.is_down?
end

[View source]
def self.kp_enter_pressed? : Bool #

Returns whether Key::KpEnter is in the pressed state.

def self.kp_enter_pressed? : Bool
  Key::KpEnter.is_pressed?
end

[View source]
def self.kp_enter_released? : Bool #

Returns whether Key::KpEnter is in the released state.

def self.kp_enter_released? : Bool
  Key::KpEnter.is_released?
end

[View source]
def self.kp_enter_up? : Bool #

Returns whether Key::KpEnter is in the up state.

def self.kp_enter_up? : Bool
  Key::KpEnter.is_up?
end

[View source]
def self.kp_equal_down? : Bool #

Returns whether Key::KpEqual is in the down state.

def self.kp_equal_down? : Bool
  Key::KpEqual.is_down?
end

[View source]
def self.kp_equal_pressed? : Bool #

Returns whether Key::KpEqual is in the pressed state.

def self.kp_equal_pressed? : Bool
  Key::KpEqual.is_pressed?
end

[View source]
def self.kp_equal_released? : Bool #

Returns whether Key::KpEqual is in the released state.

def self.kp_equal_released? : Bool
  Key::KpEqual.is_released?
end

[View source]
def self.kp_equal_up? : Bool #

Returns whether Key::KpEqual is in the up state.

def self.kp_equal_up? : Bool
  Key::KpEqual.is_up?
end

[View source]
def self.kp_multiply_down? : Bool #

Returns whether Key::KpMultiply is in the down state.

def self.kp_multiply_down? : Bool
  Key::KpMultiply.is_down?
end

[View source]
def self.kp_multiply_pressed? : Bool #

Returns whether Key::KpMultiply is in the pressed state.

def self.kp_multiply_pressed? : Bool
  Key::KpMultiply.is_pressed?
end

[View source]
def self.kp_multiply_released? : Bool #

Returns whether Key::KpMultiply is in the released state.

def self.kp_multiply_released? : Bool
  Key::KpMultiply.is_released?
end

[View source]
def self.kp_multiply_up? : Bool #

Returns whether Key::KpMultiply is in the up state.

def self.kp_multiply_up? : Bool
  Key::KpMultiply.is_up?
end

[View source]
def self.kp_subtract_down? : Bool #

Returns whether Key::KpSubtract is in the down state.

def self.kp_subtract_down? : Bool
  Key::KpSubtract.is_down?
end

[View source]
def self.kp_subtract_pressed? : Bool #

Returns whether Key::KpSubtract is in the pressed state.

def self.kp_subtract_pressed? : Bool
  Key::KpSubtract.is_pressed?
end

[View source]
def self.kp_subtract_released? : Bool #

Returns whether Key::KpSubtract is in the released state.

def self.kp_subtract_released? : Bool
  Key::KpSubtract.is_released?
end

[View source]
def self.kp_subtract_up? : Bool #

Returns whether Key::KpSubtract is in the up state.

def self.kp_subtract_up? : Bool
  Key::KpSubtract.is_up?
end

[View source]
def self.l_down? : Bool #

Returns whether Key::L is in the down state.

def self.l_down? : Bool
  Key::L.is_down?
end

[View source]
def self.l_pressed? : Bool #

Returns whether Key::L is in the pressed state.

def self.l_pressed? : Bool
  Key::L.is_pressed?
end

[View source]
def self.l_released? : Bool #

Returns whether Key::L is in the released state.

def self.l_released? : Bool
  Key::L.is_released?
end

[View source]
def self.l_up? : Bool #

Returns whether Key::L is in the up state.

def self.l_up? : Bool
  Key::L.is_up?
end

[View source]
def self.left_alt_down? : Bool #

Returns whether Key::LeftAlt is in the down state.

def self.left_alt_down? : Bool
  Key::LeftAlt.is_down?
end

[View source]
def self.left_alt_pressed? : Bool #

Returns whether Key::LeftAlt is in the pressed state.

def self.left_alt_pressed? : Bool
  Key::LeftAlt.is_pressed?
end

[View source]
def self.left_alt_released? : Bool #

Returns whether Key::LeftAlt is in the released state.

def self.left_alt_released? : Bool
  Key::LeftAlt.is_released?
end

[View source]
def self.left_alt_up? : Bool #

Returns whether Key::LeftAlt is in the up state.

def self.left_alt_up? : Bool
  Key::LeftAlt.is_up?
end

[View source]
def self.left_bracket_down? : Bool #

Returns whether Key::LeftBracket is in the down state.

def self.left_bracket_down? : Bool
  Key::LeftBracket.is_down?
end

[View source]
def self.left_bracket_pressed? : Bool #

Returns whether Key::LeftBracket is in the pressed state.

def self.left_bracket_pressed? : Bool
  Key::LeftBracket.is_pressed?
end

[View source]
def self.left_bracket_released? : Bool #

Returns whether Key::LeftBracket is in the released state.

def self.left_bracket_released? : Bool
  Key::LeftBracket.is_released?
end

[View source]
def self.left_bracket_up? : Bool #

Returns whether Key::LeftBracket is in the up state.

def self.left_bracket_up? : Bool
  Key::LeftBracket.is_up?
end

[View source]
def self.left_control_down? : Bool #

Returns whether Key::LeftControl is in the down state.

def self.left_control_down? : Bool
  Key::LeftControl.is_down?
end

[View source]
def self.left_control_pressed? : Bool #

Returns whether Key::LeftControl is in the pressed state.

def self.left_control_pressed? : Bool
  Key::LeftControl.is_pressed?
end

[View source]
def self.left_control_released? : Bool #

Returns whether Key::LeftControl is in the released state.

def self.left_control_released? : Bool
  Key::LeftControl.is_released?
end

[View source]
def self.left_control_up? : Bool #

Returns whether Key::LeftControl is in the up state.

def self.left_control_up? : Bool
  Key::LeftControl.is_up?
end

[View source]
def self.left_down? : Bool #

Returns whether Key::Left is in the down state.

def self.left_down? : Bool
  Key::Left.is_down?
end

[View source]
def self.left_pressed? : Bool #

Returns whether Key::Left is in the pressed state.

def self.left_pressed? : Bool
  Key::Left.is_pressed?
end

[View source]
def self.left_released? : Bool #

Returns whether Key::Left is in the released state.

def self.left_released? : Bool
  Key::Left.is_released?
end

[View source]
def self.left_shift_down? : Bool #

Returns whether Key::LeftShift is in the down state.

def self.left_shift_down? : Bool
  Key::LeftShift.is_down?
end

[View source]
def self.left_shift_pressed? : Bool #

Returns whether Key::LeftShift is in the pressed state.

def self.left_shift_pressed? : Bool
  Key::LeftShift.is_pressed?
end

[View source]
def self.left_shift_released? : Bool #

Returns whether Key::LeftShift is in the released state.

def self.left_shift_released? : Bool
  Key::LeftShift.is_released?
end

[View source]
def self.left_shift_up? : Bool #

Returns whether Key::LeftShift is in the up state.

def self.left_shift_up? : Bool
  Key::LeftShift.is_up?
end

[View source]
def self.left_super_down? : Bool #

Returns whether Key::LeftSuper is in the down state.

def self.left_super_down? : Bool
  Key::LeftSuper.is_down?
end

[View source]
def self.left_super_pressed? : Bool #

Returns whether Key::LeftSuper is in the pressed state.

def self.left_super_pressed? : Bool
  Key::LeftSuper.is_pressed?
end

[View source]
def self.left_super_released? : Bool #

Returns whether Key::LeftSuper is in the released state.

def self.left_super_released? : Bool
  Key::LeftSuper.is_released?
end

[View source]
def self.left_super_up? : Bool #

Returns whether Key::LeftSuper is in the up state.

def self.left_super_up? : Bool
  Key::LeftSuper.is_up?
end

[View source]
def self.left_up? : Bool #

Returns whether Key::Left is in the up state.

def self.left_up? : Bool
  Key::Left.is_up?
end

[View source]
def self.m_down? : Bool #

Returns whether Key::M is in the down state.

def self.m_down? : Bool
  Key::M.is_down?
end

[View source]
def self.m_pressed? : Bool #

Returns whether Key::M is in the pressed state.

def self.m_pressed? : Bool
  Key::M.is_pressed?
end

[View source]
def self.m_released? : Bool #

Returns whether Key::M is in the released state.

def self.m_released? : Bool
  Key::M.is_released?
end

[View source]
def self.m_up? : Bool #

Returns whether Key::M is in the up state.

def self.m_up? : Bool
  Key::M.is_up?
end

[View source]
def self.menu_down? : Bool #

Returns whether Key::Menu is in the down state.

def self.menu_down? : Bool
  Key::Menu.is_down?
end

[View source]
def self.menu_pressed? : Bool #

Returns whether Key::Menu is in the pressed state.

def self.menu_pressed? : Bool
  Key::Menu.is_pressed?
end

[View source]
def self.menu_released? : Bool #

Returns whether Key::Menu is in the released state.

def self.menu_released? : Bool
  Key::Menu.is_released?
end

[View source]
def self.menu_up? : Bool #

Returns whether Key::Menu is in the up state.

def self.menu_up? : Bool
  Key::Menu.is_up?
end

[View source]
def self.minus_down? : Bool #

Returns whether Key::Minus is in the down state.

def self.minus_down? : Bool
  Key::Minus.is_down?
end

[View source]
def self.minus_pressed? : Bool #

Returns whether Key::Minus is in the pressed state.

def self.minus_pressed? : Bool
  Key::Minus.is_pressed?
end

[View source]
def self.minus_released? : Bool #

Returns whether Key::Minus is in the released state.

def self.minus_released? : Bool
  Key::Minus.is_released?
end

[View source]
def self.minus_up? : Bool #

Returns whether Key::Minus is in the up state.

def self.minus_up? : Bool
  Key::Minus.is_up?
end

[View source]
def self.n_down? : Bool #

Returns whether Key::N is in the down state.

def self.n_down? : Bool
  Key::N.is_down?
end

[View source]
def self.n_pressed? : Bool #

Returns whether Key::N is in the pressed state.

def self.n_pressed? : Bool
  Key::N.is_pressed?
end

[View source]
def self.n_released? : Bool #

Returns whether Key::N is in the released state.

def self.n_released? : Bool
  Key::N.is_released?
end

[View source]
def self.n_up? : Bool #

Returns whether Key::N is in the up state.

def self.n_up? : Bool
  Key::N.is_up?
end

[View source]
def self.nine_down? : Bool #

Returns whether Key::Nine is in the down state.

def self.nine_down? : Bool
  Key::Nine.is_down?
end

[View source]
def self.nine_pressed? : Bool #

Returns whether Key::Nine is in the pressed state.

def self.nine_pressed? : Bool
  Key::Nine.is_pressed?
end

[View source]
def self.nine_released? : Bool #

Returns whether Key::Nine is in the released state.

def self.nine_released? : Bool
  Key::Nine.is_released?
end

[View source]
def self.nine_up? : Bool #

Returns whether Key::Nine is in the up state.

def self.nine_up? : Bool
  Key::Nine.is_up?
end

[View source]
def self.null_down? : Bool #

Returns whether Key::Null is in the down state.

def self.null_down? : Bool
  Key::Null.is_down?
end

[View source]
def self.null_pressed? : Bool #

Returns whether Key::Null is in the pressed state.

def self.null_pressed? : Bool
  Key::Null.is_pressed?
end

[View source]
def self.null_released? : Bool #

Returns whether Key::Null is in the released state.

def self.null_released? : Bool
  Key::Null.is_released?
end

[View source]
def self.null_up? : Bool #

Returns whether Key::Null is in the up state.

def self.null_up? : Bool
  Key::Null.is_up?
end

[View source]
def self.num_lock_down? : Bool #

Returns whether Key::NumLock is in the down state.

def self.num_lock_down? : Bool
  Key::NumLock.is_down?
end

[View source]
def self.num_lock_pressed? : Bool #

Returns whether Key::NumLock is in the pressed state.

def self.num_lock_pressed? : Bool
  Key::NumLock.is_pressed?
end

[View source]
def self.num_lock_released? : Bool #

Returns whether Key::NumLock is in the released state.

def self.num_lock_released? : Bool
  Key::NumLock.is_released?
end

[View source]
def self.num_lock_up? : Bool #

Returns whether Key::NumLock is in the up state.

def self.num_lock_up? : Bool
  Key::NumLock.is_up?
end

[View source]
def self.o_down? : Bool #

Returns whether Key::O is in the down state.

def self.o_down? : Bool
  Key::O.is_down?
end

[View source]
def self.o_pressed? : Bool #

Returns whether Key::O is in the pressed state.

def self.o_pressed? : Bool
  Key::O.is_pressed?
end

[View source]
def self.o_released? : Bool #

Returns whether Key::O is in the released state.

def self.o_released? : Bool
  Key::O.is_released?
end

[View source]
def self.o_up? : Bool #

Returns whether Key::O is in the up state.

def self.o_up? : Bool
  Key::O.is_up?
end

[View source]
def self.one_down? : Bool #

Returns whether Key::One is in the down state.

def self.one_down? : Bool
  Key::One.is_down?
end

[View source]
def self.one_pressed? : Bool #

Returns whether Key::One is in the pressed state.

def self.one_pressed? : Bool
  Key::One.is_pressed?
end

[View source]
def self.one_released? : Bool #

Returns whether Key::One is in the released state.

def self.one_released? : Bool
  Key::One.is_released?
end

[View source]
def self.one_up? : Bool #

Returns whether Key::One is in the up state.

def self.one_up? : Bool
  Key::One.is_up?
end

[View source]
def self.p_down? : Bool #

Returns whether Key::P is in the down state.

def self.p_down? : Bool
  Key::P.is_down?
end

[View source]
def self.p_pressed? : Bool #

Returns whether Key::P is in the pressed state.

def self.p_pressed? : Bool
  Key::P.is_pressed?
end

[View source]
def self.p_released? : Bool #

Returns whether Key::P is in the released state.

def self.p_released? : Bool
  Key::P.is_released?
end

[View source]
def self.p_up? : Bool #

Returns whether Key::P is in the up state.

def self.p_up? : Bool
  Key::P.is_up?
end

[View source]
def self.page_down_down? : Bool #

Returns whether Key::PageDown is in the down state.

def self.page_down_down? : Bool
  Key::PageDown.is_down?
end

[View source]
def self.page_down_pressed? : Bool #

Returns whether Key::PageDown is in the pressed state.

def self.page_down_pressed? : Bool
  Key::PageDown.is_pressed?
end

[View source]
def self.page_down_released? : Bool #

Returns whether Key::PageDown is in the released state.

def self.page_down_released? : Bool
  Key::PageDown.is_released?
end

[View source]
def self.page_down_up? : Bool #

Returns whether Key::PageDown is in the up state.

def self.page_down_up? : Bool
  Key::PageDown.is_up?
end

[View source]
def self.page_up_down? : Bool #

Returns whether Key::PageUp is in the down state.

def self.page_up_down? : Bool
  Key::PageUp.is_down?
end

[View source]
def self.page_up_pressed? : Bool #

Returns whether Key::PageUp is in the pressed state.

def self.page_up_pressed? : Bool
  Key::PageUp.is_pressed?
end

[View source]
def self.page_up_released? : Bool #

Returns whether Key::PageUp is in the released state.

def self.page_up_released? : Bool
  Key::PageUp.is_released?
end

[View source]
def self.page_up_up? : Bool #

Returns whether Key::PageUp is in the up state.

def self.page_up_up? : Bool
  Key::PageUp.is_up?
end

[View source]
def self.pause_down? : Bool #

Returns whether Key::Pause is in the down state.

def self.pause_down? : Bool
  Key::Pause.is_down?
end

[View source]
def self.pause_pressed? : Bool #

Returns whether Key::Pause is in the pressed state.

def self.pause_pressed? : Bool
  Key::Pause.is_pressed?
end

[View source]
def self.pause_released? : Bool #

Returns whether Key::Pause is in the released state.

def self.pause_released? : Bool
  Key::Pause.is_released?
end

[View source]
def self.pause_up? : Bool #

Returns whether Key::Pause is in the up state.

def self.pause_up? : Bool
  Key::Pause.is_up?
end

[View source]
def self.period_down? : Bool #

Returns whether Key::Period is in the down state.

def self.period_down? : Bool
  Key::Period.is_down?
end

[View source]
def self.period_pressed? : Bool #

Returns whether Key::Period is in the pressed state.

def self.period_pressed? : Bool
  Key::Period.is_pressed?
end

[View source]
def self.period_released? : Bool #

Returns whether Key::Period is in the released state.

def self.period_released? : Bool
  Key::Period.is_released?
end

[View source]
def self.period_up? : Bool #

Returns whether Key::Period is in the up state.

def self.period_up? : Bool
  Key::Period.is_up?
end

[View source]
def self.pressed?(key : Key) : Bool #

Returns whether mouse_button is in the pressed state.

def self.pressed?(key : Key) : Bool
  key.is_pressed?
end

[View source]
def self.print_screen_down? : Bool #

Returns whether Key::PrintScreen is in the down state.

def self.print_screen_down? : Bool
  Key::PrintScreen.is_down?
end

[View source]
def self.print_screen_pressed? : Bool #

Returns whether Key::PrintScreen is in the pressed state.

def self.print_screen_pressed? : Bool
  Key::PrintScreen.is_pressed?
end

[View source]
def self.print_screen_released? : Bool #

Returns whether Key::PrintScreen is in the released state.

def self.print_screen_released? : Bool
  Key::PrintScreen.is_released?
end

[View source]
def self.print_screen_up? : Bool #

Returns whether Key::PrintScreen is in the up state.

def self.print_screen_up? : Bool
  Key::PrintScreen.is_up?
end

[View source]
def self.q_down? : Bool #

Returns whether Key::Q is in the down state.

def self.q_down? : Bool
  Key::Q.is_down?
end

[View source]
def self.q_pressed? : Bool #

Returns whether Key::Q is in the pressed state.

def self.q_pressed? : Bool
  Key::Q.is_pressed?
end

[View source]
def self.q_released? : Bool #

Returns whether Key::Q is in the released state.

def self.q_released? : Bool
  Key::Q.is_released?
end

[View source]
def self.q_up? : Bool #

Returns whether Key::Q is in the up state.

def self.q_up? : Bool
  Key::Q.is_up?
end

[View source]
def self.r_down? : Bool #

Returns whether Key::R is in the down state.

def self.r_down? : Bool
  Key::R.is_down?
end

[View source]
def self.r_pressed? : Bool #

Returns whether Key::R is in the pressed state.

def self.r_pressed? : Bool
  Key::R.is_pressed?
end

[View source]
def self.r_released? : Bool #

Returns whether Key::R is in the released state.

def self.r_released? : Bool
  Key::R.is_released?
end

[View source]
def self.r_up? : Bool #

Returns whether Key::R is in the up state.

def self.r_up? : Bool
  Key::R.is_up?
end

[View source]
def self.released?(key : Key) : Bool #

Returns whether mouse_button is in the released state.

def self.released?(key : Key) : Bool
  key.is_released?
end

[View source]
def self.right_alt_down? : Bool #

Returns whether Key::RightAlt is in the down state.

def self.right_alt_down? : Bool
  Key::RightAlt.is_down?
end

[View source]
def self.right_alt_pressed? : Bool #

Returns whether Key::RightAlt is in the pressed state.

def self.right_alt_pressed? : Bool
  Key::RightAlt.is_pressed?
end

[View source]
def self.right_alt_released? : Bool #

Returns whether Key::RightAlt is in the released state.

def self.right_alt_released? : Bool
  Key::RightAlt.is_released?
end

[View source]
def self.right_alt_up? : Bool #

Returns whether Key::RightAlt is in the up state.

def self.right_alt_up? : Bool
  Key::RightAlt.is_up?
end

[View source]
def self.right_bracket_down? : Bool #

Returns whether Key::RightBracket is in the down state.

def self.right_bracket_down? : Bool
  Key::RightBracket.is_down?
end

[View source]
def self.right_bracket_pressed? : Bool #

Returns whether Key::RightBracket is in the pressed state.

def self.right_bracket_pressed? : Bool
  Key::RightBracket.is_pressed?
end

[View source]
def self.right_bracket_released? : Bool #

Returns whether Key::RightBracket is in the released state.

def self.right_bracket_released? : Bool
  Key::RightBracket.is_released?
end

[View source]
def self.right_bracket_up? : Bool #

Returns whether Key::RightBracket is in the up state.

def self.right_bracket_up? : Bool
  Key::RightBracket.is_up?
end

[View source]
def self.right_control_down? : Bool #

Returns whether Key::RightControl is in the down state.

def self.right_control_down? : Bool
  Key::RightControl.is_down?
end

[View source]
def self.right_control_pressed? : Bool #

Returns whether Key::RightControl is in the pressed state.

def self.right_control_pressed? : Bool
  Key::RightControl.is_pressed?
end

[View source]
def self.right_control_released? : Bool #

Returns whether Key::RightControl is in the released state.

def self.right_control_released? : Bool
  Key::RightControl.is_released?
end

[View source]
def self.right_control_up? : Bool #

Returns whether Key::RightControl is in the up state.

def self.right_control_up? : Bool
  Key::RightControl.is_up?
end

[View source]
def self.right_down? : Bool #

Returns whether Key::Right is in the down state.

def self.right_down? : Bool
  Key::Right.is_down?
end

[View source]
def self.right_pressed? : Bool #

Returns whether Key::Right is in the pressed state.

def self.right_pressed? : Bool
  Key::Right.is_pressed?
end

[View source]
def self.right_released? : Bool #

Returns whether Key::Right is in the released state.

def self.right_released? : Bool
  Key::Right.is_released?
end

[View source]
def self.right_shift_down? : Bool #

Returns whether Key::RightShift is in the down state.

def self.right_shift_down? : Bool
  Key::RightShift.is_down?
end

[View source]
def self.right_shift_pressed? : Bool #

Returns whether Key::RightShift is in the pressed state.

def self.right_shift_pressed? : Bool
  Key::RightShift.is_pressed?
end

[View source]
def self.right_shift_released? : Bool #

Returns whether Key::RightShift is in the released state.

def self.right_shift_released? : Bool
  Key::RightShift.is_released?
end

[View source]
def self.right_shift_up? : Bool #

Returns whether Key::RightShift is in the up state.

def self.right_shift_up? : Bool
  Key::RightShift.is_up?
end

[View source]
def self.right_super_down? : Bool #

Returns whether Key::RightSuper is in the down state.

def self.right_super_down? : Bool
  Key::RightSuper.is_down?
end

[View source]
def self.right_super_pressed? : Bool #

Returns whether Key::RightSuper is in the pressed state.

def self.right_super_pressed? : Bool
  Key::RightSuper.is_pressed?
end

[View source]
def self.right_super_released? : Bool #

Returns whether Key::RightSuper is in the released state.

def self.right_super_released? : Bool
  Key::RightSuper.is_released?
end

[View source]
def self.right_super_up? : Bool #

Returns whether Key::RightSuper is in the up state.

def self.right_super_up? : Bool
  Key::RightSuper.is_up?
end

[View source]
def self.right_up? : Bool #

Returns whether Key::Right is in the up state.

def self.right_up? : Bool
  Key::Right.is_up?
end

[View source]
def self.s_down? : Bool #

Returns whether Key::S is in the down state.

def self.s_down? : Bool
  Key::S.is_down?
end

[View source]
def self.s_pressed? : Bool #

Returns whether Key::S is in the pressed state.

def self.s_pressed? : Bool
  Key::S.is_pressed?
end

[View source]
def self.s_released? : Bool #

Returns whether Key::S is in the released state.

def self.s_released? : Bool
  Key::S.is_released?
end

[View source]
def self.s_up? : Bool #

Returns whether Key::S is in the up state.

def self.s_up? : Bool
  Key::S.is_up?
end

[View source]
def self.scroll_lock_down? : Bool #

Returns whether Key::ScrollLock is in the down state.

def self.scroll_lock_down? : Bool
  Key::ScrollLock.is_down?
end

[View source]
def self.scroll_lock_pressed? : Bool #

Returns whether Key::ScrollLock is in the pressed state.

def self.scroll_lock_pressed? : Bool
  Key::ScrollLock.is_pressed?
end

[View source]
def self.scroll_lock_released? : Bool #

Returns whether Key::ScrollLock is in the released state.

def self.scroll_lock_released? : Bool
  Key::ScrollLock.is_released?
end

[View source]
def self.scroll_lock_up? : Bool #

Returns whether Key::ScrollLock is in the up state.

def self.scroll_lock_up? : Bool
  Key::ScrollLock.is_up?
end

[View source]
def self.semicolon_down? : Bool #

Returns whether Key::Semicolon is in the down state.

def self.semicolon_down? : Bool
  Key::Semicolon.is_down?
end

[View source]
def self.semicolon_pressed? : Bool #

Returns whether Key::Semicolon is in the pressed state.

def self.semicolon_pressed? : Bool
  Key::Semicolon.is_pressed?
end

[View source]
def self.semicolon_released? : Bool #

Returns whether Key::Semicolon is in the released state.

def self.semicolon_released? : Bool
  Key::Semicolon.is_released?
end

[View source]
def self.semicolon_up? : Bool #

Returns whether Key::Semicolon is in the up state.

def self.semicolon_up? : Bool
  Key::Semicolon.is_up?
end

[View source]
def self.seven_down? : Bool #

Returns whether Key::Seven is in the down state.

def self.seven_down? : Bool
  Key::Seven.is_down?
end

[View source]
def self.seven_pressed? : Bool #

Returns whether Key::Seven is in the pressed state.

def self.seven_pressed? : Bool
  Key::Seven.is_pressed?
end

[View source]
def self.seven_released? : Bool #

Returns whether Key::Seven is in the released state.

def self.seven_released? : Bool
  Key::Seven.is_released?
end

[View source]
def self.seven_up? : Bool #

Returns whether Key::Seven is in the up state.

def self.seven_up? : Bool
  Key::Seven.is_up?
end

[View source]
def self.six_down? : Bool #

Returns whether Key::Six is in the down state.

def self.six_down? : Bool
  Key::Six.is_down?
end

[View source]
def self.six_pressed? : Bool #

Returns whether Key::Six is in the pressed state.

def self.six_pressed? : Bool
  Key::Six.is_pressed?
end

[View source]
def self.six_released? : Bool #

Returns whether Key::Six is in the released state.

def self.six_released? : Bool
  Key::Six.is_released?
end

[View source]
def self.six_up? : Bool #

Returns whether Key::Six is in the up state.

def self.six_up? : Bool
  Key::Six.is_up?
end

[View source]
def self.slash_down? : Bool #

Returns whether Key::Slash is in the down state.

def self.slash_down? : Bool
  Key::Slash.is_down?
end

[View source]
def self.slash_pressed? : Bool #

Returns whether Key::Slash is in the pressed state.

def self.slash_pressed? : Bool
  Key::Slash.is_pressed?
end

[View source]
def self.slash_released? : Bool #

Returns whether Key::Slash is in the released state.

def self.slash_released? : Bool
  Key::Slash.is_released?
end

[View source]
def self.slash_up? : Bool #

Returns whether Key::Slash is in the up state.

def self.slash_up? : Bool
  Key::Slash.is_up?
end

[View source]
def self.space_down? : Bool #

Returns whether Key::Space is in the down state.

def self.space_down? : Bool
  Key::Space.is_down?
end

[View source]
def self.space_pressed? : Bool #

Returns whether Key::Space is in the pressed state.

def self.space_pressed? : Bool
  Key::Space.is_pressed?
end

[View source]
def self.space_released? : Bool #

Returns whether Key::Space is in the released state.

def self.space_released? : Bool
  Key::Space.is_released?
end

[View source]
def self.space_up? : Bool #

Returns whether Key::Space is in the up state.

def self.space_up? : Bool
  Key::Space.is_up?
end

[View source]
def self.t_down? : Bool #

Returns whether Key::T is in the down state.

def self.t_down? : Bool
  Key::T.is_down?
end

[View source]
def self.t_pressed? : Bool #

Returns whether Key::T is in the pressed state.

def self.t_pressed? : Bool
  Key::T.is_pressed?
end

[View source]
def self.t_released? : Bool #

Returns whether Key::T is in the released state.

def self.t_released? : Bool
  Key::T.is_released?
end

[View source]
def self.t_up? : Bool #

Returns whether Key::T is in the up state.

def self.t_up? : Bool
  Key::T.is_up?
end

[View source]
def self.tab_down? : Bool #

Returns whether Key::Tab is in the down state.

def self.tab_down? : Bool
  Key::Tab.is_down?
end

[View source]
def self.tab_pressed? : Bool #

Returns whether Key::Tab is in the pressed state.

def self.tab_pressed? : Bool
  Key::Tab.is_pressed?
end

[View source]
def self.tab_released? : Bool #

Returns whether Key::Tab is in the released state.

def self.tab_released? : Bool
  Key::Tab.is_released?
end

[View source]
def self.tab_up? : Bool #

Returns whether Key::Tab is in the up state.

def self.tab_up? : Bool
  Key::Tab.is_up?
end

[View source]
def self.three_down? : Bool #

Returns whether Key::Three is in the down state.

def self.three_down? : Bool
  Key::Three.is_down?
end

[View source]
def self.three_pressed? : Bool #

Returns whether Key::Three is in the pressed state.

def self.three_pressed? : Bool
  Key::Three.is_pressed?
end

[View source]
def self.three_released? : Bool #

Returns whether Key::Three is in the released state.

def self.three_released? : Bool
  Key::Three.is_released?
end

[View source]
def self.three_up? : Bool #

Returns whether Key::Three is in the up state.

def self.three_up? : Bool
  Key::Three.is_up?
end

[View source]
def self.two_down? : Bool #

Returns whether Key::Two is in the down state.

def self.two_down? : Bool
  Key::Two.is_down?
end

[View source]
def self.two_pressed? : Bool #

Returns whether Key::Two is in the pressed state.

def self.two_pressed? : Bool
  Key::Two.is_pressed?
end

[View source]
def self.two_released? : Bool #

Returns whether Key::Two is in the released state.

def self.two_released? : Bool
  Key::Two.is_released?
end

[View source]
def self.two_up? : Bool #

Returns whether Key::Two is in the up state.

def self.two_up? : Bool
  Key::Two.is_up?
end

[View source]
def self.u_down? : Bool #

Returns whether Key::U is in the down state.

def self.u_down? : Bool
  Key::U.is_down?
end

[View source]
def self.u_pressed? : Bool #

Returns whether Key::U is in the pressed state.

def self.u_pressed? : Bool
  Key::U.is_pressed?
end

[View source]
def self.u_released? : Bool #

Returns whether Key::U is in the released state.

def self.u_released? : Bool
  Key::U.is_released?
end

[View source]
def self.u_up? : Bool #

Returns whether Key::U is in the up state.

def self.u_up? : Bool
  Key::U.is_up?
end

[View source]
def self.up?(key : Key) : Bool #

Returns whether mouse_button is in the up state.

def self.up?(key : Key) : Bool
  key.is_up?
end

[View source]
def self.up_down? : Bool #

Returns whether Key::Up is in the down state.

def self.up_down? : Bool
  Key::Up.is_down?
end

[View source]
def self.up_pressed? : Bool #

Returns whether Key::Up is in the pressed state.

def self.up_pressed? : Bool
  Key::Up.is_pressed?
end

[View source]
def self.up_released? : Bool #

Returns whether Key::Up is in the released state.

def self.up_released? : Bool
  Key::Up.is_released?
end

[View source]
def self.up_up? : Bool #

Returns whether Key::Up is in the up state.

def self.up_up? : Bool
  Key::Up.is_up?
end

[View source]
def self.v_down? : Bool #

Returns whether Key::V is in the down state.

def self.v_down? : Bool
  Key::V.is_down?
end

[View source]
def self.v_pressed? : Bool #

Returns whether Key::V is in the pressed state.

def self.v_pressed? : Bool
  Key::V.is_pressed?
end

[View source]
def self.v_released? : Bool #

Returns whether Key::V is in the released state.

def self.v_released? : Bool
  Key::V.is_released?
end

[View source]
def self.v_up? : Bool #

Returns whether Key::V is in the up state.

def self.v_up? : Bool
  Key::V.is_up?
end

[View source]
def self.volume_down_down? : Bool #

Returns whether Key::VolumeDown is in the down state.

def self.volume_down_down? : Bool
  Key::VolumeDown.is_down?
end

[View source]
def self.volume_down_pressed? : Bool #

Returns whether Key::VolumeDown is in the pressed state.

def self.volume_down_pressed? : Bool
  Key::VolumeDown.is_pressed?
end

[View source]
def self.volume_down_released? : Bool #

Returns whether Key::VolumeDown is in the released state.

def self.volume_down_released? : Bool
  Key::VolumeDown.is_released?
end

[View source]
def self.volume_down_up? : Bool #

Returns whether Key::VolumeDown is in the up state.

def self.volume_down_up? : Bool
  Key::VolumeDown.is_up?
end

[View source]
def self.volume_up_down? : Bool #

Returns whether Key::VolumeUp is in the down state.

def self.volume_up_down? : Bool
  Key::VolumeUp.is_down?
end

[View source]
def self.volume_up_pressed? : Bool #

Returns whether Key::VolumeUp is in the pressed state.

def self.volume_up_pressed? : Bool
  Key::VolumeUp.is_pressed?
end

[View source]
def self.volume_up_released? : Bool #

Returns whether Key::VolumeUp is in the released state.

def self.volume_up_released? : Bool
  Key::VolumeUp.is_released?
end

[View source]
def self.volume_up_up? : Bool #

Returns whether Key::VolumeUp is in the up state.

def self.volume_up_up? : Bool
  Key::VolumeUp.is_up?
end

[View source]
def self.w_down? : Bool #

Returns whether Key::W is in the down state.

def self.w_down? : Bool
  Key::W.is_down?
end

[View source]
def self.w_pressed? : Bool #

Returns whether Key::W is in the pressed state.

def self.w_pressed? : Bool
  Key::W.is_pressed?
end

[View source]
def self.w_released? : Bool #

Returns whether Key::W is in the released state.

def self.w_released? : Bool
  Key::W.is_released?
end

[View source]
def self.w_up? : Bool #

Returns whether Key::W is in the up state.

def self.w_up? : Bool
  Key::W.is_up?
end

[View source]
def self.x_down? : Bool #

Returns whether Key::X is in the down state.

def self.x_down? : Bool
  Key::X.is_down?
end

[View source]
def self.x_pressed? : Bool #

Returns whether Key::X is in the pressed state.

def self.x_pressed? : Bool
  Key::X.is_pressed?
end

[View source]
def self.x_released? : Bool #

Returns whether Key::X is in the released state.

def self.x_released? : Bool
  Key::X.is_released?
end

[View source]
def self.x_up? : Bool #

Returns whether Key::X is in the up state.

def self.x_up? : Bool
  Key::X.is_up?
end

[View source]
def self.y_down? : Bool #

Returns whether Key::Y is in the down state.

def self.y_down? : Bool
  Key::Y.is_down?
end

[View source]
def self.y_pressed? : Bool #

Returns whether Key::Y is in the pressed state.

def self.y_pressed? : Bool
  Key::Y.is_pressed?
end

[View source]
def self.y_released? : Bool #

Returns whether Key::Y is in the released state.

def self.y_released? : Bool
  Key::Y.is_released?
end

[View source]
def self.y_up? : Bool #

Returns whether Key::Y is in the up state.

def self.y_up? : Bool
  Key::Y.is_up?
end

[View source]
def self.z_down? : Bool #

Returns whether Key::Z is in the down state.

def self.z_down? : Bool
  Key::Z.is_down?
end

[View source]
def self.z_pressed? : Bool #

Returns whether Key::Z is in the pressed state.

def self.z_pressed? : Bool
  Key::Z.is_pressed?
end

[View source]
def self.z_released? : Bool #

Returns whether Key::Z is in the released state.

def self.z_released? : Bool
  Key::Z.is_released?
end

[View source]
def self.z_up? : Bool #

Returns whether Key::Z is in the up state.

def self.z_up? : Bool
  Key::Z.is_up?
end

[View source]
def self.zero_down? : Bool #

Returns whether Key::Zero is in the down state.

def self.zero_down? : Bool
  Key::Zero.is_down?
end

[View source]
def self.zero_pressed? : Bool #

Returns whether Key::Zero is in the pressed state.

def self.zero_pressed? : Bool
  Key::Zero.is_pressed?
end

[View source]
def self.zero_released? : Bool #

Returns whether Key::Zero is in the released state.

def self.zero_released? : Bool
  Key::Zero.is_released?
end

[View source]
def self.zero_up? : Bool #

Returns whether Key::Zero is in the up state.

def self.zero_up? : Bool
  Key::Zero.is_up?
end

[View source]