Rebuild and merge context menu code

Files/Files.csproj

@@ -211,7 +211,10 @@
     <Compile Include="Dialogs\ConfirmDeleteDialog.xaml.cs">
       <DependentUpon>ConfirmDeleteDialog.xaml</DependentUpon>
     </Compile>
+    <Compile Include="Helpers\ContextFlyoutItemHelper.cs" />
+    <Compile Include="Helpers\ItemModelListToContextFlyoutHelper.cs" />
     <Compile Include="Helpers\FilePropertiesHelpers.cs" />
+    <Compile Include="Helpers\ShellContextMenuHelper.cs" />
     <Compile Include="Helpers\UIFilesystemHelpers.cs" />
     <Compile Include="Helpers\NavigationHelpers.cs" />
     <Compile Include="Helpers\UIHelpers.cs" />
@@ -293,6 +296,7 @@
     <Compile Include="ViewModels\Dialogs\DynamicDialogViewModel.cs" />
     <Compile Include="ViewModels\FolderSettingsViewModel.cs" />
     <Compile Include="ViewModels\MainPageViewModel.cs" />
+    <Compile Include="ViewModels\ContextMenuFlyoutItemViewModel.cs" />
     <Compile Include="ViewModels\PreviewPaneViewModel.cs" />
     <Compile Include="ViewModels\Previews\BasePreviewModel.cs" />
     <Compile Include="ViewModels\Previews\BasicPreviewViewModel.cs" />

Files/Helpers/ItemModelListToContextFlyoutHelper.cs

@@ -0,0 +1,125 @@
+using Files.UserControls;
+using Files.ViewModels;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Windows.UI.Xaml.Controls;
+using Windows.UI.Xaml.Input;
+using Windows.UI.Xaml.Media;
+
+namespace Files.Helpers.ContextFlyouts
+{
+    public static class ItemModelListToContextFlyoutHelper
+    {
+        public static List<MenuFlyoutItemBase> GetMenuFlyoutItemsFromModel(List<ContextMenuFlyoutItemViewModel> items)
+        {
+            var flyout = new List<MenuFlyoutItemBase>();
+            items.ForEach(i =>
+            {
+                flyout.Add(GetMenuItem(i));
+            });
+            return flyout;
+        }
+
+        private static MenuFlyoutItemBase GetMenuItem(ContextMenuFlyoutItemViewModel item)
+        {
+            switch (item.ItemType)
+            {
+                case ItemType.Separator:
+                    return new MenuFlyoutSeparator();
+
+                default:
+                    return GetMenuFlyoutItem(item);
+            }
+        }
+
+        private static MenuFlyoutItemBase GetMenuFlyoutItem(ContextMenuFlyoutItemViewModel item, bool isToggle = false)
+        {
+            if(item.Items?.Count > 0)
+            {
+                var flyoutSubItem = new MenuFlyoutSubItem()
+                {
+                    Text = item.Text,
+                    Tag = item.Tag,
+                };
+                item.Items.ForEach(i =>
+                {
+                    flyoutSubItem.Items.Add(GetMenuItem(i));
+                });
+                return flyoutSubItem;
+            } else 
+            {
+                return GetItem(item);
+            }
+        }
+
+        private static MenuFlyoutItemBase GetItem(ContextMenuFlyoutItemViewModel i)
+        {
+
+            if (i.BitmapIcon != null)
+            {
+                var item = new MenuFlyoutItemWithImage()
+                {
+                    Text = i.Text,
+                    Tag = i.Tag,
+                    Command = i.Command,
+                    CommandParameter = i.CommandParameter,
+                };
+                try
+                {
+                    item.BitmapIcon = i.BitmapIcon;
+                }
+                catch (Exception e)
+                {
+                    Debug.WriteLine(e);
+                }
+                return item;
+            }
+            MenuFlyoutItemBase flyoutItem;
+
+            if(i.ItemType == ItemType.Toggle)
+            {
+                flyoutItem = new ToggleMenuFlyoutItem()
+                {
+                    Text = i.Text,
+                    Tag = i.Tag,
+                    Command = i.Command,
+                    CommandParameter = i.CommandParameter,
+                    IsChecked = i.IsChecked,
+                };
+            } else
+            {
+                var icon = new FontIcon
+                {
+                    Glyph = !string.IsNullOrEmpty(i.Glyph) ? i.Glyph : "",
+                };
+
+                if(!string.IsNullOrEmpty(i.GlyphFontFamilyName))
+                {
+                    var fontFamily = App.Current.Resources[i.GlyphFontFamilyName] as FontFamily;
+                    icon.FontFamily = fontFamily;
+                }
+
+                flyoutItem = new MenuFlyoutItem()
+                {
+                    Text = i.Text,
+                    Tag = i.Tag,
+                    Command = i.Command,
+                    CommandParameter = i.CommandParameter,
+                    Icon = icon,
+                };
+            }
+
+            if(i.KeyboardAccelerator != null)
+            {
+                flyoutItem.KeyboardAccelerators.Add(i.KeyboardAccelerator);
+            }
+            flyoutItem.IsEnabled = i.IsEnabled;
+
+            return flyoutItem;
+        }
+    }
+}

Files/Helpers/ShellContextMenuHelper.cs

@@ -0,0 +1,172 @@
+using Files.Common;
+using Files.Filesystem;
+using Files.ViewModels;
+using Microsoft.Toolkit.Mvvm.Input;
+using Microsoft.Toolkit.Uwp;
+using Newtonsoft.Json;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+using Windows.ApplicationModel.AppService;
+using Windows.Foundation.Collections;
+using Windows.UI.Xaml.Media.Imaging;
+
+namespace Files.Helpers {
+    public static class ShellContextmenuHelper {
+        public static List<ContextMenuFlyoutItemViewModel> SetShellContextmenu(List<ContextMenuFlyoutItemViewModel> baseItems, bool shiftPressed, bool showOpenMenu, NamedPipeAsAppServiceConnection connection, string workingDirectory, List<ListedItem> selectedItems)
+        {
+            bool IsItemSelected = selectedItems?.Count > 0;
+
+            var menuItemsList = new List<ContextMenuFlyoutItemViewModel>(baseItems);
+
+            var currentBaseLayoutItemCount = baseItems.Count;
+            var maxItems = !App.AppSettings.MoveOverflowMenuItemsToSubMenu ? int.MaxValue : shiftPressed ? 6 : 4;
+
+            if (connection != null)
+            {
+                var (status, response) = Task.Run(() => connection.SendMessageForResponseAsync(new ValueSet()
+                {
+                    { "Arguments", "LoadContextMenu" },
+                    { "FilePath", IsItemSelected ?
+                        string.Join('|', selectedItems.Select(x => x.ItemPath)) :
+                        workingDirectory},
+                    { "ExtendedMenu", shiftPressed },
+                    { "ShowOpenMenu", showOpenMenu }
+                })).Result;
+                if (status == AppServiceResponseStatus.Success
+                    && response.ContainsKey("Handle"))
+                {
+                    var contextMenu = JsonConvert.DeserializeObject<Win32ContextMenu>((string)response["ContextMenu"]);
+                    if (contextMenu != null)
+                    {
+                        LoadMenuFlyoutItem(menuItemsList, contextMenu.Items, (string)response["Handle"], true, maxItems);
+                    }
+                }
+            }
+            var totalFlyoutItems = baseItems.Count - currentBaseLayoutItemCount;
+            if (totalFlyoutItems > 0 && !(baseItems[totalFlyoutItems].ItemType == ItemType.Separator))
+            {
+                menuItemsList.Insert(totalFlyoutItems, new ContextMenuFlyoutItemViewModel() { ItemType = ItemType.Separator });
+            }
+
+            return menuItemsList;
+        }
+
+        public static void LoadMenuFlyoutItem(IList<ContextMenuFlyoutItemViewModel> menuItemsListLocal,
+                                IEnumerable<Win32ContextMenuItem> menuFlyoutItems,
+                                string menuHandle,
+                                bool showIcons = true,
+                                int itemsBeforeOverflow = int.MaxValue)
+        {
+            var itemsCount = 0; // Separators do not count for reaching the overflow threshold
+            var menuItems = menuFlyoutItems.TakeWhile(x => x.Type == MenuItemType.MFT_SEPARATOR || ++itemsCount <= itemsBeforeOverflow).ToList();
+            var overflowItems = menuFlyoutItems.Except(menuItems).ToList();
+
+            if (overflowItems.Where(x => x.Type != MenuItemType.MFT_SEPARATOR).Any())
+            {
+                var moreItem = menuItemsListLocal.Where(x => x.ID == "ItemOverflow").FirstOrDefault();
+                if (moreItem == null)
+                {
+                    var menuLayoutSubItem = new ContextMenuFlyoutItemViewModel()
+                    {
+                        Text = "ContextMenuMoreItemsLabel".GetLocalized(),
+                        Tag = ((Win32ContextMenuItem)null, menuHandle),
+                        Glyph = "\xE712",
+                    };
+                    LoadMenuFlyoutItem(menuLayoutSubItem.Items, overflowItems, menuHandle, false);
+                    menuItemsListLocal.Insert(0, menuLayoutSubItem);
+                } else
+                {
+                    LoadMenuFlyoutItem(moreItem.Items, overflowItems, menuHandle, false);
+                }
+            }
+            foreach (var menuFlyoutItem in menuItems
+                .SkipWhile(x => x.Type == MenuItemType.MFT_SEPARATOR) // Remove leading separators
+                .Reverse()
+                .SkipWhile(x => x.Type == MenuItemType.MFT_SEPARATOR)) // Remove trailing separators
+            {
+                if ((menuFlyoutItem.Type == MenuItemType.MFT_SEPARATOR) && (menuItemsListLocal.FirstOrDefault().ItemType == ItemType.Separator))
+                {
+                    // Avoid duplicate separators
+                    continue;
+                }
+
+                BitmapImage image = null;
+                if (showIcons)
+                {
+                    image = new BitmapImage();
+                    if (!string.IsNullOrEmpty(menuFlyoutItem.IconBase64))
+                    {
+                        byte[] bitmapData = Convert.FromBase64String(menuFlyoutItem.IconBase64);
+                        using var ms = new MemoryStream(bitmapData);
+                        image.SetSourceAsync(ms.AsRandomAccessStream()).AsTask().Wait(10);
+                    }
+                }
+
+                if (menuFlyoutItem.Type == MenuItemType.MFT_SEPARATOR)
+                {
+                    var menuLayoutItem = new ContextMenuFlyoutItemViewModel()
+                    {
+                        ItemType = ItemType.Separator,
+                        Tag = (menuFlyoutItem, menuHandle)
+                    };
+                    menuItemsListLocal.Insert(0, menuLayoutItem);
+                }
+                else if (menuFlyoutItem.SubItems.Where(x => x.Type != MenuItemType.MFT_SEPARATOR).Any()
+                    && !string.IsNullOrEmpty(menuFlyoutItem.Label))
+                {
+                    var menuLayoutSubItem = new ContextMenuFlyoutItemViewModel()
+                    {
+                        Text = menuFlyoutItem.Label.Replace("&", ""),
+                        Tag = (menuFlyoutItem, menuHandle),
+                    };
+                    LoadMenuFlyoutItem(menuLayoutSubItem.Items, menuFlyoutItem.SubItems, menuHandle, false);
+                    menuItemsListLocal.Insert(0, menuLayoutSubItem);
+                }
+                else if (!string.IsNullOrEmpty(menuFlyoutItem.Label))
+                {
+                    var menuLayoutItem = new ContextMenuFlyoutItemViewModel()
+                    {
+                        Text = menuFlyoutItem.Label.Replace("&", ""),
+                        Tag = (menuFlyoutItem, menuHandle),
+                        BitmapIcon = image
+                    };
+                    menuLayoutItem.Command = new RelayCommand<object>(x => InvokeShellMenuItem(x));
+                    menuLayoutItem.CommandParameter = (menuFlyoutItem, menuHandle);
+                    menuItemsListLocal.Insert(0, menuLayoutItem);
+                }
+            }
+
+            static async void InvokeShellMenuItem(object tag)
+            {
+                var connection = await AppServiceConnectionHelper.Instance;
+                var (menuItem, menuHandle) = ParseContextMenuTag(tag);
+                if (connection != null)
+                {
+                    await connection.SendMessageAsync(new ValueSet()
+                {
+                    { "Arguments", "ExecAndCloseContextMenu" },
+                    { "Handle", menuHandle },
+                    { "ItemID", menuItem.ID },
+                    { "CommandString", menuItem.CommandString }
+                });
+                }
+            }
+
+            static (Win32ContextMenuItem menuItem, string menuHandle) ParseContextMenuTag(object tag)
+            {
+                if (tag is ValueTuple<Win32ContextMenuItem, string> tuple)
+                {
+                    (Win32ContextMenuItem menuItem, string menuHandle) = tuple;
+                    return (menuItem, menuHandle);
+                }
+
+                return (null, null);
+            }
+        }
+
+
+    }
+}

Files/IBaseLayout.cs

@@ -37,5 +37,6 @@ public interface IBaseLayout : IDisposable
         void FocusSelectedItems();
 
         void StartRenameItem();
+        void RefreshItems();
     }
 }

Files/Interacts/BaseLayoutCommandImplementationModel.cs

@@ -18,6 +18,7 @@
 using Windows.Foundation;
 using Windows.UI.Xaml.Input;
 using Files.ViewModels;
+using Files.DataModels;
 
 namespace Files.Interacts
 {
@@ -278,9 +279,9 @@ public virtual void CreateNewFolder(RoutedEventArgs e)
             UIFilesystemHelpers.CreateFileFromDialogResultType(AddItemType.Folder, null, associatedInstance);
         }
 
-        public virtual void CreateNewFile(RoutedEventArgs e)
+        public virtual void CreateNewFile(ShellNewEntry f)
         {
-            UIFilesystemHelpers.CreateFileFromDialogResultType(AddItemType.File, null, associatedInstance);
+            UIFilesystemHelpers.CreateFileFromDialogResultType(AddItemType.File, f, associatedInstance);
         }
 
         public virtual async void PasteItemsFromClipboard(RoutedEventArgs e)
@@ -403,6 +404,11 @@ public virtual void ItemPointerPressed(PointerRoutedEventArgs e)
             }
         }
 
+        public virtual void RefreshItems(RoutedEventArgs e)
+        {
+            SlimContentPage.RefreshItems();
+        }
+
         #endregion Command Implementation
     }
 }

Files/Interacts/BaseLayoutCommandsViewModel.cs

@@ -1,4 +1,5 @@
-using Microsoft.Toolkit.Mvvm.Input;
+using Files.DataModels;
+using Microsoft.Toolkit.Mvvm.Input;
 using System;
 using System.Windows.Input;
 using Windows.UI.Xaml;
@@ -53,13 +54,14 @@ private void InitializeCommands()
             OpenDirectoryInNewPaneCommand = new RelayCommand<RoutedEventArgs>(commandsModel.OpenDirectoryInNewPane);
             OpenInNewWindowItemCommand = new RelayCommand<RoutedEventArgs>(commandsModel.OpenInNewWindowItem);
             CreateNewFolderCommand = new RelayCommand<RoutedEventArgs>(commandsModel.CreateNewFolder);
-            CreateNewFileCommand = new RelayCommand<RoutedEventArgs>(commandsModel.CreateNewFile);
+            CreateNewFileCommand = new RelayCommand<ShellNewEntry>(commandsModel.CreateNewFile);
             PasteItemsFromClipboardCommand = new RelayCommand<RoutedEventArgs>(commandsModel.PasteItemsFromClipboard);
             CopyPathOfSelectedItemCommand = new RelayCommand<RoutedEventArgs>(commandsModel.CopyPathOfSelectedItem);
             OpenDirectoryInDefaultTerminalCommand = new RelayCommand<RoutedEventArgs>(commandsModel.OpenDirectoryInDefaultTerminal);
             ShareItemCommand = new RelayCommand<RoutedEventArgs>(commandsModel.ShareItem);
             PinDirectoryToSidebarCommand = new RelayCommand<RoutedEventArgs>(commandsModel.PinDirectoryToSidebar);
             ItemPointerPressedCommand = new RelayCommand<PointerRoutedEventArgs>(commandsModel.ItemPointerPressed);
+            RefreshCommand = new RelayCommand<RoutedEventArgs>(commandsModel.RefreshItems);
         }
 
         #endregion Command Initialization
@@ -127,6 +129,7 @@ private void InitializeCommands()
         public ICommand PinDirectoryToSidebarCommand { get; private set; }
 
         public ICommand ItemPointerPressedCommand { get; private set; }
+        public ICommand RefreshCommand { get; private set; }
 
         #endregion Commands