windows-pr 0.2.0 → 0.5.3

data/CHANGES

@@ -1,6 +1,51 @@
+= 0.5.3 - 10-Aug-2006
+* Added wide character functions to the EventLog module.
+* Added a test suite for the EventLog module.
+* Fixed method wrapper for MapViewOfFileEx.
+* Finer grained method wrapping/checking for the Windows::Registry module (the
+  RegSaveKeyEx might not be defined).
+
+= 0.5.2 - 29-Jul-2006
+* Prototype fixes/changes for CreateProcess, GlobalLock, GlobalMemoryStatusEx,
+  and CreateFileMapping.
+* Finer grained method wrapping/checking for the Windows::Process module (only
+  two methods might not be defined).
+* Added method wrappers for the Handle constants.
+* Added mmap related methods and constants.
+* Added more test cases.
+* Added wide character methods to the Windows::Directory class.
+* Added wide character helper methods.
+* Added a few more methods to MSVCRT::String. 
+
+= 0.5.1 - 26-May-2006
+* Minor updates and fixes for the Unicode and DeviceIO modules.
+* Added some wide character support, based on $KCODE values (which should
+  not be used at this time).
+
+= 0.5.0 - 23-May-2006
+* Added the Registry module
+* Added the EventLog module
+* Added the National module
+* Added the SystemInfo module
+
+= 0.4.0 - 7-May-2006
+* Bug fix for the WaitForMultipleObjects method in synchronize.rb
+* Added the Window module (just a few constants for now)
+* Added the Console module (AttachConsole, etc)
+* Added the Library module (LoadLibrary, etc)
+* Added the Directory module (CreateDirectory, etc)
+* Added the Shell module (some constants, a few methods for now)
+* Added the Unicode module (WideCharToMultiByte, etc)
+* Added process creation, priority and startf flags to the Process module
+
+= 0.3.0 - 22-Apr-2006
+* Added the Limits module.
+* Added the Security module.
+* Fixed a signature bug in the MSVCRT/Buffer module.
+
 = 0.2.0 - 13-Apr-2006
-* Added the filesystem module.
-* Fixed signature and dll mistakes in the file module.
+* Added the FileSystem module.
+* Fixed signature and dll mistakes in the File module.
 
 = 0.1.0 - 4-Apr-2006
 * Initial release

data/MANIFEST

@@ -7,15 +7,28 @@ windows-pr.gemspec
 doc/conversion_guide.txt
 
 lib/windows/clipboard.rb
+lib/windows/console.rb
 lib/windows/device_io.rb
+lib/windows/directory.rb
 lib/windows/error.rb
+lib/windows/eventlog.rb
 lib/windows/file.rb
 lib/windows/filesystem.rb
 lib/windows/handle.rb
+lib/windows/library.rb
+lib/windows/limits.rb
 lib/windows/memory.rb
+lib/windows/national.rb
 lib/windows/path.rb
+lib/windows/process.rb
+lib/windows/registry.rb
+lib/windows/security.rb
+lib/windows/shell.rb
 lib/windows/sound.rb
 lib/windows/synchronize.rb
+lib/windows/system_info.rb
+lib/windows/unicode.rb
+lib/windows/window.rb
 
 lib/windows/msvcrt/buffer.rb
 lib/windows/msvcrt/file.rb

data/README

@@ -45,6 +45,17 @@
    file contains clipboard related functions, such as CloseClipboard(), as
    well as constants such as CF_TEXT, CF_BITMAP, etc.
    
+== Wide character functions
+	I decided that the $KCODE handling was a bad idea, so most of the $KCODE
+	handling has been removed.  The only methods that change their behavior
+	based on $KCODE are the multi_to_wide and wide_to_multi helper methods
+	in the Windows::Unicode module.  If $KCODE is set to UTF8, then the code
+	point used is CP_UTF8.  Otherwise, CP_ACP is used.
+	
+	In the future I'll add the wide character functions explicitly.  I haven't
+	added many yet (as of 29-Jul-2006) but I plan on adding as many as I can
+	as time permits.
+   
 == Where are the tests, dude?
    While I've made some effort to test these functions, there are simply too
    many for me to effectively test them all.  We're ultimately talking about

data/doc/conversion_guide.txt

@@ -12,7 +12,7 @@ LPDWORD		=> 'P'
 LPTSTR 		=> 'P'
 UINT  		=> 'I'
 VOID        => 'V'
-WORD		   => 'I'
+WORD        => 'I'
 
 = C Data Types
 void     	=> 'V'
@@ -20,6 +20,6 @@ void*    	=> 'P'
 char*    	=> 'P'
 const char* => 'L'
 int			=> 'I'
-long			=> 'L'
+long        => 'L'
 struct      => 'P'
 struct*     => 'P'

data/lib/windows/clipboard.rb

@@ -1,36 +1,3 @@
-#############################################################################
-# clipboard.rb
-#
-# Includes the following functions:
-#
-# CloseClipboard()
-# CoundClipboardFormats()
-# EmptyClipboard()
-# EnumClipboardFormats()
-# GetClipboardData()
-# GetClipboardFormatName()
-# IsClipboardFormatAvailable()
-# OpenClipboard()
-# RegisterClipboardFormat()
-# SetClipboardData()
-#
-# Defines the following constants:
-#
-# CF_TEXT
-# CF_BITMAP
-# CF_METAFILEPICT
-# CF_SYLK
-# CF_DIF
-# CF_TIFF
-# CF_OEMTEXT
-# CF_DIB
-# CF_PALETTE
-# CF_PENDATA
-# CF_RIFF
-# CF_WAVE
-# CF_UNICODETEXT
-# CF_ENHMETAFILE
-#############################################################################
 require 'Win32API'
 
 module Windows

data/lib/windows/console.rb

@@ -0,0 +1,323 @@
+require 'Win32API'
+
+module Windows
+   module Console
+      CTRL_C_EVENT        = 0
+      CTRL_BREAK_EVENT    = 1
+      CTRL_LOGOFF_EVENT   = 5
+      CTRL_SHUTDOWN_EVENT = 6
+
+      ENABLE_PROCESSED_INPUT    = 0x0001
+      ENABLE_LINE_INPUT         = 0x0002
+      ENABLE_WRAP_AT_EOL_OUTPUT = 0x0002
+      ENABLE_ECHO_INPUT         = 0x0004
+      ENABLE_WINDOW_INPUT       = 0x0008
+      ENABLE_MOUSE_INPUT        = 0x0010
+      ENABLE_INSERT_MODE        = 0x0020
+      ENABLE_QUICK_EDIT_MODE    = 0x0040
+
+      STD_INPUT_HANDLE  = -10
+      STD_OUTPUT_HANDLE = -11
+      STD_ERROR_HANDLE  = -12
+      
+      # Console window constants
+      FOREGROUND_BLUE            = 0x0001
+      FOREGROUND_GREEN           = 0x0002
+      FOREGROUND_RED             = 0x0004
+      FOREGROUND_INTENSITY       = 0x0008
+      BACKGROUND_BLUE            = 0x0010
+      BACKGROUND_GREEN           = 0x0020
+      BACKGROUND_RED             = 0x0040
+      BACKGROUND_INTENSITY       = 0x0080
+      COMMON_LVB_LEADING_BYTE    = 0x0100
+      COMMON_LVB_TRAILING_BYTE   = 0x0200
+      COMMON_LVB_GRID_HORIZONTAL = 0x0400
+      COMMON_LVB_GRID_LVERTICAL  = 0x0800
+      COMMON_LVB_GRID_RVERTICAL  = 0x1000
+      COMMON_LVB_REVERSE_VIDEO   = 0x4000
+      COMMON_LVB_UNDERSCORE      = 0x8000
+      COMMON_LVB_SBCSDBCS        = 0x0300
+
+      CONSOLE_FULLSCREEN          = 1
+      CONSOLE_OVERSTRIKE          = 1
+      CONSOLE_FULLSCREEN_HARDWARE = 2
+      
+      AddConsoleAlias                = Win32API.new('kernel32', 'AddConsoleAlias', 'PPP', 'I')
+      AllocConsole                   = Win32API.new('kernel32', 'AllocConsole', 'V', 'I')
+      AttachConsole                  = Win32API.new('kernel32', 'AttachConsole', 'L', 'I')
+      CreateConsoleScreenBuffer      = Win32API.new('kernel32', 'CreateConsoleScreenBuffer', 'LLPLP', 'L')
+      FillConsoleOutputAttribute     = Win32API.new('kernel32', 'FillConsoleOutputAttribute', 'LILLP', 'I')
+      FillConsoleOutputCharacter     = Win32API.new('kernel32', 'FillConsoleOutputCharacter', 'LILLP', 'I')
+      FlushConsoleInputBuffer        = Win32API.new('kernel32', 'FlushConsoleInputBuffer', 'L', 'I')
+      FreeConsole                    = Win32API.new('kernel32', 'FreeConsole', 'V', 'I')
+      GenerateConsoleCtrlEvent       = Win32API.new('kernel32', 'GenerateConsoleCtrlEvent', 'LL', 'I')
+      GetConsoleAlias                = Win32API.new('kernel32', 'GetConsoleAlias', 'PPLP', 'L')
+      GetConsoleAliases              = Win32API.new('kernel32', 'GetConsoleAliases', 'PLP', 'L')
+      GetConsoleAliasesLength        = Win32API.new('kernel32', 'GetConsoleAliasesLength', 'P', 'L')
+      GetConsoleAliasExes            = Win32API.new('kernel32', 'GetConsoleAliasExes', 'PL', 'L')
+      GetConsoleAliasExesLength      = Win32API.new('kernel32', 'GetConsoleAliasExesLength', 'V', 'L')
+      GetConsoleCP                   = Win32API.new('kernel32', 'GetConsoleCP', 'V', 'I')
+      GetConsoleCursorInfo           = Win32API.new('kernel32', 'GetConsoleCursorInfo', 'LP', 'I')
+      GetConsoleDisplayMode          = Win32API.new('kernel32', 'GetConsoleDisplayMode', 'P', 'L')
+      GetConsoleFontSize             = Win32API.new('kernel32', 'GetConsoleFontSize', 'LL', 'L')
+      GetConsoleMode                 = Win32API.new('kernel32', 'GetConsoleMode', 'LP', 'I')
+      GetConsoleOutputCP             = Win32API.new('kernel32', 'GetConsoleOutputCP', 'V', 'I')
+      GetConsoleProcessList          = Win32API.new('kernel32', 'GetConsoleProcessList', 'PL', 'L')
+      GetConsoleScreenBufferInfo     = Win32API.new('kernel32', 'GetConsoleScreenBufferInfo', 'LP', 'I')
+      GetConsoleSelectionInfo        = Win32API.new('kernel32', 'GetConsoleSelectionInfo', 'P', 'I')
+      GetConsoleTitle                = Win32API.new('kernel32', 'GetConsoleTitle', 'PL', 'L')
+      GetConsoleWindow               = Win32API.new('kernel32', 'GetConsoleWindow', 'V', 'L')
+      GetCurrentConsoleFont          = Win32API.new('kernel32', 'GetCurrentConsoleFont' , 'LIP', 'I')
+      GetLargestConsoleWindowSize    = Win32API.new('kernel32', 'GetLargestConsoleWindowSize', 'L', 'L')
+      GetNumberOfConsoleInputEvents  = Win32API.new('kernel32', 'GetNumberOfConsoleInputEvents', 'LP', 'I')
+      GetNumberOfConsoleMouseButtons = Win32API.new('kernel32', 'GetNumberOfConsoleMouseButtons', 'L', 'I')
+      GetStdHandle                   = Win32API.new('kernel32', 'GetStdHandle', 'L', 'L')
+      PeekConsoleInput               = Win32API.new('kernel32', 'PeekConsoleInput', 'LPLP', 'I')
+      ReadConsole                    = Win32API.new('kernel32', 'ReadConsole', 'LPLPP', 'I')
+      ReadConsoleInput               = Win32API.new('kernel32', 'ReadConsoleInput', 'LPLP', 'I')
+      ReadConsoleOutput              = Win32API.new('kernel32', 'ReadConsoleOutput', 'LPLLP', 'I')
+      ReadConsoleOutputAttribute     = Win32API.new('kernel32', 'ReadConsoleOutputAttribute', 'LPLLP', 'I')
+      ReadConsoleOutputCharacter     = Win32API.new('kernel32', 'ReadConsoleOutputCharacter', 'LPLLP', 'I')
+      ScrollConsoleScreenBuffer      = Win32API.new('kernel32', 'ScrollConsoleScreenBuffer', 'LPPLP', 'I')
+      SetConsoleActiveScreenBuffer   = Win32API.new('kernel32', 'SetConsoleActiveScreenBuffer', 'L', 'I')
+      SetConsoleCommandHistoryMode   = Win32API.new('kernel32', 'SetConsoleCommandHistoryMode', 'L', 'I')
+      SetConsoleCP                   = Win32API.new('kernel32', 'SetConsoleCP', 'L', 'I')
+      SetConsoleCtrlHandler          = Win32API.new('kernel32', 'SetConsoleCtrlHandler', 'PI', 'I')
+      SetConsoleCursorInfo           = Win32API.new('kernel32', 'SetConsoleCursorInfo', 'LP', 'I')
+      SetConsoleCursorPosition       = Win32API.new('kernel32', 'SetConsoleCursorPosition', 'LP', 'I')
+      SetConsoleDisplayMode          = Win32API.new('kernel32', 'SetConsoleDisplayMode', 'LLP', 'I')
+      SetConsoleMode                 = Win32API.new('kernel32', 'SetConsoleMode', 'LL', 'I')
+      SetConsoleOutputCP             = Win32API.new('kernel32', 'SetConsoleOutputCP', 'I', 'I')
+      SetConsoleScreenBufferSize     = Win32API.new('kernel32', 'SetConsoleScreenBufferSize', 'LL', 'I')
+      SetConsoleTextAttribute        = Win32API.new('kernel32', 'SetConsoleTextAttribute', 'LL', 'I')
+      SetConsoleTitle                = Win32API.new('kernel32', 'SetConsoleTitle', 'P', 'I')
+      SetConsoleWindowInfo           = Win32API.new('kernel32', 'SetConsoleWindowInfo', 'LIP', 'I')
+      SetStdHandle                   = Win32API.new('kernel32', 'SetStdHandle', 'LL', 'I')
+      WriteConsole                   = Win32API.new('kernel32', 'WriteConsole', 'LPLPP', 'I')
+      WriteConsoleInput              = Win32API.new('kernel32', 'WriteConsoleInput', 'LPLP', 'I')
+      WriteConsoleOutput             = Win32API.new('kernel32', 'WriteConsoleOutput', 'LPLLP', 'I')
+      WriteConsoleOutputAttribute    = Win32API.new('kernel32', 'WriteConsoleOutputAttribute', 'LPLLP', 'I')
+      WriteConsoleOutputCharacter    = Win32API.new('kernel32', 'WriteConsoleOutputCharacter', 'LPLLP', 'I')
+
+      def AddConsoleAlias(source, target, exe)
+         AddConsoleAlias.call(source, target, exe) != 0
+      end
+
+      def AllocConsole()
+         AllocConsole.call != 0
+      end
+
+      def AttachConsole(pid)
+         AttachConsole.call(pid)
+      end
+
+      def CreateConsoleScreenBuffer(access, mode, sec, flags, data)
+         CreateConsoleScreenBuffer.call(access, mode, sec, flags, data)
+      end
+
+      def FillConsoleOutputAttribute(handle, attribute, length, coord, num)
+         FillConsoleOutputAttribute.call(handle, attribute, length, coord, num) != 0
+      end
+
+      def FlushConsoleInputBuffer(handle)
+         FlushConsoleInputBuffer.call(handle) != 0
+      end
+
+      def FreeConsole()
+         FreeConsole.call != 0
+      end
+
+      def GenerateConsoleCtrlEvent(ctrl_event, process_group_id)
+         GenerateConsoleCtrlEvent.call(ctrl_event, process_group_id) != 0
+      end
+      
+      def GetConsoleAliases(buffer, buffer_length, exe_name)
+         GetConsoleAliases.call(buffer, buffer_length, exe_name)
+      end
+
+      def GetConsoleAliasesLength(exe_name)
+         GetConsoleAliasesLength.call(exe_name)
+      end
+
+      def GetConsoleAliasExes(buffer, buffer_length)
+         GetConsoleAliasExes.call(buffer, buffer_length)
+      end
+
+      def GetConsoleAliasExesLength()
+         GetConsoleAliasExesLength.call
+      end
+
+      def GetConsoleCP()
+         GetConsoleCP.call
+      end
+
+      def GetConsoleCursorInfo(handle, cursor_info_ptr)
+         GetConsoleCursorInfo.call(handle, cursor_info_ptr)
+      end
+
+      # The docs say this returns a BOOL, but really it's a DWORD
+      def GetConsoleDisplayMode(flags)
+         GetConsoleDisplayMode.call(flags)
+      end
+
+      def GetConsoleFontSize(handle, font)
+         GetConsoleFontSize.call(handle, font)
+      end
+
+      def GetConsoleMode(handle, mode)
+         GetConsoleMode.call(handle, mode) != 0
+      end
+
+      def GetConsoleOutputCP()
+         GetConsoleOutputCP.call
+      end
+
+      def GetConsoleProcessList(proc_list, proc_count)
+         GetConsoleProcessList.call(proc_list, proc_count)
+      end
+
+      def GetConsoleScreenBufferInfo(handle, buf_info)
+         GetConsoleScreenBufferInfo.call(handle, buf_info) != 0
+      end
+
+      def GetConsoleSelectionInfo(info_struct)
+         GetConsoleSelectionInfo.call(info_struct) != 0
+      end
+
+      def GetConsoleTitle(title, size)
+         GetConsoleTitle.call(title, size)
+      end
+
+      def GetConsoleWindow()
+         GetConsoleWindow.call
+      end
+
+      def GetCurrentConsoleFont(handle, max_window, current_font_struct)
+         GetCurrentConsoleFont.call(handle, max_window, current_font_struct)
+      end
+
+      def GetLargestConsoleWindowSize(handle)
+         GetLargestConsoleWindowSize.call(handle)
+      end
+
+      def GetNumberOfConsoleInputEvents(handle, num_events)
+         GetNumberOfConsoleInputEvents.call(handle, num_events)
+      end
+
+      def GetNumberOfConsoleMouseButtons(num_mouse_buttons)
+         GetNumberOfConsoleMouseButtons.call(num_mouse_buttons)
+      end
+
+      def GetStdHandle(std_handle)
+         GetStdHandle.call(std_handle)
+      end
+
+      def PeekConsoleInput(handle, buffer, length, num_events)
+         PeekConsoleInput.call(handle, buffer, length, num_events) != 0
+      end
+
+      def ReadConsole(handle, buffer, num_to_read, num_read, res = 0)
+         ReadConsole.call(handle, buffer, num_to_read, num_read, res) != 0
+      end
+
+      def ReadConsoleInput(handle, buffer, length, num_read)
+         ReadConsoleInput.call(handle, buffer, length, num_read) != 0
+      end
+
+      def ReadConsoleOutput(handle, buffer, buf_size, buf_coord, reg)
+         ReadConsoleOutput.call(handle, buffer, buf_size, buf_coord, reg) != 0
+      end
+
+      def ReadConsoleOutputAttribute(handle, attrib, len, coord, num_read)
+         ReadConsoleOutputAttribute.call(handle, attrib, len, coord, num_read) != 0
+      end
+
+      def ReadConsoleOutputCharacter(handle, char, length, coord, num_read)
+         ReadConsoleOutputCharacter.call(handle, char, length, coord, num_read) != 0
+      end
+      
+      def ScrollConsoleScreenBuffer(handle, scroll, clip, coord, fill)
+         ScrollConsoleScreenBuffer.call(handle, scroll, clip, coord, fill) != 0
+      end
+
+      def SetConsoleActiveScreenBuffer(handle)
+         SetConsoleActiveScreenBuffer.call(handle) != 0
+      end
+
+      def SetConsoleCommandHistoryMode(flags)
+         SetConsoleCommandHistoryMode.call(flags) != 0
+      end
+
+      def SetConsoleCP(code_page_id)
+         SetConsoleCP.call(code_page_id) != 0
+      end
+
+      def SetConsoleCtrlHandler(handler, add)
+         SetConsoleCtrlHandler.call(handler, add) != 0
+      end
+
+      def SetConsoleCursorInfo(handle, cursor)
+         SetConsoleCursorInfo.call(handle, cursor) != 0
+      end
+
+      def SetConsoleCursorPosition(handle, coord)
+         SetConsoleCursorPosition.call(handle, coord) != 0
+      end
+
+      def SetConsoleDisplayMode(handle, flags, coord)
+         SetConsoleDisplayMode.call(handle, flags, coord) != 0
+      end
+
+      def SetConsoleHistoryInfo(info)
+         SetConsoleHistoryInfo.call(info) != 0
+      end
+
+      def SetConsoleMode(handle, mode)
+         SetConsoleMode.call(handle, mode) != 0
+      end
+
+      def SetConsoleOutputCP(code_page_id)
+         SetConsoleOutputCP.call(code_page_id) != 0
+      end
+      
+      def SetConsoleScreenBufferSize(handle, size)
+         SetConsoleScreenBufferSize.call(handle, size) != 0
+      end
+
+      def SetConsoleTextAttribute(handle, attribute)
+         SetConsoleTextAttribute.call(handle, attribute) != 0
+      end
+
+      def SetConsoleTitle(title)
+         SetConsoleTitle.call(title) != 0
+      end
+
+      def SetConsoleWindowInfo(handle, absolute, window)
+         SetConsoleWindowInfo.call(handle, absolute, window) != 0
+      end
+
+      def SetStdHandle(std_handle, handle)
+         SetStdHandle.call(std_handle, handle) != 0
+      end
+
+      def WriteConsole(handle, buffer, num_to_write, num_written, res = 0)
+         WriteConsole.call(handle, buffer, num_to_write, num_written, res) != 0
+      end
+
+      def WriteConsoleInput(handle, buffer, length, num_events)
+         WriteConsoleInput.call(handle, buffer, length, num_events) != 0
+      end
+
+      def WriteConsoleOutput(handle, buffer, buf_size, coord, region)
+         WriteConsoleOutput.call(handle, buffer, buf_size, coord, region) != 0
+      end
+
+      def WriteConsoleOutputAttribute(handle, attrib, length, coord, num)
+         WriteConsoleOutputAttribute.call(handle, attrib, length, coord, num) != 0
+      end
+
+      def WriteConsoleOutputCharacter(handle, char, length, coord, num)
+         WriteConsoleOutputCharacter.call(handle, char, length, coord, num) != 0
+      end
+   end
+end