/// <summary> /// Removes a node (and it's sub-tree) if it is hidden or any children which are hidden. /// </summary> /// <remarks> /// Hidden(ness) is determined by the state of the TmNode data. /// </remarks> internal void Hide() { if (TmNode.IsHidden) { Remove(); } else { TmTreeNode[] copyNodes = new TmTreeNode[Nodes.Count]; Nodes.CopyTo(copyNodes, 0); foreach (TmTreeNode node in copyNodes) { node.Hide(); } } }
/// <summary> /// Removes a node (and it's sub-tree) if it is not visible or any children which are not visible. /// </summary> /// <remarks> /// Visibility is determined by the state of the TmNode data. /// </remarks> internal void Filter() { if (!TmNode.IsVisible) { Remove(); } else { TmTreeNode[] copyNodes = new TmTreeNode[Nodes.Count]; Nodes.CopyTo(copyNodes, 0); foreach (TmTreeNode node in copyNodes) { node.Filter(); } } }
internal void UnselectNode(TmTreeNode node) { if (_selectedNodes.Contains(node)) { InternalUnselectNode(node); // the following test always fails now, see InternalUnselectNode(node) // The body of the loop seems like a good idea (select the previously selected) // however since it triggers an AfterSelect Event, it cascadingly unselects all. //if (SelectedNode == node) //{ // if (_selectedNodes.Count == 0) // ClearSelectedNode(); // else // { // OkToChangeSelection = true; // SelectedNode = _selectedNodes.Last(); // OkToChangeSelection = false; // } //} } }
//Does not cause any SelectionEvents private void InternalSelectNode(TmTreeNode node) { //If I am not going to include subThemes in selection set, //then I need to ensure that they are not highlighted //if I can't highlight them, they should not be select, //then how can I see thier metadata //better to add them to the set, and then filter later. if (node != null && !_selectedNodes.Contains(node)) // && !node.TmNode.IsSubTheme) { if (_selectedNodes.Count > 0) RemoveSelectedAncestors(node); if (_selectedNodes.Count > 0) RemoveSelectedDescendent(node); _selectedNodes.Add(node); node.TmNode.IsSelected = true; } }
//called by me or a client, so I will honor it. //I need to distinguish from calls by framework // particularly the one that selects the first node if selection is null internal void SelectNode(TmTreeNode node) { OkToChangeSelection = true; SelectedNode = node; //will trigger OnAfterSelect method to do rest of work. OkToChangeSelection = false; }
public void HideHidden() { TmTreeNode[] copyNodes = new TmTreeNode[Nodes.Count]; Nodes.CopyTo(copyNodes, 0); foreach (TmTreeNode node in copyNodes) node.Hide(); }
private void ShiftSelect(TmTreeNode node) { if (_selectedNodes.Contains(node)) { //Do not change selection set, by default new node will be the selected node } else { InternalSelectNode(node); TmTreeNode closestSibling = FindClosestSelectedSibling(node); if (closestSibling != null) { int myIndex = node.Index; int siblingIndex = closestSibling.Index; int min = (myIndex < siblingIndex) ? myIndex : siblingIndex; int max = (myIndex > siblingIndex) ? myIndex : siblingIndex; TreeNodeCollection nc = (node.Parent == null) ? Nodes : node.Parent.Nodes; for (int i = min + 1; i < max; i++) InternalSelectNode(nc[i] as TmTreeNode); } } }
/// <summary> /// Remove any ancestors in the list of selected nodes. /// </summary> /// <remarks> /// The maximum is one ancestor in the list, because /// each insert removes its ancestors. /// The list of ancestors is presumed to be shorter than the list of selected nodes /// </remarks> /// <param name="node"></param> private void RemoveSelectedAncestors(TmTreeNode node) { TmTreeNode parent = node.Parent as TmTreeNode; if (parent != null) { if (parent.TmNode.IsSelected) InternalUnselectNode(parent); else RemoveSelectedAncestors(parent); } }
public void UpdateNode(TmTreeNode node, bool recurse) { Debug.Assert(node != null, "Null argument exception for node"); if (node == null) return; BeginUpdate(); node.UpdateProperties(); if (recurse) { //Throw away and restart option node.Nodes.Clear(); foreach (TmNode child in node.TmNode.Children) { node.Nodes.Add(new TmTreeNode(child)); } // sync node.Nodes to node.TmNode.Children adding/removing nodes then update all //node.SyncNodes(node.TmNode.Children); //foreach (TreeNode child in node.Nodes) //{ // UpdateNode(child as TmTreeNode, true); //} } //Sort(); EndUpdate(); }
public void RemoveThemeListNode(TmTreeNode nodeToRemove) { Debug.Assert(nodeToRemove != null, "The themelist node is not null"); if (nodeToRemove == null) return; if (RootNodes.Contains(nodeToRemove.TmNode)) RootNodes.Remove(nodeToRemove.TmNode); if (Nodes.Contains(nodeToRemove)) Nodes.Remove(nodeToRemove); }
public TmTreeNode Insert(int index, TmNode inNode, TreeNode atNode) { if (inNode == null) throw new ArgumentNullException("inNode"); TreeNode newParentNode = atNode ?? SelectedNode; TreeNodeCollection nodes = newParentNode == null ? Nodes : newParentNode.Nodes; if (nodes == Nodes) RootNodes.Add(inNode); if (index < 0 || index > nodes.Count) index = nodes.Count; //FIXME - I think this is broken. // I am using index to place this TM node in a treeview, with no // check on the structure of the tree that the TM node lives in. TmTreeNode newNode = new TmTreeNode(inNode); nodes.Insert(index, newNode); return newNode; }
private TmTreeNode Add(TmNode node, TreeNodeCollection nodes) { if (node.IsHidden && !Settings.Default.ShowHiddenThemes) return null; TmTreeNode newNode = new TmTreeNode(node); nodes.Add(newNode); return newNode; }
/// <summary> /// Removes a node (and it's sub-tree) if it is hidden or any children which are hidden. /// </summary> /// <remarks> /// Hidden(ness) is determined by the state of the TmNode data. /// </remarks> internal void Hide() { if (TmNode.IsHidden) Remove(); else { var copyNodes = new TmTreeNode[Nodes.Count]; Nodes.CopyTo(copyNodes,0); foreach (TmTreeNode node in copyNodes) { node.Hide(); } } }
/// <summary> /// Removes a node (and it's sub-tree) if it is not visible or any children which are not visible. /// </summary> /// <remarks> /// Visibility is determined by the state of the TmNode data. /// </remarks> internal void Filter() { if (!TmNode.IsVisible) Remove(); else { var copyNodes = new TmTreeNode[Nodes.Count]; Nodes.CopyTo(copyNodes, 0); foreach (TmTreeNode node in copyNodes) { node.Filter(); } } }
/// <summary> /// Changes state of node and selected node list. /// Does not fire events or have any side effects. /// </summary> /// <param name="node"></param> private void InternalUnselectNode(TmTreeNode node) { _selectedNodes.Remove(node); node.TmNode.IsSelected = false; if (node == SelectedNode) SelectedNode = null; //will not fire any events. }
private TmTreeNode FindClosestSelectedSibling(TmTreeNode node) { if (node == null) throw new ArgumentNullException("node"); int myIndex = node.Index; TreeNodeCollection nodes = node.Parent == null ? Nodes : node.Parent.Nodes; TmTreeNode closestSibling = null; int smallestDelta = nodes.Count; for (int index = 0; index < nodes.Count; index++ ) { TmTreeNode sibling = nodes[index] as TmTreeNode; if (sibling != null && sibling.TmNode.IsSelected) { int delta = (index < myIndex) ? myIndex - index : index - myIndex; if (index != myIndex && delta < smallestDelta ) closestSibling = sibling; } } return closestSibling; }
private void ControlSelect(TmTreeNode node) { if (_selectedNodes.Contains(node)) // FIXME - find a way to unselect the SelectedNode // (code works fine for removing a node from _selectedNodes) // clicking on the SelectedNode does not fire an AfterSelect event // setting node to null in the MouseDown event, reselects node before AfterSelect event // setting SelectedNode to another node fires this event recursively InternalUnselectNode(node); else InternalSelectNode(node); }
/// <summary> /// Removes any descendents from the list of selected nodes. /// </summary> /// <remarks> /// There can be any number of descendents in the lists, but /// any descendents in the list will not have deeper /// descendents in the list. /// The list of selected nodes is presumed to be shorter than the set of descendents. /// Therefore recusively searching for selected descendents would be inefficient. /// </remarks> /// <param name="node"></param> private void RemoveSelectedDescendent(TmTreeNode node) { // I make a copy, since I cannot modify a collection while iterating. foreach (TmTreeNode selectedNode in _selectedNodes.ToList()) //add the path separator, so we do not remove siblings that have the same prefix if (selectedNode != node && selectedNode.FullPath.StartsWith(node.FullPath + node.TreeView.PathSeparator)) InternalUnselectNode(selectedNode); }
/// <summary> /// Prunes all nodes which are not visible from the tree. /// Visibility is determined by the data in the node tag. /// From the TreeView perspective this is a non-reversable operation. /// The original treeview should be cloned if it may needed. /// </summary> public void Filter() { TmTreeNode[] copyNodes = new TmTreeNode[Nodes.Count]; Nodes.CopyTo(copyNodes, 0); foreach (TmTreeNode node in copyNodes) node.Filter(); }