Пример #1
0
        public static IEnumerable<XNodeInfo> DescendantNodesInfos(IEnumerable<XNode> nodes, Func<XNode, XNodeFilter> filter = null)
        {
            //bool stop = false;
            int level = 1;
            int index = 1;
            foreach (XNode node1 in nodes)
            {
                XNodeFilter xnodeFilter = XNodeFilter.SelectNode;
                if (filter != null)
                    xnodeFilter = filter(node1);

                if (__trace)
                    pb.Trace.WriteLine("DescendantNodesInfos : source node {0}, filter {1}", node1.zGetPath(), xnodeFilter);

                XNodeInfo nodeInfo = new XNodeInfo { Index = index++,  Node = node1, Level = level, Ope = NodeOpe.Source, Selected = false, Skip = false, Stop = false };

                if ((xnodeFilter & XNodeFilter.Stop) == XNodeFilter.Stop)
                {
                    nodeInfo.Stop = true;
                    yield return nodeInfo;
                    break;
                }

                if ((xnodeFilter & XNodeFilter.SkipNode) == XNodeFilter.SkipNode)
                {
                    nodeInfo.Skip = true;
                    yield return nodeInfo;
                    continue;
                }

                if ((xnodeFilter & XNodeFilter.DontSelectNode) == 0)
                {
                    //yield return node1;
                    nodeInfo.Selected = true;
                    yield return nodeInfo;
                }
                else
                    yield return nodeInfo;

                if (__trace)
                    pb.Trace.WriteLine("DescendantNodesInfos : source node {0}", node1.zGetPath());
                XNode node2 = node1;
                XNode sourceNode = node2;
                while (true)
                {

                    // get child
                    while (true)
                    {
                        if (!(node2 is XElement))
                            break;

                        // first child node
                        XNode childNode = ((XElement)node2).FirstNode;

                        if (childNode == null)
                            break;

                        nodeInfo = new XNodeInfo { Index = index++, Node = childNode, Level = level + 1, Ope = NodeOpe.Child, Selected = false, Skip = false, Stop = false };

                        xnodeFilter = XNodeFilter.SelectNode;
                        if (filter != null)
                            xnodeFilter = filter(childNode);
                        if (__trace)
                            pb.Trace.WriteLine("DescendantNodesInfos : child node  {0}, filter {1}", childNode.zGetPath(), xnodeFilter);

                        if ((xnodeFilter & XNodeFilter.Stop) == XNodeFilter.Stop)
                        {
                            //stop = true;
                            nodeInfo.Stop = true;
                            yield return nodeInfo;
                            yield break;
                        }

                        if ((xnodeFilter & XNodeFilter.SkipNode) == XNodeFilter.SkipNode)
                        {
                            nodeInfo.Skip = true;
                            yield return nodeInfo;
                            break;
                        }

                        node2 = childNode;
                        level++;
                        if ((xnodeFilter & XNodeFilter.DontSelectNode) == 0)
                        {
                            //yield return node2;
                            //level++;
                            nodeInfo.Selected = true;
                            yield return nodeInfo;
                        }
                        else
                            yield return nodeInfo;
                    }
                    //if (stop)
                    //    break;

                    // get next sibling node or next sibling node of parent node
                    bool getChild = false;
                    bool stopNode = false;
                    while (true)
                    {
                        if (node2 == sourceNode)
                        {
                            stopNode = true;
                            break;
                        }

                        // next sibling node
                        XNode nextNode = node2.NextNode;
                        while (true)
                        {
                            if (nextNode == null)
                                break;

                            nodeInfo = new XNodeInfo { Index = index++, Node = nextNode, Level = level, Ope = NodeOpe.Siblin, Selected = false, Skip = false, Stop = false };

                            xnodeFilter = XNodeFilter.SelectNode;
                            if (filter != null)
                                xnodeFilter = filter(nextNode);

                            if (__trace)
                                pb.Trace.WriteLine("DescendantNodesInfos : next node   {0}, filter {1}", nextNode.zGetPath(), xnodeFilter);

                            if ((xnodeFilter & XNodeFilter.Stop) == XNodeFilter.Stop)
                            {
                                //stop = true;
                                nodeInfo.Stop = true;
                                yield return nodeInfo;
                                yield break;
                            }

                            if ((xnodeFilter & XNodeFilter.SkipNode) == 0)
                            {
                                node2 = nextNode;
                                if ((xnodeFilter & XNodeFilter.DontSelectNode) == 0)
                                {
                                    nodeInfo.Selected = true;
                                    yield return nodeInfo;
                                }
                                else
                                    yield return nodeInfo;
                                //else
                                //{
                                getChild = true;
                                break;
                                //}
                            }
                            else
                            {
                                nodeInfo.Skip = true;
                                yield return nodeInfo;
                            }
                            nextNode = nextNode.NextNode;
                        }
                        if (getChild)
                            break;

                        // parent node
                        node2 = node2.Parent;
                        level--;

                        nodeInfo = new XNodeInfo { Index = index++, Node = node2, Level = level, Ope = NodeOpe.Close, Selected = false, Skip = false, Stop = false };
                        yield return nodeInfo;
                    }
                    //if (stop || stopNode)
                    if (stopNode)
                        break;
                }
                //if (stop)
                //    break;
            }
        }
Пример #2
0
        public static IEnumerable <XNodeInfo> DescendantNodesInfos(IEnumerable <XNode> nodes, Func <XNode, XNodeFilter> filter = null)
        {
            //bool stop = false;
            int level = 1;
            int index = 1;

            foreach (XNode node1 in nodes)
            {
                XNodeFilter xnodeFilter = XNodeFilter.SelectNode;
                if (filter != null)
                {
                    xnodeFilter = filter(node1);
                }

                if (__trace)
                {
                    pb.Trace.WriteLine("DescendantNodesInfos : source node {0}, filter {1}", node1.zGetPath(), xnodeFilter);
                }

                XNodeInfo nodeInfo = new XNodeInfo {
                    Index = index++, Node = node1, Level = level, Ope = NodeOpe.Source, Selected = false, Skip = false, Stop = false
                };

                if ((xnodeFilter & XNodeFilter.Stop) == XNodeFilter.Stop)
                {
                    nodeInfo.Stop = true;
                    yield return(nodeInfo);

                    break;
                }

                if ((xnodeFilter & XNodeFilter.SkipNode) == XNodeFilter.SkipNode)
                {
                    nodeInfo.Skip = true;
                    yield return(nodeInfo);

                    continue;
                }

                if ((xnodeFilter & XNodeFilter.DontSelectNode) == 0)
                {
                    //yield return node1;
                    nodeInfo.Selected = true;
                    yield return(nodeInfo);
                }
                else
                {
                    yield return(nodeInfo);
                }

                if (__trace)
                {
                    pb.Trace.WriteLine("DescendantNodesInfos : source node {0}", node1.zGetPath());
                }
                XNode node2      = node1;
                XNode sourceNode = node2;
                while (true)
                {
                    // get child
                    while (true)
                    {
                        if (!(node2 is XElement))
                        {
                            break;
                        }

                        // first child node
                        XNode childNode = ((XElement)node2).FirstNode;

                        if (childNode == null)
                        {
                            break;
                        }

                        nodeInfo = new XNodeInfo {
                            Index = index++, Node = childNode, Level = level + 1, Ope = NodeOpe.Child, Selected = false, Skip = false, Stop = false
                        };

                        xnodeFilter = XNodeFilter.SelectNode;
                        if (filter != null)
                        {
                            xnodeFilter = filter(childNode);
                        }
                        if (__trace)
                        {
                            pb.Trace.WriteLine("DescendantNodesInfos : child node  {0}, filter {1}", childNode.zGetPath(), xnodeFilter);
                        }

                        if ((xnodeFilter & XNodeFilter.Stop) == XNodeFilter.Stop)
                        {
                            //stop = true;
                            nodeInfo.Stop = true;
                            yield return(nodeInfo);

                            yield break;
                        }

                        if ((xnodeFilter & XNodeFilter.SkipNode) == XNodeFilter.SkipNode)
                        {
                            nodeInfo.Skip = true;
                            yield return(nodeInfo);

                            break;
                        }

                        node2 = childNode;
                        level++;
                        if ((xnodeFilter & XNodeFilter.DontSelectNode) == 0)
                        {
                            //yield return node2;
                            //level++;
                            nodeInfo.Selected = true;
                            yield return(nodeInfo);
                        }
                        else
                        {
                            yield return(nodeInfo);
                        }
                    }
                    //if (stop)
                    //    break;

                    // get next sibling node or next sibling node of parent node
                    bool getChild = false;
                    bool stopNode = false;
                    while (true)
                    {
                        if (node2 == sourceNode)
                        {
                            stopNode = true;
                            break;
                        }

                        // next sibling node
                        XNode nextNode = node2.NextNode;
                        while (true)
                        {
                            if (nextNode == null)
                            {
                                break;
                            }

                            nodeInfo = new XNodeInfo {
                                Index = index++, Node = nextNode, Level = level, Ope = NodeOpe.Siblin, Selected = false, Skip = false, Stop = false
                            };

                            xnodeFilter = XNodeFilter.SelectNode;
                            if (filter != null)
                            {
                                xnodeFilter = filter(nextNode);
                            }

                            if (__trace)
                            {
                                pb.Trace.WriteLine("DescendantNodesInfos : next node   {0}, filter {1}", nextNode.zGetPath(), xnodeFilter);
                            }

                            if ((xnodeFilter & XNodeFilter.Stop) == XNodeFilter.Stop)
                            {
                                //stop = true;
                                nodeInfo.Stop = true;
                                yield return(nodeInfo);

                                yield break;
                            }

                            if ((xnodeFilter & XNodeFilter.SkipNode) == 0)
                            {
                                node2 = nextNode;
                                if ((xnodeFilter & XNodeFilter.DontSelectNode) == 0)
                                {
                                    nodeInfo.Selected = true;
                                    yield return(nodeInfo);
                                }
                                else
                                {
                                    yield return(nodeInfo);
                                }
                                //else
                                //{
                                getChild = true;
                                break;
                                //}
                            }
                            else
                            {
                                nodeInfo.Skip = true;
                                yield return(nodeInfo);
                            }
                            nextNode = nextNode.NextNode;
                        }
                        if (getChild)
                        {
                            break;
                        }

                        // parent node
                        node2 = node2.Parent;
                        level--;

                        nodeInfo = new XNodeInfo {
                            Index = index++, Node = node2, Level = level, Ope = NodeOpe.Close, Selected = false, Skip = false, Stop = false
                        };
                        yield return(nodeInfo);
                    }
                    //if (stop || stopNode)
                    if (stopNode)
                    {
                        break;
                    }
                }
                //if (stop)
                //    break;
            }
        }