ItemContainer default state fixes

miroiu · miroiu · commit b71fa77ed7e5 · 2024-12-07T20:38:05.000+02:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -26,12 +26,15 @@
 >	- Added a custom MouseGesture with support for key combinations
 >	- Added InputProcessor to NodifyEditor, ItemContainer and Connector, enabling the extension of controls with custom states
 >	- Added ElementOperationState to simplify the creation of complex control states
+>	- Move the viewport to the mouse position when zooming on the Minimap if ResizeToViewport is false
 > - Bugfixes:
 >	- Fixed an issue where the ItemContainer was selected by releasing the mouse button on it, even when the mouse was not captured
+>	- Fixed an issue where the ItemContainer could open its context menu even when it was not selected
 >	- Fixed an issue where the Home button caused the editor to fail to display items when contained within a ScrollViewer
 >	- Fixed an issue where connector optimization did not work when SelectedItems was not data-bound
 >	- Fixed an issue where EditorCommands.Align caused multiple arrange invalidations, one for each aligned container
 >	- Fixed an issue where controls would capture the mouse unnecessarily; they now capture it only in response to a defined gesture
+>	- Fixed an issue where the minimap could update the viewport without having the mouse captured
 	
 #### **Version 6.6.0**
 
diff --git a/Examples/Nodify.StateMachine/StateMachineViewModel.cs b/Examples/Nodify.StateMachine/StateMachineViewModel.cs
@@ -17,8 +17,16 @@ public StateMachineViewModel()
                 Conditions = new NodifyObservableCollection<BlackboardItemReferenceViewModel>(BlackboardDescriptor.GetAvailableItems<IBlackboardCondition>())
             };
 
-            Transitions.WhenAdded(c => c.Source.Transitions.Add(c.Target))
-            .WhenRemoved(c => c.Source.Transitions.Remove(c.Target))
+            Transitions.WhenAdded(c =>
+            {
+                c.Source.Transitions.Add(c.Target);
+                c.Target.Transitions.Add(c.Source);
+            })
+            .WhenRemoved(c =>
+            {
+                c.Source.Transitions.Remove(c.Target);
+                c.Target.Transitions.Remove(c.Source);
+            })
             .WhenCleared(c => c.ForEach(i =>
             {
                 i.Source.Transitions.Clear();
diff --git a/Nodify/EditorGestures.cs b/Nodify/EditorGestures.cs
@@ -13,17 +13,27 @@ public class SelectionGestures
             /// <summary>Disable selection gestures.</summary>
             public static readonly SelectionGestures None = new SelectionGestures(MouseAction.None);
 
-            public SelectionGestures(MouseAction mouseAction)
+            public SelectionGestures(MouseAction mouseAction, bool ignoreModifierKeysOnRelease)
             {
                 Replace = new MouseGesture(mouseAction);
-                Remove = new MouseGesture(mouseAction, ModifierKeys.Alt);
-                Append = new MouseGesture(mouseAction, ModifierKeys.Shift);
-                Invert = new MouseGesture(mouseAction, ModifierKeys.Control);
+                Remove = new MouseGesture(mouseAction, ModifierKeys.Alt, ignoreModifierKeysOnRelease);
+                Append = new MouseGesture(mouseAction, ModifierKeys.Shift, ignoreModifierKeysOnRelease);
+                Invert = new MouseGesture(mouseAction, ModifierKeys.Control, ignoreModifierKeysOnRelease);
                 Select = new AnyGesture(Replace, Remove, Append, Invert);
                 Cancel = new KeyGesture(Key.Escape);
             }
 
-            public SelectionGestures() : this(MouseAction.LeftClick)
+            public SelectionGestures(MouseAction mouseAction)
+                : this(mouseAction, true)
+            {
+            }
+
+            public SelectionGestures(bool ignoreModifierKeysOnRelease)
+                : this(MouseAction.LeftClick, ignoreModifierKeysOnRelease)
+            {
+            }
+
+            public SelectionGestures() : this(true)
             {
             }
 
@@ -73,8 +83,7 @@ public ItemContainerGestures()
                     Selection.Replace,
                     Selection.Remove,
                     Selection.Append,
-                    Selection.Invert,
-                    new MouseGesture(MouseAction.RightClick));
+                    Selection.Invert);
 
                 Drag = new AnyGesture(Selection.Replace, Selection.Remove, Selection.Append, Selection.Invert);
                 CancelAction = new AnyGesture(new MouseGesture(MouseAction.RightClick), new KeyGesture(Key.Escape));
@@ -110,12 +119,12 @@ public class NodifyEditorGestures
             public NodifyEditorGestures()
             {
                 Selection = new SelectionGestures();
-                Cutting = new MouseGesture(MouseAction.LeftClick, ModifierKeys.Alt | ModifierKeys.Shift);
-                PushItems = new MouseGesture(MouseAction.LeftClick, ModifierKeys.Control | ModifierKeys.Shift);
+                Cutting = new MouseGesture(MouseAction.LeftClick, ModifierKeys.Alt | ModifierKeys.Shift, true);
+                PushItems = new MouseGesture(MouseAction.LeftClick, ModifierKeys.Control | ModifierKeys.Shift, true);
                 Pan = new AnyGesture(new MouseGesture(MouseAction.RightClick), new MouseGesture(MouseAction.MiddleClick));
                 ZoomModifierKey = ModifierKeys.None;
-                ZoomIn = new MultiGesture(MultiGesture.Match.Any, new KeyGesture(Key.OemPlus, ModifierKeys.Control), new KeyGesture(Key.Add, ModifierKeys.Control));
-                ZoomOut = new MultiGesture(MultiGesture.Match.Any, new KeyGesture(Key.OemMinus, ModifierKeys.Control), new KeyGesture(Key.Subtract, ModifierKeys.Control));
+                ZoomIn = new AnyGesture(new KeyGesture(Key.OemPlus, ModifierKeys.Control), new KeyGesture(Key.Add, ModifierKeys.Control));
+                ZoomOut = new AnyGesture(new KeyGesture(Key.OemMinus, ModifierKeys.Control), new KeyGesture(Key.Subtract, ModifierKeys.Control));
                 ResetViewportLocation = new KeyGesture(Key.Home);
                 FitToScreen = new KeyGesture(Key.Home, ModifierKeys.Shift);
                 CancelAction = new AnyGesture(new MouseGesture(MouseAction.RightClick), new KeyGesture(Key.Escape));
diff --git a/Nodify/EditorStates/ConnectorConnectingState.cs b/Nodify/EditorStates/ConnectorConnectingState.cs
@@ -3,7 +3,7 @@
 
 namespace Nodify
 {
-    public class ConnectorConnectingState : ElementOperationState<Connector>
+    public class ConnectorConnectingState : DragState<Connector>
     {
         public ConnectorConnectingState(Connector connector)
             : base(connector, EditorGestures.Mappings.Connector.Connect, EditorGestures.Mappings.Connector.CancelAction)
diff --git a/Nodify/EditorStates/ContainerDefaultState.cs b/Nodify/EditorStates/ContainerDefaultState.cs
@@ -8,18 +8,20 @@ public class ContainerDefaultState : InputElementStateStack<ItemContainer>
     {
         public ContainerDefaultState(ItemContainer container) : base(container)
         {
-            PushState(new Implementation(this));
+            PushState(new SelectingState(this));
         }
 
-        private sealed class Implementation : InputElementState
+        private sealed class SelectingState : InputElementState
         {
             private Point _initialPosition;
             private SelectionType? _selectionType;
             private bool _isDragging;
 
+            private bool PreserveSelectionOnRightClick => Element.HasContextMenu || ItemContainer.PreserveSelectionOnRightClick;
+
             /// <summary>Creates a new instance of the <see cref="ContainerSelectingState"/>.</summary>
             /// <param name="container">The owner of the state.</param>
-            public Implementation(InputElementStateStack<ItemContainer> stack) : base(stack)
+            public SelectingState(InputElementStateStack<ItemContainer> stack) : base(stack)
             {
             }
 
@@ -41,22 +43,39 @@ protected override void OnMouseDown(MouseButtonEventArgs e)
                 EditorGestures.ItemContainerGestures gestures = EditorGestures.Mappings.ItemContainer;
                 if (gestures.Drag.Matches(e.Source, e))
                 {
-                    _isDragging = Element.IsDraggable;
+                    _isDragging = Element.IsDraggable && CaptureMouseSafe();
                 }
 
                 if (gestures.Selection.Select.Matches(e.Source, e))
                 {
                     _selectionType = gestures.Selection.GetSelectionType(e);
                 }
+                // Replaces the current selection when right-clicking on an element that has a context menu and is not selected.
+                // Applies only when the select gesture is not right click.
+                else if (e.ChangedButton == MouseButton.Right && PreserveSelectionOnRightClick)
+                {
+                    _selectionType = Element.IsSelected ? SelectionType.Append : SelectionType.Replace;
+                }
 
                 _initialPosition = Element.Editor.MouseLocation;
 
-                // Capture the mouse only if we have an operation
                 if (_isDragging || _selectionType.HasValue)
                 {
                     Element.Focus();
+                    e.Handled = true;
+                }
+            }
+
+            private bool CaptureMouseSafe()
+            {
+                // Avoid stealing mouse capture from other elements
+                if (Mouse.Captured == null || Element.IsMouseCaptured)
+                {
                     Element.CaptureMouse();
+                    return true;
                 }
+
+                return false;
             }
 
             /// <inheritdoc />
@@ -87,9 +106,8 @@ protected override void OnMouseUp(MouseButtonEventArgs e)
                     // explicit context menu or is configured to preserve the selection on right-click, the selection 
                     // remains unchanged. This ensures that the context menu applies to the entire selection rather 
                     // than only the clicked item.
-                    bool hasContextMenu = Element.HasContextMenu || ItemContainer.PreserveSelectionOnRightClick;
-                    bool allowContextMenu = e.ChangedButton == MouseButton.Right && Element.IsSelected && hasContextMenu;
-                    if (!(_selectionType == SelectionType.Replace && allowContextMenu))
+                    bool allowContextMenu = e.ChangedButton == MouseButton.Right && Element.IsSelected && PreserveSelectionOnRightClick;
+                    if (!allowContextMenu)
                     {
                         Element.Select(_selectionType.Value);
                     }
diff --git a/Nodify/EditorStates/ContainerDraggingState.cs b/Nodify/EditorStates/ContainerDraggingState.cs
@@ -4,7 +4,7 @@
 namespace Nodify
 {
     /// <summary>Dragging state of the container.</summary>
-    public sealed class ContainerDraggingState : InputElementStateStack<ItemContainer>.ElementOperationState
+    internal sealed class ContainerDraggingState : InputElementStateStack<ItemContainer>.DragState
     {
         private Point _previousMousePosition;
 
diff --git a/Nodify/EditorStates/DragState.cs b/Nodify/EditorStates/DragState.cs
@@ -3,7 +3,7 @@
 
 namespace Nodify
 {
-    public abstract class ElementOperationState<TElement> : InputElementState<TElement>, IInputHandler
+    public abstract class DragState<TElement> : InputElementState<TElement>, IInputHandler
         where TElement : FrameworkElement
     {
         protected InputGesture? CancelGesture { get; }
@@ -19,13 +19,13 @@ public abstract class ElementOperationState<TElement> : InputElementState<TEleme
 
         /// <summary>Constructs a new <see cref="EditorState"/>.</summary>
         /// <param name="element">The owner of the state.</param>
-        public ElementOperationState(TElement element, InputGesture beginGesture) : base(element)
+        public DragState(TElement element, InputGesture beginGesture) : base(element)
         {
             BeginGesture = beginGesture;
             PositionElement = element;
         }
 
-        public ElementOperationState(TElement element, InputGesture beginGesture, InputGesture cancelGesture)
+        public DragState(TElement element, InputGesture beginGesture, InputGesture cancelGesture)
             : this(element, beginGesture)
         {
             CancelGesture = cancelGesture;
@@ -35,19 +35,19 @@ void IInputHandler.HandleEvent(InputEventArgs e)
         {
             if (!_canReceiveInput && IsInputEventPressed(e) && BeginGesture.Matches(e.Source, e) && CanBegin)
             {
-                BeginOperation(e);
+                BeginDrag(e);
                 return;
             }
 
             if (_canReceiveInput && (IsToggle ? IsInputEventPressed(e) : IsInputEventReleased(e)) && BeginGesture.Matches(e.Source, e))
             {
-                EndOperation(e);
+                EndDrag(e);
                 return;
             }
 
             if (_canReceiveInput && (e.RoutedEvent == UIElement.LostMouseCaptureEvent || (CancelGesture?.Matches(e.Source, e) is true && IsInputEventReleased(e))))
             {
-                CancelOperation(e);
+                CancelDrag(e);
                 return;
             }
 
@@ -57,7 +57,7 @@ void IInputHandler.HandleEvent(InputEventArgs e)
             }
         }
 
-        private void CancelOperation(InputEventArgs e)
+        private void CancelDrag(InputEventArgs e)
         {
             _canReceiveInput = false;
             HandleEvent(e);
@@ -66,12 +66,13 @@ private void CancelOperation(InputEventArgs e)
             e.Handled = true;
         }
 
-        private void BeginOperation(InputEventArgs e)
+        private void BeginDrag(InputEventArgs e)
         {
+            // Avoid stealing mouse capture from other elements
             if (Mouse.Captured == null || Element.IsMouseCaptured)
             {
                 _canReceiveInput = true;
-                HandleEvent(e); // handle the event, otherwise CaptureMouse will send a MouseMove event and the current event will be handled out of order
+                HandleEvent(e); // Handle the event, otherwise CaptureMouse will send a MouseMove event and the current event will be handled out of order
                 OnBegin(e);
 
                 e.Handled = true;
@@ -86,7 +87,7 @@ private void BeginOperation(InputEventArgs e)
             }
         }
 
-        private void EndOperation(InputEventArgs e)
+        private void EndDrag(InputEventArgs e)
         {
             _canReceiveInput = false;
             HandleEvent(e);
@@ -114,7 +115,7 @@ private void EndOperation(InputEventArgs e)
             }
         }
 
-        private static bool IsInputEventReleased(InputEventArgs e)
+        protected virtual bool IsInputEventReleased(InputEventArgs e)
         {
             if (e is MouseButtonEventArgs mbe && mbe.ButtonState == MouseButtonState.Released)
                 return true;
@@ -128,7 +129,7 @@ private static bool IsInputEventReleased(InputEventArgs e)
             return false;
         }
 
-        private static bool IsInputEventPressed(InputEventArgs e)
+        protected virtual bool IsInputEventPressed(InputEventArgs e)
         {
             if (e is MouseButtonEventArgs mbe && mbe.ButtonState == MouseButtonState.Pressed)
                 return true;
diff --git a/Nodify/EditorStates/EditorCuttingState.cs b/Nodify/EditorStates/EditorCuttingState.cs
@@ -2,7 +2,7 @@
 
 namespace Nodify
 {
-    public class EditorCuttingState : ElementOperationState<NodifyEditor>
+    public class EditorCuttingState : DragState<NodifyEditor>
     {
         protected override bool HasContextMenu => Element.HasContextMenu;
 
diff --git a/Nodify/EditorStates/EditorPanningState.cs b/Nodify/EditorStates/EditorPanningState.cs
@@ -5,7 +5,7 @@
 namespace Nodify
 {
     /// <summary>The panning state of the editor.</summary>
-    public class EditorPanningState : ElementOperationState<NodifyEditor>
+    public class EditorPanningState : DragState<NodifyEditor>
     {
         protected override bool HasContextMenu => Element.HasContextMenu;
         protected override bool CanBegin => !Element.DisablePanning;
@@ -21,9 +21,7 @@ public EditorPanningState(NodifyEditor editor)
 
         protected override void OnBegin(InputEventArgs e)
         {
-            var initialMousePosition = Mouse.GetPosition(Element);
-            _prevPosition = initialMousePosition;
-
+            _prevPosition = Mouse.GetPosition(Element);
             Element.BeginPanning();
         }
 
diff --git a/Nodify/EditorStates/EditorPushingItemsState.cs b/Nodify/EditorStates/EditorPushingItemsState.cs
@@ -5,7 +5,7 @@
 
 namespace Nodify
 {
-    public class EditorPushingItemsState : ElementOperationState<NodifyEditor>
+    public class EditorPushingItemsState : DragState<NodifyEditor>
     {
         protected override bool HasContextMenu => Element.HasContextMenu;
 
diff --git a/Nodify/EditorStates/EditorSelectingState.cs b/Nodify/EditorStates/EditorSelectingState.cs
@@ -3,7 +3,7 @@
 namespace Nodify
 {
     /// <summary>The selecting state of the editor.</summary>
-    public class EditorSelectingState : ElementOperationState<NodifyEditor>
+    public class EditorSelectingState : DragState<NodifyEditor>
     {
         protected override bool HasContextMenu => Element.HasContextMenu;
         protected override bool CanBegin => Element.CanSelectMultipleItems && !Element.IsPanning;
diff --git a/Nodify/EditorStates/InputElementStateStack.cs b/Nodify/EditorStates/InputElementStateStack.cs
@@ -88,7 +88,7 @@ public void PopState()
                 => Stack.PopState();
         }
 
-        public abstract class ElementOperationState : InputElementState, IInputHandler
+        public abstract class DragState : InputElementState, IInputHandler
         {
             protected InputGesture ExitGesture { get; }
             protected InputGesture? CancelGesture { get; }
@@ -99,13 +99,13 @@ public abstract class ElementOperationState : InputElementState, IInputHandler
             private bool _canReceiveInput;
             private Point _initialPosition;
 
-            public ElementOperationState(InputElementStateStack<TElement> stack, InputGesture exitGesture) : base(stack)
+            public DragState(InputElementStateStack<TElement> stack, InputGesture exitGesture) : base(stack)
             {
                 ExitGesture = exitGesture;
                 PositionElement = stack.Element;
             }
 
-            public ElementOperationState(InputElementStateStack<TElement> stack, InputGesture exitGesture, InputGesture cancelGesture)
+            public DragState(InputElementStateStack<TElement> stack, InputGesture exitGesture, InputGesture cancelGesture)
                 : this(stack, exitGesture)
             {
                 CancelGesture = cancelGesture;
@@ -137,13 +137,13 @@ void IInputHandler.HandleEvent(InputEventArgs e)
 
                 if (_canReceiveInput && IsInputEventReleased(e) && ExitGesture.Matches(e.Source, e))
                 {
-                    EndOperation(e);
+                    EndDrag(e);
                     return;
                 }
 
                 if (_canReceiveInput && (e.RoutedEvent == UIElement.LostMouseCaptureEvent || (CancelGesture?.Matches(e.Source, e) is true && IsInputEventReleased(e))))
                 {
-                    CancelOperation(e);
+                    CancelDrag(e);
                     return;
                 }
 
@@ -153,7 +153,7 @@ void IInputHandler.HandleEvent(InputEventArgs e)
                 }
             }
 
-            private void CancelOperation(InputEventArgs e)
+            private void CancelDrag(InputEventArgs e)
             {
                 _canReceiveInput = false;
 
@@ -165,7 +165,7 @@ private void CancelOperation(InputEventArgs e)
                 PopState();
             }
 
-            private void EndOperation(InputEventArgs e)
+            private void EndDrag(InputEventArgs e)
             {
                 _canReceiveInput = false;
 
diff --git a/Nodify/Helpers/DependencyObjectExtensions.cs b/Nodify/Helpers/DependencyObjectExtensions.cs
diff --git a/Nodify/Helpers/MultiGesture.cs b/Nodify/Helpers/MultiGesture.cs
diff --git a/Nodify/InputProcessor.cs b/Nodify/InputProcessor.cs

Original file line number	Diff line number	Diff line change
`@@ -3,7 +3,7 @@`
`3`	`3`
`4`	`4`	`namespace Nodify`
`5`	`5`	`{`
`6`		`- public class ConnectorConnectingState : ElementOperationState<Connector>`
	`6`	`+ public class ConnectorConnectingState : DragState<Connector>`
`7`	`7`	`{`
`8`	`8`	`public ConnectorConnectingState(Connector connector)`
`9`	`9`	`: base(connector, EditorGestures.Mappings.Connector.Connect, EditorGestures.Mappings.Connector.CancelAction)`
Original file line number	Diff line number	Diff line change
`@@ -8,18 +8,20 @@ public class ContainerDefaultState : InputElementStateStack<ItemContainer>`
`8`	`8`	`{`
`9`	`9`	`public ContainerDefaultState(ItemContainer container) : base(container)`
`10`	`10`	`{`
`11`		`- PushState(new Implementation(this));`
	`11`	`+ PushState(new SelectingState(this));`
`12`	`12`	`}`
`13`	`13`
`14`		`- private sealed class Implementation : InputElementState`
	`14`	`+ private sealed class SelectingState : InputElementState`
`15`	`15`	`{`
`16`	`16`	`private Point _initialPosition;`
`17`	`17`	`private SelectionType? _selectionType;`
`18`	`18`	`private bool _isDragging;`
`19`	`19`
	`20`	`+ private bool PreserveSelectionOnRightClick => Element.HasContextMenu \|\| ItemContainer.PreserveSelectionOnRightClick;`
	`21`	`+`
`20`	`22`	`/// <summary>Creates a new instance of the <see cref="ContainerSelectingState"/>.</summary>`
`21`	`23`	`/// <param name="container">The owner of the state.</param>`
`22`		`- public Implementation(InputElementStateStack<ItemContainer> stack) : base(stack)`
	`24`	`+ public SelectingState(InputElementStateStack<ItemContainer> stack) : base(stack)`
`23`	`25`	`{`
`24`	`26`	`}`
`25`	`27`
`@@ -41,22 +43,39 @@ protected override void OnMouseDown(MouseButtonEventArgs e)`
`41`	`43`	`EditorGestures.ItemContainerGestures gestures = EditorGestures.Mappings.ItemContainer;`
`42`	`44`	`if (gestures.Drag.Matches(e.Source, e))`
`43`	`45`	`{`
`44`		`- _isDragging = Element.IsDraggable;`
	`46`	`+ _isDragging = Element.IsDraggable && CaptureMouseSafe();`
`45`	`47`	`}`
`46`	`48`
`47`	`49`	`if (gestures.Selection.Select.Matches(e.Source, e))`
`48`	`50`	`{`
`49`	`51`	`_selectionType = gestures.Selection.GetSelectionType(e);`
`50`	`52`	`}`
	`53`	`+ // Replaces the current selection when right-clicking on an element that has a context menu and is not selected.`
	`54`	`+ // Applies only when the select gesture is not right click.`
	`55`	`+ else if (e.ChangedButton == MouseButton.Right && PreserveSelectionOnRightClick)`
	`56`	`+ {`
	`57`	`+ _selectionType = Element.IsSelected ? SelectionType.Append : SelectionType.Replace;`
	`58`	`+ }`
`51`	`59`
`52`	`60`	`_initialPosition = Element.Editor.MouseLocation;`
`53`	`61`
`54`		`- // Capture the mouse only if we have an operation`
`55`	`62`	`if (_isDragging \|\| _selectionType.HasValue)`
`56`	`63`	`{`
`57`	`64`	`Element.Focus();`
	`65`	`+ e.Handled = true;`
	`66`	`+ }`
	`67`	`+ }`
	`68`	`+`
	`69`	`+ private bool CaptureMouseSafe()`
	`70`	`+ {`
	`71`	`+ // Avoid stealing mouse capture from other elements`
	`72`	`+ if (Mouse.Captured == null \|\| Element.IsMouseCaptured)`
	`73`	`+ {`
`58`	`74`	`Element.CaptureMouse();`
	`75`	`+ return true;`
`59`	`76`	`}`
	`77`	`+`
	`78`	`+ return false;`
`60`	`79`	`}`
`61`	`80`
`62`	`81`	`/// <inheritdoc />`
`@@ -87,9 +106,8 @@ protected override void OnMouseUp(MouseButtonEventArgs e)`
`87`	`106`	`// explicit context menu or is configured to preserve the selection on right-click, the selection`
`88`	`107`	`// remains unchanged. This ensures that the context menu applies to the entire selection rather`
`89`	`108`	`// than only the clicked item.`
`90`		`- bool hasContextMenu = Element.HasContextMenu \|\| ItemContainer.PreserveSelectionOnRightClick;`
`91`		`- bool allowContextMenu = e.ChangedButton == MouseButton.Right && Element.IsSelected && hasContextMenu;`
`92`		`- if (!(_selectionType == SelectionType.Replace && allowContextMenu))`
	`109`	`+ bool allowContextMenu = e.ChangedButton == MouseButton.Right && Element.IsSelected && PreserveSelectionOnRightClick;`
	`110`	`+ if (!allowContextMenu)`
`93`	`111`	`{`
`94`	`112`	`Element.Select(_selectionType.Value);`
`95`	`113`	`}`
Original file line number	Diff line number	Diff line change
`@@ -4,7 +4,7 @@`
`4`	`4`	`namespace Nodify`
`5`	`5`	`{`
`6`	`6`	`/// <summary>Dragging state of the container.</summary>`
`7`		`- public sealed class ContainerDraggingState : InputElementStateStack<ItemContainer>.ElementOperationState`
	`7`	`+ internal sealed class ContainerDraggingState : InputElementStateStack<ItemContainer>.DragState`
`8`	`8`	`{`
`9`	`9`	`private Point _previousMousePosition;`
`10`	`10`
Original file line number	Diff line number	Diff line change
`@@ -3,7 +3,7 @@`
`3`	`3`
`4`	`4`	`namespace Nodify`
`5`	`5`	`{`
`6`		`- public abstract class ElementOperationState<TElement> : InputElementState<TElement>, IInputHandler`
	`6`	`+ public abstract class DragState<TElement> : InputElementState<TElement>, IInputHandler`
`7`	`7`	`where TElement : FrameworkElement`
`8`	`8`	`{`
`9`	`9`	`protected InputGesture? CancelGesture { get; }`
`@@ -19,13 +19,13 @@ public abstract class ElementOperationState<TElement> : InputElementState<TEleme`
`19`	`19`
`20`	`20`	`/// <summary>Constructs a new <see cref="EditorState"/>.</summary>`
`21`	`21`	`/// <param name="element">The owner of the state.</param>`
`22`		`- public ElementOperationState(TElement element, InputGesture beginGesture) : base(element)`
	`22`	`+ public DragState(TElement element, InputGesture beginGesture) : base(element)`
`23`	`23`	`{`
`24`	`24`	`BeginGesture = beginGesture;`
`25`	`25`	`PositionElement = element;`
`26`	`26`	`}`
`27`	`27`
`28`		`- public ElementOperationState(TElement element, InputGesture beginGesture, InputGesture cancelGesture)`
	`28`	`+ public DragState(TElement element, InputGesture beginGesture, InputGesture cancelGesture)`
`29`	`29`	`: this(element, beginGesture)`
`30`	`30`	`{`
`31`	`31`	`CancelGesture = cancelGesture;`
`@@ -35,19 +35,19 @@ void IInputHandler.HandleEvent(InputEventArgs e)`
`35`	`35`	`{`
`36`	`36`	`if (!_canReceiveInput && IsInputEventPressed(e) && BeginGesture.Matches(e.Source, e) && CanBegin)`
`37`	`37`	`{`
`38`		`- BeginOperation(e);`
	`38`	`+ BeginDrag(e);`
`39`	`39`	`return;`
`40`	`40`	`}`
`41`	`41`
`42`	`42`	`if (_canReceiveInput && (IsToggle ? IsInputEventPressed(e) : IsInputEventReleased(e)) && BeginGesture.Matches(e.Source, e))`
`43`	`43`	`{`
`44`		`- EndOperation(e);`
	`44`	`+ EndDrag(e);`
`45`	`45`	`return;`
`46`	`46`	`}`
`47`	`47`
`48`	`48`	`if (_canReceiveInput && (e.RoutedEvent == UIElement.LostMouseCaptureEvent \|\| (CancelGesture?.Matches(e.Source, e) is true && IsInputEventReleased(e))))`
`49`	`49`	`{`
`50`		`- CancelOperation(e);`
	`50`	`+ CancelDrag(e);`
`51`	`51`	`return;`
`52`	`52`	`}`
`53`	`53`
`@@ -57,7 +57,7 @@ void IInputHandler.HandleEvent(InputEventArgs e)`
`57`	`57`	`}`
`58`	`58`	`}`
`59`	`59`
`60`		`- private void CancelOperation(InputEventArgs e)`
	`60`	`+ private void CancelDrag(InputEventArgs e)`
`61`	`61`	`{`
`62`	`62`	`_canReceiveInput = false;`
`63`	`63`	`HandleEvent(e);`
`@@ -66,12 +66,13 @@ private void CancelOperation(InputEventArgs e)`
`66`	`66`	`e.Handled = true;`
`67`	`67`	`}`
`68`	`68`
`69`		`- private void BeginOperation(InputEventArgs e)`
	`69`	`+ private void BeginDrag(InputEventArgs e)`
`70`	`70`	`{`
	`71`	`+ // Avoid stealing mouse capture from other elements`
`71`	`72`	`if (Mouse.Captured == null \|\| Element.IsMouseCaptured)`
`72`	`73`	`{`
`73`	`74`	`_canReceiveInput = true;`
`74`		`- HandleEvent(e); // handle the event, otherwise CaptureMouse will send a MouseMove event and the current event will be handled out of order`
	`75`	`+ HandleEvent(e); // Handle the event, otherwise CaptureMouse will send a MouseMove event and the current event will be handled out of order`
`75`	`76`	`OnBegin(e);`
`76`	`77`
`77`	`78`	`e.Handled = true;`
`@@ -86,7 +87,7 @@ private void BeginOperation(InputEventArgs e)`
`86`	`87`	`}`
`87`	`88`	`}`
`88`	`89`
`89`		`- private void EndOperation(InputEventArgs e)`
	`90`	`+ private void EndDrag(InputEventArgs e)`
`90`	`91`	`{`
`91`	`92`	`_canReceiveInput = false;`
`92`	`93`	`HandleEvent(e);`
`@@ -114,7 +115,7 @@ private void EndOperation(InputEventArgs e)`
`114`	`115`	`}`
`115`	`116`	`}`
`116`	`117`
`117`		`- private static bool IsInputEventReleased(InputEventArgs e)`
	`118`	`+ protected virtual bool IsInputEventReleased(InputEventArgs e)`
`118`	`119`	`{`
`119`	`120`	`if (e is MouseButtonEventArgs mbe && mbe.ButtonState == MouseButtonState.Released)`
`120`	`121`	`return true;`
`@@ -128,7 +129,7 @@ private static bool IsInputEventReleased(InputEventArgs e)`
`128`	`129`	`return false;`
`129`	`130`	`}`
`130`	`131`
`131`		`- private static bool IsInputEventPressed(InputEventArgs e)`
	`132`	`+ protected virtual bool IsInputEventPressed(InputEventArgs e)`
`132`	`133`	`{`
`133`	`134`	`if (e is MouseButtonEventArgs mbe && mbe.ButtonState == MouseButtonState.Pressed)`
`134`	`135`	`return true;`
Original file line number	Diff line number	Diff line change
`@@ -2,7 +2,7 @@`
`2`	`2`
`3`	`3`	`namespace Nodify`
`4`	`4`	`{`
`5`		`- public class EditorCuttingState : ElementOperationState<NodifyEditor>`
	`5`	`+ public class EditorCuttingState : DragState<NodifyEditor>`
`6`	`6`	`{`
`7`	`7`	`protected override bool HasContextMenu => Element.HasContextMenu;`
`8`	`8`
Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,7 @@`
`5`	`5`	`namespace Nodify`
`6`	`6`	`{`
`7`	`7`	`/// <summary>The panning state of the editor.</summary>`
`8`		`- public class EditorPanningState : ElementOperationState<NodifyEditor>`
	`8`	`+ public class EditorPanningState : DragState<NodifyEditor>`
`9`	`9`	`{`
`10`	`10`	`protected override bool HasContextMenu => Element.HasContextMenu;`
`11`	`11`	`protected override bool CanBegin => !Element.DisablePanning;`
`@@ -21,9 +21,7 @@ public EditorPanningState(NodifyEditor editor)`
`21`	`21`
`22`	`22`	`protected override void OnBegin(InputEventArgs e)`
`23`	`23`	`{`
`24`		`- var initialMousePosition = Mouse.GetPosition(Element);`
`25`		`- _prevPosition = initialMousePosition;`
`26`		`-`
	`24`	`+ _prevPosition = Mouse.GetPosition(Element);`
`27`	`25`	`Element.BeginPanning();`
`28`	`26`	`}`
`29`	`27`
Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,7 @@`
`5`	`5`
`6`	`6`	`namespace Nodify`
`7`	`7`	`{`
`8`		`- public class EditorPushingItemsState : ElementOperationState<NodifyEditor>`
	`8`	`+ public class EditorPushingItemsState : DragState<NodifyEditor>`
`9`	`9`	`{`
`10`	`10`	`protected override bool HasContextMenu => Element.HasContextMenu;`
`11`	`11`
Original file line number	Diff line number	Diff line change
`@@ -3,7 +3,7 @@`
`3`	`3`	`namespace Nodify`
`4`	`4`	`{`
`5`	`5`	`/// <summary>The selecting state of the editor.</summary>`
`6`		`- public class EditorSelectingState : ElementOperationState<NodifyEditor>`
	`6`	`+ public class EditorSelectingState : DragState<NodifyEditor>`
`7`	`7`	`{`
`8`	`8`	`protected override bool HasContextMenu => Element.HasContextMenu;`
`9`	`9`	`protected override bool CanBegin => Element.CanSelectMultipleItems && !Element.IsPanning;`
Original file line number	Diff line number	Diff line change
`@@ -88,7 +88,7 @@ public void PopState()`
`88`	`88`	`=> Stack.PopState();`
`89`	`89`	`}`
`90`	`90`
`91`		`- public abstract class ElementOperationState : InputElementState, IInputHandler`
	`91`	`+ public abstract class DragState : InputElementState, IInputHandler`
`92`	`92`	`{`
`93`	`93`	`protected InputGesture ExitGesture { get; }`
`94`	`94`	`protected InputGesture? CancelGesture { get; }`
`@@ -99,13 +99,13 @@ public abstract class ElementOperationState : InputElementState, IInputHandler`
`99`	`99`	`private bool _canReceiveInput;`
`100`	`100`	`private Point _initialPosition;`
`101`	`101`
`102`		`- public ElementOperationState(InputElementStateStack<TElement> stack, InputGesture exitGesture) : base(stack)`
	`102`	`+ public DragState(InputElementStateStack<TElement> stack, InputGesture exitGesture) : base(stack)`
`103`	`103`	`{`
`104`	`104`	`ExitGesture = exitGesture;`
`105`	`105`	`PositionElement = stack.Element;`
`106`	`106`	`}`
`107`	`107`
`108`		`- public ElementOperationState(InputElementStateStack<TElement> stack, InputGesture exitGesture, InputGesture cancelGesture)`
	`108`	`+ public DragState(InputElementStateStack<TElement> stack, InputGesture exitGesture, InputGesture cancelGesture)`
`109`	`109`	`: this(stack, exitGesture)`
`110`	`110`	`{`
`111`	`111`	`CancelGesture = cancelGesture;`
`@@ -137,13 +137,13 @@ void IInputHandler.HandleEvent(InputEventArgs e)`
`137`	`137`
`138`	`138`	`if (_canReceiveInput && IsInputEventReleased(e) && ExitGesture.Matches(e.Source, e))`
`139`	`139`	`{`
`140`		`- EndOperation(e);`
	`140`	`+ EndDrag(e);`
`141`	`141`	`return;`
`142`	`142`	`}`
`143`	`143`
`144`	`144`	`if (_canReceiveInput && (e.RoutedEvent == UIElement.LostMouseCaptureEvent \|\| (CancelGesture?.Matches(e.Source, e) is true && IsInputEventReleased(e))))`
`145`	`145`	`{`
`146`		`- CancelOperation(e);`
	`146`	`+ CancelDrag(e);`
`147`	`147`	`return;`
`148`	`148`	`}`
`149`	`149`
`@@ -153,7 +153,7 @@ void IInputHandler.HandleEvent(InputEventArgs e)`
`153`	`153`	`}`
`154`	`154`	`}`
`155`	`155`
`156`		`- private void CancelOperation(InputEventArgs e)`
	`156`	`+ private void CancelDrag(InputEventArgs e)`
`157`	`157`	`{`
`158`	`158`	`_canReceiveInput = false;`
`159`	`159`
`@@ -165,7 +165,7 @@ private void CancelOperation(InputEventArgs e)`
`165`	`165`	`PopState();`
`166`	`166`	`}`
`167`	`167`
`168`		`- private void EndOperation(InputEventArgs e)`
	`168`	`+ private void EndDrag(InputEventArgs e)`
`169`	`169`	`{`
`170`	`170`	`_canReceiveInput = false;`
`171`	`171`