wrb 2.0.0

data/lib/rwin.rb

@@ -0,0 +1,820 @@
+# Project WRB was forked from Project VisualuRuby(temp-name).
+# Author of this project: BANJO Koyu <banjokoyu at gmail.com>
+# The URL of this project: https://bitbucket.org/wrb/
+#
+# This is a script part of WRB.
+#
+# Original wrapper for Windows API between Ruby 2.3 or later
+# This is script side of RWin::API.
+#
+
+# Uncomment follows or write it on top level before require this file,
+# if you want to use UTF-16LE encoding. (But NOT recommended.)
+#
+# RWin::Application.output_encoding = Encoding::UTF_16LE
+
+require 'rwin.so'
+
+def dp(*args) # debug print
+  if /^(.+?):(\d+)(?::in `.*')?/ =~ caller.first
+    file = File.basename($1)
+    line = $2.to_i
+  end
+  dir = args.shift
+  dir.sub!(/^\@( *)/, "\\1#{file}@#{line}: ")
+  STDERR.puts sprintf(dir, *args)
+end
+
+def dpp(*args) # debug print with line number and inspected arguments
+  if /^(.+?):(\d+)(?::in `.*')?/ =~ caller.first
+    file = File.basename($1)
+    line = $2.to_i
+  end
+  STDERR.puts "#{file}@#{line}: " + sprintf("%p", args).sub(/^\[(.*)\]$/, '\1')
+end
+
+module RWin::API
+  
+=begin
+== RWin::API
+This module containes following singleton methods and useful wrapper functions.
+
+=== Singleton methods
+--- loadlib
+    Loads  multiple dlls into application. Once dlls are loaded, it skips to
+    load next time.
+    
+   RWin::API.loadlib 'user32.dll', 'kernel32'
+
+--- defun(prototypes)
+    Defines the Windows API function, which is stocked into RWin::API module as
+    module function. Once function is defined, it skips to define next time.
+    The arguments which passed to an API function are automatically changed 
+    according to these type: Integer, String and Proc as callback function.
+    Prototypes of arguments are ignored, only number of arguments is checked.
+    The return value is always an integer as LONG. 
+  
+  RWin::API.defun 'EnumWindows(CALLBACK)'
+  RWin::API.defun 'GetLastError()'
+  RWin::API.defun 'FormatMessage','LLLLPLP'
+    
+    Usage to call is bellow. 
+  
+  enum_wnd_proc = Proc.new{|hwnd| p hwnd}
+  RWin::API.EnumWindows(enum_wnd_proc)
+  buff = TCHAR[256]
+  RWin::API.FormatMessage(0x1000,0,RWin::API.getLastError,0,buff,buff.size,0)
+  puts RWin::API.encode_output(buff)
+
+--- callback_address(*proc, &block)
+    Registers Proc object as a callback function, and returns its pointer 
+    address as Integer. But usualy you may pass Proc object to the function 
+    directly. See above.
+    
+  enum_wnd_proc_address = RWin::API.callbackadress{|hwnd| p hwnd}
+
+--- defstruct(prototypes)
+    Defines a API Structure class in current context.
+    
+  POINT = RWin::API.defstruct 'int x, int y'
+  RECT  = RWin::API.defstruct 'int left, int top, int right, int bottom'
+    
+--- typealias(newtype, oldtype) 
+    Defines a alias ((<newtype>)) as ((<oldtype>))
+   
+=== Typical module functions
+--- encode_output(string)
+    Encodes string to RWin::Application.output_encoding. Use it output to 
+    $stdout. '_T()' is alias of it.
+    
+--- encode_default(str)
+    Encodes string to Encoding.default_external. Use it when join with literal.
+    '_X()' is alias of it.
+
+=end
+  
+  def self.set_dlls(*args)
+    args.each{|i|
+      i = RbConfig::CONFIG["LIBRUBY_SO"] if i.nil?
+      RWin::API::CFunc.loadLibrary(i)
+    }
+  end
+  
+  if RWin::UNICODE
+    def self.get_proc(fname, template, rettype, ubf=nil)
+      narg = template.size
+      cfunc = RWin::API::CFunc.getfunc(fname+'W', narg) || RWin::API::CFunc.new(fname, narg)
+      ubfstr = ubf ? "_ubf" : ""
+      module_eval( <<-EODEF,__FILE__,__LINE__+1)
+          @@__#{fname}__ = cfunc
+          def #{fname}(*args) @@__#{fname}__.call#{ubfstr}(*args); end
+        EODEF
+      cfunc
+    end
+  else
+    def self.get_proc(fname, template, rettype, ubf=nil)
+      narg = template.size
+      cfunc = RWin::API::CFunc.getfunc(fname+'A', narg) || RWin::API::CFunc.new(fname, narg)
+      ubfstr = ubf ? "_ubf" : ""
+      module_eval( <<-EODEF,__FILE__,__LINE__+1)
+          @@__#{fname}__ = cfunc
+          def #{fname}(*args) @@__#{fname}__.call#{ubfstr}(*args); end
+        EODEF
+      cfunc
+    end
+  end
+  
+  def self.loadlib(*args)
+    set_dlls(*args)
+  end
+  
+  def self.callbackadress(arg=nil, &block)
+    if block_given?
+      RWin::API.bindCallbackProc(Proc.new(&block))
+    elsif arg.is_a?(Proc)
+      RWin::API.bindCallbackProc(arg)
+    else
+      raise ArgumentError, "Neither Proc nor Block", caller(1)
+    end
+  end
+  
+  def self.defun_core(args, ubf)
+    n = args.size
+    if n == 0
+      raise ArgumentError, 'No function name', caller(1)
+    elsif n == 1  # DL style
+      if /^([\w\*\s]+\s)?([\w\.]+\!)?(\w+)\(([\w\*\s\,\[\]]*)\)$/.match(args[0])
+        rettype, dllname, fname, args = $1, $2, $3, $4
+        rettype ? rettype.strip! : rettype = 'L'
+        dllname.chop! if dllname
+        template = args.strip.split(/\s*,\s*/)
+      else
+        raise RuntimeError,"can't parse the function prototype: #{args[0]}", caller(1)
+      end
+      template = template.map{|i|
+        if TypeAliases[i]
+          TypeAliases[i]
+        else
+          warn "WARNING: `#{i}' is not defined on the top level" if $DEBUG||$VERBOSE
+          'P'
+        end
+      }.join('').tr('*p','P')
+    else # Win32API style
+      dllname = nil
+      fname = args[0]
+      template = args[1].is_a?(Array) ? args[1] : args[1].strip.split(/\s*,\s*/)
+      rettype = args[2] || 'L'
+      template = template.size == 1 ? template[0] : template.join('')
+    end
+    ret = TypeAliases[rettype] ||{'VOID'=>'V'}[rettype] || rettype
+    raise AegumentError, "Unrecognized return type `#{rettype}'", caller(1) if !ret||ret.size>1
+    dncase_name = fname[0, 1].downcase + fname[1,fname.size-1]
+    return if  module_eval("defined?(#{dncase_name})")
+    RWin::API::CFunc.loadLibrary(dllname) if dllname
+    prc = get_proc(fname, template, ret, ubf);
+    self.module_eval("alias #{dncase_name} #{fname}")
+    self.module_eval("module_function :#{dncase_name},:#{fname}")
+    prc
+  end
+  private_class_method(:get_proc, :set_dlls, :defun_core)
+  
+  def self.defun(*args) defun_core(args, nil); end
+  def self.defun_ubf(*args) defun_core(args, true); end
+  
+  TypeAliases = {
+    # Base
+    'B'             => 'B',
+    'C'             => 'C',
+    'H'             => 'H',
+    'W'             => 'W',
+    'L'             => 'L',
+    'P'             => 'P',
+    'S'             => 'S',
+    'U'             => 'U',
+    'T'             => RWin::UNICODE ? 'W' : 'C',
+    'c'             => 'c', # Not encoded string for char*
+    'Q'             => 'Q', # X64 ? ULONGLONG : ULONG
+    'I'             => 'I', # X64 ? LONGLONG : LONG
+    
+    # Common
+    'byte'          => 'B',
+    'char'          => 'c', # Not encoded string for char*
+    'wchar_t'       => 'W',
+    'unsignedchar'  => 'B',
+    'short'         => 'H',
+    'int'           => 'L',
+    'uint'          => 'U',
+    'unsigned'      => 'U',
+    'unsignedint'   => 'U',
+    'long'          => 'L',
+    'unsignedlong'  => 'U',
+    'void'          => 'L',
+    
+    # Windows
+    'CHAR'          => 'C', # Encoded string for CHAR*
+    'UCHAR'         => 'B',
+    'BYTE'          => 'B',
+    'WCHAR'         => 'W',
+    'SHORT'         => 'H',
+    'WORD'          => 'H',
+    'ATOM'          => 'L',
+    'INT'           => 'L',
+    'UINT'          => 'U',
+    'BOOL'          => 'L',
+    'LONG'          => 'L',
+    'ULONG'         => 'U',
+    'DWORD'         => 'U',
+    'HICON'         => 'U',
+    'COLORREF'      => 'U',
+    'LPARAM'        => 'Q',
+    'WPARAM'        => 'Q',
+    'VOID*'         => 'P',
+    'LPSTR'         => 'S',
+    'LPWSTR'        => 'S',
+    'LPTSTR'        => 'S',
+    'LPCSTR'        => 'S',
+    'LPCWSTR'       => 'S',
+    'LPCTSTR'       => 'S',
+    'TCHAR'         => RWin::UNICODE ? 'W' : 'C',
+    'HANDLE'        => 'Q',
+    'HINSTANCE'     => 'Q',
+    'HWND'          => 'Q',
+    'HDC'           => 'Q',
+    'HBITMAP'       => 'Q',
+    'ULONG_PTR'     => 'Q', # for X64
+    'UINT_PTR'      => 'Q', # for X64
+    'DWORD_PTR'     => 'Q', # for X64
+    'LONG_PTR'      => 'I', # for X64
+    'INT_PTR'       => 'I' # for X64
+  }
+  
+  TypeLength = {
+    'B' => 1,
+    'C' => 1,
+    'H' => 2,
+    'W' => 2,
+    'L' => 4,
+    'U' => 4,
+    'P' => RWin::X64 ? 8 : 4,
+    'S' => RWin::X64 ? 8 : 4,
+    'Q' => RWin::X64 ? 8 : 4,
+    'I' => RWin::X64 ? 8 : 4
+  }
+  
+  # Pre-defined functions
+  loadlib 'kernel32'
+  defun "GetLastError()"
+  defun "DWORD FormatMessage(DWORD, LONG, DWORD, DWORD, LPTSTR, DWORD, void*)"
+  defun "GlobalLock(HANDLE)"
+  defun "GlobalUnlock(HANDLE)"
+  
+  loadlib 'user32'
+  defun "GetClassName(hWnd, lpClassname, nMaxcount)"
+  defun "MessageBox(HWND hWnd, LPCTSTR lpText, LPCTSTR lpCaptioon, UINT uType )"
+  defun "GetActiveWindow()"
+  defun "GetFocus()"
+  defun 'GetDlgItem(HWND iDlg, int nIDDlgitem)'
+  defun 'GetSystemMetrics(int nIndex)'
+  defun 'SystemParametersInfo(UINT uiAction, UINT uiParam, PVOID pvParam, UINT fWinIni)'
+  
+#  loadlib 'gdi32'
+  defun "gdi32.dll!GetStockObject(int fnObject)"
+  
+  def self.lasterror()
+    buff = TCHAR[256]
+    len = FormatMessage(0x1000, 0, RWin::API.GetLastError, 0, buff, buff.size, nil)
+    buff.to_s
+  end
+
+  @@__nullchar_w_ = "\0\0".force_encoding(Encoding::UTF_16LE)
+  @@__nullregexp_w_ = Regexp.new("\0*$".encode!(Encoding::UTF_16LE))
+  @@__crregexp_w_ = Regexp.new("\r".encode!(Encoding::UTF_16LE))
+  @@__lfregexp_w_ = Regexp.new("\n".encode!(Encoding::UTF_16LE))
+  @@__crlfchar_w_ = "\r\n".encode!(Encoding::UTF_16LE)
+    
+  def adjust_internal_lf_code(s)
+    str = s.to_s
+    if str.encoding==Encoding::UTF_16LE
+      str.gsub(@@__crregexp_w_ , '').gsub(@@__lfregexp_w_, @@__crlfchar_w_)
+    else
+      str.gsub(/\r/, '').gsub(/\n/, "\r\n")
+    end
+  end
+  
+  def adjust_output_lf_code(s)
+    str = s.to_s
+    if str.encoding==Encoding::UTF_16LE
+      str.gsub(@@__crregexp_w_, '')
+    else
+      str.gsub(/\r/, '')
+    end
+  end
+  
+  def encode_internal(s)
+    str = s.to_s
+    str.encode(Encoding::UTF_16LE).gsub(@@__nullregexp_w_, '').concat(@@__nullchar_w_)
+  end
+  
+  def encode_output(s)
+    str = s.to_s
+    enc = RWin::Application.external_encoding
+    if str.encoding == Encoding::ASCII_8BIT
+      str.force_encoding(Encoding::UTF_16LE)
+    end
+    r = str.encode(enc)
+    if enc == Encoding::UTF_16LE
+      r.gsub(@@__nullregexp_w_, '')
+    else
+      r.gsub(/\0*$/, '')
+    end
+  end
+    
+  def encode_default(s)
+    str = s.to_s
+    if str.encoding == Encoding::ASCII_8BIT
+      str.force_encoding(Encoding::UTF_16LE)
+    end
+    str.encode(Encoding.default_external).gsub(/\0*$/, '')
+  end
+  
+  def encode_wide(str) encode_internal(str); end
+  
+  def encoding2bin(str) str.force_encoding(Encoding::ASCII_8BIT); end
+  
+  def encoding2default(str)
+    str.force_encoding(Encoding.default_external)
+  end
+  
+  alias _T encode_output
+  alias _X encode_default
+  
+  def typealias(newtype, oldtype)
+    if btypes = TypeAliases[oldtype]
+      raise TypeError,"template `P' not allowed, change type directly", caller(1) if btypes=='P'
+      TypeAliases[newtype] = btypes
+    else
+      raise ArgumentError, "#{oldtype} is not registered", caller(1)
+    end
+  end
+  
+  module_function :typealias, :adjust_output_lf_code, :adjust_internal_lf_code,
+                  :encode_output, :encode_default, :encode_internal,
+                  :encode_wide, :encoding2bin, :encoding2default, :_T, :_X
+  
+  if RWin::X64
+    def uint2int(u)
+      u = u & 0xffffffff_ffffffff
+      u > 0x7fffffff_ffffffff ? u - 0x100000000_00000000 : u
+    end
+    def int2uint(i)
+      i = i & 0xffffffff_ffffffff
+    end
+  else
+    def uint2int(u)
+      u = u & 0xffffffff
+      u > 0x7fffffff ? u - 0x100000000 : u
+    end
+    def int2uint(i)
+      i = i & 0xffffffff
+    end
+  end
+  module_function :uint2int, :int2uint
+  
+  class CStruct # additional methods on Ruby side
+    Classes = nil
+    ArgCount = 1
+    Offsets = nil
+    References = nil
+    include Enumerable
+#    def each()
+#      self.class::Members.each{|name|# dpp name.to_s
+#        yield(name ? name.intern : nil, eval(name.to_s))
+#      }
+#    end
+#    def to_a()
+#      if !self.class::Members || self.class::Members == [nil]
+#        self[0, -1].inject([]){|ar, i| ar << (i.is_a?(CStruct) ? i.to_a : i)}
+#      else
+#        self.inject([]){|ar, i| ar << (i[1].is_a?(CStruct) ? i[1].to_a : i[1])}
+#      end
+#    end
+#    def to_hsh()
+#      hs = {}
+#      self.each{|nm, v| hs[nm] = (v.is_a?(CStruct) ? v.to_hsh : v)}
+#      hs
+#    end
+#    alias to_ary to_a
+    
+    def to_a(rflag=true)
+      to_ary(rflag)
+    end
+    
+    def self.defmembers(*args)
+      #get num of membuers
+      cmembers = self::SOffsets.unpack("SSS")[2]
+      # get first member
+      offset, ifunc, mblen, nth, klsidx = self::SOffsets[8, 8].unpack("SCCSS")
+      if args[0] && cmembers==1 && nth>0
+        alias_method(args[0], :value)
+        alias_method(args[0]+'=', :value=)
+      elsif args.size==1 && nth>0
+        define_method(args[0]){ self[0] }
+        define_method(args[0]+"=") {|x|
+          return self[0] = x if ifunc==2 || ifunc==4
+          raise TypeError, "Argument must be an Array at variable length." unless x.is_a? Array
+          x.each_with_index{|v, i| self[i] = v }
+        }
+      else
+        args.each_with_index{|s, i|
+          define_method(s){ self[i] }
+          define_method(s+"="){|x| self[i] = x }
+        }
+      end
+    end
+    
+    def self.[](*args);
+      if (cmembers = self::SOffsets.unpack("SSS")[2]) == 1
+        offset, ifunc, mblen, nth, klsidx = self::SOffsets[8, 8].unpack("SCCSS")
+        if nth==0
+          __new_and_set_args__(*args)
+        else
+          if  args[0].is_a?(String) || args[0].is_a?(Array)
+            obj = alloc(mblen*args[0].size)
+            obj.value = args[0]
+            obj
+          else
+            alloc(mblen*args[0])
+          end
+        end
+      else
+        __new_and_set_args__(*args)
+      end
+    end
+    
+    def self.+(arg)
+      offset, ifunc, mblen, nth, klsidx = self::SOffsets[-8, 8].unpack("SCCSS")
+#      dpp offset, ifunc, mblen, nth, klsidx
+      if nth==0
+        raise ArgumentError, "Not a variable length Array."
+      else
+        alloc(self::Size + mblen*arg)
+      end
+    end
+    
+    def to_hsh()
+      members = self.class.instance_methods - RWin::API::CStruct.instance_methods
+      members.select{|i| !(i.to_s=~/.*=$/)}.sort.inject({}){|h, m|
+        v = __send__(m)
+        h[m] = (v.is_a?(RWin::API::CStruct) ? v.to_hsh : v)
+        h
+      }
+    end
+    alias :to_h :to_hsh
+    
+    def dump()
+      q, r = self.bytesize.divmod(16)
+      s = ""
+      q.times{|i|
+        b = self.slice(i*16, 16).to_b.unpack("C*")
+        p b
+        s += sprintf("%02X "*8+ " "+"%02X "*8, *b) +
+                     b.inject(""){|a,b| a+(b>64 ? b.chr : '.')} + "\n"
+      }
+      b = self.slice(q*16, r).to_b.unpack("C*")
+      p b
+      if r > 8
+        s += sprintf("%02X "*8 + " ", *b[0, 8]) 
+        rr = r - 8
+        offset = 8
+        offset2 = 0
+      else
+        offset = 0
+        offset2 = 1
+        rr = r
+      end
+      s += sprintf("%02X "*rr, *b[offset, rr]) 
+      s += " "*((16-r)*3+offset2)+b.inject(""){|a,b| a+(b>64 ? b.chr : '.')}
+    end
+    
+    private
+    def self._get_defined_type(modules, tstr)
+      if RWin::API.const_defined?(tstr)
+        RWin::API.const_get(tstr)
+      elsif modules
+        modules.each{|mod| #; dpp mod, tstr, mod.const_defined?(tstr)
+          if mod.const_defined?(tstr) #
+            c = mod.module_eval(tstr) #; dpp mod, c, caller[0, 3]
+            return c
+          end
+        }
+        nil
+      else
+        nil
+      end
+    end
+    
+    protected
+    def self.parse_arg(s, mod)
+      if s.match(/(\w+)\s*(\*?)\s*(\w*)(?:(\[\d*\]))?/)
+        tstr, ptr, name, ar = $1, $2, $3, $4
+        if ptr == "*" # member is pointer
+          at = TypeAliases[tstr]
+          case at
+          when 'c'
+            b_type = 's'
+          when 'C', 'W'
+            b_type = 'S'
+          when 'L'
+            b_type = 'l'
+          when 'U'
+            b_type = 'u'
+          when 'I'
+            b_type = 'i'
+          when 'Q'
+            b_type = 'q'
+          else
+            if klass = _get_defined_type(mod, tstr)
+              unless klass < RWin::API::CStruct
+                raise ArgumentError, "#{tstr} is not discendant of RWin::API::CStruct", caller(1)
+              end
+            else
+              raise ArgumentError, "Unknown type '#{tstr}' for CStruct"#, caller(1)
+            end              
+            b_type = 'P'
+          end
+          len = TypeLength['P']
+        elsif b_type = TypeAliases[tstr]
+          b_type.upcase! # upcase is for 'c'
+          len = TypeLength[b_type] 
+        elsif (klass=_get_defined_type(mod, tstr)) #; dpp klass #, caller[0]
+          unless klass < RWin::API::CStruct
+            raise ArgumentError, "#{tstr} is not discendant of RWin::API::CStruct", caller(1)
+          end
+#          b_type = klass::Template
+          b_type = 'K'
+          len = klass::Size
+        else
+          raise ArgumentError, "Unknown type '#{tstr}' for CStruct"#, caller(1)
+        end
+      else
+        raise ArgumentError, "unexpected element #{s}", caller(1)
+      end
+      if ar
+        nth = ar.tr('\[\]', '').to_i
+        nth = nth==0 ? 1 : nth
+      end
+      [klass, b_type, name, len, nth.to_i]
+    end
+        
+    def self.adjust_byte_align(offset, b_size) # Faster than bit operation!
+      return 0 if b_size != 4 && b_size != 2
+      mod = offset % b_size
+      mod==0 ? 0 : b_size - mod
+    end
+    def self.adjust_byte_align(offset, b_size) # dpp offset, b_size!
+      return 0 if b_size!=8 && b_size!=4 && b_size!=2
+      mod = offset % b_size
+      mod==0 ? 0 : b_size - mod
+    end
+  end   # class CStruct
+  
+  ################# CStruct inherited class definition ##################
+  
+=begin
+   ==RWin::API.defstruct([current_module,] definittions...) 
+=end
+  
+  @@_klasses_ = []
+  def self.defstruct(*args)
+    if args[0]==true || args[0]==nil || args[0]==false || args[0]==:pack
+      need_pack = args.shift
+      need_pack = true if need_pack
+    else
+      need_pack = nil;
+    end
+#    dpp need_pack
+    if args[0].class == Class || args[0].class == Module || args[0].class == Object
+      mname = args.shift.name + '::DUMMY'
+    elsif  (kls = @@_klasses_.pop) &&
+      mname = kls.to_s
+    end
+    if mname && !mname.empty?
+      ar = mname.split('::')
+      ar.pop
+      modules = ar.inject([]){|ar, s| ar << ar.last.to_s + '::' + s}.map{|i| eval(i)}
+      modules.reverse!
+    end
+    args = args[0].split(/\s*[,;]\s*/) if args.size == 1
+    
+    if args.size == 1 && args[0].match(/^([A-Z]?\w*)\s*\[\s*\]/) # variable length array
+      newclass = Class.new(CStruct){
+        klass, b_type, name, len, a_size = parse_arg(args[0], modules)
+#        self.def_members b_type+'1', nil, klass ? [klass] : nil
+        deftemplate(b_type+'1', klass ? [klass] : nil)
+      }
+    else
+      newclass = Class.new(CStruct){
+        members = []
+        classes = []
+        offset = 0
+        template = ""
+        btypes = ""
+        maxbytes = 1
+        args.each do |arg|
+          klass, b_type, name, len, a_size = parse_arg(arg, modules)
+#          dpp klass, b_type, name, len, a_size
+          b_size = TypeLength[b_type] #;dpp [maxbytes, b_size]
+          maxbytes = b_size if b_size && maxbytes < b_size
+          if a_size == 0                          # member except array
+            btypes = b_type
+            offset += len
+          elsif a_size >= 1     # Array
+            btypes = b_type + a_size.to_s
+            offset += len * a_size
+          else
+            raise ArgumentError, "illegal data size: #{a_size}", caller(1)
+          end
+          members << name.to_s
+          classes << klass
+          klass = nil
+          template.concat btypes
+        end # each
+        members = members==[""] ? nil : members
+        classes = classes==[nil] ? nil : classes
+        # self.def_members(template, members, classes, need_pack)
+        deftemplate(template, classes && classes.compact, need_pack)
+        defmembers(*members)
+      } # Class.new
+    end
+    @@_klasses_ << newclass
+    newclass
+  end
+  
+# set members into pre-defined class 
+  
+  class POINT 
+    defmembers("x", "y")
+  end
+  class SIZE
+    defmembers("cx", "cy")
+  end
+  class RECT
+    defmembers("left", "top", "right", "bottom")
+  end
+  class LOGBRUSH 
+    defmembers("lbStyle", "lbColor", "lbHatch")
+  end
+  class LOGFONT
+    defmembers("lfHeight", "lfWidth", "lfEscapement", "lfOrientation", "lfWeight", 
+    "lfItalic", "lfUnderline", "lfStrikeOut", "lfCharSet", "lfOutPrecision", 
+    "lfClipPrecision", "lfQuality", "lfPitchAndFamily", "lfFaceName")
+  end
+  class LOGPEN 
+    defmembers("lopnStyle", "lopnWidth", "lopnColor")
+  end
+  class BITMAPINFO
+    defmembers("biSize", "biWidth","biHeight", "biPlanes", "biBitCount",
+    "biCompression", "biSizeImage", "biXPelsPerMeter", "biYPelsPerMeter",
+    "biClrUsed", "biClrImportant", "bmiColors")
+  end
+  class IMAGEINFO
+    defmembers("hbmImage", "hbmMask", "left", "top", "right", "bottom")
+  end
+  
+  class MENUITEMINFO 
+    defmembers("cbSize", "fMask",
+    "fType", "fState", "wID", "hSubMenu", "hbmpChecked", "hbmpUnchecked",
+    "dwItemData", "dwTypeData", "cch", "hbmpItem")
+  end
+  class  DEVMODE
+    defmembers("dmDeviceName", "dmSpecVersion", "dmDriverVersion", "dmSize", "dmDriverExtra",
+    "dmFields", "dmOrientation", "dmPaperSize", "dmPaperLength", "dmPaperWidth", "dmScale",
+    "dmCopies", "dmDefaultSource", "dmPrintQuality", "dmColor", "dmDuplex", "dmYResolution", "dmTTOption", "dmCollate", "dmFormName", "dmLogPixels", "dmBitsPerPel", "dmPelsWidth",
+    "dmPelsHeight", "dmDisplayFlags", "dmDisplayFrequency", "dmICMMethod", "dmICMIntent",
+    "dmMediaType", "dmDitherType", "dmReserved1", "dmReserved2", "dmPanningWidth",
+    "dmPanningHeight")
+  end
+end # RWin::API
+
+class Object::String
+  # Monkey patch of numeric conversion in an incompatible encoing.
+  # This extension must be use the refinements.
+  alias :__hex__  :hex
+  alias :__to_c__ :to_c
+  alias :__to_f__ :to_f
+  alias :__to_i__ :to_i
+    
+  def hex()
+    encoding.ascii_compatible? ? __hex__ : encode(Encoding::UTF_8).__hex__
+  end
+  def to_c()
+    encoding.ascii_compatible? ? __to_c__ : encode(Encoding::UTF_8).__to_c__
+  end
+  def to_f()
+    encoding.ascii_compatible? ? __to_f__ : encode(Encoding::UTF_8).__to_f__
+  end
+  def to_i(base = 10)
+    encoding.ascii_compatible? ? __to_i__(base) : encode(Encoding::UTF_8).__to_i__(base)
+  end
+end
+
+if $0 == __FILE__ # Testing
+#  p RWin::X64
+#end
+#__END__
+  
+  include RWin
+  include API
+  API.loadlib nil
+  
+  STDERR.puts "ruby #{RUBY_VERSION} p#{RUBY_PATCHLEVEL} #{RUBY_PLATFORM}"
+  struct1 = API::TCHAR[11]
+  struct1.value =  'mytest12345'
+  if RWin::UNICODE
+    p RWin::UNICODE
+    p struct1.to_s.force_encoding(Encoding::ASCII_8BIT)
+  else
+    p RWin::UNICODE
+    p struct1.to_s
+  end
+  
+  IMAGE_RELOCATION = RWin::API.defstruct "
+      DWORD VirtualAddress;
+      DWORD SymbolTableIndex;
+      WORD  Type;"
+  
+  p IMAGE_RELOCATION.new.size
+  
+  POINTARRAY = API.defstruct "POINT pt[2]"; p POINTARRAY::Template, POINTARRAY::Classes
+  
+  pary = POINTARRAY.new
+  pary.pt[1].x = 10
+  pary.pt[1].y = 20
+  p pary.pt[1].to_a
+
+
+  Mytest10 =  API.defstruct 'short x[4], int y[2]'
+  Mytest14 = API.defstruct 'int a[3], Mytest10 b, POINT* c'
+  p Mytest14::Template
+#  p Mytest14::Members
+  t10 = Mytest10[[5, 6, 7, 8], [9, 10]]
+  p t10.to_a
+  p Mytest14::Template
+  t = Mytest14[[0, 1, 2], t10, POINT[11, 12]]
+  
+  p t.b.x[3]
+  p t.to_a
+  
+  puts t.dump
+  
+  API.loadlib 'user32.dll', 'kernel32'
+  API.defun 'GetWindowText(hwnd, lpString, nMaxc)'
+  API.defun 'EnumWindows(CALLBACK, LPARAM)'
+  API.defun 'EnumChildWindows(HWND, CALLBACK, LPARAM)'
+#    prc = lambda {|hwnd| puts hwnd; -1}
+  #enum_windows_proc_address = API.callbackadress(prc)
+  enum_windows_proc_address = API.callbackadress{|hwnd, lparam|
+    str = TCHAR[128]
+    l = API.GetWindowText(hwnd, str, 128)
+    STDERR.printf("%#x, %p\n", hwnd, (str.to_s rescue str[0, 16]))
+#    STDERR.printf("%#x, %p, %p\n", hwnd, l, (str.to_s rescue str[0, l*2].pack('C*')))
+    -1
+  }
+  dpp enum_windows_proc_address
+  EnumChildWindows(0, enum_windows_proc_address, 0)
+#  EnumWindows(enum_windows_proc_address, 0)
+#    EnumWindows(prc, 0)
+  
+#  puts  RWin::Application.unicode? ? 'UNICODE' : 'not UNICODE'
+  
+  API.defun 'LONG GetCursorPos(POINT)'
+  API.defun 'long SetCursorPos(INT, INT)'
+  API.defun 'SetLastError(L)'
+  API.defun 'GetLastError()'
+  API.defun 'DWORD FormatMessage(DWORD, LONG, DWORD, DWORD, LPTSTR, DWORD, void*)'
+  
+#  POINT = API.defstruct 'LONG x', 'LONG y'
+  TEST  = API.defstruct 'int a[3], POINT b, POINT* c'
+  p TEST::Template
+  p TEST::Classes
+  pt = POINT.new
+  pt.x = 5; pt.y = 6
+  v = TEST[[0,1,2], POINT[3,4], pt]
+  p v.to_s
+#  v.a[0] = 1
+#  v.a[2] = 4
+#  v.b = POINT[5,6]
+#  v.b.y  = 8
+#  p v.b.to_a
+#  p v.c
+#  p v.to_a
+  puts v.dump
+  
+  v = POINT.new
+  SetLastError(0)
+  getCursorPos(v)
+  #p v.to_a
+
+  SetCursorPos(500, 500)
+  puts API.lasterror()
+end