MercurialOpenHardwareMonitor / file revision
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | raw | help
External/Aga.Controls/Tree/TreeNodeAdv.cs
author moel.mich
Sun, 23 Sep 2012 18:37:43 +0000
changeset 380 573f1fff48b2
parent 345 0c551e8818e0
permissions -rw-r--r--
Fixed Issue 387. The new implementation does not try to start a ring 0 driver that already exists, but could not be opened. It tries to delete the driver and install it new. The driver is now stored temporarily in the application folder. The driver is not correctly removed on system shutdown. 
     1 using System;

     2 using System.Collections.Generic;

     3 using System.Collections.ObjectModel;

     4 using System.Runtime.Serialization;

     5 using System.Security.Permissions;

     6 

     7 namespace Aga.Controls.Tree

     8 {

     9 	[Serializable]

    10 	public sealed class TreeNodeAdv : ISerializable

    11 	{

    12 		#region NodeCollection

    13 		private class NodeCollection : Collection<TreeNodeAdv>

    14 		{

    15 			private TreeNodeAdv _owner;

    16 

    17 			public NodeCollection(TreeNodeAdv owner)

    18 			{

    19 				_owner = owner;

    20 			}

    21 

    22 			protected override void ClearItems()

    23 			{

    24 				while (this.Count != 0)

    25 					this.RemoveAt(this.Count - 1);

    26 			}

    27 

    28 			protected override void InsertItem(int index, TreeNodeAdv item)

    29 			{

    30 				if (item == null)

    31 					throw new ArgumentNullException("item");

    32 

    33 				if (item.Parent != _owner)

    34 				{

    35 					if (item.Parent != null)

    36 						item.Parent.Nodes.Remove(item);

    37 					item._parent = _owner;

    38 					item._index = index;

    39 					for (int i = index; i < Count; i++)

    40 						this[i]._index++;

    41 					base.InsertItem(index, item);

    42 				}

    43 

    44 				if (_owner.Tree != null && _owner.Tree.Model == null)

    45 				{

    46 					_owner.Tree.SmartFullUpdate();

    47 				}

    48 			}

    49 

    50 			protected override void RemoveItem(int index)

    51 			{

    52 				TreeNodeAdv item = this[index];

    53 				item._parent = null;

    54 				item._index = -1;

    55 				for (int i = index + 1; i < Count; i++)

    56 					this[i]._index--;

    57 				base.RemoveItem(index);

    58 

    59 				if (_owner.Tree != null && _owner.Tree.Model == null)

    60 				{

    61 					_owner.Tree.UpdateSelection();

    62 					_owner.Tree.SmartFullUpdate();

    63 				}

    64 			}

    65 

    66 			protected override void SetItem(int index, TreeNodeAdv item)

    67 			{

    68 				if (item == null)

    69 					throw new ArgumentNullException("item");

    70 				RemoveAt(index);

    71 				InsertItem(index, item);

    72 			}

    73 		}

    74 		#endregion

    75 

    76 		#region Events

    77 

    78 		public event EventHandler<TreeViewAdvEventArgs> Collapsing;

    79 		internal void OnCollapsing()

    80 		{

    81 			if (Collapsing != null)

    82 				Collapsing(this, new TreeViewAdvEventArgs(this));

    83 		}

    84 

    85 		public event EventHandler<TreeViewAdvEventArgs> Collapsed;

    86 		internal void OnCollapsed()

    87 		{

    88 			if (Collapsed != null)

    89 				Collapsed(this, new TreeViewAdvEventArgs(this));

    90 		}

    91 

    92 		public event EventHandler<TreeViewAdvEventArgs> Expanding;

    93 		internal void OnExpanding()

    94 		{

    95 			if (Expanding != null)

    96 				Expanding(this, new TreeViewAdvEventArgs(this));

    97 		}

    98 

    99 		public event EventHandler<TreeViewAdvEventArgs> Expanded;

   100 		internal void OnExpanded()

   101 		{

   102 			if (Expanded != null)

   103 				Expanded(this, new TreeViewAdvEventArgs(this));

   104 		}

   105 

   106 		#endregion

   107 

   108 		#region Properties

   109 

   110 		private TreeViewAdv _tree;

   111 		public TreeViewAdv Tree

   112 		{

   113 			get { return _tree; }

   114 		}

   115 

   116 		private int _row;

   117 		public int Row

   118 		{

   119 			get { return _row; }

   120 			internal set { _row = value; }

   121 		}

   122 

   123 		private int _index = -1;

   124 		public int Index

   125 		{

   126 			get

   127 			{

   128 				return _index;

   129 			}

   130 		}

   131 

   132 		private bool _isSelected;

   133 		public bool IsSelected

   134 		{

   135 			get { return _isSelected; }

   136 			set

   137 			{

   138 				if (_isSelected != value)

   139 				{

   140 					if (Tree.IsMyNode(this))

   141 					{

   142 						//_tree.OnSelectionChanging

   143 						if (value)

   144 						{

   145 							if (!_tree.Selection.Contains(this))

   146 								_tree.Selection.Add(this);

   147 

   148 							if (_tree.Selection.Count == 1)

   149 								_tree.CurrentNode = this;

   150 						}

   151 						else

   152 							_tree.Selection.Remove(this);

   153 						_tree.UpdateView();

   154 						_tree.OnSelectionChanged();

   155 					}

   156 					_isSelected = value;

   157 				}

   158 			}

   159 		}

   160 

   161 		/// <summary>

   162 		/// Returns true if all parent nodes of this node are expanded.

   163 		/// </summary>

   164 		internal bool IsVisible

   165 		{

   166 			get

   167 			{

   168 				TreeNodeAdv node = _parent;

   169 				while (node != null)

   170 				{

   171 					if (!node.IsExpanded)

   172 						return false;

   173 					node = node.Parent;

   174 				}

   175 				return true;

   176 			}

   177 		}

   178 

   179 		private bool _isLeaf;

   180 		public bool IsLeaf

   181 		{

   182 			get { return _isLeaf; }

   183 			internal set { _isLeaf = value; }

   184 		}

   185 

   186 		private bool _isExpandedOnce;

   187 		public bool IsExpandedOnce

   188 		{

   189 			get { return _isExpandedOnce; }

   190 			internal set { _isExpandedOnce = value; }

   191 		}

   192 

   193 		private bool _isExpanded;

   194 		public bool IsExpanded

   195 		{

   196 			get { return _isExpanded; }

   197 			set

   198 			{

   199 				if (value)

   200 					Expand();

   201 				else

   202 					Collapse();

   203 			}

   204 		}

   205 

   206 		internal void AssignIsExpanded(bool value)

   207 		{

   208 			_isExpanded = value;

   209 		}

   210 

   211 		private TreeNodeAdv _parent;

   212 		public TreeNodeAdv Parent

   213 		{

   214 			get { return _parent; }

   215 		}

   216 

   217 		public int Level

   218 		{

   219 			get

   220 			{

   221 				if (_parent == null)

   222 					return 0;

   223 				else

   224 					return _parent.Level + 1;

   225 			}

   226 		}

   227 

   228 		public TreeNodeAdv PreviousNode

   229 		{

   230 			get

   231 			{

   232 				if (_parent != null)

   233 				{

   234 					int index = Index;

   235 					if (index > 0)

   236 						return _parent.Nodes[index - 1];

   237 				}

   238 				return null;

   239 			}

   240 		}

   241 

   242 		public TreeNodeAdv NextNode

   243 		{

   244 			get

   245 			{

   246 				if (_parent != null)

   247 				{

   248 					int index = Index;

   249 					if (index < _parent.Nodes.Count - 1)

   250 						return _parent.Nodes[index + 1];

   251 				}

   252 				return null;

   253 			}

   254 		}

   255 

   256 		internal TreeNodeAdv BottomNode

   257 		{

   258 			get

   259 			{

   260 				TreeNodeAdv parent = this.Parent;

   261 				if (parent != null)

   262 				{

   263 					if (parent.NextNode != null)

   264 						return parent.NextNode;

   265 					else

   266 						return parent.BottomNode;

   267 				}

   268 				return null;

   269 			}

   270 		}

   271 

   272 		internal TreeNodeAdv NextVisibleNode

   273 		{

   274 			get

   275 			{

   276 				if (IsExpanded && Nodes.Count > 0)

   277 					return Nodes[0];

   278 				else

   279 				{

   280 					TreeNodeAdv nn = NextNode;

   281 					if (nn != null)

   282 						return nn;

   283 					else

   284 						return BottomNode;

   285 				}

   286 			}

   287 		}

   288 

   289 		public bool CanExpand

   290 		{

   291 			get

   292 			{

   293 				return (Nodes.Count > 0 || (!IsExpandedOnce && !IsLeaf));

   294 			}

   295 		}

   296 

   297 		private object _tag;

   298 		public object Tag

   299 		{

   300 			get { return _tag; }

   301 		}

   302 

   303 		private Collection<TreeNodeAdv> _nodes;

   304 		internal Collection<TreeNodeAdv> Nodes

   305 		{

   306 			get { return _nodes; }

   307 		}

   308 

   309 		private ReadOnlyCollection<TreeNodeAdv> _children;

   310 		public ReadOnlyCollection<TreeNodeAdv> Children

   311 		{

   312 			get

   313 			{

   314 				return _children;

   315 			}

   316 		}

   317 

   318 		private int? _rightBounds;

   319 		internal int? RightBounds

   320 		{

   321 			get { return _rightBounds; }

   322 			set { _rightBounds = value; }

   323 		}

   324 

   325 		private int? _height;

   326 		internal int? Height

   327 		{

   328 			get { return _height; }

   329 			set { _height = value; }

   330 		}

   331 

   332 		private bool _isExpandingNow;

   333 		internal bool IsExpandingNow

   334 		{

   335 			get { return _isExpandingNow; }

   336 			set { _isExpandingNow = value; }

   337 		}

   338 

   339 		private bool _autoExpandOnStructureChanged = true;

   340 		public bool AutoExpandOnStructureChanged

   341 		{

   342 			get { return _autoExpandOnStructureChanged; }

   343 			set { _autoExpandOnStructureChanged = value; }

   344 		}

   345 

   346 		#endregion

   347 

   348 		public TreeNodeAdv(object tag)

   349 			: this(null, tag)

   350 		{

   351 		}

   352 

   353 		internal TreeNodeAdv(TreeViewAdv tree, object tag)

   354 		{

   355 			_row = -1;

   356 			_tree = tree;

   357 			_nodes = new NodeCollection(this);

   358 			_children = new ReadOnlyCollection<TreeNodeAdv>(_nodes);

   359 			_tag = tag;

   360 		}

   361 

   362 		public override string ToString()

   363 		{

   364 			if (Tag != null)

   365 				return Tag.ToString();

   366 			else

   367 				return base.ToString();

   368 		}

   369 

   370 		public void Collapse()

   371 		{

   372 			if (_isExpanded)

   373 				Collapse(true);

   374 		}

   375 

   376 		public void CollapseAll()

   377 		{

   378 			Collapse(false);

   379 		}

   380 

   381 		public void Collapse(bool ignoreChildren)

   382 		{

   383 			SetIsExpanded(false, ignoreChildren);

   384 		}

   385 

   386 		public void Expand()

   387 		{

   388 			if (!_isExpanded)

   389 				Expand(true);

   390 		}

   391 

   392 		public void ExpandAll()

   393 		{

   394 			Expand(false);

   395 		}

   396 

   397 		public void Expand(bool ignoreChildren)

   398 		{

   399 			SetIsExpanded(true, ignoreChildren);

   400 		}

   401 

   402 		private void SetIsExpanded(bool value, bool ignoreChildren)

   403 		{

   404 			if (Tree == null)

   405 				_isExpanded = value;

   406 			else

   407 				Tree.SetIsExpanded(this, value, ignoreChildren);

   408 		}

   409 

   410 		#region ISerializable Members

   411 

   412 		private TreeNodeAdv(SerializationInfo info, StreamingContext context)

   413 			: this(null, null)

   414 		{

   415 			int nodesCount = 0;

   416 			nodesCount = info.GetInt32("NodesCount");

   417 			_isExpanded = info.GetBoolean("IsExpanded");

   418 			_tag = info.GetValue("Tag", typeof(object));

   419 

   420 			for (int i = 0; i < nodesCount; i++)

   421 			{

   422 				TreeNodeAdv child = (TreeNodeAdv)info.GetValue("Child" + i, typeof(TreeNodeAdv));

   423 				Nodes.Add(child);

   424 			}

   425 

   426 		}

   427 

   428 		[SecurityPermission(SecurityAction.Demand, SerializationFormatter = true)]

   429 		public void GetObjectData(SerializationInfo info, StreamingContext context)

   430 		{

   431 			info.AddValue("IsExpanded", IsExpanded);

   432 			info.AddValue("NodesCount", Nodes.Count);

   433 			if ((Tag != null) && Tag.GetType().IsSerializable)

   434 				info.AddValue("Tag", Tag, Tag.GetType());

   435 

   436 			for (int i = 0; i < Nodes.Count; i++)

   437 				info.AddValue("Child" + i, Nodes[i], typeof(TreeNodeAdv));

   438 

   439 		}

   440 

   441 		#endregion

   442 	}

   443 }
OpenHardwareMonitor