vigilem-evdev 0.1.3

data/lib/vigilem/evdev/dom.rb

@@ -0,0 +1,8 @@
+module Vigilem
+module Evdev
+module DOM
+end
+end
+end
+
+require 'vigilem/evdev/dom/adapter'

data/lib/vigilem/evdev/dom/adapter.rb

@@ -0,0 +1,87 @@
+require 'vigilem/core/adapters'
+
+require 'vigilem/core/event_handler'
+
+require 'vigilem/core/eventable'
+
+require 'vigilem/evdev'
+
+require 'vigilem/evdev/dom/input_event_converter'
+
+module Vigilem
+module Evdev
+  class KeyEvent < SimpleDelegator
+    
+    # 
+    # 
+    def is_a?
+      __getobj__.is_a?
+    end
+    
+    # 
+    # 
+    def self.cast(event)
+      new(event)
+    end
+  end
+module DOM
+  # 
+  # 
+  class Adapter
+    
+    include InputEventConverter
+    
+    include Core::Adapters::BufferedAdapter
+    
+    include Core::EventHandler
+    
+    default_handler()
+    
+    # 
+    # @param  devices
+    def initialize(*devices)
+      initialize_buffered(InputSystemHandler.new(*devices))
+      on(KeyEvent) {|event| to_dom_key_event(event) } 
+    end
+    
+    # 
+    # @return [Hash]
+    def type_hash
+      @type_hash ||= { System::Input::EV_KEY => KeyEvent }
+    end
+    
+    # 
+    # 
+    def to_dom_event(event)
+      handle(event)
+    end
+    
+    include Core::Eventable
+    
+    # 
+    # @param  [Integer] limit, defaults to 1
+    # @return [Array<DOM::Event>]
+    def read_many_nonblock(limit=1)
+      synchronize {
+        buffered!(limit) do |len_remainder|
+          dom_src_events = link.read_many_nonblock(len_remainder).map do |event| 
+            handle(cast(event))
+          end.compact.flatten
+          # the DOM converter may return more events than called for
+          ret, to_buffer = Support::Utils.split_at(dom_src_events, len_remainder)
+          buffer.concat([*to_buffer])
+          ret
+        end
+      }
+    end
+    
+    # 
+    # @param  event
+    def cast(event)
+      type_hash[event.type].respond.cast(event)
+    end
+    
+  end
+end
+end
+end

data/lib/vigilem/evdev/dom/code_values_tables.rb

@@ -0,0 +1,172 @@
+require 'vigilem/support/key_map'
+
+module Vigilem
+module Evdev::DOM
+  # @todo there are plenty of mappings missing
+  # http://www.w3.org/TR/2014/WD-DOM-Level-3-Events-code-20140612/
+  module CodeValuesTables
+    
+    include Evdev::System::Input::KeysAndButtons
+    
+    code_values = Vigilem::DOM::CodeValues
+    
+    WritingSystemKeys = Support::KeyMap.new({
+      KEY_GRAVE      => 'Backquote',
+      KEY_BACKSLASH  => 'Backslash',
+      KEY_BACKSPACE  => 'Backspace',
+      KEY_LEFTBRACE  => 'BracketLeft',
+      KEY_RIGHTBRACE => 'BracketRight',
+      KEY_COMMA      => 'Comma',
+      KEY_EQUAL      => 'Equal',
+      :'?'           => ['IntlBackslash', 'IntlHash'],
+      KEY_RO         => 'IntlRo',
+      KEY_YEN        => 'IntlYen',
+      KEY_MINUS      => 'Minus',
+      KEY_DOT        => 'Period',
+      KEY_APOSTROPHE => 'Quote',
+      KEY_SEMICOLON  => 'Semicolon',
+      KEY_SLASH      => 'Slash'
+    })
+                      
+    FunctionalKeys = Support::KeyMap.new({
+      KEY_LEFTALT        => 'AltLeft',
+      KEY_RIGHTALT       => 'AltRight',
+      KEY_CAPSLOCK       => 'CapsLock', 
+      KEY_COMPOSE        => 'ContextMenu',
+      KEY_LEFTCTRL       => 'ControlLeft',
+      KEY_RIGHTCTRL      => 'ControlRight',
+      KEY_ENTER          => 'Enter',
+      KEY_LEFTMETA       => 'OSLeft',
+      KEY_RIGHTMETA      => 'OSRight',
+      KEY_LEFTSHIFT      => 'ShiftLeft',
+      KEY_RIGHTSHIFT     => 'ShiftRight',
+      KEY_SPACE          => 'Space',
+      KEY_TAB            => 'Tab',
+      :'?'               => ['Convert', 'KanaMode', 'NonConvert'],
+      KEY_HANGEUL        => 'Lang1',
+      KEY_HANJA          => 'Lang2',
+      KEY_KATAKANA       => 'Lang3',
+      KEY_HIRAGANA       => 'Lang4',
+      KEY_ZENKAKUHANKAKU => 'Lang5'
+    })
+      
+    
+    ControlPadSection = Support::KeyMap.new({
+      KEY_DELETE   => 'Delete',
+      KEY_END      => 'End',
+      KEY_HELP     => 'Help',
+      KEY_HOME     => 'Home',
+      KEY_INSERT   => 'Insert',
+      KEY_PAGEDOWN => 'Page Down',
+      KEY_PAGEUP   => 'Page Up'
+    })
+    
+    ArrowPadSection = Support::KeyMap[[KEY_DOWN, KEY_LEFT, KEY_RIGHT, KEY_UP].zip(code_values::ArrowPadSection)]
+    
+    NumpadSection = Support::KeyMap.new({
+      KEY_NUMLOCK    => 'NumLock',
+      KEY_KP0        => 'Numpad0',
+      KEY_KP1        => 'Numpad1',
+      KEY_KP2        => 'Numpad2',
+      KEY_KP3        => 'Numpad3',
+      KEY_KP4        => 'Numpad4',
+      KEY_KP5        => 'Numpad5',
+      KEY_KP6        => 'Numpad6',
+      KEY_KP7        => 'Numpad7',
+      KEY_KP8        => 'Numpad8',
+      KEY_KP9        => 'Numpad9',
+      KEY_KPPLUS     => 'NumpadAdd',
+      KEY_KPDOT      => 'NumpadBackspace',
+      :'?'           => ['NumpadClear', 'NumpadClearEntry', 'NumpadComma', 
+                          'NumpadEqual', 'NumpadMemoryAdd', 'NumpadMemoryClear', 
+                          'NumpadMemoryRecall', 'NumpadMemoryStore', 
+                          'NumpadMemorySubtract', 'NumpadParenLeft', 
+                                                  'NumpadParenRight'],
+      KEY_KPDOT      => 'NumpadDecimal',
+      KEY_KPSLASH    => 'NumpadDivide',
+      KEY_KPENTER    => 'NumpadEnter',
+      KEY_KPASTERISK => 'NumpadMultiply',
+      KEY_KPMINUS    => 'NumpadSubtract'
+    })
+    
+    FunctionSection = Support::KeyMap.new({
+      KEY_ESC        => 'Escape',
+      KEY_F1         => 'F1',
+      KEY_F2         => 'F2',
+      KEY_F3         => 'F3',
+      KEY_F4         => 'F4',
+      KEY_F5         => 'F5',
+      KEY_F6         => 'F6',
+      KEY_F7         => 'F7',
+      KEY_F8         => 'F8',
+      KEY_F9         => 'F9',
+      KEY_F10        => 'F10',
+      KEY_F11        => 'F11',
+      KEY_F12        => 'F12',
+      KEY_FN         => 'Fn',
+      :'?'           => 'FLock',
+      KEY_PRINT      => 'PrintScreen',
+      KEY_SCROLLLOCK => 'ScrollLock',
+      KEY_PAUSE      => 'Pause'
+    })
+    
+    MediaKeys = Support::KeyMap.new({ 
+      :'?'                 => ['BrowserBack', 'BrowserFavorites', 
+                              'BrowserForward', 'BrowserHome', 
+                              'BrowserRefresh', 'BrowserSearch', 
+                                                    'BrowserStop'],
+      [KEY_EJECTCD, 
+         KEY_EJECTCLOSECD] => 'Eject',
+      KEY_PROG1            => 'LaunchApp1',
+      KEY_PROG1            => 'LaunchApp2',
+      KEY_EMAIL            => 'LaunchMail',
+      KEY_PLAYPAUSE        => 'MediaPlayPause',
+      KEY_PROGRAM          => 'MediaSelect',
+      KEY_STOPCD           => 'MediaStop',
+      KEY_NEXTSONG         => 'MediaTrackNext',
+      KEY_PREVIOUSSONG     => 'MediaTrackPrevious',
+      KEY_POWER            => 'Power',
+      KEY_SLEEP            => 'Sleep',
+      KEY_VOLUMEDOWN       => 'VolumeDown',
+      KEY_MUTE             => 'VolumeMute',
+      KEY_VOLUMEUP         => 'VolumeUp',
+      KEY_WAKEUP           => 'WakeUp'
+    })
+    
+    LegacyKeysandNon_StandardKeys = Support::KeyMap.new({
+      :'?'         => ['Hyper','Super', 'Turbo', 'Abort', 'Resume'],
+      KEY_SUSPEND  => 'Suspend',
+      KEY_AGAIN    => 'Again',
+      KEY_COPY     => 'Copy',
+      KEY_CUT      => 'Cut',
+      KEY_FIND     => 'Find',
+      KEY_OPEN     => 'Open', 
+      KEY_PASTE    => 'Paste',
+      KEY_PROPS    => 'Props',
+      KEY_SELECT   => 'Select',
+      KEY_UNDO     => 'Undo',
+      KEY_HIRAGANA => 'Hiragana',
+      KEY_KATAKANA => 'Katakana'
+    })
+    
+    Sections = [WritingSystemKeys, FunctionalKeys, ControlPadSection,
+                      ArrowPadSection, NumpadSection, FunctionSection,
+                              MediaKeys, LegacyKeysandNon_StandardKeys]
+    
+    def self.add_names(key_map)
+      key_map.left_side_alias(:keycode)
+      key_map.left_side_alias(:keycodes)
+      key_map.right_side_alias(:dom_code)
+      key_map.right_side_alias(:dom_codes)
+    end
+    
+    Sections.each {|sec| add_names(sec) }
+  end
+  
+  CodeTable = CodeValuesTables::Sections.each_with_object(Support::KeyMap.new()) do |table, memo|
+    memo.merge! table
+  end
+  
+  CodeValuesTables.add_names(CodeTable)
+end
+end

data/lib/vigilem/evdev/dom/input_event_converter.rb

@@ -0,0 +1,329 @@
+require 'vigilem/dom'
+
+require 'vigilem/core/lockable_pipeline_component'
+
+require 'vigilem/_evdev'
+
+require 'vigilem/evdev/system'
+
+require 'vigilem/evdev/system/input'
+
+require 'vigilem/evdev/dom/input_event_utils'
+
+require 'vigilem/evdev/system/keymap_loaders'
+
+require 'vigilem/evdev/dom/code_values_tables'
+require 'vigilem/evdev/dom/key_values_tables'
+require 'vigilem/evdev/dom/kp_table'
+
+module Vigilem
+module Evdev
+module DOM
+  # @todo  fix charsets, printable characters, etc, split up KeyTables
+  # @todo  fixme REFACTOR!
+  module InputEventConverter
+    
+    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'
+    
+    include CodeValuesTables
+    include KeyValuesTables
+    
+    include Core::LockablePipelineComponent
+    
+    include InputEventUtils
+    
+    attr_writer :current_keys, :key_map
+    
+    private :current_keys=
+    
+    KeymapLoaders = System::KeymapLoaders
+    
+    # 
+    # @return [NilClass]
+    def initialize_input_event_converter
+      key_map
+      nil
+    end
+    
+    # 
+    # @return [KeyMap]
+    def key_map
+      Evdev.key_map
+    end
+    
+    # 
+    # @return [Array]
+    def current_keys
+      @current_keys ||= []
+    end
+    
+    # gets the current modifier keys
+    # @todo   capsshift
+    # @return [Array<Array<String, String>>] [['ctrl', 'r']]
+    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
+    
+    # gets the current modifier keys
+    # @return [Array<String>] i.e. ['ctrl']
+    def current_mod_keys
+      current_mod_keys_w_loc.map(&:first)
+    end
+    
+    # grabs the current modifier keys and adds the location 
+    # to the end
+    # @return [Array<String>] i.e. ['ctrlr']
+    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
+    
+    # gets the keysyms for the given keycode string and current mod keys
+    # @param  [String] keycode_str, i.e. "keycode30"
+    # @return [Array<String> || String] the keysyms and (uni|hex)codes
+    def keysyms(keycode_str)
+      key_map.keysyms(Support::Utils.unwrap_ary([current_mod_keys_keymap_fmt, keycode_str].flatten))
+    end
+    
+    def keysyms!(keycode_str)
+      key_map.keysyms(Support::Utils.unwrap_ary(keycode_str))
+    end
+    
+    # gets the DOM::KeyEvent#type from InputEvent#value and
+    # Dom::KeyEvent#key
+    # @param  [Integer] event_value, InputEvent#value
+    # @param  [String] dom_key_value, DOM::KeyEvent#key
+    # @return [Array<String> || NilClass] the type of event based on 
+    #                                     the given args
+    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
+    
+    # 
+    # @return [Hash]
+    def dom_types
+      @dom_types ||= { 0 => ['keyup'], 1 => (down_press = %w(keydown keypress)), 2 => down_press }
+    end
+    
+    # takes a code from an input_event and returns a String
+    # representing a DOM::KeyEvent#key
+    # @todo   refactor
+    # @param  [Integer] event_code, InputEvent#code
+    # @return [String] the representing DOM::KeyEvent#key
+    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
+    
+    # 
+    # 
+    def printable_char?(hex_char)
+      Support::Utils.in_ranged_array?(PRINTABLE_CHARS, hex_char)
+    end
+    
+    # 
+    # @return [NilClass || Fixnum]
+    def char_ref?(str)
+      str =~ /^\+?U\+|0x0[\dA-z]+/i # unicode or hex_string
+    end
+    
+    # @todo   fixme!
+    # @param  [String] str
+    # @return 
+    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
+    
+    # gets the DOM::KeyEvent#code fromm a keycode anem and 
+    # a DOMLLKeyEvent#key
+    # @todo   needs to be more strict
+    # @todo   items modified shift still returns the code for 
+    #         the unshifted 
+    # @param  [Fixnum] event_code
+    # @param  [String] dom_key, DOM::KeyEvent#key
+    # @return [String] DOM::KeyEvent#code
+    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
+    
+    # gets the DOM_KEY_LOCATION_* of the keycode
+    # @param  [String || Symbol] keycode_name
+    # @return [Integer] dom location, DOM::KeyEvent::KeyLocations
+    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
+    
+    # creates a SharedKeyboardAndMouseEventInit from #current_mod_keys
+    # and a passed in keycode_name
+    # @param  [String ||Symbol] keycode_name, KEY_RIGHTCTRL
+    # @return [Array<symbol>]
+    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
+    
+    # takes the InputEvent and returns a representing DOM::KeyEvent
+    # @todo   refactor
+    # @param  [InputEvent] input_event
+    # @return [Array<DOM::KeyEvent>]
+    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
+    
+    # 
+    # @param  [Hash] os_specific
+    # @param  [Fixnum] dom_location
+    # @return [Array || NilClass]
+    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
+    
+    # 
+    # @param  [Hash] os_specific
+    # @param  [Fixnum] dom_location
+    # @return [TrueClass || FalseClass]
+    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
+    
+    # 
+    # @param  [String]
+    # @return [Array<Symbol> || NilClass]
+    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
+    
+  end
+end
+end
+end