/// <summary> /// Get the visible node which matches the given data. /// </summary> /// <param name="nodes">nodes collection</param> /// <param name="data">data.</param> /// <returns>visible node.</returns> internal TreeNode GetVisibleNode(TreeNodes nodes, object data) { TreeNode treeNode = null; foreach (var node in nodes) { if (node.Item == data) { if (!node.IsFiltered) { treeNode = node; } break; } else { if (!node.IsFiltered && node.IsExpanded) { treeNode = GetVisibleNode(node.ChildNodes, data); } if (treeNode != null) { break; } } } return(treeNode); }
/// <summary> /// Validates the CheckBoxProperty value by considering selection mode. /// </summary> /// <param name="nodes">specifies the tree node collection.</param> internal void ValidateCheckBoxPropertyValue(TreeNodes nodes) { if (string.IsNullOrEmpty(treeGrid.CheckBoxMappingName)) { return; } if (treeGrid.CheckBoxSelectionMode == CheckBoxSelectionMode.Default) { return; } var list = nodes.Where(i => i.IsChecked == true); if (treeGrid.SelectionMode == GridSelectionMode.Single) { if (list.Count() > 1) { throw new Exception("Not possible to have IsChecked as true for more than one item when selection mode is single"); } if (list.Any() && treeGrid.SelectionController.SelectedRows.Any(r => r.Node != list.FirstOrDefault())) { throw new Exception("Not possible to have IsChecked as true for more than one item when selection mode is single"); } } else if (treeGrid.SelectionMode == GridSelectionMode.None) { if (list.Any()) { throw new Exception("Not possible to have IsChecked as true for more than one item when selection mode is None"); } } }
internal TreeNode FindParentNode(TreeNodes nodes, TreeNode tempNode) { TreeNode parentNode = null; var index = nodes.nodeList.BinarySearch(tempNode, SortComparer); if (index < 0) { foreach (var node in nodes) { if (node.IsExpanded || node.ChildNodes.Any()) { parentNode = FindParentNode(node.ChildNodes, tempNode); if (parentNode != null) { break; } } } } else { parentNode = nodes[index]; } return(parentNode); }
internal TreeNode FindParentNode(TreeNodes nodes, object childValue) { TreeNode parentNode = null; foreach (var node in nodes) { var record = node.Item; object parentValue = propertyAccessProvider.GetValue(record, parentPropertyName); // if (IsEqual(parentValue, childValue)) if (!IsEqual(SelfRelationRootValue, childValue, true) && IsEqual(parentValue, childValue)) { parentNode = node; break; } } if (parentNode == null) { foreach (var node in nodes) { if (node.IsExpanded || node.ChildNodes.Any()) { parentNode = FindParentNode(node.ChildNodes, childValue); if (parentNode != null) { break; } } } } return(parentNode); }
internal void AddTreeNodes(TreeNode parentNode, TreeNodes nodes) { foreach (var node in nodes) { AddNode(parentNode, node, parentNode == null ? Nodes.RootNodes.Count : parentNode.ChildNodes.Count); } }
private TreeNodes CopyTreeNodes(TreeNodes treeNodes) { var nodes = new TreeNodes(); nodes.nodeList = treeNodes.nodeList.ToList(); nodes.sourceList = treeNodes.sourceList.ToList(); return(nodes); }
internal TreeNode(object item, int level, bool isExpanded, TreeNode parentNode, Func <TreeGridView> getView) { Level = level; Item = item; ParentNode = parentNode; ChildNodes = new TreeNodes(); this.isExpanded = isExpanded; isDirty = false; maxLevel = level; GetView = getView; }
/// <summary> /// Finds the next visible node. /// </summary> /// <param name="nodes">nodes collection.</param> /// <param name="node">specific node.</param> /// <returns>visible node.</returns> private TreeNode FindNode(TreeNodes nodes, TreeNode node) { int nodeIndex = nodes.IndexOf(node); for (int i = nodeIndex + 1; i < nodes.Count; i++) { if (!nodes[i].IsFiltered) { return(nodes[i]); } } return(null); }
public TreeNodesEnumerator(TreeNodes nodes) { this.RootNodes = nodes; this.Helper = new TreeNodesTraversalHelper(RootNodes); if (nodes.Count == 0) { this.next = null; } else { next = nodes.FirstOrDefault(n => !n.IsFiltered); } }
private TreeNodes GetNodeCollection(object parentValue) { var nodes = new TreeNodes(); foreach (object record in SourceCollection) { object childValue = propertyAccessProvider.GetValue(record, childPropertyName); if (IsEqual(parentValue, childValue)) { var node = FindNodefromData(null, record, true); if (node != null) { nodes.Add(node); } } } return(nodes); }
private bool FindNode(TreeNode node, TreeNodes nodes) { foreach (var treeNode in nodes) { if (treeNode.Equals(node)) { return(true); } if (treeNode.IsExpanded) { var found = FindNode(node, treeNode.ChildNodes); if (found) { return(true); } else { continue; } } } return(false); }
public TreeNode GetNode(TreeNodes treeNodes, int index) { TreeNode node = null; var nodes = treeNodes.Where(n => !n.IsFiltered); var actualIndex = index; foreach (TreeNode rootNode in nodes) { if (index <= 0) { node = rootNode; break; } else { if (rootNode != null && rootNode.IsExpanded) { var nodeCount = rootNode.GetYAmountCache(); if (index <= nodeCount - 1) { index--; node = GetNode(rootNode.ChildNodes, index); break; } else { index -= nodeCount; } } else { index--; } } } return(node); }
internal override void ValidateCheckBoxPropertyValue(TreeNodes nodes) { TreeGrid.NodeCheckBoxController.ValidateCheckBoxPropertyValue(nodes); }
public TreeNode() { ChildNodes = new TreeNodes(); isDirty = false; maxLevel = level; }
public void Dispose() { this.RootNodes = null; }
public TreeNodeCollection() { RootNodes = new TreeNodes(); helper = new TreeNodesTraversalHelper(this.RootNodes); }
private void UpdateNodesOnParentPropertyChange(object sender, TreeNode treeNode, PropertyChangedEventArgs e) { if (SelfRelationUpdateMode.HasFlag(SelfRelationUpdateMode.None)) { return; } var parentValue = propertyAccessProvider.GetValue(sender, parentPropertyName); if (treeNode != null && treeNode.ChildNodes.Any()) { object childValue = propertyAccessProvider.GetValue(treeNode.ChildNodes[0].Item, childPropertyName); // checking parent property is changed or not (by comparing child and parent property values) if (IsEqual(parentValue, childValue)) { return; } } if ((e == null && SelfRelationUpdateMode.HasFlag(SelfRelationUpdateMode.MoveOnEdit)) || (e != null && SelfRelationUpdateMode.HasFlag(SelfRelationUpdateMode.MoveOnPropertyChange))) { TreeNodes nodeCollection = null; object childValue = propertyAccessProvider.GetValue(sender, childPropertyName); // if (!IsEqual(parentValue, childValue) || (IsEqual(parentValue, childValue) && SelfRelationRootValue == DependencyProperty.UnsetValue)) if (!IsEqual(parentValue, childValue) || SelfRelationRootValue == DependencyProperty.UnsetValue) { // Root value not set case. Remove root nodes if it has child property value equals to parent property value. nodeCollection = RemoveNodesHavingChildPropertyEqualsToNewParentProperty(parentValue, treeNode); } // For property change case only if (treeNode == null) { var childItems = GetChildSourceFromParentID(SelfRelationRootValue, null, true); foreach (var childItem in childItems) { CanAddRootNode(childItem, true); } } else { if (SelfRelationRootValue == DependencyProperty.UnsetValue) { AddRootNodesFromRemovedParent(treeNode); // When parent and child value both are same, need to add the child nodes(removed from root nodes) having child property equal to parent property. if (nodeCollection != null && nodeCollection.Any() && IsEqual(parentValue, childValue) && SelfRelationRootValue == DependencyProperty.UnsetValue) { nodeCollection.Remove(treeNode); if (treeNode.IsExpanded || treeNode.ChildNodes.Any()) { AddTreeNodes(treeNode, nodeCollection); } } } else { ResetNodes(treeNode, true); } // After parent property name is changed, if node is expanded and dont have child node, need to populate child nodes based on new parent property value. if (treeNode.IsExpanded && !treeNode.ChildNodes.Any()) { TreeGrid.TreeGridModel.ExpandNode(treeNode, true); } else { IsChildNodeAvailable(treeNode); var rowIndex = TreeGrid.ResolveToRowIndex(treeNode); TreeGrid.UpdateDataRow(rowIndex); } } } }
public TreeNodesTraversalHelper(TreeNodes Nodes) { this.RootNodes = Nodes; }