private void FireFoxChildWindowOpened(object sender, AutomationEventArgs e) { var element = sender as AutomationElement; if (element == null) { return; } // Filter for a proxy message if (!MatchWindow(element, PROXY_CLASSNAME, PROXY_AUTOMATIONID, PROXY_NAME)) { return; } // Find the cancel button var controls = element.FindAll(TreeScope.Children, Condition.TrueCondition).ToList(); var cancelButton = controls.FirstOrDefault(c => c.Current.ControlType == ControlType.Button && c.Current.Name == "Cancel"); if (cancelButton == null) { return; } // Get the click pattern object clickPatternObj; if (!cancelButton.TryGetCurrentPattern(InvokePattern.Pattern, out clickPatternObj)) { return; } ((InvokePattern)clickPatternObj).Invoke(); // click the cancel button }
private void OnEvent(object src, AutomationEventArgs e) { AutomationElement el = src as AutomationElement; string itemType = el.Current.ClassName; string id = el.Current.AutomationId; string text = this.GetText((src as AutomationElement)); if (e.EventId == InvokePattern.InvokedEvent) { Activity act = new Activity() { Type = Activity.Types.Click, ControlDisplayText = text, ControlType = itemType, WPath = this.GetWPath(this.GetAncestorWalk(el)) }; this.m_Activities.Add(act); } else if (e.EventId == SelectionPattern.InvalidatedEvent) { Activity act = new Activity() { Type = Activity.Types.SelectionChange, ControlDisplayText = text, ControlType = itemType, WPath = this.GetWPath(this.GetAncestorWalk(el)) }; this.m_Activities.Add(act); } }
private void MessageBoxButtonHandler(object sender, AutomationEventArgs e) { Console.WriteLine("Dialog Button clicked at : " + DateTime.Now.ToString()); // (...) // Remove the handler after, since the next MessageBox needs a new handler. Automation.RemoveAutomationEventHandler(e.EventId, buttonElement, DialogButtonHandler); }
public bool WaitFor(AutomationElementWrapper element, SomethingToWaitFor check, TimeSpan timeout, FailureToHappenHandler failureHandler, IEnumerable <AutomationEventWrapper> events) { Monitor.Enter(_waitingRoom); _triggeringEvent = null; DateTime started = DateTime.Now; var handlerRemovers = AddPulsingHandlers(events, element); bool checkPassed = true; while (!check(element, _triggeringEvent) && DateTime.Now.Subtract(started).CompareTo(timeout) < 0) { checkPassed = false; Monitor.Wait(_waitingRoom, timeout); } Monitor.Exit(_waitingRoom); ClearPulsingHandlers(handlerRemovers); if (!checkPassed && !check(element, null)) { failureHandler(element); return(false); } return(true); }
//------------------------------------------------------ // // Constructors // //------------------------------------------------------ #region Constructors internal CalloutQueueItem(Delegate clientCallback, UiaCoreApi.UiaCacheResponse cacheResponse, AutomationEventArgs e, UiaCoreApi.UiaCacheRequest cacheRequest) { _clientCallback = clientCallback; _cacheResponse = cacheResponse; _e = e; _cacheRequest = cacheRequest; }
private void OnWindowOpened(object sender, AutomationEventArgs automationEventArgs) { if (!configurationManager.ConfigFile.AutoApplyProfiles) { return; } var element = sender as AutomationElement; if (element == null) { return; } var profile = configurationManager.ConfigFile.WindowProfiles.SingleOrDefault(p => new Regex(p.TitleRegex).IsMatch(element.Current.Name)); if (profile == null) { return; } var process = Process.GetProcessById(element.Current.ProcessId); if (process == null || !process.ProcessName.Equals(profile.ProcessName)) { return; } ApplyWindowComposition(element.Current.NativeWindowHandle, profile.WindowComposition); }
// Runs on an automation event thread void PopupListElementSelectedHandler(object sender, AutomationEventArgs e) { Logger.WindowWatcher.Verbose($"PopupList PopupListElementSelectedHandler on thread {Thread.CurrentThread.ManagedThreadId}"); var selectedItem = (AutomationElement)sender; UpdateSelectedItem(selectedItem); }
//------------------------------------------------------ // // Private Methods // //------------------------------------------------------ #region Private Methods private static void OnToolTipEvents(IntPtr hwnd, int eventId, object idProp, int idObject, int idChild) { if (idObject != NativeMethods.OBJID_WINDOW) { return; } if (!IsToolTip(hwnd)) { return; } // Raise ToolTipClosedEvent on OBJECT_HIDE WinEvents. Not raising the event for EVENT_OBJECT_DESTROY // because to do this means having to change code downstream from RaiseAutomationEvent to accept a // null src. PS #1007309 (Client-side proxies that raise events end up going through server-side // code) would be a good time to fix this issue (may then be able to pass null src). Most tool tips // currently get created, then shown and hidden, and are destroyed when the app exits so the impact // here should be minimal since the ToolTip is probaby not showing when the app exits. if (eventId == NativeMethods.EVENT_OBJECT_HIDE /*|| eventId == NativeMethods.EVENT_OBJECT_DESTROY*/) { WindowsTooltip wtv = new WindowsTooltip(hwnd, null, 0); AutomationEventArgs e = new AutomationEventArgs(AutomationElement.ToolTipClosedEvent); AutomationInteropProvider.RaiseAutomationEvent(AutomationElement.ToolTipClosedEvent, wtv, e); } }
public void DoSubWindowOpenAction(object src, AutomationEventArgs e) { AutomationElement subWindow = null; String subWinTitle; AutomationElement button = null; AutomationElement element; try { subWinTitle = Init.GetSubWinTitle(); element = src as AutomationElement; if (!Regex.IsMatch(element.Current.Name, subWinTitle)) { return; } } catch (ElementNotAvailableException) { return; } if (e.EventId == WindowPattern.WindowOpenedEvent) { Init.SetSubWinTitle(subWinTitle); subWindow = element; Init.SetSubWindow(subWindow); subWindow = Init.GetSubWindow(); Init.SetButton(); button = Init.GetButton(); RegisterButtonClickEvent(button); } }
//#endregion Invoke-UiaScript protected virtual void SaveEventInput( AutomationElement src, AutomationEventArgs e, string programmaticName, bool infoAdded) { }
public void DoMainWindowOpenAction(object src, AutomationEventArgs e) { String mainWinTitle; AutomationElement mainWindow = null; AutomationElement element; try { mainWinTitle = Init.GetMainWinTitle(); element = src as AutomationElement; if (!Regex.IsMatch(element.Current.Name, mainWinTitle, RegexOptions.IgnoreCase)) { return; } } catch (ElementNotAvailableException) { return; } if (e.EventId == WindowPattern.WindowOpenedEvent) { Init.SetMainWinTitle(element.Current.Name); mainWindow = element; Init.SetmainWindow(mainWindow); mainWindow = Init.GetmainWindow(); RegisterSubWinOpenEvent(mainWindow); } }
public void DoMainWindowCloseAction(object src, AutomationEventArgs e) { String mainWinTitle; try { mainWinTitle = Init.GetMainWinTitle(); var element = src as AutomationElement; if (!(element.Current.Name == mainWinTitle)) { return; } } catch (ElementNotAvailableException) { return; } if (e.EventId == WindowPattern.WindowClosedEvent) { // TODO: event handling } }
private void OnWindowOpened(object sender, AutomationEventArgs e) { var element = sender as AutomationElement; if ((element == null) || !string.Equals(element.Current.Name, _codeSignerSettings.ProgramName, StringComparison.Ordinal)) { return; } var pattern = (WindowPattern)element.GetCurrentPattern(WindowPattern.Pattern); pattern.WaitForInputIdle(10000); var edit = element.FindFirst(TreeScope.Descendants, new AndCondition(new PropertyCondition(AutomationElement.ControlTypeProperty, ControlType.Edit), new PropertyCondition(AutomationElement.NameProperty, _codeSignerSettings.PasswordBoxName))); var ok = element.FindFirst(TreeScope.Descendants, new AndCondition(new PropertyCondition(AutomationElement.ControlTypeProperty, ControlType.Button), new PropertyCondition(AutomationElement.NameProperty, _codeSignerSettings.AcceptButtonContent))); if ((edit != null) && (ok != null)) { var vp = (ValuePattern)edit.GetCurrentPattern(ValuePattern.Pattern); vp.SetValue(_storedPassword.ToInsecureString()); var ip = (InvokePattern)ok.GetCurrentPattern(InvokePattern.Pattern); ip.Invoke(); } else { _log?.WriteEntry("CodeSignerPasswordService stopping...", EventLogEntryType.Information); Console.WriteLine("SafeNet window detected but could not find password box and/or 'OK' button"); } }
private static void AutoCorrect(object sender, AutomationEventArgs e) { var element = (AutomationElement)sender; string originalText = element.GetText(); string newText = originalText; if (newText.EndsWith(".")) { foreach (var replacement in REPLACEMENTS) { if (newText.Contains(replacement.Key)) { newText = newText.Replace(replacement.Key, replacement.Value); } } } if (newText != originalText) { element.SetFocus(); SendKeys.SendWait("^{HOME}"); SendKeys.SendWait("^+{END}"); SendKeys.SendWait("{DEL}"); SendKeys.SendWait(newText); } }
public override void RaiseAutomationEvent(AutomationEvent eventId, AutomationEventArgs e) { if (eventId == InvokePatternIdentifiers.InvokedEvent || eventId == SelectionItemPatternIdentifiers.ElementSelectedEvent) { if (!selected) { selected = true; NotifyStateChange(Atk.StateType.Selected, selected); } ((ICanHaveSelection)this).RecursivelyDeselectAll(this); } else if (eventId == AutomationElementIdentifiers.AutomationFocusChangedEvent) { selected = !selected; NotifyStateChange(Atk.StateType.Selected, selected); if (selected) { //this causes the following in accerciser: focus:(0, 0, None) Atk.Focus.TrackerNotify(this); } ((ICanHaveSelection)this).RecursivelyDeselectAll(selected ? this : null); } else { Log.Warn("MenuItem: RaiseAutomationEvent({0},...) not implemented", eventId.ProgrammaticName); base.RaiseAutomationEvent(eventId, e); } }
// OnMenuEvent - Called by MenuTracker class private static void OnMenuEvent(AutomationElement rawEl, bool menuHasOpened) { AutomationEvent eventId = menuHasOpened ? AutomationElement.MenuOpenedEvent : AutomationElement.MenuClosedEvent; AutomationEventArgs e = new AutomationEventArgs(eventId); RaiseEventInThisClientOnly(eventId, rawEl, e); }
/// <summary> /// Event handler for the structure changed event. /// </summary> private static void OnStructureChanged(object src, AutomationEventArgs e) { if ((src as AutomationElement).Current.Name == "Wunderlist") { eventControl?.Set(); } }
public override void RaiseAutomationEvent(AutomationEvent eventId, AutomationEventArgs e) { if (eventId == TextPatternIdentifiers.TextChangedEvent) { string newText = Provider.GetPropertyValue(AutomationElementIdentifiers.NameProperty.Id) as string; // Don't fire spurious events if the text hasn't changed if (textExpert.Text == newText) { return; } // First delete all text, then insert the new text textExpert.EmitTextChanged(Atk.TextChangedDetail.Delete, 0, textExpert.Length); textExpert.EmitTextChanged(Atk.TextChangedDetail.Insert, 0, newText == null ? 0 : newText.Length); // Accessible name and label text are one and // the same, so update accessible name Name = newText; EmitVisibleDataChanged(); } }
public override void RaiseAutomationEvent(AutomationEvent eventId, AutomationEventArgs e) { if (editableTextExpert.RaiseAutomationEvent(eventId, e)) { return; } if (eventId == SelectionItemPatternIdentifiers.ElementSelectedEvent) { List list = Parent as List; if (list != null) { list.NotifyItemSelected(this); } else { NotifyStateChange(Atk.StateType.Selected, true); } } else if (eventId == SelectionItemPatternIdentifiers.ElementAddedToSelectionEvent) { NotifyStateChange(Atk.StateType.Selected, true); } else if (eventId == SelectionItemPatternIdentifiers.ElementRemovedFromSelectionEvent) { NotifyStateChange(Atk.StateType.Selected, false); } }
private void SelectionChanged(object sender, AutomationEventArgs e) { AutomationElement element = sender as AutomationElement; if (AutomationEventHandlerGuard(element)) { return; } AutomationElement parent = GetExplorerWindow(element); if (parent != null) { IntPtr hwnd = new IntPtr(parent.Current.NativeWindowHandle); string[] items = ExplorerAdapter.GetSelectedItems(hwnd); if (items != null) { if (ExplorerSelectionChanged != null) { ExplorerSelectionChanged(this, items); } } } }
private void OnWindowDelete(object sender, AutomationEventArgs e) { /* * Delete window handle that exist in the list on window close event * */ try { AutomationElement element = sender as AutomationElement; if (e.EventId == WindowPattern.WindowClosedEvent) { if (element != null) { string windowName = element.Current.Name; int[] rid = element.GetRuntimeId(); common.LogMessage("Removed: " + element.Current.ControlType.ProgrammaticName + " : " + windowName + " : " + rid); if (this.IndexOf(element) != -1) { this.Remove(element); } common.LogMessage("Removed - Window list count: " + this.Count); } } } catch { // Since window list is added / removed in different thread // values of windowList might be altered and an exception is thrown // Just handle the global exception } }
private static void OnWindowOpened(object sender, AutomationEventArgs automationEventArgs) { try { var element = sender as AutomationElement; if (element != null) { if (element.Current.Name.Trim() == "Editor for A Hat in Time (64-bit, DX9, Cooked Editor, PMT)") { if (Benchmark != null) { Benchmark.Stop(); } Meme.StopElevatorMusic(); } else if (element.Current.Name.Trim() == "Editor for A Hat in Time (64-bit, DX9)") { Meme.PlayElevatorMusic(); } } } catch (ElementNotAvailableException) { } }
/// <summary> /// Handle invoke events of interest. /// </summary> /// <param name="src">Object that raised the event.</param> /// <param name="e">Event arguments.</param> /// <remarks> /// Some controls that have not implemented UI Automation correctly /// may fire spurious events. For example, a WinForms button will /// fire an InvokedEvent on a mouse-down and then another series of /// InvokedEvents on the subsequent mouse-up.</remarks> private void OnInvoke(object src, AutomationEventArgs e) { DateTime invokeTime = DateTime.Now; Feedback("Invoke event."); AutomationElement invokedElement = src as AutomationElement; Feedback(invokedElement.Current.Name); ElementStore invokeEvent = new ElementStore(); try { invokeEvent.AutomationID = invokedElement.Current.AutomationId; invokeEvent.ClassName = invokedElement.Current.ClassName; invokeEvent.ControlType = invokedElement.Current.ControlType.ProgrammaticName; invokeEvent.EventID = e.EventId.ProgrammaticName; invokeEvent.SupportedPatterns = invokedElement.GetSupportedPatterns(); invokeEvent.EventTime = invokeTime; elementQueue.Enqueue(invokeEvent); } catch (NullReferenceException) { return; } }
///-------------------------------------------------------------------- /// <summary> /// AutomationEventHandler delegate. /// </summary> /// <param name="src">Object that raised the event.</param> /// <param name="e">Event arguments.</param> ///-------------------------------------------------------------------- private void OnWindowOpenOrClose(object src, AutomationEventArgs e) { // Make sure the element still exists. Elements such as tooltips // can disappear before the event is processed. AutomationElement sourceElement; try { sourceElement = src as AutomationElement; } catch (ElementNotAvailableException) { return; } if (e.EventId == WindowPattern.WindowOpenedEvent) { // TODO: event handling return; } if (e.EventId == WindowPattern.WindowClosedEvent) { // TODO: event handling return; } }
private void onWindowOpened(object?sender, AutomationEventArgs e) { if (sender is AutomationElement windowEl) { onWindowOpened(windowEl.toSystemWindow()); } }
//------------------------------------------------------ // // Constructors // //------------------------------------------------------ #region Constructors internal ClientSideQueueItem(Delegate clientCallback, AutomationElement srcEl, UiaCoreApi.UiaCacheRequest request, AutomationEventArgs e) { _clientCallback = clientCallback; _srcEl = srcEl; _request = request; _e = e; }
void OnWindowOpenOrClose(object src, AutomationEventArgs e) { if (e.EventId != WindowPattern.WindowOpenedEvent) { return; } AutomationElement sourceElement; try { sourceElement = src as AutomationElement; //Check the event source is caculator or not. //In production code, string should be read from resource to support localization testing. if (sourceElement.Current.Name == "计算器") { calcWindow = sourceElement; } } catch (ElementNotAvailableException) { return; } //Start testing ExecuteTest(); }
private void OnUIAutomationEvent(object src, AutomationEventArgs e) { if (!positionThread.IsAlive) { loop(); } }
/// <summary> /// Window was closed. Raise an event to indicate this /// </summary> /// <param name="sender">event sender</param> /// <param name="e">event ards</param> private void onWindowClose(object sender, AutomationEventArgs e) { if (EvtOnWindowClosed != null) { Log.Debug("Triggering event closed"); EvtOnWindowClosed(_hwnd); } }
void PopupListElementSelectedHandler(object sender, AutomationEventArgs e) { _syncContext.Post(delegate { Debug.Print("### Thread receiving PopupListElementSelectedHandler: " + Thread.CurrentThread.ManagedThreadId); UpdateSelectedItem(sender as AutomationElement); }, null); }
public static void RaiseAutomationEvent(AutomationEvent eventId, IRawElementProviderSimple provider, AutomationEventArgs e) { Utility.ValidateArgumentNonNull(eventId, "eventId"); Utility.ValidateArgumentNonNull(provider, "provider"); Utility.ValidateArgumentNonNull(e, "e"); if (e.EventId == AutomationElementIdentifiers.AsyncContentLoadedEvent) { AsyncContentLoadedEventArgs args = e as AsyncContentLoadedEventArgs; if (args == null) { throw new ArgumentException("e"); } UiaCoreProviderApi.UiaRaiseAsyncContentLoadedEvent(provider, args.AsyncContentLoadedState, args.PercentComplete); } else { if ((e.EventId == WindowPatternIdentifiers.WindowClosedEvent) && !(e is WindowClosedEventArgs)) { throw new ArgumentException("e"); } UiaCoreProviderApi.UiaRaiseAutomationEvent(provider, eventId.Id); } }