uia 0.0.5.1 → 0.0.6

data/ext/UiaDll/UiaDll/ElementStructures.h

@@ -7,27 +7,37 @@ typedef struct _ElementInformation {
   int* runtimeId;
   int runtimeIdLength;
   char* name;
+  char* className;
   int controlTypeId;
   int* patterns;
   int patternsLength;
   char* id;
 
-  _ElementInformation() : name(NULL), nativeWindowHandle(0), runtimeId(NULL), patterns(NULL), id(NULL) {}
+  bool isEnabled;
 
-  _ElementInformation(Element^ element) : name(NULL), nativeWindowHandle(0), runtimeId(NULL), patterns(NULL), id(NULL) {
-    Update(element);
+  _ElementInformation() : name(NULL), nativeWindowHandle(0), runtimeId(NULL), patterns(NULL), id(NULL), className(NULL) {}
+
+  _ElementInformation(Element^ element) : name(NULL), nativeWindowHandle(0), runtimeId(NULL), patterns(NULL), id(NULL), className(NULL) {
+    Refresh(element);
+  }
+
+  static _ElementInformation* From(Element^ element) {
+    return nullptr != element ? new _ElementInformation(element) : NULL;
   }
 
-  void Update(Element^ element) {
+  void Refresh(Element^ element) {
     Reset();
     id = StringHelper::ToUnmanaged(element->Id);
     name = StringHelper::ToUnmanaged(element->Name);
+    className = StringHelper::ToUnmanaged(element->ClassName);
     nativeWindowHandle = element->NativeWindowHandle;
     runtimeId = ArrayHelper::FromArray(element->RuntimeId);
     runtimeIdLength = element->RuntimeId->Length;
     controlTypeId = element->ControlTypeId;
     patterns = ArrayHelper::FromArray(element->SupportedPatternIds);
     patternsLength = element->SupportedPatternIds->Length;
+
+    isEnabled = element->IsEnabled;
   }
 
   ~_ElementInformation() {
@@ -36,11 +46,11 @@ typedef struct _ElementInformation {
 
 private:
   void Reset() {
-    delete[] name; delete[] runtimeId; delete[] patterns; delete[] id;
-    name = NULL; runtimeId = NULL; patterns = NULL; id = NULL;
+    delete[] name; delete[] runtimeId; delete[] patterns; delete[] id; delete[] className;
+    name = NULL; runtimeId = NULL; patterns = NULL; id = NULL; className = NULL;
   }
 
-} ElementInformation, *PElementInformation;
+} ElementInformation, *ElementInformationPtr;
 
 typedef struct _Elements {
   int length;
@@ -54,11 +64,11 @@ typedef struct _Elements {
 
     auto index = 0;
     for each(auto element in elements) {
-      this->elements[index++].Update(element);
+      this->elements[index++].Refresh(element);
     }
   }
 
   ~_Elements() {
     delete[] elements;
   }
-} Elements, *PElements;
+} Elements, *ElementsPtr;

data/ext/UiaDll/UiaDll/ExpandCollapseMethods.cpp

@@ -0,0 +1,33 @@
+#include "Stdafx.h"
+
+extern "C" {
+  __declspec(dllexport) void ExpandCollapse_Release(ExpandCollapseInfoPtr expandCollapseInfo) {
+    delete expandCollapseInfo;
+  }
+
+  __declspec(dllexport) ExpandCollapseInfoPtr ExpandCollapse_Information(ElementInformationPtr element, char* errorInfo, const int errorInfoLength) {
+    try {
+      auto info = Find(element)->As<ExpandCollapsePattern^>(ExpandCollapsePattern::Pattern)->Current;
+      return new ExpandCollapseInfo(info.ExpandCollapseState.ToString());
+    } catch(Exception^ e) {
+      StringHelper::CopyToUnmanagedString(e->Message, errorInfo, errorInfoLength);
+      return NULL;
+    }
+  }
+
+  __declspec(dllexport) void ExpandCollapse_Expand(ElementInformationPtr element, char* errorInfo, const int errorInfoLength) {
+    try {
+      Find(element)->As<ExpandCollapsePattern^>(ExpandCollapsePattern::Pattern)->Expand();
+    } catch(Exception^ e) {
+      StringHelper::CopyToUnmanagedString(e->Message, errorInfo, errorInfoLength);
+    }
+  }
+
+  __declspec(dllexport) void ExpandCollapse_Collapse(ElementInformationPtr element, char* errorInfo, const int errorInfoLength) {
+    try {
+      Find(element)->As<ExpandCollapsePattern^>(ExpandCollapsePattern::Pattern)->Collapse();
+    } catch(Exception^ e) {
+      StringHelper::CopyToUnmanagedString(e->Message, errorInfo, errorInfoLength);
+    }
+  }
+}

data/ext/UiaDll/UiaDll/InvokePatternMethods.cpp

@@ -0,0 +1,11 @@
+#include "Stdafx.h"
+
+extern "C" {
+  __declspec(dllexport) void Invoke(ElementInformationPtr element, char* errorInfo, const int errorInfoLength) {
+    try {
+      Find(element)->As<InvokePattern^>(InvokePattern::Pattern)->Invoke();
+    } catch(Exception^ e) {
+      StringHelper::CopyToUnmanagedString(e->Message, errorInfo, errorInfoLength);
+    }
+  }
+}

data/ext/UiaDll/UiaDll/PatternInformationStructures.h

@@ -0,0 +1,90 @@
+#pragma once
+
+#include "StringHelper.h"
+#include "ElementStructures.h"
+
+using namespace System::Windows::Automation;
+
+typedef struct _ValuePatternInformation {
+  bool IsReadOnly;
+  char* Value;
+
+  _ValuePatternInformation(String^ value, bool IsReadOnly) {
+    init(value, IsReadOnly);
+  }
+
+  _ValuePatternInformation(ValuePattern::ValuePatternInformation^ info) {
+    init(info->Value, info->IsReadOnly);
+  }
+
+  ~_ValuePatternInformation() {
+    delete[] Value;
+  }
+
+private:
+  void init(String^ value, bool IsReadOnly) {
+    this->IsReadOnly = IsReadOnly;
+    Value = StringHelper::ToUnmanaged(value);
+  }
+
+} ValuePatternInformation, *ValuePatternInformationPtr;
+
+typedef struct _ToggleInformation {
+  char* ToggleState;
+
+  _ToggleInformation(String^ toggleState) {
+    ToggleState = StringHelper::ToUnmanaged(toggleState);
+  }
+
+  ~_ToggleInformation() {
+    delete[] ToggleState;
+  }
+
+} ToggleInformation, *ToggleInformationPtr;
+
+typedef struct _SelectionInformation {
+  bool CanSelectMultiple;
+  bool IsSelectionRequired;
+
+  _SelectionInformation(SelectionPattern::SelectionPatternInformation^ info) {
+    CanSelectMultiple = info->CanSelectMultiple;
+    IsSelectionRequired = info->IsSelectionRequired;
+  }
+} SelectionInformation, *SelectionInformationPtr;
+
+typedef struct _SelectionItemInformation {
+  bool IsSelected;
+  ElementInformationPtr Container;
+
+  _SelectionItemInformation(SelectionItemPattern::SelectionItemPatternInformation^ info) {
+    init(info->IsSelected, Element::From(info->SelectionContainer));
+  }
+
+  _SelectionItemInformation(bool isSelected, Element^ selectionContainer) { // for testing
+    init(isSelected, selectionContainer);
+  }
+
+  ~_SelectionItemInformation() {
+    delete Container;
+  }
+
+private:
+  void init(bool isSelected, Element^ selectionContainer) {
+    IsSelected = isSelected;
+    Container = new ElementInformation(selectionContainer);
+  }
+
+} SelectionItemInformation, *SelectionItemInformationPtr;
+
+
+typedef struct _ExpandCollapseInfo {
+  char* ExpandCollapseState;
+
+  _ExpandCollapseInfo(String^ expandCollapseState) {
+    ExpandCollapseState = StringHelper::ToUnmanaged(expandCollapseState);
+  }
+  
+  ~_ExpandCollapseInfo() {
+    delete[] ExpandCollapseState;
+  }
+} ExpandCollapseInfo, *ExpandCollapseInfoPtr;

data/ext/UiaDll/UiaDll/SelectionItemMethods.cpp

@@ -0,0 +1,40 @@
+#include "Stdafx.h"
+
+extern "C" {
+  __declspec(dllexport) void SelectionItem_Release(SelectionItemInformationPtr selectionItemInfo) {
+    delete selectionItemInfo;
+  }
+
+  __declspec(dllexport) SelectionItemInformationPtr SelectionItem_Information(ElementInformationPtr element, char* errorInfo, const int errorInfoLength) {
+    try {
+      auto info = Find(element)->As<SelectionItemPattern^>(SelectionItemPattern::Pattern)->Current;
+      return new SelectionItemInformation(info);
+    } catch(Exception^ e) {
+      StringHelper::CopyToUnmanagedString(e->Message, errorInfo, errorInfoLength);
+    }
+  }
+
+  __declspec(dllexport) void SelectionItem_Select(ElementInformationPtr element, char* errorInfo, const int errorInfoLength) {
+    try {
+      Find(element)->As<SelectionItemPattern^>(SelectionItemPattern::Pattern)->Select();
+    } catch(Exception^ e) {
+      StringHelper::CopyToUnmanagedString(e->Message, errorInfo, errorInfoLength);
+    }
+  }
+
+  __declspec(dllexport) void SelectionItem_AddToSelection(ElementInformationPtr element, char* errorInfo, const int errorInfoLength) {
+    try {
+      Find(element)->As<SelectionItemPattern^>(SelectionItemPattern::Pattern)->AddToSelection();
+    } catch(Exception^ e) {
+      StringHelper::CopyToUnmanagedString(e->Message, errorInfo, errorInfoLength);
+    }
+  }
+
+  __declspec(dllexport) void SelectionItem_RemoveFromSelection(ElementInformationPtr element, char* errorInfo, const int errorInfoLength) {
+    try {
+      Find(element)->As<SelectionItemPattern^>(SelectionItemPattern::Pattern)->RemoveFromSelection();
+    } catch(Exception^ e) {
+      StringHelper::CopyToUnmanagedString(e->Message, errorInfo, errorInfoLength);
+    }
+  }
+}

data/ext/UiaDll/UiaDll/SelectionMethods.cpp

@@ -0,0 +1,16 @@
+#include "Stdafx.h"
+
+extern "C" {
+  __declspec(dllexport) void Selection_Release(SelectionInformationPtr selectionInfo) {
+    delete selectionInfo;
+  }
+
+  __declspec(dllexport) SelectionInformationPtr Selection_Information(ElementInformationPtr element, char* errorInfo, const int errorInfoLength) {
+    try {
+      return new SelectionInformation(Find(element)->As<SelectionPattern^>(SelectionPattern::Pattern)->Current);
+    } catch(Exception^ e) {
+      StringHelper::CopyToUnmanagedString(e->Message, errorInfo, errorInfoLength);
+      return NULL;
+    }
+  }
+}

data/ext/UiaDll/UiaDll/Stdafx.h

@@ -12,3 +12,6 @@ using namespace UIA::Helper;
 #include "StringHelper.h"
 #include "ArrayHelper.h"
 #include "ElementStructures.h"
+#include "PatternInformationStructures.h"
+
+extern "C" Element^ Find(ElementInformationPtr element);

data/ext/UiaDll/UiaDll/ToggleMethods.cpp

@@ -0,0 +1,25 @@
+#include "Stdafx.h"
+
+extern "C" {
+  __declspec(dllexport) void Toggle_Release(ToggleInformationPtr toggleInfo) {
+    delete toggleInfo;
+  }
+
+  __declspec(dllexport) ToggleInformationPtr Toggle_Information(ElementInformationPtr element, char* errorInfo, const int errorInfoLength) {
+    try {
+      auto info = Find(element)->As<TogglePattern^>(TogglePattern::Pattern)->Current;
+      return new ToggleInformation(info.ToggleState.ToString());
+    } catch(Exception^ e) {
+      StringHelper::CopyToUnmanagedString(e->Message, errorInfo, errorInfoLength);
+      return NULL;
+    }
+  }
+
+  __declspec(dllexport) void Toggle(ElementInformationPtr element, char* errorInfo, const int errorInfoLength) {
+    try {
+      Find(element)->As<TogglePattern^>(TogglePattern::Pattern)->Toggle();
+    } catch(Exception^ e) {
+      StringHelper::CopyToUnmanagedString(e->Message, errorInfo, errorInfoLength);
+    }
+  }
+}

data/ext/UiaDll/UiaDll/UiaDll.vcxproj

@@ -74,11 +74,14 @@
     <Reference Include="System" />
     <Reference Include="System.Data" />
     <Reference Include="System.Xml" />
+    <Reference Include="UIAutomationClient" />
+    <Reference Include="UIAutomationTypes" />
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="ArrayHelper.h" />
     <ClInclude Include="DynamicAssemblyResolver.h" />
     <ClInclude Include="ElementStructures.h" />
+    <ClInclude Include="PatternInformationStructures.h" />
     <ClInclude Include="Stdafx.h" />
     <ClInclude Include="StringHelper.h" />
   </ItemGroup>
@@ -86,11 +89,17 @@
     <ClCompile Include="AssemblyInfo.cpp" />
     <ClCompile Include="DynamicAssemblyResolver.cpp" />
     <ClCompile Include="ElementMethods.cpp" />
+    <ClCompile Include="ExpandCollapseMethods.cpp" />
+    <ClCompile Include="InvokePatternMethods.cpp" />
+    <ClCompile Include="SelectionItemMethods.cpp" />
+    <ClCompile Include="SelectionMethods.cpp" />
     <ClCompile Include="Stdafx.cpp">
       <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">Create</PrecompiledHeader>
       <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">Create</PrecompiledHeader>
     </ClCompile>
+    <ClCompile Include="ToggleMethods.cpp" />
     <ClCompile Include="UiaDll.cpp" />
+    <ClCompile Include="ValuePatternMethods.cpp" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\UIA.Helper\UIA.Helper.csproj">

data/ext/UiaDll/UiaDll/UiaDll.vcxproj.filters

@@ -13,6 +13,9 @@
       <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
       <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
     </Filter>
+    <Filter Include="Source Files\Patterns">
+      <UniqueIdentifier>{a1dddb33-e832-4b83-b6d7-46462084fad2}</UniqueIdentifier>
+    </Filter>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="Stdafx.h">
@@ -30,6 +33,9 @@
     <ClInclude Include="ElementStructures.h">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="PatternInformationStructures.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="UiaDll.cpp">
@@ -47,5 +53,23 @@
     <ClCompile Include="ElementMethods.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="ValuePatternMethods.cpp">
+      <Filter>Source Files\Patterns</Filter>
+    </ClCompile>
+    <ClCompile Include="InvokePatternMethods.cpp">
+      <Filter>Source Files\Patterns</Filter>
+    </ClCompile>
+    <ClCompile Include="ToggleMethods.cpp">
+      <Filter>Source Files\Patterns</Filter>
+    </ClCompile>
+    <ClCompile Include="SelectionItemMethods.cpp">
+      <Filter>Source Files\Patterns</Filter>
+    </ClCompile>
+    <ClCompile Include="SelectionMethods.cpp">
+      <Filter>Source Files\Patterns</Filter>
+    </ClCompile>
+    <ClCompile Include="ExpandCollapseMethods.cpp">
+      <Filter>Source Files\Patterns</Filter>
+    </ClCompile>
   </ItemGroup>
 </Project>

data/ext/UiaDll/UiaDll/ValuePatternMethods.cpp

@@ -0,0 +1,25 @@
+#include "Stdafx.h"
+
+extern "C" {
+  __declspec(dllexport) void Value_Release(ValuePatternInformationPtr valueInformation) {
+    delete valueInformation;
+  }
+
+  __declspec(dllexport) void Value_Set(ElementInformationPtr element, const char* value, char* errorInfo, const int errorInfoLength) {
+    try {
+      Find(element)->As<ValuePattern^>(ValuePattern::Pattern)->SetValue(gcnew String(value));
+    } catch(Exception^ e) {
+      StringHelper::CopyToUnmanagedString(e->Message, errorInfo, errorInfoLength);
+    }
+  }
+
+  __declspec(dllexport) ValuePatternInformationPtr Value_Information(ElementInformationPtr element, char* errorInfo, const int errorInfoLength) {
+    try {
+      auto valuePattern = Find(element)->As<ValuePattern^>(ValuePattern::Pattern);
+      return new ValuePatternInformation(valuePattern->Current);
+    } catch(Exception^ e) {
+      StringHelper::CopyToUnmanagedString(e->Message, errorInfo, errorInfoLength);
+      return NULL;
+    }
+  }
+}

data/lib/uia.rb

@@ -1,21 +1,29 @@
 require 'uia/version'
 require 'uia/library'
-require 'uia/element'
 require 'uia/library/constants'
+require 'uia/element'
+require 'uia/finder'
 
 module Uia
   class BadLocator < StandardError; end
+  extend Finder
+
+  def self.children
+    Library.root_children.children
+  end
 
-  def find_element(how)
+  def self.find_element(how)
     case
       when how[:id]
-        Element.new Library.find_by_id(how[:id])
+        find_by_id how[:id]
+      when how[:name]
+        find_by_name how[:name]
       when how[:pid]
-        Element.new Library.find_by_pid(how[:pid])
+        find_by_pid how[:pid]
       when how[:runtime_id]
-        Element.new Library.find_by_runtime_id(how[:runtime_id])
+        find_by_runtime_id how[:runtime_id]
       when how[:handle]
-        Element.new Library.find_by_handle(how[:handle])
+        find_by_handle how[:handle]
       else
         raise BadLocator, "#{how} is not a valid locator"
     end

data/lib/uia/element.rb

@@ -1,20 +1,51 @@
+require 'uia/patterns/expand_collapse'
+require 'uia/patterns/invoke'
+require 'uia/patterns/selection'
+require 'uia/patterns/selection_item'
+require 'uia/patterns/toggle'
+require 'uia/patterns/value'
+require 'uia/library/element_attributes'
+
 module Uia
   class Element
+    extend ElementAttributes
+
     def initialize(element)
       @element = element
       @default = lambda { [:unknown] }
     end
 
+    element_attr :id, :name, :handle, :runtime_id, :enabled?, :class_name
+
     def control_type
-      Library::Constants::ControlTypes.find(@default) { |_, v| v == control_type_id }.first
+      Library::Constants::ControlTypes.find(@default) { |_, v| v == @element.control_type_id }.first
     end
 
-    def patterns
-      pattern_ids.map do |id|
-        Library::Constants::Patterns.find(@default) { |_, v| v == id }.first
+    def refresh
+      Library.refresh @element
+      self
+    end
+
+    def find(locator)
+      case
+        when locator[:id]
+          Library::find_child_by_id(@element, locator[:id])
+        when locator[:name]
+          Library::find_child_by_name(@element, locator[:name])
       end
     end
 
+    def as(pattern)
+      which =  "Uia::Patterns::#{pattern.to_s.capitalize}".split('::').reduce(Object) do |m, current|
+        m.const_get current.split('_').map(&:capitalize).join
+      end
+      extend which
+    end
+
+    def patterns
+      @element.pattern_ids.map {|id| Library::Constants::Patterns.find(@default) { |_, v| v == id }.first }
+    end
+
     def children
       @element.children.map { |c| Element.new c }
     end
@@ -27,12 +58,5 @@ module Uia
       Library.click(@element)
       true
     end
-
-    def method_missing(meth, *args, &block)
-      if @element.respond_to? meth
-        return @element.send(meth, *args, &block)
-      end
-      super
-    end
   end
 end