rautomation 0.10.0 → 0.11.0

data/ext/UiaDll/UiaDll/{AutomationFinder.h → Locator.h}

@@ -2,10 +2,12 @@
 using namespace System::Windows;
 using namespace System::Windows::Automation;
 
-ref class AutomationFinder
+ref class Locator
 {
 public:
-	AutomationFinder(AutomationElement^ automationElement);
+	static AutomationElement^ FindFor(const FindInformation& findInformation);
+
+	Locator(AutomationElement^ automationElement);
 	AutomationElement^ Find(const FindInformation& findInformation);
 	AutomationElementCollection^ Find(...array<Condition^>^ conditions);
 	AutomationElementCollection^ Find(const UIAutomation::TreeScope scope, ...array<Condition^>^ conditions);

data/ext/UiaDll/UiaDll/MenuItemSelector.cpp

@@ -16,7 +16,7 @@ BOOL MenuItemSelector::MenuItemExists(const HWND windowHandle, list<const char*>
 	try {
 		auto automationElement = AutomationElement::FromHandle(IntPtr(windowHandle));
 		return FindMenuItem(automationElement, menuItems) != nullptr;
-	} catch(Exception^ e) {
+	} catch(Exception^) {
 		return FALSE;
 	}
 }
@@ -54,7 +54,7 @@ ExpandCollapsePattern^ MenuItemSelector::AsExpandCollapse(AutomationElement^ fou
 	{
 		return dynamic_cast<ExpandCollapsePattern^>(foundMenuItem->GetCurrentPattern(ExpandCollapsePattern::Pattern));
 	}
-	catch(Exception^ e)
+	catch(Exception^)
 	{
 		return nullptr;
 	}
@@ -68,7 +68,7 @@ void MenuItemSelector::TryToExpand(ExpandCollapsePattern^ expandCollapsePattern)
 	{
 		expandCollapsePattern->Expand();
 	}
-	catch(Exception^ e)
+	catch(Exception^)
 	{
 		expandCollapsePattern->Expand();
 	}

data/ext/UiaDll/UiaDll/MenuMethods.cpp

@@ -6,6 +6,7 @@ void MenuSelectPath(const HWND windowHandle, char* errorInfo, const int errorInf
 
 extern "C" {
 
+  #pragma managed(push, off)
 	__declspec ( dllexport ) void Menu_SelectPath(const HWND windowHandle, char* errorInfo, const int errorInfoSize, const char* arg0, ...) {
 		va_list arguments;
 		va_start(arguments, arg0);			
@@ -21,7 +22,9 @@ extern "C" {
 
 		MenuSelectPath(windowHandle, errorInfo, errorInfoSize, menuItems);
 	}
+  #pragma managed(pop)
 
+  #pragma managed(push, off)
 	__declspec ( dllexport ) BOOL Menu_ItemExists(const HWND windowHandle, const char* arg0, ...) {
 		va_list arguments;
 		va_start(arguments, arg0);			
@@ -37,6 +40,7 @@ extern "C" {
 
 		return MenuItemExists(windowHandle, menuItems);
 	}
+  #pragma managed(pop)
 }
 
 BOOL MenuItemExists(const HWND windowHandle, std::list<const char*>& menuItems)

data/ext/UiaDll/UiaDll/SelectListMethods.cpp

@@ -1,42 +1,61 @@
 #include "stdafx.h"
-#include "AutomatedSelectList.h"
+#include "Locator.h"
+#include "StringHelper.h"
+
+using namespace RAutomation::UIA::Controls;
 
 extern "C" {
 
 	__declspec ( dllexport ) int SelectList_Count(const FindInformation& findInformation) {
-		auto autoSelectList = gcnew AutomatedSelectList(findInformation);
-		return autoSelectList->Count;
+		auto selectList = gcnew SelectList(Locator::FindFor(findInformation));
+		return selectList->Count;
 	}
 
-  __declspec ( dllexport ) int SelectList_Options(const FindInformation& findInformation, const char* options[]) {
-    auto selectList = gcnew AutomatedSelectList(findInformation);
-    return selectList->GetOptions(options);
-  }
+	__declspec ( dllexport ) int SelectList_Options(const FindInformation& findInformation, const char* options[]) {
+		auto selectList = gcnew SelectList(Locator::FindFor(findInformation));
+		return StringHelper::Copy(selectList->Options, options);
+	}
 
 	__declspec ( dllexport ) int SelectList_SelectedIndex(const FindInformation& findInformation) {
-		auto autoSelectList = gcnew AutomatedSelectList(findInformation);
-		return autoSelectList->SelectedIndex;
+		auto selectList = gcnew SelectList(Locator::FindFor(findInformation));
+		return selectList->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 ) void SelectList_Selection(const FindInformation& findInformation, char* selection, const int selectionLength) {
+		auto selectList = gcnew SelectList(Locator::FindFor(findInformation));
+		StringHelper::CopyToUnmanagedString(selectList->Selection, selection, selectionLength);
+	}
 
 	__declspec ( dllexport ) bool SelectList_ValueAt(const FindInformation& findInformation, const int whichItem, char* comboValue, const int comboValueSize) {
-		auto autoSelectList = gcnew AutomatedSelectList(findInformation);
-		return autoSelectList->GetValueByIndex(whichItem, comboValue, comboValueSize);
+		try {
+			auto selectList = gcnew SelectList(Locator::FindFor(findInformation));
+			StringHelper::CopyToUnmanagedString(selectList->At(whichItem), comboValue, comboValueSize);
+			return true;
+		} catch(Exception^ e) {
+			Console::WriteLine(e);
+			return false;
+		}
 	}
 
 	__declspec ( dllexport ) bool SelectList_SelectIndex(const FindInformation& findInformation, const int whichItem) {
-		auto autoSelectList = gcnew AutomatedSelectList(findInformation);
-		return autoSelectList->SelectByIndex(whichItem);
+		try {
+			auto selectList = gcnew SelectList(Locator::FindFor(findInformation));
+			selectList->SelectedIndex = whichItem;
+			return true;
+		} catch(Exception^ e) {
+			Console::WriteLine(e);
+			return false;
+		}
 	}
 
 	__declspec ( dllexport ) int SelectList_SelectValue(const FindInformation& findInformation, char *pValue) {
-		auto autoSelectList = gcnew AutomatedSelectList(findInformation);
-		return autoSelectList->SelectByValue(pValue);
+		try {
+			auto selectList = gcnew SelectList(Locator::FindFor(findInformation));
+			selectList->Selection = gcnew String(pValue);
+			return true;
+		} catch(Exception^ e) {
+			Console::WriteLine(e);
+			return false;
+		}
 	}
 }

data/ext/UiaDll/UiaDll/SpinnerMethods.cpp

@@ -0,0 +1,61 @@
+#include "stdafx.h"
+#include "Locator.h"
+#include "StringHelper.h"
+
+using namespace RAutomation::UIA::Controls;
+
+extern "C" {
+	__declspec (dllexport) double Spinner_GetValue(const FindInformation& findInformation, char* errorInfo, const int errorInfoLength) {
+		try {
+			auto spinner = gcnew Spinner(Locator::FindFor(findInformation));
+      return spinner->Value;
+		} catch(Exception^ e) {
+			StringHelper::CopyToUnmanagedString(e->Message, errorInfo, errorInfoLength);
+		}
+	}
+
+	__declspec (dllexport) void Spinner_SetValue(const FindInformation& findInformation, double theValue, char* errorInfo, const int errorInfoLength) {
+		try {
+			auto spinner = gcnew Spinner(Locator::FindFor(findInformation));
+      spinner->Value = theValue;
+		} catch(Exception^ e) {
+			StringHelper::CopyToUnmanagedString(e->Message, errorInfo, errorInfoLength);
+		}
+	}
+
+	__declspec (dllexport) double Spinner_Minimum(const FindInformation& findInformation, char* errorInfo, const int errorInfoLength) {
+		try {
+			auto spinner = gcnew Spinner(Locator::FindFor(findInformation));
+      return spinner->Minimum;
+		} catch(Exception^ e) {
+			StringHelper::CopyToUnmanagedString(e->Message, errorInfo, errorInfoLength);
+		}
+	}
+
+	__declspec (dllexport) double Spinner_Maximum(const FindInformation& findInformation, char* errorInfo, const int errorInfoLength) {
+		try {
+			auto spinner = gcnew Spinner(Locator::FindFor(findInformation));
+      return spinner->Maximum;
+		} catch(Exception^ e) {
+			StringHelper::CopyToUnmanagedString(e->Message, errorInfo, errorInfoLength);
+		}
+	}
+
+	__declspec (dllexport) double Spinner_Increment(const FindInformation& findInformation, char* errorInfo, const int errorInfoLength) {
+		try {
+			auto spinner = gcnew Spinner(Locator::FindFor(findInformation));
+      return spinner->Increment();
+		} catch(Exception^ e) {
+			StringHelper::CopyToUnmanagedString(e->Message, errorInfo, errorInfoLength);
+		}
+	}
+
+	__declspec (dllexport) double Spinner_Decrement(const FindInformation& findInformation, char* errorInfo, const int errorInfoLength) {
+		try {
+			auto spinner = gcnew Spinner(Locator::FindFor(findInformation));
+      return spinner->Decrement();
+		} catch(Exception^ e) {
+			StringHelper::CopyToUnmanagedString(e->Message, errorInfo, errorInfoLength);
+		}
+	}
+}

data/ext/UiaDll/UiaDll/StringHelper.cpp

@@ -4,7 +4,7 @@
 void StringHelper::CopyToUnmanagedString(String^ source, char* destination, const int destinationSize)
 {
 	auto unmanagedString = Marshal::StringToHGlobalAnsi(source);
-	strncpy(destination, (const char*)(void*)unmanagedString, destinationSize);
+	strncpy_s(destination, destinationSize, (const char*)(void*)unmanagedString,  _TRUNCATE);
 	Marshal::FreeHGlobal(unmanagedString);
 }
 
@@ -23,6 +23,18 @@ void StringHelper::FreeUp(const char* unmanagedStrings[], const int numberOfStri
 	}
 }
 
+int StringHelper::Copy(array<String^>^ strings, const char* unmanagedStrings[])
+{
+	if( NULL != unmanagedStrings ) {
+    auto whichItem = 0;
+    for each(String^ theString in strings) {
+      unmanagedStrings[whichItem++] = UnmanagedStringFrom(theString);
+    }
+	}
+
+	return strings->Length;
+}
+
 void StringHelper::CopyNames(AutomationElementCollection^ automationElements, const char* unmanagedStrings[])
 {
 	auto whichItem = 0;

data/ext/UiaDll/UiaDll/StringHelper.h

@@ -7,6 +7,7 @@ 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 int Copy(array<String^>^ strings, const char* unmanagedStrings[]);
 	static void CopyNames(AutomationElementCollection^ automationElements, const char* unmanagedStrings[]);
 	static void CopyClassNames(AutomationElementCollection^ automationElements, const char* unmanagedStrings[]);
 };

data/ext/UiaDll/UiaDll/TabControlMethods.cpp

@@ -1,34 +1,37 @@
 #include "stdafx.h"
-#include "AutomatedTabControl.h"
+#include "Locator.h"
+#include "StringHelper.h"
+
+using namespace RAutomation::UIA::Controls;
 
 extern "C" {
 	__declspec(dllexport) int TabControl_Items(const FindInformation& findInformation, const char* options[]) {
-		auto tabControl = gcnew AutomatedTabControl(findInformation);
-		return tabControl->GetTabItems(options);
+		auto tabControl = gcnew TabControl(Locator::FindFor(findInformation));
+		return StringHelper::Copy(tabControl->TabNames, options);
 	}
 
 	__declspec(dllexport) void TabControl_Selection(const FindInformation& findInformation, char* selection, const int selectionLength) {
-		auto tabControl = gcnew AutomatedTabControl(findInformation);
+		auto tabControl = gcnew TabControl(Locator::FindFor(findInformation));
 		StringHelper::CopyToUnmanagedString(tabControl->Selection, selection, selectionLength);
 	}
 
 	__declspec(dllexport) void TabControl_SelectByIndex(const FindInformation& findInformation, const int index, char* errorInfo, const int errorInfoLength) {
 		try {
-			auto tabControl = gcnew AutomatedTabControl(findInformation);
-			tabControl->SelectedIndex = index;
+      auto tabControl = gcnew TabControl(Locator::FindFor(findInformation));
+      return tabControl->SelectedIndex = index;
 		} catch(Exception^) {
 			_snprintf(errorInfo, errorInfoLength, "A tab with index %d was not found", index);
 		}
 	}
 
 	__declspec(dllexport) int TabControl_SelectedIndex(const FindInformation& findInformation) {
-		auto tabControl = gcnew AutomatedTabControl(findInformation);
+		auto tabControl = gcnew TabControl(Locator::FindFor(findInformation));
 		return tabControl->SelectedIndex;
 	}
 
 	__declspec(dllexport) void TabControl_SelectByValue(const FindInformation& findInformation, const char* value, char* errorInfo, const int errorInfoLength) {
 		try {
-			auto tabControl = gcnew AutomatedTabControl(findInformation);
+      auto tabControl = gcnew TabControl(Locator::FindFor(findInformation));
 			tabControl->Selection = gcnew String(value);
 		} catch(Exception^) {
 			_snprintf(errorInfo, errorInfoLength, "A tab with the value %s was not found", value);

data/ext/UiaDll/UiaDll/TableMethods.cpp

@@ -1,35 +1,34 @@
 #include "stdafx.h"
-#include "AutomatedTable.h"
+#include "Locator.h"
+#include "StringHelper.h"
+
+using namespace RAutomation::UIA::Controls;
 
 extern "C" {
 
 	__declspec ( dllexport ) int Table_GetHeaders(const FindInformation& findInformation, const char* headers[]) {
-		auto tableControl = gcnew AutomatedTable(findInformation);
-		return tableControl->GetHeaders(headers);
+		auto tableControl = gcnew TableControl(Locator::FindFor(findInformation));
+		return StringHelper::Copy(tableControl->Headers, headers);
 	}
 
 	__declspec ( dllexport ) int Table_GetValues(const FindInformation& findInformation, const char* values[]) {
-		auto tableControl = gcnew AutomatedTable(findInformation);
-		return tableControl->GetValues(values);
+		auto tableControl = gcnew TableControl(Locator::FindFor(findInformation));
+		return StringHelper::Copy(tableControl->Values, 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 FindInformation& findInformation) {
 		try {
-			auto tableControl = gcnew AutomatedTable(findInformation);
+			auto tableControl = gcnew TableControl(Locator::FindFor(findInformation));
 			return tableControl->RowCount;
 		} catch(Exception^ e) {
 			Console::WriteLine(e->ToString());
+      return 0;
 		}
 	}
 
 	__declspec ( dllexport ) bool Table_CoordinateIsValid(const FindInformation& findInformation, const int whichItemIndex, const int whichColumnIndex) {
 		try {
-			auto tableControl = gcnew AutomatedTable(findInformation);
+			auto tableControl = gcnew TableControl(Locator::FindFor(findInformation));
 			return tableControl->Exists(whichItemIndex, whichColumnIndex);
 		} catch(Exception^ e) {
 			Console::WriteLine(e->ToString());
@@ -39,9 +38,8 @@ extern "C" {
 
 	__declspec ( dllexport ) void Table_ValueAt(const FindInformation& findInformation, const int row, const int column, char *foundValue, const int foundValueLength) {
 		try {
-			auto tableControl = gcnew AutomatedTable(findInformation);
-			auto rowValue = tableControl->ValueAt(row, column);
-			StringHelper::CopyToUnmanagedString(rowValue, foundValue, foundValueLength);
+			auto tableControl = gcnew TableControl(Locator::FindFor(findInformation));
+			StringHelper::CopyToUnmanagedString(tableControl->ValueAt(row, column), foundValue, foundValueLength);
 		} catch(Exception^ e) {
 			Console::WriteLine(e->ToString());
 		}
@@ -49,8 +47,8 @@ extern "C" {
 
 	__declspec ( dllexport ) void Table_SelectByIndex(const FindInformation& findInformation, const int dataItemIndex) {
 		try {
-			auto tableControl = gcnew AutomatedTable(findInformation);
-			tableControl->Select(dataItemIndex);
+			auto tableControl = gcnew TableControl(Locator::FindFor(findInformation));
+			tableControl->SelectedIndex = dataItemIndex;
 		} catch(Exception^ e) {
 			Console::WriteLine(e->ToString());
 		}
@@ -58,17 +56,18 @@ extern "C" {
 
 	__declspec ( dllexport ) bool Table_IsSelectedByIndex(const FindInformation& findInformation, const int dataItemIndex) {
 		try {
-			auto tableControl = gcnew AutomatedTable(findInformation);
-			return tableControl->IsSelected(dataItemIndex);
+			auto tableControl = gcnew TableControl(Locator::FindFor(findInformation));
+			return tableControl->SelectedIndex == dataItemIndex;
 		} catch(Exception^ e) {
 			Console::WriteLine(e->ToString());
+      return false;
 		}
 	}
 
 	__declspec ( dllexport ) void Table_SelectByValue(const FindInformation& findInformation, const char* dataItemValue) {
 		try {
-			auto tableControl = gcnew AutomatedTable(findInformation);
-			tableControl->Select(dataItemValue);
+			auto tableControl = gcnew TableControl(Locator::FindFor(findInformation));
+			tableControl->Value = gcnew String(dataItemValue);
 		} catch(Exception^ e) {
 			Console::WriteLine(e->ToString());
 		}

data/ext/UiaDll/UiaDll/TextMethods.cpp

@@ -1,23 +1,25 @@
 #include "stdafx.h"
-#include "AutomatedText.h"
+#include "Locator.h"
 #include "StringHelper.h"
 
+using namespace RAutomation::UIA::Controls;
+
 extern "C" {
-  __declspec ( dllexport ) void Text_GetValue(const FindInformation& findInformation, char* theValue, const int maximumLength) {
-    try {
-      auto control = gcnew AutomatedText(findInformation);
-      StringHelper::CopyToUnmanagedString(control->Text, theValue, maximumLength);
-    } catch(Exception^ e) {
-      Console::WriteLine("Text_GetValue:  {0}", e->Message);
-    }
-  }
+	__declspec ( dllexport ) void Text_GetValue(const FindInformation& findInformation, char* theValue, const int maximumLength) {
+		try {
+			auto text =  gcnew TextControl(Locator::FindFor(findInformation));
+			StringHelper::CopyToUnmanagedString(text->Value, theValue, maximumLength);
+		} catch(Exception^ e) {
+			Console::WriteLine("Text_GetValue:  {0}", e->Message);
+		}
+	}
 
-  __declspec ( dllexport ) void Text_SetValue(const FindInformation& findInformation, const char* theValue) {
-    try {
-      auto control = gcnew AutomatedText(findInformation);
-      control->Text = gcnew String(theValue);
-    } catch(Exception^ e) {
-      Console::WriteLine("Text_SetValue:  {0}", e->Message);
-    }
-  }
+	__declspec ( dllexport ) void Text_SetValue(const FindInformation& findInformation, const char* theValue) {
+		try {
+			auto text =  gcnew TextControl(Locator::FindFor(findInformation));
+			text->Value = gcnew String(theValue);
+		} catch(Exception^ e) {
+			Console::WriteLine("Text_SetValue:  {0}", e->Message);
+		}
+	}
 }

data/ext/UiaDll/UiaDll/UiaDll.cpp

@@ -1,350 +1,199 @@
-// UiaDll.cpp : Defines the exported functions for the DLL application.
-//
-
 #include "stdafx.h"
-#include "AutomationClicker.h"
-#include "AutomationControl.h"
-#include "AutomationFinder.h"
-#include "ExpandCollapseHelper.h"
+#include "Locator.h"
+#include "DynamicAssemblyResolver.h"
 #include "StringHelper.h"
-#include "SelectionItem.h"
-#include "Toggle.h"
-
-IUIAutomation* getGlobalIUIAutomation() ;
-
-extern "C" {
-
-  __declspec ( dllexport ) bool ElementExists(const FindInformation& findInformation) {
-    auto automationElement = gcnew AutomationControl(findInformation);
-    return automationElement->Exists;
-  }
-
-  __declspec ( dllexport ) int NativeWindowHandle(const FindInformation& findInformation) { 
-    auto automationElement = gcnew AutomationControl(findInformation);
-    return automationElement->Exists ? automationElement->Element->Current.NativeWindowHandle : 0;
-  }
-
-  __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);
-    }
-  }
-
-  __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);
-    }
-  }
-
-  __declspec ( dllexport ) bool IsEnabled(const FindInformation& findInformation) {
-    try {
-      return (gcnew AutomationControl(findInformation))->IsEnabled;
-    } catch(Exception^ e) {
-      Console::WriteLine("IsEnabled:  {0}", e->Message);
-      return false;
-    }
-  }
-
-  __declspec ( dllexport ) bool IsFocused(const FindInformation& findInformation) {
-    try {
-      return (gcnew AutomationControl(findInformation))->IsFocused;
-    } catch(Exception^ e) {
-      Console::WriteLine("IsFocused:  {0}", e->Message);
-      return false;
-    }
-  }
-
-  __declspec ( dllexport ) bool SetControlFocus(const FindInformation& findInformation) {
-    try {
-      (gcnew AutomationControl(findInformation))->Element->SetFocus();
-      return true;
-    } catch(Exception^ e) {
-      Console::WriteLine("IsFocused:  {0}", e->Message);
-      return false;
-    }
-  }
-
-  __declspec ( dllexport ) int GetClassNames(const FindInformation& findInformation, const char* classNames[]) {
-    auto control = gcnew AutomationControl(findInformation);
-    auto finder = gcnew AutomationFinder(control->Element);
-
-    auto allChildren = finder->Find();
-
-    if( NULL != classNames ) {
-      StringHelper::CopyClassNames(allChildren, classNames);
-    }
-
-    return allChildren->Count;
-  }
-
-  __declspec ( dllexport ) IUIAutomationElement *RA_ElementFromHandle(HWND hwnd) {
-    IUIAutomationElement *pElement ;
-
-    HRESULT hr = getGlobalIUIAutomation()->ElementFromHandle(hwnd, &pElement) ;
-    if (SUCCEEDED(hr))
-      return pElement ;
-    else {
-      printf("RA_ElementFromHandle: Cannot find element from handle 0x%x. HRESULT was 0x%x\r\n", hwnd, hr) ;
-      return NULL ;
-    }
-  }
-
-  __declspec ( dllexport ) IUIAutomationElement *RA_ElementFromPoint(int xCoord, int yCoord) {
-    IUIAutomationElement *pElement ;
-    POINT point;
-
-    point.x = xCoord;
-    point.y = yCoord;
-
-    HRESULT hr = getGlobalIUIAutomation()->ElementFromPoint(point, &pElement) ;
-    if (SUCCEEDED(hr))
-      return pElement ;
-    else {
-      printf("RA_ElementFromPoint: Cannot find element from point %d , %d. HRESULT was 0x%x\r\n", xCoord, yCoord, hr) ;
-      return NULL ;
-    }
-  }
 
-  __declspec ( dllexport ) HWND RA_CurrentNativeWindowHandle(IUIAutomationElement *pElement) {
-    UIA_HWND uia_hwnd ;
+using namespace RAutomation::UIA;
+using namespace RAutomation::UIA::Controls;
+using namespace RAutomation::UIA::Extensions;
 
-    if (pElement == NULL) {
-      printf("RA_CurrentNativeWindowHandle: Cannot operate on NULL element\r\n") ;
-      return (HWND)0 ;
-    }
+using namespace System::Diagnostics;
 
-    pElement->get_CurrentNativeWindowHandle(&uia_hwnd) ;
-    return (HWND)uia_hwnd ;
-  }
-
-  __declspec ( dllexport ) int RA_GetCurrentControlType(IUIAutomationElement *pElement) {
-    CONTROLTYPEID control_type ;
-
-    HRESULT hr = pElement->get_CurrentControlType(&control_type) ;
-    if (SUCCEEDED(hr))
-      return control_type ;
-    else {
-      printf("RA_GetCurrentControlType: CurrentControlType returned 0x%x\r\n", hr) ;
-      return 0 ;
-    }
-  }
-
-  __declspec ( dllexport ) long RA_ClickMouse() {
-    mouse_event(MOUSEEVENTF_LEFTDOWN, 0, 0, 0, 0);
-    mouse_event(MOUSEEVENTF_LEFTUP, 0, 0, 0, 0);
-    return 0;
-  }
-
-  __declspec ( dllexport ) long RA_MoveMouse(int x, int y) {
-    return SetCursorPos(x,y);
-  }
-
-  __declspec ( dllexport ) int RA_CurrentIsOffscreen(IUIAutomationElement *pElement, int *visible) {
-    BOOL offscreen;
-
-    HRESULT hr = pElement->get_CurrentIsOffscreen(&offscreen) ;
-    if (SUCCEEDED(hr)) {
-      if(offscreen){
-        *visible = 1;
-      }
-      else
-      {
-        *visible = 0;
-      }
-      return 1;
-    }
-    else {
-      printf("RA_CurrentIsOffscreen: get_CurrentIsOffscreen failed 0x%x\r\n", hr) ;
-      return 0 ;
-    }
-  }
-
-  __declspec ( dllexport ) int RA_FindChildren(IUIAutomationElement *pElement, IUIAutomationElement *pChildren[]) {
-    IUIAutomationCondition *pTrueCondition ;
-    IUIAutomationElementArray *pElementArray ;
-    int element_count ;
-
-    HRESULT hr = getGlobalIUIAutomation()->CreateTrueCondition(&pTrueCondition) ;
-    if (FAILED(hr)) {
-      printf("RA_FindChildren: Could not create true condition 0x%x\r\n", hr) ;
-      return 0 ;
-    }
-
-    hr = pElement->FindAll(TreeScope_Children, pTrueCondition, &pElementArray) ;
-    if (FAILED(hr)) {
-      printf("RA_FindChildren: FindAll failed 0x%x\r\n", hr) ;
-      return 0 ;
-    }
-
-    hr = pElementArray->get_Length(&element_count) ;
-    if (FAILED(hr)) {
-      printf("RA_FindChildren: get_length failed 0x%x\r\n", hr) ;
-      return 0 ;
-    }
-
-    if (pChildren != NULL) {
-      // given some memory get the details
-      for (int index = 0; index < element_count; index++) {
-        IUIAutomationElement *pElement ;
-
-        hr = pElementArray->GetElement(index, &pElement) ;
-        if (FAILED(hr)) {
-          printf("RA_FindChildren: GetElement failed 0x%x\r\n", hr) ;
-        } else {
-          pChildren[index] = pElement ;
-        }
-      }
-    }
-
-    return element_count ;
-  }
-
-  __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 IsSet(const FindInformation& findInformation) {
-    try {
-      auto toggle = gcnew Toggle(findInformation);
-      return toggle->IsSet;
-    } catch(Exception^ e) {
-      Debug::WriteLine("IsSet:  {0}", e->Message);
-      return false;
-    }
-  }
+extern "C" {
+	__declspec(dllexport) void initialize(char* privateAssemblyDirectory) {
+		DynamicAssemblyResolver::PrivatePath = gcnew String(privateAssemblyDirectory);
+	}
+
+	__declspec ( dllexport ) bool ElementExists(const FindInformation& findInformation) {
+    return Element::Exists(Locator::FindFor(findInformation));
+	}
+
+	__declspec ( dllexport ) int NativeWindowHandle(const FindInformation& findInformation) { 
+    return Element::NativeWindowHandle(Locator::FindFor(findInformation));
+	}
+
+	__declspec ( dllexport ) int HandleFromPoint(int xCoord, int yCoord) {
+		auto element = AutomationElement::FromPoint(Point((double)xCoord, (double)yCoord));
+		return Element::NativeWindowHandle(element);
+	}
+
+	__declspec ( dllexport ) int BoundingRectangle(const FindInformation& findInformation, long *rectangle) {
+		try {
+			auto boundary = Element::BoundingRectangle(Locator::FindFor(findInformation));
+
+			rectangle[0] = (long)boundary.Left;
+			rectangle[1] = (long)boundary.Top;
+			rectangle[2] = (long)boundary.Right;
+			rectangle[3] = (long)boundary.Bottom;
+			return 1;
+		}
+		catch(Exception^ e) {
+			Console::WriteLine("BoundingRectangle:  {0}", e->Message);
+			return 0;
+		}
+	}
+
+	__declspec ( dllexport ) bool IsOffscreen(const FindInformation& findInformation) {
+		return Element::IsOffscreen(Locator::FindFor(findInformation));
+	}
+
+	__declspec ( dllexport ) int ControlType(const FindInformation& findInformation) {
+		try {
+      return Element::ControlType(Locator::FindFor(findInformation))->Id;
+		} catch(Exception^ e) {
+			Console::WriteLine("ControlType:  {0}", e->Message);
+			return 0;
+		}
+	}
+
+	__declspec ( dllexport ) int ProcessId(const FindInformation& findInformation) {
+		try {
+      return Element::ProcessId(Locator::FindFor(findInformation));
+		} 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 currentName = Element::Name(Locator::FindFor(findInformation));
+	  StringHelper::CopyToUnmanagedString(currentName, name, nameLength);
+		} catch(Exception^ e) {
+			Console::WriteLine("Name:  {0}", e->Message);
+		}
+	}
+
+	__declspec ( dllexport ) void ClassName(const FindInformation& findInformation, char* className, const int classNameLength) {
+		try {
+      auto currentClassName = Element::ClassName(Locator::FindFor(findInformation));
+			StringHelper::CopyToUnmanagedString(currentClassName, className, classNameLength);
+		} catch(Exception^ e) {
+			Console::WriteLine("ClassName:  {0}", e->Message);
+		}
+	}
+
+	__declspec ( dllexport ) bool IsEnabled(const FindInformation& findInformation) {
+		try {
+			return Element::IsEnabled(Locator::FindFor(findInformation));
+		} catch(Exception^ e) {
+			Console::WriteLine("IsEnabled:  {0}", e->Message);
+			return false;
+		}
+	}
+
+	__declspec ( dllexport ) bool IsFocused(const FindInformation& findInformation) {
+		try {
+			return Element::IsFocused(Locator::FindFor(findInformation));
+		} catch(Exception^ e) {
+			Console::WriteLine("IsFocused:  {0}", e->Message);
+			return false;
+		}
+	}
+
+	__declspec ( dllexport ) bool SetControlFocus(const FindInformation& findInformation) {
+		try {
+			Locator::FindFor(findInformation)->SetFocus();
+			return true;
+		} catch(Exception^ e) {
+			Console::WriteLine("IsFocused:  {0}", e->Message);
+			return false;
+		}
+	}
+
+	__declspec ( dllexport ) int GetClassNames(const FindInformation& findInformation, const char* classNames[]) {
+		auto allChildren = Locator::FindFor(findInformation)->FindAll(System::Windows::Automation::TreeScope::Subtree, Condition::TrueCondition);
+
+		if( NULL != classNames ) {
+			StringHelper::CopyClassNames(allChildren, classNames);
+		}
+
+		return allChildren->Count;
+	}
+
+	__declspec ( dllexport ) long ClickMouse() {
+		mouse_event(MOUSEEVENTF_LEFTDOWN, 0, 0, 0, 0);
+		mouse_event(MOUSEEVENTF_LEFTUP, 0, 0, 0, 0);
+		return 0;
+	}
+
+	__declspec ( dllexport ) long MoveMouse(int x, int y) {
+		return SetCursorPos(x,y);
+	}
+
+	__declspec ( dllexport ) bool IsSet(const FindInformation& findInformation) {
+		try {
+			return Element::IsToggled(Locator::FindFor(findInformation));
+		} catch(Exception^ e) {
+			Debug::WriteLine("IsSet:  {0}", e->Message);
+			return false;
+		}
+	}
+
+	__declspec ( dllexport ) bool IsSelected(const FindInformation& findInformation) {
+		try {
+			return Element::IsSelected(Locator::FindFor(findInformation));
+		} catch(Exception^ e) {
+			Debug::WriteLine("IsSelected:  {0}", e->Message);
+			return false;
+		}
+	}
+
+	__declspec ( dllexport ) bool Click(const FindInformation& findInformation, char* errorInfo, const int errorInfoSize) {
+		try {
+			return Clicker::Click(Locator::FindFor(findInformation));
+		} catch(Exception^ e) {
+			if( errorInfo ) {
+				StringHelper::CopyToUnmanagedString(e->ToString(), errorInfo, errorInfoSize);
+			}
 
-  __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 ;
-    HRESULT hr = pElement->GetCurrentPattern(UIA_SelectionItemPatternId, (IUnknown**)&pSelectionPattern) ;
-    if (FAILED(hr)) {
-      printf("RA_GetIsSelected: getCurrentPattern failed 0x%x\r\n") ;
-      return FALSE ;
-    }
-
-    hr = pSelectionPattern->Select();
-    if (FAILED(hr)) {
-      printf("RA_Select: Select failed 0x%x\r\n", hr) ;
-      return 0 ;
-    }
-
-    return 1;
-  }
-
-  __declspec ( dllexport ) bool RA_Click(const FindInformation& findInformation, char* errorInfo, const int errorInfoSize) {
-    try {
-      auto automationClicker = gcnew AutomationClicker(findInformation);
-      return automationClicker->Click();
-    } catch(Exception^ e) {
-      if( errorInfo ) {
-        StringHelper::CopyToUnmanagedString(e->ToString(), errorInfo, errorInfoSize);
-        return false;
-      }
-    }
-  }
-
-  __declspec ( dllexport ) void RA_PointAndClick(const HWND windowHandle, char* errorInfo, const int errorInfoSize) {
-    try {
-      auto automationClicker = gcnew AutomationClicker(windowHandle);
-      automationClicker->MouseClick();
-    } catch(Exception^ e) {
-      if( errorInfo ) {
-        StringHelper::CopyToUnmanagedString(e->ToString(), errorInfo, errorInfoSize);
-      }
-    }
-  }
-
-  __declspec ( dllexport ) void RA_ExpandItemByValue(const FindInformation& findInformation, const char* whichItem) {
-    try {
-      auto expandCollapseHelper = gcnew ExpandCollapseHelper();
-      expandCollapseHelper->ExpandByValue(findInformation, whichItem);
-    } catch(Exception^ e) {
-      Console::WriteLine(e->ToString());
-    }
-  }
-
-  __declspec ( dllexport ) void RA_ExpandItemByIndex(const FindInformation& findInformation, const int whichItemIndex) {
-    try {
-      auto expandCollapseHelper = gcnew ExpandCollapseHelper();
-      expandCollapseHelper->ExpandByIndex(findInformation, whichItemIndex);
-    } catch(Exception^ e) {
-      Console::WriteLine(e->ToString());
-    }
-  }
-
-  __declspec ( dllexport ) void RA_CollapseItemByValue(const FindInformation& findInformation, const char* whichItem) {
-    try {
-      auto expandCollapseHelper = gcnew ExpandCollapseHelper();
-      expandCollapseHelper->CollapseByValue(findInformation, whichItem);
-    } catch(Exception^ e) {
-      Console::WriteLine(e->ToString());
-    }
-  }
-
-  __declspec ( dllexport ) void RA_CollapseItemByIndex(const FindInformation& findInformation, const int whichItemIndex) {
-    try {
-      auto expandCollapseHelper = gcnew ExpandCollapseHelper();
-      expandCollapseHelper->CollapseByIndex(findInformation, whichItemIndex);
-    } catch(Exception^ e) {
-      Console::WriteLine(e->ToString());
-    }
-  }
+		}
+	}
+
+	__declspec ( dllexport ) void ExpandItemByValue(const FindInformation& findInformation, const char* whichItem) {
+		try {
+			auto expander = gcnew Expander(Locator::FindFor(findInformation));
+      expander->Expand(gcnew String(whichItem));
+		} catch(Exception^ e) {
+			Console::WriteLine(e->ToString());
+		}
+	}
+
+	__declspec ( dllexport ) void ExpandItemByIndex(const FindInformation& findInformation, const int whichItemIndex) {
+		try {
+			auto expander = gcnew Expander(Locator::FindFor(findInformation));
+			expander->Expand(whichItemIndex);
+		} catch(Exception^ e) {
+			Console::WriteLine(e->ToString());
+		}
+	}
+
+	__declspec ( dllexport ) void CollapseItemByValue(const FindInformation& findInformation, const char* whichItem) {
+		try {
+			auto collapser = gcnew Collapser(Locator::FindFor(findInformation));
+			collapser->Collapse(gcnew String(whichItem));
+		} catch(Exception^ e) {
+			Console::WriteLine(e->ToString());
+		}
+	}
+
+	__declspec ( dllexport ) void CollapseItemByIndex(const FindInformation& findInformation, const int whichItemIndex) {
+		try {
+			auto collapser = gcnew Collapser(Locator::FindFor(findInformation));
+			collapser->Collapse(whichItemIndex);
+		} catch(Exception^ e) {
+			Console::WriteLine(e->ToString());
+		}
+	}
 }