rautomation 0.6.3 → 0.7.0

data/lib/rautomation/adapter/{win_ffi → ms_uia}/functions.rb

@@ -1,6 +1,9 @@
+#todo - replace as much of this as possible with UIA versions
+
+
 module RAutomation
   module Adapter
-    module WinFfi
+    module MsUia
       # @private
       module Functions
         extend FFI::Library
@@ -128,20 +131,6 @@ module RAutomation
             locators
           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)
@@ -180,16 +169,25 @@ module RAutomation
           end
 
           def control_hwnd(window_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
+            case
+              when locators[:id]
+                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
+              when locators[:point]
+                uia_control = UiaDll::element_from_point(locators[:point][0], locators[:point][1])
+                hwnd = UiaDll::current_native_window_handle(uia_control) # return HWND of UIA element
+                raise UnknownElementException, "#{locators[:point]} does not exist" if hwnd == 0
+                hwnd
+              else
+                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) or (hwnd == nil)
+                hwnd
             end
           end
 
@@ -243,7 +241,7 @@ module RAutomation
           end
 
           def retrieve_table_strings_for_row(control_hwnd, row)
-            hModule = load_library("oleacc.dll")   # TODO should be done only one time
+            hModule = load_library("oleacc.dll") # TODO should be done only one time
 
             strings_ptr = FFI::MemoryPointer.new :pointer
             columns_ptr = FFI::MemoryPointer.new :pointer

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

@@ -0,0 +1,122 @@
+#todo - common file, extract it
+
+module RAutomation
+  module Adapter
+    module MsUia
+      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
+              when "{home}"
+                Constants::VK_HOME
+              when "{end}"
+                Constants::VK_END
+              when "{delete}"
+                Constants::VK_DELETE
+              when "{pgdown}"
+                Constants::VK_NEXT
+              when "{pgup}"
+                Constants::VK_PRIOR
+              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]
+              case char
+                when "!"
+                  chars += in_upcase(49)
+                when "@"
+                  chars += in_upcase(50)
+                when "\#"
+                  chars += in_upcase(51)
+                when "$"
+                  chars += in_upcase(52)
+                when "%"
+                  chars += in_upcase(53)
+                when "^"
+                  chars += in_upcase(54)
+                when "&"
+                  chars += in_upcase(55)
+                when "*"
+                  chars += in_upcase(56)
+                when "("
+                  chars += in_upcase(57)
+                when ")"
+                  chars += in_upcase(48)
+                when "\""
+                  chars += in_upcase(0xDE)
+                when "'"
+                  chars << 0xDE
+                when "/"
+                  chars << 0xBF
+                when "-"
+                  chars << 0xBD
+                when ","
+                  chars << 0xBC
+                when "'"
+                  chars << 0xDE
+                when "&"
+                  chars += in_upcase(0x37)
+                when "_"
+                  chars += in_upcase(0xBD)
+                when "<"
+                  chars += in_upcase(0xBC)
+                when ">"
+                  chars += in_upcase(0xBE)
+                else
+                  if char =~ /[A-Z]/
+                    chars += in_upcase(char_code)
+                  else
+                    chars << char_code
+                  end
+              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 → ms_uia}/label.rb

@@ -1,16 +1,17 @@
 module RAutomation
   module Adapter
-    module WinFfi
+    module MsUia
       class Label < Control
         include WaitHelper
         include Locators
 
+        #todo - replace with UIA version
         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)
+          super && matches_type?(Constants::UIA_TEXT_CONTROL_TYPE)
         end
 
         alias_method :exists?, :exist?

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

@@ -0,0 +1,91 @@
+module RAutomation
+  module Adapter
+    module MsUia
+
+      class ListBox < Control
+        include WaitHelper
+        include Locators
+
+        def count
+          UiaDll::find_children(uia_element, nil)
+        end
+
+        def items
+          list_items = []
+          children = FFI::MemoryPointer.new :pointer, self.count
+          length = UiaDll::find_children(uia_element, children)
+
+          children.read_array_of_pointer(length).each do |child|
+            if (UiaDll::current_control_type(child) == Constants::UIA_LIST_ITEM_CONTROL_TYPE) or (UiaDll::current_control_type(child) == Constants::UIA_DATA_ITEM_CONTROL_TYPE)
+              child_name = FFI::MemoryPointer.new :char, UiaDll::get_name(child, nil) + 1
+              UiaDll::get_name(child, child_name)
+              list_items.push(@window.list_item(:value => child_name.read_string))
+            end
+          end
+
+          list_items
+        end
+
+        def strings
+          items.collect { |item| item.value}
+        end
+
+        def value
+          count.times do |index|
+            if selected?(index)
+              return strings[index]
+            end
+          end
+
+          ""
+        end
+
+        def exist?
+          super && matches_type?(Constants::UIA_LIST_CONTROL_TYPE)
+        end
+
+        alias_method :exists?, :exist?
+
+        def selected?(index)
+          if items[index]
+            return items[index].selected?
+          end
+
+          false
+        end
+
+        def select(index)
+          children = FFI::MemoryPointer.new :pointer, self.count
+
+          length = UiaDll::find_children(uia_element, children)
+
+          target_element = children.read_array_of_pointer(length)[index]
+
+          UiaDll::select(target_element)
+        end
+
+        def list_boundary
+          boundary = FFI::MemoryPointer.new :long, 4
+
+          Functions.send_message(hwnd, Constants::LB_GETITEMRECT, 0 ,boundary)
+
+          boundary.read_array_of_long(4)
+        end
+
+        def get_top_index
+          Functions.send_message(hwnd, Constants::LB_GETTOPINDEX, 0 ,nil)
+        end
+
+        def list_item_height
+          Functions.send_message(hwnd, Constants::LB_GETITEMHEIGHT, 0 ,nil)
+        end
+
+        def scroll_to_item(row)
+          Functions.send_message(hwnd, Constants::LB_SETTOPINDEX, row ,nil)
+        end
+
+      end
+    end
+  end
+end
+

data/lib/rautomation/adapter/ms_uia/list_item.rb

@@ -0,0 +1,49 @@
+module RAutomation
+  module Adapter
+    module MsUia
+      class ListItem < Control
+        include WaitHelper
+        include Locators
+
+        #Can't get by value without a handle or a bug fix in the new way of getting a control by value so this is a workaround
+        def uia_element
+          if @locators[:value]
+            uia_window = UiaDll::element_from_handle(@window.hwnd)
+            begin
+              uia_window.read_pointer
+            rescue FFI::NullPointerError => e
+              raise UnknownElementException, "Window with handle #{@window.hwnd} does not exist"
+            end
+            uia_control = UiaDll::find_child_by_name(uia_window, @locators[:value].to_s)
+            begin
+              uia_control.read_pointer
+            rescue FFI::NullPointerError => e
+              raise UnknownElementException, "#{@locators[:value]} does not exist"
+            end
+            uia_control
+          else
+            super
+          end
+        end
+
+        def value
+          list_item = uia_element
+          item_value = FFI::MemoryPointer.new :char, UiaDll::get_name(list_item, nil) + 1
+          UiaDll::get_name(list_item, item_value)
+          item_value.read_string
+        end
+
+        def exist?
+          super && matches_type?(Constants::UIA_LIST_ITEM_CONTROL_TYPE)
+        end
+
+        def selected?
+          UiaDll::get_is_selected(uia_element)
+        end
+
+        alias_method :exists?, :exist?
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+#todo - some files are common between Win32 and MsUia adapter, consider pulling out to shared location
+
+module RAutomation
+  module Adapter
+    module MsUia
+      module Locators
+
+        private
+
+        def extract(locators)
+          # windows locators
+          @hwnd = locators[:hwnd].to_i if locators[:hwnd]
+          locators[:pid] = locators[:pid].to_i if locators[:pid]
+          locators[:index] = locators[:index].to_i if locators[:index]
+
+          # control locator
+          locators = self.class::DEFAULT_LOCATORS.merge(locators) if self.class.const_defined?(:DEFAULT_LOCATORS)
+          @locators = {:index => 0}.merge locators
+        end
+      end
+    end
+  end
+end

data/lib/rautomation/adapter/{win_ffi → ms_uia}/radio.rb

@@ -1,6 +1,6 @@
 module RAutomation
   module Adapter
-    module WinFfi
+    module MsUia
       class Radio < Control
         include WaitHelper
         include Locators
@@ -8,7 +8,7 @@ module RAutomation
 
 
         def exist?
-          @locators[:id].nil? ? super : super && matches_type(Constants::UIA_RADIO_BUTTON_CONTROL_TYPE)
+          super && matches_type?(Constants::UIA_RADIO_BUTTON_CONTROL_TYPE)
         end
 
         alias_method :exists?, :exist?

data/lib/rautomation/adapter/{win_ffi → ms_uia}/select_list.rb

@@ -1,6 +1,6 @@
 module RAutomation
   module Adapter
-    module WinFfi
+    module MsUia
 
       class SelectList < Control
         include WaitHelper
@@ -11,16 +11,18 @@ module RAutomation
 
           def initialize(select_list, text, index)
             @select_list = select_list
-            @text = text
-            @index = index
+            @text        = text
+            @index       = index
           end
 
+          #todo - replace with UIA version
           def selected?
             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(@select_list.control_hwnd, selected_idx)
           end
 
+          #todo - replace with UIA version
           def select
             @select_list.assert_enabled
             Functions.send_message(@select_list.control_hwnd, Constants::CB_SETCURSEL, @index, nil) != Constants::CB_ERR
@@ -29,18 +31,25 @@ module RAutomation
           alias_method :set, :select
         end
 
+        #todo - replace with UIA version
         def initialize(window, locators)
           super
           @hwnd = Functions.control_hwnd(@window.hwnd, @locators)
         end
 
+        def set(value)
+          list      = UiaDll::element_from_handle(@hwnd)
+          UiaDll::set_value(list, value)
+        end
+
+        #todo - replace with UIA version
         def options(options = {})
           items = []
 
           item_count.times do |item_no|
             item = Functions.retrieve_combobox_item_text(@hwnd, item_no)
 
-            if options[:text] 
+            if options[:text]
               items.push(SelectListOption.new(self, item, item_no)) if options[:text] == item
             else
               items.push(SelectListOption.new(self, item, item_no))
@@ -51,10 +60,11 @@ module RAutomation
         end
 
         def value
-          selected_option = options.find {|option| option.selected?}
+          selected_option = options.find { |option| option.selected? }
           selected_option ? selected_option.text : ""
         end
 
+        #todo - replace with UIA version
         def option(options)
           item_count.times do |item_no|
             item = Functions.retrieve_combobox_item_text(@hwnd, item_no)
@@ -68,19 +78,43 @@ module RAutomation
           @hwnd
         end
 
+        def select(index)
+          Functions.send_message(@hwnd, Constants::CB_SETCURSEL, index, nil) != Constants::CB_ERR
+        end
+
+        def list_item_height
+          Functions.send_message(@hwnd, Constants::CB_GETITEMHEIGHT, 0 ,nil)
+        end
+
+        def dropbox_boundary
+          boundary = FFI::MemoryPointer.new :long, 4
+
+          Functions.send_message(@hwnd, Constants::CB_GETDROPPEDCONTROLRECT, 0 ,boundary)
+
+          boundary.read_array_of_long(4)
+        end
+
+        def get_top_index
+          Functions.send_message(@hwnd, Constants::CB_GETTOPINDEX, 0 ,nil)
+        end
+
+        def scroll_to_item(row)
+          Functions.send_message(@hwnd, Constants::CB_SETTOPINDEX , row ,nil)
+        end
+
         def exist?
-          @locators[:id].nil? ? super : super && matches_type(Constants::UIA_COMBOBOX_CONTROL_TYPE)
+          super && matches_type?(Constants::UIA_COMBOBOX_CONTROL_TYPE)
         end
 
         alias_method :exists?, :exist?
 
         private
 
+        #todo - replace with UIA version
         def item_count
           Functions.send_message(@hwnd, Constants::CB_GETCOUNT, 0, nil)
         end
 
-
       end
     end
   end