vigilem-win32_api 0.0.10

data/lib/vigilem/win32_api/utils/keyboard.rb

@@ -0,0 +1,120 @@
+require 'vigilem/win32_api/virtual_keys'
+
+module Vigilem::Win32API
+module Utils
+# http://www.w3.org/TR/2013/WD-uievents-20130725/keyboard-sections.svg
+# http://www.computer-hardware-explained.com/image-files/computer-keyboard-layout-explained.jpg
+# https://upload.wikimedia.org/wikipedia/commons/9/9c/ISO_keyboard_%28105%29_QWERTY_UK.svg
+# http://i.stack.imgur.com/FU0R2.png
+# 
+module Keyboard
+  
+  include Vigilem::Win32API::VirtualKeys
+  
+  # 
+  # 
+  module ControlPadKeys
+    
+    # 
+    # @param  virtual_key
+    # @return [TrueClass || FalseClass]
+    def control_pad_key?(virtual_key)
+      [Keyboard::VK[:INSERT], Keyboard::VK[:DELETE], Keyboard::VK[:PRIOR], Keyboard::VK[:NEXT], Keyboard::VK[:END], Keyboard::VK[:HOME]].include?(virtual_key)
+    end
+  end
+  
+  include ControlPadKeys
+  extend ControlPadKeys
+  
+  # 
+  # 
+  module NavigationKeys
+    
+    # 
+    # @param  virtual_key
+    # @return [TrueClass || FalseClass]
+    def arrow_key?(virtual_key)
+      virtual_key.between?(Keyboard::VK[:LEFT], Keyboard::VK[:DOWN])
+    end
+    
+    # 
+    # @param  virtual_key
+    # @param  dw_state_names
+    # @return [TrueClass || FalseClass]
+    def nav_arrow_key?(virtual_key, *dw_state_names)
+      arrow_key?(virtual_key) and dw_state_names.include?(:ENHANCED_KEY)
+    end
+    
+    # the pad above the arrow keys, what is CLEAR again?
+    #
+    # @param  virtual_key
+    # @param  dw_state_names
+    # @return [TrueClass || FalseClass]
+    def nav_control_key?(virtual_key, *dw_state_names)
+      (control_key?(virtual_key) or virtual_key == Keyboard::VK[:CLEAR]) and dw_state_names.include?(:ENHANCED_KEY)
+    end
+  end
+  
+  include NavigationKeys
+  extend NavigationKeys
+  
+  # 
+  # 
+  module NumpadKeys
+    
+    # 
+    # @param  virtual_key
+    # @return [TrueClass || FalseClass]
+    def numlock?(virtual_key)
+      virtual_key == Keyboard::VK[:NUMLOCK]
+    end
+    
+    # 
+    # @param  virtual_key
+    # @param  [Array] dw_state_names
+    # @return [TrueClass || FalseClass]
+    def numpad_return?(virtual_key, *dw_state_names)
+      virtual_key == 0x0D and dw_state_names.include?(:ENHANCED_KEY)
+    end
+    
+    # 
+    # numpad_except_return_or_numlock
+    # @param  virtual_key
+    # @return [TrueClass || FalseClass]
+    def numpad_number_function?(virtual_key)
+      virtual_key.between?(Keyboard::VK[:NUMPAD0], Keyboard::VK[:DIVIDE])
+    end
+    
+    # 
+    # @param  virtual_key
+    # @param  [Array] dw_state_names
+    # @return [TrueClass || FalseClass]
+    def numpad_arrow?(virtual_key, *dw_state_names)
+      arrow_key?(virtual_key) and not dw_state_names.include?(:ENHANCED_KEY)
+    end
+    
+    # 
+    # @param  virtual_key
+    # @param  [Array] dw_state_names
+    # @return [TrueClass || FalseClass]
+    def numpad_control_key?(virtual_key, *dw_state_names)
+      control_pad_key?(virtual_key) and not dw_state_names.include?(:ENHANCED_KEY)
+    end
+    
+    # 
+    # @param  virtual_key
+    # @param  [Array] dw_state_names
+    # @return [TrueClass || FalseClass]
+    def numpad?(virtual_key, *dw_state_names)
+      numpad_return?(virtual_key, *dw_state_names) or numpad_number_function?(virtual_key) or 
+        numlock?(virtual_key) or numpad_control_key?(virtual_key, *dw_state_names)
+    end
+    
+  end
+  
+  include NumpadKeys
+  extend NumpadKeys
+  
+end
+end
+end

data/lib/vigilem/win32_api/version.rb

@@ -0,0 +1,5 @@
+module Vigilem
+module Win32API
+  VERSION = '0.0.10'
+end
+end

data/lib/vigilem/win32_api/virtual_keys/map.rb

@@ -0,0 +1,211 @@
+require 'vigilem/support/key_map'
+
+module Vigilem
+module Win32API
+  # https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent
+  module VirtualKeys
+    Map = Support::KeyMap.new({
+      0x01 => :VK_LBUTTON,
+      0x02 => :VK_RBUTTON,
+      0x03 => :VK_CANCEL,
+      0x04 => :VK_MBUTTON,
+      0x05 => :VK_XBUTTON1,
+      0x06 => :VK_XBUTTON2,
+      [0x07, 0x0A..0x0B, 0x0E..0x0F, 0x16, 0x1A, 
+        0x3A..0x40, 0x5E, 0x88..0x8F, 0x97..0x9F, 
+        0xB8..0xB9, 0xC1..0xD7, 0xD8..0xDA, 0xE0, 0xE8] => :VK_UNASSIGNED,
+      0x08 => :VK_BACK,
+      0x09 => :VK_TAB,
+      0x0C => :VK_CLEAR,
+      0x0D => :VK_RETURN,
+      0x10 => :VK_SHIFT,
+      0x11 => :VK_CONTROL,
+      0x12 => :VK_MENU,
+      0x13 => :VK_PAUSE,
+      0x14 => :VK_CAPITAL,
+      0x15 => :VK_KANA,
+      0x15 => :VK_HANGUEL,
+      0x15 => :VK_HANGUL,
+      0x17 => :VK_JUNJA,
+      0x18 => :VK_FINAL,
+      0x19 => :VK_HANJA,
+      0x19 => :VK_KANJI,
+      0x1B => :VK_ESCAPE,
+      0x1C => :VK_CONVERT,
+      0x1D => :VK_NONCONVERT,
+      0x1E => :VK_ACCEPT,
+      0x1F => :VK_MODECHANGE,
+      0x20 => :VK_SPACE,
+      0x21 => :VK_PRIOR,
+      0x22 => :VK_NEXT,
+      0x23 => :VK_END,
+      0x24 => :VK_HOME,
+      0x25 => :VK_LEFT,
+      0x26 => :VK_UP,
+      0x27 => :VK_RIGHT,
+      0x28 => :VK_DOWN,
+      0x29 => :VK_SELECT,
+      0x2A => :VK_PRINT,
+      0x2B => :VK_EXECUTE,
+      0x2C => :VK_SNAPSHOT,
+      0x2D => :VK_INSERT,
+      0x2E => :VK_DELETE,
+      0x2F => :VK_HELP,
+      0x30 => :VK_0,
+      0x31 => :VK_1,
+      0x32 => :VK_2,
+      0x33 => :VK_3,
+      0x34 => :VK_4,
+      0x35 => :VK_5,
+      0x36 => :VK_6,
+      0x37 => :VK_7,
+      0x38 => :VK_8,
+      0x39 => :VK_9,
+      0x41 => :VK_A,
+      0x42 => :VK_B,
+      0x43 => :VK_C,
+      0x44 => :VK_D,
+      0x45 => :VK_E,
+      0x46 => :VK_F,
+      0x47 => :VK_G,
+      0x48 => :VK_H,
+      0x49 => :VK_I,
+      0x4A => :VK_J,
+      0x4B => :VK_K,
+      0x4C => :VK_L,
+      0x4D => :VK_M,
+      0x4E => :VK_N,
+      0x4F => :VK_O,
+      0x50 => :VK_P,
+      0x51 => :VK_Q,
+      0x52 => :VK_R,
+      0x53 => :VK_S,
+      0x54 => :VK_T,
+      0x55 => :VK_U,
+      0x56 => :VK_V,
+      0x57 => :VK_W,
+      0x58 => :VK_X,
+      0x59 => :VK_Y,
+      0x5A => :VK_Z,
+      0x5B => :VK_LWIN,
+      0x5C => :VK_RWIN,
+      0x5D => :VK_APPS,
+      0x5F => :VK_SLEEP,
+      0x60 => :VK_NUMPAD0,
+      0x61 => :VK_NUMPAD1,
+      0x62 => :VK_NUMPAD2,
+      0x63 => :VK_NUMPAD3,
+      0x64 => :VK_NUMPAD4,
+      0x65 => :VK_NUMPAD5,
+      0x66 => :VK_NUMPAD6,
+      0x67 => :VK_NUMPAD7,
+      0x68 => :VK_NUMPAD8,
+      0x69 => :VK_NUMPAD9,
+      0x6A => :VK_MULTIPLY,
+      0x6B => :VK_ADD,
+      0x6C => :VK_SEPARATOR,
+      0x6D => :VK_SUBTRACT,
+      0x6E => :VK_DECIMAL,
+      0x6F => :VK_DIVIDE,
+      0x70 => :VK_F1,
+      0x71 => :VK_F2,
+      0x72 => :VK_F3,
+      0x73 => :VK_F4,
+      0x74 => :VK_F5,
+      0x75 => :VK_F6,
+      0x76 => :VK_F7,
+      0x77 => :VK_F8,
+      0x78 => :VK_F9,
+      0x79 => :VK_F10,
+      0x7A => :VK_F11,
+      0x7B => :VK_F12,
+      0x7C => :VK_F13,
+      0x7D => :VK_F14,
+      0x7E => :VK_F15,
+      0x7F => :VK_F16,
+      0x80 => :VK_F17,
+      0x81 => :VK_F18,
+      0x82 => :VK_F19,
+      0x83 => :VK_F20,
+      0x84 => :VK_F21,
+      0x85 => :VK_F22,
+      0x86 => :VK_F23,
+      0x87 => :VK_F24,
+      0x90 => :VK_NUMLOCK,
+      0x91 => :VK_SCROLL,
+      [0x92..0x96, 0xE3..0xE4, 0xE9..0xF5] => :VK_OEM,
+      0xA0 => :VK_LSHIFT,
+      0xA1 => :VK_RSHIFT,
+      0xA2 => :VK_LCONTROL,
+      0xA3 => :VK_RCONTROL,
+      0xA4 => :VK_LMENU,
+      0xA5 => :VK_RMENU,
+      0xA6 => :VK_BROWSER_BACK,
+      0xA7 => :VK_BROWSER_FORWARD,
+      0xA8 => :VK_BROWSER_REFRESH,
+      0xA9 => :VK_BROWSER_STOP,
+      0xAA => :VK_BROWSER_SEARCH,
+      0xAB => :VK_BROWSER_FAVORITES,
+      0xAC => :VK_BROWSER_HOME,
+      0xAD => :VK_VOLUME_MUTE,
+      0xAE => :VK_VOLUME_DOWN,
+      0xAF => :VK_VOLUME_UP,
+      0xB0 => :VK_MEDIA_NEXT_TRACK,
+      0xB1 => :VK_MEDIA_PREV_TRACK,
+      0xB2 => :VK_MEDIA_STOP,
+      0xB3 => :VK_MEDIA_PLAY_PAUSE,
+      0xB4 => :VK_LAUNCH_MAIL,
+      0xB5 => :VK_LAUNCH_MEDIA_SELECT,
+      0xB6 => :VK_LAUNCH_APP1,
+      0xB7 => :VK_LAUNCH_APP2,
+      0xBA => :VK_OEM_1,
+      0xBB => :VK_OEM_PLUS,
+      0xBC => :VK_OEM_COMMA,
+      0xBD => :VK_OEM_MINUS,
+      0xBE => :VK_OEM_PERIOD,
+      0xBF => :VK_OEM_2,
+      0xC0 => :VK_OEM_3,
+      0xDB => :VK_OEM_4,
+      0xDC => :VK_OEM_5,
+      0xDD => :VK_OEM_6,
+      0xDE => :VK_OEM_7,
+      0xDF => :VK_OEM_8,
+      0xE1 => :VK_OEM,
+      0xE2 => :VK_OEM_102,
+      0xE5 => :VK_PROCESSKEY,
+      0xE6 => :VK_OEM,
+      0xE7 => :VK_PACKET,
+      0xF6 => :VK_ATTN,
+      0xF7 => :VK_CRSEL,
+      0xF8 => :VK_EXSEL,
+      0xF9 => :VK_EREOF,
+      0xFA => :VK_PLAY,
+      0xFB => :VK_ZOOM,
+      0xFC => :VK_NONAME,
+      0xFD => :VK_PA1,
+      0xFE => :VK_OEM_CLEAR,
+      0xF2 => :VK_OEM_COPY,
+      0xF3 => :VK_OEM_AUTO,
+      0xF4 => :VK_OEM_ENLW,
+      0xF5 => :VK_OEM_BACKTAB #"RomanCharacters" for Japanese keyboard layout, "Unidentified" for the others.
+    })
+    
+                             # windows uses "Virtual-Key Codes" format
+    code_aliases = [:dom_key, :virtual_key_code, :virtual_key_codes]
+    vk_aliases = :win_vk, :virtual_key, :virtual_keys, :virtual_keyname, :virtual_keynames
+    
+    VK = Map.class.new
+    
+    Map.left_side_aliases(*code_aliases)
+    VK.left_side_aliases(*vk_aliases)
+    
+    Map.right_side_aliases(*vk_aliases)
+    VK.right_side_aliases(*code_aliases)
+    
+    Map.each_with_object(VK) do |(key, value), hsh| 
+      vk_name = value.to_s[3..-1]
+      hsh[sym = :"#{vk_name}"] = key
+    end
+  end
+end
+end

data/lib/vigilem/win32_api/virtual_keys.rb

@@ -0,0 +1,9 @@
+require 'vigilem/win32_api/virtual_keys/map'
+
+module Vigilem::Win32API
+
+# 
+module VirtualKeys
+  Map.each {|num, name| const_set(name, num) unless const_defined?(name) }
+end
+end

data/lib/vigilem/win32_api.rb

@@ -0,0 +1,61 @@
+require 'ffi'
+
+require 'vigilem/win32_api/constants'
+
+require 'vigilem/win32_api/types'
+require 'vigilem/win32_api/console_input_events'
+
+require 'vigilem/win32_api/input__record'
+require 'vigilem/win32_api/p_input__record'
+
+module Vigilem
+
+# @see    http://msdn.microsoft.com for usage
+# @todo   consider FFI options Hash :blocking (Boolean) — default: @blocking — set to true if the C function is a blocking call
+module Win32API
+  extend ::FFI::Library
+  
+  ffi_lib 'kernel32', 'user32'
+  ffi_convention :stdcall
+  
+  attach_function :GetStdHandle, [:DWORD], :HANDLE
+  
+  attach_function :MapVirtualKeyW, [:UINT, :UINT], :UINT
+  
+ module_function
+  
+  def PeekConsoleInputW(hConsoleInput, lpBuffer, nLength, lpNumberOfEventsRead)
+    _PeekConsoleInputW(hConsoleInput, lpBuffer, nLength, lpNumberOfEventsRead)
+  end
+  
+  def ReadConsoleInputW(hConsoleInput, lpBuffer, nLength, lpNumberOfEventsRead)
+    _ReadConsoleInputW(hConsoleInput, lpBuffer, nLength, lpNumberOfEventsRead)
+  end
+  
+  def ReadConsoleInputW(hConsoleInput, lpBuffer, nLength, lpNumberOfEventsRead)
+    _ReadConsoleInputW(hConsoleInput, lpBuffer, nLength, lpNumberOfEventsRead)
+  end
+  
+  def WriteConsoleInputW(hConsoleInput, lpBuffer, nLength, lpNumberOfEventsRead)
+    _WriteConsoleInputW(hConsoleInput, lpBuffer, nLength, lpNumberOfEventsRead)
+  end
+  
+ private
+  
+  attach_function :_PeekConsoleInputW, :PeekConsoleInputW, [:HANDLE, :PINPUT_RECORD, :DWORD, :pointer], :BOOL
+  
+  attach_function :_ReadConsoleInputW, :ReadConsoleInputW, [:HANDLE, :PINPUT_RECORD, :DWORD, :pointer], :BOOL
+  
+  attach_function :_ReadConsoleInputW, :ReadConsoleInputW, [:HANDLE, :PINPUT_RECORD, :DWORD, :pointer], :BOOL
+  
+  # future use
+  attach_function :_WriteConsoleInputW, :WriteConsoleInputW, [:HANDLE, :PINPUT_RECORD, :DWORD, :pointer], :BOOL
+  
+end
+end
+
+require 'vigilem/win32_api/rubyized'
+
+require 'vigilem/win32_api/input_system_handler'
+
+require 'vigilem/win32_api/dom'

data/spec/acceptance/custom_input_system.feature

@@ -0,0 +1,3 @@
+#Feature: Allow the input system to be changed and customized
+
+  

data/spec/acceptance/dom_adapter.feature

@@ -0,0 +1,7 @@
+#Feature: Provide a DOM Adapter for the Win32 API
+
+  #Scenario: get DOM events from api
+    # this is badly formed @see the step for the reason why
+    #Given read_console_input called before user presses a key
+     #Then a PINPUT_RECORD is returned
+    

data/spec/acceptance/rubyized.feature

@@ -0,0 +1,6 @@
+Feature: Provide a simple win 32 api for the dev
+  
+  Scenario: get events from api
+    # this is badly formed @see the step for the reason why
+    Given read_console_input called before user presses a key
+     Then a PINPUT_RECORD is returned

data/spec/acceptance/steps/custom_input_system_steps.rb

@@ -0,0 +1,37 @@
+=begin
+require 'bundler'
+Bundler.setup
+
+require 'vigilem/win32'
+
+require 'vigilem/win32_api/event_common'
+
+include Vigilem::Win32API
+
+module FakeInputSystem
+  class << self
+    
+    INPUT_RECORD = Vigilem::Win32API::INPUT_RECORD
+    
+    def GetStdHandle(arg)
+      3
+    end
+    
+    def PeekConsoleInputW(hConsoleInput, lpBuffer, nLength, lpNumberOfEventsRead)
+      lpBuffer.replace([INPUT_RECORD.new])
+      1
+    end
+    
+    def ReadConsoleInputW(hConsoleInput, lpBuffer, nLength, lpNumberOfEventsRead)
+      lpBuffer.replace([INPUT_RECORD.new])
+      1
+    end
+  end
+end
+
+adapt = EventCommon::Adapter.new.attach(InputSystemHandler.new(FakeInputSystem))
+
+puts 'press a button'
+
+puts adapt.read_console_input.inspect
+=end

data/spec/acceptance/steps/dom_adapter_steps.rb

@@ -0,0 +1,7 @@
+#require 'vigilem/win32_api/dom'
+
+module DomAdapterSteps
+  
+  #step 
+  
+end

data/spec/acceptance/steps/rubyized_steps.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+module RubyizedSteps
+
+  include InputHelper
+  
+  # this is malformed but due do timing and blocking this si the best way
+  step 'read_console_input called before user presses a key' do
+    adapt = InputSystemHandler.new
+    flush
+    write_console_input_test
+    @api_return = adapt.read_console_input
+  end
+  
+  step 'a PINPUT_RECORD is returned' do
+    expect(@api_return).to be_a ::Vigilem::Win32API::PINPUT_RECORD
+  end
+end
+
+RSpec.configure { |c| c.include RubyizedSteps }

data/spec/attributes_and_size_test.rb

@@ -0,0 +1,10 @@
+shared_examples 'attributes_and_size_test' do
+    
+  it 'will have methods as attrs' do
+    expect(described_class.new).to respond_to(*ary)
+  end
+  
+  it %q(will have an size eql to it's layout types sizes) do
+    expect(described_class.new.to_ptr.type_size).to eql(sze)
+  end
+end

data/spec/input_helper.rb

@@ -0,0 +1,41 @@
+require 'fiddle/import'
+
+module InputHelper
+  include Vigilem::Win32API
+  
+  module Fid
+    require 'fiddle/types'
+    
+    extend Fiddle::Importer
+    
+    dlload 'kernel32.dll', 'user32.dll'
+    
+    include Fiddle::Win32Types
+    
+    extern 'HANDLE GetStdHandle(DWORD)', :stdcall
+    
+    extern 'BOOL FlushConsoleInputBuffer(HANDLE)', :stdcall
+    
+    extern 'BOOL WriteConsoleInput(HANDLE, PVOID, DWORD, PVOID)', :stdcall
+  end
+  
+  def std_handle
+    Fid.GetStdHandle(0xFFFFFFF6)
+  end
+  
+  # clear out the user entered stuff queue
+  def flush
+    Fid.FlushConsoleInputBuffer(std_handle) 
+  end
+  
+  def write_console_input_test
+    nLength ||= 20
+    lpNumberOfEventsWritten ||= ' ' * 4
+    Fid.WriteConsoleInput(std_handle, [0x0001, 1, 0, 0x61, 1, 0x41, 97].pack('SxxlSSSSL'), 
+                                                                           nLength, lpNumberOfEventsWritten)
+  end
+end
+
+RSpec.configure do |c|
+  c.include InputHelper
+end

data/spec/spec_helper.rb

@@ -0,0 +1,28 @@
+# @todo metal events need to be in another windows console
+# @todo alot of the receive methods are too brittle
+
+require 'bundler'
+Bundler.setup
+
+require 'timeout'
+
+require 'vigilem/support/core_ext/debug_puts'
+
+require 'attributes_and_size_test'
+
+require 'input_helper'
+
+=begin
+#to discover when tests hang which will happen because I have not correctly isolated the tests
+# also can use rspec -f d
+RSpec.configure do |config|
+  
+  config.before :all do |example_group|
+    puts "#{example_group.class.description}"
+  end
+  
+  config.before :each do |example|
+    puts "->#{example.description}"
+  end
+end
+=end

data/spec/turnip_helper.rb

@@ -0,0 +1 @@
+Dir.glob("spec/acceptance/steps/**/*_steps.rb") { |f| load f, true }