uia 0.0.5.1 → 0.0.6

data/lib/uia/finder.rb

@@ -0,0 +1,33 @@
+module Uia
+  module Finder
+    def find_by_id(id)
+      find_by_property(:id, id)
+    end
+
+    def find_by_name(name)
+      find_by_property(:name, name)
+    end
+
+    def find_by_pid(pid)
+      Library.find_by_pid(pid)
+    end
+
+    def find_by_runtime_id(runtime_id)
+      Library.find_by_runtime_id(runtime_id)
+    end
+
+    def find_by_handle(handle)
+      Library.find_by_handle handle
+    end
+
+    private
+    def find_by_property(property, what)
+      case what
+        when String
+          Library.send("find_by_#{property}", what)
+        when Regexp
+          children.find { |e| e.send(property) =~ what }
+      end
+    end
+  end
+end

data/lib/uia/library.rb

@@ -17,33 +17,75 @@ module Uia
     attach_function :init, :initialize, [:string], :void
     init(uia_directory)
 
-    def self.attach_throwable_function(name_alias, name, arg_types, return_type)
+    def self.attach_throwable_function(name_alias, name, arg_types, return_type, &block)
       attach_function name, arg_types + [:pointer, :int], return_type
       define_singleton_method(name_alias) do |*args|
-        can_throw(name, *args)
+        result = can_throw(name, *args)
+        return block.call(result) if block
+        result
       end
     end
 
+    # returns nil rather than empty FFI::Struct for Uia::Element
+    element_or_nil = lambda { |e| Uia::Element.new(e) unless e.empty? }
+
     # cleanup
     attach_function :release_element, :Element_Release, [:pointer], :void
     attach_function :release_elements, :Element_ReleaseMany, [:pointer], :void
+    attach_function :release_value_info, :Value_Release, [:pointer], :void
+    attach_function :release_toggle_info, :Toggle_Release, [:pointer], :void
+    attach_function :release_selection_info, :Selection_Release, [:pointer], :void
+    attach_function :release_selection_item_info, :SelectionItem_Release, [:pointer], :void
+    attach_function :release_expand_collapse_info, :ExpandCollapse_Release, [:pointer], :void
+
+    # root methods
+    attach_throwable_function :root_children, :Root_Children, [], ElementChildrenStruct.by_ref
 
     # finding elements
-    attach_throwable_function :find_by_id, :Element_FindById, [:string], ElementStruct.by_ref
-    attach_throwable_function :find_by_pid, :Element_FindByProcessId, [:int], ElementStruct.by_ref
+    attach_throwable_function :find_by_id, :Element_FindById, [:string], ElementStruct.by_ref, &element_or_nil
+    attach_throwable_function :find_by_name, :Element_FindByName, [:string], ElementStruct.by_ref, &element_or_nil
+    attach_throwable_function :find_by_pid, :Element_FindByProcessId, [:int], ElementStruct.by_ref, &element_or_nil
     attach_throwable_function :find_by_handle, :Element_FindByHandle, [:int], ElementStruct.by_ref
     attach_function :Element_FindByRuntimeId, [:pointer, :int, :pointer, :int], ElementStruct.by_ref
 
     # element methods
+    attach_throwable_function :find_child_by_id, :Element_FindChildById, [:pointer, :string], ElementStruct.by_ref, &element_or_nil
+    attach_throwable_function :find_child_by_name, :Element_FindChildByName, [:pointer, :string], ElementStruct.by_ref, &element_or_nil
     attach_throwable_function :children, :Element_Children, [:pointer], ElementChildrenStruct.by_ref
-    attach_throwable_function :children_of_type, :Element_ChildrenOfType, [:pointer, PropertyId], ElementChildrenStruct.by_ref
     attach_throwable_function :descendants, :Element_Descendants, [:pointer], ElementChildrenStruct.by_ref
     attach_throwable_function :click, :Element_Click, [:pointer], :void
+    attach_throwable_function :refresh, :Element_Refresh, [:pointer], :void
+
+    # ValuePattern methods
+    attach_throwable_function :set_value, :Value_Set, [:pointer, :string], :void
+    attach_throwable_function :value_info, :Value_Information, [:pointer], ValueInformation.by_ref
+
+    # ExpandCollapsePattern methods
+    attach_throwable_function :expand_collapse_info, :ExpandCollapse_Information, [:pointer], ExpandCollapseInformation.by_ref
+    attach_throwable_function :expand, :ExpandCollapse_Expand, [:pointer], :void
+    attach_throwable_function :collapse, :ExpandCollapse_Collapse, [:pointer], :void
+
+    # InvokePattern methods
+    attach_throwable_function :invoke, :Invoke, [:pointer], :void
+
+    # TogglePattern methods
+    attach_throwable_function :toggle_information, :Toggle_Information, [:pointer], ToggleInformation.by_ref
+    attach_throwable_function :toggle, :Toggle, [:pointer], :void
+
+    # SelectionPattern methods
+    attach_throwable_function :selection_info, :Selection_Information, [:pointer], SelectionInformation.by_ref
+
+    # SelectionItemPattern methods
+    attach_throwable_function :selection_item_info, :SelectionItem_Information, [:pointer], SelectionItemInformation.by_ref
+    attach_throwable_function :select, :SelectionItem_Select, [:pointer], :void
+    attach_throwable_function :add_to_selection, :SelectionItem_AddToSelection, [:pointer], :void
+    attach_throwable_function :remove_from_selection, :SelectionItem_RemoveFromSelection, [:pointer], :void
 
     def self.find_by_runtime_id(id)
       p = FFI::MemoryPointer.new :int, id.count
       p.write_array_of_int(id)
-      can_throw(:Element_FindByRuntimeId, p, id.count)
+      result = can_throw(:Element_FindByRuntimeId, p, id.count)
+      Uia::Element.new(result) unless result.empty?
     end
 
     def self.can_throw(method, *args)

data/lib/uia/library/element_attributes.rb

@@ -0,0 +1,11 @@
+module Uia
+  module ElementAttributes
+    def element_attr(*attrs)
+      attrs.each do |attr|
+        define_method(attr) do
+          @element.send(attr)
+        end
+      end
+    end
+  end
+end

data/lib/uia/library/structs.rb

@@ -9,10 +9,12 @@ module Uia
                  :runtime_id, :pointer,
                  :number_of_ids, :int,
                  :name, :string,
+                 :class_name, :string,
                  :control_type_id, :int,
                  :patterns, :pointer,
                  :patterns_length, :int,
-                 :id, :string
+                 :id, :string,
+                 :is_enabled, :bool
 
           def id
             self[:id]
@@ -38,15 +40,26 @@ module Uia
             self[:patterns].read_array_of_int(self[:patterns_length])
           end
 
-          def children(type=nil)
-            elements = (type && Library.children_of_type(self, type)) || Library.children(self)
-            elements.children
+          def children
+            Library.children(self).children
           end
 
           def descendants
             Library.descendants(self).children
           end
 
+          def empty?
+            to_ptr.address == 0
+          end
+
+          def enabled?
+            self[:is_enabled]
+          end
+
+          def class_name
+            self[:class_name]
+          end
+
           private
           def number_of_ids
             self[:number_of_ids]
@@ -72,7 +85,7 @@ module Uia
              :items, :pointer
 
       def children
-        @children ||= self[:length].times.collect do |i|
+        self[:length].times.collect do |i|
           ElementCast.new(self[:items] + i * ElementCast.size)
         end
       end
@@ -81,5 +94,80 @@ module Uia
         Library.release_elements(pointer)
       end
     end
+
+    class ValueInformation < FFI::ManagedStruct
+      layout :is_read_only, :bool,
+             :value, :string
+
+      def read_only?
+        self[:is_read_only]
+      end
+
+      def value
+        self[:value]
+      end
+
+      def self.release(pointer)
+        Library.release_value_info(pointer)
+      end
+    end
+
+    class ToggleInformation < FFI::ManagedStruct
+      layout :state, :string
+
+      def state
+        self[:state]
+      end
+
+      def self.release(pointer)
+        Library.release_toggle_info(pointer)
+      end
+    end
+
+    class SelectionInformation < FFI::ManagedStruct
+      layout :can_multi_select, :bool,
+             :is_selection_required, :bool
+
+      def multi_select?
+        self[:can_multi_select]
+      end
+
+      def selection_required?
+        self[:is_selection_required]
+      end
+
+      def self.release(pointer)
+        Library.release_selection_info(pointer)
+      end
+    end
+
+    class SelectionItemInformation < FFI::ManagedStruct
+      layout :is_selected, :bool,
+             :container, ElementCast.ptr
+
+      def selected?
+        self[:is_selected]
+      end
+
+      def container
+        self[:container] unless self[:container].empty?
+      end
+
+      def self.release(pointer)
+        Library.release_selection_item_info(pointer)
+      end
+    end
+
+    class ExpandCollapseInformation < FFI::ManagedStruct
+      layout :expand_collapse_state, :string
+
+      def expand_collapse_state
+        self[:expand_collapse_state]
+      end
+
+      def self.release(pointer)
+        Library.release_expand_collapse_info(pointer)
+      end
+    end
   end
 end

data/lib/uia/patterns/expand_collapse.rb

@@ -0,0 +1,17 @@
+module Uia
+  module Patterns
+    module ExpandCollapse
+      def expand
+        Library.expand(@element)
+      end
+
+      def collapse
+        Library.collapse(@element)
+      end
+
+      def expand_collapse_state
+        Library.expand_collapse_info(@element).expand_collapse_state.downcase.to_sym
+      end
+    end
+  end
+end

data/lib/uia/patterns/invoke.rb

@@ -0,0 +1,9 @@
+module Uia
+  module Patterns
+    module Invoke
+      def invoke
+        Library.invoke @element
+      end
+    end
+  end
+end

data/lib/uia/patterns/selection.rb

@@ -0,0 +1,17 @@
+module Uia
+  module Patterns
+    module Selection
+      def selection_items
+        descendants.map {|e| e.as :selection_item }
+      end
+
+      def multi_select?
+        Library.selection_info(@element).multi_select?
+      end
+
+      def selection_required?
+        Library.selection_info(@element).selection_required?
+      end
+    end
+  end
+end

data/lib/uia/patterns/selection_item.rb

@@ -0,0 +1,25 @@
+module Uia
+  module Patterns
+    module SelectionItem
+      def select
+        Library.select @element
+      end
+
+      def add_to_selection
+        Library.add_to_selection @element
+      end
+
+      def remove_from_selection
+        Library.remove_from_selection @element
+      end
+
+      def selected?
+        Library.selection_item_info(@element).selected?
+      end
+
+      def container
+        Uia::Element.new Library.selection_item_info(@element).container
+      end
+    end
+  end
+end

data/lib/uia/patterns/toggle.rb

@@ -0,0 +1,17 @@
+module Uia
+  module Patterns
+    module Toggle
+      def toggle_state
+        Library.toggle_information(@element).state.downcase.to_sym
+      end
+
+      def toggle_state=(state)
+        toggle unless state == toggle_state
+      end
+
+      def toggle
+        Library.toggle @element
+      end
+    end
+  end
+end

data/lib/uia/patterns/value.rb

@@ -0,0 +1,22 @@
+module Uia
+  module Patterns
+    module Value
+      def value=(value)
+        Library.set_value(@element, value)
+      end
+
+      def value
+        value_information.value
+      end
+
+      def read_only?
+        value_information.read_only?
+      end
+
+      private
+      def value_information
+        Library.value_info(@element)
+      end
+    end
+  end
+end

data/lib/uia/version.rb

@@ -1,3 +1,3 @@
 module Uia
-  VERSION = '0.0.5.1'
+  VERSION = '0.0.6'
 end

data/spec/spec_helper.rb

@@ -7,8 +7,6 @@ require 'childprocess'
 require 'ffi'
 require 'uia'
 
-include Uia
-
 RSpec.configure do |config|
   config.before(:all) do
     @app = ChildProcess.build('spec/app/WindowsForms.exe').start

data/spec/uia/element_spec.rb

@@ -1,19 +1,22 @@
 require 'spec_helper'
 
-describe Element do
-  Given(:element) { find_element(id: 'MainFormWindow') }
-  Given(:about_box) { find_element(id: 'AboutBox') }
+describe Uia::Element do
+  Given(:element) { Uia.find_element(id: 'MainFormWindow') }
+  Given(:about_box) { Uia.find_element(id: 'AboutBox') }
 
   context 'properties' do
+    let(:raw_element) { element.instance_variable_get(:@element) }
     Then { element.handle != 0 }
     Then { element.name == 'MainFormWindow' }
     Then { element.id == 'MainFormWindow' }
+    Then { element.class_name =~ /Forms.*app/i }
+    Then { expect(element.find(id: 'textField')).to be_enabled }
 
     context '#control_type' do
       Then { element.control_type == :window }
 
       context 'unknown' do
-        Given { element.stub(:control_type_id).and_return(777) }
+        Given { raw_element.stub(:control_type_id).and_return(777) }
         Then { element.control_type == :unknown }
       end
     end
@@ -22,10 +25,34 @@ describe Element do
       Then { element.patterns.should =~ [:transform, :window] }
 
       context 'unknown' do
-        Given { element.stub(:pattern_ids).and_return([7777]) }
-        Then { element.patterns.should == [:unknown]}
+        Given { raw_element.stub(:pattern_ids).and_return([7777]) }
+        Then { element.patterns.should == [:unknown] }
       end
     end
+
+    context '#refresh' do
+      Given!(:check_box) do
+        check_box = element.find(id: 'checkBox').as :toggle
+        check_box.toggle_state = :off
+        check_box
+      end
+
+      Given!(:label) { element.find(id: 'checkBoxLabel') }
+      When { check_box.toggle_state = :on; label.refresh }
+      Then { label.name == 'checkBox is on' }
+    end
+  end
+
+  context '#find' do
+    context 'id' do
+      Then { element.find(id: 'textField') != nil }
+      Then { element.find(id: 'does not exist') == nil }
+    end
+
+    context 'name' do
+      Then { element.find(name: 'No option selected') != nil }
+      Then { element.find(name: 'does not exist') == nil }
+    end
   end
 
   context '#click' do
@@ -46,11 +73,11 @@ describe Element do
 
   context '#children' do
     Then { element.children.count == 27 }
-    Then { element.children.all? { |c| c.instance_of? Element } }
+    Then { element.children.all? { |c| c.instance_of? Uia::Element } }
   end
 
   context '#descendants' do
     Then { element.descendants.count > element.children.count }
-    Then { element.descendants.all? { |c| c.instance_of? Element } }
+    Then { element.descendants.all? { |c| c.instance_of? Uia::Element } }
   end
 end