rautomation 2.0.1-x64-mingw32

data/ext/UiaDll/UiaDll/ReadMe.txt

@@ -0,0 +1,38 @@
+========================================================================
+    DYNAMIC LINK LIBRARY : UiaDll Project Overview
+========================================================================
+
+AppWizard has created this UiaDll DLL for you.  
+
+This file contains a summary of what you will find in each of the files that
+make up your UiaDll application.
+
+UiaDll.vcxproj
+    This is the main project file for VC++ projects generated using an Application Wizard. 
+    It contains information about the version of Visual C++ that generated the file, and 
+    information about the platforms, configurations, and project features selected with the
+    Application Wizard.
+
+UiaDll.vcxproj.filters
+    This is the filters file for VC++ projects generated using an Application Wizard. 
+    It contains information about the association between the files in your project 
+    and the filters. This association is used in the IDE to show grouping of files with
+    similar extensions under a specific node (for e.g. ".cpp" files are associated with the
+    "Source Files" filter).
+
+UiaDll.cpp
+    This is the main DLL source file.
+
+UiaDll.h
+    This file contains a class declaration.
+
+AssemblyInfo.cpp
+	Contains custom attributes for modifying assembly metadata.
+
+/////////////////////////////////////////////////////////////////////////////
+Other notes:
+
+AppWizard uses "TODO:" to indicate parts of the source code you
+should add to or customize.
+
+/////////////////////////////////////////////////////////////////////////////

data/ext/UiaDll/UiaDll/SelectListMethods.cpp

@@ -0,0 +1,84 @@
+#include "stdafx.h"
+#include "Locator.h"
+#include "StringHelper.h"
+
+using namespace RAutomation::UIA::Controls;
+
+extern "C" {
+
+	__declspec ( dllexport ) int SelectList_Count(const FindInformation& findInformation) {
+		auto selectList = gcnew SelectList(Locator::FindFor(findInformation));
+		return selectList->Count;
+	}
+
+	__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 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 SelectList(Locator::FindFor(findInformation));
+		StringHelper::CopyToUnmanagedString(selectList->Selection, selection, selectionLength);
+	}
+
+  __declspec ( dllexport ) int SelectList_Selections(const FindInformation& findInformation, const char* selections[]) {
+		auto selectList = gcnew SelectList(Locator::FindFor(findInformation));
+    return StringHelper::Copy(selectList->Selections, selections);
+  }
+
+	__declspec ( dllexport ) bool SelectList_ValueAt(const FindInformation& findInformation, const int whichItem, char* comboValue, const int 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 ) void SelectList_RemoveIndex(const FindInformation& findInformation, const int whichItem, char* errorInfo, const int errorInfoLength) {
+    try {
+      auto selectList = gcnew SelectList(Locator::FindFor(findInformation));
+      selectList->Remove(whichItem);
+    } catch(Exception^ e) {
+        StringHelper::Write(e, errorInfo, errorInfoLength);
+    }
+  }
+
+  __declspec ( dllexport ) void SelectList_RemoveValue(const FindInformation& findInformation, const char* whichItem, char* errorInfo, const int errorInfoLength) {
+    try {
+      auto selectList = gcnew SelectList(Locator::FindFor(findInformation));
+      selectList->Remove(gcnew String(whichItem));
+    } catch(Exception^ e) {
+        StringHelper::Write(e, errorInfo, errorInfoLength);
+    }
+  }
+
+	__declspec ( dllexport ) bool SelectList_SelectIndex(const FindInformation& findInformation, const int 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) {
+		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

@@ -0,0 +1,57 @@
+#include "StdAfx.h"
+#include "StringHelper.h"
+
+void StringHelper::CopyToUnmanagedString(String^ source, char* destination, const int destinationSize)
+{
+	auto unmanagedString = Marshal::StringToHGlobalAnsi(source);
+	strncpy_s(destination, destinationSize, (const char*)(void*)unmanagedString,  _TRUNCATE);
+	Marshal::FreeHGlobal(unmanagedString);
+}
+
+void StringHelper::Write(Exception^ error, char* destination, const int destinationSize)
+{
+    StringHelper::CopyToUnmanagedString(error->Message, destination, destinationSize);
+}
+
+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];
+	}
+}
+
+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;
+	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

@@ -0,0 +1,15 @@
+#pragma once
+using namespace System::Windows::Automation;
+
+ref class StringHelper
+{
+public:
+	static void CopyToUnmanagedString(String^ source, char* destination, const int destinationSize);
+  static void StringHelper::Write(Exception^ error, 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/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/TabControlMethods.cpp

@@ -0,0 +1,40 @@
+#include "stdafx.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 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 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 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 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 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

@@ -0,0 +1,108 @@
+#include "stdafx.h"
+#include "Locator.h"
+#include "ArrayHelper.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 TableControl(Locator::FindFor(findInformation));
+    return StringHelper::Copy(tableControl->Headers, headers);
+  }
+
+  __declspec ( dllexport ) int Table_GetValues(const FindInformation& findInformation, const char* values[]) {
+    auto tableControl = gcnew TableControl(Locator::FindFor(findInformation));
+    return StringHelper::Copy(tableControl->Values, values);
+  }
+
+  __declspec ( dllexport ) int Table_GetSelectedIndexes(const FindInformation& findInformation, int selectedIndexes[]) {
+    auto tableControl = gcnew TableControl(Locator::FindFor(findInformation));
+    return ArrayHelper::Copy(tableControl->SelectedIndexes, selectedIndexes);
+  }
+
+  __declspec ( dllexport ) int Table_RowCount(const FindInformation& findInformation) {
+    try {
+      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 TableControl(Locator::FindFor(findInformation));
+      return tableControl->Exists(whichItemIndex, whichColumnIndex);
+    } catch(Exception^ e) {
+      Console::WriteLine(e->ToString());
+      return false;
+    }
+  }
+
+  __declspec ( dllexport ) void Table_ValueAt(const FindInformation& findInformation, const int row, const int column, char *foundValue, const int foundValueLength) {
+    try {
+      auto tableControl = gcnew TableControl(Locator::FindFor(findInformation));
+      StringHelper::CopyToUnmanagedString(tableControl->ValueAt(row, column), foundValue, foundValueLength);
+    } catch(Exception^ e) {
+      Console::WriteLine(e->ToString());
+    }
+  }
+
+  __declspec ( dllexport ) void Table_SelectByIndex(const FindInformation& findInformation, const int dataItemIndex, char* errorInfo, const int errorInfoLength) {
+    try {
+      auto tableControl = gcnew TableControl(Locator::FindFor(findInformation));
+      tableControl->SelectedIndex = dataItemIndex;
+    } catch(Exception^ e) {
+      StringHelper::Write(e, errorInfo, errorInfoLength);
+    }
+  }
+
+  __declspec ( dllexport ) void Table_SingleSelectByIndex(const FindInformation& findInformation, const int dataItemIndex, char* errorInfo, const int errorInfoLength) {
+    try {
+      auto tableControl = gcnew TableControl(Locator::FindFor(findInformation));
+      tableControl->SingleSelect(dataItemIndex);
+    } catch(Exception^ e) {
+      StringHelper::Write(e, errorInfo, errorInfoLength);
+    }
+  }
+
+  __declspec ( dllexport ) void Table_RemoveRowByIndex(const FindInformation& findInformation, const int dataItemIndex, char* errorInfo, const int errorInfoLength) {
+    try {
+      auto tableControl = gcnew TableControl(Locator::FindFor(findInformation));
+      tableControl->Remove(dataItemIndex);
+    } catch(Exception^ e) {
+      StringHelper::Write(e, errorInfo, errorInfoLength);
+    }
+  }
+
+  __declspec ( dllexport ) void Table_RemoveRowByValue(const FindInformation& findInformation, const char* dataItemValue, char* errorInfo, const int errorInfoLength) {
+    try {
+      auto tableControl = gcnew TableControl(Locator::FindFor(findInformation));
+      tableControl->Remove(gcnew String(dataItemValue));
+    } catch(Exception^ e) {
+      StringHelper::Write(e, errorInfo, errorInfoLength);
+    }
+  }
+
+  __declspec ( dllexport ) bool Table_IsSelectedByIndex(const FindInformation& findInformation, const int dataItemIndex) {
+    try {
+      auto tableControl = gcnew TableControl(Locator::FindFor(findInformation));
+      return tableControl->IsRowSelected(dataItemIndex);
+    } catch(Exception^ e) {
+      Console::WriteLine(e->ToString());
+      return false;
+    }
+  }
+
+  __declspec ( dllexport ) void Table_SelectByValue(const FindInformation& findInformation, const char* dataItemValue, char* errorInfo, const int errorInfoLength) {
+    try {
+      auto tableControl = gcnew TableControl(Locator::FindFor(findInformation));
+      tableControl->Value = gcnew String(dataItemValue);
+    } catch(Exception^ e) {
+      StringHelper::Write(e, errorInfo, errorInfoLength);
+    }
+  }
+}

data/ext/UiaDll/UiaDll/TextMethods.cpp

@@ -0,0 +1,25 @@
+#include "stdafx.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 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 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/ToggleStateHelper.h

@@ -0,0 +1,10 @@
+#pragma once
+class ToggleStateHelper
+{
+public:
+	ToggleStateHelper(void);
+	~ToggleStateHelper(void);
+
+	BOOL IsSet(IUIAutomationElement* automationElement);
+};
+

data/ext/UiaDll/UiaDll/UiaDll.cpp

@@ -0,0 +1,216 @@
+#include "stdafx.h"
+#include "Locator.h"
+#include "DynamicAssemblyResolver.h"
+#include "StringHelper.h"
+
+using namespace RAutomation::UIA;
+using namespace RAutomation::UIA::Controls;
+using namespace RAutomation::UIA::Extensions;
+
+using namespace System::Diagnostics;
+
+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) void SendKeys(const FindInformation& findInformation, const char* keysToSend, char* errorInfo, const long errorInfoLength) {
+        try {
+            Element::SendKeys(Locator::FindFor(findInformation), gcnew String(keysToSend));
+        } catch(Exception^ e) {
+            StringHelper::CopyToUnmanagedString(e->Message, errorInfo, errorInfoLength);
+        }
+    }
+
+	__declspec ( dllexport ) void HelpText(const FindInformation& findInformation, char* helpText, const int helpTextLength) {
+		try {
+			auto helpTextProperty = Element::HelpText(Locator::FindFor(findInformation));
+			StringHelper::CopyToUnmanagedString(helpTextProperty, helpText, helpTextLength);
+		} catch(Exception^ e) {
+			Console::WriteLine("HelpText: {0}", e->Message);
+		}
+	}
+
+	__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);
+			}
+
+      return false;
+		}
+	}
+
+	__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());
+		}
+	}
+}

data/ext/UiaDll/UiaDll/UiaDll.h

@@ -0,0 +1,13 @@
+// UiaDll.h
+
+#pragma once
+
+using namespace System;
+
+namespace UiaDll {
+
+	public ref class Class1
+	{
+		// TODO: Add your methods for this class here.
+	};
+}