rdp-rautomation 0.6.3.1

data/lib/rautomation/adapter/helper.rb

@@ -0,0 +1,20 @@
+module RAutomation
+  module Adapter
+    autoload :Autoit, File.dirname(__FILE__) + "/autoit.rb"
+    autoload :WinFfi, File.dirname(__FILE__) + "/win_ffi.rb"
+
+    module Helper
+      extend self
+
+      # @private
+      # Retrieves default {Adapter} for the current platform.
+      def default_adapter
+        if ENV['OS'] == 'Windows_NT'
+          :win_ffi
+        else
+          raise "unsupported platform for RAutomation: #{RUBY_PLATFORM}"
+        end
+      end
+    end
+  end
+end

data/lib/rautomation/adapter/win_ffi.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_ffi/constants"
+require File.dirname(__FILE__) + "/win_ffi/keystroke_converter"
+require File.dirname(__FILE__) + "/win_ffi/functions"
+require File.dirname(__FILE__) + "/win_ffi/locators"
+require File.dirname(__FILE__) + "/win_ffi/window"
+require File.dirname(__FILE__) + "/win_ffi/button_helper"
+require File.dirname(__FILE__) + "/win_ffi/control"
+require File.dirname(__FILE__) + "/win_ffi/button"
+require File.dirname(__FILE__) + "/win_ffi/checkbox"
+require File.dirname(__FILE__) + "/win_ffi/radio"
+require File.dirname(__FILE__) + "/win_ffi/text_field"
+require File.dirname(__FILE__) + "/win_ffi/select_list"
+require File.dirname(__FILE__) + "/win_ffi/table"
+require File.dirname(__FILE__) + "/win_ffi/label"
+require File.dirname(__FILE__) + "/win_ffi/list_box"

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

@@ -0,0 +1,25 @@
+module RAutomation
+  module Adapter
+    module WinFfi
+      class Button < Control
+        include WaitHelper
+        include Locators
+
+        # Default locators used for searching buttons.
+        DEFAULT_LOCATORS = {:class => /button/i}
+
+        # @see RAutomation::Button#value
+        def value
+          Functions.control_value(Functions.control_hwnd(@window.hwnd, @locators))
+        end
+
+        def exist?
+          @locators[:id].nil? ? super : super && matches_type(Constants::UIA_BUTTON_CONTROL_TYPE)
+        end
+
+        alias_method :exists?, :exist?
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+module RAutomation
+  module Adapter
+    module WinFfi
+      module ButtonHelper
+
+        def set?
+          control_hwnd = Functions.control_hwnd(@window.hwnd, @locators)
+          Functions.control_set? control_hwnd
+        end
+
+        # @todo call a windows function to do this without clicking
+        def clear
+          click {!set?} if set?
+        end
+
+        # @todo call a windows function to do this without clicking
+        def set
+          click {set?} unless set?
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+module RAutomation
+  module Adapter
+    module WinFfi
+      class Checkbox < Control
+        include WaitHelper
+        include Locators
+        include ButtonHelper
+
+
+        def exist?
+          @locators[:id].nil? ? super : super && matches_type(Constants::UIA_CHECKBOX_CONTROL_TYPE)
+        end
+
+        alias_method :exists?, :exist?
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,94 @@
+module RAutomation
+  module Adapter
+    module WinFfi
+      # @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
+
+        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
+
+        # IAccessible Button States
+        STATE_SYSTEM_UNAVAILABLE = 0x00000001
+        STATE_SYSTEM_SELECTED = 0x00000002
+        STATE_SYSTEM_FOCUSED = 0x00000004
+        STATE_SYSTEM_CHECKED = 0x00000010
+
+        # Combobox
+        CB_GETCOUNT = 0x0146
+        CB_GETLBTEXTLEN = 0x0149
+        CB_GETLBTEXT = 0x0148
+        CB_GETCURSEL = 0x0147
+        CB_ERR = -1
+        CB_SETCURSEL = 0x14E
+
+        # listview
+        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

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

@@ -0,0 +1,79 @@
+module RAutomation
+  module Adapter
+    module WinFfi
+      class Control
+        include WaitHelper
+        include Locators
+
+        # Creates the control object.
+        # @note this method is not meant to be accessed directly
+        # @param [RAutomation::Window] window this button belongs to.
+        # @param [Hash] locators for searching the button.
+        # @option locators [String, Regexp] :value Value (text) of the button
+        # @option locators [String, Regexp] :class Internal class name of the button
+        # @option locators [String, Fixnum] :id Internal ID of the button
+        # @option locators [String, Fixnum] :index 0-based index to specify n-th button if all other criteria match
+        # @see RAutomation::Window#button
+        def initialize(window, locators)
+          @window = window
+          extract(locators)
+        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
+
+            block_given? ? yield : clicked && !exist?
+          end
+        end
+
+        def exist?
+          !!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
+end

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

@@ -0,0 +1,333 @@
+module RAutomation
+  module Adapter
+    module WinFfi
+      # @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 :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
+          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 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
+
+          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
+            end
+          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 = 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
+