rautomation 0.6.3 → 0.7.0

data/lib/rautomation/adapter/win_32.rb

@@ -0,0 +1,21 @@
+begin
+  gem "ffi"
+rescue Gem::LoadError
+  raise Gem::LoadError, "Unable to load FFI gem. Install it with:\n\tgem install ffi"
+end
+require "ffi"
+require File.dirname(__FILE__) + "/win_32/constants"
+require File.dirname(__FILE__) + "/win_32/keys"
+require File.dirname(__FILE__) + "/win_32/functions"
+require File.dirname(__FILE__) + "/win_32/locators"
+require File.dirname(__FILE__) + "/win_32/window"
+require File.dirname(__FILE__) + "/win_32/button_helper"
+require File.dirname(__FILE__) + "/win_32/control"
+require File.dirname(__FILE__) + "/win_32/button"
+require File.dirname(__FILE__) + "/win_32/checkbox"
+require File.dirname(__FILE__) + "/win_32/radio"
+require File.dirname(__FILE__) + "/win_32/text_field"
+require File.dirname(__FILE__) + "/win_32/select_list"
+require File.dirname(__FILE__) + "/win_32/table"
+require File.dirname(__FILE__) + "/win_32/label"
+require File.dirname(__FILE__) + "/win_32/list_box"

data/lib/rautomation/adapter/win_32/button.rb

@@ -0,0 +1,14 @@
+module RAutomation
+  module Adapter
+    module Win32
+      class Button < Control
+        include WaitHelper
+        include Locators
+
+        # Default locators used for searching buttons.
+        DEFAULT_LOCATORS = {:class => /button/i}
+
+      end
+    end
+  end
+end

data/lib/rautomation/adapter/{win_ffi → win_32}/button_helper.rb

@@ -1,6 +1,6 @@
 module RAutomation
   module Adapter
-    module WinFfi
+    module Win32
       module ButtonHelper
 
         def set?

data/lib/rautomation/adapter/win_32/checkbox.rb

@@ -0,0 +1,14 @@
+module RAutomation
+  module Adapter
+    module Win32
+      class Checkbox < Control
+        include WaitHelper
+        include Locators
+        include ButtonHelper
+
+        DEFAULT_LOCATORS = {:class => /button/i}
+
+      end
+    end
+  end
+end

data/lib/rautomation/adapter/win_32/constants.rb

@@ -0,0 +1,68 @@
+module RAutomation
+  module Adapter
+    module Win32
+      # @private
+      module Constants
+        WM_GETTEXT = 0xD
+        WM_SETTEXT = 0xC
+        WM_GETTEXTLENGTH = 0xE
+        WM_CLOSE = 0x10
+
+        SW_MAXIMIZE = 3
+        SW_MINIMIZE = 6
+        SW_RESTORE = 9
+
+        SMTO_ABORTIFHUNG = 0x2
+
+        STANDARD_RIGHTS_REQUIRED = 0xF0000
+        SYNCHRONIZE = 0x100000
+        PROCESS_ALL_ACCESS = STANDARD_RIGHTS_REQUIRED | SYNCHRONIZE | 0xFFF
+
+        BM_CLICK = 0xF5
+        BM_GETSTATE = 0xF2
+        BST_CHECKED = 0x1
+
+        # keybd_event constants
+        KEYEVENTF_EXTENDEDKEY = 0x1
+        KEYEVENTF_KEYUP = 0x2
+
+        # GetWindow constants
+        GW_ENABLEDPOPUP = 6
+
+        # HRESULT
+        S_OK = 0
+
+        # IAccessible Button States
+        STATE_SYSTEM_UNAVAILABLE = 0x00000001
+        STATE_SYSTEM_SELECTED = 0x00000002
+        STATE_SYSTEM_FOCUSED = 0x00000004
+        STATE_SYSTEM_CHECKED = 0x00000010
+
+        # Combobox
+        CB_GETCOUNT = 0x0146
+        CB_GETTOPINDEX  = 0x015b
+        CB_GETLBTEXTLEN = 0x0149
+        CB_GETLBTEXT = 0x0148
+        CB_GETCURSEL = 0x0147
+        CB_GETDROPPEDCONTROLRECT = 0x0152
+        CB_GETITEMHEIGHT = 0x0154
+        CB_ERR = -1
+        CB_SETCURSEL = 0x14E
+        CB_SELECTSTRING = 0x14D
+        CB_SETEDITSEL = 0x142
+
+        # listview
+        LVM_FIRST = 0x1000
+        LVM_GETITEMCOUNT = LVM_FIRST + 4
+
+        # listbox
+        LB_GETCOUNT = 0x18b
+        LB_GETTEXT = 0x189
+        LB_GETTEXTLEN = 0x18a
+        LB_SETCURSEL = 0x186
+        LB_GETSEL = 0x187
+
+      end
+    end
+  end
+end

data/lib/rautomation/adapter/{win_ffi → win_32}/control.rb

@@ -1,6 +1,6 @@
 module RAutomation
   module Adapter
-    module WinFfi
+    module Win32
       class Control
         include WaitHelper
         include Locators
@@ -19,56 +19,63 @@ module RAutomation
           extract(locators)
         end
 
+        def hwnd
+          Functions.control_hwnd(@window.hwnd, @locators)
+        end
+
+        def class_name
+          Functions.control_class(hwnd)
+        end
+
         def click
           assert_enabled
           clicked = false
           wait_until do
-            hwnd = Functions.control_hwnd(@window.hwnd, @locators)
-
             @window.activate
             @window.active? &&
-              Functions.set_control_focus(hwnd) &&
-              Functions.control_click(hwnd) &&
-              clicked = true # is clicked at least once
+                focus &&
+                Functions.control_click(hwnd) &&
+                clicked = true # is clicked at least once
 
             block_given? ? yield : clicked && !exist?
           end
         end
 
+        def hwnd
+          Functions.control_hwnd(@window.hwnd, @locators)
+        end
+
         def exist?
-          !!Functions.control_hwnd(@window.hwnd, @locators)
+          !!hwnd
+        rescue UnknownElementException
+          false
         end
 
+        alias_method :exists?, :exist?
+
         def enabled?
           !disabled?
         end
 
         def disabled?
-          Functions.unavailable?(Functions.control_hwnd(@window.hwnd, @locators))
+          Functions.unavailable? hwnd
         end
 
-        def has_focus?
-          Functions.has_focus?(Functions.control_hwnd(@window.hwnd, @locators))
-        end
-
-        def set_focus
+        def focus
           assert_enabled
-          uia_control = UiaDll::element_from_handle(Functions.control_hwnd(@window.hwnd, @locators))
-          UiaDll::set_focus(uia_control)
+          @window.activate
+          Functions.set_control_focus hwnd
         end
 
-        def uia_control(automation_id)
-          uia_window = UiaDll::element_from_handle(@window.hwnd) # finds IUIAutomationElement for given parent window
-          uia_element = UiaDll::find_child_by_id(uia_window, automation_id.to_s)
-          fail "Cannot find UIAutomationElement" if uia_element.nil?
-          uia_element
+        def focused?
+          Functions.has_focus?(hwnd)
         end
 
-        def matches_type(clazz)
-          UiaDll::current_control_type(uia_control(@locators[:id])) == clazz
+        def value
+          Functions.control_value(hwnd)
         end
 
-        alias_method :exists?, :exist?
+        private
 
         def assert_enabled
           raise "Cannot interact with disabled control #{@locators.inspect} on window #{@window.locators.inspect}!" if disabled?

data/lib/rautomation/adapter/win_32/functions.rb

@@ -0,0 +1,313 @@
+module RAutomation
+  module Adapter
+    module Win32
+      # @private
+      module Functions
+        extend FFI::Library
+
+        # TODO once done adapt the path to the DLL (somewhere in the packaged gem)
+        ffi_lib 'user32', 'kernel32', 'ole32', File.dirname(__FILE__) + '/../../../../ext/IAccessibleDLL/Release/iaccessibleDll.dll'
+        ffi_convention :stdcall
+
+        callback :enum_callback, [:long, :pointer], :bool
+
+        # user32
+        attach_function :enum_windows, :EnumWindows,
+                        [:enum_callback, :pointer], :long
+        attach_function :enum_child_windows, :EnumChildWindows,
+                        [:long, :enum_callback, :pointer], :long
+        attach_function :_close_window, :CloseWindow,
+                        [:long], :bool
+        attach_function :minimized, :IsIconic,
+                        [:long], :bool
+        attach_function :_window_title, :GetWindowTextA,
+                        [:long, :pointer, :int], :int
+        attach_function :window_title_length, :GetWindowTextLengthA,
+                        [:long], :int
+        attach_function :window_exists, :IsWindow,
+                        [:long], :bool
+        attach_function :_window_class, :GetClassNameA,
+                        [:long, :pointer, :int], :int
+        attach_function :window_visible, :IsWindowVisible,
+                        [:long], :bool
+        attach_function :show_window, :ShowWindow,
+                        [:long, :int], :bool
+        attach_function :send_message, :SendMessageA,
+                        [:long, :uint, :uint, :pointer], :long
+        attach_function :send_message_timeout, :SendMessageTimeoutA,
+                        [:long, :uint, :uint, :pointer, :uint, :uint, :pointer], :bool
+        attach_function :post_message, :PostMessageA,
+                        [:long, :uint, :uint, :pointer], :bool
+        attach_function :window_thread_process_id, :GetWindowThreadProcessId,
+                        [:long, :pointer], :long
+        attach_function :attach_thread_input, :AttachThreadInput,
+                        [:long, :long, :bool], :bool
+        attach_function :set_foreground_window, :SetForegroundWindow,
+                        [:long], :bool
+        attach_function :bring_window_to_top, :BringWindowToTop,
+                        [:long], :bool
+        attach_function :set_active_window, :SetActiveWindow,
+                        [:long], :long
+        attach_function :foreground_window, :GetForegroundWindow,
+                        [], :long
+        attach_function :send_key, :keybd_event,
+                        [:uchar, :uchar, :int, :pointer], :void
+        attach_function :control_id, :GetDlgCtrlID,
+                        [:long], :int
+        attach_function :_set_control_focus, :SetFocus,
+                        [:long], :long
+        attach_function :get_window, :GetWindow,
+                        [:long, :uint], :long
+        attach_function :get_last_error, :GetLastError,
+                        [], :long
+
+        # kernel32
+        attach_function :current_thread_id, :GetCurrentThreadId,
+                        [], :long
+        attach_function :open_process, :OpenProcess,
+                        [:int, :bool, :int], :long
+        attach_function :terminate_process, :TerminateProcess,
+                        [:long, :uint], :bool
+        attach_function :close_handle, :CloseHandle,
+                        [:long], :bool
+        attach_function :load_library, :LoadLibraryA,
+                        [:string], :long
+
+        # ole32
+        attach_function :co_initialize, :CoInitialize,
+                        [:pointer], :uint16
+
+        # iaccessible
+        attach_function :get_button_state, :get_button_state,
+                        [:long], :long
+        attach_function :get_table_row_strings, :get_table_row_strings,
+                        [:long, :long, :pointer, :long, :pointer], :void
+        attach_function :select_table_row, :select_table_row,
+                        [:long, :long, :long], :void
+        attach_function :get_table_row_state, :get_table_row_state,
+                        [:long, :long, :long], :long
+
+        class << self
+
+          def window_title(hwnd)
+            title_length = window_title_length(hwnd) + 1
+            title = FFI::MemoryPointer.new :char, title_length
+            _window_title(hwnd, title, title_length)
+            title.read_string
+          end
+
+          alias_method :control_title, :window_title
+
+          def window_text(hwnd)
+            found_text = []
+            window_callback = FFI::Function.new(:bool, [:long, :pointer], {:convention => :stdcall}) do |child_hwnd, _|
+              found_text << text_for(child_hwnd)
+              true
+            end
+            enum_child_windows(hwnd, window_callback, nil)
+            found_text.join(" ")
+          end
+
+          alias_method :control_text, :window_text
+
+          def window_hwnd(locators)
+            find_hwnd(locators) do |hwnd|
+              window_visible(hwnd) && locators_match?(locators, window_properties(hwnd, locators))
+            end
+          end
+
+          def child_window_locators(parent_hwnd, locators)
+            child_hwnd = locators[:hwnd] || child_hwnd(parent_hwnd, locators)
+            if child_hwnd
+              locators.merge!(:hwnd => child_hwnd)
+            else
+              popup_hwnd = get_window(parent_hwnd, Constants::GW_ENABLEDPOPUP)
+              if popup_hwnd != parent_hwnd
+                popup_properties = window_properties(popup_hwnd, locators)
+                locators.merge!(:hwnd => popup_hwnd) if locators_match?(locators, popup_properties)
+              end
+            end
+            locators
+          end
+
+          def window_pid(hwnd)
+            pid = FFI::MemoryPointer.new :int
+            window_thread_process_id(hwnd, pid)
+            pid.read_int
+          end
+
+          def window_class(hwnd)
+            class_name = FFI::MemoryPointer.new :char, 512
+            _window_class(hwnd, class_name, 512)
+            class_name.read_string
+          end
+
+          alias_method :control_class, :window_class
+
+          def close_window(hwnd)
+            _close_window(hwnd)
+            closed = send_message_timeout(hwnd, Constants::WM_CLOSE,
+                                          0, nil, Constants::SMTO_ABORTIFHUNG, 1000, nil)
+            # force it to close
+            unless closed
+              process_hwnd = open_process(Constants::PROCESS_ALL_ACCESS, false, window_pid(hwnd))
+              terminate_process(process_hwnd, 0)
+              close_handle(process_hwnd)
+            end
+          end
+
+          def activate_window(hwnd)
+            set_foreground_window(hwnd)
+            set_active_window(hwnd)
+            bring_window_to_top(hwnd)
+            within_foreground_thread(hwnd) do
+              set_foreground_window(hwnd)
+              set_active_window(hwnd)
+              bring_window_to_top(hwnd)
+            end
+          end
+
+          alias_method :activate_control, :activate_window
+
+          def control_hwnd(window_hwnd, locators)
+            hwnd = find_hwnd(locators, window_hwnd) do |hwnd|
+              locators_match?(locators, control_properties(hwnd, locators))
+            end
+
+            raise UnknownElementException, "Element with #{locators.inspect} does not exist" if hwnd == 0 || hwnd.nil?
+            hwnd
+          end
+
+          alias_method :child_hwnd, :control_hwnd
+
+          def control_value(control_hwnd)
+            text_for(control_hwnd)
+          end
+
+          def control_click(control_hwnd)
+            post_message(control_hwnd, Constants::BM_CLICK, 0, nil)
+          end
+
+          def set_control_focus(control_hwnd)
+            within_foreground_thread control_hwnd do
+              _set_control_focus(control_hwnd)
+            end
+          end
+
+          def set_control_text(control_hwnd, text)
+            send_message(control_hwnd, Constants::WM_SETTEXT, 0, text)
+          end
+
+          def control_set?(control_hwnd)
+            get_button_state(control_hwnd) & Constants::STATE_SYSTEM_CHECKED != 0
+          end
+
+          def has_focus?(control_hwnd)
+            get_button_state(control_hwnd) & Constants::STATE_SYSTEM_FOCUSED != 0
+          end
+
+          def unavailable?(control_hwnd)
+            get_button_state(control_hwnd) & Constants::STATE_SYSTEM_UNAVAILABLE != 0
+          end
+
+          def retrieve_combobox_item_text(control_hwnd, item_no)
+            text_len = send_message(control_hwnd, Constants::CB_GETLBTEXTLEN, item_no, nil)
+
+            string_buffer = FFI::MemoryPointer.new :char, text_len
+            send_message(control_hwnd, Constants::CB_GETLBTEXT, item_no, string_buffer)
+            string_buffer.read_string
+          end
+
+          def control_name(control_hwnd)
+            string_buffer = FFI::MemoryPointer.new :char, 255
+            if (get_control_name(control_hwnd, string_buffer) == Constants::S_OK)
+              string_buffer.read_string
+            else
+              fail "Cannot get name for control with HWND 0x" + control_hwnd.to_s(16)
+            end
+          end
+
+          def retrieve_table_strings_for_row(control_hwnd, row)
+            hModule = load_library("oleacc.dll") # TODO should be done only one time
+
+            strings_ptr = FFI::MemoryPointer.new :pointer
+            columns_ptr = FFI::MemoryPointer.new :pointer
+
+            get_table_row_strings(hModule, control_hwnd, strings_ptr, row, columns_ptr)
+            str_ptr = strings_ptr.read_pointer
+            columns = columns_ptr.read_long
+
+            str_ptr.get_array_of_string(0, columns)
+          end
+
+          private
+
+          def within_foreground_thread(hwnd)
+            foreground_thread = current_thread_id
+            other_thread = window_thread_process_id(hwnd, nil)
+            attach_thread_input(foreground_thread, other_thread, true) unless other_thread == foreground_thread
+            yield
+          ensure
+            attach_thread_input(foreground_thread, other_thread, false) unless other_thread == foreground_thread
+          end
+
+          def window_properties(hwnd, locators)
+            element_properties(:window, hwnd, locators)
+          end
+
+          def control_properties(hwnd, locators)
+            element_properties(:control, hwnd, locators)
+          end
+
+          def element_properties(type, hwnd, locators)
+            locators.inject({}) do |properties, locator|
+              properties[locator[0]] = self.send("#{type}_#{locator[0]}", hwnd) unless locator[0] == :index
+              properties
+            end
+          end
+
+          def locators_match?(locators, properties)
+            locators.all? do |locator, value|
+              locator == :index or
+                value.is_a?(Regexp) ? properties[locator] =~ value : properties[locator] == value
+            end
+          end
+
+          def find_hwnd(locators, window_hwnd = nil)
+            found_hwnd = nil
+            found_index = -1
+            window_callback = FFI::Function.new(:bool, [:long, :pointer], {:convention => :stdcall}) do |hwnd, _|
+              if yield(hwnd)
+                found_index += 1
+
+                if locators[:index]
+                  found_hwnd = hwnd if locators[:index] == found_index
+                else
+                  found_hwnd = hwnd
+                end
+              end
+              !found_hwnd
+            end
+
+            unless window_hwnd
+              enum_windows(window_callback, nil)
+            else
+              enum_child_windows(window_hwnd, window_callback, nil)
+            end
+
+            found_hwnd
+          end
+
+          def text_for(hwnd)
+            text_length = send_message(hwnd, Constants::WM_GETTEXTLENGTH, 0, nil) + 1
+            text = FFI::MemoryPointer.new :char, text_length
+            send_message(hwnd, Constants::WM_GETTEXT, text_length, text)
+            text.read_string
+          end
+
+        end
+      end
+    end
+  end
+end
+