wrb 2.0.0

data/lib/wrb/components/registry.rb

@@ -0,0 +1,408 @@
+require 'wrb'
+
+module WR
+  module RC
+    REG_SZ        = 1
+    REG_EXPAND_SZ = 2
+    REG_BINARY    = 3
+    REG_DWORD     = 4
+    REG_MULTI_SZ  = 7
+    REG_QWORD     = 11
+    
+    REG_OPTION_NON_VOLATILE = 0
+    REG_OPTION_VOLATILE     = 1
+    
+    REG_CREATED_NEW_KEY     = 1
+    REG_OPENED_EXISTING_KEY = 2
+    
+    HKEY_CLASSES_ROOT   = 0x80000000
+    HKEY_CURRENT_USER   = 0x80000001
+    HKEY_LOCAL_MACHINE  = 0x80000002
+    HKEY_USERS          = 0x80000003
+    HKEY_CURRENT_CONFIG = 0x80000005
+    
+    HKCR   = 0x80000000
+    HKCU   = 0x80000001
+    HKLM   = 0x80000002
+    
+    KEY_READ  = 0x20019
+    KEY_WRITE = 0x20006
+  end
+  
+  API.loadlib "advapi32.dll"
+  
+  API.defun "RegOpenKeyEx( 
+               HKEY hKey, 
+               LPCWSTR lpSubKey, 
+               DWORD ulOptions, 
+               REGSAM samDesired, 
+               PHKEY phkResult)"
+             
+  API.defun "RegCreateKeyEx( 
+               HKEY hKey, 
+               LPCWSTR lpSubKey, 
+               DWORD Reserved, 
+               LPWSTR lpClass, 
+               DWORD dwOptions,
+               REGSAM samDesired, 
+               LPSECURITY_ATTRIBUTES lpSecurityAttributes, 
+               PHKEY phkResult, 
+               LPDWORD lpdwDisposition)"
+             
+  API.defun "RegEnumValue( 
+               HKEY hKey, 
+               DWORD dwIndex, 
+               LPWSTR lpValueName, 
+               LPDWORD lpcchValueName, 
+               LPDWORD lpReserved, 
+               LPDWORD lpType, 
+               LPBYTE lpData, 
+               LPDWORD lpcbData)"
+   
+  API.defun "RegEnumKeyEx(
+               HKEY hKey, 
+               DWORD dwIndex, 
+               LPWSTR lpName, 
+               LPDWORD lpcName, 
+               LPDWORD lpReserved, 
+               LPWSTR lpClass, 
+               LPDWORD lpcbClass, 
+               PFILETIME lpftLastWriteTime)"
+  
+  API.defun "RegQueryValueEx( 
+               HKEY hKey, 
+               LPCWSTR lpValueName, 
+               LPDWORD lpReserved, 
+               LPDWORD lpType, 
+               LPBYTE  lpData, 
+               LPDWORD lpcbData)"
+
+  API.defun "RegSetValueEx(
+               HKEY hKey,
+               LPCWSTR lpValueName,
+               DWORD   Reserved,
+               DWORD   dwType,
+               const   BYTE* lpData,
+               DWORD   cbData)"
+  
+ API.defun "RegQueryInfoKey(
+              HKEY hKey,
+              LPTSTR  lpClass,
+              LPDWORD lpcClass,
+              LPDWORD lpReserved,
+              LPDWORD lpcSubKeys,
+              LPDWORD lpcMaxSubKeyLen,
+              LPDWORD lpcMaxClassLen,
+              LPDWORD lpcValues,
+              LPDWORD lpcMaxValueNameLen,
+              LPDWORD lpcMaxValueLen,
+              LPDWORD lpcbSecurityDescriptor,
+              PFILETIME lpftLastWriteTime)"
+
+  API.defun "RegDeleteValue(HKEY hKey, LPCWSTR lpValueName)"
+  API.defun "RegDeleteKey(HKEY hKey, LPCWSTR lpSubKey)"
+  API.defun "RegCloseKey(HKEY hKey)"
+  
+  # Provides an interface that allows an application to access the Windows-registry. 
+  # <br>See also <a href="https://docs.microsoft.com/en-us/windows/desktop/sysinfo/windows-system-information">
+  # Windows System Information section of Microsft Docs</a>
+  class Registry
+    include RC
+    
+    HANDLE  = API.defstruct('HANDLE value')
+    LPDWORD = HANDLE
+    LPLONxG = API.defstruct('LONG value')
+    
+    RegRootKey = {
+      'HKEY_CLASSES_ROOT'   => 0x80000000,
+      'HKEY_CURRENT_USER'   => 0x80000001,
+      'HKEY_LOCAL_MACHINE'  => 0x80000002,
+      'HKEY_USERS'          => 0x80000003,
+      'HKEY_CURRENT_CONFIG' => 0x80000005,
+      'HKCR'   => 0x80000000,
+      'HKCU'   => 0x80000001,
+      'HKLM'   => 0x80000002,
+    }
+    
+    RegAccessMask = {
+      'r' => KEY_READ,
+      'w' => KEY_WRITE,
+      'rw' => KEY_READ | KEY_WRITE,
+      'wr' => KEY_READ | KEY_WRITE
+    }
+    
+    #
+    def self.split_regpath(regpath)
+      /^(HK.+?)\\(.+)/.match regpath
+      k = $1
+      hkey = RegRootKey[k]
+      raise "Invalid key: #{k}" unless hkey
+      subkey = $2.to_s
+      [hkey, subkey]
+    end
+    #
+    def self.check_hkey(hkey)
+      case hkey
+      when HKEY_CLASSES_ROOT, HKEY_CURRENT_USER, HKEY_LOCAL_MACHINE, HKEY_USERS,
+           HKEY_CURRENT_CONFIG
+        return
+      else
+        raise "illegal handle of HKEY 0x#{hkey.to_s(16)}" 
+      end
+    end
+  
+    # self.open(regpath, regmask='r')
+    def self.open(*args)
+      raise "wrong number of arguments (#{args.size})" if args.size > 3 || args.size == 0
+      if args[0].is_a? Integer
+        hkey, subkey, regmask = args
+        check_hkey(hkey)
+      elsif args[0].is_a? String
+        hkey, subkey = split_regpath(args[0].tr('/', '\\'))
+        regmask = args[1]
+      end
+      reg = self.new(hkey, subkey, regmask || 'r')
+      reg.openkey
+      begin
+        yield reg
+      ensure
+        reg.closekey
+        reg = nil
+        GC.start
+      end
+    end
+  
+    # self.create(regpath, regmask='r', option=REG_OPTION_NON_VOLATILE)
+    def self.create(*args)
+      raise "wrong number of arguments (#{args.size})" if args.size > 4 || args.size == 0
+      if args[0].is_a? Integer
+        hkey, subkey, regmask, option = args
+        check_hkey(hkey)
+      elsif args[0].is_a? String
+        hkey, subkey = split_regpath(args[0].tr('/', '\\'))
+        case args[1]
+        when REG_OPTION_NON_VOLATILE, REG_OPTION_VOLATILE
+          regmask = 'r'
+        else
+          regmask = args[1]
+          option = args[2]
+        end
+      end
+      reg = self.new(hkey, subkey, regmask || 'r')
+      reg.createkey(option)
+      begin
+        yield reg
+      ensure
+        reg.closekey
+        reg = nil
+        GC.start
+      end
+    end
+  
+    attr_reader :created_new_key, :option, :hkey, :subkey, :access_mask
+  
+    def initialize(hkey, subkey, regmask)
+      @access_mask = RegAccessMask[regmask]
+      raise "Invalid operation type: \"#{regmask}\"" unless @access_mask
+      @hkey = hkey
+      @subkey = subkey.tr('/', '\\')
+      @access_handle = nil
+      @created_new_key = nil
+    end
+  
+    def openkey()
+      haccess = HANDLE.new
+      check_err API.RegOpenKeyEx(@hkey, @subkey, nil, @access_mask, haccess)
+      @access_handle = haccess.value
+    end
+    
+    def createkey(option = REG_OPTION_NON_VOLATILE)
+      haccess = HANDLE.new
+      lpdispositon = LPDWORD.new
+      check_err API.RegCreateKeyEx(@hkey, @subkey, nil, nil, option, @access_mask, 
+                                   nil, haccess, lpdispositon)
+      @access_handle = haccess.value
+      @created_new_key = lpdispositon.value == REG_CREATED_NEW_KEY ? true : nil
+    end
+  
+    def closekey()
+#      check_err API.RegCloseKey(@hkey)
+      API.RegCloseKey(@hkey)
+    end
+    
+    
+    
+    def read(regentry=nil)
+      lptype = LPDWORD.new
+      lpcbData = LPDWORD.new
+      r = API.RegQueryValueEx(@access_handle, regentry, nil, lptype, nil, lpcbData)
+      return nil unless r==0
+      regtype = lptype.value
+      bufflen = lpcbData.value
+      case regtype
+      when REG_SZ, REG_EXPAND_SZ
+        buff = TCHAR[bufflen]
+        check_err API.RegQueryValueEx(@access_handle, regentry, nil, lptype, buff, lpcbData)
+        buff.to_s
+      when REG_BINARY
+        buff = BYTE[bufflen]
+        check_err API.RegQueryValueEx(@access_handle, regentry, nil, lptype, buff, lpcbData)
+        buff
+      when REG_DWORD
+        buff = LPDWORD.new
+        check_err API.RegQueryValueEx(@access_handle, regentry, nil, lptype, buff, lpcbData)
+        buff.value
+      when REG_MULTI_SZ
+        buff = TCHAR[bufflen]
+        check_err API.RegQueryValueEx(@access_handle, regentry, nil, lptype, buff, lpcbData)
+        buff.to_s.split("\0")
+      when REG_QWORD
+        buff = TCHAR[bufflen]
+        check_err API.RegQueryValueEx(@access_handle, regentry, nil, lptype, buff, lpcbData)
+        buff.unpack('Q')[0]
+      else
+        raise "Unretrevable type : #{regtype}"
+      end
+    end
+    
+    def [](regentry) read(regentry); end
+  
+    def write(regentry, data, regtype = nil)
+      if regtype
+        case regtype
+        when REG_SZ
+          write_sz(regentry, data)
+        when REG_EXPAND_SZ
+          write_sz(regentry, data, regtyep)
+        when REG_BINARY
+          write_binary(regentry, data)
+        when REG_DWORD
+          write_dword(regentry, data)
+        when REG_MULTI_SZ
+          write_multi(regentry, data)
+        when REG_QWORD
+          write_qword(regentry, data)
+        else
+          raise "illegal data type: #{regtype}"
+        end
+      else
+        if data.is_a? Integer
+          if data & 0xffffffff00000000 > 0
+            write_qword(regentry, data)
+          else
+            write_dword(regentry, data)
+          end
+        elsif data.is_a? Array
+          write_multi(regentry, data)
+        else
+          write_sz(regentry, data)
+        end
+      end
+    end
+  
+    def []=(regentry, data) 
+      write(regentry, data); 
+    end
+  
+    def delete_value(regentry)
+      check_err API.RegDeleteValue(@access_handle, regentry)
+    end
+    alias delete delete_value
+  
+    def delete_key(keyname)
+      check_err 5 if @access_mask == KEY_READ
+      check_err API.RegDeleteKey(@access_handle, keyname)
+    end
+  
+    def each_values
+      csubkeys, cmaxsubkeylen, cvalues, cmaxvaluenamelen, cmaxvaluelen = self.info
+      ar = []
+      lpValueName = TCHAR[cmaxvaluenamelen]
+      lpDataf = TCHAR[cmaxvaluelen]
+      lpType = LPDWORD.new
+      cvalues.tmes{|idx|
+        check_err RegEnumValue(@access_handle, idx, lpValueName, cmaxvaluenamelen,
+                             nil, lpType, lpData, cmaxvaluelen)
+        yield()
+      }
+    end
+  
+    def each_keys
+      csubkeys, cmaxsubkeylen, cvalues, cmaxvaluenamelen, cmaxvaluelen = self.info
+      p [csubkeys, cmaxsubkeylen, cvalues, cmaxvaluenamelen, cmaxvaluelen]
+    end
+  
+    def info()
+      lpcSubKeys = LPDWORD.new
+      lpcMaxSubKeyLen = LPDWORD.new
+      lpcValues = LPDWORD.new
+      lpcMaxValueNameLen = LPDWORD.new
+      lpcMaxValueLen= LPDWORD.new
+      check_err API.RegQueryInfoKey(@access_handle, nil, nil, nil, lpcSubKeys,
+                              lpcMaxSubKeyLen, nil, lpcValues,
+                              lpcMaxValueNameLen, lpcMaxValueLen, nil, nil)
+      [lpcSubKeys.value, lpcMaxSubKeyLen.value, lpcValues.value, 
+                       lpcMaxValueNameLen.value, lpcMaxValueLen.value]
+    end
+  
+    private 
+  
+    def write_sz(regentry, data, regtype = REG_SZ)
+      lpdata = API.encode_internal(data)
+      check_err API.RegSetValueEx(@access_handle, regentry, nil, regtype, lpdata, 
+                                  lpdata.bytesize)
+    end
+  
+    def write_binary(regentry, data)
+      lpdata = API.encoding2bin(data)
+      check_err API.RegSetValueEx(@access_handle, regentry, nil, REG_BINARY, 
+                                  lpdata, lpdata.bytesize)
+    end
+  
+    def write_dword(regentry, data)
+      lpdata = LPDWORD.new
+      lpdata.value = data
+      check_err API.RegSetValueEx(@access_handle, regentry, nil, REG_DWORD, lpdata, 4)
+    end
+  
+    def write_multi(regentry, data)
+      lpdata = API.encode_internal(data.join("\0"))
+      check_err API.RegSetValueEx(@access_handle, regentry, nil, REG_MULTI_SZ, lpdata, lpdata.bytesize)
+    end
+  
+    def write_qword(regentry, data)
+      lpdata = API.defstruct("ULONG[2]").new
+      lpdata[0] = data & 0xffffffff
+      lpdata[1] = data >> 32
+      check_err API.RegSetValueEx(@access_handle, regentry, nil, REG_QWORD, lpdata, 8)
+    end
+  
+    def check_err(err)
+      return if err == 0
+      raise RuntimeError, API.lasterror
+    end
+  end
+end
+
+#__END__
+################### testing ###################
+module WR
+  r = Registry.create('HKCU/Software/YSLab/mytest2','wr'){|reg|
+    reg.delete("mytestStr")
+    reg["mytestStr"] ||= "46.06"
+  }
+  
+#  Registry.open('HKCU/Software/YSLab/mytest2', 'wr'){|reg|
+#    p reg.created_new_key
+    #p reg.read("mytestArray")
+#    reg.write("mytestArray",["string1", "string2", "string3","string4", "1234"])
+#    reg.write("mytestStr", "46.03")
+#    reg.delete("mytestArray")
+#    reg.each_keys{|k| p k}
+#  } if false
+#  
+#  Registry.open('HKCU\\Software\\yslab','w'){|reg|
+#    reg.delete_key('mytest2')
+#  }
+end if  __FILE__ == $0
+

data/lib/wrb/components/richedit.rb

@@ -0,0 +1,1181 @@
+module WR
+  require_relative './edit' unless defined?(Edit)
+  
+  module RC
+    ES_SAVESEL          = 0x00008000
+    ES_SUNKEN           = 0x00004000
+    ES_DISABLENOSCROLL  = 0x00002000
+    ES_SELECTIONBAR     = 0x01000000
+    ES_NOOLEDRAGDROP    = 0x00000008
+    ES_EX_NOCALLOLEINIT = 0x00000000
+    ES_VERTICAL         = 0x00400000
+    ES_NOIME            = 0x00080000
+    ES_SELFIME          = 0x00040000
+    
+#  EM_GETLIMITTEXT = WM_USER+37
+#  EM_POSFROMCHAR  = WM_USER+38 
+#  EM_CHARFROMPOS  = WM_USER+39
+#  EM_SCROLLCARET  = WM_USER+49
+    
+    EM_CANPASTE           = WM_USER+50
+    EM_DISPLAYBAND        = WM_USER+51
+    EM_EXGETSEL           = WM_USER+52
+    EM_EXLIMITTEXT        = WM_USER+53
+    EM_EXLINEFROMCHAR     = WM_USER+54
+    EM_EXSETSEL           = WM_USER+55
+    EM_FINDTEXT           = WM_USER+56
+    EM_FORMATRANGE        = WM_USER+57
+    EM_GETCHARFORMAT      = WM_USER+58
+    EM_GETEVENTMASK       = WM_USER+59
+    EM_GETOLEINTERFACE    = WM_USER+60
+    EM_GETPARAFORMAT      = WM_USER+61
+    EM_GETSELTEXT         = WM_USER+62
+    EM_HIDESELECTION      = WM_USER+63
+    EM_PASTESPECIAL       = WM_USER+64
+    EM_REQUESTRESIZE      = WM_USER+65
+    EM_SELECTIONTYPE      = WM_USER+66
+    EM_SETBKGNDCOLOR      = WM_USER+67
+    EM_SETCHARFORMAT      = WM_USER+68
+    EM_SETEVENTMASK       = WM_USER+69
+    EM_SETOLECALLBACK     = WM_USER+70
+    EM_SETPARAFORMAT      = WM_USER+71
+    EM_SETTARGETDEVICE    = WM_USER+72
+    EM_STREAMIN           = WM_USER+73
+    EM_STREAMOUT          = WM_USER+74
+    EM_GETTEXTRANGE       = WM_USER+75
+    EM_FINDWORDBREAK      = WM_USER+76
+    EM_SETOPTIONS         = WM_USER+77
+    EM_GETOPTIONS         = WM_USER+78
+    EM_FINDTEXTEX         = WM_USER+79
+    EM_GETWORDBREAKPROCEX = WM_USER+80
+    EM_SETWORDBREAKPROCEX = WM_USER+81
+    EM_SETUNDOLIMIT       = WM_USER+82
+    EM_REDO               = WM_USER+84
+    EM_CANREDO            = WM_USER+85
+    EM_GETUNDONAME        = WM_USER+86
+    EM_GETREDONAME        = WM_USER+87
+    EM_STOPGROUPTYPING    = WM_USER+88
+    EM_SETTEXTMODE        = WM_USER+89
+    EM_GETTEXTMODE        = WM_USER+90
+    EM_AUTOURLDETECT      = WM_USER+91
+    EM_GETAUTOURLDETECT   = WM_USER+92
+    EM_SETPALETTE         = WM_USER+93
+    EM_GETTEXTEX          = WM_USER+94
+    EM_GETTEXTLENGTHEX    = WM_USER+95
+    EM_SHOWSCROLLBAR      = WM_USER+96
+    EM_SETTEXTEX          = WM_USER+97
+
+    EM_SETPUNCTUATION     = WM_USER+100
+    EM_GETPUNCTUATION     = WM_USER+101
+    EM_SETWORDWRAPMODE    = WM_USER+102
+    EM_GETWORDWRAPMODE    = WM_USER+103
+    EM_SETIMECOLOR        = WM_USER+104
+    EM_GETIMECOLOR        = WM_USER+105
+    EM_SETIMEOPTIONS      = WM_USER+106
+    EM_GETIMEOPTIONS      = WM_USER+107
+    EM_CONVPOSITION       = WM_USER+108
+    EM_SETLANGOPTIONS     = WM_USER+120
+    EM_GETLANGOPTIONS     = WM_USER+121
+    EM_GETIMECOMPMODE     = WM_USER+122
+    EM_FINDTEXTW          = WM_USER+123
+    EM_FINDTEXTEXW        = WM_USER+124
+    EM_RECONVERSION       = WM_USER+125
+    EM_SETIMEMODEBIAS     = WM_USER+126
+    EM_GETIMEMODEBIAS     = WM_USER+127
+
+    EM_SETBIDIOPTIONS       = WM_USER+200
+    EM_GETBIDIOPTIONS       = WM_USER+201
+    EM_SETTYPOGRAPHYOPTIONS = WM_USER+202
+    EM_GETTYPOGRAPHYOPTIONS = WM_USER+203
+    EM_SETEDITSTYLE         = WM_USER+204
+    EM_GETEDITSTYLE         = WM_USER+205
+
+    EM_OUTLINE          = WM_USER+220
+
+    EM_GETSCROLLPOS     = WM_USER+221
+    EM_SETSCROLLPOS     = WM_USER+222
+
+    EM_SETFONTSIZE      = WM_USER+223
+    EM_GETZOOM          = WM_USER+224
+    EM_SETZOOM          = WM_USER+225
+    EM_GETVIEWKIND      = WM_USER+226
+    EM_SETVIEWKIND      = WM_USER+227
+
+    EM_GETPAGE          = WM_USER+228
+    EM_SETPAGE          = WM_USER+229
+    EM_GETHYPHENATEINFO = WM_USER+230
+    EM_SETHYPHENATEINFO = WM_USER+231
+    EM_GETPAGEROTATE    = WM_USER+235
+    EM_SETPAGEROTATE    = WM_USER+236
+    EM_GETCTFMODEBIAS   = WM_USER+237
+    EM_SETCTFMODEBIAS   = WM_USER+238
+    EM_GETCTFOPENSTATUS = WM_USER+240
+    EM_SETCTFOPENSTATUS = WM_USER+241
+    EM_GETIMECOMPTEXT   = WM_USER+242
+    EM_ISIME            = WM_USER+243
+    EM_GETIMEPROPERTY   = WM_USER+244
+
+    EM_GETQUERYRTFOBJ = WM_USER+269
+    EM_SETQUERYRTFOBJ = WM_USER+270
+
+    EN_MSGFILTER         = 0x0700
+    EN_REQUESTRESIZE     = 0x0701
+    EN_SELCHANGE         = 0x0702
+    EN_DROPFILES         = 0x0703
+    EN_PROTECTED         = 0x0704
+    EN_CORRECTTEXT       = 0x0705
+    EN_STOPNOUNDO        = 0x0706
+    EN_IMECHANGE         = 0x0707
+    EN_SAVECLIPBOARD     = 0x0708
+    EN_OLEOPFAILED       = 0x0709
+    EN_OBJECTPOSITIONS   = 0x070a
+    EN_LINK              = 0x070b
+    EN_DRAGDROPDONE      = 0x070c
+    EN_PARAGRAPHEXPANDED = 0x070d
+    EN_PAGECHANGE        = 0x070e
+    EN_LOWFIRTF          = 0x070f
+    EN_ALIGNLTR          = 0x0710
+    EN_ALIGNRTL          = 0x0711
+
+    ENM_NONE              = 0x00000000
+    ENM_CHANGE            = 0x00000001
+    ENM_UPDATE            = 0x00000002
+    ENM_SCROLL            = 0x00000004
+    ENM_SCROLLEVENTS      = 0x00000008
+    ENM_DRAGDROPDONE      = 0x00000010
+    ENM_PARAGRAPHEXPANDED = 0x00000020
+    ENM_PAGECHANGE        = 0x00000040
+    ENM_KEYEVENTS         = 0x00010000
+    ENM_MOUSEEVENTS       = 0x00020000
+    ENM_REQUESTRESIZE     = 0x00040000
+    ENM_SELCHANGE         = 0x00080000
+    ENM_DROPFILES         = 0x00100000
+    ENM_PROTECTED         = 0x00200000
+    ENM_CORRECTTEXT       = 0x00400000
+    ENM_IMECHANGE         = 0x00800000
+    ENM_LANGCHANGE        = 0x01000000
+    ENM_OBJECTPOSITIONS   = 0x02000000
+    ENM_LINK              = 0x04000000
+    ENM_LOWFIRTF          = 0x08000000
+    
+    SES_EMULATESYSEDIT     = 0x1
+    SES_BEEPONMAXTEXT      = 0x2
+    SES_EXTENDBACKCOLOR    = 0x4
+    SES_MAPCPS             = 0x8
+    SES_EMULATE10          = 0x10
+    SES_USECRLF            = 0x20
+    SES_USEAIMM            = 0x40
+    SES_NOIME              = 0x80
+    SES_ALLOWBEEPS         = 0x100
+    SES_UPPERCASE          = 0x200
+    SES_LOWERCASE          = 0x400
+    SES_NOINPUTSEQUENCECHK = 0x800
+    SES_BIDI               = 0x1000
+    SES_SCROLLONKILLFOCUS  = 0x2000
+    SES_XLTCRCRLFTOCR      = 0x4000
+    SES_DRAFTMODE          = 0x8000
+    SES_USECTF             = 0x10000
+    SES_HIDEGRIDLINES      = 0x20000
+    SES_USEATFONT          = 0x40000
+    SES_CUSTOMLOOK         = 0x80000
+    SES_LBSCROLLNOTIFY     = 0x100000
+    SES_CTFALLOWEMBED      = 0x200000
+    SES_CTFALLOWSMARTTAG   = 0x400000
+    SES_CTFALLOWPROOFING   = 0x800000
+
+    IMF_AUTOKEYBOARD       = 0x0001
+    IMF_AUTOFONT           = 0x0002
+    IMF_IMECANCELCOMPLETE  = 0x0004
+    IMF_IMEALWAYSSENDNOTIFY= 0x0008
+    IMF_AUTOFONTSIZEADJUST = 0x0010
+    IMF_UIFONTS            = 0x0020
+    IMF_DUALFONT           = 0x0080
+
+    ICM_NOTOPEN    = 0x0000
+    ICM_LEVEL3     = 0x0001
+    ICM_LEVEL2     = 0x0002
+    ICM_LEVEL2_5   = 0x0003
+    ICM_LEVEL2_SUI = 0x0004
+    ICM_CTF        = 0x0005
+    
+    TM_PLAINTEXT       = 1
+    TM_RICHTEXT        = 2
+    TM_SINGLELEVELUNDO = 4
+    TM_MULTILEVELUNDO  = 8
+    TM_SINGLECODEPAGE  = 16
+    TM_MULTICODEPAGE   = 32
+    
+    CFM_BOLD          = 0x00000001
+    CFM_ITALIC        = 0x00000002
+    CFM_UNDERLINE     = 0x00000004
+    CFM_STRIKEOUT     = 0x00000008
+    CFM_PROTECTED     = 0x00000010
+    CFM_LINK          = 0x00000020
+    CFM_SIZE          = 0x80000000
+    CFM_COLOR         = 0x40000000
+    CFM_FACE          = 0x20000000
+    CFM_OFFSET        = 0x10000000
+    CFM_CHARSET       = 0x08000000
+    
+    CFM_SMALLCAPS     = 0x00000040
+    CFM_ALLCAPS       = 0x00000080
+    CFM_HIDDEN        = 0x00000100
+    CFM_OUTLINE       = 0x00000200
+    CFM_SHADOW        = 0x00000400
+    CFM_EMBOSS        = 0x00000800
+    CFM_IMPRINT       = 0x00001000
+    CFM_DISABLED      = 0x00002000
+    CFM_REVISED       = 0x00004000
+
+    CFM_BACKCOLOR     = 0x04000000
+    CFM_LCID          = 0x02000000
+    CFM_UNDERLINETYPE = 0x00800000
+    CFM_WEIGHT        = 0x00400000
+    CFM_SPACING       = 0x00200000
+    CFM_KERNING       = 0x00100000
+    CFM_STYLE         = 0x00080000
+    CFM_ANIMATION     = 0x00040000
+    CFM_REVAUTHOR     = 0x00008000
+    
+    CFE_BOLD          = 0x00000001
+    CFE_ITALIC        = 0x00000002
+    CFE_UNDERLINE     = 0x00000004
+    CFE_STRIKEOUT     = 0x00000008
+    CFE_PROTECTED     = 0x00000010
+    CFE_LINK          = 0x00000020
+    CFE_AUTOCOLOR     = 0x40000000
+    CFE_SMALLCAPS     = CFM_SMALLCAPS
+    CFE_ALLCAPS       = CFM_ALLCAPS
+    CFE_HIDDEN        = CFM_HIDDEN
+    CFE_OUTLINE       = CFM_OUTLINE
+    CFE_SHADOW        = CFM_SHADOW
+    CFE_EMBOSS        = CFM_EMBOSS
+    CFE_IMPRINT       = CFM_IMPRINT
+    CFE_DISABLED      = CFM_DISABLED
+    CFE_REVISED       = CFM_REVISED
+    
+    CFE_SUBSCRIPT     = 0x00010000
+    CFE_SUPERSCRIPT   = 0x00020000
+    CFE_AUTOBACKCOLOR = CFM_BACKCOLOR
+    
+    CFM_SUBSCRIPT     = CFE_SUBSCRIPT | CFE_SUPERSCRIPT
+    CFM_SUPERSCRIPT   = CFM_SUBSCRIPT
+    
+    CFM_EFFECTS = CFM_BOLD | CFM_ITALIC | CFM_UNDERLINE | CFM_STRIKEOUT | CFM_PROTECTED | CFM_LINK
+    CFM_ALL = CFM_EFFECTS | CFM_SIZE | CFM_FACE | CFM_OFFSET | CFM_CHARSET
+    CFM_EFFECTS2 = CFM_EFFECTS | CFM_DISABLED | CFM_SMALLCAPS | CFM_ALLCAPS | CFM_HIDDEN |
+                   CFM_OUTLINE | CFM_SHADOW | CFM_EMBOSS | CFM_IMPRINT | CFM_DISABLED |
+                   CFM_REVISED | CFM_SUBSCRIPT | CFM_SUPERSCRIPT | CFM_BACKCOLOR
+    CFM_ALL2 = CFM_ALL | CFM_EFFECTS2 | CFM_BACKCOLOR | CFM_LCID | CFM_UNDERLINETYPE |
+               CFM_WEIGHT | CFM_REVAUTHOR | CFM_SPACING | CFM_KERNING | CFM_STYLE | CFM_ANIMATION
+    
+    CFU_UNDERLINENONE            = 0
+    CFU_UNDERLINE                = 1
+    CFU_UNDERLINEWORD            = 2
+    CFU_UNDERLINEDOUBLE          = 3
+    CFU_UNDERLINEDOTTED          = 4
+    CFU_UNDERLINEDASH            = 5
+    CFU_UNDERLINEDASHDOT         = 6
+    CFU_UNDERLINEDASHDOTDOT      = 7
+    CFU_UNDERLINEWAVE            = 8
+    CFU_UNDERLINETHICK           = 9
+    CFU_UNDERLINEHAIRLINE        = 10
+    CFU_UNDERLINEDOUBLEWAVE      = 11
+    CFU_UNDERLINEHEAVYWAVE       = 12
+    CFU_UNDERLINELONGDASH        = 13
+    CFU_UNDERLINETHICKDASH       = 14
+    CFU_UNDERLINETHICKDASHDOT    = 15
+    CFU_UNDERLINETHICKDASHDOTDOT = 16
+    CFU_UNDERLINETHICKDOTTED     = 17
+    CFU_UNDERLINETHICKLONGDASH   = 18
+    CFU_INVERT                   = 0xFE
+    CFU_CF1UNDERLINE             = 0xFF
+
+    yHeightCharPtsMost = 1638
+    
+    SCF_SELECTION      = 0x0001
+    SCF_WORD           = 0x0002
+    SCF_DEFAULT        = 0x0000
+    SCF_ALL            = 0x0004     # not valid with SCF_SELECTION or SCF_WORD
+    SCF_USEUIRULES     = 0x0008
+    SCF_ASSOCIATEFONT  = 0x0010
+    SCF_NOKBUPDATE     = 0x0020
+    SCF_ASSOCIATEFONT2 = 0x0040
+
+    PFA_LEFT             = 1
+    PFA_RIGHT            = 2
+    PFA_CENTER           = 3
+    PFA_JUSTIFY          = 4
+    PFA_FULL_INTERWORD   = 4
+    PFA_FULL_INTERLETTER = 5
+    PFA_FULL_SCALED      = 6
+    PFA_FULL_GLYPHS      = 7
+    PFA_SNAP_GRID        = 8
+    
+    PFM_STARTINDENT       = 0x00000001
+    PFM_RIGHTINDENT       = 0x00000002
+    PFM_OFFSET            = 0x00000004
+    PFM_ALIGNMENT         = 0x00000008
+    PFM_TABSTOPS          = 0x00000010
+    PFM_NUMBERING         = 0x00000020
+    PFM_OFFSETINDENT      = 0x80000000
+    
+    PFM_SPACEBEFORE       = 0x00000040
+    PFM_SPACEAFTER        = 0x00000080
+    PFM_LINESPACING       = 0x00000100
+    PFM_STYLE             = 0x00000400
+    PFM_BORDER            = 0x00000800
+    PFM_SHADING           = 0x00001000
+    PFM_NUMBERINGSTYLE    = 0x00002000
+    PFM_NUMBERINGTAB      = 0x00004000
+    PFM_NUMBERINGSTART    = 0x00008000
+
+    PFM_RTLPARA           = 0x00010000
+    PFM_KEEP              = 0x00020000
+    PFM_KEEPNEXT          = 0x00040000
+    PFM_PAGEBREAKBEFORE   = 0x00080000
+    PFM_NOLINENUMBER      = 0x00100000
+    PFM_NOWIDOWCONTROL    = 0x00200000
+    PFM_DONOTHYPHEN       = 0x00400000
+    PFM_SIDEBYSIDE        = 0x00800000
+    PFM_TABLE             = 0x40000000
+    PFM_TEXTWRAPPINGBREAK = 0x20000000
+    PFM_TABLEROWDELIMITER = 0x10000000
+
+    PFM_COLLAPSED         = 0x01000000
+    PFM_OUTLINELEVEL      = 0x02000000
+    PFM_BOX               = 0x04000000
+    PFM_RESERVED2         = 0x08000000
+    
+    SF_TEXT           = 0x0001
+    SF_RTF            = 0x0002
+    SF_RTFNOOBJS      = 0x0003
+    SF_TEXTIZED       = 0x0004
+    SF_UNICODE        = 0x0010
+    SF_USECODEPAGE    = 0x0020
+    SF_NCRFORNONASCII = 0x0040
+
+    ST_DEFAULT = 0
+    ST_KEEPUNDO = 1
+    ST_SELECTION = 2
+    ST_NEWCHARS = 4
+
+    GT_DEFAULT = 0
+    GT_USECRLF = 1
+    GT_SELECTION = 2
+    GT_RAWTEXT = 4
+    GT_NOHIDDENTEXT = 8
+
+    GTL_DEFAULT = 0
+    GTL_USECRLF = 1
+    GTL_PRECISE = 2
+    GTL_CLOSE = 4
+    GTL_NUMCHARS = 8
+    GTL_NUMBYTES = 16
+    
+    UID_UNKNOWN = 0
+    UID_TYPING = 1
+    UID_DELETE = 2
+    UID_DRAGDROP = 3
+    UID_CUT = 4
+    UID_PASTE = 5
+    UID_AUTOCORRECT = 6
+    
+    WBF_WORDWRAP = 0x010
+    WBF_WORDBREAK = 0x020
+    WBF_OVERFLOW = 0x040
+    WBF_LEVEL1 = 0x080
+    WBF_LEVEL2 = 0x100
+    WBF_CUSTOM = 0x200
+    
+    CREATE_ALWAYS = 2
+    OPEN_EXISTING = 3
+    GENERIC_READ  = 0x80000000
+    GENERIC_WRITE = 0x40000000
+    FILE_ATTRIBUTE_NORMAL   = 0x00000080
+    FILE_FLAG_WRITE_THROUGH = 0x80000000
+    
+  end
+  
+  # This control enables the user to enter, edit, print, and save text.
+  # The text can be assigned character and paragraph formatting.
+  # <br>See also <a href="https://docs.microsoft.com/en-us/windows/desktop/Controls/
+  #window-controls"> Windows Control section of Microsoft Docs.</a>
+  class Richedit < Edit
+#    API.loadlib 'riched20.dll'
+    API.loadlib 'MsftEdit.dll'
+  
+    RICHEDIT_CLASSA = "RichEdit20A"
+    RICHEDIT_CLASSW = "RichEdit50W"
+    RICHEDIT_CLASS  = RWin::UNICODE ? RICHEDIT_CLASSW : RICHEDIT_CLASSA
+    
+    MAX_TAB_STOPS     = 32
+    DEFAULT_TABSPACES = 4
+    DEFAULTTABS = (1..MAX_TAB_STOPS).inject([]){|r, i| r << i*DEFAULT_TABSPACES}
+    
+    API::TypeAliases['LCID'] = 'U'
+    CHARFORMAT = API.defstruct "
+      UINT cbSize;
+      DWORD dwMask;
+      DWORD dwEffects;
+      LONG yHeight;
+      LONG yOffset;
+      COLORREF crTextColor;
+      BYTE bCharSet;
+      BYTE bPitchAndFamily;
+      TCHAR szFaceName[#{LF_FACESIZE}];"
+      
+    CHARFORMAT2 = API.defstruct "
+      UINT cbSize;
+      DWORD dwMask;
+      DWORD dwEffects;
+      LONG yHeight;
+      LONG yOffset;
+      COLORREF crTextColor;
+      BYTE bCharSet;
+      BYTE bPitchAndFamily;
+      TCHAR szFaceName[#{LF_FACESIZE}];
+      WORD wWeight;
+      SHORT sSpacing;
+      COLORREF crBackColor;
+      LCID lcid;
+      DWORD dwReserved;
+      SHORT sStyle;
+      WORD wKerning;
+      BYTE bUnderlineType;
+      BYTE bAnimation;
+      BYTE bRevAuthor;
+      BYTE bReserved1;"
+    
+    PARAFORMAT = API.defstruct "
+      UINT cbSize;
+      DWORD dwMask;
+      WORD wNumbering;
+      WORD wReserved;
+      LONG dxStartIndent;
+      LONG dxRightIndent;
+      LONG dxOffset;
+      WORD wAlignment;
+      SHORT cTabCount;
+      LONG rgxTabs[#{MAX_TAB_STOPS}];"
+      
+    PARAFORMAT2 = API.defstruct "
+      UINT cbSize;
+      DWORD dwMask;
+      WORD wNumbering;
+      WORD wReserved;
+      LONG dxStartIndent;
+      LONG dxRightIndent;
+      LONG dxOffset;
+      WORD wAlignment;
+      SHORT cTabCount;
+      LONG rgxTabs[#{MAX_TAB_STOPS}];
+      LONG dySpaceBefore;
+      LONG dySpaceAfter;
+      LONG dyLineSpacing;
+      SHORT sStyle;
+      BYTE bLineSpacingRule;
+      BYTE bOutlineLevel;
+      WORD wShadingWeight;
+      WORD wShadingStyle;
+      WORD wNumberingStart;
+      WORD wNumberingStyle;
+      WORD wNumberingTab;
+      WORD wBorderSpace;
+      WORD wBorderWidth;
+      WORD wBorders;"
+    
+    CHARRANGE = API.defstruct "
+      LONG cpMin;
+      LONG cpMax;"
+
+    TEXTRANGE = API.defstruct "
+      CHARRANGE chrg;
+      LPTSTR lpstrText"
+    
+    FINDTEXT = API.defstruct "
+      CHARRANGE chrg;
+      LPTSTR lpstrText;"
+    
+    FINDTEXTEX = API.defstruct "
+      CHARRANGE chrg;
+      LPCTSTR lpstrText;
+      CHARRANGE chrgText;"
+    
+    FORMATRANGE = API.defstruct "
+      HDC hdc;
+      HDC hdcTarget;
+      RECT rc;
+      RECT rcPage;
+      CHARRANGE chrg;"
+    
+    MSGFILTER = API.defstruct "
+      NMHDR nmhdr;
+      UINT msg;
+      WPARAM wParam;
+      LPARAM lParam;"
+    
+    REQRESIZE = API.defstruct "
+      NMHDR nmhdr;
+      RECT  rc;"
+    
+    SELCHANGE = API.defstruct "
+      NMHDR nmhdr;
+      CHARRANGE chrg;
+      WORD seltyp;"
+    
+    ENDROPFILES = API.defstruct "
+      NMHDR nmhdr;
+      HANDLE hDrop;
+      LONG cp;
+      BOOL fProtected;"
+    
+    ENPROTECTED = API.defstruct "
+      NMHDR     nmhdr;
+      UINT      msg;
+      WPARAM    wParam;
+      LPARAM    lParam;
+      CHARRANGE chrg;"
+    
+    ENCORRECTTEXT = API.defstruct "
+      NMHDR     nmhdr;
+      CHARRANGE chrg;
+      WORD      seltyp;"
+    
+    ENSAVECLIPBOARD = API.defstruct "
+      NMHDR nmhdr;
+      LONG  cObjectCount;
+      LONG  cch;"
+    
+    API.typealias('HRESULT', 'HANDLE')
+    ENOLEOPFAILED = API.defstruct "
+      NMHDR   nmhdr;
+      LONG    iob;
+      LONG    lOper;
+      HRESULT hr;"
+      
+    OBJECTPOSITIONS = API.defstruct "
+      NMHDR nmhdr;
+      LONG  cObjectCount;
+      LONG  *pcpPositions;"
+    
+    ENLINK = API.defstruct "
+      NMHDR     nmhdr;
+      UINT      msg;
+      WPARAM    wParam;
+      LPARAM    lParam;
+      CHARRANGE chrg;"
+    
+    ENLOWFIRTF = API.defstruct "
+      NMHDR nmhdr;
+      CHAR  *szControl;"
+
+    API.typealias('EDITSTREAMCALLBACK', 'ULONG')
+    EDITSTREAM = API.defstruct "
+      DWORD dwCookie;
+      DWORD dwError; 
+      EDITSTREAMCALLBACK pfnCallback;"
+    
+    SETTEXTEX = API.defstruct "
+      DWORD flags;
+      UINT codepage;"
+    
+    GETTEXTEX = API.defstruct "
+      DWORD cb;
+      DWORD flags;
+      UINT codepage;
+      LPCSTR lpDefaultChar;
+      int *lpUsedDefChar;"
+
+    GETTEXTLENGTHEX = API.defstruct "
+      DWORD flags;
+      UINT codepage;"
+    
+    CN_GENERIC = 0
+    CN_TEXTCHANGED = 1
+    CN_NEWUNDO = 2
+    CN_NEWREDO = 4
+
+    CHANGENOTIFY = API.defstruct "
+      DWORD dwChangeType;
+      void *pvCookieData;"
+    
+    CFEffects = {
+      :bold      => CFE_BOLD, 
+      :italic    => CFE_ITALIC, 
+      :underline => CFE_UNDERLINE,
+      :strikeout => CFE_STRIKEOUT,
+      :protected => CFE_PROTECTED,
+      :link      => CFE_LINK
+    }
+    
+    PFAlignments = {
+      :left             => PFA_LEFT,
+      :center           => PFA_CENTER,
+      :right            => PFA_RIGHT,
+      :justify          => PFA_JUSTIFY,
+      :full_interword   => PFA_FULL_INTERWORD,
+      :full_interletter => PFA_FULL_INTERLETTER,
+      :full_scaled      => PFA_FULL_SCALED,
+      :full_glyphs      => PFA_FULL_GLYPHS,
+      :snap_grid        => PFA_SNAP_GRID
+    }
+    
+    class Effects
+      def initialize(*args)
+        args = args[0] if args[0].is_a?(Array)
+        @effects = 0
+        args.each{|i| @effects |= i.is_a?(Symbol) ? CFEffects[arg].to_i : i.to_i}
+      end
+      
+      def |(arg)
+        @effects |= arg.is_a?(Symbol) ? CFEffects[arg].to_i : arg.to_i
+        self
+      end
+      
+      def &(arg)
+        @effects &= arg.is_a?(Symbol) ? CFEffects[arg].to_i : arg.to_i
+        self
+      end
+      
+      def to_i()
+        @effects
+      end
+    end
+    
+    class Format # wrapper of CHARFORMAT2, PARAFORMAT2
+      include RC
+      attr_reader :charformat, :paraformat
+
+      def initialize()
+#        @seltype = seltype # SCF_SELECTION, SCF_WORD, SCF_DEFAULT, SCF_ALL ...
+        @charformat = CHARFORMAT2[CHARFORMAT2::Size]
+        @paraformat = PARAFORMAT2[PARAFORMAT2::Size]
+      end
+      
+      ###### charformat ######
+      
+      def facename()
+        @charformat.szFaceName.to_s
+      end
+      def facename=(str)
+        if str.to_s == ''
+          @charformat.dwMask &= ~CFM_FACE
+          @charformat.szFaceName = nil
+        else
+          @charformat.dwMask |= CFM_FACE
+          @charformat.szFaceName = str
+        end
+      end
+      
+      def height()
+        @charformat.yHeight
+      end
+      def height=(h)
+        @charformat.dwMask |= CFM_SIZE
+        @charformat.yHeight = h
+      end
+      
+      def color
+        @charformat.crTextColor
+      end
+      def color=(*args)
+        txtclr, bkclr = args[0]
+        if txtclr
+          @charformat.dwMask |= CFM_COLOR
+          @charformat.crTextColor = txtclr
+          if bkclr
+            @charformat.dwMask |= CFM_BACKCOLOR
+            @charformat.crBackColor = bkclr
+         end
+        else
+          @charformat.dwMask &= ~CFM_COLOR
+          @charformat.dwMask &= ~CFM_BACKCOLOR
+          @charformat.crTextColor = 0
+          @charformat.crBackColor = 0
+        end
+      end
+      
+      def effects()
+        @charformat.dwEffects
+      end
+      def effects=(*args)
+        args = args[0] if args[0].is_a?(Array)
+        effects = 0
+        args.each{|i| effects |= i.is_a?(Symbol) ? CFEffects[i].to_i : i.to_i }
+        if effects == 0
+          @charformat.dwMask |= CFM_EFFECTS
+          @charformat.dwEffects = 0
+        else
+          @charformat.dwMask |= CFM_EFFECTS
+          @charformat.dwEffects = effects
+        end
+      end
+      
+      def style()
+        @charformat.sStyle
+      end
+      def style=(ss)
+        @charformat.dwMask |= CFM_STYLE
+        @charformat.sStyle = ss
+      end
+      
+      ###### paraformat ######
+      
+      def alignment()
+        @paraformat.wAlignment
+      end
+      def alignment=(al)
+        al = PFAlignments[al] if al.is_a?(Symbol)
+        @paraformat.dwMask = PFM_ALIGNMENT
+        @paraformat.wAlignment = al
+      end
+      
+      def tabstops()
+        @paraformat.rgxTabs.to_a
+      end
+      def tabstops=(*args)
+        tabs = args[0] if args[0].is_a?(Array)
+        @paraformat.dwMask = PFM_TABSTOPS
+        @paraformat.rgxTabs = tabs
+      end
+      
+      ##### sets, gets ######
+      
+      def get(owner, mask, seltype=SCF_SELECTION)
+        @charformat.clear(CHARFORMAT2::Size, mask)
+        owner.SendMessage(EM_GETCHARFORMAT, seltype, @charformat)
+        self
+      end
+      def set(owner, seltype=SCF_SELECTION)
+        owner.SendMessage(EM_SETCHARFORMAT, seltype, @charformat) if @charformat.dwMask > 0
+        owner.SendMessage(EM_SETPARAFORMAT, 0, @paraformat) if @paraformat.dwMask > 0
+        @charformat.clear(CHARFORMAT2::Size)
+        @paraformat.clear(PARAFORMAT2::Size)
+      end
+    end
+    
+    class Selection #< Edit::Selection
+      include RC
+      
+      attr_reader :seltype
+      
+      def initialize(onr)
+        @owner = onr
+        @seltype = SCF_SELECTION
+        @format = Format.new()
+      end
+      
+      def seltype=(type)
+        @seltype = type
+      end
+      
+      def format()
+        @format
+      end
+      def format=(*args)
+        @format.charformat.dwMask = 0
+        args = args[0] if args[0].is_a?(Array)
+        if args[0].is_a?(Richedit::Format)
+          @format = args.shift
+        end
+        effects = []
+        color = []
+        while i = args.shift
+          if i.is_a?(String)
+            @format.facename = i
+          elsif i.is_a?(Symbol)
+            effects << i
+          elsif i < 0
+            @format.height = i
+          else
+            color << i
+          end
+        end
+        @format.effects = effects
+        @format.color = color
+        @format.set(@owner, @seltype)
+      end
+      
+      def text()
+        selstart, selend = self.get
+        buff = TCHAR[selend-selstart+1]
+        @owner.SendMessage(EM_GETSELTEXT, 0, buff)
+        buff.to_s.tr("\r", "\n")
+      end
+      def text=(txt)
+        @owner.SendMessage(EM_REPLACESEL, 1, txt) #API.adjust_internal_lf_code(txt))
+      end
+      
+      def color()
+        @format.get(@owner, CFM_COLOR).color
+      end
+      def color=(clr)
+        @format.color = clr
+        @format.set(@owner, @seltype)
+      end
+      
+      def effects()
+        @format.effects
+      end
+      def effects=(*args)
+        @format.effects = args[0]
+        @format.set(@owner, @seltype)
+      end
+      
+      def hieght()
+        @format.height
+      end
+      def height=(h)
+        @format.height = h
+        @format.set(@owner, @seltype)
+      end
+      
+      def alignment()
+        @format.alignment
+      end
+      def alignment=(arg)
+        @format.alignment = arg
+        @format.set(@owner)
+      end
+      
+      def style()
+        @format.get(@owner, CFM_STYLE).style
+      end
+      def style=(ss)
+        @format.style = ss
+        @format.set(@owner)
+      end
+      
+      def selstart()
+        chrng = CHARRANGE.new
+        @owner.SendMessage(EM_EXGETSEL, 0, chrng)
+        chrng.cpMin
+      end
+      def selend()
+        chrng = CHARRANGE.new
+        @owner.SendMessage(EM_EXGETSEL, 0, chrng)
+        chrng.cpMax
+      end
+      
+      def get()
+        chrng = CHARRANGE.new
+        @owner.SendMessage(EM_EXGETSEL, 0, chrng)
+        [chrng.cpMin, chrng.cpMax]
+      end
+      alias to_a get
+      def set(selstart, selend=selstart)
+        chrng = CHARRANGE[selstart, selend]
+        @owner.SendMessage(EM_EXSETSEL, 0, chrng) == 0 ? nil : self
+      end
+      
+    end # class
+    
+    ##################### Main ####################
+    
+    PreDefinedEvents = {
+      :msgfilter       => [WM_NOTIFY, EN_MSGFILTER, 'xs', MSGFILTER],
+      :requestresize   => [WM_NOTIFY, EN_REQUESTRESIZE, 'xs', REQRESIZE],
+      :selchange       => [WM_NOTIFY, EN_SELCHANGE, 'xs', SELCHANGE],
+      :dropfiles       => [WM_NOTIFY, EN_DROPFILES, 'xs', ENDROPFILES],
+      :protected       => [WM_NOTIFY, EN_PROTECTED, 'xs', ENPROTECTED],
+      :correcttext     => [WM_NOTIFY, EN_CORRECTTEXT, 'xs', ENCORRECTTEXT],
+      :stopnoundo      => [WM_NOTIFY, EN_STOPNOUNDO, 'xs', NMHDR],
+      :imechange       => [WM_COMMAND, EN_IMECHANGE, 'hi'],
+      :saveclipboard   => [WM_NOTIFY, EN_SAVECLIPBOARD, 'xs', ENSAVECLIPBOARD],
+      :oleopfailed     => [WM_NOTIFY, EN_OLEOPFAILED, 'xs', ENOLEOPFAILED],
+      :objectpositions => [WM_NOTIFY, EN_OBJECTPOSITIONS, 'xs', OBJECTPOSITIONS],
+      :link            => [WM_NOTIFY, EN_LINK, 'xs', ENLINK],
+      :dragdropdone    => [WM_NOTIFY, EN_DRAGDROPDONE, 'xs', NMHDR],
+      :paragraphexpanded => [WM_NOTIFY, EN_PARAGRAPHEXPANDED, 'xs', NMHDR],
+      :pagechange      => [WM_NOTIFY, EN_PAGECHANGE], # not defined?
+      :lowfirtf        => [WM_NOTIFY, EN_LOWFIRTF, 'xs', ENLOWFIRTF],
+      :alignltr        => [WM_COMMAND, EN_ALIGNLTR, 'hi'],
+      :alignrtl        => [WM_COMMAND, EN_ALIGNRTL, 'hi'],
+      :change          => [WM_NOTIFY, EN_CHANGE, 'xs', CHANGENOTIFY],
+#      :change          => [WM_COMMAND, EN_CHANGE, 'hi'],
+      :setfocus  => [WM_COMMAND, EN_SETFOCUS, 'hi'],
+      :killfocus => [WM_COMMAND, EN_KILLFOCUS, 'hi'],
+      :update     => [WM_COMMAND, EN_UPDATE, 'hi'],
+      :errspace  => [WM_COMMAND, EN_ERRSPACE, 'hi'],
+      :maxtext   => [WM_COMMAND, EN_MAXTEXT, 'hi'],
+      :hscroll   => [WM_COMMAND, EN_HSCROLL, 'hi'],
+      :vscroll   => [WM_COMMAND, EN_VSCROLL,  'hi']
+    }
+    DefaultEvents = [
+      :change, # ???_change(CHANGENOTIFY)
+      :update  # ???_update(idcmd, code, hwnd)
+    ]
+    
+    def initialize(*args)
+      super
+      @_classname = RICHEDIT_CLASS
+      self.style |= ES_MULTILINE
+      @_acceptable_events = PreDefinedEvents.dup
+    end
+    #
+    def create()
+      super
+      @_parent.set_msgtranslator(WM_NOTIFY) unless @_parent.get_msgtranslator(WM_NOTIFY)
+#      SendMessage(EM_SETLANGOPTIONS, 0, 0)
+      @selection = Richedit::Selection.new(self)
+      self.limittext = @_limittext if @_limittext
+      self.eventmask = @_eventmask if @_eventmask
+    end
+    
+    # Gets the current text limit for this edit control.
+    def limittext()
+      alive? ? SendMessage(EM_GETLIMITTEXT, 0, 0) : @_limittext
+    end
+    
+    # Sets the text limit of this edit control. 
+    def limittext=(lim)
+      if alive?
+        SendMessage(EM_EXLIMITTEXT, 0, lim)
+      else
+        @_limittext = lim
+      end
+    end
+    
+    # Retrieves the event mask for this rich edit control.
+    def eventmask()
+      alive? ? SendMessage(EM_GETEVENTMASK, 0, 0) : @_eventmask
+    end
+    # Sets the event mask for this rich edit control. 
+    def eventmask=(mask)
+      alive? ? SendMessage(EM_SETEVENTMASK, 0, mask) : @_eventmask = mask
+    end
+    # Sets the event mask for this rich edit control. <br>
+    # Returns previous event mask
+    def seteventmask(mask)
+      SendMessage(EM_SETEVENTMASK, 0, mask)
+    end
+    
+    # Obtains the current scroll position of this edit control.
+    def scrollpos()
+      pt = POINT.new
+      SendMessage(EM_GETSCROLLPOS, 0, pt)
+      [pt.x, pt.y]
+    end
+    # Tells this rich edit control to scroll to a particular point.
+    def scrollpos=(*args)
+      x, y = args[0].is_a?(Array) ? args[0] : [0, args[0]]
+      pt = POINT[x, y]
+      SendMessage(EM_SETSCROLLPOS, 0, pt)
+    end
+    # Scrolls this edit control to first position of document.
+    def scrollhome()
+      SendMessage(EM_SETSCROLLPOS, 0, POINT.new)
+    end
+    
+    # Gets the starting and ending character positions of the current selection.
+    def selection()
+      @selection
+    end
+    
+    # selection=(starting[, ending])
+    # Selects a range of characters in an edit control.
+    def selection=(*args)
+      selstart, selend = args[0].is_a?(Array) ? args[0] : [args[0], args[0]]
+      @selection.set(selstart, selend)
+    end
+    
+    
+    # Retreives the range of a word of current selection.
+    def word()
+      @selection.seltype = SCF_SELECTION | SCF_WORD
+      selection
+    end
+    
+    # Retreives the entire selection of this rich edit control.
+    def all()
+      @selection.seltype = SCF_ALL
+      selection
+    end
+    
+    # []=(position, length=1, text)
+    # Inserts and replaces at the specified <i>position</i> and <i>length</i> by the <i>text</i> in this edit control.
+    def []=(*args) #; dpp args
+      idx = args.shift
+      len = args[0].is_a?(Integer) ? args.shift : 1
+      args = args[0] if args[0].is_a?(Array)
+      @selection.set(idx, idx + len)
+      args.each{|i|
+        if i.is_a?(String)
+          @selection.text = i
+        elsif i.is_a?(Integer)
+          @selection.color = i
+        elsif i.is_a?(Symbol)
+          @selection.effects = i
+        elsif i.is_a?(Format)
+        end
+      }
+    end
+    
+    if RWin::UNICODE
+      # Gets a text length of this edit control.
+      def textlength()
+        gtlen = GETTEXTLENGTHEX[GT_DEFAULT, CP_UNICODE]
+        SendMessage(EM_GETTEXTLENGTHEX, gtlen, 0)
+      end
+    else
+      # Gets a text length of this edit control.
+      def textlength()
+        SenMmessage(WM_GETTEXTLENGTH, 0, 0)
+      end
+    end
+    
+    # Retrieves the type of the next undo action, if any. <br>
+    # Retruns an integer as UNDONAMEID.
+    def getundoname()
+      SendMessage(EM_GETUNDONAME, 0, 0)
+    end
+    # Retrieves the type of the next redo action, if any.
+    # Retruns an integer as UNDONAMEID.
+    def getredoname()
+      SendMessage(EM_GETREDONAME, 0, 0)
+    end
+    
+    # Sets the maximum number of actions that can stored in the undo queue.
+    def setundolimit(lim=100)
+      SendMessage(EM_SETUNDOLIMIT, lim, 0)
+    end
+    
+    # Retreives a line number of specified position in this edit control.
+    def pos2line(pos)
+      SendMessage(EM_EXLINEFROMCHAR, 0, pos)
+    end
+    
+    # Retreives a first position of specified line number in this edit control.
+    def line2pos(lin)
+      SendMessage(EM_LINEINDEX, lin, 0)
+    end
+    
+    # Retrieves a specified range of characters from this rich edit control.
+    def textrange(from, to)
+      lpstr = TCHAR[to - from + 1]
+      txtrng = TEXTRANGE[CHARRANGE[from, to], lpstr]
+      SendMessage(EM_GETTEXTRANGE, 0, txtrng)
+      txtrng.lpstrText.to_s
+    end
+    
+    # Retreives a position of specified coordinate(x, y) in this edit control.
+    def point2pos(x, y) 
+      SendMessage(EM_CHARFROMPOS, 0, POINT[x, y])
+    end
+    alias hittest point2pos
+    
+    # Retreives a line number of specified coordinate(x, y) in this edit control.
+    def point2line(x, y)
+      pos2line(point2pos(x, y))
+    end
+    
+    # Scrolls the text to specified line and column.
+    def linescroll(ln)
+      SendMessage(EM_LINESCROLL, 0, ln)
+    end
+    
+    # Counts num of lines in this edit control.
+    def countlines()
+      SendMessage(EM_GETLINECOUNT, 0, 0)
+    end
+    
+    # Gets the length of a line of specified position.
+    def linelength(pos)
+      SendMessage(EM_LINELENGTH, pos, 0)
+    end
+    
+    # Sets initial font for this edit control. This is for font-inheritance.
+    def font=(fnt)
+      @__font = fnt.respond_to?(:font) ? fnt.font : fnt
+      super
+    end
+    # Gets initial font for this edit control.
+    def font()
+      @__font
+    end
+    
+    # Clears all documents in this edit control.
+    def clear()
+      self.text = ''
+      charformat = CHARFORMAT2[CHARFORMAT2::Size, CFM_ALL2]
+      chrng = CHARRANGE[0, 0]
+      SendMessage(EM_EXSETSEL, 0, chrng)
+    end
+    
+    API.loadlib 'kernel32.dll'
+    API.defun 'CreateFile(LPCTSTR lpFileName, 
+                          DWORD dwDesiredAccess,
+                          DWORD dwShareMode,
+                          LPSECURITY_ATTRIBUTES lpSecurityAttributes, 
+                          DWORD dwCreationDisposition,
+                          DWORD dwFlagsAndAttributes, 
+                          HANDLE hTemplateFile)'
+    
+    API.defun 'CloseHandle(HANDLE handle)'
+    
+    API.defun 'WriteFile( HANDLE hFile,
+                          LPCVOID lpBuffer,
+                          DWORD nNumberOfBytesToWrite,
+                          LPDWORD lpNumberOfBytesWritten,
+                          LPOVERLAPPED lpOverlapped)'
+    
+    API.defun 'ReadFile(  HANDLE hFile,
+                          LPVOID lpBuffer,
+                          DWORD nNumberOfBytesToRead,
+                          LPDWORD lpNumberOfBytesRead,
+                          LPOVERLAPPED lpOverlapped)'
+    
+    # Saves this rich-edit control to the <i>path</i> with specified format.
+    def saveto(path, uformat=SF_RTF)
+      editstreamcallback = lambda{|hFile, pbBuf, cb, pcb|
+        API.WriteFile(hFile, pbBuf, cb, pcb, 0)
+        return 0
+      }
+     hfile = API.createFile(path, GENERIC_WRITE, 0, 0, CREATE_ALWAYS, 
+                            FILE_ATTRIBUTE_NORMAL | FILE_FLAG_WRITE_THROUGH, 0)
+#      hfile = API.createFile(path, 0x40000000, 0, 0, 2, 0x80000080, 0)
+      raise "Failed to open file:`#{path}'" if hfile == 0
+      begin
+        editstream = EDITSTREAM.new
+        editstream.dwCookie = hfile
+        editstream.pfnCallback = API.bindCallbackProc(editstreamcallback)
+        SendMessage(EM_STREAMOUT, uformat, editstream)
+      ensure
+        API.closeHandle(hfile)
+        API.releaseCallbackProc(editstreamcallback)
+      end
+    end
+    
+    
+    # Loads from specified <i>poath</i> into this rich-edit control with specified format.<br>
+    # All existing documents will be cleared on loading.
+    def loadfrom(path, uformat=SF_RTF)
+      editstreamcallback = lambda{|hFile, pbBuf, cb, pcb| # dpp [hFile, pbBuf, cb, pcb]
+        API.ReadFile(hFile, pbBuf, cb, pcb, 0)
+        return 0
+      }
+     hfile = API.createFile(path, GENERIC_READ, 0, 0, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0)
+#      hfile = API.createFile(path, 0x80000000, 0, 0, 3, 0x00000080, 0)
+      raise "Failed to open file:`#{path}'" if hfile == 0
+      begin
+        editstream = EDITSTREAM.new
+        editstream.dwCookie = hfile
+        editstream.pfnCallback = API.bindCallbackProc(editstreamcallback)
+        SendMessage(EM_STREAMIN, uformat, editstream)
+      ensure
+        API.closeHandle(hfile)
+        API.releaseCallbackProc(editstreamcallback)
+      end
+    end
+    
+    protected
+    def _apply_options(arg)
+      if st=WinStyles[arg]
+        self.style |= st
+        return nil
+      end
+      super
+    end
+  end # class
+end