rautomation 0.10.0 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6d214593bdd0a96a896107ac65185546ba21fb97
-  data.tar.gz: 7067fcd4ff5bfdbdd0e3ea57528337de1b3a0003
+  metadata.gz: ba425fe2212cdb7f9f34623423af85e658b97977
+  data.tar.gz: 3e0b9423dc16e4bfdaa1f6e94d409076dc859ce6
 SHA512:
-  metadata.gz: d32f355823ab33e46aa0ee8400dd2771d3c027a5773e4b57271c5af4c8ca6de2178d1fe2a4227b423d5cfa257d5b6ada7177af120d29760826fbf24ca31bb45b
-  data.tar.gz: 5b84555b5f03746d8d395015a4b521dc676167045af85a4c55ed35d116a3c03212ff22086de3bc2239332e14084ee296eea548a5298de833c1d2112a8b57c7d6
+  metadata.gz: 43102aa78240ef7dc3a270ee1037cc8f02cd91c39f795eb362d403da5fc27285c2a390013b397f78d478444adcc8228405fbff71d585a0e5bc744032b55c11a9
+  data.tar.gz: d1a8f0f19361f7f26067e8b14513a3c76a1506cef9c1cb33fb26bf1586f4e2706022deb8309e229c1b10fe954901b4e2582eb6c75cbcdaafabb8ee0d708cff3e

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    rautomation (0.10.0)
+    rautomation (0.11.0)
       ffi
 
 GEM

data/History.rdoc

@@ -1,4 +1,10 @@
-== 0.9.5
+== 0.11.0 / 2013-08-10
+
+=== MsUia adapter
+
+  * Add support for Window#spinner
+
+== 0.10.0 / 2013-07-26
 
 === MsUia adapter
 

data/VERSION

@@ -1 +1 @@
-0.10.0
+0.11.0

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

@@ -0,0 +1,59 @@
+using System;
+using System.Runtime.InteropServices;
+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.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,76 @@
+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 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));
+            }
+        }
+
+        private static void Select(AutomationElement element)
+        {
+            var selectionItem = element.AsSelectionItem();
+
+            try
+            {
+                Clicker.MouseClick(element);
+            }
+            catch { }
+
+            if (!selectionItem.Current.IsSelected)
+                selectionItem.Select();
+        }
+
+        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,87 @@
+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 { DataItems.ElementAt(value).AsSelectionItem().Select(); }
+        }
+
+        public string Value
+        {
+            set { SelectionElements.First(x => x.Current.Name == value).AsSelectionItem().Select(); }
+        }
+
+        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(); }
+        }
+
+        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();
+        }
+    }
+}