End operation if cancellation is not supported (#171)

miroiu · web-flow · commit 0c8a4f951344 · 2024-12-07T22:29:14.000+02:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -11,6 +11,8 @@
 >	- Renamed UnselectAllConnection to UnselectAllConnections in NodifyEditor
 >	- Removed DragStarted, DragDelta and DragCompleted routed events from ItemContainer
 >	- Replaced the System.Windows.Input.MouseGesture with Nodify.MouseGesture
+>	- Moved AllowCuttingCancellation from CuttingLine to NodifyEditor
+>	- Moved AllowDraggingCancellation from ItemContainer to NodifyEditor
 > - Features:
 >	- Added BeginPanning, UpdatePanning, EndPanning, CancelPanning and AllowPanningCancellation to NodifyEditor
 >	- Added UpdateCuttingLine to NodifyEditor
diff --git a/Examples/Nodify.Playground/EditorSettings.cs b/Examples/Nodify.Playground/EditorSettings.cs
@@ -220,6 +220,11 @@ private EditorSettings()
                     val => Instance.MouseActionSuppressionThreshold = val,
                     "Context menu suppression threshold: ",
                     "Disable context menu after mouse moved this far"),
+                new ProxySettingViewModel<bool>(
+                    () => Instance.PreserveSelectionOnRightClick,
+                    val => Instance.PreserveSelectionOnRightClick = val,
+                    "Preserve selection on right click: ",
+                    "Whether right-click on the container should preserve the current selection."),
                 new ProxySettingViewModel<double>(
                     () => Instance.AutoPanningTickRate,
                     val => Instance.AutoPanningTickRate = val,
@@ -600,6 +605,12 @@ public GroupingMovementMode GroupingNodeMovement
 
         #region Advanced settings
 
+        public bool PreserveSelectionOnRightClick
+        {
+            get => ItemContainer.PreserveSelectionOnRightClick;
+            set => ItemContainer.PreserveSelectionOnRightClick = value;
+        }
+
         public double MouseActionSuppressionThreshold
         {
             get => NodifyEditor.MouseActionSuppressionThreshold;
@@ -614,8 +625,8 @@ public double AutoPanningTickRate
 
         public bool AllowCuttingCancellation
         {
-            get => CuttingLine.AllowCuttingCancellation;
-            set => CuttingLine.AllowCuttingCancellation = value;
+            get => NodifyEditor.AllowCuttingCancellation;
+            set => NodifyEditor.AllowCuttingCancellation = value;
         }
 
         public bool AllowPushItemsCancellation
@@ -638,8 +649,8 @@ public bool AllowSelectionCancellation
 
         public bool AllowDraggingCancellation
         {
-            get => ItemContainer.AllowDraggingCancellation;
-            set => ItemContainer.AllowDraggingCancellation = value;
+            get => NodifyEditor.AllowDraggingCancellation;
+            set => NodifyEditor.AllowDraggingCancellation = value;
         }
 
         public bool AllowPendingConnectionCancellation
diff --git a/Nodify/Connections/CuttingLine.cs b/Nodify/Connections/CuttingLine.cs
@@ -20,11 +20,6 @@ public static bool GetIsOverElement(UIElement elem)
         public static void SetIsOverElement(UIElement elem, bool value)
             => elem.SetValue(IsOverElementProperty, value);
 
-        /// <summary>
-        /// Gets or sets whether cancelling a cutting operation is allowed (see <see cref="EditorGestures.NodifyEditorGestures.CancelAction"/>).
-        /// </summary>
-        public static bool AllowCuttingCancellation { get; set; } = true;
-
         /// <summary>
         /// Gets or sets the start point.
         /// </summary>
diff --git a/Nodify/EditorStates/ContainerDraggingState.cs b/Nodify/EditorStates/ContainerDraggingState.cs
@@ -9,7 +9,7 @@ public class ContainerDraggingState : ContainerState
         private Point _initialMousePosition;
         private Point _previousMousePosition;
         
-        private bool Canceled { get; set; } = ItemContainer.AllowDraggingCancellation;
+        private bool Canceled { get; set; } = NodifyEditor.AllowDraggingCancellation;
 
         /// <summary>Constructs an instance of the <see cref="ContainerDraggingState"/> state.</summary>
         /// <param name="container">The owner of the state.</param>
@@ -69,7 +69,7 @@ public override void HandleMouseUp(MouseButtonEventArgs e)
 
                 PopState();
             }
-            else if (ItemContainer.AllowDraggingCancellation && gestures.CancelAction.Matches(e.Source, e))
+            else if (NodifyEditor.AllowDraggingCancellation && gestures.CancelAction.Matches(e.Source, e))
             {
                 Canceled = true;
                 e.Handled = true;
@@ -82,7 +82,7 @@ public override void HandleMouseUp(MouseButtonEventArgs e)
         public override void HandleKeyUp(KeyEventArgs e)
         {
             EditorGestures.ItemContainerGestures gestures = EditorGestures.Mappings.ItemContainer;
-            if (ItemContainer.AllowDraggingCancellation && gestures.CancelAction.Matches(e.Source, e))
+            if (NodifyEditor.AllowDraggingCancellation && gestures.CancelAction.Matches(e.Source, e))
             {
                 Canceled = true;
                 PopState();
diff --git a/Nodify/EditorStates/EditorCuttingState.cs b/Nodify/EditorStates/EditorCuttingState.cs
@@ -6,7 +6,7 @@ namespace Nodify
     public class EditorCuttingState : EditorState
     {
         private Point _initialPosition;
-        private bool Canceled { get; set; } = CuttingLine.AllowCuttingCancellation;
+        private bool Canceled { get; set; } = NodifyEditor.AllowCuttingCancellation;
 
         public EditorCuttingState(NodifyEditor editor) : base(editor)
         {
@@ -52,7 +52,7 @@ public override void HandleMouseUp(MouseButtonEventArgs e)
 
                 PopState();
             }
-            else if (CuttingLine.AllowCuttingCancellation && gestures.CancelAction.Matches(e.Source, e))
+            else if (NodifyEditor.AllowCuttingCancellation && gestures.CancelAction.Matches(e.Source, e))
             {
                 Canceled = true;
                 e.Handled = true;   // prevents opening context menu
@@ -69,7 +69,7 @@ public override void HandleMouseMove(MouseEventArgs e)
         public override void HandleKeyUp(KeyEventArgs e)
         {
             EditorGestures.NodifyEditorGestures gestures = EditorGestures.Mappings.Editor;
-            if (CuttingLine.AllowCuttingCancellation && gestures.CancelAction.Matches(e.Source, e))
+            if (NodifyEditor.AllowCuttingCancellation && gestures.CancelAction.Matches(e.Source, e))
             {
                 Canceled = true;
                 PopState();
diff --git a/Nodify/ItemContainer.cs b/Nodify/ItemContainer.cs
@@ -232,11 +232,6 @@ private static void OnIsSelectedChanged(DependencyObject d, DependencyPropertyCh
 
         #region Fields
 
-        /// <summary>
-        /// Gets or sets whether cancelling a dragging operation is allowed.
-        /// </summary>
-        public static bool AllowDraggingCancellation { get; set; } = true;
-
         /// <summary>
         /// Indicates whether right-click on the container should preserve the current selection. 
         /// </summary>
diff --git a/Nodify/NodifyEditor.Cutting.cs b/Nodify/NodifyEditor.Cutting.cs
@@ -10,6 +10,8 @@ namespace Nodify
     [StyleTypedProperty(Property = nameof(CuttingLineStyle), StyleTargetType = typeof(CuttingLine))]
     public partial class NodifyEditor
     {
+        #region Dependency properties
+
         protected static readonly DependencyPropertyKey CuttingLineStartPropertyKey = DependencyProperty.RegisterReadOnly(nameof(CuttingLineStart), typeof(Point), typeof(NodifyEditor), new FrameworkPropertyMetadata(BoxValue.Point));
         public static readonly DependencyProperty CuttingLineStartProperty = CuttingLineStartPropertyKey.DependencyProperty;
 
@@ -95,6 +97,13 @@ public ICommand? CuttingCompletedCommand
             set => SetValue(CuttingCompletedCommandProperty, value);
         }
 
+        #endregion
+
+        /// <summary>
+        /// Gets or sets whether cancelling a cutting operation is allowed (see <see cref="EditorGestures.NodifyEditorGestures.CancelAction"/>).
+        /// </summary>
+        public static bool AllowCuttingCancellation { get; set; } = true;
+
         /// <summary>
         /// Gets or sets whether the cutting line should apply the preview style to the interesected elements.
         /// </summary>
@@ -111,6 +120,13 @@ public ICommand? CuttingCompletedCommand
         private List<FrameworkElement>? _cuttingLinePreviousConnections;
         private readonly LineGeometry _cuttingLineGeometry = new LineGeometry();
 
+        /// <summary>
+        /// Starts the cutting operation at the current <see cref="MouseLocation"/>. Call <see cref="EndCutting"/> to complete the operation or <see cref="CancelCutting"/> to abort it.
+        /// </summary>
+        /// <remarks>This method has no effect if a cutting operation is already in progress.</remarks>
+        public void BeginCutting()
+            => BeginCutting(MouseLocation);
+
         /// <summary>
         /// Starts the cutting operation at the specified location. Call <see cref="EndCutting"/> to complete the operation or <see cref="CancelCutting"/> to abort it.
         /// </summary>
@@ -161,18 +177,23 @@ public void UpdateCuttingLine(Point location)
         }
 
         /// <summary>
-        /// Cancels the current cutting operation without applying any changes.
+        /// Cancels the current cutting operation without applying any changes if <see cref="AllowCuttingCancellation"/> is true.
+        /// Otherwise, it ends the cutting operation by calling <see cref="EndCutting"/>.
         /// </summary>
         /// <remarks>This method has no effect if there's no cutting operation in progress.</remarks>
         public void CancelCutting()
         {
-            if (!CuttingLine.AllowCuttingCancellation || !IsCutting)
+            if (!AllowCuttingCancellation)
             {
+                EndCutting();
                 return;
             }
 
-            ResetConnectionStyle();
-            IsCutting = false;
+            if (IsCutting)
+            {
+                ResetConnectionStyle();
+                IsCutting = false;
+            }
         }
 
         /// <summary>
diff --git a/Nodify/NodifyEditor.Dragging.cs b/Nodify/NodifyEditor.Dragging.cs
@@ -7,6 +7,8 @@ namespace Nodify
 {
     public partial class NodifyEditor
     {
+        #region Dependency properties
+
         public static readonly DependencyProperty ItemsDragStartedCommandProperty = DependencyProperty.Register(nameof(ItemsDragStartedCommand), typeof(ICommand), typeof(NodifyEditor));
         public static readonly DependencyProperty ItemsDragCompletedCommandProperty = DependencyProperty.Register(nameof(ItemsDragCompletedCommand), typeof(ICommand), typeof(NodifyEditor));
 
@@ -66,6 +68,13 @@ public bool IsDragging
             private set => SetValue(IsDraggingPropertyKey, value);
         }
 
+        #endregion
+
+        /// <summary>
+        /// Gets or sets whether cancelling a dragging operation is allowed.
+        /// </summary>
+        public static bool AllowDraggingCancellation { get; set; } = true;
+
         /// <summary>
         /// Gets or sets if the current position of containers that are being dragged should not be committed until the end of the dragging operation.
         /// </summary>
@@ -77,7 +86,7 @@ public bool IsDragging
         /// Initiates the dragging operation using the currently selected <see cref="ItemContainer" />s.
         /// </summary>
         /// <remarks>This method has no effect if a dragging operation is already in progress.</remarks>
-        public void BeginDragging() 
+        public void BeginDragging()
             => BeginDragging(SelectedContainers);
 
         /// <summary>
@@ -87,7 +96,7 @@ public void BeginDragging()
         /// <remarks>This method has no effect if a dragging operation is already in progress.</remarks>
         public void BeginDragging(IEnumerable<ItemContainer> containers)
         {
-            if(IsDragging)
+            if (IsDragging)
             {
                 return;
             }
@@ -132,18 +141,23 @@ public void EndDragging()
         }
 
         /// <summary>
-        /// Cancels the ongoing dragging operation, reverting any changes made to the positions of the dragged items.
+        /// Cancels the ongoing dragging operation, reverting any changes made to the positions of the dragged items if <see cref="AllowDraggingCancellation"/> is true.
+        /// Otherwise, it ends the dragging operation by calling <see cref="EndDragging"/>.
         /// </summary>
         /// <remarks>This method has no effect if there's no dragging operation in progress.</remarks>
         public void CancelDragging()
         {
-            if (!ItemContainer.AllowDraggingCancellation || !IsDragging)
+            if (!AllowDraggingCancellation)
             {
+                EndDragging();
                 return;
             }
 
-            _draggingStrategy!.Abort();
-            IsDragging = false;
+            if (IsDragging)
+            {
+                _draggingStrategy!.Abort();
+                IsDragging = false;
+            }
         }
 
         private IDraggingStrategy CreateDraggingStrategy(IEnumerable<ItemContainer> containers)
diff --git a/Nodify/NodifyEditor.Panning.cs b/Nodify/NodifyEditor.Panning.cs
@@ -1,5 +1,4 @@
 ﻿using System;
-using System.Diagnostics;
 using System.Windows;
 using System.Windows.Input;
 using System.Windows.Threading;
@@ -8,6 +7,8 @@ namespace Nodify
 {
     public partial class NodifyEditor
     {
+        #region Dependency properties
+
         public static readonly DependencyProperty AutoPanSpeedProperty = DependencyProperty.Register(nameof(AutoPanSpeed), typeof(double), typeof(NodifyEditor), new FrameworkPropertyMetadata(15d));
         public static readonly DependencyProperty AutoPanEdgeDistanceProperty = DependencyProperty.Register(nameof(AutoPanEdgeDistance), typeof(double), typeof(NodifyEditor), new FrameworkPropertyMetadata(15d));
         public static readonly DependencyProperty DisableAutoPanningProperty = DependencyProperty.Register(nameof(DisableAutoPanning), typeof(bool), typeof(NodifyEditor), new FrameworkPropertyMetadata(BoxValue.False, OnDisableAutoPanningChanged));
@@ -70,6 +71,8 @@ public bool IsPanning
             private set => SetValue(IsPanningPropertyKey, value);
         }
 
+        #endregion
+
         /// <summary>
         /// Gets or sets whether panning cancellation is allowed (see <see cref="EditorGestures.NodifyEditorGestures.CancelAction"/>).
         /// </summary>
@@ -122,17 +125,22 @@ public void UpdatePanning(Vector amount)
 
         /// <summary>
         /// Cancels the current panning operation and reverts the viewport to its initial location if <see cref="AllowPanningCancellation"/> is true.
+        /// Otherwise, it ends the panning operation by calling <see cref="EndPanning"/>.
         /// </summary>
         /// <remarks>This method has no effect if there's no panning operation in progress.</remarks>
         public void CancelPanning()
         {
-            if (!AllowPanningCancellation || !IsPanning)
+            if (!AllowPanningCancellation)
             {
+                EndPanning();
                 return;
             }
 
-            ViewportLocation = _initialPanningLocation;
-            IsPanning = false;
+            if (IsPanning)
+            {
+                ViewportLocation = _initialPanningLocation;
+                IsPanning = false;
+            }
         }
 
         /// <summary>
@@ -146,6 +154,11 @@ public void EndPanning()
 
         #region Auto panning
 
+        private readonly MouseEventArgs _autoPanningEventArgs = new MouseEventArgs(Mouse.PrimaryDevice, 0, Stylus.CurrentStylusDevice)
+        {
+            RoutedEvent = MouseMoveEvent
+        };
+
         private void HandleAutoPanning(object? sender, EventArgs e)
         {
             if (!IsPanning && IsMouseCaptureWithin)
@@ -177,7 +190,9 @@ private void HandleAutoPanning(object? sender, EventArgs e)
                 ViewportLocation = new Point(x, y);
                 MouseLocation = Mouse.GetPosition(ItemsHost);
 
-                State.HandleAutoPanning(new MouseEventArgs(Mouse.PrimaryDevice, 0));
+                _autoPanningEventArgs.Handled = false;
+                _autoPanningEventArgs.Source = this;
+                State.HandleAutoPanning(_autoPanningEventArgs);
             }
         }
 
diff --git a/Nodify/NodifyEditor.PushingItems.cs b/Nodify/NodifyEditor.PushingItems.cs
@@ -58,6 +58,7 @@ public Style PushedAreaStyle
         /// <summary>
         /// Gets or sets whether push items cancellation is allowed (see <see cref="EditorGestures.NodifyEditorGestures.CancelAction"/>).
         /// </summary>
+        /// <remarks>Has no effect if <see cref="AllowDraggingCancellation"/> is false.</remarks>
         public static bool AllowPushItemsCancellation { get; set; } = true;
 
         private IPushStrategy? _pushStrategy;
@@ -70,7 +71,7 @@ public Style PushedAreaStyle
         /// <param name="orientation">The orientation of the <see cref="PushedArea"/>.</param>
         public void BeginPushingItems(Point location, Orientation orientation)
         {
-            if(IsPushingItems)
+            if (IsPushingItems)
             {
                 return;
             }
@@ -114,17 +115,22 @@ public void EndPushingItems()
 
         /// <summary>
         /// Cancels the current pushing operation and reverts the <see cref="PushedArea"/> to its initial state if <see cref="AllowPushItemsCancellation"/> is true.
+        /// Otherwise, it ends the pushing operation by calling <see cref="EndPushingItems"/>.
         /// </summary>
         /// <remarks>This method has no effect if there's no pushing operation in progress.</remarks>
         public void CancelPushingItems()
         {
-            if (!AllowPushItemsCancellation || !IsPushingItems)
+            if (!AllowPushItemsCancellation)
             {
+                EndPushingItems();
                 return;
             }
 
-            PushedArea = _pushStrategy!.Cancel();
-            IsPushingItems = false;
+            if (IsPushingItems)
+            {
+                PushedArea = _pushStrategy!.Cancel();
+                IsPushingItems = false;
+            }
         }
 
         private void UpdatePushedArea()
diff --git a/Nodify/NodifyEditor.Selecting.cs b/Nodify/NodifyEditor.Selecting.cs

Original file line number	Diff line number	Diff line change
`@@ -9,7 +9,7 @@ public class ContainerDraggingState : ContainerState`
`9`	`9`	`private Point _initialMousePosition;`
`10`	`10`	`private Point _previousMousePosition;`
`11`	`11`
`12`		`- private bool Canceled { get; set; } = ItemContainer.AllowDraggingCancellation;`
	`12`	`+ private bool Canceled { get; set; } = NodifyEditor.AllowDraggingCancellation;`
`13`	`13`
`14`	`14`	`/// <summary>Constructs an instance of the <see cref="ContainerDraggingState"/> state.</summary>`
`15`	`15`	`/// <param name="container">The owner of the state.</param>`
`@@ -69,7 +69,7 @@ public override void HandleMouseUp(MouseButtonEventArgs e)`
`69`	`69`
`70`	`70`	`PopState();`
`71`	`71`	`}`
`72`		`- else if (ItemContainer.AllowDraggingCancellation && gestures.CancelAction.Matches(e.Source, e))`
	`72`	`+ else if (NodifyEditor.AllowDraggingCancellation && gestures.CancelAction.Matches(e.Source, e))`
`73`	`73`	`{`
`74`	`74`	`Canceled = true;`
`75`	`75`	`e.Handled = true;`
`@@ -82,7 +82,7 @@ public override void HandleMouseUp(MouseButtonEventArgs e)`
`82`	`82`	`public override void HandleKeyUp(KeyEventArgs e)`
`83`	`83`	`{`
`84`	`84`	`EditorGestures.ItemContainerGestures gestures = EditorGestures.Mappings.ItemContainer;`
`85`		`- if (ItemContainer.AllowDraggingCancellation && gestures.CancelAction.Matches(e.Source, e))`
	`85`	`+ if (NodifyEditor.AllowDraggingCancellation && gestures.CancelAction.Matches(e.Source, e))`
`86`	`86`	`{`
`87`	`87`	`Canceled = true;`
`88`	`88`	`PopState();`
Original file line number	Diff line number	Diff line change
`@@ -6,7 +6,7 @@ namespace Nodify`
`6`	`6`	`public class EditorCuttingState : EditorState`
`7`	`7`	`{`
`8`	`8`	`private Point _initialPosition;`
`9`		`- private bool Canceled { get; set; } = CuttingLine.AllowCuttingCancellation;`
	`9`	`+ private bool Canceled { get; set; } = NodifyEditor.AllowCuttingCancellation;`
`10`	`10`
`11`	`11`	`public EditorCuttingState(NodifyEditor editor) : base(editor)`
`12`	`12`	`{`
`@@ -52,7 +52,7 @@ public override void HandleMouseUp(MouseButtonEventArgs e)`
`52`	`52`
`53`	`53`	`PopState();`
`54`	`54`	`}`
`55`		`- else if (CuttingLine.AllowCuttingCancellation && gestures.CancelAction.Matches(e.Source, e))`
	`55`	`+ else if (NodifyEditor.AllowCuttingCancellation && gestures.CancelAction.Matches(e.Source, e))`
`56`	`56`	`{`
`57`	`57`	`Canceled = true;`
`58`	`58`	`e.Handled = true; // prevents opening context menu`
`@@ -69,7 +69,7 @@ public override void HandleMouseMove(MouseEventArgs e)`
`69`	`69`	`public override void HandleKeyUp(KeyEventArgs e)`
`70`	`70`	`{`
`71`	`71`	`EditorGestures.NodifyEditorGestures gestures = EditorGestures.Mappings.Editor;`
`72`		`- if (CuttingLine.AllowCuttingCancellation && gestures.CancelAction.Matches(e.Source, e))`
	`72`	`+ if (NodifyEditor.AllowCuttingCancellation && gestures.CancelAction.Matches(e.Source, e))`
`73`	`73`	`{`
`74`	`74`	`Canceled = true;`
`75`	`75`	`PopState();`
Original file line number	Diff line number	Diff line change
`@@ -7,6 +7,8 @@ namespace Nodify`
`7`	`7`	`{`
`8`	`8`	`public partial class NodifyEditor`
`9`	`9`	`{`
	`10`	`+ #region Dependency properties`
	`11`	`+`
`10`	`12`	`public static readonly DependencyProperty ItemsDragStartedCommandProperty = DependencyProperty.Register(nameof(ItemsDragStartedCommand), typeof(ICommand), typeof(NodifyEditor));`
`11`	`13`	`public static readonly DependencyProperty ItemsDragCompletedCommandProperty = DependencyProperty.Register(nameof(ItemsDragCompletedCommand), typeof(ICommand), typeof(NodifyEditor));`
`12`	`14`
`@@ -66,6 +68,13 @@ public bool IsDragging`
`66`	`68`	`private set => SetValue(IsDraggingPropertyKey, value);`
`67`	`69`	`}`
`68`	`70`
	`71`	`+ #endregion`
	`72`	`+`
	`73`	`+ /// <summary>`
	`74`	`+ /// Gets or sets whether cancelling a dragging operation is allowed.`
	`75`	`+ /// </summary>`
	`76`	`+ public static bool AllowDraggingCancellation { get; set; } = true;`
	`77`	`+`
`69`	`78`	`/// <summary>`
`70`	`79`	`/// Gets or sets if the current position of containers that are being dragged should not be committed until the end of the dragging operation.`
`71`	`80`	`/// </summary>`
`@@ -77,7 +86,7 @@ public bool IsDragging`
`77`	`86`	`/// Initiates the dragging operation using the currently selected <see cref="ItemContainer" />s.`
`78`	`87`	`/// </summary>`
`79`	`88`	`/// <remarks>This method has no effect if a dragging operation is already in progress.</remarks>`
`80`		`- public void BeginDragging()`
	`89`	`+ public void BeginDragging()`
`81`	`90`	`=> BeginDragging(SelectedContainers);`
`82`	`91`
`83`	`92`	`/// <summary>`
`@@ -87,7 +96,7 @@ public void BeginDragging()`
`87`	`96`	`/// <remarks>This method has no effect if a dragging operation is already in progress.</remarks>`
`88`	`97`	`public void BeginDragging(IEnumerable<ItemContainer> containers)`
`89`	`98`	`{`
`90`		`- if(IsDragging)`
	`99`	`+ if (IsDragging)`
`91`	`100`	`{`
`92`	`101`	`return;`
`93`	`102`	`}`
`@@ -132,18 +141,23 @@ public void EndDragging()`
`132`	`141`	`}`
`133`	`142`
`134`	`143`	`/// <summary>`
`135`		`- /// Cancels the ongoing dragging operation, reverting any changes made to the positions of the dragged items.`
	`144`	`+ /// Cancels the ongoing dragging operation, reverting any changes made to the positions of the dragged items if <see cref="AllowDraggingCancellation"/> is true.`
	`145`	`+ /// Otherwise, it ends the dragging operation by calling <see cref="EndDragging"/>.`
`136`	`146`	`/// </summary>`
`137`	`147`	`/// <remarks>This method has no effect if there's no dragging operation in progress.</remarks>`
`138`	`148`	`public void CancelDragging()`
`139`	`149`	`{`
`140`		`- if (!ItemContainer.AllowDraggingCancellation \|\| !IsDragging)`
	`150`	`+ if (!AllowDraggingCancellation)`
`141`	`151`	`{`
	`152`	`+ EndDragging();`
`142`	`153`	`return;`
`143`	`154`	`}`
`144`	`155`
`145`		`- _draggingStrategy!.Abort();`
`146`		`- IsDragging = false;`
	`156`	`+ if (IsDragging)`
	`157`	`+ {`
	`158`	`+ _draggingStrategy!.Abort();`
	`159`	`+ IsDragging = false;`
	`160`	`+ }`
`147`	`161`	`}`
`148`	`162`
`149`	`163`	`private IDraggingStrategy CreateDraggingStrategy(IEnumerable<ItemContainer> containers)`
Original file line number	Diff line number	Diff line change
`@@ -58,6 +58,7 @@ public Style PushedAreaStyle`
`58`	`58`	`/// <summary>`
`59`	`59`	`/// Gets or sets whether push items cancellation is allowed (see <see cref="EditorGestures.NodifyEditorGestures.CancelAction"/>).`
`60`	`60`	`/// </summary>`
	`61`	`+ /// <remarks>Has no effect if <see cref="AllowDraggingCancellation"/> is false.</remarks>`
`61`	`62`	`public static bool AllowPushItemsCancellation { get; set; } = true;`
`62`	`63`
`63`	`64`	`private IPushStrategy? _pushStrategy;`
`@@ -70,7 +71,7 @@ public Style PushedAreaStyle`
`70`	`71`	`/// <param name="orientation">The orientation of the <see cref="PushedArea"/>.</param>`
`71`	`72`	`public void BeginPushingItems(Point location, Orientation orientation)`
`72`	`73`	`{`
`73`		`- if(IsPushingItems)`
	`74`	`+ if (IsPushingItems)`
`74`	`75`	`{`
`75`	`76`	`return;`
`76`	`77`	`}`
`@@ -114,17 +115,22 @@ public void EndPushingItems()`
`114`	`115`
`115`	`116`	`/// <summary>`
`116`	`117`	`/// Cancels the current pushing operation and reverts the <see cref="PushedArea"/> to its initial state if <see cref="AllowPushItemsCancellation"/> is true.`
	`118`	`+ /// Otherwise, it ends the pushing operation by calling <see cref="EndPushingItems"/>.`
`117`	`119`	`/// </summary>`
`118`	`120`	`/// <remarks>This method has no effect if there's no pushing operation in progress.</remarks>`
`119`	`121`	`public void CancelPushingItems()`
`120`	`122`	`{`
`121`		`- if (!AllowPushItemsCancellation \|\| !IsPushingItems)`
	`123`	`+ if (!AllowPushItemsCancellation)`
`122`	`124`	`{`
	`125`	`+ EndPushingItems();`
`123`	`126`	`return;`
`124`	`127`	`}`
`125`	`128`
`126`		`- PushedArea = _pushStrategy!.Cancel();`
`127`		`- IsPushingItems = false;`
	`129`	`+ if (IsPushingItems)`
	`130`	`+ {`
	`131`	`+ PushedArea = _pushStrategy!.Cancel();`
	`132`	`+ IsPushingItems = false;`
	`133`	`+ }`
`128`	`134`	`}`
`129`	`135`
`130`	`136`	`private void UpdatePushedArea()`