win 0.3.16 → 0.3.17

data/HISTORY

@@ -58,3 +58,7 @@
 == 0.3.16 / 2010-06-11
 
 * System::Version module completed
+
+== 0.3.17 / 2010-06-13
+
+* Message fucntions now accept both Pointer and Long lParams

data/VERSION

@@ -1 +1 @@
-0.3.16
+0.3.17

data/lib/win/gui/input.rb

@@ -193,7 +193,7 @@ module Win
       #            A positive value indicates that the wheel was rotated forward, away from the user; a negative value
       #            indicates that the wheel was rotated backward, toward the user. One wheel click is defined as
       #            WHEEL_DELTA, which is 120.
-      #          - If dwFlags contains MOUSEEVENTF_WHHEEL, then data specifies the amount of
+      #          - If dwFlags contains MOUSEEVENTF_WHEEL, then data specifies the amount of
       #            wheel movement. A positive value indicates that the wheel was rotated to the right; a negative value
       #            indicates that the wheel was rotated to the left. One wheel click is defined as WHEEL_DELTA (= 120).
       #          - Windows 2000/XP: If flags contains MOUSEEVENTF_XDOWN or MOUSEEVENTF_XUP, then data specifies which

data/lib/win/gui/message.rb

@@ -421,6 +421,7 @@ module Win
       #            {|handle, msg, data, l_result| callback code }
       #
       function :SendMessageCallback, [:HWND, :uint, :uint, :pointer, :SendAsyncProc, :ulong], :int8, boolean: true,
+               alternative: [[:HWND, :uint, :uint, :long, :SendAsyncProc, :ulong], :int8, ->(*args){Integer === args[3]}],
                &->(api, handle, msg, w_param, l_param, data=0, &block){
                api.call(handle, msg, w_param, l_param, block, data)}
 
@@ -462,28 +463,8 @@ module Win
       #:call-seq:
       # success = post_message(handle, msg, w_param, l_param)
       #
-      function :PostMessage, [:ulong, :uint, :uint, :pointer], :int,
-               boolean: true, camel_name: :PostMessagePointer, snake_name: :post_message_pointer
-      function :PostMessage, [:ulong, :uint, :uint, :long], :int,
-               boolean: true, camel_name: :PostMessageLong, snake_name: :post_message_long
-
-      def PostMessage(handle, msg, w_param, l_param)
-        # Routes call depending on lParam type (:pointer or :long)
-        case l_param
-          when Fixnum
-            PostMessageLong(handle, msg, w_param, l_param)
-          else
-            PostMessagePointer(handle, msg, w_param, l_param)
-        end
-      end
-
-      def post_message(handle, msg, w_param, l_param, &block)
-        if block
-          block[PostMessage(handle, msg, w_param, l_param)]
-        else
-          PostMessage(handle, msg, w_param, l_param) != 0
-        end
-      end
+      function :PostMessage, [:ulong, :uint, :uint, :pointer], :int, boolean: true,
+               alternative: [[:ulong, :uint, :uint, :long], :int, ->(*args){Integer === args.last}]
 
       ##
       # The SendMessage function sends the specified message to a window or windows. It calls the window procedure for
@@ -526,7 +507,8 @@ module Win
       #:call-seq:
       # send_message(handle, msg, w_param, l_param)
       #
-      function :SendMessage, [:ulong, :uint, :uint, :pointer], :int   # LPARAM different from PostMessage!
+      function :SendMessage, [:ulong, :uint, :uint, :pointer], :int,
+               alternative: [[:ulong, :uint, :uint, :long], :int, ->(*args){Integer === args.last}]
 
       ##
       # :method: :SendMessageLong?

data/lib/win/library.rb

@@ -311,16 +311,20 @@ module Win
       ffi_lib *(ffi_libraries.map(&:name) << options[:dll]) if options[:dll]
       libs = ffi_libraries.map(&:name)
 
-      effective_name = if options[:alternative]
+      alternative = options.delete(:alternative) # Function may have alternative signature
+      effective_name = if alternative
 
-        alt_params, alt_returns, condition = generate_signature(*options.dup[:alternative])
+        alt_params, alt_returns, condition = generate_signature(*alternative)
         api = function name, params, returns,
-                       options.dup.merge( camel_only: true, camel_name: "#{camel_name}Original")
+                       options.merge( camel_only: true, camel_name: "#{camel_name}Original")
         alt_api = function name, alt_params, alt_returns,
-                           options.dup.merge( camel_only: true, camel_name: "#{camel_name}Alternative")
+                           options.merge( camel_only: true, camel_name: "#{camel_name}Alternative")
+
         define_method camel_name do |*args|
           (condition[*args] ? alt_api : api).call(*args)
         end
+        module_function camel_name
+        public camel_name
         api.effective_name
       else
         effective_names.inject(nil) do |func, effective_name|
@@ -349,21 +353,10 @@ module Win
       # Generate body for snake_case method
       method_body = generate_snake_method_body(api, options, &def_block)
 
-      # Define snake_case instance method
+      # Define snake_case as both instance and module-level method
       define_method snake_name, &method_body
-
-      # We need to define module(class) level method, but something went wrong with module_function :(
-#      module_function snake_name    # TODO: Doesn't work as a perfect replacement for eigen_class stuff. :( Why?
-
-      # OK, instead of module_method we're going to directly modify eigenclass
-      eigen_class = class << self;
-        self;
-      end
-
-      # Define snake_case class method inside eigenclass, that should do it
-      eigen_class.class_eval do
-        define_method snake_name, &method_body
-      end
+      module_function snake_name
+      public snake_name
 
       # Define (instance method!) aliases, if any
       aliases.each {|ali| alias_method ali, snake_name }
@@ -466,7 +459,8 @@ module Win
     # Win::Library::API is a wrapper for callable function API object that mimics Win32::API
     class API
 
-      # The name of the DLL(s) that export this API function
+      # The name of the DLL(s) that export this API function.
+      # dll_name alias needed for compatibility with Win32::API interface
       attr_reader :dll
       alias_method :dll_name, :dll
 
@@ -478,7 +472,9 @@ module Win
 
       # The name of the actual Windows API function. For example, if you passed 'GetUserName' to the
       # constructor, then the effective function name would be either 'GetUserNameA' or 'GetUserNameW'.
-      attr_accessor :effective_function_name
+      # effective_function_name alias needed for compatibility with Win32::API interface
+      attr_accessor :effective_name
+      alias_method :effective_function_name, :effective_name
 
       # The prototype, returned as an array of FFI types
       attr_reader :prototype
@@ -486,10 +482,10 @@ module Win
       # The return type (:void for no return value)
       attr_reader :return_type
 
-      def initialize( namespace, function_name, effective_function_name, prototype, return_type, dll )
+      def initialize( namespace, function_name, effective_name, prototype, return_type, dll )
         @namespace = namespace
         @function_name = function_name.to_sym
-        @effective_function_name = effective_function_name.to_sym
+        @effective_name = effective_name.to_sym
         @prototype = prototype
         @return_type = return_type
         @dll = dll

data/lib/win/system/info.rb

@@ -3,13 +3,13 @@ require 'win/library'
 module Win
   module System
 
-    # Contains constants and Win32 API functions related to dialog manipulation.
-    # Windows dialog basics can be found here:
-    # http://msdn.microsoft.com/en-us/library/ms644996#init_box
+    # Contains constants and Win32 API functions related to system information functions.
+    # More functions of this type can be found here:
+    # http://msdn.microsoft.com/en-us/library/ms724953%28v=VS.85%29.aspx
     module Info
       extend Win::Library
 
-      # Enum COMPUTER_NAME_FORMAT (for GetComputerNameEx)
+      # Enum COMPUTER_NAME_FORMAT (for GetComputerNameEx). TODO: convert into FFI::Enum
 
       ComputerNameNetBIOS                    = 0
       ComputerNameDnsHostname                = 1

data/spec/win/gui/input_spec.rb

@@ -39,7 +39,20 @@ module WinGuiInputTest
 
     describe '#mouse_event' do
       spec { use {mouse_event( flags = MOUSEEVENTF_ABSOLUTE, dx = 0, dy = 0, data=0, extra_info=0 )}}
-      it 'Emulates Mouse clicks'
+
+      it 'emulates mouse clicks' do
+        test_app do |app|
+          # Position cursor at app's "Close Window" control
+          left, top, right, bottom = get_window_rect(app.handle)
+          set_cursor_pos(x=right-5, y=top+5).should be_true
+
+          mouse_event MOUSEEVENTF_LEFTDOWN, 0, 0, 0, 0
+          mouse_event MOUSEEVENTF_LEFTUP, 0, 0, 0, 0
+          sleep SLEEP_DELAY
+          window?(app.handle).should == false
+        end
+      end
+
     end # describe '#mouse_event'
 
     describe "#get_cursor_pos" do

data/spec/win/gui/message_spec.rb

@@ -15,7 +15,7 @@ module WinGuiMessageTest
   end
 
   def msg
-    @msg ||=Win::Gui::Message::Msg.new
+    @msg ||= Win::Gui::Message::Msg.new
   end
 
   def msg_callback
@@ -83,21 +83,32 @@ module WinGuiMessageTest
     end # describe '#post_message'
 
     describe '#send_message' do
+      after(:all){close_test_app if @launched_test_app}
+
       spec{ use{ success = SendMessage(handle = 0, msg = 0, w_param = 0, l_param = nil) }}
       spec{ use{ success = send_message(handle = 0, msg = 0, w_param = 0, l_param = nil) }}
 
-      it 'directly sends the specified message to a window or windows' do
-        app = launch_test_app
-
-        num_chars = send_message app.handle, WM_GETTEXT, buffer.size, buffer
-        buffer.get_bytes(0, num_chars).should == "LockNote - Steganos LockNote"
+      context 'sends a message to the specified window' do
+        it 'with nil as last argument(lParam)' do
+          app = launch_test_app
+          send_message(app.handle, WM_SYSCOMMAND, SC_CLOSE, nil)
+          sleep SLEEP_DELAY
+          window?(app.handle).should == false
+        end
 
-        num_chars = send_message app.textarea, WM_GETTEXT, buffer.size, buffer
-        buffer.get_bytes(0, num_chars).should =~ /Welcome to Steganos LockNote/
+        it 'with pointer as last argument(lParam)' do
+          app = launch_test_app
+          send_message(app.handle, WM_SYSCOMMAND, SC_CLOSE, FFI::MemoryPointer.new(:long))
+          sleep SLEEP_DELAY
+          window?(app.handle).should == false
+        end
 
-        send_message(app.handle, WM_SYSCOMMAND, SC_CLOSE, nil)
-        sleep SLEEP_DELAY  # delay to allow window close
-        window?(app.handle).should == false
+        it 'with Fixnum as last argument(lParam)' do
+          app = launch_test_app
+          send_message(app.handle, WM_SYSCOMMAND, SC_CLOSE, 0)
+          sleep SLEEP_DELAY
+          window?(app.handle).should == false
+        end
       end
     end # describe '#send_message'
 
@@ -111,13 +122,13 @@ module WinGuiMessageTest
       it "sends message to window and returns, specifying callback to be called by system after message is processed" do
         sent = SendMessageCallback(@app.handle, WM_USER, 0, nil, msg_callback, data=13)
         sent.should == 1
-        @handle.should == nil
+        @handle.should == nil  # Callback did not fire just yet
         @message.should == nil
         @data.should == nil
         @result.should == nil
 
-        sleep SLEEP_DELAY # small delay to allow message delivery
-        peek_message           # dispatching sent message (even though there is nothing in queue)
+        sleep SLEEP_DELAY # Small delay to allow message delivery
+        peek_message      # Dispatching sent message (even though there is nothing in queue)
 
         @handle.should == @app.handle
         @message.should == WM_USER
@@ -126,16 +137,26 @@ module WinGuiMessageTest
       end
 
       it "snake_case api defaults data to 0, converts block into callback and returns true/false" do
-        sent = send_message_callback(@app.handle, WM_USER, 0, nil){|*args|@data=args[2]}
+        sent = send_message_callback(@app.handle, WM_USER, 0, nil){|*args| @data=args[2]}
         sent.should == true
-        @data.should == nil
+        @data.should == nil    # Callback did not fire just yet
 
-        sleep SLEEP_DELAY # small delay to allow message delivery
-        peek_message           # dispatching sent message (even though there is nothing in queue)
+        sleep SLEEP_DELAY # Small delay to allow message delivery
+        peek_message      # Dispatching sent message (even though there is nothing in queue)
 
         @data.should == 0
       end
 
+      it "can be used with :pointer as a 4th arg" do
+        sent = send_message_callback(@app.handle, WM_USER, 0, FFI::MemoryPointer.new(:long)){|*args|}
+        sent.should == true
+      end
+
+      it "can be used with :long as a 4th arg" do
+        sent = send_message_callback(@app.handle, WM_USER, 0, 0){|*args|}
+        sent.should == true
+      end
+
       it "fails if unable to send message" do
         sent = SendMessageCallback(not_a_handle, WM_USER, 0, nil, msg_callback, 0)
         sent.should == 0

data/spec/win/gui/window_spec.rb

@@ -468,25 +468,50 @@ module WinGuiWindowTest
           end
         end # context GA_PARENT
 
-        #           GA_ROOT - Retrieves the root window by walking the chain of parent windows.
+        context 'GA_ROOT - Retrieves the root window by walking the chain of parent windows' do
+          it "retrieves a handle to the specified window's root (top level parent)" do
+            child = find_window_ex(@app.handle, 0, nil, nil)
+            root1 = GetAncestor(child, GA_ROOT)
+            root2 = get_ancestor(child, GA_ROOT)
+            root1.should == root2
+            root1.should == @app.handle
+          end
+        end
         #           GA_ROOTOWNER - Retrieves the owned root window by walking the chain of parent and owner windows
         #                          returned by GetParent.
-        it "original api retrieves the handle to the ancestor of the specified window. " do
-          pending
-          success = GetAncestor(hwnd=0, ga_flags=0)
-        end
-
-        it "snake_case api retrieves the handle to the ancestor of the specified window. " do
-          pending
-          success = get_ancestor(hwnd=0, ga_flags=0)
-        end
-
       end # describe get_ancestor
 
       describe "#get_window" do
         spec{ use{ handle = GetWindow(any_handle, command=0) }}
         spec{ use{ handle = get_window(any_handle, command=0) }}
 
+        #        GW_ENABLEDPOPUP - Windows 2000/XP: The retrieved handle identifies the enabled popup window owned by
+
+        context 'GW_HWND... works with windows of the same type' do
+          before(:all) do
+            @statusbar = find_window_ex(@app.handle, 0, STATUSBAR_CLASS, nil)
+            @textarea = find_window_ex(@app.handle, 0, TEXTAREA_CLASS, nil)
+          end
+
+          it 'GW_HWNDFIRST - The retrieved handle identifies the window of the same type that is highest in Z order' do
+            get_window(@statusbar, GW_HWNDFIRST).should == @statusbar
+          end
+          it 'GW_HWNDLAST -  The retrieved handle identifies the window of the same type that is lowest in the Z order' do
+            get_window(@statusbar, GW_HWNDLAST).should == @textarea
+          end
+          it 'GW_HWNDNEXT -  The retrieved handle identifies the window below the specified window in the Z order' do
+            get_window(@statusbar, GW_HWNDNEXT).should == @textarea
+          end
+          it 'GW_HWNDPREV -  The retrieved handle identifies the window above the specified window in the Z order' do
+            get_window(@textarea, GW_HWNDPREV).should == @statusbar
+          end
+
+          it 'returns nil/0 in case nothing is returned' do
+            get_window(@textarea, GW_HWNDNEXT).should == nil
+            GetWindow(@textarea, GW_HWNDNEXT).should == 0
+          end
+        end # context 'GW_HWND...
+
         context "GW_CHILD retrieves a window handle to a first (top of the Z order) child of given window" do
           before(:all) do
             #        GW_CHILD - The retrieved handle identifies the child window at the top of the Z order, if the specified
@@ -510,11 +535,12 @@ module WinGuiWindowTest
         end # context GW_CHILD
 
         context "GW_OWNER - retrieves a handle to an owner of a given Window" do
-          #        GW_OWNER - The retrieved handle identifies the specified window's owner window, if any. For more
+          # Ownership is a relationship between two top level windows while Parent is a relationship between a top
+          # level and a WS_CHILD, or a WS_CHILD and another WS_CHILD. The parent of a button is the form it is on,
+          # while a message box is owned by the form that showed it.
 
           it 'returns owner (but NOT parent!) of a given window' do
-            pending
-
+            pending 'Need to open modal dialog, app should be it`s owner'
             child = find_window_ex(@app.handle, 0, nil, nil)
             p owner1 = GetWindow(child, GW_OWNER)
             p owner2 = get_window(child, GW_OWNER)
@@ -526,27 +552,12 @@ module WinGuiWindowTest
             GetWindow(@app.handle, GW_OWNER).should == 0
             get_window(@app.handle, GW_OWNER).should == nil
           end
-
-        end
-
-        it "GW_OWNER - retrieves a handle to a window that has the specified relationship to given Window" do
-          pending
-          #        GW_ENABLEDPOPUP - Windows 2000/XP: The retrieved handle identifies the enabled popup window owned by
-          #        GW_HWNDFIRST - The retrieved handle identifies the window of the same type that is highest in Z order.
-          #        GW_HWNDLAST -  The retrieved handle identifies the window of the same type that is lowest in the Z order.
-          #        GW_HWNDNEXT -  The retrieved handle identifies the window below the specified window in the Z order.
-          #        GW_HWNDPREV -  The retrieved handle identifies the window above the specified window in the Z order.
-          #        GW_OWNER - The retrieved handle identifies the specified window's owner window, if any. For more
         end
       end # describe get_window
 
       describe '#enum_windows' do
-#        before(:each){@app = launch_test_app}
-#        after(:each){close_test_app}
 
         spec{ use{ handles = enum_windows(value = 13)   }}
-        spec{ use{ enum_windows do |handle, message|
-        end  }}
 
         it 'iterates through all the top-level windows, passing each top level window handle and value to a given block' do
           enum_windows(13) do |handle, message|
@@ -558,7 +569,6 @@ module WinGuiWindowTest
 
         it 'returns an array of top-level window handles if block is not given' do
           enum = enum_windows(13)
-#          p enum
           enum.should be_a_kind_of Array
           enum.should_not be_empty
           enum.should have_at_least(5).elements # typical number of top windows in WinXP system?

data/spec/win/library_spec.rb

@@ -1,5 +1,6 @@
 require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 require 'win/library'
+require 'win/gui/message'
 
 module WinLibraryTest
 
@@ -43,7 +44,7 @@ module WinLibraryTest
   end
 
   def redefined_methods
-    [:FindWindow, :IsWindow, :EnumWindows, :GetUserName, :GetForegroundWindow, :keybd_event]
+    [:FindWindow, :IsWindow, :EnumWindows, :GetUserName, :GetForegroundWindow, :keybd_event, :SendMessage]
   end
 
   def hide_method(*names) # hide original method(s) if it is defined
@@ -296,6 +297,30 @@ module WinLibraryTest
         end
       end
 
+      context 'defining API function with alternative signature' do
+        before(:each) do
+          @def_block = nil
+          MyLib.function :SendMessage, [:ulong, :uint, :uint, :pointer], :int,
+                         alternative: [[:ulong, :uint, :uint, :long], :int, ->(*args){Integer === args.last}]
+        end
+
+        it 'defines camel and snake methods (as well as hidden Original/Alternative methods)' do
+            expect { send_message(any_handle, Win::Gui::Message::WM_GETTEXT, buffer.size, buffer) }.to_not raise_error
+            expect { send_message(any_handle, Win::Gui::Message::WM_GETTEXT, buffer.size, buffer.address) }.to_not raise_error
+        end
+
+        it 'defines camel and snake methods that work with both signatures' do
+          respond_to?(:SendMessage).should be_true
+          respond_to?(:send_message).should be_true
+          respond_to?(:SendMessageOriginal).should be_true
+          respond_to?(:SendMessageAlternative).should be_true
+          MyLib.respond_to?(:SendMessage).should be_true
+          MyLib.respond_to?(:send_message).should be_true
+          MyLib.respond_to?(:SendMessageOriginal).should be_true
+          MyLib.respond_to?(:SendMessageAlternative).should be_true
+        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' }.
@@ -330,7 +355,7 @@ module WinLibraryTest
         end
       end
 
-      context 'defining API function that has snake_case name' do
+      context 'defining API function that has original snake_case name' do
         it 'should define original function in (generated) CamelCase' do
           MyLib.function :keybd_event, [:char, :char, :ulong, :ulong], :void
           expect {KeybdEvent(Win::Gui::Input::VK_CONTROL, 0, Win::Gui::Input::KEYEVENTF_KEYDOWN, 0)}.to_not raise_error

metadata

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