rautomation 2.0.1-x64-mingw32

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

@@ -0,0 +1,336 @@
+module RAutomation
+  module Adapter
+    module Win32
+      # @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 :_get_window_rect, :GetWindowRect,
+                        [:long, :pointer], :bool
+        attach_function :_move_window, :MoveWindow,
+                        [:long, :int, :int, :int, :int, :bool], :bool
+        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
+        attach_function :send_input, :SendInput,
+                        [:uint, :pointer, :int], :int
+        attach_function :_get_cursor_pos, :GetCursorPos,
+                        [:pointer], :bool
+        attach_function :set_cursor_pos, :SetCursorPos,
+                        [:int, :int], :int
+
+        # kernel32
+        attach_function :current_thread_id, :GetCurrentThreadId,
+                        [], :long
+        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_x86, :LoadLibraryA,
+                        [:string], :long
+        attach_function :_load_library_x64, :LoadLibraryA,
+                        [:string], :uint64
+
+        # 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_x86, :select_table_row,
+                        [:long, :long, :long], :void
+        attach_function :_select_table_row_x64, :select_table_row,
+                        [:uint64, :long, :long], :void
+        attach_function :_get_table_row_state_x86, :get_table_row_state,
+                        [:long, :long, :long], :long
+        attach_function :_get_table_row_state_x64, :get_table_row_state,
+                        [:uint64, :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 move_window(hwnd, x, y, width, height)
+            _move_window(hwnd, x, y, width, height, true)
+          end
+
+          def get_cursor_pos
+            ptr = FFI::MemoryPointer.new(:long, 2)
+            _get_cursor_pos(ptr)
+            x, y = ptr.read_array_of_long(2)
+            return {:x => x, :y => y}
+          end
+
+          def window_rect(hwnd)
+            x = FFI::MemoryPointer.new(:long, 4)
+            _get_window_rect(hwnd, x)
+            x.read_array_of_long(4)
+          end
+
+          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.join(" ")
+          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 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
+
+          alias_method :activate_control, :activate_window
+
+          def control_hwnd(window_hwnd, locators)
+            find_hwnd(locators, window_hwnd) do |hwnd|
+              locators_match?(locators, control_properties(hwnd, locators))
+            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 load_library(dll)
+            send("_load_library_#{Platform.architecture}", dll)
+          end
+
+          def get_table_row_state(oleacc_module_handle, control_hwnd, row)
+            send("_get_table_row_state_#{Platform.architecture}", oleacc_module_handle, control_hwnd, row)
+          end
+
+          def select_table_row(oleacc_module_handle, control_hwnd, row)
+            send("_select_table_row_#{Platform.architecture}", oleacc_module_handle, control_hwnd, row)
+          end
+
+          private
+
+          def within_foreground_thread(hwnd)
+            foreground_thread = current_thread_id
+            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|
+              if locator[0] == :hwnd
+                properties[locator[0]] = hwnd
+              elsif locator[0] != :index
+                properties[locator[0]] = self.send("#{type}_#{locator[0]}", hwnd)
+              end
+              properties
+            end
+          end
+
+          def locators_match?(locators, properties)
+            locators.all? do |locator, value|
+              locator == :index or
+                value.is_a?(Regexp) ? properties[locator] =~ value : properties[locator] == value
+            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/win_32/keys.rb

@@ -0,0 +1,146 @@
+module RAutomation
+  module Adapter
+    module Win32
+      class Keys
+        KEYS = {
+          # keycodes from http://msdn.microsoft.com/en-us/library/windows/desktop/dd375731(v=vs.85).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,
+          :left_bracket  => 0xDB,
+          :right_bracket => 0xDD,
+          :single_quote  => 0xDE,
+          :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     => 0xBA,
+          :equals        => 0xBB,
+          :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,
+          :comma         => 0xBC,
+          :dash          => 0xBD,
+          :period        => 0xBE,
+          :slash         => 0xBF,
+          :grave         => 0xC0,
+          :backslash     => 0xDC
+        }
+
+        MAPPED_KEYS = {
+          "\\" => KEYS[:backslash],
+          "-"  => KEYS[:dash],
+          "/"  => KEYS[:slash],
+          "="  => KEYS[:equals],
+          ";"  => KEYS[:semicolon],
+          "'"  => KEYS[:single_quote],
+          "."  => KEYS[:period],
+          ","  => KEYS[:comma],
+          "["  => KEYS[:left_bracket],
+          "]"  => KEYS[:right_bracket],
+          '`'  => KEYS[:grave]
+        }
+
+        # Assumes US standard keyboard layout
+        SPECIAL_KEYS = {
+          "!"   => 0x31,
+          "@"   => 0x32,
+          "#"   => 0x33,
+          "$"   => 0x34,
+          "%"   => 0x35,
+          "^"   => 0x36,
+          "&"   => 0x37,
+          "*"   => 0x38,
+          "("   => 0x39,
+          ")"   => 0x30,
+          "_"   => KEYS[:dash],
+          "+"   => KEYS[:equals],
+          "{"   => KEYS[:left_bracket],
+          "}"   => KEYS[:right_bracket],
+          ":"   => KEYS[:semicolon],
+          "\""  => KEYS[:single_quote],
+          "|"   => KEYS[:backslash],
+          "?"   => KEYS[:slash],
+          ">"   => KEYS[:period],
+          "<"   => KEYS[:comma],
+          "~"   => KEYS[:grave]
+        }
+
+        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]/ || MAPPED_KEYS[key] ? MAPPED_KEYS[key] || 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/win_32/label.rb

@@ -0,0 +1,10 @@
+module RAutomation
+  module Adapter
+    module Win32
+      class Label < Control
+        include WaitHelper
+        include Locators
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+module RAutomation
+  module Adapter
+    module Win32
+      class ListBox < Control
+        include WaitHelper
+        include Locators
+
+        # Default locators used for searching buttons.
+        DEFAULT_LOCATORS = {:class => /listbox/i}
+
+        def count
+          Functions.send_message(hwnd, Constants::LB_GETCOUNT, 0, nil)
+        end
+
+        alias_method :size, :count
+
+        def items
+          count.times.reduce([]) do |memo, i|
+            text_length = Functions.send_message(hwnd, Constants::LB_GETTEXTLEN, 0, nil) + 1
+            text = FFI::MemoryPointer.new :char, text_length
+            Functions.send_message(hwnd, Constants::LB_GETTEXT, i, text)
+            memo << text.read_string
+          end
+        end
+
+        alias_method :strings, :items
+
+        def selected?(i)
+          Functions.send_message(hwnd, Constants::LB_GETSEL, i, nil) > 0
+        end
+
+        def select(i)
+          Functions.send_message(hwnd, Constants::LB_SETCURSEL, i, nil)
+        end
+
+      end
+    end
+  end
+end
+

data/lib/rautomation/adapter/win_32/locators.rb

@@ -0,0 +1,22 @@
+module RAutomation
+  module Adapter
+    module Win32
+      # @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 = {:index => 0}.merge locators
+        end
+      end
+    end
+  end
+end

data/lib/rautomation/adapter/win_32/mouse.rb

@@ -0,0 +1,59 @@
+module RAutomation
+  module Adapter
+    module Win32
+      class Mouse
+        def initialize(window)
+          @window = window
+        end
+
+        def move(coords={})
+          @last_position = coords = (@last_position || position).merge(coords)
+
+          until position[:x] == coords[:x] && position[:y] == coords[:y]
+            @window.activate
+            Functions.set_cursor_pos coords[:x], coords[:y]
+          end
+        end
+
+        def position
+          Functions.get_cursor_pos
+        end
+
+        def click
+          send_input down_event, up_event
+        end
+
+        def press
+          send_input down_event, down_event
+        end
+
+        def release
+          send_input up_event, up_event
+        end
+
+        private
+
+        def send_input *inputs
+          @window.activate
+          Functions.send_input inputs.size, inputs.join, inputs[0].size
+        end
+
+        def down_event
+          input Constants::MOUSEEVENTF_LEFTDOWN
+        end
+
+        def up_event
+          input Constants::MOUSEEVENTF_LEFTUP
+        end
+
+        def input flag
+          mouse_input = Array.new(7, 0)
+          mouse_input[0] = Constants::INPUT_MOUSE
+          mouse_input[4] = flag
+          Platform.is_x86? ? mouse_input.pack('L*') : mouse_input.pack('QLLLLQQ')
+        end
+
+      end
+    end
+  end
+end

data/lib/rautomation/adapter/win_32/password_field.rb

@@ -0,0 +1,15 @@
+module RAutomation
+  module Adapter
+    module Win32
+      class PasswordField < TextField
+
+        private
+
+        def set?(text)
+          # getting value from password field will not retrieve anything
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+module RAutomation
+  module Adapter
+    module Win32
+      class Radio < Control
+        include WaitHelper
+        include Locators
+        include ButtonHelper
+      end
+    end
+  end
+end