vigilem-win32_api 0.0.10

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: bbde09d132a14953b05aeb4838acc918ab48c878
+  data.tar.gz: 8a9eb4816a5a373fedd2838ce1fb05eba9305d90
+SHA512:
+  metadata.gz: 1cbfeaef82619e2b953cf1dc4da2c01756aebb4b32d41c869226e19090db8bca0af9dc8c6da2daa62bc61568bf127977efcb7fd0e889e2c79ec9a014d850c6ce
+  data.tar.gz: 8d93eaf3ee72ae910bf61d06e33ff9f69e335167c34c4d939818d59130af29f64d9bf0a09b547b624ca68cc02b121c738f8f1fcb9b99cbc29a20125e09557af8

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 jtzero
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/lib/vigilem/win32_api/console_input_events.rb

@@ -0,0 +1,78 @@
+module Vigilem
+module Win32API
+  # 
+  # group of all the console input events listed by MSoft
+  module ConsoleInputEvents
+    
+    
+    # 
+    class MOUSE_EVENT_RECORD < ::VFFIStruct
+      layout_with_methods :dwMousePosition, Win32API::COORD,
+                     :dwButtonState, :DWORD,
+                     :dwControlKeyState, :DWORD,
+                     :dwEventFlags, :DWORD
+    end
+    
+    
+    # 
+    class WINDOW_BUFFER_SIZE_RECORD < ::VFFIStruct
+      layout_with_methods :dwSize, Win32API::COORD
+    end
+    
+    
+    # "These events are used internally and should be ignored."
+    class MENU_EVENT_RECORD < ::VFFIStruct
+      layout_with_methods :dwCommandId, :uint
+    end
+    
+    
+    # "These events are used internally and should be ignored."
+    class FOCUS_EVENT_RECORD < ::VFFIStruct
+      layout_with_methods :bSetFocus, :BOOL
+    end
+    
+    
+    # 
+    class KEY_EVENT_RECORD < ::VFFIStruct
+      layout_with_methods :bKeyDown, :BOOL,
+                          :wRepeatCount, :WORD,
+                          :wVirtualKeyCode, :WORD,
+                          :wVirtualScanCode, :WORD,
+                          *union(:uChar, 
+                            [:UnicodeChar, :unicode_char], :WCHAR,
+                            [:AsciiChar, :ascii_char], :CHAR
+                          ),
+                          :dwControlKeyState, :uint
+      
+      alias_method :b_key_down, :bKeyDown
+      alias_method :w_repeat_count, :wRepeatCount
+      alias_method :w_virtual_key_code, :wVirtualKeyCode
+      alias_method :w_virtual_scan_code, :wVirtualScanCode
+      alias_method :u_char, :uChar
+      alias_method :dw_control_key_state, :dwControlKeyState
+    end
+    
+    @events = Win32API::Constants::Events
+    
+    # 
+    # @return [Array<Symbol>]
+    def self.vk_names
+      @_console_input_events_ ||= @events.constants.grep(/^(?!CTRL).*/)
+    end
+    
+    # 
+    # @return [TransmutableHash<Integer, Symbol>]
+    def self.vk_hash
+      @_console_input_event_hash_ ||= vk_names.map.with_object(Support::TransmutableHash.new()) {|event_name, hsh| hsh[@events.const_get(event_name)] = event_name }
+    end
+    
+    # 
+    # @return [Array<VFFIStruct>]
+    def self.structs
+      @_structs_ ||= constants.map {|const| const_get(const) }
+    end
+  end
+  
+  include ConsoleInputEvents
+end
+end

data/lib/vigilem/win32_api/constants.rb

@@ -0,0 +1,97 @@
+module Vigilem
+module Win32API
+  
+  # @note   the colors may be removed in future releases
+  module Constants
+    
+    STD_INPUT_HANDLE = 0xFFFFFFF6
+    STD_OUTPUT_HANDLE = 0xFFFFFFF5
+    STD_ERROR_HANDLE = 0xFFFFFFF4
+    INVALID_HANDLE_VALUE = 0xFFFFFFFF
+    GENERIC_READ = 0x80000000
+    GENERIC_WRITE = 0x40000000
+    FILE_SHARE_READ = 0x00000001
+    FILE_SHARE_WRITE = 0x00000002
+    CONSOLE_TEXTMODE_BUFFER = 0x00000001
+    FOREGROUND_BLUE = 0x0001
+    FOREGROUND_GREEN = 0x0002
+    FOREGROUND_RED = 0x0004
+    FOREGROUND_INTENSITY = 0x0008
+    BACKGROUND_BLUE = 0x0010
+    BACKGROUND_GREEN = 0x0020
+    BACKGROUND_RED = 0x0040
+    BACKGROUND_INTENSITY = 0x0080
+    ENABLE_PROCESSED_INPUT = 0x0001
+    ENABLE_LINE_INPUT = 0x0002
+    ENABLE_ECHO_INPUT = 0x0004
+    ENABLE_WINDOW_INPUT = 0x0008
+    ENABLE_MOUSE_INPUT = 0x0010
+    ENABLE_PROCESSED_OUTPUT = 0x0001
+    ENABLE_WRAP_AT_EOL_OUTPUT = 0x0002
+    
+    MOUSE_WHEELED = 0x0004
+    DOUBLE_CLICK = 0x0002
+    MOUSE_MOVED = 0x0001
+    FROM_LEFT_1ST_BUTTON_PRESSED = 0x0001
+    FROM_LEFT_2ND_BUTTON_PRESSED = 0x0004
+    FROM_LEFT_3RD_BUTTON_PRESSED = 0x0008
+    FROM_LEFT_4TH_BUTTON_PRESSED = 0x0010
+    RIGHTMOST_BUTTON_PRESSED = 0x0002
+    
+    module Events
+      CTRL_C_EVENT = 0x0000
+      CTRL_BREAK_EVENT = 0x0001
+      CTRL_CLOSE_EVENT = 0x0002
+      CTRL_LOGOFF_EVENT = 0x0005
+      CTRL_SHUTDOWN_EVENT = 0x0006
+    end
+    
+    # @see ReadConsoleInput
+    module DWControlKeys
+      CAPSLOCK_ON              = 0x0080 # The CAPS LOCK light is on.
+      ENHANCED_KEY             = 0x0100 # The key is enhanced.
+      LEFT_ALT_PRESSED         = 0x0002 # The left ALT key is pressed.
+      LEFT_CTRL_PRESSED        = 0x0008 # The left CTRL key is pressed.
+      NUMLOCK_ON               = 0x0020 # The NUM LOCK light is on.
+      RIGHT_ALT_PRESSED        = 0x0001 # The right ALT key is pressed.
+      RIGHT_CTRL_PRESSED       = 0x0004 # The right CTRL key is pressed.
+      SCROLLLOCK_ON            = 0x0040 # The SCROLL LOCK light is on.
+      SHIFT_PRESSED            = 0x0010 # The SHIFT key is pressed.
+    end
+    
+    include DWControlKeys
+    
+    module Events
+      KEY_EVENT                = 0x0001
+      MOUSE_EVENT              = 0x0002
+      WINDOW_BUFFER_SIZE_EVENT = 0x0004
+      MENU_EVENT               = 0x0008
+      FOCUS_EVENT              = 0x0010
+    end
+    
+    include Events
+    
+    module MapType 
+      MAPVK_VK_TO_VSC          = 0
+      MAPVK_VSC_TO_VK          = 1
+      MAPVK_VK_TO_CHAR         = 2
+      MAPVK_VSC_TO_VK_EX       = 3
+    end
+    
+    include MapType
+    
+    module MAPVK
+      VK_TO_VSC                = MapType::MAPVK_VK_TO_VSC
+      VSC_TO_VK                = MapType::MAPVK_VSC_TO_VK
+      VK_TO_CHAR               = MapType::MAPVK_VK_TO_CHAR
+      VSC_TO_VK_EX             = MapType::MAPVK_VSC_TO_VK_EX
+    end
+    MapVK = MAPVK
+    
+    MapType::MAPVK = MapType::MapVK = MAPVK
+    
+  end
+  include Constants
+  
+end
+end

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

@@ -0,0 +1,59 @@
+require 'vigilem./core/adapters/buffered_adapter'
+
+require 'vigilem/core/eventable'
+
+require 'vigilem/core/event_handler'
+
+require 'vigilem/win32_api/input_system_handler'
+
+module Vigilem
+module Win32API
+module DOM
+  # 
+  # 
+  class Adapter
+    
+    require 'vigilem/win32_api/dom/input_record_utils'
+    
+    include InputRecordUtils
+    
+    include Core::Adapters::BufferedAdapter
+    
+    include Core::EventHandler
+    
+    default_handler()
+    
+    # 
+    # @param  link
+    def initialize(link=InputSystemHandler.new)
+      initialize_buffered(link)
+      self.dom_ir_utils_source = link
+      on(Win32API::KEY_EVENT_RECORD) {|event| to_dom_key_event(event) } 
+    end
+    
+    include Core::Eventable
+    
+    # 
+    # @param  [Integer] limit
+    # @return 
+    def read_many_nonblock(limit=1)
+      buffered!(limit) do |len_remainder|
+        dom_src_events = link.read_many_nonblock(len_remainder).map do |event| 
+          handle(event.event_record)
+        end.compact.flatten
+        ret, to_buffer = Support::Utils.split_at(dom_src_events, len_remainder)
+        buffer.concat([*to_buffer])
+        ret
+      end
+    end
+    
+    # 
+    # @return [TrueClass || FalseClass]
+    def has_any?
+      not buffer.empty? || link.has_any?
+    end
+    
+  end
+end
+end
+end

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

@@ -0,0 +1,136 @@
+module Vigilem
+module Win32API::DOM
+  # http://www.w3.org/TR/2014/WD-DOM-Level-3-Events-code-20140612/
+  module CodeValuesTables
+    
+    code_values = Vigilem::DOM::CodeValues
+    
+    WritingSystemKeys = Support::KeyMap.new({
+      :VK_OEM_3      => 'Backquote',
+      :VK_OEM_5      => 'Backslash',
+      :VK_BACK       => 'Backspace', 
+      :VK_OEM_4      => 'BracketLeft', 
+      :VK_OEM_6      => 'BracketRight', 
+      :VK_OEM_COMMA  => 'Comma',
+      :VK_OEM_PLUS   => 'Equal',
+      #'IntlBackslash', 'IntlHash', 'IntlRo', 'IntlYen', 
+      :VK_OEM_MINUS  => 'Minus', 
+      :VK_OEM_PERIOD => 'Period', 
+      :VK_OEM_7      => 'Quote', 
+      :VK_OEM_1      => 'Semicolon', 
+      :VK_OEM_2      => 'Slash'})
+                      
+    FunctionalKeys = Support::KeyMap.new({
+      :VK_MENU       => %w(AltLeft AltRight),
+      :VK_LMEMU      => 'AltLeft',
+      :VK_RMEMU      => 'AltRight',
+      :VK_CAPITAL    => 'CapsLock', 
+      :VK_APPS       => 'ContextMenu', 
+      :VK_CONTROL    => %w(ControlLeft ControlRight'),
+      :VK_LCONTROL   => 'ControlLeft', 
+      :VK_RCONTROL   => 'ControlRight',
+      :VK_RETURN     => 'Enter', 
+      :VK_LWIN       => 'OSLeft', 
+      :VK_RWIN       => 'OSRight', 
+      :VK_SHIFT      => %w(ShiftLeft ShiftRight),
+      :VK_LSHIFT     => 'ShiftLeft',
+      :VK_RSHIFT     => 'ShiftRight',
+      :VK_KANA       => 'KanaMode',
+      :VK_NONCONVERT => 'NonConvert' })
+      #'Lang1', 'Lang2', 'Lang3', 'Lang4', 'Lang5' eh?
+    
+    ControlPadSection = Support::KeyMap.new({
+      [:ENHANCED_KEY, :VK_DELETE] => 'Delete',
+      [:ENHANCED_KEY, :VK_END]    => 'End',
+      :VK_HELP                    => 'Help',
+      [:ENHANCED_KEY, :VK_HOME]   => 'Home',
+      [:ENHANCED_KEY, :VK_INSERT] => 'Insert',
+      [:ENHANCED_KEY, :VK_NEXT]   => 'PageDown',
+      [:ENHANCED_KEY, :VK_PRIOR]  => 'PageUp'
+    })
+    
+    ArrowPadSection = Support::KeyMap[[
+        [:ENHANCED_KEY, :VK_DOWN],
+        [:ENHANCED_KEY, :VK_LEFT],
+        [:ENHANCED_KEY, :VK_RIGHT],
+        [:ENHANCED_KEY, :VK_UP]
+      ].zip(code_values::ArrowPadSection)
+    ]
+    
+    NumpadSection = Support::KeyMap.new({
+      [:ENHANCED_KEY, :VK_NUMLOCK] => 'NumLock',
+      :VK_NUMPAD0                  => 'Numpad0',
+      :VK_INSERT                   => 'Numpad0',
+      :VK_NUMPAD1                  => 'Numpad1',
+      :VK_END                      => 'Numpad1',
+      :VK_NUMPAD2                  => 'Numpad2',
+      :VK_DOWN                     => 'Numpad2',
+      :VK_NUMPAD3                  => 'Numpad3',
+      :VK_NEXT                     => 'Numpad3',
+      :VK_NUMPAD4                  => 'Numpad4',
+      :VK_LEFT                     => 'Numpad4',
+      :VK_NUMPAD5                  => 'Numpad5',
+      :VK_NUMPAD6                  => 'Numpad6',
+      :VK_RIGHT                    => 'Numpad6',
+      :VK_NUMPAD7                  => 'Numpad7',
+      :VK_HOME                     => 'Numpad7',
+      :VK_NUMPAD8                  => 'Numpad8',
+      :VK_UP                       => 'Numpad8',
+      :VK_NUMPAD9                  => 'Numpad9',
+      :VK_PRIOR                    => 'Numpad9',
+      :VK_ADD                      => 'NumpadAdd',
+      :'?'                         => 'NumpadBackspace',
+      :VK_DELETE                   => 'NumpadDecimal',
+      :VK_DECIMAL                  => 'NumpadDecimal',
+      [:ENHANCED_KEY, :VK_DIVIDE]  => 'NumpadDivide',
+      [:ENHANCED_KEY, :VK_RETURN]  => 'NumpadEnter',
+      :VK_MULTIPLY                 => 'NumpadMultiply',
+      :VK_SUBTRACT                 => 'NumpadSubtract'})
+    #'NumpadClear', 'NumpadClearEntry', 'NumpadComma', 'NumpadEqual', 'NumpadMemoryAdd', 'NumpadMemoryClear', 'NumpadMemoryRecall', 'NumpadMemoryStore', 'NumpadMemorySubtract', 'NumpadParenLeft', 'NumpadParenRight'
+    
+    FunctionSection = Support::KeyMap.new({
+      :VK_MENU                   => %w(AltLeft AltRight),
+      :VK_LMENU                  => 'AltLeft',
+      :VK_RMENU                  => 'AltRight',
+      [:ENHANCED_KEY, :VK_MENU]  => 'AltRight',
+      :VK_CAPITAL                => 'CapsLock',
+      [:ENHANCED_KEY, :VK_APPS]  => 'ContextMenu',
+      :VK_LWIN                   => 'ContextMenu',
+      :VK_RWIN                   => 'ContextMenu',
+      :VK_CONTROL                => ['ControlLeft', 'ControlRight'],
+      :VK_LCONTROL               => 'ControlLeft',
+      :VK_RCONTROL               => 'ControlRight',
+      :VK_SCROLL                 => 'ScrollLock', 
+      :VK_PAUSE                  => 'Pause',
+      :VK_SPACE                  => 'Space',
+      :VK_TAB                    => 'Tab'
+    })
+    
+    #['Fn', 'FLock', 'PrintScreen', ]
+    
+    MediaKeys = Support::KeyMap.new({ 
+      :VK_MEDIA_NEXT_TRACK    => 'MediaTrackNext',
+      :VK_MEDIA_PREV_TRACK    => 'MediaTrackPrevious',
+      :VK_LAUNCH_MEDIA_SELECT => 'MediaSelect'})
+      
+      #'Eject', 'Power', 'WakeUp'
+    
+    LegacyKeysandNon_StandardKeys = Support::KeyMap.new({:VK_SELECT => 'Select'})
+      
+    #['Hyper', 'Super', 'Turbo', 'Abort', 'Resume', 'Suspend', 'Again', 'Copy', 'Cut', 'Find', 'Open', 'Paste', 'Props', 'Undo', 'Hiragana', 'Katakana']
+  end
+  CodeTable = CodeValuesTables.constants.each_with_object(Support::KeyMap.new()) do |table_name, memo| 
+    table = CodeValuesTables.const_get(table_name)
+    table.right_side_alias(:dom_code)
+    table.right_side_alias(:dom_codes)
+    table.left_side_alias(:win_vk)
+    table.left_side_alias(:win_vks)
+    memo.merge! table
+  end
+  
+  CodeTable.right_side_alias(:dom_code)
+  CodeTable.right_side_alias(:dom_codes)
+  CodeTable.left_side_alias(:win_vk)
+  CodeTable.left_side_alias(:win_vks)
+end
+end

data/lib/vigilem/win32_api/dom/input_record_utils.rb

@@ -0,0 +1,259 @@
+require 'vigilem/support'
+
+require 'vigilem/win32_api'
+require 'vigilem/win32_api/utils/keyboard'
+
+require 'vigilem/win32_api/virtual_keys'
+
+require 'vigilem/win32_api/dom/key_values_tables'
+require 'vigilem/win32_api/dom/code_values_tables'
+
+module Vigilem
+module Win32API
+module DOM
+  # http://msdn.microsoft.com/en-us/library/windows/desktop/dd375731%28v=vs.85%29.aspx
+  # methods to convert InputRecords to DOM Events
+  # @abstract requires a dom_ir_utils_source method
+  #           and included into the same module
+  #           as RubyizedAPI
+  # @todo module KeyEventRecordUtils
+  module InputRecordUtils
+    
+    NULL_STR = "\x00"
+    
+    UNKNOWN_VAL = 'Unidentified'
+    
+    include VirtualKeys
+    
+    include Constants
+    
+    include CodeValuesTables
+    
+    include Utils::Keyboard
+    
+    # the current keys being pressed
+    # @return [Array]
+    def current_keys
+      @current_keys ||= []
+    end
+    
+    # converts and event_record to DOM KeyEvent
+    # @note the righ Alt and right ctrl are 'enhanced' 
+    # @param  [] event_record
+    # @return [Array<Vigilem::DOM::KeyboardEvent>]
+    def to_dom_key_event(event_record)
+      dw_state_names = dw_control_key_state_vks(event_record.dwControlKeyState)
+                    
+                    # all test need fixed
+                    # will this work for a range? if not it needs to 
+      virtual_key_name = Map.virtual_keyname(vk_code = event_record.wVirtualKeyCode)
+      
+      modifiers = dom_modifiers(*dw_state_names)
+      
+      dom_loc = dom_location(virtual_key_name, event_record.wVirtualScanCode, dw_state_names)
+      
+      key = dom_key(virtual_key_name, u_char = event_record.uChar.UnicodeChar)
+      
+      code = dom_code(virtual_key_name, u_char, dom_loc, *dw_state_names)
+      
+      options = {:key => key, :code => code, :location => dom_loc, :repeat => false, 
+                              :modifiers => modifiers, :os_specific => ::FFIUtils.struct_to_h(event_record) }
+      
+      if event_record.bKeyDown == 1
+        if (prev_event = current_keys.last) and %w(keypress keydown).include?(prev_event.type) and prev_event.key == options[:key]
+          options[:repeat] = true
+        end
+        
+        key_event = ::VDOM::KeyboardEvent.new('keydown', options)
+        key_down_events = [key_event, key_event.copy_to('keypress')]
+        @current_keys += key_down_events.flatten
+        key_down_events
+      else
+        key_event = ::VDOM::KeyboardEvent.new('keyup', options)
+        current_keys.delete_if {|current| current.key == key_event.key and current.location == key_event.location }
+        [*key_event].flatten
+      end
+    end
+    
+    # converts a Integer representing dwControlKeyState from KEY_EVENT_RECORD to an 
+    # array of virtual-keys, Symbols
+    # @param  [Integer] dw_control_key_state
+    # @return [Array<Symbol>] the win modifiers
+    def dw_control_key_state_vks(dw_control_key_state)
+      DWControlKeys.constants.select do |const|
+        (dw_control_key_state & (value = DWControlKeys.const_get(const))) == value
+      end
+    end
+    
+    # 
+    # @return [Hash]
+    def location_less_vks_map
+      @location_less_vks_map ||= {:VK_MENU => /alt/i, :VK_CONTROL => /control|ctrl/i, :VK_SHIFT => /shift/i }
+    end
+    
+    # 
+    # @param  [Symbol] vk_name
+    # @return [TrueClass || FalseClass]
+    def vk_without_location_info?(vk_name)
+      location_less_vks_map.keys.include? vk_name
+    end
+    
+    # 
+    # @return [Hash]
+    def shift_scan_code_to_location_vk
+      @shift_scan_location ||= { dom_ir_utils_source.map_virtual_key(VK[:LSHIFT], MAPVK::VK_TO_VSC) => :VK_LSHIFT, 
+                                 dom_ir_utils_source.map_virtual_key(VK[:RSHIFT], MAPVK::VK_TO_VSC) => :VK_RSHIFT }
+    end
+    
+    class << self
+      # 
+      # @param  [String<'L'||'l'||'R'||'r'>] str, to convert
+      # @return [String<'R'||'r'||'L'||'l'>] its opposite
+      def flip_lr_sides(str)
+        str.tr('LlRr', 'RrLl')
+      end
+      
+      # 
+      # @param  [Symbol] key_name
+      # @return [String || NilClass]
+      def lr_location_from_name(key_name)
+        key_name.to_s.gsub(/VK_(L(?!EFT)|R(?!IGHT))?.+/, '\1')[/L|R/]
+      end
+      
+      # 
+      # @param  [String] str, value to test
+      # @return [TrueClass || FalseClass] whether or not the String
+      # is #empty? or just contains NULL_STR
+      def empty_or_null?(str)
+        str.strip.empty? or (str == NULL_STR * str.length)
+      end
+      
+    end
+    
+    # 
+    # @param  [Symbol] vk_name
+    # @param  [Array<Symbol>] dw_state_names
+    # @return [Integer<0|1|2>]
+    def dom_location(vk_name, v_scancode, dw_state_names)
+      l_r_location = InputRecordUtils.lr_location_from_name(vk_name) ||
+                     lr_not_in_name(vk_name, v_scancode, dw_state_names) || ""
+      
+      ::VDOM::Utils.common_str_to_dom_location(l_r_location.upcase) || DOM_KEY_LOCATION_STANDARD
+    end
+    
+    # gets the l or r using other params than just the name
+    # @see    location_less_vks_map
+    # @param  [Symbol] vk_name
+    # @param  [Integer] v_scancode
+    # @param  [Symbol<#{location_less_vks_map.keys}>]
+    # @raise  [RuntimeError] when the location cannot be found
+    # @return [String<'l'|'r'>]
+    def lr_not_in_name!(vk_name, v_scancode, dw_state_names)
+      if lr = lr_not_in_name(vk_name, v_scancode, dw_state_names)
+        lr
+      else
+        raise RuntimeError, "Cannot get location from #{vk_name}, #{v_scancode}, #{current_keys}, #{dw_state_names}"
+      end
+    end
+    
+    # gets the l or r using other params than just the name
+    # @see    location_less_vks_map
+    # @param  [Symbol] vk_name
+    # @param  [Integer] v_scancode
+    # @param  [Symbol<#{location_less_vks_map.keys}>]
+    # @return [String<'l'||'r'>]
+    def lr_not_in_name(vk_name, v_scancode, dw_state_names)
+      if vk_name == :VK_SHIFT
+        if lr = InputRecordUtils.lr_location_from_name(shift_scan_code_to_location_vk[v_scancode])
+          lr.downcase
+        end
+      else
+        regexp = location_less_vks_map[vk_name]
+        # other side key pressed? weird but eh
+        if other_location = current_keys.find {|current| current.key =~ regexp }
+          InputRecordUtils.flip_lr_sides(::VDOM::Utils.to_dom_location_common_str(other_location.location)).downcase
+        # ok other one isn't being pressed then the one showing up in dw_control_state is this
+        else
+          applicable_state_names = dw_state_names.grep(regexp)
+          # there are no previous keys 
+          if applicable_state_names.size > 1
+            raise "Both `#{vk_name}' are pressed but there is no record in the current keys:#{current_keys.join(',')}"
+          elsif location = InputRecordUtils.lr_location_from_name(dw_state_names.grep(regexp).first)
+            location.downcase
+          end
+        end
+      end
+    end
+    
+    # @see    MapVirtualKey, 
+    # @param  [Symbol] virtual_key
+    # @param  u_char
+    # @return [String]
+    def dom_key(virtual_key, u_char)
+      vk = :"VK_#{virtual_key.to_s.gsub(/^VK_/, '')}"
+         # returns 0 when no character available
+      if KeyValuesTables::WhitespaceKeys.has_key?(vk) or
+        (character = dom_ir_utils_source.map_virtual_key(Map.virtual_key_code(vk), MAPVK::VK_TO_CHAR)) == 0
+        KeyTable.dom_key(vk) || UNKNOWN_VAL
+      else
+        u_char.chr
+      end
+    end
+    
+    # 
+    # @param  [Symbol] virtual_key
+    # @param  [String] u_char_value
+    # @param  [String<"l"||"r"> || Integer] location
+    # @raise  RuntimeError 
+    # @return 
+    def dom_code(virtual_key, u_char_value, location, *dw_state_names)
+      if (code = CodeTable.dom_code(Support::Utils.unwrap_ary([*dw_state_names.grep(:ENHANCED_KEY), virtual_key])))
+        if code.is_a? Array
+          dom_loc = location.is_a?(String) ? ::VDOM::Utils.common_str_to_dom_location(location.upcase) : location
+          code.grep(::VDOM::Utils.codes_regex[dom_loc]).first
+        else
+          code
+        end
+      else
+        if(char = u_char_value.chr) =~ /^[a-z]$/i
+          "Key#{char.upcase}"
+        elsif char =~ /^[0-9]$/
+          "Digit#{char}"
+        else
+          UNKNOWN_VAL
+        end
+      end
+    end
+    
+    # @see    Vigilem::DOM::KeyEvent::alternative_key_names
+    # @param  [Array] dw_control_state_names
+    # @return [Array] 
+    def dom_modifiers(*dw_control_state_names)
+      ::VDOM::KeyboardEvent::shared_keyboard_and_mouse_event_init(dw_control_state_names.map do |mod| 
+          if mod == :RIGHT_ALT_PRESSED
+            :metaKey
+          else
+            mod.to_s.gsub(/right|left|pressed|on|_/i, '').downcase.to_sym
+          end
+        end)
+    end
+    
+   private
+    
+    attr_writer :dom_ir_utils_source
+    
+    alias_method :dom_ir_utils_src=, :dom_ir_utils_source=
+    
+    # 
+    # @raise  [NotImplementedError]
+    # @return 
+    def dom_ir_utils_source
+      @dom_ir_utils_source ||= self
+    end
+    
+    alias_method :dom_ir_utils_src=, :dom_ir_utils_source
+    
+  end
+end
+end
+end