rautomation 2.0.1-x86-mingw32

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

@@ -0,0 +1,279 @@
+#todo - replace as much of this as possible with UIA versions
+
+
+module RAutomation
+  module Adapter
+    module MsUia
+      # @private
+      module Functions
+        extend FFI::Library
+
+        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 :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
+
+        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
+          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.merge(:adapter => :ms_uia)
+          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
+
+          def control_hwnd(window_hwnd, locators)
+            case
+              when locators[:id]
+                UiaDll.cached_hwnd(UiaDll::SearchCriteria.from_locator(window_hwnd, locators))
+              when locators[:point]
+                UiaDll::handle_from_point(*locators[:point])
+              else
+                find_hwnd(locators, window_hwnd) do |hwnd|
+                  locators_match?(locators, control_properties(hwnd, locators))
+                end
+            end
+          end
+
+          alias_method :child_hwnd, :control_hwnd
+
+          def control_value(control_hwnd)
+            text_for(control_hwnd)
+          end
+
+          def set_control_focus(control_hwnd)
+            within_foreground_thread control_hwnd do
+              _set_control_focus(control_hwnd)
+            end
+          end
+
+          def retrieve_combobox_item_text(control_hwnd, item_no)
+            text_len = 1024
+            string_buffer = FFI::MemoryPointer.new :char, text_len
+            UiaDll::select_list_value_at control_hwnd, item_no, string_buffer, text_len
+            string_buffer.read_string
+          end
+
+          def control_name(control_hwnd)
+            UiaDll::name(UiaDll::SearchCriteria.from_locator(control_hwnd, :hwnd => control_hwnd))
+          end
+
+          private
+
+          def within_foreground_thread(hwnd)
+            foreground_thread = window_thread_process_id(foreground_window, nil)
+            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|
+              if locator == :index
+                true
+              elsif value.is_a?(Regexp)
+                properties[locator] =~ value
+              else
+                properties[locator] == value
+              end
+            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
+

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

@@ -0,0 +1,121 @@
+module RAutomation
+  module Adapter
+    module MsUia
+      class Keys
+        KEYS = {
+          # keycodes from http://msdn.microsoft.com/en-us/library/ms927178.aspx
+          :null         => 0x00,
+          :cancel       => 0x03,
+          :help         => 0x2F,
+          :backspace    => 0x08,
+          :tab          => 0x09,
+          :clear        => 0x0C,
+          :return       => 0x0D,
+          :enter        => 0x0D,
+          :shift        => 0x10,
+          :left_shift   => 0xA0,
+          :control      => 0x11,
+          :left_control => 0xA2,
+          :alt          => 0x12,
+          :left_alt     => 0xA4,
+          :pause        => 0x13,
+          :escape       => 0x1B,
+          :space        => 0x20,
+          :page_up      => 0x21,
+          :page_down    => 0x22,
+          :end          => 0x23,
+          :home         => 0x24,
+          :left         => 0x25,
+          :arrow_left   => 0x25,
+          :up           => 0x26,
+          :arrow_up     => 0x26,
+          :right        => 0x27,
+          :arrow_right  => 0x27,
+          :down         => 0x28,
+          :arrow_down   => 0x28,
+          :insert       => 0x2D,
+          :delete       => 0x2E,
+          :semicolon    => 0x3B,
+          :equals       => 0x3D,
+          :numpad0      => 0x60,
+          :numpad1      => 0x61,
+          :numpad2      => 0x62,
+          :numpad3      => 0x63,
+          :numpad4      => 0x64,
+          :numpad5      => 0x65,
+          :numpad6      => 0x66,
+          :numpad7      => 0x67,
+          :numpad8      => 0x68,
+          :numpad9      => 0x69,
+          :multiply     => 0x6A,
+          :add          => 0x6B,
+          :separator    => 0x6C,
+          :subtract     => 0x6D,
+          :decimal      => 0x6E,
+          :divide       => 0x6F,
+          :f1           => 0x70,
+          :f2           => 0x71,
+          :f3           => 0x72,
+          :f4           => 0x73,
+          :f5           => 0x74,
+          :f6           => 0x75,
+          :f7           => 0x76,
+          :f8           => 0x77,
+          :f9           => 0x78,
+          :f10          => 0x79,
+          :f11          => 0x7A,
+          :f12          => 0x7B,
+        }            
+
+        SPECIAL_KEYS = {
+          "!"   => 0x31,
+          "@"   => 0x32,
+          "#"   => 0x33,
+          "$"   => 0x34,
+          "%"   => 0x35,
+          "^"   => 0x36,
+          "&"   => 0x37,
+          "*"   => 0x38,
+          "("   => 0x39,
+          ")"   => 0x30,
+          "_"   => 0x2D,
+          "+"   => 0x3D,
+          "{"   => 0x5B,
+          "}"   => 0x5D,
+          ":"   => 0x3B,
+          "\""  => 0x27,
+          "|"   => 0x5C,
+          "?"   => 0x2F,
+          ">"   => 0x2E,
+          "<"   => 0x2C
+        }
+
+        def self.[](key)
+          KEYS[key] or raise "unsupported key #{key.inspect}"
+        end
+
+        def self.encode(keys)
+          keys.reduce([]) do |converted, key|
+            if key.is_a?(Symbol)
+              converted << Keys[key]
+            elsif key.is_a?(Array)
+              converted << (key.map {|k| encode([k])} << Keys[:null]).flatten
+            else # key is a string
+              converted += encode_str(key)
+            end
+            converted
+          end
+        end
+
+        def self.encode_str(keys)
+          keys.to_s.split("").map do |key|
+            key =~ /[a-z]/ ? key.upcase.unpack("c")[0] : 
+              key =~ /[A-Z]/ || SPECIAL_KEYS[key] ? [Keys[:shift], SPECIAL_KEYS[key] || key.unpack("c")[0], Keys[:null]] :
+              key.unpack("c")[0]
+          end
+        end
+
+      end
+    end
+  end
+end

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/ms_uia/label.rb

@@ -0,0 +1,18 @@
+module RAutomation
+  module Adapter
+    module MsUia
+      class Label < Control
+        include WaitHelper
+        include Locators
+
+        def exist?
+          super && matches_type?(Constants::UIA_TEXT_CONTROL_TYPE)
+        end
+
+        alias_method :exists?, :exist?
+        alias_method :value, :control_name
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+module RAutomation
+  module Adapter
+    module MsUia
+
+      class ListBox < Control
+        include WaitHelper
+        include Locators
+
+        def count
+          UiaDll::select_list_count search_information
+        end
+
+        def items
+          UiaDll::table_values(search_information).map do |list_item|
+            @window.list_item(:value => list_item)
+          end
+        end
+
+        def strings
+          UiaDll::table_values(search_information)
+        end
+
+        def value
+          UiaDll::selection search_information
+        end
+
+        def exist?
+          super && matches_type?(Constants::UIA_LIST_CONTROL_TYPE)
+        end
+
+        alias_method :exists?, :exist?
+
+        def selected?(index)
+          item = items[index]
+          return item && item.selected?
+        end
+
+        def select(index)
+          UiaDll::select_list_select_index search_information, index
+        end
+
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,22 @@
+module RAutomation
+  module Adapter
+    module MsUia
+      class ListItem < Control
+        include WaitHelper
+        include Locators
+
+        def exist?
+          super && matches_type?(Constants::UIA_LIST_ITEM_CONTROL_TYPE)
+        end
+
+        def selected?
+          UiaDll::is_selected(search_information)
+        end
+
+        alias_method :exists?, :exist?
+        alias_method :value, :control_name
+
+      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/ms_uia/menu.rb

@@ -0,0 +1,36 @@
+module RAutomation
+  module Adapter
+    module MsUia
+      class Menu
+        attr_reader :menu_items
+        attr_reader :window
+
+        def initialize(window, locator)
+          @menu_items = [] << locator[:text]
+          @window = window
+        end
+
+        def menu(locator)
+          @menu_items << locator[:text]
+          self
+        end
+
+        def exists?
+          UiaDll::menu_item_exists window.hwnd, *menu_items_arg
+        end
+
+        def open
+          error_info = FFI::MemoryPointer.new :char, 1024
+          UiaDll::select_menu_item window.hwnd, error_info, 1024, *menu_items_arg
+          error = error_info.get_string 0
+          raise error unless error.empty?
+        end
+
+        private
+        def menu_items_arg
+          menu_items.map {|s| [:string, s]}.flatten << :pointer << nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module RAutomation
+  module Adapter
+    module MsUia
+      class Radio < Control
+        include WaitHelper
+        include Locators
+        include ButtonHelper
+
+
+        def exist?
+          super && matches_type?(Constants::UIA_RADIO_BUTTON_CONTROL_TYPE)
+        end
+
+        def set?
+          UiaDll::is_selected(search_information)
+        end
+
+        alias_method :exists?, :exist?
+
+      end
+    end
+  end
+end