Table#rows

ext/UiaDll/UiaDll/AutomatedTable.cpp

@@ -12,6 +12,34 @@ int AutomatedTable::RowCount::get()
 	return tablePattern->Current.RowCount;
 }
 
+bool AutomatedTable::Exists(const char* whichItem)
+{
+	return Exists(gcnew PropertyCondition(AutomationElement::NameProperty, gcnew String(whichItem)));
+}
+
+bool AutomatedTable::Exists(const int whichItemIndex)
+{
+	return Exists(gcnew PropertyCondition(TableItemPattern::RowProperty, whichItemIndex));
+}
+
+String^ AutomatedTable::ValueAt(const int dataRow)
+{
+	return DataItemAt(dataRow)->Current.Name;
+}
+
+AutomationElement^ AutomatedTable::DataItemAt(const int whichItemIndex)
+{
+	auto dataItemProperty = gcnew PropertyCondition(AutomationElement::IsTableItemPatternAvailableProperty, true);
+	auto indexProperty = gcnew PropertyCondition(TableItemPattern::RowProperty, whichItemIndex);
+	return _tableControl->FindFirst(System::Windows::Automation::TreeScope::Subtree, gcnew AndCondition(dataItemProperty, indexProperty));
+}
+
+bool AutomatedTable::Exists(Condition^ condition)
+{
+	auto dataItemProperty = gcnew PropertyCondition(AutomationElement::IsTableItemPatternAvailableProperty, true);
+	return _tableControl->FindAll(System::Windows::Automation::TreeScope::Subtree, gcnew AndCondition(dataItemProperty, condition))->Count > 0;
+}
+
 void AutomatedTable::Select(const int dataItemIndex)
 {
 	auto dataItemProperty = gcnew PropertyCondition(AutomationElement::ControlTypeProperty, ControlType::DataItem);

ext/UiaDll/UiaDll/AutomatedTable.h

@@ -5,7 +5,9 @@ ref class AutomatedTable
 {
 public:
 	AutomatedTable(const HWND windowHandle);
-
+	bool Exists(const char* whichItem);
+	bool Exists(const int whichItemIndex);
+	String^ ValueAt(const int whichItemIndex);
 	void Select(const int dataItemIndex);
 
 	property int RowCount {
@@ -14,5 +16,7 @@ ref class AutomatedTable
 
 private:
 	AutomationElement^ _tableControl;
+	bool Exists(Condition^ condition);
+	AutomationElement^ DataItemAt(const int whichItemIndex);
 };
 

ext/UiaDll/UiaDll/UiaDll.cpp

@@ -464,6 +464,36 @@ extern "C" {
 		}
 	}
 
+	__declspec ( dllexport ) bool RA_DataItemExistsByValue(const HWND windowHandle, const char* whichItem) {
+		try {
+			auto tableControl = gcnew AutomatedTable(windowHandle);
+			return tableControl->Exists(whichItem);
+		} catch(Exception^ e) {
+			Console::WriteLine(e->ToString());
+			return false;
+		}
+	}
+
+	__declspec ( dllexport ) bool RA_DataItemExistsByIndex(const HWND windowHandle, const int whichItemIndex) {
+		try {
+			auto tableControl = gcnew AutomatedTable(windowHandle);
+			return tableControl->Exists(whichItemIndex);
+		} catch(Exception^ e) {
+			Console::WriteLine(e->ToString());
+			return false;
+		}
+	}
+
+	__declspec ( dllexport ) void RA_RowValueAt(const HWND windowHandle, const int row, char *foundValue, const int foundValueLength) {
+		try {
+			auto tableControl = gcnew AutomatedTable(windowHandle);
+			auto rowValue = tableControl->ValueAt(row);
+			StringHelper::CopyToUnmanagedString(rowValue, foundValue, foundValueLength);
+		} catch(Exception^ e) {
+			Console::WriteLine(e->ToString());
+		}
+	}
+
 	__declspec ( dllexport ) void RA_SelectDataItem(const HWND windowHandle, const int dataItemIndex) {
 		try {
 			auto tableControl = gcnew AutomatedTable(windowHandle);

lib/rautomation/adapter/ms_uia/table.rb

@@ -1,9 +1,53 @@
 module RAutomation
   module Adapter
     module MsUia
+      class Row
+        include Locators
+
+        def initialize(window, locators)
+          @hwnd = window.hwnd
+          @locators = extract(locators)
+        end
+
+        def index
+          @locators[:index] || 0
+        end
+
+        def value
+          UiaDll::row_value_at @hwnd, @locators[:index]
+        end
+
+        def exists?
+          UiaDll::data_item_exists_by_index(@hwnd, @locators[:index])
+        end
+
+        alias_method :text, :value
+        alias_method :row, :index
+      end
+
       class Table < Control
         include WaitHelper
         include Locators
+        extend ElementCollections
+
+        has_many :rows
+
+        def row(locators={})
+          rows(locators).first
+        end
+
+        def rows(locators={})
+          Rows.new(self, locators).select do |row|
+            locators_match? locators, row
+          end
+        end
+
+        def locators_match?(locators, row)
+          locators.all? do |locator, value|
+            return row.value =~ value if value.is_a? Regexp
+            return row.send(locator) == value
+          end
+        end
 
         def strings
           rows = []

lib/rautomation/adapter/ms_uia/uia_dll.rb

@@ -74,6 +74,19 @@ module UiaDll
                         [:long], :int
         attach_function :select_data_item, :RA_SelectDataItem,
                         [:long, :int], :void
+        attach_function :data_item_exists_by_value, :RA_DataItemExistsByValue,
+                        [:long, :string], :bool
+        attach_function :data_item_exists_by_index, :RA_DataItemExistsByIndex,
+                        [:long, :int], :bool
+
+        attach_function :RA_RowValueAt,
+                        [:long, :int, :pointer, :int], :void
+
+        def self.row_value_at(hwnd, which_index)
+          string = FFI::MemoryPointer.new :char, 1024
+          RA_RowValueAt hwnd, which_index, string, 1024
+          string.read_string
+        end
       end
     end
   end

spec/adapter/ms_uia/table_spec.rb

@@ -52,5 +52,49 @@
     table.row_count.should eq(2)
   end
 
+  context "#rows" do
+    let(:table) { RAutomation::Window.new(:title => "DataEntryForm").table(:id => "personListView") }
+
+    it "has rows" do
+      table.rows.size.should eq 2
+    end
+
+    it "have values" do
+      table.rows.map(&:value).should eq ["John Doe", "Anna Doe"]
+    end
+
+    it "values are also text" do
+      table.rows.map(&:text).should eq ["John Doe", "Anna Doe"]
+    end
+
+    context "locators" do
+      it "can locate by text" do
+        table.rows(:text => "Anna Doe").size.should eq 1
+      end
+
+      it "can locate by regex" do
+        table.rows(:text => /Doe/).size.should eq 2
+      end
+
+      it "can locate by index" do
+        table.rows(:index => 1).first.text.should eq "Anna Doe"
+      end
+
+      it "an index is also a row" do
+        table.rows(:row => 1).first.text.should eq "Anna Doe"
+      end
+    end
+
+    context "singular row" do
+      it "grabs the first by default" do
+        table.row.text.should eq "John Doe"
+      end
+
+      it "can haz locators too" do
+        table.row(:text => "Anna Doe").text.should eq "Anna Doe"
+      end
+    end
+  end
+
 end