Restore menu keyboard navigation

MainWindow.xaml

@@ -60,11 +60,15 @@
                         Margin="0,0,8,0">
                     <Button.ContextMenu>
                         <ContextMenu>
+                            <MenuItem Header="Validate Targets" Click="ValidateTargets_Click"/>
+                            <Separator/>
                             <MenuItem Header="Backup Config" Click="BackupConfig_Click"/>
                             <MenuItem Header="Restore from Backup" Click="RestoreConfig_Click"/>
                             <Separator/>
                             <MenuItem Header="Export Config" Click="ExportConfig_Click"/>
                             <MenuItem Header="Import Config" Click="ImportConfig_Click"/>
+                            <MenuItem Header="Export Selected Item" Click="ExportSelectedItem_Click"/>
+                            <MenuItem Header="Import Item" Click="ImportItem_Click"/>
                             <Separator/>
                             <MenuItem Header="Reset to Defaults" Click="ResetConfig_Click"/>
                             <MenuItem Header="Reload Config" Click="ReloadConfig_Click"/>

MainWindow.xaml.cs

@@ -3,6 +3,7 @@ using System.Windows.Controls;
 using System.Windows.Forms;
 using System.Windows.Media;
 using System.IO;
+using System.Text;
 using System.Windows.Input;
 using TaskbarLauncher.Models;
 using TaskbarLauncher.Services;
@@ -21,6 +22,7 @@ public partial class MainWindow : Window
     private List<int>? selectedPath;
     private string? loadedAutoIconPath;
     private System.Windows.Point dragStartPoint;
+    private sealed record TargetValidationIssue(string ItemPath, string Problem);
 
     public MainWindow()
     {
@@ -39,6 +41,18 @@ public partial class MainWindow : Window
         RefreshView();
     }
 
+    public void SelectItemForEdit(LauncherItem item)
+    {
+        if (controller is null)
+        {
+            return;
+        }
+
+        RefreshView(item);
+        Show();
+        Activate();
+    }
+
     private void RefreshView(LauncherItem? itemToSelect = null)
     {
         if (controller is null)
@@ -69,9 +83,53 @@ public partial class MainWindow : Window
         }
     }
 
-    private static TreeViewItem CreateTreeItem(LauncherItem item)
+    private TreeViewItem CreateTreeItem(LauncherItem item)
     {
-        var treeItem = new TreeViewItem { Header = $"{item.Title} ({item.Type})", Tag = item };
+        var pinMenuItem = new System.Windows.Controls.MenuItem
+        {
+            Header = item.IsFavorite ? "Unpin from Top" : "Pin to Top"
+        };
+        pinMenuItem.Click += ToggleFavorite_Click;
+
+        var disableMenuItem = new System.Windows.Controls.MenuItem
+        {
+            Header = item.IsDisabled ? "Enable Item" : "Disable Item"
+        };
+        disableMenuItem.Click += ToggleDisabled_Click;
+
+        var openContainingFolderMenuItem = new System.Windows.Controls.MenuItem
+        {
+            Header = "Open Containing Folder",
+            IsEnabled = CanOpenContainingFolder(item)
+        };
+        openContainingFolderMenuItem.Click += OpenContainingFolder_Click;
+
+        var duplicateMenuItem = new System.Windows.Controls.MenuItem { Header = "Duplicate Item" };
+        duplicateMenuItem.Click += DuplicateItem_Click;
+
+        var sortMenuItem = new System.Windows.Controls.MenuItem
+        {
+            Header = item.Type == LauncherItemType.Menu ? "Sort This Menu" : "Sort This Level"
+        };
+        sortMenuItem.Click += SortSelected_Click;
+
+        var treeItem = new TreeViewItem
+        {
+            Header = $"{GetTreeStatusPrefix(item)}{item.Title} ({item.Type})",
+            Tag = item,
+            ContextMenu = new System.Windows.Controls.ContextMenu()
+        };
+        treeItem.ContextMenu.Items.Add(pinMenuItem);
+        treeItem.ContextMenu.Items.Add(disableMenuItem);
+        treeItem.ContextMenu.Items.Add(openContainingFolderMenuItem);
+        treeItem.ContextMenu.Items.Add(duplicateMenuItem);
+        treeItem.ContextMenu.Items.Add(sortMenuItem);
+        treeItem.PreviewMouseRightButtonDown += (_, e) =>
+        {
+            treeItem.IsSelected = true;
+            e.Handled = false;
+        };
+
         foreach (LauncherItem child in item.Children)
         {
             treeItem.Items.Add(CreateTreeItem(child));
@@ -80,6 +138,22 @@ public partial class MainWindow : Window
         return treeItem;
     }
 
+    private static string GetTreeStatusPrefix(LauncherItem item)
+    {
+        List<string> parts = [];
+        if (item.IsFavorite)
+        {
+            parts.Add("Pinned");
+        }
+
+        if (item.IsDisabled)
+        {
+            parts.Add("Disabled");
+        }
+
+        return parts.Count == 0 ? "" : $"[{string.Join(", ", parts)}] ";
+    }
+
     private bool SelectTreeItem(LauncherItem item)
     {
         foreach (object root in ItemsTree.Items)
@@ -156,15 +230,42 @@ public partial class MainWindow : Window
 
     private void ItemsTree_DragOver(object sender, System.Windows.DragEventArgs e)
     {
-        e.Effects = CanDrop(e) ? System.Windows.DragDropEffects.Move : System.Windows.DragDropEffects.None;
+        if (CanMoveDroppedItem(e))
+        {
+            e.Effects = System.Windows.DragDropEffects.Move;
+        }
+        else if (CanAddExternalDroppedItems(e.Data))
+        {
+            e.Effects = System.Windows.DragDropEffects.Copy;
+        }
+        else
+        {
+            e.Effects = System.Windows.DragDropEffects.None;
+        }
+
         e.Handled = true;
     }
 
     private void ItemsTree_Drop(object sender, System.Windows.DragEventArgs e)
     {
-        if (controller is null ||
-            !e.Data.GetDataPresent(typeof(LauncherItem)) ||
-            e.Data.GetData(typeof(LauncherItem)) is not LauncherItem draggedItem)
+        if (controller is null)
+        {
+            return;
+        }
+
+        if (e.Data.GetDataPresent(typeof(LauncherItem)) &&
+            e.Data.GetData(typeof(LauncherItem)) is LauncherItem draggedItem)
+        {
+            MoveDroppedItem(e, draggedItem);
+            return;
+        }
+
+        AddExternalDroppedItems(e);
+    }
+
+    private void MoveDroppedItem(System.Windows.DragEventArgs e, LauncherItem draggedItem)
+    {
+        if (controller is null)
         {
             return;
         }
@@ -213,7 +314,59 @@ public partial class MainWindow : Window
         e.Handled = true;
     }
 
-    private bool CanDrop(System.Windows.DragEventArgs e)
+    private void AddExternalDroppedItems(System.Windows.DragEventArgs e)
+    {
+        if (controller is null)
+        {
+            return;
+        }
+
+        List<LauncherItem> droppedItems = CreateItemsFromDropData(e.Data, controller.Config.DisplayMode);
+        if (droppedItems.Count == 0)
+        {
+            return;
+        }
+
+        ApplyCurrentItem();
+
+        TreeViewItem? targetTreeItem = FindAncestor<TreeViewItem>(e.OriginalSource as DependencyObject);
+        LauncherItem? targetItem = targetTreeItem?.Tag as LauncherItem;
+        if (targetItem is null)
+        {
+            controller.Config.Items.AddRange(droppedItems);
+        }
+        else if (targetItem.Type == LauncherItemType.Menu)
+        {
+            targetItem.Children.AddRange(droppedItems);
+            if (targetTreeItem is not null)
+            {
+                targetTreeItem.IsExpanded = true;
+            }
+        }
+        else
+        {
+            List<LauncherItem>? targetSiblings = FindSiblings(controller.Config.Items, targetItem);
+            if (targetSiblings is null)
+            {
+                controller.Config.Items.AddRange(droppedItems);
+            }
+            else
+            {
+                int targetIndex = targetSiblings.IndexOf(targetItem);
+                targetSiblings.InsertRange(targetIndex + 1, droppedItems);
+            }
+        }
+
+        LauncherItem itemToSelect = droppedItems[0];
+        selectedPath = FindItemPath(itemToSelect);
+        RefreshView(itemToSelect);
+        StatusText.Text = droppedItems.Count == 1
+            ? $"Added {itemToSelect.Title}. Click Save to keep it."
+            : $"Added {droppedItems.Count} items. Click Save to keep them.";
+        e.Handled = true;
+    }
+
+    private bool CanMoveDroppedItem(System.Windows.DragEventArgs e)
     {
         if (!e.Data.GetDataPresent(typeof(LauncherItem)) ||
             e.Data.GetData(typeof(LauncherItem)) is not LauncherItem draggedItem)
@@ -226,6 +379,204 @@ public partial class MainWindow : Window
         return targetItem is null || (!ReferenceEquals(draggedItem, targetItem) && !ContainsItem(draggedItem, targetItem));
     }
 
+    private static bool CanAddExternalDroppedItems(System.Windows.IDataObject data)
+    {
+        return data.GetDataPresent(System.Windows.DataFormats.FileDrop) ||
+            data.GetDataPresent(System.Windows.DataFormats.UnicodeText) ||
+            data.GetDataPresent(System.Windows.DataFormats.Text) ||
+            data.GetDataPresent("UniformResourceLocatorW") ||
+            data.GetDataPresent("UniformResourceLocator");
+    }
+
+    private static List<LauncherItem> CreateItemsFromDropData(System.Windows.IDataObject data, LauncherDisplayMode displayMode)
+    {
+        List<LauncherItem> items = [];
+
+        if (data.GetDataPresent(System.Windows.DataFormats.FileDrop) &&
+            data.GetData(System.Windows.DataFormats.FileDrop) is string[] paths)
+        {
+            foreach (string path in paths)
+            {
+                LauncherItem? item = CreateItemFromPath(path, displayMode);
+                if (item is not null)
+                {
+                    items.Add(item);
+                }
+            }
+        }
+
+        if (items.Count > 0)
+        {
+            return items;
+        }
+
+        string? droppedText = GetDroppedText(data);
+        if (!string.IsNullOrWhiteSpace(droppedText))
+        {
+            foreach (string line in droppedText.Split(["\r\n", "\n"], StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries))
+            {
+                LauncherItem? item = CreateItemFromText(line, displayMode);
+                if (item is not null)
+                {
+                    items.Add(item);
+                }
+            }
+        }
+
+        return items;
+    }
+
+    private static string? GetDroppedText(System.Windows.IDataObject data)
+    {
+        if (data.GetDataPresent(System.Windows.DataFormats.UnicodeText))
+        {
+            return data.GetData(System.Windows.DataFormats.UnicodeText) as string;
+        }
+
+        if (data.GetDataPresent(System.Windows.DataFormats.Text))
+        {
+            return data.GetData(System.Windows.DataFormats.Text) as string;
+        }
+
+        return GetDroppedUrlFormatText(data, "UniformResourceLocatorW", Encoding.Unicode) ??
+            GetDroppedUrlFormatText(data, "UniformResourceLocator", Encoding.UTF8);
+    }
+
+    private static string? GetDroppedUrlFormatText(System.Windows.IDataObject data, string format, Encoding encoding)
+    {
+        if (!data.GetDataPresent(format))
+        {
+            return null;
+        }
+
+        object? rawData = data.GetData(format);
+        return rawData switch
+        {
+            string text => text,
+            byte[] bytes => DecodeDroppedUrlBytes(bytes, encoding),
+            MemoryStream stream => DecodeDroppedUrlBytes(stream.ToArray(), encoding),
+            _ => null
+        };
+    }
+
+    private static string DecodeDroppedUrlBytes(byte[] bytes, Encoding encoding)
+    {
+        return encoding.GetString(bytes).TrimEnd('\0', '\r', '\n', ' ');
+    }
+
+    private static LauncherItem? CreateItemFromText(string text, LauncherDisplayMode displayMode)
+    {
+        string target = text.Trim();
+        if (!Uri.TryCreate(target, UriKind.Absolute, out Uri? uri) ||
+            (uri.Scheme != Uri.UriSchemeHttp && uri.Scheme != Uri.UriSchemeHttps))
+        {
+            return null;
+        }
+
+        return new LauncherItem
+        {
+            Title = GetWebsiteTitle(uri),
+            Type = LauncherItemType.Website,
+            Target = uri.ToString(),
+            IconPath = uri.ToString(),
+            DisplayMode = displayMode
+        };
+    }
+
+    private static LauncherItem CreateWebsiteItem(Uri uri, string title, LauncherDisplayMode displayMode)
+    {
+        return new LauncherItem
+        {
+            Title = title,
+            Type = LauncherItemType.Website,
+            Target = uri.ToString(),
+            IconPath = uri.ToString(),
+            DisplayMode = displayMode
+        };
+    }
+
+    private static LauncherItem? CreateItemFromPath(string path, LauncherDisplayMode displayMode)
+    {
+        if (string.IsNullOrWhiteSpace(path))
+        {
+            return null;
+        }
+
+        string fullPath = path.Trim();
+        if (Directory.Exists(fullPath))
+        {
+            return new LauncherItem
+            {
+                Title = new DirectoryInfo(fullPath).Name,
+                Type = LauncherItemType.Folder,
+                Target = fullPath,
+                IconPath = fullPath,
+                DisplayMode = displayMode
+            };
+        }
+
+        if (!File.Exists(fullPath))
+        {
+            return null;
+        }
+
+        if (Path.GetExtension(fullPath).Equals(".url", StringComparison.OrdinalIgnoreCase))
+        {
+            return CreateItemFromInternetShortcut(fullPath, displayMode);
+        }
+
+        LauncherItemType type = IsApplicationPath(fullPath) ? LauncherItemType.App : LauncherItemType.File;
+        return new LauncherItem
+        {
+            Title = Path.GetFileNameWithoutExtension(fullPath),
+            Type = type,
+            Target = fullPath,
+            IconPath = fullPath,
+            DisplayMode = displayMode
+        };
+    }
+
+    private static LauncherItem? CreateItemFromInternetShortcut(string path, LauncherDisplayMode displayMode)
+    {
+        foreach (string line in File.ReadLines(path))
+        {
+            if (!line.StartsWith("URL=", StringComparison.OrdinalIgnoreCase))
+            {
+                continue;
+            }
+
+            string target = line["URL=".Length..].Trim();
+            if (Uri.TryCreate(target, UriKind.Absolute, out Uri? uri) &&
+                (uri.Scheme == Uri.UriSchemeHttp || uri.Scheme == Uri.UriSchemeHttps))
+            {
+                return CreateWebsiteItem(uri, Path.GetFileNameWithoutExtension(path), displayMode);
+            }
+        }
+
+        return null;
+    }
+
+    private static bool IsApplicationPath(string path)
+    {
+        string extension = Path.GetExtension(path);
+        return extension.Equals(".exe", StringComparison.OrdinalIgnoreCase) ||
+            extension.Equals(".lnk", StringComparison.OrdinalIgnoreCase) ||
+            extension.Equals(".bat", StringComparison.OrdinalIgnoreCase) ||
+            extension.Equals(".cmd", StringComparison.OrdinalIgnoreCase) ||
+            extension.Equals(".ps1", StringComparison.OrdinalIgnoreCase);
+    }
+
+    private static string GetWebsiteTitle(Uri uri)
+    {
+        string host = uri.Host;
+        if (host.StartsWith("www.", StringComparison.OrdinalIgnoreCase))
+        {
+            host = host[4..];
+        }
+
+        return string.IsNullOrWhiteSpace(host) ? uri.ToString() : host;
+    }
+
     private static bool ContainsItem(LauncherItem parent, LauncherItem possibleChild)
     {
         foreach (LauncherItem child in parent.Children)
@@ -498,6 +849,85 @@ public partial class MainWindow : Window
         StatusText.Text = "Added submenu. Rename it, then Save.";
     }
 
+    private void ToggleFavorite_Click(object sender, RoutedEventArgs e)
+    {
+        if (controller is null || selectedItem is null)
+        {
+            return;
+        }
+
+        ApplyCurrentItem();
+        selectedItem.IsFavorite = !selectedItem.IsFavorite;
+        LauncherItem itemToSelect = selectedItem;
+        selectedPath = FindItemPath(itemToSelect);
+        RefreshView(itemToSelect);
+        StatusText.Text = itemToSelect.IsFavorite
+            ? $"Pinned {itemToSelect.Title}. Click Save to keep it."
+            : $"Unpinned {itemToSelect.Title}. Click Save to keep it.";
+    }
+
+    private void ToggleDisabled_Click(object sender, RoutedEventArgs e)
+    {
+        if (controller is null || selectedItem is null)
+        {
+            return;
+        }
+
+        ApplyCurrentItem();
+        selectedItem.IsDisabled = !selectedItem.IsDisabled;
+        LauncherItem itemToSelect = selectedItem;
+        selectedPath = FindItemPath(itemToSelect);
+        RefreshView(itemToSelect);
+        StatusText.Text = itemToSelect.IsDisabled
+            ? $"Disabled {itemToSelect.Title}. Click Save to keep it."
+            : $"Enabled {itemToSelect.Title}. Click Save to keep it.";
+    }
+
+    private void OpenContainingFolder_Click(object sender, RoutedEventArgs e)
+    {
+        if (selectedItem is null)
+        {
+            return;
+        }
+
+        ApplyCurrentItem();
+        if (!LauncherController.OpenContainingFolder(selectedItem, out string? error) && !string.IsNullOrWhiteSpace(error))
+        {
+            MessageBox.Show(error, "Taskbar Launcher");
+        }
+    }
+
+    private static bool CanOpenContainingFolder(LauncherItem item)
+    {
+        return item.Type is LauncherItemType.App or LauncherItemType.File && !string.IsNullOrWhiteSpace(item.Target);
+    }
+
+    private void DuplicateItem_Click(object sender, RoutedEventArgs e)
+    {
+        if (controller is null || selectedItem is null)
+        {
+            return;
+        }
+
+        ApplyCurrentItem();
+        string originalTitle = selectedItem.Title;
+        LauncherItem duplicate = DuplicateItem(selectedItem);
+        List<LauncherItem>? siblings = FindSiblings(controller.Config.Items, selectedItem);
+        if (siblings is null)
+        {
+            controller.Config.Items.Add(duplicate);
+        }
+        else
+        {
+            int selectedIndex = siblings.IndexOf(selectedItem);
+            siblings.Insert(selectedIndex + 1, duplicate);
+        }
+
+        selectedPath = FindItemPath(duplicate);
+        RefreshView(duplicate);
+        StatusText.Text = $"Duplicated {originalTitle}. Click Save to keep it.";
+    }
+
     private static LauncherItem CreateNewItem(LauncherDisplayMode displayMode)
     {
         return new LauncherItem
@@ -520,6 +950,34 @@ public partial class MainWindow : Window
         };
     }
 
+    private static LauncherItem DuplicateItem(LauncherItem item)
+    {
+        return DuplicateItem(item, renameRoot: true);
+    }
+
+    private static LauncherItem DuplicateItem(LauncherItem item, bool renameRoot)
+    {
+        return new LauncherItem
+        {
+            Title = renameRoot ? GetDuplicateTitle(item.Title) : item.Title,
+            Type = item.Type,
+            Target = item.Target,
+            Arguments = item.Arguments,
+            IconPath = item.IconPath,
+            IsFavorite = item.IsFavorite,
+            IsDisabled = item.IsDisabled,
+            DisplayMode = item.DisplayMode,
+            Children = item.Children.Select(child => DuplicateItem(child, renameRoot: false)).ToList()
+        };
+    }
+
+    private static string GetDuplicateTitle(string title)
+    {
+        return string.IsNullOrWhiteSpace(title)
+            ? "Copy"
+            : $"{title} Copy";
+    }
+
     private void Delete_Click(object sender, RoutedEventArgs e)
     {
         if (controller is null || selectedItem is null)
@@ -595,6 +1053,46 @@ public partial class MainWindow : Window
         RefreshView(selectedItem);
     }
 
+    private void SortSelected_Click(object sender, RoutedEventArgs e)
+    {
+        if (controller is null || selectedItem is null)
+        {
+            return;
+        }
+
+        ApplyCurrentItem();
+        LauncherItem itemToSelect = selectedItem;
+        if (selectedItem.Type == LauncherItemType.Menu)
+        {
+            SortItems(selectedItem.Children);
+            RefreshView(itemToSelect);
+            StatusText.Text = $"Sorted {itemToSelect.Title}. Click Save to keep it.";
+            return;
+        }
+
+        List<LauncherItem>? siblings = FindSiblings(controller.Config.Items, selectedItem);
+        if (siblings is null)
+        {
+            return;
+        }
+
+        SortItems(siblings);
+        RefreshView(itemToSelect);
+        StatusText.Text = $"Sorted this level. Click Save to keep it.";
+    }
+
+    private static void SortItems(List<LauncherItem> items)
+    {
+        List<LauncherItem> sortedItems = items
+            .OrderByDescending(item => item.IsFavorite)
+            .ThenBy(item => item.Title, StringComparer.CurrentCultureIgnoreCase)
+            .ThenBy(item => item.Type)
+            .ToList();
+
+        items.Clear();
+        items.AddRange(sortedItems);
+    }
+
     private static bool RemoveItem(List<LauncherItem> items, LauncherItem item)
     {
         if (items.Remove(item))
@@ -809,6 +1307,114 @@ public partial class MainWindow : Window
         }
     }
 
+    private void ExportSelectedItem_Click(object sender, RoutedEventArgs e)
+    {
+        if (selectedItem is null)
+        {
+            MessageBox.Show("Select an item or menu to export first.", "Taskbar Launcher");
+            return;
+        }
+
+        ApplyCurrentItem();
+        string safeTitle = MakeSafeFileName(string.IsNullOrWhiteSpace(selectedItem.Title) ? "launcher-item" : selectedItem.Title);
+        using SaveFileDialog dialog = new()
+        {
+            Title = "Export selected launcher item",
+            Filter = "JSON item files|*.json|All files|*.*",
+            FileName = $"{safeTitle}-{DateTime.Now:yyyyMMdd-HHmmss}.json",
+            InitialDirectory = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments)
+        };
+
+        if (dialog.ShowDialog() != System.Windows.Forms.DialogResult.OK)
+        {
+            return;
+        }
+
+        try
+        {
+            string exportPath = ConfigService.ExportItemTo(dialog.FileName, selectedItem);
+            StatusText.Text = $"Exported {selectedItem.Title} to {exportPath}";
+        }
+        catch (Exception ex)
+        {
+            MessageBox.Show($"Could not export selected item.\n\n{ex.Message}", "Taskbar Launcher");
+        }
+    }
+
+    private void ImportItem_Click(object sender, RoutedEventArgs e)
+    {
+        if (controller is null)
+        {
+            return;
+        }
+
+        using OpenFileDialog dialog = new()
+        {
+            Title = "Import launcher item",
+            Filter = "JSON item files|*.json|All files|*.*",
+            InitialDirectory = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments)
+        };
+
+        if (dialog.ShowDialog() != System.Windows.Forms.DialogResult.OK)
+        {
+            return;
+        }
+
+        try
+        {
+            ApplyCurrentItem();
+            LauncherItem importedItem = ConfigService.ImportItemFrom(dialog.FileName);
+            AddImportedItem(importedItem);
+            selectedPath = FindItemPath(importedItem);
+            RefreshView(importedItem);
+            StatusText.Text = $"Imported {importedItem.Title}. Click Save to keep it.";
+        }
+        catch (Exception ex)
+        {
+            MessageBox.Show($"Could not import item.\n\n{ex.Message}", "Taskbar Launcher");
+        }
+    }
+
+    private void AddImportedItem(LauncherItem importedItem)
+    {
+        if (controller is null)
+        {
+            return;
+        }
+
+        if (selectedItem is null)
+        {
+            controller.Config.Items.Add(importedItem);
+            return;
+        }
+
+        if (selectedItem.Type == LauncherItemType.Menu)
+        {
+            selectedItem.Children.Add(importedItem);
+            return;
+        }
+
+        List<LauncherItem>? siblings = FindSiblings(controller.Config.Items, selectedItem);
+        if (siblings is null)
+        {
+            controller.Config.Items.Add(importedItem);
+            return;
+        }
+
+        int selectedIndex = siblings.IndexOf(selectedItem);
+        siblings.Insert(selectedIndex + 1, importedItem);
+    }
+
+    private static string MakeSafeFileName(string fileName)
+    {
+        foreach (char invalidChar in Path.GetInvalidFileNameChars())
+        {
+            fileName = fileName.Replace(invalidChar, '-');
+        }
+
+        return fileName.Trim();
+    }
+
     private void ResetConfig_Click(object sender, RoutedEventArgs e)
     {
         MessageBoxResult result = MessageBox.Show(
@@ -893,6 +1499,159 @@ public partial class MainWindow : Window
         ConfigService.OpenConfigFolder();
     }
 
+    private void ValidateTargets_Click(object sender, RoutedEventArgs e)
+    {
+        if (controller is null)
+        {
+            return;
+        }
+
+        ApplyConfigFields();
+        List<TargetValidationIssue> issues = [];
+        ValidateTargets(controller.Config.Items, [], issues);
+
+        if (issues.Count == 0)
+        {
+            StatusText.Text = "Validation complete. No broken targets found.";
+            MessageBox.Show("No broken targets found.", "Taskbar Launcher");
+            return;
+        }
+
+        string message = $"Found {issues.Count} possible broken target(s):\n\n" +
+            string.Join("\n", issues.Take(20).Select(issue => $"- {issue.ItemPath}: {issue.Problem}"));
+        if (issues.Count > 20)
+        {
+            message += $"\n\nShowing first 20 of {issues.Count}.";
+        }
+
+        StatusText.Text = $"Validation found {issues.Count} possible broken target(s).";
+        MessageBox.Show(message, "Taskbar Launcher");
+    }
+
+    private static void ValidateTargets(IEnumerable<LauncherItem> items, List<string> parentNames, List<TargetValidationIssue> issues)
+    {
+        foreach (LauncherItem item in items)
+        {
+            List<string> itemPath = [.. parentNames, string.IsNullOrWhiteSpace(item.Title) ? "Untitled" : item.Title];
+            if (!item.IsDisabled && TryGetTargetIssue(item, out string? problem) && problem is not null)
+            {
+                issues.Add(new TargetValidationIssue(string.Join(" > ", itemPath), problem));
+            }
+
+            if (item.Children.Count > 0)
+            {
+                ValidateTargets(item.Children, itemPath, issues);
+            }
+        }
+    }
+
+    private static bool TryGetTargetIssue(LauncherItem item, out string? problem)
+    {
+        problem = null;
+
+        if (item.Type == LauncherItemType.Menu || item.IsDisabled)
+        {
+            return false;
+        }
+
+        if (string.IsNullOrWhiteSpace(item.Target))
+        {
+            problem = "Target is blank.";
+            return true;
+        }
+
+        string target = Environment.ExpandEnvironmentVariables(item.Target.Trim());
+        switch (item.Type)
+        {
+            case LauncherItemType.Folder:
+                if (!Directory.Exists(target))
+                {
+                    problem = "Folder does not exist.";
+                    return true;
+                }
+
+                return false;
+
+            case LauncherItemType.Website:
+                if (!Uri.TryCreate(target, UriKind.Absolute, out Uri? uri) ||
+                    (uri.Scheme != Uri.UriSchemeHttp && uri.Scheme != Uri.UriSchemeHttps))
+                {
+                    problem = "Website target is not a valid http or https URL.";
+                    return true;
+                }
+
+                return false;
+
+            case LauncherItemType.App:
+                if (!File.Exists(target) && !CommandExistsOnPath(target))
+                {
+                    problem = "Application or shortcut was not found.";
+                    return true;
+                }
+
+                return false;
+
+            case LauncherItemType.File:
+                if (!File.Exists(target))
+                {
+                    problem = "File does not exist.";
+                    return true;
+                }
+
+                return false;
+
+            default:
+                problem = "Item type is not recognized.";
+                return true;
+        }
+    }
+
+    private static bool CommandExistsOnPath(string target)
+    {
+        if (target.IndexOfAny([Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar]) >= 0)
+        {
+            return false;
+        }
+
+        string? pathValue = Environment.GetEnvironmentVariable("PATH");
+        if (string.IsNullOrWhiteSpace(pathValue))
+        {
+            return false;
+        }
+
+        string extension = Path.GetExtension(target);
+        IEnumerable<string> candidateNames = string.IsNullOrWhiteSpace(extension)
+            ? GetExecutableCandidateNames(target)
+            : [target];
+
+        foreach (string directory in pathValue.Split(Path.PathSeparator, StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries))
+        {
+            foreach (string candidateName in candidateNames)
+            {
+                string candidatePath = Path.Combine(directory, candidateName);
+                if (File.Exists(candidatePath))
+                {
+                    return true;
+                }
+            }
+        }
+
+        return false;
+    }
+
+    private static IEnumerable<string> GetExecutableCandidateNames(string target)
+    {
+        string? pathExtValue = Environment.GetEnvironmentVariable("PATHEXT");
+        string[] extensions = string.IsNullOrWhiteSpace(pathExtValue)
+            ? [".EXE", ".CMD", ".BAT", ".COM"]
+            : pathExtValue.Split(Path.PathSeparator, StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
+
+        foreach (string extension in extensions)
+        {
+            yield return target + extension;
+        }
+    }
+
     private void About_Click(object sender, RoutedEventArgs e)
     {
         AboutWindow aboutWindow = new()
@@ -1099,6 +1858,8 @@ public partial class MainWindow : Window
             Target = TargetBox.Text.Trim(),
             Arguments = string.IsNullOrWhiteSpace(ArgumentsBox.Text) ? null : ArgumentsBox.Text.Trim(),
             IconPath = string.IsNullOrWhiteSpace(IconPathBox.Text) ? null : IconPathBox.Text.Trim(),
+            IsFavorite = selectedItem.IsFavorite,
+            IsDisabled = selectedItem.IsDisabled,
             DisplayMode = ItemDisplayModeBox.SelectedItem is LauncherDisplayMode mode
                 ? mode
                 : selectedItem.DisplayMode

Models/LauncherConfig.cs

@@ -8,6 +8,8 @@ public sealed class LauncherConfig
 
     public LauncherThemeScheme ThemeScheme { get; set; } = LauncherThemeScheme.MarkHaven;
 
+    public List<LauncherItem> RecentItems { get; set; } = [];
+
     public List<LauncherItem> Items { get; set; } = [];
 }
 
@@ -23,6 +25,10 @@ public sealed class LauncherItem
 
     public string? IconPath { get; set; }
 
+    public bool IsFavorite { get; set; }
+
+    public bool IsDisabled { get; set; }
+
     public LauncherDisplayMode DisplayMode { get; set; } = LauncherDisplayMode.CompactList;
 
     public List<LauncherItem> Children { get; set; } = [];

README.md

@@ -12,8 +12,19 @@ Download the compiled Windows release from:
 
 - System tray launcher
 - Global hotkey, default `Ctrl+Alt+Space`
-- Search/filter in the launcher popup
-- Nested menus and drag/drop ordering in Settings
+- Search/filter in the launcher popup with parent menu context
+- Keyboard navigation in the launcher popup
+- Recent items section for quickly relaunching entries
+- Nested menus, drag/drop ordering, and drag/drop item creation in Settings
+- Right-click launcher entries to edit them in Settings
+- Right-click launcher entries to pin or unpin them from the top
+- Right-click launcher entries or Settings items to temporarily disable them
+- Right-click app/file entries to open their containing folder
+- Validate missing app, file, and folder targets from Settings
+- Export and import selected items or menu sections
+- Sort a selected menu or item level alphabetically
+- Right-click item duplication in Settings
+- Right-click items in Settings to pin them to the top of their menu
 - Per-item icon and display mode
 - Automatic icon selection from app/folder targets
 - Portable `config.json`

Services/ConfigService.cs

@@ -80,6 +80,49 @@ public static class ConfigService
         return destinationPath;
     }
 
+    public static string ExportItemTo(string destinationPath, LauncherItem item)
+    {
+        if (string.IsNullOrWhiteSpace(destinationPath))
+        {
+            throw new ArgumentException("Choose a destination path for the exported item.", nameof(destinationPath));
+        }
+
+        string? destinationFolder = Path.GetDirectoryName(destinationPath);
+        if (!string.IsNullOrWhiteSpace(destinationFolder))
+        {
+            Directory.CreateDirectory(destinationFolder);
+        }
+
+        NormalizeDisplayModes(item);
+        string json = JsonSerializer.Serialize(item, JsonOptions);
+        File.WriteAllText(destinationPath, json);
+        return destinationPath;
+    }
+
+    public static LauncherItem ImportItemFrom(string sourcePath)
+    {
+        if (!File.Exists(sourcePath))
+        {
+            throw new FileNotFoundException("The selected item file was not found.", sourcePath);
+        }
+
+        string json = File.ReadAllText(sourcePath);
+        LauncherItem item;
+        try
+        {
+            item = JsonSerializer.Deserialize<LauncherItem>(json, JsonOptions)
+                ?? throw new InvalidDataException("The selected item file could not be read.");
+        }
+        catch (JsonException ex)
+        {
+            throw new InvalidDataException("The selected file is not a valid Taskbar Launcher item export.", ex);
+        }
+
+        ValidateItem(item);
+        NormalizeDisplayModes(item);
+        return item;
+    }
+
     public static LauncherConfig ImportFrom(string sourcePath)
     {
         LauncherConfig config = ReadConfigFile(sourcePath);
@@ -190,10 +233,20 @@ public static class ConfigService
             throw new InvalidDataException("The selected config is missing launcher items.");
         }
 
+        if (config.RecentItems is null)
+        {
+            config.RecentItems = [];
+        }
+
         foreach (LauncherItem item in config.Items)
         {
             ValidateItem(item);
         }
+
+        foreach (LauncherItem item in config.RecentItems)
+        {
+            ValidateItem(item);
+        }
     }
 
     private static void ValidateItem(LauncherItem item)
@@ -226,6 +279,16 @@ public static class ConfigService
             config.ThemeScheme = LauncherThemeScheme.MarkHaven;
         }
 
+        config.RecentItems ??= [];
+        config.RecentItems.RemoveAll(item => item.Type == LauncherItemType.Menu || item.IsDisabled || string.IsNullOrWhiteSpace(item.Target));
+        foreach (LauncherItem item in config.RecentItems)
+        {
+            item.IsFavorite = false;
+            item.IsDisabled = false;
+            item.Children = [];
+            NormalizeDisplayModes(item);
+        }
+
         foreach (LauncherItem item in config.Items)
         {
             NormalizeDisplayModes(item);

Services/LauncherController.cs

@@ -9,6 +9,8 @@ namespace TaskbarLauncher.Services;
 
 public sealed class LauncherController : IDisposable
 {
+    private const int MaxRecentItems = 8;
+
     private readonly HotkeyService hotkeyService = new();
     private NotifyIcon? notifyIcon;
     private LauncherPopup? popup;
@@ -41,6 +43,12 @@ public sealed class LauncherController : IDisposable
         settingsWindow.Activate();
     }
 
+    public void ShowSettings(LauncherItem itemToEdit)
+    {
+        settingsWindow ??= new MainWindow(this);
+        settingsWindow.SelectItemForEdit(itemToEdit);
+    }
+
     public void ShowAbout()
     {
         if (aboutWindow?.IsVisible == true)
@@ -64,7 +72,7 @@ public sealed class LauncherController : IDisposable
             return;
         }
 
-        popup = new LauncherPopup(Config, LaunchItem, OpenAllItems, ShowSettings);
+        popup = new LauncherPopup(Config, LaunchItem, OpenAllItems, ShowSettings, ShowSettings, OpenContainingFolderFromPopup);
         popup.Closed += (_, _) => popup = null;
         popup.ShowNearTaskbar();
     }
@@ -130,6 +138,7 @@ public sealed class LauncherController : IDisposable
     {
         if (TryLaunchItem(item, out string? error))
         {
+            RecordRecentItem(item);
             popup?.Close();
             return;
         }
@@ -140,6 +149,45 @@ public sealed class LauncherController : IDisposable
         }
     }
 
+    private void RecordRecentItem(LauncherItem item)
+    {
+        if (item.Type == LauncherItemType.Menu || item.IsDisabled || string.IsNullOrWhiteSpace(item.Target))
+        {
+            return;
+        }
+
+        Config.RecentItems.RemoveAll(recent => IsSameRecentItem(recent, item));
+        Config.RecentItems.Insert(0, CreateRecentItem(item));
+        if (Config.RecentItems.Count > MaxRecentItems)
+        {
+            Config.RecentItems.RemoveRange(MaxRecentItems, Config.RecentItems.Count - MaxRecentItems);
+        }
+
+        ConfigService.Save(Config);
+    }
+
+    private static bool IsSameRecentItem(LauncherItem recent, LauncherItem item)
+    {
+        return string.Equals(recent.Target, item.Target, StringComparison.OrdinalIgnoreCase) &&
+            string.Equals(recent.Arguments ?? "", item.Arguments ?? "", StringComparison.OrdinalIgnoreCase);
+    }
+
+    private static LauncherItem CreateRecentItem(LauncherItem item)
+    {
+        return new LauncherItem
+        {
+            Title = item.Title,
+            Type = item.Type,
+            Target = item.Target,
+            Arguments = item.Arguments,
+            IconPath = item.IconPath,
+            IsFavorite = false,
+            IsDisabled = false,
+            DisplayMode = item.DisplayMode,
+            Children = []
+        };
+    }
+
     private void OpenAllItems(LauncherItem menuItem)
     {
         List<string> failures = [];
@@ -147,7 +195,7 @@ public sealed class LauncherController : IDisposable
 
         foreach (LauncherItem child in menuItem.Children)
         {
-            if (child.Type == LauncherItemType.Menu || string.IsNullOrWhiteSpace(child.Target))
+            if (child.Type == LauncherItemType.Menu || child.IsDisabled || string.IsNullOrWhiteSpace(child.Target))
             {
                 continue;
             }
@@ -155,6 +203,7 @@ public sealed class LauncherController : IDisposable
             if (TryLaunchItem(child, out string? error))
             {
                 launchedCount++;
+                RecordRecentItem(child);
             }
             else if (!string.IsNullOrWhiteSpace(error))
             {
@@ -172,7 +221,15 @@ public sealed class LauncherController : IDisposable
         }
     }
 
-    private static bool TryLaunchItem(LauncherItem item, out string? error)
+    private void OpenContainingFolderFromPopup(LauncherItem item)
+    {
+        if (!OpenContainingFolder(item, out string? error) && !string.IsNullOrWhiteSpace(error))
+        {
+            System.Windows.MessageBox.Show(error, "Taskbar Launcher");
+        }
+    }
+
+    public static bool OpenContainingFolder(LauncherItem item, out string? error)
     {
         error = null;
 
@@ -181,6 +238,42 @@ public sealed class LauncherController : IDisposable
             return false;
         }
 
+        string target = Environment.ExpandEnvironmentVariables(item.Target);
+        string? folderPath = Directory.Exists(target)
+            ? target
+            : Path.GetDirectoryName(target);
+
+        if (string.IsNullOrWhiteSpace(folderPath) || !Directory.Exists(folderPath))
+        {
+            error = $"{item.Title}: Containing folder was not found.";
+            return false;
+        }
+
+        try
+        {
+            Process.Start(new ProcessStartInfo
+            {
+                FileName = folderPath,
+                UseShellExecute = true
+            });
+            return true;
+        }
+        catch (Exception ex)
+        {
+            error = $"{item.Title}: {ex.Message}";
+            return false;
+        }
+    }
+
+    private static bool TryLaunchItem(LauncherItem item, out string? error)
+    {
+        error = null;
+
+        if (item.Type == LauncherItemType.Menu || item.IsDisabled || string.IsNullOrWhiteSpace(item.Target))
+        {
+            return false;
+        }
+
         string target = Environment.ExpandEnvironmentVariables(item.Target);
 
         try

TaskbarLauncher.csproj

@@ -12,8 +12,8 @@
     <Authors>Ray Berezowski</Authors>
     <ApplicationIcon>Assets\AppIcon.ico</ApplicationIcon>
     <Version>1.0.1</Version>
-    <AssemblyVersion>1.0.1.1</AssemblyVersion>
-    <FileVersion>1.0.1.1</FileVersion>
+    <AssemblyVersion>1.0.1.16</AssemblyVersion>
+    <FileVersion>1.0.1.16</FileVersion>
     <InformationalVersion>1.0.1</InformationalVersion>
   </PropertyGroup>
 

Views/LauncherPopup.xaml.cs

@@ -14,19 +14,25 @@ public partial class LauncherPopup : Window
     private const double HeaderAndChromeHeight = 118;
     private bool isRepositionQueued;
     private readonly List<System.Windows.Controls.Button> visibleLaunchButtons = [];
+    private readonly List<System.Windows.Controls.Control> visibleNavigationControls = [];
 
     private readonly LauncherConfig config;
     private readonly Action<LauncherItem> launchItem;
     private readonly Action<LauncherItem> openAllItems;
     private readonly Action showSettings;
+    private readonly Action<LauncherItem> editItem;
+    private readonly Action<LauncherItem> openContainingFolder;
+    private sealed record SearchMatch(LauncherItem Item, string ParentPath);
 
-    public LauncherPopup(LauncherConfig config, Action<LauncherItem> launchItem, Action<LauncherItem> openAllItems, Action showSettings)
+    public LauncherPopup(LauncherConfig config, Action<LauncherItem> launchItem, Action<LauncherItem> openAllItems, Action showSettings, Action<LauncherItem> editItem, Action<LauncherItem> openContainingFolder)
     {
         InitializeComponent();
         this.config = config;
         this.launchItem = launchItem;
         this.openAllItems = openAllItems;
         this.showSettings = showSettings;
+        this.editItem = editItem;
+        this.openContainingFolder = openContainingFolder;
         BuildItems();
         SizeChanged += (_, _) => QueueReposition();
     }
@@ -91,14 +97,46 @@ public partial class LauncherPopup : Window
     {
         ItemsPanel.Children.Clear();
         visibleLaunchButtons.Clear();
+        visibleNavigationControls.Clear();
+
+        if (config.RecentItems.Any(item => !item.IsDisabled))
+        {
+            ItemsPanel.Children.Add(CreateRecentItemsControl());
+        }
+
         bool expandMenusByDefault = config.Items.Count <= 2;
-        foreach (LauncherItem item in config.Items)
+        foreach (LauncherItem item in GetDisplayItems(config.Items))
         {
             ItemsPanel.Children.Add(CreateItemControl(item, 0, expandMenusByDefault));
         }
+
+        RebuildNavigationLists();
     }
 
-    private FrameworkElement CreateItemControl(LauncherItem item, int depth, bool expandMenusByDefault)
+    private Expander CreateRecentItemsControl()
+    {
+        Expander expander = new()
+        {
+            Header = new TextBlock { Text = "Recent" },
+            IsExpanded = true,
+            Margin = new Thickness(0, 4, 0, 8),
+            Focusable = true
+        };
+        expander.KeyDown += NavigationControl_KeyDown;
+        expander.Expanded += (_, _) => RebuildNavigationAndReposition();
+        expander.Collapsed += (_, _) => RebuildNavigationAndReposition();
+
+        StackPanel recentItems = new();
+        foreach (LauncherItem item in config.RecentItems.Where(item => !item.IsDisabled))
+        {
+            recentItems.Children.Add(CreateItemControl(item, 1, expandMenusByDefault: false, allowEdit: false));
+        }
+
+        expander.Content = recentItems;
+        return expander;
+    }
+
+    private FrameworkElement CreateItemControl(LauncherItem item, int depth, bool expandMenusByDefault, bool allowEdit = true)
     {
         if (item.Type == LauncherItemType.Menu)
         {
@@ -106,13 +144,18 @@ public partial class LauncherPopup : Window
             {
                 Header = CreateMenuHeader(item),
                 IsExpanded = expandMenusByDefault,
-                Margin = new Thickness(depth * 12, 4, 0, 4)
+                Margin = new Thickness(depth * 12, 4, 0, 4),
+                Focusable = true,
+                Tag = item
             };
+            expander.KeyDown += NavigationControl_KeyDown;
+            expander.Expanded += (_, _) => RebuildNavigationAndReposition();
+            expander.Collapsed += (_, _) => RebuildNavigationAndReposition();
 
             StackPanel children = new();
-            foreach (LauncherItem child in item.Children)
+            foreach (LauncherItem child in GetDisplayItems(item.Children))
             {
-                children.Children.Add(CreateItemControl(child, depth + 1, expandMenusByDefault));
+                children.Children.Add(CreateItemControl(child, depth + 1, expandMenusByDefault, allowEdit));
             }
 
             expander.Content = children;
@@ -129,20 +172,12 @@ public partial class LauncherPopup : Window
         };
 
         button.Click += (_, _) => launchItem(item);
-        button.KeyDown += (_, e) =>
+        if (allowEdit)
         {
-            if (e.Key == Key.Enter)
-            {
-                launchItem(item);
-                e.Handled = true;
+            button.ContextMenu = CreateItemContextMenu(item);
         }
-            else if (e.Key == Key.Escape)
-            {
-                Close();
-                e.Handled = true;
-            }
-        };
-        visibleLaunchButtons.Add(button);
+
+        button.KeyDown += LaunchButton_KeyDown;
         return button;
     }
 
@@ -161,6 +196,10 @@ public partial class LauncherPopup : Window
 
         System.Windows.Controls.ContextMenu contextMenu = new();
         contextMenu.Items.Add(openAllMenuItem);
+        contextMenu.Items.Add(new Separator());
+        contextMenu.Items.Add(CreatePinMenuItem(item));
+        contextMenu.Items.Add(CreateDisableMenuItem(item));
+        contextMenu.Items.Add(CreateEditMenuItem(item));
 
         return new TextBlock
         {
@@ -169,9 +208,99 @@ public partial class LauncherPopup : Window
         };
     }
 
+    private System.Windows.Controls.ContextMenu CreateItemContextMenu(LauncherItem item)
+    {
+        System.Windows.Controls.ContextMenu contextMenu = new();
+        contextMenu.Items.Add(CreatePinMenuItem(item));
+        contextMenu.Items.Add(CreateDisableMenuItem(item));
+        contextMenu.Items.Add(CreateOpenContainingFolderMenuItem(item));
+        contextMenu.Items.Add(CreateEditMenuItem(item));
+        return contextMenu;
+    }
+
+    private System.Windows.Controls.MenuItem CreatePinMenuItem(LauncherItem item)
+    {
+        System.Windows.Controls.MenuItem pinMenuItem = new()
+        {
+            Header = item.IsFavorite ? "Unpin from Top" : "Pin to Top"
+        };
+        pinMenuItem.Click += (_, e) =>
+        {
+            item.IsFavorite = !item.IsFavorite;
+            ConfigService.Save(config);
+            BuildItems();
+            QueueReposition();
+            e.Handled = true;
+        };
+
+        return pinMenuItem;
+    }
+
+    private System.Windows.Controls.MenuItem CreateDisableMenuItem(LauncherItem item)
+    {
+        System.Windows.Controls.MenuItem disableMenuItem = new()
+        {
+            Header = item.IsDisabled ? "Enable Item" : "Disable Item"
+        };
+        disableMenuItem.Click += (_, e) =>
+        {
+            item.IsDisabled = !item.IsDisabled;
+            ConfigService.Save(config);
+            BuildItems();
+            QueueReposition();
+            e.Handled = true;
+        };
+
+        return disableMenuItem;
+    }
+
+    private System.Windows.Controls.MenuItem CreateOpenContainingFolderMenuItem(LauncherItem item)
+    {
+        System.Windows.Controls.MenuItem openFolderMenuItem = new()
+        {
+            Header = "Open Containing Folder",
+            IsEnabled = CanOpenContainingFolder(item)
+        };
+        openFolderMenuItem.Click += (_, e) =>
+        {
+            openContainingFolder(item);
+            e.Handled = true;
+        };
+
+        return openFolderMenuItem;
+    }
+
+    private System.Windows.Controls.MenuItem CreateEditMenuItem(LauncherItem item)
+    {
+        System.Windows.Controls.MenuItem editMenuItem = new()
+        {
+            Header = "Edit in Settings"
+        };
+        editMenuItem.Click += (_, e) =>
+        {
+            editItem(item);
+            Close();
+            e.Handled = true;
+        };
+
+        return editMenuItem;
+    }
+
     private static bool IsLaunchable(LauncherItem item)
     {
-        return item.Type != LauncherItemType.Menu && !string.IsNullOrWhiteSpace(item.Target);
+        return item.Type != LauncherItemType.Menu && !item.IsDisabled && !string.IsNullOrWhiteSpace(item.Target);
+    }
+
+    private static bool CanOpenContainingFolder(LauncherItem item)
+    {
+        return item.Type is LauncherItemType.App or LauncherItemType.File && !string.IsNullOrWhiteSpace(item.Target);
+    }
+
+    private static IEnumerable<LauncherItem> GetDisplayItems(IEnumerable<LauncherItem> items)
+    {
+        return items
+            .Where(item => !item.IsDisabled)
+            .OrderByDescending(item => item.IsFavorite);
     }
 
     private void SearchBox_TextChanged(object sender, TextChangedEventArgs e)
@@ -194,8 +323,8 @@ public partial class LauncherPopup : Window
         ItemsPanel.Children.Clear();
         visibleLaunchButtons.Clear();
 
-        List<LauncherItem> matches = [];
-        CollectMatches(config.Items, query, matches);
+        List<SearchMatch> matches = [];
+        CollectMatches(config.Items, query, [], matches);
 
         if (matches.Count == 0)
         {
@@ -208,34 +337,117 @@ public partial class LauncherPopup : Window
             return;
         }
 
-        foreach (LauncherItem item in matches)
+        foreach (SearchMatch match in matches)
         {
-            ItemsPanel.Children.Add(CreateItemControl(item, 0, expandMenusByDefault: false));
+            ItemsPanel.Children.Add(CreateSearchResultControl(match));
+        }
+
+        RebuildNavigationLists();
+    }
+
+    private FrameworkElement CreateSearchResultControl(SearchMatch match)
+    {
+        System.Windows.Controls.Button button = new()
+        {
+            Content = CreateSearchResultContent(match),
+            Margin = new Thickness(0, 2, 0, 2),
+            MinHeight = Math.Max(DisplayModeMetrics.GetRowHeight(GetEffectiveDisplayMode(match.Item)), 48),
+            HorizontalContentAlignment = System.Windows.HorizontalAlignment.Left,
+            Tag = match.Item,
+            ContextMenu = CreateItemContextMenu(match.Item)
+        };
+
+        button.Click += (_, _) => launchItem(match.Item);
+        button.KeyDown += LaunchButton_KeyDown;
+
+        return button;
+    }
+
+    private void RebuildNavigationAndReposition()
+    {
+        RebuildNavigationLists();
+        QueueReposition();
+    }
+
+    private void RebuildNavigationLists()
+    {
+        visibleLaunchButtons.Clear();
+        visibleNavigationControls.Clear();
+        AddVisibleNavigationControls(ItemsPanel.Children);
+    }
+
+    private void AddVisibleNavigationControls(UIElementCollection elements)
+    {
+        foreach (UIElement element in elements)
+        {
+            switch (element)
+            {
+                case Expander expander:
+                    visibleNavigationControls.Add(expander);
+                    if (expander.IsExpanded && expander.Content is System.Windows.Controls.Panel panel)
+                    {
+                        AddVisibleNavigationControls(panel.Children);
+                    }
+
+                    break;
+
+                case System.Windows.Controls.Button button:
+                    visibleNavigationControls.Add(button);
+                    if (button.Tag is LauncherItem)
+                    {
+                        visibleLaunchButtons.Add(button);
+                    }
+
+                    break;
+            }
         }
     }
 
-    private static void CollectMatches(IEnumerable<LauncherItem> items, string query, List<LauncherItem> matches)
+    private object CreateSearchResultContent(SearchMatch match)
     {
-        foreach (LauncherItem item in items)
+        StackPanel panel = new();
+        panel.Children.Add((UIElement)CreateButtonContent(match.Item));
+
+        if (!string.IsNullOrWhiteSpace(match.ParentPath))
         {
-            bool isLaunchable = item.Type != LauncherItemType.Menu;
-            if (isLaunchable && Matches(item, query))
+            panel.Children.Add(new TextBlock
             {
-                matches.Add(item);
+                Text = match.ParentPath,
+                FontSize = 11,
+                Foreground = (System.Windows.Media.Brush)System.Windows.Application.Current.Resources["AppMutedTextBrush"],
+                Margin = new Thickness(0, 3, 0, 0),
+                TextTrimming = TextTrimming.CharacterEllipsis
+            });
+        }
+
+        return panel;
+    }
+
+    private static void CollectMatches(IEnumerable<LauncherItem> items, string query, List<string> parentNames, List<SearchMatch> matches)
+    {
+        foreach (LauncherItem item in GetDisplayItems(items))
+        {
+            bool isLaunchable = item.Type != LauncherItemType.Menu && !item.IsDisabled;
+            string parentPath = string.Join(" > ", parentNames);
+            if (isLaunchable && Matches(item, query, parentPath))
+            {
+                matches.Add(new SearchMatch(item, parentPath));
             }
 
             if (item.Children.Count > 0)
             {
-                CollectMatches(item.Children, query, matches);
+                string menuName = string.IsNullOrWhiteSpace(item.Title) ? "Untitled" : item.Title;
+                CollectMatches(item.Children, query, [.. parentNames, menuName], matches);
             }
         }
     }
 
-    private static bool Matches(LauncherItem item, string query)
+    private static bool Matches(LauncherItem item, string query, string parentPath)
     {
         return item.Title.Contains(query, StringComparison.OrdinalIgnoreCase) ||
             item.Target.Contains(query, StringComparison.OrdinalIgnoreCase) ||
-            (item.Arguments?.Contains(query, StringComparison.OrdinalIgnoreCase) ?? false);
+            (item.Arguments?.Contains(query, StringComparison.OrdinalIgnoreCase) ?? false) ||
+            parentPath.Contains(query, StringComparison.OrdinalIgnoreCase);
     }
 
     private void SearchBox_PreviewKeyDown(object sender, System.Windows.Input.KeyEventArgs e)
@@ -254,14 +466,142 @@ public partial class LauncherPopup : Window
             return;
         }
 
-        if (e.Key == Key.Down && visibleLaunchButtons.FirstOrDefault() is System.Windows.Controls.Button firstButton)
+        if (e.Key == Key.Down)
         {
-            Keyboard.ClearFocus();
-            firstButton.Focus();
+            FocusNavigationControl(0);
+            e.Handled = true;
+            return;
+        }
+
+        if (e.Key == Key.Up)
+        {
+            FocusNavigationControl(visibleNavigationControls.Count - 1);
+            e.Handled = true;
+            return;
+        }
+
+        if (e.Key == Key.Home)
+        {
+            SearchBox.CaretIndex = 0;
+            e.Handled = true;
+            return;
+        }
+
+        if (e.Key == Key.End)
+        {
+            SearchBox.CaretIndex = SearchBox.Text.Length;
             e.Handled = true;
         }
     }
 
+    private void LaunchButton_KeyDown(object sender, System.Windows.Input.KeyEventArgs e)
+    {
+        if (sender is not System.Windows.Controls.Button button)
+        {
+            return;
+        }
+
+        if (e.Key == Key.Enter && button.Tag is LauncherItem item)
+        {
+            launchItem(item);
+            e.Handled = true;
+            return;
+        }
+
+        if (e.Key == Key.Escape)
+        {
+            Close();
+            e.Handled = true;
+            return;
+        }
+
+        HandleNavigationControlKey(button, e);
+    }
+
+    private void NavigationControl_KeyDown(object sender, System.Windows.Input.KeyEventArgs e)
+    {
+        if (sender is not System.Windows.Controls.Control control)
+        {
+            return;
+        }
+
+        if (e.Key == Key.Enter && control is Expander expander)
+        {
+            expander.IsExpanded = !expander.IsExpanded;
+            QueueReposition();
+            e.Handled = true;
+            return;
+        }
+
+        if (e.Key == Key.Escape)
+        {
+            Close();
+            e.Handled = true;
+            return;
+        }
+
+        HandleNavigationControlKey(control, e);
+    }
+
+    private void HandleNavigationControlKey(System.Windows.Controls.Control control, System.Windows.Input.KeyEventArgs e)
+    {
+        int index = visibleNavigationControls.IndexOf(control);
+        if (index < 0)
+        {
+            return;
+        }
+
+        if (e.Key == Key.Down)
+        {
+            FocusNavigationControl(index + 1);
+            e.Handled = true;
+            return;
+        }
+
+        if (e.Key == Key.Up)
+        {
+            if (index == 0)
+            {
+                SearchBox.Focus();
+                SearchBox.CaretIndex = SearchBox.Text.Length;
+            }
+            else
+            {
+                FocusNavigationControl(index - 1);
+            }
+
+            e.Handled = true;
+            return;
+        }
+
+        if (e.Key == Key.Home)
+        {
+            FocusNavigationControl(0);
+            e.Handled = true;
+            return;
+        }
+
+        if (e.Key == Key.End)
+        {
+            FocusNavigationControl(visibleNavigationControls.Count - 1);
+            e.Handled = true;
+        }
+    }
+
+    private void FocusNavigationControl(int index)
+    {
+        if (visibleNavigationControls.Count == 0)
+        {
+            return;
+        }
+
+        int clampedIndex = Math.Clamp(index, 0, visibleNavigationControls.Count - 1);
+        System.Windows.Controls.Control control = visibleNavigationControls[clampedIndex];
+        Keyboard.ClearFocus();
+        control.Focus();
+        control.BringIntoView();
+    }
+
     protected override void OnKeyDown(System.Windows.Input.KeyEventArgs e)
     {
         if (e.Key == Key.Escape)

config.example.json

@@ -1,6 +1,8 @@
 {
   "Hotkey": "Ctrl+Alt+Space",
   "DisplayMode": "CompactList",
+  "ThemeScheme": "MarkHaven",
+  "RecentItems": [],
   "Items": [
     {
       "Title": "Folders",
@@ -8,6 +10,8 @@
       "Target": "",
       "Arguments": null,
       "IconPath": null,
+      "IsFavorite": false,
+      "IsDisabled": false,
       "DisplayMode": "CompactList",
       "Children": [
         {
@@ -16,6 +20,8 @@
           "Target": "%USERPROFILE%\\Documents",
           "Arguments": null,
           "IconPath": "%USERPROFILE%\\Documents",
+          "IsFavorite": false,
+          "IsDisabled": false,
           "DisplayMode": "CompactList",
           "Children": []
         },
@@ -25,6 +31,8 @@
           "Target": "%USERPROFILE%\\Downloads",
           "Arguments": null,
           "IconPath": "%USERPROFILE%\\Downloads",
+          "IsFavorite": false,
+          "IsDisabled": false,
           "DisplayMode": "CompactList",
           "Children": []
         }
@@ -36,6 +44,8 @@
       "Target": "",
       "Arguments": null,
       "IconPath": null,
+      "IsFavorite": false,
+      "IsDisabled": false,
       "DisplayMode": "CompactList",
       "Children": [
         {
@@ -44,6 +54,8 @@
           "Target": "notepad.exe",
           "Arguments": null,
           "IconPath": "notepad.exe",
+          "IsFavorite": false,
+          "IsDisabled": false,
           "DisplayMode": "CompactList",
           "Children": []
         }

docs/INSTALL.md

@@ -19,6 +19,16 @@ Install the **.NET Desktop Runtime** for **Windows x64**.
 2. Run `TaskbarLauncher.exe`.
 3. The app appears in the system tray.
 4. Press `Ctrl+Alt+Space` to open the launcher.
+5. Right-click a launcher entry and choose **Edit in Settings** to jump to that item.
+6. Right-click a launcher entry and choose **Pin to Top** or **Unpin from Top**.
+7. Right-click a launcher entry and choose **Disable Item** to hide it until it is enabled again from Settings.
+8. Right-click an app or file entry and choose **Open Containing Folder**.
+
+Recently launched entries appear in the launcher popup under **Recent**.
+
+Search results include the parent menu path when an item is inside a menu.
+
+Use arrow keys, Home, End, Enter, and Escape to navigate the launcher popup from the keyboard.
 
 ## Configure
 
@@ -30,6 +40,14 @@ From Settings you can:
 - Add submenus
 - Add folders, apps, files, and websites
 - Drag/drop items to reorder
+- Drag/drop files, folders, shortcuts, or web links into the launcher item list
+- Right-click an item and choose **Duplicate Item** to copy it
+- Right-click an item and choose **Pin to Top** to show it first in its menu
+- Right-click an item and choose **Disable Item** or **Enable Item** to hide or restore it
+- Right-click an app or file item and choose **Open Containing Folder**
+- Use **Config... > Validate Targets** to check for missing app, file, and folder targets
+- Use **Config... > Export Selected Item** or **Import Item** to share one item or menu section
+- Right-click an item and choose **Sort This Menu** or **Sort This Level**
 - Set per-item icon sizes
 - Back up and restore `config.json`
 - Enable Start with Windows