vigilem-win32_api 0.0.10

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

@@ -0,0 +1,123 @@
+module Vigilem
+module Win32API::DOM
+  
+  # converts Windows VK if available or VK
+  # https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent.code
+  # https://bugzilla.mozilla.org/show_bug.cgi?id=865649
+  module KeyValuesTables
+    key_values = Vigilem::DOM::KeyValues
+    
+    ModifierKeys = Support::KeyMap.new({
+      :''          => 'Accel',
+      :VK_MENU     => 'Alt',
+      :VK_LMENU    => 'Alt',
+      :''          => 'AltGraph',
+      :VK_CAPITAL  => 'CapsLock',
+      :VK_CONTROL  => 'Control',
+      :VK_LCONTROL => 'Control',
+      :VK_RCONTROL => 'Control',
+      :''          => 'Fn',
+      :''          => 'FnLock',
+      :''          => 'Hyper',
+      :VK_RMENU    => 'Meta',
+      :VK_NUMLOCK  => 'NumLock',
+      :VK_LWIN     => 'OS', #The operating system key (e.g. the "Windows Logo" key).
+      :VK_SCROLL   => 'ScrollLock',
+      :VK_SHIFT    => 'Shift',
+      :VK_LSHIFT   => 'Shift',
+      :VK_RSHIFT   => 'Shift',
+      :''          => 'Super',
+      :''          => 'Symbol',
+      :VK_SYMBOL   => 'SymbolLock' #0x7A:VK_F11:VK_SYMBOL:Symbol (SYM) key.
+    })
+    
+    WhitespaceKeys = Support::KeyMap[[:VK_RETURN, :VK_SEPARATOR, :VK_TAB].zip(key_values::WhitespaceKeys)]
+    #The space or spacebar key is encoded as ' '.
+
+    NavigationKeys = Support::KeyMap[[:VK_DOWN, :VK_LEFT, :VK_RIGHT, :VK_UP, 
+                               :VK_END, :VK_HOME,:VK_NEXT, :VK_PRIOR].zip(key_values::NavigationKeys)]
+    EditingKeys = Support::KeyMap[[:VK_BACK, :VK_CLEAR, :'', :VK_CRSEL, :'', :VK_DELETE, :VK_EREOF, 
+                            :VK_EXSEL, :VK_INSERT, :'', :'', :''].zip(key_values::EditingKeys)]
+    UIKeys = Support::KeyMap[[:VK_ACCEPT, #IME accept?
+      :'', :VK_ATTN, :VK_CANCEL, :VK_APPS, :VK_ESCAPE, :VK_EXECUTE,
+      :'', :VK_HELP, :VK_PAUSE, :'', :'',
+      :VK_SCROLL, :VK_ZOOM, :VK_ZOOM].zip(key_values::UIKeys)]
+    DeviceKeys = Support::KeyMap.new({
+      :'' => ['BrightnessDown', 'BrightnessUp', 'Camera', 'Eject', 'LogOff', 'Power', 'PowerOff', 'Hibernate', 'Standby', 'WakeUp'],
+      :VK_SNAPSHOT => 'PrintScreen' #doesn;t work with readconsoleinput
+    })
+    IMEandCompositionKeys = Support::KeyMap.new({
+      :'' => ['AllCandidates', 'Alphanumeric', 'CodeInput', 'Compose', 'GroupFirst', 'GroupLast', 'GroupNext', 'GroupPrevious', 
+                                                                          'NextCandidate', 'PreviousCandidate', 'SingleCandidate'],
+      :VK_CONVERT    => 'Convert',
+      :VK_FINAL      => 'FinalMode',
+      :VK_MODECHANGE => 'ModeChange',
+      :VK_NONCONVERT => 'NonConvert',
+      :VK_PROCESSKEY => 'Process'
+    })
+    KeysspecifictoKoreankeyboards = Support::KeyMap.new({
+      :VK_OEM_BACKTAB           => 'RomanCharacters', #"RomanCharacters" for Japanese keyboard layout, "Unidentified" for the others.
+      :VK_HANGUEL               => 'HangulMode',
+      :VK_HANGUEL               => 'HangulMode',
+      :VK_HANJA                 => 'HanjaMode',
+      :VK_JUNJA                 => 'JunjaMode'
+    })
+    KeysspecifictoJapanesekeyboards = Support::KeyMap.new({
+      :VK_OEM_ENLW => 'Zenkaku',
+      :VK_OEM_AUTO => 'Hankaku',
+      :''          => ['ZenkakuHankaku', 'Katakana', 'HiraganaKatakana', 'Eisu'],
+      :VK_KANA     => 'KanaMode',
+      :VK_KANJI    => 'KanjiMode',
+      :VK_OEM_COPY => 'Hiragana' #"Hiragana" for Japanese keyboard layout, "Unidentified" for the others.
+    })
+    General_PurposeFunctionKeys = Support::KeyMap.new({
+      :VK_F1  => 'F1',
+      :VK_F2  => 'F2',
+      :VK_F3  => 'F3',
+      :VK_F4  => 'F4',
+      :VK_F5  => 'F5',
+      :VK_F6  => 'F6',
+      :VK_F7  => 'F7',
+      :VK_F8  => 'F8',
+      :VK_F9  => 'F9',
+      :VK_F10 => 'F10',
+      :VK_F11 => 'F11',
+      :VK_F12 => 'F12',
+      :'' => ['Soft1', 'Soft2', 'Soft3', 'Soft4']
+    })
+    #Mediamedia
+    MultimediaKeys = Support::KeyMap.new({
+    #These are extra keys found on "multimedia" keyboards.
+      :''                      => ['Close', 'MailForward', 'MailReply', 'MailSend', 'New', 'Open', 'Save', 'SpellCheck'],
+      :VK_MEDIA_PLAY_PAUSE    => 'MediaPlayPause',
+      :VK_LAUNCH_MEDIA_SELECT => 'MediaSelect',
+      :VK_MEDIA_STOP          => 'MediaStop',
+      :VK_MEDIA_NEXT_TRACK    => 'MediaTrackNext',
+      :VK_MEDIA_PREV_TRACK    => 'MediaTrackPrevious',
+      :VK_PRINT               => 'Print',
+      :VK_VOLUME_DOWN         => 'VolumeDown',
+      :VK_VOLUME_UP           => 'VolumeUp',
+      :VK_VOLUME_MUTE         => 'VolumeMute'
+    })
+    ApplicationKeys = Support::KeyMap.new({
+      :'' => ['LaunchCalculator', 'LaunchCalendar', 'LaunchMediaPlayer', 'LaunchMusicPlayer', 
+             'LaunchMyComputer', 'LaunchScreenSaver', 'LaunchSpreadsheet', 'LaunchWebBrowser', 
+                                                          'LaunchWebCam', 'LaunchWordProcessor'],
+      :VK_LAUNCH_MAIL => 'LaunchMail'
+    })
+    BrowserKeys = Support::KeyMap[key_values::BrowserKeys.zip([:VK_BROWSER_BACK, :VK_BROWSER_FAVORITES, :VK_BROWSER_FORWARD, :VK_BROWSER_HOME, :VK_BROWSER_REFRESH, :VK_BROWSER_SEARCH, :VK_BROWSER_STOP])]
+    #The key values for media controllers (e.g. remote controls for 
+    #television, audio systems, and set-top boxes) are 
+    #derived in part from the consumer electronics technical specifications:
+    MediaControllerKeys = Support::KeyMap[key_values::MediaControllerKeys.zip([:'']).reverse]
+    
+    SpecialKeyValues = Support::KeyMap.new({ :'' => 'Unidentified' })
+    
+  end
+  KeyTable = KeyValuesTables.constants.each_with_object(Support::KeyMap.new()) {|table_name, memo| memo.merge! KeyValuesTables.const_get(table_name) }
+  KeyTable.default = 'Unidentified'
+  
+  KeyTable.right_side_alias(:dom_key)
+  KeyTable.left_side_alias(:win_vk)
+end
+end

data/lib/vigilem/win32_api/dom.rb

@@ -0,0 +1,5 @@
+require 'vigilem/dom'
+
+require 'vigilem/win32_api/dom/input_record_utils'
+
+require 'vigilem/win32_api/dom/adapter'

data/lib/vigilem/win32_api/eventable.rb

@@ -0,0 +1,41 @@
+module Vigilem::Win32API
+  # 
+  # @abstract included into the same module as RubyizedAPI
+  #           or respond_to? [:read_console_input, :peek_console_input]  
+  module Eventable
+    
+    # @param  [Integer] limit
+    # @return [Array]
+    def read_many_nonblock(limit=1)
+      [*(read_console_input({:nLength => limit, :blocking => false }) if has_any?)]
+    end
+    
+    # blocks until the specified number of events are read
+    # @param  [Integer] number_of_events=1
+    # @return [Array] 
+    def read_many(number_of_events=1)
+      read_console_input({:nLength => number_of_events, :blocking => true })
+    end
+    
+    # non_blocking
+    # commonly used with event processing
+    # @param  [Integer]
+    # @return [InputRecord]
+    def read_one_nonblock
+      read_one if has_any?
+    end
+    
+    # blocking
+    # reads one event from the input buffer
+    # @return [Array]
+    def read_one
+      read_console_input.shift
+    end
+    
+    # checks whether the input buffer has events
+    # @return [TrueClass || FalseClass]
+    def has_any?
+      peek_console_input.size > 0
+    end
+  end
+end

data/lib/vigilem/win32_api/input__record.rb

@@ -0,0 +1,53 @@
+module Vigilem
+
+# 
+module Win32API
+  
+  
+  # 
+  class INPUT_RECORD < ::VFFIStruct
+    
+    # @!attr [Integer] the ID type of this record
+    layout_with_methods :EventType, :WORD,
+      *(union(:Event) do
+        ConsoleInputEvents.vk_names.map do |event|
+          event.to_s.downcase.titlecase.split(/\s+/).join.to_sym
+        end.sort.zip(ConsoleInputEvents.structs.sort {|klass, other_klass| klass.name <=> other_klass.name }).flatten
+      end)
+    
+    # 
+    # @return [Hash]
+    def to_h
+      FFIUtils.struct_to_h(self)
+    end
+    
+    # 
+    # @return [Integer]
+    def type
+      self.EventType
+    end
+    
+    # 
+    # @return [INPUT_RECORD::Union::*_EVENT_RECORD]
+    def event_record
+      self.class.event_record(self)
+    end
+    
+    # 
+    # @param  input_record [EventUnion?]
+    # @return [INPUT_RECORD::Union::*_EVENT_RECORD]
+    def self.event_record(input_record)
+      sym = ConsoleInputEvents.vk_hash[input_record.EventType].to_s.downcase.titlecase.gsub(/\s+/, '').to_sym
+      input_record.Event[sym] unless sym.nil? or sym.empty?
+    end
+    
+    # 
+    # @return [String] 
+    def inspect
+      head, tail = super.split(' ', 2)
+      "#{head} event_record=#{event_record.inspect} #{tail}"
+    end
+  end
+  InputRecord = INPUT_RECORD
+end
+end

data/lib/vigilem/win32_api/input_system_handler.rb

@@ -0,0 +1,124 @@
+require 'vigilem/core/input_system_handler'
+
+require 'vigilem/core/hub'
+
+require 'vigilem/core/adapters/buffered_adapter'
+
+require 'vigilem/win32_api'
+
+require 'vigilem/win32_api/rubyized'
+
+require 'vigilem/win32_api/eventable'
+
+module Vigilem
+module Win32API
+  
+  # 
+  class InputSystemHandler
+    
+    include Core::InputSystemHandler
+    
+    include Core::Adapters::BufferedAdapter
+    
+    include Rubyized
+    
+    include Eventable
+    
+    # 
+    # @param lnk
+    def initialize(lnk=nil)
+      initialize_buffered(lnk || Vigilem::Win32API)
+    end
+    
+    def win32_api_rubyized_source
+      self
+    end
+    
+    def_delegator :link, :GetStdHandle
+    
+    # 
+    # @param  [Finum] hConsoleInput
+    # @param  [PINPUT_RECORD] lpBuffer, out, this item will be updated
+    # @param  [Integer] nLength
+    # @param  [::FFI::Pointer] lpNumberOfEventsRead, out, this item will be updated
+    # @return [Integer] 1 or 0
+    def PeekConsoleInput(hConsoleInput, lpBuffer, nLength, lpNumberOfEventsRead)
+      semaphore.synchronize {
+        events = buffered(nLength) do |len_remainder|
+          ret = link.PeekConsoleInputW(hConsoleInput, lpBuffer, nLength, lpNumberOfEventsRead)
+          lpBuffer
+        end
+        _update_out_args(lpBuffer, lpNumberOfEventsRead, events)
+        ret ||= 1
+      }
+    end
+    
+    # 
+    # @param  [Finum] hConsoleInput
+    # @param  [PINPUT_RECORD] lpBuffer, out, this item will be updated
+    # @param  [Integer] nLength
+    # @param  [::FFI::Pointer] lpNumberOfEventsRead, out, this item will be updated
+    # @return [Integer] 1 or 0
+    def ReadConsoleInput(hConsoleInput, lpBuffer, nLength, lpNumberOfEventsRead)
+      semaphore.synchronize {
+        events = buffered!(nLength) do |still_to_get|
+          ret = link.ReadConsoleInputW(hConsoleInput, lpBuffer, still_to_get, lpNumberOfEventsRead)
+          demux(*lpBuffer) unless lpBuffer.empty?
+          lpBuffer
+        end
+        _update_out_args(lpBuffer, lpNumberOfEventsRead, events)
+        ret ||= 1
+      }
+    end
+    
+    # 
+    # @see    
+    # @param  [Integer] uCode
+    # @param  [Integer] uMapType
+    # @return 
+    def MapVirtualKey(uCode, uMapType)
+      # without this it could fail silently
+      raise ArgumentError, "uCode has to be a Integer not #{uCode.class}:`#{uCode}'" unless uCode.is_a? Integer
+      raise ArgumentError, "uMapType has to be a Integer not #{uMapType.class}:`#{uMapType}'" unless uMapType.is_a? Integer
+      link.MapVirtualKeyW(uCode, uMapType)
+    end
+    
+    # the hub that sends and receives messages for 
+    # this buffer
+    # @raise  RuntimeError
+    # @return 
+    def hub
+      @hub ||= (Core::Hub.aquire(link()) << self.buffer)
+    end
+    
+    # 
+    # @see    Hub#demux
+    # @param  [Array] msgs
+    # @return 
+    def demux(*msgs)
+      hub.demux(self, *msgs)
+    end
+   private
+    
+    # 
+    # @param  [PINPUT_RECORD] lpBuffer
+    # @param  [::FFI::Pointer] lpNumberOfEventsRead
+    # @param  [Array] events
+    # @return [Array]
+    def _update_out_args(lpBuffer, lpNumberOfEventsRead, events)
+      FFIUtils.add_int_typedef(lpNumberOfEventsRead, :dword, evnt_sze = events.size)
+      begin
+        lpBuffer.replace(events + [*lpBuffer[evnt_sze..-1]])
+      rescue ArgumentError => e
+        if e.message =~ /bad value for range/
+          e.message.replace("#{e.message}, #{evnt_sze.inspect}..-1")
+          raise e
+        else
+          raise
+        end
+      end
+    end
+    
+  end
+end
+end

data/lib/vigilem/win32_api/p_input__record.rb

@@ -0,0 +1,55 @@
+require 'vigilem/ffi'
+
+module Vigilem
+module Win32API
+  
+  # 
+  class PINPUT_RECORD
+    
+    include FFI::ArrayPointerSync
+    
+    # @see    ArrayPointerSync#initialize_array_sync
+    # @param  [Integer || FFI::Pointer] max_len_or_ptr
+    # @param  [Array] 
+    def initialize(max_len_or_ptr, *init_values)
+      initialize_ary_ptr_sync(max_len_or_ptr, *init_values)
+    end
+    
+    class << self
+      
+      # 
+      # @param  [FFI::Pointer]
+      # @return [self]
+      def from_pointer(pointer)
+        new(pointer)
+      end
+      
+      # 
+      # @return [Class || Symbol]
+      def ary_type
+        INPUT_RECORD
+      end
+      
+      # Converts the specified value from the native type.
+      # @param  value
+      # @param  ctx
+      # @return [PINPUT_RECORD]
+      def from_native(value, ctx)
+        new(value)
+      end
+      
+      # Converts the specified value to the native type.
+      # @param  value
+      # @param  ctx
+      # @return [FFI::Pointer]
+      def to_native(value, ctx)
+        value.ptr
+      end
+    end
+    
+  end
+  PInputRecord = PINPUT_RECORD
+  ::FFI.typedef(PINPUT_RECORD, :pinput_record)
+  ::FFI.typedef(PINPUT_RECORD, :PINPUT_RECORD)
+end
+end

data/lib/vigilem/win32_api/rubyized.rb

@@ -0,0 +1,114 @@
+require 'vigilem/win32_api'
+
+module Vigilem::Win32API
+  # @abstract 
+  # @see      http://msdn.microsoft.com
+  module Rubyized
+    
+    include Vigilem::Win32API::Constants
+    
+    # 
+    # @param  [Integer] handle defaults to Vigilem::Win32API::STD_INPUT_HANDLE
+    # @return [Integer]
+    def get_std_handle(handle=Vigilem::Win32API::STD_INPUT_HANDLE)
+      win32_api_rubyized_src.GetStdHandle(handle)
+    end
+    
+    # 
+    # @param  [Hash] 
+    # @option opts [Integer] :hConsoleInput
+    # @option opts [PINPUT_RECORD || Array] :lpBuffer
+    # @option opts [Integer] :nLength
+    # @option opts [Integer] :lpNumberOfEventsRead
+    # @return [PINPUT_RECORD]
+    def peek_console_input(opts={})
+      _options(opts)
+      win32_api_rubyized_src.PeekConsoleInput(opts[:hConsoleInput], opts[:lpBuffer], opts[:nLength], opts[:lpNumberOfEventsRead])
+      opts[:lpBuffer]
+    end
+    
+    # default behaviour is that of read_console_input (block if no msgs in the buffer, 
+    # if opts[:blocking] == true, the method will block until lpBuffer full
+    # if opts[:blocking] == false, there will be no blocking
+    # @param  [Hash] 
+    # @option opts [Integer] :hConsoleInput
+    # @option opts [PINPUT_RECORD || Array] :lpBuffer
+    # @option opts [Integer] :nLength
+    # @option opts [Integer] :lpNumberOfEventsRead
+    # @return [PINPUT_RECORD]
+    def read_console_input(opts={})
+      _options(opts)
+      
+      lp_buffer = []
+      
+      if (default = (blocking = opts[:blocking]).nil?) or blocking
+        begin
+          win32_api_rubyized_src.ReadConsoleInput(opts[:hConsoleInput], opts[:lpBuffer], opts[:nLength], opts[:lpNumberOfEventsRead])
+          lp_buffer += opts[:lpBuffer]
+        end while (not default) and lp_buffer.size < opts[:nLength]
+        opts[:lpBuffer].replace(lp_buffer)
+      elsif not peek_console_input.empty?
+        win32_api_rubyized_src.ReadConsoleInput(opts[:hConsoleInput], opts[:lpBuffer], opts[:nLength], opts[:lpNumberOfEventsRead])
+        opts[:lpBuffer]
+      end
+    end
+    
+    # Translates (maps) a virtual-key code into a scan code or character 
+    # value, or translates a scan code into a virtual-key code. 
+    # @param  [Integer] code, the uCode
+    # @param  [Symbol || Integer] conversion, the uMapType, Vigilem::Win32API::Constants::MapType
+    # @raise  ArgumentError when conversion is a Symbol and not a valid uMapType name
+    # @raise  ArgumentError when conversion is a Integer and not a valid uMapType code
+    # @return [Integer] 
+    def map_virtual_key(code, conversion)
+      conversion_value = if conversion.is_a? Symbol
+        raise ArgumentError, "`#{conversion}' is not an available uMapType name" unless MapType.constants.include? conversion
+        API::Rubyized.const_get(conversion)
+      elsif not (@uMapeTypes ||= MapType.constants.map {|const| Vigilem::Win32API::Rubyized.const_get(const) }).include? conversion
+        raise ArgumentError, "`#{conversion}' is not an available uMapType" 
+      end
+      win32_api_rubyized_src.MapVirtualKey(code, conversion_value || conversion)
+    end
+    
+   private
+    
+    # sets up default options for peek and read based 
+    # on user input
+    # @note   default nLength is 1
+    # @param  [Hash] opts
+    # @option opts [Integer] :hConsoleInput 
+    # @option opts [Integer] :nLength 
+    # @option opts [Win32API::PINPUT_RECORD || Array] :lpBuffer
+    # @option opts [NilClass || Integer] :lpNumberOfEventsRead
+    # @option opts [NilClass || TrueClass || FalseClass] :blocking
+    # @return [Hash]
+    def _options(opts={})
+      opts[:hConsoleInput] ||= get_std_handle()
+      
+      if opts[:lpBuffer].is_a? Array
+        opts[:nLength] = opts[:lpBuffer].size
+        opts[:lpBuffer] = Vigilem::Win32API::PINPUT_RECORD.new(opts[:nLength], *opts[:lpBuffer])
+      else 
+        opts[:nLength] ||= 1
+        opts[:lpBuffer] ||= Vigilem::Win32API::PINPUT_RECORD.new(opts[:nLength])
+      end
+      opts[:lpNumberOfEventsRead] ||= FFI::MemoryPointer.new(:DWORD, 1)
+      
+      opts
+    end
+    
+    attr_writer :win32_api_rubyized_source
+    
+    alias_method :win32_api_rubyized_src=, :win32_api_rubyized_source=
+    
+    # 
+    # @raise  [NotImplementedError]
+    # @return 
+    def win32_api_rubyized_source
+      @win32_api_rubyized_source ||= self
+    end
+    
+    alias_method :win32_api_rubyized_src, :win32_api_rubyized_source
+    
+  end
+end

data/lib/vigilem/win32_api/types.rb

@@ -0,0 +1,153 @@
+require 'ffi'
+
+require 'vigilem/core'
+
+module Vigilem
+module Win32API
+  
+  # 
+  module Types
+    
+    extend ::FFI::Library
+  
+    # Check for 64b operating systems.
+    if Vigilem::Core::System.x64bit?
+      ::FFI.typedef(:uint64, :ulong_ptr)
+      ::FFI.typedef(:int64, :long_ptr)
+    else
+      ::FFI.typedef(:ulong, :ulong_ptr)
+      ::FFI.typedef(:long, :long_ptr)
+    end
+    
+    
+    # 
+    module PVOID
+      extend ::FFI::DataConverter
+      native_type ::FFI::Type::POINTER
+      
+      class << self
+        # Converts the specified value from the native type.
+        # @return [Bignum, Integer]
+        def from_native(value, ctx)
+          value.address
+        end
+        
+        # Converts the specified value to the native type.
+        # @return [::FFI::Pointer]
+        def to_native(value, ctx)
+          case
+          when value.kind_of?(::FFI::Pointer)
+            value
+          when value.kind_of?(::FFI::Struct)
+            value.to_ptr
+          else
+            ::FFI::Pointer.new(value.to_i)
+          end
+        end
+      end
+    end
+    
+    
+    # 
+    class PBYTE
+    
+      include ::Vigilem::FFI::ArrayPointerSync
+      
+      # @see    ArrayPointerSync#initialize_array_sync
+      # @param  [Integer || ::FFI::Pointer] max_len_or_ptr
+      # @param  [Array] 
+      def initialize(max_len_or_ptr, *init_values)
+        initialize_array_sync(max_len_or_ptr, *init_values)
+      end
+      
+      class << self
+        
+        # 
+        # [Class || Symbol] 
+        def array_type
+          :BYTE
+        end
+        
+        # Converts the specified value from the native type.
+        # @return [Integer]
+        def from_native(value, ctx)
+          new(value)
+        end
+        
+        # Converts the specified value to the native type.
+        # @return [::FFI::Pointer]
+        def to_native(value, ctx)
+          case 
+          when value.is_a?(::FFI::Pointer)
+            value
+          when value.is_a?(self)
+            value.ptr
+          else
+            raise "#{value} is an Unsupported Type"
+          end
+        end
+      end
+    end
+    
+    ::FFI.typedef(PVOID, :p_void)
+    ::FFI.typedef(PVOID, :PVOID)
+    
+    ::FFI.typedef(PBYTE, :PBYTE)
+    
+    ::FFI.typedef(:p_void, :handle)
+    ::FFI.typedef(:PVOID, :HANDLE)
+    
+    ::FFI.typedef(:handle, :h_wnd)
+    ::FFI.typedef(:h_wnd, :HWND)
+    
+    ::FFI.typedef(:ushort, :word)
+    ::FFI.typedef(:word, :WORD)
+    
+    ::FFI.typedef(:ushort, :wchar)
+    ::FFI.typedef(:wchar, :WCHAR)
+    
+    ::FFI.typedef(:ushort, :char)
+    ::FFI.typedef(:char, :CHAR)
+    
+    ::FFI.typedef(:uint, :dword)
+    ::FFI.typedef(:uint, :DWORD)
+    
+    ::FFI.typedef(:uint, :UINT)
+    
+    ::FFI.typedef(:int, :BOOL)
+    
+    ::FFI.typedef(:uchar, :BYTE)
+    
+    ::FFI.typedef(:ulong_ptr, :WPARAM)
+    ::FFI.typedef(:long_ptr, :LPARAM)
+    
+    
+    # 
+    class POINT < ::VFFIStruct
+      layout_with_methods :x, :long,
+                          :y, :long
+    end
+    
+    
+    # 
+    class MSG < ::VFFIStruct
+      layout_with_methods :hwnd, :HWND,
+                          :message, :uint,
+                          :wParam, :WPARAM,
+                          :lParam, :LPARAM,
+                          :time, :DWORD,
+                          :pt, POINT
+    end
+    
+    
+    # 
+    class COORD < ::VFFIStruct
+      layout_with_methods :x, :short,
+                          :y, :short
+    end
+    
+  end
+  
+  include Types
+end
+end