Feature: Enable drag and drop reordering for Pinned Sidebar items

src/Files.App.Controls/Sidebar/DragDropExceptionHelper.cs

@@ -0,0 +1,42 @@
+// Copyright (c) Files Community
+// Licensed under the MIT License.
+
+using System.Diagnostics;
+using System.Runtime.InteropServices;
+
+namespace Files.App.Controls
+{
+	/// <summary>
+	/// Provides helper methods for classifying expected drag-and-drop COM failures
+	/// caused by stale OLE drag payloads (e.g. from Windows Explorer).
+	/// </summary>
+	internal static class DragDropExceptionHelper
+	{
+		// CLIPBRD_E_CANT_OPEN / OLE_E_NOTRUNNING: clipboard/data object is no longer available
+		private const int HRESULT_CLIPBOARD_DATA_UNAVAILABLE = unchecked((int)0x800401D0);
+
+		// RPC_E_SERVERFAULT: OLE/RPC drag pipeline failure (stale cross-process drag)
+		private const int HRESULT_RPC_OLE_FAILURE = unchecked((int)0x80010105);
+
+		/// <summary>
+		/// Returns <see langword="true"/> when <paramref name="ex"/> is a <see cref="COMException"/>
+		/// with an HResult that indicates a stale or already-released OLE drag payload.
+		/// These are expected during sidebar reorder when the user also has File Explorer open.
+		/// </summary>
+		public static bool IsExpectedStaleDragData(Exception ex)
+		{
+			return ex is COMException com &&
+				   (com.HResult == HRESULT_CLIPBOARD_DATA_UNAVAILABLE ||
+					com.HResult == HRESULT_RPC_OLE_FAILURE);
+		}
+
+		/// <summary>
+		/// Writes a debug-level trace for a stale drag payload event.
+		/// </summary>
+		[Conditional("DEBUG")]
+		public static void LogStaleDrag(Exception ex, string message)
+		{
+			Debug.WriteLine($"[DragDrop] {message} HResult=0x{ex.HResult:X8}");
+		}
+	}
+}

src/Files.App.Controls/Sidebar/ISidebarItemModel.cs

@@ -21,4 +21,17 @@ public interface ISidebarItemModel : INotifyPropertyChanged
 		/// </summary>
 		bool PaddedItem { get; }
 	}
+
+	public interface IDraggableSidebarItemModel : ISidebarItemModel
+	{
+		/// <summary>
+		/// The file path used for drag and drop operations
+		/// </summary>
+		string? DropPath { get; }
+
+		/// <summary>
+		/// Indicates whether the item supports reorder dropping
+		/// </summary>
+		bool IsReorderDropItem { get; }
+	}
 }

src/Files.App.Controls/Sidebar/ISidebarViewModel.cs

@@ -9,6 +9,12 @@ namespace Files.App.Controls
 {
 	public record ItemInvokedEventArgs(PointerUpdateKind PointerUpdateKind) { }
 	public record ItemDroppedEventArgs(object DropTarget, DataPackageView DroppedItem, SidebarItemDropPosition dropPosition, DragEventArgs RawEvent) { }
-	public record ItemDragOverEventArgs(object DropTarget, DataPackageView DroppedItem, SidebarItemDropPosition dropPosition, DragEventArgs RawEvent) { }
+	public record ItemDragOverEventArgs(object DropTarget, DataPackageView DroppedItem, SidebarItemDropPosition dropPosition, DragEventArgs RawEvent)
+	{
+		/// <summary>
+		/// Set by the event handler to signal async completion
+		/// </summary>
+		public Task? CompletionTask { get; set; }
+	}
 	public record ItemContextInvokedArgs(object? Item, Point Position) { }
 }

src/Files.App.Controls/Sidebar/SidebarItem.cs

@@ -92,7 +92,17 @@ public void HandleItemChange()
 			HookupItemChangeListener(null, Item);
 			UpdateExpansionState();
 			ReevaluateSelection();
-			CanDrag = Item?.GetType().GetProperty("Path")?.GetValue(Item) is string path && Path.IsPathRooted(path);
+
+			if (Item is IDraggableSidebarItemModel draggableItem)
+			{
+				CanDrag = IsValidDropPath(draggableItem.DropPath);
+				UseReorderDrop = !IsGroupHeader && CanDrag && draggableItem.IsReorderDropItem;
+			}
+			else
+			{
+				CanDrag = false;
+				UseReorderDrop = false;
+			}
 		}
 
 		private void HookupOwners()
@@ -138,32 +148,51 @@ private void HookupItemChangeListener(ISidebarItemModel? oldItem, ISidebarItemMo
 			}
 		}
 
+		private static bool IsValidDropPath(string? path)
+			=> path is not null && (System.IO.Path.IsPathRooted(path) || path.StartsWith("Shell:", StringComparison.OrdinalIgnoreCase));
+
 		private void SidebarItem_DragStarting(UIElement sender, DragStartingEventArgs args)
 		{
-			if (Item?.GetType().GetProperty("Path")?.GetValue(Item) is not string dragPath || !Path.IsPathRooted(dragPath))
+			if (Item is not IDraggableSidebarItemModel draggableItem || draggableItem.DropPath is not string dragPath || !IsValidDropPath(dragPath))
 				return;
 
-			args.Data.SetData(StandardDataFormats.Text, dragPath);
-			args.Data.RequestedOperation = DataPackageOperation.Move | DataPackageOperation.Copy | DataPackageOperation.Link;
-			args.Data.SetDataProvider(StandardDataFormats.StorageItems, async request =>
+			try
 			{
-				var deferral = request.GetDeferral();
-				try
+				args.Data.SetData(StandardDataFormats.Text, dragPath);
+				args.Data.RequestedOperation = DataPackageOperation.Move | DataPackageOperation.Copy | DataPackageOperation.Link;
+				args.Data.SetDataProvider(StandardDataFormats.StorageItems, async request =>
 				{
-					if (Directory.Exists(dragPath))
+					var deferral = request.GetDeferral();
+					try
 					{
-						var folder = await StorageFolder.GetFolderFromPathAsync(dragPath);
-						request.SetData(new IStorageItem[] { folder });
+						if (Directory.Exists(dragPath))
+						{
+							var folder = await StorageFolder.GetFolderFromPathAsync(dragPath);
+							request.SetData(new IStorageItem[] { folder });
+						}
 					}
-				}
-				catch
-				{
-				}
-				finally
-				{
-					deferral.Complete();
-				}
-			});
+					catch (Exception ex) when (DragDropExceptionHelper.IsExpectedStaleDragData(ex))
+					{
+						DragDropExceptionHelper.LogStaleDrag(ex, "Stale external drag payload while resolving StorageFolder in data provider.");
+					}
+					finally
+					{
+						try
+						{
+							deferral.Complete();
+						}
+						catch (Exception ex) when (DragDropExceptionHelper.IsExpectedStaleDragData(ex))
+						{
+							DragDropExceptionHelper.LogStaleDrag(ex, "Stale OLE deferral during drag data provider completion.");
+						}
+					}
+				});
+			}
+			catch (Exception ex) when (DragDropExceptionHelper.IsExpectedStaleDragData(ex))
+			{
+				DragDropExceptionHelper.LogStaleDrag(ex, "Stale OLE drag payload on DragStarting, cancelling drag.");
+				args.Cancel = true;
+			}
 		}
 
 		private void SetFlyoutOpen(bool isOpen = true)
@@ -394,21 +423,61 @@ private async void ItemBorder_DragOver(object sender, DragEventArgs e)
 				IsExpanded = true;
 			}
 
-			var insertsAbove = DetermineDropTargetPosition(e);
-			if (insertsAbove == SidebarItemDropPosition.Center)
+			DragOperationDeferral? deferral = null;
+			try
 			{
-				VisualStateManager.GoToState(this, "DragOnTop", true);
+				deferral = e.GetDeferral();
 			}
-			else if (insertsAbove == SidebarItemDropPosition.Top)
+			catch (Exception ex) when (DragDropExceptionHelper.IsExpectedStaleDragData(ex))
 			{
-				VisualStateManager.GoToState(this, "DragInsertAbove", true);
+				DragDropExceptionHelper.LogStaleDrag(ex, "Stale OLE drag payload on GetDeferral during DragOver.");
+				VisualStateManager.GoToState(this, "Normal", true);
+				return;
 			}
-			else if (insertsAbove == SidebarItemDropPosition.Bottom)
+
+			try
 			{
-				VisualStateManager.GoToState(this, "DragInsertBelow", true);
-			}
+				var dropPosition = DetermineDropTargetPosition(e);
 
-			Owner?.RaiseItemDragOver(this, insertsAbove, e);
+				if (Owner is not null)
+					await Owner.RaiseItemDragOverAsync(this, dropPosition, e);
+
+				if (!e.Handled || e.AcceptedOperation == DataPackageOperation.None)
+				{
+					VisualStateManager.GoToState(this, "Normal", true);
+					return;
+				}
+
+				if (dropPosition == SidebarItemDropPosition.Center)
+				{
+					VisualStateManager.GoToState(this, "DragOnTop", true);
+				}
+				else if (dropPosition == SidebarItemDropPosition.Top)
+				{
+					VisualStateManager.GoToState(this, "DragInsertAbove", true);
+				}
+				else if (dropPosition == SidebarItemDropPosition.Bottom)
+				{
+					VisualStateManager.GoToState(this, "DragInsertBelow", true);
+				}
+			}
+			catch (Exception ex) when (DragDropExceptionHelper.IsExpectedStaleDragData(ex))
+			{
+				DragDropExceptionHelper.LogStaleDrag(ex, "Stale external drag payload during sidebar DragOver processing.");
+				e.AcceptedOperation = DataPackageOperation.None;
+				VisualStateManager.GoToState(this, "Normal", true);
+			}
+			finally
+			{
+				try
+				{
+					deferral?.Complete();
+				}
+				catch (Exception ex) when (DragDropExceptionHelper.IsExpectedStaleDragData(ex))
+				{
+					DragDropExceptionHelper.LogStaleDrag(ex, "Stale OLE deferral on DragOver completion.");
+				}
+			}
 		}
 
 		private void ItemBorder_ContextRequested(UIElement sender, Microsoft.UI.Xaml.Input.ContextRequestedEventArgs args)
@@ -425,7 +494,16 @@ private void ItemBorder_DragLeave(object sender, DragEventArgs e)
 		private void ItemBorder_Drop(object sender, DragEventArgs e)
 		{
 			UpdatePointerState();
-			Owner?.RaiseItemDropped(this, DetermineDropTargetPosition(e), e);
+			try
+			{
+				Owner?.RaiseItemDropped(this, DetermineDropTargetPosition(e), e);
+			}
+			catch (Exception ex) when (DragDropExceptionHelper.IsExpectedStaleDragData(ex))
+			{
+				DragDropExceptionHelper.LogStaleDrag(ex, "Stale external drag payload during sidebar Drop, drop discarded.");
+				e.AcceptedOperation = DataPackageOperation.None;
+				e.Handled = true;
+			}
 		}
 
 		private SidebarItemDropPosition DetermineDropTargetPosition(DragEventArgs args)

src/Files.App.Controls/Sidebar/SidebarView.xaml.cs

@@ -4,6 +4,7 @@
 using Microsoft.UI.Input;
 using Microsoft.UI.Xaml.Input;
 using Microsoft.UI.Xaml.Markup;
+using Windows.ApplicationModel.DataTransfer;
 using Windows.Foundation;
 using Windows.System;
 using Windows.UI.Core;
@@ -53,13 +54,36 @@ internal void RaiseContextRequested(SidebarItem item, Point e)
 		internal void RaiseItemDropped(SidebarItem sideBarItem, SidebarItemDropPosition dropPosition, DragEventArgs rawEvent)
 		{
 			if (sideBarItem.Item is null) return;
-			ItemDropped?.Invoke(this, new(sideBarItem.Item, rawEvent.DataView, dropPosition, rawEvent));
+			DataPackageView dataView;
+			try
+			{
+				dataView = rawEvent.DataView;
+			}
+			catch (Exception ex) when (DragDropExceptionHelper.IsExpectedStaleDragData(ex))
+			{
+				DragDropExceptionHelper.LogStaleDrag(ex, "Stale OLE drag payload reading DataView in RaiseItemDropped.");
+				return;
+			}
+			ItemDropped?.Invoke(this, new(sideBarItem.Item, dataView, dropPosition, rawEvent));
 		}
 
-		internal void RaiseItemDragOver(SidebarItem sideBarItem, SidebarItemDropPosition dropPosition, DragEventArgs rawEvent)
+		internal async Task RaiseItemDragOverAsync(SidebarItem sideBarItem, SidebarItemDropPosition dropPosition, DragEventArgs rawEvent)
 		{
 			if (sideBarItem.Item is null) return;
-			ItemDragOver?.Invoke(this, new(sideBarItem.Item, rawEvent.DataView, dropPosition, rawEvent));
+			DataPackageView dataView;
+			try
+			{
+				dataView = rawEvent.DataView;
+			}
+			catch (Exception ex) when (DragDropExceptionHelper.IsExpectedStaleDragData(ex))
+			{
+				DragDropExceptionHelper.LogStaleDrag(ex, "Stale OLE drag payload reading DataView in RaiseItemDragOverAsync.");
+				return;
+			}
+			var args = new ItemDragOverEventArgs(sideBarItem.Item, dataView, dropPosition, rawEvent);
+			ItemDragOver?.Invoke(this, args);
+			if (args.CompletionTask is not null)
+				await args.CompletionTask;
 		}
 
 		private void UpdateMinimalMode()

src/Files.App/Data/Contracts/INavigationControlItem.cs

@@ -5,12 +5,16 @@
 
 namespace Files.App.Data.Contracts
 {
-	public interface INavigationControlItem : IComparable<INavigationControlItem>, INotifyPropertyChanged, ISidebarItemModel
+	public interface INavigationControlItem : IComparable<INavigationControlItem>, INotifyPropertyChanged, IDraggableSidebarItemModel
 	{
 		public new string Text { get; }
 
 		public string Path { get; }
 
+		string? IDraggableSidebarItemModel.DropPath => Path;
+
+		bool IDraggableSidebarItemModel.IsReorderDropItem => Section == SectionType.Pinned;
+
 		public SectionType Section { get; }
 
 		public NavigationControlItemType ItemType { get; }

src/Files.App/Data/Items/LocationItem.cs

@@ -48,6 +48,8 @@ public string Path
 				ToolTip = string.IsNullOrEmpty(Path) ||
 					Path.Contains('?', StringComparison.Ordinal) ||
 					Path.StartsWith("shell:", StringComparison.OrdinalIgnoreCase) ||
+					Path.StartsWith("::{", StringComparison.Ordinal) ||
+					Path.StartsWith(@"\\SHELL\", StringComparison.OrdinalIgnoreCase) ||
 					Path.EndsWith(ShellLibraryItem.EXTENSION, StringComparison.OrdinalIgnoreCase) ||
 					Path == "Home" ||
 					Path == "ReleaseNotes" ||