rautomation 2.0.1-x86-mingw32

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

@@ -0,0 +1,70 @@
+module RAutomation
+  module Adapter
+    module Autoit
+      class TextField
+        include WaitHelper
+        include Locators
+
+        # Default locators used for searching text fields.
+        DEFAULT_LOCATORS = {:class => /edit/i}
+
+        # @private
+        # Special-cased locators
+        LOCATORS = {
+                [:class, Regexp] => :regexpclass,
+                :index => :instance,
+                :value => :text
+        }
+
+        # Creates the text field object.
+        # @note this method is not meant to be accessed directly, but only through {RAutomation::Window#text_field}!
+        # @param [RAutomation::Window] window this text field belongs to.
+        # @param [Hash] locators for searching the text field.
+        # @option locators [String, Regexp] :class Internal class name of the text field
+        # @option locators [String, Regexp] :value Value (text) of the text field
+        # @option locators [String, Integer] :id Internal ID of the text field
+        # @option locators [String, Integer] :index 0-based index to specify n-th text field if all other criteria match
+        # @see RAutomation::Window#text_field
+        def initialize(window, locators)
+          @window = window
+          extract(locators)
+        end
+
+        def hwnd
+          Window.autoit.ControlGetHandle(@window.locator_hwnd, "", @autoit_locators).hex
+        end
+
+        # @see RAutomation::TextField#set
+        def set(text)
+          wait_until do
+            @window.activate
+            @window.active? &&
+                    Window.autoit.ControlFocus(@window.locator_hwnd, "", @autoit_locators) == 1 &&
+                    Window.autoit.ControlSetText(@window.locator_hwnd, "", @autoit_locators, text) == 1 &&
+                    value == text
+          end
+        end
+
+        # @see RAutomation::TextField#clear
+        def clear
+          set ""
+        end
+
+        # @see RAutomation::TextField#value
+        def value
+          Window.autoit.ControlGetText(@window.locator_hwnd, "", @autoit_locators)
+        end
+
+        # @see RAutomation::TextField#exists?
+        def exists?
+          hwnd != 0
+        end
+
+        def hwnd
+          handle = Window.autoit.ControlGetHandle(@window.locator_hwnd, "", @autoit_locators)
+          handle.to_i(16)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,197 @@
+module RAutomation
+  module Adapter
+    module Autoit
+      class Window
+        include WaitHelper
+        include Locators
+
+        class << self
+          # @private
+          def autoit
+            @@autoit
+          end
+
+          # @private
+          def load_autoit
+            @@autoit = WIN32OLE.new('AutoItX3.Control')
+          rescue WIN32OLERuntimeError
+            dll = File.dirname(__FILE__) + "/../../../../ext/AutoItX/AutoItX3.dll"
+            unless system("regsvr32.exe /s #{dll.gsub('/', '\\')}")
+              raise "Start Ruby with administrative rights when using AutoIt adapter for the first time."
+            end
+            @@autoit = WIN32OLE.new('AutoItX3.Control')
+          end
+        end
+
+        load_autoit
+        @@autoit.AutoItSetOption("WinWaitDelay", 350)
+
+        # Locators of the window.
+        attr_reader :locators
+
+        # @private
+        # Special-cased locators
+        LOCATORS = {
+            [:title, Regexp] => :regexptitle,
+            :index => :instance,
+            :hwnd => :handle
+        }
+
+        # 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, Integer] :hwnd Window handle in decimal format
+        # @option locators [String, Integer] :index 0-based index to specify n-th window if all other criteria match
+        # @see RAutomation::Window#initialize
+        def initialize(container, locators)
+          @container = container
+          @hwnd = locators[:hwnd]
+          @locator_index = locators.delete(:index) if locators[:index] && locators.size == 1
+          @locator_pid = locators.delete(:pid).to_i if locators[:pid]
+          @locator_text = locators.delete(:text)
+          extract(locators)
+        end
+
+        # Retrieves handle of the window.
+        # @note Searches only for visible windows.
+        # @see RAutomation::Window#hwnd
+        def hwnd
+          @hwnd ||= begin
+            locators = @autoit_locators
+            if @locator_index || @locator_pid
+              # @todo Come up with some better solution for this case
+              locators = "[regexptitle:]" # match all, needed for the case when only :index or :pid is used
+            end
+            windows = @@autoit.WinList(locators, @locator_text).pop.compact.
+                map { |handle| RAutomation::Window.new(:hwnd => handle.hex) }
+            windows.delete_if { |window| !window.visible? }
+
+            if @locator_pid
+              window = windows.find { |win| win.pid == @locator_pid }
+            else
+              window = windows[@locator_index || 0]
+            end
+            window ? window.hwnd : nil
+          end
+        end
+
+        # @see RAutomation::Window#pid
+        def pid
+          @@autoit.WinGetProcess(locator_hwnd).to_i
+        end
+
+        # @see RAutomation::Window#title
+        def title
+          @@autoit.WinGetTitle(locator_hwnd)
+        end
+
+        # @see RAutomation::Window#class_names
+        def class_names
+          @@autoit.WinGetClassList(locator_hwnd).split("\n").sort
+        end
+
+        # @see RAutomation::Window#activate
+        def activate
+          @@autoit.WinWait(locator_hwnd, "", 1)
+          @@autoit.WinActivate(locator_hwnd)
+          sleep 1
+        end
+
+        # @see RAutomation::Window#active?
+        def active?
+          @@autoit.WinActive(locator_hwnd) == 1
+        end
+
+        # @see RAutomation::Window#text
+        def text
+          @@autoit.WinGetText(locator_hwnd)
+        end
+
+        # @see RAutomation::Window#exists?
+        def exists?
+          @@autoit.WinExists(locator_hwnd) == 1
+        end
+
+        # @see RAutomation::Window#visible?
+        def visible?
+          @@autoit.WinGetState(locator_hwnd) & 2 == 2
+        end
+
+        # @see RAutomation::Window#maximize
+        def maximize
+          @@autoit.WinSetState(locator_hwnd, "", @@autoit.SW_MAXIMIZE)
+          sleep 1
+        end
+
+        # @see RAutomation::Window#minimize
+        def minimize
+          @@autoit.WinSetState(locator_hwnd, "", @@autoit.SW_MINIMIZE)
+          sleep 1
+        end
+
+        # @see RAutomation::Window#minimized?
+        def minimized?
+          @@autoit.WinGetState(locator_hwnd) & 16 == 16
+        end
+
+        # @see RAutomation::Window#restore
+        def restore
+          @@autoit.WinSetState(locator_hwnd, "", @@autoit.SW_RESTORE)
+          sleep 1
+        end
+
+        # Activates the window and sends keys to it.
+        #
+        # Refer to AutoIt documentation at http://www.autoitscript.com/autoit3/docs/appendix/SendKeys.htm
+        # for keys syntax.
+        # @see RAutomation::Window#send_keys
+        def send_keys(keys)
+          wait_until do
+            activate
+            active?
+          end
+          @@autoit.Send(keys[0])
+        end
+
+        # @see RAutomation::Window#close
+        def close
+          @@autoit.WinClose(locator_hwnd)
+          @@autoit.WinKill(locator_hwnd)
+        end
+
+        def mouse
+          @container.wait_until_present
+          Mouse.new(self)
+        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 AutoIt directly.
+        # @example execute AutoIt's WinGetTitle function:
+        #   RAutomation::Window.new(:hwnd => 123456).WinGetTitle(...)
+        # @see RAutomation::Window#method_missing
+        def method_missing(name, *args)
+          @@autoit.send(name, *args)
+        end
+
+        # @private
+        def locator_hwnd
+          "[HANDLE:#{hwnd.to_i.to_s(16)}]"
+        end
+      end
+    end
+  end
+end

data/lib/rautomation/adapter/autoit.rb

@@ -0,0 +1,8 @@
+Kernel.warn "[WARN] RAutomation AutoIt adapter is DEPRECATED and will be removed in the future!"
+
+require "win32ole"
+require File.dirname(__FILE__) + "/autoit/locators"
+require File.dirname(__FILE__) + "/autoit/button"
+require File.dirname(__FILE__) + "/autoit/text_field"
+require File.dirname(__FILE__) + "/autoit/window"
+require File.dirname(__FILE__) + "/autoit/mouse"

data/lib/rautomation/adapter/helper.rb

@@ -0,0 +1,64 @@
+module RAutomation
+  module Adapter
+    autoload :Autoit, File.dirname(__FILE__) + "/autoit.rb"
+    autoload :MsUia, File.dirname(__FILE__) + "/ms_uia.rb"
+    autoload :Win32, File.dirname(__FILE__) + "/win_32.rb"
+
+    module Helper
+      require 'fileutils'
+      require File.expand_path('../../platform', __FILE__)
+      extend self
+
+      # @private
+      # Retrieves default {Adapter} for the current platform.
+      def default_adapter
+        if ENV['OS'] == 'Windows_NT'
+          :win_32
+        else
+          raise "unsupported platform for RAutomation: #{RUBY_PLATFORM}"
+        end
+      end
+
+      def supported_for_current_platform?(adapter)
+        Platform.is_x86? || adapter == :win_32
+      end
+
+      def find_missing_externals(externals)
+        externals.select do |ext|
+          path = "#{Dir.pwd}/#{File.dirname(ext)}"
+          file = File.basename(ext)
+          !Dir.exist?(path) && !File.exist?("#{path}/#{file}")
+        end
+      end
+
+      def build_solution(ext)
+        return if ext =~ /RAutomation.UIA.dll/ # skip this since its built in UiaDll.sln
+
+        name = File.basename(ext, File.extname(ext))
+        msbuild_solution(name)
+      end
+
+      def msbuild_solution(name)
+        cmd = "msbuild /p:Configuration=Release ext\\#{name}\\#{name}.sln"
+        cmd += " && #{cmd} /p:Platform=x64" unless name == 'WindowsForms'
+        system(cmd) or raise StandardError, "An error occurred when trying to build solution #{name}. " +
+                                            "Make sure msbuild binary is in your PATH and the project is configured correctly"
+      end
+
+      def move_adapter_dlls(externals, architecture)
+        raise ArgumentError, "Invalid platform #{architecture}" unless %w[x86 x64].any? { |arch| arch == architecture }
+        puts "Moving #{architecture} dll's into 'Release' folder.."
+
+        externals.each do |dest_path|
+          next if dest_path =~ /WindowsForms/
+          dll_path = dest_path.gsub('Release', "#{architecture}Release")
+          dest_dir = File.dirname(dest_path)
+          FileUtils.mkdir_p(dest_dir) unless Dir.exist?(dest_dir)
+          FileUtils.cp(dll_path, dest_path)
+        end
+
+        externals
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+module RAutomation
+  module Adapter
+    module MsUia
+      class Button < Control
+        include WaitHelper
+        include Locators
+
+        # Default locators used for searching buttons.
+        DEFAULT_LOCATORS = {:class => /button/i}
+
+        def exist?
+          super && matches_type?(Constants::UIA_BUTTON_CONTROL_TYPE)
+        end
+
+        alias_method :exists?, :exist?
+        alias_method :value, :control_name
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+module RAutomation
+  module Adapter
+    module MsUia
+      module ButtonHelper
+
+        # @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/ms_uia/checkbox.rb

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

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

@@ -0,0 +1,111 @@
+module RAutomation
+  module Adapter
+    module MsUia
+      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
+        VK_NEXT = 0x22
+        VK_PRIOR = 0x21
+
+        # 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_GETTOPINDEX  = 0x015b
+        CB_GETLBTEXTLEN = 0x0149
+        CB_GETLBTEXT = 0x0148
+        CB_GETCURSEL = 0x0147
+        CB_GETDROPPEDCONTROLRECT = 0x0152
+        CB_GETITEMHEIGHT = 0x0154
+        CB_ERR = -1
+        CB_SETCURSEL = 0x14E
+        CB_SELECTSTRING = 0x14D
+        CB_SETEDITSEL = 0x142
+        CB_SETTOPINDEX = 0x015c
+
+        #ListBox
+        LB_SETTOPINDEX   = 0x0197
+        LB_GETITEMHEIGHT = 0x01A1
+        LB_GETITEMRECT   = 0x0198
+        LB_GETTOPINDEX   = 0x018E
+
+        # 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_DATA_GRID_CONTROL_TYPE =50028
+        UIA_DATA_ITEM_CONTROL_TYPE =50029
+        UIA_CHECKBOX_CONTROL_TYPE = 50002
+        UIA_BUTTON_CONTROL_TYPE = 50000
+        UIA_TEXT_CONTROL_TYPE = 50020
+        UIA_RADIO_BUTTON_CONTROL_TYPE = 50013
+        UIA_COMBOBOX_CONTROL_TYPE = 50003
+        UIA_EDIT_CONTROL_TYPE = 50004
+        UIA_DOCUMENT_CONTROL_TYPE = 50030
+        UIA_HEADER_CONTROL_TYPE = 50034
+        UIA_HEADER_ITEM_CONTROL_TYPE = 50035
+        UIA_WINDOW_CONTROL_TYPE = 50032
+        UIA_PANE_CONTROL_TYPE = 50033
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,134 @@
+module RAutomation
+  module Adapter
+    module MsUia
+      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, Integer] :id Internal ID of the button
+        # @option locators [String, Integer] :index 0-based index to specify n-th button if all other criteria match
+        # @option locators [String, Boolean] :children_only limit the scope of the search to children only
+        # @see RAutomation::Window#button
+        def initialize(window, locators)
+          @window = window
+          extract(locators)
+        end
+
+        def cached_hwnd
+          @cached_hwnd ||= UiaDll::cached_hwnd(UiaDll::SearchCriteria.from_locator(@window.hwnd, @locators))
+          @cached_hwnd == 0 ? nil : @cached_hwnd
+        end
+
+        #todo - replace with UIA version
+        def hwnd
+          Functions.control_hwnd(@window.hwnd, @locators)
+        end
+
+        def search_information
+          info = UiaDll::SearchCriteria.from_locator(@window.hwnd, @locators)
+          if info.how == 0 || cached_hwnd
+            info.how = :hwnd
+            info.data = cached_hwnd || hwnd
+          end
+
+          info
+        end
+
+        #todo - replace with UIA version
+        def click
+          assert_enabled
+          clicked = false
+          wait_until do
+            @window.activate
+            @window.active? &&
+                UiaDll::control_click(search_information) &&
+                clicked = true # is clicked at least once
+
+            block_given? ? yield : clicked && !exist?
+          end
+        end
+
+        def exist?
+          begin
+            UiaDll::exists?(search_information) || !!hwnd
+          rescue UnknownElementException
+            false
+          end
+        end
+
+        def enabled?
+          UiaDll::is_enabled(search_information)
+        end
+
+        def disabled?
+          !enabled?
+        end
+
+        #todo - replace with UIA version
+        def focused?
+          UiaDll::is_focused(search_information)
+        end
+
+        def focus
+          assert_enabled
+          UiaDll::set_focus(search_information)
+        end
+
+        def bounding_rectangle
+          UiaDll::bounding_rectangle(search_information)
+        end
+
+        def visible?
+          !UiaDll::is_offscreen(search_information)
+        end
+
+        def matches_type?(*classes)
+          classes.include? get_current_control_type
+        end
+
+        def get_current_control_type
+          UiaDll::current_control_type(search_information)
+        end
+
+        def new_pid
+          UiaDll::process_id(search_information)
+        end
+
+        def control_name
+          UiaDll::name(search_information)
+        end
+
+        def help_text
+          UiaDll::help_text(search_information)
+        end
+
+        def control_class
+          UiaDll::class_name(search_information)
+        end
+
+        alias_method :exists?, :exist?
+
+        def assert_enabled
+          raise "Cannot interact with disabled control #{@locators.inspect} on window #{@window.locators.inspect}!" if disabled?
+        end
+
+        def expand(which_item)
+          UiaDll::expand_by_value search_information, which_item if which_item.is_a? String
+          UiaDll::expand_by_index search_information, which_item if which_item.is_a? Integer
+        end
+
+        def collapse(which_item)
+          UiaDll::collapse_by_value search_information, which_item if which_item.is_a? String
+          UiaDll::collapse_by_index search_information, which_item if which_item.is_a? Integer
+        end
+
+      end
+    end
+  end
+end