rautomation 0.5.1 → 0.6.0

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

@@ -14,7 +14,7 @@ module RAutomation
 
         SMTO_ABORTIFHUNG = 0x2
 
-        STANDARD_RIGHTS_REQUIRED = 0xF0000 
+        STANDARD_RIGHTS_REQUIRED = 0xF0000
         SYNCHRONIZE = 0x100000
         PROCESS_ALL_ACCESS = STANDARD_RIGHTS_REQUIRED | SYNCHRONIZE | 0xFFF
 
@@ -26,13 +26,41 @@ module RAutomation
         KEYEVENTF_EXTENDEDKEY = 0x1
         KEYEVENTF_KEYUP = 0x2
 
+        VK_BACK = 0x08
+        VK_TAB = 0x09
+        VK_RETURN = 0x0D
+        VK_SPACE = 0x20
+        VK_CAPITAL = 0x14
+        VK_LEFT = 0x25
+        VK_UP = 0x26
+        VK_RIGHT = 0x27
+        VK_DOWN = 0x28
+        VK_SHIFT = 0x10
+        VK_LSHIFT = 0xA0
+        VK_RSHIFT = 0xA1
+        VK_MENU = 0x12
+        VK_LMENU = 0xA4
+        VK_RMENU = 0xA5
+        VK_CONTROL = 0x11
+        VK_LCONTROL = 0xA2
+        VK_RCONTROL = 0xA3
+        VK_ESCAPE = 0x1B
+        VK_END = 0x23
+        VK_HOME = 0x24
+        VK_NUMLOCK = 0x90
+        VK_DELETE = 0x2E
+        VK_INSERT = 0x2D
+
         # GetWindow constants
         GW_ENABLEDPOPUP = 6
 
         # HRESULT
-        S_OK                 = 0
+        S_OK = 0
 
         # IAccessible Button States
+        STATE_SYSTEM_UNAVAILABLE = 0x00000001
+        STATE_SYSTEM_SELECTED = 0x00000002
+        STATE_SYSTEM_FOCUSED = 0x00000004
         STATE_SYSTEM_CHECKED = 0x00000010
 
         # Combobox
@@ -47,7 +75,20 @@ module RAutomation
         LVM_FIRST = 0x1000
         LVM_GETITEMCOUNT = LVM_FIRST + 4
 
+        # UI Automation control type IDs
+        UIA_LIST_CONTROL_TYPE = 50008
+        UIA_LIST_ITEM_CONTROL_TYPE = 50007
+        UIA_CHECKBOX_CONTROL_TYPE = 50002
+        UIA_BUTTON_CONTROL_TYPE = 50000
+        UIA_LABEL_CONTROL_TYPE = 50020
+        UIA_RADIO_BUTTON_CONTROL_TYPE = 50013
+        UIA_COMBOBOX_CONTROL_TYPE = 50003
+        UIA_EDIT_CONTROL_TYPE = 50004
+        UIA_HEADER_CONTROL_TYPE = 50034
+        UIA_HEADER_ITEM_CONTROL_TYPE	=	50035
+
+
       end
     end
   end
-end
+end

data/lib/rautomation/adapter/win_ffi/control.rb

@@ -20,15 +20,16 @@ module RAutomation
         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
+              Functions.set_control_focus(hwnd) &&
+              Functions.control_click(hwnd) &&
+              clicked = true # is clicked at least once
 
             block_given? ? yield : clicked && !exist?
           end
@@ -38,8 +39,40 @@ module RAutomation
           !!Functions.control_hwnd(@window.hwnd, @locators)
         end
 
+        def enabled?
+          !disabled?
+        end
+
+        def disabled?
+          Functions.unavailable?(Functions.control_hwnd(@window.hwnd, @locators))
+        end
+
+        def has_focus?
+          Functions.has_focus?(Functions.control_hwnd(@window.hwnd, @locators))
+        end
+
+        def set_focus
+          assert_enabled
+          uia_control = UiaDll::element_from_handle(Functions.control_hwnd(@window.hwnd, @locators))
+          UiaDll::set_focus(uia_control)
+        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
+        end
+
+        def matches_type(clazz)
+          UiaDll::current_control_type(uia_control(@locators[:id])) == clazz
+        end
+
         alias_method :exists?, :exist?
 
+        def assert_enabled
+          raise "Cannot interact with disabled control #{@locators.inspect} on window #{@window.locators.inspect}!" if disabled?
+        end
       end
     end
   end

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

@@ -78,6 +78,12 @@ module RAutomation
         # 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
 
@@ -174,8 +180,16 @@ module RAutomation
           end
 
           def control_hwnd(window_hwnd, locators)
-            find_hwnd(locators, window_hwnd) do |hwnd|
-              locators_match?(locators, control_properties(hwnd, locators))
+            if locators[:id].nil?
+              find_hwnd(locators, window_hwnd) do |hwnd|
+                locators_match?(locators, control_properties(hwnd, locators))
+              end
+            else
+              uia_window = UiaDll::element_from_handle(window_hwnd) # finds IUIAutomationElement for given parent window
+              uia_control = UiaDll::find_child_by_id(uia_window, locators[:id].to_s)
+              hwnd = UiaDll::current_native_window_handle(uia_control) # return HWND of UIA element
+              raise UnknownElementException, "#{locators[:id]} does not exist" if hwnd == 0
+              hwnd
             end
           end
 
@@ -203,6 +217,14 @@ module RAutomation
             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)
 
@@ -212,7 +234,6 @@ module RAutomation
           end
 
           def control_name(control_hwnd)
-            puts "Trying to get control name for #{control_hwnd}"
             string_buffer = FFI::MemoryPointer.new :char, 255
             if (get_control_name(control_hwnd, string_buffer) == Constants::S_OK)
               string_buffer.read_string
@@ -221,6 +242,19 @@ module RAutomation
             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)

data/lib/rautomation/adapter/win_ffi/keystroke_converter.rb

@@ -0,0 +1,67 @@
+module RAutomation
+  module Adapter
+    module WinFfi
+      class KeystrokeConverter
+        class << self
+          def convert(str)
+            special_characters = ""
+
+            str.split(/([{}])/).inject([]) do |converted_keys, str|
+              if str == "}"
+                converted_keys << convert_special_characters(special_characters << str)
+                special_characters = ""
+              elsif str == "{" || !special_characters.empty?
+                special_characters << str
+              else
+                converted_keys += convert_characters(str)
+              end
+              converted_keys
+            end.flatten
+          end
+
+          private
+
+          def convert_special_characters chars
+            case chars.downcase
+            when "{tab}"
+              Constants::VK_TAB
+            when "{backspace}"
+              Constants::VK_BACK
+            when "{enter}"
+              Constants::VK_RETURN
+            when "{left}"
+              Constants::VK_LEFT
+            when "{right}"
+              Constants::VK_RIGHT
+            when "{down}"
+              Constants::VK_DOWN
+            when "{up}"
+              Constants::VK_UP
+            else
+              # unsupported special tag, ignore the tag itself, but convert the
+              # characters inside the tag
+              convert_characters(chars.gsub(/[{}]/, ""))
+            end
+          end
+
+          private
+
+          def convert_characters(element)
+            element.split(//).inject([]) do |chars, char|
+              char_code = char.upcase.unpack("c")[0]
+              if char =~ /[A-Z]/
+                chars += in_upcase(char_code)
+              else
+                chars << char_code
+              end
+            end
+          end
+
+          def in_upcase(char_code)
+            [Constants::VK_LSHIFT, char_code]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rautomation/adapter/win_ffi/label.rb

@@ -0,0 +1,21 @@
+module RAutomation
+  module Adapter
+    module WinFfi
+      class Label < Control
+        include WaitHelper
+        include Locators
+
+        def value
+          Functions.control_value(Functions.control_hwnd(@window.hwnd, @locators))
+        end
+
+        def exist?
+          @locators[:id].nil? ? super : super && matches_type(Constants::UIA_LABEL_CONTROL_TYPE)
+        end
+
+        alias_method :exists?, :exist?
+
+      end
+    end
+  end
+end

data/lib/rautomation/adapter/win_ffi/list_box.rb

@@ -0,0 +1,60 @@
+module RAutomation
+  module Adapter
+    module WinFfi
+
+      class ListBox < Control
+        include WaitHelper
+        include Locators
+
+        def count
+          UiaDll::find_children(uia_control(@locators[:id]), nil)
+        end
+
+        def items
+          list_items = []
+          children = FFI::MemoryPointer.new :pointer, self.count
+          length = UiaDll::find_children(uia_control(@locators[:id]), children)
+          children.read_array_of_pointer(length).each do |child|
+            child_name = FFI::MemoryPointer.new :char, UiaDll::get_name(child, nil) + 1
+            UiaDll::get_name(child, child_name)
+            list_items.push child_name.read_string
+          end
+          list_items
+        end
+
+        def exist?
+          @locators[:id].nil? ? super : super && matches_type(Constants::UIA_LIST_CONTROL_TYPE)
+        end
+
+        alias_method :exists?, :exist?
+
+        def selected?(index)
+          children = FFI::MemoryPointer.new :pointer, self.count
+          length = UiaDll::find_children(uia_control(@locators[:id]), children)
+          target_element = children.read_array_of_pointer(length)[index]
+          is_selected = FFI::MemoryPointer.new :int, 1
+
+          if UiaDll::get_is_selected(target_element, is_selected) == 1
+            return is_selected.read_int == 1
+          else
+            return false
+          end
+        end
+
+        def select(index)
+          children = FFI::MemoryPointer.new :pointer, self.count
+
+          length = UiaDll::find_children(uia_control(@locators[:id]), children)
+          target_element = children.read_array_of_pointer(length)[index]
+
+          UiaDll::select(target_element)
+        end
+
+        alias_method :strings, :items
+
+
+      end
+    end
+  end
+end
+

data/lib/rautomation/adapter/win_ffi/locators.rb

@@ -13,7 +13,6 @@ module RAutomation
           locators[:index] = locators[:index].to_i if locators[:index]
 
           # control locator
-          locators[:id] = locators[:id].to_i if locators[:id]
           locators = self.class::DEFAULT_LOCATORS.merge(locators) if self.class.const_defined?(:DEFAULT_LOCATORS)
           @locators = locators
         end

data/lib/rautomation/adapter/win_ffi/ms_uia/uia_dll.rb

@@ -0,0 +1,36 @@
+module RAutomation
+  module Adapter
+    module WinFfi
+      # @private
+      module UiaDll
+        extend FFI::Library
+
+        ffi_lib File.dirname(__FILE__) + '/../../../../../ext/UiaDll/Release/UiaDll.dll'
+        ffi_convention :stdcall
+
+        attach_function :find_window, :RA_FindWindow,
+                        [:string], :pointer
+        attach_function :is_offscreen, :RA_IsOffscreen,
+                        [:pointer], :bool
+        attach_function :element_from_handle, :RA_ElementFromHandle,
+                        [:long], :pointer
+        attach_function :find_child_by_id, :RA_FindChildById,
+                        [:pointer, :string], :pointer
+        attach_function :current_native_window_handle, :RA_CurrentNativeWindowHandle,
+                        [:pointer], :long
+        attach_function :set_focus, :RA_SetFocus,
+                        [:pointer], :bool
+        attach_function :current_control_type, :RA_GetCurrentControlType,
+                        [:pointer], :int
+        attach_function :find_children, :RA_FindChildren,
+                        [:pointer, :pointer], :int
+        attach_function :get_name, :RA_GetName,
+                        [:pointer, :pointer], :int
+        attach_function :get_is_selected, :RA_GetIsSelected,
+                        [:pointer, :pointer], :int
+        attach_function :select, :RA_Select,
+                        [:pointer], :int
+      end
+    end
+  end
+end

data/lib/rautomation/adapter/win_ffi/radio.rb

@@ -6,6 +6,13 @@ module RAutomation
         include Locators
         include ButtonHelper
 
+
+        def exist?
+          @locators[:id].nil? ? super : super && matches_type(Constants::UIA_RADIO_BUTTON_CONTROL_TYPE)
+        end
+
+        alias_method :exists?, :exist?
+
       end
     end
   end

data/lib/rautomation/adapter/win_ffi/select_list.rb

@@ -9,21 +9,24 @@ module RAutomation
         class SelectListOption
           attr_accessor :text, :index, :control_hwnd
 
-          def initialize(control_hwnd, text, index)
-            @control_hwnd = control_hwnd
+          def initialize(select_list, text, index)
+            @select_list = select_list
             @text = text
             @index = index
           end
 
           def selected?
-            selected_idx = Functions.send_message(@control_hwnd, Constants::CB_GETCURSEL, 0, nil)
+            selected_idx = Functions.send_message(@select_list.control_hwnd, Constants::CB_GETCURSEL, 0, nil)
             return false if selected_idx == Constants::CB_ERR
-            @text == Functions.retrieve_combobox_item_text(@control_hwnd, selected_idx)
+            @text == Functions.retrieve_combobox_item_text(@select_list.control_hwnd, selected_idx)
           end
 
           def select
-            Functions.send_message(@control_hwnd, Constants::CB_SETCURSEL, @index, nil) != Constants::CB_ERR
+            @select_list.assert_enabled
+            Functions.send_message(@select_list.control_hwnd, Constants::CB_SETCURSEL, @index, nil) != Constants::CB_ERR
           end
+
+          alias_method :set, :select
         end
 
         def initialize(window, locators)
@@ -38,9 +41,9 @@ module RAutomation
             item = Functions.retrieve_combobox_item_text(@hwnd, item_no)
 
             if options[:text] 
-              items.push(SelectListOption.new(@hwnd, item, item_no)) if options[:text] == item
+              items.push(SelectListOption.new(self, item, item_no)) if options[:text] == item
             else
-              items.push(SelectListOption.new(@hwnd, item, item_no))
+              items.push(SelectListOption.new(self, item, item_no))
             end
           end
 
@@ -52,12 +55,32 @@ module RAutomation
           selected_option ? selected_option.text : ""
         end
 
+        def option(options)
+          item_count.times do |item_no|
+            item = Functions.retrieve_combobox_item_text(@hwnd, item_no)
+            return SelectListOption.new(self, item, item_no) if options[:text] == item
+          end
+
+          nil
+        end
+
+        def control_hwnd
+          @hwnd
+        end
+
+        def exist?
+          @locators[:id].nil? ? super : super && matches_type(Constants::UIA_COMBOBOX_CONTROL_TYPE)
+        end
+
+        alias_method :exists?, :exist?
+
         private
 
         def item_count
           Functions.send_message(@hwnd, Constants::CB_GETCOUNT, 0, nil)
         end
 
+
       end
     end
   end