rautomation 0.7.3 → 0.8.0

data/.gitignore

@@ -14,21 +14,22 @@ tmtags
 *.swp
 
 ## PROJECT::GENERAL
-coverage
-rdoc
-pkg
+/coverage
+/rdoc
+/pkg
 
 ## PROJECT::SPECIFIC
-.idea/*
+/.idea/*
 
-.yardoc/
-doc/
+/.yardoc/
+/doc/
 
 ## VisualStudio
 Debug
 Release
 ipch
 *.sdf
+*.suo
 *.user
-!ext/IAccessibleDLL/Release/*.dll
-
+*.opensdf
+_ReSharper*/

data/Gemfile.lock

@@ -1,14 +1,14 @@
 PATH
   remote: .
   specs:
-    rautomation (0.7.2)
+    rautomation (0.7.3)
       ffi
 
 GEM
   remote: http://rubygems.org/
   specs:
     diff-lcs (1.1.3)
-    ffi (1.0.11)
+    ffi (1.1.5-x86-mingw32)
     rake (0.9.2.2)
     rspec (2.8.0)
       rspec-core (~> 2.8.0)

data/History.rdoc

@@ -1,3 +1,16 @@
+== 0.8.0 / 2012-12-26
+
+=== MsUia adapter
+
+  * Add Control#collapse for collapsing values in collapsable items.
+  * Add Control#expand for expanding values in expandable items.
+  * Add Row#cell(s).
+  * Add Table#cell(s).
+  * Add Table#row(s).
+  * Add Window#menu for selecting menu items.
+  * Fire change events when SelectList selections have been changed.
+  * Window#child instantiates MsUia adapter Window.
+
 == 0.7.3 / 2012-10-31
 
 === Win32 adapter

data/README.rdoc

@@ -96,8 +96,9 @@ In case of any problems, feel free to contact me.
 
 == Contributors
 
-* Stephan Schwab - http://github.com/snscaimito
-* Eric Kessler - http://github.com/enkessler
+* Levi Wilson - https://github.com/leviwilson
+* Eric Kessler - https://github.com/enkessler
+* Stephan Schwab - https://github.com/snscaimito
 
 == Note on Patches/Pull Requests
 

data/Rakefile

@@ -3,31 +3,51 @@ require 'bundler'
 
 Bundler::GemHelper.install_tasks
 
-task :default => "spec:all"
-
-namespace :spec do
-  require 'rspec/core/rake_task'
-  RSpec::Core::RakeTask.new(:spec)
+namespace :build do
+  build_tasks = [
+    {:name => :uia_dll, :path => "UiaDll"},
+    {:name => :i_accessible_dll, :path => "IAccessibleDLL"},
+    {:name => :windows_forms, :path => "WindowsForms"}
+  ]
 
-  RSpec::Core::RakeTask.new(:rcov) do |spec|
-    spec.rcov = true
+  build_tasks.each do |build_task|
+    desc "Build #{build_task[:path]}"
+    task build_task[:name] do
+      sh "msbuild /property:Configuration=Release ext\\#{build_task[:path]}\\#{build_task[:path]}.sln"
+    end
   end
 
+  desc "Build all external dependencies"
+  task :all => build_tasks.map { |t| "build:#{t[:name]}"}
+end
+
+task :build => "build:all"
+
+namespace :spec do
   adapters = %w[win_32 autoit ms_uia]
+
   adapters.each do |adapter|
-    desc "Run specs against #{adapter} adapter"
+    desc "Run RSpec code examples against #{adapter} adapter"
     task adapter do
       ENV["RAUTOMATION_ADAPTER"] = adapter
       puts "Running specs for adapter: #{adapter}"
-      task = Rake::Task["spec:spec"]
+      task = Rake::Task["spec"]
       task.reenable
       task.invoke      
     end
   end
 
-  desc "Run specs against all adapters"
+  desc "Run RSpec code examples against all adapters"
   task :all => adapters.map {|a| "spec:#{a}"}
 end
 
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+task :spec => :build
+
+RSpec::Core::RakeTask.new(:rcov) { |spec| spec.rcov = true }
+
 require 'yard'
 YARD::Rake::YardocTask.new
+
+task :default => "spec:all"

data/VERSION

@@ -1 +1 @@
-0.7.3
+0.8.0

data/ext/UiaDll/UiaDll/AssemblyInfo.cpp

@@ -0,0 +1,40 @@
+#include "stdafx.h"
+
+using namespace System;
+using namespace System::Reflection;
+using namespace System::Runtime::CompilerServices;
+using namespace System::Runtime::InteropServices;
+using namespace System::Security::Permissions;
+
+//
+// General Information about an assembly is controlled through the following
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+//
+[assembly:AssemblyTitleAttribute("UiaDll")];
+[assembly:AssemblyDescriptionAttribute("")];
+[assembly:AssemblyConfigurationAttribute("")];
+[assembly:AssemblyCompanyAttribute("")];
+[assembly:AssemblyProductAttribute("UiaDll")];
+[assembly:AssemblyCopyrightAttribute("Copyright (c)  2012")];
+[assembly:AssemblyTrademarkAttribute("")];
+[assembly:AssemblyCultureAttribute("")];
+
+//
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version
+//      Build Number
+//      Revision
+//
+// You can specify all the value or you can default the Revision and Build Numbers
+// by using the '*' as shown below:
+
+[assembly:AssemblyVersionAttribute("1.0.*")];
+
+[assembly:ComVisible(false)];
+
+[assembly:CLSCompliantAttribute(true)];
+
+[assembly:SecurityPermission(SecurityAction::RequestMinimum, UnmanagedCode = true)];

data/ext/UiaDll/UiaDll/AutomatedComboBox.cpp

@@ -0,0 +1,66 @@
+#include "StdAfx.h"
+#include "AutomatedComboBox.h"
+
+AutomatedComboBox::AutomatedComboBox(const HWND windowHandle)
+{
+	_comboControl = AutomationElement::FromHandle(IntPtr(windowHandle));
+}
+
+bool AutomatedComboBox::SelectByIndex(const int whichItem)
+{
+	try {
+	  auto selectionItems = _comboControl->FindAll(System::Windows::Automation::TreeScope::Subtree, SelectionCondition);
+	  Select(selectionItems[whichItem]);
+	  return true;
+	} catch(Exception^ e) {
+		Console::WriteLine(e->ToString());
+		return false;
+	}
+}
+
+bool AutomatedComboBox::SelectByValue(const char* whichItem)
+{
+	try {
+	  auto nameCondition = gcnew PropertyCondition(AutomationElement::NameProperty, gcnew String(whichItem));
+	  auto selectionAndNameCondition = gcnew AndCondition(SelectionCondition, nameCondition);
+
+	  Select(_comboControl->FindFirst(System::Windows::Automation::TreeScope::Subtree, selectionAndNameCondition));
+	  return true;
+	} catch(Exception^ e) {
+		Console::WriteLine(e->ToString());
+		return false;
+	}
+}
+
+bool AutomatedComboBox::GetValueByIndex(const int whichItem, char* comboValue, const int comboValueSize)
+{
+	try {
+		auto selectionItem = SelectionItems[whichItem];
+		auto nameProperty = dynamic_cast<String^>(selectionItem->GetCurrentPropertyValue(AutomationElement::NameProperty));
+
+		StringHelper::CopyToUnmanagedString(nameProperty, comboValue, comboValueSize);
+		return true;
+	} catch(Exception^ e) {
+		Console::WriteLine(e->ToString());
+		return false;
+	}
+}
+
+int AutomatedComboBox::SelectedIndex::get() {
+	int selectedIndex = 0;
+	for each(AutomationElement^ selectionItem in SelectionItems) {
+	  auto selectionPattern = dynamic_cast<SelectionItemPattern^>(selectionItem->GetCurrentPattern(SelectionItemPattern::Pattern));
+	  if( selectionPattern->Current.IsSelected ) {
+		  return selectedIndex;
+	  }
+	  ++selectedIndex;
+	}
+	return -1;
+}
+
+
+void AutomatedComboBox::Select(AutomationElement^ itemToSelect)
+{
+	auto selectionPattern = dynamic_cast<SelectionItemPattern^>(itemToSelect->GetCurrentPattern(SelectionItemPattern::Pattern));
+	selectionPattern->Select();
+}

data/ext/UiaDll/UiaDll/AutomatedComboBox.h

@@ -0,0 +1,32 @@
+#pragma once
+using namespace System::Windows::Automation;
+
+public ref class AutomatedComboBox
+{
+public:
+	AutomatedComboBox(const HWND windowHandle);
+	bool SelectByIndex(const int whichItem);
+	bool SelectByValue(const char* whichItem);
+	bool GetValueByIndex(const int whichItem, char* comboValue, const int comboValueSize);
+
+	property int Count {
+		int get() { return SelectionItems->Count; }
+	}
+
+	property int SelectedIndex {
+		int get();
+	}
+
+private:
+	AutomationElement^	_comboControl;
+	void Select(AutomationElement^ itemToSelect);
+
+	property AutomationElementCollection^ SelectionItems {
+	  AutomationElementCollection^ get() { return _comboControl->FindAll(System::Windows::Automation::TreeScope::Subtree, SelectionCondition); }
+	}
+
+	property PropertyCondition^ SelectionCondition {
+	  PropertyCondition^ get() { return gcnew PropertyCondition(AutomationElement::IsSelectionItemPatternAvailableProperty, true); }
+	}
+};
+

data/ext/UiaDll/UiaDll/AutomatedTable.cpp

@@ -0,0 +1,50 @@
+#include "StdAfx.h"
+#include "AutomatedTable.h"
+
+AutomatedTable::AutomatedTable(const HWND windowHandle)
+{
+	_tableControl = AutomationElement::FromHandle(IntPtr(windowHandle));
+}
+
+int AutomatedTable::RowCount::get()
+{
+	auto tablePattern = dynamic_cast<TablePattern^>(_tableControl->GetCurrentPattern(TablePattern::Pattern));
+	return tablePattern->Current.RowCount;
+}
+
+bool AutomatedTable::Exists(const char* whichItem)
+{
+	return Exists(gcnew PropertyCondition(AutomationElement::NameProperty, gcnew String(whichItem)));
+}
+
+bool AutomatedTable::Exists(const int whichItemIndex, const int whichColumnIndex)
+{
+	return nullptr != DataItemAt(whichItemIndex, whichColumnIndex);
+}
+
+String^ AutomatedTable::ValueAt(const int whichItemIndex, const int whichItemColumn)
+{
+	return DataItemAt(whichItemIndex, whichItemColumn)->Current.Name;
+}
+
+AutomationElement^ AutomatedTable::DataItemAt(const int whichItemIndex, const int whichItemColumn)
+{
+	auto dataItemProperty = gcnew PropertyCondition(AutomationElement::IsTableItemPatternAvailableProperty, true);
+	auto indexProperty = gcnew PropertyCondition(TableItemPattern::RowProperty, whichItemIndex);
+	auto columnProperty = gcnew PropertyCondition(TableItemPattern::ColumnProperty, whichItemColumn);
+	return _tableControl->FindFirst(System::Windows::Automation::TreeScope::Subtree, gcnew AndCondition(dataItemProperty, indexProperty, columnProperty));
+}
+
+bool AutomatedTable::Exists(Condition^ condition)
+{
+	auto dataItemProperty = gcnew PropertyCondition(AutomationElement::IsTableItemPatternAvailableProperty, true);
+	return _tableControl->FindAll(System::Windows::Automation::TreeScope::Subtree, gcnew AndCondition(dataItemProperty, condition))->Count > 0;
+}
+
+void AutomatedTable::Select(const int dataItemIndex)
+{
+	auto dataItemProperty = gcnew PropertyCondition(AutomationElement::ControlTypeProperty, ControlType::DataItem);
+	auto dataItem = _tableControl->FindAll(System::Windows::Automation::TreeScope::Subtree, dataItemProperty)[dataItemIndex];
+	auto selectionItemPattern = dynamic_cast<SelectionItemPattern^>(dataItem->GetCurrentPattern(SelectionItemPattern::Pattern));
+	selectionItemPattern->Select();
+}

data/ext/UiaDll/UiaDll/AutomatedTable.h

@@ -0,0 +1,22 @@
+#pragma once
+using namespace System::Windows::Automation;
+
+ref class AutomatedTable
+{
+public:
+	AutomatedTable(const HWND windowHandle);
+	bool Exists(const char* whichItem);
+	bool Exists(const int whichItemIndex, const int whichColumnIndex);
+	String^ ValueAt(const int whichItemIndex, const int whichColumnIndex);
+	void Select(const int dataItemIndex);
+
+	property int RowCount {
+		int get();
+	}
+
+private:
+	AutomationElement^ _tableControl;
+	bool Exists(Condition^ condition);
+	AutomationElement^ DataItemAt(const int whichItemIndex, const int whichItemRow);
+};
+

data/ext/UiaDll/UiaDll/AutomationClicker.cpp

@@ -0,0 +1,50 @@
+#include "StdAfx.h"
+#include "AutomationClicker.h"
+
+AutomationClicker::AutomationClicker(const HWND windowHandle) {
+	_automationElement = AutomationElement::FromHandle(IntPtr(windowHandle));
+}
+
+void AutomationClicker::Click() {
+	if( CanInvoke() ) {
+		return Invoke();
+	} else if( CanToggle() ) {
+		return Toggle();
+	} else if( CanSelect() ) {
+		return Select();
+	}
+
+	throw gcnew Exception(gcnew String("AutomationElement did not support the InvokePattern, TogglePattern or the SelectionItemPattern"));
+}
+
+void AutomationClicker::MouseClick() {
+	_automationElement->SetFocus();
+	auto clickablePoint = _automationElement->GetClickablePoint();
+	Cursor::Position = Point((int)clickablePoint.X, (int)clickablePoint.Y);
+	mouse_event(MOUSEEVENTF_LEFTDOWN, 0, 0, 0, 0);
+	mouse_event(MOUSEEVENTF_LEFTUP, 0, 0, 0, 0);
+}
+
+bool AutomationClicker::CanInvoke() {
+	return (bool)(_automationElement->GetCurrentPropertyValue(AutomationElement::IsInvokePatternAvailableProperty));
+}
+
+void AutomationClicker::Invoke() {
+	dynamic_cast<InvokePattern^>(_automationElement->GetCurrentPattern(InvokePattern::Pattern))->Invoke();
+}
+
+bool AutomationClicker::CanToggle() {
+	return (bool)(_automationElement->GetCurrentPropertyValue(AutomationElement::IsTogglePatternAvailableProperty));
+}
+
+void AutomationClicker::Toggle() {
+	dynamic_cast<TogglePattern^>(_automationElement->GetCurrentPattern(TogglePattern::Pattern))->Toggle();
+}
+
+bool AutomationClicker::CanSelect() {
+	return (bool)(_automationElement->GetCurrentPropertyValue(AutomationElement::IsSelectionItemPatternAvailableProperty));
+}
+
+void AutomationClicker::Select() {
+	dynamic_cast<SelectionItemPattern^>(_automationElement->GetCurrentPattern(SelectionItemPattern::Pattern))->Select();
+}

data/ext/UiaDll/UiaDll/AutomationClicker.h

@@ -0,0 +1,24 @@
+#pragma once
+using namespace System::Windows::Automation;
+using namespace System::Windows::Forms;
+using namespace System::Drawing;
+
+ref class AutomationClicker
+{
+public:
+	AutomationClicker(const HWND windowHandle);
+	void Click();
+	void MouseClick();
+
+private:
+	AutomationElement^	_automationElement;
+
+	bool CanInvoke();
+	void Invoke();
+
+	bool CanToggle();
+	void Toggle();
+
+	bool CanSelect();
+	void Select();
+};

data/ext/UiaDll/UiaDll/ExpandCollapseHelper.cpp

@@ -0,0 +1,53 @@
+#include "StdAfx.h"
+#include "ExpandCollapseHelper.h"
+
+
+void ExpandCollapseHelper::ExpandByValue(const HWND windowHandle, const char* whichItem)
+{
+	Expand(ExpandableItem(windowHandle, whichItem));
+}
+
+void ExpandCollapseHelper::ExpandByIndex(const HWND windowHandle, const int whichItemIndex)
+{
+	auto expandableItem = ExpandableItems(windowHandle)[whichItemIndex];
+	Expand(expandableItem);
+}
+
+void ExpandCollapseHelper::CollapseByValue(const HWND windowHandle, const char* whichItem)
+{
+	Collapse(ExpandableItem(windowHandle, whichItem));
+}
+
+void ExpandCollapseHelper::CollapseByIndex(const HWND windowHandle, const int whichItemIndex)
+{
+	auto expandableItem = ExpandableItems(windowHandle)[whichItemIndex];
+	Collapse(expandableItem);
+}
+
+AutomationElementCollection^ ExpandCollapseHelper::ExpandableItems(const HWND windowHandle)
+{
+	auto automationElement = AutomationElement::FromHandle(IntPtr(windowHandle));
+	return automationElement->FindAll(System::Windows::Automation::TreeScope::Subtree, IsExpandable);
+}
+
+AutomationElement^ ExpandCollapseHelper::ExpandableItem(const HWND windowHandle, const char* whichItem)
+{
+	auto automationElement = AutomationElement::FromHandle(IntPtr(windowHandle));
+	auto andTheNameMatches = gcnew PropertyCondition(AutomationElement::NameProperty, gcnew String(whichItem));
+	return automationElement->FindFirst(System::Windows::Automation::TreeScope::Subtree, gcnew AndCondition(IsExpandable, andTheNameMatches));
+}
+
+void ExpandCollapseHelper::Expand(AutomationElement^ automationElement)
+{
+	dynamic_cast<ExpandCollapsePattern^>(automationElement->GetCurrentPattern(ExpandCollapsePattern::Pattern))->Expand();
+}
+
+void ExpandCollapseHelper::Collapse(AutomationElement^ automationElement)
+{
+	dynamic_cast<ExpandCollapsePattern^>(automationElement->GetCurrentPattern(ExpandCollapsePattern::Pattern))->Collapse();
+}
+
+PropertyCondition^ ExpandCollapseHelper::IsExpandable::get()
+{
+	return gcnew PropertyCondition(AutomationElement::IsExpandCollapsePatternAvailableProperty, true);
+}

data/ext/UiaDll/UiaDll/ExpandCollapseHelper.h

@@ -0,0 +1,22 @@
+#pragma once
+using namespace System::Windows::Automation;
+
+ref class ExpandCollapseHelper
+{
+public:
+	void ExpandByValue(const HWND windowHandle, const char* whichItem);
+	void ExpandByIndex(const HWND windowHandle, const int whichItemIndex);
+	void CollapseByValue(const HWND windowHandle, const char* whichItem);
+	void CollapseByIndex(const HWND windowHandle, const int whichItemIndex);
+
+private:
+	AutomationElementCollection^ ExpandableItems(const HWND windowHandle);
+	AutomationElement^ ExpandableItem(const HWND windowHandle, const char* whichItem);
+	void Expand(AutomationElement^ automationElement);
+	void Collapse(AutomationElement^ automationElement);
+
+	property PropertyCondition^ IsExpandable {
+		PropertyCondition^ get();
+	}
+};
+

data/ext/UiaDll/UiaDll/MenuItemSelector.cpp

@@ -0,0 +1,75 @@
+#include "StdAfx.h"
+#include "MenuItemSelector.h"
+
+using namespace std;
+
+void MenuItemSelector::SelectMenuPath(const HWND windowHandle, list<const char*>& menuItems)
+{
+	auto automationElement = AutomationElement::FromHandle(IntPtr(windowHandle));
+	auto foundMenuItem = FindMenuItem(automationElement, menuItems);
+	auto invokePattern = dynamic_cast<InvokePattern^>(foundMenuItem->GetCurrentPattern(InvokePattern::Pattern));
+	invokePattern->Invoke();
+}
+
+BOOL MenuItemSelector::MenuItemExists(const HWND windowHandle, list<const char*>& menuItems)
+{
+	try {
+		auto automationElement = AutomationElement::FromHandle(IntPtr(windowHandle));
+		return FindMenuItem(automationElement, menuItems) != nullptr;
+	} catch(Exception^ e) {
+		return FALSE;
+	}
+}
+
+AutomationElement^ MenuItemSelector::FindMenuItem(AutomationElement^ rootElement, std::list<const char*>& menuItems)
+{
+	auto foundMenuItem = rootElement;
+
+	for(list<const char*>::iterator menuItem = menuItems.begin(); menuItem != menuItems.end(); ++menuItem) {
+		foundMenuItem = GetNextMenuItem(foundMenuItem, gcnew String(*menuItem));
+	}
+
+	return foundMenuItem;
+}
+
+PropertyCondition^ MenuItemSelector::NameConditionFor(String^ name)
+{
+	return gcnew PropertyCondition(AutomationElement::NameProperty, name);
+}
+
+AutomationElement^ MenuItemSelector::GetNextMenuItem(AutomationElement^ foundMenuItem, String^ nextMenu)
+{
+	TryToExpand(AsExpandCollapse(foundMenuItem));
+	auto nextMenuItem = foundMenuItem->FindFirst(System::Windows::Automation::TreeScope::Subtree,
+								   gcnew AndCondition(MenuItemControlType, NameConditionFor(nextMenu)));
+	if( nullptr == nextMenuItem ) {
+		throw gcnew Exception(String::Format("MenuItem with the text \"{0}\" does not exist", nextMenu));
+	}
+	return nextMenuItem;
+}
+
+ExpandCollapsePattern^ MenuItemSelector::AsExpandCollapse(AutomationElement^ foundMenuItem)
+{
+	try
+	{
+		return dynamic_cast<ExpandCollapsePattern^>(foundMenuItem->GetCurrentPattern(ExpandCollapsePattern::Pattern));
+	}
+	catch(Exception^ e)
+	{
+		return nullptr;
+	}
+}
+
+void MenuItemSelector::TryToExpand(ExpandCollapsePattern^ expandCollapsePattern)
+{
+	if (nullptr == expandCollapsePattern) return;
+
+	try
+	{
+		expandCollapsePattern->Expand();
+	}
+	catch(Exception^ e)
+	{
+		expandCollapsePattern->Expand();
+	}
+}

data/ext/UiaDll/UiaDll/MenuItemSelector.h

@@ -0,0 +1,22 @@
+#pragma once
+using namespace System::Windows::Automation;
+
+public ref class MenuItemSelector
+{
+public:
+	void SelectMenuPath(const HWND windowHandle, std::list<const char*>& menuItems);
+	BOOL MenuItemExists(const HWND windowHandle, std::list<const char*>& menuItems);
+
+private:
+	AutomationElement^ FindMenuItem(AutomationElement^ rootElement, std::list<const char*>& menuItems);
+	PropertyCondition^ NameConditionFor(String^ name);
+	AutomationElement^ GetNextMenuItem(AutomationElement^ foundMenuItem, String^ nextMenu);
+	ExpandCollapsePattern^ AsExpandCollapse(AutomationElement^ foundMenuItem);
+	void TryToExpand(ExpandCollapsePattern^ expandCollapsePattern);
+
+	property PropertyCondition^ MenuItemControlType {
+private:
+	PropertyCondition^ get() { return gcnew PropertyCondition(AutomationElement::ControlTypeProperty, ControlType::MenuItem); }
+	}
+};
+

data/ext/UiaDll/UiaDll/ReadMe.txt

@@ -2,15 +2,14 @@
     DYNAMIC LINK LIBRARY : UiaDll Project Overview
 ========================================================================
 
-AppWizard has created this UiaDll DLL for you.
+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
+    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.
 
@@ -24,25 +23,16 @@ UiaDll.vcxproj.filters
 UiaDll.cpp
     This is the main DLL source file.
 
-	When created, this DLL does not export any symbols. As a result, it
-	will not produce a .lib file when it is built. If you wish this project
-	to be a project dependency of some other project, you will either need to
-	add code to export some symbols from the DLL so that an export library
-	will be produced, or you can set the Ignore Input Library property to Yes
-	on the General propert page of the Linker folder in the project's Property
-	Pages dialog box.
-
-/////////////////////////////////////////////////////////////////////////////
-Other standard files:
+UiaDll.h
+    This file contains a class declaration.
 
-StdAfx.h, StdAfx.cpp
-    These files are used to build a precompiled header (PCH) file
-    named UiaDll.pch and a precompiled types file named StdAfx.obj.
+AssemblyInfo.cpp
+	Contains custom attributes for modifying assembly metadata.
 
 /////////////////////////////////////////////////////////////////////////////
 Other notes:
 
-AppWizard uses "TODO:" comments to indicate parts of the source code you
+AppWizard uses "TODO:" to indicate parts of the source code you
 should add to or customize.
 
 /////////////////////////////////////////////////////////////////////////////

data/ext/UiaDll/UiaDll/StringHelper.cpp

@@ -0,0 +1,9 @@
+#include "StdAfx.h"
+#include "StringHelper.h"
+
+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);
+}