733 lines
33 KiB
C#
733 lines
33 KiB
C#
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);
|
||
Usage.Changed += OnUsageChanged;
|
||
Closed += (_, _) => { _portalWatcher?.Dispose(); Usage.Changed -= OnUsageChanged; };
|
||
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 (tab?.IsRecent == true)
|
||
items = Usage.Recent(RecentCount).Select(p => new IconItem { Path = p }).ToList();
|
||
else 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, tab);
|
||
|
||
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 = tab?.IsRecent == true ? "Noch nichts gestartet – was du über DeskCore öffnest, erscheint hier"
|
||
: 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);
|
||
|
||
/// <summary>Wie viele Einträge eine „Zuletzt benutzt“-Box zeigt.</summary>
|
||
private const int RecentCount = 24;
|
||
|
||
private void OnUsageChanged()
|
||
{
|
||
// Zuletzt-Tab oder Sortierung nach Häufigkeit → neu ordnen (kurz verzögert, falls mehrere Starts kommen)
|
||
if (Tab?.IsRecent == true || Def.Sort == "Häufig") Dispatcher.BeginInvoke(Refresh, DispatcherPriority.Background);
|
||
}
|
||
|
||
private List<IconItem> Sort(List<IconItem> items, FenceTab? tab)
|
||
{
|
||
// Zuletzt benutzt: neueste zuerst – außer es ist ausdrücklich "Häufig" gewählt
|
||
if (tab?.IsRecent == true)
|
||
return Def.Sort == "Häufig" ? items.OrderByDescending(i => Usage.Score(i.Path)).ToList() : items;
|
||
// Eigene Reihenfolge: wie gezogen; Neues hinten dran (alphabetisch)
|
||
if (Def.Sort == "Eigene" && tab is not null)
|
||
{
|
||
var order = tab.Order;
|
||
return items.OrderBy(i => order.FindIndex(n => string.Equals(n, Path.GetFileName(i.Path), StringComparison.OrdinalIgnoreCase)) is var k and >= 0 ? k : int.MaxValue)
|
||
.ThenBy(i => i.Name, StringComparer.CurrentCultureIgnoreCase).ToList();
|
||
}
|
||
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; } }),
|
||
"Häufig" => x.OrderByDescending(i => Usage.Score(i.Path)).ThenBy(i => i.Name, StringComparer.CurrentCultureIgnoreCase),
|
||
_ => 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.IsCategory ? S.Categories.GetValueOrDefault(t.Value) : null;
|
||
var glyph = new TextBlock
|
||
{
|
||
Text = t.IsRecent ? "" : 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.IsCategory ? "TextBrush" : "AccentBrush"),
|
||
};
|
||
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.IsRecent ? "Was du zuletzt über DeskCore gestartet hast" : 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 { Usage.Start(i.Path); }
|
||
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 { IsCategory: true } 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)
|
||
{
|
||
if (_dragging)
|
||
{
|
||
// Innerhalb der eigenen Box: neu anordnen (nicht bei „Zuletzt benutzt“ – die ordnet sich selbst)
|
||
e.Effects = Tab is { IsRecent: false } ? DragDropEffects.Copy : DragDropEffects.None;
|
||
ShowDropMarker(e.Effects == DragDropEffects.None ? null : e.GetPosition(Items));
|
||
}
|
||
else
|
||
e.Effects = e.Data.GetDataPresent(DataFormats.FileDrop) && CurrentFolder is not null
|
||
? (e.AllowedEffects.HasFlag(DragDropEffects.Copy) ? DragDropEffects.Copy : DragDropEffects.Move)
|
||
: DragDropEffects.None;
|
||
e.Handled = true;
|
||
}
|
||
|
||
private void Items_DragLeave(object sender, DragEventArgs e) => ShowDropMarker(null);
|
||
|
||
private void Items_Drop(object sender, DragEventArgs e)
|
||
{
|
||
ShowDropMarker(null);
|
||
if (_dragging)
|
||
{
|
||
if (Tab is { IsRecent: false } t) Reorder(t, Selected, e.GetPosition(Items));
|
||
return;
|
||
}
|
||
if (CurrentFolder is { } folder && e.Data.GetData(DataFormats.FileDrop) is string[] files)
|
||
App.Win?.TransferAll(files, folder);
|
||
}
|
||
|
||
// ---------- Eigene Reihenfolge ----------
|
||
|
||
/// <summary>Einfügestelle an der Mausposition: vor welchem Eintrag landet das Gezogene? (Count = ans Ende)</summary>
|
||
private (int Index, Rect? Marker) InsertionAt(Point p)
|
||
{
|
||
var list = Items.ItemsSource as List<IconItem> ?? [];
|
||
for (int k = 0; k < list.Count; k++)
|
||
{
|
||
if (Items.ItemContainerGenerator.ContainerFromIndex(k) is not ListBoxItem c || !c.IsVisible) continue;
|
||
var r = new Rect(c.TranslatePoint(new Point(0, 0), Items), c.RenderSize);
|
||
if (p.Y < r.Top) return (k, new Rect(r.Left - 2, r.Top, 3, r.Height)); // Zeile darüber, ganz links
|
||
if (p.Y <= r.Bottom && p.X < r.Left + r.Width / 2) return (k, new Rect(r.Left - 2, r.Top, 3, r.Height));
|
||
}
|
||
if (list.Count > 0 && Items.ItemContainerGenerator.ContainerFromIndex(list.Count - 1) is ListBoxItem last)
|
||
{
|
||
var r = new Rect(last.TranslatePoint(new Point(0, 0), Items), last.RenderSize);
|
||
return (list.Count, new Rect(r.Right - 1, r.Top, 3, r.Height));
|
||
}
|
||
return (list.Count, null);
|
||
}
|
||
|
||
private void ShowDropMarker(Point? p)
|
||
{
|
||
if (p is { } pos && InsertionAt(pos).Marker is { } m)
|
||
{
|
||
DropMarker.Margin = new Thickness(m.Left, m.Top, 0, 0);
|
||
DropMarker.Height = m.Height;
|
||
DropMarker.Visibility = Visibility.Visible;
|
||
}
|
||
else DropMarker.Visibility = Visibility.Collapsed;
|
||
}
|
||
|
||
private void Reorder(FenceTab tab, List<IconItem> moved, Point drop)
|
||
{
|
||
var list = Items.ItemsSource as List<IconItem> ?? [];
|
||
if (moved.Count == 0) return;
|
||
int index = InsertionAt(drop).Index;
|
||
// Einfügestelle in der Liste ohne die gezogenen Einträge
|
||
int before = list.Take(index).Count(i => moved.Contains(i));
|
||
var rest = list.Where(i => !moved.Contains(i)).ToList();
|
||
rest.InsertRange(Math.Clamp(index - before, 0, rest.Count), moved);
|
||
|
||
tab.Order = rest.Select(i => Path.GetFileName(i.Path)).ToList();
|
||
bool switched = Def.Sort != "Eigene";
|
||
Def.Sort = "Eigene";
|
||
S.Save();
|
||
Refresh();
|
||
foreach (var i in (Items.ItemsSource as List<IconItem> ?? []).Where(i => moved.Any(m => m.Path == i.Path)))
|
||
Items.SelectedItems.Add(i);
|
||
if (switched) App.TrayIcon?.Notify("Eigene Reihenfolge", "Die Box ist jetzt so sortiert, wie du die Icons ziehst. Ändern unter „Aussehen …“.");
|
||
}
|
||
|
||
// =====================================================================
|
||
// 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 { IsCategory: true } 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.IsCategory && string.Equals(x.Value, c, StringComparison.OrdinalIgnoreCase))))
|
||
add.Items.Add(MainWindow.MenuItem(c, S.Categories.GetValueOrDefault(c)?.Glyph ?? "", () => AddTab(new FenceTab { Value = c })));
|
||
if (!Def.Tabs.Any(x => x.IsRecent))
|
||
add.Items.Add(MainWindow.MenuItem("Zuletzt benutzt", "", () => AddTab(new FenceTab { Kind = FenceTab.RecentKind })));
|
||
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);
|
||
var copy = MainWindow.MenuItem("Auf Seite kopieren", "\uE8C8", 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);
|
||
var ci = MainWindow.MenuItem(S.Pages[p], "\uE8A1", () => FenceManager.CopyToPage(Def, page));
|
||
ci.IsEnabled = page != Def.Page;
|
||
copy.Items.Add(ci);
|
||
}
|
||
FenceMenu.Items.Add(move);
|
||
FenceMenu.Items.Add(copy);
|
||
}
|
||
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.IsCategory) menu.Items.Add(MainWindow.MenuItem("In DeskCore öffnen", "", () => App.Win?.ShowCategory(t.Value)));
|
||
else if (t.IsFolder) 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 auf dieser Seite schon in einer anderen Box? Dann hierher holen statt doppelt anzeigen
|
||
if (tab.IsCategory) FenceManager.RemoveCategoryTab(tab.Value, except: Def, Def.Page);
|
||
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);
|
||
}
|