[DYN-8893] Improvements to group behavior (#16334)

Author: ivaylo-matov

src/DynamoCoreWpf/Utilities/WpfUtilities.cs

@@ -111,5 +111,18 @@ public static async void DelayInvoke(this Dispatcher ds, int delay, Action callb
             await ds.BeginInvoke(callback);
         }
 
+        /// <summary>
+        /// Recursively searches up the visual tree from the specified child to find the first parent of type <typeparamref name="T"/>.
+        /// </summary>
+        /// <typeparam name="T">The type of parent to search for.</typeparam>
+        /// <param name="child">The starting element in the visual tree.</param>
+        /// <returns>The first parent of type <typeparamref name="T"/> if found; otherwise, <c>null</c>.</returns>
+        public static T FindParent<T>(DependencyObject child) where T : DependencyObject
+        {
+            var parent = VisualTreeHelper.GetParent(child);
+            if (parent == null) return null;
+            return parent is T typedParent ? typedParent : FindParent<T>(parent);
+        }
+
     }
 }

src/DynamoCoreWpf/ViewModels/Core/StateMachine.cs

@@ -30,6 +30,7 @@ partial class WorkspaceViewModel
 
         private readonly StateMachine stateMachine = null;
         private List<DraggedNode> draggedNodes = new List<DraggedNode>();
+        private Dictionary<Guid, Point> draggedGroupOriginalPositions = new();
 
         // When a new connector is created or a single connector is selected,
         // activeConnectors has array size of 1.
@@ -65,7 +66,8 @@ partial class WorkspaceViewModel
         [JsonIgnore]
         internal ConnectorViewModel FirstActiveConnector
         {
-            get {
+            get
+            {
                 if (null != activeConnectors && activeConnectors.Count() > 0)
                 {
                     return activeConnectors[0];
@@ -149,6 +151,14 @@ internal void BeginDragSelection(Point2D mouseCursor)
             {
                 throw new InvalidOperationException(Wpf.Properties.Resources.InvalidDraggingOperationMessgae);
             }
+
+            // Track original positions of any selected annotation groups at the beginning of a drag
+            // This allows us to later determine whether the group was truly moved or just clicked
+            draggedGroupOriginalPositions.Clear();
+            foreach (var group in DynamoSelection.Instance.Selection.OfType<AnnotationModel>())
+            {
+                draggedGroupOriginalPositions[group.GUID] = new Point(group.X, group.Y);
+            }
         }
 
         internal void UpdateDraggedSelection(Point2D mouseCursor)
@@ -763,6 +773,28 @@ internal bool HandleMouseRelease(object sender, MouseButtonEventArgs e)
                             .OfType<AnnotationModel>()
                             .ToList();
 
+                        // DYN-8893: Prevent accidental grouping when overlapping groups are clicked without dragging
+                        // If a group visually overlaps another and is simply clicked (not dragged),
+                        // grouping can be mistakenly triggered. To avoid this, we record original positions
+                        // of dragged groups and compare them on mouse release. Grouping only proceeds if
+                        // a group was actually moved. This check is skipped if only nodes are selected
+                        bool anyGroupMoved = dragedGroups.All(group =>
+                        {
+                            if (!owningWorkspace.draggedGroupOriginalPositions.TryGetValue(group.GUID, out var originalPos))
+                                return true; // Assume moved if not tracked
+
+                            var current = group.Position;
+                            return Math.Abs(originalPos.X - current.X) > 0.1 && Math.Abs(originalPos.Y - current.Y) > 0.1;
+                        });
+
+                        // If we're dealing with groups and none of them moved, we shouldn't group them
+                        if (!anyGroupMoved && dragedGroups.Any())
+                        {
+                            dropGroup.NodeHoveringState = false;
+                            SetCurrentState(State.None);
+                            return false;
+                        }
+
                         // We do not want to add dragged groups content twice
                         // so we filter it out here.
                         var modelsToAdd = DynamoSelection.Instance.Selection

src/DynamoCoreWpf/ViewModels/Core/WorkspaceViewModel.cs

@@ -1225,6 +1225,26 @@ private bool IsModelInCollapsedGroup(ModelBase model)
             return IsInCollapsedGroup;
         }
 
+        /// <summary>
+        /// Handles double-clicks on annotation groups by creating a CBN at the click position
+        /// and adding it to the group if the position intersects with the group's region.
+        /// </summary>
+        internal void HandleAnnotationDoubleClick(Point position, AnnotationModel annotation)
+        {
+            if (DynamoViewModel?.Model == null) return;
+
+            var model = DynamoViewModel.Model;
+
+            // Create and add code node block
+            var newNode = new CodeBlockNodeModel(model.LibraryServices);
+            var cmd = new DynamoModel.CreateNodeCommand(newNode, position.X, position.Y, false, true);
+            DynamoViewModel.ExecuteCommand(cmd);
+
+            var updated = annotation.Nodes.ToList();
+            updated.Add(newNode);
+            annotation.Nodes = updated;
+        }
+
         private static bool IsInRegion(Rect2D region, ILocatable locatable, bool fullyEnclosed)
         {
             double x0 = locatable.X;

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

@@ -21,6 +21,7 @@
 using Dynamo.UI.Prompts;
 using Dynamo.Utilities;
 using Dynamo.ViewModels;
+using ModifierKeys = System.Windows.Input.ModifierKeys;
 using Dynamo.Views;
 using Dynamo.Wpf.Utilities;
 using DynCmd = Dynamo.Models.DynamoModel;
@@ -152,6 +153,7 @@ public AnnotationView()
             Loaded += AnnotationView_Loaded;
             DataContextChanged += AnnotationView_DataContextChanged;
             this.groupTextBlock.SizeChanged += GroupTextBlock_SizeChanged;
+            PreviewMouseDoubleClick += OnAnnotationDoubleClick;
 
             // Because the size of the collapsedAnnotationRectangle doesn't necessarily change 
             // when going from Visible to collapse (and other way around), we need to also listen
@@ -206,6 +208,7 @@ private void AnnotationView_Unloaded(object sender, RoutedEventArgs e)
         {
             Loaded -= AnnotationView_Loaded;
             DataContextChanged -= AnnotationView_DataContextChanged;
+            PreviewMouseDoubleClick -= OnAnnotationDoubleClick;
             if (groupTextBlock != null)
                 groupTextBlock.SizeChanged -= GroupTextBlock_SizeChanged;
             if (collapsedAnnotationRectangle != null)
@@ -294,6 +297,29 @@ private void AnnotationView_Loaded(object sender, RoutedEventArgs e)
             }
         }
 
+        private void OnAnnotationDoubleClick(object sender, MouseButtonEventArgs e)
+        {
+            if (Keyboard.Modifiers == ModifierKeys.Shift || Keyboard.Modifiers == ModifierKeys.Control)
+                return;
+
+            var workspace = WpfUtilities.FindParent<WorkspaceView>(this);
+            if (workspace == null)
+                return;
+
+            var clickPosition = e.GetPosition(workspace.WorkspaceElements);
+            var model = ViewModel.AnnotationModel;
+
+            // Define the area below the text block where nodes reside
+            var annoRectArea = new Rect(model.X, model.Y + model.TextBlockHeight, model.Width, model.ModelAreaHeight);
+
+            // Only create CBN if click is in model area (not in the title/text area)
+            if (!annoRectArea.Contains(clickPosition))
+                return;
+
+            workspace.ViewModel?.HandleAnnotationDoubleClick(clickPosition, model);
+            e.Handled = true;
+        }
+
         private void OnNodeColorSelectionChanged(object sender, SelectionChangedEventArgs e)
         {
             if (e.AddedItems == null || (e.AddedItems.Count <= 0))