Upload via GUI (180 Dateien)

App.xaml.cs

@@ -1,128 +1,191 @@
-using System.IO;
+using System.IO;
-using System.Windows;
+using System.Windows;
-using System.Windows.Interop;
+using System.Windows.Interop;
-
+
-namespace DeskCore;
+namespace DeskCore;
-
+
-public partial class App : Application
+public partial class App : Application
-{
+{
-    private const string MutexName = "DeskCore.Instanz";
+    private const string MutexName = "DeskCore.Instanz";
-    private const string ShowEventName = "DeskCore.Anzeigen";
+
-
+    public static MainWindow? Win { get; private set; }
-    public static MainWindow? Win { get; private set; }
+    public static Tray? TrayIcon { get; private set; }
-    public static Tray? TrayIcon { get; private set; }
+    public static bool Quitting { get; private set; }
-    public static bool Quitting { get; private set; }
+
-
+    private static Hotkey? _hotkey;
-    private static Hotkey? _hotkey;
+    private static Hotkey? _peekHotkey;
-    private static Watcher? _watcher;
+    private static Hotkey? _pagePrev, _pageNext;
-    private Mutex? _mutex;
+    private static System.Windows.Threading.DispatcherTimer? _desktopTimer;
-    private EventWaitHandle? _showEvent;
+    private static Watcher? _watcher;
-
+    private Mutex? _mutex;
-    protected override void OnStartup(StartupEventArgs e)
+
-    {
+    protected override void OnStartup(StartupEventArgs e)
-        // Nur eine Instanz: eine zweite holt einfach das vorhandene Fenster nach vorne
+    {
-        _mutex = new Mutex(true, MutexName, out bool first);
+        // Nur eine Instanz: weitere Aufrufe reichen ihren Befehl (oder "Fenster zeigen") an die laufende weiter
-        if (!first)
+        _mutex = new Mutex(true, MutexName, out bool first);
-        {
+        if (!first)
-            try { EventWaitHandle.OpenExisting(ShowEventName).Set(); } catch { }
+        {
-            Shutdown();
+            Commands.Send(e.Args);
-            return;
+            Shutdown();
-        }
+            return;
-        Migration.Run(); // alte "Desktop Sortierer"-Ordner übernehmen – vor allem anderen
+        }
-        _showEvent = new EventWaitHandle(false, EventResetMode.AutoReset, ShowEventName);
+        Migration.Run(); // alte "Desktop Sortierer"-Ordner übernehmen – vor allem anderen
-        new Thread(() =>
+        Commands.Listen(args => Dispatcher.BeginInvoke(() => HandleCommand(args)));
-        {
+
-            while (_showEvent.WaitOne())
+        DispatcherUnhandledException += (_, args) =>
-                Dispatcher.BeginInvoke(() => Win?.ShowFromBackground());
+        {
-        }) { IsBackground = true, Name = "ShowListener" }.Start();
+            var log = Path.Combine(Storage.Root, "fehler.log");
-
+            try { File.AppendAllText(log, $"[{DateTime.Now}] {args.Exception}\n\n"); } catch { }
-        DispatcherUnhandledException += (_, args) =>
+            MessageBox.Show($"Unerwarteter Fehler:\n\n{args.Exception.Message}\n\nDetails: {log}", "DeskCore",
-        {
+                MessageBoxButton.OK, MessageBoxImage.Error);
-            var log = Path.Combine(Storage.Root, "fehler.log");
+            args.Handled = true;
-            try { File.AppendAllText(log, $"[{DateTime.Now}] {args.Exception}\n\n"); } catch { }
+        };
-            MessageBox.Show($"Unerwarteter Fehler:\n\n{args.Exception.Message}\n\nDetails: {log}", "DeskCore",
+
-                MessageBoxButton.OK, MessageBoxImage.Error);
+        base.OnStartup(e);
-            args.Handled = true;
+        ShutdownMode = ShutdownMode.OnExplicitShutdown;
-        };
+
-
+        Storage.FlushHolding(); // Reste eines Absturzes in den Papierkorb
-        base.OnStartup(e);
+        Theme.Init();
-        ShutdownMode = ShutdownMode.OnExplicitShutdown;
+        Theme.Changed += FenceManager.RefreshAll;
-
+
-        Storage.FlushHolding(); // Reste eines Absturzes in den Papierkorb
+        Win = new MainWindow();
-        Theme.Init();
+        MainWindow = Win;
-        Theme.Changed += FenceManager.RefreshAll;
+        var hwnd = new WindowInteropHelper(Win).EnsureHandle();
-
+
-        Win = new MainWindow();
+        _hotkey = new Hotkey(hwnd);
-        MainWindow = Win;
+        _hotkey.Pressed += () => Win.ToggleFromHotkey();
-        var hwnd = new WindowInteropHelper(Win).EnsureHandle();
+        ApplyHotkey();
-
+        _peekHotkey = new Hotkey(hwnd, 0xB002);
-        _hotkey = new Hotkey(hwnd);
+        _peekHotkey.Pressed += FenceManager.TogglePeek;
-        _hotkey.Pressed += () => Win.ToggleFromHotkey();
+        ApplyPeekHotkey();
-        ApplyHotkey();
+        // Desktop-Seiten: Win + Alt + Pfeil links/rechts
-
+        _pagePrev = new Hotkey(hwnd, 0xB003);
-        TrayIcon = new Tray();
+        _pagePrev.Pressed += () => FenceManager.NextPage(-1);
-        TrayIcon.Clicked += () => Win.ShowFromBackground();
+        _pagePrev.Register(Hotkey.ModWin | Hotkey.ModAlt, 0x25);
-        TrayIcon.BalloonClicked += () => Win.ShowFromBackground();
+        _pageNext = new Hotkey(hwnd, 0xB004);
-        TrayIcon.MenuRequested += () => Win.ShowTrayMenu();
+        _pageNext.Pressed += () => FenceManager.NextPage(1);
-        ApplyTray();
+        _pageNext.Register(Hotkey.ModWin | Hotkey.ModAlt, 0x27);
-
+
-        _watcher = new Watcher(Dispatcher);
+        TrayIcon = new Tray();
-        _watcher.Changed += () =>
+        TrayIcon.Clicked += () => Win.ShowFromBackground();
-        {
+        TrayIcon.BalloonClicked += () => Win.ShowFromBackground();
-            Win.OnStorageChanged();
+        TrayIcon.MenuRequested += () => Win.ShowTrayMenu();
-            FenceManager.RefreshAll();
+        ApplyTray();
-        };
+
-        _watcher.NewOnDesktop += Win.AutoSortNew;
+        _watcher = new Watcher(Dispatcher);
-
+        _watcher.Changed += () =>
-        Autostart.RefreshPath();
+        {
-
+            Win.OnStorageChanged();
-        bool minimized = e.Args.Contains("--minimized", StringComparer.OrdinalIgnoreCase);
+            FenceManager.RefreshAll();
-        if (!minimized || !AppSettings.Current.TrayEnabled) Win.Show();
+            Win.ScheduleDeadShortcutScan(); // z. B. Deinstallation hat die Desktop-Verknüpfung entfernt
-        FenceManager.Sync();
+        };
-
+        _watcher.NewOnDesktop += Win.AutoSortNew;
-        // Bildschirm abgesteckt/Auflösung geändert → Fenster und Boxen wieder in den sichtbaren Bereich holen
+
-        Microsoft.Win32.SystemEvents.DisplaySettingsChanged += (_, _) => Dispatcher.BeginInvoke(() =>
+        Autostart.RefreshPath();
-        {
+
-            Win.EnsureOnScreen();
+        // Mit einem Befehl gestartet (z. B. Start-Gruppe per Desktop-Verknüpfung)? Dann ohne Fenster.
-            FenceManager.EnsureOnScreen();
+        if (Commands.WantsWindow(e.Args) || !AppSettings.Current.TrayEnabled) Win.Show();
-        });
+        FenceManager.Sync();
-
+
-        Win.CheckForUpdatesOnStartup();
+        // Bildschirm abgesteckt/Auflösung geändert → Fenster und Boxen wieder in den sichtbaren Bereich holen
-    }
+        Microsoft.Win32.SystemEvents.DisplaySettingsChanged += (_, _) => Dispatcher.BeginInvoke(() =>
-
+        {
-    /// <summary>Tastenkürzel neu registrieren. false = von anderem Programm belegt.</summary>
+            Win.EnsureOnScreen();
-    public static bool ApplyHotkey()
+            FenceManager.OnDisplayChanged();
-    {
+        });
-        if (_hotkey is null) return false;
+
-        var s = AppSettings.Current;
+        Win.CheckForUpdatesOnStartup();
-        if (!s.HotkeyEnabled) { _hotkey.Unregister(); return true; }
+        if (!Commands.WantsWindow(e.Args)) Dispatcher.BeginInvoke(() => HandleCommand(e.Args));
-        return _hotkey.Register(s.HotkeyModifiers, s.HotkeyKey);
+        Win.StartDeadShortcutWatch();
-    }
+        DesktopToggle.Apply();
-
+
-    public static void ApplyTray()
+        // Positionen der Desktop-Icons regelmäßig lesen (für Aufziehen, Doppelklick und die Icon-Tönung)
-    {
+        _desktopTimer = new System.Windows.Threading.DispatcherTimer { Interval = TimeSpan.FromSeconds(2) };
-        if (TrayIcon is not null) TrayIcon.Visible = AppSettings.Current.TrayEnabled;
+        _desktopTimer.Tick += (_, _) => RefreshDesktopIcons();
-    }
+        _desktopTimer.Start();
-
+        RefreshDesktopIcons();
-    public static void Quit()
+    }
-    {
+
-        if (Quitting) return;
+    private static void RefreshDesktopIcons()
-        Quitting = true;
+    {
-        Win?.CancelBusyAndWait(); // z. B. große Kopie abbrechen, halbe Dateien aufräumen
+        var s = AppSettings.Current;
-        Win?.SavePlacement();
+        if (Quitting) return;
-        Win?.Undo.FlushAll();
+        // Nur lesen, wenn eine Funktion die Positionen braucht
-        FenceManager.CloseAll();
+        if (s.DesktopTint is null && !s.DrawFences && !s.QuickHide) return;
-        _watcher?.Dispose();
+        try { DesktopIcons.RefreshCache(); } catch { /* Explorer gerade neu gestartet o. Ä. */ }
-        _hotkey?.Dispose();
+        DesktopTint.Refresh();
-        TrayIcon?.Dispose();
+    }
-        Win?.Close();
+
-        Current.Shutdown();
+    /// <summary>Befehl von der Befehlszeile oder einem weiteren Aufruf ausführen.</summary>
-    }
+    private static void HandleCommand(string[] args)
-
+    {
-    protected override void OnExit(ExitEventArgs e)
+        if (Win is null || Quitting) return;
-    {
+        if (Commands.Value(args, "--launch") is { } group) Win.LaunchGroupByName(group);
-        TrayIcon?.Dispose();
+        else if (Commands.Value(args, "--snapshot") is { } snap) Win.RestoreSnapshotByName(snap);
-        _mutex?.Dispose();
+        else if (Commands.Has(args, "--toggle-desktop")) DesktopToggle.Toggle();
-        base.OnExit(e);
+        else if (Commands.Has(args, "--peek")) FenceManager.TogglePeek();
-    }
+        else if (Commands.Value(args, "--page") is { } page) SwitchPageByName(page);
-}
+        else if (Commands.WantsWindow(args)) Win.ShowFromBackground();
+    }
+
+    /// <summary>DeskCore.exe --page "Name" oder --page 2.</summary>
+    private static void SwitchPageByName(string page)
+    {
+        var pages = AppSettings.Current.Pages;
+        int i = pages.FindIndex(p => string.Equals(p, page, StringComparison.OrdinalIgnoreCase));
+        if (i < 0 && int.TryParse(page, out var n)) i = n - 1;
+        if (i >= 0 && i < pages.Count) FenceManager.SwitchPage(i);
+        else TrayIcon?.Notify("Seite nicht gefunden", $"Es gibt keine Desktop-Seite „{page}“.");
+    }
+
+    /// <summary>Tastenkürzel neu registrieren. false = von anderem Programm belegt.</summary>
+    public static bool ApplyHotkey()
+    {
+        if (_hotkey is null) return false;
+        var s = AppSettings.Current;
+        if (!s.HotkeyEnabled) { _hotkey.Unregister(); return true; }
+        return _hotkey.Register(s.HotkeyModifiers, s.HotkeyKey);
+    }
+
+    /// <summary>Peek-Kürzel neu registrieren. false = von anderem Programm belegt.</summary>
+    public static bool ApplyPeekHotkey()
+    {
+        if (_peekHotkey is null) return false;
+        var s = AppSettings.Current;
+        if (!s.PeekEnabled) { _peekHotkey.Unregister(); return true; }
+        return _peekHotkey.Register(s.PeekModifiers, s.PeekKey);
+    }
+
+    public static void ApplyTray()
+    {
+        if (TrayIcon is not null) TrayIcon.Visible = AppSettings.Current.TrayEnabled;
+    }
+
+    public static void Quit()
+    {
+        if (Quitting) return;
+        Quitting = true;
+        Win?.CancelBusyAndWait(); // z. B. große Kopie abbrechen, halbe Dateien aufräumen
+        Win?.SavePlacement();
+        _desktopTimer?.Stop();
+        DesktopToggle.Stop();
+        DesktopToggle.RestoreOnExit();
+        _peekHotkey?.Dispose();
+        _pagePrev?.Dispose();
+        _pageNext?.Dispose();
+        Win?.Undo.FlushAll();
+        FenceManager.CloseAll();
+        _watcher?.Dispose();
+        _hotkey?.Dispose();
+        TrayIcon?.Dispose();
+        Win?.Close();
+        Current.Shutdown();
+    }
+
+    protected override void OnExit(ExitEventArgs e)
+    {
+        TrayIcon?.Dispose();
+        _mutex?.Dispose();
+        base.OnExit(e);
+    }
+}

Backup.cs

@@ -170,6 +170,12 @@ public static class Backup
             if (!s.Rules.Any(x => string.Equals(x.Contains, r.Contains, StringComparison.OrdinalIgnoreCase) &&
                                   string.Equals(x.Category, r.Category, StringComparison.OrdinalIgnoreCase)))
                 s.Rules.Add(r);
+        foreach (var g in from.LaunchGroups ?? [])
+            if (!s.LaunchGroups.Any(x => string.Equals(x.Name, g.Name, StringComparison.OrdinalIgnoreCase)))
+                s.LaunchGroups.Add(g);
+        foreach (var snap in from.Snapshots ?? [])
+            if (!s.Snapshots.Any(x => string.Equals(x.Name, snap.Name, StringComparison.OrdinalIgnoreCase)))
+                s.Snapshots.Add(snap);
         s.Save();
     }
 }

Commands.cs

@@ -0,0 +1,70 @@
+using System.IO;
+using System.IO.Pipes;
+
+namespace DeskCore;
+
+/// <summary>
+/// Befehlszeile von DeskCore, z. B. für Desktop-Verknüpfungen und Skripte:
+///   DeskCore.exe --launch "Arbeit"          Start-Gruppe starten
+///   DeskCore.exe --snapshot "Name"          Box-Anordnung wiederherstellen
+///   DeskCore.exe --toggle-desktop           Desktop-Icons und Boxen ein-/ausblenden
+///   DeskCore.exe --peek                     Boxen vor alle Fenster holen
+///   DeskCore.exe --minimized                im Infobereich starten
+/// Läuft DeskCore schon, wird der Befehl an die laufende Instanz weitergereicht.
+/// </summary>
+public static class Commands
+{
+    private const string PipeName = "DeskCore.Befehle";
+    private const char Separator = '\u001F';
+
+    public static string? Value(string[] args, string name)
+    {
+        int i = Array.FindIndex(args, a => a.Equals(name, StringComparison.OrdinalIgnoreCase));
+        return i >= 0 && i + 1 < args.Length ? args[i + 1] : null;
+    }
+
+    public static bool Has(string[] args, string name) => args.Any(a => a.Equals(name, StringComparison.OrdinalIgnoreCase));
+
+    /// <summary>Soll für diesen Aufruf das Hauptfenster erscheinen?</summary>
+    public static bool WantsWindow(string[] args) =>
+        !Has(args, "--minimized") && Value(args, "--launch") is null && Value(args, "--snapshot") is null &&
+        !Has(args, "--toggle-desktop") && !Has(args, "--peek");
+
+    /// <summary>An die laufende Instanz senden.</summary>
+    public static bool Send(string[] args)
+    {
+        try
+        {
+            using var client = new NamedPipeClientStream(".", PipeName, PipeDirection.Out);
+            client.Connect(3000);
+            using var w = new StreamWriter(client);
+            w.Write(string.Join(Separator, args));
+            w.Flush();
+            return true;
+        }
+        catch { return false; }
+    }
+
+    /// <summary>
+    /// Empfängt Befehle weiterer Aufrufe (im Hintergrund). Die Pipe ist standardmäßig nur für den
+    /// eigenen Benutzer beschreibbar – andere Benutzer können DeskCore keine Befehle schicken.
+    /// </summary>
+    public static void Listen(Action<string[]> onCommand)
+    {
+        new Thread(() =>
+        {
+            while (true)
+            {
+                try
+                {
+                    using var server = new NamedPipeServerStream(PipeName, PipeDirection.In, 1);
+                    server.WaitForConnection();
+                    using var r = new StreamReader(server);
+                    var text = r.ReadToEnd();
+                    onCommand(text.Length == 0 ? [] : text.Split(Separator));
+                }
+                catch { Thread.Sleep(500); }
+            }
+        }) { IsBackground = true, Name = "Befehle" }.Start();
+    }
+}

DesktopIcons.cs

@@ -0,0 +1,233 @@
+using System.Runtime.InteropServices;
+using System.Text;
+
+namespace DeskCore;
+
+/// <summary>Ein Icon auf dem echten Windows-Desktop (Bildschirm-Pixel).</summary>
+public record DesktopIcon(string Path, int X, int Y, int IconSize, int CellWidth);
+
+/// <summary>
+/// Liest Positionen und Größe der echten Desktop-Icons über die offizielle Shell-Schnittstelle (IFolderView)
+/// aus – ohne etwas in den Explorer einzuschleusen. Nur auf dem UI-Thread (STA) aufrufen.
+/// </summary>
+public static class DesktopIcons
+{
+    /// <summary>Alle Desktop-Icons mit Position – oder leer, wenn der Desktop gerade nicht erreichbar ist.</summary>
+    public static List<DesktopIcon> Read()
+    {
+        var result = new List<DesktopIcon>();
+        try
+        {
+            var view = DesktopFolderView(out var listView);
+            if (view is null || listView == IntPtr.Zero) return result;
+            var view2 = view as IFolderView2;
+            int iconSize = 48;
+            if (view2 is not null && view2.GetViewModeAndIconSize(out _, out var size) == 0) iconSize = size;
+            view.GetSpacing(out var spacing);
+            var origin = new POINT();
+            ClientToScreen(listView, ref origin);
+
+            view.ItemCount(SVGIO_ALLVIEW, out int count);
+            for (int i = 0; i < count; i++)
+            {
+                if (view.Item(i, out var pidl) != 0 || pidl == IntPtr.Zero) continue;
+                try
+                {
+                    if (view.GetItemPosition(pidl, out var pos) != 0) continue;
+                    string path = "";
+                    if (view2 is not null && view2.GetItem(i, typeof(IShellItem).GUID, out var obj) == 0 && obj is IShellItem item)
+                    {
+                        if (item.GetDisplayName(SIGDN_FILESYSPATH, out var p) == 0)
+                        {
+                            path = Marshal.PtrToStringUni(p) ?? "";
+                            Marshal.FreeCoTaskMem(p);
+                        }
+                        Marshal.ReleaseComObject(item);
+                    }
+                    result.Add(new DesktopIcon(path, origin.X + pos.X, origin.Y + pos.Y, iconSize, spacing.X));
+                }
+                finally { Marshal.FreeCoTaskMem(pidl); }
+            }
+        }
+        catch { }
+        return result;
+    }
+
+    /// <summary>
+    /// Rechteck des Icon-Bildes in Bildschirm-Pixeln. Die Position aus IFolderView ist bereits die linke obere
+    /// Ecke des Bildes (gemessen: Eintrag beginnt (Abstand − Bildgröße) / 2 weiter links, 3 px weiter oben).
+    /// </summary>
+    public static (int L, int T, int Size) IconRect(DesktopIcon i) => (i.X, i.Y + IconTopOffset, i.IconSize);
+
+    /// <summary>Feinkorrektur nach unten (Windows zeichnet das Bild mit kleinem Rand).</summary>
+    public static int IconTopOffset { get; set; } = 3;
+
+    /// <summary>Gesamte Fläche eines Eintrags (Bild + Beschriftung), z. B. für Klick-Tests.</summary>
+    public static (int L, int T, int W, int H) CellRect(DesktopIcon i)
+    {
+        int pad = Math.Max(0, (i.CellWidth - i.IconSize) / 2);
+        return (i.X - pad, i.Y, i.CellWidth, i.IconSize + 44);
+    }
+
+    /// <summary>Zuletzt gelesene Icons (für schnelle Prüfungen aus dem Maus-Hook, ohne COM-Aufruf).</summary>
+    public static volatile IReadOnlyList<DesktopIcon> Cached = [];
+
+    /// <summary>Zwischenspeicher auffrischen (UI-Thread). Gibt true zurück, wenn sich etwas geändert hat.</summary>
+    public static bool RefreshCache()
+    {
+        var fresh = Read();
+        bool changed = fresh.Count != Cached.Count || fresh.Where((x, n) => x != Cached[n]).Any();
+        Cached = fresh;
+        return changed;
+    }
+
+    public static bool HitsIcon(int x, int y) => Cached.Any(i =>
+    {
+        var (l, t, w, h) = CellRect(i);
+        return x >= l && x < l + w && y >= t && y < t + h;
+    });
+
+    // ---------- Desktop-Ansicht finden ----------
+
+    private static IFolderView? DesktopFolderView(out IntPtr listView)
+    {
+        listView = IntPtr.Zero;
+        var shellWindows = (IShellWindows)Activator.CreateInstance(Type.GetTypeFromCLSID(CLSID_ShellWindows)!)!;
+        try
+        {
+            object loc = CSIDL_DESKTOP, empty = new object();
+            var disp = shellWindows.FindWindowSW(ref loc, ref empty, SWC_DESKTOP, out _, SWFO_NEEDDISPATCH);
+            if (disp is not IServiceProvider sp) return null;
+            var sidBrowser = SID_STopLevelBrowser;
+            var iidBrowser = typeof(IShellBrowser).GUID;
+            if (sp.QueryService(ref sidBrowser, ref iidBrowser, out var browserObj) != 0) return null;
+            var browser = (IShellBrowser)browserObj;
+            if (browser.QueryActiveShellView(out var shellView) != 0 || shellView is null) return null;
+            shellView.GetWindow(out var defView);
+            listView = FindWindowEx(defView, IntPtr.Zero, "SysListView32", null);
+            return shellView as IFolderView;
+        }
+        finally { Marshal.ReleaseComObject(shellWindows); }
+    }
+
+    // ---------- COM-Schnittstellen (nur die benötigten Methoden in vtable-Reihenfolge) ----------
+
+    private const int CSIDL_DESKTOP = 0, SWC_DESKTOP = 8, SWFO_NEEDDISPATCH = 1, SVGIO_ALLVIEW = 2;
+    private const uint SIGDN_FILESYSPATH = 0x80058000;
+    private static readonly Guid CLSID_ShellWindows = new("9BA05972-F6A8-11CF-A442-00A0C90A8F39");
+    private static readonly Guid SID_STopLevelBrowser = new("4C96BE40-915C-11CF-99D3-00AA004AE837");
+
+    [StructLayout(LayoutKind.Sequential)] private struct POINT { public int X, Y; }
+
+    [ComImport, Guid("85CB6900-4D95-11CF-960C-0080C7F4EE85"), InterfaceType(ComInterfaceType.InterfaceIsDual)]
+    private interface IShellWindows
+    {
+        int Count { get; }
+        [return: MarshalAs(UnmanagedType.IDispatch)] object Item(object index);
+        [return: MarshalAs(UnmanagedType.IUnknown)] object _NewEnum();
+        void Register([MarshalAs(UnmanagedType.IDispatch)] object pid, int hwnd, int swClass, out int plCookie);
+        void RegisterPending(int lThreadId, ref object pvarloc, ref object pvarlocRoot, int swClass, out int plCookie);
+        void Revoke(int lCookie);
+        void OnNavigate(int lCookie, ref object pvarLoc);
+        void OnActivated(int lCookie, short fActive);
+        [return: MarshalAs(UnmanagedType.IDispatch)]
+        object FindWindowSW(ref object pvarLoc, ref object pvarLocRoot, int swClass, out int pHWND, int swfwOptions);
+    }
+
+    [ComImport, Guid("6D5140C1-7436-11CE-8034-00AA006009FA"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+    private interface IServiceProvider
+    {
+        [PreserveSig] int QueryService(ref Guid guidService, ref Guid riid, [MarshalAs(UnmanagedType.Interface)] out object ppvObject);
+    }
+
+    [ComImport, Guid("000214E2-0000-0000-C000-000000000046"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+    private interface IShellBrowser
+    {
+        void GetWindow(out IntPtr phwnd);
+        void ContextSensitiveHelp(bool fEnterMode);
+        void InsertMenusSB(IntPtr hmenuShared, IntPtr lpMenuWidths);
+        void SetMenuSB(IntPtr hmenuShared, IntPtr holemenuRes, IntPtr hwndActiveObject);
+        void RemoveMenusSB(IntPtr hmenuShared);
+        void SetStatusTextSB(IntPtr pszStatusText);
+        void EnableModelessSB(bool fEnable);
+        void TranslateAcceleratorSB(IntPtr pmsg, ushort wID);
+        void BrowseObject(IntPtr pidl, uint wFlags);
+        void GetViewStateStream(uint grfMode, out IntPtr ppStrm);
+        void GetControlWindow(uint id, out IntPtr phwnd);
+        void SendControlMsg(uint id, uint uMsg, IntPtr wParam, IntPtr lParam, out IntPtr pret);
+        [PreserveSig] int QueryActiveShellView(out IShellView ppshv);
+    }
+
+    [ComImport, Guid("000214E3-0000-0000-C000-000000000046"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+    private interface IShellView
+    {
+        void GetWindow(out IntPtr phwnd);
+    }
+
+    [ComImport, Guid("CDE725B0-CCC9-4519-917E-325D72FAB4CE"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+    private interface IFolderView
+    {
+        [PreserveSig] int GetCurrentViewMode(out uint pViewMode);
+        [PreserveSig] int SetCurrentViewMode(uint ViewMode);
+        [PreserveSig] int GetFolder(ref Guid riid, out IntPtr ppv);
+        [PreserveSig] int Item(int iItemIndex, out IntPtr ppidl);
+        [PreserveSig] int ItemCount(uint uFlags, out int pcItems);
+        [PreserveSig] int Items(uint uFlags, ref Guid riid, out IntPtr ppv);
+        [PreserveSig] int GetSelectionMarkedItem(out int piItem);
+        [PreserveSig] int GetFocusedItem(out int piItem);
+        [PreserveSig] int GetItemPosition(IntPtr pidl, out POINT ppt);
+        [PreserveSig] int GetSpacing(out POINT ppt);
+    }
+
+    [ComImport, Guid("1AF3A467-214F-4298-908E-06B03E0B39F9"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+    private interface IFolderView2
+    {
+        // IFolderView
+        [PreserveSig] int GetCurrentViewMode(out uint pViewMode);
+        [PreserveSig] int SetCurrentViewMode(uint ViewMode);
+        [PreserveSig] int GetFolder(ref Guid riid, out IntPtr ppv);
+        [PreserveSig] int Item(int iItemIndex, out IntPtr ppidl);
+        [PreserveSig] int ItemCount(uint uFlags, out int pcItems);
+        [PreserveSig] int Items(uint uFlags, ref Guid riid, out IntPtr ppv);
+        [PreserveSig] int GetSelectionMarkedItem(out int piItem);
+        [PreserveSig] int GetFocusedItem(out int piItem);
+        [PreserveSig] int GetItemPosition(IntPtr pidl, out POINT ppt);
+        [PreserveSig] int GetSpacing(out POINT ppt);
+        [PreserveSig] int GetDefaultSpacing(out POINT ppt);
+        [PreserveSig] int GetAutoArrange();
+        [PreserveSig] int SelectItem(int iItem, uint dwFlags);
+        [PreserveSig] int SelectAndPositionItems(uint cidl, IntPtr apidl, IntPtr apt, uint dwFlags);
+        // IFolderView2
+        [PreserveSig] int SetGroupBy(IntPtr key, bool fAscending);
+        [PreserveSig] int GetGroupBy(IntPtr pkey, out bool pfAscending);
+        [PreserveSig] int SetViewProperty(IntPtr pidl, IntPtr propkey, IntPtr propvar);
+        [PreserveSig] int GetViewProperty(IntPtr pidl, IntPtr propkey, IntPtr ppropvar);
+        [PreserveSig] int SetTileViewProperties(IntPtr pidl, IntPtr pszPropList);
+        [PreserveSig] int SetExtendedTileViewProperties(IntPtr pidl, IntPtr pszPropList);
+        [PreserveSig] int SetText(int iType, IntPtr pwszText);
+        [PreserveSig] int SetCurrentFolderFlags(uint dwMask, uint dwFlags);
+        [PreserveSig] int GetCurrentFolderFlags(out uint pdwFlags);
+        [PreserveSig] int GetSortColumnCount(out int pcColumns);
+        [PreserveSig] int SetSortColumns(IntPtr rgSortColumns, int cColumns);
+        [PreserveSig] int GetSortColumns(IntPtr rgSortColumns, int cColumns);
+        [PreserveSig] int GetItem(int iItem, [MarshalAs(UnmanagedType.LPStruct)] Guid riid, [MarshalAs(UnmanagedType.Interface)] out object ppv);
+        [PreserveSig] int GetVisibleItem(int iStart, bool fPrevious, out int piItem);
+        [PreserveSig] int GetSelectedItem(int iStart, out int piItem);
+        [PreserveSig] int GetSelection(bool fNoneImpliesFolder, out IntPtr ppsia);
+        [PreserveSig] int GetSelectionState(IntPtr pidl, out uint pdwFlags);
+        [PreserveSig] int InvokeVerbOnSelection(IntPtr pszVerb);
+        [PreserveSig] int SetViewModeAndIconSize(int uViewMode, int iImageSize);
+        [PreserveSig] int GetViewModeAndIconSize(out int puViewMode, out int piImageSize);
+    }
+
+    [ComImport, Guid("43826D1E-E718-42EE-BC55-A1E261C37BFE"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+    private interface IShellItem
+    {
+        [PreserveSig] int BindToHandler(IntPtr pbc, ref Guid bhid, ref Guid riid, out IntPtr ppv);
+        [PreserveSig] int GetParent(out IShellItem ppsi);
+        [PreserveSig] int GetDisplayName(uint sigdnName, out IntPtr ppszName);
+    }
+
+    [DllImport("user32.dll")] private static extern bool ClientToScreen(IntPtr hWnd, ref POINT lpPoint);
+    [DllImport("user32.dll", CharSet = CharSet.Unicode)] private static extern IntPtr FindWindowEx(IntPtr parent, IntPtr after, string? cls, string? title);
+}

DesktopOverlays.cs

@@ -0,0 +1,261 @@
+using System.IO;
+using System.Runtime.InteropServices;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Interop;
+using System.Windows.Media;
+using System.Windows.Media.Animation;
+using System.Windows.Shapes;
+using System.Windows.Threading;
+
+namespace DeskCore;
+
+/// <summary>Gemeinsame Hilfen für klickdurchlässige Overlay-Fenster.</summary>
+internal static class Overlay
+{
+    public static Window Create(bool topmost)
+    {
+        var w = new Window
+        {
+            WindowStyle = WindowStyle.None, AllowsTransparency = true, Background = Brushes.Transparent,
+            ShowInTaskbar = false, ShowActivated = false, Topmost = topmost, ResizeMode = ResizeMode.NoResize,
+            Focusable = false, IsHitTestVisible = false,
+        };
+        w.SourceInitialized += (_, _) =>
+        {
+            var hwnd = new WindowInteropHelper(w).Handle;
+            long ex = GetWindowLongPtr(hwnd, GWL_EXSTYLE).ToInt64();
+            SetWindowLongPtr(hwnd, GWL_EXSTYLE, new IntPtr(ex | WS_EX_TRANSPARENT | WS_EX_LAYERED | WS_EX_TOOLWINDOW | WS_EX_NOACTIVATE));
+        };
+        return w;
+    }
+
+    /// <summary>Wie die Boxen: Besitzer = Desktop, immer ganz unten (über den Desktop-Icons, unter allen Fenstern).</summary>
+    public static void PinToDesktop(Window w)
+    {
+        var hwnd = new WindowInteropHelper(w).Handle;
+        var progman = FindWindow("Progman", null);
+        if (progman != IntPtr.Zero) SetWindowLongPtr(hwnd, GWLP_HWNDPARENT, progman);
+        HwndSource.FromHwnd(hwnd).AddHook((IntPtr h, int msg, IntPtr wp, IntPtr lp, ref bool handled) =>
+        {
+            if (msg == WM_WINDOWPOSCHANGING)
+            {
+                var pos = Marshal.PtrToStructure<WINDOWPOS>(lp);
+                pos.hwndInsertAfter = new IntPtr(1); // HWND_BOTTOM
+                pos.flags &= ~SWP_NOZORDER;
+                Marshal.StructureToPtr(pos, lp, false);
+            }
+            return IntPtr.Zero;
+        });
+    }
+
+    private const int GWL_EXSTYLE = -20, GWLP_HWNDPARENT = -8, WM_WINDOWPOSCHANGING = 0x46;
+    private const long WS_EX_TRANSPARENT = 0x20, WS_EX_LAYERED = 0x80000, WS_EX_TOOLWINDOW = 0x80, WS_EX_NOACTIVATE = 0x8000000;
+    private const uint SWP_NOZORDER = 0x4;
+
+    [StructLayout(LayoutKind.Sequential)]
+    private struct WINDOWPOS { public IntPtr hwnd, hwndInsertAfter; public int x, y, cx, cy; public uint flags; }
+
+    [DllImport("user32.dll", CharSet = CharSet.Unicode)] private static extern IntPtr FindWindow(string? cls, string? title);
+    [DllImport("user32.dll")] private static extern IntPtr GetWindowLongPtr(IntPtr h, int i);
+    [DllImport("user32.dll")] private static extern IntPtr SetWindowLongPtr(IntPtr h, int i, IntPtr v);
+}
+
+// =========================================================================
+// Seitenanzeige beim Wechseln der Desktop-Seite
+// =========================================================================
+
+public static class PageIndicator
+{
+    private static Window? _w;
+    private static TextBlock? _name;
+    private static StackPanel? _dots;
+    private static DispatcherTimer? _hide;
+
+    public static void Show(string name, int index, int count)
+    {
+        if (_w is null)
+        {
+            _w = Overlay.Create(topmost: true);
+            _w.SizeToContent = SizeToContent.WidthAndHeight;
+            _name = new TextBlock { FontSize = 15, FontWeight = FontWeights.SemiBold, HorizontalAlignment = HorizontalAlignment.Center };
+            _dots = new StackPanel { Orientation = Orientation.Horizontal, HorizontalAlignment = HorizontalAlignment.Center, Margin = new Thickness(0, 8, 0, 0) };
+            _w.Content = new Border
+            {
+                Padding = new Thickness(22, 12, 22, 12), CornerRadius = new CornerRadius(10), Margin = new Thickness(12),
+                Child = new StackPanel { Children = { _name, _dots } },
+            };
+            _hide = new DispatcherTimer { Interval = TimeSpan.FromMilliseconds(1300) };
+            _hide.Tick += (_, _) =>
+            {
+                _hide.Stop();
+                var fade = new DoubleAnimation(0, TimeSpan.FromMilliseconds(350));
+                fade.Completed += (_, _) => { if (_w.Opacity == 0) _w.Hide(); };
+                _w.BeginAnimation(UIElement.OpacityProperty, fade);
+            };
+        }
+        var res = Application.Current.Resources;
+        var border = (Border)_w.Content;
+        border.Background = (Brush)res["FlyoutBrush"];
+        border.BorderBrush = (Brush)res["FlyoutStrokeBrush"];
+        border.BorderThickness = new Thickness(1);
+        border.Effect = (System.Windows.Media.Effects.Effect)res["FlyoutShadow"];
+        _name!.Text = name;
+        _name.Foreground = (Brush)res["TextBrush"];
+        _dots!.Children.Clear();
+        for (int i = 0; i < count; i++)
+            _dots.Children.Add(new Ellipse
+            {
+                Width = 7, Height = 7, Margin = new Thickness(4, 0, 4, 0),
+                Fill = (Brush)res[i == index ? "AccentBrush" : "ControlStrongStrokeBrush"],
+            });
+
+        _w.BeginAnimation(UIElement.OpacityProperty, null);
+        _w.Opacity = 1;
+        _w.Show();
+        _w.UpdateLayout();
+        var wa = Screens.PrimaryWorkArea;
+        _w.Left = wa.Left + (wa.Width - _w.ActualWidth) / 2;
+        _w.Top = wa.Bottom - _w.ActualHeight - 40;
+        _hide!.Stop();
+        _hide.Start();
+    }
+}
+
+// =========================================================================
+// Rahmen beim Aufziehen einer neuen Box (rechte Maustaste auf dem Desktop)
+// =========================================================================
+
+public static class DrawBoxOverlay
+{
+    private static Window? _w;
+
+    public static void Begin()
+    {
+        if (_w is null)
+        {
+            _w = Overlay.Create(topmost: true);
+            var res = Application.Current.Resources;
+            var accent = ((SolidColorBrush)res["AccentBrush"]).Color;
+            _w.Content = new Grid
+            {
+                Children =
+                {
+                    new Rectangle
+                    {
+                        RadiusX = 8, RadiusY = 8, StrokeThickness = 2, StrokeDashArray = [4, 3],
+                        Stroke = new SolidColorBrush(accent), Fill = new SolidColorBrush(Color.FromArgb(0x38, accent.R, accent.G, accent.B)),
+                    },
+                    new TextBlock
+                    {
+                        Text = "Neue Box", Foreground = Brushes.White, FontSize = 14, FontWeight = FontWeights.SemiBold,
+                        HorizontalAlignment = HorizontalAlignment.Center, VerticalAlignment = VerticalAlignment.Center,
+                        Effect = new System.Windows.Media.Effects.DropShadowEffect { BlurRadius = 6, ShadowDepth = 0, Opacity = 0.8 },
+                    },
+                },
+            };
+        }
+        _w.Width = _w.Height = 1;
+        _w.Show();
+    }
+
+    /// <summary>Rechteck in Bildschirm-Pixeln.</summary>
+    public static void Update(Rect px)
+    {
+        if (_w is null) return;
+        double s = Screens.Scale;
+        _w.Left = px.X / s;
+        _w.Top = px.Y / s;
+        _w.Width = Math.Max(1, px.Width / s);
+        _w.Height = Math.Max(1, px.Height / s);
+    }
+
+    public static void Finish(Rect px)
+    {
+        _w?.Hide();
+        double s = Screens.Scale;
+        var dip = new Rect(px.X / s, px.Y / s, px.Width / s, px.Height / s);
+        if (dip.Width < 120 || dip.Height < 60) return; // zu klein – war wohl nur ein Versehen
+        FenceManager.ShowCreateMenu(dip);
+    }
+}
+
+// =========================================================================
+// Tönung der echten Desktop-Icons
+// =========================================================================
+
+/// <summary>
+/// Legt eine klickdurchlässige Farbschicht exakt über die Bilder der Desktop-Icons. Die Positionen stammen aus der
+/// offiziellen Shell-Schnittstelle; am Explorer selbst wird nichts verändert. Icons unter Boxen bleiben ausgespart.
+/// </summary>
+public static class DesktopTint
+{
+    private static Window? _w;
+    private static Canvas? _canvas;
+    private static string _signature = "";
+
+    private static AppSettings S => AppSettings.Current;
+
+    /// <summary>Schicht neu aufbauen, wenn sich Icons, Boxen oder Einstellungen geändert haben.</summary>
+    public static void Refresh(bool force = false)
+    {
+        bool on = S.DesktopTint is not null && !FenceManager.Hidden && DesktopToggle.IconsVisible();
+        if (!on)
+        {
+            _w?.Hide();
+            _signature = "";
+            return;
+        }
+        var icons = DesktopIcons.Cached.Where(i => i.Path.Length > 0).ToList();
+        var fences = FenceManager.OpenRects();
+        var sig = $"{S.DesktopTint}|{S.DesktopTintStrength}|{DesktopIcons.IconTopOffset}|" +
+                  string.Join(";", icons.Select(i => $"{i.X},{i.Y},{i.IconSize}")) + "|" + string.Join(";", fences.Select(r => r.ToString()));
+        if (!force && sig == _signature && _w?.IsVisible == true) return;
+        _signature = sig;
+
+        if (_w is null)
+        {
+            _w = Overlay.Create(topmost: false);
+            _canvas = new Canvas();
+            _w.Content = _canvas;
+            _w.SourceInitialized += (_, _) => Overlay.PinToDesktop(_w);
+        }
+
+        // Fenster über die gesamte Desktop-Fläche (alle Bildschirme)
+        double s = Screens.Scale;
+        var vs = new Rect(SystemParameters.VirtualScreenLeft, SystemParameters.VirtualScreenTop,
+            SystemParameters.VirtualScreenWidth, SystemParameters.VirtualScreenHeight);
+        _w.Left = vs.Left;
+        _w.Top = vs.Top;
+        _w.Width = vs.Width;
+        _w.Height = vs.Height;
+
+        var tint = CategoryColors.Brush(S.DesktopTint) ?? Brushes.Transparent;
+        _canvas!.Children.Clear();
+        foreach (var icon in icons)
+        {
+            var (l, t, size) = DesktopIcons.IconRect(icon);
+            var r = new Rect(l / s, t / s, size / s, size / s);
+            if (fences.Any(f => f.IntersectsWith(r))) continue; // liegt unter einer Box
+            var item = new IconItem { Path = icon.Path };
+            var rect = new Rectangle
+            {
+                Width = r.Width, Height = r.Height, Fill = tint, Opacity = Math.Clamp(S.DesktopTintStrength, 0.1, 0.95),
+                Visibility = Visibility.Hidden, // erst zeigen, wenn die Form (das Icon) geladen ist
+            };
+            void Apply()
+            {
+                if (item.Icon is null) return;
+                rect.OpacityMask = new ImageBrush(item.Icon) { Stretch = Stretch.Fill };
+                rect.Visibility = Visibility.Visible;
+            }
+            item.PropertyChanged += (_, _) => Apply();
+            Canvas.SetLeft(rect, r.X - vs.Left);
+            Canvas.SetTop(rect, r.Y - vs.Top);
+            _canvas.Children.Add(rect);
+            IconLoader.Load(item, size);
+            Apply();
+        }
+        if (!_w.IsVisible) _w.Show();
+    }
+}

DesktopToggle.cs

@@ -0,0 +1,272 @@
+using System.Diagnostics;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Windows;
+using System.Windows.Automation;
+
+namespace DeskCore;
+
+/// <summary>
+/// Maus-Funktionen direkt auf dem Windows-Desktop – ohne etwas in den Explorer einzuschleusen:
+///  • Doppelklick auf freie Stelle: Desktop-Icons und Boxen aus-/einblenden ("Schnell verstecken")
+///  • Rechte Maustaste auf freier Stelle ziehen: neue Box aufziehen (normaler Rechtsklick bleibt unverändert)
+///  • Mausrad über dem Desktop: Desktop-Seite wechseln
+/// </summary>
+public static class DesktopToggle
+{
+    private static IntPtr _hook;
+    private static LowLevelMouseProc? _proc; // Referenz halten, sonst räumt der GC den Callback weg
+    private static long _lastDownTick;
+    private static POINT _lastDownPt;
+
+    // Box aufziehen
+    private static bool _rPending, _rDrawing, _updatePosted;
+    private static POINT _rStart, _rCurrent;
+    private static long _lastWheelTick;
+
+    private static AppSettings S => AppSettings.Current;
+
+    public static void Apply()
+    {
+        bool needed = S.QuickHide || S.DrawFences || (S.PageWheel && S.Pages.Count > 1);
+        if (needed) Start();
+        else Stop();
+    }
+
+    private static void Start()
+    {
+        if (_hook != IntPtr.Zero) return;
+        _proc = Proc;
+        using var module = Process.GetCurrentProcess().MainModule!;
+        _hook = SetWindowsHookEx(WH_MOUSE_LL, _proc, GetModuleHandle(module.ModuleName), 0);
+    }
+
+    public static void Stop()
+    {
+        if (_hook == IntPtr.Zero) return;
+        UnhookWindowsHookEx(_hook);
+        _hook = IntPtr.Zero;
+    }
+
+    /// <summary>Muss sehr schnell sein: nur Fensterklasse und zwischengespeicherte Icon-Positionen prüfen.</summary>
+    private static IntPtr Proc(int nCode, IntPtr wParam, IntPtr lParam)
+    {
+        if (nCode < 0) return CallNextHookEx(_hook, nCode, wParam, lParam);
+        var info = Marshal.PtrToStructure<MSLLHOOKSTRUCT>(lParam);
+        bool injected = (info.flags & LLMHF_INJECTED) != 0;
+        int msg = wParam.ToInt32();
+        var dispatcher = Application.Current?.Dispatcher;
+
+        switch (msg)
+        {
+            case WM_LBUTTONDOWN when S.QuickHide:
+            {
+                long now = Environment.TickCount64;
+                bool isDouble = now - _lastDownTick <= GetDoubleClickTime() &&
+                                Math.Abs(info.pt.x - _lastDownPt.x) <= 4 && Math.Abs(info.pt.y - _lastDownPt.y) <= 4;
+                if (isDouble)
+                {
+                    _lastDownTick = 0;
+                    var pt = info.pt;
+                    dispatcher?.BeginInvoke(() => OnDoubleClick(pt));
+                }
+                else
+                {
+                    _lastDownTick = now;
+                    _lastDownPt = info.pt;
+                }
+                break;
+            }
+
+            case WM_RBUTTONDOWN when !injected && S.DrawFences && IsDesktopAt(info.pt) && !DesktopIcons.HitsIcon(info.pt.x, info.pt.y):
+                // Rechtsklick auf freie Desktop-Fläche abfangen – bleibt es ein Klick, wird er unten nachgereicht
+                _rPending = true;
+                _rDrawing = false;
+                _rStart = _rCurrent = info.pt;
+                return new IntPtr(1);
+
+            case WM_MOUSEMOVE when _rPending:
+                _rCurrent = info.pt;
+                if (!_rDrawing && (Math.Abs(info.pt.x - _rStart.x) > 8 || Math.Abs(info.pt.y - _rStart.y) > 8))
+                {
+                    _rDrawing = true;
+                    dispatcher?.BeginInvoke(() => DrawBoxOverlay.Begin());
+                }
+                if (_rDrawing && !_updatePosted)
+                {
+                    _updatePosted = true;
+                    dispatcher?.BeginInvoke(() => { _updatePosted = false; DrawBoxOverlay.Update(PixelRect(_rStart, _rCurrent)); });
+                }
+                break;
+
+            case WM_RBUTTONUP when _rPending && !injected:
+            {
+                _rPending = false;
+                var rect = PixelRect(_rStart, info.pt);
+                if (_rDrawing) dispatcher?.BeginInvoke(() => DrawBoxOverlay.Finish(rect));
+                else dispatcher?.BeginInvoke(ReplayRightClick); // normales Desktop-Kontextmenü
+                return new IntPtr(1);
+            }
+
+            case WM_MOUSEWHEEL when S.PageWheel && S.Pages.Count > 1 && !injected:
+            {
+                if ((GetKeyState(VK_CONTROL) & 0x8000) != 0) break; // Strg+Rad = Icon-Größe (Windows)
+                long now = Environment.TickCount64;
+                if (now - _lastWheelTick < 350 || !IsDesktopAt(info.pt)) break;
+                _lastWheelTick = now;
+                int delta = (short)((info.mouseData >> 16) & 0xFFFF);
+                dispatcher?.BeginInvoke(() => FenceManager.NextPage(delta < 0 ? 1 : -1));
+                break;
+            }
+        }
+        return CallNextHookEx(_hook, nCode, wParam, lParam);
+    }
+
+    private static Rect PixelRect(POINT a, POINT b) =>
+        new(Math.Min(a.x, b.x), Math.Min(a.y, b.y), Math.Abs(a.x - b.x), Math.Abs(a.y - b.y));
+
+    /// <summary>Liegt unter dem Punkt direkt der Desktop (kein Fenster darüber)?</summary>
+    private static bool IsDesktopAt(POINT pt)
+    {
+        var cls = ClassName(WindowFromPoint(pt));
+        return cls is "WorkerW" or "Progman" or "SHELLDLL_DefView" ||
+               (cls == "SysListView32" && ClassName(GetParent(WindowFromPoint(pt))) == "SHELLDLL_DefView");
+    }
+
+    /// <summary>Abgefangenen Rechtsklick an Windows weitergeben (wird als "eingespeist" markiert und nicht erneut abgefangen).</summary>
+    private static void ReplayRightClick()
+    {
+        var inputs = new[]
+        {
+            new INPUT { type = INPUT_MOUSE, mi = new MOUSEINPUT { dwFlags = MOUSEEVENTF_RIGHTDOWN } },
+            new INPUT { type = INPUT_MOUSE, mi = new MOUSEINPUT { dwFlags = MOUSEEVENTF_RIGHTUP } },
+        };
+        SendInput((uint)inputs.Length, inputs, Marshal.SizeOf<INPUT>());
+    }
+
+    private static void OnDoubleClick(POINT pt)
+    {
+        if (!IsEmptyDesktopSpot(pt)) return;
+        Toggle();
+    }
+
+    /// <summary>Liegt der Punkt auf dem Desktop – und zwar nicht auf einem Icon?</summary>
+    private static bool IsEmptyDesktopSpot(POINT pt)
+    {
+        var hwnd = WindowFromPoint(pt);
+        var cls = ClassName(hwnd);
+        if (cls is "WorkerW" or "Progman" or "SHELLDLL_DefView") return true; // Icons gerade ausgeblendet
+        if (cls != "SysListView32" || ClassName(GetParent(hwnd)) != "SHELLDLL_DefView") return false;
+        // Auf ein Icon geklickt? Dann ist es ein normaler Programmstart, nichts tun.
+        try
+        {
+            var el = AutomationElement.FromPoint(new Point(pt.x, pt.y));
+            for (var e = el; e is not null; e = TreeWalker.RawViewWalker.GetParent(e))
+            {
+                var type = e.Current.ControlType;
+                if (type == ControlType.ListItem) return false;
+                if (type == ControlType.List) break;
+            }
+            return true;
+        }
+        catch { return false; }
+    }
+
+    /// <summary>Desktop-Icons und Boxen umschalten (auch per Befehl --toggle-desktop).</summary>
+    public static void Toggle()
+    {
+        var view = DesktopView();
+        var list = view == IntPtr.Zero ? IntPtr.Zero : FindWindowEx(view, IntPtr.Zero, "SysListView32", null);
+        bool iconsVisible = list != IntPtr.Zero && IsWindowVisible(list);
+        if (view != IntPtr.Zero) SendMessage(view, WM_COMMAND, new IntPtr(0x7402), IntPtr.Zero); // "Desktopsymbole anzeigen" umschalten
+        FenceManager.SetHidden(iconsVisible);
+        DesktopTint.Refresh();
+    }
+
+    /// <summary>Beim Beenden: ausgeblendete Desktop-Icons wieder zeigen, damit niemand vor einem leeren Desktop sitzt.</summary>
+    public static void RestoreOnExit()
+    {
+        if (!FenceManager.Hidden) return;
+        var view = DesktopView();
+        var list = view == IntPtr.Zero ? IntPtr.Zero : FindWindowEx(view, IntPtr.Zero, "SysListView32", null);
+        if (view != IntPtr.Zero && list != IntPtr.Zero && !IsWindowVisible(list))
+            SendMessage(view, WM_COMMAND, new IntPtr(0x7402), IntPtr.Zero);
+    }
+
+    /// <summary>Das Fenster mit den Desktop-Icons (liegt je nach Zustand unter Progman oder einem WorkerW).</summary>
+    public static IntPtr DesktopView()
+    {
+        var progman = FindWindow("Progman", null);
+        var view = FindWindowEx(progman, IntPtr.Zero, "SHELLDLL_DefView", null);
+        if (view != IntPtr.Zero) return view;
+        IntPtr worker = IntPtr.Zero;
+        while ((worker = FindWindowEx(IntPtr.Zero, worker, "WorkerW", null)) != IntPtr.Zero)
+        {
+            view = FindWindowEx(worker, IntPtr.Zero, "SHELLDLL_DefView", null);
+            if (view != IntPtr.Zero) return view;
+        }
+        return IntPtr.Zero;
+    }
+
+    /// <summary>Sind die Desktop-Icons gerade sichtbar?</summary>
+    public static bool IconsVisible()
+    {
+        var view = DesktopView();
+        var list = view == IntPtr.Zero ? IntPtr.Zero : FindWindowEx(view, IntPtr.Zero, "SysListView32", null);
+        return list != IntPtr.Zero && IsWindowVisible(list);
+    }
+
+    private static string ClassName(IntPtr hwnd)
+    {
+        if (hwnd == IntPtr.Zero) return "";
+        var sb = new StringBuilder(64);
+        GetClassName(hwnd, sb, sb.Capacity);
+        return sb.ToString();
+    }
+
+    private const int WH_MOUSE_LL = 14, WM_COMMAND = 0x0111, VK_CONTROL = 0x11;
+    private const int WM_MOUSEMOVE = 0x0200, WM_LBUTTONDOWN = 0x0201, WM_RBUTTONDOWN = 0x0204, WM_RBUTTONUP = 0x0205, WM_MOUSEWHEEL = 0x020A;
+    private const uint LLMHF_INJECTED = 0x1, INPUT_MOUSE = 0, MOUSEEVENTF_RIGHTDOWN = 0x0008, MOUSEEVENTF_RIGHTUP = 0x0010;
+
+    private delegate IntPtr LowLevelMouseProc(int nCode, IntPtr wParam, IntPtr lParam);
+
+    [StructLayout(LayoutKind.Sequential)] private struct POINT { public int x, y; }
+
+    [StructLayout(LayoutKind.Sequential)]
+    private struct MSLLHOOKSTRUCT
+    {
+        public POINT pt;
+        public uint mouseData, flags, time;
+        public IntPtr dwExtraInfo;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    private struct MOUSEINPUT
+    {
+        public int dx, dy;
+        public uint mouseData, dwFlags, time;
+        public IntPtr dwExtraInfo;
+    }
+
+    [StructLayout(LayoutKind.Explicit)]
+    private struct INPUT
+    {
+        [FieldOffset(0)] public uint type;
+        [FieldOffset(8)] public MOUSEINPUT mi; // 64-Bit: Union beginnt bei Offset 8
+    }
+
+    [DllImport("user32.dll", SetLastError = true)] private static extern IntPtr SetWindowsHookEx(int idHook, LowLevelMouseProc lpfn, IntPtr hMod, uint dwThreadId);
+    [DllImport("user32.dll")] private static extern bool UnhookWindowsHookEx(IntPtr hhk);
+    [DllImport("user32.dll")] private static extern IntPtr CallNextHookEx(IntPtr hhk, int nCode, IntPtr wParam, IntPtr lParam);
+    [DllImport("kernel32.dll", CharSet = CharSet.Unicode)] private static extern IntPtr GetModuleHandle(string lpModuleName);
+    [DllImport("user32.dll")] private static extern uint GetDoubleClickTime();
+    [DllImport("user32.dll")] private static extern short GetKeyState(int vk);
+    [DllImport("user32.dll")] private static extern uint SendInput(uint n, INPUT[] inputs, int size);
+    [DllImport("user32.dll")] private static extern IntPtr WindowFromPoint(POINT p);
+    [DllImport("user32.dll")] private static extern IntPtr GetParent(IntPtr hWnd);
+    [DllImport("user32.dll", CharSet = CharSet.Unicode)] private static extern int GetClassName(IntPtr hWnd, StringBuilder name, int max);
+    [DllImport("user32.dll", CharSet = CharSet.Unicode)] private static extern IntPtr FindWindow(string? cls, string? title);
+    [DllImport("user32.dll", CharSet = CharSet.Unicode)] private static extern IntPtr FindWindowEx(IntPtr parent, IntPtr after, string? cls, string? title);
+    [DllImport("user32.dll")] private static extern bool IsWindowVisible(IntPtr hWnd);
+    [DllImport("user32.dll")] private static extern IntPtr SendMessage(IntPtr hWnd, int msg, IntPtr wParam, IntPtr lParam);
+}

Directory.Build.props

@@ -1,7 +1,7 @@
 <Project>
-  <!-- Eine Versionsnummer für App und Installer – nur hier ändern -->
+  <!-- Eine Versionsnummer für App und Installer – nur hier ändern -->
   <PropertyGroup>
-    <Version>1.0.1</Version>
+    <Version>1.0.2</Version>
     <!-- keine Git-Kennung an die Produktversion anhängen (sonst "1.0.1+a1b2c3…") -->
     <IncludeSourceRevisionInInformationalVersion>false</IncludeSourceRevisionInInformationalVersion>
   </PropertyGroup>

FenceManager.cs

@@ -0,0 +1,394 @@
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Media;
+using System.Windows.Threading;
+
+namespace DeskCore;
+
+/// <summary>Verwaltet alle Desktop-Boxen: Anzeigen, Peek, Ausblenden, Snapshots und Anordnung je Bildschirm-Setup.</summary>
+public static class FenceManager
+{
+    private static readonly List<FenceWindow> _open = [];
+    private static AppSettings S => AppSettings.Current;
+    private static DispatcherTimer? _peekWatch;
+    private static string? _screenSignature;
+
+    /// <summary>Boxen gerade per "Schnell verstecken" ausgeblendet?</summary>
+    public static bool Hidden { get; private set; }
+
+    /// <summary>Boxen gerade per Peek vor allen Fenstern?</summary>
+    public static bool Peeking { get; private set; }
+
+    public static void Sync()
+    {
+        _screenSignature ??= ScreenSignature();
+        // Boxen auf nicht (mehr) vorhandenen Seiten landen auf der letzten Seite
+        foreach (var f in S.Fences) f.Page = Math.Clamp(f.Page, 0, S.Pages.Count - 1);
+        var wanted = S.FencesEnabled && !Hidden
+            ? S.Fences.Where(f => f.Tabs.Count > 0 && f.Page == S.CurrentPage).ToList()
+            : [];
+
+        foreach (var w in _open.Where(w => !wanted.Contains(w.Def)).ToList())
+        {
+            w.Close();
+            _open.Remove(w);
+        }
+
+        var wa = Screens.PrimaryWorkArea;
+        foreach (var def in wanted)
+        {
+            var w = _open.FirstOrDefault(x => x.Def == def);
+            if (w is not null) { w.Refresh(); continue; }
+
+            if (def.X is null)
+            {
+                // neue Box: oben rechts beginnen – links liegen meist die Desktop-Icons
+                int perRow = Math.Max(1, (int)((wa.Width - 48) / (def.W + 16)));
+                int i = _open.Count;
+                def.X = wa.Right - 24 - def.W - (i % perRow) * (def.W + 16);
+                def.Y = wa.Top + 24 + (i / perRow) * (def.H + 16);
+            }
+            w = new FenceWindow(def);
+            _open.Add(w);
+            w.Show();
+        }
+    }
+
+    public static void RefreshAll()
+    {
+        foreach (var w in _open) w.Refresh();
+    }
+
+    public static void CloseAll()
+    {
+        foreach (var w in _open) w.Close();
+        _open.Clear();
+    }
+
+    public static void Remove(FenceDef def)
+    {
+        S.Fences.Remove(def);
+        S.Save();
+        Sync();
+        App.Win?.RefreshFromFences();
+    }
+
+    /// <summary>Kategorie aus allen Boxen (außer except) entfernen – eine Kategorie soll nur in einer Box stehen.</summary>
+    public static void RemoveCategoryTab(string category, FenceDef? except)
+    {
+        foreach (var f in S.Fences.Where(f => f != except))
+            f.Tabs.RemoveAll(t => !t.IsFolder && string.Equals(t.Value, category, StringComparison.OrdinalIgnoreCase));
+        S.Fences.RemoveAll(f => f != except && f.Tabs.Count == 0);
+    }
+
+    /// <summary>Tab als eigene Box daneben lösen.</summary>
+    public static void DetachTab(FenceDef def, int index)
+    {
+        if (index < 0 || index >= def.Tabs.Count || def.Tabs.Count < 2) return;
+        var tab = def.Tabs[index];
+        def.Tabs.RemoveAt(index);
+        def.ActiveTab = Math.Clamp(def.ActiveTab, 0, def.Tabs.Count - 1);
+        S.Fences.Add(new FenceDef
+        {
+            Page = def.Page, Tabs = [tab], X = (def.X ?? 0) + 40, Y = (def.Y ?? 0) + 40, W = def.W, H = def.H,
+            Background = def.Background, Opacity = def.Opacity, Blur = def.Blur, IconSize = def.IconSize, Sort = def.Sort, Tint = def.Tint,
+        });
+        S.Save();
+        Sync();
+    }
+
+    public static string? PickFolder()
+    {
+        var dlg = new Microsoft.Win32.OpenFolderDialog { Title = "Ordner für das Portal wählen" };
+        return dlg.ShowDialog() == true ? dlg.FolderName : null;
+    }
+
+    /// <summary>Neue Box, die live einen beliebigen Ordner zeigt (z. B. Downloads).</summary>
+    public static void AddPortal()
+    {
+        if (PickFolder() is not { } folder) return;
+        S.Fences.Add(new FenceDef { Page = S.CurrentPage, Tabs = [new FenceTab { Kind = FenceTab.FolderKind, Value = folder }] });
+        S.FencesEnabled = true;
+        S.Save();
+        Sync();
+    }
+
+    /// <summary>Flächen der sichtbaren Boxen (WPF-Einheiten), z. B. damit die Icon-Tönung sie ausspart.</summary>
+    public static List<Rect> OpenRects() =>
+        _open.Where(w => w.IsVisible).Select(w => new Rect(w.Left, w.Top, w.ActualWidth, w.ActualHeight)).ToList();
+
+    /// <summary>Nach dem Aufziehen: Menü "Neue Box hier" an der Mausposition.</summary>
+    public static void ShowCreateMenu(Rect area)
+    {
+        var menu = new ContextMenu { Placement = System.Windows.Controls.Primitives.PlacementMode.MousePoint };
+        var header = MainWindow.MenuItem("Neue Box hier für …", "\uE8A1", null, bold: true);
+        header.IsEnabled = false;
+        menu.Items.Add(header);
+        menu.Items.Add(new Separator());
+
+        void Create(FenceTab tab)
+        {
+            if (!tab.IsFolder) RemoveCategoryTab(tab.Value, except: null);
+            S.Fences.Add(new FenceDef
+            {
+                Page = S.CurrentPage, Tabs = [tab],
+                X = area.X, Y = area.Y, W = Math.Max(180, area.Width), H = Math.Max(120, area.Height),
+            });
+            S.FencesEnabled = true;
+            S.Save();
+            Sync();
+            App.Win?.RefreshFromFences();
+        }
+
+        foreach (var c in Storage.Categories())
+        {
+            var label = S.HasFence(c) ? $"{c}  (aus anderer Box hierher holen)" : c;
+            menu.Items.Add(MainWindow.MenuItem(label, S.Categories.GetValueOrDefault(c)?.Glyph ?? "\uF12B",
+                () => Create(new FenceTab { Value = c })));
+        }
+        if (Storage.Categories().Count > 0) menu.Items.Add(new Separator());
+        menu.Items.Add(MainWindow.MenuItem("Neue Kategorie …", "\uE710", () =>
+        {
+            if (App.Win?.CreateCategoryInteractive() is { } name) Create(new FenceTab { Value = name });
+        }));
+        menu.Items.Add(MainWindow.MenuItem("Ordner-Portal …", "\uF12B", () =>
+        {
+            if (PickFolder() is { } folder) Create(new FenceTab { Kind = FenceTab.FolderKind, Value = folder });
+        }));
+        menu.Items.Add(new Separator());
+        menu.Items.Add(MainWindow.MenuItem("Abbrechen", "\uE711", () => { }));
+        // Damit das Menü bei Klick daneben zugeht, muss es im Vordergrund sein
+        menu.Opened += (_, _) =>
+        {
+            if (PresentationSource.FromVisual(menu) is System.Windows.Interop.HwndSource src) SetForegroundWindow(src.Handle);
+        };
+        menu.IsOpen = true;
+    }
+
+    [System.Runtime.InteropServices.DllImport("user32.dll")] private static extern bool SetForegroundWindow(IntPtr hwnd);
+
+    // =====================================================================
+    // Desktop-Seiten
+    // =====================================================================
+
+    /// <summary>Zur nächsten/vorigen Seite wechseln (rundum).</summary>
+    public static void NextPage(int delta)
+    {
+        if (S.Pages.Count < 2) return;
+        SwitchPage((S.CurrentPage + delta + S.Pages.Count) % S.Pages.Count);
+    }
+
+    public static void SwitchPage(int index)
+    {
+        index = Math.Clamp(index, 0, S.Pages.Count - 1);
+        if (Peeking) EndPeek();
+        bool changed = index != S.CurrentPage;
+        S.CurrentPage = index;
+        S.Save();
+        if (changed) Sync();
+        PageIndicator.Show(S.Pages[index], index, S.Pages.Count);
+        App.Win?.RefreshFromFences();
+    }
+
+    public static void MoveToPage(FenceDef def, int page)
+    {
+        def.Page = Math.Clamp(page, 0, S.Pages.Count - 1);
+        S.Save();
+        Sync();
+    }
+
+    /// <summary>Seite löschen: ihre Boxen wandern auf die Seite davor.</summary>
+    public static void DeletePage(int index)
+    {
+        if (S.Pages.Count < 2 || index < 0 || index >= S.Pages.Count) return;
+        S.Pages.RemoveAt(index);
+        foreach (var f in S.Fences)
+            if (f.Page == index) f.Page = Math.Max(0, index - 1);
+            else if (f.Page > index) f.Page--;
+        if (S.CurrentPage >= index && S.CurrentPage > 0) S.CurrentPage--;
+        S.Save();
+        CloseAll();
+        Sync();
+    }
+
+    // =====================================================================
+    // Aussehen
+    // =====================================================================
+
+    public static void EditLook(FenceWindow w)
+    {
+        var def = w.Def;
+        var res = Application.Current.Resources;
+        var before = AppSettings.CloneFences([def])[0];
+        var panel = new StackPanel();
+        TextBlock Label(string t, double top = 16) => new() { Text = t, Margin = new Thickness(0, top, 0, 8), FontWeight = FontWeights.SemiBold, FontSize = 13 };
+
+        // Hintergrund
+        panel.Children.Add(Label("Hintergrund", 0));
+        var bgPanel = new WrapPanel();
+        void AddSwatch(WrapPanel p, string group, string? hex, Brush brush, string tip, Func<string?> get, Action<string?> set)
+        {
+            var rb = new RadioButton { Style = (Style)res["SwatchRadio"], GroupName = group, Background = brush, ToolTip = tip, IsChecked = get() == hex };
+            rb.Checked += (_, _) => { set(hex); w.ApplyLook(); };
+            p.Children.Add(rb);
+        }
+        AddSwatch(bgPanel, "bg", null, (Brush)res["FenceBrush"], "Passend zum Design", () => def.Background, v => def.Background = v);
+        foreach (var (name, hex) in CategoryColors.All.Concat([("Schwarz", "#101010"), ("Weiß", "#F5F5F5")]))
+            AddSwatch(bgPanel, "bg", hex, CategoryColors.Brush(hex)!, name, () => def.Background, v => def.Background = v);
+        panel.Children.Add(bgPanel);
+
+        // Deckkraft
+        panel.Children.Add(Label("Deckkraft"));
+        var opacity = new Slider { Minimum = 20, Maximum = 100, Value = Math.Round(def.Opacity * 100), TickFrequency = 5, IsSnapToTickEnabled = true };
+        opacity.ValueChanged += (_, _) => { def.Opacity = opacity.Value / 100; w.ApplyLook(); };
+        panel.Children.Add(opacity);
+
+        var blur = new CheckBox { Content = "Milchglas (Hintergrund verschwommen)", IsChecked = def.Blur, Margin = new Thickness(0, 12, 0, 0) };
+        blur.Click += (_, _) => { def.Blur = blur.IsChecked == true; w.ApplyLook(); };
+        panel.Children.Add(blur);
+
+        // Icon-Größe und Sortierung als Segmente
+        StackPanel Segments(string group, (string Label, string Value)[] options, string current, Action<string> set)
+        {
+            var sp = new StackPanel { Orientation = Orientation.Horizontal };
+            foreach (var (label, value) in options)
+            {
+                var rb = new RadioButton { Style = (Style)res["SegmentRadio"], GroupName = group, Content = label, IsChecked = value == current };
+                rb.Checked += (_, _) => { set(value); w.Refresh(); };
+                sp.Children.Add(rb);
+            }
+            return sp;
+        }
+        panel.Children.Add(Label("Icon-Größe"));
+        panel.Children.Add(new Border
+        {
+            Style = (Style)res["SegmentGroup"], HorizontalAlignment = HorizontalAlignment.Left,
+            Child = Segments("size", [("Klein", "Small"), ("Mittel", "Medium"), ("Groß", "Large")], def.IconSize.ToString(),
+                v => def.IconSize = Enum.Parse<ViewMode>(v)),
+        });
+        panel.Children.Add(Label("Sortieren nach"));
+        panel.Children.Add(new Border
+        {
+            Style = (Style)res["SegmentGroup"], HorizontalAlignment = HorizontalAlignment.Left,
+            Child = Segments("sort", [("Name", "Name"), ("Typ", "Typ"), ("Datum", "Datum")], def.Sort, v => def.Sort = v),
+        });
+
+        // Icon-Tönung
+        panel.Children.Add(Label("Icon-Tönung"));
+        var tintPanel = new WrapPanel();
+        AddSwatch(tintPanel, "tint", null, Brushes.Transparent, "Keine Tönung", () => def.Tint, v => def.Tint = v);
+        foreach (var (name, hex) in CategoryColors.All)
+            AddSwatch(tintPanel, "tint", hex, CategoryColors.Brush(hex)!, name, () => def.Tint, v => def.Tint = v);
+        panel.Children.Add(tintPanel);
+
+        var owner = App.Win!;
+        if (Dialog.Show(owner, "Aussehen der Box", panel, "Speichern", "Abbrechen", null, width: 470))
+            S.Save();
+        else
+        {
+            // Vorschau zurücknehmen
+            (def.Background, def.Opacity, def.Blur, def.IconSize, def.Sort, def.Tint) =
+                (before.Background, before.Opacity, before.Blur, before.IconSize, before.Sort, before.Tint);
+            w.Refresh();
+        }
+    }
+
+    // =====================================================================
+    // Peek & Schnell verstecken
+    // =====================================================================
+
+    public static void TogglePeek()
+    {
+        if (Peeking) EndPeek();
+        else StartPeek();
+    }
+
+    private static void StartPeek()
+    {
+        if (_open.Count == 0) return;
+        if (Hidden) SetHidden(false);
+        Peeking = true;
+        foreach (var w in _open) w.SetPeek(true);
+        _open[0].Activate();
+        // Peek endet, sobald ein anderes Fenster aktiv wird
+        _peekWatch ??= new DispatcherTimer(TimeSpan.FromMilliseconds(300), DispatcherPriority.Background, (_, _) =>
+        {
+            if (!_open.Any(w => w.IsActive) && !_open.Any(w => w.IsMouseOver)) EndPeek();
+        }, Application.Current.Dispatcher);
+        _peekWatch.Start();
+    }
+
+    public static void EndPeek()
+    {
+        _peekWatch?.Stop();
+        if (!Peeking) return;
+        Peeking = false;
+        foreach (var w in _open) w.SetPeek(false);
+    }
+
+    /// <summary>Alle Boxen aus- bzw. wieder einblenden (Schnell verstecken).</summary>
+    public static void SetHidden(bool hidden)
+    {
+        if (Hidden == hidden) return;
+        Hidden = hidden;
+        if (hidden) EndPeek();
+        Sync();
+    }
+
+    // =====================================================================
+    // Bildschirme & Snapshots
+    // =====================================================================
+
+    /// <summary>Kennung der aktuellen Bildschirm-Anordnung (Anzahl, Größen, Positionen).</summary>
+    private static string ScreenSignature() =>
+        string.Join("|", System.Windows.Forms.Screen.AllScreens
+            .OrderBy(s => s.Bounds.X).ThenBy(s => s.Bounds.Y)
+            .Select(s => $"{s.Bounds.X},{s.Bounds.Y},{s.Bounds.Width}x{s.Bounds.Height}"));
+
+    private static Dictionary<string, double[]> CurrentPositions() =>
+        S.Fences.Where(f => f.X is not null).ToDictionary(f => f.Id, f => new[] { f.X!.Value, f.Y!.Value, f.W, f.H });
+
+    /// <summary>
+    /// Bildschirm angesteckt/abgesteckt oder Auflösung geändert: Anordnung der alten Konstellation merken
+    /// und – falls bekannt – die zur neuen Konstellation passende wiederherstellen.
+    /// </summary>
+    public static void OnDisplayChanged()
+    {
+        var newSig = ScreenSignature();
+        if (_screenSignature is { } oldSig && oldSig != newSig)
+        {
+            S.ScreenLayouts[oldSig] = CurrentPositions();
+            if (S.ScreenLayouts.TryGetValue(newSig, out var layout))
+            {
+                foreach (var f in S.Fences)
+                    if (layout.TryGetValue(f.Id, out var r) && r.Length == 4)
+                        (f.X, f.Y, f.W, f.H) = (r[0], r[1], r[2], r[3]);
+                foreach (var w in _open) w.Reapply();
+            }
+            S.Save();
+        }
+        _screenSignature = newSig;
+        foreach (var w in _open) w.EnsureOnScreen();
+    }
+
+    public static void SaveSnapshot(string name)
+    {
+        S.Snapshots.RemoveAll(s => string.Equals(s.Name, name, StringComparison.OrdinalIgnoreCase));
+        S.Snapshots.Add(new FenceSnapshot { Name = name, Fences = AppSettings.CloneFences(S.Fences) });
+        S.Save();
+    }
+
+    /// <summary>Anordnung wiederherstellen. Gibt die Anordnung davor zurück (für Rückgängig).</summary>
+    public static List<FenceDef> RestoreSnapshot(FenceSnapshot snap) => ApplyFences(AppSettings.CloneFences(snap.Fences));
+
+    public static List<FenceDef> ApplyFences(List<FenceDef> fences)
+    {
+        var before = AppSettings.CloneFences(S.Fences);
+        CloseAll();
+        S.Fences = fences;
+        S.FencesEnabled = true;
+        S.Save();
+        Sync();
+        return before;
+    }
+}

FenceWindow.xaml

@@ -1,29 +1,37 @@
 <Window x:Class="DeskCore.FenceWindow"
         xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+        xmlns:sys="clr-namespace:System;assembly=System.Runtime"
         WindowStyle="None" AllowsTransparency="True" Background="Transparent" ResizeMode="CanResize"
         ShowInTaskbar="False" ShowActivated="False" MinWidth="180" MinHeight="40"
         FontFamily="{DynamicResource UiFont}" FontSize="12" Foreground="{DynamicResource TextBrush}"
         TextOptions.TextFormattingMode="Display" UseLayoutRounding="True">
 
     <WindowChrome.WindowChrome>
-        <WindowChrome CaptionHeight="36" ResizeBorderThickness="6" GlassFrameThickness="0" CornerRadius="0"/>
+        <WindowChrome x:Name="Chrome" CaptionHeight="36" ResizeBorderThickness="6" GlassFrameThickness="0" CornerRadius="0"/>
     </WindowChrome.WindowChrome>
 
-    <Border CornerRadius="8" Background="{DynamicResource FenceBrush}" BorderBrush="{DynamicResource FlyoutStrokeBrush}"
+    <Window.Resources>
-            BorderThickness="1" ClipToBounds="True">
+        <!-- Kachelgrößen je Box (im Code je nach Einstellung gesetzt) -->
-        <DockPanel>
+        <sys:Double x:Key="FTileW">78</sys:Double>
-            <!-- Titel (zum Verschieben ziehen, Doppelklick = ein-/ausklappen) -->
+        <sys:Double x:Key="FTileH">80</sys:Double>
-            <Grid DockPanel.Dock="Top" Height="36" Background="Transparent" x:Name="TitleBar">
+        <sys:Double x:Key="FIcon">32</sys:Double>
+    </Window.Resources>
+
+    <Border x:Name="Root" CornerRadius="8" BorderBrush="{DynamicResource FlyoutStrokeBrush}" BorderThickness="1" ClipToBounds="True">
+        <DockPanel x:Name="Content_">
+            <!-- Titel / Tabs (zum Verschieben ziehen, Doppelklick = ein-/ausklappen) -->
+            <Grid DockPanel.Dock="Top" Height="36" Background="Transparent" x:Name="TitleBar" MouseLeftButtonDown="TitleBar_MouseLeftButtonDown">
                 <Grid.ColumnDefinitions>
-                    <ColumnDefinition Width="Auto"/>
                     <ColumnDefinition Width="*"/>
                     <ColumnDefinition Width="Auto"/>
                     <ColumnDefinition Width="Auto"/>
+                    <ColumnDefinition Width="Auto"/>
                 </Grid.ColumnDefinitions>
-                <TextBlock x:Name="GlyphText" FontFamily="{DynamicResource IconFont}" FontSize="14" VerticalAlignment="Center" Margin="12,0,10,0"/>
+                <StackPanel x:Name="TabStrip" Orientation="Horizontal" Margin="6,0,0,0" VerticalAlignment="Center" ClipToBounds="True"/>
-                <TextBlock x:Name="TitleText" Grid.Column="1" FontSize="13" FontWeight="SemiBold" VerticalAlignment="Center"
+                <TextBlock x:Name="LockGlyph" Grid.Column="1" Text="&#xE72E;" FontFamily="{DynamicResource IconFont}" FontSize="11"
-                           TextTrimming="CharacterEllipsis"/>
+                           Foreground="{DynamicResource TextTertiaryBrush}" VerticalAlignment="Center" Margin="6,0,0,0"
+                           Visibility="Collapsed" ToolTip="Box ist gesperrt"/>
                 <TextBlock x:Name="CountText" Grid.Column="2" Foreground="{DynamicResource TextTertiaryBrush}" VerticalAlignment="Center" Margin="8,0"/>
                 <Button x:Name="MenuButton" Grid.Column="3" Style="{StaticResource SubtleButton}" Padding="7,5" MinHeight="0" Margin="0,0,4,0"
                         WindowChrome.IsHitTestVisibleInChrome="True" Click="MenuButton_Click" ToolTip="Optionen">
@@ -34,6 +42,15 @@
                 </Button>
             </Grid>
 
+            <!-- Ordner-Portal: Unterordner-Navigation -->
+            <DockPanel x:Name="PortalBar" DockPanel.Dock="Top" Margin="6,0,8,4" Visibility="Collapsed">
+                <Button DockPanel.Dock="Left" Style="{StaticResource SubtleButton}" Padding="6,3" MinHeight="0" Click="PortalUp_Click" ToolTip="Zurück">
+                    <TextBlock Text="&#xE72B;" FontFamily="{DynamicResource IconFont}" FontSize="11"/>
+                </Button>
+                <TextBlock x:Name="PortalPath" VerticalAlignment="Center" Margin="6,0,0,0" TextTrimming="CharacterEllipsis"
+                           Foreground="{DynamicResource TextSecondaryBrush}"/>
+            </DockPanel>
+
             <Grid x:Name="Body">
                 <ListBox x:Name="Items" Padding="6,0,6,8" SelectionMode="Extended" ItemContainerStyle="{StaticResource TileItem}"
                          AllowDrop="True" DragOver="Items_DragOver" Drop="Items_Drop"
@@ -50,8 +67,16 @@
                     </ListBox.ItemsPanel>
                     <ListBox.ItemTemplate>
                         <DataTemplate>
-                            <StackPanel Width="78" Height="80" ToolTip="{Binding Name}">
+                            <StackPanel Width="{DynamicResource FTileW}" Height="{DynamicResource FTileH}" ToolTip="{Binding Name}">
-                                <Image Source="{Binding Icon}" Width="32" Height="32" Margin="0,8,0,0" RenderOptions.BitmapScalingMode="HighQuality"/>
+                                <Grid Width="{DynamicResource FIcon}" Height="{DynamicResource FIcon}" Margin="0,8,0,0">
+                                    <Image Source="{Binding Icon}" RenderOptions.BitmapScalingMode="HighQuality"/>
+                                    <!-- Icon-Tönung: Farbfläche in Form des Icons -->
+                                    <Rectangle Fill="{DynamicResource FTint}" Opacity="0.6" IsHitTestVisible="False">
+                                        <Rectangle.OpacityMask>
+                                            <ImageBrush ImageSource="{Binding Icon}"/>
+                                        </Rectangle.OpacityMask>
+                                    </Rectangle>
+                                </Grid>
                                 <TextBlock Text="{Binding Name}" TextAlignment="Center" TextWrapping="Wrap" TextTrimming="CharacterEllipsis"
                                            MaxHeight="30" LineHeight="15" Margin="4,6,4,0"/>
                             </StackPanel>

FenceWindow.xaml.cs

@@ -1,346 +1,634 @@
-using System.Diagnostics;
+using System.Diagnostics;
-using System.IO;
+using System.IO;
-using System.Runtime.InteropServices;
+using System.Runtime.InteropServices;
-using System.Windows;
+using System.Windows;
-using System.Windows.Controls;
+using System.Windows.Controls;
-using System.Windows.Input;
+using System.Windows.Input;
-using System.Windows.Interop;
+using System.Windows.Interop;
-using System.Windows.Media;
+using System.Windows.Media;
-using System.Windows.Threading;
+using System.Windows.Media.Animation;
-
+using System.Windows.Shell;
-namespace DeskCore;
+using System.Windows.Threading;
-
+
-/// <summary>Eine "Box" auf dem Desktop, die den Inhalt einer Kategorie zeigt.</summary>
+namespace DeskCore;
-public partial class FenceWindow : Window
+
-{
+/// <summary>
-    private const double CollapsedHeight = 38;
+/// Eine Box auf dem Desktop: zeigt eine oder mehrere Kategorien bzw. Ordner (Tabs),
-    private readonly DispatcherTimer _saveTimer;
+/// mit eigenem Aussehen, Einklappen, Sperren, Chamäleon und Peek.
-    private bool _applying;
+/// </summary>
-
+public partial class FenceWindow : Window
-    public string Category { get; private set; }
+{
-
+    private const double CollapsedHeight = 38;
-    public FenceWindow(string category)
+    private readonly DispatcherTimer _saveTimer;
-    {
+    private readonly DispatcherTimer _collapseTimer;
-        InitializeComponent();
+    private FileSystemWatcher? _portalWatcher;
-        Category = category;
+    private DispatcherTimer? _portalRefresh;
-        _saveTimer = new DispatcherTimer(TimeSpan.FromMilliseconds(700), DispatcherPriority.Background, (_, _) =>
+    private bool _applying;
-        {
+    private bool _hoverExpanded;
-            _saveTimer!.Stop();
+    private bool _mouseInside;
-            AppSettings.Current.Save();
+    /// <summary>Unterordner, in den im Ordner-Portal navigiert wurde (null = Wurzel).</summary>
-        }, Dispatcher);
+    private string? _portalSub;
-        _saveTimer.Stop();
+
-
+    public FenceDef Def { get; }
-        ApplyBounds();
+    private static AppSettings S => AppSettings.Current;
-        LocationChanged += (_, _) => RememberBounds();
+
-        SizeChanged += (_, _) => RememberBounds();
+    public FenceWindow(FenceDef def)
-        SourceInitialized += (_, _) => PinToDesktop();
+    {
-        Refresh();
+        InitializeComponent();
-    }
+        Def = def;
-
+        _saveTimer = new DispatcherTimer(TimeSpan.FromMilliseconds(700), DispatcherPriority.Background, (_, _) =>
-    private CategoryMeta Meta => AppSettings.Current.Meta(Category);
+        {
-
+            _saveTimer!.Stop();
-    public void Rename(string newName)
+            S.Save();
-    {
+        }, Dispatcher);
-        Category = newName;
+        _saveTimer.Stop();
-        Refresh();
+        _collapseTimer = new DispatcherTimer { Interval = TimeSpan.FromMilliseconds(500) };
-    }
+        _collapseTimer.Tick += (_, _) =>
-
+        {
-    // ---------- Position/Größe ----------
+            _collapseTimer.Stop();
-
+            if (!_mouseInside && _hoverExpanded && !ItemMenu.IsOpen && !FenceMenu.IsOpen) CollapseAfterHover();
-    private void ApplyBounds()
+        };
-    {
+
-        _applying = true;
+        ApplyBounds();
-        var m = Meta;
+        LocationChanged += (_, _) => RememberBounds();
-        Width = Math.Max(MinWidth, m.FenceW);
+        SizeChanged += (_, _) => RememberBounds();
-        Height = m.FenceCollapsed ? CollapsedHeight : Math.Max(120, m.FenceH);
+        SourceInitialized += (_, _) => PinToDesktop();
-        var wa = Screens.PrimaryWorkArea;
+        MouseEnter += (_, _) => OnHover(true);
-        double left = m.FenceX ?? wa.Right - Width - 24, top = m.FenceY ?? wa.Top + 24;
+        MouseLeave += (_, _) => OnHover(false);
-        // Bildschirm abgesteckt? → zurück auf den Hauptbildschirm (oben rechts)
+        Closed += (_, _) => _portalWatcher?.Dispose();
-        if (!Screens.IsReachable(new Rect(left, top, Width, Height)))
+        Refresh();
-        {
+    }
-            left = wa.Right - Width - 24;
+
-            top = wa.Top + 24;
+    // =====================================================================
-            m.FenceX = left;
+    // Position, Größe, Einklappen
-            m.FenceY = top;
+    // =====================================================================
-        }
+
-        Left = left;
+    private void ApplyBounds()
-        Top = top;
+    {
-        Body.Visibility = m.FenceCollapsed ? Visibility.Collapsed : Visibility.Visible;
+        _applying = true;
-        _applying = false;
+        Width = Math.Max(MinWidth, Def.W);
-    }
+        Height = Def.Collapsed && !_hoverExpanded ? CollapsedHeight : Math.Max(120, Def.H);
-
+        var wa = Screens.PrimaryWorkArea;
-    /// <summary>Nach Bildschirm-Änderungen: Box wieder sichtbar machen.</summary>
+        double left = Def.X ?? wa.Right - Width - 24, top = Def.Y ?? wa.Top + 24;
-    public void EnsureOnScreen()
+        // Bildschirm abgesteckt? → zurück auf den Hauptbildschirm (oben rechts)
-    {
+        if (!Screens.IsReachable(new Rect(left, top, Width, Height)))
-        if (Screens.IsReachable(new Rect(Left, Top, ActualWidth, ActualHeight))) return;
+        {
-        Meta.FenceX = null;
+            left = wa.Right - Width - 24;
-        Meta.FenceY = null;
+            top = wa.Top + 24;
-        ApplyBounds();
+            Def.X = left;
-        AppSettings.Current.Save();
+            Def.Y = top;
-    }
+        }
-
+        Left = left;
-    private void RememberBounds()
+        Top = top;
-    {
+        Body.Visibility = Def.Collapsed && !_hoverExpanded ? Visibility.Collapsed : Visibility.Visible;
-        if (_applying || !IsLoaded) return;
+        _applying = false;
-        var m = Meta;
+    }
-        m.FenceX = Left;
+
-        m.FenceY = Top;
+    /// <summary>Position/Größe aus den Einstellungen neu übernehmen (z. B. nach Snapshot).</summary>
-        m.FenceW = Width;
+    public void Reapply()
-        if (!m.FenceCollapsed) m.FenceH = Height;
+    {
-        _saveTimer.Stop();
+        ApplyBounds();
-        _saveTimer.Start();
+        ApplyLook();
-    }
+        Refresh();
-
+    }
-    private void ToggleCollapsed()
+
-    {
+    public void EnsureOnScreen()
-        Meta.FenceCollapsed = !Meta.FenceCollapsed;
+    {
-        ApplyBounds();
+        if (Screens.IsReachable(new Rect(Left, Top, ActualWidth, ActualHeight))) return;
-        AppSettings.Current.Save();
+        Def.X = null;
-    }
+        Def.Y = null;
-
+        ApplyBounds();
-    // ---------- Inhalt ----------
+        S.Save();
-
+    }
-    public void Refresh()
+
-    {
+    private void RememberBounds()
-        var meta = Meta;
+    {
-        TitleText.Text = Category;
+        if (_applying || !IsLoaded || _hoverExpanded) return;
-        GlyphText.Text = meta.Glyph ?? "";
+        Def.X = Left;
-        GlyphText.Foreground = CategoryColors.Brush(meta.Color) ?? (Brush)FindResource("TextBrush");
+        Def.Y = Top;
-
+        Def.W = Width;
-        var items = Storage.Entries(Storage.CategoryPath(Category))
+        if (!Def.Collapsed) Def.H = Height;
-            .Select(p => new IconItem { Path = p })
+        _saveTimer.Stop();
-            .OrderBy(i => !Directory.Exists(i.Path)).ThenBy(i => i.Name, StringComparer.CurrentCultureIgnoreCase)
+        _saveTimer.Start();
-            .ToList();
+    }
-        int px = (int)Math.Round(32 * VisualTreeHelper.GetDpi(this).DpiScaleX);
+
-        foreach (var i in items) IconLoader.Load(i, px);
+    private void ToggleCollapsed()
-        Items.ItemsSource = items;
+    {
-        CountText.Text = items.Count.ToString();
+        _hoverExpanded = false;
-        EmptyText.Visibility = items.Count == 0 ? Visibility.Visible : Visibility.Collapsed;
+        Def.Collapsed = !Def.Collapsed;
-    }
+        ApplyBounds();
-
+        S.Save();
-    private List<IconItem> Selected => Items.SelectedItems.Cast<IconItem>().ToList();
+    }
-
+
-    private static void Open(string path)
+    /// <summary>Eingeklappte Box klappt beim Überfahren kurz auf; Chamäleon blendet ein/aus.</summary>
-    {
+    private void OnHover(bool inside)
-        try { Process.Start(new ProcessStartInfo(path) { UseShellExecute = true }); }
+    {
-        catch { }
+        _mouseInside = inside;
-    }
+        if (inside)
-
+        {
-    private void Items_MouseDoubleClick(object sender, MouseButtonEventArgs e)
+            _collapseTimer.Stop();
-    {
+            if (Def.Collapsed && !_hoverExpanded)
-        if (MainWindow.FindParent<ListBoxItem>(e.OriginalSource as DependencyObject)?.DataContext is IconItem i) Open(i.Path);
+            {
-    }
+                _hoverExpanded = true;
-
+                ApplyBounds();
-    private void Items_KeyDown(object sender, KeyEventArgs e)
+            }
-    {
+        }
-        var sel = Selected;
+        else if (_hoverExpanded) _collapseTimer.Start();
-        if (sel.Count == 0 || App.Win is not { } win) return;
+        ApplyChameleon();
-        switch (e.Key)
+    }
-        {
+
-            case Key.Enter: sel.ForEach(i => Open(i.Path)); e.Handled = true; break;
+    private void CollapseAfterHover()
-            case Key.Delete: win.DeleteIcons(sel); e.Handled = true; break;
+    {
-            case Key.F2 when sel.Count == 1: win.RenameIcon(sel[0]); e.Handled = true; break;
+        _hoverExpanded = false;
-        }
+        ApplyBounds();
-    }
+    }
-
+
-    private void Items_ContextMenuOpening(object sender, ContextMenuEventArgs e)
+    // =====================================================================
-    {
+    // Aussehen
-        var sel = Selected;
+    // =====================================================================
-        if (sel.Count == 0 || App.Win is not { } win) { e.Handled = true; return; }
+
-        ItemMenu.Items.Clear();
+    public void ApplyLook()
-        ItemMenu.Items.Add(MainWindow.MenuItem("Öffnen", "\uE8A7", () => sel.ForEach(i => Open(i.Path)), bold: true, gesture: "Enter"));
+    {
-        if (sel.Count == 1)
+        // Hintergrund: eigene Farbe oder Design-Farbe, mit eingestellter Deckkraft
-        {
+        var baseColor = Def.Background is { } hex && CategoryColors.Brush(hex) is SolidColorBrush custom
-            ItemMenu.Items.Add(MainWindow.MenuItem("Dateispeicherort öffnen", "\uED25", () =>
+            ? custom.Color
-                Process.Start("explorer.exe", $"/select,\"{sel[0].Path}\"")));
+            : ((SolidColorBrush)FindResource("FenceBrush")).Color;
-            ItemMenu.Items.Add(MainWindow.MenuItem("Umbenennen", "\uE70F", () => win.RenameIcon(sel[0]), gesture: "F2"));
+        double opacity = Math.Clamp(Def.Opacity, 0.2, 1);
-        }
+        if (Def.Blur) opacity = Math.Min(opacity, 0.75); // sonst sieht man vom Milchglas nichts
-        ItemMenu.Items.Add(new Separator());
+        var bg = new SolidColorBrush(Color.FromArgb((byte)(opacity * 255), baseColor.R, baseColor.G, baseColor.B));
-
+        bg.Freeze();
-        var moveTo = MainWindow.MenuItem("Verschieben nach", "\uE8DE", null);
+        Root.Background = bg;
-        foreach (var c in Storage.Categories().Where(c => !string.Equals(c, Category, StringComparison.OrdinalIgnoreCase)))
+        Root.CornerRadius = new CornerRadius(Def.Blur ? 0 : 8); // Milchglas wirkt nur eckig sauber
-            moveTo.Items.Add(MainWindow.MenuItem(c, AppSettings.Current.Categories.GetValueOrDefault(c)?.Glyph ?? "\uF12B",
+
-                () => win.TransferAll(sel.Select(i => i.Path), Storage.CategoryPath(c))));
+        // Icon-Größe
-        if (moveTo.Items.Count > 0) ItemMenu.Items.Add(moveTo);
+        var (w, h, icon) = Def.IconSize switch
-        ItemMenu.Items.Add(MainWindow.MenuItem("Zurück auf den Desktop legen", "\uE7F4",
+        {
-            () => win.TransferAll(sel.Select(i => i.Path), Storage.UserDesktop)));
+            ViewMode.Small => (64.0, 66.0, 24.0),
-        ItemMenu.Items.Add(MainWindow.MenuItem("Löschen", "\uE74D", () => win.DeleteIcons(sel), gesture: "Entf"));
+            ViewMode.Large => (98.0, 104.0, 48.0),
-        ItemMenu.Items.Add(new Separator());
+            _ => (78.0, 80.0, 32.0),
-        ItemMenu.Items.Add(MainWindow.MenuItem("In DeskCore zeigen", "\uE8A7", ShowInApp));
+        };
-    }
+        Resources["FTileW"] = w;
-
+        Resources["FTileH"] = h;
-    private void MenuButton_Click(object sender, RoutedEventArgs e)
+        Resources["FIcon"] = icon;
-    {
+        Resources["FTint"] = CategoryColors.Brush(Def.Tint) ?? Brushes.Transparent;
-        FenceMenu.Items.Clear();
+
-        FenceMenu.Items.Add(MainWindow.MenuItem("In DeskCore öffnen", "", ShowInApp));
+        // Sperren: nicht verschieb-/vergrößerbar
-        FenceMenu.Items.Add(MainWindow.MenuItem(Meta.FenceCollapsed ? "Ausklappen" : "Einklappen",
+        Chrome.CaptionHeight = Def.Locked ? 0 : 36;
-            Meta.FenceCollapsed ? "" : "", ToggleCollapsed));
+        Chrome.ResizeBorderThickness = Def.Locked ? new Thickness(0) : new Thickness(6);
-        FenceMenu.Items.Add(new Separator());
+        LockGlyph.Visibility = Def.Locked ? Visibility.Visible : Visibility.Collapsed;
-        FenceMenu.Items.Add(MainWindow.MenuItem("Box ausblenden", "", () =>
+
-        {
+        if (IsLoaded) SetBlur(Def.Blur);
-            Meta.Fence = false;
+        ApplyChameleon();
-            AppSettings.Current.Save();
+    }
-            FenceManager.Sync();
+
-        }));
+    /// <summary>Chamäleon: Box ist fast unsichtbar, bis die Maus darüberfährt (nicht während Peek).</summary>
-        FenceMenu.PlacementTarget = MenuButton;
+    private void ApplyChameleon()
-        FenceMenu.IsOpen = true;
+    {
-    }
+        double target = S.FenceChameleon && !_mouseInside && !FenceManager.Peeking ? 0.08 : 1;
-
+        Root.BeginAnimation(OpacityProperty, new DoubleAnimation(target, TimeSpan.FromMilliseconds(target < 1 ? 600 : 150)));
-    private void ShowInApp() => App.Win?.ShowCategory(Category);
+    }
-
+
-    private Point _dragStart;
+    // =====================================================================
-    private bool _dragging;
+    // Inhalt & Tabs
-
+    // =====================================================================
-    private void Items_PreviewMouseLeftButtonDown(object sender, MouseButtonEventArgs e) => _dragStart = e.GetPosition(null);
+
-
+    private FenceTab? Tab => Def.Active;
-    private void Items_PreviewMouseMove(object sender, MouseEventArgs e)
+
-    {
+    /// <summary>Ordner des aktiven Tabs (bei Ordner-Portalen ggf. ein Unterordner).</summary>
-        if (e.LeftButton != MouseButtonState.Pressed || _dragging) return;
+    private string? CurrentFolder => Tab switch
-        var d = e.GetPosition(null) - _dragStart;
+    {
-        if (Math.Abs(d.X) < SystemParameters.MinimumHorizontalDragDistance &&
+        null => null,
-            Math.Abs(d.Y) < SystemParameters.MinimumVerticalDragDistance) return;
+        { IsFolder: true } t => _portalSub ?? t.Value,
-        if (MainWindow.FindParent<ListBoxItem>(e.OriginalSource as DependencyObject) is null) return;
+        { } t => Storage.CategoryPath(t.Value),
-        var paths = Selected.Select(i => i.Path).ToArray();
+    };
-        if (paths.Length == 0) return;
+
-        _dragging = true;
+    public void Refresh()
-        try
+    {
-        {
+        ApplyLook();
-            // nur "Kopieren" erlauben: der Explorer soll die Datei nicht aus der Kategorie entfernen.
+        BuildTabs();
-            // In eine andere Box/Kategorie gezogen, verschiebt DeskCore selbst.
+
-            DragDrop.DoDragDrop(Items, new DataObject(DataFormats.FileDrop, paths), DragDropEffects.Copy);
+        var tab = Tab;
-        }
+        var folder = CurrentFolder;
-        finally { _dragging = false; }
+        bool portal = tab?.IsFolder == true;
-    }
+        PortalBar.Visibility = portal && _portalSub is not null ? Visibility.Visible : Visibility.Collapsed;
-
+        if (portal && _portalSub is not null) PortalPath.Text = Path.GetRelativePath(tab!.Value, _portalSub);
-    private void Items_DragOver(object sender, DragEventArgs e)
+        WatchPortal(portal ? folder : null);
-    {
+
-        e.Effects = e.Data.GetDataPresent(DataFormats.FileDrop) && !_dragging
+        List<IconItem> items = [];
-            ? (e.AllowedEffects.HasFlag(DragDropEffects.Copy) ? DragDropEffects.Copy : DragDropEffects.Move)
+        if (folder is not null && Directory.Exists(folder))
-            : DragDropEffects.None;
+            items = (portal ? PortalEntries(folder) : Storage.Entries(folder)).Select(p => new IconItem { Path = p }).ToList();
-        e.Handled = true;
+        items = Sort(items);
-    }
+
-
+        int px = (int)Math.Round((double)Resources["FIcon"] * VisualTreeHelper.GetDpi(this).DpiScaleX);
-    private void Items_Drop(object sender, DragEventArgs e)
+        foreach (var i in items) IconLoader.Load(i, px);
-    {
+        Items.ItemsSource = items;
-        if (!_dragging && e.Data.GetData(DataFormats.FileDrop) is string[] files)
+        CountText.Text = items.Count.ToString();
-            App.Win?.TransferAll(files, Storage.CategoryPath(Category));
+        EmptyText.Text = folder is not null && !Directory.Exists(folder) ? "Ordner nicht gefunden" : "Leer – Icons hierher ziehen";
-    }
+        EmptyText.Visibility = items.Count == 0 ? Visibility.Visible : Visibility.Collapsed;
-
+    }
-    // ---------- Auf dem Desktop festhalten ----------
+
-
+    /// <summary>Ordner-Portal zeigt alles außer versteckten/System-Dateien.</summary>
-    private void PinToDesktop()
+    private static IEnumerable<string> PortalEntries(string dir) => Storage.Entries(dir);
-    {
+
-        var hwnd = new WindowInteropHelper(this).Handle;
+    private List<IconItem> Sort(List<IconItem> items)
-        // Besitzer = Desktop (Progman): bleibt bei Win+D sichtbar und liegt über den Desktop-Icons
+    {
-        var progman = FindWindow("Progman", null);
+        var folders = items.Where(i => Directory.Exists(i.Path));
-        if (progman != IntPtr.Zero) SetWindowLongPtr(hwnd, GWLP_HWNDPARENT, progman);
+        var files = items.Where(i => !Directory.Exists(i.Path));
-        // Nicht in Alt+Tab
+        IEnumerable<IconItem> Order(IEnumerable<IconItem> x) => Def.Sort switch
-        var ex = GetWindowLongPtr(hwnd, GWL_EXSTYLE).ToInt64();
+        {
-        SetWindowLongPtr(hwnd, GWL_EXSTYLE, new IntPtr((ex | WS_EX_TOOLWINDOW) & ~WS_EX_APPWINDOW));
+            "Typ" => x.OrderBy(i => Path.GetExtension(i.Path), StringComparer.OrdinalIgnoreCase).ThenBy(i => i.Name, StringComparer.CurrentCultureIgnoreCase),
-        HwndSource.FromHwnd(hwnd).AddHook(Hook);
+            "Datum" => x.OrderByDescending(i => { try { return File.GetLastWriteTime(i.Path); } catch { return DateTime.MinValue; } }),
-        SetWindowPos(hwnd, HWND_BOTTOM, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
+            _ => x.OrderBy(i => i.Name, StringComparer.CurrentCultureIgnoreCase),
-    }
+        };
-
+        return Order(folders).Concat(Order(files)).ToList();
-    private IntPtr Hook(IntPtr hwnd, int msg, IntPtr wParam, IntPtr lParam, ref bool handled)
+    }
-    {
+
-        switch (msg)
+    private void BuildTabs()
-        {
+    {
-            case WM_WINDOWPOSCHANGING:
+        TabStrip.Children.Clear();
-                // immer ganz unten bleiben, nie über anderen Fenstern
+        for (int i = 0; i < Def.Tabs.Count; i++)
-                var wp = Marshal.PtrToStructure<WINDOWPOS>(lParam);
+        {
-                wp.hwndInsertAfter = HWND_BOTTOM;
+            var t = Def.Tabs[i];
-                wp.flags &= ~SWP_NOZORDER;
+            bool active = i == Math.Clamp(Def.ActiveTab, 0, Def.Tabs.Count - 1);
-                Marshal.StructureToPtr(wp, lParam, false);
+            var meta = t.IsFolder ? null : S.Categories.GetValueOrDefault(t.Value);
-                break;
+            var glyph = new TextBlock
-            case WM_NCLBUTTONDBLCLK:
+            {
-                ToggleCollapsed();
+                Text = t.IsFolder ? "" : meta?.Glyph ?? "",
-                handled = true;
+                FontFamily = (FontFamily)FindResource("IconFont"), FontSize = 13, VerticalAlignment = VerticalAlignment.Center,
-                break;
+                Margin = new Thickness(0, 0, 7, 0),
-            case WM_SYSCOMMAND when (wParam.ToInt32() & 0xFFF0) == SC_MAXIMIZE:
+                Foreground = CategoryColors.Brush(meta?.Color) ?? (Brush)FindResource(t.IsFolder ? "AccentBrush" : "TextBrush"),
-                handled = true;
+            };
-                break;
+            var label = new TextBlock
-        }
+            {
-        return IntPtr.Zero;
+                Text = t.Title, VerticalAlignment = VerticalAlignment.Center, TextTrimming = TextTrimming.CharacterEllipsis,
-    }
+                FontSize = 13, MaxWidth = Def.Tabs.Count == 1 ? 220 : 120,
-
+                FontWeight = active ? FontWeights.SemiBold : FontWeights.Normal,
-    private const int GWL_EXSTYLE = -20, GWLP_HWNDPARENT = -8;
+                Foreground = (Brush)FindResource(active ? "TextBrush" : "TextSecondaryBrush"),
-    private const long WS_EX_TOOLWINDOW = 0x80, WS_EX_APPWINDOW = 0x40000;
+            };
-    private const int WM_WINDOWPOSCHANGING = 0x46, WM_NCLBUTTONDBLCLK = 0xA3, WM_SYSCOMMAND = 0x112, SC_MAXIMIZE = 0xF030;
+            var content = new StackPanel { Orientation = Orientation.Horizontal, Children = { glyph, label } };
-    private const uint SWP_NOSIZE = 0x1, SWP_NOMOVE = 0x2, SWP_NOZORDER = 0x4, SWP_NOACTIVATE = 0x10;
+            var underline = new Border
-    private static readonly IntPtr HWND_BOTTOM = new(1);
+            {
-
+                Height = 2, CornerRadius = new CornerRadius(1), Margin = new Thickness(4, 0, 4, 0), VerticalAlignment = VerticalAlignment.Bottom,
-    [StructLayout(LayoutKind.Sequential)]
+                Background = active && Def.Tabs.Count > 1 ? (Brush)FindResource("AccentBrush") : Brushes.Transparent,
-    private struct WINDOWPOS
+            };
-    {
+            var btn = new Button
-        public IntPtr hwnd, hwndInsertAfter;
+            {
-        public int x, y, cx, cy;
+                Style = (Style)FindResource("SubtleButton"), Padding = new Thickness(6, 4, 6, 4), MinHeight = 0, Tag = i,
-        public uint flags;
+                Content = new Grid { Children = { content, underline } }, Margin = new Thickness(0, 0, 2, 0),
-    }
+                ToolTip = t.IsFolder ? t.Value : $"Kategorie „{t.Value}“",
-
+            };
-    [DllImport("user32.dll", CharSet = CharSet.Unicode)] private static extern IntPtr FindWindow(string? cls, string? title);
+            WindowChrome.SetIsHitTestVisibleInChrome(btn, Def.Tabs.Count > 1); // bei nur einem Tab: Titel = Ziehfläche
-    [DllImport("user32.dll")] private static extern IntPtr GetWindowLongPtr(IntPtr h, int i);
+            btn.Click += (_, _) => SwitchTab((int)btn.Tag);
-    [DllImport("user32.dll")] private static extern IntPtr SetWindowLongPtr(IntPtr h, int i, IntPtr v);
+            btn.MouseRightButtonUp += (_, ev) => { ShowTabMenu((int)btn.Tag); ev.Handled = true; };
-    [DllImport("user32.dll")] private static extern bool SetWindowPos(IntPtr h, IntPtr after, int x, int y, int cx, int cy, uint flags);
+            TabStrip.Children.Add(btn);
-}
+        }
-
+    }
-/// <summary>Hält die Desktop-Boxen passend zu den Einstellungen.</summary>
+
-public static class FenceManager
+    private void SwitchTab(int index)
-{
+    {
-    private static readonly List<FenceWindow> _open = [];
+        if (index == Def.ActiveTab) return;
-
+        Def.ActiveTab = index;
-    public static void Sync()
+        _portalSub = null;
-    {
+        S.Save();
-        var s = AppSettings.Current;
+        Refresh();
-        var wanted = s.FencesEnabled
+    }
-            ? Storage.Categories().Where(c => s.Categories.GetValueOrDefault(c)?.Fence == true).ToList()
+
-            : [];
+    // ---------- Ordner-Portal ----------
-
+
-        foreach (var f in _open.Where(f => !wanted.Contains(f.Category, StringComparer.OrdinalIgnoreCase)).ToList())
+    private void WatchPortal(string? folder)
-        {
+    {
-            f.Close();
+        if (string.Equals(_portalWatcher?.Path, folder, StringComparison.OrdinalIgnoreCase)) return;
-            _open.Remove(f);
+        _portalWatcher?.Dispose();
-        }
+        _portalWatcher = null;
-
+        if (folder is null || !Directory.Exists(folder)) return;
-        var wa = SystemParameters.WorkArea;
+        _portalRefresh ??= new DispatcherTimer(TimeSpan.FromMilliseconds(400), DispatcherPriority.Background, (_, _) =>
-        foreach (var c in wanted)
+        {
-        {
+            _portalRefresh!.Stop();
-            var f = _open.FirstOrDefault(x => string.Equals(x.Category, c, StringComparison.OrdinalIgnoreCase));
+            Refresh();
-            if (f is not null) { f.Refresh(); continue; }
+        }, Dispatcher);
-
+        try
-            // Neue Box: neben die vorhandenen setzen
+        {
-            var meta = s.Meta(c);
+            _portalWatcher = new FileSystemWatcher(folder)
-            if (meta.FenceX is null)
+            {
-            {
+                NotifyFilter = NotifyFilters.FileName | NotifyFilters.DirectoryName | NotifyFilters.LastWrite,
-                // oben rechts beginnen – links liegen meist die Desktop-Icons
+                EnableRaisingEvents = true,
-                int perRow = Math.Max(1, (int)((wa.Width - 48) / (meta.FenceW + 16)));
+            };
-                int i = _open.Count;
+            FileSystemEventHandler poke = (_, _) => Dispatcher.BeginInvoke(() => { _portalRefresh.Stop(); _portalRefresh.Start(); });
-                meta.FenceX = wa.Right - 24 - meta.FenceW - (i % perRow) * (meta.FenceW + 16);
+            _portalWatcher.Created += poke;
-                meta.FenceY = wa.Top + 24 + (i / perRow) * (meta.FenceH + 16);
+            _portalWatcher.Deleted += poke;
-            }
+            _portalWatcher.Renamed += (s, e) => poke(s, e);
-            f = new FenceWindow(c);
+        }
-            _open.Add(f);
+        catch { }
-            f.Show();
+    }
-        }
+
-    }
+    private void PortalUp_Click(object sender, RoutedEventArgs e)
-
+    {
-    public static void RefreshAll()
+        if (Tab is not { IsFolder: true } t || _portalSub is null) return;
-    {
+        var parent = Path.GetDirectoryName(_portalSub.TrimEnd('\\'));
-        foreach (var f in _open) f.Refresh();
+        _portalSub = parent is null || Storage.SamePath(parent, t.Value) || !Storage.IsUnder(parent, t.Value) ? null : parent;
-    }
+        Refresh();
-
+    }
-    public static void EnsureOnScreen()
+
-    {
+    // =====================================================================
-        foreach (var f in _open) f.EnsureOnScreen();
+    // Icons
-    }
+    // =====================================================================
-
+
-    public static void Renamed(string oldName, string newName)
+    private List<IconItem> Selected => Items.SelectedItems.Cast<IconItem>().ToList();
-    {
+
-        _open.FirstOrDefault(x => string.Equals(x.Category, oldName, StringComparison.OrdinalIgnoreCase))?.Rename(newName);
+    private void Open(IconItem i)
-    }
+    {
-
+        // Im Ordner-Portal öffnen Ordner sich innerhalb der Box
-    public static void CloseAll()
+        if (Tab?.IsFolder == true && Directory.Exists(i.Path) && !i.Path.EndsWith(".lnk", StringComparison.OrdinalIgnoreCase))
-    {
+        {
-        foreach (var f in _open) f.Close();
+            _portalSub = i.Path;
-        _open.Clear();
+            Refresh();
-    }
+            return;
-}
+        }
+        try { Process.Start(new ProcessStartInfo(i.Path) { UseShellExecute = true }); }
+        catch { }
+    }
+
+    private void Items_MouseDoubleClick(object sender, MouseButtonEventArgs e)
+    {
+        if (MainWindow.FindParent<ListBoxItem>(e.OriginalSource as DependencyObject)?.DataContext is IconItem i) Open(i);
+    }
+
+    private void Items_KeyDown(object sender, KeyEventArgs e)
+    {
+        if (e.Key == Key.Escape && FenceManager.Peeking) { FenceManager.EndPeek(); e.Handled = true; return; }
+        var sel = Selected;
+        if (sel.Count == 0 || App.Win is not { } win) return;
+        switch (e.Key)
+        {
+            case Key.Enter: sel.ForEach(Open); e.Handled = true; break;
+            case Key.Delete: win.DeleteIcons(sel); e.Handled = true; break;
+            case Key.F2 when sel.Count == 1: win.RenameIcon(sel[0]); e.Handled = true; break;
+            case Key.Back when _portalSub is not null: PortalUp_Click(this, e); e.Handled = true; break;
+        }
+    }
+
+    private void Items_ContextMenuOpening(object sender, ContextMenuEventArgs e)
+    {
+        var sel = Selected;
+        if (sel.Count == 0 || App.Win is not { } win) { e.Handled = true; return; }
+        ItemMenu.Items.Clear();
+        ItemMenu.Items.Add(MainWindow.MenuItem("Öffnen", "", () => sel.ForEach(Open), bold: true, gesture: "Enter"));
+        if (sel.Count == 1)
+        {
+            ItemMenu.Items.Add(MainWindow.MenuItem("Dateispeicherort öffnen", "", () =>
+                Process.Start("explorer.exe", $"/select,\"{sel[0].Path}\"")));
+            ItemMenu.Items.Add(MainWindow.MenuItem("Umbenennen", "", () => win.RenameIcon(sel[0]), gesture: "F2"));
+        }
+        ItemMenu.Items.Add(new Separator());
+
+        bool inStorage = sel.All(i => Storage.IsInStorage(i.Path));
+        var moveTo = MainWindow.MenuItem(inStorage ? "Verschieben nach" : "Sichern in", inStorage ? "" : "", null);
+        var ownCategory = Tab is { IsFolder: false } t ? t.Value : null;
+        foreach (var c in Storage.Categories().Where(c => !string.Equals(c, ownCategory, StringComparison.OrdinalIgnoreCase)))
+            moveTo.Items.Add(MainWindow.MenuItem(c, S.Categories.GetValueOrDefault(c)?.Glyph ?? "",
+                () => win.TransferAll(sel.Select(i => i.Path), Storage.CategoryPath(c))));
+        if (moveTo.Items.Count > 0) ItemMenu.Items.Add(moveTo);
+        ItemMenu.Items.Add(win.LaunchGroupSubmenu(sel.Select(i => i.Path).ToList()));
+        if (inStorage)
+            ItemMenu.Items.Add(MainWindow.MenuItem("Zurück auf den Desktop legen", "",
+                () => win.TransferAll(sel.Select(i => i.Path), Storage.UserDesktop)));
+        ItemMenu.Items.Add(MainWindow.MenuItem("Löschen", "", () => win.DeleteIcons(sel), gesture: "Entf"));
+    }
+
+    // ---------- Ziehen ----------
+
+    private Point _dragStart;
+    private bool _dragging;
+
+    private void Items_PreviewMouseLeftButtonDown(object sender, MouseButtonEventArgs e) => _dragStart = e.GetPosition(null);
+
+    private void Items_PreviewMouseMove(object sender, MouseEventArgs e)
+    {
+        if (e.LeftButton != MouseButtonState.Pressed || _dragging) return;
+        var d = e.GetPosition(null) - _dragStart;
+        if (Math.Abs(d.X) < SystemParameters.MinimumHorizontalDragDistance &&
+            Math.Abs(d.Y) < SystemParameters.MinimumVerticalDragDistance) return;
+        if (MainWindow.FindParent<ListBoxItem>(e.OriginalSource as DependencyObject) is null) return;
+        var paths = Selected.Select(i => i.Path).ToArray();
+        if (paths.Length == 0) return;
+        _dragging = true;
+        try
+        {
+            // nur "Kopieren" erlauben: der Explorer soll die Datei nicht aus der Kategorie entfernen.
+            // In eine andere Box/Kategorie gezogen, verschiebt DeskCore selbst.
+            DragDrop.DoDragDrop(Items, new DataObject(DataFormats.FileDrop, paths), DragDropEffects.Copy | DragDropEffects.Link);
+        }
+        finally { _dragging = false; }
+    }
+
+    private void Items_DragOver(object sender, DragEventArgs e)
+    {
+        e.Effects = e.Data.GetDataPresent(DataFormats.FileDrop) && !_dragging && CurrentFolder is not null
+            ? (e.AllowedEffects.HasFlag(DragDropEffects.Copy) ? DragDropEffects.Copy : DragDropEffects.Move)
+            : DragDropEffects.None;
+        e.Handled = true;
+    }
+
+    private void Items_Drop(object sender, DragEventArgs e)
+    {
+        if (!_dragging && CurrentFolder is { } folder && e.Data.GetData(DataFormats.FileDrop) is string[] files)
+            App.Win?.TransferAll(files, folder);
+    }
+
+    // =====================================================================
+    // Menüs
+    // =====================================================================
+
+    private void TitleBar_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
+    {
+        // gesperrte Box: Titelleiste ist normale Fläche → Doppelklick selbst auswerten
+        if (e.ClickCount == 2) { ToggleCollapsed(); e.Handled = true; }
+    }
+
+    private void MenuButton_Click(object sender, RoutedEventArgs e)
+    {
+        FenceMenu.Items.Clear();
+        if (Tab is { IsFolder: false } t)
+            FenceMenu.Items.Add(MainWindow.MenuItem("In DeskCore öffnen", "", () => App.Win?.ShowCategory(t.Value)));
+        else if (Tab is { IsFolder: true } pt)
+            FenceMenu.Items.Add(MainWindow.MenuItem("Im Explorer öffnen", "", () => Process.Start("explorer.exe", $"\"{CurrentFolder ?? pt.Value}\"")));
+
+        // Tabs
+        var add = MainWindow.MenuItem("Tab hinzufügen", "", null);
+        foreach (var c in Storage.Categories().Where(c => !Def.Tabs.Any(x => !x.IsFolder && string.Equals(x.Value, c, StringComparison.OrdinalIgnoreCase))))
+            add.Items.Add(MainWindow.MenuItem(c, S.Categories.GetValueOrDefault(c)?.Glyph ?? "", () => AddTab(new FenceTab { Value = c })));
+        if (add.Items.Count > 0) add.Items.Add(new Separator());
+        add.Items.Add(MainWindow.MenuItem("Ordner-Portal…", "", () =>
+        {
+            if (FenceManager.PickFolder() is { } folder) AddTab(new FenceTab { Kind = FenceTab.FolderKind, Value = folder });
+        }));
+        FenceMenu.Items.Add(add);
+        if (Def.Tabs.Count > 1)
+            FenceMenu.Items.Add(MainWindow.MenuItem($"Tab „{Tab?.Title}“ entfernen", "", () => RemoveTab(Def.ActiveTab)));
+
+        FenceMenu.Items.Add(new Separator());
+        FenceMenu.Items.Add(MainWindow.MenuItem("Aussehen…", "", () => FenceManager.EditLook(this)));
+        FenceMenu.Items.Add(MainWindow.MenuItem(Def.Collapsed ? "Ausklappen" : "Einklappen",
+            Def.Collapsed ? "" : "", ToggleCollapsed));
+        FenceMenu.Items.Add(MainWindow.MenuItem(Def.Locked ? "Entsperren" : "Sperren (nicht mehr verschiebbar)",
+            Def.Locked ? "" : "", () => { Def.Locked = !Def.Locked; S.Save(); ApplyLook(); }));
+        if (S.Pages.Count > 1)
+        {
+            var move = MainWindow.MenuItem("Auf Seite verschieben", "\uE8AB", null);
+            for (int p = 0; p < S.Pages.Count; p++)
+            {
+                int page = p;
+                var mi = MainWindow.MenuItem(S.Pages[p], "\uE8A1", () => FenceManager.MoveToPage(Def, page));
+                mi.IsEnabled = page != Def.Page;
+                move.Items.Add(mi);
+            }
+            FenceMenu.Items.Add(move);
+        }
+        FenceMenu.Items.Add(new Separator());
+        FenceMenu.Items.Add(MainWindow.MenuItem("Box schließen", "", () => FenceManager.Remove(Def)));
+        FenceMenu.PlacementTarget = MenuButton;
+        FenceMenu.IsOpen = true;
+    }
+
+    private void ShowTabMenu(int index)
+    {
+        if (index < 0 || index >= Def.Tabs.Count) return;
+        var t = Def.Tabs[index];
+        var menu = new ContextMenu();
+        if (!t.IsFolder) menu.Items.Add(MainWindow.MenuItem("In DeskCore öffnen", "", () => App.Win?.ShowCategory(t.Value)));
+        else menu.Items.Add(MainWindow.MenuItem("Im Explorer öffnen", "", () => Process.Start("explorer.exe", $"\"{t.Value}\"")));
+        if (Def.Tabs.Count > 1)
+        {
+            menu.Items.Add(MainWindow.MenuItem("Als eigene Box lösen", "", () => FenceManager.DetachTab(Def, index)));
+            menu.Items.Add(MainWindow.MenuItem("Tab entfernen", "", () => RemoveTab(index)));
+        }
+        menu.IsOpen = true;
+    }
+
+    private void AddTab(FenceTab tab)
+    {
+        // Kategorie steckt schon in einer anderen Box? Dann dorthin verschieben statt doppelt anzeigen
+        if (!tab.IsFolder) FenceManager.RemoveCategoryTab(tab.Value, except: Def);
+        Def.Tabs.Add(tab);
+        Def.ActiveTab = Def.Tabs.Count - 1;
+        _portalSub = null;
+        S.Save();
+        FenceManager.Sync();
+        Refresh();
+    }
+
+    private void RemoveTab(int index)
+    {
+        if (index < 0 || index >= Def.Tabs.Count) return;
+        Def.Tabs.RemoveAt(index);
+        Def.ActiveTab = Math.Clamp(Def.ActiveTab, 0, Math.Max(0, Def.Tabs.Count - 1));
+        _portalSub = null;
+        S.Save();
+        if (Def.Tabs.Count == 0) FenceManager.Remove(Def);
+        else Refresh();
+    }
+
+    // =====================================================================
+    // Auf dem Desktop festhalten, Peek, Milchglas
+    // =====================================================================
+
+    private IntPtr Hwnd => new WindowInteropHelper(this).Handle;
+
+    private void PinToDesktop()
+    {
+        var hwnd = Hwnd;
+        // Besitzer = Desktop (Progman): bleibt bei Win+D sichtbar und liegt über den Desktop-Icons
+        var progman = FindWindow("Progman", null);
+        if (progman != IntPtr.Zero) SetWindowLongPtr(hwnd, GWLP_HWNDPARENT, progman);
+        // Nicht in Alt+Tab
+        var ex = GetWindowLongPtr(hwnd, GWL_EXSTYLE).ToInt64();
+        SetWindowLongPtr(hwnd, GWL_EXSTYLE, new IntPtr((ex | WS_EX_TOOLWINDOW) & ~WS_EX_APPWINDOW));
+        HwndSource.FromHwnd(hwnd).AddHook(Hook);
+        SetWindowPos(hwnd, HWND_BOTTOM, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
+        SetBlur(Def.Blur);
+    }
+
+    /// <summary>Peek: Box vor alle Fenster holen bzw. wieder ganz nach hinten.</summary>
+    public void SetPeek(bool on)
+    {
+        var hwnd = Hwnd;
+        if (hwnd == IntPtr.Zero) return;
+        SetWindowPos(hwnd, on ? HWND_TOPMOST : HWND_NOTOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
+        if (!on) SetWindowPos(hwnd, HWND_BOTTOM, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
+        ApplyChameleon();
+    }
+
+    private IntPtr Hook(IntPtr hwnd, int msg, IntPtr wParam, IntPtr lParam, ref bool handled)
+    {
+        switch (msg)
+        {
+            case WM_WINDOWPOSCHANGING when !FenceManager.Peeking:
+                // immer ganz unten bleiben, nie über anderen Fenstern (außer während Peek)
+                var wp = Marshal.PtrToStructure<WINDOWPOS>(lParam);
+                wp.hwndInsertAfter = HWND_BOTTOM;
+                wp.flags &= ~SWP_NOZORDER;
+                Marshal.StructureToPtr(wp, lParam, false);
+                break;
+            case WM_NCLBUTTONDBLCLK:
+                ToggleCollapsed();
+                handled = true;
+                break;
+            case WM_SYSCOMMAND when (wParam.ToInt32() & 0xFFF0) == SC_MAXIMIZE:
+                handled = true;
+                break;
+        }
+        return IntPtr.Zero;
+    }
+
+    /// <summary>Milchglas (verschwommener Hintergrund) über die Windows-Composition-Schnittstelle.</summary>
+    private void SetBlur(bool on)
+    {
+        var hwnd = Hwnd;
+        if (hwnd == IntPtr.Zero) return;
+        var accent = new AccentPolicy { AccentState = on ? 3 : 0 }; // 3 = ACCENT_ENABLE_BLURBEHIND
+        int size = Marshal.SizeOf(accent);
+        var ptr = Marshal.AllocHGlobal(size);
+        try
+        {
+            Marshal.StructureToPtr(accent, ptr, false);
+            var data = new WindowCompositionAttributeData { Attribute = 19, Data = ptr, SizeOfData = size }; // 19 = WCA_ACCENT_POLICY
+            SetWindowCompositionAttribute(hwnd, ref data);
+        }
+        catch { }
+        finally { Marshal.FreeHGlobal(ptr); }
+    }
+
+    private const int GWL_EXSTYLE = -20, GWLP_HWNDPARENT = -8;
+    private const long WS_EX_TOOLWINDOW = 0x80, WS_EX_APPWINDOW = 0x40000;
+    private const int WM_WINDOWPOSCHANGING = 0x46, WM_NCLBUTTONDBLCLK = 0xA3, WM_SYSCOMMAND = 0x112, SC_MAXIMIZE = 0xF030;
+    private const uint SWP_NOSIZE = 0x1, SWP_NOMOVE = 0x2, SWP_NOZORDER = 0x4, SWP_NOACTIVATE = 0x10;
+    private static readonly IntPtr HWND_BOTTOM = new(1), HWND_TOPMOST = new(-1), HWND_NOTOPMOST = new(-2);
+
+    [StructLayout(LayoutKind.Sequential)]
+    private struct WINDOWPOS
+    {
+        public IntPtr hwnd, hwndInsertAfter;
+        public int x, y, cx, cy;
+        public uint flags;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    private struct AccentPolicy
+    {
+        public int AccentState, AccentFlags, GradientColor, AnimationId;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    private struct WindowCompositionAttributeData
+    {
+        public int Attribute;
+        public IntPtr Data;
+        public int SizeOfData;
+    }
+
+    [DllImport("user32.dll", CharSet = CharSet.Unicode)] private static extern IntPtr FindWindow(string? cls, string? title);
+    [DllImport("user32.dll")] private static extern IntPtr GetWindowLongPtr(IntPtr h, int i);
+    [DllImport("user32.dll")] private static extern IntPtr SetWindowLongPtr(IntPtr h, int i, IntPtr v);
+    [DllImport("user32.dll")] private static extern bool SetWindowPos(IntPtr h, IntPtr after, int x, int y, int cx, int cy, uint flags);
+    [DllImport("user32.dll")] private static extern int SetWindowCompositionAttribute(IntPtr hwnd, ref WindowCompositionAttributeData data);
+}

GameLibraries.cs

@@ -0,0 +1,101 @@
+using System.IO;
+using System.Text.Json;
+using System.Text.RegularExpressions;
+using Microsoft.Win32;
+
+namespace DeskCore;
+
+/// <summary>
+/// Erkennt, ob ein Spiel aus einem Steam- oder Epic-Link (.url) noch installiert ist.
+/// Ergebnis null = "weiß ich nicht" → DeskCore lässt den Link dann sicherheitshalber stehen.
+/// </summary>
+public static class GameLibraries
+{
+    private static readonly Regex SteamRun = new(@"^steam://(?:rungameid|run|launch)/(\d+)", RegexOptions.IgnoreCase);
+    private const string EpicPrefix = "com.epicgames.launcher://apps/";
+
+    /// <summary>Ist das Spiel hinter diesem Launcher-Link noch installiert? (null = nicht feststellbar)</summary>
+    public static bool? IsInstalled(string url)
+    {
+        url = url.Trim();
+        var m = SteamRun.Match(url);
+        if (m.Success) return SteamAppInstalled(m.Groups[1].Value);
+        if (url.StartsWith(EpicPrefix, StringComparison.OrdinalIgnoreCase)) return EpicAppInstalled(url);
+        return null;
+    }
+
+    // ---------- Steam ----------
+
+    private static (DateTime When, List<string>? Libraries) _steamCache;
+
+    /// <summary>Alle Steam-Bibliotheksordner – oder null, wenn Steam fehlt bzw. eine Bibliothek gerade nicht erreichbar ist.</summary>
+    private static List<string>? SteamLibraries()
+    {
+        if (DateTime.UtcNow - _steamCache.When < TimeSpan.FromSeconds(30)) return _steamCache.Libraries;
+        List<string>? result = null;
+        try
+        {
+            using var k = Registry.CurrentUser.OpenSubKey(@"Software\Valve\Steam");
+            if (k?.GetValue("SteamPath") is string sp && sp.Length > 0)
+            {
+                var steamPath = Path.GetFullPath(sp.Replace('/', '\\'));
+                var libs = new List<string> { steamPath };
+                var vdf = Path.Combine(steamPath, "steamapps", "libraryfolders.vdf");
+                if (File.Exists(vdf))
+                {
+                    foreach (Match lm in Regex.Matches(File.ReadAllText(vdf), "\"path\"\\s+\"([^\"]+)\""))
+                        libs.Add(Path.GetFullPath(lm.Groups[1].Value.Replace(@"\\", @"\")));
+                }
+                libs = libs.Distinct(StringComparer.OrdinalIgnoreCase).ToList();
+                // Liegt eine Bibliothek auf einem abgesteckten Laufwerk, könnte das Spiel dort sein → nichts entscheiden
+                result = libs.All(l => Directory.Exists(Path.Combine(l, "steamapps"))) ? libs : null;
+            }
+        }
+        catch { result = null; }
+        _steamCache = (DateTime.UtcNow, result);
+        return result;
+    }
+
+    private static bool? SteamAppInstalled(string appId)
+    {
+        var libs = SteamLibraries();
+        if (libs is null) return null;
+        return libs.Any(l => File.Exists(Path.Combine(l, "steamapps", $"appmanifest_{appId}.acf")));
+    }
+
+    // ---------- Epic Games ----------
+
+    private static bool? EpicAppInstalled(string url)
+    {
+        // Format: com.epicgames.launcher://apps/<namespace>%3A<katalog>%3A<AppName>?action=launch
+        //    oder com.epicgames.launcher://apps/<AppName>?action=launch
+        var rest = url[EpicPrefix.Length..];
+        var q = rest.IndexOf('?');
+        if (q >= 0) rest = rest[..q];
+        var appName = Uri.UnescapeDataString(rest).Split(':').Last().Trim();
+        if (appName.Length == 0) return null;
+
+        var manifests = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData),
+            "Epic", "EpicGamesLauncher", "Data", "Manifests");
+        if (!Directory.Exists(manifests)) return null; // Epic-Launcher nicht (mehr) vorhanden → nicht entscheiden
+        try
+        {
+            foreach (var f in Directory.EnumerateFiles(manifests, "*.item"))
+            {
+                using var doc = JsonDocument.Parse(File.ReadAllText(f));
+                var root = doc.RootElement;
+                if (!root.TryGetProperty("AppName", out var an) ||
+                    !string.Equals(an.GetString(), appName, StringComparison.OrdinalIgnoreCase)) continue;
+                // Installationsort auf abgestecktem Laufwerk? → nicht entscheiden
+                if (root.TryGetProperty("InstallLocation", out var loc) && loc.GetString() is { Length: > 0 } dir)
+                {
+                    var drive = new DriveInfo(Path.GetPathRoot(dir)!);
+                    if (!drive.IsReady) return null;
+                }
+                return true;
+            }
+            return false;
+        }
+        catch { return null; }
+    }
+}

Hotkey.cs

@@ -1,138 +1,140 @@
-using System.Runtime.InteropServices;
+using System.Runtime.InteropServices;
-using System.Windows.Input;
+using System.Windows.Input;
-using System.Windows.Interop;
+using System.Windows.Interop;
-using Microsoft.Win32;
+using Microsoft.Win32;
-
+
-namespace DeskCore;
+namespace DeskCore;
-
+
-/// <summary>Systemweites Tastenkürzel (RegisterHotKey).</summary>
+/// <summary>Systemweites Tastenkürzel (RegisterHotKey).</summary>
-public sealed class Hotkey : IDisposable
+public sealed class Hotkey : IDisposable
-{
+{
-    public const int ModAlt = 0x1, ModCtrl = 0x2, ModShift = 0x4, ModWin = 0x8;
+    public const int ModAlt = 0x1, ModCtrl = 0x2, ModShift = 0x4, ModWin = 0x8;
-    private const int ModNoRepeat = 0x4000, WmHotkey = 0x0312, Id = 0xB001;
+    private const int ModNoRepeat = 0x4000, WmHotkey = 0x0312;
-
+    private readonly int Id;
-    private readonly IntPtr _hwnd;
+
-    private readonly HwndSource _source;
+    private readonly IntPtr _hwnd;
-    private bool _registered;
+    private readonly HwndSource _source;
-
+    private bool _registered;
-    public event Action? Pressed;
+
-
+    public event Action? Pressed;
-    public Hotkey(IntPtr hwnd)
+
-    {
+    public Hotkey(IntPtr hwnd, int id = 0xB001)
-        _hwnd = hwnd;
+    {
-        _source = HwndSource.FromHwnd(hwnd);
+        Id = id;
-        _source.AddHook(Hook);
+        _hwnd = hwnd;
-    }
+        _source = HwndSource.FromHwnd(hwnd);
-
+        _source.AddHook(Hook);
-    /// <summary>Registriert das Kürzel. false = schon von einem anderen Programm belegt.</summary>
+    }
-    public bool Register(int modifiers, int vk)
+
-    {
+    /// <summary>Registriert das Kürzel. false = schon von einem anderen Programm belegt.</summary>
-        Unregister();
+    public bool Register(int modifiers, int vk)
-        if (vk == 0) return false;
+    {
-        _registered = RegisterHotKey(_hwnd, Id, modifiers | ModNoRepeat, vk);
+        Unregister();
-        return _registered;
+        if (vk == 0) return false;
-    }
+        _registered = RegisterHotKey(_hwnd, Id, modifiers | ModNoRepeat, vk);
-
+        return _registered;
-    public void Unregister()
+    }
-    {
+
-        if (_registered) UnregisterHotKey(_hwnd, Id);
+    public void Unregister()
-        _registered = false;
+    {
-    }
+        if (_registered) UnregisterHotKey(_hwnd, Id);
-
+        _registered = false;
-    private IntPtr Hook(IntPtr hwnd, int msg, IntPtr wParam, IntPtr lParam, ref bool handled)
+    }
-    {
+
-        if (msg == WmHotkey && wParam.ToInt32() == Id)
+    private IntPtr Hook(IntPtr hwnd, int msg, IntPtr wParam, IntPtr lParam, ref bool handled)
-        {
+    {
-            Pressed?.Invoke();
+        if (msg == WmHotkey && wParam.ToInt32() == Id)
-            handled = true;
+        {
-        }
+            Pressed?.Invoke();
-        return IntPtr.Zero;
+            handled = true;
-    }
+        }
-
+        return IntPtr.Zero;
-    public static string Describe(int modifiers, int vk)
+    }
-    {
+
-        if (vk == 0) return "–";
+    public static string Describe(int modifiers, int vk)
-        var parts = new List<string>();
+    {
-        if ((modifiers & ModWin) != 0) parts.Add("Win");
+        if (vk == 0) return "–";
-        if ((modifiers & ModCtrl) != 0) parts.Add("Strg");
+        var parts = new List<string>();
-        if ((modifiers & ModAlt) != 0) parts.Add("Alt");
+        if ((modifiers & ModWin) != 0) parts.Add("Win");
-        if ((modifiers & ModShift) != 0) parts.Add("Umschalt");
+        if ((modifiers & ModCtrl) != 0) parts.Add("Strg");
-        var key = KeyInterop.KeyFromVirtualKey(vk);
+        if ((modifiers & ModAlt) != 0) parts.Add("Alt");
-        parts.Add(key switch
+        if ((modifiers & ModShift) != 0) parts.Add("Umschalt");
-        {
+        var key = KeyInterop.KeyFromVirtualKey(vk);
-            >= Key.D0 and <= Key.D9 => ((char)('0' + (key - Key.D0))).ToString(),
+        parts.Add(key switch
-            Key.Space => "Leertaste",
+        {
-            _ => key.ToString(),
+            >= Key.D0 and <= Key.D9 => ((char)('0' + (key - Key.D0))).ToString(),
-        });
+            Key.Space => "Leertaste",
-        return string.Join(" + ", parts);
+            _ => key.ToString(),
-    }
+        });
-
+        return string.Join(" + ", parts);
-    public void Dispose()
+    }
-    {
+
-        Unregister();
+    public void Dispose()
-        _source.RemoveHook(Hook);
+    {
-    }
+        Unregister();
-
+        _source.RemoveHook(Hook);
-    [DllImport("user32.dll")] private static extern bool RegisterHotKey(IntPtr hWnd, int id, int fsModifiers, int vk);
+    }
-    [DllImport("user32.dll")] private static extern bool UnregisterHotKey(IntPtr hWnd, int id);
+
-}
+    [DllImport("user32.dll")] private static extern bool RegisterHotKey(IntPtr hWnd, int id, int fsModifiers, int vk);
-
+    [DllImport("user32.dll")] private static extern bool UnregisterHotKey(IntPtr hWnd, int id);
-/// <summary>Start mit Windows über HKCU\...\Run.</summary>
+}
-public static class Autostart
+
-{
+/// <summary>Start mit Windows über HKCU\...\Run.</summary>
-    private const string Key = @"Software\Microsoft\Windows\CurrentVersion\Run";
+public static class Autostart
-    private const string Name = "DeskCore";
+{
-    // Frühere Namen dieser App. "DeskHub" heißt auch ein anderes Programm → nur übernehmen, wenn der Eintrag eindeutig von uns ist.
+    private const string Key = @"Software\Microsoft\Windows\CurrentVersion\Run";
-    private static readonly string[] OldNames = ["DesktopSortierer", "DeskHub"];
+    private const string Name = "DeskCore";
-
+    // Frühere Namen dieser App. "DeskHub" heißt auch ein anderes Programm → nur übernehmen, wenn der Eintrag eindeutig von uns ist.
-    public static bool Enabled
+    private static readonly string[] OldNames = ["DesktopSortierer", "DeskHub"];
-    {
+
-        get
+    public static bool Enabled
-        {
+    {
-            try
+        get
-            {
+        {
-                using var k = Registry.CurrentUser.OpenSubKey(Key);
+            try
-                return k?.GetValue(Name) is string;
+            {
-            }
+                using var k = Registry.CurrentUser.OpenSubKey(Key);
-            catch { return false; }
+                return k?.GetValue(Name) is string;
-        }
+            }
-        set
+            catch { return false; }
-        {
+        }
-            try
+        set
-            {
+        {
-                using var k = Registry.CurrentUser.OpenSubKey(Key, writable: true) ?? Registry.CurrentUser.CreateSubKey(Key);
+            try
-                if (value) k.SetValue(Name, $"\"{Environment.ProcessPath}\" --minimized");
+            {
-                else k.DeleteValue(Name, throwOnMissingValue: false);
+                using var k = Registry.CurrentUser.OpenSubKey(Key, writable: true) ?? Registry.CurrentUser.CreateSubKey(Key);
-            }
+                if (value) k.SetValue(Name, $"\"{Environment.ProcessPath}\" --minimized");
-            catch { }
+                else k.DeleteValue(Name, throwOnMissingValue: false);
-        }
+            }
-    }
+            catch { }
-
+        }
-    /// <summary>Alten Autostart-Eintrag ("DesktopSortierer") auf den neuen Namen umstellen.</summary>
+    }
-    public static void Migrate()
+
-    {
+    /// <summary>Alten Autostart-Eintrag ("DesktopSortierer") auf den neuen Namen umstellen.</summary>
-        try
+    public static void Migrate()
-        {
+    {
-            using var k = Registry.CurrentUser.OpenSubKey(Key, writable: true);
+        try
-            if (k is null) return;
+        {
-            bool wasEnabled = false;
+            using var k = Registry.CurrentUser.OpenSubKey(Key, writable: true);
-            foreach (var old in OldNames)
+            if (k is null) return;
-            {
+            bool wasEnabled = false;
-                if (k.GetValue(old) is not string cmd) continue;
+            foreach (var old in OldNames)
-                bool ours = old == "DesktopSortierer" ||
+            {
-                            (cmd.Contains($"{old}.exe", StringComparison.OrdinalIgnoreCase) && cmd.Contains("--minimized"));
+                if (k.GetValue(old) is not string cmd) continue;
-                if (!ours) continue;
+                bool ours = old == "DesktopSortierer" ||
-                k.DeleteValue(old, throwOnMissingValue: false);
+                            (cmd.Contains($"{old}.exe", StringComparison.OrdinalIgnoreCase) && cmd.Contains("--minimized"));
-                wasEnabled = true;
+                if (!ours) continue;
-            }
+                k.DeleteValue(old, throwOnMissingValue: false);
-            if (wasEnabled) Enabled = true;
+                wasEnabled = true;
-        }
+            }
-        catch { }
+            if (wasEnabled) Enabled = true;
-    }
+        }
-
+        catch { }
-    /// <summary>Falls die exe verschoben wurde: Pfad im Autostart aktualisieren.</summary>
+    }
-    public static void RefreshPath()
+
-    {
+    /// <summary>Falls die exe verschoben wurde: Pfad im Autostart aktualisieren.</summary>
-        if (Enabled) Enabled = true;
+    public static void RefreshPath()
-    }
+    {
-}
+        if (Enabled) Enabled = true;
+    }
+}

MainWindow.Cleanup.cs

@@ -0,0 +1,114 @@
+using System.IO;
+using System.Windows;
+using System.Windows.Threading;
+
+namespace DeskCore;
+
+/// <summary>Verknüpfungen zu deinstallierten Programmen automatisch aus den Kategorien entfernen.</summary>
+public partial class MainWindow
+{
+    private DispatcherTimer? _deadScanTimer;
+    private DispatcherTimer? _deadScanPeriodic;
+    private bool _deadScanRunning;
+    private DispatcherTimer? _deadConfirmTimer;
+    private readonly Dictionary<string, DateTime> _deadSince = new(StringComparer.OrdinalIgnoreCase);
+    private static readonly TimeSpan ConfirmAfter = TimeSpan.FromSeconds(60);
+
+    /// <summary>Zweite Prüfung kurz nach Ablauf der Wartezeit.</summary>
+    private void ScheduleConfirmScan()
+    {
+        if (_deadConfirmTimer is null)
+        {
+            _deadConfirmTimer = new DispatcherTimer { Interval = ConfirmAfter + TimeSpan.FromSeconds(5) };
+            _deadConfirmTimer.Tick += (_, _) => { _deadConfirmTimer.Stop(); CleanupDeadShortcuts(); };
+        }
+        if (!_deadConfirmTimer.IsEnabled) _deadConfirmTimer.Start();
+    }
+
+    /// <summary>Einmal beim Start einrichten: Prüfung kurz nach dem Start und danach alle 10 Minuten.</summary>
+    public void StartDeadShortcutWatch()
+    {
+        _deadScanTimer = new DispatcherTimer { Interval = TimeSpan.FromSeconds(4) };
+        _deadScanTimer.Tick += (_, _) => { _deadScanTimer.Stop(); CleanupDeadShortcuts(); };
+        // Deinstallationen über die Windows-Einstellungen ändern unsere Ordner nicht → zusätzlich regelmäßig prüfen
+        _deadScanPeriodic = new DispatcherTimer { Interval = TimeSpan.FromMinutes(10) };
+        _deadScanPeriodic.Tick += (_, _) => CleanupDeadShortcuts();
+        _deadScanPeriodic.Start();
+        ScheduleDeadShortcutScan();
+    }
+
+    /// <summary>Nach Änderungen (z. B. Deinstallation entfernt die Desktop-Verknüpfung) gebündelt prüfen.</summary>
+    public void ScheduleDeadShortcutScan()
+    {
+        if (_deadScanTimer is null) return;
+        _deadScanTimer.Stop();
+        _deadScanTimer.Start();
+    }
+
+    private async void CleanupDeadShortcuts()
+    {
+        if (!S.RemoveDeadShortcuts || _deadScanRunning || IsBusy) return;
+        _deadScanRunning = true;
+        try
+        {
+            var keep = S.KeptShortcuts.ToList();
+            var found = await Task.Run(() => Storage.FindDeadShortcuts(keep));
+
+            // Updates ersetzen ihre Programmdatei manchmal kurz → erst entfernen, wenn sie mindestens
+            // eine Minute lang fehlt (zweite Prüfung), sonst würde ein laufendes Update fälschlich aufgeräumt
+            var now = DateTime.UtcNow;
+            foreach (var p in _deadSince.Keys.Where(k => !found.Contains(k, StringComparer.OrdinalIgnoreCase)).ToList())
+                _deadSince.Remove(p);
+            foreach (var p in found) _deadSince.TryAdd(p, now);
+            var dead = found.Where(p => now - _deadSince[p] >= ConfirmAfter).ToList();
+            if (dead.Count < found.Count) ScheduleConfirmScan();
+            if (dead.Count == 0) return;
+            foreach (var p in dead) _deadSince.Remove(p);
+
+            var entry = new UndoEntry(dead.Count == 1
+                ? $"„{Storage.DisplayName(dead[0])}“ entfernen (Programm deinstalliert)"
+                : $"{dead.Count} Verknüpfungen deinstallierter Programme entfernen");
+            var removed = new List<string>();
+            foreach (var p in dead)
+            {
+                try
+                {
+                    // Reihenfolge beim Rückgängigmachen: erst zurückholen, dann merken, dass sie bleiben soll
+                    var path = p;
+                    entry.Add(() =>
+                    {
+                        if (!S.KeptShortcuts.Contains(path, StringComparer.OrdinalIgnoreCase)) S.KeptShortcuts.Add(path);
+                        S.Save();
+                        return null;
+                    });
+                    entry.AddDelete(p, Storage.Delete(p));
+                    removed.Add(p);
+                }
+                catch { }
+            }
+            if (removed.Count == 0) return;
+            Undo.Push(entry);
+            Refresh();
+            FenceManager.RefreshAll();
+
+            var text = removed.Count == 1
+                ? $"„{Storage.DisplayName(removed[0])}“ entfernt – das Programm ist nicht mehr installiert"
+                : $"{removed.Count} Verknüpfungen entfernt – die Programme sind nicht mehr installiert";
+            if (IsVisible && IsActive) ShowToast(text, "", undoable: true);
+            else App.TrayIcon?.Notify("Aufgeräumt", text);
+        }
+        finally
+        {
+            _deadScanRunning = false;
+        }
+    }
+
+    private void DeadShortcutsToggle_Click(object sender, RoutedEventArgs e)
+    {
+        S.RemoveDeadShortcuts = DeadShortcutsToggle.IsChecked == true;
+        // beim Einschalten: früher behaltene Verknüpfungen wieder prüfen lassen
+        if (S.RemoveDeadShortcuts) S.KeptShortcuts.RemoveAll(p => !File.Exists(p));
+        S.Save();
+        if (S.RemoveDeadShortcuts) ScheduleDeadShortcutScan();
+    }
+}

MainWindow.Fences.cs

@@ -0,0 +1,119 @@
+using System.Windows;
+
+namespace DeskCore;
+
+/// <summary>Einstellungen der Desktop-Boxen: Portale, Schnell verstecken, Peek, Chamäleon und Snapshots.</summary>
+public partial class MainWindow
+{
+    /// <summary>Box geschlossen o. Ä. → Kennzeichnung "hat Box" in der Seitenleiste aktualisieren.</summary>
+    public void RefreshFromFences()
+    {
+        Refresh();
+        if (InSettings) { LoadFenceSettings(); LoadDesktopSettings(); }
+    }
+
+    private void LoadFenceSettings()
+    {
+        QuickHideToggle.IsChecked = S.QuickHide;
+        PeekToggle.IsChecked = S.PeekEnabled;
+        PeekHint.Text = $"{Hotkey.Describe(S.PeekModifiers, S.PeekKey)} holt alle Boxen vor die offenen Fenster. " +
+                        "Nochmal drücken, Esc oder woanders hinklicken schickt sie zurück.";
+        ChameleonToggle.IsChecked = S.FenceChameleon;
+        SnapshotList.ItemsSource = null;
+        SnapshotList.ItemsSource = S.Snapshots.OrderByDescending(x => x.Created).ToList();
+    }
+
+    private void AddPortal_Click(object sender, RoutedEventArgs e)
+    {
+        int before = S.Fences.Count;
+        FenceManager.AddPortal();
+        if (S.Fences.Count > before) ShowToast("Ordner-Portal liegt jetzt auf dem Desktop", "");
+        LoadSettingsView();
+    }
+
+    private void QuickHideToggle_Click(object sender, RoutedEventArgs e)
+    {
+        S.QuickHide = QuickHideToggle.IsChecked == true;
+        S.Save();
+        DesktopToggle.Apply();
+    }
+
+    private void PeekToggle_Click(object sender, RoutedEventArgs e)
+    {
+        S.PeekEnabled = PeekToggle.IsChecked == true;
+        S.Save();
+        if (!App.ApplyPeekHotkey())
+            PeekHint.Text = "⚠ Diese Tastenkombination ist schon von einem anderen Programm belegt.";
+    }
+
+    private void ChameleonToggle_Click(object sender, RoutedEventArgs e)
+    {
+        S.FenceChameleon = ChameleonToggle.IsChecked == true;
+        S.Save();
+        FenceManager.RefreshAll();
+    }
+
+    // ---------- Snapshots ----------
+
+    private void SaveSnapshot_Click(object sender, RoutedEventArgs e)
+    {
+        if (S.Fences.Count == 0)
+        {
+            ShowToast("Es gibt noch keine Boxen zum Speichern", "", info: true);
+            return;
+        }
+        var name = Dialog.Prompt(this, "Anordnung speichern", "Name für diese Anordnung (z. B. „Arbeit“ oder „Zocken“):",
+            $"Anordnung {S.Snapshots.Count + 1}", "Speichern",
+            t => t.Trim().Length == 0 ? "Bitte einen Namen eingeben." : t.Contains('"') ? "Bitte ohne Anführungszeichen." : null);
+        if (name is null) return;
+        bool replace = S.Snapshots.Any(x => string.Equals(x.Name, name, StringComparison.OrdinalIgnoreCase));
+        FenceManager.SaveSnapshot(name);
+        LoadFenceSettings();
+        ShowToast(replace ? $"Anordnung „{name}“ aktualisiert" : $"Anordnung „{name}“ gespeichert", "");
+    }
+
+    private void RestoreSnapshot(FenceSnapshot snap)
+    {
+        var before = FenceManager.RestoreSnapshot(snap);
+        var entry = new UndoEntry($"Anordnung „{snap.Name}“ laden");
+        entry.Add(() => { FenceManager.ApplyFences(before); return null; });
+        Undo.Push(entry);
+        Refresh();
+        ShowToast($"Anordnung „{snap.Name}“ wiederhergestellt", "", undoable: true);
+    }
+
+    private void RestoreSnapshot_Click(object sender, RoutedEventArgs e)
+    {
+        if ((sender as FrameworkElement)?.Tag is FenceSnapshot snap) RestoreSnapshot(snap);
+    }
+
+    private void DeleteSnapshot_Click(object sender, RoutedEventArgs e)
+    {
+        if ((sender as FrameworkElement)?.Tag is not FenceSnapshot snap) return;
+        S.Snapshots.Remove(snap);
+        S.Save();
+        var entry = new UndoEntry($"Anordnung „{snap.Name}“ löschen");
+        entry.Add(() => { S.Snapshots.Add(snap); S.Save(); return null; });
+        Undo.Push(entry);
+        LoadFenceSettings();
+        ShowToast($"Anordnung „{snap.Name}“ gelöscht", "", undoable: true);
+    }
+
+    /// <summary>Für die Befehlszeile: DeskCore.exe --snapshot "Name".</summary>
+    public void RestoreSnapshotByName(string name)
+    {
+        var snap = S.Snapshots.FirstOrDefault(x => string.Equals(x.Name, name, StringComparison.OrdinalIgnoreCase));
+        if (snap is null) App.TrayIcon?.Notify("Anordnung nicht gefunden", $"Es gibt keine gespeicherte Anordnung „{name}“.");
+        else RestoreSnapshot(snap);
+    }
+
+    // ---------- Regeln: Name oder Dateityp ----------
+
+    private void RuleKind_Click(object sender, RoutedEventArgs e)
+    {
+        if ((sender as FrameworkElement)?.Tag is not SortRule r) return;
+        r.Kind = r.Kind == "Typ" ? "Name" : "Typ";
+        S.Save();
+        LoadSettingsView();
+    }
+}

MainWindow.LaunchGroups.cs

@@ -0,0 +1,413 @@
+using System.Diagnostics;
+using System.IO;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Media;
+
+namespace DeskCore;
+
+/// <summary>Start-Gruppen: ein Klick startet mehrere Programme nacheinander.</summary>
+public partial class MainWindow
+{
+    private LaunchGroupItem? CurrentGroup => LaunchList.SelectedItem as LaunchGroupItem;
+
+    /// <summary>Kategorie-Dialog von außen (z. B. "Neue Box hier" auf dem Desktop).</summary>
+    public string? CreateCategoryInteractive() => NewCategory();
+
+    private static string DelayText(LaunchGroup g) =>
+        g.DelaySeconds <= 0 ? "gleichzeitig" : $"{g.DelaySeconds:0.#} s Abstand";
+
+    /// <summary>Wo liegt ein Element? (für Tooltip/Listenansicht)</summary>
+    private static string LocationOf(string path)
+    {
+        var dir = Path.GetDirectoryName(path) ?? "";
+        if (Storage.IsDesktopDir(dir)) return DesktopName;
+        return Storage.IsInStorage(path) ? Path.GetFileName(dir) : dir;
+    }
+
+    private void LoadGroupIcons(LaunchGroup g)
+    {
+        var items = g.Items.Select(p => new IconItem { Path = p, Category = LocationOf(p) }).ToList();
+        HeaderText.Text = g.Name;
+        int missing = items.Count(i => !File.Exists(i.Path) && !Directory.Exists(i.Path));
+        SubText.Text = $"{Plural(items.Count, "Programm", "Programme")}  ·  {DelayText(g)}" +
+                       (missing > 0 ? $"  ·  ⚠ {missing} nicht mehr vorhanden" : "");
+        SetEmpty("", "Noch leer",
+            "Ziehe Programme hierher oder auf die Gruppe links – oder Rechtsklick auf ein Icon → „Zur Start-Gruppe hinzufügen“.");
+
+        // Reihenfolge = Startreihenfolge, deshalb hier nicht sortieren
+        var px = IconPixels;
+        foreach (var item in items) IconLoader.Load(item, px);
+        IconList.ItemsSource = items;
+
+        EmptyState.Visibility = items.Count == 0 ? Visibility.Visible : Visibility.Collapsed;
+        CategoryCommands.Visibility = Visibility.Collapsed;
+        InfoBar.Visibility = Visibility.Collapsed;
+        GroupCommands.Visibility = Visibility.Visible;
+    }
+
+    private void SelectGroup(LaunchGroup g)
+    {
+        var item = LaunchList.Items.OfType<LaunchGroupItem>().FirstOrDefault(x => x.Group == g);
+        if (item is not null) LaunchList.SelectedItem = item;
+    }
+
+    // ---------- Starten ----------
+
+    /// <summary>Startet alle Programme der Gruppe nacheinander (mit eingestelltem Abstand).</summary>
+    public async void LaunchGroupNow(LaunchGroup g)
+    {
+        if (g.Items.Count == 0)
+        {
+            ShowToast($"„{g.Name}“ ist noch leer", "", info: true);
+            return;
+        }
+        int started = 0;
+        var problems = new List<string>();
+        var items = g.Items.ToList();
+        for (int i = 0; i < items.Count; i++)
+        {
+            if (i > 0 && g.DelaySeconds > 0) await Task.Delay(TimeSpan.FromSeconds(g.DelaySeconds));
+            var p = items[i];
+            if (!File.Exists(p) && !Directory.Exists(p)) { problems.Add($"„{Storage.DisplayName(p)}“ gibt es nicht mehr"); continue; }
+            try
+            {
+                Process.Start(new ProcessStartInfo(p) { UseShellExecute = true });
+                started++;
+            }
+            catch (Exception ex) { problems.Add($"„{Storage.DisplayName(p)}“: {ex.Message}"); }
+        }
+
+        var text = $"„{g.Name}“: {Plural(started, "Programm", "Programme")} gestartet" +
+                   (problems.Count > 0 ? $" · {problems.Count} nicht" : "");
+        if (IsVisible && IsActive) ShowToast(text, problems.Count > 0 ? "" : "", info: problems.Count > 0);
+        else App.TrayIcon?.Notify(g.Name, problems.Count > 0 ? text + "\n" + string.Join("\n", problems.Take(3)) : text);
+    }
+
+    /// <summary>Für die Befehlszeile und Desktop-Verknüpfungen: DeskCore.exe --launch "Name".</summary>
+    public bool LaunchGroupByName(string name)
+    {
+        var g = S.LaunchGroups.FirstOrDefault(x => string.Equals(x.Name, name, StringComparison.OrdinalIgnoreCase));
+        if (g is null)
+        {
+            App.TrayIcon?.Notify("Start-Gruppe nicht gefunden", $"Es gibt keine Start-Gruppe „{name}“.");
+            return false;
+        }
+        LaunchGroupNow(g);
+        return true;
+    }
+
+    private void LaunchCurrentGroup_Click(object sender, RoutedEventArgs e)
+    {
+        if (CurrentGroup is { } g) LaunchGroupNow(g.Group);
+    }
+
+    private void LaunchGroupPlay_Click(object sender, RoutedEventArgs e)
+    {
+        if ((sender as FrameworkElement)?.Tag is LaunchGroupItem g) LaunchGroupNow(g.Group);
+        e.Handled = true;
+    }
+
+    // ---------- Anlegen / Bearbeiten ----------
+
+    /// <summary>Dialog für Name, Startabstand und Farbe. Gibt null bei Abbruch zurück.</summary>
+    private (string Name, double Delay, string? Color)? LaunchGroupDialog(string title, string primary, LaunchGroup? existing)
+    {
+        var res = Application.Current.Resources;
+        var panel = new StackPanel();
+        TextBlock Label(string t, double top = 16) => new()
+        {
+            Text = t, Margin = new Thickness(0, top, 0, 8), FontWeight = FontWeights.SemiBold, FontSize = 13,
+        };
+
+        panel.Children.Add(Label("Name", 0));
+        var nameBox = new TextBox { Text = existing?.Name ?? "" };
+        panel.Children.Add(nameBox);
+
+        panel.Children.Add(Label("Abstand zwischen den Programmen"));
+        var delayText = new TextBlock { VerticalAlignment = VerticalAlignment.Center, Width = 110, Foreground = (Brush)res["TextSecondaryBrush"] };
+        var slider = new Slider { Minimum = 0, Maximum = 10, TickFrequency = 0.5, IsSnapToTickEnabled = true, Value = existing?.DelaySeconds ?? 1 };
+        void UpdateDelay() => delayText.Text = slider.Value <= 0 ? "gleichzeitig" : $"{slider.Value:0.#} Sekunden";
+        slider.ValueChanged += (_, _) => UpdateDelay();
+        UpdateDelay();
+        var row = new DockPanel();
+        DockPanel.SetDock(delayText, Dock.Right);
+        row.Children.Add(delayText);
+        row.Children.Add(slider);
+        panel.Children.Add(row);
+        panel.Children.Add(new TextBlock
+        {
+            Text = "Etwas Abstand hilft, wenn Programme beim Start viel Leistung brauchen.", FontSize = 12, Margin = new Thickness(0, 4, 0, 0),
+            TextWrapping = TextWrapping.Wrap, Foreground = (Brush)res["TextTertiaryBrush"],
+        });
+
+        panel.Children.Add(Label("Farbe"));
+        string? color = existing?.Color;
+        var swatches = new WrapPanel();
+        var none = new RadioButton
+        {
+            Style = (Style)res["SwatchRadio"], GroupName = "lgcolor", ToolTip = "Akzentfarbe", Background = (Brush)res["AccentBrush"],
+            IsChecked = color is null,
+        };
+        none.Checked += (_, _) => color = null;
+        swatches.Children.Add(none);
+        foreach (var (cname, hex) in CategoryColors.All)
+        {
+            var rb = new RadioButton
+            {
+                Style = (Style)res["SwatchRadio"], GroupName = "lgcolor", ToolTip = cname, Background = CategoryColors.Brush(hex),
+                IsChecked = string.Equals(color, hex, StringComparison.OrdinalIgnoreCase),
+            };
+            rb.Checked += (_, _) => color = hex;
+            swatches.Children.Add(rb);
+        }
+        panel.Children.Add(swatches);
+
+        string? Validate()
+        {
+            var n = nameBox.Text.Trim();
+            if (n.Length == 0) return "Bitte einen Namen eingeben.";
+            if (n.Contains('"')) return "Der Name darf keine Anführungszeichen enthalten.";
+            bool taken = S.LaunchGroups.Any(x => x != existing && string.Equals(x.Name, n, StringComparison.OrdinalIgnoreCase));
+            return taken ? "Eine Start-Gruppe mit diesem Namen gibt es schon." : null;
+        }
+
+        if (!Dialog.Show(this, title, panel, primary, "Abbrechen", Validate, nameBox, width: 470)) return null;
+        return (nameBox.Text.Trim(), slider.Value, color);
+    }
+
+    private LaunchGroup? NewLaunchGroup(IEnumerable<string>? initialItems = null)
+    {
+        var form = LaunchGroupDialog("Neue Start-Gruppe", "Erstellen", null);
+        if (form is null) return null;
+        var g = new LaunchGroup { Name = form.Value.Name, DelaySeconds = form.Value.Delay, Color = form.Value.Color };
+        S.LaunchGroups.Add(g);
+        if (initialItems is not null) AddPathsToGroup(g, initialItems, toast: false);
+        S.Save();
+
+        var entry = new UndoEntry($"Start-Gruppe „{g.Name}“ erstellen");
+        entry.Add(() => { S.LaunchGroups.Remove(g); S.Save(); return null; });
+        Undo.Push(entry);
+        Refresh();
+        return g;
+    }
+
+    private void NewLaunchGroup_Click(object sender, RoutedEventArgs e)
+    {
+        if (NewLaunchGroup() is not { } g) return;
+        ShowBrowse();
+        SelectGroup(g);
+        ShowToast($"Start-Gruppe „{g.Name}“ erstellt – jetzt Programme hineinziehen", "", undoable: true);
+    }
+
+    private void EditLaunchGroup(LaunchGroup g)
+    {
+        var form = LaunchGroupDialog("Start-Gruppe bearbeiten", "Speichern", g);
+        if (form is null) return;
+        var before = (g.Name, g.DelaySeconds, g.Color);
+        (g.Name, g.DelaySeconds, g.Color) = form.Value;
+        S.Save();
+        var entry = new UndoEntry($"Start-Gruppe „{before.Name}“ bearbeiten");
+        entry.Add(() => { (g.Name, g.DelaySeconds, g.Color) = before; S.Save(); return null; });
+        Undo.Push(entry);
+        Refresh();
+        if (before.Name != g.Name)
+            ShowToast("Gespeichert – eine vorhandene Desktop-Verknüpfung bitte neu anlegen (sie nutzt noch den alten Namen)", "", info: true);
+        else ShowToast("Start-Gruppe gespeichert", undoable: true);
+    }
+
+    private void EditLaunchGroup_Click(object sender, RoutedEventArgs e)
+    {
+        if (CurrentGroup is { } g) EditLaunchGroup(g.Group);
+    }
+
+    private void DeleteLaunchGroup(LaunchGroup g)
+    {
+        if (!Dialog.Confirm(this, "Start-Gruppe löschen?",
+                $"„{g.Name}“ wird entfernt. Die Programme selbst bleiben unverändert.", "Löschen"))
+            return;
+        int index = S.LaunchGroups.IndexOf(g);
+        S.LaunchGroups.Remove(g);
+        S.Save();
+        var entry = new UndoEntry($"Start-Gruppe „{g.Name}“ löschen");
+        entry.Add(() => { S.LaunchGroups.Insert(Math.Min(index, S.LaunchGroups.Count), g); S.Save(); return null; });
+        Undo.Push(entry);
+        Refresh();
+        ShowToast($"Start-Gruppe „{g.Name}“ gelöscht", "", undoable: true);
+    }
+
+    private void DeleteLaunchGroup_Click(object sender, RoutedEventArgs e)
+    {
+        if (CurrentGroup is { } g) DeleteLaunchGroup(g.Group);
+    }
+
+    private void MoveLaunchGroup(LaunchGroup g, int delta)
+    {
+        int i = S.LaunchGroups.IndexOf(g), j = i + delta;
+        if (i < 0 || j < 0 || j >= S.LaunchGroups.Count) return;
+        (S.LaunchGroups[i], S.LaunchGroups[j]) = (S.LaunchGroups[j], S.LaunchGroups[i]);
+        S.Save();
+        Refresh();
+    }
+
+    // ---------- Inhalt ----------
+
+    /// <summary>
+    /// Desktop-Icons, die schon in einer Kategorie gesichert sind, werden durch die gesicherte Kopie ersetzt –
+    /// so funktioniert die Gruppe auch noch, wenn das Icon später vom Desktop gelöscht wird.
+    /// </summary>
+    private static string ResolveForGroup(string path)
+    {
+        if (Storage.IsInStorage(path)) return path;
+        foreach (var c in Storage.Categories())
+            if (Storage.Entries(Storage.CategoryPath(c)).FirstOrDefault(e => Storage.SameItem(e, path)) is { } saved)
+                return saved;
+        return path;
+    }
+
+    private void AddPathsToGroup(LaunchGroup g, IEnumerable<string> paths, bool toast = true)
+    {
+        int added = 0, dup = 0;
+        foreach (var raw in paths)
+        {
+            var p = ResolveForGroup(raw);
+            if (g.Items.Contains(p, StringComparer.OrdinalIgnoreCase)) { dup++; continue; }
+            g.Items.Add(p);
+            added++;
+        }
+        S.Save();
+        if (!toast) return;
+        Refresh();
+        if (added == 0) ShowToast(dup == 1 ? "Das ist schon in der Gruppe" : "Alles schon in der Gruppe", "", info: true);
+        else ShowToast($"{Plural(added, "Programm", "Programme")} zu „{g.Name}“ hinzugefügt", "");
+    }
+
+    private void RemoveFromGroup(LaunchGroup g, List<IconItem> sel)
+    {
+        var before = g.Items.ToList();
+        foreach (var i in sel) g.Items.RemoveAll(p => string.Equals(p, i.Path, StringComparison.OrdinalIgnoreCase));
+        S.Save();
+        var entry = new UndoEntry($"Aus „{g.Name}“ entfernen");
+        entry.Add(() => { g.Items = before; S.Save(); return null; });
+        Undo.Push(entry);
+        Refresh();
+        ShowToast($"{Plural(sel.Count, "Programm", "Programme")} aus „{g.Name}“ entfernt – die Dateien bleiben erhalten", "", undoable: true);
+    }
+
+    private void MoveInGroup(LaunchGroup g, IconItem item, int delta)
+    {
+        int i = g.Items.FindIndex(p => string.Equals(p, item.Path, StringComparison.OrdinalIgnoreCase)), j = i + delta;
+        if (i < 0 || j < 0 || j >= g.Items.Count) return;
+        (g.Items[i], g.Items[j]) = (g.Items[j], g.Items[i]);
+        S.Save();
+        Refresh();
+    }
+
+    /// <summary>Kontextmenü der Icons, wenn eine Start-Gruppe angezeigt wird.</summary>
+    private void FillGroupItemMenu(LaunchGroup g, List<IconItem> sel)
+    {
+        IconMenu.Items.Add(MenuItem("Öffnen", "", () => sel.ForEach(i => Open(i.Path)), bold: true, gesture: "Enter"));
+        if (sel.Count == 1)
+        {
+            IconMenu.Items.Add(MenuItem("Dateispeicherort öffnen", "", () =>
+                Process.Start("explorer.exe", $"/select,\"{sel[0].Path}\"")));
+            IconMenu.Items.Add(new Separator());
+            int idx = g.Items.FindIndex(p => string.Equals(p, sel[0].Path, StringComparison.OrdinalIgnoreCase));
+            var up = MenuItem("Früher starten", "", () => MoveInGroup(g, sel[0], -1));
+            up.IsEnabled = idx > 0;
+            var down = MenuItem("Später starten", "", () => MoveInGroup(g, sel[0], +1));
+            down.IsEnabled = idx >= 0 && idx < g.Items.Count - 1;
+            IconMenu.Items.Add(up);
+            IconMenu.Items.Add(down);
+        }
+        IconMenu.Items.Add(new Separator());
+        IconMenu.Items.Add(MenuItem("Aus Start-Gruppe entfernen", "", () => RemoveFromGroup(g, sel), gesture: "Entf"));
+    }
+
+    /// <summary>Untermenü "Zur Start-Gruppe hinzufügen" (Haupt-Kontextmenü und Desktop-Boxen).</summary>
+    public MenuItem LaunchGroupSubmenu(List<string> paths)
+    {
+        var menu = MenuItem("Zur Start-Gruppe hinzufügen", "", null);
+        foreach (var g in S.LaunchGroups)
+            menu.Items.Add(MenuItem(g.Name, "", () => AddPathsToGroup(g, paths)));
+        if (menu.Items.Count > 0) menu.Items.Add(new Separator());
+        menu.Items.Add(MenuItem("Neue Start-Gruppe…", "", () =>
+        {
+            if (NewLaunchGroup(paths) is { } g)
+                ShowToast($"Start-Gruppe „{g.Name}“ mit {Plural(g.Items.Count, "Programm", "Programmen")} erstellt", "", undoable: true);
+        }));
+        return menu;
+    }
+
+    // ---------- Seitenleiste ----------
+
+    private void LaunchList_ContextMenuOpening(object sender, ContextMenuEventArgs e)
+    {
+        if (FindParent<ListBoxItem>(e.OriginalSource as DependencyObject)?.DataContext is not LaunchGroupItem item)
+        {
+            e.Handled = true;
+            return;
+        }
+        var g = item.Group;
+        int idx = S.LaunchGroups.IndexOf(g);
+        LaunchMenu.Items.Clear();
+        LaunchMenu.Items.Add(MenuItem("Alle starten", "", () => LaunchGroupNow(g), bold: true));
+        LaunchMenu.Items.Add(MenuItem("Bearbeiten…", "", () => EditLaunchGroup(g)));
+        LaunchMenu.Items.Add(MenuItem("Verknüpfung auf den Desktop", "", () => CreateGroupShortcut(g)));
+        LaunchMenu.Items.Add(new Separator());
+        var up = MenuItem("Nach oben", "", () => MoveLaunchGroup(g, -1));
+        up.IsEnabled = idx > 0;
+        var down = MenuItem("Nach unten", "", () => MoveLaunchGroup(g, +1));
+        down.IsEnabled = idx < S.LaunchGroups.Count - 1;
+        LaunchMenu.Items.Add(up);
+        LaunchMenu.Items.Add(down);
+        LaunchMenu.Items.Add(new Separator());
+        LaunchMenu.Items.Add(MenuItem("Löschen", "", () => DeleteLaunchGroup(g)));
+    }
+
+    private void LaunchList_DragOver(object sender, DragEventArgs e)
+    {
+        var lbi = FindParent<ListBoxItem>(e.OriginalSource as DependencyObject);
+        bool ok = lbi is not null && e.Data.GetDataPresent(DataFormats.FileDrop);
+        SetDropHighlight(ok ? lbi : null);
+        e.Effects = ok ? DragDropEffects.Link | (e.AllowedEffects & DragDropEffects.Copy) : DragDropEffects.None;
+        e.Handled = true;
+    }
+
+    private void LaunchList_Drop(object sender, DragEventArgs e)
+    {
+        SetDropHighlight(null);
+        if (FindParent<ListBoxItem>(e.OriginalSource as DependencyObject)?.DataContext is LaunchGroupItem item &&
+            e.Data.GetData(DataFormats.FileDrop) is string[] files)
+            AddPathsToGroup(item.Group, files);
+    }
+
+    // ---------- Desktop-Verknüpfung ----------
+
+    private void LaunchGroupShortcut_Click(object sender, RoutedEventArgs e)
+    {
+        if (CurrentGroup is { } g) CreateGroupShortcut(g.Group);
+    }
+
+    /// <summary>Legt "&lt;Name&gt; starten.lnk" auf den Desktop, die DeskCore.exe --launch "&lt;Name&gt;" aufruft.</summary>
+    private void CreateGroupShortcut(LaunchGroup g)
+    {
+        try
+        {
+            var exe = Environment.ProcessPath!;
+            var safe = string.Concat(g.Name.Split(Path.GetInvalidFileNameChars()));
+            var link = Storage.UniquePath(Storage.UserDesktop, $"{safe} starten.lnk");
+            Storage.MarkCreated(link); // nicht von der Auto-Sortierung einsammeln lassen
+            dynamic shell = Activator.CreateInstance(Type.GetTypeFromProgID("WScript.Shell")!)!;
+            dynamic l = shell.CreateShortcut(link);
+            l.TargetPath = exe;
+            l.Arguments = $"--launch \"{g.Name}\"";
+            l.WorkingDirectory = Path.GetDirectoryName(exe);
+            l.IconLocation = $"{exe},0";
+            l.Description = $"Startet die DeskCore-Start-Gruppe „{g.Name}“";
+            l.Save();
+            ShowToast($"„{Path.GetFileNameWithoutExtension(link)}“ liegt jetzt auf dem Desktop", "");
+        }
+        catch (Exception ex) { Error("Verknüpfung fehlgeschlagen", ex.Message); }
+    }
+}

MainWindow.Pages.cs

@@ -0,0 +1,134 @@
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Media;
+
+namespace DeskCore;
+
+/// <summary>Einstellungen für Desktop-Seiten, das Aufziehen neuer Boxen und die Tönung der Desktop-Icons.</summary>
+public partial class MainWindow
+{
+    public record PageRow(int Index, string Name, string Info, Brush Dot);
+
+    private bool _loadingDesktopSettings;
+
+    private void LoadDesktopSettings()
+    {
+        _loadingDesktopSettings = true;
+        DrawFencesToggle.IsChecked = S.DrawFences;
+        PageWheelBox.IsChecked = S.PageWheel;
+        PageWheelBox.IsEnabled = S.Pages.Count > 1;
+
+        var res = Application.Current.Resources;
+        PageList.ItemsSource = S.Pages.Select((name, i) =>
+        {
+            int boxes = S.Fences.Count(f => f.Page == i);
+            var info = (boxes == 1 ? "1 Box" : $"{boxes} Boxen") + (i == S.CurrentPage ? " · wird gerade angezeigt" : "");
+            return new PageRow(i, name, info, (Brush)res[i == S.CurrentPage ? "AccentBrush" : "ControlStrongStrokeBrush"]);
+        }).ToList();
+
+        DesktopTintSwatches.Children.Clear();
+        void AddSwatch(string? hex, Brush brush, string tip)
+        {
+            var rb = new RadioButton
+            {
+                Style = (Style)res["SwatchRadio"], GroupName = "desktoptint", Background = brush, ToolTip = tip,
+                IsChecked = S.DesktopTint == hex,
+            };
+            rb.Checked += (_, _) =>
+            {
+                if (_loadingDesktopSettings) return;
+                S.DesktopTint = hex;
+                S.Save();
+                DesktopTintStrength.IsEnabled = hex is not null;
+                DesktopIcons.RefreshCache();
+                DesktopTint.Refresh(force: true);
+            };
+            DesktopTintSwatches.Children.Add(rb);
+        }
+        AddSwatch(null, Brushes.Transparent, "Keine Tönung");
+        foreach (var (name, hex) in CategoryColors.All.Concat([("Grau", "#8A8A8A"), ("Weiß", "#F5F5F5")]))
+            AddSwatch(hex, CategoryColors.Brush(hex)!, name);
+        DesktopTintStrength.Value = Math.Round(S.DesktopTintStrength * 100);
+        DesktopTintStrength.IsEnabled = S.DesktopTint is not null;
+        _loadingDesktopSettings = false;
+    }
+
+    private void DrawFencesToggle_Click(object sender, RoutedEventArgs e)
+    {
+        S.DrawFences = DrawFencesToggle.IsChecked == true;
+        S.Save();
+        DesktopToggle.Apply();
+    }
+
+    private void PageWheel_Click(object sender, RoutedEventArgs e)
+    {
+        S.PageWheel = PageWheelBox.IsChecked == true;
+        S.Save();
+        DesktopToggle.Apply();
+    }
+
+    private void DesktopTintStrength_ValueChanged(object sender, RoutedPropertyChangedEventArgs<double> e)
+    {
+        if (_loadingDesktopSettings || !IsLoaded) return;
+        S.DesktopTintStrength = DesktopTintStrength.Value / 100;
+        S.Save();
+        DesktopTint.Refresh(force: true);
+    }
+
+    // ---------- Seiten ----------
+
+    private static string? ValidatePageName(string t, int except) =>
+        t.Trim().Length == 0 ? "Bitte einen Namen eingeben."
+        : S.Pages.Where((_, i) => i != except).Any(p => string.Equals(p, t.Trim(), StringComparison.OrdinalIgnoreCase))
+            ? "Diesen Namen gibt es schon." : null;
+
+    private void AddPage_Click(object sender, RoutedEventArgs e)
+    {
+        var name = Dialog.Prompt(this, "Neue Desktop-Seite", "Name der Seite (z. B. „Arbeit“ oder „Freizeit“):",
+            $"Seite {S.Pages.Count + 1}", "Hinzufügen", t => ValidatePageName(t, -1));
+        if (name is null) return;
+        S.Pages.Add(name.Trim());
+        S.Save();
+        DesktopToggle.Apply();
+        LoadDesktopSettings();
+        ShowToast($"Seite „{name.Trim()}“ hinzugefügt",
+            "Mit „Anzeigen“ wechselst du hin – neue Boxen landen immer auf der gerade angezeigten Seite.");
+    }
+
+    private void ShowPage_Click(object sender, RoutedEventArgs e)
+    {
+        if ((sender as FrameworkElement)?.Tag is int i) FenceManager.SwitchPage(i);
+        LoadDesktopSettings();
+    }
+
+    private void RenamePage_Click(object sender, RoutedEventArgs e)
+    {
+        if ((sender as FrameworkElement)?.Tag is not int i || i >= S.Pages.Count) return;
+        var name = Dialog.Prompt(this, "Seite umbenennen", "Neuer Name:", S.Pages[i], "Umbenennen", t => ValidatePageName(t, i));
+        if (name is null) return;
+        S.Pages[i] = name.Trim();
+        S.Save();
+        LoadDesktopSettings();
+    }
+
+    private void DeletePage_Click(object sender, RoutedEventArgs e)
+    {
+        if ((sender as FrameworkElement)?.Tag is not int i || i >= S.Pages.Count) return;
+        if (S.Pages.Count < 2)
+        {
+            ShowToast("Die letzte Seite kann nicht gelöscht werden", "", info: true);
+            return;
+        }
+        var name = S.Pages[i];
+        int boxes = S.Fences.Count(f => f.Page == i);
+        if (boxes > 0 && !Dialog.Confirm(this, "Seite löschen",
+                $"Auf „{name}“ liegen {boxes} Box(en). Sie wandern auf die Seite „{S.Pages[i == 0 ? 1 : i - 1]}“.",
+                "Löschen"))
+            return;
+        FenceManager.DeletePage(i);
+        DesktopToggle.Apply();
+        Refresh();
+        LoadDesktopSettings();
+        ShowToast($"Seite „{name}“ gelöscht", "");
+    }
+}

Migration.cs

@@ -22,6 +22,7 @@ public static class Migration
 
     public static void Run()
     {
+        if (Environment.GetEnvironmentVariable("DESKCORE_DATA") is { Length: > 0 }) return; // Testmodus: nichts umziehen
         if (FindLegacy() is { } legacy)
         {
             foreach (var folder in Folders)
@@ -67,6 +68,10 @@ public static class Migration
     /// <summary>Neuer Ordner – außer der Umzug hat nicht geklappt und nur der alte existiert.</summary>
     public static string Pick(Environment.SpecialFolder folder, params string[] sub)
     {
+        // Testmodus: alle Daten in einem eigenen Ordner, damit Tests nie echte Einstellungen/Kategorien berühren
+        if (Environment.GetEnvironmentVariable("DESKCORE_DATA") is { Length: > 0 } testRoot)
+            return Path.Combine([testRoot, folder.ToString(), .. sub]);
+
         var baseDir = Environment.GetFolderPath(folder);
         if (!Directory.Exists(Path.Combine(baseDir, NewName)) && FindLegacy() is { } legacy
             && Directory.Exists(Path.Combine(baseDir, legacy)))

Models.cs

@@ -1,97 +1,109 @@
-using System.ComponentModel;
+using System.ComponentModel;
-using System.IO;
+using System.IO;
-using System.Windows.Media;
+using System.Windows.Media;
-
+
-namespace DeskCore;
+namespace DeskCore;
-
+
-public class CategoryItem
+public class CategoryItem
-{
+{
-    public required string Name { get; init; }
+    public required string Name { get; init; }
-    public bool IsDesktop { get; init; }
+    public bool IsDesktop { get; init; }
-    public int Count { get; set; }
+    public int Count { get; set; }
-    public string Folder => IsDesktop ? Storage.UserDesktop : Storage.CategoryPath(Name);
+    public string Folder => IsDesktop ? Storage.UserDesktop : Storage.CategoryPath(Name);
-
+
-    public CategoryMeta? Meta => IsDesktop ? null : AppSettings.Current.Categories.GetValueOrDefault(Name);
+    public CategoryMeta? Meta => IsDesktop ? null : AppSettings.Current.Categories.GetValueOrDefault(Name);
-    public string Glyph => IsDesktop ? "" : Meta?.Glyph ?? "";
+    public string Glyph => IsDesktop ? "" : Meta?.Glyph ?? "";
-    public Brush? GlyphBrush => CategoryColors.Brush(Meta?.Color);
+    public Brush? GlyphBrush => CategoryColors.Brush(Meta?.Color);
-    public bool HasFence => Meta?.Fence == true;
+    public bool HasFence => !IsDesktop && AppSettings.Current.HasFence(Name);
-}
+}
-
+
-public static class CategoryColors
+/// <summary>Eintrag einer Start-Gruppe in der Seitenleiste.</summary>
-{
+public class LaunchGroupItem
-    public static readonly (string Name, string Hex)[] All =
+{
-    [
+    public required LaunchGroup Group { get; init; }
-        ("Blau", "#3B82F6"), ("Türkis", "#12A594"), ("Grün", "#22A06B"), ("Gelb", "#E2A600"),
+    public string Name => Group.Name;
-        ("Orange", "#F07A1A"), ("Rot", "#E5484D"), ("Pink", "#D6409F"), ("Lila", "#8E4EC6"), ("Grau", "#8B8D98"),
+    public int Count => Group.Items.Count;
-    ];
+    public string Glyph => ""; // Abspielen
-
+    public Brush? GlyphBrush => CategoryColors.Brush(Group.Color);
-    public static Brush? Brush(string? hex)
+    public bool HasFence => false;
-    {
+    public bool IsDesktop => true; // blendet den Umsortier-Griff der Kategorien aus
-        if (string.IsNullOrEmpty(hex)) return null;
+}
-        try
+
-        {
+public static class CategoryColors
-            var b = new SolidColorBrush((Color)ColorConverter.ConvertFromString(hex));
+{
-            b.Freeze();
+    public static readonly (string Name, string Hex)[] All =
-            return b;
+    [
-        }
+        ("Blau", "#3B82F6"), ("Türkis", "#12A594"), ("Grün", "#22A06B"), ("Gelb", "#E2A600"),
-        catch { return null; }
+        ("Orange", "#F07A1A"), ("Rot", "#E5484D"), ("Pink", "#D6409F"), ("Lila", "#8E4EC6"), ("Grau", "#8B8D98"),
-    }
+    ];
-}
+
-
+    public static Brush? Brush(string? hex)
-public static class CategoryGlyphs
+    {
-{
+        if (string.IsNullOrEmpty(hex)) return null;
-    public static readonly (string Glyph, string Name)[] All =
+        try
-    [
+        {
-        ("", "Ordner"), ("", "Spiele"), ("", "Arbeit"), ("", "Code"),
+            var b = new SolidColorBrush((Color)ColorConverter.ConvertFromString(hex));
-        ("", "Musik"), ("", "Video"), ("", "Bilder"), ("", "Internet"),
+            b.Freeze();
-        ("", "Mail"), ("", "Shopping"), ("", "System"), ("", "Werkzeuge"),
+            return b;
-        ("", "Dokumente"), ("", "Favoriten"), ("", "Herz"), ("", "Cloud"),
+        }
-        ("", "Downloads"), ("", "Personen"), ("", "Bibliothek"), ("", "Rechner"),
+        catch { return null; }
-        ("", "Ideen"), ("", "Zuhause"), ("", "Lernen"), ("", "Erweiterungen"),
+    }
-        ("", "Computer"), ("", "Sicherheit"), ("", "Ebenen"),
+}
-    ];
+
-}
+public static class CategoryGlyphs
-
+{
-public class IconItem : INotifyPropertyChanged
+    public static readonly (string Glyph, string Name)[] All =
-{
+    [
-    public required string Path { get; init; }
+        ("", "Ordner"), ("", "Spiele"), ("", "Arbeit"), ("", "Code"),
-    public string? Category { get; init; }
+        ("", "Musik"), ("", "Video"), ("", "Bilder"), ("", "Internet"),
-
+        ("", "Mail"), ("", "Shopping"), ("", "System"), ("", "Werkzeuge"),
-    private ImageSource? _icon;
+        ("", "Dokumente"), ("", "Favoriten"), ("", "Herz"), ("", "Cloud"),
-    public ImageSource? Icon
+        ("", "Downloads"), ("", "Personen"), ("", "Bibliothek"), ("", "Rechner"),
-    {
+        ("", "Ideen"), ("", "Zuhause"), ("", "Lernen"), ("", "Erweiterungen"),
-        get => _icon;
+        ("", "Computer"), ("", "Sicherheit"), ("", "Ebenen"),
-        set { _icon = value; PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Icon))); }
+    ];
-    }
+}
-
+
-    /// <summary>Nur für Desktop-Icons: Kategorie, in der bereits eine Kopie liegt.</summary>
+public class IconItem : INotifyPropertyChanged
-    public string? SortedInto { get; init; }
+{
-    public bool IsSorted => SortedInto is not null;
+    public required string Path { get; init; }
-
+    public string? Category { get; init; }
-    public string Name => Storage.DisplayName(Path);
+
-
+    private ImageSource? _icon;
-    public string TypeText
+    public ImageSource? Icon
-    {
+    {
-        get
+        get => _icon;
-        {
+        set { _icon = value; PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Icon))); }
-            if (Directory.Exists(Path)) return "Ordner";
+    }
-            var ext = System.IO.Path.GetExtension(Path).ToLowerInvariant();
+
-            return ext switch
+    /// <summary>Nur für Desktop-Icons: Kategorie, in der bereits eine Kopie liegt.</summary>
-            {
+    public string? SortedInto { get; init; }
-                ".lnk" => "Verknüpfung",
+    public bool IsSorted => SortedInto is not null;
-                ".url" => "Internetverknüpfung",
+
-                ".exe" => "Programm",
+    public string Name => Storage.DisplayName(Path);
-                "" => "Datei",
+
-                _ => ext.TrimStart('.').ToUpperInvariant() + "-Datei",
+    public string TypeText
-            };
+    {
-        }
+        get
-    }
+        {
-
+            if (Directory.Exists(Path)) return "Ordner";
-    public string LocationText => SortedInto is not null ? $"✓ gesichert in {SortedInto}" : Category ?? "";
+            var ext = System.IO.Path.GetExtension(Path).ToLowerInvariant();
-
+            return ext switch
-    public string ToolTip =>
+            {
-        SortedInto is not null ? $"{Name}\n✓ Bereits gesichert in „{SortedInto}“ – kann vom Desktop gelöscht werden." :
+                ".lnk" => "Verknüpfung",
-        Category is not null ? $"{Name}\nOrt: {Category}" : $"{Name}\n{TypeText}";
+                ".url" => "Internetverknüpfung",
-
+                ".exe" => "Programm",
-    public event PropertyChangedEventHandler? PropertyChanged;
+                "" => "Datei",
-}
+                _ => ext.TrimStart('.').ToUpperInvariant() + "-Datei",
+            };
+        }
+    }
+
+    public string LocationText => SortedInto is not null ? $"✓ gesichert in {SortedInto}" : Category ?? "";
+
+    public string ToolTip =>
+        SortedInto is not null ? $"{Name}\n✓ Bereits gesichert in „{SortedInto}“ – kann vom Desktop gelöscht werden." :
+        Category is not null ? $"{Name}\nOrt: {Category}" : $"{Name}\n{TypeText}";
+
+    public event PropertyChangedEventHandler? PropertyChanged;
+}

README.md

@@ -24,18 +24,43 @@ Danach kannst du die Icons vom Desktop löschen. In DeskCore bleiben sie erhalte
 
 ---
 
+## Inhalt
+
+- [Auf einen Blick](#auf-einen-blick)
+- [Was du brauchst](#was-du-brauchst)
+- [Installieren](#installieren)
+- [So räumst du deinen Desktop auf](#so-räumst-du-deinen-desktop-auf)
+- [Programme starten](#programme-starten)
+- [Start-Gruppen – mehrere Programme mit einem Klick](#start-gruppen--mehrere-programme-mit-einem-klick)
+- [Boxen auf dem Desktop](#boxen-auf-dem-desktop)
+- [Desktop-Seiten](#desktop-seiten)
+- [Den Desktop schick machen](#den-desktop-schick-machen)
+- [Automatisch sortieren](#automatisch-sortieren)
+- [Weitere Extras](#weitere-extras)
+- [Alle Tastenkürzel](#alle-tastenkürzel)
+- [Hoppla, falsch geklickt?](#hoppla-falsch-geklickt)
+- [Häufige Fragen](#häufige-fragen)
+- [Deinstallieren](#deinstallieren)
+- [Lizenz](#lizenz)
+
+---
+
 ## Auf einen Blick
 
 | | |
 |---|---|
 | 🗂️ **Eigene Kategorien** | mit Symbol und Farbe, Reihenfolge frei wählbar |
 | ✅ **Sicher aufräumen** | Icons werden gesichert, bevor du sie vom Desktop löschst |
-| 🧱 **Desktop-Boxen** | Kategorien als verschiebbare Kästen direkt auf dem Desktop |
+| ▶️ **Start-Gruppen** | ein Klick startet mehrere Programme auf einmal |
+| 🧱 **Desktop-Boxen** | Kategorien oder Ordner als Kästen direkt auf dem Desktop, mit Tabs und eigenem Aussehen |
+| 📑 **Desktop-Seiten** | mehrere Desktops zum Umschalten, z. B. „Arbeit“ und „Freizeit“ |
+| 🎨 **Icons einfärben** | alle Desktop-Icons in einem einheitlichen Farbton |
+| 👁️ **Schnell verstecken** | Doppelklick auf den Desktop – alles weg, noch ein Doppelklick – alles wieder da |
 | ⚡ **Automatisch sortieren** | neue Icons landen per Regel von selbst in der richtigen Kategorie |
+| 🧹 **Räumt selbst auf** | deinstallierte Programme verschwinden auch aus DeskCore |
 | 🔍 **Suche** | jedes Programm in Sekunden finden |
 | ↩️ **Rückgängig** | Strg + Z macht jeden Schritt rückgängig |
 | 🌙 **Hell & Dunkel** | passt sich Windows an oder nach deinem Geschmack |
-| ⌨️ **Immer griffbereit** | Win + Umschalt + D oder Klick auf das Symbol neben der Uhr |
 | 💾 **Sicherung** | alles als ZIP sichern, z. B. für einen neuen PC |
 | 🔄 **Updates** | DeskCore sagt Bescheid, wenn es eine neue Version gibt |
 
@@ -65,11 +90,13 @@ Nur wenn „.NET“ fehlt und installiert wird, fragt Windows einmal nach. Einfa
 > Bei neuen Programmen zeigt Windows manchmal „Der Computer wurde durch Windows geschützt“.
 > Klick dann auf **„Weitere Informationen“** und danach auf **„Trotzdem ausführen“**.
 
+**Update auf eine neue Version:** Einfach den neuen Installer starten. Deine Kategorien und Einstellungen bleiben erhalten.
+
 ---
 
 ## So räumst du deinen Desktop auf
 
-### 1. Gruppe anlegen
+### 1. Kategorie anlegen
 Unten links auf **„+ Neue Kategorie“** klicken und einen Namen eingeben, z. B. **Spiele**.
 Auf Wunsch suchst du dir noch ein Symbol und eine Farbe aus.
 
@@ -91,6 +118,12 @@ Die kannst du ohne Sorge vom Desktop löschen:
 
 **Fertig!** Dein Desktop ist leer, und deine Programme findest du jetzt in DeskCore.
 
+### Kategorien verwalten
+- **Umbenennen, Symbol oder Farbe ändern:** Kategorie anklicken → oben **„Bearbeiten“**
+- **Reihenfolge ändern:** Kategorie links mit der Maus **nach oben oder unten ziehen** (oder Rechtsklick → **Nach oben / Nach unten**)
+- **Ordner im Explorer ansehen:** oben **„Im Explorer öffnen“**
+- **Löschen:** oben **„Kategorie löschen“** – die Icons landen im Papierkorb, Strg + Z holt alles zurück
+
 ---
 
 ## Programme starten
@@ -98,51 +131,216 @@ Die kannst du ohne Sorge vom Desktop löschen:
 - Kategorie links anklicken
 - **Doppelklick** auf das Icon
 
-Oder schneller: **Suchfeld** oben benutzen, den Namen eintippen und Doppelklick.
+Oder schneller: **Suchfeld** oben benutzen (Strg + F), den Namen eintippen und Doppelklick.
+Die Suche findet Programme in allen Kategorien und auf dem Desktop.
+
+Auch über das **DeskCore-Symbol neben der Uhr** kommst du per Rechtsklick direkt an deine Kategorien.
 
 ---
 
-## Nützliche Extras
+## Start-Gruppen – mehrere Programme mit einem Klick
 
-### DeskCore schnell öffnen
+Du startest jeden Tag dieselben Programme, z. B. Browser, Mail und Teams? Pack sie in eine **Start-Gruppe**.
-- **Win + Umschalt + D** drücken, von überall aus
+Ein Klick, und alle gehen nacheinander auf.
-- oder unten rechts neben der Uhr auf das **DeskCore-Symbol** klicken
 
-Wenn du das Fenster mit dem **X** schließt, läuft DeskCore unten rechts weiter.
+**Gruppe anlegen**
-Richtig beenden: **Rechtsklick auf das Symbol neben der Uhr → Beenden**
+1. Links unten bei **„Start-Gruppen“** auf das **+** klicken
+2. Namen eingeben, z. B. **Feierabend** oder **Arbeit**
+3. Einstellen, wie viele Sekunden zwischen den Programmen liegen sollen (oder „gleichzeitig“)
+
+**Programme hinzufügen**
+- Ein Icon mit der Maus **auf die Start-Gruppe ziehen**, oder
+- Rechtsklick auf ein Icon → **„Zur Start-Gruppe hinzufügen“**
+
+**Starten**
+- Auf das kleine **▶** neben der Gruppe klicken, oder
+- Gruppe anklicken → **„Alle starten“**, oder
+- Rechtsklick auf das DeskCore-Symbol neben der Uhr → **„… starten“**
+
+**Noch bequemer:** Gruppe anklicken → **„Verknüpfung auf den Desktop“**.
+Dann liegt ein Symbol auf dem Desktop, das die ganze Gruppe startet.
+
+Die Reihenfolge änderst du per Rechtsklick auf ein Programm → **„Früher starten“ / „Später starten“**.
+Ein Programm aus der Gruppe nehmen: Rechtsklick → **„Aus Start-Gruppe entfernen“**. Das Programm selbst bleibt dabei unangetastet.
+
+---
+
+## Boxen auf dem Desktop
+
+Eine **Box** ist ein Kasten direkt auf deinem Desktop, in dem die Icons einer Kategorie liegen.
+So hast du deine Programme auf dem Desktop – aber ordentlich.
+
+### Box anlegen
+Es gibt drei Wege:
+- Kategorie in DeskCore anklicken → oben **„Als Box auf den Desktop“**
+- Mit **gedrückter rechter Maustaste** auf einer freien Stelle des Desktops **einen Rahmen ziehen**. Danach wählst du, welche Kategorie hinein soll – oder legst gleich eine neue an.
+  (Ein ganz normaler Rechtsklick öffnet weiterhin das gewohnte Windows-Menü.)
+- **Einstellungen → Desktop-Boxen → Boxen auf dem Desktop anzeigen** schaltet alle Boxen auf einmal ein oder aus
+
+### Mit Boxen arbeiten
+- **Verschieben:** an der Titelleiste ziehen
+- **Größe ändern:** am Rand ziehen
+- **Einklappen:** Doppelklick auf den Titel – noch ein Doppelklick klappt sie wieder auf. Fährst du mit der Maus über eine eingeklappte Box, geht sie kurz auf.
+- **Programm starten:** Doppelklick auf das Icon
+- **Rechtsklick auf ein Icon:** Öffnen, Umbenennen, Löschen, in eine andere Kategorie verschieben oder **„Zurück auf den Desktop legen“**
+- Icons lassen sich auch einfach in eine Box hinein- oder aus ihr herausziehen
+
+Das **Menü einer Box** (die drei Punkte ⋯ oben rechts) bietet:
+
+| Menüpunkt | Was passiert |
+|---|---|
+| **Tab hinzufügen** | Eine weitere Kategorie in dieselbe Box packen. Oben erscheinen dann Reiter zum Umschalten. |
+| **Ordner-Portal …** | Einen Ordner als Reiter hinzufügen (siehe unten) |
+| **Aussehen …** | Farbe, Deckkraft, Milchglas, Icon-Größe, Sortierung und Icon-Tönung der Box |
+| **Sperren** | Die Box lässt sich nicht mehr versehentlich verschieben oder in der Größe ändern |
+| **Auf Seite verschieben** | Die Box auf eine andere [Desktop-Seite](#desktop-seiten) schicken |
+| **Box schließen** | Die Box verschwindet vom Desktop. Die Kategorie in DeskCore bleibt natürlich erhalten. |
+
+Rechtsklick auf einen **Reiter**: **„Als eigene Box lösen“** macht daraus wieder eine eigene Box, **„Tab entfernen“** nimmt ihn heraus.
+
+### Ordner-Portal
+Ein Portal ist eine Box, die **live einen beliebigen Ordner** zeigt, z. B. **Downloads** oder einen Projektordner.
+Neue Dateien erscheinen sofort darin, und Unterordner öffnest du direkt in der Box.
+Anlegen: **Einstellungen → Desktop-Boxen → Ordner-Portal → „Ordner wählen …“** oder beim Aufziehen einer Box **„Ordner-Portal …“** wählen.
+
+### Peek – Boxen nach vorne holen
+Alle Fenster sind offen und verdecken den Desktop? Drück **Win + Umschalt + B**.
+Die Boxen kommen nach vorne, über alle Fenster. Nochmal drücken, **Esc** oder woanders hinklicken schickt sie zurück.
+Ein- und ausschalten unter **Einstellungen → Peek**.
+
+### Anordnungen speichern (Snapshots)
+Du hast deine Boxen perfekt angeordnet? Speicher dir das:
+**Einstellungen → Snapshots → „Aktuelle Anordnung speichern“**.
+Mit **„Wiederherstellen“** ist später alles wieder genau so – auch über das DeskCore-Symbol neben der Uhr.
+
+Arbeitest du mal am Laptop allein und mal mit Monitor? DeskCore merkt sich die Positionen der Boxen **für jede Bildschirm-Anordnung automatisch**.
+
+---
+
+## Desktop-Seiten
+
+Du kannst **mehrere Desktop-Seiten** anlegen, z. B. **Arbeit** und **Freizeit** – jede Seite hat ihre eigenen Boxen.
+So siehst du nach Feierabend nur deine Spiele und tagsüber nur deine Arbeitsprogramme.
+
+**Seiten anlegen:** **Einstellungen → Desktop-Seiten → „Seite hinzufügen“**.
+Dort kannst du Seiten auch umbenennen (Stift) oder löschen (Mülleimer). Die Boxen einer gelöschten Seite wandern auf die Seite davor, es geht also nichts verloren.
+
+**Zwischen Seiten wechseln:**
+- **Win + Alt + ←** oder **→**
+- **Mausrad** drehen, während die Maus über einer freien Stelle des Desktops ist
+- Rechtsklick auf das DeskCore-Symbol neben der Uhr → **„Desktop-Seite“**
+- in den Einstellungen bei der Seite auf **„Anzeigen“**
+
+Beim Wechseln zeigt DeskCore kurz unten am Bildschirm, auf welcher Seite du bist.
+Neue Boxen landen immer auf der Seite, die gerade angezeigt wird. Eine Box auf eine andere Seite schicken: Box-Menü ⋯ → **„Auf Seite verschieben“**.
+
+> Die Icons, die direkt auf dem Desktop liegen (nicht in einer Box), siehst du auf jeder Seite.
+
+---
+
+## Den Desktop schick machen
+
+### Desktop-Icons einfärben
+**Einstellungen → Desktop-Icons tönen:** eine Farbe anklicken, und alle Icons auf dem Desktop bekommen denselben Farbton.
+Mit dem Regler **„Stärke“** stellst du ein, wie kräftig. Der erste, leere Kreis schaltet die Tönung wieder aus.
+Die Icons in den Boxen färbst du getrennt über das Box-Menü ⋯ → **„Aussehen …“**.
+
+### Schnell verstecken
+**Doppelklick auf eine freie Stelle des Desktops** blendet alle Icons und Boxen aus – perfekt für ein sauberes Hintergrundbild oder eine Bildschirmfreigabe.
+Noch ein Doppelklick holt alles zurück. Einschalten unter **Einstellungen → Schnell verstecken**.
+
+### Chamäleon
+Die Boxen werden fast unsichtbar und erscheinen erst, wenn du mit der Maus darüberfährst.
+Einschalten unter **Einstellungen → Chamäleon**.
 
 ### Hell oder Dunkel
-Oben rechts auf die **Sonne bzw. den Mond** klicken und auswählen.
+Oben rechts auf die **Sonne bzw. den Mond** klicken und auswählen – oder **„Wie Windows“**, dann passt sich DeskCore automatisch an.
-
-### Boxen auf dem Desktop
-Eine Kategorie kann als kleine **Box direkt auf dem Desktop** erscheinen:
-Kategorie anklicken und oben auf **„Als Box auf den Desktop“** klicken.
-Die Box kannst du verschieben und in der Größe ändern. Ein Doppelklick auf ihren Titel klappt sie ein und aus.
-
-### Automatisch sortieren
-DeskCore kann neue Icons selbst einsortieren, z. B. alles mit „Steam“ im Namen → **Spiele**.
-Einstellen kannst du das unter **Einstellungen → Automatisch sortieren → Regel hinzufügen**.
-
-### Reihenfolge der Kategorien
-Kategorie links mit der Maus **nach oben oder unten ziehen**.
-Oder per Rechtsklick → **Nach oben / Nach unten**.
 
 ### Ansicht
 Oben rechts gibt es den **Ansicht-Knopf**: kleine, mittlere oder große Symbole oder eine Liste.
 
-### Icons in den Desktop-Boxen
+---
-Auch in einer Box auf dem Desktop kannst du per **Rechtsklick** umbenennen, löschen, in eine andere Kategorie verschieben
+
-oder zurück auf den Desktop legen. Icons lassen sich auch einfach aus der Box herausziehen.
+## Automatisch sortieren
+
+DeskCore kann neue Icons selbst einsortieren. Sobald z. B. ein Installer eine Verknüpfung auf den Desktop legt, wandert sie in die richtige Kategorie.
+
+So geht's: **Einstellungen → Automatisch sortieren → „Regel hinzufügen“**. Es gibt zwei Arten von Regeln
+(zum Umschalten auf die Art der Regel klicken):
+
+| Regel | Beispiel |
+|---|---|
+| **Name enthält** | alles mit „Steam“ im Namen → **Spiele** |
+| **Dateityp ist** | Bilder, Videos, Musik, Dokumente, Archive, Programme, Ordner – oder Endungen wie „pdf, docx“ → **Dokumente** |
+
+Die erste passende Regel gewinnt. Groß- und Kleinschreibung ist egal.
+Mit **„Danach vom Desktop entfernen“** verschwindet das Original gleich vom Desktop.
+**„Jetzt auf den Desktop anwenden“** sortiert alles ein, was schon auf dem Desktop liegt.
+
+---
+
+## Weitere Extras
+
+### DeskCore schnell öffnen
+- **Win + Umschalt + D** drücken, von überall aus (änderbar unter **Einstellungen → Tastenkürzel**)
+- oder unten rechts neben der Uhr auf das **DeskCore-Symbol** klicken
+
+Wenn du das Fenster mit dem **X** schließt, läuft DeskCore unten rechts weiter – deine Boxen bleiben also da.
+Richtig beenden: **Rechtsklick auf das Symbol neben der Uhr → Beenden**
+
+### Das Symbol neben der Uhr
+Ein Rechtsklick darauf bietet dir alles Wichtige, ohne das Fenster zu öffnen:
+deine Kategorien, Start-Gruppen, gespeicherte Anordnungen, Desktop-Seiten und **„Desktop ausblenden“**.
+
+### Mit Windows starten
+**Einstellungen → Mit Windows starten.** DeskCore startet dann unauffällig neben der Uhr, und Boxen sowie Auto-Sortierung sind sofort da.
+
+### Deinstallierte Programme verschwinden von selbst
+Deinstallierst du ein Programm, entfernt DeskCore dessen Icon nach etwa einer Minute auch aus deinen Kategorien – auch bei **Steam- und Epic-Spielen**.
+Strg + Z holt es zurück. Ausschalten unter **Einstellungen → Deinstallierte Programme entfernen**.
+
+### Sicherung
+**Einstellungen → Sicherung → „Sichern …“** speichert alle Kategorien, Boxen, Start-Gruppen und Einstellungen in eine ZIP-Datei.
+Mit **„Wiederherstellen …“** holst du alles zurück, z. B. auf einem neuen PC.
 
 ### Updates
 DeskCore schaut einmal am Tag nach, ob es eine neue Version gibt.
 Wenn ja, erscheint oben ein Hinweis. Ein Klick auf **„Jetzt aktualisieren“** genügt, und DeskCore startet danach von selbst neu.
+Prüfen von Hand: **Einstellungen → Updates → „Jetzt prüfen“**.
+
+---
+
+## Alle Tastenkürzel
+
+**Überall in Windows**
+
+| Taste | Was passiert |
+|---|---|
+| **Win + Umschalt + D** | DeskCore öffnen / verstecken |
+| **Win + Umschalt + B** | Peek: Boxen nach vorne holen |
+| **Win + Alt + ← / →** | Desktop-Seite wechseln |
+
+**Im DeskCore-Fenster**
+
+| Taste | Was passiert |
+|---|---|
+| **Strg + F** | Suchen |
+| **Esc** | Suche leeren |
+| **Strg + A** | Alles markieren |
+| **Enter** | Öffnen |
+| **F2** | Umbenennen |
+| **Entf** | Löschen |
+| **Strg + Z** | Rückgängig |
+| **Strg + N** | Neue Kategorie |
+| **Alt + ↑ / ↓** | Kategorie nach oben / unten verschieben |
+| **Strg + 1 … 9** | Zur Kategorie 1 … 9 springen |
+| **F5** | Aktualisieren |
 
 ---
 
 ## Hoppla, falsch geklickt?
 
-**Strg + Z** macht den letzten Schritt rückgängig.
+**Strg + Z** macht den letzten Schritt rückgängig – auch mehrmals hintereinander.
 Unten im Fenster erscheint nach vielen Aktionen auch kurz ein Knopf **„Rückgängig“**.
 
 ---
@@ -156,6 +354,21 @@ Auch wenn DeskCore mal nicht läuft, ist also nichts weg.
 **Ich habe etwas gelöscht. Ist es für immer weg?**
 Nein. Erst geht **Strg + Z**, und danach liegt es noch im **Papierkorb** von Windows.
 
+**Ich habe ein Programm deinstalliert – verschwindet es auch aus DeskCore?**
+Ja, automatisch nach etwa einer Minute – auch bei **Steam- und Epic-Spielen**. Hast du es dir anders überlegt: **Strg + Z** holt es zurück.
+Programme auf einem gerade abgesteckten USB- oder Netzlaufwerk bleiben natürlich erhalten.
+
+**Mein Rechtsklick auf den Desktop fühlt sich anders an.**
+Damit du Boxen aufziehen kannst, schaut DeskCore kurz, ob du ziehst oder nur klickst. Das Windows-Menü erscheint deshalb erst beim **Loslassen** der Taste.
+Stört dich das: **Einstellungen → Box auf dem Desktop aufziehen** ausschalten.
+
+**Das Mausrad wechselt ungewollt die Desktop-Seite.**
+Unter **Einstellungen → Desktop-Seiten** den Haken bei **„Mit dem Mausrad … wechseln“** entfernen.
+Mit gedrückter **Strg**-Taste ändert das Mausrad wie gewohnt die Icon-Größe des Desktops.
+
+**Die Farbe der Icon-Tönung sitzt nicht genau auf den Icons.**
+Kurz warten – DeskCore liest die Positionen alle zwei Sekunden neu. Hast du gerade die Bildschirmskalierung geändert, hilft ein Neustart von DeskCore.
+
 **Ein Icon lässt sich nicht verschieben („Keine Berechtigung“).**
 Manche Icons gehören allen Benutzern des PCs. Dafür DeskCore einmal mit
 **Rechtsklick → „Als Administrator ausführen“** starten.
@@ -166,14 +379,26 @@ Beim Kopieren siehst du einen Fortschrittsbalken und kannst jederzeit **abbreche
 
 **Ich habe einen Bildschirm abgesteckt und das Fenster ist weg.**
 Keine Sorge: DeskCore und die Desktop-Boxen holen sich automatisch auf den verbliebenen Bildschirm zurück.
+Steckst du den Bildschirm wieder an, kommen die Boxen an ihre alten Plätze.
 
 **Ich bekomme einen neuen PC. Was jetzt?**
 **Einstellungen → Sicherung → „Sichern …“** speichert alles in eine ZIP-Datei.
 Auf dem neuen PC installierst du DeskCore und wählst **„Wiederherstellen …“**.
 
-**Das Tastenkürzel funktioniert nicht.**
+**Ein Tastenkürzel funktioniert nicht.**
 Ein anderes Programm benutzt es vielleicht schon. Unter **Einstellungen → Tastenkürzel** ins Feld klicken und eine andere Kombination drücken.
 
+**Kann ich DeskCore auch per Verknüpfung oder Skript steuern?**
+Ja, für Fortgeschrittene:
+
+| Befehl | Was passiert |
+|---|---|
+| `DeskCore.exe --launch "Feierabend"` | Start-Gruppe „Feierabend“ starten |
+| `DeskCore.exe --snapshot "Arbeit"` | Gespeicherte Anordnung „Arbeit“ wiederherstellen |
+| `DeskCore.exe --page "Freizeit"` | Zur Desktop-Seite „Freizeit“ wechseln (oder `--page 2`) |
+| `DeskCore.exe --toggle-desktop` | Desktop aus- / einblenden |
+| `DeskCore.exe --peek` | Boxen nach vorne holen |
+
 ---
 
 ## Deinstallieren

Screens.cs

@@ -1,39 +1,39 @@
-using System.Windows;
+using System.Windows;
-
+
-namespace DeskCore;
+namespace DeskCore;
-
+
-/// <summary>Bildschirm-Hilfen, damit Fenster nie außerhalb des sichtbaren Bereichs landen (z. B. nach Abstecken eines Monitors).</summary>
+/// <summary>Bildschirm-Hilfen, damit Fenster nie außerhalb des sichtbaren Bereichs landen (z. B. nach Abstecken eines Monitors).</summary>
-public static class Screens
+public static class Screens
-{
+{
-    /// <summary>Umrechnung Pixel → WPF-Einheiten (System-DPI).</summary>
+    /// <summary>Umrechnung Pixel → WPF-Einheiten (System-DPI).</summary>
-    private static double Scale
+    public static double Scale
-    {
+    {
-        get
+        get
-        {
+        {
-            using var g = System.Drawing.Graphics.FromHwnd(IntPtr.Zero);
+            using var g = System.Drawing.Graphics.FromHwnd(IntPtr.Zero);
-            return g.DpiX / 96.0;
+            return g.DpiX / 96.0;
-        }
+        }
-    }
+    }
-
+
-    /// <summary>Arbeitsbereiche (ohne Taskleiste) aller angeschlossenen Bildschirme in WPF-Einheiten.</summary>
+    /// <summary>Arbeitsbereiche (ohne Taskleiste) aller angeschlossenen Bildschirme in WPF-Einheiten.</summary>
-    public static List<Rect> WorkAreas()
+    public static List<Rect> WorkAreas()
-    {
+    {
-        var s = Scale;
+        var s = Scale;
-        return System.Windows.Forms.Screen.AllScreens
+        return System.Windows.Forms.Screen.AllScreens
-            .Select(m => new Rect(m.WorkingArea.X / s, m.WorkingArea.Y / s, m.WorkingArea.Width / s, m.WorkingArea.Height / s))
+            .Select(m => new Rect(m.WorkingArea.X / s, m.WorkingArea.Y / s, m.WorkingArea.Width / s, m.WorkingArea.Height / s))
-            .ToList();
+            .ToList();
-    }
+    }
-
+
-    public static Rect PrimaryWorkArea => SystemParameters.WorkArea;
+    public static Rect PrimaryWorkArea => SystemParameters.WorkArea;
-
+
-    /// <summary>Ist genug vom Fenster (Titelleiste) auf irgendeinem Bildschirm sichtbar, um es greifen zu können?</summary>
+    /// <summary>Ist genug vom Fenster (Titelleiste) auf irgendeinem Bildschirm sichtbar, um es greifen zu können?</summary>
-    public static bool IsReachable(Rect window)
+    public static bool IsReachable(Rect window)
-    {
+    {
-        var title = new Rect(window.X, window.Y, window.Width, Math.Min(40, window.Height));
+        var title = new Rect(window.X, window.Y, window.Width, Math.Min(40, window.Height));
-        return WorkAreas().Any(a =>
+        return WorkAreas().Any(a =>
-        {
+        {
-            var i = Rect.Intersect(a, title);
+            var i = Rect.Intersect(a, title);
-            return !i.IsEmpty && i.Width >= Math.Min(120, window.Width / 2) && i.Height >= 20;
+            return !i.IsEmpty && i.Width >= Math.Min(120, window.Width / 2) && i.Height >= 20;
-        });
+        });
-    }
+    }
-}
+}

Settings.cs

@@ -1,141 +1,303 @@
-using System.IO;
+using System.IO;
-using System.Text.Json;
+using System.Text.Json;
-using System.Text.Json.Serialization;
+using System.Text.Json.Serialization;
-
+
-namespace DeskCore;
+namespace DeskCore;
-
+
-public enum DesignMode { System, Light, Dark }
+public enum DesignMode { System, Light, Dark }
-public enum ViewMode { Small, Medium, Large, List }
+public enum ViewMode { Small, Medium, Large, List }
-
+
-public class CategoryMeta
+public class CategoryMeta
-{
+{
-    public string? Glyph { get; set; }
+    public string? Glyph { get; set; }
-    public string? Color { get; set; }
+    public string? Color { get; set; }
-    public bool Fence { get; set; }
+    // Die folgenden Box-Felder stammen aus Version 1.0.x und werden nur noch beim Umstieg auf FenceDef gelesen
-    public double? FenceX { get; set; }
+    public bool Fence { get; set; }
-    public double? FenceY { get; set; }
+    public double? FenceX { get; set; }
-    public double FenceW { get; set; } = 340;
+    public double? FenceY { get; set; }
-    public double FenceH { get; set; } = 260;
+    public double FenceW { get; set; } = 340;
-    public bool FenceCollapsed { get; set; }
+    public double FenceH { get; set; } = 260;
-}
+    public bool FenceCollapsed { get; set; }
-
+}
-public class SortRule
+
-{
+/// <summary>Eine Start-Gruppe: ein Klick startet mehrere Programme nacheinander.</summary>
-    public string Contains { get; set; } = "";
+public class LaunchGroup
-    public string Category { get; set; } = "";
+{
-}
+    public string Name { get; set; } = "";
-
+    /// <summary>Pfade in Startreihenfolge (meist Verknüpfungen aus den Kategorien).</summary>
-/// <summary>Alle Einstellungen, gespeichert in %APPDATA%\DeskCore\settings.json.</summary>
+    public List<string> Items { get; set; } = [];
-public class AppSettings
+    /// <summary>Wartezeit zwischen zwei Programmen in Sekunden.</summary>
-{
+    public double DelaySeconds { get; set; } = 1;
-    public DesignMode Design { get; set; } = DesignMode.System;
+    public string? Color { get; set; }
-    public ViewMode View { get; set; } = ViewMode.Medium;
+}
-
+
-    public bool TrayEnabled { get; set; } = true;
+public class SortRule
-    public bool CloseToTray { get; set; } = true;
+{
-    public bool TrayHintShown { get; set; }
+    /// <summary>"Name" = Name enthält …, "Typ" = Dateityp ist … (z. B. "Bilder" oder "pdf, docx")</summary>
-
+    public string Kind { get; set; } = "Name";
-    public bool HotkeyEnabled { get; set; } = true;
+    public string Contains { get; set; } = "";
-    public int HotkeyModifiers { get; set; } = Hotkey.ModWin | Hotkey.ModShift;
+    public string Category { get; set; } = "";
-    public int HotkeyKey { get; set; } = 0x44; // D
+    [JsonIgnore] public string KindText => Kind == "Typ" ? "Dateityp ist" : "Name enthält";
-
+}
-    public bool AutoSort { get; set; }
+
-    public bool AutoSortRemoveFromDesktop { get; set; }
+/// <summary>Ein Tab einer Desktop-Box: eine Kategorie oder ein beliebiger Ordner ("Ordner-Portal").</summary>
-    public List<SortRule> Rules { get; set; } = [];
+public class FenceTab
-
+{
-    public bool FencesEnabled { get; set; } = true;
+    public const string CategoryKind = "Kategorie", FolderKind = "Ordner";
-
+    public string Kind { get; set; } = CategoryKind;
-    // Fenster merken (WPF-Einheiten)
+    /// <summary>Kategoriename bzw. Ordnerpfad.</summary>
-    public double? WindowLeft { get; set; }
+    public string Value { get; set; } = "";
-    public double? WindowTop { get; set; }
+    [JsonIgnore] public bool IsFolder => Kind == FolderKind;
-    public double? WindowWidth { get; set; }
+    [JsonIgnore] public string Title => IsFolder ? Path.GetFileName(Value.TrimEnd('\\')) is { Length: > 0 } n ? n : Value : Value;
-    public double? WindowHeight { get; set; }
+}
-    public bool WindowMaximized { get; set; }
+
-
+/// <summary>Eine Desktop-Box mit Position, Tabs und Aussehen.</summary>
-    // Updates
+public class FenceDef
-    public bool AutoUpdateCheck { get; set; } = true;
+{
-    public DateTime? LastUpdateCheck { get; set; }
+    public string Id { get; set; } = Guid.NewGuid().ToString("N");
-    public string? SkippedVersion { get; set; }
+    public List<FenceTab> Tabs { get; set; } = [];
-
+    public int ActiveTab { get; set; }
-    public List<string> CategoryOrder { get; set; } = [];
+    public double? X { get; set; }
-    public Dictionary<string, CategoryMeta> Categories { get; set; } = new(StringComparer.OrdinalIgnoreCase);
+    public double? Y { get; set; }
-
+    public double W { get; set; } = 340;
-    // ---------- Laden/Speichern ----------
+    public double H { get; set; } = 260;
-
+    public bool Collapsed { get; set; }
-    public static readonly string Folder = Migration.Pick(Environment.SpecialFolder.ApplicationData);
+    /// <summary>Gesperrt: nicht verschieb- oder vergrößerbar.</summary>
-    private static readonly string FilePath = Path.Combine(Folder, "settings.json");
+    public bool Locked { get; set; }
-
+    /// <summary>Hintergrundfarbe (#RRGGBB) oder null = passend zum Design.</summary>
-    public static readonly JsonSerializerOptions Json = new()
+    public string? Background { get; set; }
-    {
+    /// <summary>Deckkraft des Hintergrunds 0.2–1.</summary>
-        WriteIndented = true,
+    public double Opacity { get; set; } = 0.92;
-        Converters = { new JsonStringEnumConverter() },
+    /// <summary>Milchglas-Effekt (Hintergrund verschwommen).</summary>
-    };
+    public bool Blur { get; set; }
-
+    public ViewMode IconSize { get; set; } = ViewMode.Medium;
-    public static AppSettings Current { get; private set; } = Load();
+    /// <summary>"Name", "Typ" oder "Datum"</summary>
-
+    public string Sort { get; set; } = "Name";
-    public static event Action? Saved;
+    /// <summary>Icon-Tönung (#RRGGBB) oder null.</summary>
-
+    public string? Tint { get; set; }
-    private static AppSettings Load()
+
-    {
+    /// <summary>Desktop-Seite, auf der die Box liegt (0 = erste Seite).</summary>
-        AppSettings s;
+    public int Page { get; set; }
-        try
+
-        {
+    [JsonIgnore] public FenceTab? Active => Tabs.Count == 0 ? null : Tabs[Math.Clamp(ActiveTab, 0, Tabs.Count - 1)];
-            s = File.Exists(FilePath)
+}
-                ? JsonSerializer.Deserialize<AppSettings>(File.ReadAllText(FilePath), Json) ?? new()
+
-                : new();
+/// <summary>Gespeicherte Anordnung aller Desktop-Boxen.</summary>
-        }
+public class FenceSnapshot
-        catch { s = new(); }
+{
-
+    public string Name { get; set; } = "";
-        s.Categories = new(s.Categories ?? [], StringComparer.OrdinalIgnoreCase);
+    public DateTime Created { get; set; } = DateTime.Now;
-        s.Rules ??= [];
+    public List<FenceDef> Fences { get; set; } = [];
-        s.CategoryOrder ??= [];
+    [JsonIgnore] public string Info => $"{Fences.Count} {(Fences.Count == 1 ? "Box" : "Boxen")} · gespeichert am {Created:dd.MM.yyyy HH:mm}";
-
+}
-        // Übernahme der alten Einstellung aus Version 2
+
-        var old = Path.Combine(Folder, "design.txt");
+/// <summary>Alle Einstellungen, gespeichert in %APPDATA%\DeskCore\settings.json.</summary>
-        if (File.Exists(old))
+public class AppSettings
-        {
+{
-            try
+    public DesignMode Design { get; set; } = DesignMode.System;
-            {
+    public ViewMode View { get; set; } = ViewMode.Medium;
-                var v = File.ReadAllText(old).Trim();
+
-                s.Design = v == "Light" ? DesignMode.Light : v == "Dark" ? DesignMode.Dark : DesignMode.System;
+    public bool TrayEnabled { get; set; } = true;
-                File.Delete(old);
+    public bool CloseToTray { get; set; } = true;
-            }
+    public bool TrayHintShown { get; set; }
-            catch { }
+
-        }
+    public bool HotkeyEnabled { get; set; } = true;
-        return s;
+    public int HotkeyModifiers { get; set; } = Hotkey.ModWin | Hotkey.ModShift;
-    }
+    public int HotkeyKey { get; set; } = 0x44; // D
-
+
-    public void Save()
+    public bool AutoSort { get; set; }
-    {
+    public bool AutoSortRemoveFromDesktop { get; set; }
-        try
+    public List<SortRule> Rules { get; set; } = [];
-        {
+
-            Directory.CreateDirectory(Folder);
+    public bool FencesEnabled { get; set; } = true;
-            File.WriteAllText(FilePath, JsonSerializer.Serialize(this, Json));
+    public List<FenceDef> Fences { get; set; } = [];
-        }
+    public List<FenceSnapshot> Snapshots { get; set; } = [];
-        catch { }
+    /// <summary>Box-Positionen je Bildschirm-Anordnung (Signatur → Box-Id → x, y, w, h).</summary>
-        Saved?.Invoke();
+    public Dictionary<string, Dictionary<string, double[]>> ScreenLayouts { get; set; } = [];
-    }
+    /// <summary>Chamäleon: Boxen blenden sich aus, bis die Maus darüberfährt.</summary>
-
+    public bool FenceChameleon { get; set; }
-    public CategoryMeta Meta(string category)
+    /// <summary>Doppelklick auf eine freie Desktop-Stelle blendet Icons und Boxen aus/ein.</summary>
-    {
+    public bool QuickHide { get; set; } = true;
-        if (!Categories.TryGetValue(category, out var m))
+    /// <summary>Peek: Tastenkürzel holt alle Boxen vor die Fenster.</summary>
-            Categories[category] = m = new CategoryMeta();
+    public bool PeekEnabled { get; set; } = true;
-        return m;
+    public int PeekModifiers { get; set; } = Hotkey.ModWin | Hotkey.ModShift;
-    }
+    public int PeekKey { get; set; } = 0x42; // B wie "Boxen"
-
+
-    public void RenameCategory(string oldName, string newName)
+    /// <summary>Desktop-Seiten: jede Seite hat ihre eigenen Boxen.</summary>
-    {
+    public List<string> Pages { get; set; } = ["Seite 1"];
-        if (Categories.Remove(oldName, out var m)) Categories[newName] = m;
+    public int CurrentPage { get; set; }
-        for (int i = 0; i < CategoryOrder.Count; i++)
+    /// <summary>Mausrad über einer freien Desktop-Stelle wechselt die Seite.</summary>
-            if (string.Equals(CategoryOrder[i], oldName, StringComparison.OrdinalIgnoreCase)) CategoryOrder[i] = newName;
+    public bool PageWheel { get; set; } = true;
-        foreach (var r in Rules)
+
-            if (string.Equals(r.Category, oldName, StringComparison.OrdinalIgnoreCase)) r.Category = newName;
+    /// <summary>Rechte Maustaste auf freier Desktop-Fläche ziehen → neue Box.</summary>
-    }
+    public bool DrawFences { get; set; } = true;
-
+
-    public void RemoveCategory(string name)
+    /// <summary>Tönung der echten Desktop-Icons (#RRGGBB) oder null = aus.</summary>
-    {
+    public string? DesktopTint { get; set; }
-        Categories.Remove(name);
+    public double DesktopTintStrength { get; set; } = 0.55;
-        CategoryOrder.RemoveAll(n => string.Equals(n, name, StringComparison.OrdinalIgnoreCase));
+
-        Rules.RemoveAll(r => string.Equals(r.Category, name, StringComparison.OrdinalIgnoreCase));
+    /// <summary>Verknüpfungen zu deinstallierten Programmen automatisch entfernen.</summary>
-    }
+    public bool RemoveDeadShortcuts { get; set; } = true;
-}
+    /// <summary>Tote Verknüpfungen, die der Nutzer per Rückgängig behalten wollte.</summary>
+    public List<string> KeptShortcuts { get; set; } = [];
+
+    // Fenster merken (WPF-Einheiten)
+    public double? WindowLeft { get; set; }
+    public double? WindowTop { get; set; }
+    public double? WindowWidth { get; set; }
+    public double? WindowHeight { get; set; }
+    public bool WindowMaximized { get; set; }
+
+    // Updates
+    public bool AutoUpdateCheck { get; set; } = true;
+    public DateTime? LastUpdateCheck { get; set; }
+    public string? SkippedVersion { get; set; }
+
+    public List<string> CategoryOrder { get; set; } = [];
+    public List<LaunchGroup> LaunchGroups { get; set; } = [];
+    public Dictionary<string, CategoryMeta> Categories { get; set; } = new(StringComparer.OrdinalIgnoreCase);
+
+    // ---------- Laden/Speichern ----------
+
+    public static readonly string Folder = Migration.Pick(Environment.SpecialFolder.ApplicationData);
+    private static readonly string FilePath = Path.Combine(Folder, "settings.json");
+
+    public static readonly JsonSerializerOptions Json = new()
+    {
+        WriteIndented = true,
+        Converters = { new JsonStringEnumConverter() },
+    };
+
+    public static AppSettings Current { get; private set; } = Load();
+
+    public static event Action? Saved;
+
+    private static AppSettings Load()
+    {
+        AppSettings s;
+        try
+        {
+            s = File.Exists(FilePath)
+                ? JsonSerializer.Deserialize<AppSettings>(File.ReadAllText(FilePath), Json) ?? new()
+                : new();
+        }
+        catch { s = new(); }
+
+        s.Categories = new(s.Categories ?? [], StringComparer.OrdinalIgnoreCase);
+        s.Rules ??= [];
+        s.CategoryOrder ??= [];
+        s.KeptShortcuts ??= [];
+        s.LaunchGroups ??= [];
+        s.Fences ??= [];
+        s.Snapshots ??= [];
+        s.ScreenLayouts ??= [];
+        if (s.Pages is null || s.Pages.Count == 0) s.Pages = ["Seite 1"];
+        s.CurrentPage = Math.Clamp(s.CurrentPage, 0, s.Pages.Count - 1);
+
+        // Umstieg von 1.0.x: Box gehörte fest zu einer Kategorie → eigenständige Box mit einem Tab
+        foreach (var (name, meta) in s.Categories)
+        {
+            if (!meta.Fence) continue;
+            s.Fences.Add(new FenceDef
+            {
+                Tabs = [new FenceTab { Value = name }],
+                X = meta.FenceX, Y = meta.FenceY, W = meta.FenceW, H = meta.FenceH, Collapsed = meta.FenceCollapsed,
+            });
+            meta.Fence = false;
+        }
+
+        // Übernahme der alten Einstellung aus Version 2
+        var old = Path.Combine(Folder, "design.txt");
+        if (File.Exists(old))
+        {
+            try
+            {
+                var v = File.ReadAllText(old).Trim();
+                s.Design = v == "Light" ? DesignMode.Light : v == "Dark" ? DesignMode.Dark : DesignMode.System;
+                File.Delete(old);
+            }
+            catch { }
+        }
+        return s;
+    }
+
+    public void Save()
+    {
+        try
+        {
+            Directory.CreateDirectory(Folder);
+            File.WriteAllText(FilePath, JsonSerializer.Serialize(this, Json));
+        }
+        catch { }
+        Saved?.Invoke();
+    }
+
+    public CategoryMeta Meta(string category)
+    {
+        if (!Categories.TryGetValue(category, out var m))
+            Categories[category] = m = new CategoryMeta();
+        return m;
+    }
+
+    public void RenameCategory(string oldName, string newName)
+    {
+        if (Categories.Remove(oldName, out var m)) Categories[newName] = m;
+        for (int i = 0; i < CategoryOrder.Count; i++)
+            if (string.Equals(CategoryOrder[i], oldName, StringComparison.OrdinalIgnoreCase)) CategoryOrder[i] = newName;
+        foreach (var r in Rules)
+            if (string.Equals(r.Category, oldName, StringComparison.OrdinalIgnoreCase)) r.Category = newName;
+        foreach (var t in Fences.SelectMany(f => f.Tabs))
+            if (!t.IsFolder && string.Equals(t.Value, oldName, StringComparison.OrdinalIgnoreCase)) t.Value = newName;
+        // Start-Gruppen zeigen auf Dateien in der Kategorie → Pfade mit umbenennen
+        var oldDir = Storage.CategoryPath(oldName).TrimEnd('\\') + "\\";
+        var newDir = Storage.CategoryPath(newName).TrimEnd('\\') + "\\";
+        foreach (var g in LaunchGroups)
+            for (int i = 0; i < g.Items.Count; i++)
+                if (g.Items[i].StartsWith(oldDir, StringComparison.OrdinalIgnoreCase))
+                    g.Items[i] = newDir + g.Items[i][oldDir.Length..];
+    }
+
+    /// <summary>Wird diese Kategorie in irgendeiner Box angezeigt?</summary>
+    public bool HasFence(string category) =>
+        Fences.Any(f => f.Tabs.Any(t => !t.IsFolder && string.Equals(t.Value, category, StringComparison.OrdinalIgnoreCase)));
+
+    /// <summary>Kategorie als eigene Box anzeigen bzw. aus allen Boxen entfernen.</summary>
+    public void SetFence(string category, bool on)
+    {
+        if (on)
+        {
+            if (!HasFence(category)) Fences.Add(new FenceDef { Page = CurrentPage, Tabs = [new FenceTab { Value = category }] });
+            FencesEnabled = true;
+        }
+        else
+        {
+            foreach (var f in Fences)
+                f.Tabs.RemoveAll(t => !t.IsFolder && string.Equals(t.Value, category, StringComparison.OrdinalIgnoreCase));
+            Fences.RemoveAll(f => f.Tabs.Count == 0);
+        }
+    }
+
+    /// <summary>Tiefe Kopie (für Snapshots).</summary>
+    public static List<FenceDef> CloneFences(List<FenceDef> fences) =>
+        JsonSerializer.Deserialize<List<FenceDef>>(JsonSerializer.Serialize(fences, Json), Json) ?? [];
+
+    /// <summary>Datei wurde umbenannt/verschoben → Start-Gruppen zeigen auf den neuen Pfad.</summary>
+    public void ReplaceLaunchPath(string oldPath, string newPath)
+    {
+        bool changed = false;
+        foreach (var g in LaunchGroups)
+            for (int i = 0; i < g.Items.Count; i++)
+                if (string.Equals(g.Items[i], oldPath, StringComparison.OrdinalIgnoreCase)) { g.Items[i] = newPath; changed = true; }
+        if (changed) Save();
+    }
+
+    public void RemoveCategory(string name)
+    {
+        foreach (var f in Fences)
+            f.Tabs.RemoveAll(t => !t.IsFolder && string.Equals(t.Value, name, StringComparison.OrdinalIgnoreCase));
+        Fences.RemoveAll(f => f.Tabs.Count == 0);
+        Categories.Remove(name);
+        CategoryOrder.RemoveAll(n => string.Equals(n, name, StringComparison.OrdinalIgnoreCase));
+        Rules.RemoveAll(r => string.Equals(r.Category, name, StringComparison.OrdinalIgnoreCase));
+    }
+}

Storage.cs

@@ -1,392 +1,476 @@
-using System.Collections.Concurrent;
+using System.Collections.Concurrent;
-using System.IO;
+using System.IO;
-
+
-namespace DeskCore;
+namespace DeskCore;
-
+
-public enum TransferStatus { Ok, Skipped, Error, Cancelled }
+public enum TransferStatus { Ok, Skipped, Error, Cancelled }
-
+
-/// <param name="Copied">true = kopiert (Original bleibt), false = verschoben</param>
+/// <param name="Copied">true = kopiert (Original bleibt), false = verschoben</param>
-public record TransferResult(TransferStatus Status, string Source, string? Dest = null, bool Copied = false, string? Message = null);
+public record TransferResult(TransferStatus Status, string Source, string? Dest = null, bool Copied = false, string? Message = null);
-
+
-/// <summary>
+/// <summary>
-/// Kategorien sind einfache Unterordner von %USERPROFILE%\DeskCore.
+/// Kategorien sind einfache Unterordner von %USERPROFILE%\DeskCore.
-/// Icons vom Desktop werden dorthin kopiert – es bleiben normale Dateien.
+/// Icons vom Desktop werden dorthin kopiert – es bleiben normale Dateien.
-/// </summary>
+/// </summary>
-public static class Storage
+public static class Storage
-{
+{
-    public static readonly string Root = Migration.Pick(Environment.SpecialFolder.UserProfile);
+    public static readonly string Root = Migration.Pick(Environment.SpecialFolder.UserProfile);
-
+
-    public static readonly string UserDesktop = Environment.GetFolderPath(Environment.SpecialFolder.DesktopDirectory);
+    public static readonly string UserDesktop = Environment.GetFolderPath(Environment.SpecialFolder.DesktopDirectory);
-    public static readonly string PublicDesktop = Environment.GetFolderPath(Environment.SpecialFolder.CommonDesktopDirectory);
+    public static readonly string PublicDesktop = Environment.GetFolderPath(Environment.SpecialFolder.CommonDesktopDirectory);
-
+
-    /// <summary>Hier liegen gelöschte Elemente, solange man sie noch rückgängig machen kann.</summary>
+    /// <summary>Hier liegen gelöschte Elemente, solange man sie noch rückgängig machen kann.</summary>
-    public static readonly string Holding = Migration.Pick(Environment.SpecialFolder.LocalApplicationData, "Geloescht");
+    public static readonly string Holding = Migration.Pick(Environment.SpecialFolder.LocalApplicationData, "Geloescht");
-
+
-    // ---------- Kategorien ----------
+    // ---------- Kategorien ----------
-
+
-    public static List<string> Categories()
+    public static List<string> Categories()
-    {
+    {
-        Directory.CreateDirectory(Root);
+        Directory.CreateDirectory(Root);
-        var order = AppSettings.Current.CategoryOrder;
+        var order = AppSettings.Current.CategoryOrder;
-        return Directory.GetDirectories(Root)
+        return Directory.GetDirectories(Root)
-            .Select(Path.GetFileName)
+            .Select(Path.GetFileName)
-            .OfType<string>()
+            .OfType<string>()
-            .OrderBy(n => order.FindIndex(o => string.Equals(o, n, StringComparison.OrdinalIgnoreCase)) is var i and >= 0 ? i : int.MaxValue)
+            .OrderBy(n => order.FindIndex(o => string.Equals(o, n, StringComparison.OrdinalIgnoreCase)) is var i and >= 0 ? i : int.MaxValue)
-            .ThenBy(n => n, StringComparer.CurrentCultureIgnoreCase)
+            .ThenBy(n => n, StringComparer.CurrentCultureIgnoreCase)
-            .ToList();
+            .ToList();
-    }
+    }
-
+
-    public static string CategoryPath(string name) => Path.Combine(Root, name);
+    public static string CategoryPath(string name) => Path.Combine(Root, name);
-
+
-    public static IEnumerable<string> Entries(string dir)
+    public static IEnumerable<string> Entries(string dir)
-    {
+    {
-        if (!Directory.Exists(dir)) return [];
+        if (!Directory.Exists(dir)) return [];
-        try
+        try
-        {
+        {
-            return Directory.EnumerateFileSystemEntries(dir)
+            return Directory.EnumerateFileSystemEntries(dir)
-                .Where(p =>
+                .Where(p =>
-                {
+                {
-                    var n = Path.GetFileName(p);
+                    var n = Path.GetFileName(p);
-                    if (n.Equals("desktop.ini", StringComparison.OrdinalIgnoreCase)) return false;
+                    if (n.Equals("desktop.ini", StringComparison.OrdinalIgnoreCase)) return false;
-                    try
+                    try
-                    {
+                    {
-                        var attr = File.GetAttributes(p);
+                        var attr = File.GetAttributes(p);
-                        return !attr.HasFlag(FileAttributes.Hidden) && !attr.HasFlag(FileAttributes.System);
+                        return !attr.HasFlag(FileAttributes.Hidden) && !attr.HasFlag(FileAttributes.System);
-                    }
+                    }
-                    catch { return false; }
+                    catch { return false; }
-                })
+                })
-                .ToList();
+                .ToList();
-        }
+        }
-        catch { return []; }
+        catch { return []; }
-    }
+    }
-
+
-    public static IEnumerable<string> DesktopEntries() =>
+    public static IEnumerable<string> DesktopEntries() =>
-        Entries(UserDesktop).Concat(Entries(PublicDesktop));
+        Entries(UserDesktop).Concat(Entries(PublicDesktop));
-
+
-    public static bool IsDesktopDir(string dir) =>
+    public static bool IsDesktopDir(string dir) =>
-        SamePath(dir, UserDesktop) || SamePath(dir, PublicDesktop);
+        SamePath(dir, UserDesktop) || SamePath(dir, PublicDesktop);
-
+
-    public static bool IsInStorage(string path) =>
+    public static bool IsInStorage(string path) =>
-        path.StartsWith(Root.TrimEnd('\\') + "\\", StringComparison.OrdinalIgnoreCase);
+        path.StartsWith(Root.TrimEnd('\\') + "\\", StringComparison.OrdinalIgnoreCase);
-
+
-    public static string? ValidateName(string name)
+    public static string? ValidateName(string name)
-    {
+    {
-        name = name.Trim();
+        name = name.Trim();
-        if (name.Length == 0) return "Bitte einen Namen eingeben.";
+        if (name.Length == 0) return "Bitte einen Namen eingeben.";
-        if (name.IndexOfAny(Path.GetInvalidFileNameChars()) >= 0) return "Der Name enthält ungültige Zeichen ( \\ / : * ? \" < > | ).";
+        if (name.IndexOfAny(Path.GetInvalidFileNameChars()) >= 0) return "Der Name enthält ungültige Zeichen ( \\ / : * ? \" < > | ).";
-        if (name is "." or ".." || name.EndsWith('.')) return "Ungültiger Name.";
+        if (name is "." or ".." || name.EndsWith('.')) return "Ungültiger Name.";
-        return null;
+        return null;
-    }
+    }
-
+
-    // ---------- Duplikate ----------
+    // ---------- Duplikate ----------
-
+
-    private static readonly ConcurrentDictionary<string, (DateTime Stamp, string? Target)> _lnkCache = new(StringComparer.OrdinalIgnoreCase);
+    private static readonly ConcurrentDictionary<string, (DateTime Stamp, string? Target)> _lnkCache = new(StringComparer.OrdinalIgnoreCase);
-
+
-    /// <summary>Ziel einer Verknüpfung (.lnk/.url), sonst null.</summary>
+    /// <summary>Ziel einer Verknüpfung (.lnk/.url), sonst null.</summary>
-    public static string? ShortcutTarget(string path)
+    public static string? ShortcutTarget(string path)
-    {
+    {
-        var ext = Path.GetExtension(path).ToLowerInvariant();
+        var ext = Path.GetExtension(path).ToLowerInvariant();
-        if (ext is not (".lnk" or ".url")) return null;
+        if (ext is not (".lnk" or ".url")) return null;
-        DateTime stamp;
+        DateTime stamp;
-        try { stamp = File.GetLastWriteTimeUtc(path); } catch { return null; }
+        try { stamp = File.GetLastWriteTimeUtc(path); } catch { return null; }
-        if (_lnkCache.TryGetValue(path, out var c) && c.Stamp == stamp) return c.Target;
+        if (_lnkCache.TryGetValue(path, out var c) && c.Stamp == stamp) return c.Target;
-
+
-        string? target = null;
+        string? target = null;
-        try
+        try
-        {
+        {
-            if (ext == ".url")
+            if (ext == ".url")
-            {
+            {
-                target = File.ReadLines(path).FirstOrDefault(l => l.StartsWith("URL=", StringComparison.OrdinalIgnoreCase))?[4..];
+                target = File.ReadLines(path).FirstOrDefault(l => l.StartsWith("URL=", StringComparison.OrdinalIgnoreCase))?[4..];
-            }
+            }
-            else
+            else
-            {
+            {
-                dynamic shell = Activator.CreateInstance(Type.GetTypeFromProgID("WScript.Shell")!)!;
+                dynamic shell = Activator.CreateInstance(Type.GetTypeFromProgID("WScript.Shell")!)!;
-                dynamic lnk = shell.CreateShortcut(path);
+                dynamic lnk = shell.CreateShortcut(path);
-                string t = lnk.TargetPath;
+                string t = lnk.TargetPath;
-                string a = lnk.Arguments;
+                string a = lnk.Arguments;
-                target = string.IsNullOrEmpty(t) ? null : (t + " " + a).Trim();
+                target = string.IsNullOrEmpty(t) ? null : (t + " " + a).Trim();
-            }
+            }
-        }
+        }
-        catch { }
+        catch { }
-        if (string.IsNullOrWhiteSpace(target)) target = null;
+        if (string.IsNullOrWhiteSpace(target)) target = null;
-        _lnkCache[path] = (stamp, target);
+        _lnkCache[path] = (stamp, target);
-        return target;
+        return target;
-    }
+    }
-
+
-    /// <summary>Gleicher Dateiname oder Verknüpfung mit gleichem Ziel?</summary>
+    // ---------- Verknüpfungen zu deinstallierten Programmen ----------
-    public static bool SameItem(string a, string b)
+
-    {
+    private static readonly ConcurrentDictionary<string, (DateTime Stamp, string? Target)> _targetPathCache = new(StringComparer.OrdinalIgnoreCase);
-        if (string.Equals(Path.GetFileName(a), Path.GetFileName(b), StringComparison.OrdinalIgnoreCase)) return true;
+
-        var ta = ShortcutTarget(a);
+    /// <summary>Reiner Zielpfad einer .lnk-Verknüpfung (ohne Argumente), sonst null.</summary>
-        return ta is not null && string.Equals(ta, ShortcutTarget(b), StringComparison.OrdinalIgnoreCase);
+    public static string? LinkTargetPath(string path)
-    }
+    {
-
+        if (!string.Equals(Path.GetExtension(path), ".lnk", StringComparison.OrdinalIgnoreCase)) return null;
-    /// <summary>Liegt das Element (oder ein gleichwertiges) schon in diesem Ordner?</summary>
+        DateTime stamp;
-    public static string? FindEquivalent(string dir, string item) =>
+        try { stamp = File.GetLastWriteTimeUtc(path); } catch { return null; }
-        Entries(dir).FirstOrDefault(e => !SamePath(e, item) && SameItem(e, item));
+        if (_targetPathCache.TryGetValue(path, out var c) && c.Stamp == stamp) return c.Target;
-
+        string? target = null;
-    /// <summary>In welcher Kategorie liegt das Element bereits? (für das ✓ auf dem Desktop)</summary>
+        try
-    public static string? FindCategoryOf(string item, IReadOnlyDictionary<string, List<string>> categoryEntries)
+        {
-    {
+            // Direkt über IShellLink lesen (Rohpfad). WScript.Shell "repariert" Ziele, die es nicht findet,
-        foreach (var (cat, entries) in categoryEntries)
+            // z. B. \\server\… zu C:\server\… – darauf darf eine Lösch-Entscheidung nicht beruhen.
-            if (entries.Any(e => SameItem(e, item))) return cat;
+            var link = (IShellLinkW)new ShellLinkCoClass();
-        return null;
+            try
-    }
+            {
-
+                ((System.Runtime.InteropServices.ComTypes.IPersistFile)link).Load(path, 0); // STGM_READ
-    // ---------- Übertragen ----------
+                var sb = new System.Text.StringBuilder(32768);
-
+                link.GetPath(sb, sb.Capacity, IntPtr.Zero, 0x4); // SLGP_RAWPATH
-    /// <summary>
+                var raw = sb.ToString().Trim();
-    /// Übernimmt Datei/Ordner nach targetDir. Kommt die Quelle von außerhalb der App (z. B. vom Desktop),
+                target = raw.Length == 0 ? null : Environment.ExpandEnvironmentVariables(raw);
-    /// wird kopiert – das Original kann danach gelöscht werden. Innerhalb der App und zurück auf den
+            }
-    /// Desktop wird verschoben. Gleiche Elemente werden nicht doppelt angelegt.
+            finally { System.Runtime.InteropServices.Marshal.ReleaseComObject(link); }
-    /// </summary>
+        }
-    public static TransferResult Transfer(string source, string targetDir, bool forceMove = false,
+        catch { }
-        Action<long>? onBytes = null, CancellationToken ct = default)
+        _targetPathCache[path] = (stamp, target);
-    {
+        return target;
-        if (ct.IsCancellationRequested) return new(TransferStatus.Cancelled, source);
+    }
-        var name = Path.GetFileName(source.TrimEnd('\\'));
+
-        try
+    [System.Runtime.InteropServices.ComImport, System.Runtime.InteropServices.Guid("00021401-0000-0000-C000-000000000046")]
-        {
+    private class ShellLinkCoClass { }
-            if (SamePath(Path.GetDirectoryName(source), targetDir))
+
-                return new(TransferStatus.Skipped, source, Message: $"„{name}“ ist schon dort.");
+    [System.Runtime.InteropServices.ComImport, System.Runtime.InteropServices.Guid("000214F9-0000-0000-C000-000000000046"),
-            if (Directory.Exists(source) &&
+     System.Runtime.InteropServices.InterfaceType(System.Runtime.InteropServices.ComInterfaceType.InterfaceIsIUnknown)]
-                (targetDir.TrimEnd('\\') + "\\").StartsWith(source.TrimEnd('\\') + "\\", StringComparison.OrdinalIgnoreCase))
+    private interface IShellLinkW
-                return new(TransferStatus.Error, source, Message: $"„{name}“ kann nicht in sich selbst verschoben werden.");
+    {
-
+        void GetPath([System.Runtime.InteropServices.MarshalAs(System.Runtime.InteropServices.UnmanagedType.LPWStr)] System.Text.StringBuilder pszFile,
-            bool copy = !forceMove && !IsInStorage(source) && IsInStorage(targetDir);
+            int cch, IntPtr pfd, uint fFlags);
-            if (FindEquivalent(targetDir, source) is { } existing)
+        // weitere Methoden werden nicht gebraucht (Reihenfolge der vtable ab hier egal)
-            {
+    }
-                var where = IsDesktopDir(targetDir) ? "auf dem Desktop" : $"in „{Path.GetFileName(targetDir)}“";
+
-                return new(TransferStatus.Skipped, source, existing, Message: $"„{DisplayName(source)}“ ist schon {where}.");
+    /// <summary>
-            }
+    /// Zeigt die Verknüpfung auf ein Programm, das es nicht mehr gibt (z. B. deinstalliert)?
-
+    /// Bewusst vorsichtig – im Zweifel "nein":
-            Directory.CreateDirectory(targetDir);
+    /// .lnk nur mit festem Ziel auf einer eingebauten, erreichbaren Festplatte; .url nur bei Steam/Epic, wenn deren
-            var dest = UniquePath(targetDir, name);
+    /// Installationsliste das Spiel nicht mehr kennt. Netzwerk-/USB-Laufwerke, Web-Links, Store-Apps und
-            try
+    /// Windows-Installer-Verknüpfungen werden nie als tot gewertet.
-            {
+    /// </summary>
-                if (copy) CopyAny(source, dest, onBytes, ct);
+    public static bool IsDeadShortcut(string path)
-                else MoveAny(source, dest, onBytes, ct);
+    {
-            }
+        // Steam-/Epic-Links: deren eigene Installationslisten fragen
-            catch (OperationCanceledException)
+        if (string.Equals(Path.GetExtension(path), ".url", StringComparison.OrdinalIgnoreCase))
-            {
+        {
-                // halb kopiertes Ziel wieder entfernen – die Quelle ist unverändert
+            var url = ShortcutTarget(path);
-                // (beim Verschieben zwischen Laufwerken wird die Quelle erst nach vollständiger Kopie gelöscht)
+            return url is not null && GameLibraries.IsInstalled(url) == false;
-                DeletePartial(dest);
+        }
-                return new(TransferStatus.Cancelled, source);
+
-            }
+        var target = LinkTargetPath(path);
-            return new(TransferStatus.Ok, source, dest, copy);
+        if (target is null) return false;
-        }
+        try
-        catch (UnauthorizedAccessException)
+        {
-        {
+            if (!Path.IsPathFullyQualified(target) || target.StartsWith(@"\\")) return false; // relativ oder Netzwerk
-            return new(TransferStatus.Error, source, Message: $"„{name}“: Keine Berechtigung. " +
+            var drive = new DriveInfo(Path.GetPathRoot(target)!);
-                "(Icons auf dem öffentlichen Desktop brauchen Administratorrechte – App ggf. als Administrator starten.)");
+            if (!drive.IsReady || drive.DriveType != DriveType.Fixed) return false;      // abgesteckt/USB/Netz
-        }
+            var installer = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.Windows), "Installer");
-        catch (Exception ex)
+            if (IsUnder(target, installer)) return false;                                // MSI-"Werbe"-Verknüpfung
-        {
+            return !File.Exists(target) && !Directory.Exists(target);
-            return new(TransferStatus.Error, source, Message: $"„{name}“: {ex.Message}");
+        }
-        }
+        catch { return false; }
-    }
+    }
-
+
-    /// <summary>Verschiebt Datei oder Ordner – auch zwischen Laufwerken.</summary>
+    /// <summary>Alle toten Verknüpfungen in den Kategorien (ohne die, die der Nutzer behalten will).</summary>
-    public static void MoveAny(string source, string dest, Action<long>? onBytes = null, CancellationToken ct = default)
+    public static List<string> FindDeadShortcuts(ICollection<string> keep) =>
-    {
+        Categories()
-        NoteCreated(dest);
+            .SelectMany(c => Entries(CategoryPath(c)))
-        if (File.Exists(source))
+            .Where(p => !keep.Contains(p, StringComparer.OrdinalIgnoreCase) && IsDeadShortcut(p))
-        {
+            .ToList();
-            File.Move(source, dest);
+
-            return;
+    /// <summary>Gleicher Dateiname oder Verknüpfung mit gleichem Ziel?</summary>
-        }
+    public static bool SameItem(string a, string b)
-        if (string.Equals(Path.GetPathRoot(source), Path.GetPathRoot(dest), StringComparison.OrdinalIgnoreCase))
+    {
-        {
+        if (string.Equals(Path.GetFileName(a), Path.GetFileName(b), StringComparison.OrdinalIgnoreCase)) return true;
-            Directory.Move(source, dest);
+        var ta = ShortcutTarget(a);
-            return;
+        return ta is not null && string.Equals(ta, ShortcutTarget(b), StringComparison.OrdinalIgnoreCase);
-        }
+    }
-        CopyDirectory(source, dest, onBytes, ct);
+
-        Directory.Delete(source, recursive: true);
+    /// <summary>Liegt das Element (oder ein gleichwertiges) schon in diesem Ordner?</summary>
-    }
+    public static string? FindEquivalent(string dir, string item) =>
-
+        Entries(dir).FirstOrDefault(e => !SamePath(e, item) && SameItem(e, item));
-    public static void CopyAny(string source, string dest, Action<long>? onBytes = null, CancellationToken ct = default)
+
-    {
+    /// <summary>In welcher Kategorie liegt das Element bereits? (für das ✓ auf dem Desktop)</summary>
-        NoteCreated(dest);
+    public static string? FindCategoryOf(string item, IReadOnlyDictionary<string, List<string>> categoryEntries)
-        if (Directory.Exists(source)) CopyDirectory(source, dest, onBytes, ct);
+    {
-        else CopyFile(source, dest, onBytes, ct);
+        foreach (var (cat, entries) in categoryEntries)
-    }
+            if (entries.Any(e => SameItem(e, item))) return cat;
-
+        return null;
-    /// <summary>Benennt ein Element um. Gibt den neuen Pfad zurück.</summary>
+    }
-    public static string Rename(string path, string newName)
+
-    {
+    // ---------- Übertragen ----------
-        var dir = Path.GetDirectoryName(path)!;
+
-        var dest = Path.Combine(dir, newName);
+    /// <summary>
-        if (string.Equals(path, dest, StringComparison.Ordinal)) return path;
+    /// Übernimmt Datei/Ordner nach targetDir. Kommt die Quelle von außerhalb der App (z. B. vom Desktop),
-        if (string.Equals(path, dest, StringComparison.OrdinalIgnoreCase))
+    /// wird kopiert – das Original kann danach gelöscht werden. Innerhalb der App und zurück auf den
-        {   // nur Groß-/Kleinschreibung geändert
+    /// Desktop wird verschoben. Gleiche Elemente werden nicht doppelt angelegt.
-            var tmp = path + ".umbenennen";
+    /// </summary>
-            MoveAny(path, tmp);
+    public static TransferResult Transfer(string source, string targetDir, bool forceMove = false,
-            MoveAny(tmp, dest);
+        Action<long>? onBytes = null, CancellationToken ct = default)
-            return dest;
+    {
-        }
+        if (ct.IsCancellationRequested) return new(TransferStatus.Cancelled, source);
-        if (File.Exists(dest) || Directory.Exists(dest)) throw new IOException($"„{newName}“ gibt es dort schon.");
+        var name = Path.GetFileName(source.TrimEnd('\\'));
-        MoveAny(path, dest);
+        try
-        return dest;
+        {
-    }
+            if (SamePath(Path.GetDirectoryName(source), targetDir))
-
+                return new(TransferStatus.Skipped, source, Message: $"„{name}“ ist schon dort.");
-    /// <summary>
+            if (Directory.Exists(source) &&
-    /// "Löscht" ein Element: es wandert erst in einen internen Ordner, damit Strg+Z funktioniert.
+                (targetDir.TrimEnd('\\') + "\\").StartsWith(source.TrimEnd('\\') + "\\", StringComparison.OrdinalIgnoreCase))
-    /// Erst wenn es nicht mehr rückgängig gemacht werden kann, geht es in den Papierkorb.
+                return new(TransferStatus.Error, source, Message: $"„{name}“ kann nicht in sich selbst verschoben werden.");
-    /// </summary>
+
-    public static string Delete(string path)
+            bool copy = !forceMove && !IsInStorage(source) && IsInStorage(targetDir);
-    {
+            if (FindEquivalent(targetDir, source) is { } existing)
-        var dir = Path.Combine(Holding, Guid.NewGuid().ToString("N"));
+            {
-        Directory.CreateDirectory(dir);
+                var where = IsDesktopDir(targetDir) ? "auf dem Desktop" : $"in „{Path.GetFileName(targetDir)}“";
-        var dest = Path.Combine(dir, Path.GetFileName(path.TrimEnd('\\')));
+                return new(TransferStatus.Skipped, source, existing, Message: $"„{DisplayName(source)}“ ist schon {where}.");
-        MoveAny(path, dest);
+            }
-        return dest;
+
-    }
+            Directory.CreateDirectory(targetDir);
-
+            var dest = UniquePath(targetDir, name);
-    /// <summary>Endgültig in den Windows-Papierkorb.</summary>
+            try
-    public static void Recycle(string path)
+            {
-    {
+                if (copy) CopyAny(source, dest, onBytes, ct);
-        try
+                else MoveAny(source, dest, onBytes, ct);
-        {
+            }
-            if (Directory.Exists(path))
+            catch (OperationCanceledException)
-                Microsoft.VisualBasic.FileIO.FileSystem.DeleteDirectory(path,
+            {
-                    Microsoft.VisualBasic.FileIO.UIOption.OnlyErrorDialogs, Microsoft.VisualBasic.FileIO.RecycleOption.SendToRecycleBin);
+                // halb kopiertes Ziel wieder entfernen – die Quelle ist unverändert
-            else if (File.Exists(path))
+                // (beim Verschieben zwischen Laufwerken wird die Quelle erst nach vollständiger Kopie gelöscht)
-                Microsoft.VisualBasic.FileIO.FileSystem.DeleteFile(path,
+                DeletePartial(dest);
-                    Microsoft.VisualBasic.FileIO.UIOption.OnlyErrorDialogs, Microsoft.VisualBasic.FileIO.RecycleOption.SendToRecycleBin);
+                return new(TransferStatus.Cancelled, source);
-
+            }
-            // leeren Hilfsordner aufräumen
+            return new(TransferStatus.Ok, source, dest, copy);
-            var parent = Path.GetDirectoryName(path);
+        }
-            if (parent is not null && IsUnder(parent, Holding) && Directory.Exists(parent) && !Directory.EnumerateFileSystemEntries(parent).Any())
+        catch (UnauthorizedAccessException)
-                Directory.Delete(parent);
+        {
-        }
+            return new(TransferStatus.Error, source, Message: $"„{name}“: Keine Berechtigung. " +
-        catch { }
+                "(Icons auf dem öffentlichen Desktop brauchen Administratorrechte – App ggf. als Administrator starten.)");
-    }
+        }
-
+        catch (Exception ex)
-    /// <summary>Reste von einem Absturz in den Papierkorb legen.</summary>
+        {
-    public static void FlushHolding()
+            return new(TransferStatus.Error, source, Message: $"„{name}“: {ex.Message}");
-    {
+        }
-        if (!Directory.Exists(Holding)) return;
+    }
-        foreach (var d in Directory.GetDirectories(Holding))
+
-            foreach (var e in Directory.EnumerateFileSystemEntries(d).ToList())
+    /// <summary>Verschiebt Datei oder Ordner – auch zwischen Laufwerken.</summary>
-                Recycle(e);
+    public static void MoveAny(string source, string dest, Action<long>? onBytes = null, CancellationToken ct = default)
-    }
+    {
-
+        NoteCreated(dest);
-    // ---------- Selbst angelegte Desktop-Elemente merken (damit die Auto-Sortierung sie ignoriert) ----------
+        if (File.Exists(source))
-
+        {
-    private static readonly ConcurrentDictionary<string, DateTime> _created = new(StringComparer.OrdinalIgnoreCase);
+            File.Move(source, dest);
-
+            return;
-    private static void NoteCreated(string path) => _created[path] = DateTime.UtcNow;
+        }
-
+        if (string.Equals(Path.GetPathRoot(source), Path.GetPathRoot(dest), StringComparison.OrdinalIgnoreCase))
-    public static bool CreatedByApp(string path) =>
+        {
-        _created.TryGetValue(path, out var t) && DateTime.UtcNow - t < TimeSpan.FromSeconds(15);
+            Directory.Move(source, dest);
-
+            return;
-    /// <summary>Größe eines Ordners in Bytes (bricht ab, sobald limit überschritten ist).</summary>
+        }
-    public static long DirectorySize(string dir, long limit = long.MaxValue)
+        CopyDirectory(source, dest, onBytes, ct);
-    {
+        Directory.Delete(source, recursive: true);
-        long sum = 0;
+    }
-        try
+
-        {
+    public static void CopyAny(string source, string dest, Action<long>? onBytes = null, CancellationToken ct = default)
-            foreach (var f in Directory.EnumerateFiles(dir, "*", SearchOption.AllDirectories))
+    {
-            {
+        NoteCreated(dest);
-                try { sum += new FileInfo(f).Length; } catch { }
+        if (Directory.Exists(source)) CopyDirectory(source, dest, onBytes, ct);
-                if (sum > limit) break;
+        else CopyFile(source, dest, onBytes, ct);
-            }
+    }
-        }
+
-        catch { }
+    /// <summary>Benennt ein Element um. Gibt den neuen Pfad zurück.</summary>
-        return sum;
+    public static string Rename(string path, string newName)
-    }
+    {
-
+        var dir = Path.GetDirectoryName(path)!;
-    // ---------- Helfer ----------
+        var dest = Path.Combine(dir, newName);
-
+        if (string.Equals(path, dest, StringComparison.Ordinal)) return path;
-    public static string DisplayName(string path)
+        if (string.Equals(path, dest, StringComparison.OrdinalIgnoreCase))
-    {
+        {   // nur Groß-/Kleinschreibung geändert
-        var n = Path.GetFileName(path.TrimEnd('\\'));
+            var tmp = path + ".umbenennen";
-        var ext = Path.GetExtension(n).ToLowerInvariant();
+            MoveAny(path, tmp);
-        return ext is ".lnk" or ".url" or ".appref-ms" ? Path.GetFileNameWithoutExtension(n) : n;
+            MoveAny(tmp, dest);
-    }
+            return dest;
-
+        }
-    /// <summary>Endung, die beim Umbenennen erhalten bleibt (bei Verknüpfungen versteckt).</summary>
+        if (File.Exists(dest) || Directory.Exists(dest)) throw new IOException($"„{newName}“ gibt es dort schon.");
-    public static string HiddenExtension(string path)
+        MoveAny(path, dest);
-    {
+        return dest;
-        var ext = Path.GetExtension(path);
+    }
-        return ext.ToLowerInvariant() is ".lnk" or ".url" or ".appref-ms" ? ext : "";
+
-    }
+    /// <summary>
-
+    /// "Löscht" ein Element: es wandert erst in einen internen Ordner, damit Strg+Z funktioniert.
-    public static bool SamePath(string? a, string? b) =>
+    /// Erst wenn es nicht mehr rückgängig gemacht werden kann, geht es in den Papierkorb.
-        a is not null && b is not null &&
+    /// </summary>
-        string.Equals(Path.GetFullPath(a).TrimEnd('\\'), Path.GetFullPath(b).TrimEnd('\\'), StringComparison.OrdinalIgnoreCase);
+    public static string Delete(string path)
-
+    {
-    public static bool IsUnder(string path, string dir) =>
+        var dir = Path.Combine(Holding, Guid.NewGuid().ToString("N"));
-        (Path.GetFullPath(path).TrimEnd('\\') + "\\").StartsWith(Path.GetFullPath(dir).TrimEnd('\\') + "\\", StringComparison.OrdinalIgnoreCase);
+        Directory.CreateDirectory(dir);
-
+        var dest = Path.Combine(dir, Path.GetFileName(path.TrimEnd('\\')));
-    public static string UniquePath(string dir, string fileName)
+        MoveAny(path, dest);
-    {
+        return dest;
-        var path = Path.Combine(dir, fileName);
+    }
-        if (!File.Exists(path) && !Directory.Exists(path)) return path;
+
-        var stem = Path.GetFileNameWithoutExtension(fileName);
+    /// <summary>Endgültig in den Windows-Papierkorb.</summary>
-        var ext = Path.GetExtension(fileName);
+    public static void Recycle(string path)
-        for (int i = 2; ; i++)
+    {
-        {
+        try
-            path = Path.Combine(dir, $"{stem} ({i}){ext}");
+        {
-            if (!File.Exists(path) && !Directory.Exists(path)) return path;
+            if (Directory.Exists(path))
-        }
+                Microsoft.VisualBasic.FileIO.FileSystem.DeleteDirectory(path,
-    }
+                    Microsoft.VisualBasic.FileIO.UIOption.OnlyErrorDialogs, Microsoft.VisualBasic.FileIO.RecycleOption.SendToRecycleBin);
-
+            else if (File.Exists(path))
-    private static void CopyDirectory(string source, string dest, Action<long>? onBytes, CancellationToken ct)
+                Microsoft.VisualBasic.FileIO.FileSystem.DeleteFile(path,
-    {
+                    Microsoft.VisualBasic.FileIO.UIOption.OnlyErrorDialogs, Microsoft.VisualBasic.FileIO.RecycleOption.SendToRecycleBin);
-        Directory.CreateDirectory(dest);
+
-        foreach (var f in Directory.GetFiles(source))
+            // leeren Hilfsordner aufräumen
-            CopyFile(f, Path.Combine(dest, Path.GetFileName(f)), onBytes, ct);
+            var parent = Path.GetDirectoryName(path);
-        foreach (var d in Directory.GetDirectories(source))
+            if (parent is not null && IsUnder(parent, Holding) && Directory.Exists(parent) && !Directory.EnumerateFileSystemEntries(parent).Any())
-            CopyDirectory(d, Path.Combine(dest, Path.GetFileName(d)), onBytes, ct);
+                Directory.Delete(parent);
-    }
+        }
-
+        catch { }
-    /// <summary>Kopiert in 1-MB-Stücken, damit Fortschritt angezeigt und abgebrochen werden kann.</summary>
+    }
-    private static void CopyFile(string source, string dest, Action<long>? onBytes, CancellationToken ct)
+
-    {
+    /// <summary>Reste von einem Absturz in den Papierkorb legen.</summary>
-        ct.ThrowIfCancellationRequested();
+    public static void FlushHolding()
-        const int Chunk = 1 << 20;
+    {
-        using (var input = new FileStream(source, FileMode.Open, FileAccess.Read, FileShare.ReadWrite | FileShare.Delete, Chunk, FileOptions.SequentialScan))
+        if (!Directory.Exists(Holding)) return;
-        using (var output = new FileStream(dest, FileMode.CreateNew, FileAccess.Write, FileShare.None, Chunk))
+        foreach (var d in Directory.GetDirectories(Holding))
-        {
+            foreach (var e in Directory.EnumerateFileSystemEntries(d).ToList())
-            var buffer = new byte[Chunk];
+                Recycle(e);
-            int read;
+    }
-            while ((read = input.Read(buffer, 0, buffer.Length)) > 0)
+
-            {
+    // ---------- Selbst angelegte Desktop-Elemente merken (damit die Auto-Sortierung sie ignoriert) ----------
-                ct.ThrowIfCancellationRequested();
+
-                output.Write(buffer, 0, read);
+    private static readonly ConcurrentDictionary<string, DateTime> _created = new(StringComparer.OrdinalIgnoreCase);
-                onBytes?.Invoke(read);
+
-            }
+    private static void NoteCreated(string path) => _created[path] = DateTime.UtcNow;
-        }
+
-        // Zeitstempel und Attribute wie beim normalen Kopieren übernehmen
+    /// <summary>Von der App selbst angelegte Datei merken (z. B. Desktop-Verknüpfung einer Start-Gruppe).</summary>
-        try
+    public static void MarkCreated(string path) => NoteCreated(path);
-        {
+
-            File.SetCreationTimeUtc(dest, File.GetCreationTimeUtc(source));
+    public static bool CreatedByApp(string path) =>
-            File.SetLastWriteTimeUtc(dest, File.GetLastWriteTimeUtc(source));
+        _created.TryGetValue(path, out var t) && DateTime.UtcNow - t < TimeSpan.FromSeconds(15);
-            File.SetAttributes(dest, File.GetAttributes(source) & ~FileAttributes.ReadOnly);
+
-        }
+    /// <summary>Größe eines Ordners in Bytes (bricht ab, sobald limit überschritten ist).</summary>
-        catch { }
+    public static long DirectorySize(string dir, long limit = long.MaxValue)
-    }
+    {
-
+        long sum = 0;
-    private static void DeletePartial(string path)
+        try
-    {
+        {
-        try
+            foreach (var f in Directory.EnumerateFiles(dir, "*", SearchOption.AllDirectories))
-        {
+            {
-            if (Directory.Exists(path)) Directory.Delete(path, recursive: true);
+                try { sum += new FileInfo(f).Length; } catch { }
-            else if (File.Exists(path)) File.Delete(path);
+                if (sum > limit) break;
-        }
+            }
-        catch { }
+        }
-    }
+        catch { }
-
+        return sum;
-    /// <summary>Wie viele Bytes müssen für diese Übertragung tatsächlich kopiert werden? (0 = nur umbenennen)</summary>
+    }
-    public static long BytesToCopy(string source, string targetDir, bool forceMove)
+
-    {
+    // ---------- Helfer ----------
-        bool copy = !forceMove && !IsInStorage(source) && IsInStorage(targetDir);
+
-        bool crossDrive = !string.Equals(Path.GetPathRoot(Path.GetFullPath(source)), Path.GetPathRoot(Path.GetFullPath(targetDir)),
+    public static string DisplayName(string path)
-            StringComparison.OrdinalIgnoreCase);
+    {
-        if (!copy && !crossDrive) return 0;
+        var n = Path.GetFileName(path.TrimEnd('\\'));
-        try { return Directory.Exists(source) ? DirectorySize(source) : new FileInfo(source).Length; }
+        var ext = Path.GetExtension(n).ToLowerInvariant();
-        catch { return 0; }
+        return ext is ".lnk" or ".url" or ".appref-ms" ? Path.GetFileNameWithoutExtension(n) : n;
-    }
+    }
-}
+
+    /// <summary>Endung, die beim Umbenennen erhalten bleibt (bei Verknüpfungen versteckt).</summary>
+    public static string HiddenExtension(string path)
+    {
+        var ext = Path.GetExtension(path);
+        return ext.ToLowerInvariant() is ".lnk" or ".url" or ".appref-ms" ? ext : "";
+    }
+
+    public static bool SamePath(string? a, string? b) =>
+        a is not null && b is not null &&
+        string.Equals(Path.GetFullPath(a).TrimEnd('\\'), Path.GetFullPath(b).TrimEnd('\\'), StringComparison.OrdinalIgnoreCase);
+
+    public static bool IsUnder(string path, string dir) =>
+        (Path.GetFullPath(path).TrimEnd('\\') + "\\").StartsWith(Path.GetFullPath(dir).TrimEnd('\\') + "\\", StringComparison.OrdinalIgnoreCase);
+
+    public static string UniquePath(string dir, string fileName)
+    {
+        var path = Path.Combine(dir, fileName);
+        if (!File.Exists(path) && !Directory.Exists(path)) return path;
+        var stem = Path.GetFileNameWithoutExtension(fileName);
+        var ext = Path.GetExtension(fileName);
+        for (int i = 2; ; i++)
+        {
+            path = Path.Combine(dir, $"{stem} ({i}){ext}");
+            if (!File.Exists(path) && !Directory.Exists(path)) return path;
+        }
+    }
+
+    private static void CopyDirectory(string source, string dest, Action<long>? onBytes, CancellationToken ct)
+    {
+        Directory.CreateDirectory(dest);
+        foreach (var f in Directory.GetFiles(source))
+            CopyFile(f, Path.Combine(dest, Path.GetFileName(f)), onBytes, ct);
+        foreach (var d in Directory.GetDirectories(source))
+            CopyDirectory(d, Path.Combine(dest, Path.GetFileName(d)), onBytes, ct);
+    }
+
+    /// <summary>Kopiert in 1-MB-Stücken, damit Fortschritt angezeigt und abgebrochen werden kann.</summary>
+    private static void CopyFile(string source, string dest, Action<long>? onBytes, CancellationToken ct)
+    {
+        ct.ThrowIfCancellationRequested();
+        const int Chunk = 1 << 20;
+        using (var input = new FileStream(source, FileMode.Open, FileAccess.Read, FileShare.ReadWrite | FileShare.Delete, Chunk, FileOptions.SequentialScan))
+        using (var output = new FileStream(dest, FileMode.CreateNew, FileAccess.Write, FileShare.None, Chunk))
+        {
+            var buffer = new byte[Chunk];
+            int read;
+            while ((read = input.Read(buffer, 0, buffer.Length)) > 0)
+            {
+                ct.ThrowIfCancellationRequested();
+                output.Write(buffer, 0, read);
+                onBytes?.Invoke(read);
+            }
+        }
+        // Zeitstempel und Attribute wie beim normalen Kopieren übernehmen
+        try
+        {
+            File.SetCreationTimeUtc(dest, File.GetCreationTimeUtc(source));
+            File.SetLastWriteTimeUtc(dest, File.GetLastWriteTimeUtc(source));
+            File.SetAttributes(dest, File.GetAttributes(source) & ~FileAttributes.ReadOnly);
+        }
+        catch { }
+    }
+
+    private static void DeletePartial(string path)
+    {
+        try
+        {
+            if (Directory.Exists(path)) Directory.Delete(path, recursive: true);
+            else if (File.Exists(path)) File.Delete(path);
+        }
+        catch { }
+    }
+
+    /// <summary>Wie viele Bytes müssen für diese Übertragung tatsächlich kopiert werden? (0 = nur umbenennen)</summary>
+    public static long BytesToCopy(string source, string targetDir, bool forceMove)
+    {
+        bool copy = !forceMove && !IsInStorage(source) && IsInStorage(targetDir);
+        bool crossDrive = !string.Equals(Path.GetPathRoot(Path.GetFullPath(source)), Path.GetPathRoot(Path.GetFullPath(targetDir)),
+            StringComparison.OrdinalIgnoreCase);
+        if (!copy && !crossDrive) return 0;
+        try { return Directory.Exists(source) ? DirectorySize(source) : new FileInfo(source).Length; }
+        catch { return 0; }
+    }
+}

Theme.cs

@@ -1,74 +1,74 @@
-using System.Windows;
+using System.Windows;
-using System.Windows.Media;
+using System.Windows.Media;
-using Microsoft.Win32;
+using Microsoft.Win32;
-
+
-namespace DeskCore;
+namespace DeskCore;
-
+
-/// <summary>Übernimmt Hell/Dunkel-Modus und Akzentfarbe von Windows – auch live, wenn man sie ändert.</summary>
+/// <summary>Übernimmt Hell/Dunkel-Modus und Akzentfarbe von Windows – auch live, wenn man sie ändert.</summary>
-public static class Theme
+public static class Theme
-{
+{
-    public static bool IsLight { get; private set; } = true;
+    public static bool IsLight { get; private set; } = true;
-
+
-    /// <summary>Vom Benutzer gewählter Modus; "System" folgt der Windows-Einstellung.</summary>
+    /// <summary>Vom Benutzer gewählter Modus; "System" folgt der Windows-Einstellung.</summary>
-    public static DesignMode Mode => AppSettings.Current.Design;
+    public static DesignMode Mode => AppSettings.Current.Design;
-
+
-    public static void Init()
+    public static void Init()
-    {
+    {
-        Apply();
+        Apply();
-        SystemEvents.UserPreferenceChanged += (_, e) =>
+        SystemEvents.UserPreferenceChanged += (_, e) =>
-        {
+        {
-            if (e.Category is UserPreferenceCategory.General or UserPreferenceCategory.Color or UserPreferenceCategory.VisualStyle)
+            if (e.Category is UserPreferenceCategory.General or UserPreferenceCategory.Color or UserPreferenceCategory.VisualStyle)
-                Application.Current.Dispatcher.BeginInvoke(Apply);
+                Application.Current.Dispatcher.BeginInvoke(Apply);
-        };
+        };
-    }
+    }
-
+
-    public static void Apply()
+    public static void Apply()
-    {
+    {
-        IsLight = Mode switch
+        IsLight = Mode switch
-        {
+        {
-            DesignMode.Light => true,
+            DesignMode.Light => true,
-            DesignMode.Dark => false,
+            DesignMode.Dark => false,
-            _ => ReadDword(@"Software\Microsoft\Windows\CurrentVersion\Themes\Personalize", "AppsUseLightTheme") != 0,
+            _ => ReadDword(@"Software\Microsoft\Windows\CurrentVersion\Themes\Personalize", "AppsUseLightTheme") != 0,
-        };
+        };
-        var res = Application.Current.Resources;
+        var res = Application.Current.Resources;
-        res.MergedDictionaries[0] = new ResourceDictionary
+        res.MergedDictionaries[0] = new ResourceDictionary
-        {
+        {
-            Source = new Uri($"pack://application:,,,/Themes/Colors.{(IsLight ? "Light" : "Dark")}.xaml")
+            Source = new Uri($"pack://application:,,,/Themes/Colors.{(IsLight ? "Light" : "Dark")}.xaml")
-        };
+        };
-
+
-        // DWM speichert die Akzentfarbe als ABGR
+        // DWM speichert die Akzentfarbe als ABGR
-        int abgr = ReadDword(@"Software\Microsoft\Windows\DWM", "AccentColor") is var v and not -1 ? v : unchecked((int)0xFFD77800);
+        int abgr = ReadDword(@"Software\Microsoft\Windows\DWM", "AccentColor") is var v and not -1 ? v : unchecked((int)0xFFD77800);
-        var accent = Color.FromRgb((byte)abgr, (byte)(abgr >> 8), (byte)(abgr >> 16));
+        var accent = Color.FromRgb((byte)abgr, (byte)(abgr >> 8), (byte)(abgr >> 16));
-
+
-        // Wie Windows 11: im Hellmodus etwas dunkler + weiße Schrift, im Dunkelmodus deutlich heller + schwarze Schrift
+        // Wie Windows 11: im Hellmodus etwas dunkler + weiße Schrift, im Dunkelmodus deutlich heller + schwarze Schrift
-        var a = IsLight ? Mix(accent, Colors.Black, 0.12) : Mix(accent, Colors.White, 0.45);
+        var a = IsLight ? Mix(accent, Colors.Black, 0.12) : Mix(accent, Colors.White, 0.45);
-        res["AccentBrush"] = Brush(a);
+        res["AccentBrush"] = Brush(a);
-        res["AccentHoverBrush"] = Brush(IsLight ? Mix(a, Colors.White, 0.1) : Mix(a, Colors.Black, 0.1));
+        res["AccentHoverBrush"] = Brush(IsLight ? Mix(a, Colors.White, 0.1) : Mix(a, Colors.Black, 0.1));
-        res["OnAccentBrush"] = Brush(IsLight ? Colors.White : Colors.Black);
+        res["OnAccentBrush"] = Brush(IsLight ? Colors.White : Colors.Black);
-        res["AccentSubtleBrush"] = Brush(Color.FromArgb(IsLight ? (byte)0x22 : (byte)0x30, a.R, a.G, a.B));
+        res["AccentSubtleBrush"] = Brush(Color.FromArgb(IsLight ? (byte)0x22 : (byte)0x30, a.R, a.G, a.B));
-        res["AccentSubtleStrokeBrush"] = Brush(Color.FromArgb(IsLight ? (byte)0x55 : (byte)0x60, a.R, a.G, a.B));
+        res["AccentSubtleStrokeBrush"] = Brush(Color.FromArgb(IsLight ? (byte)0x55 : (byte)0x60, a.R, a.G, a.B));
-        Changed?.Invoke();
+        Changed?.Invoke();
-    }
+    }
-
+
-    public static event Action? Changed;
+    public static event Action? Changed;
-
+
-    private static int ReadDword(string key, string name)
+    private static int ReadDword(string key, string name)
-    {
+    {
-        try
+        try
-        {
+        {
-            using var k = Registry.CurrentUser.OpenSubKey(key);
+            using var k = Registry.CurrentUser.OpenSubKey(key);
-            return k?.GetValue(name) is int i ? i : -1;
+            return k?.GetValue(name) is int i ? i : -1;
-        }
+        }
-        catch { return -1; }
+        catch { return -1; }
-    }
+    }
-
+
-    private static Color Mix(Color c, Color with, double t) => Color.FromRgb(
+    private static Color Mix(Color c, Color with, double t) => Color.FromRgb(
-        (byte)(c.R + (with.R - c.R) * t), (byte)(c.G + (with.G - c.G) * t), (byte)(c.B + (with.B - c.B) * t));
+        (byte)(c.R + (with.R - c.R) * t), (byte)(c.G + (with.G - c.G) * t), (byte)(c.B + (with.B - c.B) * t));
-
+
-    private static SolidColorBrush Brush(Color c)
+    private static SolidColorBrush Brush(Color c)
-    {
+    {
-        var b = new SolidColorBrush(c);
+        var b = new SolidColorBrush(c);
-        b.Freeze();
+        b.Freeze();
-        return b;
+        return b;
-    }
+    }
-}
+}

Watcher.cs

@@ -1,111 +1,140 @@
-using System.IO;
+using System.IO;
-using System.Windows.Threading;
+using System.Windows.Threading;
-
+
-namespace DeskCore;
+namespace DeskCore;
-
+
-/// <summary>
+/// <summary>
-/// Beobachtet Desktop und Kategorie-Ordner. Meldet Änderungen gebündelt (statt bei jedem einzelnen Ereignis)
+/// Beobachtet Desktop und Kategorie-Ordner. Meldet Änderungen gebündelt (statt bei jedem einzelnen Ereignis)
-/// und sammelt neu auf dem Desktop aufgetauchte Elemente für die automatische Sortierung.
+/// und sammelt neu auf dem Desktop aufgetauchte Elemente für die automatische Sortierung.
-/// </summary>
+/// </summary>
-public sealed class Watcher : IDisposable
+public sealed class Watcher : IDisposable
-{
+{
-    private readonly List<FileSystemWatcher> _watchers = [];
+    private readonly List<FileSystemWatcher> _watchers = [];
-    private readonly DispatcherTimer _changedTimer;
+    private readonly DispatcherTimer _changedTimer;
-    private readonly DispatcherTimer _newTimer;
+    private readonly DispatcherTimer _newTimer;
-    private readonly HashSet<string> _newOnDesktop = new(StringComparer.OrdinalIgnoreCase);
+    private readonly HashSet<string> _newOnDesktop = new(StringComparer.OrdinalIgnoreCase);
-    private readonly object _lock = new();
+    private readonly object _lock = new();
-
+
-    /// <summary>Irgendetwas hat sich geändert (UI-Thread).</summary>
+    /// <summary>Irgendetwas hat sich geändert (UI-Thread).</summary>
-    public event Action? Changed;
+    public event Action? Changed;
-    /// <summary>Neue Elemente auf dem Desktop (UI-Thread, nach kurzer Wartezeit).</summary>
+    /// <summary>Neue Elemente auf dem Desktop (UI-Thread, nach kurzer Wartezeit).</summary>
-    public event Action<List<string>>? NewOnDesktop;
+    public event Action<List<string>>? NewOnDesktop;
-
+
-    public Watcher(Dispatcher dispatcher)
+    public Watcher(Dispatcher dispatcher)
-    {
+    {
-        _changedTimer = new DispatcherTimer(TimeSpan.FromMilliseconds(350), DispatcherPriority.Background, (_, _) =>
+        _changedTimer = new DispatcherTimer(TimeSpan.FromMilliseconds(350), DispatcherPriority.Background, (_, _) =>
-        {
+        {
-            _changedTimer!.Stop();
+            _changedTimer!.Stop();
-            Changed?.Invoke();
+            Changed?.Invoke();
-        }, dispatcher);
+        }, dispatcher);
-        _changedTimer.Stop();
+        _changedTimer.Stop();
-
+
-        // Etwas länger warten: Installer legen Verknüpfungen oft in mehreren Schritten an
+        // Etwas länger warten: Installer legen Verknüpfungen oft in mehreren Schritten an
-        _newTimer = new DispatcherTimer(TimeSpan.FromSeconds(2), DispatcherPriority.Background, (_, _) =>
+        _newTimer = new DispatcherTimer(TimeSpan.FromSeconds(2), DispatcherPriority.Background, (_, _) =>
-        {
+        {
-            _newTimer!.Stop();
+            _newTimer!.Stop();
-            List<string> items;
+            List<string> items;
-            lock (_lock) { items = _newOnDesktop.ToList(); _newOnDesktop.Clear(); }
+            lock (_lock) { items = _newOnDesktop.ToList(); _newOnDesktop.Clear(); }
-            items = items.Where(p => (File.Exists(p) || Directory.Exists(p)) && !Storage.CreatedByApp(p)).ToList();
+            items = items.Where(p => (File.Exists(p) || Directory.Exists(p)) && !Storage.CreatedByApp(p)).ToList();
-            if (items.Count > 0) NewOnDesktop?.Invoke(items);
+            if (items.Count > 0) NewOnDesktop?.Invoke(items);
-        }, dispatcher);
+        }, dispatcher);
-        _newTimer.Stop();
+        _newTimer.Stop();
-
+
-        Directory.CreateDirectory(Storage.Root);
+        Directory.CreateDirectory(Storage.Root);
-        Add(Storage.UserDesktop, false, true);
+        Add(Storage.UserDesktop, false, true);
-        Add(Storage.PublicDesktop, false, true);
+        Add(Storage.PublicDesktop, false, true);
-        Add(Storage.Root, true, false);
+        Add(Storage.Root, true, false);
-    }
+    }
-
+
-    private void Add(string dir, bool subdirs, bool isDesktop)
+    private void Add(string dir, bool subdirs, bool isDesktop)
-    {
+    {
-        if (!Directory.Exists(dir)) return;
+        if (!Directory.Exists(dir)) return;
-        try
+        try
-        {
+        {
-            var w = new FileSystemWatcher(dir)
+            var w = new FileSystemWatcher(dir)
-            {
+            {
-                IncludeSubdirectories = subdirs,
+                IncludeSubdirectories = subdirs,
-                NotifyFilter = NotifyFilters.FileName | NotifyFilters.DirectoryName | NotifyFilters.LastWrite,
+                NotifyFilter = NotifyFilters.FileName | NotifyFilters.DirectoryName | NotifyFilters.LastWrite,
-                InternalBufferSize = 64 * 1024,
+                InternalBufferSize = 64 * 1024,
-            };
+            };
-            FileSystemEventHandler onChange = (_, e) =>
+            FileSystemEventHandler onChange = (_, e) =>
-            {
+            {
-                Poke();
+                Poke();
-                if (isDesktop && e.ChangeType == WatcherChangeTypes.Created) NoteNew(e.FullPath);
+                if (isDesktop && e.ChangeType == WatcherChangeTypes.Created) NoteNew(e.FullPath);
-            };
+            };
-            w.Created += onChange;
+            w.Created += onChange;
-            w.Deleted += onChange;
+            w.Deleted += onChange;
-            w.Changed += onChange;
+            w.Changed += onChange;
-            w.Renamed += (_, e) => { Poke(); if (isDesktop) NoteNew(e.FullPath); };
+            w.Renamed += (_, e) => { Poke(); if (isDesktop) NoteNew(e.FullPath); };
-            w.Error += (_, _) => Poke();
+            w.Error += (_, _) => Poke();
-            w.EnableRaisingEvents = true;
+            w.EnableRaisingEvents = true;
-            _watchers.Add(w);
+            _watchers.Add(w);
-        }
+        }
-        catch { }
+        catch { }
-    }
+    }
-
+
-    private void NoteNew(string path)
+    private void NoteNew(string path)
-    {
+    {
-        var name = Path.GetFileName(path);
+        var name = Path.GetFileName(path);
-        if (name.StartsWith('~') || name.EndsWith(".tmp", StringComparison.OrdinalIgnoreCase) ||
+        if (name.StartsWith('~') || name.EndsWith(".tmp", StringComparison.OrdinalIgnoreCase) ||
-            name.Equals("desktop.ini", StringComparison.OrdinalIgnoreCase)) return;
+            name.Equals("desktop.ini", StringComparison.OrdinalIgnoreCase)) return;
-        lock (_lock) _newOnDesktop.Add(path);
+        lock (_lock) _newOnDesktop.Add(path);
-        _newTimer.Dispatcher.BeginInvoke(() => { _newTimer.Stop(); _newTimer.Start(); });
+        _newTimer.Dispatcher.BeginInvoke(() => { _newTimer.Stop(); _newTimer.Start(); });
-    }
+    }
-
+
-    private void Poke() => _changedTimer.Dispatcher.BeginInvoke(() => { _changedTimer.Stop(); _changedTimer.Start(); });
+    private void Poke() => _changedTimer.Dispatcher.BeginInvoke(() => { _changedTimer.Stop(); _changedTimer.Start(); });
-
+
-    public void Dispose()
+    public void Dispose()
-    {
+    {
-        foreach (var w in _watchers) w.Dispose();
+        foreach (var w in _watchers) w.Dispose();
-        _changedTimer.Stop();
+        _changedTimer.Stop();
-        _newTimer.Stop();
+        _newTimer.Stop();
-    }
+    }
-}
+}
-
+
-public static class AutoSorter
+public static class AutoSorter
-{
+{
-    /// <summary>Erste passende Regel → Kategoriename (nur existierende Kategorien).</summary>
+    /// <summary>Dateityp-Gruppen für Regeln vom Typ "Dateityp ist".</summary>
-    public static string? Match(string path)
+    private static readonly Dictionary<string, string[]> Groups = new(StringComparer.CurrentCultureIgnoreCase)
-    {
+    {
-        var name = Storage.DisplayName(path);
+        ["Bilder"] = ["jpg", "jpeg", "png", "gif", "bmp", "webp", "heic", "tif", "tiff", "svg", "ico", "raw", "psd"],
-        var cats = Storage.Categories();
+        ["Videos"] = ["mp4", "mkv", "avi", "mov", "wmv", "webm", "m4v", "flv", "mpg", "mpeg"],
-        foreach (var r in AppSettings.Current.Rules)
+        ["Musik"] = ["mp3", "wav", "flac", "aac", "ogg", "m4a", "wma", "opus"],
-        {
+        ["Dokumente"] = ["pdf", "doc", "docx", "xls", "xlsx", "ppt", "pptx", "odt", "ods", "odp", "txt", "rtf", "md", "csv"],
-            if (string.IsNullOrWhiteSpace(r.Contains)) continue;
+        ["Archive"] = ["zip", "rar", "7z", "tar", "gz", "bz2", "xz", "iso"],
-            if (!name.Contains(r.Contains.Trim(), StringComparison.CurrentCultureIgnoreCase)) continue;
+        ["Programme"] = ["exe", "msi", "lnk", "url", "appref-ms", "bat", "cmd"],
-            var cat = cats.FirstOrDefault(c => string.Equals(c, r.Category, StringComparison.OrdinalIgnoreCase));
+        ["Verknüpfungen"] = ["lnk", "url", "appref-ms"],
-            if (cat is not null) return cat;
+    };
-        }
+
-        return null;
+    /// <summary>Passt eine Regel auf das Element?</summary>
-    }
+    public static bool Matches(SortRule r, string path)
-}
+    {
+        var value = r.Contains.Trim();
+        if (value.Length == 0) return false;
+        if (r.Kind != "Typ") return Storage.DisplayName(path).Contains(value, StringComparison.CurrentCultureIgnoreCase);
+
+        bool isFolder = Directory.Exists(path);
+        var ext = Path.GetExtension(path).TrimStart('.').ToLowerInvariant();
+        foreach (var token in value.Split([',', ';', ' '], StringSplitOptions.RemoveEmptyEntries))
+        {
+            var t = token.Trim().TrimStart('*', '.').ToLowerInvariant();
+            if (t is "ordner") { if (isFolder) return true; continue; }
+            if (Groups.TryGetValue(t, out var exts)) { if (!isFolder && exts.Contains(ext)) return true; continue; }
+            if (!isFolder && t == ext) return true;
+        }
+        return false;
+    }
+
+    /// <summary>Erste passende Regel → Kategoriename (nur existierende Kategorien).</summary>
+    public static string? Match(string path)
+    {
+        var cats = Storage.Categories();
+        foreach (var r in AppSettings.Current.Rules)
+        {
+            if (!Matches(r, path)) continue;
+            var cat = cats.FirstOrDefault(c => string.Equals(c, r.Category, StringComparison.OrdinalIgnoreCase));
+            if (cat is not null) return cat;
+        }
+        return null;
+    }
+}

artifacts/app/LICENSE.txt

@@ -0,0 +1,38 @@
+DeskCore – Lizenz- und Nutzungsbedingungen
+
+Copyright (c) M_Viper. Alle Rechte vorbehalten.
+
+Diese Software („DeskCore") sowie sämtlicher zugehöriger Quellcode, Ressourcen und
+Dokumentation sind urheberrechtlich geschützt. Mit der Nutzung dieser Software
+erkennst du die folgenden Bedingungen an.
+
+1. Erlaubte Nutzung
+   Die Nutzung von DeskCore ist ausschließlich für den privaten, nicht-kommerziellen
+   Gebrauch gestattet.
+
+2. Untersagt ist insbesondere
+   - Die Weitergabe dieser Software oder von Teilen davon an Dritte
+   - Das Verändern, Dekompilieren, Zurückentwickeln (Reverse Engineering) oder
+     Bearbeiten des Codes
+   - Die Veröffentlichung – auch in veränderter oder abgeleiteter Form –
+     an anderer Stelle als den offiziellen Kanälen des Autors
+   - Der Verkauf sowie jede sonstige kommerzielle Nutzung
+
+3. Keine Gewährleistung
+   Die Software wird ohne jegliche Gewährleistung bereitgestellt, weder
+   ausdrücklich noch stillschweigend, einschließlich, aber nicht beschränkt auf
+   die Gewährleistung der Marktgängigkeit, der Eignung für einen bestimmten
+   Zweck und der Nichtverletzung von Rechten Dritter. Der Autor haftet nicht für
+   Schäden, die aus der Nutzung oder Unmöglichkeit der Nutzung der Software
+   entstehen.
+
+4. Rechtsfolgen bei Verstoß
+   Wer gegen diese Bedingungen verstößt, macht sich strafbar und kann rechtlich
+   belangt werden. Alle Rechte, die hier nicht ausdrücklich eingeräumt werden,
+   bleiben beim Autor vorbehalten.
+
+5. Markenhinweis
+   DeskCore ist kein offizielles Produkt von Microsoft. Windows ist
+   eine Marke der Microsoft Corporation.
+
+Kontakt: https://m-viper.de

artifacts/setup/DeskCore-Setup.exe.config

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<configuration>
+  <startup>
+    <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.8" />
+  </startup>
+</configuration>

bin/Release/net9.0-windows/DeskCore.deps.json

@@ -0,0 +1,23 @@
+{
+  "runtimeTarget": {
+    "name": ".NETCoreApp,Version=v9.0",
+    "signature": ""
+  },
+  "compilationOptions": {},
+  "targets": {
+    ".NETCoreApp,Version=v9.0": {
+      "DeskCore/1.1.0": {
+        "runtime": {
+          "DeskCore.dll": {}
+        }
+      }
+    }
+  },
+  "libraries": {
+    "DeskCore/1.1.0": {
+      "type": "project",
+      "serviceable": false,
+      "sha512": ""
+    }
+  }
+}

bin/Release/net9.0-windows/DeskCore.runtimeconfig.json

@@ -0,0 +1,20 @@
+{
+  "runtimeOptions": {
+    "tfm": "net9.0",
+    "frameworks": [
+      {
+        "name": "Microsoft.NETCore.App",
+        "version": "9.0.0"
+      },
+      {
+        "name": "Microsoft.WindowsDesktop.App",
+        "version": "9.0.0"
+      }
+    ],
+    "configProperties": {
+      "System.Reflection.Metadata.MetadataUpdater.IsSupported": false,
+      "System.Runtime.Serialization.EnableUnsafeBinaryFormatterSerialization": false,
+      "CSWINRT_USE_WINDOWS_UI_XAML_PROJECTIONS": false
+    }
+  }
+}

bin/Release/net9.0-windows/LICENSE.txt

@@ -0,0 +1,38 @@
+DeskCore – Lizenz- und Nutzungsbedingungen
+
+Copyright (c) M_Viper. Alle Rechte vorbehalten.
+
+Diese Software („DeskCore") sowie sämtlicher zugehöriger Quellcode, Ressourcen und
+Dokumentation sind urheberrechtlich geschützt. Mit der Nutzung dieser Software
+erkennst du die folgenden Bedingungen an.
+
+1. Erlaubte Nutzung
+   Die Nutzung von DeskCore ist ausschließlich für den privaten, nicht-kommerziellen
+   Gebrauch gestattet.
+
+2. Untersagt ist insbesondere
+   - Die Weitergabe dieser Software oder von Teilen davon an Dritte
+   - Das Verändern, Dekompilieren, Zurückentwickeln (Reverse Engineering) oder
+     Bearbeiten des Codes
+   - Die Veröffentlichung – auch in veränderter oder abgeleiteter Form –
+     an anderer Stelle als den offiziellen Kanälen des Autors
+   - Der Verkauf sowie jede sonstige kommerzielle Nutzung
+
+3. Keine Gewährleistung
+   Die Software wird ohne jegliche Gewährleistung bereitgestellt, weder
+   ausdrücklich noch stillschweigend, einschließlich, aber nicht beschränkt auf
+   die Gewährleistung der Marktgängigkeit, der Eignung für einen bestimmten
+   Zweck und der Nichtverletzung von Rechten Dritter. Der Autor haftet nicht für
+   Schäden, die aus der Nutzung oder Unmöglichkeit der Nutzung der Software
+   entstehen.
+
+4. Rechtsfolgen bei Verstoß
+   Wer gegen diese Bedingungen verstößt, macht sich strafbar und kann rechtlich
+   belangt werden. Alle Rechte, die hier nicht ausdrücklich eingeräumt werden,
+   bleiben beim Autor vorbehalten.
+
+5. Markenhinweis
+   DeskCore ist kein offizielles Produkt von Microsoft. Windows ist
+   eine Marke der Microsoft Corporation.
+
+Kontakt: https://m-viper.de

bin/Release/net9.0-windows/win-x64/DeskCore.deps.json

@@ -0,0 +1,24 @@
+{
+  "runtimeTarget": {
+    "name": ".NETCoreApp,Version=v9.0/win-x64",
+    "signature": ""
+  },
+  "compilationOptions": {},
+  "targets": {
+    ".NETCoreApp,Version=v9.0": {},
+    ".NETCoreApp,Version=v9.0/win-x64": {
+      "DeskCore/1.0.2": {
+        "runtime": {
+          "DeskCore.dll": {}
+        }
+      }
+    }
+  },
+  "libraries": {
+    "DeskCore/1.0.2": {
+      "type": "project",
+      "serviceable": false,
+      "sha512": ""
+    }
+  }
+}