rdp-rautomation 0.6.3.1

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

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

@@ -0,0 +1,19 @@
+module RAutomation
+  module Adapter
+    module WinFfi
+      class Radio < Control
+        include WaitHelper
+        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
+end

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

@@ -0,0 +1,87 @@
+module RAutomation
+  module Adapter
+    module WinFfi
+
+      class SelectList < Control
+        include WaitHelper
+        include Locators
+
+        class SelectListOption
+          attr_accessor :text, :index, :control_hwnd
+
+          def initialize(select_list, text, index)
+            @select_list = select_list
+            @text = text
+            @index = index
+          end
+
+          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
+
+          def select
+            @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)
+          super
+          @hwnd = Functions.control_hwnd(@window.hwnd, @locators)
+        end
+
+        def options(options = {})
+          items = []
+
+          item_count.times do |item_no|
+            item = Functions.retrieve_combobox_item_text(@hwnd, item_no)
+
+            if options[:text] 
+              items.push(SelectListOption.new(self, item, item_no)) if options[:text] == item
+            else
+              items.push(SelectListOption.new(self, item, item_no))
+            end
+          end
+
+          items
+        end
+
+        def value
+          selected_option = options.find {|option| option.selected?}
+          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
+end

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

@@ -0,0 +1,57 @@
+module RAutomation
+  module Adapter
+    module WinFfi
+      class Table < Control
+        include WaitHelper
+        include Locators
+
+        def strings
+          rows = []
+          header_columns = []
+
+          raise "Not a list control" unless UiaDll::current_control_type(uia_control(@locators[:id])) == Constants::UIA_LIST_CONTROL_TYPE
+
+          children_count = count_children(uia_control(@locators[:id]))
+          children = FFI::MemoryPointer.new :pointer, children_count
+          UiaDll::find_children(uia_control(@locators[:id]), children)
+          children.read_array_of_pointer(children_count).each do |child|
+            grandchildren_count = count_children(child)
+            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
+
+            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 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_control(@locators[:id]), nil)
+        end
+
+        private
+
+        def count_children(element)
+          UiaDll::find_children(element, nil)
+        end
+
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+module RAutomation
+  module Adapter
+    module WinFfi
+      class TextField < Control
+        include WaitHelper
+        include Locators
+
+        # Default locators used for searching text fields.
+        DEFAULT_LOCATORS = {:class => /edit/i}
+
+        # @see RAutomation::TextField#set
+        def set(text)
+          raise "Cannot set value on a disabled text field" if disabled?
+
+          wait_until do
+            hwnd = Functions.control_hwnd(@window.hwnd, @locators)
+            @window.activate
+            @window.active? &&
+                    Functions.set_control_focus(hwnd) &&
+                    Functions.set_control_text(hwnd, text) &&
+                    value == text
+          end
+        end
+
+        # @see RAutomation::TextField#clear
+        def clear
+          raise "Cannot set value on a disabled text field" if disabled?
+          set ""
+        end
+
+        # @see RAutomation::TextField#value
+        def value
+          Functions.control_value(hwnd)
+        end
+
+        # @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)
+        end
+
+        alias_method :exists?, :exist?
+
+
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,226 @@
+module RAutomation
+  module Adapter
+    module WinFfi
+      autoload :UiaDll, File.dirname(__FILE__) + "/ms_uia/uia_dll"
+
+      class Window
+        include WaitHelper
+        include Locators
+        extend ElementCollections
+
+        has_many :controls
+
+        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.
+
+        # 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(locators)
+          extract(locators)
+        end
+
+        # Retrieves handle of the window.
+        # @note Searches only for visible windows.
+        # @see RAutomation::Window#hwnd
+        def hwnd
+          @hwnd ||= Functions.window_hwnd(@locators)
+        end
+
+        # @see RAutomation::Window#pid
+        def pid
+          Functions.window_pid(hwnd)
+        end
+
+        # @see RAutomation::Window#title
+        def title
+          Functions.window_title(hwnd)
+        end
+
+        # @see RAutomation::Window#activate
+        def activate
+          return if !exists? || active?
+          restore if minimized?
+          Functions.activate_window(hwnd)
+          sleep 1
+        end
+
+        # @see RAutomation::Window#active?
+        def active?
+          exists? && Functions.foreground_window == hwnd
+        end
+
+        # @see RAutomation::Window#text
+        def text
+          Functions.window_text(hwnd)
+        end
+
+        # @see RAutomation::Window#exists?
+        def exists?
+          result = hwnd && Functions.window_exists(hwnd)
+          !!result
+        end
+
+        # @see RAutomation::Window#visible?
+        def visible?
+          Functions.window_visible(hwnd)
+        end
+
+        # @see RAutomation::Window#maximize
+        def maximize
+          Functions.show_window(hwnd, Constants::SW_MAXIMIZE)
+          sleep 1
+        end
+
+        # @see RAutomation::Window#minimize
+        def minimize
+          Functions.show_window(hwnd, Constants::SW_MINIMIZE)
+          sleep 1
+        end
+
+        # @see RAutomation::Window#minimized?
+        def minimized?
+          Functions.minimized(hwnd)
+        end
+
+        # @see RAutomation::Window#restore
+        def restore
+          Functions.show_window(hwnd, Constants::SW_RESTORE)
+          sleep 1
+        end
+
+        # 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).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
+
+        # @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
+
+        def label(locator)
+          Label.new(self, locator)
+        end
+
+        def control(locator)
+          Control.new(self, locator)
+        end
+
+        def controls(locator)
+          Controls.new(self, locator)
+        end
+
+        def list_box(locator)
+          ListBox.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
+
+        # extend public API
+        RAutomation::Window.class_eval do
+          def select_list(locator)
+            wait_until_exists
+            RAutomation::Adapter::WinFfi::SelectList.new(@window, locator)
+          end
+
+          def checkbox(locator)
+            wait_until_exists
+            RAutomation::Adapter::WinFfi::Checkbox.new(@window, locator)
+          end
+
+          def radio(locator)
+            wait_until_exists
+            RAutomation::Adapter::WinFfi::Radio.new(@window, locator)
+          end
+
+          def table(locator)
+            wait_until_exists
+            RAutomation::Adapter::WinFfi::Table.new(@window, locator)
+          end
+
+          # Creates the child window object.
+          # @note This is an WinFfi 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(@window.hwnd, locators)
+          end
+        end
+
+        private
+
+        def press_key key
+          Functions.send_key(key, 0, 0, nil)
+          sleep 0.01
+        end
+
+        def release_key key
+          Functions.send_key(key, 0, Constants::KEYEVENTF_KEYUP, nil)
+          sleep 0.1
+        end
+      end
+    end
+  end
+end