Improve NewWindow open mode (#4)

Chaoses-Ib · Chaoses-Ib · commit 9a5656e474d2 · 2023-03-13T00:58:42.000+08:00
diff --git a/ObsidianShell.CLI/Program.cs b/ObsidianShell.CLI/Program.cs
@@ -14,7 +14,7 @@ internal class Program
     {
         static Settings _settings;
 
-        static void Main(string[] args)
+        static async Task Main(string[] args)
         {
             AppDomain.CurrentDomain.UnhandledException += (sender, eventArgs) =>
             {
@@ -30,7 +30,7 @@ static void Main(string[] args)
             _settings = Settings.Load();
 
             Obsidian obsidian = new Obsidian(_settings);
-            obsidian.OpenFile(args[0]);
+            await obsidian.OpenFile(args[0]);
         }
     }
 }
diff --git a/ObsidianShell.GUI/MainViewModel.cs b/ObsidianShell.GUI/MainViewModel.cs
@@ -66,6 +66,7 @@ public MainViewModel()
                 ObsidianOpenMode.CurrentTab,
                 ObsidianOpenMode.NewTab,
                 ObsidianOpenMode.NewWindow,
+                ObsidianOpenMode.VaultAndNewWindow,
                 ObsidianOpenMode.NewPane,
                 ObsidianOpenMode.HoverPopover
             };
diff --git a/ObsidianShell/NativeMethods.txt b/ObsidianShell/NativeMethods.txt
@@ -0,0 +1,11 @@
+BringWindowToTop
+EnumThreadWindows
+GetAsyncKeyState
+GetClassName
+GetWindow
+IsIconic
+IsWindowVisible
+SendMessage
+SetWindowPos
+ShowWindow
+WM_GETTEXT
diff --git a/ObsidianShell/Obsidian.cs b/ObsidianShell/Obsidian.cs
@@ -5,9 +5,13 @@
 using System.IO;
 using System.Linq;
 using System.Runtime;
+using System.Runtime.InteropServices;
 using System.Text;
+using System.Threading;
 using System.Threading.Tasks;
 using System.Windows.Forms;
+using Windows.Win32;
+using Windows.Win32.Foundation;
 
 namespace ObsidianShell
 {
@@ -20,15 +24,15 @@ public Obsidian(Settings settings)
             _settings = settings;
         }
         
-        public void OpenFile(string path)
+        public async Task OpenFile(string path)
         {
             switch (_settings.OpenMode)
             {
                 case OpenMode.VaultFallback:
                     {
                         if (IsFileInVault(path))
                         {
-                            OpenFileInVault(path);
+                            await OpenFileInVault(path);
                         }
                         else
                         {
@@ -40,17 +44,17 @@ public void OpenFile(string path)
                     {
                         if (IsFileInVault(path))
                         {
-                            OpenFileInVault(path);
+                            await OpenFileInVault(path);
                         }
                         else
                         {
-                            OpenFileInRecent(path);
+                            await OpenFileInRecent(path);
                         }
                         break;
                     }
                 case OpenMode.Recent:
                     {
-                        OpenFileInRecent(path);
+                        await OpenFileInRecent(path);
                         break;
                     }
             }
@@ -63,7 +67,7 @@ private static string PercentEncode(string text)
             return Uri.EscapeDataString(text);
         }
 
-        private void OpenFileInVault(string path, string vaultPath = null)
+        private async Task OpenFileInVault(string path, string vaultPath = null)
         {
             if (_settings.EnableAdvancedURI is false)
             {
@@ -73,7 +77,7 @@ private void OpenFileInVault(string path, string vaultPath = null)
             {
                 vaultPath = vaultPath ?? GetFileVaultPath(path);
                 string vault = GetVaultName(vaultPath);
-                string filename = Utils.GetRelativePath(vaultPath, path);
+                string filepath = Utils.GetRelativePath(vaultPath, path);
 
                 ObsidianOpenMode obsidianOpenMode = _settings.ObsidianDefaultOpenMode;
                 if (Utils.IsKeyPressed(Keys.ControlKey))
@@ -85,20 +89,60 @@ private void OpenFileInVault(string path, string vaultPath = null)
                 if (Utils.IsKeyPressed(Keys.LWin) || Utils.IsKeyPressed(Keys.RWin))
                     obsidianOpenMode = _settings.ObsidianWinOpenMode;
 
-                string openmode = obsidianOpenMode switch
+                if (obsidianOpenMode is ObsidianOpenMode.NewWindow)
                 {
-                    ObsidianOpenMode.CurrentTab => "false",
-                    ObsidianOpenMode.NewTab => "tab",
-                    ObsidianOpenMode.NewWindow => "window",
-                    ObsidianOpenMode.NewPane => "split",
-                    ObsidianOpenMode.HoverPopover => "popover",
-                    _ => throw new ArgumentException()
-                };
-                
-                Process.Start($"obsidian://advanced-uri?vault={PercentEncode(vault)}&filepath={PercentEncode(filename)}&openmode={openmode}");
+                    await OpenFileInNewWindow(vault, filepath);
+                }
+                else
+                {
+                    string openmode = obsidianOpenMode switch
+                    {
+                        ObsidianOpenMode.CurrentTab => "false",
+                        ObsidianOpenMode.NewTab => "tab",
+                        //ObsidianOpenMode.NewWindow => "window",
+                        ObsidianOpenMode.NewPane => "split",
+                        ObsidianOpenMode.HoverPopover => "popover",
+                        ObsidianOpenMode.VaultAndNewWindow => "window",
+                        _ => throw new ArgumentException()
+                    };
+                    Process.Start($"obsidian://advanced-uri?vault={PercentEncode(vault)}&filepath={PercentEncode(filepath)}&openmode={openmode}");
+                }
             }
         }
 
+        private async Task OpenFileInNewWindow(string vault, string filepath)
+        {
+            List<WindowVisualState> states = Utils.EnumerateProcessWindowHandles("Obsidian", "Chrome_WidgetWin_1").Select(w => new WindowVisualState(w)).ToList();
+            Process.Start($"obsidian://advanced-uri?vault={PercentEncode(vault)}&filepath={PercentEncode(filepath)}&openmode=window");
+
+            Stopwatch stopwach = Stopwatch.StartNew();
+            do
+            {
+                await Task.Delay(50);
+                // This is not precise enough. If the vault hasn't been opend before, Obsidian will create two or more windows.
+                // But that case is hard to detect.
+                if (Utils.EnumerateProcessWindowHandles("Obsidian", "Chrome_WidgetWin_1").Count() > states.Count)
+                {
+                    // 250~477ms
+                    Debug.WriteLine($"Found new window after {stopwach.ElapsedMilliseconds}ms");
+                    break;
+                }
+            } while (stopwach.ElapsedMilliseconds < 10000);
+
+            foreach (WindowVisualState state in states)
+            {
+                state.Restore();
+            }
+
+            /*
+            // If not specify Chrome_WidgetWin_1, we will get Chrome_WidgetWin_0.
+            HWND newWindow = Utils.EnumerateProcessWindowHandles("Obsidian", "Chrome_WidgetWin_1").Where(x => !states.Select(x => x.Handle).Contains(x)).First();
+            Debug.WriteLine($"New window: {new WindowVisualState(newWindow)}");
+
+            PInvoke.BringWindowToTop(newWindow);
+            */
+        }
+
         private static string GetVaultName(string path)
         {
             return Path.GetFileName(path);
@@ -142,7 +186,7 @@ private void OpenFileByFallback(string path)
             Process.Start(editor, String.Format(_settings.FallbackMarkdownEditorArguments, $@"""{path}"""));
         }
 
-        private void OpenFileInRecent(string path)
+        private async Task OpenFileInRecent(string path)
         {
             // hard link stays valid when the source file is deleted;
             // symbolic link requires SeCreateSymbolicLinkPrivilege;
@@ -177,7 +221,7 @@ private void OpenFileInRecent(string path)
                 path_in_recent = CreateLinkInRecent(directory.Parent, false) + '\\' + directory.Name;
             }
 
-            OpenFileInVault(path_in_recent, _settings.RecentVault);
+            await OpenFileInVault(path_in_recent, _settings.RecentVault);
         }
 
         private static string FormatLinkName(string prefixed_name, bool explicitDirectory)
diff --git a/ObsidianShell/ObsidianShell.csproj b/ObsidianShell/ObsidianShell.csproj
@@ -6,15 +6,19 @@
   </PropertyGroup>
 
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
-    <DebugType>none</DebugType>
+    <DebugType>full</DebugType>
   </PropertyGroup>
 
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">
-    <DebugType>none</DebugType>
+    <DebugType>full</DebugType>
   </PropertyGroup>
 
   <ItemGroup>
     <PackageReference Include="Fastenshtein" Version="1.0.0.8" />
+    <PackageReference Include="Microsoft.Windows.CsWin32" Version="0.2.188-beta">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
     <PackageReference Include="NCode.ReparsePoints" Version="1.0.2" />
     <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
     <PackageReference Include="PropertyChanged.Fody" Version="4.1.0" />
diff --git a/ObsidianShell/Settings.cs b/ObsidianShell/Settings.cs
@@ -18,8 +18,9 @@ public enum ObsidianOpenMode
         CurrentTab = 0,
         NewTab = 1,
         NewWindow = 2,
+        VaultAndNewWindow = 5,
         NewPane = 3,
-        HoverPopover = 4
+        HoverPopover = 4,
     }
 
     public class Settings : INotifyPropertyChanged
@@ -35,10 +36,10 @@ public class Settings : INotifyPropertyChanged
         public int RecentVaultSubdirectoriesLimit { get; set; } = 10;
 
         public bool EnableAdvancedURI { get; set; } = false;
-        public ObsidianOpenMode ObsidianDefaultOpenMode { get; set; } = ObsidianOpenMode.NewWindow;
+        public ObsidianOpenMode ObsidianDefaultOpenMode { get; set; } = ObsidianOpenMode.NewTab;
         public ObsidianOpenMode ObsidianCtrlOpenMode { get; set; } = ObsidianOpenMode.NewPane;
-        public ObsidianOpenMode ObsidianShiftOpenMode { get; set; } = ObsidianOpenMode.CurrentTab;
-        public ObsidianOpenMode ObsidianAltOpenMode { get; set; } = ObsidianOpenMode.NewTab;
+        public ObsidianOpenMode ObsidianShiftOpenMode { get; set; } = ObsidianOpenMode.NewWindow;
+        public ObsidianOpenMode ObsidianAltOpenMode { get; set; } = ObsidianOpenMode.CurrentTab;
         public ObsidianOpenMode ObsidianWinOpenMode { get; set; } = ObsidianOpenMode.HoverPopover;
 
         private static string GetPath()
diff --git a/ObsidianShell/Utils.cs b/ObsidianShell/Utils.cs
@@ -1,22 +1,114 @@
 ﻿using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.IO;
 using System.Linq;
 using System.Runtime.InteropServices;
 using System.Text;
 using System.Threading.Tasks;
 using System.Windows.Forms;
+using Windows.Win32;
+using Windows.Win32.Foundation;
+using Windows.Win32.UI.WindowsAndMessaging;
 
 namespace ObsidianShell
 {
+    internal class WindowVisualState
+    {
+        public HWND Handle { get; }
+        //private bool _visibility;
+        private bool _minimized;
+        private HWND _prevWindow;
+
+        public WindowVisualState(HWND handle)
+        {
+            Handle = handle;
+            //_visibility = PInvoke.IsWindowVisible(handle);
+            _minimized = PInvoke.IsIconic(handle);
+            _prevWindow = GetPrevVisibleWindow(handle);
+        }
+
+        private static HWND GetPrevVisibleWindow(HWND handle)
+        {
+            HWND nextWindow = handle;
+            while ((nextWindow = PInvoke.GetWindow(nextWindow, GET_WINDOW_CMD.GW_HWNDPREV)) != default)
+            {
+                if (PInvoke.IsWindowVisible(nextWindow))
+                    return nextWindow;
+            }
+            return default;
+        }
+
+        public void Restore()
+        {
+            WindowVisualState newState = new(Handle);
+            if (//newState._visibility != _visibility ||
+                newState._minimized != _minimized ||
+                newState._prevWindow != _prevWindow
+                )
+            {
+                SET_WINDOW_POS_FLAGS flags = SET_WINDOW_POS_FLAGS.SWP_NOSIZE | SET_WINDOW_POS_FLAGS.SWP_NOMOVE | SET_WINDOW_POS_FLAGS.SWP_NOACTIVATE;
+                //flags |= _visibility ? SET_WINDOW_POS_FLAGS.SWP_SHOWWINDOW : SET_WINDOW_POS_FLAGS.SWP_HIDEWINDOW;
+                // SetWindowPos will move hWnd below hWndInsertAfter
+                PInvoke.SetWindowPos(Handle, _prevWindow, 0, 0, 0, 0, flags);
+
+                if (_minimized)
+                    PInvoke.ShowWindow(Handle, SHOW_WINDOW_CMD.SW_MINIMIZE);
+
+                Debug.WriteLine($"{this}\n-> {newState}\n-> {new WindowVisualState(Handle)}");
+            }
+        }
+
+        public override string ToString()
+        {
+            return @$"{Handle.Value}({Utils.GetClassName(Handle)}:{Utils.GetWindowText(Handle)}) {""/*_visibility*/} {_minimized} {_prevWindow.Value}({Utils.GetClassName(_prevWindow)}:{Utils.GetWindowText(_prevWindow)})";
+        }
+    }
+
     internal class Utils
     {
-        [DllImport("user32.dll")]
-        private static extern short GetAsyncKeyState(Keys vKey);
+        internal static string GetClassName(HWND hWnd)
+        {
+            unsafe
+            {
+                char* className = stackalloc char[256];
+                PInvoke.GetClassName(hWnd, className, 256);
+                return new string(className);
+            }
+        }        
+
+        internal static string GetWindowText(HWND hWnd)
+        {
+            unsafe
+            {
+                char* buffer = stackalloc char[256];
+                PInvoke.SendMessage(hWnd, PInvoke.WM_GETTEXT, 256, (nint)buffer);
+                return new(buffer);
+            }
+        }
+
+        public static IEnumerable<HWND> EnumerateProcessWindowHandles(string friendlyProcessName, string className = null)
+        {
+            List<HWND> handles = new();
+            foreach (Process process in Process.GetProcessesByName(friendlyProcessName))
+            {
+                foreach (ProcessThread thread in process.Threads)
+                {
+                    PInvoke.EnumThreadWindows((uint)thread.Id, (hWnd, lParam) => {
+                        if (className is null || GetClassName(hWnd) == className)
+                        {
+                            handles.Add(hWnd);
+                        }
+                        return true;
+                    }, IntPtr.Zero);
+                }
+            }
+            return handles;
+        }
 
         public static bool IsKeyPressed(Keys key)
         {
-            return (GetAsyncKeyState(key) & 0x8000) != 0;            
+            return (PInvoke.GetAsyncKeyState((int)key) & 0x8000) != 0;
         }
 
         /// <summary>

Original file line number	Diff line number	Diff line change
`@@ -14,7 +14,7 @@ internal class Program`
`14`	`14`	`{`
`15`	`15`	`static Settings _settings;`
`16`	`16`
`17`		`- static void Main(string[] args)`
	`17`	`+ static async Task Main(string[] args)`
`18`	`18`	`{`
`19`	`19`	`AppDomain.CurrentDomain.UnhandledException += (sender, eventArgs) =>`
`20`	`20`	`{`
`@@ -30,7 +30,7 @@ static void Main(string[] args)`
`30`	`30`	`_settings = Settings.Load();`
`31`	`31`
`32`	`32`	`Obsidian obsidian = new Obsidian(_settings);`
`33`		`- obsidian.OpenFile(args[0]);`
	`33`	`+ await obsidian.OpenFile(args[0]);`
`34`	`34`	`}`
`35`	`35`	`}`
`36`	`36`	`}`
Original file line number	Diff line number	Diff line change
`@@ -5,9 +5,13 @@`
`5`	`5`	`using System.IO;`
`6`	`6`	`using System.Linq;`
`7`	`7`	`using System.Runtime;`
	`8`	`+using System.Runtime.InteropServices;`
`8`	`9`	`using System.Text;`
	`10`	`+using System.Threading;`
`9`	`11`	`using System.Threading.Tasks;`
`10`	`12`	`using System.Windows.Forms;`
	`13`	`+using Windows.Win32;`
	`14`	`+using Windows.Win32.Foundation;`
`11`	`15`
`12`	`16`	`namespace ObsidianShell`
`13`	`17`	`{`
`@@ -20,15 +24,15 @@ public Obsidian(Settings settings)`
`20`	`24`	`_settings = settings;`
`21`	`25`	`}`
`22`	`26`
`23`		`- public void OpenFile(string path)`
	`27`	`+ public async Task OpenFile(string path)`
`24`	`28`	`{`
`25`	`29`	`switch (_settings.OpenMode)`
`26`	`30`	`{`
`27`	`31`	`case OpenMode.VaultFallback:`
`28`	`32`	`{`
`29`	`33`	`if (IsFileInVault(path))`
`30`	`34`	`{`
`31`		`- OpenFileInVault(path);`
	`35`	`+ await OpenFileInVault(path);`
`32`	`36`	`}`
`33`	`37`	`else`
`34`	`38`	`{`
`@@ -40,17 +44,17 @@ public void OpenFile(string path)`
`40`	`44`	`{`
`41`	`45`	`if (IsFileInVault(path))`
`42`	`46`	`{`
`43`		`- OpenFileInVault(path);`
	`47`	`+ await OpenFileInVault(path);`
`44`	`48`	`}`
`45`	`49`	`else`
`46`	`50`	`{`
`47`		`- OpenFileInRecent(path);`
	`51`	`+ await OpenFileInRecent(path);`
`48`	`52`	`}`
`49`	`53`	`break;`
`50`	`54`	`}`
`51`	`55`	`case OpenMode.Recent:`
`52`	`56`	`{`
`53`		`- OpenFileInRecent(path);`
	`57`	`+ await OpenFileInRecent(path);`
`54`	`58`	`break;`
`55`	`59`	`}`
`56`	`60`	`}`
`@@ -63,7 +67,7 @@ private static string PercentEncode(string text)`
`63`	`67`	`return Uri.EscapeDataString(text);`
`64`	`68`	`}`
`65`	`69`
`66`		`- private void OpenFileInVault(string path, string vaultPath = null)`
	`70`	`+ private async Task OpenFileInVault(string path, string vaultPath = null)`
`67`	`71`	`{`
`68`	`72`	`if (_settings.EnableAdvancedURI is false)`
`69`	`73`	`{`
`@@ -73,7 +77,7 @@ private void OpenFileInVault(string path, string vaultPath = null)`
`73`	`77`	`{`
`74`	`78`	`vaultPath = vaultPath ?? GetFileVaultPath(path);`
`75`	`79`	`string vault = GetVaultName(vaultPath);`
`76`		`- string filename = Utils.GetRelativePath(vaultPath, path);`
	`80`	`+ string filepath = Utils.GetRelativePath(vaultPath, path);`
`77`	`81`
`78`	`82`	`ObsidianOpenMode obsidianOpenMode = _settings.ObsidianDefaultOpenMode;`
`79`	`83`	`if (Utils.IsKeyPressed(Keys.ControlKey))`
`@@ -85,20 +89,60 @@ private void OpenFileInVault(string path, string vaultPath = null)`
`85`	`89`	`if (Utils.IsKeyPressed(Keys.LWin) \|\| Utils.IsKeyPressed(Keys.RWin))`
`86`	`90`	`obsidianOpenMode = _settings.ObsidianWinOpenMode;`
`87`	`91`
`88`		`- string openmode = obsidianOpenMode switch`
	`92`	`+ if (obsidianOpenMode is ObsidianOpenMode.NewWindow)`
`89`	`93`	`{`
`90`		`- ObsidianOpenMode.CurrentTab => "false",`
`91`		`- ObsidianOpenMode.NewTab => "tab",`
`92`		`- ObsidianOpenMode.NewWindow => "window",`
`93`		`- ObsidianOpenMode.NewPane => "split",`
`94`		`- ObsidianOpenMode.HoverPopover => "popover",`
`95`		`- _ => throw new ArgumentException()`
`96`		`- };`
`97`		`-`
`98`		`- Process.Start($"obsidian://advanced-uri?vault={PercentEncode(vault)}&filepath={PercentEncode(filename)}&openmode={openmode}");`
	`94`	`+ await OpenFileInNewWindow(vault, filepath);`
	`95`	`+ }`
	`96`	`+ else`
	`97`	`+ {`
	`98`	`+ string openmode = obsidianOpenMode switch`
	`99`	`+ {`
	`100`	`+ ObsidianOpenMode.CurrentTab => "false",`
	`101`	`+ ObsidianOpenMode.NewTab => "tab",`
	`102`	`+ //ObsidianOpenMode.NewWindow => "window",`
	`103`	`+ ObsidianOpenMode.NewPane => "split",`
	`104`	`+ ObsidianOpenMode.HoverPopover => "popover",`
	`105`	`+ ObsidianOpenMode.VaultAndNewWindow => "window",`
	`106`	`+ _ => throw new ArgumentException()`
	`107`	`+ };`
	`108`	`+ Process.Start($"obsidian://advanced-uri?vault={PercentEncode(vault)}&filepath={PercentEncode(filepath)}&openmode={openmode}");`
	`109`	`+ }`
`99`	`110`	`}`
`100`	`111`	`}`
`101`	`112`
	`113`	`+ private async Task OpenFileInNewWindow(string vault, string filepath)`
	`114`	`+ {`
	`115`	`+ List<WindowVisualState> states = Utils.EnumerateProcessWindowHandles("Obsidian", "Chrome_WidgetWin_1").Select(w => new WindowVisualState(w)).ToList();`
	`116`	`+ Process.Start($"obsidian://advanced-uri?vault={PercentEncode(vault)}&filepath={PercentEncode(filepath)}&openmode=window");`
	`117`	`+`
	`118`	`+ Stopwatch stopwach = Stopwatch.StartNew();`
	`119`	`+ do`
	`120`	`+ {`
	`121`	`+ await Task.Delay(50);`
	`122`	`+ // This is not precise enough. If the vault hasn't been opend before, Obsidian will create two or more windows.`
	`123`	`+ // But that case is hard to detect.`
	`124`	`+ if (Utils.EnumerateProcessWindowHandles("Obsidian", "Chrome_WidgetWin_1").Count() > states.Count)`
	`125`	`+ {`
	`126`	`+ // 250~477ms`
	`127`	`+ Debug.WriteLine($"Found new window after {stopwach.ElapsedMilliseconds}ms");`
	`128`	`+ break;`
	`129`	`+ }`
	`130`	`+ } while (stopwach.ElapsedMilliseconds < 10000);`
	`131`	`+`
	`132`	`+ foreach (WindowVisualState state in states)`
	`133`	`+ {`
	`134`	`+ state.Restore();`
	`135`	`+ }`
	`136`	`+`
	`137`	`+ /*`
	`138`	`+ // If not specify Chrome_WidgetWin_1, we will get Chrome_WidgetWin_0.`
	`139`	`+ HWND newWindow = Utils.EnumerateProcessWindowHandles("Obsidian", "Chrome_WidgetWin_1").Where(x => !states.Select(x => x.Handle).Contains(x)).First();`
	`140`	`+ Debug.WriteLine($"New window: {new WindowVisualState(newWindow)}");`
	`141`	`+`
	`142`	`+ PInvoke.BringWindowToTop(newWindow);`
	`143`	`+ */`
	`144`	`+ }`
	`145`	`+`
`102`	`146`	`private static string GetVaultName(string path)`
`103`	`147`	`{`
`104`	`148`	`return Path.GetFileName(path);`
`@@ -142,7 +186,7 @@ private void OpenFileByFallback(string path)`
`142`	`186`	`Process.Start(editor, String.Format(_settings.FallbackMarkdownEditorArguments, $@"""{path}"""));`
`143`	`187`	`}`
`144`	`188`
`145`		`- private void OpenFileInRecent(string path)`
	`189`	`+ private async Task OpenFileInRecent(string path)`
`146`	`190`	`{`
`147`	`191`	`// hard link stays valid when the source file is deleted;`
`148`	`192`	`// symbolic link requires SeCreateSymbolicLinkPrivilege;`
`@@ -177,7 +221,7 @@ private void OpenFileInRecent(string path)`
`177`	`221`	`path_in_recent = CreateLinkInRecent(directory.Parent, false) + '\\' + directory.Name;`
`178`	`222`	`}`
`179`	`223`
`180`		`- OpenFileInVault(path_in_recent, _settings.RecentVault);`
	`224`	`+ await OpenFileInVault(path_in_recent, _settings.RecentVault);`
`181`	`225`	`}`
`182`	`226`
`183`	`227`	`private static string FormatLinkName(string prefixed_name, bool explicitDirectory)`