public override void Select(CssEvent e)
        {
            // Get the CS:
            ComputedStyle cs = e.SelectorTarget.computedStyle;

            // Create and apply using an informer:
            SparkInformerNode informer = cs.GetOrCreateVirtualInformer(Priority, true);

            if (informer.OnStart == null)
            {
                // Add a text node as the first child:
                RenderableTextNode textNode = new RenderableTextNode();
                informer.appendChild(textNode);

                // Setup the delegates!
                informer.OnStart = delegate(Renderman renderer, SparkInformerNode node){
                    // Apply first letter - it'll be consumed by the first text node to encounter it:
                    renderer.FirstLetter = node;
                };

                informer.OnEnd = delegate(Renderman renderer, SparkInformerNode node){
                    // Just in case it wasn't used up:
                    renderer.FirstLetter = null;
                };
            }

            e.SelectorTarget = informer.RenderData;
        }
예제 #2
0
        /// <summary>Selects elements from this document using the given CSS selector.
        /// Do note that this is not designed to be used in high-performance situations and
        /// you should cache the results as much as possible.</summary>
        public Dom.NodeList querySelectorAll(string selector, bool one)
        {
            // Create results set:
            Dom.NodeList results = new Dom.NodeList();

            if (string.IsNullOrEmpty(selector))
            {
                // Empty set:
                return(results);
            }

            Node root = documentElement;

            // Create the lexer:
            Css.CssLexer lexer = new Css.CssLexer(selector, root);

            List <Css.Selector> all = new List <Css.Selector>();

            // Read selectors:
            lexer.ReadSelectors(all);

            if (all.Count == 0)
            {
                // Invalid selector:
                return(results);
            }

            // Create a blank event to store the targets, if any:
            CssEvent e = new CssEvent();

            // Perform the selection process:
            (root as IRenderableNode).querySelectorAll(all.ToArray(), results, e, one);

            return(results);
        }
        /// <summary>Does the given element satisfy this selection requirement?</summary>
        public override void Select(CssEvent e)
        {
            // Change the element being targeted.

            // Unavailable at the moment; we'll need to check if this is an imported
            // element in a MathML scope and if so, change the target to the anonymous block.
            e.CurrentNode = null;
        }
예제 #4
0
        /// <summary>call this to try to match this selector.
        /// If it matches, it will return the element which style should be applied to.</summary>
        public Node Test(ComputedStyle style, CssEvent e)
        {
            if (StructureMatch(style, e))
            {
                return(e.CurrentNode);
            }

            return(null);
        }
        public override void MoveUpwards(CssEvent e)
        {
            // Current node:
            Node node = e.CurrentNode;

            if (node != null)
            {
                e.CurrentNode = node.previousElementSibling;
            }
        }
예제 #6
0
        /// <summary>Gets or creates the virtual.</summary>
        internal void CreateVirtual(CssEvent e, int priority)
        {
            // Get the CS:
            ComputedStyle cs = e.SelectorTarget.computedStyle;

            // Create and apply:
            Node node = cs.GetOrCreateVirtual(priority, "span", true);

            e.SelectorTarget = (node as IRenderableNode).RenderData;
        }
예제 #7
0
        public override void MoveUpwards(CssEvent e)
        {
            // Current node:
            Dom.Node node = e.CurrentNode;

            if (node != null)
            {
                e.CurrentNode = node.parentNode;

                if (e.CurrentNode is Dom.Document)
                {
                    e.CurrentNode = null;
                }
            }
        }
예제 #8
0
        /// <summary>Doesn't create the virtual if it doesn't exist.</summary>
        internal void GetVirtual(CssEvent e, int priority)
        {
            // Get the CS:
            ComputedStyle cs = e.SelectorTarget.computedStyle;

            VirtualElements virts = cs.RenderData.Virtuals;

            IRenderableNode node = null;

            if (virts != null)
            {
                // Get and apply:
                node = virts.Get(priority) as IRenderableNode;
            }

            // Update the target:
            e.SelectorTarget = (node == null) ? null : node.RenderData;
        }
예제 #9
0
 public override void Select(CssEvent e)
 {
     // Get/ create the v-child:
     CreateVirtual(e, Priority);
 }
예제 #10
0
        /// <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);
        }
예제 #11
0
        /// <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);
        }
예제 #12
0
 /// <summary>Gets all child elements with the given tag.</summary>
 /// <param name="selectors">The selectors to match.</param>
 /// <returns>The set of all tags with this tag.</returns>
 public void querySelectorAll(Selector[] selectors, INodeList results, CssEvent e, bool one)
 {
 }
예제 #13
0
 public override void Select(CssEvent e)
 {
     // Get the v-child (this one does not create it if it doesn't exist):
     GetVirtual(e, Priority);
 }
예제 #14
0
 /// <summary>Moves e.CurrentNode through the DOM
 /// ('backwards', e.g. from something to its parent).</summary>
 public virtual void MoveUpwards(CssEvent e)
 {
 }
예제 #15
0
 public virtual void Select(CssEvent e)
 {
 }