public int GetNodeLevel(MultiSelectTreeNode node)
{
int num = 0;
while ((node = node.Parent) != null)
{
num++;
}
return(num);
}
private MultiSelectTreeNode GetLastVisibleNode()
{
MultiSelectTreeNode nextVisibleNode = Nodes[0];
while (nextVisibleNode.NextVisibleNode != null)
{
nextVisibleNode = nextVisibleNode.NextVisibleNode;
}
return(nextVisibleNode);
}
public MultiSelectTreeNode GetRootParent(MultiSelectTreeNode child)
{
MultiSelectTreeNode parent = child;
while (parent.Parent != null)
{
parent = parent.Parent;
}
return(parent);
}
private bool IsChildOf(MultiSelectTreeNode child, MultiSelectTreeNode parent)
{
for (MultiSelectTreeNode node = child; node != null; node = node.Parent)
{
if (node == parent)
{
return(true);
}
}
return(false);
}
private int GetNumberOfVisibleNodes()
{
int num = 0;
for (MultiSelectTreeNode node = Nodes[0]; node != null; node = node.NextVisibleNode)
{
if (node.IsVisible)
{
num++;
}
}
return(num);
}
protected override void OnMouseUp(MouseEventArgs e)
{
if (!_nodeProcessedOnMouseDown)
{
MultiSelectTreeNode nodeAt = (MultiSelectTreeNode)base.GetNodeAt(e.X, e.Y);
if (IsClickOnNode(nodeAt, e))
{
ProcessNodeRange(_mostRecentSelectedNode, nodeAt, e, Control.ModifierKeys, TreeViewAction.ByMouse, true);
}
}
_nodeProcessedOnMouseDown = false;
base.OnMouseUp(e);
}
private void UnselectAllNodesNotBelongingDirectlyToParent(MultiSelectTreeNode parent, TreeViewAction tva)
{
ArrayList list = new ArrayList();
foreach (MultiSelectTreeNode node in _selectedNodes)
{
if (node.Parent != parent)
{
list.Add(node);
}
}
foreach (MultiSelectTreeNode node2 in list)
{
SelectNode(node2, false, tva);
}
}
protected override void OnMouseDown(MouseEventArgs e)
{
_keysStartNode = null;
intMouseClicks = e.Clicks;
MultiSelectTreeNode nodeAt = (MultiSelectTreeNode)base.GetNodeAt(e.X, e.Y);
if (nodeAt != null)
{
if (!IsPlusMinusClicked(nodeAt, e) && (nodeAt != null) && IsClickOnNode(nodeAt, e) && !IsNodeSelected(nodeAt))
{
_nodeProcessedOnMouseDown = true;
ProcessNodeRange(_mostRecentSelectedNode, nodeAt, e, Control.ModifierKeys, TreeViewAction.ByMouse, true);
}
base.OnMouseDown(e);
}
}
private bool IsTreeViewEnabled()
{
// iterate through ancestors to find treeview as this node might have only just been
// added and therefore the TreeView property will still return null.
MultiSelectTreeNode node = this;
while (node != null)
{
if (node.TreeView != null)
{
return(node.TreeView.Enabled);
}
node = node.Parent;
}
return(true);
}
private void UnselectAllNodesExceptNode(MultiSelectTreeNode nodeKeepSelected, TreeViewAction tva)
{
List <MultiSelectTreeNode> list = new List <MultiSelectTreeNode>();
foreach (MultiSelectTreeNode node in _selectedNodes)
{
if (nodeKeepSelected == null)
{
list.Add(node);
}
else if ((nodeKeepSelected != null) && (node != nodeKeepSelected))
{
list.Add(node);
}
}
foreach (MultiSelectTreeNode node2 in list)
{
SelectNode(node2, false, tva);
}
}
private void UnselectNodesOutsideRange(MultiSelectTreeNode startNode, MultiSelectTreeNode endNode, TreeViewAction tva)
{
if (startNode != null && endNode != null)
{
MultiSelectTreeNode node = null;
MultiSelectTreeNode node2 = null;
if (startNode.Bounds.Y < endNode.Bounds.Y)
{
node = startNode;
node2 = endNode;
}
else
{
node = endNode;
node2 = startNode;
}
MultiSelectTreeNode tn = node;
while (tn != null)
{
tn = tn.PrevVisibleNode;
if (tn != null)
{
SelectNode(tn, false, tva);
}
}
tn = node2;
while (tn != null)
{
tn = tn.NextVisibleNode;
if (tn != null)
{
SelectNode(tn, false, tva);
}
}
}
}
private bool SelectNode(MultiSelectTreeNode node, bool select, TreeViewAction tva)
{
bool selected = false;
if (node == null)
{
return(false);
}
if (select)
{
if (!IsNodeSelected(node))
{
MultiSelectTreeViewCancelEventArgs e = new MultiSelectTreeViewCancelEventArgs(node, false, tva);
OnBeforeSelect(e);
if (e.Cancel)
{
return(false);
}
_selectedNodes.Add(node);
selected = true;
_selectionChanged = true;
OnAfterSelect(new TreeViewEventArgs(node, tva));
}
_mostRecentSelectedNode = node;
return(selected);
}
if (IsNodeSelected(node))
{
OnBeforeDeselect(new TreeViewEventArgs(node));
_selectedNodes.Remove(node);
_selectionChanged = true;
OnAfterDeselect(new TreeViewEventArgs(node));
}
return(selected);
}
public void UpdateCheckboxVisibility(MultiSelectTreeNode treeNode)
{
if (CheckBoxes && treeNode.Handle != IntPtr.Zero && Handle != IntPtr.Zero)
{
NativeMethods.TVITEM tvItem = new NativeMethods.TVITEM();
tvItem.hItem = treeNode.Handle;
tvItem.mask = NativeMethods.TVIF_STATE;
tvItem.stateMask = NativeMethods.TVIS_STATEIMAGEMASK;
tvItem.state = 0;
if (treeNode.ShowCheckBox && treeNode.Checked)
{
tvItem.state = 2 << 12;
}
else if (treeNode.ShowCheckBox)
{
tvItem.state = 1 << 12;
}
IntPtr lparam = Marshal.AllocHGlobal(Marshal.SizeOf(tvItem));
Marshal.StructureToPtr(tvItem, lparam, false);
Win32.SendMessage(Handle, NativeMethods.TVM_SETITEM, IntPtr.Zero, lparam);
}
}
private bool IsNodeSelected(MultiSelectTreeNode node)
{
return(node != null && _selectedNodes.Contains(node));
}
public MultiSelectTreeViewCancelEventArgs(MultiSelectTreeNode node, bool cancel, TreeViewAction action)
: base(cancel)
{
_node = node;
_action = action;
}
/// <summary>
/// Processes a node range.
/// </summary>
/// <param name="startNode">Start node of range.</param>
/// <param name="endNode">End node of range.</param>
/// <param name="e">MouseEventArgs.</param>
/// <param name="keys">Keys.</param>
/// <param name="tva">TreeViewAction.</param>
/// <param name="allowStartEdit">True if node can go to edit mode, false if not.</param>
private void ProcessNodeRange(MultiSelectTreeNode startNode, MultiSelectTreeNode endNode, MouseEventArgs e, Keys keys, TreeViewAction tva, bool allowStartEdit)
{
_selectionChanged = false; // prepare for OnSelectionsChanged
if (e.Button == MouseButtons.Left)
{
_wasDoubleClick = (intMouseClicks == 2);
MultiSelectTreeNode tnTemp = null;
int intNodeLevelStart;
if (((keys & Keys.Control) == 0) && ((keys & Keys.Shift) == 0))
{
// CTRL and SHIFT not held down
_selectionMirrorPoint = endNode;
int intNumberOfSelectedNodes = SelectedNodes.Count;
// If it was a double click, select node and suspend further processing
if (_wasDoubleClick)
{
base.OnMouseDown(e);
return;
}
if (!IsPlusMinusClicked(endNode, e))
{
bool blnNodeWasSelected = false;
if (IsNodeSelected(endNode))
{
blnNodeWasSelected = true;
}
UnselectAllNodesExceptNode(endNode, tva);
SelectNode(endNode, true, tva);
if ((blnNodeWasSelected) && (LabelEdit) && (allowStartEdit) && (!_wasDoubleClick) && (intNumberOfSelectedNodes <= 1))
{
// Node should be put in edit mode
_nodeToStartEditOn = endNode;
System.Threading.ThreadPool.QueueUserWorkItem(StartEdit);
}
}
}
else if (((keys & Keys.Control) != 0) && ((keys & Keys.Shift) == 0))
{
// CTRL held down
_selectionMirrorPoint = null;
if (!IsNodeSelected(endNode))
{
switch (_selectionMode)
{
case TreeViewSelectionMode.SingleSelect:
UnselectAllNodesExceptNode(endNode, tva);
break;
case TreeViewSelectionMode.MultiSelectSameRootBranch:
MultiSelectTreeNode tnAbsoluteParent2 = GetRootParent(endNode);
UnselectAllNodesNotBelongingToParent(tnAbsoluteParent2, tva);
break;
case TreeViewSelectionMode.MultiSelectSameLevel:
UnselectAllNodesNotBelongingToLevel(GetNodeLevel(endNode), tva);
break;
case TreeViewSelectionMode.MultiSelectSameLevelAndRootBranch:
MultiSelectTreeNode tnAbsoluteParent = GetRootParent(endNode);
UnselectAllNodesNotBelongingToParent(tnAbsoluteParent, tva);
UnselectAllNodesNotBelongingToLevel(GetNodeLevel(endNode), tva);
break;
case TreeViewSelectionMode.MultiSelectSameParent:
MultiSelectTreeNode tnParent = endNode.Parent;
UnselectAllNodesNotBelongingDirectlyToParent(tnParent, tva);
break;
}
SelectNode(endNode, true, tva);
}
else
{
SelectNode(endNode, false, tva);
}
}
else if (((keys & Keys.Control) == 0) && ((keys & Keys.Shift) != 0))
{
// SHIFT pressed
if (_selectionMirrorPoint == null)
{
_selectionMirrorPoint = startNode;
}
switch (_selectionMode)
{
case TreeViewSelectionMode.SingleSelect:
UnselectAllNodesExceptNode(endNode, tva);
SelectNode(endNode, true, tva);
break;
case TreeViewSelectionMode.MultiSelectSameRootBranch:
MultiSelectTreeNode tnAbsoluteParentStartNode = GetRootParent(startNode);
tnTemp = startNode;
// Check each visible node from startNode to endNode and select it if needed
while ((tnTemp != null) && (tnTemp != endNode))
{
if (startNode.Bounds.Y > endNode.Bounds.Y)
{
tnTemp = tnTemp.PrevVisibleNode;
}
else
{
tnTemp = tnTemp.NextVisibleNode;
}
if (tnTemp != null)
{
MultiSelectTreeNode tnAbsoluteParent = GetRootParent(tnTemp);
if (tnAbsoluteParent == tnAbsoluteParentStartNode)
{
SelectNode(tnTemp, true, tva);
}
}
}
UnselectAllNodesNotBelongingToParent(tnAbsoluteParentStartNode, tva);
UnselectNodesOutsideRange(_selectionMirrorPoint, endNode, tva);
break;
case TreeViewSelectionMode.MultiSelectSameLevel:
intNodeLevelStart = GetNodeLevel(startNode);
tnTemp = startNode;
// Check each visible node from startNode to endNode and select it if needed
while ((tnTemp != null) && (tnTemp != endNode))
{
if (startNode.Bounds.Y > endNode.Bounds.Y)
{
tnTemp = tnTemp.PrevVisibleNode;
}
else
{
tnTemp = tnTemp.NextVisibleNode;
}
if (tnTemp != null)
{
int intNodeLevel = GetNodeLevel(tnTemp);
if (intNodeLevel == intNodeLevelStart)
{
SelectNode(tnTemp, true, tva);
}
}
}
UnselectAllNodesNotBelongingToLevel(intNodeLevelStart, tva);
UnselectNodesOutsideRange(_selectionMirrorPoint, endNode, tva);
break;
case TreeViewSelectionMode.MultiSelectSameLevelAndRootBranch:
MultiSelectTreeNode tnAbsoluteParentStart = GetRootParent(startNode);
intNodeLevelStart = GetNodeLevel(startNode);
tnTemp = startNode;
// Check each visible node from startNode to endNode and select it if needed
while ((tnTemp != null) && (tnTemp != endNode))
{
if (startNode.Bounds.Y > endNode.Bounds.Y)
{
tnTemp = tnTemp.PrevVisibleNode;
}
else
{
tnTemp = tnTemp.NextVisibleNode;
}
if (tnTemp != null)
{
int intNodeLevel = GetNodeLevel(tnTemp);
MultiSelectTreeNode tnAbsoluteParent = GetRootParent(tnTemp);
if ((intNodeLevel == intNodeLevelStart) && (tnAbsoluteParent == tnAbsoluteParentStart))
{
SelectNode(tnTemp, true, tva);
}
}
}
UnselectAllNodesNotBelongingToParent(tnAbsoluteParentStart, tva);
UnselectAllNodesNotBelongingToLevel(intNodeLevelStart, tva);
UnselectNodesOutsideRange(_selectionMirrorPoint, endNode, tva);
break;
case TreeViewSelectionMode.MultiSelect:
SelectNodesInsideRange(_selectionMirrorPoint, endNode, tva);
UnselectNodesOutsideRange(_selectionMirrorPoint, endNode, tva);
break;
case TreeViewSelectionMode.MultiSelectSameParent:
MultiSelectTreeNode tnParentStartNode = startNode.Parent;
tnTemp = startNode;
// Check each visible node from startNode to endNode and select it if needed
while ((tnTemp != null) && (tnTemp != endNode))
{
if (startNode.Bounds.Y > endNode.Bounds.Y)
{
tnTemp = tnTemp.PrevVisibleNode;
}
else
{
tnTemp = tnTemp.NextVisibleNode;
}
if (tnTemp != null)
{
MultiSelectTreeNode tnParent = tnTemp.Parent;
if (tnParent == tnParentStartNode)
{
SelectNode(tnTemp, true, tva);
}
}
}
UnselectAllNodesNotBelongingDirectlyToParent(tnParentStartNode, tva);
UnselectNodesOutsideRange(_selectionMirrorPoint, endNode, tva);
break;
}
}
else if (((keys & Keys.Control) != 0) && ((keys & Keys.Shift) != 0))
{
// SHIFT AND CTRL pressed
switch (_selectionMode)
{
case TreeViewSelectionMode.SingleSelect:
UnselectAllNodesExceptNode(endNode, tva);
SelectNode(endNode, true, tva);
break;
case TreeViewSelectionMode.MultiSelectSameRootBranch:
MultiSelectTreeNode tnAbsoluteParentStartNode = GetRootParent(startNode);
tnTemp = startNode;
// Check each visible node from startNode to endNode and select it if needed
while ((tnTemp != null) && (tnTemp != endNode))
{
if (startNode.Bounds.Y > endNode.Bounds.Y)
{
tnTemp = tnTemp.PrevVisibleNode;
}
else
{
tnTemp = tnTemp.NextVisibleNode;
}
if (tnTemp != null)
{
MultiSelectTreeNode tnAbsoluteParent = GetRootParent(tnTemp);
if (tnAbsoluteParent == tnAbsoluteParentStartNode)
{
SelectNode(tnTemp, true, tva);
}
}
}
UnselectAllNodesNotBelongingToParent(tnAbsoluteParentStartNode, tva);
break;
case TreeViewSelectionMode.MultiSelectSameLevel:
intNodeLevelStart = GetNodeLevel(startNode);
tnTemp = startNode;
// Check each visible node from startNode to endNode and select it if needed
while ((tnTemp != null) && (tnTemp != endNode))
{
if (startNode.Bounds.Y > endNode.Bounds.Y)
{
tnTemp = tnTemp.PrevVisibleNode;
}
else
{
tnTemp = tnTemp.NextVisibleNode;
}
if (tnTemp != null)
{
int intNodeLevel = GetNodeLevel(tnTemp);
if (intNodeLevel == intNodeLevelStart)
{
SelectNode(tnTemp, true, tva);
}
}
}
UnselectAllNodesNotBelongingToLevel(intNodeLevelStart, tva);
break;
case TreeViewSelectionMode.MultiSelectSameLevelAndRootBranch:
MultiSelectTreeNode tnAbsoluteParentStart = GetRootParent(startNode);
intNodeLevelStart = GetNodeLevel(startNode);
tnTemp = startNode;
// Check each visible node from startNode to endNode and select it if needed
while ((tnTemp != null) && (tnTemp != endNode))
{
if (startNode.Bounds.Y > endNode.Bounds.Y)
{
tnTemp = tnTemp.PrevVisibleNode;
}
else
{
tnTemp = tnTemp.NextVisibleNode;
}
if (tnTemp != null)
{
int intNodeLevel = GetNodeLevel(tnTemp);
MultiSelectTreeNode tnAbsoluteParent = GetRootParent(tnTemp);
if ((intNodeLevel == intNodeLevelStart) && (tnAbsoluteParent == tnAbsoluteParentStart))
{
SelectNode(tnTemp, true, tva);
}
}
}
UnselectAllNodesNotBelongingToParent(tnAbsoluteParentStart, tva);
UnselectAllNodesNotBelongingToLevel(intNodeLevelStart, tva);
break;
case TreeViewSelectionMode.MultiSelect:
tnTemp = startNode;
// Check each visible node from startNode to endNode and select it if needed
while ((tnTemp != null) && (tnTemp != endNode))
{
if (startNode.Bounds.Y > endNode.Bounds.Y)
{
tnTemp = tnTemp.PrevVisibleNode;
}
else
{
tnTemp = tnTemp.NextVisibleNode;
}
if (tnTemp != null)
{
SelectNode(tnTemp, true, tva);
}
}
break;
case TreeViewSelectionMode.MultiSelectSameParent:
MultiSelectTreeNode tnParentStartNode = startNode.Parent;
tnTemp = startNode;
// Check each visible node from startNode to endNode and select it if needed
while ((tnTemp != null) && (tnTemp != endNode))
{
if (startNode.Bounds.Y > endNode.Bounds.Y)
{
tnTemp = tnTemp.PrevVisibleNode;
}
else
{
tnTemp = tnTemp.NextVisibleNode;
}
if (tnTemp != null)
{
MultiSelectTreeNode tnParent = tnTemp.Parent;
if (tnParent == tnParentStartNode)
{
SelectNode(tnTemp, true, tva);
}
}
}
UnselectAllNodesNotBelongingDirectlyToParent(tnParentStartNode, tva);
break;
}
}
}
else if (e.Button == MouseButtons.Right)
{
// if right mouse button clicked, clear selection and select right-clicked node
if (!IsNodeSelected(endNode))
{
UnselectAllNodes(tva);
SelectNode(endNode, true, tva);
}
}
OnSelectionsChanged();
}
protected override void OnKeyDown(KeyEventArgs e)
{
Keys none = Keys.None;
switch (e.Modifiers)
{
case Keys.Shift:
case Keys.Control:
case (Keys.Control | Keys.Shift):
none = Keys.Shift;
if (_keysStartNode == null)
{
_keysStartNode = _mostRecentSelectedNode;
}
break;
default:
_keysStartNode = null;
break;
}
int intNumber = 0;
MultiSelectTreeNode endNode = null;
switch (e.KeyCode)
{
case Keys.Prior:
intNumber = GetNumberOfVisibleNodes();
endNode = GetNextTreeNode(_mostRecentSelectedNode, false, intNumber);
break;
case Keys.Next:
intNumber = GetNumberOfVisibleNodes();
endNode = GetNextTreeNode(_mostRecentSelectedNode, true, intNumber);
break;
case Keys.End:
endNode = GetLastVisibleNode();
break;
case Keys.Home:
endNode = Nodes[0];
break;
case Keys.Left:
if (_mostRecentSelectedNode.IsExpanded)
{
_mostRecentSelectedNode.Collapse();
}
else
{
endNode = _mostRecentSelectedNode.Parent;
}
break;
case Keys.Up:
endNode = _mostRecentSelectedNode.PrevVisibleNode;
break;
case Keys.Right:
if (_mostRecentSelectedNode.IsExpanded)
{
endNode = _mostRecentSelectedNode.NextVisibleNode;
if (endNode != null && !endNode.Parent.Equals(_mostRecentSelectedNode))
{
endNode = null;
}
}
else
{
_mostRecentSelectedNode.Expand();
}
break;
case Keys.Down:
endNode = _mostRecentSelectedNode.NextVisibleNode;
break;
default:
base.OnKeyDown(e);
return;
}
if (endNode != null)
{
ProcessNodeRange(_keysStartNode, endNode, new MouseEventArgs(MouseButtons.Left, 1, Cursor.Position.X, Cursor.Position.Y, 0), none, TreeViewAction.ByKeyboard, false);
_mostRecentSelectedNode = endNode;
}
if (_mostRecentSelectedNode != null)
{
MultiSelectTreeNode tnMostRecentSelectedNode = null;
switch (e.KeyCode)
{
case Keys.Prior:
tnMostRecentSelectedNode = GetNextTreeNode(_mostRecentSelectedNode, false, intNumber - 2);
break;
case Keys.Next:
tnMostRecentSelectedNode = GetNextTreeNode(_mostRecentSelectedNode, true, intNumber - 2);
break;
case Keys.End:
case Keys.Home:
tnMostRecentSelectedNode = _mostRecentSelectedNode;
break;
case Keys.Up:
tnMostRecentSelectedNode = GetNextTreeNode(_mostRecentSelectedNode, false, 5);
break;
case Keys.Down:
tnMostRecentSelectedNode = GetNextTreeNode(_mostRecentSelectedNode, true, 5);
break;
}
if (tnMostRecentSelectedNode != null)
{
if (((e.KeyData & Keys.Control) != 0) || ((e.KeyData & Keys.Shift) != 0))
{
SuspendLayout();
int prevScrollPos = HScrollPos;
tnMostRecentSelectedNode.EnsureVisible();
HScrollPos = prevScrollPos;
ResumeLayout();
}
else
{
tnMostRecentSelectedNode.EnsureVisible();
}
}
}
base.OnKeyDown(e);
}
private bool IsPlusMinusClicked(MultiSelectTreeNode node, MouseEventArgs e)
{
return(e.X < (20 + (GetNodeLevel(node) * 20)) - HScrollPos);
}
private bool IsClickOnNode(MultiSelectTreeNode node, MouseEventArgs e)
{
return(node != null && e.X < node.Bounds.X + node.Bounds.Width);
}
