Watch node custom size serialization (#13844)

reddyashish · web-flow · commit 6447f9e0c966 · 2023-03-28T14:02:09.000-04:00
* Watch node custom size serialization

* Fix tests

* Fix edge cases.

* Add test

* Fix tests

* comments
diff --git a/src/DynamoCoreWpf/ViewModels/Preview/WatchViewModel.cs b/src/DynamoCoreWpf/ViewModels/Preview/WatchViewModel.cs
@@ -9,6 +9,7 @@
 using Dynamo.Utilities;
 using Microsoft.Practices.Prism.ViewModel;
 using Dynamo.Configuration;
+using CoreNodeModels;
 
 namespace Dynamo.ViewModels
 {
@@ -36,6 +37,8 @@ internal void Click()
         public const string EMPTY_DICTIONARY = "Empty Dictionary";
         public const string DICTIONARY = "Dictionary";
 
+        internal Watch WatchNode { get; set; }
+
         private ObservableCollection<WatchViewModel> children = new ObservableCollection<WatchViewModel>();
         private string label;
         private string link;
diff --git a/src/DynamoCoreWpf/Views/Preview/WatchTree.xaml.cs b/src/DynamoCoreWpf/Views/Preview/WatchTree.xaml.cs
@@ -1,8 +1,9 @@
-﻿using System.Windows;
+using System.Windows;
 using System.Windows.Controls;
 using System.Windows.Controls.Primitives;
 using Dynamo.ViewModels;
 using System;
+using CoreNodeModels;
 
 namespace Dynamo.Controls
 {
@@ -15,10 +16,10 @@ public partial class WatchTree : UserControl
     {
         private WatchViewModel _vm;
         private WatchViewModel prevWatchViewModel;
-        private readonly double defaultWidthSize = 200;
+        private static readonly double defaultWidthSize = 200;
         private readonly double extraWidthSize = 20;
         private readonly double widthPerCharacter = 7.5;
-        private readonly int defaultHeightSize = 200;
+        private static readonly int defaultHeightSize = 200;
         private readonly int minWidthSize = 100;
         private readonly int minHeightSize = 38;
         private readonly int minHeightForList = 83;
@@ -34,8 +35,8 @@ public WatchTree(WatchViewModel vm)
             this.Unloaded += WatchTree_Unloaded;
         }
 
-        internal double DefaultWidthSize { get { return defaultWidthSize; } }
-        internal double DefaultHeightSize { get { return defaultHeightSize; } }
+        internal static double DefaultWidthSize { get { return defaultWidthSize; } }
+        internal static double DefaultHeightSize { get { return defaultHeightSize; } }
         internal double ExtratWidthSize { get { return extraWidthSize; } }
         internal double WidthPerCharacter { get { return widthPerCharacter; } }
         internal double MaxWidthSize { get { return defaultWidthSize * 2; } }
@@ -53,15 +54,27 @@ void WatchTree_Loaded(object sender, RoutedEventArgs e)
 
         private void _vm_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
         {
+            //We need to restore the custom size for the watch nodes in the workspace. 
+            var customSizesDict = Watch.NodeSizes;
+            var customWidth = double.NaN;
+            var customHeight= double.NaN;
+
+            if (_vm.WatchNode != null)
+            {
+                customSizesDict.TryGetValue(_vm.WatchNode.GUID, out var customSizes);
+                customWidth = customSizes == null ? double.NaN : customSizes.Item1;
+                customHeight = customSizes == null ? double.NaN : customSizes.Item2;
+            }
+
             if (e.PropertyName == nameof(WatchViewModel.IsCollection))
             {
                 // // The WatchTree controll will resize only if its role is a WatchNode (starts with an specific height), otherwise it won't resize (Bubble role).
                 if (!Double.IsNaN(this.Height))
                 {
                     if (_vm.IsCollection)
                     {
-                        this.Height = defaultHeightSize;
-                        this.inputGrid.MinHeight = minHeightForList;
+                        Height = this.Height != customHeight ? defaultHeightSize : Height;
+                        inputGrid.MinHeight = minHeightForList;
                     }
                     else
                     {
@@ -70,7 +83,7 @@ private void _vm_PropertyChanged(object sender, System.ComponentModel.PropertyCh
                         {
                             if (NodeLabel.Contains(Environment.NewLine) || NodeLabel.ToUpper() == nameof(WatchViewModel.DICTIONARY))
                             {
-                                this.Height = defaultHeightSize;
+                                Height = this.Height != customHeight ? defaultHeightSize : Height;
                             }
                         }
                     }
@@ -99,7 +112,7 @@ private void _vm_PropertyChanged(object sender, System.ComponentModel.PropertyCh
                     }
                     else
                     {
-                        this.Width = defaultWidthSize;
+                        this.Width = this.Width != customWidth ? defaultWidthSize : this.Width;
                     }
                 }
             }
@@ -213,6 +226,8 @@ private void ThumbResizeThumbOnDragDeltaHandler(object sender, DragDeltaEventArg
             {
                 Height = yAdjust;
             }
+
+            Watch.NodeSizes[_vm.WatchNode.GUID] = new Tuple<double, double>(Width, Height);
         }
     }
 }
diff --git a/src/Libraries/CoreNodeModels/Watch.cs b/src/Libraries/CoreNodeModels/Watch.cs
@@ -1,4 +1,4 @@
-﻿using System;
+using System;
 using System.Collections.Generic;
 using CoreNodeModels.Properties;
 using Dynamo.Engine;
@@ -40,6 +40,22 @@ private Watch(IEnumerable<PortModel> inPorts, IEnumerable<PortModel> outPorts):b
             HasRunOnce = false;
         }
 
+        /// <summary>
+        ///     Watch node's Width
+        public double WatchWidth { get; set; }
+        /// <summary>
+        ///     Watch node's Height
+        public double WatchHeight { get; set; }
+
+        //Stores the custom sizes for each watch node.
+        public static Dictionary<Guid, Tuple<double,double>> NodeSizes = new Dictionary<Guid, Tuple<double, double>>();
+
+        public void SetWatchSize(double w, double h)
+        {
+            WatchWidth = w;
+            WatchHeight = h;
+        }
+
         public Watch()
         {
             InPorts.Add(new PortModel(PortType.Input, this, new PortData("", Resources.WatchPortDataInputToolTip)));
@@ -48,7 +64,6 @@ public Watch()
             RegisterAllPorts();
 
             ArgumentLacing = LacingStrategy.Disabled;
-
             ShouldDisplayPreviewCore = false;
             HasRunOnce = false;
         }
diff --git a/src/Libraries/CoreNodeModelsWpf/NodeViewCustomizations/Watch.cs b/src/Libraries/CoreNodeModelsWpf/NodeViewCustomizations/Watch.cs
@@ -43,20 +43,35 @@ public void CustomizeView(Watch nodeModel, NodeView nodeView)
             rootWatchViewModel = new WatchViewModel(dynamoViewModel.BackgroundPreviewViewModel.AddLabelForPath);
 
             var watchTree = new WatchTree(rootWatchViewModel);
+
+            rootWatchViewModel.WatchNode = watch;
             watchTree.BorderThickness = new Thickness(1, 1, 1, 1);
             watchTree.BorderBrush = new SolidColorBrush(Color.FromRgb(220,220,220));
 
             watchTree.SetWatchNodeProperties();
 
+            nodeView.SizeChanged += (sender, args) =>
+                nodeModel.SetSize(args.NewSize.Width, args.NewSize.Height);
+
+            watchTree.SizeChanged += (sender, args) =>
+                nodeModel.SetWatchSize(args.NewSize.Width, args.NewSize.Height);
+
             nodeView.PresentationGrid.Children.Add(watchTree);
             nodeView.PresentationGrid.Visibility = Visibility.Visible;
             // disable preview control
             nodeView.TogglePreviewControlAllowance();
 
+            ResetWatch();
+
+            watchTree.Width = nodeModel.WatchWidth == 0 ? watchTree.Width : nodeModel.WatchWidth;
+            watchTree.Height = nodeModel.WatchHeight == 0 ? watchTree.Height : nodeModel.WatchHeight;
+            
+            //Store width and height info of the node in the dictionary.
+            Watch.NodeSizes[watch.GUID] = new Tuple<double, double>(nodeModel.WatchWidth, nodeModel.WatchHeight);
+
             Bind(watchTree, nodeView);
 
             Subscribe();
-            ResetWatch();
         }
 
         private void Bind(WatchTree watchTree, NodeView nodeView)
@@ -132,6 +147,9 @@ private void OnPortConnected(PortModel port, ConnectorModel connectorModel)
         {
             Tuple<int, NodeModel> input;
 
+            //set default width and height when a new connection is made to the watch node.
+            watch.SetWatchSize(WatchTree.DefaultWidthSize, WatchTree.DefaultHeightSize);
+
             if (!watch.TryGetInput(watch.InPorts.IndexOf(connectorModel.End), out input)
                 || astBeingComputed == null) return;
 
@@ -265,4 +283,4 @@ private void OnCopyToClipboardClick(object sender, RoutedEventArgs e)
             if (!string.IsNullOrEmpty(content)) Clipboard.SetText(content);
         }
     }
-}
+}
diff --git a/test/DynamoCoreWpfTests/PreviewBubbleTests.cs b/test/DynamoCoreWpfTests/PreviewBubbleTests.cs
@@ -294,7 +294,7 @@ public void Watch_DefaultSize()
             DispatcherUtil.DoEvents();
 
             Assert.NotNull(rawEmptyWatchNode);
-            Assert.AreEqual(rawEmptyWatchNode.Width, rawEmptyWatchNode.DefaultWidthSize);
+            Assert.AreEqual(rawEmptyWatchNode.Width, WatchTree.DefaultWidthSize);
         }
 
         [Test]
@@ -358,7 +358,7 @@ public void Watch_ListSize()
 
             Assert.NotNull(listWatchNode);
             Assert.IsTrue(isTheCodeAList);
-            Assert.AreEqual(rawListWatchNode.Height, rawListWatchNode.DefaultHeightSize);
+            Assert.AreEqual(rawListWatchNode.Height, WatchTree.DefaultHeightSize);
         }
 
         [Test]
@@ -444,7 +444,7 @@ public void Watch_MultilineString()
 
             Assert.NotNull(multiLineStringWatchNode);
             Assert.IsTrue(containsNewLine);
-            Assert.AreEqual(rawMultiLineStringtWatchNode.DefaultHeightSize, rawMultiLineStringtWatchNode.Height);
+            Assert.AreEqual(WatchTree.DefaultHeightSize, rawMultiLineStringtWatchNode.Height);
         }
 
         [Test]
@@ -470,7 +470,7 @@ public void Watch_Dictionary()
 
             Assert.NotNull(dictionaryWatchNode);
             Assert.IsTrue(isDictionary);
-            Assert.AreEqual(rawDictionaryWatchNode.DefaultHeightSize, rawDictionaryWatchNode.Height);
+            Assert.AreEqual(WatchTree.DefaultHeightSize, rawDictionaryWatchNode.Height);
         }
 
         #endregion
diff --git a/test/DynamoCoreWpfTests/WatchNodeTests.cs b/test/DynamoCoreWpfTests/WatchNodeTests.cs
@@ -1,16 +1,17 @@
-﻿using Dynamo.Interfaces;
-using NUnit.Framework;
-using System.IO;
-using Dynamo.ViewModels;
-using ProtoCore.Mirror;
 using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
 using System.Linq;
+using System.Threading;
 using CoreNodeModels;
+using Dynamo.Controls;
 using Dynamo.Graph.Nodes;
 using Dynamo.Graph.Nodes.ZeroTouch;
+using Dynamo.Interfaces;
 using Dynamo.Tests;
-using System.Globalization;
-using System.Threading;
+using Dynamo.ViewModels;
+using NUnit.Framework;
+using ProtoCore.Mirror;
 
 namespace DynamoCoreWpfTests 
 {
@@ -256,6 +257,44 @@ public void WatchNestedDictionary()
             Assert.AreEqual(2, watchVM.NumberOfItems);
         }
 
+        [Test]
+        public void WatchNodeSizeSerializationTest()
+        {
+            string openPath = Path.Combine(TestDirectory, @"core\watch\WatchSerializationTest.dyn");
+            ViewModel.OpenCommand.Execute(openPath);
+            ViewModel.HomeSpace.Run();
+
+            var watchNode = ViewModel.Model.CurrentWorkspace.NodeFromWorkspace("76ea40b1-5e21-48b8-9051-0b6b03ee5075") as Watch;
+
+            //assert default width and height for the watch node.
+            Assert.AreEqual(watchNode.WatchWidth, WatchTree.DefaultWidthSize);
+            Assert.AreEqual(watchNode.WatchHeight, WatchTree.DefaultHeightSize);
+            
+            //Set the width and height of watch node to new values.
+            watchNode.WatchWidth = 150;
+            watchNode.WatchHeight = 300;
+
+            //save the workspace and reopen it to test (de)seralization
+            ViewModel.HomeSpace.Save(openPath);
+            ViewModel.HomeSpace.Clear();
+
+            ViewModel.OpenCommand.Execute(openPath);
+            ViewModel.HomeSpace.Run();
+
+            watchNode = ViewModel.Model.CurrentWorkspace.NodeFromWorkspace("76ea40b1-5e21-48b8-9051-0b6b03ee5075") as Watch;
+
+            //Assert new width and height
+            Assert.AreEqual(watchNode.WatchWidth, 150);
+            Assert.AreEqual(watchNode.WatchHeight, 300);
+
+            //reset back to default.
+            watchNode.WatchWidth = WatchTree.DefaultWidthSize;
+            watchNode.WatchHeight = WatchTree.DefaultHeightSize;
+
+            ViewModel.HomeSpace.Save(openPath);
+            ViewModel.HomeSpace.Clear();
+        }
+
         [Test]
         public void WatchNumber()
         {
diff --git a/test/core/watch/WatchSerializationTest.dyn b/test/core/watch/WatchSerializationTest.dyn

Original file line number	Diff line number	Diff line change
`@@ -1,8 +1,9 @@`
`1`		`-using System.Windows;`
	`1`	`+using System.Windows;`
`2`	`2`	`using System.Windows.Controls;`
`3`	`3`	`using System.Windows.Controls.Primitives;`
`4`	`4`	`using Dynamo.ViewModels;`
`5`	`5`	`using System;`
	`6`	`+using CoreNodeModels;`
`6`	`7`
`7`	`8`	`namespace Dynamo.Controls`
`8`	`9`	`{`
`@@ -15,10 +16,10 @@ public partial class WatchTree : UserControl`
`15`	`16`	`{`
`16`	`17`	`private WatchViewModel _vm;`
`17`	`18`	`private WatchViewModel prevWatchViewModel;`
`18`		`- private readonly double defaultWidthSize = 200;`
	`19`	`+ private static readonly double defaultWidthSize = 200;`
`19`	`20`	`private readonly double extraWidthSize = 20;`
`20`	`21`	`private readonly double widthPerCharacter = 7.5;`
`21`		`- private readonly int defaultHeightSize = 200;`
	`22`	`+ private static readonly int defaultHeightSize = 200;`
`22`	`23`	`private readonly int minWidthSize = 100;`
`23`	`24`	`private readonly int minHeightSize = 38;`
`24`	`25`	`private readonly int minHeightForList = 83;`
`@@ -34,8 +35,8 @@ public WatchTree(WatchViewModel vm)`
`34`	`35`	`this.Unloaded += WatchTree_Unloaded;`
`35`	`36`	`}`
`36`	`37`
`37`		`- internal double DefaultWidthSize { get { return defaultWidthSize; } }`
`38`		`- internal double DefaultHeightSize { get { return defaultHeightSize; } }`
	`38`	`+ internal static double DefaultWidthSize { get { return defaultWidthSize; } }`
	`39`	`+ internal static double DefaultHeightSize { get { return defaultHeightSize; } }`
`39`	`40`	`internal double ExtratWidthSize { get { return extraWidthSize; } }`
`40`	`41`	`internal double WidthPerCharacter { get { return widthPerCharacter; } }`
`41`	`42`	`internal double MaxWidthSize { get { return defaultWidthSize * 2; } }`
`@@ -53,15 +54,27 @@ void WatchTree_Loaded(object sender, RoutedEventArgs e)`
`53`	`54`
`54`	`55`	`private void _vm_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)`
`55`	`56`	`{`
	`57`	`+ //We need to restore the custom size for the watch nodes in the workspace.`
	`58`	`+ var customSizesDict = Watch.NodeSizes;`
	`59`	`+ var customWidth = double.NaN;`
	`60`	`+ var customHeight= double.NaN;`
	`61`	`+`
	`62`	`+ if (_vm.WatchNode != null)`
	`63`	`+ {`
	`64`	`+ customSizesDict.TryGetValue(_vm.WatchNode.GUID, out var customSizes);`
	`65`	`+ customWidth = customSizes == null ? double.NaN : customSizes.Item1;`
	`66`	`+ customHeight = customSizes == null ? double.NaN : customSizes.Item2;`
	`67`	`+ }`
	`68`	`+`
`56`	`69`	`if (e.PropertyName == nameof(WatchViewModel.IsCollection))`
`57`	`70`	`{`
`58`	`71`	`// // The WatchTree controll will resize only if its role is a WatchNode (starts with an specific height), otherwise it won't resize (Bubble role).`
`59`	`72`	`if (!Double.IsNaN(this.Height))`
`60`	`73`	`{`
`61`	`74`	`if (_vm.IsCollection)`
`62`	`75`	`{`
`63`		`- this.Height = defaultHeightSize;`
`64`		`- this.inputGrid.MinHeight = minHeightForList;`
	`76`	`+ Height = this.Height != customHeight ? defaultHeightSize : Height;`
	`77`	`+ inputGrid.MinHeight = minHeightForList;`
`65`	`78`	`}`
`66`	`79`	`else`
`67`	`80`	`{`
`@@ -70,7 +83,7 @@ private void _vm_PropertyChanged(object sender, System.ComponentModel.PropertyCh`
`70`	`83`	`{`
`71`	`84`	`if (NodeLabel.Contains(Environment.NewLine) \|\| NodeLabel.ToUpper() == nameof(WatchViewModel.DICTIONARY))`
`72`	`85`	`{`
`73`		`- this.Height = defaultHeightSize;`
	`86`	`+ Height = this.Height != customHeight ? defaultHeightSize : Height;`
`74`	`87`	`}`
`75`	`88`	`}`
`76`	`89`	`}`
`@@ -99,7 +112,7 @@ private void _vm_PropertyChanged(object sender, System.ComponentModel.PropertyCh`
`99`	`112`	`}`
`100`	`113`	`else`
`101`	`114`	`{`
`102`		`- this.Width = defaultWidthSize;`
	`115`	`+ this.Width = this.Width != customWidth ? defaultWidthSize : this.Width;`
`103`	`116`	`}`
`104`	`117`	`}`
`105`	`118`	`}`
`@@ -213,6 +226,8 @@ private void ThumbResizeThumbOnDragDeltaHandler(object sender, DragDeltaEventArg`
`213`	`226`	`{`
`214`	`227`	`Height = yAdjust;`
`215`	`228`	`}`
	`229`	`+`
	`230`	`+ Watch.NodeSizes[_vm.WatchNode.GUID] = new Tuple<double, double>(Width, Height);`
`216`	`231`	`}`
`217`	`232`	`}`
`218`	`233`	`}`