Class: Accessibility::String::EventGenerator

Inherits:

Object

Object
Accessibility::String::EventGenerator

Defined in:: lib/accessibility/string.rb

Overview

Generate a sequence of keyboard events given a sequence of tokens. The token format is defined by the Lexer class output; it is best to use that class to generate the tokens.

Examples:


# Upper case 'A'
EventGenerator.new(["A"]).generate  # => [[56,true],[70,true],[70,false],[56,false]]

# Press the volume up key
EventGenerator.new([["\\F12"]]).generate # => [[0x6F,true],[0x6F,false]]

# Hotkey, press and hold command key and then 'a', then release both
EventGenerator.new([["\\CMD",["a"]]]).generate # => [[55,true],[70,true],[70,false],[55,false]]

# Press the return/enter key
EventGenerator.new(["\n"]).generate # => [[10,true],[10,false]]

Constant Summary collapse

MAPPING = Dynamic mapping of characters to keycodes. The map is generated at startup time in order to support multiple keyboard layouts. Returns: (Hash{String=>Fixnum})

{}

CUSTOM =

Note:

These mappings are all static and come from ‘/System/Library/Frameworks/Carbon.framework/Versions/A/Frameworks/HIToolbox.framework/Versions/A/Headers/Events.h`

Map of custom escape sequences to their hardcoded keycode value.

Returns:

(Hash{String=>Fixnum})

{
  "\\FUNCTION"      => 0x3F,      # Standard Control Keys
  "\\FN"            => 0x3F,
  "\\CONTROL"       => 0x3B,
  "\\CTRL"          => 0x3B,
  "\\OPTION"        => 0x3A,
  "\\OPT"           => 0x3A,
  "\\ALT"           => 0x3A,
  "\\COMMAND"       => 0x37,
  "\\CMD"           => 0x37,
  "\\LSHIFT"        => 0x38,
  "\\SHIFT"         => 0x38,
  "\\CAPSLOCK"      => 0x39,
  "\\CAPS"          => 0x39,
  "\\ROPTION"       => 0x3D,
  "\\ROPT"          => 0x3D,
  "\\RALT"          => 0x3D,
  "\\RCONTROL"      => 0x3E,
  "\\RCTRL"         => 0x3E,
  "\\RSHIFT"        => 0x3C,
  "\\ESCAPE"        => 0x35,      # Top Row Keys
  "\\ESC"           => 0x35,
  "\\VOLUMEUP"      => 0x48,
  "\\VOLUP"         => 0x48,
  "\\VOLUMEDOWN"    => 0x49,
  "\\VOLDOWN"       => 0x49,
  "\\MUTE"          => 0x4A,
  "\\F1"            => 0x7A,
  "\\F2"            => 0x78,
  "\\F3"            => 0x63,
  "\\F4"            => 0x76,
  "\\F5"            => 0x60,
  "\\F6"            => 0x61,
  "\\F7"            => 0x62,
  "\\F8"            => 0x64,
  "\\F9"            => 0x65,
  "\\F10"           => 0x6D,
  "\\F11"           => 0x67,
  "\\F12"           => 0x6F,
  "\\F13"           => 0x69,
  "\\F14"           => 0x6B,
  "\\F15"           => 0x71,
  "\\F16"           => 0x6A,
  "\\F17"           => 0x40,
  "\\F18"           => 0x4F,
  "\\F19"           => 0x50,
  "\\F20"           => 0x5A,
  "\\HELP"          => 0x72,      # Island Keys
  "\\HOME"          => 0x73,
  "\\END"           => 0x77,
  "\\PAGEUP"        => 0x74,
  "\\PAGEDOWN"      => 0x79,
  "\\DELETE"        => 0x75,
  "\\LEFT"          => 0x7B,      # Arrow Keys
  "\\<-"            => 0x7B,
  "\\RIGHT"         => 0x7C,
  "\\->"            => 0x7C,
  "\\DOWN"          => 0x7D,
  "\\UP"            => 0x7E,
  "\\0"             => 0x52,      # Keypad Keys
  "\\1"             => 0x53,
  "\\2"             => 0x54,
  "\\3"             => 0x55,
  "\\4"             => 0x56,
  "\\5"             => 0x57,
  "\\6"             => 0x58,
  "\\7"             => 0x59,
  "\\8"             => 0x5B,
  "\\9"             => 0x5C,
  "\\DECIMAL"       => 0x41,
  "\\."             => 0x41,
  "\\PLUS"          => 0x45,
  "\\+"             => 0x45,
  "\\MULTIPLY"      => 0x43,
  "\\*"             => 0x43,
  "\\MINUS"         => 0x4E,
  "\\-"             => 0x4E,
  "\\DIVIDE"        => 0x4B,
  "\\/"             => 0x4B,
  "\\EQUALS"        => 0x51,
  "\\="             => 0x51,
  "\\ENTER"         => 0x4C,
  "\\CLEAR"         => 0x47,
}

SHIFTED = Mapping of shifted (characters written when holding shift) characters to keycodes. Returns: (Hash{String=>Fixnum})

{
  '~'               => '`',
  '!'               => '1',
  '@'               => '2',
  '#'               => '3',
  '$'               => '4',
  '%'               => '5',
  '^'               => '6',
  '&'               => '7',
  '*'               => '8',
  '('               => '9',
  ')'               => '0',
  '{'               => '[',
  '}'               => ']',
  '?'               => '/',
  '+'               => '=',
  '|'               => "\\",
  ':'               => ';',
  '_'               => '-',
  '"'               => "'",
  '<'               => ',',
  '>'               => '.',
  'A'               => 'a',
  'B'               => 'b',
  'C'               => 'c',
  'D'               => 'd',
  'E'               => 'e',
  'F'               => 'f',
  'G'               => 'g',
  'H'               => 'h',
  'I'               => 'i',
  'J'               => 'j',
  'K'               => 'k',
  'L'               => 'l',
  'M'               => 'm',
  'N'               => 'n',
  'O'               => 'o',
  'P'               => 'p',
  'Q'               => 'q',
  'R'               => 'r',
  'S'               => 's',
  'T'               => 't',
  'U'               => 'u',
  'V'               => 'v',
  'W'               => 'w',
  'X'               => 'x',
  'Y'               => 'y',
  'Z'               => 'z',
}

OPTIONED = Mapping of optioned (characters written when holding option/alt) characters to keycodes. Returns: (Hash{String=>Fixnum})

{
  '¡'               => '1',
  '™'               => '2',
  '£'               => '3',
  '¢'               => '4',
  '∞'               => '5',
  '§'               => '6',
  '¶'               => '7',
  '•'               => '8',
  'ª'               => '9',
  'º'               => '0',
  '“'               => '[',
  '‘'               => ']',
  'æ'               => "'",
  '≤'               => ',',
  '≥'               => '.',
  'π'               => 'p',
  '¥'               => 'y',
  'ƒ'               => 'f',
  '©'               => 'g',
  '®'               => 'r',
  '¬'               => 'l',
  '÷'               => '/',
  '≠'               => '=',
  '«'               => "\\",
  'å'               => 'a',
  'ø'               => 'o',
  '´'               => 'e',
  '¨'               => 'u',
  'ˆ'               => 'i',
  '∂'               => 'd',
  '˙'               => 'h',
  '†'               => 't',
  '˜'               => 'n',
  'ß'               => 's',
  '–'               => '-',
  '…'               => ';',
  'œ'               => 'q',
  '∆'               => 'j',
  '˚'               => 'k',
  '≈'               => 'x',
  '∫'               => 'b',
  'µ'               => 'm',
  '∑'               => 'w',
  '√'               => 'v',
  'Ω'               => 'z',
}

Instance Attribute Summary collapse

#events ⇒ Array<Array(Fixnum,Boolean)> readonly

Once #generate is called, this contains the sequence of events.

Class Method Summary collapse

.regenerate_dynamic_mapping ⇒ Object

Regenerate the portion of the key mapping that is set dynamically based on keyboard layout (e.g. US, Dvorak, etc.).

Instance Method Summary collapse

#generate ⇒ Array<Array(Fixnum,Boolean)>

Generate the events for the tokens the event generator was initialized with.
#initialize(tokens) ⇒ EventGenerator constructor

A new instance of EventGenerator.

Constructor Details

#initialize(tokens) ⇒ `EventGenerator`

Returns a new instance of EventGenerator.

Parameters:

(Array<String,Array<String,Array...>>)

# File 'lib/accessibility/string.rb', line 399

def initialize tokens
  @tokens = tokens
  # *3 since the output array will be at least *2 the
  # number of tokens passed in, but will often be larger
  # due to shifted/optioned characters and custom escapes;
  # though a better number could be derived from
  # analyzing common input...
  @events = Array.new tokens.size*3
end

Instance Attribute Details

#events ⇒ `Array<Array(Fixnum,Boolean)>` (readonly)

Once #generate is called, this contains the sequence of events.

Returns:

(Array<Array(Fixnum,Boolean)>)



396
397
398

# File 'lib/accessibility/string.rb', line 396

def events
  @events
end

Class Method Details

.regenerate_dynamic_mapping ⇒ `Object`

Regenerate the portion of the key mapping that is set dynamically based on keyboard layout (e.g. US, Dvorak, etc.).

This method should be called whenever the keyboard layout changes. This can be called automatically by registering for a notification in a run looped environment.

# File 'lib/accessibility/string.rb', line 174

def self.regenerate_dynamic_mapping
  # KeyCoder is declared in the Objective-C extension
  MAPPING.merge! KeyCoder.dynamic_mapping
  # Also add an alias to the mapping
  MAPPING["\n"] = MAPPING["\r"]
end

Instance Method Details

#generate ⇒ `Array<Array(Fixnum,Boolean)>`

Generate the events for the tokens the event generator was initialized with. Returns the generated events, though you can also use #events to get the events later.