/// <summary> /// Get automationelement by name, filtered by classname - mouse click if found /// </summary> /// <param name="parent"></param> /// <param name="automationName">case-insensitive automation name</param> /// <param name="controlType"></param> /// <param name="controlType2"></param> /// <exception cref="ApplicationException">if matching element not found</exception> /// <exception cref="ApplicationException">if specified element is not enabled</exception> public static void FindElementByNameFilteredByControlTypeAndMouseClick(AutomationElement parent, string automationName, ControlType controlType, ControlType controlType2, TimeSpan mouseClickDelay, TreeScope treeScope) { FindElementByNameFilteredByControlTypeWithTimeoutAndMouseClick(parent, automationName, controlType, controlType2, AddinTestUtility.FindRibbonButtonsTimeout, //findDelay mouseClickDelay, treeScope); }
public static void AddAutomationPropertyChangedEventHandler(AutomationElement element, TreeScope scope, AutomationPropertyChangedEventHandler eventHandler, params AutomationProperty[] properties) { Utility.ValidateArgumentNonNull(element, "element"); Utility.ValidateArgumentNonNull(eventHandler, "eventHandler"); Utility.ValidateArgumentNonNull(properties, "properties"); if (properties.Length == 0) { throw new ArgumentException("AtLeastOnePropertyMustBeSpecified"); } int[] propertyIdArray = new int[properties.Length]; for (int i = 0; i < properties.Length; ++i) { Utility.ValidateArgumentNonNull(properties[i], "properties"); propertyIdArray[i] = properties[i].Id; } try { PropertyEventListener listener = new PropertyEventListener(AutomationElement.StructureChangedEvent, element, eventHandler); Factory.AddPropertyChangedEventHandler( element.NativeElement, (UIAutomationClient.TreeScope)scope, CacheRequest.CurrentNativeCacheRequest, listener, propertyIdArray); ClientEventList.Add(listener); } catch (System.Runtime.InteropServices.COMException e) { Exception newEx; if (Utility.ConvertException(e, out newEx)) { throw newEx; } else { throw; } } }
public AutomationElementCollection GetAllChildNodes(AutomationElement element, AutomationProperty automationProperty, object value, TreeScope treeScope) { var allChildNodes = element.FindAll(treeScope, GetPropertyCondition(automationProperty, value)); if (allChildNodes == null) throw new ElementNotAvailableException("Not able to find the child nodes of the element"); return allChildNodes; }
internal static IEnumerable<AutomationElement> FindAll( AutomationElement parent, TreeScope scope, Condition condition) { return FindAll(parent, scope, condition, FindTimeout); }
/// <summary> /// Responds to button click; saves options and starts /// the UI Automation worker thread. /// </summary> /// <param name="sender">Object that raised the event.</param> /// <param name="e">Event arguments.</param> private void btnProps_Click(object sender, EventArgs e) { // Convert Drawing.Point to Windows.Point. var drawingPoint = Cursor.Position; _targetPoint = new Point(drawingPoint.X, drawingPoint.Y); // Save caching settings in member variables so UI isn't accessed // directly by the other thread. _elementMode = rbFull.Checked ? AutomationElementMode.Full : AutomationElementMode.None; // For simplicity, always include Element in scope. _cacheScope = TreeScope.Element; if (cbDescendants.Checked) { _cacheScope |= TreeScope.Descendants; } // Note: if descendants are specified, children // are automatically included. else if (cbChildren.Checked) { _cacheScope |= TreeScope.Children; } _fetcher = new UiAutomationFetcher(this, _targetPoint, _cacheScope, _elementMode); // Start another thread to do the UI Automation work. var threadDelegate = new ThreadStart(StartWorkerThread); _workerThread = new Thread(threadDelegate) {Priority = ThreadPriority.Highest}; _workerThread.Start(); OutputResults("Wait..." + Environment.NewLine); }
public static CacheRequest BuildCacheRequest(TreeScope treeScope, params AutomationProperty[] properties) { var cr = new CacheRequest { TreeScope = treeScope }; foreach (var property in properties) cr.Add(property); return cr; }
public static AutomationElement TryElementByCondition(this AutomationElement element, TreeScope scope, Condition condition) { var result = scope == TreeScope.Parent || scope == TreeScope.Ancestors ? new TreeWalker(condition).GetParent(element) : element.FindFirst(scope, condition); return result; }
public static void AddAutomationEventHandler (AutomationEvent eventId, IRawElementProviderSimple provider, TreeScope scope, AutomationEventHandler eventHandler) { var entry = new AutomationEventEntry (eventId, provider, scope, eventHandler); lock (automationEventEntries) automationEventEntries.Add (entry); }
public static void AddStructureChangedEventHandler ( IRawElementProviderSimple provider, TreeScope scope, StructureChangedEventHandler eventHandler) { var entry = new StructureChangedEventEntry (provider, scope, eventHandler); lock (structureChangedEventEntries) structureChangedEventEntries.Add (entry); }
/// <summary> /// Constructor. /// </summary> /// <param name="form">The application form.</param> /// <param name="targetPoint">The screen coordinates of the cursor.</param> /// <param name="scope">The TreeScope for caching.</param> /// <param name="mode">The mode for caching.</param> public UiAutomationFetcher(FetchTimerForm form, Point targetPt, TreeScope scope, AutomationElementMode cacheMode) { _appForm = form; _treeScope = scope; _targetPoint = targetPt; _mode = cacheMode; }
public static void AddAutomationPropertyChangedEventHandler ( IRawElementProviderSimple provider, TreeScope scope, AutomationPropertyChangedEventHandler eventHandler, int [] properties) { var entry = new PropertyChangedEventEntry (provider, scope, properties, eventHandler); lock (propertyChangedEventEntries) propertyChangedEventEntries.Add (entry); }
public static AutomationElement getAutomationElement(AutomationElement parent, TreeScope scope, ControlType type, string name) { var element = parent.FindFirst(scope, new AndCondition( new PropertyCondition(AutomationElement.ControlTypeProperty, type), new PropertyCondition(AutomationElement.NameProperty, name), Automation.ControlViewCondition)); return element; }
internal static async Task<AutomationEventArgs> Event( AutomationEvent eventId, AutomationElement element = null, TreeScope scope = TreeScope.Descendants) { using (var waitr = new Waiter(eventId, element, scope)) { await waitr.Completion.Task; return waitr.EvtArgs; } }
public AutomationElement GetElement(AutomationElement rootElement, AutomationProperty property, object value, TreeScope searchScope) { AutomationElement aeMainWindow = null; int numWaits = 0; do { aeMainWindow = rootElement.FindFirst(searchScope, new PropertyCondition(property, value)); ++numWaits; Thread.Sleep(200); } while (aeMainWindow == null && numWaits < 50); return aeMainWindow; }
public void AddAutomationPropertyChangedEventHandler (IElement element, TreeScope scope, AutomationPropertyChangedEventHandler eventHandler, AutomationProperty[] properties) { if (element == null) return; ClientElement clientElement = element as ClientElement; if (clientElement == null) { Log.Error ("[ClientAutomationSource.AddAutomationPropertyChangedEventHandler] Not ClientElement"); return; } int [] propertyIds = Array.ConvertAll (properties, p => p.Id); ClientEventManager.AddAutomationPropertyChangedEventHandler ( clientElement.Provider, scope, eventHandler, propertyIds); }
/// <summary> /// Extract Window from parent window /// </summary> /// <param name="parent"></param> /// <param name="titleName"></param> /// <returns></returns> public static AutomationElement ExtractElement(AutomationElement parent, string nameValue, TreeScope treeScope) { ValidateArgumentNotNull(parent, "Extract Window from parent window"); Condition condition = new PropertyCondition(AutomationElement.NameProperty, nameValue); AutomationElement appElement; DateTime timeOut = DateTime.Now.AddMilliseconds(TimeOutMillSec); do { appElement = parent.FindFirst(treeScope, condition); } while (appElement == null && DateTime.Now < timeOut); return appElement; }
public void AddAutomationEventHandler (AutomationEvent eventId, IElement element, TreeScope scope, AutomationEventHandler eventHandler) { if (element == null) // elements from local providers are not descendants of the RootElement. return; ClientElement clientElement = element as ClientElement; if (clientElement == null) { Log.Error ("[ClientAutomationSource.AddAutomationEventHandler] Not ClientElement"); return; } ClientEventManager.AddAutomationEventHandler (eventId, clientElement.Provider, scope, eventHandler); }
//------------------------------------------------------ // // Constructors // //------------------------------------------------------ #region Constructors // full ctor internal EventListener( AutomationEvent eventId, TreeScope scope, AutomationProperty [] properties, UiaCoreApi.UiaCacheRequest cacheRequest ) { _eventId = eventId; _scope = scope; if (properties != null) _properties = (AutomationProperty[])properties.Clone(); else _properties = null; _cacheRequest = cacheRequest; }
public IEnumerable<WiniumElement> Find(TreeScope scope, Predicate<FrameworkElement> predicate) { if (!Enum.IsDefined(typeof(TreeScope), scope)) { throw new ArgumentException("One of TreeScope.Children or TreeScope.Descendants should be set"); } foreach (var descendant in IterDescendants(this.Element, !scope.HasFlag(TreeScope.Descendants))) { if (predicate(descendant)) { yield return new WiniumElement(descendant); } } }
public AutomationElementCollection ExpandComboBoxViewAndReturnChildren(AutomationElement element, AutomationProperty property, object value, TreeScope searchScope) { try { var comboBox = GetFirstChildNode(element, AutomationElement.AutomationIdProperty, value, searchScope); var expandPattern = GetExpandCollapsePattern(comboBox, AutomationElement.ControlTypeProperty, ControlType.ComboBox, TreeScope.Element); if (expandPattern == null) throw new ElementNotAvailableException("Couldnt Find Expand Pattern in combobox"); expandPattern.Expand(); return this.GetAllChildNodes(comboBox, AutomationElement.ControlTypeProperty, ControlType.ListItem, TreeScope.Children); } catch (Exception e1) { throw e1; } }
internal Waiter(AutomationEvent eventId, AutomationElement element = null, TreeScope scope = TreeScope.Descendants) { this._eventId = eventId; this._element = element ?? AutomationElement.RootElement; this._scope = scope; this._handler = new AutomationEventHandler((src, e) => { this.EvtArgs = e; this.Completion.SetResult(true); }); Automation.AddAutomationEventHandler( this._eventId, this._element, this._scope, this._handler); }
public ExpandCollapsePattern GetExpandCollapsePattern(AutomationElement element, AutomationProperty property, object value, TreeScope searchScope) { AutomationElement aeExpanderElement; int numWaits = 0; do { aeExpanderElement = GetFirstChildNode(element, property, value, searchScope); ++numWaits; Thread.Sleep(300); } while (aeExpanderElement == null && numWaits < 75); object objPattern; ExpandCollapsePattern togPattern; if (true == aeExpanderElement.TryGetCurrentPattern(ExpandCollapsePattern.Pattern, out objPattern)) { togPattern = objPattern as ExpandCollapsePattern; return togPattern; } else return null; }
internal static IEnumerable<AutomationElement> FindAll( AutomationElement parent, TreeScope scope, Condition condition, int timeout) { var dtn = DateTime.Now.AddMilliseconds(timeout); // ReSharper disable once LoopVariableIsNeverChangedInsideLoop while (DateTime.Now <= dtn) { var elements = parent.FindAll(scope, condition); if (elements.Count > 0) { return elements.Cast<AutomationElement>(); } } return Enumerable.Empty<AutomationElement>(); }
internal static AutomationElement FindFirst( AutomationElement parent, TreeScope scope, Condition condition, int timeout) { var dtn = DateTime.Now.AddMilliseconds(timeout); // ReSharper disable once LoopVariableIsNeverChangedInsideLoop while (DateTime.Now <= dtn) { var element = parent.FindFirst(scope, condition); if (element != null) { return element; } } return null; }
private static void ScopeDecision(TreeScope scope, AutomationElement root, AutomationElement parent, AutomationElement element, out bool considerNode, out bool visitChildren) { switch(scope) { case TreeScope.Subtree: considerNode = true; visitChildren = true; break; case TreeScope.Children: considerNode = (parent == root); visitChildren = (parent == null); break; case TreeScope.Descendants: considerNode = (parent != null); visitChildren = true; break; case TreeScope.Element: considerNode = (parent == null); visitChildren = false; break; default: throw new Exception("TreeScope.Ancestors and TreeScope.Parent not supported"); } }
public IEnumerable<WiniumElement> Find(TreeScope scope, Predicate<FrameworkElement> predicate) { if (!Enum.IsDefined(typeof(TreeScope), scope)) { throw new ArgumentException("One of TreeScope.Children or TreeScope.Descendants should be set"); } // yield main visual tree if (predicate(this.VisualRoot.Element)) { yield return this.VisualRoot; } if (scope.HasFlag(TreeScope.Descendants)) { foreach (var element in this.VisualRoot.Find(scope, predicate)) { yield return element; } } // yield popups (AppBar, etc.) foreach (var popupChild in this.OpenPopups) { if (predicate(popupChild.Element)) { yield return popupChild; } if (scope.HasFlag(TreeScope.Descendants)) { foreach (var popupElement in popupChild.Find(scope, predicate)) { yield return popupElement; } } } }
public static void AddAutomationEventHandler(AutomationEvent eventId, AutomationElement element, TreeScope scope, AutomationEventHandler eventHandler) { Utility.ValidateArgumentNonNull(element, "element"); Utility.ValidateArgumentNonNull(eventHandler, "eventHandler"); Utility.ValidateArgument(eventId != AutomationElement.AutomationFocusChangedEvent, "Use FocusChange notification instead"); Utility.ValidateArgument(eventId != AutomationElement.StructureChangedEvent, "Use StructureChange notification instead"); Utility.ValidateArgument(eventId != AutomationElement.AutomationPropertyChangedEvent, "Use PropertyChange notification instead"); try { BasicEventListener listener = new BasicEventListener(eventId, element, eventHandler); Factory.AddAutomationEventHandler( eventId.Id, element.NativeElement, (UIAutomationClient.TreeScope)scope, CacheRequest.CurrentNativeCacheRequest, listener); ClientEventList.Add(listener); } catch (System.Runtime.InteropServices.COMException e) { Exception newEx; if (Utility.ConvertException(e, out newEx)) { throw newEx; } else { throw; } } }
/// <summary> /// Registers a structure changed event. /// </summary> public IDisposable SubscribeToStructureChangedEvent(TreeScope treeScope, Action <UiElement, StructureChangedEventArgs> action) { return(this.AutomationElement.SubscribeToStructureChangedEvent( treeScope, (sender, args) => action(FromAutomationElement((AutomationElement)sender), args))); }
public override IAutomationStructureChangedEventHandler RegisterStructureChangedEvent(TreeScope treeScope, Action <AutomationElement, StructureChangeType, int[]> action) { throw new NotImplementedException(); }
/// <inheritdoc /> public NotificationEventHandlerBase RegisterNotificationEvent(TreeScope treeScope, Action <AutomationElement, NotificationKind, NotificationProcessing, string, string> action) { return(FrameworkAutomationElement.RegisterNotificationEvent(treeScope, action)); }
/// <inheritdoc /> public ActiveTextPositionChangedEventHandlerBase RegisterActiveTextPositionChangedEvent(TreeScope treeScope, Action <AutomationElement, ITextRange> action) { return(FrameworkAutomationElement.RegisterActiveTextPositionChangedEvent(treeScope, action)); }
/// <inheritdoc /> public override NotificationEventHandlerBase RegisterNotificationEvent(TreeScope treeScope, Action <AutomationElement, NotificationKind, NotificationProcessing, string, string> action) { throw new NotSupportedByFrameworkException(); }
/// <inheritdoc /> public override ActiveTextPositionChangedEventHandlerBase RegisterActiveTextPositionChangedEvent(TreeScope treeScope, Action <AutomationElement, ITextRange> action) { throw new NotImplementedException(); }
public IAutomationStructureChangedEventHandler RegisterStructureChangedEvent(TreeScope treeScope, Action <AutomationElement, StructureChangeType, int[]> action) { return(BasicAutomationElement.RegisterStructureChangedEvent(treeScope, action)); }
/// <inheritdoc /> public override AutomationElement[] FindAllWithOptions(TreeScope treeScope, ConditionBase condition, TreeTraversalOptions traversalOptions, AutomationElement root) { throw new NotSupportedByFrameworkException(); }
public IAutomationEventHandler RegisterEvent(EventId @event, TreeScope treeScope, Action <AutomationElement, EventId> action) { return(BasicAutomationElement.RegisterEvent(@event, treeScope, action)); }
public IAutomationPropertyChangedEventHandler RegisterPropertyChangedEvent(TreeScope treeScope, Action <AutomationElement, PropertyId, object> action, params PropertyId[] properties) { return(BasicAutomationElement.RegisterPropertyChangedEvent(treeScope, action, properties)); }
/// <summary> /// Finds the first element which is in the given treescope and matches the condition /// </summary> public AutomationElement FindFirst(TreeScope treeScope, ConditionBase condition) { return(FindFirst(treeScope, condition, Retry.DefaultRetryFor)); }
public override IAutomationPropertyChangedEventHandler RegisterPropertyChangedEvent(TreeScope treeScope, Action <AutomationElement, PropertyId, object> action, PropertyId[] properties) { throw new NotImplementedException(); }
/// <summary> /// Called by a client to add a listener for property changed events. /// </summary> /// <param name="element">Element on which to listen for property changed 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">Callback object to call when a specified property change occurs.</param> /// <param name="properties">Params array of properties to listen for changes in.</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 AddAutomationPropertyChangedEventHandler( AutomationElement element, // reference element for listening to the event TreeScope scope, // scope to listen to AutomationPropertyChangedEventHandler eventHandler, // callback object params AutomationProperty [] properties // listen for changes to these properties ) { Misc.ValidateArgumentNonNull(element, "element" ); Misc.ValidateArgumentNonNull(eventHandler, "eventHandler" ); Misc.ValidateArgumentNonNull(properties, "properties" ); if (properties.Length == 0) { throw new ArgumentException( SR.Get(SRID.AtLeastOnePropertyMustBeSpecified) ); } // Check that no properties are interpreted properties // foreach (AutomationProperty property in properties) { Misc.ValidateArgumentNonNull(property, "properties" ); } // Add a client-side listener for for this event request EventListener l = new EventListener(AutomationElement.AutomationPropertyChangedEvent, scope, properties, CacheRequest.CurrentUiaCacheRequest); ClientEventManager.AddListener(element, eventHandler, l); }
public abstract AutomationElement[] FindAll(TreeScope treeScope, ConditionBase condition);
/// <summary> /// Find all matching elements in the specified order. /// </summary> public AutomationElement[] FindAllWithOptions(TreeScope treeScope, ConditionBase condition, TreeTraversalOptions traversalOptions, AutomationElement root) { return(FrameworkAutomationElement.FindAllWithOptions(treeScope, condition, traversalOptions, root)); }
/// <summary> /// Return the parent automation element /// </summary> private AutomationElement getAutomationElement(AutomationElement parent, Condition condition, TreeScope scope) { AutomationElement element; DateTime timeBound = DateTime.Now + TimeSpan.FromSeconds(20); do { element = parent.FindFirst(scope, condition); Thread.Sleep(TimeSpan.FromSeconds(1)); } while (element == null && timeBound > DateTime.Now); return(element); }
public override IAutomationEventHandler RegisterEvent(EventId @event, TreeScope treeScope, Action <AutomationElement, EventId> action) { throw new NotImplementedException(); }
/// <inheritdoc /> public override TextEditTextChangedEventHandlerBase RegisterTextEditTextChangedEventHandler(TreeScope treeScope, TextEditChangeType textEditChangeType, Action <AutomationElement, TextEditChangeType, string[]> action) { throw new NotSupportedByFrameworkException(); }
public override AutomationElement FindFirst(TreeScope treeScope, ConditionBase condition) { throw new NotImplementedException(); }
/// <inheritdoc /> public override AutomationEventHandlerBase RegisterAutomationEvent(EventId @event, TreeScope treeScope, Action <AutomationElement, EventId> action) { var eventHandler = new UIA2AutomationEventHandler(this, @event, action); UIA.Automation.AddAutomationEventHandler(UIA.AutomationEvent.LookupById(@event.Id), NativeElement, (UIA.TreeScope)treeScope, eventHandler.EventHandler); return(eventHandler); }
public abstract IAutomationStructureChangedEventHandler RegisterStructureChangedEvent(TreeScope treeScope, Action <AutomationElement, StructureChangeType, int[]> action);
/// <inheritdoc /> public TextEditTextChangedEventHandlerBase RegisterTextEditTextChangedEventHandler(TreeScope treeScope, TextEditChangeType textEditChangeType, Action <AutomationElement, TextEditChangeType, string[]> action) { return(FrameworkAutomationElement.RegisterTextEditTextChangedEventHandler(treeScope, textEditChangeType, action)); }
public abstract IAutomationPropertyChangedEventHandler RegisterPropertyChangedEvent(TreeScope treeScope, Action <AutomationElement, PropertyId, object> action, PropertyId[] properties);
/// <inheritdoc /> public StructureChangedEventHandlerBase RegisterStructureChangedEvent(TreeScope treeScope, Action <AutomationElement, StructureChangeType, int[]> action) { return(FrameworkAutomationElement.RegisterStructureChangedEvent(treeScope, action)); }
public abstract IAutomationEventHandler RegisterEvent(EventId @event, TreeScope treeScope, Action <AutomationElement, EventId> action);
/// <summary> /// Ctor to create an event handler (with CUIAutomation) and register it. /// </summary> protected EventListenerBase(CUIAutomation uia, IUIAutomationElement element, TreeScope scope, int eventId, HandleUIAutomationEventMessage peDelegate) : this(element, scope, eventId, peDelegate) { this.UIAutomation = uia; }
public abstract AutomationElement FindFirst(TreeScope treeScope, ConditionBase condition);
public override AutomationElement[] FindAll(TreeScope treeScope, ConditionBase condition) { var nativeFoundElements = NativeElement.FindAll((UIA.TreeScope)treeScope, ConditionConverter.ToNative(condition)); return(AutomationElementConverter.NativeArrayToManaged(Automation, nativeFoundElements)); }
public override IAutomationStructureChangedEventHandler RegisterStructureChangedEvent(TreeScope treeScope, Action <AutomationElement, StructureChangeType, int[]> action) { var eventHandler = new UIA2StructureChangedEventHandler(Automation, action); UIA.Automation.AddStructureChangedEventHandler(NativeElement, (UIA.TreeScope)treeScope, eventHandler.EventHandler); return(eventHandler); }
/// <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); }
public override AutomationElement FindFirst(TreeScope treeScope, ConditionBase condition) { var nativeFoundElement = NativeElement.FindFirst((UIA.TreeScope)treeScope, ConditionConverter.ToNative(condition)); return(AutomationElementConverter.NativeToManaged(Automation, nativeFoundElement)); }
/// <summary> /// Called by a client to add a listener for structure change events. /// </summary> /// <param name="element">Element on which to listen for structure change 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 a structure change 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 AddStructureChangedEventHandler(AutomationElement element, TreeScope scope, StructureChangedEventHandler eventHandler) { Misc.ValidateArgumentNonNull(element, "element"); Misc.ValidateArgumentNonNull(eventHandler, "eventHandler"); // Add a client-side listener for for this event request EventListener l = new EventListener(AutomationElement.StructureChangedEvent, scope, null, CacheRequest.CurrentUiaCacheRequest); ClientEventManager.AddListener(element, eventHandler, l); }
public override IAutomationPropertyChangedEventHandler RegisterPropertyChangedEvent(TreeScope treeScope, Action <AutomationElement, PropertyId, object> action, PropertyId[] properties) { var eventHandler = new UIA2PropertyChangedEventHandler(Automation, action); UIA.Automation.AddAutomationPropertyChangedEventHandler(NativeElement, (UIA.TreeScope)treeScope, eventHandler.EventHandler); return(eventHandler); }