fixup! expant/collapse tree node on double click fix

sergiye · sergiye · commit c3ff68ec5cc0 · 2024-11-16T16:15:19.000+02:00
diff --git a/Aga.Controls/Tree/Input/NormalInputState.cs b/Aga.Controls/Tree/Input/NormalInputState.cs
@@ -24,14 +24,18 @@ public override void KeyDown(KeyEventArgs args)
 				{
 					case Keys.Right:
 						if (!Tree.CurrentNode.IsExpanded)
-							Tree.CurrentNode.IsExpanded = true;
+                        {
+							Tree.CurrentNode.Expand(true);
+                        }
 						else if (Tree.CurrentNode.Nodes.Count > 0)
 							Tree.SelectedNode = Tree.CurrentNode.Nodes[0];
 						args.Handled = true;
 						break;
 					case Keys.Left:
 						if (Tree.CurrentNode.IsExpanded)
-							Tree.CurrentNode.IsExpanded = false;
+                        {
+                            Tree.CurrentNode.Collapse(true);
+                        }
 						else if (Tree.CurrentNode.Parent != Tree.Root)
 							Tree.SelectedNode = Tree.CurrentNode.Parent;
 						args.Handled = true;
@@ -63,12 +67,12 @@ public override void KeyDown(KeyEventArgs args)
 						args.Handled = true;
 						break;
 					case Keys.Subtract:
-						Tree.CurrentNode.Collapse();
+						Tree.CurrentNode.Collapse(true);
 						args.Handled = true;
 						args.SuppressKeyPress = true;
 						break;
 					case Keys.Add:
-						Tree.CurrentNode.Expand();
+						Tree.CurrentNode.Expand(true);
 						args.Handled = true;
 						args.SuppressKeyPress = true;
 						break;
diff --git a/Aga.Controls/Tree/NodeControls/NodePlusMinus.cs b/Aga.Controls/Tree/NodeControls/NodePlusMinus.cs
@@ -91,8 +91,13 @@ public override void MouseDown(TreeNodeAdvMouseEventArgs args)
 			{
 				args.Handled = true;
 				if (args.Node.CanExpand)
-					args.Node.IsExpanded = !args.Node.IsExpanded;
-			}
+                {
+                    if (args.Node.IsExpanded)
+                        args.Node.Collapse(true);
+                    else
+                        args.Node.Expand(true);
+                }
+            }
 		}
 
 		public override void MouseDoubleClick(TreeNodeAdvMouseEventArgs args)
diff --git a/Aga.Controls/Tree/TreeNodeAdv.cs b/Aga.Controls/Tree/TreeNodeAdv.cs
@@ -1,5 +1,4 @@
 using System;
-using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Runtime.Serialization;
 using System.Security.Permissions;
@@ -83,10 +82,10 @@ internal void OnCollapsing()
 		}
 
 		public event EventHandler<TreeViewAdvEventArgs> Collapsed;
-		internal void OnCollapsed()
+		internal void OnCollapsed(bool byUser)
 		{
 			if (Collapsed != null)
-				Collapsed(this, new TreeViewAdvEventArgs(this));
+				Collapsed(this, new TreeViewAdvEventArgs(this, byUser));
 		}
 
 		public event EventHandler<TreeViewAdvEventArgs> Expanding;
@@ -97,10 +96,10 @@ internal void OnExpanding()
 		}
 
 		public event EventHandler<TreeViewAdvEventArgs> Expanded;
-		internal void OnExpanded()
+		internal void OnExpanded(bool byUser)
 		{
 			if (Expanded != null)
-				Expanded(this, new TreeViewAdvEventArgs(this));
+				Expanded(this, new TreeViewAdvEventArgs(this, byUser));
 		}
 
 		#endregion
@@ -194,13 +193,6 @@ public bool IsExpandedOnce
 		public bool IsExpanded
 		{
 			get { return _isExpanded; }
-			set
-			{
-				if (value)
-					Expand();
-				else
-					Collapse();
-			}
 		}
 
 		internal void AssignIsExpanded(bool value)
@@ -367,34 +359,34 @@ public override string ToString()
 				return base.ToString();
 		}
 
-		public void Collapse()
+		public void Collapse(bool raisedByUser)
 		{
 			if (_isExpanded)
-				Collapse(true);
+				Collapse(true, raisedByUser);
 		}
 
 		public void CollapseAll()
 		{
-			Collapse(false);
+			Collapse(false, false);
 		}
 
-		public void Collapse(bool ignoreChildren)
+		public void Collapse(bool ignoreChildren, bool raisedByUser)
 		{
 			SetIsExpanded(false, ignoreChildren);
 		}
 
-		public void Expand()
+		public void Expand(bool raisedByUser)
 		{
 			if (!_isExpanded)
-				Expand(true);
+				Expand(true, raisedByUser);
 		}
 
 		public void ExpandAll()
 		{
-			Expand(false);
+			Expand(false, false);
 		}
 
-		public void Expand(bool ignoreChildren)
+		public void Expand(bool ignoreChildren, bool raisedByUser)
 		{
 			SetIsExpanded(true, ignoreChildren);
 		}
diff --git a/Aga.Controls/Tree/TreeViewAdv.Input.cs b/Aga.Controls/Tree/TreeViewAdv.Input.cs
@@ -194,7 +194,12 @@ protected override void OnMouseDoubleClick(MouseEventArgs e)
 				if (!args.Handled)
 				{
 					if (args.Node != null && args.Button == MouseButtons.Left)
-						args.Node.IsExpanded = !args.Node.IsExpanded;
+                    {
+                        if (args.Node.IsExpanded)
+                            args.Node.Collapse(true);
+                        else
+                            args.Node.Expand(true);
+                    }
 				}
 			}
 
diff --git a/Aga.Controls/Tree/TreeViewAdv.cs b/Aga.Controls/Tree/TreeViewAdv.cs
@@ -129,10 +129,10 @@ private void OnCollapsing(TreeNodeAdv node)
 
 		[Category("Behavior")]
 		public event EventHandler<TreeViewAdvEventArgs> Collapsed;
-		private void OnCollapsed(TreeNodeAdv node)
+		private void OnCollapsed(TreeNodeAdv node, bool byUser)
 		{
 			if (Collapsed != null)
-				Collapsed(this, new TreeViewAdvEventArgs(node));
+				Collapsed(this, new TreeViewAdvEventArgs(node, byUser));
 		}
 
 		[Category("Behavior")]
@@ -145,10 +145,10 @@ private void OnExpanding(TreeNodeAdv node)
 
 		[Category("Behavior")]
 		public event EventHandler<TreeViewAdvEventArgs> Expanded;
-		private void OnExpanded(TreeNodeAdv node)
+		private void OnExpanded(TreeNodeAdv node, bool byUser)
 		{
 			if (Expanded != null)
-				Expanded(this, new TreeViewAdvEventArgs(node));
+				Expanded(this, new TreeViewAdvEventArgs(node, byUser));
 		}
 
 		[Category("Behavior")]
@@ -436,7 +436,7 @@ public void EnsureVisible(TreeNodeAdv node)
 			TreeNodeAdv parent = node.Parent;
 			while (parent != _root)
 			{
-				parent.IsExpanded = true;
+				parent.Expand(false);
 				parent = parent.Parent;
 			}
 			ScrollTo(node);
@@ -717,7 +717,7 @@ private void CreateNodes()
 			Selection.Clear();
 			SelectionStart = null;
 			_root = new TreeNodeAdv(this, null);
-			_root.IsExpanded = true;
+			_root.Expand(false);
 			if (_root.Nodes.Count > 0)
 				CurrentNode = _root.Nodes[0];
 			else
@@ -778,6 +778,7 @@ private struct ExpandArgs
 			public TreeNodeAdv Node;
 			public bool Value;
 			public bool IgnoreChildren;
+			public bool ChangedByUser;
 		}
 
 		public void AbortBackgroundExpandingThreads()
@@ -789,7 +790,7 @@ public void AbortBackgroundExpandingThreads()
 			Invalidate();
 		}
 
-		internal void SetIsExpanded(TreeNodeAdv node, bool value, bool ignoreChildren)
+		internal void SetIsExpanded(TreeNodeAdv node, bool value, bool ignoreChildren, bool byUser)
 		{
 			ExpandArgs eargs = new ExpandArgs();
 			eargs.Node = node;
@@ -798,22 +799,22 @@ internal void SetIsExpanded(TreeNodeAdv node, bool value, bool ignoreChildren)
 
 			if (AsyncExpanding && LoadOnDemand && !_threadPool.IsMyThread(Thread.CurrentThread))
 			{
-				WaitCallback wc = delegate(object argument) { SetIsExpanded((ExpandArgs)argument); };
+				WaitCallback wc = delegate(object argument) { SetIsExpanded((ExpandArgs)argument, byUser); };
 				_threadPool.QueueUserWorkItem(wc, eargs);
 			}
 			else
-				SetIsExpanded(eargs);
+				SetIsExpanded(eargs, byUser);
 		}
 
-		private void SetIsExpanded(ExpandArgs eargs)
+		private void SetIsExpanded(ExpandArgs eargs, bool byUser)
 		{
 			bool update = !eargs.IgnoreChildren && !AsyncExpanding;
 			if (update)
 				BeginUpdate();
 			try
 			{
 				if (IsMyNode(eargs.Node) && eargs.Node.IsExpanded != eargs.Value)
-					SetIsExpanded(eargs.Node, eargs.Value);
+					SetIsExpanded(eargs.Node, eargs.Value, byUser);
 
 				if (!eargs.IgnoreChildren)
 					SetIsExpandedRecursive(eargs.Node, eargs.Value);
@@ -825,7 +826,7 @@ private void SetIsExpanded(ExpandArgs eargs)
 			}
 		}
 
-		internal void SetIsExpanded(TreeNodeAdv node, bool value)
+		internal void SetIsExpanded(TreeNodeAdv node, bool value, bool byUser)
 		{
 			if (Root == node && !value)
 				return; //Can't collapse root node
@@ -857,13 +858,13 @@ internal void SetIsExpanded(TreeNodeAdv node, bool value)
 
 			if (value)
 			{
-				OnExpanded(node);
-				node.OnExpanded();
+				OnExpanded(node, byUser);
+				node.OnExpanded(byUser);
 			}
 			else
 			{
-				OnCollapsed(node);
-				node.OnCollapsed();
+				OnCollapsed(node, byUser);
+				node.OnCollapsed(byUser);
 			}
 		}
 
@@ -887,7 +888,10 @@ internal void SetIsExpandedRecursive(TreeNodeAdv root, bool value)
 			for (int i = 0; i < root.Nodes.Count; i++)
 			{
 				TreeNodeAdv node = root.Nodes[i];
-				node.IsExpanded = value;
+                if (value)
+                    node.Expand(false);
+                else
+                    node.Collapse(false);
 				SetIsExpandedRecursive(node, value);
 			}
 		}
@@ -1143,7 +1147,7 @@ private void RestoreExpandedNodes(TreeNodeAdv node, Dictionary<object, object> l
 		{
 			if (node.Tag != null && list.ContainsKey(node.Tag))
 			{
-				node.IsExpanded = true;
+				node.Expand(false);
 				foreach (var child in node.Children)
 					RestoreExpandedNodes(child, list);
 			}
diff --git a/Aga.Controls/Tree/TreeViewAdvEventArgs.cs b/Aga.Controls/Tree/TreeViewAdvEventArgs.cs
@@ -1,21 +1,16 @@
 using System;
-using System.Collections.Generic;
-using System.Text;
 
 namespace Aga.Controls.Tree
 {
 	public class TreeViewAdvEventArgs : EventArgs
 	{
-		private TreeNodeAdv _node;
+        public TreeNodeAdv Node { get; }
+        public bool RaisedByUser { get; }
 
-		public TreeNodeAdv Node
+        public TreeViewAdvEventArgs(TreeNodeAdv node, bool raisedByUser = false)
 		{
-			get { return _node; }
-		}
-
-		public TreeViewAdvEventArgs(TreeNodeAdv node)
-		{
-			_node = node;
-		}
+			Node = node;
+            RaisedByUser = raisedByUser;
+        }
 	}
 }
diff --git a/OpenHardwareMonitor/UI/MainForm.Designer.cs b/OpenHardwareMonitor/UI/MainForm.Designer.cs
diff --git a/OpenHardwareMonitor/UI/MainForm.cs b/OpenHardwareMonitor/UI/MainForm.cs
@@ -617,7 +617,7 @@ private void Timer_Tick(object sender, EventArgs e)
         if (!backgroundUpdater.IsBusy)
             backgroundUpdater.RunWorkerAsync();
 
-        //RestoreCollapsedNodeState(treeView);
+        RestoreCollapsedNodeState(treeView);
     }
 
     private void SaveConfiguration()
@@ -675,7 +675,7 @@ private void RestoreCollapsedNodeState(TreeViewAdv treeViewAdv)
 
         foreach (TreeNodeAdv node in collapsedHwNodes)
         {
-            node.IsExpanded = false;
+            node.Collapse(false);
         }
     }
 
@@ -713,23 +713,20 @@ private void AboutMenuItem_Click(object sender, EventArgs e)
         _ = new AboutBox().ShowDialog();
     }
 
+    private void TreeView_CollapsedOrExpanded(object sender, TreeViewAdvEventArgs info)
+    {
+        if (info.RaisedByUser && info.Node.Tag is IExpandPersistNode expandPersistNode)
+            expandPersistNode.Expanded = info.Node.IsExpanded;
+    }
+
     private void TreeView_Click(object sender, EventArgs e)
     {
         if (!(e is MouseEventArgs m) || (m.Button != MouseButtons.Left && m.Button != MouseButtons.Right))
             return;
 
         NodeControlInfo info = treeView.GetNodeControlInfoAt(new Point(m.X, m.Y));
-        if (m.Button == MouseButtons.Left && info.Node != null)
-        {
-            if (info.Node.Tag is IExpandPersistNode expandPersistNode)
-            {
-                expandPersistNode.Expanded = info.Node.IsExpanded;
-            }
-            return;
-        }
-
         treeView.SelectedNode = info.Node;
-        if (info.Node != null)
+        if (m.Button == MouseButtons.Right && info.Node != null)
         {
             if (info.Node.Tag is SensorNode node && node.Sensor != null)
             {

Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,4 @@`
`1`	`1`	`using System;`
`2`		`-using System.Collections.Generic;`
`3`	`2`	`using System.Collections.ObjectModel;`
`4`	`3`	`using System.Runtime.Serialization;`
`5`	`4`	`using System.Security.Permissions;`
`@@ -83,10 +82,10 @@ internal void OnCollapsing()`
`83`	`82`	`}`
`84`	`83`
`85`	`84`	`public event EventHandler<TreeViewAdvEventArgs> Collapsed;`
`86`		`- internal void OnCollapsed()`
	`85`	`+ internal void OnCollapsed(bool byUser)`
`87`	`86`	`{`
`88`	`87`	`if (Collapsed != null)`
`89`		`- Collapsed(this, new TreeViewAdvEventArgs(this));`
	`88`	`+ Collapsed(this, new TreeViewAdvEventArgs(this, byUser));`
`90`	`89`	`}`
`91`	`90`
`92`	`91`	`public event EventHandler<TreeViewAdvEventArgs> Expanding;`
`@@ -97,10 +96,10 @@ internal void OnExpanding()`
`97`	`96`	`}`
`98`	`97`
`99`	`98`	`public event EventHandler<TreeViewAdvEventArgs> Expanded;`
`100`		`- internal void OnExpanded()`
	`99`	`+ internal void OnExpanded(bool byUser)`
`101`	`100`	`{`
`102`	`101`	`if (Expanded != null)`
`103`		`- Expanded(this, new TreeViewAdvEventArgs(this));`
	`102`	`+ Expanded(this, new TreeViewAdvEventArgs(this, byUser));`
`104`	`103`	`}`
`105`	`104`
`106`	`105`	`#endregion`
`@@ -194,13 +193,6 @@ public bool IsExpandedOnce`
`194`	`193`	`public bool IsExpanded`
`195`	`194`	`{`
`196`	`195`	`get { return _isExpanded; }`
`197`		`- set`
`198`		`- {`
`199`		`- if (value)`
`200`		`- Expand();`
`201`		`- else`
`202`		`- Collapse();`
`203`		`- }`
`204`	`196`	`}`
`205`	`197`
`206`	`198`	`internal void AssignIsExpanded(bool value)`
`@@ -367,34 +359,34 @@ public override string ToString()`
`367`	`359`	`return base.ToString();`
`368`	`360`	`}`
`369`	`361`
`370`		`- public void Collapse()`
	`362`	`+ public void Collapse(bool raisedByUser)`
`371`	`363`	`{`
`372`	`364`	`if (_isExpanded)`
`373`		`- Collapse(true);`
	`365`	`+ Collapse(true, raisedByUser);`
`374`	`366`	`}`
`375`	`367`
`376`	`368`	`public void CollapseAll()`
`377`	`369`	`{`
`378`		`- Collapse(false);`
	`370`	`+ Collapse(false, false);`
`379`	`371`	`}`
`380`	`372`
`381`		`- public void Collapse(bool ignoreChildren)`
	`373`	`+ public void Collapse(bool ignoreChildren, bool raisedByUser)`
`382`	`374`	`{`
`383`	`375`	`SetIsExpanded(false, ignoreChildren);`
`384`	`376`	`}`
`385`	`377`
`386`		`- public void Expand()`
	`378`	`+ public void Expand(bool raisedByUser)`
`387`	`379`	`{`
`388`	`380`	`if (!_isExpanded)`
`389`		`- Expand(true);`
	`381`	`+ Expand(true, raisedByUser);`
`390`	`382`	`}`
`391`	`383`
`392`	`384`	`public void ExpandAll()`
`393`	`385`	`{`
`394`		`- Expand(false);`
	`386`	`+ Expand(false, false);`
`395`	`387`	`}`
`396`	`388`
`397`		`- public void Expand(bool ignoreChildren)`
	`389`	`+ public void Expand(bool ignoreChildren, bool raisedByUser)`
`398`	`390`	`{`
`399`	`391`	`SetIsExpanded(true, ignoreChildren);`
`400`	`392`	`}`
Original file line number	Diff line number	Diff line change
`@@ -194,7 +194,12 @@ protected override void OnMouseDoubleClick(MouseEventArgs e)`
`194`	`194`	`if (!args.Handled)`
`195`	`195`	`{`
`196`	`196`	`if (args.Node != null && args.Button == MouseButtons.Left)`
`197`		`- args.Node.IsExpanded = !args.Node.IsExpanded;`
	`197`	`+ {`
	`198`	`+ if (args.Node.IsExpanded)`
	`199`	`+ args.Node.Collapse(true);`
	`200`	`+ else`
	`201`	`+ args.Node.Expand(true);`
	`202`	`+ }`
`198`	`203`	`}`
`199`	`204`	`}`
`200`	`205`
Original file line number	Diff line number	Diff line change
`@@ -129,10 +129,10 @@ private void OnCollapsing(TreeNodeAdv node)`
`129`	`129`
`130`	`130`	`[Category("Behavior")]`
`131`	`131`	`public event EventHandler<TreeViewAdvEventArgs> Collapsed;`
`132`		`- private void OnCollapsed(TreeNodeAdv node)`
	`132`	`+ private void OnCollapsed(TreeNodeAdv node, bool byUser)`
`133`	`133`	`{`
`134`	`134`	`if (Collapsed != null)`
`135`		`- Collapsed(this, new TreeViewAdvEventArgs(node));`
	`135`	`+ Collapsed(this, new TreeViewAdvEventArgs(node, byUser));`
`136`	`136`	`}`
`137`	`137`
`138`	`138`	`[Category("Behavior")]`
`@@ -145,10 +145,10 @@ private void OnExpanding(TreeNodeAdv node)`
`145`	`145`
`146`	`146`	`[Category("Behavior")]`
`147`	`147`	`public event EventHandler<TreeViewAdvEventArgs> Expanded;`
`148`		`- private void OnExpanded(TreeNodeAdv node)`
	`148`	`+ private void OnExpanded(TreeNodeAdv node, bool byUser)`
`149`	`149`	`{`
`150`	`150`	`if (Expanded != null)`
`151`		`- Expanded(this, new TreeViewAdvEventArgs(node));`
	`151`	`+ Expanded(this, new TreeViewAdvEventArgs(node, byUser));`
`152`	`152`	`}`
`153`	`153`
`154`	`154`	`[Category("Behavior")]`
`@@ -436,7 +436,7 @@ public void EnsureVisible(TreeNodeAdv node)`
`436`	`436`	`TreeNodeAdv parent = node.Parent;`
`437`	`437`	`while (parent != _root)`
`438`	`438`	`{`
`439`		`- parent.IsExpanded = true;`
	`439`	`+ parent.Expand(false);`
`440`	`440`	`parent = parent.Parent;`
`441`	`441`	`}`
`442`	`442`	`ScrollTo(node);`
`@@ -717,7 +717,7 @@ private void CreateNodes()`
`717`	`717`	`Selection.Clear();`
`718`	`718`	`SelectionStart = null;`
`719`	`719`	`_root = new TreeNodeAdv(this, null);`
`720`		`- _root.IsExpanded = true;`
	`720`	`+ _root.Expand(false);`
`721`	`721`	`if (_root.Nodes.Count > 0)`
`722`	`722`	`CurrentNode = _root.Nodes[0];`
`723`	`723`	`else`
`@@ -778,6 +778,7 @@ private struct ExpandArgs`
`778`	`778`	`public TreeNodeAdv Node;`
`779`	`779`	`public bool Value;`
`780`	`780`	`public bool IgnoreChildren;`
	`781`	`+ public bool ChangedByUser;`
`781`	`782`	`}`
`782`	`783`
`783`	`784`	`public void AbortBackgroundExpandingThreads()`
`@@ -789,7 +790,7 @@ public void AbortBackgroundExpandingThreads()`
`789`	`790`	`Invalidate();`
`790`	`791`	`}`
`791`	`792`
`792`		`- internal void SetIsExpanded(TreeNodeAdv node, bool value, bool ignoreChildren)`
	`793`	`+ internal void SetIsExpanded(TreeNodeAdv node, bool value, bool ignoreChildren, bool byUser)`
`793`	`794`	`{`
`794`	`795`	`ExpandArgs eargs = new ExpandArgs();`
`795`	`796`	`eargs.Node = node;`
`@@ -798,22 +799,22 @@ internal void SetIsExpanded(TreeNodeAdv node, bool value, bool ignoreChildren)`
`798`	`799`
`799`	`800`	`if (AsyncExpanding && LoadOnDemand && !_threadPool.IsMyThread(Thread.CurrentThread))`
`800`	`801`	`{`
`801`		`- WaitCallback wc = delegate(object argument) { SetIsExpanded((ExpandArgs)argument); };`
	`802`	`+ WaitCallback wc = delegate(object argument) { SetIsExpanded((ExpandArgs)argument, byUser); };`
`802`	`803`	`_threadPool.QueueUserWorkItem(wc, eargs);`
`803`	`804`	`}`
`804`	`805`	`else`
`805`		`- SetIsExpanded(eargs);`
	`806`	`+ SetIsExpanded(eargs, byUser);`
`806`	`807`	`}`
`807`	`808`
`808`		`- private void SetIsExpanded(ExpandArgs eargs)`
	`809`	`+ private void SetIsExpanded(ExpandArgs eargs, bool byUser)`
`809`	`810`	`{`
`810`	`811`	`bool update = !eargs.IgnoreChildren && !AsyncExpanding;`
`811`	`812`	`if (update)`
`812`	`813`	`BeginUpdate();`
`813`	`814`	`try`
`814`	`815`	`{`
`815`	`816`	`if (IsMyNode(eargs.Node) && eargs.Node.IsExpanded != eargs.Value)`
`816`		`- SetIsExpanded(eargs.Node, eargs.Value);`
	`817`	`+ SetIsExpanded(eargs.Node, eargs.Value, byUser);`
`817`	`818`
`818`	`819`	`if (!eargs.IgnoreChildren)`
`819`	`820`	`SetIsExpandedRecursive(eargs.Node, eargs.Value);`
`@@ -825,7 +826,7 @@ private void SetIsExpanded(ExpandArgs eargs)`
`825`	`826`	`}`
`826`	`827`	`}`
`827`	`828`
`828`		`- internal void SetIsExpanded(TreeNodeAdv node, bool value)`
	`829`	`+ internal void SetIsExpanded(TreeNodeAdv node, bool value, bool byUser)`
`829`	`830`	`{`
`830`	`831`	`if (Root == node && !value)`
`831`	`832`	`return; //Can't collapse root node`
`@@ -857,13 +858,13 @@ internal void SetIsExpanded(TreeNodeAdv node, bool value)`
`857`	`858`
`858`	`859`	`if (value)`
`859`	`860`	`{`
`860`		`- OnExpanded(node);`
`861`		`- node.OnExpanded();`
	`861`	`+ OnExpanded(node, byUser);`
	`862`	`+ node.OnExpanded(byUser);`
`862`	`863`	`}`
`863`	`864`	`else`
`864`	`865`	`{`
`865`		`- OnCollapsed(node);`
`866`		`- node.OnCollapsed();`
	`866`	`+ OnCollapsed(node, byUser);`
	`867`	`+ node.OnCollapsed(byUser);`
`867`	`868`	`}`
`868`	`869`	`}`
`869`	`870`
`@@ -887,7 +888,10 @@ internal void SetIsExpandedRecursive(TreeNodeAdv root, bool value)`
`887`	`888`	`for (int i = 0; i < root.Nodes.Count; i++)`
`888`	`889`	`{`
`889`	`890`	`TreeNodeAdv node = root.Nodes[i];`
`890`		`- node.IsExpanded = value;`
	`891`	`+ if (value)`
	`892`	`+ node.Expand(false);`
	`893`	`+ else`
	`894`	`+ node.Collapse(false);`
`891`	`895`	`SetIsExpandedRecursive(node, value);`
`892`	`896`	`}`
`893`	`897`	`}`
`@@ -1143,7 +1147,7 @@ private void RestoreExpandedNodes(TreeNodeAdv node, Dictionary<object, object> l`
`1143`	`1147`	`{`
`1144`	`1148`	`if (node.Tag != null && list.ContainsKey(node.Tag))`
`1145`	`1149`	`{`
`1146`		`- node.IsExpanded = true;`
	`1150`	`+ node.Expand(false);`
`1147`	`1151`	`foreach (var child in node.Children)`
`1148`	`1152`	`RestoreExpandedNodes(child, list);`
`1149`	`1153`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,21 +1,16 @@`
`1`	`1`	`using System;`
`2`		`-using System.Collections.Generic;`
`3`		`-using System.Text;`
`4`	`2`
`5`	`3`	`namespace Aga.Controls.Tree`
`6`	`4`	`{`
`7`	`5`	`public class TreeViewAdvEventArgs : EventArgs`
`8`	`6`	`{`
`9`		`- private TreeNodeAdv _node;`
	`7`	`+ public TreeNodeAdv Node { get; }`
	`8`	`+ public bool RaisedByUser { get; }`
`10`	`9`
`11`		`- public TreeNodeAdv Node`
	`10`	`+ public TreeViewAdvEventArgs(TreeNodeAdv node, bool raisedByUser = false)`
`12`	`11`	`{`
`13`		`- get { return _node; }`
`14`		`- }`
`15`		`-`
`16`		`- public TreeViewAdvEventArgs(TreeNodeAdv node)`
`17`		`- {`
`18`		`- _node = node;`
`19`		`- }`
	`12`	`+ Node = node;`
	`13`	`+ RaisedByUser = raisedByUser;`
	`14`	`+ }`
`20`	`15`	`}`
`21`	`16`	`}`
Original file line number	Diff line number	Diff line change
`@@ -617,7 +617,7 @@ private void Timer_Tick(object sender, EventArgs e)`
`617`	`617`	`if (!backgroundUpdater.IsBusy)`
`618`	`618`	`backgroundUpdater.RunWorkerAsync();`
`619`	`619`
`620`		`- //RestoreCollapsedNodeState(treeView);`
	`620`	`+ RestoreCollapsedNodeState(treeView);`
`621`	`621`	`}`
`622`	`622`
`623`	`623`	`private void SaveConfiguration()`
`@@ -675,7 +675,7 @@ private void RestoreCollapsedNodeState(TreeViewAdv treeViewAdv)`
`675`	`675`
`676`	`676`	`foreach (TreeNodeAdv node in collapsedHwNodes)`
`677`	`677`	`{`
`678`		`- node.IsExpanded = false;`
	`678`	`+ node.Collapse(false);`
`679`	`679`	`}`
`680`	`680`	`}`
`681`	`681`
`@@ -713,23 +713,20 @@ private void AboutMenuItem_Click(object sender, EventArgs e)`
`713`	`713`	`_ = new AboutBox().ShowDialog();`
`714`	`714`	`}`
`715`	`715`
	`716`	`+ private void TreeView_CollapsedOrExpanded(object sender, TreeViewAdvEventArgs info)`
	`717`	`+ {`
	`718`	`+ if (info.RaisedByUser && info.Node.Tag is IExpandPersistNode expandPersistNode)`
	`719`	`+ expandPersistNode.Expanded = info.Node.IsExpanded;`
	`720`	`+ }`
	`721`	`+`
`716`	`722`	`private void TreeView_Click(object sender, EventArgs e)`
`717`	`723`	`{`
`718`	`724`	`if (!(e is MouseEventArgs m) \|\| (m.Button != MouseButtons.Left && m.Button != MouseButtons.Right))`
`719`	`725`	`return;`
`720`	`726`
`721`	`727`	`NodeControlInfo info = treeView.GetNodeControlInfoAt(new Point(m.X, m.Y));`
`722`		`- if (m.Button == MouseButtons.Left && info.Node != null)`
`723`		`- {`
`724`		`- if (info.Node.Tag is IExpandPersistNode expandPersistNode)`
`725`		`- {`
`726`		`- expandPersistNode.Expanded = info.Node.IsExpanded;`
`727`		`- }`
`728`		`- return;`
`729`		`- }`
`730`		`-`
`731`	`728`	`treeView.SelectedNode = info.Node;`
`732`		`- if (info.Node != null)`
	`729`	`+ if (m.Button == MouseButtons.Right && info.Node != null)`
`733`	`730`	`{`
`734`	`731`	`if (info.Node.Tag is SensorNode node && node.Sensor != null)`
`735`	`732`	`{`