/// <summary>Applies a structurally matched selector to the DOM.
/// Occurs shortly after StructureMatch.</summary>
public MatchingSelector BakeToTarget(ComputedStyle cs, CssEvent e)
{
// Get the node:
Node node = cs.Element;
// First, generate our instance:
MatchingSelector ms = new MatchingSelector();
// Update it:
ms.Selector = this;
ms.MatchedRoots = new MatchingRoot[RootCount];
// For each root, create a MatchingRoot object.
// Apply target - this helps track which element we're actually testing:
e.CurrentNode = node;
e.SelectorTarget = null;
// We always start from the tail and work backwards.
// If we get a match, then the caller can do whatever it wants to the target.
for (int i = RootCount - 1; i >= 0; i--)
{
// Get the matcher:
RootMatcher rm = Roots[i];
// Try matching this root:
if (!rm.TryMatch(e.CurrentNode))
{
// Failed! If we had a matcher and it has Repeat set true, try again:
if (rm.NextMatcher != null && rm.NextMatcher.Repeat)
{
// Move target:
rm.NextMatcher.MoveUpwards(e);
// Try matching again:
i++;
continue;
}
}
else
{
// Match! e.CurrentNode is the node to add.
// Create the instance:
MatchingRoot matchedRoot = new MatchingRoot();
matchedRoot.Root = rm;
matchedRoot.Selector = ms;
matchedRoot.Node = e.CurrentNode;
// Get renderable node:
IRenderableNode renderable = (e.CurrentNode as IRenderableNode);
// Add to selector:
ms.MatchedRoots[i] = matchedRoot;
// Add:
ComputedStyle nodeCs = renderable.ComputedStyle;
// Push the match now into the linked list:
if (nodeCs.FirstMatch == null)
{
nodeCs.FirstMatch = matchedRoot;
nodeCs.LastMatch = matchedRoot;
}
else
{
matchedRoot.PreviousInStyle = nodeCs.LastMatch;
nodeCs.LastMatch.NextInStyle = matchedRoot;
nodeCs.LastMatch = matchedRoot;
}
if (rm.IsTarget)
{
// Update the target now:
e.SelectorTarget = renderable.RenderData;
}
}
// If we have a structure matcher, run it now. It'll move CurrentNode for us:
if (rm.PreviousMatcher != null)
{
// Move target:
rm.PreviousMatcher.MoveUpwards(e);
}
}
// Final pass - if we have a pseudo-element, apply it now:
if (PseudoElement != null)
{
PseudoElement.Select(e);
}
// Apply target:
ms.Target = e.SelectorTarget;
// Finally, refresh all:
ms.ResetActive();
return(ms);
}
/// <summary>True if this selector matches the structure of the DOM where the given CS is.</summary>
public bool StructureMatch(ComputedStyle cs, CssEvent e)
{
// Get the node:
Node node = cs.Element;
if (node == null)
{
return(false);
}
// Apply target - this helps track which element we're actually testing:
e.CurrentNode = node;
// We always start from the tail and work backwards.
// If we get a match, then the caller can do whatever it wants to the target.
for (int i = RootCount - 1; i >= 0; i--)
{
// Get the matcher:
RootMatcher rm = Roots[i];
// Try matching this root:
if (!rm.TryMatch(e.CurrentNode))
{
// Failed! If we had a matcher and it has Repeat set true, try again:
if (rm.NextMatcher != null && rm.NextMatcher.Repeat)
{
// Move target:
rm.NextMatcher.MoveUpwards(e);
// Still got a node?
if (e.CurrentNode == null)
{
return(false);
}
// Try matching again:
i++;
continue;
}
return(false);
}
// If we have a structure matcher, run it now. It'll move CurrentNode for us:
if (rm.PreviousMatcher != null)
{
// Move target:
rm.PreviousMatcher.MoveUpwards(e);
// Still got a node?
if (e.CurrentNode == null)
{
return(false);
}
}
}
// If we have a pseudo element, make sure parents haven't also matched this selector.
if (PseudoElement != null)
{
// Have any parents matched this selector?
Node parent = node.parentNode;
while (parent != null)
{
if (parent["spark-virt"] != null)
{
// Already on a virtual element - quit there.
return(false);
}
parent = parent.parentNode;
}
}
// All clear!
return(true);
}
/// <summary>True if this node still matches the structure of the node it's on.</summary>
public bool StructuralMatch()
{
// Try matching it again:
return(Root.TryMatch(Node));
}