private void OnStructureChangedEventHandler(object sender, StructureChangedEventArgs args)
{
Monitor.Enter(lockObject);
if (sender != null)
{
AutomationElement element = sender as AutomationElement;
ControlType ctype
= (ControlType)element.GetCurrentPropertyValue(AutomationElementIdentifiers.ControlTypeProperty);
if (ctype == ControlType.Pane) // NOTE: In our implementation we are using ToolTip instead of Pane
{
helpProviderElement = element;
// NameProperty must be equal to this.Message
Assert.AreEqual(Message,
(string)helpProviderElement.GetCurrentPropertyValue(AutomationElementIdentifiers.NameProperty),
string.Format("Message: {0} different to {1}",
(string)helpProviderElement.GetCurrentPropertyValue(AutomationElementIdentifiers.NameProperty),
Message));
Monitor.Pulse(lockObject);
// We are done listening for the HelpProvider ToolTip
AutomationElement formElement = AutomationElement.FromHandle(form.Handle);
Automation.RemoveStructureChangedEventHandler(formElement,
OnStructureChangedEventHandler);
}
}
Monitor.Exit(lockObject);
}
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 override void RaiseAutomationPropertyChangedEvent(AutomationPropertyChangedEventArgs e)
{
if (e.Property == AutomationElementIdentifiers.ControlTypeProperty)
{
//We remove the current Adapter and add it again to reflect the ControlType change
StructureChangedEventArgs args
= new StructureChangedEventArgs(StructureChangeType.ChildRemoved,
new int[] { 0 }); //TODO: Fix ?
AutomationInteropProvider.RaiseStructureChangedEvent(Provider,
args);
args = new StructureChangedEventArgs(StructureChangeType.ChildAdded,
new int[] { 0 }); //TODO: Fix ?
AutomationInteropProvider.RaiseStructureChangedEvent(Provider,
args);
}
if (e.Property == TogglePatternIdentifiers.ToggleStateProperty)
{
//if it's a toggle, it should not be a basic Button class, but CheckBox or other
throw new NotSupportedException("Toggle events should not land here (should not be reached)");
}
else
{
base.RaiseAutomationPropertyChangedEvent(e);
}
}
internal void RaiseStructureChangedEvent(IRawElementProviderSimple provider,
StructureChangedEventArgs e)
{
if (provider == null)
{
return;
}
var wrapper = AutomationBridge.Instance.FindWrapperByProvider(provider);
if (wrapper == null)
{
Log.Error("[UiaDbusBridge.RaiseStructureChangedEvent] Inconsistent provider -> wrapper mapping state",
provider.GetPropertyValue(AutomationElementIdentifiers.NameProperty.Id));
return;
}
lock (structureEventHandlers) {
foreach (AutomationEventHandlerData handler in structureEventHandlers)
{
if (IsProviderInScope(provider, handler.Provider, handler.Scope))
{
OnStructureChanged(handler.HandlerId, handler.EventId, wrapper.Path,
e.StructureChangeType);
}
}
}
}
// </Snippet102>
// <Snippet103>
///--------------------------------------------------------------------
/// <summary>
/// Event handler for grid structure change.
/// </summary>
/// <param name="src">Object that raised the event.</param>
/// <param name="e">Event arguments.</param>
///--------------------------------------------------------------------
private void OnGridStructureChange(
object src, StructureChangedEventArgs 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;
}
GridPattern gridPattern = GetGridPattern(sourceElement);
if (gridPattern == null)
{
return;
}
if (gridPattern.Current.ColumnCount != columnCount)
{
// Column item added.
}
else if (gridPattern.Current.RowCount != rowCount)
{
// Row item added.
}
}
/// <summary>
/// Handles structure-changed events. If a new app window has been added, this method ensures
/// it's in the list of runtime IDs and subscribed to window-close events.
/// </summary>
/// <param name="sender">Object that raised the event.</param>
/// <param name="e">Event arguments.</param>
/// <remarks>
/// An exception can be thrown by the UI Automation core if the element disappears
/// before it can be processed -- for example, if a menu item is only briefly visible.
/// This exception cannot be caught here because it crosses native/managed boundaries.
/// In the debugger, you can ignore it and continue execution. The exception does not cause
/// a break when the executable is being run.
/// </remarks>
private void OnStructureChanged(object sender, StructureChangedEventArgs e)
{
AutomationElement element = sender as AutomationElement;
//element
logger.Info("OnStructureChanged: " + e.StructureChangeType);
if (e.StructureChangeType == StructureChangeType.ChildAdded)
{
try
{
int[] rid = e.GetRuntimeId();
if (!runtimeIdList.Contains(rid) &&
!Comparison.CheckListElementContain(listAutoElementAdded, element) &&
!Comparison.CheckListElementContain(listElementAdded, element))
{
newElementAddedNotify.NewElementAddedCallback(element);
}
runtimeIdList.Add(rid);
listAutoElementAdded.Add(element);
} catch (ElementNotAvailableException ex)
{
logger.Error("Element not available exception. " + Utils.ExceptionToString(ex));
}
}
}
private void OnStructureChanged(object sender, StructureChangedEventArgs e)
{
if (StructureChangedHandler != null)
{
StructureChangedHandler(uiElement, e);
}
}
public void HandleStructureChangedEvent(IUIAutomationElement sender, StructureChangeType changeType, int[] runtimeId)
{
StructureChangedEventArgs args = new StructureChangedEventArgs(
(StructureChangeType)changeType,
(int[])runtimeId);
this._structureChangeHandler(AutomationElement.Wrap(sender), args);
}
void UIAutomationClient.IUIAutomationStructureChangedEventHandler.HandleStructureChangedEvent(UIAutomationClient.IUIAutomationElement sender, UIAutomationClient.StructureChangeType changeType, Array runtimeId)
{
StructureChangedEventArgs args = new StructureChangedEventArgs(
(StructureChangeType)changeType,
(int[])runtimeId);
this._structureChangeHandler(AutomationElement.Wrap(sender), args);
}
private void OnStructureChange(object src, StructureChangedEventArgs e)
{
AutomationElement source = src as AutomationElement;
ElementStore structureChange = new ElementStore();
structureChange.AutomationID = source.Current.AutomationId;
structureChange.EventID = e.EventId.ProgrammaticName;
elementStore.Enqueue(structureChange);
}
public void RaiseStructureChangedEvent(object provider, StructureChangedEventArgs e)
{
var simpleProvider = provider as IRawElementProviderSimple;
if (e.StructureChangeType == StructureChangeType.ChildAdded)
{
if (simpleProvider == null)
{
return;
}
object providerHandleObj =
simpleProvider.GetPropertyValue(AEIds.NativeWindowHandleProperty.Id);
var providerHandle = providerHandleObj != null
? (IntPtr)providerHandleObj
: IntPtr.Zero;
var element = new ProviderElementWrapper(simpleProvider);
element.Register(SessionBus);
lock (providerWrapperMapping)
providerWrapperMapping [simpleProvider] = element;
if (providerHandle != IntPtr.Zero)
{
lock (pointerProviderMapping) {
#if DEBUG
if (pointerProviderMapping.ContainsKey(providerHandle))
{
Log.Error("Duplicate provider handle, {0}, {1}",
simpleProvider.GetPropertyValue(AEIds.NameProperty.Id),
simpleProvider.GetPropertyValue(AEIds.LocalizedControlTypeProperty.Id));
}
#endif
pointerProviderMapping [providerHandle] = simpleProvider;
}
}
if (IsRootWindow(simpleProvider))
{
app.AddRootElement(element);
}
//The event shall be raised after the provider is added to providerWrapperMapping
app.RaiseStructureChangedEvent(simpleProvider, e);
}
else if (e.StructureChangeType == StructureChangeType.ChildRemoved)
{
//The event shall be raised before the provider is deleted from providerWrapperMapping
app.RaiseStructureChangedEvent(simpleProvider, e);
HandleTotalElementRemoval(simpleProvider);
}
else
{
app.RaiseStructureChangedEvent(simpleProvider, e);
}
}
// TODO: This should be exposed as an event and popup resize should be elsewhere
private void PopupListStructureChangedHandler(object sender, StructureChangedEventArgs e)
{
_syncContext.Post(delegate
{
Debug.WriteLine(">>> PopupList structure changed - " + e.StructureChangeType.ToString());
// CONSIDER: Others too?
if (e.StructureChangeType == StructureChangeType.ChildAdded)
{
var functionList = sender as AutomationElement;
var listRect = (Rect)functionList.GetCurrentPropertyValue(AutomationElement.BoundingRectangleProperty);
var listElement = functionList.FindFirst(TreeScope.Children, Condition.TrueCondition);
if (listElement != null)
{
_popupListList = listElement;
// TODO: Move this code!
TestMoveWindow(_popupListList, (int)listRect.X, (int)listRect.Y);
TestMoveWindow(functionList, 0, 0);
var selPat = listElement.GetCurrentPattern(SelectionPattern.Pattern) as SelectionPattern;
Automation.AddAutomationEventHandler(
SelectionItemPattern.ElementSelectedEvent, listElement, TreeScope.Children, PopupListElementSelectedHandler);
// Update the current selection, if any
var curSel = selPat.Current.GetSelection();
if (curSel.Length > 0)
{
try
{
UpdateSelectedItem(curSel[0]);
}
catch (Exception ex)
{
Debug.Print("Error during UpdateSelected! " + ex);
}
}
}
else
{
Debug.WriteLine("ERROR!!! Structure changed but no children anymore.");
}
}
else if (e.StructureChangeType == StructureChangeType.ChildRemoved)
{
if (_popupListList != null)
{
Automation.RemoveAutomationEventHandler(SelectionItemPattern.ElementSelectedEvent, _popupListList, PopupListElementSelectedHandler);
_popupListList = null;
}
SelectedItemText = String.Empty;
SelectedItemBounds = Rect.Empty;
SelectedItemChanged(this, EventArgs.Empty);
}
}, null);
}
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 static void RaiseStructureChangedEvent(
IRawElementProviderSimple provider,
StructureChangedEventArgs e)
{
Validate.ArgumentNotNull(parameter: provider, parameterName: nameof(provider));
Validate.ArgumentNotNull(parameter: e, parameterName: nameof(e));
var runtimeId = e.GetRuntimeId();
Marshal.ThrowExceptionForHR(errorCode: NativeMethods.UiaRaiseStructureChangedEvent(provider: provider, structureChangeType: e.StructureChangeType, runtimeId: runtimeId, runtimeIdLen: runtimeId.Length));
}
public void RaiseStructureChangedEvent(object provider, StructureChangedEventArgs e)
{
var providerSimple = provider as IRawElementProviderSimple;
if (providerSimple == null)
{
return;
}
ClientEventManager.RaiseStructureChangedEvent(providerSimple, e);
}
//</Snippet1200>
/// <summary>
/// Handles the StructureChanged event. Each time the automation element
/// tree under the tab control changes, this event is raised.
/// StructureChangedEventArgs can provide more information as to what kind of change happened.
/// </summary>
/// <param name="sender">The object that raised the event.</param>
/// <param name="e">Event arguments.</param>
private void onStructureChanged(object sender, StructureChangedEventArgs e)
{
if (sender != null)
{
string newStructure = GetAutomationStructure((AutomationElement)sender);
if (newStructure != "")
{
ShowStructure(((AutomationElement)sender).Current.Name +
" indicated that the tree has changed. The new structure is: \r\n\r\n" + newStructure);
}
}
}
/// <summary>
/// Responds to a removal from the UI Automation tree structure
/// by raising an event.
/// </summary>
/// <param name="list">
/// The list from which the item was removed.
/// </param>
/// <remarks>
/// For the runtime Id of the list, pass 0 because the provider cannot know
/// what its actual runtime ID is.
/// </remarks>
public static void OnStructureChangeRemove(CustomListControl list)
{
if (AutomationInteropProvider.ClientsAreListening)
{
int[] fakeRuntimeId = { 0 };
StructureChangedEventArgs args =
new StructureChangedEventArgs(StructureChangeType.ChildrenBulkRemoved,
fakeRuntimeId);
AutomationInteropProvider.RaiseStructureChangedEvent(
(IRawElementProviderSimple)list.Provider, args);
}
}
public static void RaiseStructureChangedEvent(IRawElementProviderSimple provider,
StructureChangedEventArgs e)
{
lock (structureChangedEventEntries)
foreach (var entry in structureChangedEventEntries)
{
if (IsProviderInScope(provider, entry.Provider, entry.Scope))
{
var clientElement =
ClientAutomationSource.Instance.GetOrCreateElement(provider);
var element = SourceManager.GetOrCreateAutomationElement(clientElement);
entry.Handler(element, e);
}
}
}
public override void RaiseStructureChangedEvent(object childProvider, StructureChangedEventArgs e)
{
/*IRawElementProviderSimple simpleChildProvider =
* (IRawElementProviderSimple) childProvider;
* //TODO: remove elements
* if (e.StructureChangeType == StructureChangeType.ChildrenBulkAdded) {
* int controlTypeId = (int) simpleChildProvider.GetPropertyValue (AutomationElementIdentifiers.ControlTypeProperty.Id);
* if (controlTypeId == ControlType.Button.Id) {
* // TODO: Consider generalizing...
* Button button = new Button ((IInvokeProvider) childProvider);
* AddOneChild (button);
* AddRelationship (Atk.RelationType.Embeds, button);
* //TODO: add to mappings
* }
* }*/
}
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 EnsureStructureEventsSetUp(DCI.IApplication app, string busName)
{
if (!structureEventBusNames.Contains(busName))
{
structureEventBusNames.Add(busName);
app.StructureChanged += delegate(int hId, int evtId, string providerPath,
StructureChangeType changeType) {
var handler = eventHandlerManager.GetStructureEventHandlerById(hId);
if (handler != null)
{
UiaDbusElement elem = GetOrCreateElement(busName, providerPath);
AutomationElement ae = SourceManager.GetOrCreateAutomationElement(elem);
var args = new StructureChangedEventArgs(changeType, elem.RuntimeId);
handler(ae, args);
}
};
}
}
// </Snippet106>
// <Snippet105>
/// <summary>
/// Handles structure-changed events. If a new app window has been added, this method ensures
/// it's in the list of runtime IDs and subscribed to window-close events.
/// </summary>
/// <param name="sender">Object that raised the event.</param>
/// <param name="e">Event arguments.</param>
/// <remarks>
/// An exception can be thrown by the UI Automation core if the element disappears
/// before it can be processed -- for example, if a menu item is only briefly visible.
/// This exception cannot be caught here because it crosses native/managed boundaries.
/// In the debugger, you can ignore it and continue execution. The exception does not cause
/// a break when the executable is being run.
/// </remarks>
private void OnStructureChanged(object sender, StructureChangedEventArgs e)
{
AutomationElement element = sender as AutomationElement;
if (e.StructureChangeType == StructureChangeType.ChildAdded)
{
Object windowPattern;
if (false == element.TryGetCurrentPattern(WindowPattern.Pattern, out windowPattern))
{
return;
}
int[] rid = e.GetRuntimeId();
if (RuntimeIdListed(rid, savedRuntimeIds) < 0)
{
AddToWindowHandler(element);
savedRuntimeIds.Add(rid);
}
}
}
public override void RaiseAutomationPropertyChangedEvent(AutomationPropertyChangedEventArgs e)
{
if (e.Property == AutomationElementIdentifiers.ControlTypeProperty)
{
//We remove the current Adapter and add it again to reflect the ControlType change
StructureChangedEventArgs args
= new StructureChangedEventArgs(StructureChangeType.ChildRemoved,
new int[] { 0 }); //TODO: Fix ?
AutomationInteropProvider.RaiseStructureChangedEvent(Provider,
args);
args = new StructureChangedEventArgs(StructureChangeType.ChildAdded,
new int[] { 0 }); //TODO: Fix ?
AutomationInteropProvider.RaiseStructureChangedEvent(Provider,
args);
}
else
{
base.RaiseAutomationPropertyChangedEvent(e);
}
}
private async void OnStructureChanged(object sender, StructureChangedEventArgs e)
{
if (_cts != null)
{
_cts.Cancel();
}
_cts = new CancellationTokenSource();
var cts = _cts;
await Task.Delay(100);
if (cts.IsCancellationRequested)
{
return;
}
try
{
await Update();
}
catch { }
Debug.WriteLine("structure");
}
private void OnStructureChanged(object sender, StructureChangedEventArgs e)
{
Debug.WriteLine("\n\n----------------------------\nOnStructureChanged\n-----------------------------\n" +
"e.StructureChangeType = " + Enum.GetName(typeof(StructureChangeType), e.StructureChangeType) +
"\ne.EventId.ProgrammaticName = " + e.EventId.ProgrammaticName +
"\n\n");
if (this._node.TreeNode.TreeView == null) //if tree currentTestTypeRootNode was removed then stop listening
{
Stop();
}
else
{
//we will refresh child nodes
this._node.RefreshChildrenNodes();
//and make sure that children children nodes are populated
foreach (AutomationElementTreeNode childNode in this._node.Children)
{
childNode.EnsureChildrenNodesPopulated(true);
}
}
}
public static void RaiseStructureChangedEvent(IRawElementProviderSimple provider, StructureChangedEventArgs e)
{
Utility.ValidateArgumentNonNull(provider, "provider");
Utility.ValidateArgumentNonNull(e, "e");
UiaCoreProviderApi.UiaRaiseStructureChangedEvent(provider, (UIAutomationClient.StructureChangeType)e.StructureChangeType, e.GetRuntimeId());
}
public static void RaiseStructureChangedEvent(IRawElementProviderSimple provider, StructureChangedEventArgs e)
{
Utility.ValidateArgumentNonNull(provider, "provider");
Utility.ValidateArgumentNonNull(e, "e");
UiaCoreProviderApi.UiaRaiseStructureChangedEvent(provider, (UIAutomationClient.StructureChangeType)e.StructureChangeType, e.GetRuntimeId());
}
// 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);
}
}
}
public override void RaiseStructureChangedEvent(object childProvider, StructureChangedEventArgs e)
{
// TODO
Log.Warn("TextContainer: RaiseStructureChangedEvent not implemented.");
}
public override void RaiseStructureChangedEvent(object childProvider, StructureChangedEventArgs e)
{
// TODO
}
public void HandleEvent(object sender, StructureChangedEventArgs e)
{
OnMatchingEvent((AutomationElement)sender);
}