public static int GetVisibleNodeIndex(TLNode node)
{
if (node == null || node.IsVisible() == false || node.GetRootCollection() == null)
{
return(-1);
}
// Finding the node index is done by searching up the tree and use the visible node count from each node.
// First all previous siblings are searched, then when first sibling in the node collection is reached
// the node is switch to the parent node and the again a search is done up the sibling list.
// This way only higher up the tree are being iterated while nodes at the same level are skipped.
// Worst case scenario is if all nodes are at the same level. In that case the search is a linear search.
// adjust count for the visible count of the current node.
int count = -node.VisibleNodeCount;
while (node != null)
{
count += node.VisibleNodeCount;
if (node.PrevSibling != null)
{
node = node.PrevSibling;
}
else
{
node = node.Parent;
if (node != null)
{
count -= node.VisibleNodeCount - 1; // -1 is for the node itself
}
}
}
return(count);
}
public override void NotifyBeforeExpand(TLNode nodeToExpand, bool expanding)
{
if (!m_tree.DesignMode)
{
m_tree.OnNotifyBeforeExpand(nodeToExpand, expanding);
}
}
public static TLNode GetNextNode(TLNode startingNode, int searchOffset)
{
if (searchOffset == 0)
{
return(startingNode);
}
if (searchOffset > 0)
{
ForwardNodeEnumerator iterator = new ForwardNodeEnumerator(startingNode, true);
while (searchOffset-- >= 0 && iterator.MoveNext())
{
;
}
return(iterator.Current);
}
if (searchOffset < 0)
{
ReverseNodeEnumerator iterator = new ReverseNodeEnumerator(startingNode, true);
while (searchOffset++ <= 0 && iterator.MoveNext())
{
;
}
return(iterator.Current);
}
return(null);
}
public override TLNode Add(TLNode newnode)
{
var node = base.Add(newnode);
m_tree.RecalcLayout();
return(node);
}
protected virtual void raiseAfterSelect(TLNode node)
{
if (AfterSelect != null)
{
AfterSelect(this, new TreeViewEventArgs(null));
}
}
protected override void OnMouseDown(MouseEventArgs e)
{
this.Focus();
if (e.Button == MouseButtons.Right)
{
Point mousePoint = new Point(e.X, e.Y);
TLNode clickedNode = CalcHitNode(mousePoint);
if (clickedNode != null)
{
// if multi select the selection is cleard if clicked node is not in selection
if (MultiSelect)
{
if (NodesSelection.Contains(clickedNode) == false)
{
MultiSelectAdd(clickedNode, Control.ModifierKeys);
}
}
FocusedNode = clickedNode;
Invalidate();
}
BeforeShowContextMenu();
}
if (e.Button == MouseButtons.Left)
{
HitInfo info = Columns.CalcHitInfo(new Point(e.X, e.Y), HScrollValue());
if ((int)(info.HitType & HitInfo.eHitType.kColumnHeaderResize) > 0)
{
m_resizingColumn = info.Column;
m_resizingColumnScrollOffset = HScrollValue();
return;
}
}
base.OnMouseDown(e);
}
protected virtual void raiseNotifyBeforeExpand(TLNode node, bool isExpanding)
{
if (NotifyBeforeExpand != null)
{
NotifyBeforeExpand(node, isExpanding);
}
}
protected virtual void raiseNotifyAfterExpand(TLNode node, bool isExpanded)
{
if (NotifyAfterExpand != null)
{
NotifyAfterExpand(node, isExpanded);
}
}
internal static void SetHasChildren(TLNode node, bool hasChildren)
{
if (node != null)
{
node.m_hasChildren = hasChildren;
}
}
public virtual void PaintCell(Graphics dc,
Rectangle cellRect,
TLNode node,
TreeListColumn column,
TreeList.TextFormatting format,
object data)
{
if (format.BackColor != Color.Transparent)
{
Rectangle r = cellRect;
r.X = column.CalculatedRect.X;
r.Width = column.CalculatedRect.Width;
using (SolidBrush brush = new SolidBrush(format.BackColor))
dc.FillRectangle(brush, r);
}
if (data != null)
{
cellRect = ColumnHeaderPainter.AdjustRectangle(cellRect, format.Padding);
//dc.DrawRectangle(Pens.Black, cellRect);
Color color = format.ForeColor;
if (m_owner.FocusedNode == node && Application.RenderWithVisualStyles == false)
{
color = SystemColors.HighlightText;
}
TextFormatFlags flags = TextFormatFlags.EndEllipsis | TextFormatFlags.NoPrefix | format.GetFormattingFlags();
TextRenderer.DrawText(dc, data.ToString(), m_owner.Font, cellRect, color, flags);
}
}
protected virtual void PaintImage(Graphics dc, Rectangle imageRect, TLNode node, Image image)
{
if (image != null)
{
dc.DrawImageUnscaled(image, imageRect);
}
}
public virtual void DrawSelectionBackground(Graphics dc, Rectangle nodeRect, TLNode node)
{
if (m_owner.NodesSelection.Contains(node) || m_owner.FocusedNode == node)
{
if (!Application.RenderWithVisualStyles)
{
// have to fill the solid background only before the node is painted
dc.FillRectangle(SystemBrushes.FromSystemColor(SystemColors.Highlight), nodeRect);
}
else
{
// have to draw the transparent background after the node is painted
VisualStyleItemBackground.Style style = VisualStyleItemBackground.Style.Normal;
if (m_owner.Focused == false)
{
style = VisualStyleItemBackground.Style.Inactive;
}
VisualStyleItemBackground rendere = new VisualStyleItemBackground(style);
rendere.DrawBackground(m_owner, dc, nodeRect);
}
}
if (m_owner.Focused && (m_owner.FocusedNode == node))
{
nodeRect.Height += 1;
nodeRect.Inflate(-1, -1);
ControlPaint.DrawFocusRectangle(dc, nodeRect);
}
}
public void InsertAfter(TLNode node, TLNode insertAfter)
{
m_version++;
ClearInternalArray();
Debug.Assert(node.Owner == null, "node.Owner == null");
if (insertAfter == null)
{
node.InsertBefore(m_firstNode, this);
m_firstNode = node;
}
else
{
node.InsertAfter(insertAfter, this);
}
if (m_lastNode == insertAfter)
{
m_lastNode = node;
node.Id = m_nextId++;
}
else
{
m_IdDirty++;
}
m_count++;
}
public virtual void Remove(TLNode node)
{
if (m_lastNode == null)
{
return;
}
m_version++;
ClearInternalArray();
//Debug.Assert(node != null && object.ReferenceEquals(node.Owner, this), "Remove(Node node)");
TLNode prev = node.PrevSibling;
TLNode next = node.NextSibling;
node.Remove();
if (prev == null) // first node
{
m_firstNode = next;
}
if (next == null) // last node
{
m_lastNode = prev;
}
m_IdDirty++;
m_count--;
TLNode.SetHasChildren(m_owner, m_count != 0);
}
protected override void OnMouseClick(MouseEventArgs e)
{
if (e.Button == MouseButtons.Left)
{
Point mousePoint = new Point(e.X, e.Y);
TLNode clickedNode = CalcHitNode(mousePoint);
if (clickedNode != null && Columns.Count > 0)
{
int clickedRow = CalcHitRow(mousePoint);
Rectangle glyphRect = GetPlusMinusRectangle(clickedNode, Columns.VisibleColumns[0], clickedRow);
if (clickedNode.HasChildren && glyphRect != Rectangle.Empty && glyphRect.Contains(mousePoint))
{
clickedNode.Expanded = !clickedNode.Expanded;
}
if (MultiSelect)
{
MultiSelectAdd(clickedNode, Control.ModifierKeys);
}
else
{
FocusedNode = clickedNode;
}
}
}
base.OnMouseClick(e);
}
protected virtual object GetData(TLNode node, TreeListColumn column)
{
if (node[column.Index] != null)
{
return(node[column.Index]);
}
return(null);
}
protected virtual Image GetNodeBitmap(TLNode node)
{
if (Images != null && node.ImageId >= 0 && node.ImageId < Images.Images.Count)
{
return(Images.Images[node.ImageId]);
}
return(null);
}
void MultiSelectAdd(TLNode clickedNode, Keys modifierKeys)
{
if (Control.ModifierKeys == Keys.None)
{
foreach (TLNode node in NodesSelection)
{
int newrow = NodeCollection.GetVisibleNodeIndex(node);
InvalidateRow(newrow);
}
NodesSelection.Clear();
NodesSelection.Add(clickedNode);
}
if (Control.ModifierKeys == Keys.Shift)
{
if (NodesSelection.Count == 0)
{
NodesSelection.Add(clickedNode);
}
else
{
int startrow = NodeCollection.GetVisibleNodeIndex(NodesSelection[0]);
int currow = NodeCollection.GetVisibleNodeIndex(clickedNode);
if (currow > startrow)
{
TLNode startingNode = NodesSelection[0];
NodesSelection.Clear();
foreach (TLNode node in NodeCollection.ForwardNodeIterator(startingNode, clickedNode, true))
{
NodesSelection.Add(node);
}
Invalidate();
}
if (currow < startrow)
{
TLNode startingNode = NodesSelection[0];
NodesSelection.Clear();
foreach (TLNode node in NodeCollection.ReverseNodeIterator(startingNode, clickedNode, true))
{
NodesSelection.Add(node);
}
Invalidate();
}
}
}
if (Control.ModifierKeys == Keys.Control)
{
if (NodesSelection.Contains(clickedNode))
{
NodesSelection.Remove(clickedNode);
}
else
{
NodesSelection.Add(clickedNode);
}
}
InvalidateRow(NodeCollection.GetVisibleNodeIndex(clickedNode));
FocusedNode = clickedNode;
}
public static IEnumerable ForwardNodeIterator(TLNode firstNode, bool mustBeVisible)
{
ForwardNodeEnumerator iterator = new ForwardNodeEnumerator(firstNode, mustBeVisible);
while (iterator.MoveNext())
{
yield return(iterator.Current);
}
}
/// <summary>
/// MakeVisible will expand all the parents up the tree.
/// </summary>
public void MakeVisible()
{
TLNode parent = Parent;
while (parent != null)
{
parent.Expanded = true;
parent = parent.Parent;
}
}
public TLNode NodeAtIndex(int index)
{
TLNode node = FirstNode;
while (index-- > 0 && node != null)
{
node = node.NextSibling;
}
return(node);
}
public TLNode GetRoot()
{
TLNode parent = this;
while (parent.Parent != null)
{
parent = parent.Parent;
}
return(parent);
}
object GetDataDesignMode(TLNode node, TreeListColumn column)
{
string id = string.Empty;
while (node != null)
{
id = node.Owner.GetNodeIndex(node).ToString() + ":" + id;
node = node.Parent;
}
return("<temp>" + id);
}
protected override void OnMouseDoubleClick(MouseEventArgs e)
{
base.OnMouseDoubleClick(e);
Point mousePoint = new Point(e.X, e.Y);
TLNode clickedNode = CalcHitNode(mousePoint);
if (clickedNode != null && clickedNode.HasChildren)
{
clickedNode.Expanded = !clickedNode.Expanded;
}
}
protected virtual void PaintCell(Graphics dc, Rectangle cellRect, TLNode node, TreeListColumn column)
{
if (this.DesignMode)
{
CellPainter.PaintCell(dc, cellRect, node, column, GetFormatting(node, column), GetDataDesignMode(node, column));
}
else
{
CellPainter.PaintCell(dc, cellRect, node, column, GetFormatting(node, column), GetData(node, column));
}
}
protected virtual int GetIndentSize(TLNode node)
{
int indent = 0;
TLNode parent = node.Parent;
while (parent != null)
{
indent += ViewOptions.Indent;
parent = parent.Parent;
}
return(indent);
}
public static TLNode FindNodesBottomLeaf(TLNode node, bool mustBeVisible)
{
if (mustBeVisible && node.Expanded == false)
{
return(node);
}
if (node.HasChildren == false || node.Nodes.LastNode == null)
{
return(node);
}
node = node.Nodes.LastNode;
return(FindNodesBottomLeaf(node, mustBeVisible));
}
void OnVScroll(object sender, ScrollEventArgs e)
{
int diff = e.NewValue - e.OldValue;
//assumedScrollPos += diff;
if (e.NewValue == 0)
{
m_firstVisibleNode = Nodes.FirstNode;
diff = 0;
}
m_firstVisibleNode = NodeCollection.GetNextNode(m_firstVisibleNode, diff);
Invalidate();
}
public bool MoveNext()
{
if (m_firstNode == null)
{
return(false);
}
if (m_current == null)
{
m_current = m_firstNode;
return(true);
}
m_current = m_current.NextSibling;
return(m_current != null);
}
public void EnsureVisible(TLNode node)
{
int screenvisible = MaxVisibleRows() - 1;
int visibleIndex = NodeCollection.GetVisibleNodeIndex(node);
if (visibleIndex < VScrollValue())
{
SetVScrollValue(visibleIndex);
}
if (visibleIndex > VScrollValue() + screenvisible)
{
SetVScrollValue(visibleIndex - screenvisible);
}
}
