rautomation 0.8.0 → 0.9.0

data/ext/UiaDll/UiaDll/AutomationFinder.cpp

@@ -0,0 +1,57 @@
+#include "StdAfx.h"
+#include "AutomationFinder.h"
+
+AutomationFinder::AutomationFinder(AutomationElement^ automationElement)
+{
+	_automationElement = automationElement;
+}
+
+AutomationElementCollection^ AutomationFinder::Find(...array<Condition^>^ conditions)
+{
+	return _automationElement->FindAll(System::Windows::Automation::TreeScope::Subtree, SomethingOrEverything(conditions));
+}
+
+AutomationElement^ AutomationFinder::FindFirst(...array<Condition^>^ conditions)
+{
+	return _automationElement->FindFirst(System::Windows::Automation::TreeScope::Subtree, SomethingOrEverything(conditions));
+}
+
+AutomationElement^ AutomationFinder::Find(const FindInformation& findInformation)
+{
+  switch(findInformation.how) {
+    case FindMethod::Id:
+		{
+      auto searchCondition = gcnew PropertyCondition(AutomationElement::AutomationIdProperty, gcnew String(findInformation.data.stringData));
+      return FindAt(findInformation.index, searchCondition);
+		}
+    case FindMethod::Value:
+		{
+      auto searchCondition = gcnew PropertyCondition(AutomationElement::NameProperty, gcnew String(findInformation.data.stringData));
+      return FindAt(findInformation.index, searchCondition);
+		}
+    case FindMethod::Focus:
+      return AutomationElement::FocusedElement;
+    case FindMethod::ScreenPoint:
+			return AutomationElement::FromPoint(Point(findInformation.data.pointData[0], findInformation.data.pointData[1]));
+    case FindMethod::Handle:
+      return AutomationElement::FromHandle(IntPtr(findInformation.data.intData));
+	}
+
+  return nullptr;
+}
+
+AutomationElement^ AutomationFinder::FindAt(const int whichItem, ...array<Condition^>^ conditions)
+{
+	return Find(conditions)[whichItem];
+}
+
+Condition^ AutomationFinder::SomethingOrEverything(...array<Condition^>^ conditions)
+{
+	if( conditions->Length == 0 ) {
+		return Condition::TrueCondition;
+	} else if( conditions->Length == 1 ) {
+		return conditions[0];
+	}
+
+	return gcnew AndCondition(conditions);
+}

data/ext/UiaDll/UiaDll/AutomationFinder.h

@@ -0,0 +1,48 @@
+#pragma once
+using namespace System::Windows;
+using namespace System::Windows::Automation;
+
+ref class AutomationFinder
+{
+public:
+	AutomationFinder(AutomationElement^ automationElement);
+	AutomationElementCollection^ Find(...array<Condition^>^ conditions);
+	AutomationElement^ Find(const FindInformation& findInformation);
+	AutomationElement^ FindFirst(...array<Condition^>^ conditions);
+	AutomationElement^ FindAt(const int whichItem, ...array<Condition^>^ conditions);
+
+	static property Condition^ IsSelectionItem {
+		Condition^ get() {
+			return gcnew PropertyCondition(AutomationElement::IsSelectionItemPatternAvailableProperty, true);
+		}
+	}
+
+	static property Condition^ IsTableItem {
+		Condition^ get() {
+			return gcnew PropertyCondition(AutomationElement::IsTableItemPatternAvailableProperty, true);
+		}
+	}
+
+	static property Condition^ IsDataItem {
+		Condition^ get() {
+			return gcnew PropertyCondition(AutomationElement::ControlTypeProperty, ControlType::DataItem);
+		}
+	}
+
+	static property Condition^ IsHeaderItem {
+		Condition^ get() {
+			return gcnew PropertyCondition(AutomationElement::ControlTypeProperty, ControlType::HeaderItem);
+		}
+	}
+
+	static property Condition^ IsListItem {
+		Condition^ get() {
+			return gcnew PropertyCondition(AutomationElement::ControlTypeProperty, ControlType::ListItem);
+		}
+	}
+
+private:
+	AutomationElement^ _automationElement;
+	Condition^ SomethingOrEverything(...array<Condition^>^ conditions);
+};
+

data/ext/UiaDll/UiaDll/ControlMethods.cpp

@@ -0,0 +1,15 @@
+#include "stdafx.h"
+#include "AutomationControl.h"
+#include "StringHelper.h"
+
+extern "C" {
+	__declspec ( dllexport ) void Control_GetValue(const HWND windowHandle, char* theValue, const int maximumLength) {
+		auto control = gcnew AutomationControl(windowHandle);
+		StringHelper::CopyToUnmanagedString(control->Value, theValue, maximumLength);
+	}
+
+	__declspec ( dllexport ) void Control_SetValue(const HWND windowHandle, const char* theValue) {
+		auto control = gcnew AutomationControl(windowHandle);
+		control->Value = gcnew String(theValue);
+	}
+}

data/ext/UiaDll/UiaDll/MenuItemSelector.h

@@ -1,4 +1,6 @@
 #pragma once
+#include "StringHelper.h"
+
 using namespace System::Windows::Automation;
 
 public ref class MenuItemSelector

data/ext/UiaDll/UiaDll/MenuMethods.cpp

@@ -0,0 +1,58 @@
+#include "stdafx.h"
+#include "MenuItemSelector.h"
+
+BOOL MenuItemExists(const HWND windowHandle, std::list<const char*>& menuItems);
+void MenuSelectPath(const HWND windowHandle, char* errorInfo, const int errorInfoSize, std::list<const char*>& menuItems);
+
+extern "C" {
+
+	__declspec ( dllexport ) void Menu_SelectPath(const HWND windowHandle, char* errorInfo, const int errorInfoSize, const char* arg0, ...) {
+		va_list arguments;
+		va_start(arguments, arg0);			
+
+		std::list<const char*> menuItems;
+
+		const char* lastArgument = arg0;
+		while( NULL != lastArgument ) {
+			menuItems.push_back(lastArgument);
+			lastArgument = va_arg(arguments, const char*);
+		}
+		va_end(arguments);
+
+		MenuSelectPath(windowHandle, errorInfo, errorInfoSize, menuItems);
+	}
+
+	__declspec ( dllexport ) BOOL Menu_ItemExists(const HWND windowHandle, const char* arg0, ...) {
+		va_list arguments;
+		va_start(arguments, arg0);			
+
+		std::list<const char*> menuItems;
+
+		const char* lastArgument = arg0;
+		while( NULL != lastArgument ) {
+			menuItems.push_back(lastArgument);
+			lastArgument = va_arg(arguments, const char*);
+		}
+		va_end(arguments);
+
+		return MenuItemExists(windowHandle, menuItems);
+	}
+}
+
+BOOL MenuItemExists(const HWND windowHandle, std::list<const char*>& menuItems)
+{
+	auto menuSelector = gcnew MenuItemSelector();
+	return menuSelector->MenuItemExists(windowHandle, menuItems);
+}
+
+void MenuSelectPath(const HWND windowHandle, char* errorInfo, const int errorInfoSize, std::list<const char*>& menuItems)
+{
+	try {
+		auto menuSelector = gcnew MenuItemSelector();
+		menuSelector->SelectMenuPath(windowHandle, menuItems);
+	} catch(Exception^ e) {
+		if( errorInfo ) {
+			StringHelper::CopyToUnmanagedString(e->ToString(), errorInfo, errorInfoSize);
+		}
+	}
+}

data/ext/UiaDll/UiaDll/SelectListMethods.cpp

@@ -0,0 +1,37 @@
+#include "stdafx.h"
+#include "AutomatedSelectList.h"
+
+extern "C" {
+
+	__declspec ( dllexport ) int SelectList_Count(const FindInformation& findInformation) {
+		auto autoSelectList = gcnew AutomatedSelectList(findInformation);
+		return autoSelectList->Count;
+	}
+
+	__declspec ( dllexport ) int SelectList_SelectedIndex(const HWND windowHandle) {
+		auto autoSelectList = gcnew AutomatedSelectList(windowHandle);
+		return autoSelectList->SelectedIndex;
+	}
+
+  __declspec ( dllexport ) void SelectList_Selection(const FindInformation& findInformation, char* selection, const int selectionLength) {
+    auto selectList = gcnew AutomatedSelectList(findInformation);
+    auto currentSelections = selectList->Selection;
+    auto firstSelection = currentSelections.Length == 0 ? "" : currentSelections[0];
+    StringHelper::CopyToUnmanagedString(firstSelection, selection, selectionLength);
+  }
+
+	__declspec ( dllexport ) bool SelectList_ValueAt(const HWND windowHandle, const int whichItem, char* comboValue, const int comboValueSize) {
+		auto autoSelectList = gcnew AutomatedSelectList(windowHandle);
+		return autoSelectList->GetValueByIndex(whichItem, comboValue, comboValueSize);
+	}
+
+	__declspec ( dllexport ) bool SelectList_SelectIndex(const FindInformation& findInformation, const int whichItem) {
+		auto autoSelectList = gcnew AutomatedSelectList(findInformation);
+		return autoSelectList->SelectByIndex(whichItem);
+	}
+
+	__declspec ( dllexport ) int SelectList_SelectValue(const FindInformation& findInformation, char *pValue) {
+		auto autoSelectList = gcnew AutomatedSelectList(findInformation);
+		return autoSelectList->SelectByValue(pValue);
+	}
+}

data/ext/UiaDll/UiaDll/SelectionItem.cpp

@@ -0,0 +1,10 @@
+#include "StdAfx.h"
+#include "SelectionItem.h"
+
+SelectionItem::SelectionItem(const HWND windowHandle) : AutomationControl(windowHandle)
+{
+}
+
+SelectionItem::SelectionItem(const FindInformation& findInformation) : AutomationControl(findInformation)
+{
+}

data/ext/UiaDll/UiaDll/SelectionItem.h

@@ -0,0 +1,21 @@
+#pragma once
+#include "automationcontrol.h"
+ref class SelectionItem :
+public AutomationControl
+{
+public:
+  SelectionItem(const HWND windowHandle);
+  SelectionItem(const FindInformation& findInformation);
+
+  property bool IsSelected {
+    bool get() { return AsSelectionItemPattern->Current.IsSelected; }
+  }
+
+private:
+	property SelectionItemPattern^ AsSelectionItemPattern {
+		SelectionItemPattern^ get() {
+			return dynamic_cast<SelectionItemPattern^>(_control->GetCurrentPattern(SelectionItemPattern::Pattern));
+		}
+	}
+};
+

data/ext/UiaDll/UiaDll/StringHelper.cpp

@@ -4,6 +4,37 @@
 void StringHelper::CopyToUnmanagedString(String^ source, char* destination, const int destinationSize)
 {
 	auto unmanagedString = Marshal::StringToHGlobalAnsi(source);
-	strncpy(destination, (const char*)(void*)unmanagedString, destinationSize - 1);
-	Marshal::FreeHGlobal(unmanagedString);
+	strncpy(destination, (const char*)(void*)unmanagedString, destinationSize);
+	Marshal::FreeHGlobal(unmanagedString);
 }
+
+char* StringHelper::UnmanagedStringFrom(String^ source)
+{
+	const int numberOfBytes = source->Length + 1;
+	auto unmanagedString = new char[numberOfBytes];
+	CopyToUnmanagedString(source, unmanagedString, numberOfBytes);
+	return unmanagedString;
+}
+
+void StringHelper::FreeUp(const char* unmanagedStrings[], const int numberOfStrings)
+{
+	for(auto whichString = 0; whichString < numberOfStrings; ++whichString) {
+		delete[] unmanagedStrings[whichString];
+	}
+}
+
+void StringHelper::CopyNames(AutomationElementCollection^ automationElements, const char* unmanagedStrings[])
+{
+	auto whichItem = 0;
+	for each(AutomationElement^ automationElement in automationElements) {
+		unmanagedStrings[whichItem++] = UnmanagedStringFrom(automationElement->Current.Name);
+	}
+}
+
+void StringHelper::CopyClassNames(AutomationElementCollection^ automationElements, const char* unmanagedStrings[])
+{
+	auto whichItem = 0;
+	for each(AutomationElement^ automationElement in automationElements) {
+		unmanagedStrings[whichItem++] = UnmanagedStringFrom(automationElement->Current.ClassName);
+	}
+}

data/ext/UiaDll/UiaDll/StringHelper.h

@@ -1,7 +1,13 @@
 #pragma once
+using namespace System::Windows::Automation;
+
 ref class StringHelper
 {
 public:
 	static void CopyToUnmanagedString(String^ source, char* destination, const int destinationSize);
+	static char* UnmanagedStringFrom(String^ source);
+	static void FreeUp(const char* unmanagedStrings[], const int numberOfStrings);
+	static void CopyNames(AutomationElementCollection^ automationElements, const char* unmanagedStrings[]);
+	static void CopyClassNames(AutomationElementCollection^ automationElements, const char* unmanagedStrings[]);
 };
 

data/ext/UiaDll/UiaDll/StringMethods.cpp

@@ -0,0 +1,8 @@
+#include "stdafx.h"
+#include "StringHelper.h"
+
+extern "C" {
+	__declspec ( dllexport ) void String_CleanUp(const char* strings[], const int numberOfStrings) {
+		StringHelper::FreeUp(strings, numberOfStrings);
+	}
+}

data/ext/UiaDll/UiaDll/TableMethods.cpp

@@ -0,0 +1,76 @@
+#include "stdafx.h"
+#include "AutomatedTable.h"
+
+extern "C" {
+
+	__declspec ( dllexport ) int Table_GetHeaders(const HWND windowHandle, const char* headers[]) {
+		auto tableControl = gcnew AutomatedTable(windowHandle);
+		return tableControl->GetHeaders(headers);
+	}
+
+	__declspec ( dllexport ) int Table_GetValues(const HWND windowHandle, const char* values[]) {
+		auto tableControl = gcnew AutomatedTable(windowHandle);
+		return tableControl->GetValues(values);
+	}
+
+  __declspec ( dllexport ) int Table_FindValues(const FindInformation& findInformation, const char* values[]) {
+		auto tableControl = gcnew AutomatedTable(findInformation);
+		return tableControl->GetValues(values);
+  }
+
+	__declspec ( dllexport ) int Table_RowCount(const HWND windowHandle) {
+		try {
+			auto tableControl = gcnew AutomatedTable(windowHandle);
+			return tableControl->RowCount;
+		} catch(Exception^ e) {
+			Console::WriteLine(e->ToString());
+		}
+	}
+
+	__declspec ( dllexport ) bool Table_CoordinateIsValid(const HWND windowHandle, const int whichItemIndex, const int whichColumnIndex) {
+		try {
+			auto tableControl = gcnew AutomatedTable(windowHandle);
+			return tableControl->Exists(whichItemIndex, whichColumnIndex);
+		} catch(Exception^ e) {
+			Console::WriteLine(e->ToString());
+			return false;
+		}
+	}
+
+	__declspec ( dllexport ) void Table_ValueAt(const HWND windowHandle, const int row, const int column, char *foundValue, const int foundValueLength) {
+		try {
+			auto tableControl = gcnew AutomatedTable(windowHandle);
+			auto rowValue = tableControl->ValueAt(row, column);
+			StringHelper::CopyToUnmanagedString(rowValue, foundValue, foundValueLength);
+		} catch(Exception^ e) {
+			Console::WriteLine(e->ToString());
+		}
+	}
+
+	__declspec ( dllexport ) void Table_SelectByIndex(const HWND windowHandle, const int dataItemIndex) {
+		try {
+			auto tableControl = gcnew AutomatedTable(windowHandle);
+			tableControl->Select(dataItemIndex);
+		} catch(Exception^ e) {
+			Console::WriteLine(e->ToString());
+		}
+	}
+
+	__declspec ( dllexport ) bool Table_IsSelectedByIndex(const HWND windowHandle, const int dataItemIndex) {
+		try {
+			auto tableControl = gcnew AutomatedTable(windowHandle);
+			return tableControl->IsSelected(dataItemIndex);
+		} catch(Exception^ e) {
+			Console::WriteLine(e->ToString());
+		}
+	}
+
+	__declspec ( dllexport ) void Table_SelectByValue(const HWND windowHandle, const char* dataItemValue) {
+		try {
+			auto tableControl = gcnew AutomatedTable(windowHandle);
+			tableControl->Select(dataItemValue);
+		} catch(Exception^ e) {
+			Console::WriteLine(e->ToString());
+		}
+	}
+}

data/ext/UiaDll/UiaDll/Toggle.cpp

@@ -0,0 +1,2 @@
+#include "StdAfx.h"
+#include "Toggle.h"

data/ext/UiaDll/UiaDll/Toggle.h

@@ -0,0 +1,22 @@
+#pragma once
+#include "AutomationControl.h"
+
+ref class Toggle : public AutomationControl
+{
+public:
+  Toggle(const HWND windowHandle) : AutomationControl(windowHandle) {}
+  Toggle(const FindInformation& findInformation) : AutomationControl(findInformation) {}
+
+  property bool IsSet {
+    bool get() { return AsTogglePattern->Current.ToggleState == System::Windows::Automation::ToggleState::On; }
+  }
+
+private:
+	property TogglePattern^ AsTogglePattern {
+		TogglePattern^ get() {
+			return dynamic_cast<TogglePattern^>(_control->GetCurrentPattern(TogglePattern::Pattern));
+		}
+	}
+  
+};
+

data/ext/UiaDll/UiaDll/UiaDll.cpp

@@ -2,77 +2,90 @@
 //
 
 #include "stdafx.h"
-#include "AutomatedComboBox.h"
-#include "AutomatedTable.h"
 #include "AutomationClicker.h"
+#include "AutomationControl.h"
+#include "AutomationFinder.h"
 #include "ExpandCollapseHelper.h"
-#include "MenuItemSelector.h"
-#include "ToggleStateHelper.h"
+#include "StringHelper.h"
+#include "SelectionItem.h"
+#include "Toggle.h"
 
 IUIAutomation* getGlobalIUIAutomation() ;
 
-
-BOOL MenuItemExists(const HWND windowHandle, std::list<const char*>& menuItems);
-void SelectMenuItem(const HWND windowHandle, char* errorInfo, const int errorInfoSize, std::list<const char*>& menuItems);
-int McppHowManyDataItemsFor(const HWND windowHandle);
-
 extern "C" {
-	__declspec( dllexport ) IUIAutomationElement *RA_FindWindow(char *pszAutomationId) {
-		IUIAutomationElement *pRootElement ;
-
-		HRESULT hr = getGlobalIUIAutomation()->GetRootElement(&pRootElement) ;
-		if (SUCCEEDED(hr)) {
-			IUIAutomationCondition *pCondition ;
-			VARIANT varProperty ;
-
-			VariantInit(&varProperty) ;
-			varProperty.vt = VT_BSTR ;
-			varProperty.bstrVal = _bstr_t(pszAutomationId) ;
 
-			hr = getGlobalIUIAutomation()->CreatePropertyCondition(UIA_AutomationIdPropertyId, varProperty, &pCondition) ;
-			if (SUCCEEDED(hr)) {
-				IUIAutomationElement *pFound ;
-
-				hr = pRootElement->FindFirst(TreeScope_Children, pCondition, &pFound) ;
-				if (SUCCEEDED(hr)) {
-					return pFound ;
-				}
-			}
+	__declspec ( dllexport ) bool ElementExists(const FindInformation& findInformation) {
+        auto automationElement = gcnew AutomationControl(findInformation);
+        return automationElement->Exists;
+	}
+
+	__declspec ( dllexport ) int BoundingRectangle(const FindInformation& findInformation, long *rectangle) {
+    try {
+      auto automationElement = gcnew AutomationControl(findInformation);
+      auto boundary = automationElement->BoundingRectangle;
+
+      rectangle[0] = boundary.Left;
+      rectangle[1] = boundary.Top;
+      rectangle[2] = boundary.Right;
+      rectangle[3] = boundary.Bottom;
+      return 1;
+    }
+    catch(Exception^ e) {
+      Console::WriteLine("BoundingRectangle:  {0}", e->Message);
+      return 0;
+    }
+	}
+
+	__declspec ( dllexport ) int ControlType(const FindInformation& findInformation) {
+    try {
+      auto automationElement = gcnew AutomationControl(findInformation);
+      return automationElement->ControlType->Id;
+    } catch(Exception^ e) {
+      Console::WriteLine("ControlType:  {0}", e->Message);
+      return 0;
+    }
+	}
+
+  __declspec ( dllexport ) int ProcessId(const FindInformation& findInformation) {
+    try {
+      auto automationElement = gcnew AutomationControl(findInformation);
+      return automationElement->ProcessId;
+    } catch(Exception^ e) {
+      Console::WriteLine("ProcessId:  {0}", e->Message);
+      return 0;
+    }
+  }
+
+  __declspec ( dllexport ) void Name(const FindInformation& findInformation, char* name, const int nameLength) {
+		try {
+			auto control = gcnew AutomationControl(findInformation);
+			StringHelper::CopyToUnmanagedString(control->Name, name, nameLength);
+		} catch(Exception^ e) {
+      Console::WriteLine("Name:  {0}", e->Message);
 		}
-		return NULL ;
-	}
+  }
 
-	//This doesn't work
-	__declspec( dllexport ) int RA_FindWindowByPID(int processId, IUIAutomationElement *pElement) {
-		IUIAutomationElement *pRootElement;
+  __declspec ( dllexport ) void ClassName(const FindInformation& findInformation, char* className, const int classNameLength) {
+		try {
+			auto control = gcnew AutomationControl(findInformation);
+			StringHelper::CopyToUnmanagedString(control->ClassName, className, classNameLength);
+		} catch(Exception^ e) {
+      Console::WriteLine("ClassName:  {0}", e->Message);
+		}
+  }
 
-		HRESULT hr = getGlobalIUIAutomation()->GetRootElement(&pRootElement);
-		if (SUCCEEDED(hr)) {
-			IUIAutomationCondition *pCondition;
-			VARIANT varProperty;
+  __declspec ( dllexport ) int GetClassNames(const FindInformation& findInformation, const char* classNames[]) {
+    auto control = gcnew AutomationControl(findInformation);
+    auto finder = gcnew AutomationFinder(control->Element);
 
-			VariantInit(&varProperty);
-			varProperty.vt = VT_I4;
-			varProperty.intVal = (processId);
+    auto allChildren = finder->Find();
 
-			hr = getGlobalIUIAutomation()->CreatePropertyCondition(UIA_ProcessIdPropertyId, varProperty, &pCondition);
-			if (SUCCEEDED(hr)) {
+    if( NULL != classNames ) {
+      StringHelper::CopyClassNames(allChildren, classNames);
+    }
 
-				hr = pRootElement->FindFirst(TreeScope_Children, pCondition, &pElement);
-				if (SUCCEEDED(hr)) {
-					return 1;
-				}
-			}
-		}
-		return 0;
-	}
-
-	__declspec( dllexport ) BOOL RA_IsOffscreen(IUIAutomationElement *pElement) {
-		BOOL isOffscreen ;
-		pElement->get_CurrentIsOffscreen(&isOffscreen) ;
-
-		return isOffscreen ;
-	}
+    return allChildren->Count;
+  }
 
 	__declspec ( dllexport ) IUIAutomationElement *RA_ElementFromHandle(HWND hwnd) {
 		IUIAutomationElement *pElement ;
@@ -86,19 +99,6 @@ extern "C" {
 		}
 	}
 
-	__declspec ( dllexport ) IUIAutomationElement *RA_GetFocusedElement() {
-		IUIAutomationElement *pelement;
-
-		HRESULT hr = getGlobalIUIAutomation()->GetFocusedElement(&pelement);
-
-		if (SUCCEEDED(hr))
-			return pelement;
-		else {
-			printf("RA_GetFocusedElement: Cannot find element from focus. HRESULT was 0x%x\r\n", hr) ;
-			return false ;
-		}
-	}
-
 	__declspec ( dllexport ) IUIAutomationElement *RA_ElementFromPoint(int xCoord, int yCoord) {
 		IUIAutomationElement *pElement ;
 		POINT point;
@@ -143,34 +143,6 @@ extern "C" {
 		}
 	}
 
-	__declspec ( dllexport ) IUIAutomationElement *RA_FindChildByName(IUIAutomationElement *pElement, char *elementName) {
-		IUIAutomationCondition *pCondition ;
-		VARIANT varProperty ;
-
-		VariantInit(&varProperty) ;
-		varProperty.vt = VT_BSTR ;
-		varProperty.bstrVal = _bstr_t(elementName) ;
-
-		HRESULT hr = getGlobalIUIAutomation()->CreatePropertyCondition(UIA_NamePropertyId, varProperty, &pCondition) ;
-		if (SUCCEEDED(hr)) {
-			IUIAutomationElement *pFound ;
-
-			hr = pElement->FindFirst(TreeScope_Descendants, pCondition, &pFound) ;
-			if (SUCCEEDED(hr)) {
-				if (pFound == NULL)
-					printf("RA_FindChildByName: Element with automation name %s was not found\r\n", elementName) ;
-				//printf("RA_FindChildByName: success with value %s\r\n", elementName) ;
-				return pFound ;
-			} else {
-				printf("RA_FindChildByName: FindFirst for children looking for %s failed. hr = 0x%x\r\n", elementName, hr) ;
-				return NULL ;
-			}
-		} else {
-			printf("RA_FindChildByName: Cannot create search condition. hr = 0x%x\r\n", hr) ;
-			return NULL ;
-		}
-	}
-
 	__declspec ( dllexport ) HWND RA_CurrentNativeWindowHandle(IUIAutomationElement *pElement) {
 		UIA_HWND uia_hwnd ;
 
@@ -183,21 +155,6 @@ extern "C" {
 		return (HWND)uia_hwnd ;
 	}
 
-	__declspec ( dllexport ) int RA_GetCurrentProcessId(IUIAutomationElement *pElement) {
-		HRESULT hr;
-		int process_id;
-
-		hr = pElement->get_CurrentProcessId(&process_id);
-
-		if  (SUCCEEDED(hr)){
-			return process_id;
-		}
-		else {
-			printf("RA_GetCurrentProcessId: get_CurrentProcessId returned 0x%x\r\n", hr) ;
-			return 0 ;
-		}
-	}
-
 	__declspec ( dllexport ) BOOL RA_SetFocus(IUIAutomationElement *pElement) {
 		HRESULT hr = pElement->SetFocus() ;
 		if (hr != S_OK)
@@ -228,29 +185,6 @@ extern "C" {
 		return SetCursorPos(x,y);
 	}
 
-	__declspec ( dllexport ) long RA_GetDesktopHandle() {
-		return (long)GetDesktopWindow();
-	}
-
-	__declspec ( dllexport ) int RA_CurrentBoundingRectangle(IUIAutomationElement *pElement, long *rectangle) {
-		RECT boundary;
-
-		HRESULT hr = pElement->get_CurrentBoundingRectangle(&boundary) ;
-		if (SUCCEEDED(hr)) {
-
-			rectangle[0] = boundary.left;
-			rectangle[1] = boundary.top;
-			rectangle[2] = boundary.right;
-			rectangle[3] = boundary.bottom;
-
-			return 1;
-		}
-		else {
-			printf("RA_CurrentBoundingRectangle: get_CurrentBoundingRectangle failed 0x%x\r\n", hr) ;
-			return 0 ;
-		}
-	}
-
 	__declspec ( dllexport ) int RA_CurrentIsOffscreen(IUIAutomationElement *pElement, int *visible) {
 		BOOL offscreen;
 
@@ -311,74 +245,35 @@ extern "C" {
 		return element_count ;
 	}
 
-	__declspec ( dllexport ) int RA_GetName(IUIAutomationElement *pElement, char *pName) {
-		BSTR bstrName ;
-		HRESULT hr = pElement->get_CurrentName(&bstrName) ;
-
-		if (FAILED(hr)) {
-			printf("RA_GetName: get_CurrentName failed 0x%x\r\n", hr) ;
-			return -1 ;
-		}
-
-		char *pszName = _com_util::ConvertBSTRToString(bstrName) ;
-
-		if (pszName != NULL){
-			if (pName == NULL) {
-				return strlen(pszName) ;
-			} else {
-				strcpy(pName, pszName) ;
-				return strlen(pszName) ;
-			}
-		} else {
-			return -1;
-		}
-	}
-
-	__declspec ( dllexport ) int RA_GetClassName(IUIAutomationElement *pElement, char *pClass) {
-		BSTR bstrClass ;
-		HRESULT hr = pElement->get_CurrentClassName(&bstrClass) ;
-
-		if (FAILED(hr)) {
-			printf("RA_GetName: get_CurrentClassName failed 0x%x\r\n", hr) ;
-			return -1 ;
-		}
-
-		char *pszClass = _com_util::ConvertBSTRToString(bstrClass) ;
-
-		if (pszClass != NULL){
-			if (pClass == NULL) {
-				return strlen(pszClass) ;
-			} else {
-				strcpy(pClass, pszClass) ;
-				return strlen(pszClass) ;
-			}
-		} else {
-			return -1;
+	__declspec ( dllexport ) bool RA_GetControlName(const HWND windowHandle, char* windowName, const int windowNameLength) {
+		try {
+			auto control = gcnew AutomationControl(windowHandle);
+			StringHelper::CopyToUnmanagedString(control->Name, windowName, windowNameLength);
+			return true;
+		} catch(Exception^ e) {
+			return false;
 		}
 	}
 
-	__declspec ( dllexport ) BOOL RA_GetIsSet(IUIAutomationElement *pElement) {
-		return ToggleStateHelper().IsSet(pElement);
-	}
+  __declspec ( dllexport ) bool IsSet(const FindInformation& findInformation) {
+    try {
+      auto toggle = gcnew Toggle(findInformation);
+      return toggle->IsSet;
+    } catch(Exception^ e) {
+      Debug::WriteLine("IsSet:  {0}", e->Message);
+      return false;
+    }
+  }
 
-	__declspec ( dllexport ) BOOL RA_GetIsSelected(IUIAutomationElement *pElement) {
-		ISelectionItemProvider *pSelectionPattern ;
-		HRESULT hr = pElement->GetCurrentPattern(UIA_SelectionItemPatternId, (IUnknown**)&pSelectionPattern) ;
-
-		if (FAILED(hr)) {
-			printf("RA_GetIsSelected: getCurrentPattern failed 0x%x\r\n") ;
-			return FALSE ;
-		}
-
-		BOOL RetVal ;
-		hr = pSelectionPattern->get_IsSelected(&RetVal) ;
-		if (FAILED(hr)) {
-			printf("RA_GetIsSelected: get_IsSelected failed 0x%x\r\n", hr) ;
-			return FALSE ;
-		} else {
-			return RetVal ;
-		}
-	}
+  __declspec ( dllexport ) bool IsSelected(const FindInformation& findInformation) {
+    try {
+      auto selectionItem = gcnew SelectionItem(findInformation);
+      return selectionItem->IsSelected;
+    } catch(Exception^ e) {
+      Debug::WriteLine("IsSelected:  {0}", e->Message);
+      return false;
+    }
+  }
 
 	__declspec ( dllexport ) int RA_Select(IUIAutomationElement *pElement) {
 		ISelectionItemProvider *pSelectionPattern ;
@@ -419,114 +314,6 @@ extern "C" {
 		}
 	}
 
-	__declspec ( dllexport ) int RA_GetComboOptionsCount(const HWND windowHandle) {
-		auto autoComboBox = gcnew AutomatedComboBox(windowHandle);
-		return autoComboBox->Count;
-	}
-
-	__declspec ( dllexport ) int RA_GetSelectedComboIndex(const HWND windowHandle) {
-		auto autoComboBox = gcnew AutomatedComboBox(windowHandle);
-		return autoComboBox->SelectedIndex;
-	}
-
-	__declspec ( dllexport ) bool RA_GetComboValueByIndex(const HWND windowHandle, const int whichItem, char* comboValue, const int comboValueSize) {
-		auto autoComboBox = gcnew AutomatedComboBox(windowHandle);
-		return autoComboBox->GetValueByIndex(whichItem, comboValue, comboValueSize);
-	}
-
-	__declspec ( dllexport ) bool RA_SelectComboByIndex(const HWND windowHandle, const int whichItem) {
-		auto autoComboBox = gcnew AutomatedComboBox(windowHandle);
-		return autoComboBox->SelectByIndex(whichItem);
-	}
-
-	__declspec ( dllexport ) int RA_SelectComboByValue(IUIAutomationElement *pElement, char *pValue) {
-		UIA_HWND windowHandle = 0;
-		pElement->get_CurrentNativeWindowHandle(&windowHandle);
-
-		auto autoComboBox = gcnew AutomatedComboBox((const HWND) windowHandle);
-		return autoComboBox->SelectByValue(pValue);
-	}
-
-	__declspec ( dllexport ) void RA_SelectMenuItem(const HWND windowHandle, char* errorInfo, const int errorInfoSize, const char* arg0, ...) {
-		va_list arguments;
-		va_start(arguments, arg0);			
-
-		std::list<const char*> menuItems;
-
-		const char* lastArgument = arg0;
-		while( NULL != lastArgument ) {
-			menuItems.push_back(lastArgument);
-			lastArgument = va_arg(arguments, const char*);
-		}
-		va_end(arguments);
-
-		SelectMenuItem(windowHandle, errorInfo, errorInfoSize, menuItems);
-	}
-
-	__declspec ( dllexport ) BOOL RA_MenuItemExists(const HWND windowHandle, const char* arg0, ...) {
-		va_list arguments;
-		va_start(arguments, arg0);			
-
-		std::list<const char*> menuItems;
-
-		const char* lastArgument = arg0;
-		while( NULL != lastArgument ) {
-			menuItems.push_back(lastArgument);
-			lastArgument = va_arg(arguments, const char*);
-		}
-		va_end(arguments);
-
-		return MenuItemExists(windowHandle, menuItems);
-	}
-
-	__declspec ( dllexport ) int RA_GetDataItemCount(const HWND windowHandle) {
-		try {
-			auto tableControl = gcnew AutomatedTable(windowHandle);
-			return tableControl->RowCount;
-		} catch(Exception^ e) {
-			Console::WriteLine(e->ToString());
-		}
-	}
-
-	__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_DataItemExists(const HWND windowHandle, const int whichItemIndex, const int whichColumnIndex) {
-		try {
-			auto tableControl = gcnew AutomatedTable(windowHandle);
-			return tableControl->Exists(whichItemIndex, whichColumnIndex);
-		} catch(Exception^ e) {
-			Console::WriteLine(e->ToString());
-			return false;
-		}
-	}
-
-	__declspec ( dllexport ) void RA_CellValueAt(const HWND windowHandle, const int row, const int column, char *foundValue, const int foundValueLength) {
-		try {
-			auto tableControl = gcnew AutomatedTable(windowHandle);
-			auto rowValue = tableControl->ValueAt(row, column);
-			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);
-			tableControl->Select(dataItemIndex);
-		} catch(Exception^ e) {
-			Console::WriteLine(e->ToString());
-		}
-	}
-
 	__declspec ( dllexport ) void RA_ExpandItemByValue(const HWND windowHandle, const char* whichItem) {
 		try {
 			auto expandCollapseHelper = gcnew ExpandCollapseHelper();
@@ -563,21 +350,3 @@ extern "C" {
 		}
 	}
 }
-
-BOOL MenuItemExists(const HWND windowHandle, std::list<const char*>& menuItems)
-{
-	auto menuSelector = gcnew MenuItemSelector();
-	return menuSelector->MenuItemExists(windowHandle, menuItems);
-}
-
-void SelectMenuItem(const HWND windowHandle, char* errorInfo, const int errorInfoSize, std::list<const char*>& menuItems)
-{
-	try {
-		auto menuSelector = gcnew MenuItemSelector();
-		menuSelector->SelectMenuPath(windowHandle, menuItems);
-	} catch(Exception^ e) {
-		if( errorInfo ) {
-			StringHelper::CopyToUnmanagedString(e->ToString(), errorInfo, errorInfoSize);
-		}
-	}
-}