/// <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();
}
