win 0.1.16 → 0.1.18

data/VERSION

@@ -1 +1 @@
-0.1.16
+0.1.18

data/lib/win/error.rb

@@ -851,6 +851,13 @@ module Win
     FORMAT_MESSAGE_ARGUMENT_ARRAY    = 0x00002000
     FORMAT_MESSAGE_MAX_WIDTH_MASK    = 0x000000FF
 
+    # Set/GetErrorMode values:
+
+    SEM_FAILCRITICALERRORS     = 0x0001
+    SEM_NOALIGNMENTFAULTEXCEPT = 0x0004
+    SEM_NOGPFAULTERRORBOX      = 0x0002
+    SEM_NOOPENFILEERRORBOX     = 0x8000
+
     ##
     # FormatMessage Function
     # Formats a message string. The function requires a message definition as input. The message definition
@@ -1011,12 +1018,11 @@ module Win
     function :FormatMessage, [:DWORD, :LPCVOID, :DWORD, :DWORD, :LPTSTR, :DWORD, :varargs], :DWORD,
              &->(api, flags=FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_ARGUMENT_ARRAY,
                      source=nil, message_id=0, language_id=0, *args){
-             buffer   = FFI::MemoryPointer.new :char, 260
+             buffer = FFI::MemoryPointer.new :char, 260
              args = [:int, 0] if args.empty?
              num_chars = api.call(flags, source, message_id, language_id, buffer, buffer.size, *args)
              num_chars == 0 ? nil : buffer.get_bytes(0, num_chars).strip }
 
-
     ##
     # GetLastError Function
     # Retrieves the calling thread's last-error code value. The last-error code is maintained on a
@@ -1062,5 +1068,157 @@ module Win
              &->(api) { error_code = api.call
              flags = FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_ARGUMENT_ARRAY
              format_message(flags, nil, error_code)}
+
+    ##
+    # SetLastError Function
+    # Sets the last-error code for the calling thread.
+    #
+    # [*Syntax*] void WINAPI SetLastError( DWORD dwErrCode );
+    #
+    # dwErrCode:: [in] The last-error code for the thread.
+    #
+    # *Returns*:: This function does not return a value.
+    # ---
+    # *Remarks*:
+    # - The last-error code is kept in thread local storage so that multiple threads do not overwrite each
+    #   other's values.
+    # - This function is intended primarily for use by dynamic-link libraries (DLL). A DLL can provide the
+    #   applications that are using it with additional diagnostic information by calling this function after
+    #   an error occurs. Most functions call SetLastError or SetLastErrorEx only when they fail. However, some
+    #   system functions call SetLastError or SetLastErrorEx under conditions of success; those cases are
+    #   noted in each function's documentation.
+    # - Applications can optionally retrieve the value set by this function by using the GetLastError function
+    #   immediately after a function fails.
+    # - Error codes are 32-bit values (bit 31 is the most significant bit). Bit 29 is reserved for
+    #   application-defined error codes; no system error code has this bit set. If you are defining an error
+    #   code for your application, set this bit to indicate that the error code has been defined by your
+    #   application and to ensure that your error code does not conflict with any system-defined error codes.
+    # ---
+    # <b>Enhanced (snake_case) API: </b>
+    #
+    # :call-seq:
+    #  set_last_error(err_code)
+    #
+    function :SetLastError, [:DWORD], :void
+
+    ##
+    # SetLastErrorEx Function sets the last-error code.
+    # Currently, this function is identical to the SetLastError function. The second parameter is ignored.
+    #
+    # [*Syntax*] void WINAPI SetLastErrorEx( DWORD dwErrCode, DWORD dwType );
+    #
+    # dwErrCode:: The last-error code for the thread.
+    # dwType:: This parameter is ignored.
+    #
+    # *Returns*:: This function does not return a value.
+    # ---
+    # *Remarks*:
+    # The last-error code is kept in thread local storage so that multiple threads do not overwrite each
+    # other's values.
+    # This function is intended primarily for use by dynamic-link libraries (DLL). A DLL can provide the
+    # applications that are using it with additional diagnostic information by calling this function after
+    # an error occurs. Most functions call SetLastError or SetLastErrorEx only when they fail. However, some
+    # system functions call SetLastError or SetLastErrorEx under conditions of success; those cases are
+    # noted in each function's documentation.
+    # Applications can optionally retrieve the value set by this function by using the GetLastError function
+    # immediately after a function fails.
+    # Error codes are 32-bit values (bit 31 is the most significant bit). Bit 29 is reserved for
+    # application-defined error codes; no system error code has this bit set. If you are defining an error
+    # code for your application, set this bit to indicate that the error code has been defined by the
+    # application and to ensure that your error code does not conflict with any system-defined error codes.
+    #
+    # :call-seq:
+    #  set_last_error_ex(err_code, dw_type)
+    #
+    try_function :SetLastErrorEx, [:DWORD, :DWORD], :void
+    # fails silently unless platform is XP++
+
+    ##
+    # GetErrorMode Function
+    # Retrieves the error mode for the current process.
+    #
+    # [*Syntax*] UINT WINAPI GetErrorMode( void );
+    #
+    # This function has no parameters.
+    #
+    # *Returns*:: The process error mode. This function returns one of the following values.
+    #         SEM_FAILCRITICALERRORS:: The system does not display the critical-error-handler message box. Instead,
+    #                                  the system sends the error to the calling process.
+    #         SEM_NOALIGNMENTFAULTEXCEPT:: The system automatically fixes memory alignment faults and makes them
+    #                                      invisible to the application. It does this for the calling process and any
+    #                                      descendant processes. This feature is only supported by certain processor
+    #                                      architectures. For more information, see the Remarks section.
+    #                                      After this value is set for a process, subsequent attempts to clear the
+    #                                      value are ignored.
+    #         SEM_NOGPFAULTERRORBOX:: The system does not display the general-protection-fault message box. This flag
+    #                                 should only be set by debugging applications that handle general protection (GP)
+    #                                 faults themselves with an exception handler.
+    #         SEM_NOOPENFILEERRORBOX:: The system does not display a message box when it fails to find a file. Instead,
+    #                                  the error is returned to the calling process.
+    # ---
+    # *Remarks*:
+    # Each process has an associated error mode that indicates to the system how the application is going to
+    # respond to serious errors. A child process inherits the error mode of its parent process.
+    # To change the error mode for the process, use the SetErrorMode function.
+    # ------
+    # <b> Only works in Vista++! </b>
+    # ------
+    # :call-seq:
+    #  mode = get_error_mode()
+    #
+    try_function :GetErrorMode, [], :UINT
+    # fails silently unless platform is Vista++
+
+    ##
+    # SetErrorMode Function controls whether the system will handle the specified types of serious errors or whether
+    # the process will handle them.
+    #
+    # [*Syntax*] UINT WINAPI SetErrorMode( UINT uMode );
+    #
+    # uMode:: The process error mode. This parameter can be one or more of the following values.
+    #         0:: Use the system default, which is to display all error dialog boxes.
+    #         SEM_FAILCRITICALERRORS:: The system does not display the critical-error-handler message box. Instead,
+    #                                  the system sends the error to the calling process.
+    #         SEM_NOALIGNMENTFAULTEXCEPT:: The system automatically fixes memory alignment faults and makes them
+    #                                      invisible to the application. It does this for the calling process and any
+    #                                      descendant processes. This feature is only supported by certain processor
+    #                                      architectures. For more information, see the Remarks section.
+    #                                      After this value is set for a process, subsequent attempts to clear the
+    #                                      value are ignored.
+    #         SEM_NOGPFAULTERRORBOX:: The system does not display the general-protection-fault message box. This flag
+    #                                 should only be set by debugging applications that handle general protection (GP)
+    #                                 faults themselves with an exception handler.
+    #         SEM_NOOPENFILEERRORBOX:: The system does not display a message box when it fails to find a file. Instead,
+    #                                  the error is returned to the calling process.
+    #
+    # *Returns*:: The return value is the previous state of the error-mode bit flags.
+    # ---
+    # *Remarks*:
+    # Each process has an associated error mode that indicates to the system how the application is going to
+    # respond to serious errors. A child process inherits the error mode of its parent process. To retrieve
+    # the process error mode, use the GetErrorMode function.
+    # Because the error mode is set for the entire process, you must ensure that multi-threaded applications
+    # do not set different error-mode flags. Doing so can lead to inconsistent error handling.
+    # The system does not make alignment faults visible to an application on all processor architectures.
+    # Therefore, specifying SEM_NOALIGNMENTFAULTEXCEPT is not an error on such architectures, but the system
+    # is free to silently ignore the request. This means that code sequences such as the following are not
+    # always valid on x86 computers:
+    #
+    #   SetErrorMode(SEM_NOALIGNMENTFAULTEXCEPT);
+    #   fuOldErrorMode = SetErrorMode(0);
+    #   ASSERT(fuOldErrorMode == SEM_NOALIGNMENTFAULTEXCEPT);
+    #
+    # Itanium::  An application must explicitly call SetErrorMode with SEM_NOALIGNMENTFAULTEXCEPT to have the
+    #            system automatically fix alignment faults. The default setting is for the system to make alignment
+    #            faults visible to an application.
+    # Visual Studio 2005::  When declaring a pointer to a structure that may not have aligned data, you can use
+    #                       __unaligned keyword to indicate that the type must be read one byte at a time. For more
+    #                       information, see Windows Data Alignment.
+    #
+    # :call-seq:
+    #  success = set_error_mode(mode)
+    #
+    function :SetErrorMode, [:UINT], :UINT
+
   end
 end

data/lib/win/gui.rb

@@ -2,7 +2,6 @@ require 'win/gui/window'
 require 'win/gui/input'
 require 'win/gui/message'
 require 'win/gui/dialog'
-require 'win/gui/window/window'
 
 module Win
   

data/lib/win/gui/dialog.rb

@@ -33,15 +33,15 @@ module Win
       # Convenience methods:
 
       # finds top-level dialog window by title and yields found dialog window to block if given
-      def dialog(title, seconds=3)
-        d = begin
-          win = Window::Window.top_level(title, seconds)
-          yield(win) ? win : nil
-        rescue TimeoutError
-        end
-        d.wait_for_close if d
-        return d
-      end
+#      def dialog(title, seconds=3)
+#        d = begin
+#          win = Window::Window.top_level(title, seconds)
+#          yield(win) ? win : nil
+#        rescue TimeoutError
+#        end
+#        d.wait_for_close if d
+#        return d
+#      end
     end
   end
 end

data/lib/win/gui/input.rb

@@ -288,6 +288,38 @@ module Win
       #
       function :SetCursorPos, [:int, :int], :int, boolean: true
 
+      ##
+      # GetCursorPos Function retrieves the cursor's position, in screen coordinates.
+      #
+      # [*Syntax*]  BOOL GetCursorPos( LPPOINT lpPoint );
+      #
+      # lpPoint:: [out] Pointer to a POINT structure that receives the screen coordinates of the cursor.
+      #
+      # *Returns*:: Returns nonzero if successful or zero otherwise. To get extended error information, call
+      #             GetLastError.
+      # ---
+      # *Remarks*:
+      # The cursor position is always specified in screen coordinates and is not affected by the mapping mode
+      # of the window that contains the cursor.
+      # The calling process must have WINSTA_READATTRIBUTES access to the window station.
+      # The input desktop must be the current desktop when you call GetCursorPos. Call OpenInputDesktop to
+      # determine whether the current desktop is the input desktop. If it is not, call SetThreadDesktop with
+      # the HDESK returned by OpenInputDesktop to switch to that desktop.
+      # ---
+      # <b>Enhanced (snake_case) API: accepts no args, returns a pair (x, y) of cursor coordinates</b>
+      #
+      # :call-seq:
+      #  x, y = get_cursor_pos()
+      #
+      function :GetCursorPos, [:pointer], :int8, 
+               &->(api) {
+               point = FFI::MemoryPointer.new(:long, 2)
+               res = api.call point
+               res == 0 ? [nil, nil] : point.read_array_of_long(2) }
+      # weird lambda literal instead of normal block is needed because current version of RDoc
+      # goes crazy if block is attached to meta-definition
+
+
       # Convenience methods
 
       ##

data/lib/win/gui/message.rb

@@ -416,7 +416,7 @@ module Win
       #:call-seq:
       # success = post_message(handle, msg, w_param, l_param)
       #
-      function :PostMessage, [:ulong, :uint, :long, :uint], :int, boolean: true
+      function :PostMessage, [:ulong, :uint, :long, :pointer], :int, boolean: true
 
       ##
       # The SendMessage function sends the specified message to a window or windows. It calls the window procedure for

data/lib/win/gui/window.rb

@@ -530,7 +530,7 @@ module Win
       # :call-seq:
       #   handles = enum_windows( [value=0] ) {|handle, value| your callback procedure }
       #
-      function :EnumWindows, [:EnumWindowsProc, :long], :bool, &return_enum
+      function :EnumWindows, [:EnumWindowsProc, :long], :int8, &return_enum
 
       ##
       # EnumDesktopWindows Function enumerates all top-level windows associated with the specified desktop.
@@ -568,7 +568,7 @@ module Win
       # :call-seq:
       #   handles = enum_desktop_windows( desktop_handle, [value=0] ) {|handle, value| your callback procedure }
       #
-      function :EnumDesktopWindows, [:ulong, :EnumWindowsProc, :long], :bool, &return_enum
+      function :EnumDesktopWindows, [:ulong, :EnumWindowsProc, :long], :int8, &return_enum
 
       ##
       # The EnumChildWindows function enumerates the child windows that belong to the specified parent window by
@@ -602,7 +602,7 @@ module Win
       #:call-seq:
       #   handles = enum_child_windows( parent_handle, [value=0] ) {|handle, value| your callback procedure }
       #
-      function :EnumChildWindows, [:HWND, :EnumWindowsProc, :long], :bool, &return_enum
+      function :EnumChildWindows, [:HWND, :EnumWindowsProc, :long], :int8, &return_enum
 
       ##
       # GetForegroundWindow function returns a handle to the foreground window (the window with which the user
@@ -660,7 +660,7 @@ module Win
       # I have not find so far how to REALLY destroy window in different thread without it asking user anything.
       #
       def shut_window( win_handle)
-        post_message(win_handle, Win::GUI::Message::WM_SYSCOMMAND, Win::GUI::Message::SC_CLOSE, 0)
+        post_message(win_handle, Win::GUI::Message::WM_SYSCOMMAND, Win::GUI::Message::SC_CLOSE, nil)
       end
 
       ##

data/lib/win/library.rb

@@ -374,7 +374,16 @@ module Win
         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,
       #

data/spec/spec_helper.rb

@@ -9,6 +9,18 @@ $debug = true
 # Customize RSpec with my own extensions
 module ClassMacros
 
+  def os
+    `ver`
+  end
+
+  def vista?
+    os =~ /Version 6/
+  end
+
+  def xp?
+    os =~ /XP/
+  end
+
   # wrapper for it method that extracts description from example source code, such as:
   # spec { use{    function(arg1 = 4, arg2 = 'string')  }}
   def spec &block

data/spec/win/error_spec.rb

@@ -8,7 +8,11 @@ module WinErrorTest
   include Win::GUI::Window
 
   def buffer
-    FFI::MemoryPointer.new(:char, 1024)
+    FFI::MemoryPointer.new(:char, 260)
+  end
+
+  def sys_flags
+    FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_ARGUMENT_ARRAY
   end
 
   describe Win::Error, ' contains a set of pre-defined Windows API functions' do
@@ -29,25 +33,80 @@ module WinErrorTest
         window_text(0)
         get_last_error.should == "Invalid window handle."
       end
-
     end # describe "#get_last_error"
 
     describe "#format_message" do
-      spec{ use{ num_chars = FormatMessage(dw_flags=0, lp_source=nil, dw_message_id=0, dw_language_id=0, buffer, buffer.size, :int, 0) }}
-      spec{ use{ message = format_message(dw_flags=0, lp_source=nil, dw_message_id=0, dw_language_id=0, :int, 0) }}
+      spec{ use{ num_chars = FormatMessage(sys_flags, source=nil, message_id=0, language_id=0, buffer, buffer.size, :int, 0) }}
+      spec{ use{ message = format_message(sys_flags, source=nil, message_id=0, language_id=0, :int, 0) }}
 
-      it "original api Formats a message string. The function requires a message definition as input. The message definition " do
-        pending
-        num_chars = FormatMessage(dw_flags=0, nil, dw_message_id=0, dw_language_id=0, buffer, buffer.size, :int, 0)
+      it "original api formats a message string - system message" do
+        find_window(TEST_IMPOSSIBLE, TEST_IMPOSSIBLE)
+        message_id = GetLastError()
+        buf = buffer()
+        num_chars = FormatMessage(sys_flags, nil, message_id, dw_language_id=0, buf, buf.size, :int, 0)
+        buf.get_bytes(0, num_chars).strip.should == "The system cannot find the file specified."
       end
 
-      it "snake_case api Formats a message string. The function requires a message definition as input. The message definition " do
-        pending
-        message = format_message(dw_flags=0, nil, dw_message_id=0, dw_language_id=0, lp_buffer=0, n_size=0,:int, 0)
+      it "snake_case api Formats a message string - system message" do
+        find_window(TEST_IMPOSSIBLE, TEST_IMPOSSIBLE)
+        message = format_message(sys_flags, nil, dw_message_id=GetLastError())
+        message.should == "The system cannot find the file specified."
       end
-
     end # describe format_message
 
+    describe "#set_last_error" do
+      spec{ use{ SetLastError(err_code=0) }}
+      spec{ use{ set_last_error(err_code=0) }}
+
+      it "original api sets the last-error code for the calling thread." do
+        SetLastError(dw_err_code=0xF000)
+        GetLastError().should == ERROR_USER_DEFINED_BASE
+      end
+
+      it "snake_case api also sets the last-error code for the calling thread." do
+        set_last_error(3000)
+        get_last_error.should == "The specified print monitor is unknown."
+      end
+    end # describe set_last_error
+
+    if xp? || vista? # This function works only on XP++
+      describe "#set_last_error_ex" do
+        spec{ use{ SetLastErrorEx(dw_err_code=0, dw_type=0) }}
+        spec{ use{ set_last_error_ex(dw_err_code=0, dw_type=0) }}
+
+        it "original api sets the last-error code for the calling thread." do
+          SetLastErrorEx(dw_err_code=0xF000, dw_type=0)
+          GetLastError().should == ERROR_USER_DEFINED_BASE
+        end
+
+        it "snake_case api also sets the last-error code for the calling thread." do
+          set_last_error_ex(3000,0)
+          get_last_error.should == "The specified print monitor is unknown."
+        end
+      end # describe set_last_error_ex
+    end
+
+    if vista? # This function works only on Vista++
+      describe "#get_error_mode" do
+        spec{ use{ mode = GetErrorMode() }}
+        spec{ use{ mode = get_error_mode() }}
+
+        it "original api retrieves the error mode for the current process." do
+          p mode = GetErrorMode()
+        end
+
+        it "snake_case api also retrieves the error mode for the current process." do
+          p mode = get_error_mode()
+        end
+      end # describe get_error_mode
+    end
+
+    describe "#set_error_mode" do
+      spec{ use{ success = SetErrorMode(u_mode=0) }}
+      spec{ use{ success = set_error_mode(u_mode=0) }}
+
+      it "controls whether the system OR process will handle the specified types of serious errors"
+    end # describe set_error_mode
 
   end # describe Win::Error
 end

data/spec/win/gui/dialog_spec.rb

@@ -14,43 +14,29 @@ module WinWindowTest
 
       it 'returns handle to correctly specified control'
 
-      it 'does something else' do
-        pending
-        test_app do |app|
-          text = '123 456'
-          text.upcase.each_byte do |b| # upcase needed since user32 keybd_event expects upper case chars
-            keybd_event(b.ord, 0, KEYEVENTF_KEYDOWN, 0)
-            sleep TEST_KEY_DELAY
-            keybd_event(b.ord, 0, KEYEVENTF_KEYUP, 0)
-            sleep TEST_KEY_DELAY
-          end
-          app.textarea.text.should =~ Regexp.new(text)
-          7.times {keystroke(VK_CONTROL, 'Z'.ord)} # dirty hack!
-        end
-      end
     end
 
     describe Win::GUI::Dialog, ' defines convenience/service methods on top of Windows API' do
-      describe 'dialog' do
-        spec{ use{ dialog( title ='Dialog Title', timeout_sec = 0.001, &any_block)  }}
-
-        it 'finds top-level dialog window by title' do
-          pending 'Some problems (?with timeouts?) leave window open ~half of the runs'
-          test_app do |app|
-            keystroke(VK_ALT, 'F'.ord, 'A'.ord)
-            @found = false
-            dialog('Save As', 0.5) do |dialog_window|
-              @found = true
-              keystroke(VK_ESCAPE)
-              dialog_window
-            end
-            @found.should == true
-          end
-        end
-
-        it 'yields found dialog window to a given block'
-
-      end
+#      describe 'dialog' do
+#        spec{ use{ dialog( title ='Dialog Title', timeout_sec = 0.001, &any_block)  }}
+#
+#        it 'finds top-level dialog window by title' do
+#          pending 'Some problems (?with timeouts?) leave window open ~half of the runs'
+#          test_app do |app|
+#            keystroke(VK_ALT, 'F'.ord, 'A'.ord)
+#            @found = false
+#            dialog('Save As', 0.5) do |dialog_window|
+#              @found = true
+#              keystroke(VK_ESCAPE)
+#              dialog_window
+#            end
+#            @found.should == true
+#          end
+#        end
+#
+#        it 'yields found dialog window to a given block'
+#
+#      end
     end
   end
 end

data/spec/win/gui/input_spec.rb

@@ -7,7 +7,7 @@ module WinWindowTest
   include WinTestApp
   include Win::GUI::Input
 
-  describe Win::GUI::Input do
+  describe Win::GUI::Input, ' defines a set of API functions related to user input' do
 
     describe '#keydb_event' do
       spec{ use{ keybd_event(vkey = 0, bscan = 0, flags = 0, extra_info = 0) }}
@@ -25,18 +25,49 @@ module WinWindowTest
           5.times {keystroke(VK_CONTROL, 'Z'.ord)} # rolling back changes to allow window closing without dialog!
         end
       end
-    end
+    end # describe '#keydb_event'
     
     describe '#mouse_event' do
       spec { use {mouse_event( flags = MOUSEEVENTF_ABSOLUTE , dx = 0, dy = 0, data=0, extra_info=0 )}}
       it 'Emulates Mouse clicks'
-    end
+    end # describe '#mouse_event'
+
+    describe "#get_cursor_pos" do
+      spec{ use{ success = GetCursorPos(lp_point=FFI::MemoryPointer.new(:long, 2)) }}
+      spec{ use{ x, y = get_cursor_pos() }}
+
+      it "original api returns success code and puts cursor's screen coordinates into supplied buffer" do
+        success = GetCursorPos(lp_point=FFI::MemoryPointer.new(:long, 2))
+        success.should_not == 0
+        x, y = lp_point.read_array_of_long(2)
+        x.should be_an Integer
+        x.should be >= 0
+        y.should be_an Integer
+        y.should be >= 0
+      end
+
+      it "snake_case api returns the cursor's position, in screen coordinates" do
+        x, y = get_cursor_pos()
+        x.should be_an Integer
+        x.should be >= 0
+        y.should be_an Integer
+        y.should be >= 0
+      end
+    end # describe get_cursor_pos
 
     describe '#set_cursor_pos' do
+      spec { use {success = SetCursorPos(x=0, y=0)}}
       spec { use {success = set_cursor_pos(x=0, y=0)}}
-      it 'how to test set_cursor_pos?'
-    end
-  end
+
+      it 'sets cursor`s position, in screen coordinates' do
+        SetCursorPos(x=600, y=600).should be_true
+        get_cursor_pos().should == [600,600]
+        set_cursor_pos(x=0, y=0).should be_true
+        get_cursor_pos().should == [0,0]
+      end
+    end # describe '#set_cursor_pos'
+
+  end # Win::GUI::Input, ' defines a set of API functions related to user input'
 
   describe Win::GUI::Input, ' defines convenience/service methods on top of Windows API' do
     describe '#keystroke' do
@@ -50,7 +81,7 @@ module WinWindowTest
           2.times {keystroke(VK_CONTROL, 'Z'.ord)} # rolling back changes to allow window closing without dialog!
         end
       end
-    end
+    end # describe '#keystroke'
 
     describe '#type_in' do
       spec{ use{ type_in(message = '') }}
@@ -63,7 +94,8 @@ module WinWindowTest
           5.times {keystroke(VK_CONTROL, 'Z'.ord)} # rolling back changes to allow window closing without dialog!
         end
       end
-    end
-  end
+    end # describe '#type_in'
+
+  end # Win::GUI::Input, ' defines convenience/service methods on top of Windows API'
 end
 

data/spec/win/gui/message_spec.rb

@@ -6,33 +6,44 @@ module WinGUIMessageTest
 
   include WinTestApp
   include Win::GUI::Message
+  include Win::GUI::Window
 
-  describe Win::GUI::Message do
+  describe Win::GUI::Message, ' defines a set of API functions related to Window messaging'  do
+    after(:each){close_test_app if @launched_test_app}
 
     describe '#post_message' do
-      spec{ use{ success = PostMessage(handle = 0, msg = 0, w_param = 0, l_param = 0) }}
-      spec{ use{ success = post_message(handle = 0, msg = 0, w_param = 0, l_param = 0) }}
+      spec{ use{ success = PostMessage(handle = 0, msg = 0, w_param = 0, l_param = nil) }}
+      spec{ use{ success = post_message(handle = 0, msg = 0, w_param = 0, l_param = nil) }}
+
+      it 'places (posts) a message in the message queue associated with the thread that created the specified window' do
+        app = launch_test_app
+        post_message(app.handle, WM_SYSCOMMAND, SC_CLOSE, nil)
+        sleep TEST_SLEEP_DELAY
+        window?(app.handle).should == false
+      end
 
-      it 'places (posts) a message in the message queue associated with the thread that created the specified window'
       it 'returns without waiting for the thread to process the message'
-    end
+    end # describe '#post_message'
 
     describe '#send_message' do
       spec{ use{ success = SendMessage(handle = 0, msg = 0, w_param = 1024, l_param = "\x0"*1024) }}
       spec{ use{ success = send_message(handle = 0, msg = 0, w_param = 1024, l_param = "\x0"*1024) }}
-      # handle (L) - Handle to the window whose window procedure is to receive the message. The following values have special meanings.
-      #   HWND_BROADCAST - The message is posted to all top-level windows in the system, including disabled or invisible unowned windows,
-      #     overlapped windows, and pop-up windows. The message is not posted to child windows.
-      #   NULL - The function behaves like a call to PostThreadMessage with the dwThreadId parameter set to the identifier of the current thread.
-      # msg (L) - Specifies the message to be posted.
-      # w_param (L) - Specifies additional message-specific information.
-      # l_param (L) - Specifies additional message-specific information.
-      # return (L) - Nonzero if success, zero if function failed. To get extended error information, call GetLastError.
-
-      it 'sends the specified message to a window or windows'
-      it 'calls the window procedure and does not return until the window procedure has processed the message'
-    end
-  end
+
+      it 'sends the specified message to a window or windows' do
+        app = launch_test_app
+        buffer = FFI::MemoryPointer.new :char, 1024
+        num_chars = send_message app.handle, WM_GETTEXT, buffer.size, buffer
+        buffer.get_bytes(0, num_chars).should == "LockNote - Steganos LockNote"
+
+        num_chars = send_message app.textarea, WM_GETTEXT, buffer.size, buffer
+        buffer.get_bytes(0, num_chars).should =~ /Welcome to Steganos LockNote/
+
+        send_message(app.handle, WM_SYSCOMMAND, SC_CLOSE, nil)
+        sleep TEST_SLEEP_DELAY
+        window?(app.handle).should == false
+      end
+    end # describe '#send_message'
+  end # Win::GUI::Message, ' defines a set of API functions related to Window messaging'
 end
 
 

data/spec/win/gui/window_spec.rb

@@ -31,7 +31,7 @@ module WinWindowTest
     end
   end
 
-  describe Win::GUI::Window, ' defines a set user32 API functions related to Window manipulation' do
+  describe Win::GUI::Window, ' defines a set of API functions related to Window manipulation' do
     context 'ensuring test app closes' do
       after(:each){close_test_app if @launched_test_app}
 

data/spec/win/library_spec.rb

@@ -15,7 +15,7 @@ module WinLibraryTest
       when :find_window
         #api.dll_name.should == 'user32' # The name of the DLL that exports the API function
         api.effective_function_name.should == 'FindWindowA' # Actual function returned by the constructor: 'GetUserName' ->'GetUserNameA' or 'GetUserNameW'
-        api.function_name.should == 'FindWindow' # The name of the function passed to the constructor
+        api.function_name.should == :FindWindow # The name of the function passed to the constructor
         api.prototype.should == [:pointer, :pointer] # The prototype, returned as an array of characters
         api.return_type.should == :ulong # The prototype, returned as an array of characters
     end
@@ -29,16 +29,16 @@ module WinLibraryTest
         if n == rights.size
           expect {send method, *rights}.to_not raise_error
         else
-        args = (1..n).map {wrongs[rand(wrongs.size)]}
-        expect {send method, *args}.
-                to raise_error "wrong number of arguments (#{args.size} for #{rights.size})"
+          args = (1..n).map {wrongs[rand(wrongs.size)]}
+          expect {send method, *args}.
+                  to raise_error "wrong number of arguments (#{args.size} for #{rights.size})"
         end
       end
     end
   end
 
   def any_handle
-    MyLib.function 'FindWindow', 'PP', 'L' unless respond_to? :find_window
+    MyLib.function :FindWindow, 'PP', 'L' unless respond_to? :find_window
     find_window(nil, nil)
   end
 
@@ -80,262 +80,263 @@ module WinLibraryTest
 
     before(:each) { hide_method *redefined_methods } # hide original methods if  defined
     after(:each) { restore_method *redefined_methods } # restore original methods if hidden
+    context '::function' do
+      context 'defining enhanced API function method' do
+        spec{ use{ MyLib.function(:FindWindow, 'PP', 'l', rename: nil, aliases: nil, boolean: nil, zeronil: nil, &any_block) }}
+
+        it 'defines new instance methods with appropriate names' do
+          MyLib.function :FindWindow, 'PP', 'L'
+          respond_to?(:FindWindow).should be_true
+          respond_to?(:find_window).should be_true
+        end
 
-    context 'defining enhanced API function method' do
-      spec{ use{ MyLib.function('FindWindow', 'PP', 'l', rename: nil, aliases: nil, boolean: nil, zeronil: nil, &any_block) }}
-
-      it 'defines new instance methods with appropriate names' do
-        MyLib.function 'FindWindow', 'PP', 'L'
-        respond_to?(:FindWindow).should be_true
-        respond_to?(:find_window).should be_true
-      end
-
-      it 'constructs argument prototype from uppercase string, enforces the args count' do
-        expect { MyLib.function 'FindWindow', 'PP', 'L' }.to_not raise_error
-        should_count_args :find_window, :FindWindow, [nil, nil], [nil, TEST_IMPOSSIBLE, 'cmd']
-      end
+        it 'constructs argument prototype from uppercase string, enforces the args count' do
+          expect { MyLib.function :FindWindow, 'PP', 'L' }.to_not raise_error
+          should_count_args :find_window, :FindWindow, [nil, nil], [nil, TEST_IMPOSSIBLE, 'cmd']
+        end
 
-      it 'constructs argument prototype from (mixed) array, enforces the args count' do
-        expect { MyLib.function 'FindWindow', [:pointer, 'P'], 'L' }.to_not raise_error
-        should_count_args :find_window, :FindWindow, [nil, nil], [nil, TEST_IMPOSSIBLE, 'cmd']
-      end
+        it 'constructs argument prototype from (mixed) array, enforces the args count' do
+          expect { MyLib.function :FindWindow, [:pointer, 'P'], 'L' }.to_not raise_error
+          should_count_args :find_window, :FindWindow, [nil, nil], [nil, TEST_IMPOSSIBLE, 'cmd']
+        end
 
-      it 'with :rename option, overrides snake_case name for defined method but leaves CamelCase intact' do
-        MyLib.function 'FindWindow', 'PP', 'L', :rename=> 'my_own_find'
-        expect {find_window(nil, nil)}.to raise_error NoMethodError
-        expect {FindWindow(nil, nil)}.to_not raise_error
-        expect {my_own_find(nil, nil)}.to_not raise_error
-      end
+        it 'with :rename option, overrides snake_case name for defined method but leaves CamelCase intact' do
+          MyLib.function :FindWindow, 'PP', 'L', :rename=> 'my_own_find'
+          expect {find_window(nil, nil)}.to raise_error NoMethodError
+          expect {FindWindow(nil, nil)}.to_not raise_error
+          expect {my_own_find(nil, nil)}.to_not raise_error
+        end
 
-      it 'defined snake_case method returns expected value when called' do
-        MyLib.function 'FindWindow', 'PP', 'L'
-        find_window(nil, nil).should_not == 0
-        find_window(nil, TEST_IMPOSSIBLE).should == 0
-        find_window(TEST_IMPOSSIBLE, nil).should == 0
-        find_window(TEST_IMPOSSIBLE, TEST_IMPOSSIBLE).should == 0
-      end
+        it 'defined snake_case method returns expected value when called' do
+          MyLib.function :FindWindow, 'PP', 'L'
+          find_window(nil, nil).should_not == 0
+          find_window(nil, TEST_IMPOSSIBLE).should == 0
+          find_window(TEST_IMPOSSIBLE, nil).should == 0
+          find_window(TEST_IMPOSSIBLE, TEST_IMPOSSIBLE).should == 0
+        end
 
-      it 'defined CamelCase method returns expected value when called' do
-        MyLib.function 'FindWindow', 'PP', 'L'
-        FindWindow(nil, nil).should_not == 0
-        FindWindow(nil, TEST_IMPOSSIBLE).should == 0
-        FindWindow(TEST_IMPOSSIBLE, nil).should == 0
-        FindWindow(TEST_IMPOSSIBLE, TEST_IMPOSSIBLE).should == 0
-      end
+        it 'defined CamelCase method returns expected value when called' do
+          MyLib.function :FindWindow, 'PP', 'L'
+          FindWindow(nil, nil).should_not == 0
+          FindWindow(nil, TEST_IMPOSSIBLE).should == 0
+          FindWindow(TEST_IMPOSSIBLE, nil).should == 0
+          FindWindow(TEST_IMPOSSIBLE, TEST_IMPOSSIBLE).should == 0
+        end
 
 #      it 'returns underlying Win32::API object if defined method is called with (:api) argument ' do
-#        MyLib.function 'FindWindow', 'PP', 'L'
+#        MyLib.function :FindWindow, 'PP', 'L'
 #        expect {find_window(:api)}.to_not raise_error
 #        should_be :find_window, find_window(:api)
 #      end
 
-      it 'returns underlying Win32::API object' do
-        FWAPI = MyLib.function 'FindWindow', 'PP', 'L'
-        should_be :find_window, FWAPI
+        it 'returns underlying Win32::API object' do
+          FWAPI = MyLib.function :FindWindow, 'PP', 'L'
+          should_be :find_window, FWAPI
+        end
       end
-    end
 
-    context 'defining aliases' do
-      it 'adds alias for defined method with :alias option' do
-        MyLib.function( 'FindWindow', 'PP', 'L', :alias => 'my_own_find')
-        expect {find_window(nil, nil)}.to_not raise_error
-        expect {my_own_find(nil, nil)}.to_not raise_error
-      end
+      context 'defining aliases' do
+        it 'adds alias for defined method with :alias option' do
+          MyLib.function( :FindWindow, 'PP', 'L', :alias => 'my_own_find')
+          expect {find_window(nil, nil)}.to_not raise_error
+          expect {my_own_find(nil, nil)}.to_not raise_error
+        end
 
-      it 'adds aliases for defined method with :aliases option' do
-        MyLib.function 'FindWindow', 'PP', 'L', :aliases => ['my_own_find', 'my_own_find1']
-        expect {find_window(nil, nil)}.to_not raise_error
-        expect {my_own_find(nil, nil)}.to_not raise_error
-        expect {my_own_find1(nil, nil)}.to_not raise_error
-      end
+        it 'adds aliases for defined method with :aliases option' do
+          MyLib.function :FindWindow, 'PP', 'L', :aliases => ['my_own_find', 'my_own_find1']
+          expect {find_window(nil, nil)}.to_not raise_error
+          expect {my_own_find(nil, nil)}.to_not raise_error
+          expect {my_own_find1(nil, nil)}.to_not raise_error
+        end
 
-      it 'adds Rubyesque alias to IsXxx API test function' do
-        MyLib.function 'IsWindow', 'L', 'B'
-        respond_to?(:window?).should be_true
-        respond_to?(:is_window).should be_true
-      end
+        it 'adds Rubyesque alias to IsXxx API test function' do
+          MyLib.function 'IsWindow', 'L', 'B'
+          respond_to?(:window?).should be_true
+          respond_to?(:is_window).should be_true
+        end
 
-      it 'adds Rubyesque alias to GetXxx API getter function' do
-        MyLib.function 'GetComputerName', 'PP', 'I', :dll=> 'kernel32'
-        respond_to?(:get_computer_name).should be_true
-        respond_to?(:computer_name).should be_true
+        it 'adds Rubyesque alias to GetXxx API getter function' do
+          MyLib.function 'GetComputerName', 'PP', 'I', :dll=> 'kernel32'
+          respond_to?(:get_computer_name).should be_true
+          respond_to?(:computer_name).should be_true
+        end
       end
-    end
 
-    context 'defining API with :boolean option converts result to boolean' do
-      before(:each) { MyLib.function 'FindWindow', 'PP', 'L', :boolean => true }
+      context 'defining API with :boolean option converts result to boolean' do
+        before(:each) { MyLib.function :FindWindow, 'PP', 'L', :boolean => true }
 
-      it 'defines new instance method' do
-        respond_to?(:find_window).should be_true
-        respond_to?(:FindWindow).should be_true
-      end
+        it 'defines new instance method' do
+          respond_to?(:find_window).should be_true
+          respond_to?(:FindWindow).should be_true
+        end
 
-      it 'defined snake_case method returns false/true instead of zero/non-zero' do
-        find_window(nil, nil).should == true
-        find_window(nil, TEST_IMPOSSIBLE).should == false
-      end
+        it 'defined snake_case method returns false/true instead of zero/non-zero' do
+          find_window(nil, nil).should == true
+          find_window(nil, TEST_IMPOSSIBLE).should == false
+        end
 
-      it 'defined CamelCase method still returns zero/non-zero' do
-        FindWindow(nil, nil).should_not == true
-        FindWindow(nil, nil).should_not == 0
-        FindWindow(nil, TEST_IMPOSSIBLE).should == 0
-      end
+        it 'defined CamelCase method still returns zero/non-zero' do
+          FindWindow(nil, nil).should_not == true
+          FindWindow(nil, nil).should_not == 0
+          FindWindow(nil, TEST_IMPOSSIBLE).should == 0
+        end
 
-      it 'defined methods enforce the argument count' do
-        should_count_args :find_window, :FindWindow, [nil, nil], [nil, TEST_IMPOSSIBLE, 'cmd']
+        it 'defined methods enforce the argument count' do
+          should_count_args :find_window, :FindWindow, [nil, nil], [nil, TEST_IMPOSSIBLE, 'cmd']
+        end
       end
-    end
 
-    context 'defining API with :zeronil option converts zero result to nil' do
-      before(:each) {MyLib.function 'FindWindow', 'PP', 'L', :zeronil => true}
+      context 'defining API with :zeronil option converts zero result to nil' do
+        before(:each) {MyLib.function :FindWindow, 'PP', 'L', :zeronil => true}
 
-      it 'defines new instance method' do
-        respond_to?(:find_window).should be_true
-        respond_to?(:FindWindow).should be_true
-      end
+        it 'defines new instance method' do
+          respond_to?(:find_window).should be_true
+          respond_to?(:FindWindow).should be_true
+        end
 
-      it 'defined CamelCase method still returns zero/non-zero' do
-        FindWindow(nil, nil).should_not == true
-        FindWindow(nil, nil).should_not == 0
-        FindWindow(nil, TEST_IMPOSSIBLE).should == 0
-      end
+        it 'defined CamelCase method still returns zero/non-zero' do
+          FindWindow(nil, nil).should_not == true
+          FindWindow(nil, nil).should_not == 0
+          FindWindow(nil, TEST_IMPOSSIBLE).should == 0
+        end
 
-      it 'defined method returns nil (but NOT false) instead of zero' do
-        find_window(nil, TEST_IMPOSSIBLE).should_not == false
-        find_window(nil, TEST_IMPOSSIBLE).should == nil
-      end
+        it 'defined method returns nil (but NOT false) instead of zero' do
+          find_window(nil, TEST_IMPOSSIBLE).should_not == false
+          find_window(nil, TEST_IMPOSSIBLE).should == nil
+        end
 
-      it 'defined method does not return true when result is non-zero' do
-        find_window(nil, nil).should_not == true
-        find_window(nil, nil).should_not == 0
-      end
+        it 'defined method does not return true when result is non-zero' do
+          find_window(nil, nil).should_not == true
+          find_window(nil, nil).should_not == 0
+        end
 
-      it 'defined methods enforce the argument count' do
-        should_count_args :find_window, :FindWindow, [nil, nil], [nil, TEST_IMPOSSIBLE, 'cmd']
+        it 'defined methods enforce the argument count' do
+          should_count_args :find_window, :FindWindow, [nil, nil], [nil, TEST_IMPOSSIBLE, 'cmd']
+        end
       end
-    end
 
-    context 'using DLL other than default user32 with :dll option' do
-      before(:each) {MyLib.function 'GetComputerName', 'PP', 'I', :dll=> 'kernel32'}
+      context 'using DLL other than default user32 with :dll option' do
+        before(:each) {MyLib.function 'GetComputerName', 'PP', 'I', :dll=> 'kernel32'}
 
-      it 'defines new instance method with appropriate name' do
-        respond_to?(:GetComputerName).should be_true
-        respond_to?(:get_computer_name).should be_true
-        respond_to?(:computer_name).should be_true
-      end
+        it 'defines new instance method with appropriate name' do
+          respond_to?(:GetComputerName).should be_true
+          respond_to?(:get_computer_name).should be_true
+          respond_to?(:computer_name).should be_true
+        end
 
-      it 'returns expected result' do
-        MyLib.function 'GetComputerName', ['P', 'P'], 'I', :dll=> 'kernel32'
-        hostname = `hostname`.strip.upcase
-        name = " " * 128
-        get_computer_name(name, "128")
-        name.unpack("A*").first.should == hostname
+        it 'returns expected result' do
+          MyLib.function 'GetComputerName', ['P', 'P'], 'I', :dll=> 'kernel32'
+          hostname = `hostname`.strip.upcase
+          name = " " * 128
+          get_computer_name(name, "128")
+          name.unpack("A*").first.should == hostname
+        end
       end
-    end
 
-    context 'trying to define an invalid API function' do
-      it 'raises error when trying to define function with a wrong function name' do
-        expect { MyLib.function 'FindWindowImpossible', 'PP', 'L' }.
-                to raise_error( /Function 'FindWindowImpossible' not found/ )
+      context 'trying to define an invalid API function' do
+        it 'raises error when trying to define function with a wrong function name' do
+          expect { MyLib.function 'FindWindowImpossible', 'PP', 'L' }.
+                  to raise_error( /Function 'FindWindowImpossible' not found/ )
+        end
       end
-    end
 
-    context 'defining API function using definition block' do
-      it 'defines new instance method' do
-        MyLib.function( 'FindWindow', 'PP', 'L' ){|api, *args|}
-        respond_to?(:find_window).should be_true
-        respond_to?(:FindWindow).should be_true
-      end
+      context 'defining API function using definition block' do
+        it 'defines new instance method' do
+          MyLib.function( :FindWindow, 'PP', 'L' ){|api, *args|}
+          respond_to?(:find_window).should be_true
+          respond_to?(:FindWindow).should be_true
+        end
 
-      it 'does not enforce argument count outside of block' do
-        MyLib.function( 'FindWindow', 'PP', 'L' ){|api, *args|}
-        expect { find_window }.to_not raise_error
-        expect { find_window(nil) }.to_not raise_error
-        expect { find_window(nil, 'Str', 1) }.to_not raise_error
-      end
+        it 'does not enforce argument count outside of block' do
+          MyLib.function( :FindWindow, 'PP', 'L' ){|api, *args|}
+          expect { find_window }.to_not raise_error
+          expect { find_window(nil) }.to_not raise_error
+          expect { find_window(nil, 'Str', 1) }.to_not raise_error
+        end
 
-      it 'returns block return value when defined method is called' do
-        MyLib.function( 'FindWindow', 'PP', 'L' ){|api, *args| 'Value'}
-        find_window(nil).should == 'Value'
-      end
+        it 'returns block return value when defined method is called' do
+          MyLib.function( :FindWindow, 'PP', 'L' ){|api, *args| 'Value'}
+          find_window(nil).should == 'Value'
+        end
 
-      it 'passes arguments and underlying Win32::API object to the block' do
-        MyLib.function( 'FindWindow', 'PP', 'L' ) do |api, *args|
-          @api = api
-          @args = args
+        it 'passes arguments and underlying Win32::API object to the block' do
+          MyLib.function( :FindWindow, 'PP', 'L' ) do |api, *args|
+            @api = api
+            @args = args
+          end
+          expect {find_window(1, 2, 3) }.to_not raise_error
+          @args.should == [1, 2, 3]
+          should_be :find_window, @api
         end
-        expect {find_window(1, 2, 3) }.to_not raise_error
-        @args.should == [1, 2, 3]
-        should_be :find_window, @api
-      end
 
-      it ':rename option overrides standard name for defined method' do
-        MyLib.function( 'FindWindow', 'PP', 'L', :rename => 'my_own_find' ){|api, *args|}
-        expect {find_window(nil, nil, nil)}.to raise_error
-        expect {my_own_find(nil, nil)}.to_not raise_error
-      end
+        it ':rename option overrides standard name for defined method' do
+          MyLib.function( :FindWindow, 'PP', 'L', :rename => 'my_own_find' ){|api, *args|}
+          expect {find_window(nil, nil, nil)}.to raise_error
+          expect {my_own_find(nil, nil)}.to_not raise_error
+        end
 
-      it 'adds alias for defined method with :alias option' do
-        MyLib.function( 'FindWindow', 'PP', 'L', :alias => 'my_own_find' ){|api, *args|}
-        expect {find_window(nil, nil)}.to_not raise_error
-        expect {my_own_find(nil, nil)}.to_not raise_error
-      end
+        it 'adds alias for defined method with :alias option' do
+          MyLib.function( :FindWindow, 'PP', 'L', :alias => 'my_own_find' ){|api, *args|}
+          expect {find_window(nil, nil)}.to_not raise_error
+          expect {my_own_find(nil, nil)}.to_not raise_error
+        end
 
-      it 'adds aliases for defined method with :aliases option' do
-        MyLib.function( 'FindWindow', 'PP', 'L', :aliases => ['my_own_find', 'my_own_find1'] ) {|api, *args|}
-        expect {find_window(nil, nil)}.to_not raise_error
-        expect {my_own_find(nil, nil)}.to_not raise_error
-        expect {my_own_find1(nil, nil)}.to_not raise_error
+        it 'adds aliases for defined method with :aliases option' do
+          MyLib.function( :FindWindow, 'PP', 'L', :aliases => ['my_own_find', 'my_own_find1'] ) {|api, *args|}
+          expect {find_window(nil, nil)}.to_not raise_error
+          expect {my_own_find(nil, nil)}.to_not raise_error
+          expect {my_own_find1(nil, nil)}.to_not raise_error
+        end
       end
-    end
 
-    context 'calling defined methods with attached block to preprocess the API function results' do
-      it 'defined method yields raw result to block attached to its invocation' do
-        MyLib.function 'FindWindow', 'PP', 'L', zeronil: true
-        find_window(nil, TEST_IMPOSSIBLE) {|result| result.should == 0 }
-      end
+      context 'calling defined methods with attached block to preprocess the API function results' do
+        it 'defined method yields raw result to block attached to its invocation' do
+          MyLib.function :FindWindow, 'PP', 'L', zeronil: true
+          find_window(nil, TEST_IMPOSSIBLE) {|result| result.should == 0 }
+        end
 
-      it 'defined method returns result of block attached to its invocation' do
-        MyLib.function 'FindWindow', 'PP', 'L', zeronil: true
-        return_value = find_window(nil, TEST_IMPOSSIBLE) {|result| 'Value'}
-        return_value.should == 'Value'
-      end
+        it 'defined method returns result of block attached to its invocation' do
+          MyLib.function :FindWindow, 'PP', 'L', zeronil: true
+          return_value = find_window(nil, TEST_IMPOSSIBLE) {|result| 'Value'}
+          return_value.should == 'Value'
+        end
 
-      it 'defined method transforms result of block before returning it' do
-        MyLib.function 'FindWindow', 'PP', 'L', zeronil: true
-        return_value = find_window(nil, TEST_IMPOSSIBLE) {|result| 0 }
-        return_value.should_not == 0
-        return_value.should == nil
+        it 'defined method transforms result of block before returning it' do
+          MyLib.function :FindWindow, 'PP', 'L', zeronil: true
+          return_value = find_window(nil, TEST_IMPOSSIBLE) {|result| 0 }
+          return_value.should_not == 0
+          return_value.should == nil
+        end
       end
-    end
 
-    context 'defining API function without arguments - f(VOID)' do
-      it 'should enforce argument count to 0, NOT 1' do
-        MyLib.function 'GetForegroundWindow', [], 'L', zeronil: true
-        should_count_args :GetForegroundWindow, :get_foreground_window, :foreground_window, [], [nil, 0, 123]
+      context 'defining API function without arguments - f(VOID)' do
+        it 'should enforce argument count to 0, NOT 1' do
+          MyLib.function :GetForegroundWindow, [], 'L', zeronil: true
+          should_count_args :GetForegroundWindow, :get_foreground_window, :foreground_window, [], [nil, 0, 123]
+        end
       end
-   end
+    end
 
-    context 'working with API function callbacks' do
-      it '#callback method creates a valid callback object' do
-        pending 'What about callbacks?'
-        expect { @callback = WinGui.callback('LP', 'I') {|handle, message| true} }.to_not raise_error
-        @callback.should be_a_kind_of(Win32::API::Callback)
+    context '::callback defining API callback TYPES' do
+      it '#callback macro creates a valid callback definition' do
+        expect { MyLib.callback :MyEnumWindowsProc, [:HWND, :long], :bool}.to_not raise_error
       end
 
-      it 'created callback object can be used as a valid arg of API function expecting callback' do
-        pending 'What about callbacks?'
-        MyLib.function 'EnumWindows', 'KP', 'L'
-        @callback = WinGui.callback('LP', 'I'){|handle, message| true }
-        expect { enum_windows(@callback, 'Message') }.to_not raise_error
+      it 'created callback definition can be used to define API function expecting callback' do
+        expect {MyLib.function :EnumWindows, [:MyEnumWindowsProc, :long], :long}.to_not raise_error
+        expect { enum_windows(lambda{|handle, message| true }, 0) }.to_not raise_error
       end
+    end
 
-      it 'defined API functions expecting callback convert given block into callback' do
-        pending 'What about callbacks?'
-        pending ' What about prototype!? API is not exactly clear atm (.with_callback method?)'
-        MyLib.function 'EnumWindows', 'KP', 'L'
-        expect { enum_windows('Message'){|handle, message| true } }.to_not raise_error
+    context '::try_function to define API function that are platform-specific' do
+      if xp?
+        it 'should silently fail to define function not present on current platform' do
+          expect {MyLib.function :GetErrorMode, [], :UINT}.to raise_error /Function 'GetErrorMode' not found/
+          expect {MyLib.try_function :GetErrorMode, [], :UINT}.to_not raise_error
+          expect { GetErrorMode() }.to raise_error /undefined method `GetErrorMode'/
+          expect { get_error_mode() }.to raise_error /undefined method `get_error_mode'/
+        end
       end
     end
   end
-end
+end

data/win.gemspec

@@ -5,7 +5,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{win}
-  s.version = "0.1.16"
+  s.version = "0.1.18"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["arvicco"]

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: win
 version: !ruby/object:Gem::Version 
-  version: 0.1.16
+  version: 0.1.18
 platform: ruby
 authors: 
 - arvicco