feat: create new window when dragging tab outside the app

src/Notepads/App.xaml.cs

@@ -29,6 +29,7 @@ sealed partial class App : Application
 
  public static bool IsFirstInstance = false;
  public static bool IsGameBarWidget = false;
+ public static string PassedEditorData = string.Empty;
 
  private const string AppCenterSecret = null;
 

src/Notepads/Controls/TextEditor/ITextEditor.cs

@@ -118,6 +118,8 @@ void GetLineColumnSelection(
 
  Task SaveContentToFileAndUpdateEditorState(StorageFile file);
 
+ void UpdateEditingFile(StorageFile file);
+
  string GetContentForSharing();
 
  void TypeText(string text);

src/Notepads/Controls/TextEditor/TextEditor.xaml.cs

@@ -725,6 +725,12 @@ private async Task<TextFile> SaveContentToFile(StorageFile file)
  return new TextFile(text, encoding, lineEnding, newFileModifiedTime);
  }
 
+ public void UpdateEditingFile(StorageFile file)
+ {
+ EditingFile = file;
+ StartCheckingFileStatusPeriodically();
+ }
+
  public string GetContentForSharing()
  {
  return TextEditorCore.Document.Selection.StartPosition == TextEditorCore.Document.Selection.EndPosition ?

src/Notepads/Core/ISessionManager.cs

@@ -1,7 +1,10 @@
 namespace Notepads.Core
 {
+ using Notepads.Controls.TextEditor;
+ using Notepads.Core.SessionDataModels;
  using System;
  using System.Threading.Tasks;
+ using Windows.Storage;
 
  internal interface ISessionManager
  {
@@ -16,5 +19,7 @@ internal interface ISessionManager
  void StopSessionBackup();
 
  Task ClearSessionDataAsync();
+
+ Task<ITextEditor> RecoverTextEditorAsync(TextEditorSessionDataV1 editorSessionData, StorageFile file = null);
  }
 }

src/Notepads/Core/NotepadsCore.cs

@@ -24,6 +24,7 @@
  using Windows.UI.Xaml.Input;
  using Windows.UI.Xaml.Media;
  using Microsoft.AppCenter.Analytics;
+ using Notepads.Core.SessionDataModels;
 
  public class NotepadsCore : INotepadsCore
  {
@@ -56,13 +57,16 @@ public class NotepadsCore : INotepadsCore
 
  private readonly CoreDispatcher _dispatcher;
 
+ public const string NotepadsShouldHandleFileDrop = "NotepadsShouldHandleFileDrop";
  private const string SetDragAndDropActionStatus = "SetDragAndDropActionStatus";
  private const string NotepadsTextEditorMetaData = "NotepadsTextEditorMetaData";
  private const string NotepadsTextEditorGuid = "NotepadsTextEditorGuid";
  private const string NotepadsInstanceId = "NotepadsInstanceId";
  private const string NotepadsTextEditorLastSavedContent = "NotepadsTextEditorLastSavedContent";
  private const string NotepadsTextEditorPendingContent = "NotepadsTextEditorPendingContent";
  private const string NotepadsTextEditorEditingFilePath = "NotepadsTextEditorEditingFilePath";
+ private const string NotepadsTextEditorEditingFile = "NotepadsTextEditorEditingFile";
+ private const string NotepadsTextEditorTempFolderPath = "Temp";
 
  public NotepadsCore(SetsView sets,
  INotepadsExtensionProvider extensionProvider,
@@ -596,7 +600,8 @@ private async void Sets_DragOver(object sender, DragEventArgs args)
  }
  }
 
- if (!canHandle && args.DataView.Contains(StandardDataFormats.StorageItems))
+ if (!canHandle && args.DataView.Contains(StandardDataFormats.StorageItems) &&
+ !args.DataView.Properties.TryGetValue(NotepadsShouldHandleFileDrop, out object handleFileDrop))
  {
  try
  {
@@ -659,9 +664,8 @@ private void Sets_DragItemsStarting(object sender, DragItemsStartingEventArgs ar
  // Add Editing File
  if (editor.EditingFile != null)
  {
- args.Data.Properties.FileTypes.Add(StandardDataFormats.StorageItems);
  args.Data.Properties.Add(NotepadsTextEditorEditingFilePath, editor.EditingFilePath);
- args.Data.SetStorageItems(new List<IStorageItem>() { editor.EditingFile }, readOnly: false);
+ args.Data.Properties.Add(NotepadsTextEditorEditingFile, editor.EditingFile);
  }
 
  args.Data.Properties.Add(NotepadsTextEditorMetaData, data);
@@ -688,7 +692,8 @@ private async void Sets_Drop(object sender, DragEventArgs args)
  if (string.IsNullOrEmpty(args.DataView?.Properties?.ApplicationName) ||
  !string.Equals(args.DataView?.Properties?.ApplicationName, App.ApplicationName))
  {
- if (args.DataView == null || !args.DataView.Contains(StandardDataFormats.StorageItems)) return;
+ if (args.DataView == null || !args.DataView.Contains(StandardDataFormats.StorageItems) ||
+ args.DataView.Properties.TryGetValue(NotepadsShouldHandleFileDrop, out object handleFileDrop)) return;
  var fileDropDeferral = args.GetDeferral();
  var storageItems = await args.DataView.GetStorageItemsAsync();
  StorageItemsDropped?.Invoke(this, storageItems);
@@ -719,18 +724,9 @@ private async void Sets_Drop(object sender, DragEventArgs args)
  }
 
  StorageFile editingFile = null;
-
- if (metaData.HasEditingFile && args.DataView.Contains(StandardDataFormats.StorageItems))
+ if (metaData.HasEditingFile && args.DataView.Properties.TryGetValue(NotepadsTextEditorEditingFile, out object editingFileObj))
  {
- var storageItems = await args.DataView.GetStorageItemsAsync();
- if (storageItems.Count == 1 && storageItems[0] is StorageFile file)
- {
- editingFile = file;
- }
- else
- {
- throw new Exception("Failed to read storage file from dropped set: Expecting only one storage file.");
- }
+ editingFile = (StorageFile)editingFileObj;
  }
 
  string lastSavedText = null;
@@ -816,13 +812,91 @@ private async void Sets_SetDraggedOutside(object sender, SetDraggedOutsideEventA
  {
  if (Sets.Items?.Count > 1 && e.Set?.Content is ITextEditor textEditor)
  {
- // Only allow untitled empty document to be dragged outside for now
- if (!textEditor.IsModified && textEditor.EditingFile == null)
+ var index = Sets.SelectedIndex;
+ var message = new ValueSet();
+ var textEditorData = JsonConvert.SerializeObject(await BuildTextEditorSessionData(textEditor), Formatting.Indented);
+ if (textEditor.FileModificationState != FileModificationState.RenamedMovedOrDeleted)
+ {
+ message.Add("EditorData", textEditorData);
+ DeleteTextEditor(textEditor);
+ if (!await NotepadsProtocolService.LaunchProtocolAsync(NotepadsOperationProtocol.OpenNewInstance, message))
+ {
+ OpenTextEditor(textEditor, index);
+ }
+ }
+ else
  {
+ ApplicationSettingsStore.Write("EditorData", textEditorData);
  DeleteTextEditor(textEditor);
- await NotepadsProtocolService.LaunchProtocolAsync(NotepadsOperationProtocol.OpenNewInstance);
+ if (!await NotepadsProtocolService.LaunchProtocolAsync(NotepadsOperationProtocol.OpenNewInstance, textEditor.EditingFile))
+ {
+ OpenTextEditor(textEditor, index);
+ }
+ }
+ }
+ }
+
+ private async Task<TextEditorSessionDataV1> BuildTextEditorSessionData(ITextEditor textEditor)
+ {
+ TextEditorSessionDataV1 textEditorData = new TextEditorSessionDataV1
+ {
+ Id = textEditor.Id,
+ };
+
+ if (textEditor.EditingFile != null)
+ {
+ // Add the opened file to FutureAccessList so we can access it next launch
+ var futureAccessToken = textEditor.Id.ToString("N");
+ await FutureAccessListUtility.TryAddOrReplaceTokenInFutureAccessList(futureAccessToken, textEditor.EditingFile);
+ textEditorData.EditingFileFutureAccessToken = futureAccessToken;
+ textEditorData.EditingFileName = textEditor.EditingFileName;
+ textEditorData.EditingFilePath = textEditor.EditingFilePath;
+ }
+
+ if (textEditor.IsModified || textEditor.FileModificationState != FileModificationState.Untouched)
+ {
+ if (textEditor.EditingFile != null)
+ {
+ // Persist the last save known to the app, which might not be up-to-date (if the file was modified outside the app)
+ var lastSavedBackupFile = await SessionUtility.CreateNewFileInBackupFolderAsync(
+ textEditor.Id.ToString("N") + "-LastSaved",
+ CreationCollisionOption.ReplaceExisting,
+ NotepadsTextEditorTempFolderPath);
+
+ if (!await SessionManager.BackupTextAsync(textEditor.LastSavedSnapshot.Content,
+ textEditor.LastSavedSnapshot.Encoding,
+ textEditor.LastSavedSnapshot.LineEnding,
+ lastSavedBackupFile))
+ {
+ return null; // Error: Failed to write backup text to file
+ }
+
+ textEditorData.LastSavedBackupFilePath = lastSavedBackupFile.Path;
+ }
+
+ if (textEditor.IsModified)
+ {
+ // Persist pending changes relative to the last save
+ var pendingBackupFile = await SessionUtility.CreateNewFileInBackupFolderAsync(
+ textEditor.Id.ToString("N") + "-Pending",
+ CreationCollisionOption.ReplaceExisting,
+ NotepadsTextEditorTempFolderPath);
+
+ if (!await SessionManager.BackupTextAsync(textEditor.GetText(),
+ textEditor.LastSavedSnapshot.Encoding,
+ textEditor.LastSavedSnapshot.LineEnding,
+ pendingBackupFile))
+ {
+ return null; // Error: Failed to write backup text to file
+ }
+
+ textEditorData.PendingBackupFilePath = pendingBackupFile.Path;
  }
  }
+
+ textEditorData.StateMetaData = textEditor.GetTextEditorStateMetaData();
+
+ return textEditorData;
  }
 
  #endregion

src/Notepads/Core/SessionManager.cs

@@ -387,7 +387,7 @@ private void UnbindEditorContentStateChangeEvent(object sender, ITextEditor text
  textEditor.FileReloaded -= RemoveTextEditorSessionData;
  }
 
- private async Task<ITextEditor> RecoverTextEditorAsync(TextEditorSessionDataV1 editorSessionData)
+ public async Task<ITextEditor> RecoverTextEditorAsync(TextEditorSessionDataV1 editorSessionData, StorageFile file = null)
  {
  StorageFile editingFile = null;
 
@@ -446,10 +446,15 @@ private async Task<ITextEditor> RecoverTextEditorAsync(TextEditorSessionDataV1 e
  textEditor.ResetEditorState(editorSessionData.StateMetaData, pendingText);
  }
 
+ if (file != null)
+ {
+ textEditor.UpdateEditingFile(file);
+ }
+
  return textEditor;
  }
 
- private static async Task<bool> BackupTextAsync(string text, Encoding encoding, LineEnding lineEnding, StorageFile file)
+ public static async Task<bool> BackupTextAsync(string text, Encoding encoding, LineEnding lineEnding, StorageFile file)
  {
  try
  {

src/Notepads/Program.cs

@@ -18,8 +18,6 @@ static void Main(string[] args)
  Task.Run(LoggingService.InitializeFileSystemLoggingAsync);
 #endif
 
- IActivatedEventArgs activatedArgs = AppInstance.GetActivatedEventArgs();
-
  //if (activatedArgs == null)
  //{
  // // No activated event args, so this is not an activation via the multi-instance ID
@@ -37,55 +35,58 @@ static void Main(string[] args)
  ApplicationSettingsStore.Write(SettingsKey.ActiveInstanceIdStr, null);
  }
 
- if (activatedArgs is FileActivatedEventArgs)
- {
- RedirectOrCreateNewInstance();
- }
- else if (activatedArgs is CommandLineActivatedEventArgs)
- {
- RedirectOrCreateNewInstance();
- }
- else if (activatedArgs is ProtocolActivatedEventArgs protocolActivatedEventArgs)
+ switch (AppInstance.GetActivatedEventArgs())
  {
- LoggingService.LogInfo($"[{nameof(Main)}] [ProtocolActivated] Protocol: {protocolActivatedEventArgs.Uri}");
- var protocol = NotepadsProtocolService.GetOperationProtocol(protocolActivatedEventArgs.Uri, out _);
- if (protocol == NotepadsOperationProtocol.OpenNewInstance)
- {
- OpenNewInstance();
- }
- else
- {
- RedirectOrCreateNewInstance();
- }
- }
- else if (activatedArgs is LaunchActivatedEventArgs launchActivatedEventArgs)
- {
- bool handled = false;
+ case LaunchActivatedEventArgs launchActivatedEventArgs:
+ bool handled = false;
 
- if (!string.IsNullOrEmpty(launchActivatedEventArgs.Arguments))
- {
- var protocol = NotepadsProtocolService.GetOperationProtocol(new Uri(launchActivatedEventArgs.Arguments), out _);
- if (protocol == NotepadsOperationProtocol.OpenNewInstance)
+ if (!string.IsNullOrEmpty(launchActivatedEventArgs.Arguments))
  {
- handled = true;
- OpenNewInstance();
+ var protocol = NotepadsProtocolService.GetOperationProtocol(new Uri(launchActivatedEventArgs.Arguments), out _);
+ if (protocol == NotepadsOperationProtocol.OpenNewInstance)
+ {
+ handled = true;
+ OpenNewInstance();
+ }
  }
- }
 
- if (!handled)
- {
+ if (!handled)
+ {
+ RedirectOrCreateNewInstance();
+ }
+ break;
+ case FileActivatedEventArgs fileActivatedEventArgs:
+ if (fileActivatedEventArgs.CallerPackageFamilyName == Package.Current.Id.FamilyName)
+ {
+ OpenNewInstance();
+ }
+ else
+ {
+ RedirectOrCreateNewInstance();
+ }
+ break;
+ case ProtocolActivatedEventArgs protocolActivatedEventArgs:
+ LoggingService.LogInfo($"[{nameof(Main)}] [ProtocolActivated] Protocol: {protocolActivatedEventArgs.Uri}");
+ if (NotepadsProtocolService.GetOperationProtocol(protocolActivatedEventArgs.Uri, out _) == NotepadsOperationProtocol.OpenNewInstance)
+ {
+ OpenNewInstance();
+ }
+ else
+ {
+ RedirectOrCreateNewInstance();
+ }
+ break;
+ default:
  RedirectOrCreateNewInstance();
- }
- }
- else
- {
- RedirectOrCreateNewInstance();
+ break;
  }
  }
 
  private static void OpenNewInstance()
  {
  AppInstance.FindOrRegisterInstanceForKey(App.Id.ToString());
+ App.PassedEditorData = (string)ApplicationSettingsStore.Read("EditorData");
+ ApplicationSettingsStore.Remove("EditorData");
  App.IsFirstInstance = IsFirstInstance;
  Windows.UI.Xaml.Application.Start(p => new App());
  IsFirstInstance = false;