// CONSIDER: This will run on our automation thread // Should be OK to call MoveWindow from there - it just posts messages to the window. void TestMoveWindow(AutomationElement listWindow, int xOffset, int yOffset) { var hwndList = (IntPtr)(int)(listWindow.GetCurrentPropertyValue(AutomationElement.NativeWindowHandleProperty)); var listRect = (Rect)listWindow.GetCurrentPropertyValue(AutomationElement.BoundingRectangleProperty); Debug.Print("Moving from {0}, {1}", listRect.X, listRect.Y); Win32Helper.MoveWindow(hwndList, (int)listRect.X - xOffset, (int)listRect.Y - yOffset, (int)listRect.Width, 2 * (int)listRect.Height, true); }
/// ------------------------------------------------------------------- /// <summary></summary> /// ------------------------------------------------------------------- internal ScrollItemPatternWrapper(AutomationElement element, string testSuite, TestPriorities priority, TypeOfControl typeOfControl, TypeOfPattern typeOfPattern, string dirResults, bool testEvents, IApplicationCommands commands) : base(element, testSuite, priority, typeOfControl, typeOfPattern, dirResults, testEvents, commands) { Comment("Creating ScrollItemTests"); _pattern = (ScrollItemPattern)GetPattern(m_le, m_useCurrent, ScrollItemPattern.Pattern); if (_pattern == null) ThrowMe(CheckType.IncorrectElementConfiguration, Helpers.PatternNotSupported + ": ScrollItemPattern"); // Find the ScrollPattern _container = m_le; while (_container != null && !(bool)_container.GetCurrentPropertyValue(AutomationElement.IsScrollPatternAvailableProperty)) _container = TreeWalker.ControlViewWalker.GetParent(_container); // Check to see if we actual found the container of the scrollitem if (_container == null) ThrowMe(CheckType.IncorrectElementConfiguration, "Element does not have a container with ScrollPattern"); Comment("Found scroll container: " + Library.GetUISpyLook(_container)); _scrollPattern = (ScrollPattern)_container.GetCurrentPattern(ScrollPattern.Pattern) as ScrollPattern; }
/// <summary> /// Creates TreeNode for the AutomationElement /// </summary> public static TreeNode CreateNodeForAutomationElement(AutomationElement element, AutomationElementTreeControl parentControl) { // System.Diagnostics.Debug.WriteLine("CreateNodeForAutomationElement..."); TreeNode node = new TreeNode(TreeHelper.GetAutomationElementTreeNodeText(element)); node.Tag = new AutomationElementTreeNode(element, node, parentControl); if ((bool)element.GetCurrentPropertyValue(AutomationElement.IsContentElementProperty)) { node.ForeColor = Color.Black; //.NodeFont = new Font(FontFamily.GenericSerif, 10, FontStyle.Bold); } else { node.ForeColor = Color.DarkGray; } /*************************************************/ // this is only for test purposes, it makes the creation of each TreeNode slower //DateTime now = DateTime.Now; //DateTime endTime = now.AddMilliseconds(400); //while (DateTime.Now < endTime) ; /*************************************************/ // System.Diagnostics.Debug.WriteLine("CreateNodeForAutomationElement EXIT"); return node; }
/// <summary> /// Check to see if the specified automation element meets the requirements of the specified condition. /// </summary> /// <param name="condition">The condition to check.</param> /// <param name="element">The automation element to check.</param> /// <returns>True if the automation element meets the condition's requirements. False otherwise.</returns> public static bool IsMeetsRequirements(Condition condition, AutomationElement element) { var type = condition.GetType(); if (condition == Condition.TrueCondition) // Always return true. return true; if (condition == Condition.FalseCondition) // Always returns false. return false; if (type == typeof(NotCondition)) // Return the negation of the inner condition. return !IsMeetsRequirements(((NotCondition) condition).Condition, element); if (type == typeof(OrCondition)) // Return true if any of the inner conditions are true. return ((OrCondition) condition).GetConditions().Any(inner => IsMeetsRequirements(inner, element)); if (type == typeof(AndCondition)) // Return true if all of the inner conditions are true. return ((AndCondition) condition).GetConditions().All(inner => IsMeetsRequirements(inner, element)); if (type == typeof(StringPropertyCondition)) // Return true if the string property condition matches. return ((StringPropertyCondition) condition).IsMatch(element); if (type == typeof(PropertyCondition)) { // Return true if the property condition matches. var propertyCondition = (PropertyCondition) condition; var actual = element.GetCurrentPropertyValue(propertyCondition.Property); var expected = propertyCondition.Value; Trace.WriteLine("Checking '" + AutomationPropertyHelper.ToString(actual) + "'='" + AutomationPropertyHelper.ToString(expected) + "'", "UIAutomation-ConditionHelper"); return AutomationPropertyHelper.Equals(actual, expected); } // Don't know how to match any other conditions. throw new NotSupportedException("Condition '" + type + "' is not supported"); }
public static void LogProperties(AutomationElement element) { AutomationProperty[] automationProperties = element.GetSupportedProperties(); foreach (AutomationProperty automationProperty in automationProperties) { Logger.Info(automationProperty.ProgrammaticName + ":" + element.GetCurrentPropertyValue(automationProperty)); } }
/// <summary> /// Check if the specified automation element meets this condition's requirements. /// </summary> /// <param name="element">The element to check.</param> /// <returns>True if the automation element meets this condition's requirements.</returns> public bool IsMatch(AutomationElement element) { var actualObj = element.GetCurrentPropertyValue(Property); // If the element's current property value is null or not a string object, return false. if (actualObj == null || !(actualObj is string)) return false; // Otherwise cast to strings... var actual = (string) actualObj; var expected = (string) Value; // ... and compare them. return Matcher.IsMatch(actual, expected); }
internal override bool AppliesTo(AutomationElement element) { // TODO: Test caching behavior object currentVal = element.GetCurrentPropertyValue(property); object conditionVal = val; if (currentVal == null || conditionVal == null) { return(currentVal == conditionVal); } // Compare AutomationElements against Condition's // stored runtime ID array if (property == AEIds.LabeledByProperty || property == GridItemPatternIdentifiers.ContainingGridProperty || property == SelectionItemPatternIdentifiers.SelectionContainerProperty) { AutomationElement elementVal = currentVal as AutomationElement; int [] conditionId = conditionVal as int []; return(currentVal != null && conditionId != null && Automation.Compare(conditionId, elementVal.GetRuntimeId())); } // For some other properties, need to reconstruct proper // object for comparison if (property == AEIds.BoundingRectangleProperty) { double [] rectArray = (double [])val; conditionVal = new Rect(rectArray [0], rectArray [1], rectArray [2], rectArray [3]); } else if (property == AEIds.ClickablePointProperty) { double [] pointArray = (double [])val; conditionVal = new Point(pointArray [0], pointArray [1]); } else if (property == AEIds.ControlTypeProperty) { conditionVal = ControlType.LookupById((int)val); } else if (property == AEIds.CultureProperty) { conditionVal = new CultureInfo((int)val); } return(ArePropertyValuesEqual(conditionVal, currentVal)); }
public static bool Focus(AutoElem e) { if ((bool)e.GetCurrentPropertyValue(AutoElem.IsKeyboardFocusableProperty)) { e.SetFocus(); Console.WriteLine("UIA SetFocused"); return(true); } else { Console.WriteLine("Not UIA KbdFocusable"); } IntPtr ElemHwnd = new IntPtr(e.Current.NativeWindowHandle); if (IntPtr.Zero.Equals(ElemHwnd)) { Console.WriteLine("ElemHwnd Fail"); return(false); } int CurThd = GetCurrentThreadId(); if (CurThd == 0) { Console.WriteLine("GetCurThd Fail"); return(false); } int ElemThd = GetWindowThreadProcessId(ElemHwnd, out _); if (ElemThd == 0) { Console.WriteLine("GetElemThd Fail"); return(false); } if (!AttachThreadInput(CurThd, ElemThd, true)) { Console.WriteLine("Attach Fail"); AttachThreadInput(CurThd, ElemThd, false); return(false); } GetActiveWindow(); Console.WriteLine(GetFocus()); int v2 = SetFocus(ElemHwnd); Console.WriteLine($"{v2}"); AttachThreadInput(CurThd, ElemThd, false); return(v2 != 0); }
internal static string GetPatterns(AutomationElement element) { var properties = element.GetSupportedProperties(); var msg = new StringBuilder(); msg.Append("Supported Properties:\n"); foreach (var automationProperty in properties) { var value = element.GetCurrentPropertyValue(automationProperty); msg.AppendFormat(CultureInfo.InvariantCulture, "{0}: {1}\n", automationProperty.ProgrammaticName, value); } return msg.ToString(); }
public static void GetClassName(AutomationElement autoElement, out string className, out string localizedControlType) { ValidateArgumentNonNull(autoElement, "AutomationElement argument cannot be null"); // Sanity check className = ""; // Initialize localizedControlType = ""; // Get ClassName (edit, richedit and various flavors of each) className = GetClassName(autoElement); // get LocalizedControlType (needed for IPControl, etc.) localizedControlType = (string)autoElement.GetCurrentPropertyValue(AutomationElement.LocalizedControlTypeProperty); if (localizedControlType != null) localizedControlType = localizedControlType.ToUpperInvariant(); // Culture Invariant value for property else throw new InvalidOperationException("LocalizedControlType Property cannot return null"); }
static public object GetPropertyGridValue(Core.UIItems.WindowItems.Window mainWindow, string Name) { Panel propertyView = mainWindow.Get <Panel>(SearchCriteria.ByAutomationId("propertyGrid")); Assert.IsNotNull(propertyView); System.Windows.Automation.AutomationElement elem = propertyView.GetElement(SearchCriteria.ByControlType(System.Windows.Automation.ControlType.Table)); Assert.IsNotNull(elem); Core.UIItems.TableItems.Table table = new Core.UIItems.TableItems.Table(elem, new Core.UIItems.Actions.ProcessActionListener(elem)); Assert.IsNotNull(table); System.Windows.Automation.AutomationElement row = table.GetElement(SearchCriteria.ByText(Name)); Assert.IsNotNull(row); object obj = row.GetCurrentPropertyValue(ValuePattern.ValueProperty); Assert.IsNotNull(obj); return(obj); }
/*private static void OpElem(AutoElem e) { * * /*var Center = ((Rect)last.GetCurrentPropertyValue( * AutomationElement.BoundingRectangleProperty)).Center(); * Console.WriteLine(Center); * SetCursorPos(Center); * LeftClick(Center); LeftClick(Center); * foreach (var i in e.GetSupportedPatterns()) { * Console.WriteLine($"{i.Id}: {i.ProgrammaticName}"); * } * }*/ public static bool Auto(AutoElem e) { if ((bool)e.GetCurrentPropertyValue(AutoElem.IsOffscreenProperty)) { if (ScrollTo(e)) { return(true); } } if (Toggle(e)) { return(true); } if (Select(e)) { return(true); } if (Invoke(e)) { return(true); } return(false); }
/// ------------------------------------------------------------------- /// <summary> /// Test step to get the containing table that has table pattern implemented /// </summary> /// ------------------------------------------------------------------- void TS_GetContainTableByNavigation(AutomationElement element, out AutomationElement table, CheckType ct) { table = element; while ( !(bool)table.GetCurrentPropertyValue(AutomationElement.IsTablePatternAvailableProperty) && element != AutomationElement.RootElement ) { table = TreeWalker.RawViewWalker.GetParent(table); if (table == null) ThrowMe(ct, "There were no ancestors that suupported TablePattern"); } if (element == AutomationElement.RootElement) ThrowMe(ct, "Could not find parent element that supports TablePattern"); Comment("Found containing table w/navigation(" + Library.GetUISpyLook(table) + ")"); m_TestStep++; }
/// ------------------------------------------------------------------- /// <summary></summary> /// ------------------------------------------------------------------- void TS_GetContainGridByNavigation(AutomationElement element, out AutomationElement grid, CheckType ct) { grid = element; while ( !(bool)grid.GetCurrentPropertyValue(AutomationElement.IsGridPatternAvailableProperty) && element != AutomationElement.RootElement ) { grid = TreeWalker.RawViewWalker.GetParent(grid); if (grid == null) ThrowMe(ct, "There were not ancestors that suupported GridPattern"); } if (element == AutomationElement.RootElement) ThrowMe(ct, "Could not find parent element that supports GridPattern"); Comment("Found containing grid w/navigation(" + Library.GetUISpyLook(grid) + ")"); m_TestStep++; }
/// ------------------------------------------------------------------- /// <summary></summary> /// ------------------------------------------------------------------- bool HelperCheckBoxCurrentToggleState(AutomationElement element, ToggleState state) { Library.ValidateArgumentNonNull(element, "AutomationElement"); return ((ToggleState)element.GetCurrentPropertyValue(TogglePattern.ToggleStateProperty) == state); }
/// ------------------------------------------------------------------- /// <summary>Used by Wait*Changed methods</summary> /// ------------------------------------------------------------------- bool HelperWaitVerifySelection(AutomationElement element, string expecetdValue) { Library.ValidateArgumentNonNull(element, "element"); AutomationElement[] selection = (AutomationElement[])element.GetCurrentPropertyValue(SelectionPattern.SelectionProperty); if (selection.Length == 0) return false; return (selection[0].Current.Name == expecetdValue); }
/// ------------------------------------------------------------------- /// <summary></summary> /// ------------------------------------------------------------------- bool HelperVerifyRegistrySettingToControlValue(string key, AutomationElement element, CheckType checkType) { int regValue = (int)HelperGetKeyNameValue(key); switch (element.Current.ControlType.ProgrammaticName) { case "ControlType.CheckBox": { ToggleState ts = (ToggleState)element.GetCurrentPropertyValue(TogglePattern.ToggleStateProperty); Comment("Verify that \"{0}\".ToggleState is {1}", element.Current.Name, ts.ToString()); return regValue == 1 ? ts == ToggleState.On : ts == ToggleState.Off; } default: ThrowMe(CheckType.Verification, "Incorrect argument"); break; } return false; }
/// ------------------------------------------------------------------- /// <summary>Helper: Press button</summary> /// ------------------------------------------------------------------- void HelperPressButton(AutomationElement element, ActionMethod actionBY, CheckType checkType) { Library.ValidateArgumentNonNull(element, "Button AutomationElement"); string name = element.Current.Name; switch (actionBY) { case ActionMethod.KeyPadOnly: { string buffer = element.Current.AccessKey; if (!string.IsNullOrEmpty(buffer)) { // There is an access key so use it Comment("Pressing keyboard access key \"" + element.Current.AccessKey + "\""); Input.SendKeyboardInput(element.Current.AccessKey); } else { // No access key so set focus and press enter Comment("Setting focus to \"{0}\" and pressing ENTER", element.Current.Name); element.SetFocus(); Input.SendKeyboardInput(System.Windows.Input.Key.Enter); } } break; case ActionMethod.MouseClick: { Comment("Moving mouse to \"" + element.Current.Name + "\" and left clicking"); Input.MoveToAndClick(element); } break; default: { if (!(bool)element.GetCurrentPropertyValue(AutomationElement.IsInvokePatternAvailableProperty)) ThrowMe(checkType, "Button \"" + name + "\" does not support Invoke pattern"); Comment("Calling InvokePattern.Invoke() on \"" + name + "\""); ((InvokePattern)element.GetCurrentPattern(InvokePattern.Pattern)).Invoke(); } break; } }
/// ------------------------------------------------------------------- /// <summary></summary> /// ------------------------------------------------------------------- void TS_CollapseMenu(AutomationElement menu, CheckType checkType) { Comment("Collapsing menu(\"{0}\")", menu.Current.Name); if ((ExpandCollapseState.Collapsed != (ExpandCollapseState)menu.GetCurrentPropertyValue(ExpandCollapsePattern.ExpandCollapseStateProperty))) { Input.SendKeyboardInput(System.Windows.Input.Key.Escape, true); Input.SendKeyboardInput(System.Windows.Input.Key.Escape, false); } Wait(WaitForMenuCollapsed, _WAIT_NORMAL_MILLISECONDS, menu, checkType); m_TestStep++; }
/// ------------------------------------------------------------------- /// <summary>Walk the tree up from the AutoamtionElement until we find /// an object that supports WindowPattern. Then move is according to the /// coordinates passed in</summary> /// ------------------------------------------------------------------- internal void TS_MoveElementsWindow(AutomationElement element, double newX, double newY, out Rect orginalRect, out AutomationElement windowElement, CheckType checkType) { while ( (element != null) && (!(bool)element.GetCurrentPropertyValue(AutomationElement.IsWindowPatternAvailableProperty)) && (null != (element = TreeWalker.ControlViewWalker.GetParent(element))) ) { } if (element == null) ThrowMe(checkType, "Element does not have an Ancestor that supports WindowPattern"); windowElement = element; orginalRect = windowElement.Current.BoundingRectangle; TS_MoveElementsWindow(windowElement, newX, newY, checkType); }
// Must run on the UI thread. private void UpdateSelectedItem(AutomationElement automationElement) { SelectedItemText = (string)automationElement.GetCurrentPropertyValue(AutomationElement.NameProperty); SelectedItemBounds = (Rect)automationElement.GetCurrentPropertyValue(AutomationElement.BoundingRectangleProperty); SelectedItemChanged(this, EventArgs.Empty); }
public IntPtr ToNativeWindowHandle(AutomationElement element) { var handle = (int)element.GetCurrentPropertyValue( AutomationElement.NativeWindowHandleProperty, true); return new IntPtr(handle); }
public static void AutomationElementFromHandle(AutomationElement element) { AutomationElement obj; object handle = element.GetCurrentPropertyValue(AutomationElement.NativeWindowHandleProperty); Dump("FromHandle(" + handle + ")", true, element); if ((int)handle == 0) try { obj = AutomationElement.FromHandle(IntPtr.Zero); } catch (Exception exception) { VerifyException(element, exception, typeof(ArgumentException)); } else try { obj = AutomationElement.FromHandle(new IntPtr((int)handle)); } catch (Exception exception) { VerifyException(element, exception, typeof(ElementNotAvailableException)); } }
/// ------------------------------------------------------------------- /// <summary></summary> /// ------------------------------------------------------------------- private void TS_CollapseMenu(AutomationElement menu, CheckType checkType) { if (false == (bool)menu.GetCurrentPropertyValue(AutomationElement.IsExpandCollapsePatternAvailableProperty)) { ThrowMe(checkType, "Menu does not support ExpandCollapsePattern"); } int timeout = 0; ExpandCollapsePattern ecp = menu.GetCurrentPattern(ExpandCollapsePattern.Pattern) as ExpandCollapsePattern; ecp.Collapse(); // Yikes sleep! But we are testing events, so cannot rely on eventing to determine when we are done. while (ecp.Current.ExpandCollapseState != ExpandCollapseState.Collapsed && timeout < MAX_TIME) { Thread.Sleep(INCREMENT); timeout += INCREMENT; } m_TestStep++; }
/// <summary> /// this will set the highlighting rectangle upon automation element. /// </summary> /// <param name="selectedElement"></param> private void SetHighlightingElement(AutomationElement selectedElement) { if (selectedElement == null) SetVisibility(false); //if we do net have selected element then hide hilightling rectangle else { Rect rectangle = Rect.Empty; try { //we will try to get bounding rectangle rectangle = (Rect)selectedElement.GetCurrentPropertyValue(AutomationElement.BoundingRectangleProperty, true); } catch (Exception ex) { //if it failed then log exception ApplicationLogger.LogException(ex); } if (rectangle != Rect.Empty) { //if we have rectangle then set the highlighting rectangle this.Location = new Drawing.Rectangle((int)rectangle.Left, (int)rectangle.Top, (int)rectangle.Width, (int)rectangle.Height); SetToolTip(selectedElement); SetVisibility(true); } else { //if we don't then hide hilightting rectangle SetVisibility(false); } } }
public static void AutomationElementGetCurrentPropertyValue(AutomationElement element) { ArrayList automationProperties = null; ArrayList automationPatterns = null; Random rnd = new Random((int)DateTime.Now.Ticks); PopulateAutomationElementProperties(ref automationProperties, ref automationPatterns); AutomationProperty property = (AutomationProperty)automationProperties[rnd.Next(automationProperties.Count - 1)]; Dump("GetCurrentPropertyValue(" + property + ")", true, element); try { object obj = element.GetCurrentPropertyValue(property); } catch (Exception exception) { VerifyException(element, exception, typeof(ElementNotAvailableException), typeof(InvalidOperationException) /* {"Operation is not valid due to the current state of the object."}*/ ); } }
public static List<AutomationElement> FindAll(AutomationElement root, TreeScope scope, Condition condition, int processId) { return (List<AutomationElement>)STAHelper.Invoke( delegate() { int elementProcessId = (int)root.GetCurrentPropertyValue(AutomationElement.ProcessIdProperty); if (elementProcessId != processId) { // This happens when the element represents the desktop. // We could just filter using the ProcessIdProperty but this searches all nodes and *then* filters, // which is incredibly slow if we're searching a lot of nodes (i.e. TreeScope is Descendant). // Instead we find all direct children with the right process id and then search them inclusively. // Helpfully, there's a Subtree TreeScope which does what we want Condition processCondition = new PropertyCondition2(AutomationElement.ProcessIdProperty, processId); if (scope == TreeScope.Descendants) { List<AutomationElement> roots = AutomationExtensions.FindAllRaw(root, TreeScope.Children, processCondition); List<AutomationElement> mergedResults = new List<AutomationElement>(); foreach (AutomationElement currentRoot in roots) mergedResults.AddRange(FindAll(currentRoot, TreeScope.Subtree, condition, processId)); return mergedResults; } else { condition = (condition == null) ? processCondition : new AndCondition(condition, processCondition); } } if (condition == null) condition = Condition.TrueCondition; return AutomationExtensions.FindAllRaw(root, scope, condition); } ); }
private void ClickTheBatch(AutomationElement lstView,int batchID) { const int eachRowHeight = 19; int nPosition = 21 + eachRowHeight * batchID; System.Windows.Rect rect = (System.Windows.Rect)lstView.GetCurrentPropertyValue(AutomationElement.BoundingRectangleProperty); winMessenger.MouseMove((int)rect.Left + 100, (int)rect.Top + nPosition - eachRowHeight / 2); winMessenger.Click(); }
public void CenterInView(AutomationElement node) { var treeBounds = (System.Windows.Rect)Element.GetCurrentPropertyValue(AutomationElement.BoundingRectangleProperty); var lowHeight = treeBounds.Height / 2 - 10; var highHeight = treeBounds.Height / 2 + 10; var scroll = Element.GetScrollPattern(); if (!scroll.Current.VerticallyScrollable) { return; } scroll.SetScrollPercent(ScrollPattern.NoScroll, 0); while (true) { var nodeBounds = (System.Windows.Rect)node.GetCurrentPropertyValue(AutomationElement.BoundingRectangleProperty); var heightFromTop = nodeBounds.Top - treeBounds.Top; if (lowHeight < heightFromTop && heightFromTop < highHeight) { break; } else if (heightFromTop >= 0 && heightFromTop < lowHeight) { break; } else if (scroll.Current.VerticalScrollPercent == 100.0) { break; } scroll.ScrollVertical(ScrollAmount.SmallIncrement); } }
public static bool In(this AutomationProperty property, AutomationElement element) { return (bool) element.GetCurrentPropertyValue(property); }
ToggleState GetMenuToggleState(AutomationElement menu) { // Win32 menus only know if they are toggles if they are checked, else they are off return ((bool)menu.GetCurrentPropertyValue(AutomationElement.IsTogglePatternAvailableProperty) ? ToggleState.On : ToggleState.Off); }
/// <summary> /// Called by a client to add a listener for pattern or custom events. /// </summary> /// <param name="eventId">A control pattern or custom event identifier.</param> /// <param name="element">Element on which to listen for control pattern or custom events.</param> /// <param name="scope">Specifies whether to listen to property changes events on the specified element, and/or its ancestors and children.</param> /// <param name="eventHandler">Delegate to call when the specified event occurs.</param> /// /// <outside_see conditional="false"> /// This API does not work inside the secure execution environment. /// <exception cref="System.Security.Permissions.SecurityPermission"/> /// </outside_see> public static void AddAutomationEventHandler( AutomationEvent eventId, AutomationElement element, TreeScope scope, AutomationEventHandler eventHandler ) { Misc.ValidateArgumentNonNull(element, "element" ); Misc.ValidateArgumentNonNull(eventHandler, "eventHandler" ); Misc.ValidateArgument( eventId != AutomationElement.AutomationFocusChangedEvent, SRID.EventIdMustNotBeAutomationFocusChanged ); Misc.ValidateArgument( eventId != AutomationElement.StructureChangedEvent,SRID.EventIdMustNotBeStructureChanged ); Misc.ValidateArgument( eventId != AutomationElement.AutomationPropertyChangedEvent, SRID.EventIdMustNotBeAutomationPropertyChanged ); if (eventId == WindowPattern.WindowClosedEvent) { // Once a window closes and the hwnd is destroyed we won't be able to determine where it was in the // Automation tree; therefore only support WindowClosed events for all windows (eg. src==root and scope // is descendants) or a specific WindowPattern element (src==root of a Window and scope is the element). // Also handle odd combinations (eg. src==specific element and scope is subtree|ancestors). bool paramsValidated = false; if ( Misc.Compare( element, AutomationElement.RootElement ) ) { // For root element need to have Descendants scope set (Note: Subtree includes Descendants) if ( ( scope & TreeScope.Descendants ) == TreeScope.Descendants ) { paramsValidated = true; } } else { // otherwise non-root elements must have the entire tree (Anscestors, Element and Descendants)... if ( ( scope & ( TreeScope.Ancestors | TreeScope.Element | TreeScope.Descendants ) ) == ( TreeScope.Ancestors | TreeScope.Element | TreeScope.Descendants ) ) { paramsValidated = true; } else if ( ( scope & TreeScope.Element ) == TreeScope.Element ) { // ...OR Element where the element implements WindowPattern // PRESHARP will flag this as warning 56506/6506:Parameter 'element' to this public method must be validated: A null-dereference can occur here. // False positive, element is checked, see above #pragma warning suppress 6506 object val = element.GetCurrentPropertyValue(AutomationElement.NativeWindowHandleProperty); if ( val != null && val is int && (int)val != 0 ) { if ( HwndProxyElementProvider.IsWindowPatternWindow( NativeMethods.HWND.Cast( new IntPtr( (int)val ) ) ) ) { paramsValidated = true; } } } } if ( !paramsValidated ) { throw new ArgumentException( SR.Get( SRID.ParamsNotApplicableToWindowClosedEvent ) ); } } // Add a client-side Handler for for this event request EventListener l = new EventListener(eventId, scope, null, CacheRequest.CurrentUiaCacheRequest); ClientEventManager.AddListener(element, eventHandler, l); }
/// ------------------------------------------------------------------- /// <summary></summary> /// ------------------------------------------------------------------- void TS_ToggleCheckState(AutomationElement element, WaitTestState callBackOn, WaitTestState callBackOff, CheckType checkType) { Library.ValidateArgumentNonNull(element, "AutomationElement"); ToggleState currentToggleState; ToggleState newToggleState; // Verify that control supports ToggelPattern if (false == (bool)element.GetCurrentPropertyValue(AutomationElement.IsTogglePatternAvailableProperty)) ThrowMe(checkType, "Element does not support TogglePattern"); // Get the current ToggleState currentToggleState = ((ToggleState)element.GetCurrentPropertyValue(TogglePattern.ToggleStateProperty)); Comment("Current ToggleState of " + element.Current.Name + "\" is " + currentToggleState.ToString()); // Identify the desited ToggleState after it has been Toggled newToggleState = currentToggleState == ToggleState.Off ? ToggleState.On : ToggleState.Off; // Toggle the checkbox ((TogglePattern)element.GetCurrentPattern(TogglePattern.Pattern)).Toggle(); // Wait till it actually has been checked if (newToggleState == ToggleState.On) Wait(callBackOn, _WAIT_NORMAL_MILLISECONDS, CheckType.Verification); else Wait(callBackOff, _WAIT_NORMAL_MILLISECONDS, CheckType.Verification); m_TestStep++; }
/// <summary> /// Called by a client to add a listener for pattern or custom events. /// </summary> /// <param name="eventId">A control pattern or custom event identifier.</param> /// <param name="element">Element on which to listen for control pattern or custom events.</param> /// <param name="scope">Specifies whether to listen to property changes events on the specified element, and/or its ancestors and children.</param> /// <param name="eventHandler">Delegate to call when the specified event occurs.</param> /// /// <outside_see conditional="false"> /// This API does not work inside the secure execution environment. /// <exception cref="System.Security.Permissions.SecurityPermission"/> /// </outside_see> public static void AddAutomationEventHandler( AutomationEvent eventId, AutomationElement element, TreeScope scope, AutomationEventHandler eventHandler ) { Misc.ValidateArgumentNonNull(element, "element"); Misc.ValidateArgumentNonNull(eventHandler, "eventHandler"); Misc.ValidateArgument(eventId != AutomationElement.AutomationFocusChangedEvent, SRID.EventIdMustNotBeAutomationFocusChanged); Misc.ValidateArgument(eventId != AutomationElement.StructureChangedEvent, SRID.EventIdMustNotBeStructureChanged); Misc.ValidateArgument(eventId != AutomationElement.AutomationPropertyChangedEvent, SRID.EventIdMustNotBeAutomationPropertyChanged); if (eventId == WindowPattern.WindowClosedEvent) { // Once a window closes and the hwnd is destroyed we won't be able to determine where it was in the // Automation tree; therefore only support WindowClosed events for all windows (eg. src==root and scope // is descendants) or a specific WindowPattern element (src==root of a Window and scope is the element). // Also handle odd combinations (eg. src==specific element and scope is subtree|ancestors). bool paramsValidated = false; if (Misc.Compare(element, AutomationElement.RootElement)) { // For root element need to have Descendants scope set (Note: Subtree includes Descendants) if ((scope & TreeScope.Descendants) == TreeScope.Descendants) { paramsValidated = true; } } else { // otherwise non-root elements must have the entire tree (Anscestors, Element and Descendants)... if ((scope & (TreeScope.Ancestors | TreeScope.Element | TreeScope.Descendants)) == (TreeScope.Ancestors | TreeScope.Element | TreeScope.Descendants)) { paramsValidated = true; } else if ((scope & TreeScope.Element) == TreeScope.Element) { // ...OR Element where the element implements WindowPattern // PRESHARP will flag this as warning 56506/6506:Parameter 'element' to this public method must be validated: A null-dereference can occur here. // False positive, element is checked, see above #pragma warning suppress 6506 object val = element.GetCurrentPropertyValue(AutomationElement.NativeWindowHandleProperty); if (val != null && val is int && (int)val != 0) { if (HwndProxyElementProvider.IsWindowPatternWindow(NativeMethods.HWND.Cast(new IntPtr((int)val)))) { paramsValidated = true; } } } } if (!paramsValidated) { throw new ArgumentException(SR.Get(SRID.ParamsNotApplicableToWindowClosedEvent)); } } // Add a client-side Handler for for this event request EventListener l = new EventListener(eventId, scope, null, CacheRequest.CurrentUiaCacheRequest); ClientEventManager.AddListener(element, eventHandler, l); }
/// ------------------------------------------------------------------- /// <summary></summary> /// ------------------------------------------------------------------- void TS_VerifyToggleState(AutomationElement element, string keyname, CheckType checkType) { if (null == element) { Console.WriteLine("**********************"); Thread.Sleep(10000); ThrowMe(checkType, "element == null in TS_VerifyToggleState...could not get menu?"); } int regvalue = (int)HelperGetKeyNameValue(keyname); Comment("Verify that the toggle state of \"" + element.Current.Name + "\" is {0}", regvalue == 1 ? "toggled" : "not toggled"); bool toggleSupported = (bool)element.GetCurrentPropertyValue(AutomationElement.IsTogglePatternAvailableProperty); if (false == toggleSupported) { if (element.Current.ControlType == ControlType.MenuItem) { // win32 menus only know thre are togglable when they are checked if (regvalue == 1 ? toggleSupported != true : toggleSupported != false) ThrowMe(checkType, "ToggleState was incorrect"); } else { ThrowMe(checkType, "Should support TogglePattern"); } } else { ToggleState toggled = (ToggleState)element.GetCurrentPropertyValue(TogglePattern.ToggleStateProperty); if (regvalue == 1 ? toggled != ToggleState.On : toggled != ToggleState.Off) ThrowMe(checkType, "ToggleState was incorrect"); } m_TestStep++; }