rautomation 0.6.3 → 0.7.0

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

@@ -0,0 +1,86 @@
+module RAutomation
+  module Adapter
+    module MsUia
+      class Table < Control
+        include WaitHelper
+        include Locators
+
+        def strings
+          rows = []
+          header_columns = []
+
+          raise "Not a list control" unless UiaDll::current_control_type(uia_element) == Constants::UIA_LIST_CONTROL_TYPE
+
+
+          children_count = count_children(uia_element)
+
+          children = FFI::MemoryPointer.new :pointer, children_count
+          UiaDll::find_children(uia_element, children)
+
+
+          children.read_array_of_pointer(children_count).each do |child|
+            grandchildren_count = count_children(child)
+
+            if grandchildren_count > 0
+
+              grandchildren = FFI::MemoryPointer.new :pointer, grandchildren_count
+              UiaDll::find_children(child, grandchildren)
+
+              grandchildren.read_array_of_pointer(grandchildren_count).each do |grandchild|
+                grandchild_name = FFI::MemoryPointer.new :char, UiaDll::get_name(grandchild, nil) + 1
+                UiaDll::get_name(grandchild, grandchild_name)
+                header_columns.push grandchild_name.read_string
+              end
+            else
+              grandchild_name = FFI::MemoryPointer.new :char, UiaDll::get_name(child, nil) + 1
+              UiaDll::get_name(child, grandchild_name)
+              header_columns = grandchild_name.read_string
+            end
+
+            rows.push header_columns
+            header_columns = []
+          end
+
+          rows
+        end
+
+#        def select(row)
+#          Functions.select_table_row(Window.oleacc_module_handle, Functions.control_hwnd(@window.hwnd, @locators), row)
+#        end
+
+        def select(index)
+          children = FFI::MemoryPointer.new :pointer, row_count
+
+          length = UiaDll::find_children(uia_element, children)
+
+          target_element = children.read_array_of_pointer(length)[index]
+
+          UiaDll::select(target_element)
+        end
+
+        #todo - replace with UIA version
+        def selected?(row)
+          state = Functions.get_table_row_state(Window.oleacc_module_handle, Functions.control_hwnd(@window.hwnd, @locators), row)
+          state & Constants::STATE_SYSTEM_SELECTED != 0
+        end
+
+        def row_count
+          UiaDll::find_children(uia_element, nil)
+        end
+
+        def exist?
+          super && matches_type?(Constants::UIA_LIST_CONTROL_TYPE)
+        end
+
+        alias_method :exists?, :exist?
+
+        private
+
+        def count_children(element)
+          UiaDll::find_children(element, nil)
+        end
+
+      end
+    end
+  end
+end

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

@@ -1,6 +1,6 @@
 module RAutomation
   module Adapter
-    module WinFfi
+    module MsUia
       class TextField < Control
         include WaitHelper
         include Locators
@@ -8,6 +8,7 @@ module RAutomation
         # Default locators used for searching text fields.
         DEFAULT_LOCATORS = {:class => /edit/i}
 
+        #todo - replace with UIA version
         # @see RAutomation::TextField#set
         def set(text)
           raise "Cannot set value on a disabled text field" if disabled?
@@ -28,24 +29,24 @@ module RAutomation
           set ""
         end
 
+        #todo - replace with UIA version
         # @see RAutomation::TextField#value
         def value
           Functions.control_value(hwnd)
         end
 
+        #todo - replace with UIA version
         # @see RAutomation::TextField#hwnd
         def hwnd
           Functions.control_hwnd(@window.hwnd, @locators)
         end
 
         def exist?
-          @locators[:id].nil? ? super : super && matches_type(Constants::UIA_EDIT_CONTROL_TYPE)
+          super && matches_type?(Constants::UIA_EDIT_CONTROL_TYPE)
         end
 
         alias_method :exists?, :exist?
 
-
-
       end
     end
   end

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

@@ -0,0 +1,62 @@
+#todo - move this file up to the same level as the others
+#todo - organize the methods better
+
+module RAutomation
+  module Adapter
+    module MsUia
+      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 :element_from_point, :RA_ElementFromPoint,
+                        [:int, :int], :pointer
+        attach_function :get_focused_element, :RA_GetFocusedElement,
+                        [], :pointer
+        attach_function :find_child_by_id, :RA_FindChildById,
+                        [:pointer, :string], :pointer
+        attach_function :find_child_by_name, :RA_FindChildByName,
+                        [: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 :desktop_handle, :RA_GetDesktopHandle,
+                        [], :long
+        attach_function :move_mouse, :RA_MoveMouse,
+                        [:int,:int], :long
+        attach_function :click_mouse, :RA_ClickMouse,
+                        [], :long
+        attach_function :bounding_rectangle, :RA_CurrentBoundingRectangle,
+                        [:pointer, :pointer], :int
+        attach_function :is_offscreen, :RA_CurrentIsOffscreen,
+                        [:pointer, :pointer], :int
+        attach_function :find_children, :RA_FindChildren,
+                        [:pointer, :pointer], :int
+        attach_function :get_name, :RA_GetName,
+                        [:pointer, :pointer], :int
+        attach_function :get_class_name, :RA_GetClassName,
+                        [:pointer, :pointer], :int
+        attach_function :get_is_selected, :RA_GetIsSelected,
+                        [:pointer], :bool
+        attach_function :select, :RA_Select,
+                        [:pointer], :int
+        attach_function :set_value, :RA_Set_Value,
+                        [:pointer, :pointer], :int
+        attach_function :find_window_by_pid, :RA_FindWindowByPID,
+                        [:int], :pointer
+        attach_function :current_process_id, :RA_GetCurrentProcessId,
+                        [:pointer], :int
+      end
+    end
+  end
+end

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

@@ -0,0 +1,364 @@
+module RAutomation
+  module Adapter
+    module MsUia
+      autoload :UiaDll, File.dirname(__FILE__) + "/uia_dll"
+
+      class Window
+        include WaitHelper
+        include Locators
+        extend ElementCollections
+
+        has_many :controls
+
+        #todo - figure out what this is for and see if MsUia still needs it
+        class << self
+          def oleacc_module_handle
+            @oleacc_module_handle ||= begin
+              oleacc = Functions.load_library "oleacc.dll"
+              Functions.co_initialize nil
+              oleacc
+            end
+          end
+        end
+
+        # Locators of the window.
+        attr_reader :locators
+
+        # Possible locators are :title, :text, :hwnd, :pid, :class and :index.
+        #todo - update list of valid locators for UIA
+        # Creates the window object.
+        # @note this method is not meant to be accessed directly, but only through {RAutomation::Window#initialize}!
+        # @param [Hash] locators for searching the window.
+        # @option locators [String, Regexp] :title Title of the window
+        # @option locators [String, Regexp] :text Visible text of the window
+        # @option locators [String, Regexp] :class Internal class name of the window
+        # @option locators [String, Fixnum] :hwnd Window handle in decimal format
+        # @option locators [String, Fixnum] :pid Window process ID (PID)
+        # @option locators [String, Fixnum] :index 0-based index to specify n-th window if all other criteria match
+        #   all other criteria match
+        # @see RAutomation::Window#initialize
+        def initialize(container, locators)
+          @container = container
+          extract(locators)
+        end
+
+        #todo - replace with UIA version
+        # Retrieves handle of the window.
+        # @note Searches only for visible windows.
+        # @see RAutomation::Window#hwnd
+        def hwnd
+          @hwnd ||= Functions.window_hwnd(@locators)
+        end
+
+        #todo - replace with UIA version
+        # @see RAutomation::Window#pid
+        def pid
+          Functions.window_pid(hwnd)
+        end
+
+        #todo - replace with UIA version
+        # @see RAutomation::Window#title
+        def title
+          Functions.window_title(hwnd)
+        end
+
+        # @see RAutomation::Window#class_names
+        def class_names
+          root_element = UiaDll::element_from_handle(hwnd)
+
+          root_class = FFI::MemoryPointer.new :char, UiaDll::get_class_name(root_element, nil) + 1
+          UiaDll::get_class_name(root_element, root_class)
+
+          classes = gather_children_classes(root_element)
+          classes = classes.flatten
+          classes.delete("")
+          classes.sort
+        end
+
+        # @see RAutomation::Window#activate
+        def activate
+          return if !exists? || active?
+          restore if minimized?
+          Functions.activate_window(hwnd)
+          restore if minimized?
+          sleep 1
+        end
+
+        #todo - replace with UIA version
+        # @see RAutomation::Window#active?
+        def active?
+          exists? && Functions.foreground_window == hwnd
+        end
+
+        #todo - replace with UIA version
+        # @see RAutomation::Window#text
+        def text
+          Functions.window_text(hwnd)
+        end
+
+        #todo - replace with UIA version
+        # @see RAutomation::Window#exists?
+        def exists?
+          hwnd && Functions.window_exists(hwnd)
+        end
+
+        #todo - replace with UIA version
+        # @see RAutomation::Window#visible?
+        def visible?
+          Functions.window_visible(hwnd)
+        end
+
+        #todo - replace with UIA version
+        # @see RAutomation::Window#maximize
+        def maximize
+          Functions.show_window(hwnd, Constants::SW_MAXIMIZE)
+          sleep 1
+        end
+
+        #todo - replace with UIA version
+        # @see RAutomation::Window#minimize
+        def minimize
+          Functions.show_window(hwnd, Constants::SW_MINIMIZE)
+          sleep 1
+        end
+
+        #todo - replace with UIA version
+        # @see RAutomation::Window#minimized?
+        def minimized?
+          Functions.minimized(hwnd)
+        end
+
+        #todo - replace with UIA version
+        # @see RAutomation::Window#restore
+        def restore
+          Functions.show_window(hwnd, Constants::SW_RESTORE)
+          sleep 1
+        end
+
+        #todo - replace with UIA version if possible
+        # Activates the window and sends keys to it.
+        #
+        # Refer to KeystrokeConverter#convert_special_characters for the special keycodes.
+        # @see RAutomation::Window#send_keys
+        def send_keys(keys)
+          shift_pressed = false
+          KeystrokeConverter.convert(keys[0]).each do |key|
+            wait_until do
+              activate
+              active?
+            end
+            press_key key
+
+            if key == Constants::VK_LSHIFT
+              shift_pressed = true
+              next
+            end
+
+            release_key key
+
+            if shift_pressed
+              shift_pressed = false
+              release_key Constants::VK_LSHIFT
+            end
+          end
+        end
+
+        #todo - replace with UIA version
+        # @see RAutomation::Window#close
+        def close
+          Functions.close_window(hwnd)
+        end
+
+        # @see Button#initialize
+        # @see RAutomation::Window#button
+        def button(locator)
+          Button.new(self, locator)
+        end
+
+        # @see TextField#initialize
+        # @see RAutomation::Window#text_field
+        def text_field(locator)
+          TextField.new(self, locator)
+        end
+
+        # Redirects all method calls not part of the public API to the {Functions} directly.
+        # @see RAutomation::Window#method_missing
+        def method_missing(name, *args)
+          Functions.respond_to?(name) ? Functions.send(name, *args) : super
+        end
+
+        # MsUia adapter specific API methods
+        def element
+          case
+            when @locators[:focus]
+              uia_control = UiaDll::get_focused_element
+            when @locators[:id]
+              uia_control = UiaDll::find_window(@locators[:id].to_s)
+              raise UnknownElementException, "#{@locators[:id]} does not exist" if uia_control.nil?
+            when @locators[:point]
+              uia_control = UiaDll::element_from_point(@locators[:point][0], @locators[:point][1])
+              raise UnknownElementException, "#{@locators[:point]} does not exist" if uia_control.nil?
+            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)
+              uia_control = UiaDll::element_from_handle(hwnd)
+          end
+          uia_control
+        end
+
+        def new_pid
+          UiaDll::current_process_id(uia_control())
+        end
+
+        def display_tree
+          root_element = UiaDll::element_from_handle(hwnd)
+
+          root_name = FFI::MemoryPointer.new :char, UiaDll::get_name(root_element, nil) + 1
+          UiaDll::get_name(root_element, root_name)
+
+          [root_name.read_string.inspect, gather_children(root_element)]
+        end
+
+        def gather_children(root_element)
+          element_tree = []
+
+          child_count = count_children(root_element)
+          children = FFI::MemoryPointer.new :pointer, child_count
+          UiaDll::find_children(root_element, children)
+
+          children.read_array_of_pointer(child_count).each do |child|
+            child_name = FFI::MemoryPointer.new :char, UiaDll::get_name(child, nil) + 1
+            UiaDll::get_name(child, child_name)
+
+            grandchild_count = count_children(child)
+
+            if grandchild_count > 0
+              element_tree << [child_name.read_string, gather_children(child)]
+            else
+              element_tree << child_name.read_string
+            end
+          end
+
+          element_tree
+        end
+
+        def count_children(element)
+          UiaDll::find_children(element, nil)
+        end
+
+        def gather_children_classes(root_element)
+          element_tree = []
+
+          child_count = count_children(root_element)
+          children = FFI::MemoryPointer.new :pointer, child_count
+          UiaDll::find_children(root_element, children)
+
+          children.read_array_of_pointer(child_count).each do |child|
+            child_name = FFI::MemoryPointer.new :char, UiaDll::get_class_name(child, nil) + 1
+            UiaDll::get_class_name(child, child_name)
+
+            grandchild_count = count_children(child)
+
+            if grandchild_count > 0
+              element_tree << [child_name.read_string, gather_children_classes(child)]
+            else
+              element_tree << child_name.read_string
+            end
+          end
+
+          element_tree
+        end
+
+        def get_focused_element
+          UiaDll::get_focused_element()
+        end
+
+        def bounding_rectangle
+          window = UiaDll::element_from_handle(hwnd)
+
+          boundary = FFI::MemoryPointer.new :long, 4
+          UiaDll::bounding_rectangle(window, boundary)
+
+          boundary.read_array_of_long(4)
+        end
+
+        def move_mouse(x, y)
+          UiaDll::move_mouse(x, y)
+        end
+
+        def click_mouse()
+          UiaDll::click_mouse
+        end
+
+        def label(locator)
+          @container.wait_until_present
+          Label.new(self, locator)
+        end
+
+        def control(locator)
+          @container.wait_until_present
+          Control.new(self, locator)
+        end
+
+        def controls(locator)
+          @container.wait_until_present
+          Controls.new(self, locator)
+        end
+
+        def list_box(locator)
+          @container.wait_until_present
+          ListBox.new(self, locator)
+        end
+
+        def list_item(locator)
+          @container.wait_until_present
+          ListItem.new(self, locator)
+        end
+
+        def select_list(locator)
+          @container.wait_until_present
+          SelectList.new(self, locator)
+        end
+
+        def checkbox(locator)
+          @container.wait_until_present
+          Checkbox.new(self, locator)
+        end
+
+        def radio(locator)
+          @container.wait_until_present
+          Radio.new(self, locator)
+        end
+
+        def table(locator)
+          @container.wait_until_present
+          Table.new(self, locator)
+        end
+
+        #todo - replace with UIA version
+        # Creates the child window object.
+        # @note This is an Win32 adapter specific method, not part of the public API
+        # @example
+        #   RAutomation::Window.new(:title => /Windows Internet Explorer/i).
+        #     child(:title => /some popup/)
+        # @param (see Window#initialize)
+        # @return [RAutomation::Window] child window, popup or regular window.
+        def child(locators)
+          RAutomation::Window.new Functions.child_window_locators(hwnd, locators)
+        end
+
+        private
+
+        def press_key key
+          Functions.send_key(key, 0, 0, nil)
+        end
+
+        def release_key key
+          Functions.send_key(key, 0, Constants::KEYEVENTF_KEYUP, nil)
+        end
+      end
+    end
+  end
+end