uia 0.0.6.1 → 0.0.7

data/lib/uia/library/element_structs.rb

@@ -0,0 +1,95 @@
+require 'ffi'
+
+module Uia
+  module Library
+    module ElementLayout
+      def self.included(base)
+        base.class_eval do
+          layout :handle, :int,
+                 :runtime_id, :pointer,
+                 :number_of_ids, :int,
+                 :name, :string,
+                 :class_name, :string,
+                 :control_type_id, :int,
+                 :patterns, :pointer,
+                 :patterns_length, :int,
+                 :id, :string,
+                 :is_enabled, :bool
+
+          def id
+            self[:id]
+          end
+
+          def name
+            self[:name]
+          end
+
+          def handle
+            self[:handle]
+          end
+
+          def runtime_id
+            self[:runtime_id].read_array_of_int(number_of_ids)
+          end
+
+          def control_type_id
+            self[:control_type_id]
+          end
+
+          def pattern_ids
+            self[:patterns].read_array_of_int(self[:patterns_length])
+          end
+
+          def children
+            Library.children(self)
+          end
+
+          def descendants
+            Library.descendants(self)
+          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]
+          end
+        end
+      end
+    end
+
+    class ManagedElementStruct < FFI::ManagedStruct
+      include ElementLayout
+
+      def self.release(pointer)
+        Library.release_element(pointer)
+      end
+    end
+
+    class ElementStruct < FFI::Struct
+      include ElementLayout
+    end
+
+    class Elements < FFI::Struct
+      layout :length, :int,
+             :items, :pointer
+
+      def children
+        self[:length].times.collect do |i|
+          pointer = self[:items] + i * ElementStruct.size
+          Uia::Element.new(ElementStruct.new(pointer))
+        end
+      end
+    end
+  end
+end

data/lib/uia/library/pattern_structs.rb

@@ -0,0 +1,155 @@
+module Uia
+  module Library
+    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, ElementStruct.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
+
+    class WindowInformation < FFI::ManagedStruct
+      layout :visual_state, :string,
+             :interaction_state, :string,
+             :can_minimize, :bool,
+             :can_maximize, :bool,
+             :is_modal, :bool,
+             :is_topmost, :bool
+
+      def visual_state
+        self[:visual_state]
+      end
+
+      def can_minimize?
+        self[:can_minimize]
+      end
+
+      def can_maximize?
+        self[:can_maximize]
+      end
+
+      def modal?
+        self[:is_modal]
+      end
+
+      def topmost?
+        self[:is_topmost]
+      end
+
+      def interaction_state
+        self[:interaction_state]
+      end
+
+      def self.release(pointer)
+        Library.release_window_info(pointer)
+      end
+    end
+
+    class TableInformation < FFI::ManagedStruct
+      layout :row_count, :int,
+             :column_count, :int,
+             :headers, Elements.ptr
+
+      def row_count
+        self[:row_count]
+      end
+
+      def column_count
+        self[:column_count]
+      end
+
+      def headers
+        self[:headers].children
+      end
+
+      def self.release(pointer)
+        Library.release_table_info(pointer)
+      end
+    end
+
+    class TableItemInformation < FFI::ManagedStruct
+      layout :column, :int,
+             :row, :int
+
+      def column
+        self[:column]
+      end
+
+      def row
+        self[:row]
+      end
+
+      def self.release(pointer)
+        Library.release_table_item_info(pointer)
+      end
+    end
+
+  end
+end

data/lib/uia/library.rb

@@ -1,5 +1,6 @@
-require 'uia/library/structs'
 require 'ffi'
+require 'uia/library/element_structs'
+require 'uia/library/pattern_structs'
 
 module Uia
   module Library
@@ -24,36 +25,53 @@ module Uia
       end
     end
 
+    def self.elements_from(name_alias, name, arg_types, &block)
+      attach_function name, arg_types + [:pointer, :pointer, :int], :int
+      define_singleton_method(name_alias) do |*args|
+        elements_pointer = FFI::MemoryPointer.new :pointer
+        can_throw(name, *(args << elements_pointer)).times.collect do |which_element|
+          pointer = elements_pointer.read_pointer + which_element * ManagedElementStruct.size
+          Uia::Element.new(ManagedElementStruct.new(pointer))
+        end
+      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_window_info, :Window_Release, [: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_table_info, :Table_Release, [:pointer], :void
+    attach_function :release_table_item_info, :TableItem_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
+    elements_from :root_children, :Root_Children, []
 
     # finding elements
-    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, &element_or_nil
-    attach_function :Element_FindByRuntimeId, [:pointer, :int, :pointer, :int], ElementStruct.by_ref
+    attach_throwable_function :find_by_id, :Element_FindById, [:string], ManagedElementStruct.by_ref, &element_or_nil
+    attach_throwable_function :find_by_name, :Element_FindByName, [:string], ManagedElementStruct.by_ref, &element_or_nil
+    attach_throwable_function :find_by_pid, :Element_FindByProcessId, [:int], ManagedElementStruct.by_ref, &element_or_nil
+    attach_throwable_function :find_by_handle, :Element_FindByHandle, [:int], ManagedElementStruct.by_ref, &element_or_nil
+    attach_function :Element_FindByRuntimeId, [:pointer, :int, :pointer, :int], ManagedElementStruct.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 :descendants, :Element_Descendants, [:pointer], ElementChildrenStruct.by_ref
+    attach_throwable_function :find_child_by_id, :Element_FindChildById, [:pointer, :string], ManagedElementStruct.by_ref, &element_or_nil
+    attach_throwable_function :find_child_by_name, :Element_FindChildByName, [:pointer, :string], ManagedElementStruct.by_ref, &element_or_nil
+    elements_from :children, :Element_Children, [:pointer]
+    elements_from :descendants, :Element_Descendants, [:pointer]
     attach_throwable_function :click, :Element_Click, [:pointer], :void
     attach_throwable_function :refresh, :Element_Refresh, [:pointer], :void
 
+    # WindowPattern methods
+    attach_throwable_function :window_information, :Window_Information, [:pointer], WindowInformation.by_ref
+    attach_throwable_function :set_visual_state, :Window_SetVisualState, [:pointer, :string], :void
+
     # ValuePattern methods
     attach_throwable_function :set_value, :Value_Set, [:pointer, :string], :void
     attach_throwable_function :value_info, :Value_Information, [:pointer], ValueInformation.by_ref
@@ -79,6 +97,12 @@ module Uia
     attach_throwable_function :add_to_selection, :SelectionItem_AddToSelection, [:pointer], :void
     attach_throwable_function :remove_from_selection, :SelectionItem_RemoveFromSelection, [:pointer], :void
 
+    # TablePattern methods
+    attach_throwable_function :table_info, :Table_Information, [:pointer], TableInformation.by_ref
+
+    # TableItemPattern methods
+    attach_throwable_function :table_item_info, :TableItem_Information, [:pointer], TableItemInformation.by_ref
+
     def self.find_by_runtime_id(id)
       p = FFI::MemoryPointer.new :int, id.count
       p.write_array_of_int(id)

data/lib/uia/patterns/expand_collapse.rb

@@ -10,7 +10,7 @@ module Uia
       end
 
       def expand_collapse_state
-        Library.expand_collapse_info(@element).expand_collapse_state.downcase.to_sym
+        Library.expand_collapse_info(@element).expand_collapse_state.to_snake_case_sym
       end
     end
   end

data/lib/uia/patterns/table.rb

@@ -0,0 +1,32 @@
+module Uia
+  module Patterns
+    module Table
+      module Row
+        def items
+          select(pattern: :table_item).each { |e| e.as :table_item }
+        end
+      end
+
+      def row_count
+        table_info.row_count
+      end
+
+      def column_count
+        table_info.column_count
+      end
+
+      def headers
+        table_info.headers
+      end
+
+      def rows
+        select(control_type: :data_item).each { |e| e.extend Row }
+      end
+
+      private
+      def table_info
+        Library.table_info(@element)
+      end
+    end
+  end
+end

data/lib/uia/patterns/table_item.rb

@@ -0,0 +1,18 @@
+module Uia
+  module Patterns
+    module TableItem
+      def column
+        table_item_info.column
+      end
+
+      def row
+        table_item_info.row
+      end
+
+      private
+      def table_item_info
+        Library.table_item_info(@element)
+      end
+    end
+  end
+end

data/lib/uia/patterns/toggle.rb

@@ -2,7 +2,7 @@ module Uia
   module Patterns
     module Toggle
       def toggle_state
-        Library.toggle_information(@element).state.downcase.to_sym
+        Library.toggle_information(@element).state.to_snake_case_sym
       end
 
       def toggle_state=(state)

data/lib/uia/patterns/window.rb

@@ -0,0 +1,38 @@
+module Uia
+  module Patterns
+    module Window
+      def visual_state
+        window_information.visual_state.to_snake_case_sym
+      end
+
+      def can_minimize?
+        window_information.can_minimize?
+      end
+
+      def can_maximize?
+        window_information.can_maximize?
+      end
+
+      def modal?
+        window_information.modal?
+      end
+
+      def topmost?
+        window_information.topmost?
+      end
+
+      def visual_state=(state)
+        Library.set_visual_state(@element, state.to_camelized_s)
+      end
+
+      def interaction_state
+        window_information.interaction_state.to_snake_case_sym
+      end
+
+      private
+      def window_information
+        Library.window_information(@element)
+      end
+    end
+  end
+end

data/lib/uia/version.rb

@@ -1,3 +1,3 @@
 module Uia
-  VERSION = '0.0.6.1'
+  VERSION = '0.0.7'
 end

data/lib/uia.rb

@@ -1,15 +1,19 @@
+require 'require_all'
 require 'uia/version'
 require 'uia/library'
 require 'uia/library/constants'
-require 'uia/element'
 require 'uia/finder'
+require 'uia/element'
+
+require_rel 'uia/patterns'
+require_rel 'core_ext'
 
 module Uia
   class BadLocator < StandardError; end
   extend Finder
 
   def self.children
-    Library.root_children.children
+    Library.root_children
   end
 
   def self.find_element(how)

data/spec/uia/element_spec.rb

@@ -28,6 +28,11 @@ describe Uia::Element do
         Given { raw_element.stub(:pattern_ids).and_return([7777]) }
         Then { element.patterns.should == [:unknown] }
       end
+
+      context '#as' do
+        When(:cast) { element.as :toggle }
+        Then { cast.should have_failed UnsupportedPattern, "Pattern toggle not found in [:window, :transform]" }
+      end
     end
 
     context '#refresh' do
@@ -55,6 +60,21 @@ describe Uia::Element do
     end
   end
 
+  context '#select' do
+    context 'control_type' do
+      When(:buttons) { element.select(control_type: :radio_button) }
+      Then { buttons.map(&:control_type) == [:radio_button] * 3 }
+    end
+
+    context 'pattern' do
+      Then { element.select(pattern: :value).count == 4 }
+    end
+
+    context 'combinations' do
+      Then { element.select(control_type: :button, name: 'About')[0].id == 'aboutButton' }
+    end
+  end
+
   context '#click' do
     Given(:about) { element.children.find { |c| c.name == 'About' } }
     Given(:disabled_checkbox) { element.children.find { |c| c.name == 'checkBoxDisabled' } }

data/spec/uia/patterns/table_item_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe Uia::Patterns::TableItem do
+  Given(:data_grid) do
+    until (form = Uia.find_element(name: 'DataEntryForm'))
+      Uia.find_element(id: /MainForm/).find(name: 'Data Entry Form').as(:invoke).invoke
+    end
+
+    form.find(name: 'Add Many').as(:invoke).invoke
+    form.find(id: 'personListView').as(:table)
+  end
+  Given(:first_row) { data_grid.rows.first }
+
+  context 'properties' do
+    Given(:first_item) { first_row.items.first }
+    Given(:last_item) { first_row.items.last }
+
+    Then { last_item.column == 2 }
+    Then { first_item.row == 0 }
+  end
+end

data/spec/uia/patterns/table_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe Uia::Patterns::Table do
+  Given(:data_grid) do
+    until (form = Uia.find_element(name: 'DataEntryForm'))
+      Uia.find_element(id: /MainForm/).find(name: 'Data Entry Form').as(:invoke).invoke
+    end
+
+    form.find(name: 'Add Many').as(:invoke).invoke
+    form.find(id: 'personListView').as(:table)
+  end
+
+  context 'properties' do
+    Then { data_grid.row_count == 52 }
+    Then { data_grid.column_count == 3 }
+  end
+
+  context '#headers' do
+    Then { data_grid.headers.map(&:control_type) == [:header_item] * 3 }
+    Then { data_grid.headers.map(&:name) == ['Name', 'Date of birth', 'State'] }
+  end
+
+  context '#rows' do
+    Then { data_grid.rows.count == data_grid.row_count }
+
+    context 'row' do
+      Given(:row) { data_grid.rows[0] }
+
+      context '#items' do
+        Then { row.items.map(&:name) == ['John Doe', '12/15/1967', 'FL'] }
+      end
+    end
+  end
+end

data/spec/uia/patterns/window_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe Uia::Patterns::Window do
+  Given(:window) { Uia.find_element(id: /MainFormWindow/).as(:window) }
+
+  context 'properties' do
+    Then { window.visual_state == :normal }
+    Then { window.interaction_state == :ready_for_user_interaction }
+    Then { window.can_minimize? == true }
+    Then { window.can_maximize? == true }
+    Then { window.modal? == false }
+    Then { window.topmost? == false }
+  end
+
+  context '#visual_state=' do
+    context 'minimized' do
+      When { window.visual_state = :minimized }
+      Then { window.visual_state == :minimized }
+    end
+
+    context 'maximized' do
+      When { window.visual_state = :maximized }
+      Then { window.visual_state == :maximized }
+    end
+
+    context 'normal' do
+      When { window.visual_state = :normal }
+      Then { window.visual_state == :normal }
+    end
+  end
+end

data/uia.gemspec

@@ -26,6 +26,7 @@ Gem::Specification.new do |spec|
   spec.require_paths = ['lib']
 
   spec.add_runtime_dependency 'ffi'
+  spec.add_runtime_dependency 'require_all'
 
   spec.add_development_dependency 'bundler', '~> 1.3'
   spec.add_development_dependency 'rake'