rautomation 2.0.1-x64-mingw32

data/ext/UiaDll/RAutomation.UIA/Extensions/Enumerable.cs

@@ -0,0 +1,76 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Windows.Automation;
+
+namespace RAutomation.UIA.Extensions
+{
+    public static class Enumerable
+    {
+        public static IEnumerable<AutomationElement> Find(this AutomationElement automationElement, Condition condition)
+        {
+            return automationElement.Find(Condition.TrueCondition, condition);
+        }
+
+        public static IEnumerable<AutomationElement> Find(this AutomationElement automationElement, params Condition[] conditions)
+        {
+            return automationElement.FindAll(TreeScope.Subtree, new AndCondition(conditions)).AsEnumerable();
+        }
+
+        public static IEnumerable<AutomationElement> FindAny(this AutomationElement automationElement, params Condition[] conditions)
+        {
+            return automationElement.FindAll(TreeScope.Subtree, new OrCondition(conditions)).AsEnumerable();
+        }
+
+        public static AutomationElement FindOne(this AutomationElement automationElement, params Condition[] conditions)
+        {
+            return automationElement.FindFirst(TreeScope.Subtree, new AndCondition(conditions));
+        }
+
+        public static IEnumerable<string> Names(this IEnumerable<AutomationElement> automationElements)
+        {
+            return automationElements.Select(x => x.Current.Name);
+        }
+
+        public static IEnumerable<SelectionItemPattern> AsSelectionItems(this IEnumerable<AutomationElement> automationElements)
+        {
+            return automationElements.Select(Element.AsSelectionItem);
+        }
+
+        public static int IndexOf<T>(this IEnumerable<T> items, Func<T, bool> trueCondition)
+        {
+            var foundIndex = 0;
+            foreach (var item in items)
+            {
+                if (trueCondition(item)) return foundIndex;
+                ++foundIndex;
+            }
+
+            return -1;
+        }
+
+        public static int[] IndexesOf<T>(this IEnumerable<T> items, Func<T, bool> trueCondition)
+        {
+            var indexes = new List<int>();
+            var foundIndex = 0;
+            foreach (var item in items)
+            {
+                if (trueCondition(item)) indexes.Add(foundIndex);
+                ++foundIndex;
+            }
+
+            return indexes.ToArray();
+        }
+
+        public static void ForEach<T>(this IEnumerable<T> items, Action<T> doIt)
+        {
+            foreach (var item in items)
+                doIt(item);
+        }
+
+        public static IEnumerable<AutomationElement> AsEnumerable(this AutomationElementCollection automationElements)
+        {
+            return automationElements.Cast<AutomationElement>();
+        }
+    }
+}

data/ext/UiaDll/RAutomation.UIA/Extensions/Property.cs

@@ -0,0 +1,27 @@
+using System.Windows.Automation;
+
+namespace RAutomation.UIA.Extensions
+{
+    public static class Property
+    {
+        public static Condition Condition(this ControlType controlType)
+        {
+            return new PropertyCondition(AutomationElement.ControlTypeProperty, controlType);
+        }
+
+        public static Condition TrueCondition(this AutomationProperty property)
+        {
+            return new PropertyCondition(property, true);
+        }
+
+        public static Condition Is(this AutomationProperty property, object value)
+        {
+            return new PropertyCondition(property, value);
+        }
+
+        public static bool In(this AutomationProperty property, AutomationElement element)
+        {
+            return (bool) element.GetCurrentPropertyValue(property);
+        }
+    }
+}

data/ext/UiaDll/RAutomation.UIA/Properties/AssemblyInfo.cs

@@ -0,0 +1,36 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// 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: AssemblyTitle("RAutomation.UIA")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("RAutomation.UIA")]
+[assembly: AssemblyCopyright("Copyright ©  2013")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("8ef7f953-d78c-4088-abdb-1104f2300df8")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers 
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]

data/ext/UiaDll/RAutomation.UIA/Properties/AutomationProperties.cs

@@ -0,0 +1,18 @@
+using System.Windows.Automation;
+using RAutomation.UIA.Extensions;
+
+namespace RAutomation.UIA.Properties
+{
+    public class AutomationProperties
+    {
+        public static Condition IsSelectionItem
+        {
+            get { return new PropertyCondition(AutomationElement.IsSelectionItemPatternAvailableProperty, true); }
+        }
+
+        public static Condition IsDataItem
+        {
+            get { return ControlType.DataItem.Condition(); }
+        }
+    }
+}

data/ext/UiaDll/RAutomation.UIA/RAutomation.UIA.csproj

@@ -0,0 +1,77 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProjectGuid>{0834D9AE-B1AA-422B-B3B2-796C1C346301}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>RAutomation.UIA</RootNamespace>
+    <AssemblyName>RAutomation.UIA</AssemblyName>
+    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+    <TargetFrameworkProfile />
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x64'">
+    <PlatformTarget>x64</PlatformTarget>
+    <OutputPath>bin\x64\Debug\</OutputPath>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x64'">
+    <PlatformTarget>x64</PlatformTarget>
+    <OutputPath>bin\x64\Release\</OutputPath>
+    <RegisterForComInterop>false</RegisterForComInterop>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Drawing" />
+    <Reference Include="System.Windows.Forms" />
+    <Reference Include="System.Xml.Linq" />
+    <Reference Include="System.Data.DataSetExtensions" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Xml" />
+    <Reference Include="UIAutomationClient" />
+    <Reference Include="UIAutomationTypes" />
+    <Reference Include="WindowsBase" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="Controls\Clicker.cs" />
+    <Compile Include="Controls\SelectList.cs" />
+    <Compile Include="Controls\Spinner.cs" />
+    <Compile Include="Controls\TabControl.cs" />
+    <Compile Include="Controls\TableControl.cs" />
+    <Compile Include="Controls\TextControl.cs" />
+    <Compile Include="Expander.cs" />
+    <Compile Include="Extensions\Property.cs" />
+    <Compile Include="Extensions\Enumerable.cs" />
+    <Compile Include="Extensions\Element.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="Properties\AutomationProperties.cs" />
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+</Project>

data/ext/UiaDll/UiaDll/ArrayHelper.cpp

@@ -0,0 +1,14 @@
+#include "StdAfx.h"
+#include "ArrayHelper.h"
+
+
+int ArrayHelper::Copy(array<int, 1>^ source, int destination[])
+{
+  if( NULL != destination ) {
+    auto index = 0;
+    for each(auto value in source) {
+      destination[index++] = value;
+    }
+  }
+  return source->Length;
+}

data/ext/UiaDll/UiaDll/ArrayHelper.h

@@ -0,0 +1,7 @@
+#pragma once
+ref class ArrayHelper
+{
+public:
+  static int Copy(array<int>^ source, int destination[]);
+};
+

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/ControlMethods.cpp

@@ -0,0 +1,16 @@
+#include "stdafx.h"
+#include "Locator.h"
+#include "StringHelper.h"
+
+using namespace RAutomation::UIA::Extensions;
+
+extern "C" {
+	__declspec ( dllexport ) void Control_GetValue(const FindInformation& findInformation, char* theValue, const int maximumLength) {
+		auto value = Element::Value(Locator::FindFor(findInformation));
+		StringHelper::CopyToUnmanagedString(value, theValue, maximumLength);
+	}
+
+	__declspec ( dllexport ) void Control_SetValue(const FindInformation& findInformation, const char* theValue) {
+		Element::SetValue(Locator::FindFor(findInformation), gcnew String(theValue));
+	}
+}

data/ext/UiaDll/UiaDll/DynamicAssemblyResolver.cpp

@@ -0,0 +1,24 @@
+#include "StdAfx.h"
+#include "DynamicAssemblyResolver.h"
+
+void DynamicAssemblyResolver::PrivatePath::set(String^ path) {
+	_PrivatePath = path;
+	AppDomain::CurrentDomain->AssemblyResolve += gcnew ResolveEventHandler(Resolve);
+}
+
+Assembly^ DynamicAssemblyResolver::Resolve(Object^ sender, ResolveEventArgs^ args)
+{
+	try
+	{
+    auto fullPrivatePath = Path::Combine(_PrivatePath, AssemblyFromQualifiedName(args->Name));
+		return Assembly::LoadFrom(fullPrivatePath);
+	}
+	catch(...) { }
+
+	return nullptr;
+}
+
+String^ DynamicAssemblyResolver::AssemblyFromQualifiedName(String^ qualifiedName)
+{
+		return qualifiedName->Substring(0, qualifiedName->IndexOf(",")) + ".dll";
+}

data/ext/UiaDll/UiaDll/DynamicAssemblyResolver.h

@@ -0,0 +1,16 @@
+#pragma once
+using namespace System::IO;
+using namespace System::Reflection;
+
+ref class DynamicAssemblyResolver
+{
+public:
+  static property String^ PrivatePath {
+    void set(String^ value);
+  }
+
+private:
+  static String^ _PrivatePath = nullptr;
+  static Assembly^ Resolve(Object^ sender, ResolveEventArgs^ args);
+  static String^ AssemblyFromQualifiedName(String^ qualifiedName);
+};

data/ext/UiaDll/UiaDll/Locator.cpp

@@ -0,0 +1,93 @@
+#include "StdAfx.h"
+#include "Locator.h"
+
+Locator::Locator(AutomationElement^ automationElement)
+{
+	_automationElement = automationElement;
+}
+
+AutomationElement^ Locator::FindFor(const FindInformation& findInformation)
+{
+	try {
+		auto finder = gcnew Locator(AutomationElement::FromHandle(IntPtr(findInformation.rootWindow)));
+		return finder->Find(findInformation);
+	} catch(Exception^) {
+		return nullptr;
+	}
+}
+
+AutomationElementCollection^ Locator::Find(...array<Condition^>^ conditions)
+{
+  return Find(Subtree, conditions);
+}
+
+AutomationElementCollection^ Locator::Find(const UIAutomation::TreeScope scope, ...array<Condition^>^ conditions)
+{
+	return _automationElement->FindAll(scope, SomethingOrEverything(conditions));
+}
+
+AutomationElement^ Locator::FindFirst(...array<Condition^>^ conditions)
+{
+  return FindFirst(Subtree, conditions);
+}
+
+AutomationElement^ Locator::FindFirst(const UIAutomation::TreeScope scope, ...array<Condition^>^ conditions)
+{
+	return _automationElement->FindFirst(scope, SomethingOrEverything(conditions));
+}
+
+AutomationElement^ Locator::Find(const FindInformation& findInformation)
+{
+  auto scope = findInformation.onlySearchChildren ? Children : Subtree;
+
+  switch(findInformation.how) {
+    case Id:
+		{
+      auto searchCondition = gcnew PropertyCondition(AutomationElement::AutomationIdProperty, gcnew String(findInformation.data.stringData));
+      if( 0 == findInformation.index ) {
+        return FindFirst(scope, searchCondition);
+      }
+
+      return FindAt(scope, findInformation.index, searchCondition);
+		}
+    case Value:
+		{
+      auto searchCondition = gcnew PropertyCondition(AutomationElement::NameProperty, gcnew String(findInformation.data.stringData));
+
+      if( 0 == findInformation.index ) {
+        return FindFirst(scope, searchCondition);
+      }
+
+      return FindAt(scope, findInformation.index, searchCondition);
+		}
+    case Focus:
+      return AutomationElement::FocusedElement;
+    case ScreenPoint:
+			return AutomationElement::FromPoint(Point(findInformation.data.pointData[0], findInformation.data.pointData[1]));
+    case Handle:
+      return AutomationElement::FromHandle(IntPtr(findInformation.data.intData));
+	}
+
+  return nullptr;
+}
+
+AutomationElement^ Locator::FindAt(const int whichItem, ...array<Condition^>^ conditions)
+{
+  return FindAt(Subtree, whichItem, conditions);
+}
+
+AutomationElement^ Locator::FindAt(const UIAutomation::TreeScope scope, const int whichItem, ...array<Condition^>^ conditions)
+{
+	return Find(scope, conditions)[whichItem];
+}
+
+Condition^ Locator::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/Locator.h

@@ -0,0 +1,55 @@
+#pragma once
+using namespace System::Windows;
+using namespace System::Windows::Automation;
+
+ref class Locator
+{
+public:
+	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);
+	AutomationElement^ FindFirst(...array<Condition^>^ conditions);
+	AutomationElement^ FindFirst(const UIAutomation::TreeScope scope, ...array<Condition^>^ conditions);
+	AutomationElement^ FindAt(const int whichItem, ...array<Condition^>^ conditions);
+	AutomationElement^ FindAt(const UIAutomation::TreeScope scope, 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:
+  static UIAutomation::TreeScope Subtree = UIAutomation::TreeScope::Subtree;
+  static UIAutomation::TreeScope Children = UIAutomation::TreeScope::Children;
+	AutomationElement^ _automationElement;
+	Condition^ SomethingOrEverything(...array<Condition^>^ conditions);
+};
+

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^) {
+		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^)
+	{
+		return nullptr;
+	}
+}
+
+void MenuItemSelector::TryToExpand(ExpandCollapsePattern^ expandCollapsePattern)
+{
+	if (nullptr == expandCollapsePattern) return;
+
+	try
+	{
+		expandCollapsePattern->Expand();
+	}
+	catch(Exception^)
+	{
+		expandCollapsePattern->Expand();
+	}
+}

data/ext/UiaDll/UiaDll/MenuItemSelector.h

@@ -0,0 +1,24 @@
+#pragma once
+#include "StringHelper.h"
+
+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/MenuMethods.cpp

@@ -0,0 +1,62 @@
+#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" {
+
+  #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);			
+
+		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);
+	}
+  #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);			
+
+		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);
+	}
+  #pragma managed(pop)
+}
+
+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);
+		}
+	}
+}