using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Runtime.Serialization;
using System.Security.Permissions;
namespace Aga.Controls.Tree{
[Serializable]
public sealed class TreeNodeAdv : ISerializable
{
#region NodeCollection
private class NodeCollection : Collection<TreeNodeAdv>
{
private TreeNodeAdv _owner;
public NodeCollection(TreeNodeAdv owner)
{
_owner = owner;
}
protected override void ClearItems()
{
while (this.Count != 0)
this.RemoveAt(this.Count - 1);
}
protected override void InsertItem(int index, TreeNodeAdv item)
{
if (item == null)
throw new ArgumentNullException("item");
if (item.Parent != _owner)
{
if (item.Parent != null)
item.Parent.Nodes.Remove(item);
item._parent = _owner;
item._index = index;
for (int i = index; i < Count; i++)
this[i]._index++;
base.InsertItem(index, item);
}
if (_owner.Tree != null && _owner.Tree.Model == null)
{
_owner.Tree.SmartFullUpdate();
}
}
protected override void RemoveItem(int index)
{
TreeNodeAdv item = this[index];
item._parent = null;
item._index = -1;
for (int i = index + 1; i < Count; i++)
this[i]._index--;
base.RemoveItem(index);
if (_owner.Tree != null && _owner.Tree.Model == null)
{
_owner.Tree.UpdateSelection();
_owner.Tree.SmartFullUpdate();
}
}
protected override void SetItem(int index, TreeNodeAdv item)
{
if (item == null)
throw new ArgumentNullException("item");
RemoveAt(index);
InsertItem(index, item);
}
}
#endregion
#region Events
public event EventHandler<TreeViewAdvEventArgs> Collapsing;
internal void OnCollapsing()
{
if (Collapsing != null)
Collapsing(this, new TreeViewAdvEventArgs(this));
}
public event EventHandler<TreeViewAdvEventArgs> Collapsed;
internal void OnCollapsed()
{
if (Collapsed != null)
Collapsed(this, new TreeViewAdvEventArgs(this));
}
public event EventHandler<TreeViewAdvEventArgs> Expanding;
internal void OnExpanding()
{
if (Expanding != null)
Expanding(this, new TreeViewAdvEventArgs(this));
}
public event EventHandler<TreeViewAdvEventArgs> Expanded;
internal void OnExpanded()
{
if (Expanded != null)
Expanded(this, new TreeViewAdvEventArgs(this));
}
#endregion
#region Properties
private TreeViewAdv _tree;
public TreeViewAdv Tree
{
get { return _tree; }
}
private int _row;
public int Row
{
get { return _row; }
internal set { _row = value; }
}
private int _index = -1;
public int Index
{
get
{
return _index;
}
}
private bool _isSelected;
public bool IsSelected
{
get { return _isSelected; }
set
{
if (_isSelected != value)
{
if (Tree.IsMyNode(this))
{
//_tree.OnSelectionChanging
if (value)
{
if (!_tree.Selection.Contains(this))
_tree.Selection.Add(this);
if (_tree.Selection.Count == 1)
_tree.CurrentNode = this;
}
else
_tree.Selection.Remove(this);
_tree.UpdateView();
_tree.OnSelectionChanged();
}
_isSelected = value;
}
}
}
/// <summary>
/// Returns true if all parent nodes of this node are expanded.
/// </summary>
internal bool IsVisible
{
get
{
TreeNodeAdv node = _parent;
while (node != null)
{
if (!node.IsExpanded)
return false;
node = node.Parent;
}
return true;
}
}
private bool _isLeaf;
public bool IsLeaf
{
get { return _isLeaf; }
internal set { _isLeaf = value; }
}
private bool _isExpandedOnce;
public bool IsExpandedOnce
{
get { return _isExpandedOnce; }
internal set { _isExpandedOnce = value; }
}
private bool _isExpanded;
public bool IsExpanded
{
get { return _isExpanded; }
set
{
if (value)
Expand();
else
Collapse();
}
}
internal void AssignIsExpanded(bool value)
{
_isExpanded = value;
}
private TreeNodeAdv _parent;
public TreeNodeAdv Parent
{
get { return _parent; }
}
public int Level
{
get
{
if (_parent == null)
return 0;
else
return _parent.Level + 1;
}
}
public TreeNodeAdv PreviousNode
{
get
{
if (_parent != null)
{
int index = Index;
if (index > 0)
return _parent.Nodes[index - 1];
}
return null;
}
}
public TreeNodeAdv NextNode
{
get
{
if (_parent != null)
{
int index = Index;
if (index < _parent.Nodes.Count - 1)
return _parent.Nodes[index + 1];
}
return null;
}
}
internal TreeNodeAdv BottomNode
{
get
{
TreeNodeAdv parent = this.Parent;
if (parent != null)
{
if (parent.NextNode != null)
return parent.NextNode;
else
return parent.BottomNode;
}
return null;
}
}
internal TreeNodeAdv NextVisibleNode
{
get
{
if (IsExpanded && Nodes.Count > 0)
return Nodes[0];
else
{
TreeNodeAdv nn = NextNode;
if (nn != null)
return nn;
else
return BottomNode;
}
}
}
public bool CanExpand
{
get
{
return (Nodes.Count > 0 || (!IsExpandedOnce && !IsLeaf));
}
}
private object _tag;
public object Tag
{
get { return _tag; }
}
private Collection<TreeNodeAdv> _nodes;
internal Collection<TreeNodeAdv> Nodes
{
get { return _nodes; }
}
private ReadOnlyCollection<TreeNodeAdv> _children;
public ReadOnlyCollection<TreeNodeAdv> Children
{
get
{
return _children;
}
}
private int? _rightBounds;
internal int? RightBounds
{
get { return _rightBounds; }
set { _rightBounds = value; }
}
private int? _height;
internal int? Height
{
get { return _height; }
set { _height = value; }
}
private bool _isExpandingNow;
internal bool IsExpandingNow
{
get { return _isExpandingNow; }
set { _isExpandingNow = value; }
}
private bool _autoExpandOnStructureChanged = false;
public bool AutoExpandOnStructureChanged
{
get { return _autoExpandOnStructureChanged; }
set { _autoExpandOnStructureChanged = value; }
}
#endregion
public TreeNodeAdv(object tag)
: this(null, tag)
{
}
internal TreeNodeAdv(TreeViewAdv tree, object tag)
{
_row = -1;
_tree = tree;
_nodes = new NodeCollection(this);
_children = new ReadOnlyCollection<TreeNodeAdv>(_nodes);
_tag = tag;
}
public override string ToString()
{
if (Tag != null)
return Tag.ToString();
else
return base.ToString();
}
public void Collapse()
{
if (_isExpanded)
Collapse(true);
}
public void CollapseAll()
{
Collapse(false);
}
public void Collapse(bool ignoreChildren)
{
SetIsExpanded(false, ignoreChildren);
}
public void Expand()
{
if (!_isExpanded)
Expand(true);
}
public void ExpandAll()
{
Expand(false);
}
public void Expand(bool ignoreChildren)
{
SetIsExpanded(true, ignoreChildren);
}
private void SetIsExpanded(bool value, bool ignoreChildren)
{
if (Tree == null)
_isExpanded = value;
else
Tree.SetIsExpanded(this, value, ignoreChildren);
}
#region ISerializable Members
private TreeNodeAdv(SerializationInfo info, StreamingContext context)
: this(null, null)
{
int nodesCount = 0;
nodesCount = info.GetInt32("NodesCount");
_isExpanded = info.GetBoolean("IsExpanded");
_tag = info.GetValue("Tag", typeof(object));
for (int i = 0; i < nodesCount; i++)
{
TreeNodeAdv child = (TreeNodeAdv)info.GetValue("Child" + i, typeof(TreeNodeAdv));
Nodes.Add(child);
}
}
[SecurityPermission(SecurityAction.Demand, SerializationFormatter = true)]
public void GetObjectData(SerializationInfo info, StreamingContext context)
{
info.AddValue("IsExpanded", IsExpanded);
info.AddValue("NodesCount", Nodes.Count);
if ((Tag != null) && Tag.GetType().IsSerializable)
info.AddValue("Tag", Tag, Tag.GetType());
for (int i = 0; i < Nodes.Count; i++)
info.AddValue("Child" + i, Nodes[i], typeof(TreeNodeAdv));
}
#endregion
}
}
|