M_Viper/DeskCore
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 5 Wiki Activity

Upload via GUI (180 Dateien)

Browse Source
This commit is contained in:
M_Viper
2026-10-03 19:51:56 +00:00
parent 9b843ecab1
commit ddc30b0fe9
38 changed files with 7174 additions and 3688 deletions
Download Patch File Download Diff File Expand all files Collapse all files
App.xaml.cs
+191 -128
View File
@@ -1,128 +1,191 @@
using System.IO;
using System.Windows;
using System.Windows.Interop;
namespace DeskCore;
public partial class App : Application
{
private const string MutexName = "DeskCore.Instanz";
private const string ShowEventName = "DeskCore.Anzeigen";
public static MainWindow? Win { get; private set; }
public static Tray? TrayIcon { get; private set; }
public static bool Quitting { get; private set; }
private static Hotkey? _hotkey;
private static Watcher? _watcher;
private Mutex? _mutex;
private EventWaitHandle? _showEvent;
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);
if (!first)
{
try { EventWaitHandle.OpenExisting(ShowEventName).Set(); } catch { }
Shutdown();
return;
}
Migration.Run(); // alte "Desktop Sortierer"-Ordner übernehmen – vor allem anderen
_showEvent = new EventWaitHandle(false, EventResetMode.AutoReset, ShowEventName);
new Thread(() =>
{
while (_showEvent.WaitOne())
Dispatcher.BeginInvoke(() => Win?.ShowFromBackground());
}) { IsBackground = true, Name = "ShowListener" }.Start();
DispatcherUnhandledException += (_, args) =>
{
var log = Path.Combine(Storage.Root, "fehler.log");
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);
args.Handled = true;
};
base.OnStartup(e);
ShutdownMode = ShutdownMode.OnExplicitShutdown;
Storage.FlushHolding(); // Reste eines Absturzes in den Papierkorb
Theme.Init();
Theme.Changed += FenceManager.RefreshAll;
Win = new MainWindow();
MainWindow = Win;
var hwnd = new WindowInteropHelper(Win).EnsureHandle();
_hotkey = new Hotkey(hwnd);
_hotkey.Pressed += () => Win.ToggleFromHotkey();
ApplyHotkey();
TrayIcon = new Tray();
TrayIcon.Clicked += () => Win.ShowFromBackground();
TrayIcon.BalloonClicked += () => Win.ShowFromBackground();
TrayIcon.MenuRequested += () => Win.ShowTrayMenu();
ApplyTray();
_watcher = new Watcher(Dispatcher);
_watcher.Changed += () =>
{
Win.OnStorageChanged();
FenceManager.RefreshAll();
};
_watcher.NewOnDesktop += Win.AutoSortNew;
Autostart.RefreshPath();
bool minimized = e.Args.Contains("--minimized", StringComparer.OrdinalIgnoreCase);
if (!minimized || !AppSettings.Current.TrayEnabled) Win.Show();
FenceManager.Sync();
// Bildschirm abgesteckt/Auflösung geändert → Fenster und Boxen wieder in den sichtbaren Bereich holen
Microsoft.Win32.SystemEvents.DisplaySettingsChanged += (_, _) => Dispatcher.BeginInvoke(() =>
{
Win.EnsureOnScreen();
FenceManager.EnsureOnScreen();
});
Win.CheckForUpdatesOnStartup();
}
/// <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);
}
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();
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);
}
}
using System.IO;
using System.Windows;
using System.Windows.Interop;
namespace DeskCore;
public partial class App : Application
{
private const string MutexName = "DeskCore.Instanz";
public static MainWindow? Win { get; private set; }
public static Tray? TrayIcon { get; private set; }
public static bool Quitting { get; private set; }
private static Hotkey? _hotkey;
private static Hotkey? _peekHotkey;
private static Hotkey? _pagePrev, _pageNext;
private static System.Windows.Threading.DispatcherTimer? _desktopTimer;
private static Watcher? _watcher;
private Mutex? _mutex;
protected override void OnStartup(StartupEventArgs e)
{
// Nur eine Instanz: weitere Aufrufe reichen ihren Befehl (oder "Fenster zeigen") an die laufende weiter
_mutex = new Mutex(true, MutexName, out bool first);
if (!first)
{
Commands.Send(e.Args);
Shutdown();
return;
}
Migration.Run(); // alte "Desktop Sortierer"-Ordner übernehmen – vor allem anderen
Commands.Listen(args => Dispatcher.BeginInvoke(() => HandleCommand(args)));
DispatcherUnhandledException += (_, args) =>
{
var log = Path.Combine(Storage.Root, "fehler.log");
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);
args.Handled = true;
};
base.OnStartup(e);
ShutdownMode = ShutdownMode.OnExplicitShutdown;
Storage.FlushHolding(); // Reste eines Absturzes in den Papierkorb
Theme.Init();
Theme.Changed += FenceManager.RefreshAll;
Win = new MainWindow();
MainWindow = Win;
var hwnd = new WindowInteropHelper(Win).EnsureHandle();
_hotkey = new Hotkey(hwnd);
_hotkey.Pressed += () => Win.ToggleFromHotkey();
ApplyHotkey();
_peekHotkey = new Hotkey(hwnd, 0xB002);
_peekHotkey.Pressed += FenceManager.TogglePeek;
ApplyPeekHotkey();
// Desktop-Seiten: Win + Alt + Pfeil links/rechts
_pagePrev = new Hotkey(hwnd, 0xB003);
_pagePrev.Pressed += () => FenceManager.NextPage(-1);
_pagePrev.Register(Hotkey.ModWin | Hotkey.ModAlt, 0x25);
_pageNext = new Hotkey(hwnd, 0xB004);
_pageNext.Pressed += () => FenceManager.NextPage(1);
_pageNext.Register(Hotkey.ModWin | Hotkey.ModAlt, 0x27);
TrayIcon = new Tray();
TrayIcon.Clicked += () => Win.ShowFromBackground();
TrayIcon.BalloonClicked += () => Win.ShowFromBackground();
TrayIcon.MenuRequested += () => Win.ShowTrayMenu();
ApplyTray();
_watcher = new Watcher(Dispatcher);
_watcher.Changed += () =>
{
Win.OnStorageChanged();
FenceManager.RefreshAll();
Win.ScheduleDeadShortcutScan(); // z. B. Deinstallation hat die Desktop-Verknüpfung entfernt
};
_watcher.NewOnDesktop += Win.AutoSortNew;
Autostart.RefreshPath();
// Mit einem Befehl gestartet (z. B. Start-Gruppe per Desktop-Verknüpfung)? Dann ohne Fenster.
if (Commands.WantsWindow(e.Args) || !AppSettings.Current.TrayEnabled) Win.Show();
FenceManager.Sync();
// Bildschirm abgesteckt/Auflösung geändert → Fenster und Boxen wieder in den sichtbaren Bereich holen
Microsoft.Win32.SystemEvents.DisplaySettingsChanged += (_, _) => Dispatcher.BeginInvoke(() =>
{
Win.EnsureOnScreen();
FenceManager.OnDisplayChanged();
});
Win.CheckForUpdatesOnStartup();
if (!Commands.WantsWindow(e.Args)) Dispatcher.BeginInvoke(() => HandleCommand(e.Args));
Win.StartDeadShortcutWatch();
DesktopToggle.Apply();
// 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) };
_desktopTimer.Tick += (_, _) => RefreshDesktopIcons();
_desktopTimer.Start();
RefreshDesktopIcons();
}
private static void RefreshDesktopIcons()
{
var s = AppSettings.Current;
if (Quitting) return;
// Nur lesen, wenn eine Funktion die Positionen braucht
if (s.DesktopTint is null && !s.DrawFences && !s.QuickHide) return;
try { DesktopIcons.RefreshCache(); } catch { /* Explorer gerade neu gestartet o. Ä. */ }
DesktopTint.Refresh();
}
/// <summary>Befehl von der Befehlszeile oder einem weiteren Aufruf ausführen.</summary>
private static void HandleCommand(string[] args)
{
if (Win is null || Quitting) return;
if (Commands.Value(args, "--launch") is { } group) Win.LaunchGroupByName(group);
else if (Commands.Value(args, "--snapshot") is { } snap) Win.RestoreSnapshotByName(snap);
else if (Commands.Has(args, "--toggle-desktop")) DesktopToggle.Toggle();
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
+6
View File
@@ -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
+70
View File
@@ -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
+233
View File
@@ -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
+261
View File
@@ -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
+272
View File
@@ -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
+2 -2
View File
@@ -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
+394
View File
@@ -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
+37 -12
View File
@@ -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}"
BorderThickness="1" ClipToBounds="True">
<DockPanel>
<!-- Titel (zum Verschieben ziehen, Doppelklick = ein-/ausklappen) -->
<Grid DockPanel.Dock="Top" Height="36" Background="Transparent" x:Name="TitleBar">
<Window.Resources>
<!-- Kachelgrößen je Box (im Code je nach Einstellung gesetzt) -->
<sys:Double x:Key="FTileW">78</sys:Double>
<sys:Double x:Key="FTileH">80</sys:Double>
<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"/>
<TextBlock x:Name="TitleText" Grid.Column="1" FontSize="13" FontWeight="SemiBold" VerticalAlignment="Center"
TextTrimming="CharacterEllipsis"/>
<StackPanel x:Name="TabStrip" Orientation="Horizontal" Margin="6,0,0,0" VerticalAlignment="Center" ClipToBounds="True"/>
<TextBlock x:Name="LockGlyph" Grid.Column="1" Text="&#xE72E;" FontFamily="{DynamicResource IconFont}" FontSize="11"
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}">
<Image Source="{Binding Icon}" Width="32" Height="32" Margin="0,8,0,0" RenderOptions.BitmapScalingMode="HighQuality"/>
<StackPanel Width="{DynamicResource FTileW}" Height="{DynamicResource FTileH}" ToolTip="{Binding Name}">
<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
+634 -346
View File
@@ -1,346 +1,634 @@
using System.Diagnostics;
using System.IO;
using System.Runtime.InteropServices;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;
using System.Windows.Interop;
using System.Windows.Media;
using System.Windows.Threading;
namespace DeskCore;
/// <summary>Eine "Box" auf dem Desktop, die den Inhalt einer Kategorie zeigt.</summary>
public partial class FenceWindow : Window
{
private const double CollapsedHeight = 38;
private readonly DispatcherTimer _saveTimer;
private bool _applying;
public string Category { get; private set; }
public FenceWindow(string category)
{
InitializeComponent();
Category = category;
_saveTimer = new DispatcherTimer(TimeSpan.FromMilliseconds(700), DispatcherPriority.Background, (_, _) =>
{
_saveTimer!.Stop();
AppSettings.Current.Save();
}, Dispatcher);
_saveTimer.Stop();
ApplyBounds();
LocationChanged += (_, _) => RememberBounds();
SizeChanged += (_, _) => RememberBounds();
SourceInitialized += (_, _) => PinToDesktop();
Refresh();
}
private CategoryMeta Meta => AppSettings.Current.Meta(Category);
public void Rename(string newName)
{
Category = newName;
Refresh();
}
// ---------- Position/Größe ----------
private void ApplyBounds()
{
_applying = true;
var m = Meta;
Width = Math.Max(MinWidth, m.FenceW);
Height = m.FenceCollapsed ? CollapsedHeight : Math.Max(120, m.FenceH);
var wa = Screens.PrimaryWorkArea;
double left = m.FenceX ?? wa.Right - Width - 24, top = m.FenceY ?? wa.Top + 24;
// Bildschirm abgesteckt? → zurück auf den Hauptbildschirm (oben rechts)
if (!Screens.IsReachable(new Rect(left, top, Width, Height)))
{
left = wa.Right - Width - 24;
top = wa.Top + 24;
m.FenceX = left;
m.FenceY = top;
}
Left = left;
Top = top;
Body.Visibility = m.FenceCollapsed ? Visibility.Collapsed : Visibility.Visible;
_applying = false;
}
/// <summary>Nach Bildschirm-Änderungen: Box wieder sichtbar machen.</summary>
public void EnsureOnScreen()
{
if (Screens.IsReachable(new Rect(Left, Top, ActualWidth, ActualHeight))) return;
Meta.FenceX = null;
Meta.FenceY = null;
ApplyBounds();
AppSettings.Current.Save();
}
private void RememberBounds()
{
if (_applying || !IsLoaded) return;
var m = Meta;
m.FenceX = Left;
m.FenceY = Top;
m.FenceW = Width;
if (!m.FenceCollapsed) m.FenceH = Height;
_saveTimer.Stop();
_saveTimer.Start();
}
private void ToggleCollapsed()
{
Meta.FenceCollapsed = !Meta.FenceCollapsed;
ApplyBounds();
AppSettings.Current.Save();
}
// ---------- Inhalt ----------
public void Refresh()
{
var meta = Meta;
TitleText.Text = Category;
GlyphText.Text = meta.Glyph ?? "";
GlyphText.Foreground = CategoryColors.Brush(meta.Color) ?? (Brush)FindResource("TextBrush");
var items = Storage.Entries(Storage.CategoryPath(Category))
.Select(p => new IconItem { Path = p })
.OrderBy(i => !Directory.Exists(i.Path)).ThenBy(i => i.Name, StringComparer.CurrentCultureIgnoreCase)
.ToList();
int px = (int)Math.Round(32 * VisualTreeHelper.GetDpi(this).DpiScaleX);
foreach (var i in items) IconLoader.Load(i, px);
Items.ItemsSource = items;
CountText.Text = items.Count.ToString();
EmptyText.Visibility = items.Count == 0 ? Visibility.Visible : Visibility.Collapsed;
}
private List<IconItem> Selected => Items.SelectedItems.Cast<IconItem>().ToList();
private static void Open(string path)
{
try { Process.Start(new ProcessStartInfo(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.Path);
}
private void Items_KeyDown(object sender, KeyEventArgs e)
{
var sel = Selected;
if (sel.Count == 0 || App.Win is not { } win) return;
switch (e.Key)
{
case Key.Enter: sel.ForEach(i => Open(i.Path)); 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;
}
}
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", "\uE8A7", () => sel.ForEach(i => Open(i.Path)), bold: true, gesture: "Enter"));
if (sel.Count == 1)
{
ItemMenu.Items.Add(MainWindow.MenuItem("Dateispeicherort öffnen", "\uED25", () =>
Process.Start("explorer.exe", $"/select,\"{sel[0].Path}\"")));
ItemMenu.Items.Add(MainWindow.MenuItem("Umbenennen", "\uE70F", () => win.RenameIcon(sel[0]), gesture: "F2"));
}
ItemMenu.Items.Add(new Separator());
var moveTo = MainWindow.MenuItem("Verschieben nach", "\uE8DE", null);
foreach (var c in Storage.Categories().Where(c => !string.Equals(c, Category, StringComparison.OrdinalIgnoreCase)))
moveTo.Items.Add(MainWindow.MenuItem(c, AppSettings.Current.Categories.GetValueOrDefault(c)?.Glyph ?? "\uF12B",
() => win.TransferAll(sel.Select(i => i.Path), Storage.CategoryPath(c))));
if (moveTo.Items.Count > 0) ItemMenu.Items.Add(moveTo);
ItemMenu.Items.Add(MainWindow.MenuItem("Zurück auf den Desktop legen", "\uE7F4",
() => win.TransferAll(sel.Select(i => i.Path), Storage.UserDesktop)));
ItemMenu.Items.Add(MainWindow.MenuItem("Löschen", "\uE74D", () => win.DeleteIcons(sel), gesture: "Entf"));
ItemMenu.Items.Add(new Separator());
ItemMenu.Items.Add(MainWindow.MenuItem("In DeskCore zeigen", "\uE8A7", ShowInApp));
}
private void MenuButton_Click(object sender, RoutedEventArgs e)
{
FenceMenu.Items.Clear();
FenceMenu.Items.Add(MainWindow.MenuItem("In DeskCore öffnen", "", ShowInApp));
FenceMenu.Items.Add(MainWindow.MenuItem(Meta.FenceCollapsed ? "Ausklappen" : "Einklappen",
Meta.FenceCollapsed ? "" : "", ToggleCollapsed));
FenceMenu.Items.Add(new Separator());
FenceMenu.Items.Add(MainWindow.MenuItem("Box ausblenden", "", () =>
{
Meta.Fence = false;
AppSettings.Current.Save();
FenceManager.Sync();
}));
FenceMenu.PlacementTarget = MenuButton;
FenceMenu.IsOpen = true;
}
private void ShowInApp() => App.Win?.ShowCategory(Category);
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);
}
finally { _dragging = false; }
}
private void Items_DragOver(object sender, DragEventArgs e)
{
e.Effects = e.Data.GetDataPresent(DataFormats.FileDrop) && !_dragging
? (e.AllowedEffects.HasFlag(DragDropEffects.Copy) ? DragDropEffects.Copy : DragDropEffects.Move)
: DragDropEffects.None;
e.Handled = true;
}
private void Items_Drop(object sender, DragEventArgs e)
{
if (!_dragging && e.Data.GetData(DataFormats.FileDrop) is string[] files)
App.Win?.TransferAll(files, Storage.CategoryPath(Category));
}
// ---------- Auf dem Desktop festhalten ----------
private void PinToDesktop()
{
var hwnd = new WindowInteropHelper(this).Handle;
// 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);
}
private IntPtr Hook(IntPtr hwnd, int msg, IntPtr wParam, IntPtr lParam, ref bool handled)
{
switch (msg)
{
case WM_WINDOWPOSCHANGING:
// immer ganz unten bleiben, nie über anderen Fenstern
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;
}
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);
[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);
[DllImport("user32.dll")] private static extern bool SetWindowPos(IntPtr h, IntPtr after, int x, int y, int cx, int cy, uint flags);
}
/// <summary>Hält die Desktop-Boxen passend zu den Einstellungen.</summary>
public static class FenceManager
{
private static readonly List<FenceWindow> _open = [];
public static void Sync()
{
var s = AppSettings.Current;
var wanted = s.FencesEnabled
? Storage.Categories().Where(c => s.Categories.GetValueOrDefault(c)?.Fence == true).ToList()
: [];
foreach (var f in _open.Where(f => !wanted.Contains(f.Category, StringComparer.OrdinalIgnoreCase)).ToList())
{
f.Close();
_open.Remove(f);
}
var wa = SystemParameters.WorkArea;
foreach (var c in wanted)
{
var f = _open.FirstOrDefault(x => string.Equals(x.Category, c, StringComparison.OrdinalIgnoreCase));
if (f is not null) { f.Refresh(); continue; }
// Neue Box: neben die vorhandenen setzen
var meta = s.Meta(c);
if (meta.FenceX is null)
{
// oben rechts beginnen – links liegen meist die Desktop-Icons
int perRow = Math.Max(1, (int)((wa.Width - 48) / (meta.FenceW + 16)));
int i = _open.Count;
meta.FenceX = wa.Right - 24 - meta.FenceW - (i % perRow) * (meta.FenceW + 16);
meta.FenceY = wa.Top + 24 + (i / perRow) * (meta.FenceH + 16);
}
f = new FenceWindow(c);
_open.Add(f);
f.Show();
}
}
public static void RefreshAll()
{
foreach (var f in _open) f.Refresh();
}
public static void EnsureOnScreen()
{
foreach (var f in _open) f.EnsureOnScreen();
}
public static void Renamed(string oldName, string newName)
{
_open.FirstOrDefault(x => string.Equals(x.Category, oldName, StringComparison.OrdinalIgnoreCase))?.Rename(newName);
}
public static void CloseAll()
{
foreach (var f in _open) f.Close();
_open.Clear();
}
}
using System.Diagnostics;
using System.IO;
using System.Runtime.InteropServices;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;
using System.Windows.Interop;
using System.Windows.Media;
using System.Windows.Media.Animation;
using System.Windows.Shell;
using System.Windows.Threading;
namespace DeskCore;
/// <summary>
/// Eine Box auf dem Desktop: zeigt eine oder mehrere Kategorien bzw. Ordner (Tabs),
/// mit eigenem Aussehen, Einklappen, Sperren, Chamäleon und Peek.
/// </summary>
public partial class FenceWindow : Window
{
private const double CollapsedHeight = 38;
private readonly DispatcherTimer _saveTimer;
private readonly DispatcherTimer _collapseTimer;
private FileSystemWatcher? _portalWatcher;
private DispatcherTimer? _portalRefresh;
private bool _applying;
private bool _hoverExpanded;
private bool _mouseInside;
/// <summary>Unterordner, in den im Ordner-Portal navigiert wurde (null = Wurzel).</summary>
private string? _portalSub;
public FenceDef Def { get; }
private static AppSettings S => AppSettings.Current;
public FenceWindow(FenceDef def)
{
InitializeComponent();
Def = def;
_saveTimer = new DispatcherTimer(TimeSpan.FromMilliseconds(700), DispatcherPriority.Background, (_, _) =>
{
_saveTimer!.Stop();
S.Save();
}, Dispatcher);
_saveTimer.Stop();
_collapseTimer = new DispatcherTimer { Interval = TimeSpan.FromMilliseconds(500) };
_collapseTimer.Tick += (_, _) =>
{
_collapseTimer.Stop();
if (!_mouseInside && _hoverExpanded && !ItemMenu.IsOpen && !FenceMenu.IsOpen) CollapseAfterHover();
};
ApplyBounds();
LocationChanged += (_, _) => RememberBounds();
SizeChanged += (_, _) => RememberBounds();
SourceInitialized += (_, _) => PinToDesktop();
MouseEnter += (_, _) => OnHover(true);
MouseLeave += (_, _) => OnHover(false);
Closed += (_, _) => _portalWatcher?.Dispose();
Refresh();
}
// =====================================================================
// Position, Größe, Einklappen
// =====================================================================
private void ApplyBounds()
{
_applying = true;
Width = Math.Max(MinWidth, Def.W);
Height = Def.Collapsed && !_hoverExpanded ? CollapsedHeight : Math.Max(120, Def.H);
var wa = Screens.PrimaryWorkArea;
double left = Def.X ?? wa.Right - Width - 24, top = Def.Y ?? wa.Top + 24;
// Bildschirm abgesteckt? → zurück auf den Hauptbildschirm (oben rechts)
if (!Screens.IsReachable(new Rect(left, top, Width, Height)))
{
left = wa.Right - Width - 24;
top = wa.Top + 24;
Def.X = left;
Def.Y = top;
}
Left = left;
Top = top;
Body.Visibility = Def.Collapsed && !_hoverExpanded ? Visibility.Collapsed : Visibility.Visible;
_applying = false;
}
/// <summary>Position/Größe aus den Einstellungen neu übernehmen (z. B. nach Snapshot).</summary>
public void Reapply()
{
ApplyBounds();
ApplyLook();
Refresh();
}
public void EnsureOnScreen()
{
if (Screens.IsReachable(new Rect(Left, Top, ActualWidth, ActualHeight))) return;
Def.X = null;
Def.Y = null;
ApplyBounds();
S.Save();
}
private void RememberBounds()
{
if (_applying || !IsLoaded || _hoverExpanded) return;
Def.X = Left;
Def.Y = Top;
Def.W = Width;
if (!Def.Collapsed) Def.H = Height;
_saveTimer.Stop();
_saveTimer.Start();
}
private void ToggleCollapsed()
{
_hoverExpanded = false;
Def.Collapsed = !Def.Collapsed;
ApplyBounds();
S.Save();
}
/// <summary>Eingeklappte Box klappt beim Überfahren kurz auf; Chamäleon blendet ein/aus.</summary>
private void OnHover(bool inside)
{
_mouseInside = inside;
if (inside)
{
_collapseTimer.Stop();
if (Def.Collapsed && !_hoverExpanded)
{
_hoverExpanded = true;
ApplyBounds();
}
}
else if (_hoverExpanded) _collapseTimer.Start();
ApplyChameleon();
}
private void CollapseAfterHover()
{
_hoverExpanded = false;
ApplyBounds();
}
// =====================================================================
// Aussehen
// =====================================================================
public void ApplyLook()
{
// Hintergrund: eigene Farbe oder Design-Farbe, mit eingestellter Deckkraft
var baseColor = Def.Background is { } hex && CategoryColors.Brush(hex) is SolidColorBrush custom
? custom.Color
: ((SolidColorBrush)FindResource("FenceBrush")).Color;
double opacity = Math.Clamp(Def.Opacity, 0.2, 1);
if (Def.Blur) opacity = Math.Min(opacity, 0.75); // sonst sieht man vom Milchglas nichts
var bg = new SolidColorBrush(Color.FromArgb((byte)(opacity * 255), baseColor.R, baseColor.G, baseColor.B));
bg.Freeze();
Root.Background = bg;
Root.CornerRadius = new CornerRadius(Def.Blur ? 0 : 8); // Milchglas wirkt nur eckig sauber
// Icon-Größe
var (w, h, icon) = Def.IconSize switch
{
ViewMode.Small => (64.0, 66.0, 24.0),
ViewMode.Large => (98.0, 104.0, 48.0),
_ => (78.0, 80.0, 32.0),
};
Resources["FTileW"] = w;
Resources["FTileH"] = h;
Resources["FIcon"] = icon;
Resources["FTint"] = CategoryColors.Brush(Def.Tint) ?? Brushes.Transparent;
// Sperren: nicht verschieb-/vergrößerbar
Chrome.CaptionHeight = Def.Locked ? 0 : 36;
Chrome.ResizeBorderThickness = Def.Locked ? new Thickness(0) : new Thickness(6);
LockGlyph.Visibility = Def.Locked ? Visibility.Visible : Visibility.Collapsed;
if (IsLoaded) SetBlur(Def.Blur);
ApplyChameleon();
}
/// <summary>Chamäleon: Box ist fast unsichtbar, bis die Maus darüberfährt (nicht während Peek).</summary>
private void ApplyChameleon()
{
double target = S.FenceChameleon && !_mouseInside && !FenceManager.Peeking ? 0.08 : 1;
Root.BeginAnimation(OpacityProperty, new DoubleAnimation(target, TimeSpan.FromMilliseconds(target < 1 ? 600 : 150)));
}
// =====================================================================
// Inhalt & Tabs
// =====================================================================
private FenceTab? Tab => Def.Active;
/// <summary>Ordner des aktiven Tabs (bei Ordner-Portalen ggf. ein Unterordner).</summary>
private string? CurrentFolder => Tab switch
{
null => null,
{ IsFolder: true } t => _portalSub ?? t.Value,
{ } t => Storage.CategoryPath(t.Value),
};
public void Refresh()
{
ApplyLook();
BuildTabs();
var tab = Tab;
var folder = CurrentFolder;
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);
WatchPortal(portal ? folder : null);
List<IconItem> items = [];
if (folder is not null && Directory.Exists(folder))
items = (portal ? PortalEntries(folder) : Storage.Entries(folder)).Select(p => new IconItem { Path = p }).ToList();
items = Sort(items);
int px = (int)Math.Round((double)Resources["FIcon"] * VisualTreeHelper.GetDpi(this).DpiScaleX);
foreach (var i in items) IconLoader.Load(i, px);
Items.ItemsSource = items;
CountText.Text = items.Count.ToString();
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;
}
/// <summary>Ordner-Portal zeigt alles außer versteckten/System-Dateien.</summary>
private static IEnumerable<string> PortalEntries(string dir) => Storage.Entries(dir);
private List<IconItem> Sort(List<IconItem> items)
{
var folders = items.Where(i => Directory.Exists(i.Path));
var files = items.Where(i => !Directory.Exists(i.Path));
IEnumerable<IconItem> Order(IEnumerable<IconItem> x) => Def.Sort switch
{
"Typ" => x.OrderBy(i => Path.GetExtension(i.Path), StringComparer.OrdinalIgnoreCase).ThenBy(i => i.Name, StringComparer.CurrentCultureIgnoreCase),
"Datum" => x.OrderByDescending(i => { try { return File.GetLastWriteTime(i.Path); } catch { return DateTime.MinValue; } }),
_ => x.OrderBy(i => i.Name, StringComparer.CurrentCultureIgnoreCase),
};
return Order(folders).Concat(Order(files)).ToList();
}
private void BuildTabs()
{
TabStrip.Children.Clear();
for (int i = 0; i < Def.Tabs.Count; i++)
{
var t = Def.Tabs[i];
bool active = i == Math.Clamp(Def.ActiveTab, 0, Def.Tabs.Count - 1);
var meta = t.IsFolder ? null : S.Categories.GetValueOrDefault(t.Value);
var glyph = new TextBlock
{
Text = t.IsFolder ? "" : meta?.Glyph ?? "",
FontFamily = (FontFamily)FindResource("IconFont"), FontSize = 13, VerticalAlignment = VerticalAlignment.Center,
Margin = new Thickness(0, 0, 7, 0),
Foreground = CategoryColors.Brush(meta?.Color) ?? (Brush)FindResource(t.IsFolder ? "AccentBrush" : "TextBrush"),
};
var label = new TextBlock
{
Text = t.Title, VerticalAlignment = VerticalAlignment.Center, TextTrimming = TextTrimming.CharacterEllipsis,
FontSize = 13, MaxWidth = Def.Tabs.Count == 1 ? 220 : 120,
FontWeight = active ? FontWeights.SemiBold : FontWeights.Normal,
Foreground = (Brush)FindResource(active ? "TextBrush" : "TextSecondaryBrush"),
};
var content = new StackPanel { Orientation = Orientation.Horizontal, Children = { glyph, label } };
var underline = new Border
{
Height = 2, CornerRadius = new CornerRadius(1), Margin = new Thickness(4, 0, 4, 0), VerticalAlignment = VerticalAlignment.Bottom,
Background = active && Def.Tabs.Count > 1 ? (Brush)FindResource("AccentBrush") : Brushes.Transparent,
};
var btn = new Button
{
Style = (Style)FindResource("SubtleButton"), Padding = new Thickness(6, 4, 6, 4), MinHeight = 0, Tag = i,
Content = new Grid { Children = { content, underline } }, Margin = new Thickness(0, 0, 2, 0),
ToolTip = t.IsFolder ? t.Value : $"Kategorie „{t.Value}“",
};
WindowChrome.SetIsHitTestVisibleInChrome(btn, Def.Tabs.Count > 1); // bei nur einem Tab: Titel = Ziehfläche
btn.Click += (_, _) => SwitchTab((int)btn.Tag);
btn.MouseRightButtonUp += (_, ev) => { ShowTabMenu((int)btn.Tag); ev.Handled = true; };
TabStrip.Children.Add(btn);
}
}
private void SwitchTab(int index)
{
if (index == Def.ActiveTab) return;
Def.ActiveTab = index;
_portalSub = null;
S.Save();
Refresh();
}
// ---------- Ordner-Portal ----------
private void WatchPortal(string? folder)
{
if (string.Equals(_portalWatcher?.Path, folder, StringComparison.OrdinalIgnoreCase)) return;
_portalWatcher?.Dispose();
_portalWatcher = null;
if (folder is null || !Directory.Exists(folder)) return;
_portalRefresh ??= new DispatcherTimer(TimeSpan.FromMilliseconds(400), DispatcherPriority.Background, (_, _) =>
{
_portalRefresh!.Stop();
Refresh();
}, Dispatcher);
try
{
_portalWatcher = new FileSystemWatcher(folder)
{
NotifyFilter = NotifyFilters.FileName | NotifyFilters.DirectoryName | NotifyFilters.LastWrite,
EnableRaisingEvents = true,
};
FileSystemEventHandler poke = (_, _) => Dispatcher.BeginInvoke(() => { _portalRefresh.Stop(); _portalRefresh.Start(); });
_portalWatcher.Created += poke;
_portalWatcher.Deleted += poke;
_portalWatcher.Renamed += (s, e) => poke(s, e);
}
catch { }
}
private void PortalUp_Click(object sender, RoutedEventArgs e)
{
if (Tab is not { IsFolder: true } t || _portalSub is null) return;
var parent = Path.GetDirectoryName(_portalSub.TrimEnd('\\'));
_portalSub = parent is null || Storage.SamePath(parent, t.Value) || !Storage.IsUnder(parent, t.Value) ? null : parent;
Refresh();
}
// =====================================================================
// Icons
// =====================================================================
private List<IconItem> Selected => Items.SelectedItems.Cast<IconItem>().ToList();
private void Open(IconItem i)
{
// Im Ordner-Portal öffnen Ordner sich innerhalb der Box
if (Tab?.IsFolder == true && Directory.Exists(i.Path) && !i.Path.EndsWith(".lnk", StringComparison.OrdinalIgnoreCase))
{
_portalSub = i.Path;
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
+101
View File
@@ -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
+140 -138
View File
@@ -1,138 +1,140 @@
using System.Runtime.InteropServices;
using System.Windows.Input;
using System.Windows.Interop;
using Microsoft.Win32;
namespace DeskCore;
/// <summary>Systemweites Tastenkürzel (RegisterHotKey).</summary>
public sealed class Hotkey : IDisposable
{
public const int ModAlt = 0x1, ModCtrl = 0x2, ModShift = 0x4, ModWin = 0x8;
private const int ModNoRepeat = 0x4000, WmHotkey = 0x0312, Id = 0xB001;
private readonly IntPtr _hwnd;
private readonly HwndSource _source;
private bool _registered;
public event Action? Pressed;
public Hotkey(IntPtr hwnd)
{
_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)
{
Unregister();
if (vk == 0) return false;
_registered = RegisterHotKey(_hwnd, Id, modifiers | ModNoRepeat, vk);
return _registered;
}
public void Unregister()
{
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)
{
Pressed?.Invoke();
handled = true;
}
return IntPtr.Zero;
}
public static string Describe(int modifiers, int vk)
{
if (vk == 0) return "–";
var parts = new List<string>();
if ((modifiers & ModWin) != 0) parts.Add("Win");
if ((modifiers & ModCtrl) != 0) parts.Add("Strg");
if ((modifiers & ModAlt) != 0) parts.Add("Alt");
if ((modifiers & ModShift) != 0) parts.Add("Umschalt");
var key = KeyInterop.KeyFromVirtualKey(vk);
parts.Add(key switch
{
>= Key.D0 and <= Key.D9 => ((char)('0' + (key - Key.D0))).ToString(),
Key.Space => "Leertaste",
_ => key.ToString(),
});
return string.Join(" + ", parts);
}
public void Dispose()
{
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);
}
/// <summary>Start mit Windows über HKCU\...\Run.</summary>
public static class Autostart
{
private const string Key = @"Software\Microsoft\Windows\CurrentVersion\Run";
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 static readonly string[] OldNames = ["DesktopSortierer", "DeskHub"];
public static bool Enabled
{
get
{
try
{
using var k = Registry.CurrentUser.OpenSubKey(Key);
return k?.GetValue(Name) is string;
}
catch { return false; }
}
set
{
try
{
using var k = Registry.CurrentUser.OpenSubKey(Key, writable: true) ?? Registry.CurrentUser.CreateSubKey(Key);
if (value) k.SetValue(Name, $"\"{Environment.ProcessPath}\" --minimized");
else k.DeleteValue(Name, throwOnMissingValue: false);
}
catch { }
}
}
/// <summary>Alten Autostart-Eintrag ("DesktopSortierer") auf den neuen Namen umstellen.</summary>
public static void Migrate()
{
try
{
using var k = Registry.CurrentUser.OpenSubKey(Key, writable: true);
if (k is null) return;
bool wasEnabled = false;
foreach (var old in OldNames)
{
if (k.GetValue(old) is not string cmd) continue;
bool ours = old == "DesktopSortierer" ||
(cmd.Contains($"{old}.exe", StringComparison.OrdinalIgnoreCase) && cmd.Contains("--minimized"));
if (!ours) continue;
k.DeleteValue(old, throwOnMissingValue: false);
wasEnabled = true;
}
if (wasEnabled) Enabled = true;
}
catch { }
}
/// <summary>Falls die exe verschoben wurde: Pfad im Autostart aktualisieren.</summary>
public static void RefreshPath()
{
if (Enabled) Enabled = true;
}
}
using System.Runtime.InteropServices;
using System.Windows.Input;
using System.Windows.Interop;
using Microsoft.Win32;
namespace DeskCore;
/// <summary>Systemweites Tastenkürzel (RegisterHotKey).</summary>
public sealed class Hotkey : IDisposable
{
public const int ModAlt = 0x1, ModCtrl = 0x2, ModShift = 0x4, ModWin = 0x8;
private const int ModNoRepeat = 0x4000, WmHotkey = 0x0312;
private readonly int Id;
private readonly IntPtr _hwnd;
private readonly HwndSource _source;
private bool _registered;
public event Action? Pressed;
public Hotkey(IntPtr hwnd, int id = 0xB001)
{
Id = id;
_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)
{
Unregister();
if (vk == 0) return false;
_registered = RegisterHotKey(_hwnd, Id, modifiers | ModNoRepeat, vk);
return _registered;
}
public void Unregister()
{
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)
{
Pressed?.Invoke();
handled = true;
}
return IntPtr.Zero;
}
public static string Describe(int modifiers, int vk)
{
if (vk == 0) return "–";
var parts = new List<string>();
if ((modifiers & ModWin) != 0) parts.Add("Win");
if ((modifiers & ModCtrl) != 0) parts.Add("Strg");
if ((modifiers & ModAlt) != 0) parts.Add("Alt");
if ((modifiers & ModShift) != 0) parts.Add("Umschalt");
var key = KeyInterop.KeyFromVirtualKey(vk);
parts.Add(key switch
{
>= Key.D0 and <= Key.D9 => ((char)('0' + (key - Key.D0))).ToString(),
Key.Space => "Leertaste",
_ => key.ToString(),
});
return string.Join(" + ", parts);
}
public void Dispose()
{
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);
}
/// <summary>Start mit Windows über HKCU\...\Run.</summary>
public static class Autostart
{
private const string Key = @"Software\Microsoft\Windows\CurrentVersion\Run";
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 static readonly string[] OldNames = ["DesktopSortierer", "DeskHub"];
public static bool Enabled
{
get
{
try
{
using var k = Registry.CurrentUser.OpenSubKey(Key);
return k?.GetValue(Name) is string;
}
catch { return false; }
}
set
{
try
{
using var k = Registry.CurrentUser.OpenSubKey(Key, writable: true) ?? Registry.CurrentUser.CreateSubKey(Key);
if (value) k.SetValue(Name, $"\"{Environment.ProcessPath}\" --minimized");
else k.DeleteValue(Name, throwOnMissingValue: false);
}
catch { }
}
}
/// <summary>Alten Autostart-Eintrag ("DesktopSortierer") auf den neuen Namen umstellen.</summary>
public static void Migrate()
{
try
{
using var k = Registry.CurrentUser.OpenSubKey(Key, writable: true);
if (k is null) return;
bool wasEnabled = false;
foreach (var old in OldNames)
{
if (k.GetValue(old) is not string cmd) continue;
bool ours = old == "DesktopSortierer" ||
(cmd.Contains($"{old}.exe", StringComparison.OrdinalIgnoreCase) && cmd.Contains("--minimized"));
if (!ours) continue;
k.DeleteValue(old, throwOnMissingValue: false);
wasEnabled = true;
}
if (wasEnabled) Enabled = true;
}
catch { }
}
/// <summary>Falls die exe verschoben wurde: Pfad im Autostart aktualisieren.</summary>
public static void RefreshPath()
{
if (Enabled) Enabled = true;
}
}
MainWindow.Cleanup.cs
+114
View File
@@ -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
+119
View File
@@ -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
+413
View File
@@ -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
+134
View File
@@ -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", "");
}
}
MainWindow.xaml
+934 -676
View File
File diff suppressed because it is too large Load Diff
MainWindow.xaml.cs
+1570 -1503
View File
File diff suppressed because it is too large Load Diff
Migration.cs
+5
View File
@@ -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
+109 -97
View File
@@ -1,97 +1,109 @@
using System.ComponentModel;
using System.IO;
using System.Windows.Media;
namespace DeskCore;
public class CategoryItem
{
public required string Name { get; init; }
public bool IsDesktop { get; init; }
public int Count { get; set; }
public string Folder => IsDesktop ? Storage.UserDesktop : Storage.CategoryPath(Name);
public CategoryMeta? Meta => IsDesktop ? null : AppSettings.Current.Categories.GetValueOrDefault(Name);
public string Glyph => IsDesktop ? "" : Meta?.Glyph ?? "";
public Brush? GlyphBrush => CategoryColors.Brush(Meta?.Color);
public bool HasFence => Meta?.Fence == true;
}
public static class CategoryColors
{
public static readonly (string Name, string Hex)[] All =
[
("Blau", "#3B82F6"), ("Türkis", "#12A594"), ("Grün", "#22A06B"), ("Gelb", "#E2A600"),
("Orange", "#F07A1A"), ("Rot", "#E5484D"), ("Pink", "#D6409F"), ("Lila", "#8E4EC6"), ("Grau", "#8B8D98"),
];
public static Brush? Brush(string? hex)
{
if (string.IsNullOrEmpty(hex)) return null;
try
{
var b = new SolidColorBrush((Color)ColorConverter.ConvertFromString(hex));
b.Freeze();
return b;
}
catch { return null; }
}
}
public static class CategoryGlyphs
{
public static readonly (string Glyph, string Name)[] All =
[
("", "Ordner"), ("", "Spiele"), ("", "Arbeit"), ("", "Code"),
("", "Musik"), ("", "Video"), ("", "Bilder"), ("", "Internet"),
("", "Mail"), ("", "Shopping"), ("", "System"), ("", "Werkzeuge"),
("", "Dokumente"), ("", "Favoriten"), ("", "Herz"), ("", "Cloud"),
("", "Downloads"), ("", "Personen"), ("", "Bibliothek"), ("", "Rechner"),
("", "Ideen"), ("", "Zuhause"), ("", "Lernen"), ("", "Erweiterungen"),
("", "Computer"), ("", "Sicherheit"), ("", "Ebenen"),
];
}
public class IconItem : INotifyPropertyChanged
{
public required string Path { get; init; }
public string? Category { get; init; }
private ImageSource? _icon;
public ImageSource? Icon
{
get => _icon;
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 string? SortedInto { get; init; }
public bool IsSorted => SortedInto is not null;
public string Name => Storage.DisplayName(Path);
public string TypeText
{
get
{
if (Directory.Exists(Path)) return "Ordner";
var ext = System.IO.Path.GetExtension(Path).ToLowerInvariant();
return ext switch
{
".lnk" => "Verknüpfung",
".url" => "Internetverknüpfung",
".exe" => "Programm",
"" => "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;
}
using System.ComponentModel;
using System.IO;
using System.Windows.Media;
namespace DeskCore;
public class CategoryItem
{
public required string Name { get; init; }
public bool IsDesktop { get; init; }
public int Count { get; set; }
public string Folder => IsDesktop ? Storage.UserDesktop : Storage.CategoryPath(Name);
public CategoryMeta? Meta => IsDesktop ? null : AppSettings.Current.Categories.GetValueOrDefault(Name);
public string Glyph => IsDesktop ? "" : Meta?.Glyph ?? "";
public Brush? GlyphBrush => CategoryColors.Brush(Meta?.Color);
public bool HasFence => !IsDesktop && AppSettings.Current.HasFence(Name);
}
/// <summary>Eintrag einer Start-Gruppe in der Seitenleiste.</summary>
public class LaunchGroupItem
{
public required LaunchGroup Group { get; init; }
public string Name => Group.Name;
public int Count => Group.Items.Count;
public string Glyph => ""; // Abspielen
public Brush? GlyphBrush => CategoryColors.Brush(Group.Color);
public bool HasFence => false;
public bool IsDesktop => true; // blendet den Umsortier-Griff der Kategorien aus
}
public static class CategoryColors
{
public static readonly (string Name, string Hex)[] All =
[
("Blau", "#3B82F6"), ("Türkis", "#12A594"), ("Grün", "#22A06B"), ("Gelb", "#E2A600"),
("Orange", "#F07A1A"), ("Rot", "#E5484D"), ("Pink", "#D6409F"), ("Lila", "#8E4EC6"), ("Grau", "#8B8D98"),
];
public static Brush? Brush(string? hex)
{
if (string.IsNullOrEmpty(hex)) return null;
try
{
var b = new SolidColorBrush((Color)ColorConverter.ConvertFromString(hex));
b.Freeze();
return b;
}
catch { return null; }
}
}
public static class CategoryGlyphs
{
public static readonly (string Glyph, string Name)[] All =
[
("", "Ordner"), ("", "Spiele"), ("", "Arbeit"), ("", "Code"),
("", "Musik"), ("", "Video"), ("", "Bilder"), ("", "Internet"),
("", "Mail"), ("", "Shopping"), ("", "System"), ("", "Werkzeuge"),
("", "Dokumente"), ("", "Favoriten"), ("", "Herz"), ("", "Cloud"),
("", "Downloads"), ("", "Personen"), ("", "Bibliothek"), ("", "Rechner"),
("", "Ideen"), ("", "Zuhause"), ("", "Lernen"), ("", "Erweiterungen"),
("", "Computer"), ("", "Sicherheit"), ("", "Ebenen"),
];
}
public class IconItem : INotifyPropertyChanged
{
public required string Path { get; init; }
public string? Category { get; init; }
private ImageSource? _icon;
public ImageSource? Icon
{
get => _icon;
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 string? SortedInto { get; init; }
public bool IsSorted => SortedInto is not null;
public string Name => Storage.DisplayName(Path);
public string TypeText
{
get
{
if (Directory.Exists(Path)) return "Ordner";
var ext = System.IO.Path.GetExtension(Path).ToLowerInvariant();
return ext switch
{
".lnk" => "Verknüpfung",
".url" => "Internetverknüpfung",
".exe" => "Programm",
"" => "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
+254 -29
View File
@@ -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 &amp; 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
- **Win + Umschalt + D** drücken, von überall aus
- oder unten rechts neben der Uhr auf das **DeskCore-Symbol** klicken
Du startest jeden Tag dieselben Programme, z. B. Browser, Mail und Teams? Pack sie in eine **Start-Gruppe**.
Ein Klick, und alle gehen nacheinander auf.
Wenn du das Fenster mit dem **X** schließt, läuft DeskCore unten rechts weiter.
Richtig beenden: **Rechtsklick auf das Symbol neben der Uhr → Beenden**
**Gruppe anlegen**
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.
### 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**.
Oben rechts auf die **Sonne bzw. den Mond** klicken und auswählen – oder **„Wie Windows“**, dann passt sich DeskCore automatisch an.
### 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
+39 -39
View File
@@ -1,39 +1,39 @@
using System.Windows;
namespace DeskCore;
/// <summary>Bildschirm-Hilfen, damit Fenster nie außerhalb des sichtbaren Bereichs landen (z. B. nach Abstecken eines Monitors).</summary>
public static class Screens
{
/// <summary>Umrechnung Pixel → WPF-Einheiten (System-DPI).</summary>
private static double Scale
{
get
{
using var g = System.Drawing.Graphics.FromHwnd(IntPtr.Zero);
return g.DpiX / 96.0;
}
}
/// <summary>Arbeitsbereiche (ohne Taskleiste) aller angeschlossenen Bildschirme in WPF-Einheiten.</summary>
public static List<Rect> WorkAreas()
{
var s = Scale;
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))
.ToList();
}
public static Rect PrimaryWorkArea => SystemParameters.WorkArea;
/// <summary>Ist genug vom Fenster (Titelleiste) auf irgendeinem Bildschirm sichtbar, um es greifen zu können?</summary>
public static bool IsReachable(Rect window)
{
var title = new Rect(window.X, window.Y, window.Width, Math.Min(40, window.Height));
return WorkAreas().Any(a =>
{
var i = Rect.Intersect(a, title);
return !i.IsEmpty && i.Width >= Math.Min(120, window.Width / 2) && i.Height >= 20;
});
}
}
using System.Windows;
namespace DeskCore;
/// <summary>Bildschirm-Hilfen, damit Fenster nie außerhalb des sichtbaren Bereichs landen (z. B. nach Abstecken eines Monitors).</summary>
public static class Screens
{
/// <summary>Umrechnung Pixel → WPF-Einheiten (System-DPI).</summary>
public static double Scale
{
get
{
using var g = System.Drawing.Graphics.FromHwnd(IntPtr.Zero);
return g.DpiX / 96.0;
}
}
/// <summary>Arbeitsbereiche (ohne Taskleiste) aller angeschlossenen Bildschirme in WPF-Einheiten.</summary>
public static List<Rect> WorkAreas()
{
var s = Scale;
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))
.ToList();
}
public static Rect PrimaryWorkArea => SystemParameters.WorkArea;
/// <summary>Ist genug vom Fenster (Titelleiste) auf irgendeinem Bildschirm sichtbar, um es greifen zu können?</summary>
public static bool IsReachable(Rect window)
{
var title = new Rect(window.X, window.Y, window.Width, Math.Min(40, window.Height));
return WorkAreas().Any(a =>
{
var i = Rect.Intersect(a, title);
return !i.IsEmpty && i.Width >= Math.Min(120, window.Width / 2) && i.Height >= 20;
});
}
}
Settings.cs
+303 -141
View File
@@ -1,141 +1,303 @@
using System.IO;
using System.Text.Json;
using System.Text.Json.Serialization;
namespace DeskCore;
public enum DesignMode { System, Light, Dark }
public enum ViewMode { Small, Medium, Large, List }
public class CategoryMeta
{
public string? Glyph { get; set; }
public string? Color { get; set; }
public bool Fence { get; set; }
public double? FenceX { get; set; }
public double? FenceY { get; set; }
public double FenceW { get; set; } = 340;
public double FenceH { get; set; } = 260;
public bool FenceCollapsed { get; set; }
}
public class SortRule
{
public string Contains { get; set; } = "";
public string Category { get; set; } = "";
}
/// <summary>Alle Einstellungen, gespeichert in %APPDATA%\DeskCore\settings.json.</summary>
public class AppSettings
{
public DesignMode Design { get; set; } = DesignMode.System;
public ViewMode View { get; set; } = ViewMode.Medium;
public bool TrayEnabled { get; set; } = true;
public bool CloseToTray { get; set; } = true;
public bool TrayHintShown { get; set; }
public bool HotkeyEnabled { get; set; } = true;
public int HotkeyModifiers { get; set; } = Hotkey.ModWin | Hotkey.ModShift;
public int HotkeyKey { get; set; } = 0x44; // D
public bool AutoSort { get; set; }
public bool AutoSortRemoveFromDesktop { get; set; }
public List<SortRule> Rules { get; set; } = [];
public bool FencesEnabled { get; set; } = true;
// 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 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 ??= [];
// Ü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;
}
public void RemoveCategory(string name)
{
Categories.Remove(name);
CategoryOrder.RemoveAll(n => string.Equals(n, name, StringComparison.OrdinalIgnoreCase));
Rules.RemoveAll(r => string.Equals(r.Category, name, StringComparison.OrdinalIgnoreCase));
}
}
using System.IO;
using System.Text.Json;
using System.Text.Json.Serialization;
namespace DeskCore;
public enum DesignMode { System, Light, Dark }
public enum ViewMode { Small, Medium, Large, List }
public class CategoryMeta
{
public string? Glyph { get; set; }
public string? Color { get; set; }
// Die folgenden Box-Felder stammen aus Version 1.0.x und werden nur noch beim Umstieg auf FenceDef gelesen
public bool Fence { get; set; }
public double? FenceX { get; set; }
public double? FenceY { get; set; }
public double FenceW { get; set; } = 340;
public double FenceH { get; set; } = 260;
public bool FenceCollapsed { get; set; }
}
/// <summary>Eine Start-Gruppe: ein Klick startet mehrere Programme nacheinander.</summary>
public class LaunchGroup
{
public string Name { get; set; } = "";
/// <summary>Pfade in Startreihenfolge (meist Verknüpfungen aus den Kategorien).</summary>
public List<string> Items { get; set; } = [];
/// <summary>Wartezeit zwischen zwei Programmen in Sekunden.</summary>
public double DelaySeconds { get; set; } = 1;
public string? Color { get; set; }
}
public class SortRule
{
/// <summary>"Name" = Name enthält …, "Typ" = Dateityp ist … (z. B. "Bilder" oder "pdf, docx")</summary>
public string Kind { get; set; } = "Name";
public string Contains { get; set; } = "";
public string Category { get; set; } = "";
[JsonIgnore] public string KindText => Kind == "Typ" ? "Dateityp ist" : "Name enthält";
}
/// <summary>Ein Tab einer Desktop-Box: eine Kategorie oder ein beliebiger Ordner ("Ordner-Portal").</summary>
public class FenceTab
{
public const string CategoryKind = "Kategorie", FolderKind = "Ordner";
public string Kind { get; set; } = CategoryKind;
/// <summary>Kategoriename bzw. Ordnerpfad.</summary>
public string Value { get; set; } = "";
[JsonIgnore] public bool IsFolder => Kind == FolderKind;
[JsonIgnore] public string Title => IsFolder ? Path.GetFileName(Value.TrimEnd('\\')) is { Length: > 0 } n ? n : Value : Value;
}
/// <summary>Eine Desktop-Box mit Position, Tabs und Aussehen.</summary>
public class FenceDef
{
public string Id { get; set; } = Guid.NewGuid().ToString("N");
public List<FenceTab> Tabs { get; set; } = [];
public int ActiveTab { get; set; }
public double? X { get; set; }
public double? Y { get; set; }
public double W { get; set; } = 340;
public double H { get; set; } = 260;
public bool Collapsed { get; set; }
/// <summary>Gesperrt: nicht verschieb- oder vergrößerbar.</summary>
public bool Locked { get; set; }
/// <summary>Hintergrundfarbe (#RRGGBB) oder null = passend zum Design.</summary>
public string? Background { get; set; }
/// <summary>Deckkraft des Hintergrunds 0.2–1.</summary>
public double Opacity { get; set; } = 0.92;
/// <summary>Milchglas-Effekt (Hintergrund verschwommen).</summary>
public bool Blur { get; set; }
public ViewMode IconSize { get; set; } = ViewMode.Medium;
/// <summary>"Name", "Typ" oder "Datum"</summary>
public string Sort { get; set; } = "Name";
/// <summary>Icon-Tönung (#RRGGBB) oder null.</summary>
public string? Tint { get; set; }
/// <summary>Desktop-Seite, auf der die Box liegt (0 = erste Seite).</summary>
public int Page { get; set; }
[JsonIgnore] public FenceTab? Active => Tabs.Count == 0 ? null : Tabs[Math.Clamp(ActiveTab, 0, Tabs.Count - 1)];
}
/// <summary>Gespeicherte Anordnung aller Desktop-Boxen.</summary>
public class FenceSnapshot
{
public string Name { get; set; } = "";
public DateTime Created { get; set; } = DateTime.Now;
public List<FenceDef> Fences { get; set; } = [];
[JsonIgnore] public string Info => $"{Fences.Count} {(Fences.Count == 1 ? "Box" : "Boxen")} · gespeichert am {Created:dd.MM.yyyy HH:mm}";
}
/// <summary>Alle Einstellungen, gespeichert in %APPDATA%\DeskCore\settings.json.</summary>
public class AppSettings
{
public DesignMode Design { get; set; } = DesignMode.System;
public ViewMode View { get; set; } = ViewMode.Medium;
public bool TrayEnabled { get; set; } = true;
public bool CloseToTray { get; set; } = true;
public bool TrayHintShown { get; set; }
public bool HotkeyEnabled { get; set; } = true;
public int HotkeyModifiers { get; set; } = Hotkey.ModWin | Hotkey.ModShift;
public int HotkeyKey { get; set; } = 0x44; // D
public bool AutoSort { get; set; }
public bool AutoSortRemoveFromDesktop { get; set; }
public List<SortRule> Rules { get; set; } = [];
public bool FencesEnabled { get; set; } = true;
public List<FenceDef> Fences { get; set; } = [];
public List<FenceSnapshot> Snapshots { get; set; } = [];
/// <summary>Box-Positionen je Bildschirm-Anordnung (Signatur → Box-Id → x, y, w, h).</summary>
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; }
/// <summary>Doppelklick auf eine freie Desktop-Stelle blendet Icons und Boxen aus/ein.</summary>
public bool QuickHide { get; set; } = true;
/// <summary>Peek: Tastenkürzel holt alle Boxen vor die Fenster.</summary>
public bool PeekEnabled { get; set; } = true;
public int PeekModifiers { get; set; } = Hotkey.ModWin | Hotkey.ModShift;
public int PeekKey { get; set; } = 0x42; // B wie "Boxen"
/// <summary>Desktop-Seiten: jede Seite hat ihre eigenen Boxen.</summary>
public List<string> Pages { get; set; } = ["Seite 1"];
public int CurrentPage { get; set; }
/// <summary>Mausrad über einer freien Desktop-Stelle wechselt die Seite.</summary>
public bool PageWheel { get; set; } = true;
/// <summary>Rechte Maustaste auf freier Desktop-Fläche ziehen → neue Box.</summary>
public bool DrawFences { get; set; } = true;
/// <summary>Tönung der echten Desktop-Icons (#RRGGBB) oder null = aus.</summary>
public string? DesktopTint { get; set; }
public double DesktopTintStrength { get; set; } = 0.55;
/// <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
+476 -392
View File
@@ -1,392 +1,476 @@
using System.Collections.Concurrent;
using System.IO;
namespace DeskCore;
public enum TransferStatus { Ok, Skipped, Error, Cancelled }
/// <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);
/// <summary>
/// Kategorien sind einfache Unterordner von %USERPROFILE%\DeskCore.
/// Icons vom Desktop werden dorthin kopiert – es bleiben normale Dateien.
/// </summary>
public static class Storage
{
public static readonly string Root = Migration.Pick(Environment.SpecialFolder.UserProfile);
public static readonly string UserDesktop = Environment.GetFolderPath(Environment.SpecialFolder.DesktopDirectory);
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>
public static readonly string Holding = Migration.Pick(Environment.SpecialFolder.LocalApplicationData, "Geloescht");
// ---------- Kategorien ----------
public static List<string> Categories()
{
Directory.CreateDirectory(Root);
var order = AppSettings.Current.CategoryOrder;
return Directory.GetDirectories(Root)
.Select(Path.GetFileName)
.OfType<string>()
.OrderBy(n => order.FindIndex(o => string.Equals(o, n, StringComparison.OrdinalIgnoreCase)) is var i and >= 0 ? i : int.MaxValue)
.ThenBy(n => n, StringComparer.CurrentCultureIgnoreCase)
.ToList();
}
public static string CategoryPath(string name) => Path.Combine(Root, name);
public static IEnumerable<string> Entries(string dir)
{
if (!Directory.Exists(dir)) return [];
try
{
return Directory.EnumerateFileSystemEntries(dir)
.Where(p =>
{
var n = Path.GetFileName(p);
if (n.Equals("desktop.ini", StringComparison.OrdinalIgnoreCase)) return false;
try
{
var attr = File.GetAttributes(p);
return !attr.HasFlag(FileAttributes.Hidden) && !attr.HasFlag(FileAttributes.System);
}
catch { return false; }
})
.ToList();
}
catch { return []; }
}
public static IEnumerable<string> DesktopEntries() =>
Entries(UserDesktop).Concat(Entries(PublicDesktop));
public static bool IsDesktopDir(string dir) =>
SamePath(dir, UserDesktop) || SamePath(dir, PublicDesktop);
public static bool IsInStorage(string path) =>
path.StartsWith(Root.TrimEnd('\\') + "\\", StringComparison.OrdinalIgnoreCase);
public static string? ValidateName(string name)
{
name = name.Trim();
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 is "." or ".." || name.EndsWith('.')) return "Ungültiger Name.";
return null;
}
// ---------- Duplikate ----------
private static readonly ConcurrentDictionary<string, (DateTime Stamp, string? Target)> _lnkCache = new(StringComparer.OrdinalIgnoreCase);
/// <summary>Ziel einer Verknüpfung (.lnk/.url), sonst null.</summary>
public static string? ShortcutTarget(string path)
{
var ext = Path.GetExtension(path).ToLowerInvariant();
if (ext is not (".lnk" or ".url")) return null;
DateTime stamp;
try { stamp = File.GetLastWriteTimeUtc(path); } catch { return null; }
if (_lnkCache.TryGetValue(path, out var c) && c.Stamp == stamp) return c.Target;
string? target = null;
try
{
if (ext == ".url")
{
target = File.ReadLines(path).FirstOrDefault(l => l.StartsWith("URL=", StringComparison.OrdinalIgnoreCase))?[4..];
}
else
{
dynamic shell = Activator.CreateInstance(Type.GetTypeFromProgID("WScript.Shell")!)!;
dynamic lnk = shell.CreateShortcut(path);
string t = lnk.TargetPath;
string a = lnk.Arguments;
target = string.IsNullOrEmpty(t) ? null : (t + " " + a).Trim();
}
}
catch { }
if (string.IsNullOrWhiteSpace(target)) target = null;
_lnkCache[path] = (stamp, target);
return target;
}
/// <summary>Gleicher Dateiname oder Verknüpfung mit gleichem Ziel?</summary>
public static bool SameItem(string a, string b)
{
if (string.Equals(Path.GetFileName(a), Path.GetFileName(b), StringComparison.OrdinalIgnoreCase)) return true;
var ta = ShortcutTarget(a);
return ta is not null && string.Equals(ta, ShortcutTarget(b), StringComparison.OrdinalIgnoreCase);
}
/// <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));
/// <summary>In welcher Kategorie liegt das Element bereits? (für das ✓ auf dem Desktop)</summary>
public static string? FindCategoryOf(string item, IReadOnlyDictionary<string, List<string>> categoryEntries)
{
foreach (var (cat, entries) in categoryEntries)
if (entries.Any(e => SameItem(e, item))) return cat;
return null;
}
// ---------- Übertragen ----------
/// <summary>
/// Übernimmt Datei/Ordner nach targetDir. Kommt die Quelle von außerhalb der App (z. B. vom Desktop),
/// 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.
/// </summary>
public static TransferResult Transfer(string source, string targetDir, bool forceMove = false,
Action<long>? onBytes = null, CancellationToken ct = default)
{
if (ct.IsCancellationRequested) return new(TransferStatus.Cancelled, source);
var name = Path.GetFileName(source.TrimEnd('\\'));
try
{
if (SamePath(Path.GetDirectoryName(source), targetDir))
return new(TransferStatus.Skipped, source, Message: $"„{name}“ ist schon dort.");
if (Directory.Exists(source) &&
(targetDir.TrimEnd('\\') + "\\").StartsWith(source.TrimEnd('\\') + "\\", StringComparison.OrdinalIgnoreCase))
return new(TransferStatus.Error, source, Message: $"„{name}“ kann nicht in sich selbst verschoben werden.");
bool copy = !forceMove && !IsInStorage(source) && IsInStorage(targetDir);
if (FindEquivalent(targetDir, source) is { } existing)
{
var where = IsDesktopDir(targetDir) ? "auf dem Desktop" : $"in „{Path.GetFileName(targetDir)}“";
return new(TransferStatus.Skipped, source, existing, Message: $"„{DisplayName(source)}“ ist schon {where}.");
}
Directory.CreateDirectory(targetDir);
var dest = UniquePath(targetDir, name);
try
{
if (copy) CopyAny(source, dest, onBytes, ct);
else MoveAny(source, dest, onBytes, ct);
}
catch (OperationCanceledException)
{
// halb kopiertes Ziel wieder entfernen – die Quelle ist unverändert
// (beim Verschieben zwischen Laufwerken wird die Quelle erst nach vollständiger Kopie gelöscht)
DeletePartial(dest);
return new(TransferStatus.Cancelled, source);
}
return new(TransferStatus.Ok, source, dest, copy);
}
catch (UnauthorizedAccessException)
{
return new(TransferStatus.Error, source, Message: $"„{name}“: Keine Berechtigung. " +
"(Icons auf dem öffentlichen Desktop brauchen Administratorrechte – App ggf. als Administrator starten.)");
}
catch (Exception ex)
{
return new(TransferStatus.Error, source, Message: $"„{name}“: {ex.Message}");
}
}
/// <summary>Verschiebt Datei oder Ordner – auch zwischen Laufwerken.</summary>
public static void MoveAny(string source, string dest, Action<long>? onBytes = null, CancellationToken ct = default)
{
NoteCreated(dest);
if (File.Exists(source))
{
File.Move(source, dest);
return;
}
if (string.Equals(Path.GetPathRoot(source), Path.GetPathRoot(dest), StringComparison.OrdinalIgnoreCase))
{
Directory.Move(source, dest);
return;
}
CopyDirectory(source, dest, onBytes, ct);
Directory.Delete(source, recursive: true);
}
public static void CopyAny(string source, string dest, Action<long>? onBytes = null, CancellationToken ct = default)
{
NoteCreated(dest);
if (Directory.Exists(source)) CopyDirectory(source, dest, onBytes, ct);
else CopyFile(source, dest, onBytes, ct);
}
/// <summary>Benennt ein Element um. Gibt den neuen Pfad zurück.</summary>
public static string Rename(string path, string newName)
{
var dir = Path.GetDirectoryName(path)!;
var dest = Path.Combine(dir, newName);
if (string.Equals(path, dest, StringComparison.Ordinal)) return path;
if (string.Equals(path, dest, StringComparison.OrdinalIgnoreCase))
{ // nur Groß-/Kleinschreibung geändert
var tmp = path + ".umbenennen";
MoveAny(path, tmp);
MoveAny(tmp, dest);
return dest;
}
if (File.Exists(dest) || Directory.Exists(dest)) throw new IOException($"„{newName}“ gibt es dort schon.");
MoveAny(path, dest);
return dest;
}
/// <summary>
/// "Löscht" ein Element: es wandert erst in einen internen Ordner, damit Strg+Z funktioniert.
/// Erst wenn es nicht mehr rückgängig gemacht werden kann, geht es in den Papierkorb.
/// </summary>
public static string Delete(string path)
{
var dir = Path.Combine(Holding, Guid.NewGuid().ToString("N"));
Directory.CreateDirectory(dir);
var dest = Path.Combine(dir, Path.GetFileName(path.TrimEnd('\\')));
MoveAny(path, dest);
return dest;
}
/// <summary>Endgültig in den Windows-Papierkorb.</summary>
public static void Recycle(string path)
{
try
{
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))
Microsoft.VisualBasic.FileIO.FileSystem.DeleteFile(path,
Microsoft.VisualBasic.FileIO.UIOption.OnlyErrorDialogs, Microsoft.VisualBasic.FileIO.RecycleOption.SendToRecycleBin);
// leeren Hilfsordner aufräumen
var parent = Path.GetDirectoryName(path);
if (parent is not null && IsUnder(parent, Holding) && Directory.Exists(parent) && !Directory.EnumerateFileSystemEntries(parent).Any())
Directory.Delete(parent);
}
catch { }
}
/// <summary>Reste von einem Absturz in den Papierkorb legen.</summary>
public static void FlushHolding()
{
if (!Directory.Exists(Holding)) return;
foreach (var d in Directory.GetDirectories(Holding))
foreach (var e in Directory.EnumerateFileSystemEntries(d).ToList())
Recycle(e);
}
// ---------- Selbst angelegte Desktop-Elemente merken (damit die Auto-Sortierung sie ignoriert) ----------
private static readonly ConcurrentDictionary<string, DateTime> _created = new(StringComparer.OrdinalIgnoreCase);
private static void NoteCreated(string path) => _created[path] = DateTime.UtcNow;
public static bool CreatedByApp(string path) =>
_created.TryGetValue(path, out var t) && DateTime.UtcNow - t < TimeSpan.FromSeconds(15);
/// <summary>Größe eines Ordners in Bytes (bricht ab, sobald limit überschritten ist).</summary>
public static long DirectorySize(string dir, long limit = long.MaxValue)
{
long sum = 0;
try
{
foreach (var f in Directory.EnumerateFiles(dir, "*", SearchOption.AllDirectories))
{
try { sum += new FileInfo(f).Length; } catch { }
if (sum > limit) break;
}
}
catch { }
return sum;
}
// ---------- Helfer ----------
public static string DisplayName(string path)
{
var n = Path.GetFileName(path.TrimEnd('\\'));
var ext = Path.GetExtension(n).ToLowerInvariant();
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; }
}
}
using System.Collections.Concurrent;
using System.IO;
namespace DeskCore;
public enum TransferStatus { Ok, Skipped, Error, Cancelled }
/// <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);
/// <summary>
/// Kategorien sind einfache Unterordner von %USERPROFILE%\DeskCore.
/// Icons vom Desktop werden dorthin kopiert – es bleiben normale Dateien.
/// </summary>
public static class Storage
{
public static readonly string Root = Migration.Pick(Environment.SpecialFolder.UserProfile);
public static readonly string UserDesktop = Environment.GetFolderPath(Environment.SpecialFolder.DesktopDirectory);
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>
public static readonly string Holding = Migration.Pick(Environment.SpecialFolder.LocalApplicationData, "Geloescht");
// ---------- Kategorien ----------
public static List<string> Categories()
{
Directory.CreateDirectory(Root);
var order = AppSettings.Current.CategoryOrder;
return Directory.GetDirectories(Root)
.Select(Path.GetFileName)
.OfType<string>()
.OrderBy(n => order.FindIndex(o => string.Equals(o, n, StringComparison.OrdinalIgnoreCase)) is var i and >= 0 ? i : int.MaxValue)
.ThenBy(n => n, StringComparer.CurrentCultureIgnoreCase)
.ToList();
}
public static string CategoryPath(string name) => Path.Combine(Root, name);
public static IEnumerable<string> Entries(string dir)
{
if (!Directory.Exists(dir)) return [];
try
{
return Directory.EnumerateFileSystemEntries(dir)
.Where(p =>
{
var n = Path.GetFileName(p);
if (n.Equals("desktop.ini", StringComparison.OrdinalIgnoreCase)) return false;
try
{
var attr = File.GetAttributes(p);
return !attr.HasFlag(FileAttributes.Hidden) && !attr.HasFlag(FileAttributes.System);
}
catch { return false; }
})
.ToList();
}
catch { return []; }
}
public static IEnumerable<string> DesktopEntries() =>
Entries(UserDesktop).Concat(Entries(PublicDesktop));
public static bool IsDesktopDir(string dir) =>
SamePath(dir, UserDesktop) || SamePath(dir, PublicDesktop);
public static bool IsInStorage(string path) =>
path.StartsWith(Root.TrimEnd('\\') + "\\", StringComparison.OrdinalIgnoreCase);
public static string? ValidateName(string name)
{
name = name.Trim();
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 is "." or ".." || name.EndsWith('.')) return "Ungültiger Name.";
return null;
}
// ---------- Duplikate ----------
private static readonly ConcurrentDictionary<string, (DateTime Stamp, string? Target)> _lnkCache = new(StringComparer.OrdinalIgnoreCase);
/// <summary>Ziel einer Verknüpfung (.lnk/.url), sonst null.</summary>
public static string? ShortcutTarget(string path)
{
var ext = Path.GetExtension(path).ToLowerInvariant();
if (ext is not (".lnk" or ".url")) return null;
DateTime stamp;
try { stamp = File.GetLastWriteTimeUtc(path); } catch { return null; }
if (_lnkCache.TryGetValue(path, out var c) && c.Stamp == stamp) return c.Target;
string? target = null;
try
{
if (ext == ".url")
{
target = File.ReadLines(path).FirstOrDefault(l => l.StartsWith("URL=", StringComparison.OrdinalIgnoreCase))?[4..];
}
else
{
dynamic shell = Activator.CreateInstance(Type.GetTypeFromProgID("WScript.Shell")!)!;
dynamic lnk = shell.CreateShortcut(path);
string t = lnk.TargetPath;
string a = lnk.Arguments;
target = string.IsNullOrEmpty(t) ? null : (t + " " + a).Trim();
}
}
catch { }
if (string.IsNullOrWhiteSpace(target)) target = null;
_lnkCache[path] = (stamp, target);
return target;
}
// ---------- Verknüpfungen zu deinstallierten Programmen ----------
private static readonly ConcurrentDictionary<string, (DateTime Stamp, string? Target)> _targetPathCache = new(StringComparer.OrdinalIgnoreCase);
/// <summary>Reiner Zielpfad einer .lnk-Verknüpfung (ohne Argumente), sonst null.</summary>
public static string? LinkTargetPath(string path)
{
if (!string.Equals(Path.GetExtension(path), ".lnk", StringComparison.OrdinalIgnoreCase)) return null;
DateTime stamp;
try { stamp = File.GetLastWriteTimeUtc(path); } catch { return null; }
if (_targetPathCache.TryGetValue(path, out var c) && c.Stamp == stamp) return c.Target;
string? target = null;
try
{
// Direkt über IShellLink lesen (Rohpfad). WScript.Shell "repariert" Ziele, die es nicht findet,
// z. B. \\server\… zu C:\server\… – darauf darf eine Lösch-Entscheidung nicht beruhen.
var link = (IShellLinkW)new ShellLinkCoClass();
try
{
((System.Runtime.InteropServices.ComTypes.IPersistFile)link).Load(path, 0); // STGM_READ
var sb = new System.Text.StringBuilder(32768);
link.GetPath(sb, sb.Capacity, IntPtr.Zero, 0x4); // SLGP_RAWPATH
var raw = sb.ToString().Trim();
target = raw.Length == 0 ? null : Environment.ExpandEnvironmentVariables(raw);
}
finally { System.Runtime.InteropServices.Marshal.ReleaseComObject(link); }
}
catch { }
_targetPathCache[path] = (stamp, target);
return target;
}
[System.Runtime.InteropServices.ComImport, System.Runtime.InteropServices.Guid("00021401-0000-0000-C000-000000000046")]
private class ShellLinkCoClass { }
[System.Runtime.InteropServices.ComImport, System.Runtime.InteropServices.Guid("000214F9-0000-0000-C000-000000000046"),
System.Runtime.InteropServices.InterfaceType(System.Runtime.InteropServices.ComInterfaceType.InterfaceIsIUnknown)]
private interface IShellLinkW
{
void GetPath([System.Runtime.InteropServices.MarshalAs(System.Runtime.InteropServices.UnmanagedType.LPWStr)] System.Text.StringBuilder pszFile,
int cch, IntPtr pfd, uint fFlags);
// weitere Methoden werden nicht gebraucht (Reihenfolge der vtable ab hier egal)
}
/// <summary>
/// Zeigt die Verknüpfung auf ein Programm, das es nicht mehr gibt (z. B. deinstalliert)?
/// Bewusst vorsichtig – im Zweifel "nein":
/// .lnk nur mit festem Ziel auf einer eingebauten, erreichbaren Festplatte; .url nur bei Steam/Epic, wenn deren
/// Installationsliste das Spiel nicht mehr kennt. Netzwerk-/USB-Laufwerke, Web-Links, Store-Apps und
/// Windows-Installer-Verknüpfungen werden nie als tot gewertet.
/// </summary>
public static bool IsDeadShortcut(string path)
{
// Steam-/Epic-Links: deren eigene Installationslisten fragen
if (string.Equals(Path.GetExtension(path), ".url", StringComparison.OrdinalIgnoreCase))
{
var url = ShortcutTarget(path);
return url is not null && GameLibraries.IsInstalled(url) == false;
}
var target = LinkTargetPath(path);
if (target is null) return false;
try
{
if (!Path.IsPathFullyQualified(target) || target.StartsWith(@"\\")) return false; // relativ oder Netzwerk
var drive = new DriveInfo(Path.GetPathRoot(target)!);
if (!drive.IsReady || drive.DriveType != DriveType.Fixed) return false; // abgesteckt/USB/Netz
var installer = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.Windows), "Installer");
if (IsUnder(target, installer)) return false; // MSI-"Werbe"-Verknüpfung
return !File.Exists(target) && !Directory.Exists(target);
}
catch { return false; }
}
/// <summary>Alle toten Verknüpfungen in den Kategorien (ohne die, die der Nutzer behalten will).</summary>
public static List<string> FindDeadShortcuts(ICollection<string> keep) =>
Categories()
.SelectMany(c => Entries(CategoryPath(c)))
.Where(p => !keep.Contains(p, StringComparer.OrdinalIgnoreCase) && IsDeadShortcut(p))
.ToList();
/// <summary>Gleicher Dateiname oder Verknüpfung mit gleichem Ziel?</summary>
public static bool SameItem(string a, string b)
{
if (string.Equals(Path.GetFileName(a), Path.GetFileName(b), StringComparison.OrdinalIgnoreCase)) return true;
var ta = ShortcutTarget(a);
return ta is not null && string.Equals(ta, ShortcutTarget(b), StringComparison.OrdinalIgnoreCase);
}
/// <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));
/// <summary>In welcher Kategorie liegt das Element bereits? (für das ✓ auf dem Desktop)</summary>
public static string? FindCategoryOf(string item, IReadOnlyDictionary<string, List<string>> categoryEntries)
{
foreach (var (cat, entries) in categoryEntries)
if (entries.Any(e => SameItem(e, item))) return cat;
return null;
}
// ---------- Übertragen ----------
/// <summary>
/// Übernimmt Datei/Ordner nach targetDir. Kommt die Quelle von außerhalb der App (z. B. vom Desktop),
/// 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.
/// </summary>
public static TransferResult Transfer(string source, string targetDir, bool forceMove = false,
Action<long>? onBytes = null, CancellationToken ct = default)
{
if (ct.IsCancellationRequested) return new(TransferStatus.Cancelled, source);
var name = Path.GetFileName(source.TrimEnd('\\'));
try
{
if (SamePath(Path.GetDirectoryName(source), targetDir))
return new(TransferStatus.Skipped, source, Message: $"„{name}“ ist schon dort.");
if (Directory.Exists(source) &&
(targetDir.TrimEnd('\\') + "\\").StartsWith(source.TrimEnd('\\') + "\\", StringComparison.OrdinalIgnoreCase))
return new(TransferStatus.Error, source, Message: $"„{name}“ kann nicht in sich selbst verschoben werden.");
bool copy = !forceMove && !IsInStorage(source) && IsInStorage(targetDir);
if (FindEquivalent(targetDir, source) is { } existing)
{
var where = IsDesktopDir(targetDir) ? "auf dem Desktop" : $"in „{Path.GetFileName(targetDir)}“";
return new(TransferStatus.Skipped, source, existing, Message: $"„{DisplayName(source)}“ ist schon {where}.");
}
Directory.CreateDirectory(targetDir);
var dest = UniquePath(targetDir, name);
try
{
if (copy) CopyAny(source, dest, onBytes, ct);
else MoveAny(source, dest, onBytes, ct);
}
catch (OperationCanceledException)
{
// halb kopiertes Ziel wieder entfernen – die Quelle ist unverändert
// (beim Verschieben zwischen Laufwerken wird die Quelle erst nach vollständiger Kopie gelöscht)
DeletePartial(dest);
return new(TransferStatus.Cancelled, source);
}
return new(TransferStatus.Ok, source, dest, copy);
}
catch (UnauthorizedAccessException)
{
return new(TransferStatus.Error, source, Message: $"„{name}“: Keine Berechtigung. " +
"(Icons auf dem öffentlichen Desktop brauchen Administratorrechte – App ggf. als Administrator starten.)");
}
catch (Exception ex)
{
return new(TransferStatus.Error, source, Message: $"„{name}“: {ex.Message}");
}
}
/// <summary>Verschiebt Datei oder Ordner – auch zwischen Laufwerken.</summary>
public static void MoveAny(string source, string dest, Action<long>? onBytes = null, CancellationToken ct = default)
{
NoteCreated(dest);
if (File.Exists(source))
{
File.Move(source, dest);
return;
}
if (string.Equals(Path.GetPathRoot(source), Path.GetPathRoot(dest), StringComparison.OrdinalIgnoreCase))
{
Directory.Move(source, dest);
return;
}
CopyDirectory(source, dest, onBytes, ct);
Directory.Delete(source, recursive: true);
}
public static void CopyAny(string source, string dest, Action<long>? onBytes = null, CancellationToken ct = default)
{
NoteCreated(dest);
if (Directory.Exists(source)) CopyDirectory(source, dest, onBytes, ct);
else CopyFile(source, dest, onBytes, ct);
}
/// <summary>Benennt ein Element um. Gibt den neuen Pfad zurück.</summary>
public static string Rename(string path, string newName)
{
var dir = Path.GetDirectoryName(path)!;
var dest = Path.Combine(dir, newName);
if (string.Equals(path, dest, StringComparison.Ordinal)) return path;
if (string.Equals(path, dest, StringComparison.OrdinalIgnoreCase))
{ // nur Groß-/Kleinschreibung geändert
var tmp = path + ".umbenennen";
MoveAny(path, tmp);
MoveAny(tmp, dest);
return dest;
}
if (File.Exists(dest) || Directory.Exists(dest)) throw new IOException($"„{newName}“ gibt es dort schon.");
MoveAny(path, dest);
return dest;
}
/// <summary>
/// "Löscht" ein Element: es wandert erst in einen internen Ordner, damit Strg+Z funktioniert.
/// Erst wenn es nicht mehr rückgängig gemacht werden kann, geht es in den Papierkorb.
/// </summary>
public static string Delete(string path)
{
var dir = Path.Combine(Holding, Guid.NewGuid().ToString("N"));
Directory.CreateDirectory(dir);
var dest = Path.Combine(dir, Path.GetFileName(path.TrimEnd('\\')));
MoveAny(path, dest);
return dest;
}
/// <summary>Endgültig in den Windows-Papierkorb.</summary>
public static void Recycle(string path)
{
try
{
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))
Microsoft.VisualBasic.FileIO.FileSystem.DeleteFile(path,
Microsoft.VisualBasic.FileIO.UIOption.OnlyErrorDialogs, Microsoft.VisualBasic.FileIO.RecycleOption.SendToRecycleBin);
// leeren Hilfsordner aufräumen
var parent = Path.GetDirectoryName(path);
if (parent is not null && IsUnder(parent, Holding) && Directory.Exists(parent) && !Directory.EnumerateFileSystemEntries(parent).Any())
Directory.Delete(parent);
}
catch { }
}
/// <summary>Reste von einem Absturz in den Papierkorb legen.</summary>
public static void FlushHolding()
{
if (!Directory.Exists(Holding)) return;
foreach (var d in Directory.GetDirectories(Holding))
foreach (var e in Directory.EnumerateFileSystemEntries(d).ToList())
Recycle(e);
}
// ---------- Selbst angelegte Desktop-Elemente merken (damit die Auto-Sortierung sie ignoriert) ----------
private static readonly ConcurrentDictionary<string, DateTime> _created = new(StringComparer.OrdinalIgnoreCase);
private static void NoteCreated(string path) => _created[path] = DateTime.UtcNow;
/// <summary>Von der App selbst angelegte Datei merken (z. B. Desktop-Verknüpfung einer Start-Gruppe).</summary>
public static void MarkCreated(string path) => NoteCreated(path);
public static bool CreatedByApp(string path) =>
_created.TryGetValue(path, out var t) && DateTime.UtcNow - t < TimeSpan.FromSeconds(15);
/// <summary>Größe eines Ordners in Bytes (bricht ab, sobald limit überschritten ist).</summary>
public static long DirectorySize(string dir, long limit = long.MaxValue)
{
long sum = 0;
try
{
foreach (var f in Directory.EnumerateFiles(dir, "*", SearchOption.AllDirectories))
{
try { sum += new FileInfo(f).Length; } catch { }
if (sum > limit) break;
}
}
catch { }
return sum;
}
// ---------- Helfer ----------
public static string DisplayName(string path)
{
var n = Path.GetFileName(path.TrimEnd('\\'));
var ext = Path.GetExtension(n).ToLowerInvariant();
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
+74 -74
View File
@@ -1,74 +1,74 @@
using System.Windows;
using System.Windows.Media;
using Microsoft.Win32;
namespace DeskCore;
/// <summary>Übernimmt Hell/Dunkel-Modus und Akzentfarbe von Windows – auch live, wenn man sie ändert.</summary>
public static class Theme
{
public static bool IsLight { get; private set; } = true;
/// <summary>Vom Benutzer gewählter Modus; "System" folgt der Windows-Einstellung.</summary>
public static DesignMode Mode => AppSettings.Current.Design;
public static void Init()
{
Apply();
SystemEvents.UserPreferenceChanged += (_, e) =>
{
if (e.Category is UserPreferenceCategory.General or UserPreferenceCategory.Color or UserPreferenceCategory.VisualStyle)
Application.Current.Dispatcher.BeginInvoke(Apply);
};
}
public static void Apply()
{
IsLight = Mode switch
{
DesignMode.Light => true,
DesignMode.Dark => false,
_ => ReadDword(@"Software\Microsoft\Windows\CurrentVersion\Themes\Personalize", "AppsUseLightTheme") != 0,
};
var res = Application.Current.Resources;
res.MergedDictionaries[0] = new ResourceDictionary
{
Source = new Uri($"pack://application:,,,/Themes/Colors.{(IsLight ? "Light" : "Dark")}.xaml")
};
// DWM speichert die Akzentfarbe als ABGR
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));
// 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);
res["AccentBrush"] = Brush(a);
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["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));
Changed?.Invoke();
}
public static event Action? Changed;
private static int ReadDword(string key, string name)
{
try
{
using var k = Registry.CurrentUser.OpenSubKey(key);
return k?.GetValue(name) is int i ? i : -1;
}
catch { return -1; }
}
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));
private static SolidColorBrush Brush(Color c)
{
var b = new SolidColorBrush(c);
b.Freeze();
return b;
}
}
using System.Windows;
using System.Windows.Media;
using Microsoft.Win32;
namespace DeskCore;
/// <summary>Übernimmt Hell/Dunkel-Modus und Akzentfarbe von Windows – auch live, wenn man sie ändert.</summary>
public static class Theme
{
public static bool IsLight { get; private set; } = true;
/// <summary>Vom Benutzer gewählter Modus; "System" folgt der Windows-Einstellung.</summary>
public static DesignMode Mode => AppSettings.Current.Design;
public static void Init()
{
Apply();
SystemEvents.UserPreferenceChanged += (_, e) =>
{
if (e.Category is UserPreferenceCategory.General or UserPreferenceCategory.Color or UserPreferenceCategory.VisualStyle)
Application.Current.Dispatcher.BeginInvoke(Apply);
};
}
public static void Apply()
{
IsLight = Mode switch
{
DesignMode.Light => true,
DesignMode.Dark => false,
_ => ReadDword(@"Software\Microsoft\Windows\CurrentVersion\Themes\Personalize", "AppsUseLightTheme") != 0,
};
var res = Application.Current.Resources;
res.MergedDictionaries[0] = new ResourceDictionary
{
Source = new Uri($"pack://application:,,,/Themes/Colors.{(IsLight ? "Light" : "Dark")}.xaml")
};
// DWM speichert die Akzentfarbe als ABGR
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));
// 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);
res["AccentBrush"] = Brush(a);
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["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));
Changed?.Invoke();
}
public static event Action? Changed;
private static int ReadDword(string key, string name)
{
try
{
using var k = Registry.CurrentUser.OpenSubKey(key);
return k?.GetValue(name) is int i ? i : -1;
}
catch { return -1; }
}
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));
private static SolidColorBrush Brush(Color c)
{
var b = new SolidColorBrush(c);
b.Freeze();
return b;
}
}
Watcher.cs
+140 -111
View File
@@ -1,111 +1,140 @@
using System.IO;
using System.Windows.Threading;
namespace DeskCore;
/// <summary>
/// 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.
/// </summary>
public sealed class Watcher : IDisposable
{
private readonly List<FileSystemWatcher> _watchers = [];
private readonly DispatcherTimer _changedTimer;
private readonly DispatcherTimer _newTimer;
private readonly HashSet<string> _newOnDesktop = new(StringComparer.OrdinalIgnoreCase);
private readonly object _lock = new();
/// <summary>Irgendetwas hat sich geändert (UI-Thread).</summary>
public event Action? Changed;
/// <summary>Neue Elemente auf dem Desktop (UI-Thread, nach kurzer Wartezeit).</summary>
public event Action<List<string>>? NewOnDesktop;
public Watcher(Dispatcher dispatcher)
{
_changedTimer = new DispatcherTimer(TimeSpan.FromMilliseconds(350), DispatcherPriority.Background, (_, _) =>
{
_changedTimer!.Stop();
Changed?.Invoke();
}, dispatcher);
_changedTimer.Stop();
// Etwas länger warten: Installer legen Verknüpfungen oft in mehreren Schritten an
_newTimer = new DispatcherTimer(TimeSpan.FromSeconds(2), DispatcherPriority.Background, (_, _) =>
{
_newTimer!.Stop();
List<string> items;
lock (_lock) { items = _newOnDesktop.ToList(); _newOnDesktop.Clear(); }
items = items.Where(p => (File.Exists(p) || Directory.Exists(p)) && !Storage.CreatedByApp(p)).ToList();
if (items.Count > 0) NewOnDesktop?.Invoke(items);
}, dispatcher);
_newTimer.Stop();
Directory.CreateDirectory(Storage.Root);
Add(Storage.UserDesktop, false, true);
Add(Storage.PublicDesktop, false, true);
Add(Storage.Root, true, false);
}
private void Add(string dir, bool subdirs, bool isDesktop)
{
if (!Directory.Exists(dir)) return;
try
{
var w = new FileSystemWatcher(dir)
{
IncludeSubdirectories = subdirs,
NotifyFilter = NotifyFilters.FileName | NotifyFilters.DirectoryName | NotifyFilters.LastWrite,
InternalBufferSize = 64 * 1024,
};
FileSystemEventHandler onChange = (_, e) =>
{
Poke();
if (isDesktop && e.ChangeType == WatcherChangeTypes.Created) NoteNew(e.FullPath);
};
w.Created += onChange;
w.Deleted += onChange;
w.Changed += onChange;
w.Renamed += (_, e) => { Poke(); if (isDesktop) NoteNew(e.FullPath); };
w.Error += (_, _) => Poke();
w.EnableRaisingEvents = true;
_watchers.Add(w);
}
catch { }
}
private void NoteNew(string path)
{
var name = Path.GetFileName(path);
if (name.StartsWith('~') || name.EndsWith(".tmp", StringComparison.OrdinalIgnoreCase) ||
name.Equals("desktop.ini", StringComparison.OrdinalIgnoreCase)) return;
lock (_lock) _newOnDesktop.Add(path);
_newTimer.Dispatcher.BeginInvoke(() => { _newTimer.Stop(); _newTimer.Start(); });
}
private void Poke() => _changedTimer.Dispatcher.BeginInvoke(() => { _changedTimer.Stop(); _changedTimer.Start(); });
public void Dispose()
{
foreach (var w in _watchers) w.Dispose();
_changedTimer.Stop();
_newTimer.Stop();
}
}
public static class AutoSorter
{
/// <summary>Erste passende Regel → Kategoriename (nur existierende Kategorien).</summary>
public static string? Match(string path)
{
var name = Storage.DisplayName(path);
var cats = Storage.Categories();
foreach (var r in AppSettings.Current.Rules)
{
if (string.IsNullOrWhiteSpace(r.Contains)) continue;
if (!name.Contains(r.Contains.Trim(), StringComparison.CurrentCultureIgnoreCase)) continue;
var cat = cats.FirstOrDefault(c => string.Equals(c, r.Category, StringComparison.OrdinalIgnoreCase));
if (cat is not null) return cat;
}
return null;
}
}
using System.IO;
using System.Windows.Threading;
namespace DeskCore;
/// <summary>
/// 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.
/// </summary>
public sealed class Watcher : IDisposable
{
private readonly List<FileSystemWatcher> _watchers = [];
private readonly DispatcherTimer _changedTimer;
private readonly DispatcherTimer _newTimer;
private readonly HashSet<string> _newOnDesktop = new(StringComparer.OrdinalIgnoreCase);
private readonly object _lock = new();
/// <summary>Irgendetwas hat sich geändert (UI-Thread).</summary>
public event Action? Changed;
/// <summary>Neue Elemente auf dem Desktop (UI-Thread, nach kurzer Wartezeit).</summary>
public event Action<List<string>>? NewOnDesktop;
public Watcher(Dispatcher dispatcher)
{
_changedTimer = new DispatcherTimer(TimeSpan.FromMilliseconds(350), DispatcherPriority.Background, (_, _) =>
{
_changedTimer!.Stop();
Changed?.Invoke();
}, dispatcher);
_changedTimer.Stop();
// Etwas länger warten: Installer legen Verknüpfungen oft in mehreren Schritten an
_newTimer = new DispatcherTimer(TimeSpan.FromSeconds(2), DispatcherPriority.Background, (_, _) =>
{
_newTimer!.Stop();
List<string> items;
lock (_lock) { items = _newOnDesktop.ToList(); _newOnDesktop.Clear(); }
items = items.Where(p => (File.Exists(p) || Directory.Exists(p)) && !Storage.CreatedByApp(p)).ToList();
if (items.Count > 0) NewOnDesktop?.Invoke(items);
}, dispatcher);
_newTimer.Stop();
Directory.CreateDirectory(Storage.Root);
Add(Storage.UserDesktop, false, true);
Add(Storage.PublicDesktop, false, true);
Add(Storage.Root, true, false);
}
private void Add(string dir, bool subdirs, bool isDesktop)
{
if (!Directory.Exists(dir)) return;
try
{
var w = new FileSystemWatcher(dir)
{
IncludeSubdirectories = subdirs,
NotifyFilter = NotifyFilters.FileName | NotifyFilters.DirectoryName | NotifyFilters.LastWrite,
InternalBufferSize = 64 * 1024,
};
FileSystemEventHandler onChange = (_, e) =>
{
Poke();
if (isDesktop && e.ChangeType == WatcherChangeTypes.Created) NoteNew(e.FullPath);
};
w.Created += onChange;
w.Deleted += onChange;
w.Changed += onChange;
w.Renamed += (_, e) => { Poke(); if (isDesktop) NoteNew(e.FullPath); };
w.Error += (_, _) => Poke();
w.EnableRaisingEvents = true;
_watchers.Add(w);
}
catch { }
}
private void NoteNew(string path)
{
var name = Path.GetFileName(path);
if (name.StartsWith('~') || name.EndsWith(".tmp", StringComparison.OrdinalIgnoreCase) ||
name.Equals("desktop.ini", StringComparison.OrdinalIgnoreCase)) return;
lock (_lock) _newOnDesktop.Add(path);
_newTimer.Dispatcher.BeginInvoke(() => { _newTimer.Stop(); _newTimer.Start(); });
}
private void Poke() => _changedTimer.Dispatcher.BeginInvoke(() => { _changedTimer.Stop(); _changedTimer.Start(); });
public void Dispose()
{
foreach (var w in _watchers) w.Dispose();
_changedTimer.Stop();
_newTimer.Stop();
}
}
public static class AutoSorter
{
/// <summary>Dateityp-Gruppen für Regeln vom Typ "Dateityp ist".</summary>
private static readonly Dictionary<string, string[]> Groups = new(StringComparer.CurrentCultureIgnoreCase)
{
["Bilder"] = ["jpg", "jpeg", "png", "gif", "bmp", "webp", "heic", "tif", "tiff", "svg", "ico", "raw", "psd"],
["Videos"] = ["mp4", "mkv", "avi", "mov", "wmv", "webm", "m4v", "flv", "mpg", "mpeg"],
["Musik"] = ["mp3", "wav", "flac", "aac", "ogg", "m4a", "wma", "opus"],
["Dokumente"] = ["pdf", "doc", "docx", "xls", "xlsx", "ppt", "pptx", "odt", "ods", "odp", "txt", "rtf", "md", "csv"],
["Archive"] = ["zip", "rar", "7z", "tar", "gz", "bz2", "xz", "iso"],
["Programme"] = ["exe", "msi", "lnk", "url", "appref-ms", "bat", "cmd"],
["Verknüpfungen"] = ["lnk", "url", "appref-ms"],
};
/// <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/DeskCore.exe
BIN
View File
Binary file not shown.
artifacts/app/LICENSE.txt
+38
View File
@@ -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
BIN
View File
Binary file not shown.
artifacts/setup/DeskCore-Setup.exe.config
+6
View File
@@ -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
+23
View File
@@ -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.dll
BIN
View File
Binary file not shown.
bin/Release/net9.0-windows/DeskCore.exe
BIN
View File
Binary file not shown.
bin/Release/net9.0-windows/DeskCore.pdb
BIN
View File
Binary file not shown.
bin/Release/net9.0-windows/DeskCore.runtimeconfig.json
+20
View File
@@ -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
+38
View File
@@ -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
+24
View File
@@ -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": ""
}
}
}
bin/Release/net9.0-windows/win-x64/DeskCore.dll
BIN
View File
Binary file not shown.