DYN-9313-Resizing group should feel natural and not jumpy (DynamoDS#16453)

Co-authored-by: Ashish Aggarwal <ashish.aggarwal@autodesk.com>
Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

Author: 3 people

src/DynamoCore/Graph/Annotations/AnnotationModel.cs

@@ -23,6 +23,8 @@ public class AnnotationModel : ModelBase
         private const double ExtendSize = 10.0;
         private const double ExtendYHeight = 5.0;
         private const double NoteYAdjustment = 8.0;
+        private bool isTextChanging;
+        internal bool IsThumbResizing;
 
         #region Properties
 
@@ -259,7 +261,10 @@ public double TextBlockHeight
                 // a model and textbox. Otherwise there will be some overlap
                 Y = InitialTop - ExtendSize - textBlockHeight;
                 Height = InitialHeight + textBlockHeight - MinTextHeight;
+
+                isTextChanging = true;
                 UpdateBoundaryFromSelection();
+                isTextChanging = false;
             }
         }
 
@@ -342,7 +347,10 @@ public double WidthAdjustment
             {
                 if (value == widthAdjustment) return;
                 widthAdjustment = value;
-                UpdateBoundaryFromSelection();
+
+                // update boundary only while manually resizing the group
+                if (IsThumbResizing)
+                    UpdateBoundaryFromSelection();
             }
         }
 
@@ -359,7 +367,40 @@ public double HeightAdjustment
             {
                 if (value == heightAdjustment) return;
                 heightAdjustment = value;
-                UpdateBoundaryFromSelection();
+
+                // update boundary only while manually resizing the group
+                if (IsThumbResizing)
+                    UpdateBoundaryFromSelection();
+            }
+        }
+
+        private double userSetHeight;
+        /// <summary>
+        /// Indicates the height the user manually set using the resize thumb.
+        /// </summary>
+        public double UserSetHeight
+        {
+            get => userSetHeight;
+            set
+            {
+                if (value == userSetHeight) return;
+                userSetHeight = value;
+            }
+        }
+
+        private double userSetWidth;
+        /// <summary>
+        /// Indicates the height the user manually set using the resize thumb.
+        /// Indicates the width the user manually set using the resize thumb.
+        /// Not necessarily equal to the actual rendered width.
+        /// </summary>  
+        public double UserSetWidth
+        {
+            get => userSetWidth;
+            set
+            {
+                if (value == userSetWidth) return;
+                userSetWidth = value;
             }
         }
 
@@ -751,10 +792,60 @@ private void UpdateExpandedLayout(List<ModelBase> groupModels, double regionX, d
                 Height = yDistance + ExtendSize + ExtendYHeight + HeightAdjustment - TextBlockHeight
             };
 
-            // Store layout size and apply dimensions
-            ModelAreaHeight = region.Height;
-            Height = ModelAreaHeight + TextBlockHeight;
-            Width = Math.Max(region.Width, TextMaxWidth + ExtendSize);
+            // The actual space used by nodes (without adjustments)
+            double groupCalculatedWidth = xDistance + ExtendSize;
+            double groupCalculatedHeight = yDistance + ExtendSize + ExtendYHeight - TextBlockHeight;
+
+            if (IsThumbResizing || isTextChanging)
+            {
+                // While dragging the resize thumb or editing text
+                ModelAreaHeight = region.Height;
+                Height = ModelAreaHeight + TextBlockHeight;
+                Width = Math.Max(region.Width, TextMaxWidth + ExtendSize);
+            }
+            else
+            {
+                // HEIGHT logic
+                // user has not resized the group
+                if (UserSetHeight <= 0) 
+                {
+                    ModelAreaHeight = groupCalculatedHeight;
+                    Height = ModelAreaHeight + TextBlockHeight;
+                }
+                // some nodes are outside the user set size 
+                else if (groupCalculatedHeight >= UserSetHeight)
+                {
+                    ModelAreaHeight = groupCalculatedHeight;
+                    Height = ModelAreaHeight + TextBlockHeight;
+                    HeightAdjustment = 0;
+                }
+                // all nodes are within the user set size
+                else
+                {
+                    HeightAdjustment = Math.Max(0, UserSetHeight - groupCalculatedHeight);
+                    ModelAreaHeight = UserSetHeight;
+                    Height = UserSetHeight + TextBlockHeight;
+                }
+
+                // WIDTH logic
+                // user has not resized the group
+                if (UserSetWidth <= 0) 
+                {
+                    Width = Math.Max(region.Width, TextMaxWidth + ExtendSize);
+                }
+                // some nodes are outside the user set size 
+                else if (groupCalculatedWidth >= UserSetWidth) 
+                {
+                    Width = Math.Max(groupCalculatedWidth, TextMaxWidth + ExtendSize);
+                    WidthAdjustment = 0;
+                }
+                // all nodes are within the user set size
+                else
+                {
+                    WidthAdjustment = Math.Max(0, UserSetWidth - groupCalculatedWidth);
+                    Width = UserSetWidth;
+                }
+            }
 
             // Only store the first calculated initial height
             if (InitialHeight <= 0.0)

src/DynamoCore/Graph/Workspaces/WorkspaceModel.cs

@@ -143,6 +143,8 @@ public class ExtraAnnotationViewInfo
         public string PinnedNode;
         public double WidthAdjustment;
         public double HeightAdjustment;
+        public double UserSetWidth;
+        public double UserSetHeight;
         public bool IsOptionalInPortsCollapsed;
         public bool IsUnconnectedOutPortsCollapsed;
         public bool hasToggledOptionalInPorts;
@@ -176,6 +178,8 @@ public override bool Equals(object obj)
                 this.Background == other.Background &&
                 this.WidthAdjustment == other.WidthAdjustment &&
                 this.HeightAdjustment == other.HeightAdjustment &&
+                this.UserSetWidth == other.UserSetWidth &&
+                this.UserSetHeight == other.UserSetHeight &&
                 this.IsOptionalInPortsCollapsed == other.IsOptionalInPortsCollapsed &&
                 this.IsUnconnectedOutPortsCollapsed == other.IsUnconnectedOutPortsCollapsed &&
                 this.hasToggledOptionalInPorts == other.hasToggledOptionalInPorts &&
@@ -2723,6 +2727,8 @@ private void LoadAnnotation(ExtraAnnotationViewInfo annotationViewInfo)
             annotationModel.GUID = annotationGuidValue;
             annotationModel.HeightAdjustment = annotationViewInfo.HeightAdjustment;
             annotationModel.WidthAdjustment = annotationViewInfo.WidthAdjustment;
+            annotationModel.UserSetWidth = annotationViewInfo.UserSetWidth;
+            annotationModel.UserSetHeight = annotationViewInfo.UserSetHeight;
             annotationModel.IsOptionalInPortsCollapsed = annotationViewInfo.IsOptionalInPortsCollapsed;
             annotationModel.IsUnconnectedOutPortsCollapsed = annotationViewInfo.IsUnconnectedOutPortsCollapsed;
             annotationModel.HasToggledOptionalInPorts = annotationViewInfo.hasToggledOptionalInPorts;

src/DynamoCore/Models/DynamoModel.cs

@@ -3354,6 +3354,8 @@ private AnnotationModel CreateAnnotationModel(
                 AnnotationDescriptionText = model.AnnotationDescriptionText,
                 HeightAdjustment = model.HeightAdjustment,
                 WidthAdjustment = model.WidthAdjustment,
+                UserSetWidth = model.UserSetWidth,
+                UserSetHeight = model.UserSetHeight,
                 Background = model.Background,
                 FontSize = model.FontSize,
                 GroupStyleId = model.GroupStyleId,

src/DynamoCoreWpf/ViewModels/Core/Converters/SerializationConverters.cs

@@ -131,6 +131,10 @@ public override void WriteJson(JsonWriter writer, object value, JsonSerializer s
             writer.WriteValue(anno.WidthAdjustment);
             writer.WritePropertyName(nameof(ExtraAnnotationViewInfo.HeightAdjustment));
             writer.WriteValue(anno.HeightAdjustment);
+            writer.WritePropertyName(nameof(ExtraAnnotationViewInfo.UserSetWidth));
+            writer.WriteValue(anno.UserSetWidth);
+            writer.WritePropertyName(nameof(ExtraAnnotationViewInfo.UserSetHeight));
+            writer.WriteValue(anno.UserSetHeight);
             writer.WritePropertyName("Nodes");
             writer.WriteStartArray();
             foreach (var m in anno.Nodes)

src/DynamoCoreWpf/Views/Core/AnnotationView.xaml.cs

@@ -251,6 +251,8 @@ private void AnnotationView_Unloaded(object sender, RoutedEventArgs e)
                 mainGroupThumb.DragDelta -= AnnotationRectangleThumb_DragDelta;
                 mainGroupThumb.MouseEnter -= Thumb_MouseEnter;
                 mainGroupThumb.MouseLeave -= Thumb_MouseLeave;
+                mainGroupThumb.DragStarted -= Thumb_DragStarted;
+                mainGroupThumb.DragCompleted -= Thumb_DragCompleted;
             }
             UnregisterNamesFromScope();
         }
@@ -638,6 +640,28 @@ private void Thumb_MouseLeave(object sender, MouseEventArgs e)
             ViewModel.WorkspaceViewModel.CurrentCursor = CursorLibrary.GetCursor(CursorSet.Pointer);
         }
 
+        /// <summary>
+        /// Triggered when the user starts resizing the group using the resize thumb.
+        /// Flag that manual resizing is in progress so user-set-size is not overridden by the model logic.
+        /// </summary>
+        private void Thumb_DragStarted(object sender, DragStartedEventArgs e)
+        {
+            ViewModel.AnnotationModel.IsThumbResizing = true;
+        }
+
+        /// <summary>
+        /// Triggered when the user completes resizing the group using the resize thumb.
+        /// Finalizes the manually set size so it's preserved, and disables resizing flag.
+        /// </summary>
+        private void Thumb_DragCompleted(object sender, DragCompletedEventArgs e)
+        {
+            var model = ViewModel.AnnotationModel;
+            model.UserSetWidth = model.Width;
+            model.UserSetHeight = model.ModelAreaHeight;
+
+            ViewModel.AnnotationModel.IsThumbResizing = false;
+        }
+
         private void GroupDescriptionTextBlock_IsVisibleChanged(object sender, DependencyPropertyChangedEventArgs e)
         {
             SetTextHeight();
@@ -1527,6 +1551,8 @@ private Thumb CreateResizeThumb()
             thumb.Style = _groupResizeThumbStyle;
             thumb.MouseEnter += Thumb_MouseEnter;
             thumb.MouseLeave += Thumb_MouseLeave;
+            thumb.DragStarted += Thumb_DragStarted;
+            thumb.DragCompleted += Thumb_DragCompleted;
 
             return thumb;
         }

test/DynamoCoreTests/Graph/Annotations/AnnotationModelTests.cs

@@ -207,12 +207,107 @@ public void GroupAdaptsToSizeAdjustments()
             var heightAdjustment = 100;
 
             // Act
+            annotationModel.IsThumbResizing = true;
             annotationModel.WidthAdjustment = widthAdjustment;
             annotationModel.HeightAdjustment = heightAdjustment;
+            annotationModel.IsThumbResizing = false;
 
             // Assert
             Assert.That(annotationModel.Width == initialWidth + widthAdjustment);
             Assert.That(annotationModel.Height == initialHeight + heightAdjustment);
         }
+
+        [Test]
+        [Category("UnitTests")]
+        public void GroupDoesNotExpandBeyondUserSetSizeWhenNodeIsInside()
+        {
+            // Arrange
+            // Add the first node to initialize the group
+            var firstNode = new DummyNode();
+            annotationModel.AddToTargetAnnotationModel(firstNode);
+
+            var originalWidth = annotationModel.Width;
+            var originalHeight = annotationModel.Height;
+            var originalRect = annotationModel.Rect;
+
+            // Simulate user resizing with thumb
+            annotationModel.UserSetWidth = originalWidth + 200;
+            annotationModel.UserSetHeight = originalHeight + 200;
+            annotationModel.UpdateBoundaryFromSelection();
+
+            var userResizedWidth = annotationModel.Width;
+            var userResizedHeight = annotationModel.Height;
+
+            Assert.AreEqual(1, annotationModel.Nodes.Count());
+            Assert.IsTrue(userResizedWidth > originalWidth);
+            Assert.IsTrue(userResizedHeight > originalHeight);
+
+            // Create a second node that sits within the resized area but outside the original bounds
+            var secondNode = new DummyNode { X = 100, Y = 50 };
+
+            // Confirm the node exceeds the original boundary
+            Assert.IsTrue(secondNode.Rect.Right > originalRect.Right);
+            Assert.IsTrue(secondNode.Rect.Bottom > originalRect.Bottom);
+
+            // Act
+            annotationModel.AddToTargetAnnotationModel(secondNode);
+            annotationModel.UpdateBoundaryFromSelection();
+
+            // Assert: group size should remain at user-set dimensions
+            Assert.AreEqual(2, annotationModel.Nodes.Count());
+            Assert.AreEqual(userResizedWidth, annotationModel.Width);
+            Assert.AreEqual(userResizedHeight, annotationModel.Height);
+        }
+
+        [Test]
+        [Category("UnitTests")]
+        public void GroupExpandsWhenNodeExceedsUserSetSize_AndShrinksBackOnRemoval()
+        {
+            // Arrange: Add an initial node to initialize the group
+            var firstNode = new DummyNode();
+            annotationModel.AddToTargetAnnotationModel(firstNode);
+
+            var initialWidth = annotationModel.Width;
+            var initialHeight = annotationModel.Height;
+
+            // Simulate manual resize by the user
+            annotationModel.UserSetWidth = initialWidth + 200;
+            annotationModel.UserSetHeight = initialHeight + 200;
+            annotationModel.UpdateBoundaryFromSelection();
+
+            var resizedWidth = annotationModel.Width;
+            var resizedHeight = annotationModel.Height;
+            var resizedRect = annotationModel.Rect;
+
+            // Assert: Manual resize increased size
+            Assert.Greater(resizedWidth, initialWidth);
+            Assert.Greater(resizedHeight, initialHeight);
+
+            // Arrange: Create a second node that is fully outside the resized boundary
+            var secondNode = new DummyNode { X = 1000, Y = 500 };
+
+            // Verify that the new node falls outside the resized group bounds
+            Assert.Greater(secondNode.Rect.Left, resizedRect.Right);
+            Assert.Greater(secondNode.Rect.Top, resizedRect.Bottom);
+
+            // Act: Add the second node to the group
+            annotationModel.AddToTargetAnnotationModel(secondNode);
+            annotationModel.UpdateBoundaryFromSelection();
+
+            // Assert: Group expanded to accommodate second node
+            Assert.AreEqual(2, annotationModel.Nodes.Count());
+            Assert.Greater(annotationModel.Width, resizedWidth);
+            Assert.Greater(annotationModel.Height, resizedHeight);
+
+            // Act: Remove the second node
+            var updatedNodes = annotationModel.Nodes.Where(n => n != secondNode).ToList();
+            annotationModel.Nodes = updatedNodes;
+            annotationModel.UpdateBoundaryFromSelection();
+
+            // Assert: Group size reverts to user-defined dimensions
+            Assert.AreEqual(1, annotationModel.Nodes.Count());
+            Assert.AreEqual(resizedWidth, annotationModel.Width);
+            Assert.AreEqual(resizedHeight, annotationModel.Height);
+        }
     }
 }