/// <summary> /// 지정한 Node Container가 TreeView라면 Nodes 들을 열거하고, TreeNode라면 자신을 반환한다. /// </summary> /// <param name="nodeContainer"></param> /// <returns></returns> public static IEnumerable <RadTreeNode> GetRootNodesOrSelfNode(this IRadTreeNodeContainer nodeContainer) { if (IsDebugEnabled) { log.Debug(@"지정한 Node Container가 TreeView라면 Nodes 들을 열거하고, TreeNode라면 자신을 반환한다. nodeContainer=[{0}]", nodeContainer.AsTextAndValue()); } if (nodeContainer == null) { yield break; } if (nodeContainer is RadTreeNode) { yield return((RadTreeNode)nodeContainer); } else if (nodeContainer is RadTreeView) { var rootNodes = ((RadTreeView)nodeContainer).Nodes; foreach (RadTreeNode node in rootNodes) { yield return(node); } } }
/// <summary> /// 특정 NodeContainer가 TreeView라면 자식 Nodes들을 열거하고, TreeNode라면, TreeNode가 속한 TreeView의 Root Nodes 들을 반환합니다. /// </summary> /// <param name="nodeContainer"></param> /// <returns></returns> public static IEnumerable <RadTreeNode> FindRootNodes(this IRadTreeNodeContainer nodeContainer) { if (IsDebugEnabled) { log.Debug("특정 NodeContainer가 TreeView라면 자식 Nodes들을 열거하고, TreeNode라면, TreeNode가 속한 TreeView의 Root Nodes 들을 반환합니다... " + "nodeContainer=[{0}]", nodeContainer.AsTextAndValue()); } RadTreeView radTreeView = null; if (nodeContainer is RadTreeView) { radTreeView = (RadTreeView)nodeContainer; } else if (nodeContainer is RadTreeNode) { radTreeView = ((RadTreeNode)nodeContainer).TreeView; } if (radTreeView != null) { return(radTreeView.Nodes.Cast <RadTreeNode>()); } return(Enumerable.Empty <RadTreeNode>()); }
/// <summary> /// 엔티티를 로드하고, IRadTreeNodeContainer에 자식노드로 추가한다. /// </summary> /// <param name="node">선택된 IRadTreeNodeContainer</param> /// <param name="exceptionAction">예외발생 시 수행할 Action</param> protected virtual void LoadAndAddEntity(IRadTreeNodeContainer node, Action <Exception> exceptionAction) { if (IsDebugEnabled) { log.Debug(@"==>S 엔티티[{0}] 목록을 로드하여, TreeView에 바인딩 시킵니다...", ConcreteType.Name); } node.ShouldNotBeNull("선택된 IRadTreeNodeContainer정보가 없습니다."); try { LoadEntity(node); AddEntity(node); } catch (Exception ex) { var errorMsg = string.Format(@"엔티티[{0}]를 로드하고, Binding 시에 예외가 발생했습니다.", ConcreteType.Name); if (log.IsErrorEnabled) { log.ErrorException(errorMsg, ex); } if (exceptionAction != null) { exceptionAction(ex); } else { WebAppTool.MessageBox(errorMsg, this); } } }
protected void btnAddNode_Click(object sender, EventArgs e) { Model.OrganiztionRole org = new Model.OrganiztionRole(); IRadTreeNodeContainer target = trvChart; int ParrentOrganizationRoleId = -1, OrganizationRoleId; if (string.IsNullOrEmpty(cmbOrganizationRoles.SelectedValue)) { // Helpers.ContextHelpers.ShowMessage(this.Page, "یک نقش سازمانی انتخاب نمایید"); return; } if (trvChart.SelectedNode != null) { trvChart.SelectedNode.Expanded = true; target = trvChart.SelectedNode; ParrentOrganizationRoleId = trvChart.SelectedNode.Attributes["OrganizationRoleId"].ToInt32(); } OrganizationRoleId = cmbOrganizationRoles.SelectedValue.ToInt32(); if (org.SetParrentId(ParrentOrganizationRoleId, OrganizationRoleId) != -1) { RadTreeNode addedNode = new RadTreeNode(cmbOrganizationRoles.SelectedText); addedNode.ToolTip = string.Format("شماره نقش{0}", cmbOrganizationRoles.SelectedValue); addedNode.Attributes.Add("OrganizationRoleId", cmbOrganizationRoles.SelectedValue); addedNode.Selected = true; target.Nodes.Add(addedNode); } }
/// <summary> /// nodeContainer의 자신과 자손 TreeNode를 폭 우선 탐색 방식으로 열거합니다. /// </summary> /// <param name="nodeContainer"></param> /// <returns></returns> public static IEnumerable <RadTreeNode> GetNodesByBreadthFirst(this IRadTreeNodeContainer nodeContainer) { if (nodeContainer == null) { yield break; } if (IsDebugEnabled) { log.Debug(@"특정 NodeContainer를 폭 우선 탐색을 수행합니다. nodeContainer=[{0}]", nodeContainer.AsTextAndValue()); } // CollectionExtensions.GraphBreadthFirstScan() 을 사용할 수 있지만, TreeView의 RootNode가 여러 개라면, 폭 우선 탐색이 되지 않는다. // 그래서 여기서 전체를 다 구현했다. var toScan = new Queue <RadTreeNode>(GetRootNodesOrSelfNode(nodeContainer)); var scanned = new HashSet <RadTreeNode>(); while (toScan.Count > 0) { RadTreeNode current = toScan.Dequeue(); yield return(current); scanned.Add(current); foreach (RadTreeNode item in current.Nodes.Cast <RadTreeNode>()) { if (scanned.Contains(item) == false) { toScan.Enqueue(item); } } } }
protected void btnAddNode_Click(object sender, EventArgs e) { global::AccessManagementService.Model.OrganiztionRole org = new global::AccessManagementService.Model.OrganiztionRole(); IRadTreeNodeContainer target = trvChart; int?ParrentOrganizationRoleId = -1; int OrganizationRoleId; if (string.IsNullOrEmpty(cmbOrganizationRoles.SelectedValue)) { // Helpers.ContextHelpers.ShowMessage(this.Page, "یک نقش سازمانی انتخاب نمایید"); return; } OrganizationRoleId = cmbOrganizationRoles.SelectedValue.ToInt32(); if (trvChart.SelectedNode != null) { trvChart.SelectedNode.Expanded = true; target = trvChart.SelectedNode; ParrentOrganizationRoleId = trvChart.SelectedNode.Attributes["OrganizationRoleId"].ToInt32(); } else { ParrentOrganizationRoleId = null; //very important to set first node's parrent id to null } // org.SetParrentId( OrganizationRoleId,ParrentOrganizationRoleId); no more need because all deparment mabe use this org RadTreeNode addedNode = new RadTreeNode(cmbOrganizationRoles.SelectedText); addedNode.ToolTip = string.Format("شماره نقش{0}", cmbOrganizationRoles.SelectedValue); addedNode.Attributes.Add("OrganizationRoleId", cmbOrganizationRoles.SelectedValue); addedNode.Selected = true; target.Nodes.Add(addedNode); //cmbOrganizationRoles.DataBind(); }
/// <summary> /// <see cref="ITreeNodeEntity{T}"/>를 구현한 엔티티들을 표현할 TreeNode를 생성하여 TreeView에 추가합니다. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="parent">부모 노드 또는 TreeView</param> /// <param name="nodeFactory">TreeNode를 생성하는 Factory 함수</param> /// <param name="findNodeFunc">기존 TreeView에서 엔티티와 관련된 Node를 찾는 함수</param> /// <param name="nodeAddedAction">TreeNode 하나를 추가할 때마다 수행하는 Action</param> /// <param name="items">엔티티</param> public static void BuildTreeNodes <T>(this IRadTreeNodeContainer parent, Func <T, RadTreeNode> nodeFactory, Func <T, RadTreeNode> findNodeFunc, Action <T, RadTreeNode> nodeAddedAction, IEnumerable <T> items) where T : class, ITreeNodeEntity <T> { BuildTreeNodes(parent, nodeFactory, findNodeFunc, nodeAddedAction, items, false); }
/// <summary> /// parent Container에 <see cref="Entities"/>값을 자식으로 추가한다. /// </summary> protected virtual void AddEntity(IRadTreeNodeContainer parent) { if (IsDebugEnabled) { log.Debug(@"==>S EntityGrid에 로딩된 Entity[{0}] 컬렉션을 Binding합니다...", ConcreteType.Name); } TreeViewAdapter.AddNodes(parent, Entities); }
/// <summary> /// 지정된 노드에 Tree를 추가합니다. /// </summary> /// <param name="parent"></param> /// <param name="items"></param> public virtual void AddNodes(IRadTreeNodeContainer parent, IEnumerable <T> items) { if (IsDebugEnabled) { log.Debug(@"지정된 엔티티들을 TreeView의 노드로 추가합니다... parent={0}, items={1}", parent, items.CollectionToString()); } TelerikTool.AddNodes(parent ?? TreeViewCtrl, CreateNode, NodeAdded, items); }
/// <summary> /// 특정 NodeContainer의 자손 중 자식 노드가 없는 TreeNode들 (나무 잎) 을 열거합니다. /// </summary> /// <param name="nodeContainer"></param> /// <returns></returns> public static IEnumerable <RadTreeNode> FindLeafNodes(this IRadTreeNodeContainer nodeContainer) { nodeContainer.ShouldNotBeNull("nodeContainer"); if (IsDebugEnabled) { log.Debug(@"특정 NodeContainer 하위의 모든 Leaf Node (자식이 없는 노드) 들을 Depth First 방식으로 찾습니다. nodeContainer=[{0}]", nodeContainer.AsTextAndValue()); } return(nodeContainer.GetDescendentNodes().Where(n => n.Nodes.Count == 0)); }
/// <summary> /// 지정된 노드에 Tree를 추가합니다. /// </summary> /// <param name="parent"></param> /// <param name="items"></param> public override void AddNodes(IRadTreeNodeContainer parent, IEnumerable <T> items) { if (IsDebugEnabled) { log.Debug(@"지정된 엔티티들을 TreeView의 노드로 추가합니다... parent={0}, items={1}", parent, items.CollectionToString()); } if (items != null) { (parent ?? TreeViewCtrl).BuildTreeNodes(CreateNode, FindNodeByItem, NodeAdded, items); } }
/// <summary> /// Depth-First 탐색으로 특정 Node 와 그 자손 Node 들 중에 검사를 통과하는 Node들을 열거합니다. /// </summary> /// <param name="nodeContainer"></param> /// <param name="predicate"></param> /// <returns></returns> public static IEnumerable <RadTreeNode> FindNodes(this IRadTreeNodeContainer nodeContainer, Func <RadTreeNode, bool> predicate) { nodeContainer.ShouldNotBeNull("nodeContainer"); predicate.ShouldNotBeNull("predicate"); if (IsDebugEnabled) { log.Debug("특정 NodeContainer(TreeView or TreeNode)부터 predicate를 만족하는 RadTreeNode 들을 모두 열거합니다. nodeContainer=[{0}]", nodeContainer.AsTextAndValue()); } return(nodeContainer.GetDescendentNodes().Where(predicate)); }
/// <summary> /// 특정 값을 가진 TreeNode를 찾습니다. 없으면 null을 반환합니다. /// </summary> /// <param name="nodeContainer">RadTreeView or RadTreeNode</param> /// <param name="nodeValue">찾을 node value</param> /// <param name="ignoreCase">대소문자 무시 여부</param> /// <returns></returns> public static RadTreeNode FirstOrDefaultByValue(this IRadTreeNodeContainer nodeContainer, string nodeValue, bool ignoreCase = true) { if (nodeContainer == null) { return(null); } if (IsDebugEnabled) { log.Debug(@"특정 nodeContainer 및 자손 TreeNode 중에 Value 속성 값이 [{0}] 인 TreeNode를 찾습니다... ignoreCase=[{1}]", nodeValue, ignoreCase); } return(nodeContainer.FindNodes(n => string.Compare(n.Value, nodeValue, ignoreCase) == 0).FirstOrDefault()); }
protected override void OnPreRender(EventArgs e) { base.OnPreRender(e); User user = GetUser(); if (user == null || user.Department == null) { return; } Department department = new Department(); XmlHelper xmlhelper = new XmlHelper(); trvChart.LoadXml(user.Department.DeparetmentChartXML); foreach (var dep in department.GetDepartments(null)) { Panel container = new Panel(); if (dep.ID == user.DepartmentID) { continue; } else { if (string.IsNullOrEmpty(dep.DeparetmentChartXML)) { continue; } var xml = xmlhelper.GetElementsByString(dep.DeparetmentChartXML, "Node"); if (xml != null && xml.Count > 0) { var rootNode = xml[0]; string OrganizationRoleId = rootNode.Attribute("OrganizationRoleId").Value; string name = rootNode.Attribute("Text").Value; IRadTreeNodeContainer target = trvChart; RadTreeNode addedNode = new RadTreeNode(name); //if (trvChart.SelectedNode != null) //{ // trvChart.SelectedNode.Expanded = true; // target = trvChart.SelectedNode; //} addedNode.Attributes.Add("OrganizationRoleId", OrganizationRoleId); target.Nodes.Add(addedNode); } } } }
/// <summary> /// 遍历科目分类 /// </summary> /// <param name="classId"></param> /// <param name="node"></param> /// <param name="listModel"></param> private void RecursivelySubjectClass(Guid classId, IRadTreeNodeContainer node, IList <SubjectClassInfo> listModel, object sender) { IList <SubjectClassInfo> listChild = listModel.Where(w => w.ParentClassId == classId).ToList(); foreach (SubjectClassInfo item in listChild) { RadTreeNode treeNode = CreateNode(item.ClassName, false, item.ClassId.ToString()); if (node == null) { ((RadTreeView)sender).Nodes.Add(treeNode); } else { node.Nodes.Add(treeNode); } RecursivelySubjectClass(item.ClassId, treeNode, listModel, sender); } }
//遍历产品分类 private void RecursivelyGoodsClass(Guid goodsClassId, IRadTreeNodeContainer node, IList <GoodsClassInfo> goodsClassList) { IList <GoodsClassInfo> childGoodsClassList = goodsClassList.Where(w => w.ParentClassId == goodsClassId).ToList(); foreach (GoodsClassInfo goodsClassInfo in childGoodsClassList) { RadTreeNode goodsClassNode = CreateNode(goodsClassInfo.ClassName, false, goodsClassInfo.ClassId.ToString()); if (node == null) { TVGoodsClass.Nodes.Add(goodsClassNode); } else { node.Nodes.Add(goodsClassNode); } RecursivelyGoodsClass(goodsClassInfo.ClassId, goodsClassNode, goodsClassList); } }
/// <summary> /// 특정 TreeNode의 자식으로 노드를 추가합니다. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="parent"></param> /// <param name="nodeFactory">노드 생성 메소드</param> /// <param name="nodeAddedAction">노드 추가마다 호출되는 메소드</param> /// <param name="items"></param> public static void AddNodes <T>(this IRadTreeNodeContainer parent, Func <T, RadTreeNode> nodeFactory, Action <T, RadTreeNode> nodeAddedAction, IEnumerable <T> items) { if (items.IsEmptySequence()) { return; } parent.ShouldNotBeNull("parent"); nodeFactory.ShouldNotBeNull("nodeFactory"); if (IsDebugEnabled) { log.Debug(@"TreeNode의 자식 노드들을 추가합니다..."); } foreach (T item in items) { if (IsDebugEnabled) { log.Debug(@"엔티티를 RadTreeNode로 빌드합니다. item=[{0}]", item); } var childNode = nodeFactory(item); if (childNode != null) { parent.Nodes.Add(childNode); if (IsDebugEnabled) { log.Debug(@"TreeNode에 자식 노드를 추가했습니다. parent=[{0}], childNode=[{1}]", parent, childNode.Text); } if (nodeAddedAction != null) { nodeAddedAction(item, childNode); } } } }
/// <summary> /// 깊이 우선 탐색을 통해, 현재 Node와 Node의 자손 Node들을 열거합니다. 열거 순서에 상관없으려면 node.GetAllNodes()를 사용하세요 /// </summary> /// <param name="nodeContainer"></param> /// <returns></returns> public static IEnumerable <RadTreeNode> GetDescendentNodes(this IRadTreeNodeContainer nodeContainer) { if (nodeContainer == null) { yield break; } if (IsDebugEnabled) { log.Debug(@"특정 nodeContainer의 자신과 모든 자손 노드들을 열거합니다... nodeContainer=[{0}]", nodeContainer.AsTextAndValue()); } foreach (RadTreeNode rootNode in GetRootNodesOrSelfNode(nodeContainer)) { foreach (var childNode in rootNode.GraphDepthFirstScan(n => n.Nodes.Cast <RadTreeNode>())) { yield return(childNode); } } }
//遍历资金帐户 private void RecursivelyBankAccounts(IRadTreeNodeContainer node, Guid filialeId) { if (_reckoningElseFilialeid == filialeId) { var bankAccountsInfoList = _bankAccountsWrite.GetList().Where(ent => !ent.IsMain).OrderByDescending(ent => ent.IsUse).ToList(); foreach (var bankAccountsInfo in bankAccountsInfoList) { var childNode = CreateNode((bankAccountsInfo.IsUse ? "" : "【停用】") + bankAccountsInfo.BankName + "[" + GetBankAccountsCount(bankAccountsInfo.BankAccountsId) + "]", false, bankAccountsInfo.BankAccountsId.ToString(), "BankAccount"); node.Nodes.Add(childNode); } } else { var bankAccountsInfoList = _bankAccountDaoRead.GetListByTargetId(filialeId).OrderByDescending(ent => ent.IsUse).ToList(); foreach (var bankAccountsInfo in bankAccountsInfoList) { var childNode = CreateNode(string.Format("{0}{1}[{2}]", !bankAccountsInfo.IsUse ? "【停用】" : "", bankAccountsInfo.BankName, GetBankAccountsCount(bankAccountsInfo.BankAccountsId)), false, bankAccountsInfo.BankAccountsId.ToString(), "BankAccount"); node.Nodes.Add(childNode); } } }
/// <summary> /// <see cref="nodeContainer"/>의 모든 Node에 대한 정보를 문자열로 표현하도록 합니다. 디버그 시에만 사용하세요. /// </summary> /// <param name="nodeContainer"></param> /// <returns></returns> public static string AsTextAndValue(this IRadTreeNodeContainer nodeContainer) { if (nodeContainer == null) { return(@"NULL"); } if (nodeContainer is RadTreeNode) { var node = (RadTreeNode)nodeContainer; return(string.Format(@"RadTreeNode#Text={0},Value={1}", node.Text, node.Value)); } if (nodeContainer is RadTreeView) { var treeview = (RadTreeView)nodeContainer; return(string.Format(@"RadTreeView#ID={0},ClientID={1},SelectedValue={2}", treeview.ID, treeview.ClientID, treeview.SelectedValue)); } return(nodeContainer.ObjectToString()); }
/// <summary> /// nodeContainer의 자신과 자손 TreeNode를 깊이 우선 탐색 방식으로 열거합니다. /// </summary> /// <param name="nodeContainer">기준 노드 또는 TreeView</param> /// <returns></returns> public static IEnumerable <RadTreeNode> GetNodesByDepthFirst(this IRadTreeNodeContainer nodeContainer) { if (nodeContainer == null) { yield break; } if (IsDebugEnabled) { log.Debug(@"특정 NodeContainer를 깊이 우선 탐색을 수행합니다. nodeContainer=[{0}]", nodeContainer.AsTextAndValue()); } foreach (RadTreeNode root in GetRootNodesOrSelfNode(nodeContainer)) { yield return(root); foreach (var node in root.GraphDepthFirstScan(n => n.Nodes.Cast <RadTreeNode>())) { yield return(node); } } }
/// <summary> /// Render all Tabs including Child Tabs /// </summary> /// <param name="nodeParent"> /// Parent Node(Tab) /// </param> /// <param name="iParentTabId"> /// Parent Tab ID /// </param> private void RenderTabLevels(IRadTreeNodeContainer nodeParent, int iParentTabId) { foreach (TabInfo objTab in TabController.GetPortalTabs( this._portalSettings.PortalId, -1, false, null, true, false, true, true, false)) { if (!objTab.ParentId.Equals(iParentTabId)) { continue; } var nodeTab = new RadTreeNode(); if (nodeParent != null) { nodeParent.Nodes.Add(nodeTab); } else { this.dnntreeTabs.Nodes.Add(nodeTab); } nodeTab.Text = objTab.TabName; nodeTab.Value = objTab.TabID.ToString(); nodeTab.ImageUrl = "Images/Page.gif"; // nodeTab.ExpandedImageUrl = "Images/folderOpen.gif"; if (!string.IsNullOrEmpty(objTab.IconFile)) { nodeTab.ImageUrl = this.ResolveUrl(objTab.IconFile); } this.RenderTabLevels(nodeTab, objTab.TabID); } }
/// <summary> /// 현재 노드에 대한 자식 엔티티 목록을 로드하여 <see cref="Entities"/>에 할당합니다. /// </summary> /// <param name="node"></param> protected abstract void LoadEntity(IRadTreeNodeContainer node);
/// <summary> /// 특정 TreeNode의 자식으로 노드를 추가합니다. NFramework.Data.NHibernateEx.Domain.ITreeNodeEntity를 구현한 클래스에 대해서는 BuildTreeNodes 함수를 사용하세요. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="parent"></param> /// <param name="nodeFactory"></param> /// <param name="items"></param> public static void AddNodes <T>(this IRadTreeNodeContainer parent, Func <T, RadTreeNode> nodeFactory, IEnumerable <T> items) { AddNodes <T>(parent, nodeFactory, null, items); }
//遍历资金帐户 private bool RecursivelyBankAccounts(IRadTreeNodeContainer node, Guid targetId) { var flag = true; var personnelInfo = CurrentSession.Personnel.Get(); if (personnelInfo != null) { var selectSalePlatformInfo = CacheCollection.SalePlatform.Get(targetId); IEnumerable <BankAccountInfo> infos = _bankAccountsDao.GetListByTargetId(targetId); if (infos != null && infos.Any()) { if (selectSalePlatformInfo == null) { IList <BankAccountInfo> bankAccountList = _bankAccounts.GetBankAccountsList(personnelInfo.FilialeId, personnelInfo.BranchId, personnelInfo.PositionId) .Where(b => infos.Any(ent => ent.BankAccountsId == b.BankAccountsId) && b.IsUse) .OrderByDescending(b => b.IsUse) .ToList(); var salePlatformList = CacheCollection.SalePlatform.GetListByFilialeId(targetId); var bindingedBankAccountList = new List <BankAccountInfo>(); foreach (var salePlatformInfo in salePlatformList.Where(act => act.IsActive)) { bindingedBankAccountList.AddRange(_bankAccountsDao.GetListByTargetId(salePlatformInfo.ID)); } var needBankAccountList = (from item in bankAccountList where bindingedBankAccountList.All( ent => ent.BankAccountsId != item.BankAccountsId) select new BankAccountInfo { BankAccountsId = item.BankAccountsId, Accounts = item.Accounts, AccountsKey = item.AccountsKey, AccountsName = item.AccountsName, BankIcon = item.BankIcon, BankName = item.BankName, Description = item.Description, IsFinish = item.IsFinish, IsUse = item.IsUse, OrderIndex = item.OrderIndex, PaymentInterfaceId = item.PaymentInterfaceId, PaymentType = item.PaymentType, }).ToList(); flag = needBankAccountList.Count > 0; foreach (var bankAccountsInfo in needBankAccountList) { var childNode = CreateNode( (bankAccountsInfo.IsUse ? "" : "【停用】") + bankAccountsInfo.BankName + " - " + bankAccountsInfo.AccountsName + "[" + GetBankAccountsCount(bankAccountsInfo.BankAccountsId).ToString("N") + "]", false, bankAccountsInfo.BankAccountsId.ToString(), "BankAccount"); node.Nodes.Add(childNode); } } else { if (selectSalePlatformInfo.IsActive) { IList <BankAccountInfo> bankAccountsInfoList = _bankAccounts.GetBankAccountsList(personnelInfo.FilialeId, personnelInfo.BranchId, personnelInfo.PositionId) .Where(b => infos.Any(ent => ent.BankAccountsId == b.BankAccountsId) && b.IsUse) .OrderByDescending(b => b.IsUse) .ToList(); flag = bankAccountsInfoList.Count > 0; foreach (var bankAccountsInfo in bankAccountsInfoList) { var childNode = CreateNode( (bankAccountsInfo.IsUse ? "" : "【停用】") + bankAccountsInfo.BankName + " - " + bankAccountsInfo.AccountsName + "[" + GetBankAccountsCount(bankAccountsInfo.BankAccountsId).ToString("N") + "]", false, bankAccountsInfo.BankAccountsId.ToString(), "BankAccount"); node.Nodes.Add(childNode); } } else { flag = false; } } } } return(flag); }
/// <summary> /// <see cref="ITreeNodeEntity{T}"/>를 구현한 엔티티들을 표현할 TreeNode를 생성하여 TreeView에 추가합니다. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="parent">부모 노드 또는 TreeView</param> /// <param name="nodeFactory">TreeNode를 생성하는 Factory 함수</param> /// <param name="findNodeFunc">기존 TreeView에서 엔티티와 관련된 Node를 찾는 함수</param> /// <param name="nodeAddedAction">TreeNode 하나를 추가할 때마다 수행하는 Action</param> /// <param name="items">엔티티</param> /// <param name="includeChildren">엔티티의 자손들도 Binding 할 것인가?</param> public static void BuildTreeNodes <T>(this IRadTreeNodeContainer parent, Func <T, RadTreeNode> nodeFactory, Func <T, RadTreeNode> findNodeFunc, Action <T, RadTreeNode> nodeAddedAction, IEnumerable <T> items, bool includeChildren) where T : class, ITreeNodeEntity <T> { if (items.IsEmptySequence()) { return; } parent.ShouldNotBeNull("parent"); nodeFactory.ShouldNotBeNull("nodeFactory"); findNodeFunc.ShouldNotBeNull("findNodeFunc"); RadTreeNode parentNode = null; foreach (T item in items) { // 이미 관련 노드가 있다면 추가하지 않습니다. if (findNodeFunc(item) != null) { continue; } if (IsDebugEnabled) { log.Debug(@"엔티티를 TreeNode로 빌드하여, TreeView에 추가합니다... item=[{0}]", item); } var childNode = nodeFactory(item); if (item.Parent != null) { parentNode = findNodeFunc(item.Parent); } if (parentNode != null) { // 부모 노드가 이미 TreeView에 추가되어 있다면, 부모 노드에 자식으로 추가합니다. parentNode.Nodes.Add(childNode); } else { // 부모 노드가 없다면, parent에 추가한다. parent.Nodes.Add(childNode); } if (IsDebugEnabled) { log.Debug(@"엔티티를 TreeNode로 빌드하여, TreeView에 추가했습니다!!!. childNode=[{0}]", childNode); } if (nodeAddedAction != null) { nodeAddedAction(item, childNode); } // 자식 노드들이 있고, 추가해야 한다면 DepthFirst 방식으로 추가합니다. // if (includeChildren && item.GetChildCount() > 0) { BuildTreeNodes(parentNode ?? parent, nodeFactory, findNodeFunc, nodeAddedAction, item.Children, true); } } }