public void Add(ITreeComponent cmp, Point pos)
        {
            cmp.MoveTo(pos);

            _treeComponents.Add(cmp);
            SelectedItems = new[] { cmp };
        }
Example #2
0
 private void OnSetDone()
 {
     // Debug.Log("Tree done.");
     if (nextFrameCor == default)
     {
         _currentRunning = null;
         nextFrameCor    = StartCoroutine(RunNextFrame());
     }
 }
Example #3
0
 /// <summary>
 /// 先让树完整加载,然后再把树中的节点全部加入到指定的列表中。
 /// </summary>
 /// <param name="tree"></param>
 /// <param name="nodes"></param>
 internal static void FullAddIntoList(ITreeComponent tree, IList<Entity> nodes)
 {
     tree.LoadAllNodes();
     tree.EachNode(e =>
     {
         nodes.Add(e);
         return false;
     });
 }
Example #4
0
 /// <summary>
 /// 先让树完整加载,然后再把树中的节点全部加入到指定的列表中。
 /// </summary>
 /// <param name="tree"></param>
 /// <param name="nodes"></param>
 internal static void FullAddIntoList(ITreeComponent tree, IList <Entity> nodes)
 {
     tree.LoadAllNodes();
     tree.EachNode(e =>
     {
         nodes.Add(e);
         return(false);
     });
 }
Example #5
0
 internal static int CountNodes(ITreeComponent component)
 {
     int count = 0;
     component.EachNode(e =>
     {
         count++;
         return false;
     });
     return count;
 }
 public void UnConnect(ITreeComponent treeComponent)
 {
     foreach (var b in Arguments.ToArray())
     {
         if (b.Tree == treeComponent)
         {
             Arguments.Remove(b);
         }
     }
 }
        public string GenerateCode(ITreeComponent tree, string newLine)
        {
            if (tree is LeafComponent)
                return GenerateCode(tree as LeafComponent);
            if (tree is NodeComponent)
                return GenerateCode(tree as NodeComponent, newLine);
            if (tree is TreeRefComponent)
                return GenerateCode(tree as TreeRefComponent);

            throw new NotSupportedException("type is not supported " + tree.GetType());
        }
Example #8
0
        /// <summary>
        /// 树形EntityList转化为全部节点集合
        /// </summary>
        /// <param name="tree"></param>
        /// <returns></returns>
        public static List <T> ConvertToList <T>(ITreeComponent tree) where T : Entity
        {
            List <T> list = new List <T>();

            tree.EachNode(e =>
            {
                list.Add((T)e);
                return(false);
            });
            return(list);
        }
Example #9
0
        internal static int CountNodes(ITreeComponent component)
        {
            int count = 0;

            component.EachNode(e =>
            {
                count++;
                return(false);
            });
            return(count);
        }
Example #10
0
 internal static IList<Entity> GetParentList(ITreeComponent node)
 {
     IList<Entity> parentList = null;
     var parent = node.TreeComponentParent;
     if (parent.ComponentType == TreeComponentType.TreeChildren)
     {
         parentList = parent as Entity.EntityTreeChildren;
     }
     else if (parent.ComponentType == TreeComponentType.NodeList)
     {
         parentList = parent as EntityList;
     }
     return parentList;
 }
Example #11
0
        internal static IList <Entity> GetParentList(ITreeComponent node)
        {
            IList <Entity> parentList = null;
            var            parent     = node.TreeComponentParent;

            if (parent.ComponentType == TreeComponentType.TreeChildren)
            {
                parentList = parent as Entity.EntityTreeChildren;
            }
            else if (parent.ComponentType == TreeComponentType.NodeList)
            {
                parentList = parent as EntityList;
            }
            return(parentList);
        }
Example #12
0
        private void Initialize(ITreeComponent main, bool suppress)
        {
            _main = main;
            _main.Setup(this, default);
            if (!_main.Finalize())
            {
                throw new System.Exception(ERROR_MSG);
            }

            if (_startIssued && !suppress)
            {
                Run();
            }
            else
            {
                _runIssuedBeforeStart = !suppress;
            }
        }
        public override bool Connect(ITreeComponent fromComponent)
        {
            if (Arguments.Any(arg => arg.Tree == fromComponent))
                return false;

            if (fromComponent is LeafComponent)
            {
                var name = DesignerHelper.GetNewVariableName("arg{0}", Formulas.Select(a => a.Name));
                Arguments.Add(new Formula { Name = name, Tree = fromComponent });
                return true;
            }
            else if (fromComponent is CsvRepositoryComponent)
            {
                var name = DesignerHelper.GetNewVariableName("arg{0}", Formulas.Select(a => a.Name));
                Arguments.Add(new Repository { Tree = fromComponent });
                return true;
            }

            return false;
        }
 public bool Connect(ITreeComponent fromComponent)
 {
     return false;
 }
Example #15
0
        private static void TestTreeComponent(ITreeComponent component, int countBefore, int countAfter)
        {
            //只查询一级节点,统计该节点的个数应该正确。同时,它的 IsFullLoaded 返回假。
            //此时,调用 EachNode 遍历出的个数,应该正确。
            //调用 LoadAllNodes 查询整个树后,统计该节点的个数应该正确。
            //此时,调用 EachNode 遍历出的个数,应该正确。

            Assert.IsTrue(component.CountNodes() == countBefore, "只查询一级节点,统计该节点的个数应该正确。");
            Assert.IsTrue(!component.IsFullLoaded, "同时,它的 IsFullLoaded 返回假。");
            int count = 0;
            component.EachNode(e =>
            {
                count++;
                return false;
            });
            Assert.IsTrue(count == countBefore, "此时,调用 EachNode 遍历出的个数,应该正确。");

            component.LoadAllNodes();
            Assert.IsTrue(component.CountNodes() == countAfter, "调用 LoadAllNodes 查询整个树后,统计该节点的个数应该正确。");
            count = 0;
            component.EachNode(e =>
            {
                count++;
                return false;
            });
            Assert.IsTrue(count == countAfter, "此时,调用 EachNode 遍历出的个数,应该正确。");
        }
 public override bool Connect(ITreeComponent fromComponent)
 {
     throw new NotImplementedException();
 }
Example #17
0
 public void SetCurrentRunning(ITreeComponent current)
 {
     _currentRunning = current;
 }
 public abstract bool Connect(ITreeComponent fromComponent);
Example #19
0
        /// <summary>
        /// 删除整棵树中所有需要删除的节点。
        /// </summary>
        /// <param name="tree">The tree.</param>
        /// <param name="markSaved">if set to <c>true</c> [mark saved].</param>
        private void SubmitTreeDeletedItems(ITreeComponent tree, bool markSaved)
        {
            //整合所有要删除的节点。
            var mergedDeletedList = new List<Entity>();

            #region 加入列表的待删除节点。

            var list = tree as EntityList;
            if (list != null)
            {
                var toDeletedList = list.DeletedListField;
                if (toDeletedList != null)
                {
                    var isTreeRootList = list.IsTreeRootList;
                    for (int i = 0, c = toDeletedList.Count; i < c; i++)
                    {
                        var child = toDeletedList[i];
                        //如果在删除之后,又变换了 TreePId,那么可能是该节点已经加入到别的子树中,
                        //却无法修改根列表的 DeletedList 而导致该节点还在其中。
                        //所以需要把这些节点过滤掉,根列表只处理根节点的删除。
                        if (!isTreeRootList || child.TreePId == null)
                        {
                            //由于自关联外键没有级联删除,所以节点必须完整加载后,再全部加入到列表中。
                            TreeHelper.FullAddIntoList(child, mergedDeletedList);
                        }
                    }
                }
            }

            #endregion

            #region 加入所有节点的待删除列表节点。

            tree.EachNode(node =>
            {
                var tc = node.TreeChildrenField;
                if (tc != null)
                {
                    var tcDeleted = tc.DeletedListField;
                    if (tcDeleted != null)
                    {
                        for (int i = 0, c = tcDeleted.Count; i < c; i++)
                        {
                            var deleted = tcDeleted[i];
                            //与列表一样,必须检测删除的节点,当前是不是还属于 node。
                            if (node.Id.Equals(deleted.TreePId))
                            {
                                TreeHelper.FullAddIntoList(deleted, mergedDeletedList);
                            }
                        }
                    }
                }
                return false;
            });

            #endregion

            //反转顺序后再保存。
            mergedDeletedList.Reverse();
            for (int i = 0, c = mergedDeletedList.Count; i < c; i++)
            {
                var item = mergedDeletedList[i];
                item.PersistenceStatus = PersistenceStatus.Deleted;
                this.SubmitItem(item, false, false);
            }

            if (markSaved)
            {
                tree.MarkSaved();
            }
        }
Example #20
0
        /// <summary>
        /// 删除整棵树中所有需要删除的节点。
        /// </summary>
        /// <param name="tree">The tree.</param>
        /// <param name="markSaved">if set to <c>true</c> [mark saved].</param>
        private void SubmitTreeDeletedItems(ITreeComponent tree, bool markSaved)
        {
            //整合所有要删除的节点。
            var mergedDeletedList = new List <Entity>();

            #region 加入列表的待删除节点。

            var list = tree as EntityList;
            if (list != null)
            {
                var toDeletedList = list.DeletedListField;
                if (toDeletedList != null)
                {
                    var isTreeRootList = list.IsTreeRootList;
                    for (int i = 0, c = toDeletedList.Count; i < c; i++)
                    {
                        var child = toDeletedList[i];
                        //如果在删除之后,又变换了 TreePId,那么可能是该节点已经加入到别的子树中,
                        //却无法修改根列表的 DeletedList 而导致该节点还在其中。
                        //所以需要把这些节点过滤掉,根列表只处理根节点的删除。
                        if (!isTreeRootList || child.TreePId == null)
                        {
                            //由于自关联外键没有级联删除,所以节点必须完整加载后,再全部加入到列表中。
                            TreeHelper.FullAddIntoList(child, mergedDeletedList);
                        }
                    }
                }
            }

            #endregion

            #region 加入所有节点的待删除列表节点。

            tree.EachNode(node =>
            {
                var tc = node.TreeChildrenField;
                if (tc != null)
                {
                    var tcDeleted = tc.DeletedListField;
                    if (tcDeleted != null)
                    {
                        for (int i = 0, c = tcDeleted.Count; i < c; i++)
                        {
                            var deleted = tcDeleted[i];
                            //与列表一样,必须检测删除的节点,当前是不是还属于 node。
                            if (node.Id.Equals(deleted.TreePId))
                            {
                                TreeHelper.FullAddIntoList(deleted, mergedDeletedList);
                            }
                        }
                    }
                }
                return(false);
            });

            #endregion

            //反转顺序后再保存。
            mergedDeletedList.Reverse();
            for (int i = 0, c = mergedDeletedList.Count; i < c; i++)
            {
                var item = mergedDeletedList[i];
                item.PersistenceStatus = PersistenceStatus.Deleted;
                this.SubmitItem(item, false, false);
            }

            if (markSaved)
            {
                tree.MarkSaved();
            }
        }
 public void UnConnect(ITreeComponent treeComponent)
 {
 }