rautomation 0.6.3 → 0.7.0

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

@@ -0,0 +1,121 @@
+module RAutomation
+  module Adapter
+    module Win32
+      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/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_ffi → win_32}/locators.rb

@@ -1,6 +1,6 @@
 module RAutomation
   module Adapter
-    module WinFfi
+    module Win32
       # @private
       module Locators
 
@@ -14,7 +14,7 @@ module RAutomation
 
           # control locator
           locators = self.class::DEFAULT_LOCATORS.merge(locators) if self.class.const_defined?(:DEFAULT_LOCATORS)
-          @locators = locators
+          @locators = {:index => 0}.merge locators
         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

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

@@ -0,0 +1,97 @@
+module RAutomation
+  module Adapter
+    module Win32
+      class SelectList < Control
+        include WaitHelper
+        include Locators
+
+        # Default locators used for searching buttons.
+        DEFAULT_LOCATORS = {:class => /combobox/i}
+
+        class SelectListOption
+          attr_accessor :text, :index
+
+          def initialize(select_list, text, index)
+            @select_list = select_list
+            @text        = text
+            @index       = index
+          end
+
+          def selected?
+            selected_idx = Functions.send_message(@select_list.hwnd, Constants::CB_GETCURSEL, 0, nil)
+            return false if selected_idx == Constants::CB_ERR
+            @text == Functions.retrieve_combobox_item_text(@select_list.hwnd, selected_idx)
+          end
+
+          def select
+            @select_list.send :assert_enabled
+            Functions.send_message(@select_list.hwnd, Constants::CB_SETCURSEL, @index, nil) != Constants::CB_ERR
+          end
+
+          alias_method :set, :select
+        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 select(index)
+          Functions.send_message(hwnd, Constants::CB_SETCURSEL, index, nil) != Constants::CB_ERR
+        end
+
+        def set(text)
+          option(:text => text).set
+        end
+
+        def list_item_height
+          Functions.send_message(hwnd, Constants::CB_GETITEMHEIGHT, 0 ,nil)
+        end
+
+        def dropbox_boundary
+          boundary = FFI::MemoryPointer.new :long, 4
+
+          Functions.send_message(hwnd, Constants::CB_GETDROPPEDCONTROLRECT, 0 ,boundary)
+
+          boundary.read_array_of_long(4)
+        end
+
+        def get_top_index
+          Functions.send_message(hwnd, Constants::CB_GETTOPINDEX, 0 ,nil)
+        end
+
+        private
+
+        def item_count
+          Functions.send_message(hwnd, Constants::CB_GETCOUNT, 0, nil)
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module RAutomation
+  module Adapter
+    module Win32
+      class Table < Control
+        include WaitHelper
+        include Locators
+
+        # Default locators used for searching buttons.
+        DEFAULT_LOCATORS = {:class => /syslistview/i}
+
+        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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+module RAutomation
+  module Adapter
+    module Win32
+      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? &&
+                    focus &&
+                    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::Window#send_keys
+        def send_keys(*keys)
+          @window.container.wait_until_present
+          assert_enabled
+          @window.activate
+          focus
+          @window.send_keys(keys)
+        end
+      end
+    end
+  end
+end

data/lib/rautomation/adapter/{win_ffi → win_32}/window.rb

@@ -1,8 +1,6 @@
 module RAutomation
   module Adapter
-    module WinFfi
-      autoload :UiaDll, File.dirname(__FILE__) + "/ms_uia/uia_dll"
-
+    module Win32
       class Window
         include WaitHelper
         include Locators
@@ -20,6 +18,8 @@ module RAutomation
           end
         end
 
+        attr_reader :container
+
         # Locators of the window.
         attr_reader :locators
 
@@ -36,7 +36,8 @@ module RAutomation
         # @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)
+        def initialize(container, locators)
+          @container = container
           extract(locators)
         end
 
@@ -57,12 +58,21 @@ module RAutomation
           Functions.window_title(hwnd)
         end
 
+        # @see RAutomation::Window#class_names
+        def class_names
+          classes = []
+          controls.each do |control|
+            classes << control.class_name
+          end
+          classes.sort
+        end
+
         # @see RAutomation::Window#activate
         def activate
           return if !exists? || active?
           restore if minimized?
           Functions.activate_window(hwnd)
-          sleep 1
+          sleep 0.1
         end
 
         # @see RAutomation::Window#active?
@@ -111,29 +121,33 @@ module RAutomation
 
         # Activates the window and sends keys to it.
         #
-        # Refer to KeystrokeConverter#convert_special_characters for the special keycodes.
+        # @example
+        #   RAutomation::Window.new(:title => //).send_keys "hello!"
+        #   RAutomation::Window.new(:title => //).send_keys [:control, "a"], "world!"
+        # Refer to Keys#KEYS for all the special keycodes.
         # @see RAutomation::Window#send_keys
-        def send_keys(keys)
-          shift_pressed = false
-          KeystrokeConverter.convert(keys).each do |key|
+        def send_keys(args)
+          Keys.encode(args).each do |arg|
             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
+            if arg.is_a?(Array)
+              arg.reduce([]) do |pressed_keys, k|
+                if k == Keys[:null]
+                  pressed_keys.each {|pressed_key| release_key pressed_key}
+                  pressed_keys = []
+                else
+                  pressed_keys << press_key(k)
+                end
+                pressed_keys
+              end
+            else
+              send_key arg
             end
           end
+          sleep 1
         end
 
         # @see RAutomation::Window#close
@@ -153,72 +167,75 @@ module RAutomation
           TextField.new(self, locator)
         end
 
-        def label(locator)
-          Label.new(self, locator)
+        # 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
 
-        def control(locator)
-          Control.new(self, locator)
+        # Win32 adapter specific API methods
+        def label(locator={})
+          @container.wait_until_present
+          Label.new(self, locator)
         end
 
-        def controls(locator)
-          Controls.new(self, locator)
+        def control(locator={})
+          @container.wait_until_present
+          Control.new(self, locator)
         end
 
-        def list_box(locator)
+        def list_box(locator={})
+          @container.wait_until_present
           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
+        def select_list(locator={})
+          @container.wait_until_present
+          SelectList.new(self, locator)
         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 checkbox(locator={})
+          @container.wait_until_present
+          Checkbox.new(self, locator)
+        end
 
-          def radio(locator)
-            wait_until_exists
-            RAutomation::Adapter::WinFfi::Radio.new(@window, locator)
-          end
+        def radio(locator={})
+          @container.wait_until_present
+          Radio.new(self, locator)
+        end
 
-          def table(locator)
-            wait_until_exists
-            RAutomation::Adapter::WinFfi::Table.new(@window, locator)
-          end
+        def table(locator={})
+          @container.wait_until_present
+          Table.new(self, 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
+        # Creates the child window object.
+        # @note This is an Win32 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(hwnd, locators)
         end
 
         private
 
         def press_key key
           Functions.send_key(key, 0, 0, nil)
-          sleep 0.01
+          key
         end
 
         def release_key key
           Functions.send_key(key, 0, Constants::KEYEVENTF_KEYUP, nil)
-          sleep 0.1
+          key
+        end
+
+        def send_key key
+          press_key key
+          release_key key
+          key
         end
       end
     end