public void GetDesktop()
{
Properties = null;
Patterns = null;
Image = null;
Elements = new ObservableCollection <ElementBO>();
var item = _automation.GetDesktop();
SearchResults = new ISHAutomationElement[0];
CurrentSearchIndex = 0;
_treeWalker = _automation.TreeWalkerFactory.GetControlViewWalker();
DesktopItem = item != null ? item : null;
var items = DesktopItem.FindAllByXPath("*").Select(x => new ElementBO(new SHAutomationElement(x.FrameworkAutomationElement)));
foreach (var win in items)
{
if (SavedSettingsWindows.Any(x => (!string.IsNullOrEmpty(win.AutomationId?.Trim()) && win.AutomationId.StartsWith(x.Identifier)) || (!string.IsNullOrEmpty(win.Name?.Trim()) && win.Name.StartsWith(x.Identifier))))
{
if (!Elements.Any(x => x.AutomationElement.Equals(win.AutomationElement)))
{
Elements.Add(win);
Elements.ToList().ForEach(x => x.IsExpanded = true);
}
}
}
if (Elements.Any())
{
SelectedItem = Elements.First();
}
_dispatcherTimer = new DispatcherTimer();
_dispatcherTimer.Tick += DispatcherTimerTick;
_dispatcherTimer.Interval = TimeSpan.FromMilliseconds(1);
_dispatcherTimer.Start();
}
/// <summary>
/// Gets children based on a predicate.
/// </summary>
/// <typeparam name="T">The type of elements in the tree.</typeparam>
/// <param name="walker">
/// The <see cref="ITreeWalker<T>"/> that knows how to find the parent and child
/// nodes.
/// </param>
/// <param name="node">
/// The root node to be queried.
/// </param>
/// <param name="predicate">
/// A predicate to test each child for selection.
/// </param>
/// <returns>
/// An <see cref="System.Collections.Generic.IEnumerable<T>"/> that contains all the
/// matching children.
/// </returns>
public static IEnumerable <T> GetChildren <T>(
this ITreeWalker <T> walker,
T node,
Func <T, bool> predicate)
{
// Validate parameters.
if (walker == null)
{
throw new ArgumentNullException("walker");
}
if (node == null)
{
throw new ArgumentNullException("node");
}
if (predicate == null)
{
throw new ArgumentNullException("predicate");
}
return
(walker
.GetChildren(node)
.Where(predicate));
}
/// <summary>
/// Gets the child at the specified index or the default value of the specified type.
/// </summary>
/// <typeparam name="T">The type of elements in the tree.</typeparam>
/// <param name="walker">
/// The <see cref="ITreeWalker<T>"/> that knows how to find the parent and child
/// nodes.
/// </param>
/// <param name="node">The node whose child is to be returned.</param>
/// <param name="index">The index of the child to retrieve.</param>
/// <returns>The child node at the specified index or the default value.</returns>
/// /// <exception cref="ArgumentNullException">
/// If <paramref name="walker"/> or <paramref name="node"/> is null.
/// </exception>
/// <exception cref="ArgumentOutOfRangeException">
/// If <paramref name="index"/> is less than zero.
/// </exception>
public static T GetChildAtOrDefault <T>(
this ITreeWalker <T> walker,
T node,
int index)
{
// Validate parameters.
if (walker == null)
{
throw new ArgumentNullException("walker");
}
if (node == null)
{
throw new ArgumentNullException("node");
}
if (index < 0)
{
throw new ArgumentOutOfRangeException("index");
}
return
(walker
.GetChildren(node)
.ElementAtOrDefault(index));
}
public OrderChildrenByTreeWalker(
ITreeWalker <T> walker,
CompoundComparer <T> comparers)
{
this._Walker = walker;
this._Comparers = comparers;
}
/// <summary>
/// Gets the child at the specified index.
/// </summary>
/// <typeparam name="T">The type of elements in the tree.</typeparam>
/// <param name="walker">
/// The <see cref="ITreeWalker<T>"/> that knows how to find the parent and child
/// nodes.
/// </param>
/// <param name="node">The node whose child is to be returned.</param>
/// <param name="index">The index of the child to retrieve.</param>
/// <returns>The child node at the specified index.</returns>
/// <exception cref="ArgumentOutOfRangeException">
/// Thrown if the index is less than 0 or greater than or equal to the number of children.
/// </exception>
public static T GetChildAt <T>(this ITreeWalker <T> walker, T node, int index)
{
if (walker == null)
{
throw new ArgumentNullException("walker");
}
if (node == null)
{
throw new ArgumentNullException("node");
}
if (index < 0)
{
throw new ArgumentOutOfRangeException("index");
}
T child;
if (walker.TryGetChildAt(node, index, out child))
{
return(child);
}
else
{
throw new ArgumentOutOfRangeException("index");
}
}
/// <summary>
/// Gets the child at the specified index or the default value if the index is out of
/// range.
/// </summary>
/// <typeparam name="T">The type of elements in the tree.</typeparam>
/// <param name="walker">
/// The <see cref="ITreeWalker<T>"/> that knows how to find the parent and child
/// nodes.
/// </param>
/// <param name="nodes">The nodes whose children are to be returned.</param>
/// <param name="index">The index of the child to retrieve.</param>
/// <returns>
/// The child node at the specified index or default values for each of the nodes in
/// <see cref="nodes"/>.
/// </returns>
/// <exception cref="ArgumentNullException">
/// If <paramref name="walker"/> or <paramref name="nodes"/> is null.
/// </exception>
/// <exception cref="ArgumentOutOfRangeException">
/// If <paramref name="index"/> is less than zero.
/// </exception>
public static IEnumerable <T> GetChildAtOrDefault <T>(
this ITreeWalker <T> walker,
IEnumerable <T> nodes,
int index)
{
// Validate parameters.
if (walker == null)
{
throw new ArgumentNullException("walker");
}
if (nodes == null)
{
throw new ArgumentNullException("nodes");
}
if (index < 0)
{
throw new ArgumentOutOfRangeException("index");
}
return
(nodes
.Select(n =>
walker
.GetChildren(n)
.ElementAtOrDefault(index)));
}
/// <summary>
/// Gets the child at the specified index.
/// </summary>
/// <typeparam name="T">The type of elements in the tree.</typeparam>
/// <param name="walker">
/// The <see cref="ITreeWalker<T>"/> that knows how to find the parent and child
/// nodes.
/// </param>
/// <param name="nodes">The nodes whose children are to be returned.</param>
/// <param name="index">The index of the child to retrieve.</param>
/// <returns>
/// The child node at the specified index for each of the nodes in <see cref="nodes"/>.
/// </returns>
/// <exception cref="ArgumentOutOfRangeException">
/// Thrown if the index is less than 0 or greater than or equal to the number of children.
/// </exception>
public static IEnumerable <T> GetChildAt <T>(this ITreeWalker <T> walker, IEnumerable <T> nodes, int index)
{
if (walker == null)
{
throw new ArgumentNullException("walker");
}
if (nodes == null)
{
throw new ArgumentNullException("nodes");
}
if (index < 0)
{
throw new ArgumentOutOfRangeException("index");
}
foreach (T node in nodes)
{
T child;
if (walker.TryGetChildAt(node, index, out child))
{
yield return(child);
}
}
}
/// <summary>
/// Gets the nearest descendants that match the <paramref name="key"/>.
/// </summary>
/// <typeparam name="T">The type of elements in the tree.</typeparam>
/// <param name="walker">
/// The <see cref="ITreeWalker<T>"/> that knows how to find the parent and child
/// nodes.
/// </param>
/// <param name="node">
/// The root node to be queried.
/// </param>
/// <param name="key">
/// The key each node will be compared to.
/// </param>
/// <param name="comparer">
/// The <see cref="IEqualityComparer<T>"/> used to compare the key and the node. If
/// this is null then the default <see cref="EqualityComparer<T>.Default"/> will be
/// used.
/// </param>
/// <returns>
/// An <see cref="System.Collections.Generic.IEnumerable<T>"/> that contains all the
/// matching nodes in the tree ordered based on a pre-order traversal.
/// </returns>
public static IEnumerable <T> GetDescendants <T>(
this ITreeWalker <T> walker,
T node,
T key,
IEqualityComparer <T> comparer)
{
// Validate parameters.
if (walker == null)
{
throw new ArgumentNullException("walker");
}
if (node == null)
{
throw new ArgumentNullException("node");
}
if (key == null)
{
throw new ArgumentNullException("key");
}
// If the comparer is null then use the defautl comparer for that type.
comparer = comparer ?? EqualityComparer <T> .Default;
return(walker.GetDescendants(node, n => comparer.Equals(n, key)));
}
/// <summary>
/// Tries to get a node's parent.
/// </summary>
/// <typeparam name="T">The type of elements in the tree.</typeparam>
/// <param name="walker">
/// The <see cref="ITreeWalker<T>"/> that knows how to find the parent and child
/// nodes.
/// </param>
/// <param name="node">
/// The node whose parent is to be returned.
/// </param>
/// <param name="parent">
/// A reference to the resulting parent node. This will be a default value of type
/// <typeparamref name="T"/> if we fail to get a the parent node.
/// </param>
/// <returns>
/// True if a parent node is found, false, otherwise.
/// </returns>
public static bool TryGetParent <T>(this ITreeWalker <T> walker, T node, out T parent)
{
// Validate parameters.
if (walker == null)
{
throw new ArgumentNullException("walker");
}
if (node == null)
{
throw new ArgumentNullException("node");
}
// Get the ancestors enumerator and attempt to move to the first node.
// If we get the first node output it and return true. Otherwise, output a default
// node and return false.
using (IEnumerator <T> enumerator = walker.GetAncestors(node).GetEnumerator())
{
if (enumerator.MoveNext())
{
parent = enumerator.Current;
return(true);
}
else
{
parent = default(T);
return(false);
}
}
}
/// <summary>
/// Returns all nodes at a depth relative to the specified node.
/// </summary>
/// <typeparam name="T">The type of elements in the tree.</typeparam>
/// <param name="walker">
/// The <see cref="ITreeWalker<T>"/> that knows how to find the parent and child nodes.
/// </param>
/// <param name="node">
/// The node relative to which the level is returned.
/// </param>
/// <param name="depth">
/// The depth of the level to be returned relative to <paramref name="node"/>. This must
/// be a nonnegative number.
/// </param>
/// <returns>
/// An <see cref="System.Collections.Generic.IEnumerable<T>"/> that contains all the nodes
/// nodes at a depth relative to the specified node. A depth of 0 will return the node
/// itself, 1 all children of the node, etc...
/// </returns>
public static IEnumerable <T> GetLevel <T>(this ITreeWalker <T> walker, T node, int depth)
{
// Validate parameters.
if (walker == null)
{
throw new ArgumentNullException("walker");
}
if (node == null)
{
throw new ArgumentNullException("node");
}
if (depth < 0)
{
throw new ArgumentException("Depth must be nonnegative.", "depth");
}
// If 'depth' is zero then return the node.
// Otherwise, use GetDescendants to return all nodes at 'depth'.
if (depth == 0)
{
return(Enumerable.Repeat(node, 1));
}
else
{
return
(walker
.GetDescendants(node, (x, i) => i == depth));
}
}
public static IVirtualForest <T> New <T>(
ITreeWalker <T> treeWalker,
IEqualityComparer <T> comparer,
params T[] roots)
{
return(new VirtualForest <T>(treeWalker, comparer, roots));
}
/// <summary>
/// Gets a node and the node's siblings, i.e. all nodes that share the same parent.
/// </summary>
/// <typeparam name="T">The type of elements in the tree.</typeparam>
/// <param name="walker">
/// The <see cref="ITreeWalker<T>"/> that knows how to find the parent and child
/// nodes.
/// </param>
/// <param name="node">
/// The node whose siblings are to be returned.
/// </param>
/// <returns>
/// An <see cref="System.Collections.Generic.IEnumerable<T>"/> that contains the
/// siblings.
/// </returns>
public static IEnumerable <T> GetSiblingsAndSelf <T>(this ITreeWalker <T> walker, T node)
{
// Validate parameters.
if (walker == null)
{
throw new ArgumentNullException("walker");
}
if (node == null)
{
throw new ArgumentNullException("node");
}
// Get the node's parent.
T parent;
if (walker.TryGetParent(node, out parent))
{
// Return all of the parent's children with the exception of the original node.
return
(walker
.GetChildren(parent));
}
else
{
// If the node does not have a parent then return the node.
return(new T[] { node });
}
}
/// <summary>
/// Gets the children that match the <paramref name="key"/>.
/// </summary>
/// <typeparam name="T">The type of elements in the tree.</typeparam>
/// <param name="walker">
/// The <see cref="ITreeWalker<T>"/> that knows how to find the parent and child
/// nodes.
/// </param>
/// <param name="nodes">
/// The root nodes to be queried.
/// </param>
/// <param name="key">
/// The key that each child will be compared to.
/// </param>
/// <param name="comparer">
/// The <see cref="IEqualityComparer<T>"/> used to compare the key and the child. If
/// this is null then the default <see cref="EqualityComparer<T>.Default"/> will be
/// used.
/// </param>
/// <returns>
/// An <see cref="System.Collections.Generic.IEnumerable<T>"/> that contains all the
/// matching children.
/// </returns>
public static IEnumerable <T> GetChildren <T>(
this ITreeWalker <T> walker,
IEnumerable <T> nodes,
T key,
IEqualityComparer <T> comparer)
{
// Validate parameters.
if (walker == null)
{
throw new ArgumentNullException("walker");
}
if (nodes == null)
{
throw new ArgumentNullException("nodes");
}
if (key == null)
{
throw new ArgumentNullException("key");
}
// If the comparer is null then use the defautl comparer for that type.
comparer = comparer ?? EqualityComparer <T> .Default;
return
(nodes
.SelectMany(n => walker.GetChildren(n))
.Where(n => comparer.Equals(key, n)));
}
/// <summary>
/// Gets a node's parent node.
/// </summary>
/// <typeparam name="T">The type of elements in the tree.</typeparam>
/// <param name="walker">
/// The <see cref="ITreeWalker<T>"/> that knows how to find the parent and child
/// nodes.
/// </param>
/// <param name="node">
/// The node whose parent is to be returned.
/// </param>
/// <returns>
/// The node's parent.
/// </returns>
/// <exception cref="InvalidOperationException">
/// When the node does not have a parent.
/// </exception>
public static T GetParent <T>(this ITreeWalker <T> walker, T node)
{
// Validate parameters.
if (walker == null)
{
throw new ArgumentNullException("walker");
}
if (node == null)
{
throw new ArgumentNullException("node");
}
// Return the node's parent or throw an exception if the parent does not exist.
T parent;
if (walker.TryGetParent(node, out parent))
{
return(parent);
}
else
{
throw new InvalidOperationException("The node does not have a parent.");
}
}
/// <summary>
/// Gets a node's siblings, i.e. all nodes that share the same parent.
/// </summary>
/// <typeparam name="T">The type of elements in the tree.</typeparam>
/// <param name="walker">
/// The <see cref="ITreeWalker<T>"/> that knows how to find the parent and child
/// nodes.
/// </param>
/// <param name="node">
/// The node whose siblings are to be returned.
/// </param>
/// <param name="comparer">
/// An <see cref="System.Collections.Generic.IEqualityComparer<T>"/> that knows how
/// to compare two nodes for equality. This is used to make sure that
/// <paramref name="node"/> is not returned in the resulting
/// <see cref="System.Collections.Generic.IEnumerable<T>"/>.
/// </param>
/// <returns>
/// An <see cref="System.Collections.Generic.IEnumerable<T>"/> that contains the
/// siblings.
/// </returns>
public static IEnumerable <T> GetSiblings <T>(this ITreeWalker <T> walker, T node, IEqualityComparer <T> comparer)
{
// Validate parameters.
if (walker == null)
{
throw new ArgumentNullException("walker");
}
if (node == null)
{
throw new ArgumentNullException("node");
}
// If the comparer is null then use the default comparer.
comparer = comparer ?? EqualityComparer <T> .Default;
// Get the node's parent.
T parent;
if (walker.TryGetParent(node, out parent))
{
// Return all of the parent's children with the exception of the original node.
return
(walker
.GetChildren(parent)
.Where(x => !comparer.Equals(node, x)));
}
else
{
// If the node does not have a parent then return an empty IEnumerable.
return(Enumerable.Empty <T>());
}
}
private static string GetXPathToElement(SHAutomationElement element, ITreeWalker treeWalker, SHAutomationElement rootElement = null)
{
var parent = treeWalker.GetParent(element);
if (parent == null || (rootElement != null && parent.Equals(_callingRoot.Parent)))
{
_callingRoot = null;
return(string.Empty);
}
// Get the index
var allChildren = parent.FindAllChildren(cf => cf.ByControlType(element.Properties.ControlType));
var currentItemText = $"{element.Properties.ControlType.Value}";
if (allChildren.Length > 1)
{
// There is more than one matching child, find out the index
var indexInParent = 1; // Index starts with 1
foreach (var child in allChildren)
{
if (child.Equals(element))
{
break;
}
indexInParent++;
}
currentItemText += $"[{indexInParent}]";
}
return($"{GetXPathToElement(parent, treeWalker, rootElement)}/{currentItemText}");
}
public void Initialize(AutomationType selectedAutomationType)
{
SelectedAutomationType = selectedAutomationType;
IsInitialized = true;
if (selectedAutomationType == AutomationType.UIA2)
{
_automation = new UIA2Automation();
}
else
{
_automation = new UIA3Automation();
}
_rootElement = _automation.GetDesktop();
var desktopViewModel = new ElementViewModel(_rootElement);
desktopViewModel.SelectionChanged += DesktopViewModel_SelectionChanged;
desktopViewModel.LoadChildren(false);
Elements.Add(desktopViewModel);
// Initialize TreeWalker
_treeWalker = _automation.TreeWalkerFactory.GetControlViewWalker();
// Initialize hover
_hoverMode = new HoverMode(_automation);
_hoverMode.ElementHovered += ElementHovered;
}
public void Initialize(AutomationType selectedAutomationType)
{
SelectedAutomationType = selectedAutomationType;
IsInitialized = true;
_automation = selectedAutomationType == AutomationType.UIA2 ? (AutomationBase) new UIA2Automation() : new UIA3Automation();
_rootElement = _automation.GetDesktop();
var desktopViewModel = new ElementViewModel(_rootElement);
desktopViewModel.SelectionChanged += DesktopViewModel_SelectionChanged;
desktopViewModel.LoadChildren(false);
Elements.Add(desktopViewModel);
Elements[0].IsExpanded = true;
// Initialize TreeWalker
_treeWalker = _automation.TreeWalkerFactory.GetControlViewWalker();
// Initialize hover
_hoverMode = new HoverMode(_automation);
_hoverMode.ElementHovered += ElementToSelectChanged;
// Initialize focus tracking
_focusTrackingMode = new FocusTrackingMode(_automation);
_focusTrackingMode.ElementFocused += ElementToSelectChanged;
}
public ElementInfo GetElementParent(ElementInfo ElementInfo)
{
UIAElementInfo EI = (UIAElementInfo)ElementInfo;
if (EI.ElementObject.Equals(CurrentWindow))
{
return(null);
}
ITreeWalker walker = ((AutomationElement)EI.ElementObject).Automation.TreeWalkerFactory.GetControlViewWalker();
AutomationElement ParentAE = walker.GetParent((AutomationElement)EI.ElementObject);
if (ParentAE.Equals(CurrentWindow))
{
return(null); // CurrentWindowRootElement; // Since there are check done on root element we must return the same when found
}
if (ParentAE == null)
{
return(null);
}
UIAElementInfo RC = new UIAElementInfo()
{
ElementObject = ParentAE
}; // return minimial EI
return(RC);
}
public static VirtualTree <T> New <T>(
ITreeWalker <T> treeWalker,
T root,
IEqualityComparer <T> comparer)
{
return(new VirtualTree <T>(treeWalker, root, comparer));
}
public WindowsTreeElement(treeelement parent, bool expanded, AutomationBase automation, AutomationElement element, ITreeWalker treeWalker) : base(parent)
{
Element = new UIElement(element);
_treeWalker = treeWalker;
this.automation = automation;
RawElement = element;
IsExpanded = expanded;
string controltype = "";
string name = "unknown";
string automationid = "";
ControlType = ControlType.Window;
if (element.Properties.ControlType.IsSupported)
{
ControlType = element.Properties.ControlType.Value;
}
if (element.Properties.ControlType.IsSupported)
{
controltype = element.Properties.ControlType.Value.ToString();
}
if (element.Properties.Name.IsSupported)
{
name = element.Properties.Name.Value;
}
if (element.Properties.AutomationId.IsSupported)
{
automationid = element.Properties.AutomationId.Value;
}
Name = (controltype + " " + name + " " + automationid).Trim();
}
/// <summary>
/// Gets a node's leaves, i.e. all descendants of that node that do not have children. If
/// the node has no children then the node itself is returned.
/// </summary>
/// <typeparam name="T">The type of elements in the tree.</typeparam>
/// <param name="walker">
/// The <see cref="ITreeWalker<T>"/> that knows how to find the parent and child nodes.
/// </param>
/// <param name="node">
/// The node whose leaves are to be returned.
/// </param>
/// <returns>
/// An <see cref="System.Collections.Generic.IEnumerable<T>"/> that contains all the node's
/// leaves.
/// </returns>
public static IEnumerable <T> GetLeaves <T>(this ITreeWalker <T> walker, T node)
{
// Validate parameters.
if (walker == null)
{
throw new ArgumentNullException("walker");
}
if (node == null)
{
throw new ArgumentNullException("node");
}
// Create a stack to hold enumerators and push the child enumerator of 'node'.
Stack <IEnumerator <T> > stack = new Stack <IEnumerator <T> >();
stack.Push(walker.GetChildren(node).GetEnumerator());
if (!stack.Peek().MoveNext())
{
// If the enumerator on the stack has no items then 'node' is a leaf node.
// Dispose of the enumerator and yield 'node' and we are done.
stack.Pop().Dispose();
yield return(node);
}
else
{
// The current node is now the first child of the 'node' parameter.
// Continue looping as long as the stack has enumerators on it.
while (stack.Count > 0)
{
// Push the current node's enumerator on the stack.
stack.Push(walker.GetChildren(stack.Peek().Current).GetEnumerator());
// Continue pushing enumerators on the stack as long the enumerator on the top
// of the stack has items.
while (stack.Peek().MoveNext())
{
stack.Push(walker.GetChildren(stack.Peek().Current).GetEnumerator());
}
// Once we reach an enumerator that has no items pop that enumerator and
// dispose of it.
stack.Pop().Dispose();
// The 'Current' property of the enumerator on the top of the stack is a leaf
// node. Return it.
yield return(stack.Peek().Current);
// Continue popping enumerators off of the stack and disposing of them until
// we reach an enumerator with another item. That item become the current
// node.
while (stack.Count > 0 && !stack.Peek().MoveNext())
{
stack.Pop().Dispose();
}
}
}
}
public ScanTreeWalker(
ITreeWalker <TBaseNode> walker,
Func <TBaseNode, TValue, TValue> accumulator,
Func <TBaseNode, TValue, TValue> deccumulator)
{
this._Walker = walker;
this._Accumulator = accumulator;
this._Deccumulator = deccumulator;
}
public PruneTreeWalker(
ITreeWalker <T> walker,
Func <T, bool> predicate,
PruneOption pruneOption)
{
this._Walker = walker;
this._Predicate = predicate;
this._PruneOption = pruneOption;
}
internal static IEnumerable <VirtualTree <T> > ToVirtualTrees <T>(
this IEnumerable <T> source,
ITreeWalker <T> walker)
{
foreach (T root in source)
{
yield return(new VirtualTree <T>(walker, root));
}
}
/// <summary>
/// Enumerates a tree using the pre-order traversal method.
/// </summary>
/// <typeparam name="T">The type of elements in the tree.</typeparam>
/// <param name="walker">
/// The <see cref="ITreeWalker<T>"/> that knows how to find the parent and child nodes.
/// </param>
/// <param name="node">The root node of the tree that is to be traversed.</param>
/// <param name="excludeSubtreePredicate">
/// A <see cref="System.Func<T, Int32, Boolean>"/> that determines if the current node
/// that is being evaluated (and all of its descendants) should be included in the
/// traversal. This allows for short-circuiting of the pre-order traversal by excluding
/// particular subtrees from the traversal. The first argument is the current node being
/// evaluated and the second argument is the depth of the current node relative to the
/// original node that the traversal began on.
/// </param>
/// <param name="excludeOption">
/// Used in conjunction with the <paramref name="excludeSubtreePredicate"/>. Determines
/// if the entire subtree should be excluded or just its children.
/// </param>
/// <returns>
/// An <see cref="System.Collections.Generic.IEnumerable<T>"/> that contains all the
/// nodes in the tree ordered based on a pre-order traversal.
/// </returns>
public static IEnumerable <T> PreOrderTraversal <T>(
this ITreeWalker <T> walker,
T node,
Func <T, int, bool> excludeSubtreePredicate,
ExcludeOption excludeOption)
{
// Validate parameters.
if (walker == null)
{
throw new ArgumentNullException("walker");
}
if (node == null)
{
throw new ArgumentNullException("node");
}
// Create a stack to keep track of the branches being traversed.
Stack <IEnumerator <T> > enumerators = new Stack <IEnumerator <T> >();
enumerators.Push(Enumerable.Repeat(node, 1).GetEnumerator());
// Loop as long as we have an enumerator on the stack. When we have popped the last
// one off the stack the traversal is complete.
while (enumerators.Count > 0)
{
if (enumerators.Peek().MoveNext())
{
node = enumerators.Peek().Current;
// If the 'excludeSubtreePredicate' is not null and evaluates to true then
// yield the current node if 'excludeOption' is set to exclude the children.
// Otherwise, do not yield anything.
if (excludeSubtreePredicate != null &&
excludeSubtreePredicate.Invoke(node, enumerators.Count - 1))
{
if (excludeOption == ExcludeOption.ExcludeDescendants)
{
yield return(node);
}
}
else
{
// Yield the current node then push it and its children onto the
// stack.
yield return(node);
enumerators.Push(walker.GetChildren(node).GetEnumerator());
}
}
else
{
// Pop the enumerator and dispose of it.
enumerators.Pop().Dispose();
}
}
}
// Use this after attempting to find the excerpt element because it destroys the HTML document
private string GetSeparatorExcerpt(IHtmlDocument htmlDocument)
{
if (_separators?.Length > 0)
{
ITreeWalker walker = htmlDocument.CreateTreeWalker(htmlDocument.DocumentElement, FilterSettings.Comment);
IComment comment = (IComment)walker.ToFirst();
while (comment != null && !_separators.Contains(comment.NodeValue.Trim(), StringComparer.OrdinalIgnoreCase))
{
comment = (IComment)walker.ToNext();
}
// Found the first separator
if (comment != null)
{
// Get a clone of the parent element
IElement parent = comment.ParentElement;
if (parent.TagName.Equals("p", StringComparison.OrdinalIgnoreCase))
{
// If we were in a tag inside a paragraph, ascend to the paragraph's parent
parent = parent.ParentElement;
}
// Now remove everything after the separator
walker = htmlDocument.CreateTreeWalker(parent);
bool remove = false;
Stack <INode> removeStack = new Stack <INode>();
INode node = walker.ToFirst();
while (node != null)
{
if (node == comment)
{
remove = true;
}
// Also remove if it's a top-level element that doesn't match the query selector
if (remove ||
(node.Parent == parent &&
node is IElement &&
!string.IsNullOrEmpty(_querySelector) &&
!((IElement)node).Matches(_querySelector)))
{
removeStack.Push(node);
}
node = walker.ToNext();
}
while (removeStack.Count > 0)
{
node = removeStack.Pop();
node.Parent.RemoveChild(node);
}
return(parent.InnerHtml);
}
}
return(null);
}
internal static IVirtualForest <T> ShallowCopy <T>(
this IVirtualForest <T> source,
ITreeWalker <T> treeWalker,
Func <IEnumerable <T>, IEnumerable <T> > rootsSelector)
{
return(new VirtualForest <T>(
treeWalker,
source.Comparer,
rootsSelector(source.Roots)));
}
private void Init()
{
_automation = new UIA3Automation();
// Initialize TreeWalker
_treeWalker = _automation.TreeWalkerFactory.GetControlViewWalker();
_rootElement = _automation.GetDesktop();
_elementFinder = new AutomationHelper(_automation);
_elementFinder.ControlReleasedOverElement += ControlReleasedOverElement;
}
private void DisposeAutomationObjects()
{
_elementFinder.ControlReleasedOverElement += ControlReleasedOverElement;
_elementFinder.ControlReleasedOverElement -= ControlReleasedOverElement;
_rootElement = null;
_treeWalker = null;
_automation = null;
_elementFinder = null;
}
public virtual void WalkTree(ITreeWalker treeWalker)
{
treeWalker.OnInner(this);
foreach (var branch in Branches.Where(branch => branch != null))
{
if (branch.IsLeaf)
{
treeWalker.OnLeaf(branch.AsLeaf());
}
else if (branch.IsInner)
{
branch.AsInner().WalkTree(treeWalker);
}
}
}
public ITreeWalker WalkTree( ITreeWalker walker )
{
walker.WalkTree( this );
return walker;
}
public ITreeWalker WalkTree( ITreeWalker walker, TreeWalkerMode mode )
{
walker.WalkTree( this, mode );
return walker;
}
