win 0.3.8 → 0.3.11

data/HISTORY

@@ -26,3 +26,15 @@
 == 0.3.8 / 2010-06-02
 
 * Require paths bug fixed
+
+== 0.3.9 / 2010-06-02
+
+* Changed Win::Library mix-in mode from include to extend
+
+== 0.3.10 / 2010-06-02
+
+* Win::Library.extended refactored with module_function
+
+== 0.3.11 / 2010-06-03
+
+* GetDlgCtrlID function added

data/VERSION

@@ -1 +1 @@
-0.3.8
+0.3.11

data/lib/win/dde.rb

@@ -5,7 +5,7 @@ module Win
   # Includes functions related to DDE exchange protocol in Windows
   #
   module Dde
-    include Win::Library
+    extend Win::Library
 
     # Windows ANSI codepage:
     CP_WINANSI = 1004

data/lib/win/error.rb

@@ -7,7 +7,7 @@ module Win
   # other modules may contain additional error codes specific to their domain.
   #
   module Error
-    include Win::Library
+    extend Win::Library
 
     #Error codes:
 

data/lib/win/gui/dialog.rb

@@ -8,7 +8,7 @@ module Win
     # Windows dialog basics can be found here:
     # http://msdn.microsoft.com/en-us/library/ms644996#init_box
     module Dialog
-      include Win::Library
+      extend Win::Library
       include Win::Gui::Window
 
       # Message Box flags:
@@ -300,6 +300,36 @@ module Win
                   caption_pointer = FFI::MemoryPointer.from_string(caption)
                   api.call handle, text_pointer, caption_pointer, type }
 
+      ##
+      # The GetDlgCtrlID function retrieves the identifier of the specified control. In other words,
+      # you give it a handle (say, for a button window inside a dialog), and it returns control ID
+      # that this window is associated with (say IDOK - meaning this window is in fact "OK" button.
+      #
+      # [*Syntax*] int GetDlgCtrlID( HWND hwndCtl );
+      #
+      # hwndCtl:: [in] Handle to the control.
+      #
+      # *Returns*:: If the function succeeds, the return value is the identifier of the control.
+      # If the function fails, the return value is zero. An invalid value for the hwndCtl parameter, for
+      # example, will cause the function to fail. To get extended error information, call GetLastError.
+      # ---
+      # *Remarks*:
+      # GetDlgCtrlID accepts child window handles as well as handles of controls in dialog boxes. An
+      # application sets the identifier for a child window when it creates the window by assigning the
+      # identifier value to the hmenu parameter when calling the CreateWindow or CreateWindowEx function.
+      # Although GetDlgCtrlID may return a value if hwndCtl is a handle to a top-level window, top-level
+      # windows cannot have identifiers and such a return value is never valid.
+      # ---
+      # *See* *Also*
+      # Dialog Boxes Overview, CreateWindow, CreateWindowEx, GetDlgItem
+      # ---
+      # <b>Enhanced (snake_case) API: returns nil instead of zero if function fails</b>
+      #
+      # :call-seq:
+      #  control_id = get_dlg_ctrl_id(control_handle)
+      #
+      function :GetDlgCtrlID, [:HWND], :int, zeronil: true
+
       # Untested:
 
       ##
@@ -315,8 +345,6 @@ module Win
       ##
       function :GetDialogBaseUnits, 'V', 'L'
       ##
-      function :GetDlgCtrlID, 'L', 'I'
-      ##
       function :GetDlgItemText, 'LIPI', 'I'
       ##
       function :GetNextDlgGroupItem, 'LLI', 'L'

data/lib/win/gui/input.rb

@@ -5,7 +5,7 @@ module Win
     # Contains constants and Win32API functions related to end user input
     #
     module Input
-      include Win::Library
+      extend Win::Library
 
       # Windows defined constants:
 

data/lib/win/gui/message.rb

@@ -39,7 +39,7 @@ module Win
     #  WM::  General window
 
     module Message
-      include Win::Library
+      extend Win::Library
 
       # General window messages cover a wide range of information and requests, including messages for mouse and
       # keyboard input, menu and dialog box input, window creation and management, and Dynamic Data Exchange (DDE).
@@ -505,6 +505,13 @@ module Win
       #
       function :SendMessage, [:ulong, :uint, :uint, :pointer], :int   # LPARAM different from PostMessage!
 
+      ##
+      # :method: :SendMessageLong?
+      # We need to attach another SendMessage function, this time accepting :long instead of :pointer lParam.
+      # I do not know yet how to make FFI attach functions with same name, but different signature...
+      #
+      # function :SendMessage, [:ulong, :uint, :uint, :long], :int, alias: send_message_long?
+
       ##
       # The GetMessage function retrieves a message from the calling thread's message queue. The function
       # dispatches incoming sent messages until a posted message is available for retrieval.

data/lib/win/gui/window.rb

@@ -6,7 +6,7 @@ module Win
     # Contains constants and Win32API functions related to window manipulation
     #
     module Window
-      include Win::Library
+      extend Win::Library
 
       # ShowWindow constants:
 
@@ -390,7 +390,7 @@ module Win
                &->(api, handle, cmd=SW_SHOW) { api.call handle, cmd }
 
       ##
-      # The CloseWindow function minimizes (but does not destroy) the specified window.
+      # The CloseWindow function MINIMIZES (but does not destroy) the specified window.
       #
       # [*Syntax*]: BOOL CloseWindow( HWND hWnd );
       #
@@ -451,7 +451,7 @@ module Win
       # *Returns*: Pair of identifiers of the thread and process_id that created the window.
       #
       #:call-seq:
-      #   thread, process_id = [get_]window_tread_process_id( win_handle )
+      #   thread, process_id = [get_]window_thread_process_id( win_handle )
       #
       function :GetWindowThreadProcessId, [:HWND, :pointer], :long,
                &->(api, handle) {
@@ -812,7 +812,7 @@ module Win
       #
       function :GetAncestor, [:HWND, :UINT], :HWND, zeronil: true
 
-      
+
       # Convenience wrapper methods:
 
       ##

data/lib/win/library.rb

@@ -26,6 +26,399 @@ module Win
   # behavior you need.
   #
   module Library
+    include FFI::Library
+
+    # Mapping of Windows API types and one-letter shortcuts into FFI types.
+    # Like :ATOM => :ushort, :LPARAM => :long, :c => :char, :i => :int
+    TYPES = {
+            # FFI type shortcuts
+            C:  :uchar, #– 8-bit unsigned character (byte)
+            c:  :char, # 8-bit character (byte)
+            #   :int8       – 8-bit signed integer
+            #   :uint8      – 8-bit unsigned integer
+            S:  :ushort, # – 16-bit unsigned integer (Win32/API: S used for string params)
+            s:  :short, # – 16-bit signed integer
+            #   :uint16     – 16-bit unsigned integer
+            #   :int16      – 16-bit signed integer
+            I:  :uint, # 32-bit unsigned integer
+            i:  :int, # 32-bit signed integer
+            #   :uint32     – 32-bit unsigned integer
+            #   :int32      – 32-bit signed integer
+            L:  :ulong, # unsigned long int – platform-specific size
+            l:  :long, # long int – platform-specific size. For discussion of platforms, see:
+            #                (http://groups.google.com/group/ruby-ffi/browse_thread/thread/4762fc77130339b1)
+            #   :int64      – 64-bit signed integer
+            #   :uint64     – 64-bit unsigned integer
+            #   :long_long  – 64-bit signed integer
+            #   :ulong_long – 64-bit unsigned integer
+            F:  :float, # 32-bit floating point
+            D:  :double, # 64-bit floating point (double-precision)
+            P:  :pointer, # pointer – platform-specific size
+            p:  :string, # C-style (NULL-terminated) character string (Win32API: S)
+            B:  :bool, # (?? 1 byte in C++)
+            V:  :void, # For functions that return nothing (return type void).
+            v:  :void, # For functions that return nothing (return type void).
+            # For function argument type only:
+            # :buffer_in    – Similar to :pointer, but optimized for Buffers that the function can only read (not write).
+            # :buffer_out   – Similar to :pointer, but optimized for Buffers that the function can only write (not read).
+            # :buffer_inout – Similar to :pointer, but may be optimized for Buffers.
+            # :varargs      – Variable arguments
+            # :enum         - Enumerable type (should be defined)
+            # :char_array   - ??
+
+            # Windows-specific type defs (ms-help://MS.MSDNQTR.v90.en/winprog/winprog/windows_data_types.htm):
+            ATOM:      :ushort, # Atom ~= Symbol: Atom table stores strings and corresponding identifiers. Application
+            # places a string in an atom table and receives a 16-bit integer, called an atom, that
+            # can be used to access the string. Placed string is called an atom name.
+            # See: http://msdn.microsoft.com/en-us/library/ms648708%28VS.85%29.aspx
+            BOOL:      :bool,
+            BOOLEAN:   :bool,
+            BYTE:      :uchar, # Byte (8 bits). Declared as unsigned char
+            #CALLBACK:  K,       # Win32.API gem-specific ?? MSDN: #define CALLBACK __stdcall
+            CHAR:      :char, # 8-bit Windows (ANSI) character. See http://msdn.microsoft.com/en-us/library/dd183415%28VS.85%29.aspx
+            COLORREF:  :uint32, # Red, green, blue (RGB) color value (32 bits). See COLORREF for more info.
+            DWORD:     :uint32, # 32-bit unsigned integer. The range is 0 through 4,294,967,295 decimal.
+            DWORDLONG: :uint64, # 64-bit unsigned integer. The range is 0 through 18,446,744,073,709,551,615 decimal.
+            DWORD_PTR: :ulong, # Unsigned long type for pointer precision. Use when casting a pointer to a long type
+            # to perform pointer arithmetic. (Also commonly used for general 32-bit parameters that have
+            # been extended to 64 bits in 64-bit Windows.)  BaseTsd.h: #typedef ULONG_PTR DWORD_PTR;
+            DWORD32:   :uint32,
+            DWORD64:   :uint64,
+            HALF_PTR:  :int, # Half the size of a pointer. Use within a structure that contains a pointer and two small fields.
+            # BaseTsd.h: #ifdef (_WIN64) typedef int HALF_PTR; #else typedef short HALF_PTR;
+            HACCEL:    :ulong, # (L) Handle to an accelerator table. WinDef.h: #typedef HANDLE HACCEL;
+            # See http://msdn.microsoft.com/en-us/library/ms645526%28VS.85%29.aspx
+            HANDLE:    :ulong, # (L) Handle to an object. WinNT.h: #typedef PVOID HANDLE;
+            # todo: Platform-dependent! Need to change to :uint64 for Win64
+            HBITMAP:   :ulong, # (L) Handle to a bitmap: http://msdn.microsoft.com/en-us/library/dd183377%28VS.85%29.aspx
+            HBRUSH:    :ulong, # (L) Handle to a brush. http://msdn.microsoft.com/en-us/library/dd183394%28VS.85%29.aspx
+            HCOLORSPACE: :ulong, # (L) Handle to a color space. http://msdn.microsoft.com/en-us/library/ms536546%28VS.85%29.aspx
+            HCURSOR:   :ulong, # (L) Handle to a cursor. http://msdn.microsoft.com/en-us/library/ms646970%28VS.85%29.aspx
+            HCONV:     :ulong, # (L) Handle to a dynamic data exchange (DDE) conversation.
+            HCONVLIST: :ulong, # (L) Handle to a DDE conversation list. HANDLE - L ?
+            HDDEDATA:  :ulong, # (L) Handle to DDE data (structure?)
+            HDC:       :ulong, # (L) Handle to a device context (DC). http://msdn.microsoft.com/en-us/library/dd183560%28VS.85%29.aspx
+            HDESK:     :ulong, # (L) Handle to a desktop. http://msdn.microsoft.com/en-us/library/ms682573%28VS.85%29.aspx
+            HDROP:     :ulong, # (L) Handle to an internal drop structure.
+            HDWP:      :ulong, # (L) Handle to a deferred window position structure.
+            HENHMETAFILE: :ulong, #(L) Handle to an enhanced metafile. http://msdn.microsoft.com/en-us/library/dd145051%28VS.85%29.aspx
+            HFILE:     :uint, # (I) Special file handle to a file opened by OpenFile, not CreateFile.
+            # WinDef.h: #typedef int HFILE;
+            HFONT:     :ulong, # (L) Handle to a font. http://msdn.microsoft.com/en-us/library/dd162470%28VS.85%29.aspx
+            HGDIOBJ:   :ulong, # (L) Handle to a GDI object.
+            HGLOBAL:   :ulong, # (L) Handle to a global memory block.
+            HHOOK:     :ulong, # (L) Handle to a hook. http://msdn.microsoft.com/en-us/library/ms632589%28VS.85%29.aspx
+            HICON:     :ulong, # (L) Handle to an icon. http://msdn.microsoft.com/en-us/library/ms646973%28VS.85%29.aspx
+            HINSTANCE: :ulong, # (L) Handle to an instance. This is the base address of the module in memory.
+            # HMODULE and HINSTANCE are the same today, but were different in 16-bit Windows.
+            HKEY:      :ulong, # (L) Handle to a registry key.
+            HKL:       :ulong, # (L) Input locale identifier.
+            HLOCAL:    :ulong, # (L) Handle to a local memory block.
+            HMENU:     :ulong, # (L) Handle to a menu. http://msdn.microsoft.com/en-us/library/ms646977%28VS.85%29.aspx
+            HMETAFILE: :ulong, # (L) Handle to a metafile. http://msdn.microsoft.com/en-us/library/dd145051%28VS.85%29.aspx
+            HMODULE:   :ulong, # (L) Handle to an instance. Same as HINSTANCE today, but was different in 16-bit Windows.
+            HMONITOR:  :ulong, # (L) Рandle to a display monitor. WinDef.h: if(WINVER >= 0x0500) typedef HANDLE HMONITOR;
+            HPALETTE:  :ulong, # (L) Handle to a palette.
+            HPEN:      :ulong, # (L) Handle to a pen. http://msdn.microsoft.com/en-us/library/dd162786%28VS.85%29.aspx
+            HRESULT:   :long, # Return code used by COM interfaces. For more info, Structure of the COM Error Codes.
+            # To test an HRESULT value, use the FAILED and SUCCEEDED macros.
+            HRGN:      :ulong, # (L) Handle to a region. http://msdn.microsoft.com/en-us/library/dd162913%28VS.85%29.aspx
+            HRSRC:     :ulong, # (L) Handle to a resource.
+            HSZ:       :ulong, # (L) Handle to a DDE string.
+            HWINSTA:   :ulong, # (L) Handle to a window station. http://msdn.microsoft.com/en-us/library/ms687096%28VS.85%29.aspx
+            HWND:      :ulong, # (L) Handle to a window. http://msdn.microsoft.com/en-us/library/ms632595%28VS.85%29.aspx
+            INT:       :int, # 32-bit signed integer. The range is -2147483648 through 2147483647 decimal.
+            INT_PTR:   :int, # Signed integer type for pointer precision. Use when casting a pointer to an integer
+            # to perform pointer arithmetic. BaseTsd.h:
+            #if defined(_WIN64) typedef __int64 INT_PTR; #else typedef int INT_PTR;
+            INT32:    :int32, # 32-bit signed integer. The range is -2,147,483,648 through +...647 decimal.
+            INT64:    :int64, # 64-bit signed integer. The range is –9,223,372,036,854,775,808 through +...807
+            LANGID:   :ushort, # Language identifier. For more information, see Locales. WinNT.h: #typedef WORD LANGID;
+            # See http://msdn.microsoft.com/en-us/library/dd318716%28VS.85%29.aspx
+            LCID:     :uint32, # Locale identifier. For more information, see Locales.
+            LCTYPE:   :uint32, # Locale information type. For a list, see Locale Information Constants.
+            LGRPID:   :uint32, # Language group identifier. For a list, see EnumLanguageGroupLocales.
+            LONG:     :long, # 32-bit signed integer. The range is -2,147,483,648 through +...647 decimal.
+            LONG32:   :int32, # 32-bit signed integer. The range is -2,147,483,648 through +...647 decimal.
+            LONG64:   :int64, # 64-bit signed integer. The range is –9,223,372,036,854,775,808 through +...807
+            LONGLONG: :int64, # 64-bit signed integer. The range is –9,223,372,036,854,775,808 through +...807
+            LONG_PTR: :long, # Signed long type for pointer precision. Use when casting a pointer to a long to
+            # perform pointer arithmetic. BaseTsd.h:
+            #if defined(_WIN64) typedef __int64 LONG_PTR; #else typedef long LONG_PTR;
+            LPARAM:   :long, # Message parameter. WinDef.h as follows: #typedef LONG_PTR LPARAM;
+            LPBOOL:   :pointer, # Pointer to a BOOL. WinDef.h as follows: #typedef BOOL far *LPBOOL;
+            LPBYTE:   :pointer, # Pointer to a BYTE. WinDef.h as follows: #typedef BYTE far *LPBYTE;
+            LPCOLORREF: :pointer, # Pointer to a COLORREF value. WinDef.h as follows: #typedef DWORD *LPCOLORREF;
+            LPCSTR:   :pointer, # Pointer to a constant null-terminated string of 8-bit Windows (ANSI) characters.
+            # See Character Sets Used By Fonts. http://msdn.microsoft.com/en-us/library/dd183415%28VS.85%29.aspx
+            LPCTSTR:  :pointer, # An LPCWSTR if UNICODE is defined, an LPCSTR otherwise.
+            LPCVOID:  :pointer, # Pointer to a constant of any type. WinDef.h as follows: typedef CONST void *LPCVOID;
+            LPCWSTR:  :pointer, # Pointer to a constant null-terminated string of 16-bit Unicode characters.
+            LPDWORD:  :pointer, # Pointer to a DWORD. WinDef.h as follows: typedef DWORD *LPDWORD;
+            LPHANDLE: :pointer, # Pointer to a HANDLE. WinDef.h as follows: typedef HANDLE *LPHANDLE;
+            LPINT:    :pointer, # Pointer to an INT.
+            LPLONG:   :pointer, # Pointer to an LONG.
+            LPSTR:    :pointer, # Pointer to a null-terminated string of 8-bit Windows (ANSI) characters.
+            LPTSTR:   :pointer, # An LPWSTR if UNICODE is defined, an LPSTR otherwise.
+            LPVOID:   :pointer, # Pointer to any type.
+            LPWORD:   :pointer, # Pointer to a WORD.
+            LPWSTR:   :pointer, # Pointer to a null-terminated string of 16-bit Unicode characters.
+            LRESULT:  :long, # Signed result of message processing. WinDef.h: typedef LONG_PTR LRESULT;
+            PBOOL:    :pointer, # Pointer to a BOOL.
+            PBOOLEAN: :pointer, # Pointer to a BOOL.
+            PBYTE:    :pointer, # Pointer to a BYTE.
+            PCHAR:    :pointer, # Pointer to a CHAR.
+            PCSTR:    :pointer, # Pointer to a constant null-terminated string of 8-bit Windows (ANSI) characters.
+            PCTSTR:   :pointer, # A PCWSTR if UNICODE is defined, a PCSTR otherwise.
+            PCWSTR:    :pointer, # Pointer to a constant null-terminated string of 16-bit Unicode characters.
+            PDWORD:    :pointer, # Pointer to a DWORD.
+            PDWORDLONG: :pointer, # Pointer to a DWORDLONG.
+            PDWORD_PTR: :pointer, # Pointer to a DWORD_PTR.
+            PDWORD32:  :pointer, # Pointer to a DWORD32.
+            PDWORD64:  :pointer, # Pointer to a DWORD64.
+            PFLOAT:    :pointer, # Pointer to a FLOAT.
+            PHALF_PTR: :pointer, # Pointer to a HALF_PTR.
+            PHANDLE:   :pointer, # Pointer to a HANDLE.
+            PHKEY:     :pointer, # Pointer to an HKEY.
+            PINT:      :pointer, # Pointer to an INT.
+            PINT_PTR:  :pointer, # Pointer to an INT_PTR.
+            PINT32:    :pointer, # Pointer to an INT32.
+            PINT64:    :pointer, # Pointer to an INT64.
+            PLCID:     :pointer, # Pointer to an LCID.
+            PLONG:     :pointer, # Pointer to a LONG.
+            PLONGLONG: :pointer, # Pointer to a LONGLONG.
+            PLONG_PTR: :pointer, # Pointer to a LONG_PTR.
+            PLONG32:   :pointer, # Pointer to a LONG32.
+            PLONG64:   :pointer, # Pointer to a LONG64.
+            POINTER_32: :pointer, # 32-bit pointer. On a 32-bit system, this is a native pointer. On a 64-bit system, this is a truncated 64-bit pointer.
+            POINTER_64: :pointer, # 64-bit pointer. On a 64-bit system, this is a native pointer. On a 32-bit system, this is a sign-extended 32-bit pointer.
+            POINTER_SIGNED:   :pointer, # A signed pointer.
+            POINTER_UNSIGNED: :pointer, # An unsigned pointer.
+            PSHORT:     :pointer, # Pointer to a SHORT.
+            PSIZE_T:    :pointer, # Pointer to a SIZE_T.
+            PSSIZE_T:   :pointer, # Pointer to a SSIZE_T.
+            PSTR:       :pointer, # Pointer to a null-terminated string of 8-bit Windows (ANSI) characters. For more information, see Character Sets Used By Fonts.
+            PTBYTE:     :pointer, # Pointer to a TBYTE.
+            PTCHAR:     :pointer, # Pointer to a TCHAR.
+            PTSTR:      :pointer, # A PWSTR if UNICODE is defined, a PSTR otherwise.
+            PUCHAR:     :pointer, # Pointer to a UCHAR.
+            PUHALF_PTR: :pointer, # Pointer to a UHALF_PTR.
+            PUINT:      :pointer, # Pointer to a UINT.
+            PUINT_PTR:  :pointer, # Pointer to a UINT_PTR.
+            PUINT32:    :pointer, # Pointer to a UINT32.
+            PUINT64:    :pointer, # Pointer to a UINT64.
+            PULONG:     :pointer, # Pointer to a ULONG.
+            PULONGLONG: :pointer, # Pointer to a ULONGLONG.
+            PULONG_PTR: :pointer, # Pointer to a ULONG_PTR.
+            PULONG32:   :pointer, # Pointer to a ULONG32.
+            PULONG64:   :pointer, # Pointer to a ULONG64.
+            PUSHORT:    :pointer, # Pointer to a USHORT.
+            PVOID:      :pointer, # Pointer to any type.
+            PWCHAR:     :pointer, # Pointer to a WCHAR.
+            PWORD:      :pointer, # Pointer to a WORD.
+            PWSTR:      :pointer, # Pointer to a null- terminated string of 16-bit Unicode characters.
+            # For more information, see Character Sets Used By Fonts.
+            SC_HANDLE:  :ulong, # (L) Handle to a service control manager database.
+            # See SCM Handles http://msdn.microsoft.com/en-us/library/ms685104%28VS.85%29.aspx
+            SC_LOCK:    :pointer, # Lock to a service control manager database. For more information, see SCM Handles.
+            SERVICE_STATUS_HANDLE: :ulong, # (L) Handle to a service status value. See SCM Handles.
+            SHORT:     :short, # A 16-bit integer. The range is –32768 through 32767 decimal.
+            SIZE_T:    :ulong, #  The maximum number of bytes to which a pointer can point. Use for a count that must span the full range of a pointer.
+            SSIZE_T:   :long, # Signed SIZE_T.
+            TBYTE:     :short, # A WCHAR if UNICODE is defined, a CHAR otherwise.TCHAR:
+            TCHAR:     :short, # A WCHAR if UNICODE is defined, a CHAR otherwise.TCHAR:
+            UCHAR:     :uchar, # Unsigned CHAR (8 bit)
+            UHALF_PTR: :uint, # Unsigned HALF_PTR. Use within a structure that contains a pointer and two small fields.
+            UINT:      :uint, # Unsigned INT. The range is 0 through 4294967295 decimal.
+            UINT_PTR:  :uint, # Unsigned INT_PTR.
+            UINT32:    :uint32, # Unsigned INT32. The range is 0 through 4294967295 decimal.
+            UINT64:    :uint64, # Unsigned INT64. The range is 0 through 18446744073709551615 decimal.
+            ULONG:     :ulong, # Unsigned LONG. The range is 0 through 4294967295 decimal.
+            ULONGLONG: :ulong_long, # 64-bit unsigned integer. The range is 0 through 18446744073709551615 decimal.
+            ULONG_PTR: :ulong, # Unsigned LONG_PTR.
+            ULONG32:   :uint32, # Unsigned INT32. The range is 0 through 4294967295 decimal.
+            ULONG64:   :uint64, # Unsigned LONG64. The range is 0 through 18446744073709551615 decimal.
+            UNICODE_STRING: :pointer, # Pointer to some string structure??
+            USHORT:    :ushort, # Unsigned SHORT. The range is 0 through 65535 decimal.
+            USN:    :ulong_long, # Update sequence number (USN).
+            VOID:   [], # Any type ? Only use it to indicate no arguments or no return value
+            WCHAR:  :ushort, # 16-bit Unicode character. For more information, see Character Sets Used By Fonts.
+            # In WinNT.h: typedef wchar_t WCHAR;
+            #WINAPI: K,      # Calling convention for system functions. WinDef.h: define WINAPI __stdcall
+            WORD: :ushort, # 16-bit unsigned integer. The range is 0 through 65535 decimal.
+            WPARAM: :uint    # Message parameter. WinDef.h as follows: typedef UINT_PTR WPARAM;
+    }
+
+    ##
+    # Defines new method wrappers for Windows API function call:
+    # - Defines method with original (CamelCase) API function name and original signature (matches MSDN description)
+    # - Defines method with snake_case name (converted from CamelCase function name) with enhanced API signature
+    #   When defined snake_case method is called, it converts the arguments you provided into ones required by
+    #   original API (adding defaults, mute and transitory args as necessary), executes API function call
+    #   and (optionally) transforms the result before returning it. If a block is attached to
+    #   method invocation, raw result is yielded to this block before final transformation take place
+    # - Defines aliases for enhanced method with more Rubyesque names for getters, setters and tests:
+    #   GetWindowText -> window_test, SetWindowText -> window_text=, IsZoomed -> zoomed?
+    # ---
+    # You may modify default behavior of defined method by providing optional *def_block* to function definition.
+    # If you do so, snake_case method is defined based on your *def_block*. It receives callable API
+    # object for function being defined, arguments and (optional) runtime block with which the method
+    # will be called. Results coming from &def_block are then transformed and returned.
+    # So, your *def_block* should specify all the behavior of the method being defined. You can use *def_block* to:
+    # - Change original signature of API function, provide argument defaults, check argument types
+    # - Pack arguments into strings/structs for <in> or <in/out> parameters that expect a pointer
+    # - Allocate buffers/structs for pointers required by API functions <out> parameters
+    # - Unpack <out> and <in/out> parameters returned as pointers
+    # - Explicitly return results of API call that are returned in <out> and <in/out> parameters
+    # - Convert attached runtime blocks into callback functions and stuff them into <in> callback parameters
+    # - do other stuff that you think is appropriate to make Windows API function behavior more Ruby-like...
+    # ---
+    # Accepts following options:
+    # :dll:: Use this dll instead of default 'user32'
+    # :rename:: Use this name instead of standard (conventional) function name
+    # :alias(es):: Provides additional alias(es) for defined method
+    # :boolean:: Forces method to return true/false instead of nonzero/zero
+    # :zeronil:: Forces method to return nil if function result is zero
+    #
+    def function(name, params, returns, options={}, &def_block)
+      snake_name, effective_names, aliases = generate_names(name, options)
+      params, returns = generate_signature(params, returns)
+      libs = ffi_libraries.map(&:name)
+      boolean = options[:boolean]
+      zeronil = options[:zeronil]
+
+      effective_name = effective_names.inject(nil) do |func, effective_name|
+        func || begin
+          # tries to attach basic CamelCase method via FFI
+          attach_function(name, effective_name, params.dup, returns)
+          effective_name
+        rescue FFI::NotFoundError
+          nil
+        end
+      end
+
+      raise Win::Errors::NotFoundError.new(name, libs) unless effective_name
+
+      # Create API object that holds information about function names, params, etc
+      api = API.new(namespace, name, effective_name, params, returns, libs)
+
+      # Only define enhanced API if snake_name is different from original name (e.g. keybd_event),
+      # If names are the same, this function is already "attached", not possible to enhance its API
+      unless snake_name.to_s == name.to_s
+        method_body = if def_block
+          if zeronil
+            ->(*args, &block){ (res = def_block.(api, *args, &block)) != 0 ? res : nil }
+          elsif boolean
+            ->(*args, &block){ def_block.(api, *args, &block) != 0 }
+          else
+            ->(*args, &block){ def_block.(api, *args, &block) }
+          end
+        else
+          if zeronil
+            ->(*args, &block){ (res = block ? block[api.call(*args)] : api.call(*args)) != 0 ? res : nil }
+          elsif boolean
+            ->(*args, &block){ block ? block[api.call(*args)] : api.call(*args) != 0 }
+          else
+            ->(*args, &block){ block ? block[api.call(*args)] : api.call(*args) }
+          end
+        end
+
+        define_method snake_name, &method_body       # define snake_case instance method
+
+#        module_function snake_name    # TODO: Doesn't work as a perfect replacement for eigen_class stuff. :( Why?
+
+        eigen_class = class << self;
+          self;
+        end        # Extracting eigenclass
+
+        eigen_class.class_eval do
+          define_method snake_name, &method_body       # define snake_case class method
+        end
+      end
+
+      aliases.each {|ali| alias_method ali, snake_name }  # define aliases
+      api   #return api object from function declaration
+    end
+
+    # Try to define platform-specific function, rescue error, return message
+    #
+    def try_function(name, params, returns, options={}, &def_block)
+      begin
+        function name, params, returns, options={}, &def_block
+      rescue Win::Errors::NotFoundError
+        "This platform does not support function #{name}"
+      end
+    end
+
+    # Generates possible effective names for function in Win32 dll (name+A/W),
+    # Rubyesque name and aliases for method(s) defined based on function name,
+    #
+    def generate_names(name, options={})
+      name = name.to_s
+      effective_names = [name]
+      effective_names += ["#{name}A", "#{name}W"] unless name =~ /[WA]$/
+      aliases = ([options[:alias]] + [options[:aliases]]).flatten.compact
+      snake_name = options[:rename] || name.snake_case
+      case snake_name
+        when /^is_/
+          aliases << snake_name.sub(/^is_/, '') + '?'
+        when /^set_/
+          aliases << snake_name.sub(/^set_/, '')+ '='
+        when /^get_/
+          aliases << snake_name.sub(/^get_/, '')
+      end
+      [snake_name, effective_names, aliases]
+    end
+
+    ##
+    # Generates params and returns (signature) containing only FFI-compliant types
+    #
+    def generate_signature(params, returns)
+      params = params.split(//) if params.respond_to?(:split) # Convert params string into array
+      params.map! {|param| TYPES[param.to_sym] || param} # Convert chars into FFI type symbols
+      returns = TYPES[returns.to_sym] || returns # Convert chars into FFI type symbols
+      [params, returns]
+    end
+
+    ##
+    # Wrapper for FFI::Library.callback() that converts Win32/shortcut argument types into FFI-compliant types.
+    # This method overrides FFI::Library.callback
+    #
+    def callback(name, params, returns)
+      params, returns = generate_signature(params, returns)
+      super name.to_sym, params, returns
+    end
+
+    ##
+    # :method: namespace
+    # This method is meta-generated when Win::Library module is included into other module/class.
+    # It returns reference to including (host) class/module for use by Win::Library::API and class methods.
+
+    ##
+    # Ensures that args count is equal to params count plus diff
+    #
+    def enforce_count(args, params, diff = 0)
+      num_args = args.size
+      num_params = params.size + diff #params == 'V' ? 0 : params.size + diff
+      if num_args != num_params
+        raise ArgumentError, "wrong number of arguments (#{num_args} for #{num_params})"
+      end
+    end
+
+    ##
+    # Hook executed when Win::Library extends other module or class. It adds namespace method pointing
+    # to host module/class that is used by Win::Library to invoke attached (CamelCase) functions.
+    # Also sets default ffi libs and calling conventions.
+    def self.extended(host)
+
+      host.module_eval do
+        define_method(:namespace) {host}
+        module_function :namespace
+      end
+
+      host.ffi_lib 'user32', 'kernel32'  # Default libraries
+      host.ffi_convention :stdcall
+    end
 
     # Win::Library::API is a wrapper for callable function API object that mimics Win32::API
     class API
@@ -63,407 +456,7 @@ module Win
         @namespace.send(@function_name.to_sym, *args)
       end
 
-     # alias_method :[], :call
-    end
-
-    # Contains class methods (macros) that can be used in any module mixing in Win::Library
-    module ClassMethods
-
-      # Mapping of Windows API types and one-letter shortcuts into FFI types.
-      # Like :ATOM => :ushort, :LPARAM => :long, :c => :char, :i => :int
-      TYPES = {
-              # FFI type shortcuts
-              C:  :uchar, #– 8-bit unsigned character (byte)
-              c:  :char, # 8-bit character (byte)
-              #   :int8       – 8-bit signed integer
-              #   :uint8      – 8-bit unsigned integer
-              S:  :ushort, # – 16-bit unsigned integer (Win32/API: S used for string params)
-              s:  :short, # – 16-bit signed integer
-              #   :uint16     – 16-bit unsigned integer
-              #   :int16      – 16-bit signed integer
-              I:  :uint, # 32-bit unsigned integer
-              i:  :int, # 32-bit signed integer
-              #   :uint32     – 32-bit unsigned integer
-              #   :int32      – 32-bit signed integer
-              L:  :ulong, # unsigned long int – platform-specific size
-              l:  :long, # long int – platform-specific size. For discussion of platforms, see:
-              #                (http://groups.google.com/group/ruby-ffi/browse_thread/thread/4762fc77130339b1)
-              #   :int64      – 64-bit signed integer
-              #   :uint64     – 64-bit unsigned integer
-              #   :long_long  – 64-bit signed integer
-              #   :ulong_long – 64-bit unsigned integer
-              F:  :float, # 32-bit floating point
-              D:  :double, # 64-bit floating point (double-precision)
-              P:  :pointer, # pointer – platform-specific size
-              p:  :string, # C-style (NULL-terminated) character string (Win32API: S)
-              B:  :bool, # (?? 1 byte in C++)
-              V:  :void, # For functions that return nothing (return type void).
-              v:  :void, # For functions that return nothing (return type void).
-              # For function argument type only:
-              # :buffer_in    – Similar to :pointer, but optimized for Buffers that the function can only read (not write).
-              # :buffer_out   – Similar to :pointer, but optimized for Buffers that the function can only write (not read).
-              # :buffer_inout – Similar to :pointer, but may be optimized for Buffers.
-              # :varargs      – Variable arguments
-              # :enum         - Enumerable type (should be defined)
-              # :char_array   - ??
-
-              # Windows-specific type defs (ms-help://MS.MSDNQTR.v90.en/winprog/winprog/windows_data_types.htm):
-              ATOM:      :ushort, # Atom ~= Symbol: Atom table stores strings and corresponding identifiers. Application
-              # places a string in an atom table and receives a 16-bit integer, called an atom, that
-              # can be used to access the string. Placed string is called an atom name.
-              # See: http://msdn.microsoft.com/en-us/library/ms648708%28VS.85%29.aspx
-              BOOL:      :bool,
-              BOOLEAN:   :bool,
-              BYTE:      :uchar, # Byte (8 bits). Declared as unsigned char
-              #CALLBACK:  K,       # Win32.API gem-specific ?? MSDN: #define CALLBACK __stdcall
-              CHAR:      :char, # 8-bit Windows (ANSI) character. See http://msdn.microsoft.com/en-us/library/dd183415%28VS.85%29.aspx
-              COLORREF:  :uint32, # Red, green, blue (RGB) color value (32 bits). See COLORREF for more info.
-              DWORD:     :uint32, # 32-bit unsigned integer. The range is 0 through 4,294,967,295 decimal.
-              DWORDLONG: :uint64, # 64-bit unsigned integer. The range is 0 through 18,446,744,073,709,551,615 decimal.
-              DWORD_PTR: :ulong, # Unsigned long type for pointer precision. Use when casting a pointer to a long type
-              # to perform pointer arithmetic. (Also commonly used for general 32-bit parameters that have
-              # been extended to 64 bits in 64-bit Windows.)  BaseTsd.h: #typedef ULONG_PTR DWORD_PTR;
-              DWORD32:   :uint32,
-              DWORD64:   :uint64,
-              HALF_PTR:  :int, # Half the size of a pointer. Use within a structure that contains a pointer and two small fields.
-              # BaseTsd.h: #ifdef (_WIN64) typedef int HALF_PTR; #else typedef short HALF_PTR;
-              HACCEL:    :ulong, # (L) Handle to an accelerator table. WinDef.h: #typedef HANDLE HACCEL;
-              # See http://msdn.microsoft.com/en-us/library/ms645526%28VS.85%29.aspx
-              HANDLE:    :ulong, # (L) Handle to an object. WinNT.h: #typedef PVOID HANDLE;
-              # todo: Platform-dependent! Need to change to :uint64 for Win64
-              HBITMAP:   :ulong, # (L) Handle to a bitmap: http://msdn.microsoft.com/en-us/library/dd183377%28VS.85%29.aspx
-              HBRUSH:    :ulong, # (L) Handle to a brush. http://msdn.microsoft.com/en-us/library/dd183394%28VS.85%29.aspx
-              HCOLORSPACE: :ulong, # (L) Handle to a color space. http://msdn.microsoft.com/en-us/library/ms536546%28VS.85%29.aspx
-              HCURSOR:   :ulong, # (L) Handle to a cursor. http://msdn.microsoft.com/en-us/library/ms646970%28VS.85%29.aspx
-              HCONV:     :ulong, # (L) Handle to a dynamic data exchange (DDE) conversation.
-              HCONVLIST: :ulong, # (L) Handle to a DDE conversation list. HANDLE - L ?
-              HDDEDATA:  :ulong, # (L) Handle to DDE data (structure?)
-              HDC:       :ulong, # (L) Handle to a device context (DC). http://msdn.microsoft.com/en-us/library/dd183560%28VS.85%29.aspx
-              HDESK:     :ulong, # (L) Handle to a desktop. http://msdn.microsoft.com/en-us/library/ms682573%28VS.85%29.aspx
-              HDROP:     :ulong, # (L) Handle to an internal drop structure.
-              HDWP:      :ulong, # (L) Handle to a deferred window position structure.
-              HENHMETAFILE: :ulong, #(L) Handle to an enhanced metafile. http://msdn.microsoft.com/en-us/library/dd145051%28VS.85%29.aspx
-              HFILE:     :uint, # (I) Special file handle to a file opened by OpenFile, not CreateFile.
-              # WinDef.h: #typedef int HFILE;
-              HFONT:     :ulong, # (L) Handle to a font. http://msdn.microsoft.com/en-us/library/dd162470%28VS.85%29.aspx
-              HGDIOBJ:   :ulong, # (L) Handle to a GDI object.
-              HGLOBAL:   :ulong, # (L) Handle to a global memory block.
-              HHOOK:     :ulong, # (L) Handle to a hook. http://msdn.microsoft.com/en-us/library/ms632589%28VS.85%29.aspx
-              HICON:     :ulong, # (L) Handle to an icon. http://msdn.microsoft.com/en-us/library/ms646973%28VS.85%29.aspx
-              HINSTANCE: :ulong, # (L) Handle to an instance. This is the base address of the module in memory.
-              # HMODULE and HINSTANCE are the same today, but were different in 16-bit Windows.
-              HKEY:      :ulong, # (L) Handle to a registry key.
-              HKL:       :ulong, # (L) Input locale identifier.
-              HLOCAL:    :ulong, # (L) Handle to a local memory block.
-              HMENU:     :ulong, # (L) Handle to a menu. http://msdn.microsoft.com/en-us/library/ms646977%28VS.85%29.aspx
-              HMETAFILE: :ulong, # (L) Handle to a metafile. http://msdn.microsoft.com/en-us/library/dd145051%28VS.85%29.aspx
-              HMODULE:   :ulong, # (L) Handle to an instance. Same as HINSTANCE today, but was different in 16-bit Windows.
-              HMONITOR:  :ulong, # (L) Рandle to a display monitor. WinDef.h: if(WINVER >= 0x0500) typedef HANDLE HMONITOR;
-              HPALETTE:  :ulong, # (L) Handle to a palette.
-              HPEN:      :ulong, # (L) Handle to a pen. http://msdn.microsoft.com/en-us/library/dd162786%28VS.85%29.aspx
-              HRESULT:   :long, # Return code used by COM interfaces. For more info, Structure of the COM Error Codes.
-              # To test an HRESULT value, use the FAILED and SUCCEEDED macros.
-              HRGN:      :ulong, # (L) Handle to a region. http://msdn.microsoft.com/en-us/library/dd162913%28VS.85%29.aspx
-              HRSRC:     :ulong, # (L) Handle to a resource.
-              HSZ:       :ulong, # (L) Handle to a DDE string.
-              HWINSTA:   :ulong, # (L) Handle to a window station. http://msdn.microsoft.com/en-us/library/ms687096%28VS.85%29.aspx
-              HWND:      :ulong, # (L) Handle to a window. http://msdn.microsoft.com/en-us/library/ms632595%28VS.85%29.aspx
-              INT:       :int, # 32-bit signed integer. The range is -2147483648 through 2147483647 decimal.
-              INT_PTR:   :int, # Signed integer type for pointer precision. Use when casting a pointer to an integer
-              # to perform pointer arithmetic. BaseTsd.h:
-              #if defined(_WIN64) typedef __int64 INT_PTR; #else typedef int INT_PTR;
-              INT32:    :int32, # 32-bit signed integer. The range is -2,147,483,648 through +...647 decimal.
-              INT64:    :int64, # 64-bit signed integer. The range is –9,223,372,036,854,775,808 through +...807
-              LANGID:   :ushort, # Language identifier. For more information, see Locales. WinNT.h: #typedef WORD LANGID;
-              # See http://msdn.microsoft.com/en-us/library/dd318716%28VS.85%29.aspx
-              LCID:     :uint32, # Locale identifier. For more information, see Locales.
-              LCTYPE:   :uint32, # Locale information type. For a list, see Locale Information Constants.
-              LGRPID:   :uint32, # Language group identifier. For a list, see EnumLanguageGroupLocales.
-              LONG:     :long, # 32-bit signed integer. The range is -2,147,483,648 through +...647 decimal.
-              LONG32:   :int32, # 32-bit signed integer. The range is -2,147,483,648 through +...647 decimal.
-              LONG64:   :int64, # 64-bit signed integer. The range is –9,223,372,036,854,775,808 through +...807
-              LONGLONG: :int64, # 64-bit signed integer. The range is –9,223,372,036,854,775,808 through +...807
-              LONG_PTR: :long, # Signed long type for pointer precision. Use when casting a pointer to a long to
-              # perform pointer arithmetic. BaseTsd.h:
-              #if defined(_WIN64) typedef __int64 LONG_PTR; #else typedef long LONG_PTR;
-              LPARAM:   :long, # Message parameter. WinDef.h as follows: #typedef LONG_PTR LPARAM;
-              LPBOOL:   :pointer, # Pointer to a BOOL. WinDef.h as follows: #typedef BOOL far *LPBOOL;
-              LPBYTE:   :pointer, # Pointer to a BYTE. WinDef.h as follows: #typedef BYTE far *LPBYTE;
-              LPCOLORREF: :pointer, # Pointer to a COLORREF value. WinDef.h as follows: #typedef DWORD *LPCOLORREF;
-              LPCSTR:   :pointer, # Pointer to a constant null-terminated string of 8-bit Windows (ANSI) characters.
-              # See Character Sets Used By Fonts. http://msdn.microsoft.com/en-us/library/dd183415%28VS.85%29.aspx
-              LPCTSTR:  :pointer, # An LPCWSTR if UNICODE is defined, an LPCSTR otherwise.
-              LPCVOID:  :pointer, # Pointer to a constant of any type. WinDef.h as follows: typedef CONST void *LPCVOID;
-              LPCWSTR:  :pointer, # Pointer to a constant null-terminated string of 16-bit Unicode characters.
-              LPDWORD:  :pointer, # Pointer to a DWORD. WinDef.h as follows: typedef DWORD *LPDWORD;
-              LPHANDLE: :pointer, # Pointer to a HANDLE. WinDef.h as follows: typedef HANDLE *LPHANDLE;
-              LPINT:    :pointer, # Pointer to an INT.
-              LPLONG:   :pointer, # Pointer to an LONG.
-              LPSTR:    :pointer, # Pointer to a null-terminated string of 8-bit Windows (ANSI) characters.
-              LPTSTR:   :pointer, # An LPWSTR if UNICODE is defined, an LPSTR otherwise.
-              LPVOID:   :pointer, # Pointer to any type.
-              LPWORD:   :pointer, # Pointer to a WORD.
-              LPWSTR:   :pointer, # Pointer to a null-terminated string of 16-bit Unicode characters.
-              LRESULT:  :long, # Signed result of message processing. WinDef.h: typedef LONG_PTR LRESULT;
-              PBOOL:    :pointer, # Pointer to a BOOL.
-              PBOOLEAN: :pointer, # Pointer to a BOOL.
-              PBYTE:    :pointer, # Pointer to a BYTE.
-              PCHAR:    :pointer, # Pointer to a CHAR.
-              PCSTR:    :pointer, # Pointer to a constant null-terminated string of 8-bit Windows (ANSI) characters.
-              PCTSTR:   :pointer, # A PCWSTR if UNICODE is defined, a PCSTR otherwise.
-              PCWSTR:    :pointer, # Pointer to a constant null-terminated string of 16-bit Unicode characters.
-              PDWORD:    :pointer, # Pointer to a DWORD.
-              PDWORDLONG: :pointer, # Pointer to a DWORDLONG.
-              PDWORD_PTR: :pointer, # Pointer to a DWORD_PTR.
-              PDWORD32:  :pointer, # Pointer to a DWORD32.
-              PDWORD64:  :pointer, # Pointer to a DWORD64.
-              PFLOAT:    :pointer, # Pointer to a FLOAT.
-              PHALF_PTR: :pointer, # Pointer to a HALF_PTR.
-              PHANDLE:   :pointer, # Pointer to a HANDLE.
-              PHKEY:     :pointer, # Pointer to an HKEY.
-              PINT:      :pointer, # Pointer to an INT.
-              PINT_PTR:  :pointer, # Pointer to an INT_PTR.
-              PINT32:    :pointer, # Pointer to an INT32.
-              PINT64:    :pointer, # Pointer to an INT64.
-              PLCID:     :pointer, # Pointer to an LCID.
-              PLONG:     :pointer, # Pointer to a LONG.
-              PLONGLONG: :pointer, # Pointer to a LONGLONG.
-              PLONG_PTR: :pointer, # Pointer to a LONG_PTR.
-              PLONG32:   :pointer, # Pointer to a LONG32.
-              PLONG64:   :pointer, # Pointer to a LONG64.
-              POINTER_32: :pointer, # 32-bit pointer. On a 32-bit system, this is a native pointer. On a 64-bit system, this is a truncated 64-bit pointer.
-              POINTER_64: :pointer, # 64-bit pointer. On a 64-bit system, this is a native pointer. On a 32-bit system, this is a sign-extended 32-bit pointer.
-              POINTER_SIGNED:   :pointer, # A signed pointer.
-              POINTER_UNSIGNED: :pointer, # An unsigned pointer.
-              PSHORT:     :pointer, # Pointer to a SHORT.
-              PSIZE_T:    :pointer, # Pointer to a SIZE_T.
-              PSSIZE_T:   :pointer, # Pointer to a SSIZE_T.
-              PSTR:       :pointer, # Pointer to a null-terminated string of 8-bit Windows (ANSI) characters. For more information, see Character Sets Used By Fonts.
-              PTBYTE:     :pointer, # Pointer to a TBYTE.
-              PTCHAR:     :pointer, # Pointer to a TCHAR.
-              PTSTR:      :pointer, # A PWSTR if UNICODE is defined, a PSTR otherwise.
-              PUCHAR:     :pointer, # Pointer to a UCHAR.
-              PUHALF_PTR: :pointer, # Pointer to a UHALF_PTR.
-              PUINT:      :pointer, # Pointer to a UINT.
-              PUINT_PTR:  :pointer, # Pointer to a UINT_PTR.
-              PUINT32:    :pointer, # Pointer to a UINT32.
-              PUINT64:    :pointer, # Pointer to a UINT64.
-              PULONG:     :pointer, # Pointer to a ULONG.
-              PULONGLONG: :pointer, # Pointer to a ULONGLONG.
-              PULONG_PTR: :pointer, # Pointer to a ULONG_PTR.
-              PULONG32:   :pointer, # Pointer to a ULONG32.
-              PULONG64:   :pointer, # Pointer to a ULONG64.
-              PUSHORT:    :pointer, # Pointer to a USHORT.
-              PVOID:      :pointer, # Pointer to any type.
-              PWCHAR:     :pointer, # Pointer to a WCHAR.
-              PWORD:      :pointer, # Pointer to a WORD.
-              PWSTR:      :pointer, # Pointer to a null- terminated string of 16-bit Unicode characters.
-              # For more information, see Character Sets Used By Fonts.
-              SC_HANDLE:  :ulong, # (L) Handle to a service control manager database.
-              # See SCM Handles http://msdn.microsoft.com/en-us/library/ms685104%28VS.85%29.aspx
-              SC_LOCK:    :pointer, # Lock to a service control manager database. For more information, see SCM Handles.
-              SERVICE_STATUS_HANDLE: :ulong, # (L) Handle to a service status value. See SCM Handles.
-              SHORT:     :short, # A 16-bit integer. The range is –32768 through 32767 decimal.
-              SIZE_T:    :ulong, #  The maximum number of bytes to which a pointer can point. Use for a count that must span the full range of a pointer.
-              SSIZE_T:   :long, # Signed SIZE_T.
-              TBYTE:     :short, # A WCHAR if UNICODE is defined, a CHAR otherwise.TCHAR:
-              TCHAR:     :short, # A WCHAR if UNICODE is defined, a CHAR otherwise.TCHAR:
-              UCHAR:     :uchar, # Unsigned CHAR (8 bit)
-              UHALF_PTR: :uint, # Unsigned HALF_PTR. Use within a structure that contains a pointer and two small fields.
-              UINT:      :uint, # Unsigned INT. The range is 0 through 4294967295 decimal.
-              UINT_PTR:  :uint, # Unsigned INT_PTR.
-              UINT32:    :uint32, # Unsigned INT32. The range is 0 through 4294967295 decimal.
-              UINT64:    :uint64, # Unsigned INT64. The range is 0 through 18446744073709551615 decimal.
-              ULONG:     :ulong, # Unsigned LONG. The range is 0 through 4294967295 decimal.
-              ULONGLONG: :ulong_long, # 64-bit unsigned integer. The range is 0 through 18446744073709551615 decimal.
-              ULONG_PTR: :ulong, # Unsigned LONG_PTR.
-              ULONG32:   :uint32, # Unsigned INT32. The range is 0 through 4294967295 decimal.
-              ULONG64:   :uint64, # Unsigned LONG64. The range is 0 through 18446744073709551615 decimal.
-              UNICODE_STRING: :pointer, # Pointer to some string structure??
-              USHORT:    :ushort, # Unsigned SHORT. The range is 0 through 65535 decimal.
-              USN:    :ulong_long, # Update sequence number (USN).
-              VOID:   [], # Any type ? Only use it to indicate no arguments or no return value
-              WCHAR:  :ushort, # 16-bit Unicode character. For more information, see Character Sets Used By Fonts.
-              # In WinNT.h: typedef wchar_t WCHAR;
-              #WINAPI: K,      # Calling convention for system functions. WinDef.h: define WINAPI __stdcall
-              WORD: :ushort, # 16-bit unsigned integer. The range is 0 through 65535 decimal.
-              WPARAM: :uint    # Message parameter. WinDef.h as follows: typedef UINT_PTR WPARAM;
-      }
-
-      ##
-      # Defines new method wrappers for Windows API function call:
-      # - Defines method with original (CamelCase) API function name and original signature (matches MSDN description)
-      # - Defines method with snake_case name (converted from CamelCase function name) with enhanced API signature
-      #   When defined snake_case method is called, it converts the arguments you provided into ones required by
-      #   original API (adding defaults, mute and transitory args as necessary), executes API function call
-      #   and (optionally) transforms the result before returning it. If a block is attached to
-      #   method invocation, raw result is yielded to this block before final transformation take place
-      # - Defines aliases for enhanced method with more Rubyesque names for getters, setters and tests:
-      #   GetWindowText -> window_test, SetWindowText -> window_text=, IsZoomed -> zoomed?
-      # ---
-      # You may modify default behavior of defined method by providing optional *def_block* to function definition.
-      # If you do so, snake_case method is defined based on your *def_block*. It receives callable API
-      # object for function being defined, arguments and (optional) runtime block with which the method
-      # will be called. Results coming from &def_block are then transformed and returned.
-      # So, your *def_block* should specify all the behavior of the method being defined. You can use *def_block* to:
-      # - Change original signature of API function, provide argument defaults, check argument types
-      # - Pack arguments into strings/structs for <in> or <in/out> parameters that expect a pointer
-      # - Allocate buffers/structs for pointers required by API functions <out> parameters
-      # - Unpack <out> and <in/out> parameters returned as pointers
-      # - Explicitly return results of API call that are returned in <out> and <in/out> parameters
-      # - Convert attached runtime blocks into callback functions and stuff them into <in> callback parameters
-      # - do other stuff that you think is appropriate to make Windows API function behavior more Ruby-like...
-      # ---
-      # Accepts following options:
-      # :dll:: Use this dll instead of default 'user32'
-      # :rename:: Use this name instead of standard (conventional) function name
-      # :alias(es):: Provides additional alias(es) for defined method
-      # :boolean:: Forces method to return true/false instead of nonzero/zero
-      # :zeronil:: Forces method to return nil if function result is zero
-      #
-      def function(name, params, returns, options={}, &def_block)
-        snake_name, effective_names, aliases = generate_names(name, options)
-        params, returns = generate_signature(params, returns)
-        libs = ffi_libraries.map(&:name)
-        boolean = options[:boolean]
-        zeronil = options[:zeronil]
-
-        effective_name = effective_names.inject(nil) do |func, effective_name|
-          func || begin
-            # tries to attach basic CamelCase method via FFI
-            attach_function(name, effective_name, params.dup, returns)
-            effective_name
-          rescue FFI::NotFoundError
-            nil
-          end
-        end
-
-        raise Win::Errors::NotFoundError.new(name, libs) unless effective_name
-
-        # Create API object that holds information about function names, params, etc
-        api = API.new(namespace, name, effective_name, params, returns, libs)
-
-        # Only define enhanced API if snake_name is different from original name (e.g. keybd_event),
-        # If names are the same, this function is already "attached", not possible to enhance its API 
-        unless snake_name.to_s == name.to_s
-          method_body = if def_block
-            if zeronil
-              ->(*args, &block){ (res = def_block.(api, *args, &block)) != 0 ? res : nil }
-            elsif boolean
-              ->(*args, &block){ def_block.(api, *args, &block) != 0 }
-            else
-              ->(*args, &block){ def_block.(api, *args, &block) }
-            end
-          else
-            if zeronil
-              ->(*args, &block){ (res = block ? block[api.call(*args)] : api.call(*args)) != 0 ? res : nil }
-            elsif boolean
-              ->(*args, &block){ block ? block[api.call(*args)] : api.call(*args) != 0 }
-            else
-              ->(*args, &block){ block ? block[api.call(*args)] : api.call(*args) }
-            end
-          end
-
-          define_method snake_name, &method_body       # define snake_case instance method
-
-          eigen_class = class << self; self; end        # Extracting eigenclass
-          eigen_class.class_eval do
-            define_method snake_name, &method_body       # define snake_case class method
-          end
-        end
-
-        aliases.each {|ali| alias_method ali, snake_name }  # define aliases
-        api   #return api object from function declaration
-      end
-
-      # Try to define platform-specific function, rescue error, return message
-      #
-      def try_function(name, params, returns, options={}, &def_block)
-        begin
-          function name, params, returns, options={}, &def_block
-        rescue Win::Errors::NotFoundError
-          "This platform does not support function #{name}"
-        end
-      end
-
-      # Generates possible effective names for function in Win32 dll (name+A/W),
-      # Rubyesque name and aliases for method(s) defined based on function name,
-      #
-      def generate_names(name, options={})
-        name = name.to_s
-        effective_names = [name]
-        effective_names += ["#{name}A", "#{name}W"] unless name =~ /[WA]$/
-        aliases = ([options[:alias]] + [options[:aliases]]).flatten.compact
-        snake_name = options[:rename] || name.snake_case
-        case snake_name
-          when /^is_/
-            aliases << snake_name.sub(/^is_/, '') + '?'
-          when /^set_/
-            aliases << snake_name.sub(/^set_/, '')+ '='
-          when /^get_/
-            aliases << snake_name.sub(/^get_/, '')
-        end
-        [snake_name, effective_names, aliases]
-      end
-
-      ##
-      # Generates params and returns (signature) containing only FFI-compliant types
-      #
-      def generate_signature(params, returns)
-        params = params.split(//) if params.respond_to?(:split) # Convert params string into array
-        params.map! {|param| TYPES[param.to_sym] || param} # Convert chars into FFI type symbols
-        returns = TYPES[returns.to_sym] || returns # Convert chars into FFI type symbols
-        [params, returns]
-      end
-
-      ##
-      # Wrapper for FFI::Library#callback() that converts Win32/shortcut argument types into FFI-compliant types.
-      # This method overrides FFI.callback which must be aliased to FFI.attach_callback
-      #
-      def callback(name, params, returns)
-        params, returns = generate_signature(params, returns)
-        attach_callback name.to_sym, params, returns
-      end
-
-      ##
-      # :method: namespace
-      # This method is meta-generated when Win::Library module is included into other module/class.
-      # It returns reference to including (host) class/module for use by Win::Library::API and class methods.
-
-      ##
-      # Ensures that args count is equal to params count plus diff
-      #
-      def enforce_count(args, params, diff = 0)
-        num_args = args.size
-        num_params = params.size + diff #params == 'V' ? 0 : params.size + diff
-        if num_args != num_params
-          raise ArgumentError, "wrong number of arguments (#{num_args} for #{num_params})"
-        end
-      end
-
-    end
-
-    ##
-    # Hook executed when Win::Library is included into class or module. It extends host class/module
-    # with both FFI::Library methods and Win::Library macro methods like 'function'.
-    #
-    def self.included(host_class)
-      host_class.extend FFI::Library
-
-      # Extracting host class's eigenclass
-      # :stopdoc:
-      eigen_class = class << host_class; self; end      # :nodoc:
-
-      eigen_class.class_eval do
-        define_method(:namespace) {host_class}         # Defining new class method for host class pointing to itself
-        alias_method :attach_callback, :callback
-
-        include ClassMethods
-      end
-      # :startdoc:
-
-      host_class.ffi_lib 'user32', 'kernel32'  # Default libraries
-      host_class.ffi_convention :stdcall
+      # alias_method :[], :call
     end
   end
 end

data/spec/win/gui/dialog_spec.rb

@@ -29,11 +29,11 @@ module WinGuiDialogTest
 
       it "creates, displays, and operates a message box" do
         pending 'Not possible to test message_box directly, it blocks all related threads :('
-          t = Thread.new do
-            selected_item = message_box(handle=0, text="Text", caption="Caption", type=MB_YESNO | MB_HELP)
-            puts selected_item
-          end
-          t.join
+        t = Thread.new do
+          selected_item = message_box(handle=0, text="Text", caption="Caption", type=MB_YESNO | MB_HELP)
+          puts selected_item
+        end
+        t.join
       end
     end # describe message_box
 
@@ -58,6 +58,25 @@ module WinGuiDialogTest
         end
       end
 
+      describe "#get_dlg_ctrl_id" do
+        spec{ use{ control_id = GetDlgCtrlID(control_handle=0) }}
+        spec{ use{ control_id = get_dlg_ctrl_id(control_handle=0) }}
+
+        it "retrieves the identifier of the specified control" do
+          test_app_with_dialog do |app, dialog|
+            control = find_window_ex(dialog, 0, "Button", "&Yes")
+            get_dlg_ctrl_id(control).should == IDYES 
+          end
+        end
+
+        it "returns 0/nil for invalid control (say, if given handle is top level window" do
+          invalid_control = find_window(nil, nil) # Top level, so it must be invalid
+          GetDlgCtrlID(invalid_control).should == 0
+          get_dlg_ctrl_id(invalid_control).should == nil
+        end
+
+      end # describe get_dlg_ctrl_id
+
     end
   end
 end

data/spec/win/gui/message_spec.rb

@@ -85,10 +85,6 @@ module WinGuiMessageTest
       end
     end # describe '#send_message'
 
-    # :call-seq:
-    #  success = send_message_callback(handle, msg, w_param, l_param, data)
-    #            {|handle, msg, data, l_result| callback code }
-
     describe "#send_message_callback" do
       before(:all){@app=launch_test_app}
       after(:all){close_test_app if @launched_test_app}

data/spec/win/library_spec.rb

@@ -6,7 +6,7 @@ module WinLibraryTest
   include WinTest
 
   module MyLib # namespace for defined functions
-    include Win::Library
+    extend Win::Library
   end
   include MyLib
 
@@ -87,6 +87,7 @@ module WinLibraryTest
         it 'defines new instance methods with appropriate names' do
           MyLib.function :FindWindow, 'PP', 'L'
           respond_to?(:FindWindow).should be_true
+          MyLib.respond_to?(:find_window).should be_true
           respond_to?(:find_window).should be_true
         end
 

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 3
-  - 8
-  version: 0.3.8
+  - 11
+  version: 0.3.11
 platform: ruby
 authors: 
 - arvicco
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-06-02 00:00:00 +04:00
+date: 2010-06-03 00:00:00 +04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency