/////////////////////////////////////////////////////////////////////////////////////////////////
//
// HandleStructureChangedEvent()
//
// Sample application's handler for UIA StructureChanged events.
//
// Runs on a background thread create by UIA.
//
/////////////////////////////////////////////////////////////////////////////////////////////////
public void HandleStructureChangedEvent(IUIAutomationElement sender, StructureChangeType changeType, int[] array)
{
// A structure changed event has been sent by the browser window element or some descendant of it.
// Check that this event hasn't arrived around the time we're removing the event handler on shutdown.
if (!_fAddedEventHandler)
{
return;
}
// For this sample, all the event handler needs to do is notify the main UI thread that the
// list of hyperlinks should be refreshed to make sure it's showing the most current list.
// A shipping event handler might want to interact with the sender of the events.
// For example if this was a Focus Changed event handler, it might get the cached
// bounding rect from the sender to highlight where focus is now. Preferably the
// work done is kept to a minimum in the UIA event handler itself, so the handler
// could signal to another thread that action is required.
// Note that the browser window can send many Structure Changed events in rapid succession.
// There's nothing to be gained by trying to act on every event received, so only refresh
// the list of hyperlinks 2 seconds after an event is received. (This delay would want to
// be tuned for the best user experience in a shipping app.)
if (_timerRefresh == null)
{
_timerRefresh = new System.Windows.Forms.Timer();
_timerRefresh.Tick += new EventHandler(timerRefresh_Tick);
_timerRefresh.Interval = 2000;
_timerRefresh.Start();
}
}
private void MyStructureChangedHandler(object obj, StructureChangeType sct, bool isPropagated)
{
switch (sct)
{
case StructureChangeType.AddPreEdge: SelfValidState = false; break;
case StructureChangeType.RemovePreEdge: SelfValidState = false; break;
case StructureChangeType.AddCostart: SelfValidState = false; break;
case StructureChangeType.RemoveCostart: SelfValidState = false; break;
case StructureChangeType.AddPostEdge: break;
case StructureChangeType.RemovePostEdge: break;
case StructureChangeType.AddCofinish: break;
case StructureChangeType.RemoveCofinish: break;
case StructureChangeType.AddChildEdge: break;
case StructureChangeType.RemoveChildEdge: break;
case StructureChangeType.NewSynchronizer: SelfValidState = false; break;
case StructureChangeType.Unknown: SelfValidState = false; if (s_diagnostics)
{
Debugger.Break();
}
break;
default: throw new ApplicationException("Unknown StructureChangeType, " + sct + ", referenced.");
}
}
private void OnStructureChange(object obj, StructureChangeType chType, bool isPropagated)
{
#region Rule #1. If a vertex loses or gains a predecessor, it invalidates all of its sucessors.
if (StructureChangeTypeSvc.IsPreEdgeChange(chType))
{
if (obj is Vertex)
{
Vertex vertex = (Vertex)obj;
ArrayList successors = new ArrayList();
successors.AddRange(vertex.GetSuccessors());
while (successors.Count > 0)
{
IHasValidity ihv = (IHasValidity)successors[0];
successors.RemoveAt(0);
if (ihv is Tasks.Task)
{
((Tasks.Task)ihv).SelfValidState = false;
}
else
{
successors.AddRange(ihv.GetSuccessors());
}
}
}
}
#endregion
m_dirty = true;
}
internal static void RaiseStructureChangedEvent(StructureChangeType type,
IRawElementProviderFragment provider)
{
if (AutomationInteropProvider.ClientsAreListening)
{
int [] runtimeId = null;
if (type == StructureChangeType.ChildRemoved)
{
if (provider.FragmentRoot == null) //FIXME: How to fix it?
{
runtimeId = provider.GetRuntimeId();
}
else
{
runtimeId = provider.FragmentRoot.GetRuntimeId();
}
}
else if (type == StructureChangeType.ChildrenBulkAdded ||
type == StructureChangeType.ChildrenBulkRemoved)
{
runtimeId = new int[] { 0 }
}
;
else
{
runtimeId = provider.GetRuntimeId();
}
var invalidatedArgs = new StructureChangedEventArgs(type, runtimeId);
AutomationInteropProvider.RaiseStructureChangedEvent(provider, invalidatedArgs);
}
}
public StructureChangedEventArgs(StructureChangeType structureChangeType, int[] runtimeId)
: base(eventId: AutomationElement.StructureChangedEvent)
{
Validate.ArgumentNotNull(parameter: runtimeId, parameterName: nameof(runtimeId));
StructureChangeType = structureChangeType;
this._runtimeId = (int[])runtimeId.Clone();
}
public void HandleStructureChangedEvent(IUIAutomationElement sender, StructureChangeType changeType, int[] runtimeId)
{
StructureChangedEventArgs args = new StructureChangedEventArgs(
(StructureChangeType)changeType,
(int[])runtimeId);
this._structureChangeHandler(AutomationElement.Wrap(sender), args);
}
/// <summary>
/// Determines whether the StructureChangeType signifies a removal.
/// </summary>
/// <param name="sct">The StructureChangeType.</param>
/// <returns>true if the StructureChangeType signifies a removal.</returns>
public static bool IsRemovalChange(StructureChangeType sct)
{
return(sct.Equals(StructureChangeType.RemovePostEdge) ||
sct.Equals(StructureChangeType.RemovePreEdge) ||
sct.Equals(StructureChangeType.RemoveCostart) ||
sct.Equals(StructureChangeType.RemoveCofinish) ||
sct.Equals(StructureChangeType.RemoveChildEdge));
}
/// <summary>
/// Determines whether the StructureChangeType signifies an addition.
/// </summary>
/// <param name="sct">The StructureChangeType.</param>
/// <returns>true if the StructureChangeType signifies an addition.</returns>
public static bool IsAdditionChange(StructureChangeType sct)
{
return(sct.Equals(StructureChangeType.AddPostEdge) ||
sct.Equals(StructureChangeType.AddPreEdge) ||
sct.Equals(StructureChangeType.AddCostart) ||
sct.Equals(StructureChangeType.AddCofinish) ||
sct.Equals(StructureChangeType.NewSynchronizer) ||
sct.Equals(StructureChangeType.AddChildEdge));
}
public StructureChangedEventArgs(StructureChangeType structureChangeType, int[] runtimeId) : base(AutomationElementIdentifiers.StructureChangedEvent)
{
if (runtimeId == null)
{
throw new ArgumentNullException("runtimeId");
}
this._structureChangeType = structureChangeType;
this._runtimeID = (int[])runtimeId.Clone();
}
public void ValuesTest()
{
int[] fakeRuntimeId = { 0 };
StructureChangeType sct = StructureChangeType.ChildrenBulkAdded;
StructureChangedEventArgs args =
new StructureChangedEventArgs(sct, fakeRuntimeId);
Assert.AreEqual(AutomationElementIdentifiers.StructureChangedEvent, args.EventId, "Check Event Id");
Assert.AreEqual(sct, args.StructureChangeType, "Check StructureChangeType member");
}
public NavigationEventArgs(bool raiseEvent,
StructureChangeType changeType,
FragmentControlProvider childProvider,
int index)
: base()
{
this.raiseEvent = raiseEvent;
this.changeType = changeType;
this.childProvider = childProvider;
this.index = index;
}
public NavigationEventArgs (bool raiseEvent,
StructureChangeType changeType,
FragmentControlProvider childProvider,
int index)
: base ()
{
this.raiseEvent = raiseEvent;
this.changeType = changeType;
this.childProvider = childProvider;
this.index = index;
}
public StructureChangedEventTuple GetStructureChangedEventFrom(StructureChangeType changeType)
{
foreach (StructureChangedEventTuple tuple in StructureChangedEvents)
{
if (tuple.e.StructureChangeType == changeType)
{
return(tuple);
}
}
return(null);
}
public int GetStructureChangedEventCount(StructureChangeType changeType)
{
int count = 0;
foreach (StructureChangedEventTuple tuple in StructureChangedEvents)
{
if (tuple.e.StructureChangeType == changeType)
{
count++;
}
}
return(count);
}
public void HandleStructureChangedEvent(IUIAutomationElement sender, StructureChangeType changeType, int[] runtimeId)
{
var m = EventMessage.GetInstance(EventType.UIA_StructureChangedEventId, sender);
if (m != null)
{
m.Properties = new List <KeyValuePair <string, dynamic> >
{
new KeyValuePair <string, dynamic>("StructureChangeType", changeType),
new KeyValuePair <string, dynamic>("Runtime Id", runtimeId.ConvertInt32ArrayToString()),
};
this.ListenEventMessage(m);
}
}
protected void NotifyOnChildStructureChanged(
FragmentControlProvider subjectProvider, StructureChangeType structureChangeType, bool emitUiaEvents)
{
if (NavigationUpdated != null)
{
var args = new NavigationEventArgs(emitUiaEvents, structureChangeType, subjectProvider);
NavigationUpdated(this, args);
}
if (emitUiaEvents)
{
Helper.RaiseStructureChangedEvent(structureChangeType, subjectProvider);
Helper.RaiseStructureChangedEvent(StructureChangeType.ChildrenInvalidated, this);
}
}
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 RaiseNavigationEvent(StructureChangeType type,
ref FragmentControlProvider provider,
SWF.ScrollBar scrollbar)
{
if (type == StructureChangeType.ChildAdded)
{
provider = subject.GetScrollbarProvider(scrollbar);
provider.Initialize();
subject.AddChildProvider(provider);
}
else
{
subject.RemoveChildProvider(provider);
provider.Terminate();
provider = null;
}
}
internal static void RaiseStructureChangedEvent(IElement element, StructureChangeType type)
{
StructureChangedEventArgs e;
int [] runtimeId = (element != null
? element.RuntimeId
: new int [0]);
e = new StructureChangedEventArgs(type, runtimeId);
foreach (StructureChangedEventHandlerData handler in structureEventHandlers)
{
if (IsElementInScope(element, handler.Element, handler.Scope))
{
handler.EventHandler(SourceManager.GetOrCreateAutomationElement(element),
e);
break;
}
}
}
private void OnStructureChanged(AutomationElement ae,
StructureChangeType changeType,
int[] values)
{
switch (changeType)
{
case StructureChangeType.ChildAdded:
case StructureChangeType.ChildrenBulkAdded:
Awaiter_DoFilter(ae,
ElementAddedWaiters);
break;
case StructureChangeType.ChildRemoved:
case StructureChangeType.ChildrenBulkRemoved:
Awaiter_DoFilter(ae,
ElementRemovedWaiters);
break;
}
}
public StructureChangedEventTuple GetStructureChangedEventAt(int index,
StructureChangeType changeType)
{
if (index >= StructureChangedEvents.Count || index < 0)
{
return(null);
}
int counter = 0;
foreach (StructureChangedEventTuple tuple in StructureChangedEvents)
{
if (tuple.e.StructureChangeType == changeType)
{
if (counter++ == index)
{
return(tuple);
}
}
}
return(null);
}
public StructureChangedEventTuple GetStructureChangedEventFrom (StructureChangeType changeType)
{
foreach (StructureChangedEventTuple tuple in StructureChangedEvents) {
if (tuple.e.StructureChangeType == changeType)
return tuple;
}
return null;
}
public StructureChangedEventTuple GetStructureChangedEventFrom (object element, StructureChangeType changeType)
{
foreach (StructureChangedEventTuple tuple in StructureChangedEvents) {
if (tuple.e.StructureChangeType == changeType && tuple.provider == element)
return tuple;
}
return null;
}
// fire the structure change event if there is a client listening for it.
private void MaybeFireStructureChangeEvent(int eventId, Hashtable eventTable, IntPtr hwnd, int idObject, int idChild)
{
// if the 2-nd level table contains an entry for this event and element is not the root
// (the host hwnd provider takes care of structure changed events for the root.)
if (eventTable.ContainsKey(AutomationElement.StructureChangedEvent) && !IsClientObject(idObject, idChild))
{
// Note: src element for ChildRemoved cases needs to be the parent, but the runtime id is the child!
// the type of structure changed event that we will fire depends on which event we are receiving.
// the type then determines the src element -- either the parent or the child -- and the runtime id
// -- either the parent or the child -- for the event arguments.
IRawElementProviderFragment srcElement;
int[] runtimeId = null;
StructureChangeType type = StructureChangeType.ChildAdded; // Actual value is assigned below; any value will do here, to init the var
switch (eventId)
{
case NativeMethods.EVENT_OBJECT_CREATE:
case NativeMethods.EVENT_OBJECT_SHOW:
// src element is child. runtime id is child.
srcElement = (IRawElementProviderFragment)MsaaNativeProvider.Create(hwnd, idChild, idObject);
if (srcElement != null)
{
runtimeId = srcElement.GetRuntimeId();
type = StructureChangeType.ChildAdded;
}
break;
//case NativeMethods.EVENT_OBJECT_DESTROY:
// src element is parent. runtime id is child.
// There is nothing we can do in this case. Since the object is destroyed we can't instantiate
// it in order to get its runtime ID. Even if it had a non-zero child id such that we could
// instantiate its parent we still couldn't determine the runtime ID of the child that was destroyed.
// There's also no guarantee that an EVENT_OBJECT_DESTROY will have a corresponding EVENT_OBJECT_CREATE
// and even if it did it might use a different object id so we can't cache the information either.
// (Trident for example uses a cyclic counter to generate object ids so the object id can vary for
// the same object from one event to the next!)
case NativeMethods.EVENT_OBJECT_HIDE:
// src element is parent. runtime id is child.
srcElement = (IRawElementProviderFragment)MsaaNativeProvider.Create(hwnd, idChild, idObject);
if (srcElement != null)
{
runtimeId = srcElement.GetRuntimeId();
srcElement = (IRawElementProviderFragment)srcElement.Navigate(NavigateDirection.Parent);
type = StructureChangeType.ChildRemoved;
}
break;
default:
Debug.Assert(eventId == NativeMethods.EVENT_OBJECT_REORDER);
// src element is parent. runtime id is parent.
srcElement = (IRawElementProviderFragment)MsaaNativeProvider.Create(hwnd, idChild, idObject);
if (srcElement != null)
{
runtimeId = srcElement.GetRuntimeId();
type = StructureChangeType.ChildrenReordered;
}
break;
}
if (srcElement != null)
{
// fire the event
StructureChangedEventArgs eventArgs = new StructureChangedEventArgs(type, runtimeId);
//Debug.WriteLine(string.Format(CultureInfo.CurrentCulture, "Firing structure change event for {0}", hwnd), "NativeMsaaProxy");
AutomationInteropProvider.RaiseStructureChangedEvent(srcElement, eventArgs);
}
}
}
/// -------------------------------------------------------------------
/// <summary>
/// Method determines if the desired event was fired
/// </summary>
/// -------------------------------------------------------------------
public virtual EventFired WasEventFired(AutomationElement element, StructureChangeType structureChangeType)
{
return EventObject.WasEventFired(new EventItem(element, structureChangeType));
}
private static extern int RawUiaRaiseStructureChangedEvent(IRawElementProviderSimple provider, StructureChangeType structureChangeType, int[] runtimeId, int runtimeIdLen);
/// <inheritdoc/>
public void HandleStructureChangedEvent(AutomationElement sender, StructureChangeType changeType, int[] runtimeId)
{
this.callAction(sender, changeType, runtimeId);
}
public StructureChangedEventArgs(StructureChangeType structureChangeType, int[] runtimeId)
: base(AutomationElementIdentifiers.StructureChangedEvent)
{
if (runtimeId == null)
{
throw new ArgumentNullException("runtimeId");
}
this._structureChangeType = structureChangeType;
this._runtimeID = (int[])runtimeId.Clone();
}
/// <summary>
/// Determines whether the StructureChangeType signifies a change in a synchronizer.
/// </summary>
/// <param name="sct">The StructureChangeType.</param>
/// <returns>true if the StructureChangeType signifies a change in a synchronizer.</returns>
public static bool IsSynchronizerChange(StructureChangeType sct)
{
return(sct.Equals(StructureChangeType.NewSynchronizer));
}
private void RaiseNavigationEvent (StructureChangeType type,
ref FragmentControlProvider provider,
SWF.ScrollBar scrollbar)
{
if (type == StructureChangeType.ChildAdded) {
provider = subject.GetScrollbarProvider (scrollbar);
provider.Initialize ();
subject.AddChildProvider (provider);
} else {
subject.RemoveChildProvider (provider);
provider.Terminate ();
provider = null;
}
}
public int GetStructureChangedEventCount (StructureChangeType changeType)
{
int count = 0;
foreach (StructureChangedEventTuple tuple in StructureChangedEvents) {
if (tuple.e.StructureChangeType == changeType)
count++;
}
return count;
}
internal static void UiaRaiseStructureChangedEvent(IRawElementProviderSimple provider, StructureChangeType structureChangeType, int[] runtimeId)
{
CheckError(RawUiaRaiseStructureChangedEvent(provider, structureChangeType, runtimeId, (runtimeId == null) ? 0 : runtimeId.Length));
}
private static extern int RawUiaRaiseStructureChangedEvent(IRawElementProviderSimple provider, StructureChangeType structureChangeType, int[] runtimeId, int runtimeIdLen);
/// -------------------------------------------------------------------
/// <summary>
/// Use the application's callback to cause a structure change to occur
/// </summary>
/// -------------------------------------------------------------------
void TS_CauseStructureChange(AutomationElement element, StructureChangeType structureChangeType, CheckType ct)
{
if (_structChange == null)
_structChange = _appCommands.GetIWUIStructureChange();
_structChange.CauseStructureChange(element, structureChangeType);
Comment(structureChangeType + " has occured");
m_TestStep++;
}
/// -------------------------------------------------------------------
/// <summary>
/// Tests to see if the element supports testing the structure change events
/// </summary>
/// -------------------------------------------------------------------
private void TS_ElementSupportChangeEvents(AutomationElement element, StructureChangeType structureChangeType, CheckType checkType)
{
if (_structChange == null)
_structChange = _appCommands.GetIWUIStructureChange();
if (!_structChange.DoesControlSupportStructureChange(element, structureChangeType))
ThrowMe(checkType);
Comment("Control supports testing " + structureChangeType.ToString());
m_TestStep++;
}
internal static void RaiseStructureChangedEvent (IElement element, StructureChangeType type)
{
StructureChangedEventArgs e;
int [] runtimeId = (element != null
? element.RuntimeId
: new int [0]);
e = new StructureChangedEventArgs (type, runtimeId);
foreach (StructureChangedEventHandlerData handler in structureEventHandlers) {
if (IsElementInScope (element, handler.Element, handler.Scope)) {
handler.EventHandler (SourceManager.GetOrCreateAutomationElement (element),
e);
break;
}
}
}
public StructureChangedEventArgs (StructureChangeType structureChangeType, int[] runtimeId) :
base (AutomationElementIdentifiers.StructureChangedEvent)
{
this.structureChangeType = structureChangeType;
this.runtimeId = runtimeId;
}
/// <summary>
/// Determines whether StructureChangeType was a pre-edge change.
/// </summary>
/// <param name="sct">The StructureChangeType.</param>
/// <returns>true if the StructureChangeType signifies a change in a predecessor-edge.
/// </returns>
public static bool IsPreEdgeChange(StructureChangeType sct)
{
return(sct.Equals(StructureChangeType.AddPreEdge) || sct.Equals(StructureChangeType.RemovePreEdge));
}
public void ParseStructureChange (out StructureChangeType type, out Gst.Element owner, out bool busy) {
if (Type != MessageType.StructureChange)
throw new ArgumentException ();
IntPtr raw_ptr;
gst_message_parse_structure_change (Handle, out type, out raw_ptr, out busy);
owner = Gst.GLib.Object.GetObject (raw_ptr, false) as Gst.Element;
}
/// -------------------------------------------------------------------
/// <summary>
/// Verify that the property changed
/// </summary>
/// -------------------------------------------------------------------
internal void TS_VerifyLogicalStructureChangedEventArgs(AutomationElement element, EventFired shouldFire, StructureChangeType properties, CheckType checkType)
{
if (_testEvents)
{
Comment("Start: Looking for event that might have been fired");
EventFired ActualFired = m_StructureChangedEvents.WasEventFired(element, properties);
Comment("End : Looking for event that might have been fired");
TestIfEventShouldFire(shouldFire, ActualFired, properties, checkType);
}
else
{
Comment("Not testing for events");
}
m_TestStep++;
}
static extern void gst_message_parse_structure_change (IntPtr msg, out StructureChangeType type, out IntPtr owner, out bool busy);
public NavigationEventArgs (bool raiseEvent,
StructureChangeType changeType,
FragmentControlProvider childProvider)
: this (raiseEvent, changeType, childProvider, -1)
{
}
public static Message NewStructureChange (Gst.Object src, StructureChangeType type, Gst.Element owner, bool busy) {
Message msg = (Message) Gst.MiniObject.GetObject (gst_message_new_structure_change (src.Handle, type, owner.Handle, busy), true);
return msg;
}
private void StructureAction(AutomationElement automationAutomationElement, StructureChangeType arg2, int[] arg3)
{
AddToList($"Structure change on {ElementToString(automationAutomationElement)}: {arg2}");
}
static extern IntPtr gst_message_new_structure_change (IntPtr src, StructureChangeType type, IntPtr owner, bool busy);
internal static void UiaRaiseStructureChangedEvent(IRawElementProviderSimple provider, StructureChangeType structureChangeType, int[] runtimeId)
{
CheckError(RawUiaRaiseStructureChangedEvent(provider, structureChangeType, runtimeId, (runtimeId == null) ? 0 : runtimeId.Length));
}
/// <summary>
/// Determines whether the StructureChangeType signifies a co-finish change.
/// </summary>
/// <param name="sct">The StructureChangeType.</param>
/// <returns>true if the StructureChangeType signifies a change in a co-finish.</returns>
public static bool IsCofinishChange(StructureChangeType sct)
{
return(sct.Equals(StructureChangeType.AddCofinish) || sct.Equals(StructureChangeType.RemoveCofinish));
}
public static extern HRESULT UiaRaiseStructureChangedEvent(IRawElementProviderSimple pProvider, StructureChangeType structureChangeType, int[] pRuntimeId, int cRuntimeIdLen);
/// <summary>
/// Determines whether the StructureChangeType signifies a change in a child.
/// </summary>
/// <param name="sct">The StructureChangeType.</param>
/// <returns>true if the StructureChangeType signifies a change in a child.</returns>
public static bool IsChildChange(StructureChangeType sct)
{
return(sct.Equals(StructureChangeType.AddChildEdge) || sct.Equals(StructureChangeType.RemoveChildEdge));
}
public StructureChangedEventTuple GetStructureChangedEventAt (int index,
StructureChangeType changeType)
{
if (index >= StructureChangedEvents.Count || index < 0)
return null;
int counter = 0;
foreach (StructureChangedEventTuple tuple in StructureChangedEvents) {
if (tuple.e.StructureChangeType == changeType) {
if (counter++ == index)
return tuple;
}
}
return null;
}
/// -------------------------------------------------------------------
/// <summary>
/// Main driver for the tests to call that will cause some structure
/// change even to occur.
/// </summary>
/// -------------------------------------------------------------------
internal void TestLogicalStructureChangeEvent(StructureChangeType structureChangeType)
{
EventObject.EventList = new ArrayList();
Exception caughtException = null;
try
{
// 0) Precondition: Determine if the application supports the custom interface callback for specific test applications
TS_SupportsApplicationCallback(CheckType.IncorrectElementConfiguration);
// 1) Precondition: Determine is this appliction supports driving structure changes
TS_SupportsStructureChangeEvents(CheckType.IncorrectElementConfiguration);
// 2) Precondition: Determine if the specific element supports structure change
TS_ElementSupportChangeEvents(m_le, structureChangeType, CheckType.IncorrectElementConfiguration);
// 3) Step: Add LogicalTreeStructureListener
TS_AddLogicalTreeStructureListener(true, m_le, TreeScope.Element, CheckType.Verification);
// 4) Step: Invoke the 'Bulk Add' menu item
TS_CauseStructureChange(m_le, structureChangeType, CheckType.Verification);
// 5) Step: Wait for the LogicalStructureChangedEvent to be fired
TSC_WaitForEvents(1);
// 6) Step: That LogicalStructureChangedEvent was fired
if (m_le.Current.FrameworkId.ToLower() == "win32" &&
m_le.Current.ControlType == ControlType.List &&
(structureChangeType == StructureChangeType.ChildAdded || structureChangeType == StructureChangeType.ChildRemoved))
{
// Win32 controls can't determine when ChildAdd?Remove happens so fire a ChildInvalidated instead
TS_VerifyLogicalStructureChangedEventArgs(m_le, EventFired.True, StructureChangeType.ChildrenInvalidated, CheckType.Verification);
}
else
{
TS_VerifyLogicalStructureChangedEventArgs(m_le, EventFired.True, structureChangeType, CheckType.Verification);
}
}
catch (Exception exception)
{
caughtException = exception;
}
finally
{
if (caughtException is IncorrectElementConfigurationForTestException)
{
m_TestStep++;
}
else
{
// 7) Step: Reset the control to it's initial state
TS_ResetControlToInitialState(m_le, CheckType.Verification);
}
if (null != caughtException)
throw caughtException;
}
}
