Module: Vigilem::Evdev::DOM::InputEventConverter

Includes:: Core::LockablePipelineComponent, CodeValuesTables, InputEventUtils, KeyValuesTables

Included in:: Adapter

Defined in:: lib/vigilem/evdev/dom/input_event_converter.rb

Constant Summary collapse

KEYCODES =

System::Input::KeysAndButtons.constants.each_with_object({}) do |const, hsh| 
  hsh[System::Input.const_get(const)] = const
end

PRINTABLE_CHARS =

[0x0008..0x000a, 0x0020..0x00ff]

UNKNOWN_VAL =

'Unidentified'

KeymapLoaders =

System::KeymapLoaders

Constants included from KeyValuesTables

Constants included from System::Input::KeysAndButtons

Constants included from CodeValuesTables

CodeValuesTables::ArrowPadSection, CodeValuesTables::ControlPadSection, CodeValuesTables::FunctionSection, CodeValuesTables::FunctionalKeys, CodeValuesTables::LegacyKeysandNon_StandardKeys, CodeValuesTables::MediaKeys, CodeValuesTables::NumpadSection, CodeValuesTables::Sections, CodeValuesTables::WritingSystemKeys

Instance Attribute Summary collapse

#current_keys ⇒ Array readonly
#key_map ⇒ KeyMap

Instance Method Summary collapse

#char_ref(str) ⇒ Object
#char_ref?(str) ⇒ NilClass || Fixnum
#current_mod_keys ⇒ Array<String>

gets the current modifier keys.
#current_mod_keys_keymap_fmt ⇒ Array<String>

grabs the current modifier keys and adds the location to the end.
#current_mod_keys_w_loc ⇒ Array<Array<String, String>>

gets the current modifier keys.
#dom_code(event_code, dom_key_value) ⇒ String

gets the DOM::KeyEvent#code fromm a keycode anem and a DOMLLKeyEvent#key.
#dom_key(event_code, led_names) ⇒ String

takes a code from an input_event and returns a String representing a DOM::KeyEvent#key.
#dom_location(keycode_name) ⇒ Integer

gets the DOM_KEY_LOCATION_* of the keycode.
#dom_modifiers(keycode_name) ⇒ Array<symbol>

creates a SharedKeyboardAndMouseEventInit from #current_mod_keys and a passed in keycode_name.
#dom_type(event_value, dom_key_value) ⇒ Array<String> || NilClass

gets the DOM::KeyEvent#type from InputEvent#value and Dom::KeyEvent#key.
#dom_types ⇒ Hash
#initialize_input_event_converter ⇒ NilClass
#keysyms(keycode_str) ⇒ Array<String> || String

gets the keysyms for the given keycode string and current mod keys.
#keysyms!(keycode_str) ⇒ Object
#leds(bits_str) ⇒ Array<Symbol> || NilClass
#printable_char?(hex_char) ⇒ Boolean
#remove_from_current_keys(os_specific, dom_location) ⇒ Array || NilClass
#repeat?(os_specific, dom_location) ⇒ TrueClass || FalseClass
#to_dom_key_event(input_event) ⇒ Array<DOM::KeyEvent>

takes the InputEvent and returns a representing DOM::KeyEvent.

Methods included from InputEventUtils

#event_code_to_keycode_str, #location_str_from_keycode_name, #modifier_keymap_name

Methods included from CodeValuesTables

add_names

Instance Attribute Details

#current_keys ⇒ `Array`

Returns:

(Array)



62
63
64

# File 'lib/vigilem/evdev/dom/input_event_converter.rb', line 62

def current_keys
  @current_keys ||= []
end

#key_map ⇒ `KeyMap`

Returns:

(KeyMap)



56
57
58

# File 'lib/vigilem/evdev/dom/input_event_converter.rb', line 56

def key_map
  Evdev.key_map
end

Instance Method Details

#char_ref(str) ⇒ `Object`

TODO:

fixme!

Parameters:

str (String)

Returns:

# File 'lib/vigilem/evdev/dom/input_event_converter.rb', line 196

def char_ref(str)
  #"%c" % char
  hex_dec = str.gsub(/\+?U\+/i, '').hex
  if str =~ /^\+?U\+/ # unicode
    hex_dec.chr('UTF-8')
  elsif printable_char?(hex_dec)
    hex_dec.chr('iso-8859-1') # default dumpkeys encoding
  end
end

#char_ref?(str) ⇒ `NilClass || Fixnum`

Returns:

(NilClass || Fixnum)



189
190
191

# File 'lib/vigilem/evdev/dom/input_event_converter.rb', line 189

def char_ref?(str)
  str =~ /^\+?U\+|0x0[\dA-z]+/i # unicode or hex_string
end

#current_mod_keys ⇒ `Array<String>`

gets the current modifier keys

Returns:

(Array<String>) —

i.e. [‘ctrl’]



81
82
83

# File 'lib/vigilem/evdev/dom/input_event_converter.rb', line 81

def current_mod_keys
  current_mod_keys_w_loc.map(&:first)
end

#current_mod_keys_keymap_fmt ⇒ `Array<String>`

grabs the current modifier keys and adds the location to the end

Returns:

(Array<String>) —

i.e. [‘ctrlr’]

# File 'lib/vigilem/evdev/dom/input_event_converter.rb', line 88

def current_mod_keys_keymap_fmt
  current_mod_keys_w_loc.map do |mod_w_loc| 
    Support::KeyMap.mod_weights.keys & [mod_w_loc.first, mod_w_loc.join]
  end.compact.flatten.uniq.sort {|a,b| Support::KeyMap.mod_weights[a] <=> Support::KeyMap.mod_weights[b] }
  # ruby 2.0.0p384 (2014-01-12) [x86_64-linux-gnu] irb(main):006:0> [1,2,3,4].sort {|a| a } => [4, 3, 1, 2]
end

#current_mod_keys_w_loc ⇒ `Array<Array<String, String>>`

TODO:

capsshift

gets the current modifier keys

Returns:

(Array<Array<String, String>>) —
[‘ctrl’, ‘r’]

# File 'lib/vigilem/evdev/dom/input_event_converter.rb', line 69

def current_mod_keys_w_loc
  current_keys.map do |event|
    if (key = event.key) =~ /c(on)?tro?l|alt|shift/i and
                                          event.type == 'keydown'
      loc = to_dom_location_common_str(event.location)
      [key.gsub('control', 'ctrl').downcase, loc.downcase]
    end
  end.compact
end

#dom_code(event_code, dom_key_value) ⇒ `String`

TODO:

needs to be more strict

TODO:

items modified shift still returns the code for the unshifted

gets the DOM::KeyEvent#code fromm a keycode anem and a DOMLLKeyEvent#key

Parameters:

event_code (Fixnum)
dom_key, (String) —

DOM::KeyEvent#key

Returns:

(String) —

DOM::KeyEvent#code

# File 'lib/vigilem/evdev/dom/input_event_converter.rb', line 214

def dom_code(event_code, dom_key_value)
  keycode_name = KEYCODES[event_code]
  
  ret_code = if dom_key_value =~ /^[a-z]$/i
    "Key#{dom_key_value.upcase}"
  elsif dom_key_value =~ /^[0-9]$/
    if keycode_name =~ /^KEY_KP/
      "Numpad#{dom_key_value}"
    else
      "Digit#{dom_key_value}"
    end
  elsif not (codes = [*CodeTable.dom_codes(event_code)]).empty?
    Support::Utils.unwrap_ary(codes)
  elsif dom_key_value != UNKNOWN_VAL
    "#{dom_key_value}#{InputEventUtils.location_str_from_keycode_name(keycode_name)}"
  end
  
  ret_code ||= UNKNOWN_VAL
end

#dom_key(event_code, led_names) ⇒ `String`

TODO:

refactor

takes a code from an input_event and returns a String representing a DOM::KeyEvent#key

Parameters:

event_code, (Integer) —

InputEvent#code

Returns:

(String) —

the representing DOM::KeyEvent#key

# File 'lib/vigilem/evdev/dom/input_event_converter.rb', line 134

def dom_key(event_code, led_names)
  # use infocmp?, terminfo
  synchronize {
    keycode_str = InputEventUtils.event_code_to_keycode_str(event_code)
    
    # raise if this is nil?, char_ref will error if char_code.nil?
    code_or_sym = [*keysyms(keycode_str)].last
    
    char_code, sym = if char_ref?(code_or_sym)
      [code_or_sym, key_map.info.keysyms[code_or_sym]]
    else
      [key_map.info.char_refs[code_or_sym], code_or_sym]
    end
    
    char = char_ref(char_code)
    
    white_space_key = (WhitespaceKeys.keysyms.include?(event_code) or
                                WhitespaceKeys.keysyms.include?(sym))
    
    if char and not white_space_key
      if char.respond_to?(:upcase) and
              led_names.include?(:LED_CAPSL) and 
                                       keysyms.grep(/shift/).empty?
        return char.upcase
      else
        return char
      end
    elsif char_ref?(char_code) and (no_mods = [*keysyms!(keycode_str)].last)
      if char = char_ref(no_mods)
        return char
      end
    end
    
    if (not white_space_key) and 
         led_names.include?(:LED_NUML) and (kpkey = KPTable.char(sym))
      kpkey
    elsif (key = KeyTable.dom_codes(sym)) and not key.is_a? Array
      key
    elsif keyfrom_event = KeyTable.dom_codes(event_code) and
                                      not keyfrom_event.is_a? Array
      keyfrom_event
    else
      UNKNOWN_VAL
    end
  }
end

#dom_location(keycode_name) ⇒ `Integer`

gets the DOM_KEY_LOCATION_* of the keycode

Parameters:

keycode_name (String || Symbol)

Returns:

(Integer) —

dom location, DOM::KeyEvent::KeyLocations

# File 'lib/vigilem/evdev/dom/input_event_converter.rb', line 237

def dom_location(keycode_name)
  ::VDOM::Utils.common_str_to_dom_location(
    keycode_name.to_s.gsub(/(KEY_)?((KP)|(R)IGHT|(L)EFT)(.*)/, '\3\4\5')
  )
end

#dom_modifiers(keycode_name) ⇒ `Array<symbol>`

creates a SharedKeyboardAndMouseEventInit from #current_mod_keys and a passed in keycode_name

Parameters:

keycode_name, (String ||Symbol) —

KEY_RIGHTCTRL

Returns:

(Array<symbol>)

# File 'lib/vigilem/evdev/dom/input_event_converter.rb', line 247

def dom_modifiers(keycode_name)
  ::VDOM::KeyboardEvent::shared_keyboard_and_mouse_event_init(
    current_mod_keys +
      [keycode_name.to_s.gsub(/(KEY_)?(RIGHT|LEFT)?/i, '').downcase.to_sym]
  )
end

#dom_type(event_value, dom_key_value) ⇒ `Array<String> || NilClass`

gets the DOM::KeyEvent#type from InputEvent#value and Dom::KeyEvent#key

Parameters:

event_value, (Integer) —

InputEvent#value
dom_key_value, (String) —

DOM::KeyEvent#key

Returns:

(Array<String> || NilClass) —

the type of event based on the given args

# File 'lib/vigilem/evdev/dom/input_event_converter.rb', line 112

def dom_type(event_value, dom_key_value)
  synchronize {
    type = dom_types[event_value]
    if dom_key_value.unpack('U*').size > 1
      type.take(1)
    else
      type
    end
  }
end

#dom_types ⇒ `Hash`

Returns:

(Hash)



125
126
127

# File 'lib/vigilem/evdev/dom/input_event_converter.rb', line 125

def dom_types
  @dom_types ||= { 0 => ['keyup'], 1 => (down_press = %w(keydown keypress)), 2 => down_press }
end

#initialize_input_event_converter ⇒ `NilClass`

Returns:

(NilClass)

# File 'lib/vigilem/evdev/dom/input_event_converter.rb', line 49

def initialize_input_event_converter
  key_map
  nil
end

#keysyms(keycode_str) ⇒ `Array<String> || String`

gets the keysyms for the given keycode string and current mod keys

Parameters:

keycode_str, (String) —

i.e. “keycode30”

Returns:

(Array<String> || String) —

the keysyms and (uni|hex)codes



98
99
100

# File 'lib/vigilem/evdev/dom/input_event_converter.rb', line 98

def keysyms(keycode_str)
  key_map.keysyms(Support::Utils.unwrap_ary([current_mod_keys_keymap_fmt, keycode_str].flatten))
end

#keysyms!(keycode_str) ⇒ `Object`



102
103
104

# File 'lib/vigilem/evdev/dom/input_event_converter.rb', line 102

def keysyms!(keycode_str)
  key_map.keysyms(Support::Utils.unwrap_ary(keycode_str))
end

#leds(bits_str) ⇒ `Array<Symbol> || NilClass`

Parameters:

(String)

Returns:

(Array<Symbol> || NilClass)

# File 'lib/vigilem/evdev/dom/input_event_converter.rb', line 318

def leds(bits_str)
  if bits_str
    System::Input::LEDs.constants.select do |const|
      bits_str[System::Input::LEDs.const_get(const)].to_i > 0
    end
  end
end

#printable_char?(hex_char) ⇒ `Boolean`

Returns:

(Boolean)



183
184
185

# File 'lib/vigilem/evdev/dom/input_event_converter.rb', line 183

def printable_char?(hex_char)
  Support::Utils.in_ranged_array?(PRINTABLE_CHARS, hex_char)
end

#remove_from_current_keys(os_specific, dom_location) ⇒ `Array || NilClass`

Parameters:

os_specific (Hash)
dom_location (Fixnum)

Returns:

(Array || NilClass)

# File 'lib/vigilem/evdev/dom/input_event_converter.rb', line 297

def remove_from_current_keys(os_specific, dom_location)
  current_keys.reject! do |current|
    current.os_specific.except(:time, :value) == os_specific.except(:time, :value) and 
      current.location == dom_location
  end
end

#repeat?(os_specific, dom_location) ⇒ `TrueClass || FalseClass`

Parameters:

os_specific (Hash)
dom_location (Fixnum)

Returns:

(TrueClass || FalseClass)

# File 'lib/vigilem/evdev/dom/input_event_converter.rb', line 308

def repeat?(os_specific, dom_location)
  !!current_keys.find do |current|
    current.os_specific.except(:time) == os_specific.except(:time) and 
      current.location == dom_location
  end
end

#to_dom_key_event(input_event) ⇒ `Array<DOM::KeyEvent>`

TODO:

refactor

takes the InputEvent and returns a representing DOM::KeyEvent

Parameters:

input_event (InputEvent)

Returns:

(Array<DOM::KeyEvent>)

# File 'lib/vigilem/evdev/dom/input_event_converter.rb', line 258

def to_dom_key_event(input_event)
  synchronize {
    
    event_code = input_event.code
    keycode_name = KEYCODES[event_code]
    
    options = {:location => loc = dom_location(keycode_name), 
               :os_specific => os_spec = ::FFIUtils.struct_to_h(input_event),
               :repeat => repeat?(os_spec, loc), 
               :modifiers => dom_modifiers(keycode_name), 
                }
    
    remove_from_current_keys(options[:os_specific], options[:location])
    
    options[:key] = key = dom_key(event_code, leds(input_event.leds))
    options[:code] = dom_code(event_code, key)
    
    type = dom_type(input_event.value, key)
    
    if type.first != 'keyup'
      key_event = ::VDOM::KeyboardEvent.new(type.first, options)
      
      key_press = type[1] ? [key_event.copy_to(type[1])] : []
      key_down_events = ([key_event] + key_press)
      current_keys.concat(key_down_events)
      key_down_events
    else
      
      key_event = ::VDOM::KeyboardEvent.new(type.first, options)
      
      [*key_event].flatten
    end
  }
end

Module: Vigilem::Evdev::DOM::InputEventConverter

Constant Summary collapse

Constants included from KeyValuesTables

Constants included from System::Input::KeysAndButtons

Constants included from CodeValuesTables

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods included from InputEventUtils

Methods included from CodeValuesTables

Instance Attribute Details

#current_keys ⇒ Array

#key_map ⇒ KeyMap

Instance Method Details

#char_ref(str) ⇒ Object

#char_ref?(str) ⇒ NilClass || Fixnum

#current_mod_keys ⇒ Array<String>

#current_mod_keys_keymap_fmt ⇒ Array<String>

#current_mod_keys_w_loc ⇒ Array<Array<String, String>>

#dom_code(event_code, dom_key_value) ⇒ String

#dom_key(event_code, led_names) ⇒ String

#dom_location(keycode_name) ⇒ Integer

#dom_modifiers(keycode_name) ⇒ Array<symbol>

#dom_type(event_value, dom_key_value) ⇒ Array<String> || NilClass

#dom_types ⇒ Hash

#initialize_input_event_converter ⇒ NilClass

#keysyms(keycode_str) ⇒ Array<String> || String

#keysyms!(keycode_str) ⇒ Object

#leds(bits_str) ⇒ Array<Symbol> || NilClass

#printable_char?(hex_char) ⇒ Boolean

#remove_from_current_keys(os_specific, dom_location) ⇒ Array || NilClass

#repeat?(os_specific, dom_location) ⇒ TrueClass || FalseClass

#to_dom_key_event(input_event) ⇒ Array<DOM::KeyEvent>

#current_keys ⇒ `Array`

#key_map ⇒ `KeyMap`

#char_ref(str) ⇒ `Object`

#char_ref?(str) ⇒ `NilClass || Fixnum`

#current_mod_keys ⇒ `Array<String>`

#current_mod_keys_keymap_fmt ⇒ `Array<String>`

#current_mod_keys_w_loc ⇒ `Array<Array<String, String>>`

#dom_code(event_code, dom_key_value) ⇒ `String`

#dom_key(event_code, led_names) ⇒ `String`

#dom_location(keycode_name) ⇒ `Integer`

#dom_modifiers(keycode_name) ⇒ `Array<symbol>`

#dom_type(event_value, dom_key_value) ⇒ `Array<String> || NilClass`

#dom_types ⇒ `Hash`

#initialize_input_event_converter ⇒ `NilClass`

#keysyms(keycode_str) ⇒ `Array<String> || String`

#keysyms!(keycode_str) ⇒ `Object`

#leds(bits_str) ⇒ `Array<Symbol> || NilClass`

#printable_char?(hex_char) ⇒ `Boolean`

#remove_from_current_keys(os_specific, dom_location) ⇒ `Array || NilClass`

#repeat?(os_specific, dom_location) ⇒ `TrueClass || FalseClass`

#to_dom_key_event(input_event) ⇒ `Array<DOM::KeyEvent>`