rautomation 0.10.0 → 0.11.0

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

@@ -0,0 +1,108 @@
+using System.Windows;
+using System.Windows.Automation;
+
+namespace RAutomation.UIA.Extensions
+{
+    public static class Element
+    {
+        public static SelectionItemPattern AsSelectionItem(this AutomationElement automationElement)
+        {
+            return (SelectionItemPattern)automationElement.GetCurrentPattern(SelectionItemPattern.Pattern);
+        }
+
+        public static bool Exists(this AutomationElement automationElement)
+        {
+            return null != automationElement;
+        }
+
+        public static string Name(this AutomationElement automationElement)
+        {
+            return automationElement.Current.Name;
+        }
+
+        public static string ClassName(this AutomationElement automationElement)
+        {
+            return automationElement.Current.ClassName;
+        }
+
+        public static bool IsEnabled(this AutomationElement automationElement)
+        {
+            return automationElement.Current.IsEnabled;
+        }
+
+        public static bool IsFocused(this AutomationElement automationElement)
+        {
+            return automationElement.Current.HasKeyboardFocus;
+        }
+
+        public static int NativeWindowHandle(this AutomationElement automationElement)
+        {
+            return automationElement.Exists() ? automationElement.Current.NativeWindowHandle : 0;
+        }
+
+        public static Rect BoundingRectangle(this AutomationElement automationElement)
+        {
+            return automationElement.Current.BoundingRectangle;
+        }
+
+        public static ControlType ControlType(this AutomationElement automationElement)
+        {
+            return automationElement.Current.ControlType;
+        }
+
+        public static int ProcessId(this AutomationElement automationElement)
+        {
+            return automationElement.Current.ProcessId;
+        }
+
+        public static bool IsSelected(this AutomationElement automationElement)
+        {
+            return automationElement.AsSelectionItem().Current.IsSelected;
+        }
+
+        public static bool IsOffscreen(this AutomationElement automationElement)
+        {
+            return automationElement.Current.IsOffscreen;
+        }
+
+        public static TogglePattern AsTogglePattern(this AutomationElement automationElement)
+        {
+            return (TogglePattern)automationElement.GetCurrentPattern(TogglePattern.Pattern);
+        }
+
+        public static bool IsToggled(this AutomationElement automationElement)
+        {
+            return automationElement.AsTogglePattern().Current.ToggleState == ToggleState.On;
+        }
+
+        public static string Value(this AutomationElement automationElement)
+        {
+            return automationElement.AsValuePattern().Current.Value;
+        }
+
+        public static void SetValue(this AutomationElement automationElement, string value)
+        {
+            automationElement.AsValuePattern().SetValue(value);
+        }
+
+        public static bool IsValuePattern(this AutomationElement automationElement)
+        {
+            return (bool) automationElement.GetCurrentPropertyValue(AutomationElement.IsValuePatternAvailableProperty);
+        }
+
+        public static ValuePattern AsValuePattern(this AutomationElement automationElement)
+        {
+            return (ValuePattern) automationElement.GetCurrentPattern(ValuePattern.Pattern);
+        }
+
+        public static TextPattern AsTextPattern(this AutomationElement automationElement)
+        {
+            return (TextPattern) automationElement.GetCurrentPattern(TextPattern.Pattern);
+        }
+
+        public static T As<T>(this AutomationElement automationElement, AutomationPattern pattern)
+        {
+            return (T) automationElement.GetCurrentPattern(pattern);
+        }
+    }
+}

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

@@ -0,0 +1,63 @@
+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 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,68 @@
+<?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>
+  <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.sln

@@ -1,18 +1,40 @@
 
-Microsoft Visual Studio Solution File, Format Version 11.00
-# Visual Studio 2010
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 2012
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "UiaDll", "UiaDll\UiaDll.vcxproj", "{4A06195F-8D10-4384-97C3-86D512C40DE4}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "RAutomation.UIA", "RAutomation.UIA\RAutomation.UIA.csproj", "{0834D9AE-B1AA-422B-B3B2-796C1C346301}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Debug|Mixed Platforms = Debug|Mixed Platforms
 		Debug|Win32 = Debug|Win32
+		Release|Any CPU = Release|Any CPU
+		Release|Mixed Platforms = Release|Mixed Platforms
 		Release|Win32 = Release|Win32
 	EndGlobalSection
 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{4A06195F-8D10-4384-97C3-86D512C40DE4}.Debug|Any CPU.ActiveCfg = Debug|Win32
+		{4A06195F-8D10-4384-97C3-86D512C40DE4}.Debug|Mixed Platforms.ActiveCfg = Debug|Win32
+		{4A06195F-8D10-4384-97C3-86D512C40DE4}.Debug|Mixed Platforms.Build.0 = Debug|Win32
 		{4A06195F-8D10-4384-97C3-86D512C40DE4}.Debug|Win32.ActiveCfg = Debug|Win32
 		{4A06195F-8D10-4384-97C3-86D512C40DE4}.Debug|Win32.Build.0 = Debug|Win32
+		{4A06195F-8D10-4384-97C3-86D512C40DE4}.Release|Any CPU.ActiveCfg = Release|Win32
+		{4A06195F-8D10-4384-97C3-86D512C40DE4}.Release|Mixed Platforms.ActiveCfg = Release|Win32
+		{4A06195F-8D10-4384-97C3-86D512C40DE4}.Release|Mixed Platforms.Build.0 = Release|Win32
 		{4A06195F-8D10-4384-97C3-86D512C40DE4}.Release|Win32.ActiveCfg = Release|Win32
 		{4A06195F-8D10-4384-97C3-86D512C40DE4}.Release|Win32.Build.0 = Release|Win32
+		{0834D9AE-B1AA-422B-B3B2-796C1C346301}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{0834D9AE-B1AA-422B-B3B2-796C1C346301}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{0834D9AE-B1AA-422B-B3B2-796C1C346301}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
+		{0834D9AE-B1AA-422B-B3B2-796C1C346301}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU
+		{0834D9AE-B1AA-422B-B3B2-796C1C346301}.Debug|Win32.ActiveCfg = Debug|Any CPU
+		{0834D9AE-B1AA-422B-B3B2-796C1C346301}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{0834D9AE-B1AA-422B-B3B2-796C1C346301}.Release|Any CPU.Build.0 = Release|Any CPU
+		{0834D9AE-B1AA-422B-B3B2-796C1C346301}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
+		{0834D9AE-B1AA-422B-B3B2-796C1C346301}.Release|Mixed Platforms.Build.0 = Release|Any CPU
+		{0834D9AE-B1AA-422B-B3B2-796C1C346301}.Release|Win32.ActiveCfg = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

data/ext/UiaDll/UiaDll/ControlMethods.cpp

@@ -1,15 +1,16 @@
 #include "stdafx.h"
-#include "AutomationControl.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 control = gcnew AutomationControl(findInformation);
-		StringHelper::CopyToUnmanagedString(control->Value, theValue, maximumLength);
+		auto value = Element::Value(Locator::FindFor(findInformation));
+		StringHelper::CopyToUnmanagedString(value, theValue, maximumLength);
 	}
 
 	__declspec ( dllexport ) void Control_SetValue(const FindInformation& findInformation, const char* theValue) {
-		auto control = gcnew AutomationControl(findInformation);
-		control->Value = gcnew String(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/{AutomationFinder.cpp → Locator.cpp}

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