/// -------------------------------------------------------------------
/// <summary>
/// Method that registers the event handler OnEvent()
/// </summary>
/// -------------------------------------------------------------------
public virtual void AddEventHandler(AutomationElement element, TreeScope treeScope)
{
base.AddEventHandler();
Comment("Adding AddLogicalStructureChangedEventHandler(el, " + treeScope + ")");
handler = new StructureChangedEventHandler(OnEvent);
Automation.AddStructureChangedEventHandler(element, treeScope, handler);
}
/// <summary>
/// Constructor.
/// </summary>
public Reader()
{
// Get UI Automation root element.
elementRoot = AutomationElement.RootElement;
// Make a list of runtime IDs of top-level windows.
// An alternative would be to keep a list of process IDs. However, it is somewhat more difficult
// to track the termination of processes, because the only information available from a
// window-closed event is the runtime ID.
savedRuntimeIds = new ArrayList();
AutomationElementCollection elementCollection = elementRoot.FindAll(TreeScope.Children, Condition.TrueCondition);
// Add each application window to the list and subscribe it to the WindowClosedEvent handler.
onWindowClosed = new AutomationEventHandler(WindowClosedHandler);
foreach (AutomationElement element in elementCollection)
{
int[] rid = (int[])element.GetCurrentPropertyValue(AutomationElement.RuntimeIdProperty);
if (RuntimeIdListed(rid, savedRuntimeIds) < 0)
{
savedRuntimeIds.Add(rid);
AddToWindowHandler(element);
}
}
// Add other event handlers.
// <Snippet104>
// elementRoot is an AutomationElement.
Automation.AddStructureChangedEventHandler(elementRoot, TreeScope.Children,
new StructureChangedEventHandler(OnStructureChanged));
// </Snippet104>
Automation.AddAutomationFocusChangedEventHandler(
new AutomationFocusChangedEventHandler(OnFocusChanged));
}
/// <summary>
/// Runs the login test.
/// </summary>
public bool Login()
{
try
{
// Looks for and invoke the login button.
AutomationElement node = GetAnchor2(true);
ViewTree.RetrieveChildNodePatternByCondition(ref node, new Condition[] { new PropertyCondition(AutomationElement.AutomationIdProperty, "LoginButton") }, true, Pattern.Invoke);
// Enters the email address.
node = GetAnchor2();
ViewTree.RetrieveChildNodePatternByCondition(ref node, new Condition[] { new PropertyCondition(AutomationElement.AutomationIdProperty, "EmailTextBox") }, true, Pattern.Value, user);
// Enters the password.
node = GetAnchor2();
ViewTree.RetrieveChildNodePatternByCondition(ref node, new Condition[] { new PropertyCondition(AutomationElement.AutomationIdProperty, "PasswordBox") }, true, Pattern.Value, password);
// Before sending login credentials to the server, we must first subscribe to the structucture changed event at the level of anchor #1.
// When login is completed, the children of this node change and this way we detect our test is successful.
node = GetAnchor1();
Automation.AddStructureChangedEventHandler(node, TreeScope.Children, structureChangedEventHandler);
// Looks for and invoke the sign in button.
node = GetAnchor2();
ViewTree.RetrieveChildNodePatternByCondition(ref node, new Condition[] { new PropertyCondition(AutomationElement.AutomationIdProperty, "SignInButton") }, true, Pattern.Invoke);
return(true);
}
catch
{
return(false);
}
}
///--------------------------------------------------------------------
/// <summary>
/// Initialize both client and target applications.
/// </summary>
/// <param name="args">Startup arguments</param>
///--------------------------------------------------------------------
protected override void OnStartup(StartupEventArgs args)
{
// Create our informational window
CreateWindow();
// Get the root element from our target application.
// In general, you should try to obtain only direct children of
// the RootElement. A search for descendants may iterate through
// hundreds or even thousands of elements, possibly resulting in
// a stack overflow. If you are attempting to obtain a specific
// element at a lower level, you should start your search from the
// application window or from a container at a lower level.
targetApp =
System.Windows.Forms.Application.StartupPath + "\\Target.exe";
rootElement = StartApp(targetApp);
if (rootElement == null)
{
return;
}
// Add a structure change listener for the root element.
StructureChangedEventHandler structureChange =
new StructureChangedEventHandler(ChildElementsAdded);
Automation.AddStructureChangedEventHandler(
rootElement, TreeScope.Descendants, structureChange);
// Iterate through the controls in the target application.
FindTreeViewsInTarget();
}
public override void Start(IEventSink sink)
{
Validate.ArgumentNotNull(parameter: sink, parameterName: nameof(sink));
Stop();
this._sinkReference = new WeakReference(target: sink);
this._handlingDelegate = Handler;
Automation.AddStructureChangedEventHandler(element: this._root.AutomationElement, scope: (TreeScope)this._scope, eventHandler: this._handlingDelegate);
}
/// <summary>
/// Initializes UI automation by finding the target form, adding event handlers,
/// and displaying the current automation element structure.
/// </summary>
/// <returns>true on success; otherwise, false.</returns>
public bool StartListening()
{
bool returnCode = false;
AutomationElement rootElement = AutomationElement.RootElement;
// Set a property condition that will be used to find the main form of the
// target application. myTestForm is the name of the Form and in the case
// of a WinForms control, it is also the AutomationId of the element representing the control.
Condition cond = new PropertyCondition(AutomationElement.AutomationIdProperty, "myTestForm");
// Find the main window of the target application.
AutomationElement mainWindowElement = rootElement.FindFirst(TreeScope.Element | TreeScope.Children, cond);
if (mainWindowElement == null)
{
MessageBox.Show("Could not find the main form for the target application.");
returnCode = false;
}
else
{
// Find the "Show supported patterns" checkbox and add an event handler for when
// the toggle state changes.
AutomationElement elementCheckBox = FindByAutomationId(mainWindowElement, "chkbxShowPatterns");
AutomationProperty[] propsWanted = { TogglePattern.ToggleStateProperty };
if (elementCheckBox != null)
{
if ((bool)elementCheckBox.GetCurrentPropertyValue(AutomationElement.IsTogglePatternAvailableProperty) == true)
{
IsElementToggledOn(elementCheckBox);
AutomationPropertyChangedEventHandler _onToggleStateChanged =
new AutomationPropertyChangedEventHandler(OnToggleStateChanged);
Automation.AddAutomationPropertyChangedEventHandler(elementCheckBox,
TreeScope.Element,
_onToggleStateChanged,
propsWanted);
}
}
// Find the "UIAutomation is listening" textbox.
listenElement = FindByAutomationId(mainWindowElement, "tbListen");
// Find the tab control and add an event handler for when the automation tree structure changes.
// This event will be raised whenever the user selects a tab.
tabElement = FindByAutomationId(mainWindowElement, "tabControl1");
if (tabElement != null)
{
StructureChangedEventHandler _onStructureChanged = new StructureChangedEventHandler(onStructureChanged);
Automation.AddStructureChangedEventHandler(tabElement, TreeScope.Descendants, _onStructureChanged);
}
string StructureDescription = GetAutomationStructure(tabElement);
ShowStructure(StructureDescription);
// Check the "UIAutomation is listening" checkbox in the target application.
InformTarget(true);
returnCode = true;
}
return(returnCode);
}
private async void OnFocusChanged(object sender, AutomationFocusChangedEventArgs e)
{
_focusSource?.Cancel();
var source = new CancellationTokenSource();
_focusSource = source;
await Task.Run(async() =>
{
try
{
if (source.IsCancellationRequested)
{
return;
}
Debug.WriteLine("focus changed");
var focusedElement = sender as AutomationElement;
if (focusedElement == null)
{
return;
}
var window = GetTopLevelWindow(focusedElement, source);
if (source.IsCancellationRequested)
{
return;
}
if (window == null)
{
Debug.WriteLine("Null window");
return;
}
if (_focusedWindow == window)
{
Debug.WriteLine("Same window");
//return;
}
try
{
if (_focusedWindow != null)
{
Automation.RemoveStructureChangedEventHandler(_focusedWindow, OnStructureChanged);
}
}
catch (ArgumentException ex)
{
}
_focusedWindow = window;
FocusedWindowChanged?.Invoke(this, _focusedWindow);
await Update();
Automation.AddStructureChangedEventHandler(_focusedWindow, TreeScope.Subtree, OnStructureChanged);
}
catch (COMException)
{
}
});
}
// </Snippet101>
// <Snippet102>
///--------------------------------------------------------------------
/// <summary>
/// Set up grid event listeners.
/// </summary>
/// <param name="targetControl">
/// The automation element of interest.
/// </param>
///--------------------------------------------------------------------
private void SetGridEventListeners(AutomationElement targetControl)
{
StructureChangedEventHandler gridStructureChangedListener =
new StructureChangedEventHandler(OnGridStructureChange);
Automation.AddStructureChangedEventHandler(
targetControl,
TreeScope.Element,
gridStructureChangedListener);
}
void WatchPopupList(IntPtr hWnd)
{
_syncContext.Post(delegate
{
_popupList = AutomationElement.FromHandle(hWnd);
Automation.AddStructureChangedEventHandler(_popupList, TreeScope.Element, PopupListStructureChangedHandler);
// Automation.AddAutomationEventHandler(AutomationElement.v .AddStructureChangedEventHandler(_popupList, TreeScope.Element, PopupListStructureChangedHandler);
}
, null);
}
public void PatternsTest()
{
form.Show();
AutomationElement element = AutomationElement.FromHandle(form.Handle);
Automation.AddStructureChangedEventHandler(element,
TreeScope.Element | TreeScope.Children,
OnStructureChangedEventHandler);
Monitor.Enter(lockObject);
button.PerformClick();
Monitor.Wait(lockObject);
button1.PerformClick();
// Testing Patterns helpProviderElement
Assert.IsFalse((bool)helpProviderElement.GetCurrentPropertyValue(AutomationElementIdentifiers.IsDockPatternAvailableProperty),
"DockPatternIdentifiers should not be supported");
Assert.IsFalse((bool)helpProviderElement.GetCurrentPropertyValue(AutomationElementIdentifiers.IsExpandCollapsePatternAvailableProperty),
"ExpandCollapsePattern should not be supported");
Assert.IsFalse((bool)helpProviderElement.GetCurrentPropertyValue(AutomationElementIdentifiers.IsGridPatternAvailableProperty),
"GridPattern should not be supported");
Assert.IsFalse((bool)helpProviderElement.GetCurrentPropertyValue(AutomationElementIdentifiers.IsGridItemPatternAvailableProperty),
"GridItemPattern should not be supported");
Assert.IsFalse((bool)helpProviderElement.GetCurrentPropertyValue(AutomationElementIdentifiers.IsInvokePatternAvailableProperty),
"InvokePattern should not be supported");
Assert.IsFalse((bool)helpProviderElement.GetCurrentPropertyValue(AutomationElementIdentifiers.IsMultipleViewPatternAvailableProperty),
"MultipleViewPattern should not be supported");
Assert.IsFalse((bool)helpProviderElement.GetCurrentPropertyValue(AutomationElementIdentifiers.IsRangeValuePatternAvailableProperty),
"RangeValue should not be supported");
Assert.IsFalse((bool)helpProviderElement.GetCurrentPropertyValue(AutomationElementIdentifiers.IsScrollPatternAvailableProperty),
"ScrollPattern should not be supported");
Assert.IsFalse((bool)helpProviderElement.GetCurrentPropertyValue(AutomationElementIdentifiers.IsScrollItemPatternAvailableProperty),
"ScrollItemPattern should not be supported");
Assert.IsFalse((bool)helpProviderElement.GetCurrentPropertyValue(AutomationElementIdentifiers.IsSelectionPatternAvailableProperty),
"SelectionPattern should not be supported");
Assert.IsFalse((bool)helpProviderElement.GetCurrentPropertyValue(AutomationElementIdentifiers.IsSelectionItemPatternAvailableProperty),
"SelectionItemPattern should not be supported");
Assert.IsFalse((bool)helpProviderElement.GetCurrentPropertyValue(AutomationElementIdentifiers.IsTablePatternAvailableProperty),
"TablePattern should not be supported");
Assert.IsFalse((bool)helpProviderElement.GetCurrentPropertyValue(AutomationElementIdentifiers.IsTableItemPatternAvailableProperty),
"TableItemPattern should not be supported");
Assert.IsFalse((bool)helpProviderElement.GetCurrentPropertyValue(AutomationElementIdentifiers.IsTogglePatternAvailableProperty),
"TogglePattern should not be supported");
Assert.IsFalse((bool)helpProviderElement.GetCurrentPropertyValue(AutomationElementIdentifiers.IsTransformPatternAvailableProperty),
"TransformPattern should not be supported");
Assert.IsFalse((bool)helpProviderElement.GetCurrentPropertyValue(AutomationElementIdentifiers.IsValuePatternAvailableProperty),
"ValuePattern should not be supported");
Assert.IsFalse((bool)helpProviderElement.GetCurrentPropertyValue(AutomationElementIdentifiers.IsWindowPatternAvailableProperty),
"WindowPattern should not be supported");
Assert.IsFalse((bool)helpProviderElement.GetCurrentPropertyValue(AutomationElementIdentifiers.IsTextPatternAvailableProperty),
"TextPattern should not be supported");
form.Close();
Monitor.Exit(lockObject);
}
public void Start()
{
if (!this._isNodeLive)
{
using (new WaitCursor())
{
Automation.AddStructureChangedEventHandler(this._node.AutomationElement, TreeScope.Children, new StructureChangedEventHandler(OnStructureChanged));
this._isNodeLive = true;
}
}
}
/// <summary>
/// Set Event Handlers
/// </summary>
public void SetEventHandler(string ProcessName, ListView listView2)
{
//Grab Process
Process[] processes = Process.GetProcessesByName(ProcessName);
//Foreach process
foreach (Process p in processes)
{
//Declare Variables
AutomationElement window = AutomationElement.FromHandle(p.MainWindowHandle);
Automation.AddStructureChangedEventHandler(window, System.Windows.Automation.TreeScope.Children, new StructureChangedEventHandler(OnStructureChanged));
}
}
public override void Observe()
{
try
{
_eventHandler = new StructureChangedEventHandler(OnEvent);
Automation.AddStructureChangedEventHandler(AutomationElement.RootElement, TreeScope.Descendants, _eventHandler);
}
catch (Exception ex)
{
System.Diagnostics.Debug.Print($"{ex.Message}");
}
}
public ElementInfo(AutomationElement argUiElement, bool bWithChangedEvent)
{
uiElement = argUiElement;
m_AttrIsStr = ParseElementAttribute();
//ParseElementPattern();
//ParseImage();
if (bWithChangedEvent && argUiElement != null)
{
Automation.AddStructureChangedEventHandler(uiElement, TreeScope.Element,
new StructureChangedEventHandler(OnStructureChanged));
}
}
public static Task <Option <NodeError> > addSyncStructureEventWatcher(AutomationElement node
, TreeScope scope
, StructureChangeType chgType)
{
var t = new TaskCompletionSource <Option <NodeError> >();
Automation.AddStructureChangedEventHandler(
node
, scope
, (sender, args) =>
{
try
{
var autElem = sender as AutomationElement;
if (chgType == StructureChangeType.ChildrenBulkRemoved)
{
t.TrySetResult(None);
}
else if (chgType == StructureChangeType.ChildRemoved)
{
t.TrySetResult(None);
}
else if (chgType == StructureChangeType.ChildAdded)
{
t.TrySetResult(None);
}
else if (chgType == StructureChangeType.ChildrenBulkAdded)
{
t.TrySetResult(None);
}
else if (chgType == StructureChangeType.ChildrenInvalidated)
{
t.TrySetResult(None);
}
else
{
}
}
catch (Exception)
{
throw new NotImplementedException();
}
}
);
return(t.Task);
}
private void TestTypeNavigator( )
{
var controlName = SetupTypeNavControl(out var control);
var window = MakeWindow(control, out var r);
window.Show( );
Assert.NotNull(r.Task.Result);
if (r.Task.IsFaulted)
{
if (r.Task.Exception != null)
{
throw r.Task.Exception;
}
throw new Exception( );
}
var autoElem = FindControlAutomationElement(controlName);
Assert.NotNull(autoElem);
var hyperlinks = FindHyperlinks(autoElem);
Automation.AddStructureChangedEventHandler(
autoElem
, TreeScope.Descendants
, StructureChangedEventHandler
);
Assert.NotEmpty(hyperlinks);
foreach (AutomationElement hyperlink in hyperlinks)
{
// ReSharper disable once UnusedVariable
var linkText =
hyperlink.GetCurrentPropertyValue(AutomationElement.NameProperty);
if (DoInvokeHyperlink(hyperlink))
{
break;
}
}
}
public void TestStructureChangeEvent()
{
StructureChangeHandler handler = new StructureChangeHandler();
Automation.AddStructureChangedEventHandler(
AutomationElement.RootElement,
TreeScope.Subtree,
new StructureChangedEventHandler(handler.HandleEvent));
handler.Start();
// Start Notepad to get a structure change event
using (AppHost host = new AppHost("notepad.exe", ""))
{
}
Assert.IsTrue(handler.Confirm());
Assert.IsNotNull(handler.EventSource);
Automation.RemoveStructureChangedEventHandler(
AutomationElement.RootElement,
new StructureChangedEventHandler(handler.HandleEvent));
}
private void AddProfileChangeDetector()
{
try
{
Automation.AddStructureChangedEventHandler(Instance.profilePanel, TreeScope.Element, async delegate(object o, StructureChangedEventArgs args)
{
AutomationElement element = o as AutomationElement;
if (args.StructureChangeType == StructureChangeType.ChildRemoved)
{
SimFeedbackFacadeProvider.Instance.DispatcherHelper.Invoke((Action)(() =>
{
GuiLoggerProvider.Instance.Log("Profile Change detected...");
Instance.SelectProfileTab();
Instance.LoadElements();
}));
}
});
}
catch (Exception ex)
{
GuiLoggerProvider.Instance.Log("Error during loading of AddProfileChangeDetector: " + ex.Message);
}
}
public void AddEvent(AutomationElement elementRoot)
{
//Task.Factory.StartNew(() =>
Automation.AddStructureChangedEventHandler(elementRoot, TreeScope.Subtree,
new StructureChangedEventHandler(OnStructureChanged));
}
// </SnippetPlayback>
//private void OnFocusChange(object src, PropertyChangedEventArgs e)
//{
// FocusHandler focusedElement = src as FocusHandler;
// ElementStore focusChange = new ElementStore();
// try
// {
// focusChange.AutomationID = focusedElement.CurrentlyFocusedElement.Current.AutomationId;
// focusChange.ClassName = focusedElement.CurrentlyFocusedElement.Current.ClassName;
// focusChange.ControlType = focusedElement.CurrentlyFocusedElement.Current.ControlType.ProgrammaticName;
// focusChange.EventID = e.PropertyName;
// focusChange.SupportedPatterns = focusedElement.CurrentlyFocusedElement.GetSupportedPatterns();
// //if (elementStore.Contains(focusChange))
// //{
// // return;
// //}
// elementStore.Enqueue(focusChange);
// }
// catch (NullReferenceException)
// {
// return;
// }
//}
private void RegisterStructureChangeEventListener(AutomationElement targetApp)
{
StructureChangedEventHandler structureChangeListener = new StructureChangedEventHandler(OnStructureChange);
Automation.AddStructureChangedEventHandler(targetApp, TreeScope.Descendants, structureChangeListener);
}
public override void Add(WrappedEventHandler handler, AutomationElementWrapper element)
{
_handler = (o, e) => handler(element, e);
_element = element.Element;
Automation.AddStructureChangedEventHandler(_element, _scope, _handler);
}
public static IDisposable ToStructureChangedEvent(AutomationElement element, TreeScope treeScope, StructureChangedEventHandler handler)
{
Automation.AddStructureChangedEventHandler(element, treeScope, handler);
return(Disposable.Create(() => Automation.RemoveStructureChangedEventHandler(element, handler)));
}
static object ElementAndDescendents2SerializableObject(
AutomationElement rootElement,
int maxDepth,
List <string> ignoreChildrenOfTheseClassNames,
bool addStructureChangedEventHandler = false)
{
try
{
if (addStructureChangedEventHandler)
{
Automation.AddStructureChangedEventHandler(rootElement, TreeScope.Descendants,
(sender, e) =>
{
AutomationElement senderElement = (AutomationElement)sender;
if (senderElement != null)
{
// Check if this event is coming from below a class that we're ignoring
bool ignoreThisOne = false;
try
{
AutomationElement ancestor = TreeWalker.ControlViewWalker.GetParent(senderElement);
while (ancestor != null)
{
string cachedAncestorClassName = ancestor.Current.ClassName;
if (ignoreChildrenOfTheseClassNames.Any(
stopDiggingAfterThisClassName => cachedAncestorClassName == stopDiggingAfterThisClassName
))
{
ignoreThisOne = true;
break;
}
ancestor = TreeWalker.ControlViewWalker.GetParent(ancestor);
}
}
catch (ElementNotAvailableException)
{
}
if (!ignoreThisOne)
{
SerializeToConsoleIfNotNull(
ElementAndDescendents2SerializableObject(senderElement, maxDepth, ignoreChildrenOfTheseClassNames)
);
}
}
});
}
string cachedClassName = rootElement.Current.ClassName;
Dictionary <string, object> properties = new Dictionary <string, object>
{
{ "name", rootElement.Current.Name },
{ "className", cachedClassName },
{ "isOffscreen", rootElement.Current.IsOffscreen },
};
if (!ignoreChildrenOfTheseClassNames.Any(
stopDiggingAfterThisClassName => cachedClassName == stopDiggingAfterThisClassName
))
{
List <object> children = new List <object>();
if (maxDepth > 0)
{
AutomationElement child = TreeWalker.ControlViewWalker.GetFirstChild(rootElement);
while (child != null)
{
children.Add(ElementAndDescendents2SerializableObject(child, maxDepth - 1, ignoreChildrenOfTheseClassNames));
child = TreeWalker.ControlViewWalker.GetNextSibling(child);
}
}
if (children.Count > 0)
{
properties.Add("children", children);
}
}
return(properties);
}
catch (ElementNotAvailableException)
{
// It's gone
return(null);
}
}
protected void TestTypeControl( )
{
var controlName = SetupTypeControl(out var control);
control.SetValue(Props.RenderedTypeProperty, typeof(string));
control.Detailed = true;
var window = MakeWindow(control, out var taskCompletionSource);
Logger.Debug("showing window");
window.Show( );
Logger.Debug("Asserting that the task completion source result is not null.");
Assert.NotNull(taskCompletionSource.Task.Result);
Logger.Debug("Assertion complete.");
if (taskCompletionSource.Task.IsFaulted)
{
Logger.Debug("task faulted");
if (taskCompletionSource.Task.Exception != null)
{
throw taskCompletionSource.Task.Exception;
}
}
Task.Factory.StartNew(
() => {
var autoElem = FindControlAutomationElement(controlName);
Assert.NotNull(autoElem);
var hyperlinks = FindHyperlinks(autoElem);
Automation.AddStructureChangedEventHandler(
autoElem
, TreeScope
.Descendants
, (sender, args)
=> {
Logger.Debug(
$"structure: {args.StructureChangeType}"
);
}
);
Assert.NotEmpty(hyperlinks);
foreach (AutomationElement hyperlink in hyperlinks)
{
// ReSharper disable once UnusedVariable
var linkText =
hyperlink.GetCurrentPropertyValue(
AutomationElement
.NameProperty
);
if (hyperlink.TryGetCurrentPattern(
InvokePattern
.Pattern
, out
var patternObject
))
{
if (patternObject is InvokePattern invoke)
{
Automation
.AddAutomationPropertyChangedEventHandler(
hyperlink
, TreeScope
.Element
, (
sender
, args
) => {
Logger.Debug(
"update: "
+ args
.Property
.ProgrammaticName
+ " = "
+ args
.NewValue
);
}
, hyperlink
.GetSupportedProperties( )
);
Logger.Debug("yay");
invoke.Invoke( );
Thread.Sleep(2000);
}
}
}
}
, TaskCreationOptions.DenyChildAttach
)
.Wait(5000);
}
