IOWA 1.0.0

data/external/windows-pr/lib/windows/shell.rb

@@ -0,0 +1,88 @@
+require 'Win32API'
+
+module Windows
+   module Shell
+      # CSIDL constants
+      CSIDL_DESKTOP                 = 0x0000
+      CSIDL_INTERNET                = 0x0001
+      CSIDL_PROGRAMS                = 0x0002
+      CSIDL_CONTROLS                = 0x0003
+      CSIDL_PRINTERS                = 0x0004
+      CSIDL_PERSONAL                = 0x0005
+      CSIDL_FAVORITES               = 0x0006
+      CSIDL_STARTUP                 = 0x0007
+      CSIDL_RECENT                  = 0x0008
+      CSIDL_SENDTO                  = 0x0009
+      CSIDL_BITBUCKET               = 0x000a
+      CSIDL_STARTMENU               = 0x000b
+      CSIDL_MYDOCUMENTS             = 0x000c
+      CSIDL_MYMUSIC                 = 0x000d
+      CSIDL_MYVIDEO                 = 0x000e
+      CSIDL_DESKTOPDIRECTORY        = 0x0010
+      CSIDL_DRIVES                  = 0x0011
+      CSIDL_NETWORK                 = 0x0012
+      CSIDL_NETHOOD                 = 0x0013
+      CSIDL_FONTS                   = 0x0014
+      CSIDL_TEMPLATES               = 0x0015
+      CSIDL_COMMON_STARTMENU        = 0x0016
+      CSIDL_COMMON_PROGRAMS         = 0X0017
+      CSIDL_COMMON_STARTUP          = 0x0018
+      CSIDL_COMMON_FAVORITES        = 0x001f
+      CSIDL_COMMON_DESKTOPDIRECTORY = 0x0019
+      CSIDL_APPDATA                 = 0x001a
+      CSIDL_PRINTHOOD               = 0x001b
+      CSIDL_LOCAL_APPDATA           = 0x001c
+      CSIDL_ALTSTARTUP              = 0x001d
+      CSIDL_COMMON_ALTSTARTUP       = 0x001e
+      CSIDL_INTERNET_CACHE          = 0x0020
+      CSIDL_COOKIES                 = 0x0021
+      CSIDL_HISTORY                 = 0x0022
+      CSIDL_COMMON_APPDATA          = 0x0023
+      CSIDL_WINDOWS                 = 0x0024
+      CSIDL_SYSTEM                  = 0x0025
+      CSIDL_PROGRAM_FILES           = 0x0026
+      CSIDL_MYPICTURES              = 0x0027
+      CSIDL_PROFILE                 = 0x0028
+      CSIDL_SYSTEMX86               = 0x0029
+      CSIDL_PROGRAM_FILESX86        = 0x002a
+      CSIDL_PROGRAM_FILES_COMMON    = 0x002b
+      CSIDL_PROGRAM_FILES_COMMONX86 = 0x002c
+      CSIDL_COMMON_TEMPLATES        = 0x002d
+      CSIDL_COMMON_DOCUMENTS        = 0x002e
+      CSIDL_CONNECTIONS             = 0x0031
+      CSIDL_COMMON_MUSIC            = 0x0035
+      CSIDL_COMMON_PICTURES         = 0x0036
+      CSIDL_COMMON_VIDEO            = 0x0037
+      CSIDL_RESOURCES               = 0x0038
+      CSIDL_RESOURCES_LOCALIZED     = 0x0039
+      CSIDL_COMMON_OEM_LINKS        = 0x003a
+      CSIDL_CDBURN_AREA             = 0x003b
+      CSIDL_COMMON_ADMINTOOLS       = 0x002f
+      CSIDL_ADMINTOOLS              = 0x0030
+      
+      # Return codes
+      S_FALSE      = 1
+      E_FAIL       = 2147500037
+      E_INVALIDARG = 2147483651
+
+      # Flags
+      SHGFP_TYPE_CURRENT = 0
+      SHGFP_TYPE_DEFAULT = 1
+
+      SHGetFolderPath            = Win32API.new('shell32', 'SHGetFolderPath', 'LLLLP', 'L')
+      SHGetSpecialFolderLocation = Win32API.new('shell32', 'SHGetSpecialFolderLocation', 'LIP', 'L')
+      SHGetSpecialFolderPath     = Win32API.new('shell32', 'SHGetSpecialFolderPath', 'LPLL','L')
+
+      def SHGetFolderPath(handle, folder, token, flags, path)
+         SHGetFolderPath.call(handle, folder, token, flags, path)
+      end
+
+      def SHGetSpecialFolderLocation(handle, folder, pidl)
+         SHGetSpecialFolderLocation.call(handle, folder, pidl)
+      end
+
+      def SHGetSpecialFolderPath(handle, path, folder, create)
+         SHGetSpecialFolderPath.call(handle, path, folder, create)
+      end
+   end
+end

data/external/windows-pr/lib/windows/sound.rb

@@ -0,0 +1,52 @@
+##############################################################################
+# sound.rb
+#
+# Includes the following functions:
+#
+# Beep()
+# PlaySound()
+# WaveOutSetVolume()
+# WaveOutGetVolume()
+#
+# Defines the following constants:
+# 
+# SND_APPLICATION
+# SND_ALIAS
+# SND_ALIAS_ID
+# SND_ASYNC
+# SND_FILENAME
+# SND_LOOP
+# SND_MEMORY
+# SND_NODEFAULT
+# SND_NOSTOP
+# SND_NOWAIT
+# SND_PURGE
+# SND_RESOURCE
+# SND_SYNC
+##############################################################################
+require 'Win32API'
+
+module Windows  
+   module Sound
+      SND_SYNC          = 0x0000  # play synchronously (default)
+      SND_ASYNC         = 0x0001  # play asynchronously
+      SND_NODEFAULT     = 0x0002  # silence (!default) if sound not found
+      SND_MEMORY        = 0x0004  # pszSound points to a memory file
+      SND_LOOP          = 0x0008  # loop the sound until next sndPlaySound
+      SND_NOSTOP        = 0x0010  # don't stop any currently playing sound 
+
+      SND_NOWAIT        = 8192    # don't wait if the driver is busy
+      SND_ALIAS         = 65536   # name is a registry alias
+      SND_ALIAS_ID      = 1114112 # alias is a predefined ID
+      SND_FILENAME      = 131072  # name is file name
+      SND_RESOURCE      = 262148  # name is resource name or atom
+
+      SND_PURGE         = 0x0040  # purge non-static events for task
+      SND_APPLICATION   = 0x0080  # look for application specific association
+      
+      Beep             = Win32API.new('kernel32', 'Beep', 'LL', 'I')
+      PlaySound        = Win32API.new('winmm', 'PlaySound', 'PPL', 'I')
+      WaveOutSetVolume = Win32API.new('winmm', 'waveOutSetVolume', 'PL', 'I')
+      WaveOutGetVolume = Win32API.new('winmm', 'waveOutGetVolume', 'IP', 'I')
+   end
+end

data/external/windows-pr/lib/windows/synchronize.rb

@@ -0,0 +1,161 @@
+#######################################################################
+# synchronize.rb
+#
+# Defines the following functions:
+#
+# CreateEvent()
+# CreateMutex()
+# CreateSemaphore()
+# MsgWaitForMultipleObjects()
+# MsgWaitForMultipleObjectsEx()
+# OpenEvent()
+# OpenMutex()
+# OpenSemaphore()
+# WaitForDebugEvent()
+# WaitForSingleObject()
+# WaitForSingleObjectEx()
+# WaitForMultipleObjects()
+# WaitForMultipleObjectsEx()
+#
+# Defines the the following constants:
+#
+# WAIT_ABANDONED
+# WAIT_OBJECT_0
+# WAIT_TIMEOUT
+# WAIT_FAILED
+# INFINITE
+#
+# TODO:
+#
+# Add the rest of the synchronization functions.
+#######################################################################
+require 'Win32API'
+
+module Windows
+   module Synchronize
+      INFINITE       = 0xFFFFFFFF
+      WAIT_OBJECT_0  = 0
+      WAIT_TIMEOUT   = 0x102
+      WAIT_ABANDONED = 128
+      WAIT_FAILED    = 0xFFFFFFFF
+      
+      # Wake mask constants
+      QS_ALLEVENTS      = 0x04BF
+      QS_ALLINPUT       = 0x04FF
+      QS_ALLPOSTMESSAGE = 0x0100
+      QS_HOTKEY         = 0x0080
+      QS_INPUT          = 0x407
+      QS_KEY            = 0x0001
+      QS_MOUSE          = 0x0006
+      QS_MOUSEBUTTON    = 0x0004
+      QS_MOUSEMOVE      = 0x0002
+      QS_PAINT          = 0x0020
+      QS_POSTMESSAGE    = 0x0008
+      QS_RAWINPUT       = 0x0400
+      QS_SENDMESSAGE    = 0x0040
+      QS_TIMER          = 0x0010
+      
+      # Wait type constants
+      MWMO_ALERTABLE      = 0x0002
+      MWMO_INPUTAVAILABLE = 0x0004
+      MWMO_WAITALL        = 0x0001
+      
+      # Access rights
+      EVENT_ALL_ACCESS       = 0x1F0003
+      EVENT_MODIFY_STATE     = 0x0002
+      MUTEX_ALL_ACCESS       = 0x1F0001
+      MUTEX_MODIFY_STATE     = 0x0001
+      SEMAPHORE_ALL_ACCESS   = 0x1F0003
+      SEMAPHORE_MODIFY_STATE = 0x0002
+
+      CreateEvent     = Win32API.new('kernel32', 'CreateEvent', 'PIIP', 'L')
+      CreateMutex     = Win32API.new('kernel32', 'CreateMutex', 'PIP', 'L')
+      CreateSemaphore = Win32API.new('kernel32', 'CreateSemaphore', 'PLLP', 'L')
+
+      GetOverlappedResult = Win32API.new('kernel32', 'GetOverlappedResult', 'LPPI', 'I')
+      
+      MsgWaitForMultipleObjects   = Win32API.new('user32', 'MsgWaitForMultipleObjects', 'LPILL', 'L')
+      MsgWaitForMultipleObjectsEx = Win32API.new('user32', 'MsgWaitForMultipleObjectsEx', 'LPLLL', 'L')
+
+      OpenEvent        = Win32API.new('kernel32', 'OpenEvent', 'LIP', 'L')
+      OpenMutex        = Win32API.new('kernel32', 'OpenMutex', 'LIP', 'L')
+      OpenSemaphore    = Win32API.new('kernel32', 'OpenSemaphore', 'LIP', 'L')
+      ReleaseMutex     = Win32API.new('kernel32', 'ReleaseMutex', 'L', 'I')
+      ReleaseSemaphore = Win32API.new('kernel32', 'ReleaseSemaphore', 'LLP', 'I')
+      ResetEvent       = Win32API.new('kernel32', 'ResetEvent', 'L', 'I')
+      SetEvent         = Win32API.new('kernel32', 'SetEvent', 'L', 'I')
+
+      WaitForMultipleObjects   = Win32API.new('kernel32', 'WaitForMultipleObjects', 'LPIL', 'L')
+      WaitForMultipleObjectsEx = Win32API.new('kernel32', 'WaitForMultipleObjectsEx', 'LPILI', 'L')
+      WaitForSingleObject      = Win32API.new('kernel32', 'WaitForSingleObject', 'LL', 'L')
+      WaitForSingleObjectEx    = Win32API.new('kernel32', 'WaitForSingleObjectEx', 'LLI', 'L')
+      
+      def CreateEvent(attributes, reset, state, name)
+         CreateEvent.call(attributes, reset, state, name)
+      end
+      
+      def CreateMutex(attributes, owner, name)
+         CreateMutex.call(attributes, owner, name)
+      end
+      
+      def CreateSemaphore(attributes, initial, max, name)
+         CreateSemaphore.call(attributes, initial, max, name)
+      end
+      
+      def GetOverlappedResult(handle, overlapped, bytes_transferred, wait)
+         GetOverlappedResult.call(handle, overlapped, bytes_transferred, wait)
+      end
+      
+      def MsgWaitForMultipleObjects(count, handles, wait, milli, mask)
+         MsgWaitForMultipleObjects.call(count, handles, wait, milli, mask)
+      end
+      
+      def MsgWaitForMultipleObjectsEx(count, handles, milli, mask, flags)
+         MsgWaitForMultipleObjectsEx.call(count, handles, milli, mask, flags)
+      end
+      
+      def OpenSemaphore(access, handle, name)
+         OpenSemaphore.call(access, handle, name)
+      end
+      
+      def OpenMutex(access, handle, name)
+         OpenMutex.call(access, handle, name)
+      end
+      
+      def OpenEvent(access, handle, name)
+         OpenEvent.call(access, handle, name)
+      end
+      
+      def ReleaseMutex(handle)
+         ReleaseMutex.call(handle) != 0
+      end
+      
+      def ReleaseSemaphore(handle, release_count, previous_count)
+         ReleaseSemaphore.call(handle, release_count, previous_count) != 0
+      end
+      
+      def ResetEvent(handle)
+         ResetEvent.call(handle) != 0
+      end
+      
+      def SetEvent(handle)
+         SetEvent.call(handle) != 0
+      end
+      
+      def WaitForMultipleObjects(count, handles, wait_all, milliseconds)
+         WaitForMultipleObjects.call(count, handles, wait_all, milliseconds)
+      end
+      
+      def WaitForMultipleObjectsEx(count, handles, wait_all, milliseconds, alertable)
+         WaitForMultipleObjectsEx.call(count, handles, wait_all, milliseconds, alertable)
+      end
+      
+      def WaitForSingleObject(handle, milliseconds)
+         WaitForSingleObject.call(handle, milliseconds)
+      end
+      
+      def WaitForSingleObjectEx(handle, milliseconds, alertable)
+         WaitForSingleObject.call(handle, milliseconds, alertable)
+      end
+   end
+end

data/external/windows-pr/lib/windows/system_info.rb

@@ -0,0 +1,70 @@
+require 'Win32API'
+
+module Windows
+   module SystemInfo
+      # Obsolete processor info constants
+      PROCESSOR_INTEL_386     = 386
+      PROCESSOR_INTEL_486     = 486
+      PROCESSOR_INTEL_PENTIUM = 586
+      PROCESSOR_INTEL_IA64    = 2200
+      PROCESSOR_AMD_X8664     = 8664
+
+      # Enum COMPUTER_NAME_FORMAT
+      ComputerNameNetBIOS                    = 0
+      ComputerNameDnsHostname                = 1
+      ComputerNameDnsDomain                  = 2
+      ComputerNameDnsFullyQualified          = 3
+      ComputerNamePhysicalNetBIOS            = 4
+      ComputerNamePhysicalDnsHostname        = 5
+      ComputerNamePhysicalDnsDomain          = 6 
+      ComputerNamePhysicalDnsFullyQualified  = 7
+      ComputerNameMax                        = 8
+      
+      ExpandEnvironmentStrings = Win32API.new('kernel32', 'ExpandEnvironmentStrings', 'PPL', 'L')
+      
+      GetComputerName     = Win32API.new('kernel32', 'GetComputerName', 'PP', 'I')
+      GetComputerNameEx   = Win32API.new('kernel32', 'GetComputerNameEx', 'PPP', 'I')
+      GetSystemInfo       = Win32API.new('kernel32', 'GetSystemInfo', 'P', 'V')
+      GetUserName         = Win32API.new('advapi32', 'GetUserName', 'LL', 'I')
+      GetUserNameEx       = Win32API.new('secur32', 'GetUserNameEx', 'LPL', 'I')
+      GetVersion          = Win32API.new('kernel32', 'GetVersion', 'V', 'L')
+      GetVersionEx        = Win32API.new('kernel32', 'GetVersionEx', 'P', 'I')
+      GetWindowsDirectory = Win32API.new('kernel32', 'GetWindowsDirectory', 'LI', 'I')
+      
+      def ExpandEnvironmentStrings(src, dest, size)
+         ExpandEnvironmentStrings.call(src, dest, size)
+      end
+
+      def GetComputerName(buffer, size)
+         GetComputerNameEx.call(buffer, size) != 0
+      end
+
+      def GetComputerNameEx(name, buffer, size)
+         GetComputerNameEx.call(name, buffer, size) != 0
+      end
+
+      def GetSystemInfo(info)
+         GetSystemInfo.call(info)
+      end
+
+      def GetUserName(buf, size)
+         GetUserName.call(buf, size) != 0
+      end
+
+      def GetUserNameEx(format, buf, size)
+         GetUserNameEx.call(format, buf, size) != 0
+      end
+
+      def GetVersion()
+         GetVersion.call
+      end
+
+      def GetVersionEx(info)
+         GetVersionEx.call(info) != 0
+      end
+
+      def GetWindowsDirectory(buf, size)
+         GetWindowsDirectory.call(buf, size)
+      end
+   end
+end

data/external/windows-pr/lib/windows/unicode.rb

@@ -0,0 +1,138 @@
+require 'Win32API'
+
+module Windows
+   module Unicode
+      CP_ACP         = 0
+      CP_OEMCP       = 1
+      CP_MACCP       = 2
+      CP_THREAD_ACP  = 3
+      CP_SYMBOL      = 42
+      CP_UTF7        = 65000
+      CP_UTF8        = 65001
+
+      MB_PRECOMPOSED       = 0x00000001
+      MB_COMPOSITE         = 0x00000002
+      MB_USEGLYPHCHARS     = 0x00000004
+      MB_ERR_INVALID_CHARS = 0x00000008
+
+      WC_COMPOSITECHECK    = 0x00000200 
+      WC_DISCARDNS         = 0x00000010
+      WC_SEPCHARS          = 0x00000020
+      WC_DEFAULTCHAR       = 0x00000040
+      WC_NO_BEST_FIT_CHARS = 0x00000400
+
+      ANSI_CHARSET        = 0
+      DEFAULT_CHARSET     = 1
+      SYMBOL_CHARSET      = 2
+      SHIFTJIS_CHARSET    = 128
+      HANGEUL_CHARSET     = 129
+      HANGUL_CHARSET      = 129
+      GB2312_CHARSET      = 134
+      CHINESEBIG5_CHARSET = 136
+      OEM_CHARSET         = 255
+      JOHAB_CHARSET       = 130
+      HEBREW_CHARSET      = 177
+      ARABIC_CHARSET      = 178
+      GREEK_CHARSET       = 161
+      TURKISH_CHARSET     = 162
+      VIETNAMESE_CHARSET  = 163
+      THAI_CHARSET        = 222
+      EASTEUROPE_CHARSET  = 238
+      RUSSIAN_CHARSET     = 204
+
+      IS_TEXT_UNICODE_ASCII16            = 0x0001
+      IS_TEXT_UNICODE_REVERSE_ASCII16    = 0x0010
+      IS_TEXT_UNICODE_STATISTICS         = 0x0002
+      IS_TEXT_UNICODE_REVERSE_STATISTICS = 0x0020
+      IS_TEXT_UNICODE_CONTROLS           = 0x0004
+      IS_TEXT_UNICODE_REVERSE_CONTROLS   = 0x0040
+      IS_TEXT_UNICODE_SIGNATURE          = 0x0008
+      IS_TEXT_UNICODE_REVERSE_SIGNATURE  = 0x0080
+      IS_TEXT_UNICODE_ILLEGAL_CHARS      = 0x0100
+      IS_TEXT_UNICODE_ODD_LENGTH         = 0x0200
+      IS_TEXT_UNICODE_DBCS_LEADBYTE      = 0x0400
+      IS_TEXT_UNICODE_NULL_BYTES         = 0x1000
+      IS_TEXT_UNICODE_UNICODE_MASK       = 0x000F
+      IS_TEXT_UNICODE_REVERSE_MASK       = 0x00F0
+      IS_TEXT_UNICODE_NOT_UNICODE_MASK   = 0x0F00
+      IS_TEXT_UNICODE_NOT_ASCII_MASK     = 0xF000
+
+      TCI_SRCCHARSET  = 1
+      TCI_SRCCODEPAGE = 2
+      TCI_SRCFONTSIG  = 3
+      TCI_SRCLOCALE   = 0x100
+
+      GetTextCharset       = Win32API.new('gdi32', 'GetTextCharset', 'L', 'I')
+      GetTextCharsetInfo   = Win32API.new('gdi32', 'GetTextCharsetInfo', 'LPL', 'I')
+      IsDBCSLeadByte       = Win32API.new('kernel32', 'IsDBCSLeadByte', 'P', 'I')
+      IsDBCSLeadByteEx     = Win32API.new('kernel32', 'IsDBCSLeadByteEx', 'IP', 'I')
+      IsTextUnicode        = Win32API.new('advapi32', 'IsTextUnicode', 'PIP', 'I')
+      MultiByteToWideChar  = Win32API.new('kernel32', 'MultiByteToWideChar', 'ILPIPI', 'I')
+      TranslateCharsetInfo = Win32API.new('gdi32', 'TranslateCharsetInfo', 'PPL', 'I')
+      WideCharToMultiByte  = Win32API.new('kernel32', 'WideCharToMultiByte', 'ILPIPIPP', 'I')
+
+      def GetTextCharset(hdc)
+         GetTextCharset.call(hdc)
+      end
+
+      def GetTextCharsetInfo(hdc, sig, flags)
+         GetTextCharsetInfo.call(hdc, sig, flags)
+      end
+
+      def IsDBCSLeadByte(char)
+         IsDBCSLeadByte.call(char) != 0
+      end
+
+      def IsDBCSLeadByteEx(code_page, char)
+         IsDBCSLeadByteEx.call(code_pag, char) != 0
+      end
+
+      def IsTextUnicode(buf, size = buf.size, options = 0)
+         IsTextUnicode.call(buf, size, options) != 0
+      end
+
+      def MultiByteToWideChar(page, flags, str, str_size, buf, buf_size)
+         MultiByteToWideChar.call(page, flags, str, str_size, buf, buf_size)
+      end
+
+      def TranslateCharsetInfo(src, cs, flags)
+         TranslateCharsetInfo.call(src, cs, flags) != 0
+      end
+
+      def WideCharToMultiByte(page, flags, str, str_size, buf, buf_size, defchar, used_def)
+         WideCharToMultiByte.call(page, flags, str, str_size, buf, buf_size, defchar, used_def)
+      end
+      
+      # Convenient wrapper methods
+      
+      # Maps a string to a wide (unicode) string using UTF8.  If the function
+      # fails it just returns the string as is.
+      # 
+      def multi_to_wide(str)
+         cp  = ($KCODE == 'UTF8') ? CP_UTF8 : CP_ACP
+         buf = 0.chr * str.size * 2 # sizeof(WCHAR)
+         int = MultiByteToWideChar(cp, 0, str, str.size, buf, buf.size)
+         
+         if int > 0
+            buf[0, int*2]
+         else
+            str
+         end
+      end
+      
+      # Maps a wide character string to a new character string.  If the
+      # function fails it just returns the string as is.
+      # 
+      def wide_to_multi(str)
+         cp  = ($KCODE == 'UTF8') ? CP_UTF8 : CP_ACP
+         buf = 0.chr * str.size
+         int = WideCharToMultiByte(cp, 0, str, str.size/2, buf, buf.size, 0, 0)
+
+         if int > 0
+            buf[0, int]
+         else
+            str
+         end
+      end
+   end
+end