Improving overall quality of the implementation.

1- Bringing CommandLineToArgvW to parse command registry from Win32API
2- Execution of the context menu was a problem for some applications. This has been fixed.
3- Improved MUIVerb support

Author: Bura Chuhadar

Files.Launcher/Program.cs

@@ -4,6 +4,8 @@
 using System.Collections.Generic;
 using System.ComponentModel;
 using System.Diagnostics;
+using System.Drawing;
+using System.Drawing.Imaging;
 using System.IO;
 using System.Linq;
 using System.Runtime.InteropServices;
@@ -255,6 +257,12 @@ private static async void Connection_RequestReceived(AppServiceConnection sender
                             responseSet.Add("MUIVerbString", Win32API.ExtractStringFromDLL((string)args.Request.Message["MUIVerbLocation"], (int)args.Request.Message["MUIVerbLine"]));
                             await args.Request.SendResponseAsync(responseSet);
                             break;
+                        case "ParseAguments":
+                            var responseArray = new ValueSet();
+                            var resultArgument = Win32API.CommandLineToArgs((string)args.Request.Message["Command"]);
+                            responseArray.Add("ParsedArguments", Newtonsoft.Json.JsonConvert.SerializeObject(resultArgument));
+                            await args.Request.SendResponseAsync(responseArray);
+                            break;
                         default:
                             if(args.Request.Message.ContainsKey("Application"))
                             {

Files.Launcher/Win32API.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Drawing;
 using System.Linq;
 using System.Runtime.InteropServices;
 using System.Text;
@@ -81,6 +82,7 @@ public static IList<object> GetFileProperties(ShellItem folderItem, List<(Vanara
         [return: MarshalAs(UnmanagedType.Bool)]
         private static extern bool FreeLibrary(IntPtr hModule);
 
+
         public static string ExtractStringFromDLL(string file, int number)
         {
             IntPtr lib = LoadLibrary(file);
@@ -89,5 +91,37 @@ public static string ExtractStringFromDLL(string file, int number)
             FreeLibrary(lib);
             return result.ToString();
         }
+
+
+        [DllImport("shell32.dll", SetLastError = true)]
+        public static extern IntPtr CommandLineToArgvW([MarshalAs(UnmanagedType.LPWStr)] string lpCmdLine, out int pNumArgs);
+        
+        [DllImport("kernel32.dll")]
+        public static extern IntPtr LocalFree(IntPtr hMem);
+
+        public static string[] CommandLineToArgs(string commandLine)
+        {
+            if (String.IsNullOrEmpty(commandLine))
+                return Array.Empty<string>();
+
+            var argv = CommandLineToArgvW(commandLine, out int argc);
+            if (argv == IntPtr.Zero)
+                throw new System.ComponentModel.Win32Exception();
+            try
+            {
+                var args = new string[argc];
+                for (var i = 0; i < args.Length; i++)
+                {
+                    var p = Marshal.ReadIntPtr(argv, i * IntPtr.Size);
+                    args[i] = Marshal.PtrToStringUni(p);
+                }
+
+                return args;
+            }
+            finally
+            {
+                Marshal.FreeHGlobal(argv);
+            }
+        }
     }
 }

Files/BaseLayout.cs

@@ -15,7 +15,10 @@
 using Windows.UI.Core;
 using Windows.UI.Xaml;
 using Windows.UI.Xaml.Controls;
+using Windows.UI.Xaml.Controls.Primitives;
 using Windows.UI.Xaml.Input;
+using Windows.UI.Xaml.Media;
+using Windows.UI.Xaml.Media.Imaging;
 using Windows.UI.Xaml.Navigation;
 
 namespace Files
@@ -118,7 +121,7 @@ private void ClearShellContextMenus()
             {
                 BaseLayoutItemContextFlyout.Items.RemoveAt(BaseLayoutItemContextFlyout.Items.IndexOf(contextMenuItems[i]));
             }
-            if (BaseLayoutItemContextFlyout.Items[BaseLayoutItemContextFlyout.Items.Count-1] is MenuFlyoutSeparator flyoutSeperator)
+            if (BaseLayoutItemContextFlyout.Items[0] is MenuFlyoutSeparator flyoutSeperator)
             {
                 BaseLayoutItemContextFlyout.Items.RemoveAt(BaseLayoutItemContextFlyout.Items.IndexOf(flyoutSeperator));
             }
@@ -127,24 +130,19 @@ private void ClearShellContextMenus()
         public virtual async System.Threading.Tasks.Task SetShellContextmenu()
         {
             ClearShellContextMenus();
-            if (_SelectedItems != null)
+            if (_SelectedItems != null && _SelectedItems.Count > 0)
             {
-                if (!(BaseLayoutItemContextFlyout.Items[BaseLayoutItemContextFlyout.Items.Count - 1] is MenuFlyoutSeparator))
-                {
-                    BaseLayoutItemContextFlyout.Items.Add(new MenuFlyoutSeparator());
-                }
                 var currentBaseLayoutItemCount = BaseLayoutItemContextFlyout.Items.Count;
                 var isDirectory = !_SelectedItems.Any(c=> c.PrimaryItemAttribute == StorageItemTypes.File || c.PrimaryItemAttribute == StorageItemTypes.None);
                 foreach (var selectedItem in _SelectedItems)
                 {  
                     var menuFlyoutItems = await new RegistryReader().GetExtensionContextMenuForFiles(isDirectory, selectedItem.FileExtension);
                     LoadMenuFlyoutItem(menuFlyoutItems);
                 }
-                
-                if(currentBaseLayoutItemCount == BaseLayoutItemContextFlyout.Items.Count && 
-                    BaseLayoutItemContextFlyout.Items[BaseLayoutItemContextFlyout.Items.Count - 1] is MenuFlyoutSeparator flyoutSeperator)
+                var totalFlyoutItems = BaseLayoutItemContextFlyout.Items.Count - currentBaseLayoutItemCount;
+                if (totalFlyoutItems > 0 && !(BaseLayoutItemContextFlyout.Items[totalFlyoutItems] is MenuFlyoutSeparator))
                 {
-                    BaseLayoutItemContextFlyout.Items.RemoveAt(BaseLayoutItemContextFlyout.Items.IndexOf(flyoutSeperator));
+                    BaseLayoutItemContextFlyout.Items.Insert(totalFlyoutItems, new MenuFlyoutSeparator());
                 }
             }
         }
@@ -239,15 +237,15 @@ private void LoadMenuFlyoutItem(IEnumerable<(string commandKey,string commandNam
                 {
                     continue;
                 }
-               
+            
                 var menuLayoutItem = new MenuFlyoutItem()
                 {
                     Text = menuFlyoutItem.commandName,
                     Tag = menuFlyoutItem
                 };
                 menuLayoutItem.Click += MenuLayoutItem_Click;
 
-                BaseLayoutItemContextFlyout.Items.Add(menuLayoutItem);
+                BaseLayoutItemContextFlyout.Items.Insert(0, menuLayoutItem);
             }
         }
 
@@ -271,28 +269,24 @@ private async void MenuLayoutItem_Click(object sender, RoutedEventArgs e)
                 var (_, _, _, command) = ParseContextMenuTag(currentMenuLayoutItem.Tag);
                 if (selectedFileSystemItems.Count > 1)
                 {
-                    var commandsToExecute = new List<string>();
                     foreach (var selectedDataItem in selectedFileSystemItems)
                     {
-                        var commandToExecute = command?.Replace("%1", selectedDataItem.ItemPath);
-                        if (!string.IsNullOrEmpty(commandToExecute))
+                        var commandToExecute = await new ShellCommandParser().ParseShellCommand(command, selectedDataItem.ItemPath);
+                        if (!string.IsNullOrEmpty(commandToExecute.command))
                         {
-                            commandsToExecute.Add(commandToExecute);
+                            await Interaction.InvokeWin32Component(commandToExecute.command, commandToExecute.arguments);
                         }
-                    }
-                    if(commandsToExecute.Count > 0)
-                    {
-                        await Interaction.InvokeWin32Components(commandsToExecute);
+
                     }
                 }
                 else if (selectedFileSystemItems.Count == 1)
                 {
                     var selectedDataItem = selectedFileSystemItems[0] as ListedItem;
 
-                    var commandToExecute = command?.Replace("%1", selectedDataItem.ItemPath);
-                    if (!string.IsNullOrEmpty(commandToExecute))
+                    var commandToExecute = await new ShellCommandParser().ParseShellCommand(command, selectedDataItem.ItemPath);
+                    if (!string.IsNullOrEmpty(commandToExecute.command))
                     {
-                        await Interaction.InvokeWin32Component(commandToExecute);
+                        await Interaction.InvokeWin32Component(commandToExecute.command, commandToExecute.arguments);
                     }
                 }
             }

Files/Files.csproj

@@ -166,6 +166,7 @@
     <Compile Include="Helpers\NativeFindStorageItemHelper.cs" />
     <Compile Include="Helpers\NaturalStringComparer.cs" />
     <Compile Include="Helpers\PackageHelper.cs" />
+    <Compile Include="Helpers\ShellCommandParser.cs" />
     <Compile Include="Helpers\StringExtensions.cs" />
     <Compile Include="Helpers\ThemeHelper.cs" />
     <Compile Include="Program.cs" />

Files/Helpers/RegistryReader.cs

@@ -1,11 +1,16 @@
 using Microsoft.Win32;
 using System;
 using System.Collections.Generic;
+using System.IO;
 using System.Linq;
+using System.Runtime.InteropServices.WindowsRuntime;
 using System.Security.Principal;
 using System.Text;
 using System.Threading.Tasks;
 using Windows.Foundation.Collections;
+using Windows.Graphics.Imaging;
+using Windows.UI.Xaml.Controls;
+using Windows.UI.Xaml.Media.Imaging;
 
 namespace Files.Helpers
 {
@@ -18,45 +23,56 @@ private async Task ParseRegistryAndAddToList(List<(string commandKey, string com
             {
                 foreach (var keyname in shellKey.GetSubKeyNames())
                 {
-                    var commandNameKey = shellKey.OpenSubKey(keyname);
-                    var commandName = commandNameKey.GetValue(String.Empty)?.ToString() ?? "";
-                    //@ is a special command under the registry. We need to search for MUIVerb:
-                    if (string.IsNullOrEmpty(commandName) || commandName.StartsWith("@"))
+                    try
                     {
-
-                        var muiVerb = commandNameKey.GetValue("MUIVerb")?.ToString() ?? "";
-                        if (!string.IsNullOrEmpty(muiVerb) && App.Connection != null)
+                        var commandNameKey = shellKey.OpenSubKey(keyname);
+                        var commandName = commandNameKey.GetValue(String.Empty)?.ToString() ?? "";
+                        //@ is a special command under the registry. We need to search for MUIVerb:
+                        if (string.IsNullOrEmpty(commandName) || commandName.StartsWith("@"))
                         {
-                            var value = new ValueSet();
-                            value.Add("Arguments", "LoadMUIVerb");
-                            value.Add("MUIVerbLocation", muiVerb?.Split(',')[0]?.TrimStart('@'));
-                            value.Add("MUIVerbLine", Convert.ToInt32(muiVerb?.Split(',')[1]?.TrimStart('-')));
-                            var response = await App.Connection.SendMessageAsync(value);
-                            if (response.Status == Windows.ApplicationModel.AppService.AppServiceResponseStatus.Success
-                                && response.Message.ContainsKey("MUIVerbString"))
+
+                            var muiVerb = commandNameKey.GetValue("MUIVerb")?.ToString() ?? "";
+                            if (!string.IsNullOrEmpty(muiVerb) && App.Connection != null)
+                            {
+                                var muiVerbRequest = new ValueSet
                             {
-                                commandName = (string)response.Message["MUIVerbString"];
-                                if (string.IsNullOrEmpty(commandName))
+                                { "Arguments", "LoadMUIVerb" },
+                                { "MUIVerbLocation", muiVerb?.Split(',')[0]?.TrimStart('@') },
+                                { "MUIVerbLine", Convert.ToInt32(muiVerb?.Split(',')[1]?.TrimStart('-')) }
+                            };
+                                var responseMUIVerb = await App.Connection.SendMessageAsync(muiVerbRequest);
+                                if (responseMUIVerb.Status == Windows.ApplicationModel.AppService.AppServiceResponseStatus.Success
+                                    && responseMUIVerb.Message.ContainsKey("MUIVerbString"))
                                 {
-                                    continue;
+                                    commandName = (string)responseMUIVerb.Message["MUIVerbString"];
+                                    if (string.IsNullOrEmpty(commandName))
+                                    {
+                                        continue;
+                                    }
                                 }
                             }
+                            else
+                            {
+                                continue;
+                            }
                         }
-                        else
+                        var commandNameString = commandName.Replace("&", "");
+                        var commandIconString = commandNameKey.GetValue("Icon")?.ToString();
+
+
+                        var commandNameKeyNames = commandNameKey.GetSubKeyNames();
+                        if (commandNameKeyNames.Contains("command") && !shellList.Any(c => c.commandKey == keyname))
                         {
-                            continue;
+                            var command = commandNameKey.OpenSubKey("command");
+                            shellList.Add((commandKey: keyname, commandNameString, commandIconString, command: command.GetValue(string.Empty).ToString()));
+
                         }
                     }
-                    var commandNameString = commandName.Replace("&", "");
-                    var commandIcon = commandNameKey.GetValue("Icon")?.ToString();
-
-                    var commandNameKeyNames = commandNameKey.GetSubKeyNames();
-                    if (commandNameKeyNames.Contains("command") && !shellList.Any(c => c.commandKey == keyname))
+                    catch
                     {
-                        var command = commandNameKey.OpenSubKey("command");
-                        shellList.Add((commandKey: keyname, commandNameString, commandIcon, command: command.GetValue(string.Empty).ToString()));
-
+                        continue;
                     }
+                   
                 }
             }
         }
@@ -91,7 +107,7 @@ private async Task ParseRegistryAndAddToList(List<(string commandKey, string com
 
                 return shellList;
             }
-            catch(Exception ex)
+            catch
             {
                 return shellList;
             }

Files/Helpers/ShellCommandParser.cs

@@ -0,0 +1,75 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Text.RegularExpressions;
+using System.Threading.Tasks;
+using Windows.Foundation.Collections;
+
+namespace Files.Helpers
+{
+    class ShellCommandParser
+    {
+        /*
+
+        %0 or %1 – The first file parameter. For example "C:\Users\Eric\Desktop\New Text Document.txt". Generally this should be in quotes and the applications command line parsing should accept quotes to disambiguate files with spaces in the name and different command line parameters (this is a security best practice and I believe mentioned in MSDN).
+
+        %<n> (where <n> is 2-9) – Replace with the nth parameter.
+
+        %s – Show command.
+
+        %h – Hotkey value.
+
+        %i – IDList stored in a shared memory handle is passed here.
+
+        %l – Long file name form of the first parameter. Note that Win32/64 applications will be passed the long file name, whereas Win16 applications get the short file name. Specifying %l is preferred as it avoids the need to probe for the application type.
+
+        %d – Desktop absolute parsing name of the first parameter (for items that don't have file system paths).
+
+        %v – For verbs that are none implies all. If there is no parameter passed this is the working directory.
+
+        %w – The working directory.
+         */
+        public async Task<(string command, string arguments)> ParseShellCommand(string command, string itemPath)
+        {
+            if(string.IsNullOrEmpty(command) || string.IsNullOrEmpty(itemPath))
+            {
+                return (null, null);
+            }    
+
+            var value = new ValueSet
+                            {
+                                { "Arguments", "ParseAguments" },
+                                { "Command", command}
+                            };
+            var response = await App.Connection.SendMessageAsync(value);
+            if (response.Status == Windows.ApplicationModel.AppService.AppServiceResponseStatus.Success
+                && response.Message.ContainsKey("ParsedArguments"))
+            {
+
+                var commandToExecute = Newtonsoft.Json.JsonConvert.DeserializeObject<string[]>((string)response.Message["ParsedArguments"]);
+
+                var resultCommand = string.Join(" ", commandToExecute.Skip(1));
+                var shellFileNameRegex = new Regex("(%[0-9]|%D|%L|%U|%V)", RegexOptions.IgnoreCase);
+                resultCommand = shellFileNameRegex.Replace(resultCommand, $"\"{itemPath}\"");
+
+                var shellParentFolderRegex = new Regex("%W", RegexOptions.IgnoreCase);
+                var fileInfo = new FileInfo(itemPath);
+                resultCommand = shellParentFolderRegex.Replace(resultCommand, $"\"{fileInfo.Directory.FullName}\"");
+
+                var shellHotKeyValueRegex = new Regex("%H", RegexOptions.IgnoreCase);
+                resultCommand = shellHotKeyValueRegex.Replace(resultCommand, "0");
+
+                var shelShowCommandRegex = new Regex("%S", RegexOptions.IgnoreCase);
+                resultCommand = shelShowCommandRegex.Replace(resultCommand, "1");
+                return (commandToExecute[0], resultCommand);
+            }
+            else
+            {
+                return (null, null);
+            }
+
+        }
+    }
+}

Files/UserControls/LayoutModes/GenericFileBrowser.xaml.cs

@@ -321,6 +321,7 @@ private async void AllView_SelectionChanged(object sender, SelectionChangedEvent
         {
             AllView.CommitEdit();
             SelectedItems = AllView.SelectedItems.Cast<ListedItem>().ToList();
+
             await SetShellContextmenu();
         }