rautomation 2.0.1-x64-mingw32

data/ext/UiaDll/RAutomation.UIA/Controls/Clicker.cs

@@ -0,0 +1,63 @@
+using System;
+using System.Runtime.InteropServices;
+using System.Threading;
+using System.Windows;
+using System.Windows.Automation;
+using System.Windows.Forms;
+using RAutomation.UIA.Extensions;
+
+namespace RAutomation.UIA.Controls
+{
+    public class Clicker
+    {
+        [DllImport("user32.dll")]
+        static extern void mouse_event(uint flags, uint x, uint y, uint data, int extraInfo);
+
+        [Flags]
+        public enum MouseEvent
+        {
+            Leftdown = 0x00000002,
+            Leftup = 0x00000004,
+        }
+
+        private const uint MOUSEEVENTLF_LEFTDOWN = 0x2;
+        private const uint MOUSEEVENTLF_LEFTUP = 0x4;
+
+        public static bool Click(AutomationElement element)
+        {
+            try
+            {
+                if (AutomationElement.IsInvokePatternAvailableProperty.In(element))
+                {
+                    element.As<InvokePattern>(InvokePattern.Pattern).Invoke();
+                }
+                else if (AutomationElement.IsTogglePatternAvailableProperty.In(element))
+                {
+                    element.AsTogglePattern().Toggle();
+                }
+                else if (AutomationElement.IsSelectionItemPatternAvailableProperty.In(element))
+                {
+                    element.AsSelectionItem().Select();
+                }
+
+                return true;
+            }
+            catch (Exception e)
+            {
+                Console.WriteLine(e);
+                return false;
+            }
+        }
+
+        public static void MouseClick(AutomationElement element)
+        {
+            element.ScrollToIfPossible();
+            element.SetFocus();
+
+            var clickablePoint = element.GetClickablePoint();
+            Cursor.Position = new System.Drawing.Point((int)clickablePoint.X, (int)clickablePoint.Y);
+            mouse_event(MOUSEEVENTLF_LEFTDOWN, 0, 0, 0, 0);
+            mouse_event(MOUSEEVENTLF_LEFTUP, 0, 0, 0, 0);
+        }
+    }
+}

data/ext/UiaDll/RAutomation.UIA/Controls/SelectList.cs

@@ -0,0 +1,116 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Windows;
+using System.Windows.Automation;
+using RAutomation.UIA.Extensions;
+using RAutomation.UIA.Properties;
+
+namespace RAutomation.UIA.Controls
+{
+    public class SelectList
+    {
+        private readonly AutomationElement _element;
+
+        public SelectList(AutomationElement element)
+        {
+            _element = element;
+        }
+
+        public string[] Options
+        {
+            get { return SelectionItems.Names().ToArray(); }
+        }
+
+        public int Count
+        {
+            get { return SelectionItems.Count(); }
+        }
+
+        public int SelectedIndex
+        {
+            get { return SelectionItems.IndexOf(IsSelected); }
+            set { Select(SelectionItems.ElementAt(value)); }
+        }
+
+        public string At(int index)
+        {
+            return SelectionItems.ElementAt(index).Current.Name;
+        }
+
+        public string Selection
+        {
+            get
+            {
+                var selection = SelectionItems.FirstOrDefault(IsSelected);
+                return null == selection ? "" : selection.Current.Name;
+            }
+            set
+            {
+                Select(SelectionItems.First(x => x.Current.Name == value));
+            }
+        }
+
+        public string[] Selections
+        {
+            get { return SelectionPattern.GetSelection().Select(x => x.Current.Name).ToArray(); }
+        }
+
+        public void Remove(int index)
+        {
+            SelectionItems.ElementAt(index).AsSelectionItem().RemoveFromSelection();
+        }
+
+        public void Remove(string value)
+        {
+            SelectionNamed(value).RemoveFromSelection();
+        }
+
+        private void Select(AutomationElement element)
+        {
+            if (SelectionPattern.CanSelectMultiple)
+                MultipleSelect(element);
+            else
+                SingleSelect(element);
+        }
+
+        private static void MultipleSelect(AutomationElement element)
+        {
+            element.AsSelectionItem().AddToSelection();
+        }
+
+        private static void SingleSelect(AutomationElement element)
+        {
+            var selectionItem = element.AsSelectionItem();
+
+            try
+            {
+                Clicker.MouseClick(element);
+            }
+            catch { }
+
+            if (!selectionItem.Current.IsSelected)
+                selectionItem.Select();
+        }
+
+        private SelectionPattern.SelectionPatternInformation SelectionPattern
+        {
+            get { return _element.As<SelectionPattern>(System.Windows.Automation.SelectionPattern.Pattern).Current; }
+        }
+
+        private SelectionItemPattern SelectionNamed(string value)
+        {
+            return SelectionItems.First(x => x.Current.Name == value).AsSelectionItem();
+        }
+
+        private static bool IsSelected(AutomationElement element)
+        {
+            return element.AsSelectionItem().Current.IsSelected;
+        }
+
+        private IEnumerable<AutomationElement> SelectionItems
+        {
+            get { return _element.Find(AutomationProperties.IsSelectionItem); }
+        }
+    }
+}

data/ext/UiaDll/RAutomation.UIA/Controls/Spinner.cs

@@ -0,0 +1,46 @@
+using System.Windows.Automation;
+using RAutomation.UIA.Extensions;
+
+namespace RAutomation.UIA.Controls
+{
+    public class Spinner
+    {
+        private readonly AutomationElement _element;
+
+        public Spinner(AutomationElement element)
+        {
+            _element = element;
+        }
+
+        public double Value
+        {
+            get { return RangeValue.Current.Value; }
+            set { RangeValue.SetValue(value); }
+        }
+
+        public double Minimum
+        {
+            get { return RangeValue.Current.Minimum; }
+        }
+
+        public double Maximum
+        {
+            get { return RangeValue.Current.Maximum; }
+        }
+
+        public double Increment()
+        {
+            return Value += RangeValue.Current.SmallChange;
+        }
+
+        public double Decrement()
+        {
+            return Value -= RangeValue.Current.SmallChange;
+        }
+
+        private RangeValuePattern RangeValue
+        {
+            get { return _element.As<RangeValuePattern>(RangeValuePattern.Pattern); }
+        }
+    }
+}

data/ext/UiaDll/RAutomation.UIA/Controls/TabControl.cs

@@ -0,0 +1,54 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Windows.Automation;
+using RAutomation.UIA.Extensions;
+
+namespace RAutomation.UIA.Controls
+{
+    public class TabControl
+    {
+        private readonly AutomationElement _element;
+
+        public TabControl(AutomationElement element)
+        {
+            _element = element;
+        }
+
+        public string[] TabNames
+        {
+            get { return TabItems.Select(x => x.Current.Name).ToArray(); }
+        }
+
+        public string Selection
+        {
+            get { return TabItems.First(IsSelected).Current.Name; }
+            set { TabItems.First(x => x.Current.Name == value).AsSelectionItem().Select(); }
+        }
+
+        public int SelectedIndex
+        {
+            get { return TabItems.IndexOf(IsSelected); }
+            set { SelectionItems.ElementAt(value).Select(); }
+        }
+
+        private static bool IsSelected(AutomationElement tabItem)
+        {
+            return tabItem.AsSelectionItem().Current.IsSelected;
+        }
+
+        private IEnumerable<AutomationElement> TabItems
+        {
+            get { return _element.Find(IsTabItem); }
+        }
+
+        private IEnumerable<SelectionItemPattern> SelectionItems
+        {
+            get { return TabItems.AsSelectionItems(); }
+        }
+
+        private static Condition IsTabItem
+        {
+            get { return new PropertyCondition(AutomationElement.ControlTypeProperty, ControlType.TabItem); }
+        }
+    }
+}

data/ext/UiaDll/RAutomation.UIA/Controls/TableControl.cs

@@ -0,0 +1,132 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Windows.Automation;
+using RAutomation.UIA.Extensions;
+using RAutomation.UIA.Properties;
+
+namespace RAutomation.UIA.Controls
+{
+    public class TableControl
+    {
+        private readonly AutomationElement _element;
+
+        public TableControl(AutomationElement element)
+        {
+            _element = element;
+        }
+
+        public int RowCount
+        {
+            get { return _element.As<TablePattern>(TablePattern.Pattern).Current.RowCount; }
+        }
+
+        public int SelectedIndex
+        {
+            get { return SelectionItems.IndexOf(x => x.Current.IsSelected); }
+            set { Select(value); }
+        }
+
+        public int[] SelectedIndexes
+        {
+            get { return DataItems.IndexesOf(x => x.AsSelectionItem().Current.IsSelected); }
+        }
+
+        public bool IsRowSelected(int dataItemIndex)
+        {
+            return DataItems.ElementAt(dataItemIndex).AsSelectionItem().Current.IsSelected;
+        }
+
+        public void Remove(int dataItemIndex)
+        {
+            DataItems.ElementAt(dataItemIndex).AsSelectionItem().RemoveFromSelection();
+        }
+
+        public void Remove(string dataItemValue)
+        {
+            DataItems.FirstOrDefault(x => x.Current.Name == dataItemValue).AsSelectionItem().RemoveFromSelection();
+        }
+
+        public string Value
+        {
+            set { Select(value); }
+        }
+
+        public bool Exists(int row, int column)
+        {
+            return At(row, column).Exists();
+        }
+
+        public string ValueAt(int row, int column)
+        {
+            return At(row, column).Current.Name;
+        }
+
+        public AutomationElement At(int row, int column)
+        {
+            return _element.FindOne(IsTableItem, GridItemPattern.ColumnProperty.Is(column), GridItemPattern.RowProperty.Is(row));
+        }
+
+        public string[] Headers
+        {
+            get { return _element.Find(ControlType.HeaderItem.Condition()).Select(x => x.Current.Name).ToArray(); }
+        }
+
+        public string[] Values
+        {
+            get { return TableOrListItems.Select(x => x.Current.Name).ToArray(); }
+        }
+
+        public void SingleSelect(int value)
+        {
+            DataItems.ElementAt(value).AsSelectionItem().Select();
+        }
+
+        private void Select(int value)
+        {
+            var selectionItem = DataItems.ElementAt(value).AsSelectionItem();
+
+            if (SelectionPattern.CanSelectMultiple)
+                selectionItem.AddToSelection();
+            else
+                selectionItem.Select();
+        }
+
+        private SelectionPattern.SelectionPatternInformation SelectionPattern
+        {
+            get { return _element.As<SelectionPattern>(SelectionPatternIdentifiers.Pattern).Current; }
+        }
+
+        private void Select(string value)
+        {
+            SelectionElements.First(x => x.Current.Name == value).AsSelectionItem().Select();
+        }
+
+        private IEnumerable<SelectionItemPattern> SelectionItems
+        {
+            get { return SelectionElements.Select(x => x.As<SelectionItemPattern>(SelectionItemPattern.Pattern)); }
+        }
+
+        private IEnumerable<AutomationElement> DataItems
+        {
+            get
+            {
+                return _element.Find(AutomationProperties.IsDataItem);
+            }
+        }
+
+        private IEnumerable<AutomationElement> SelectionElements
+        {
+            get { return _element.Find(AutomationProperties.IsSelectionItem); }
+        }
+
+        private IEnumerable<AutomationElement> TableOrListItems
+        {
+            get { return _element.FindAny(IsTableItem, ControlType.ListItem.Condition()); }
+        }
+
+        private static Condition IsTableItem
+        {
+            get { return AutomationElement.IsTableItemPatternAvailableProperty.TrueCondition(); }
+        }
+    }
+}

data/ext/UiaDll/RAutomation.UIA/Controls/TextControl.cs

@@ -0,0 +1,50 @@
+using System.Runtime.Remoting.Services;
+using System.Windows.Automation;
+using System.Windows.Forms;
+using RAutomation.UIA.Extensions;
+
+namespace RAutomation.UIA.Controls
+{
+    public class TextControl
+    {
+        private readonly AutomationElement _element;
+
+        public TextControl(AutomationElement element)
+        {
+            _element = element;
+        }
+
+        public string Value
+        {
+            get { return _element.IsValuePattern() ? TextValue : DocumentText; }
+            set
+            {
+                if (_element.IsValuePattern())
+                    TextValue = value;
+                else
+                    DocumentText = value;
+            }
+        }
+
+        private string DocumentText
+        {
+            get { return _element.AsTextPattern().DocumentRange.GetText(-1); }
+            set
+            {
+                _element.SetFocus();
+                Enter("^{HOME}", "^+{END}", "{DEL}", value);
+            }
+        }
+
+        private static void Enter(params string[] keys)
+        {
+            keys.ForEach(SendKeys.SendWait);
+        }
+
+        private string TextValue
+        {
+            get { return _element.AsValuePattern().Current.Value; }
+            set { _element.AsValuePattern().SetValue(value);  }
+        }
+    }
+}

data/ext/UiaDll/RAutomation.UIA/Expander.cs

@@ -0,0 +1,59 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Windows.Automation;
+using RAutomation.UIA.Extensions;
+
+namespace RAutomation.UIA
+{
+    public class ExpandibleCollapsibleContainer
+    {
+        protected readonly AutomationElement _element;
+
+        protected ExpandibleCollapsibleContainer(AutomationElement element)
+        {
+            _element = element;
+        }
+
+        protected IEnumerable<ExpandCollapsePattern> ExpandCollapsItems
+        {
+            get { return Elements.Select(x => x.As<ExpandCollapsePattern>(ExpandCollapsePattern.Pattern)); }
+        }
+
+        protected IEnumerable<AutomationElement> Elements
+        {
+            get { return _element.Find(AutomationElement.IsExpandCollapsePatternAvailableProperty.TrueCondition()); }
+        }
+    }
+
+    public class Expander : ExpandibleCollapsibleContainer
+    {
+        public Expander(AutomationElement element) : base(element)
+        {}
+
+        public void Expand(int index)
+        {
+            ExpandCollapsItems.ElementAt(index).Expand();
+        }
+
+        public void Expand(string value)
+        {
+            Elements.FirstOrDefault(x => x.Current.Name == value).As<ExpandCollapsePattern>(ExpandCollapsePattern.Pattern).Expand();
+        }
+    }
+
+    public class Collapser : ExpandibleCollapsibleContainer
+    {
+        public Collapser(AutomationElement element) : base(element)
+        {}
+
+        public void Collapse(int index)
+        {
+            ExpandCollapsItems.ElementAt(index).Collapse();
+        }
+
+        public void Collapse(string value)
+        {
+            Elements.FirstOrDefault(x => x.Current.Name == value).As<ExpandCollapsePattern>(ExpandCollapsePattern.Pattern).Collapse();
+        }
+    }
+}

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

@@ -0,0 +1,166 @@
+using System;
+using System.Threading;
+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 string HelpText(this AutomationElement automationElement)
+        {
+            return automationElement.Current.HelpText;
+        }
+
+        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 SendKeys(this AutomationElement automationElement, string keysToSend)
+        {
+            automationElement.SetFocus();
+            System.Windows.Forms.SendKeys.SendWait(keysToSend);
+        }
+
+        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 bool CanScrollTo(this AutomationElement automationElement)
+        {
+            return (bool)automationElement.GetCurrentPropertyValue(AutomationElement.IsScrollItemPatternAvailableProperty);
+        }
+
+        public static ScrollItemPattern AsScrollItem(this AutomationElement automationElement)
+        {
+            return automationElement.As<ScrollItemPattern>(ScrollItemPatternIdentifiers.Pattern);
+        }
+
+        public static bool HasClickablePoint(this AutomationElement automationElement)
+        {
+            Point point;
+            return automationElement.TryGetClickablePoint(out point);
+        }
+
+        public static bool ScrollToIfPossible(this AutomationElement automationElement)
+        {
+            if (!automationElement.CanScrollTo())
+            {
+                return false;
+            }
+
+            if (!automationElement.HasClickablePoint())
+            {
+                automationElement.AsScrollItem().ScrollIntoView();
+                automationElement.WaitUntilClickable(3);
+            }
+
+            return true;
+        }
+
+        public static void WaitUntilClickable(this AutomationElement automationElement, int howManySeconds)
+        {
+            var then = DateTime.Now;
+            while (!automationElement.HasClickablePoint())
+            {
+                Thread.Sleep(1);
+                if ((DateTime.Now - then).Seconds > howManySeconds)
+                {
+                    throw new Exception(string.Format("Waited for more than {0} seconds to be able to click this", howManySeconds));
+                }
+            }
+        }
+
+        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);
+        }
+    }
+}