Free, open-source file converter. Convert 263 formats offline by drag & drop — images, PDF, Word, Excel, PowerPoint, HWP/HWPX, video, audio, e-books and archives. No upload, no Office needed.
C# audio-converteravaloniabatch-conversionconvertercsharpdocument-converterdocx-to-pdfdotnetdrag-and-dropfile-conversionfile-converterheic-converterhwphwpximage-converterlinuxmacospdf-convertervideo-converterwindows
fix(windows): focus donut for context-menu keyboard input (#730)
Marouane-elfadli945eedd917e1
diff --git a/DonutMenu.cs b/DonutMenu.csnew file mode 100644index 00000000..04b6ff6f--- /dev/null+++ b/DonutMenu.cs@@ -0,0 +1,1252 @@+// The donut toolbar: a ring completely divided into equal slices, one per preset.+// Used both as the live toolbar (RadialWindow) and as the editor in Settings → Donut toolbar (IsEditMode).+//+// Drawn by hand (no child controls) so it stays fast on low-end PCs and so every slice can be hit-tested by+// its exact wedge shape. Animations are tiny springs advanced on each rendered frame; with+// Motion.Enabled == false every value jumps straight to its target.+//+// After a drop the donut turns into a progress ring: see DonutMenu.Progress.cs. Group slices, which fan out a ring+// of presets, and the keyboard: DonutMenu.Groups.cs. Tab (or the wheel) flips the donut over: DonutMenu.Flip.cs.++using System.Globalization;+using Avalonia;+using Avalonia.Controls;+using Avalonia.Controls.Documents;+using Avalonia.Input;+using Avalonia.Media;+using Avalonia.Threading;+using Filee.App.Services;++namespace Filee.App.Controls;++/// <summary>One slice of the donut.</summary>+public sealed class DonutItem+{+ public required string Id { get; init; }+ public required string Label { get; init; }++ /// <summary>Small second line, e.g. the target format. Hidden when equal to <see cref="Label"/>.</summary>+ public string? Caption { get; init; }++ public bool IsEnabled { get; init; } = true;++ /// <summary>Tooltip shown for disabled slices.</summary>+ public string? DisabledReason { get; init; }++ /// <summary>+ /// A group slice: converts nothing itself; hovering it fans these out in a small ring outside the donut, where they+ /// are clicked or dropped on like ordinary slices.+ /// </summary>+ public IReadOnlyList<DonutItem>? Children { get; init; }++ /// <summary>A group slice (<see cref="Children"/> set), even one left with nothing to fan out.</summary>+ public bool IsGroup => Children is not null;++ /// <summary>A group with something to fan out.</summary>+ public bool CanExpand => Children is { Count: > 0 };+}++/// <summary>Donut-shaped menu control.</summary>+public sealed partial class DonutMenu : Control+{+ public static readonly StyledProperty<IReadOnlyList<DonutItem>?> ItemsProperty =+ AvaloniaProperty.Register<DonutMenu, IReadOnlyList<DonutItem>?>(nameof(Items));+ public static readonly StyledProperty<double> OuterRadiusProperty =+ AvaloniaProperty.Register<DonutMenu, double>(nameof(OuterRadius), 150);+ public static readonly StyledProperty<double> HoleRatioProperty =+ AvaloniaProperty.Register<DonutMenu, double>(nameof(HoleRatio), 0.42);+ public static readonly StyledProperty<double> SliceOpacityProperty =+ AvaloniaProperty.Register<DonutMenu, double>(nameof(SliceOpacity), 0.96);+ public static readonly StyledProperty<string?> CenterTitleProperty =+ AvaloniaProperty.Register<DonutMenu, string?>(nameof(CenterTitle));+ public static readonly StyledProperty<string?> CenterSubtitleProperty =+ AvaloniaProperty.Register<DonutMenu, string?>(nameof(CenterSubtitle));+ public static readonly StyledProperty<bool> IsEditModeProperty =+ AvaloniaProperty.Register<DonutMenu, bool>(nameof(IsEditMode));+ public static readonly StyledProperty<bool> AllowContextEditProperty =+ AvaloniaProperty.Register<DonutMenu, bool>(nameof(AllowContextEdit));+ public static readonly StyledProperty<bool> ReserveSubRingProperty =+ AvaloniaProperty.Register<DonutMenu, bool>(nameof(ReserveSubRing));++ /// <summary>The theme's softness (Styles/Controls.axaml binds SoftRadius): rounds the corners of the slices.</summary>+ public static readonly StyledProperty<CornerRadius> CornerRadiusProperty =+ AvaloniaProperty.Register<DonutMenu, CornerRadius>(nameof(CornerRadius));++ public static readonly StyledProperty<IBrush?> SliceBrushProperty =+ AvaloniaProperty.Register<DonutMenu, IBrush?>(nameof(SliceBrush), Brushes.White);+ public static readonly StyledProperty<IBrush?> SliceBorderBrushProperty =+ AvaloniaProperty.Register<DonutMenu, IBrush?>(nameof(SliceBorderBrush));+ public static readonly StyledProperty<IBrush?> CenterBrushProperty =+ AvaloniaProperty.Register<DonutMenu, IBrush?>(nameof(CenterBrush), Brushes.White);+ public static readonly StyledProperty<IBrush?> AccentBrushProperty =+ AvaloniaProperty.Register<DonutMenu, IBrush?>(nameof(AccentBrush), Brushes.MediumPurple);+ public static readonly StyledProperty<IBrush?> OnAccentBrushProperty =+ AvaloniaProperty.Register<DonutMenu, IBrush?>(nameof(OnAccentBrush), Brushes.White);+ public static readonly StyledProperty<IBrush?> ForegroundProperty =+ AvaloniaProperty.Register<DonutMenu, IBrush?>(nameof(Foreground), Brushes.Black);+ public static readonly StyledProperty<IBrush?> SecondaryForegroundProperty =+ AvaloniaProperty.Register<DonutMenu, IBrush?>(nameof(SecondaryForeground), Brushes.Gray);+ public static readonly StyledProperty<IBrush?> DangerBrushProperty =+ AvaloniaProperty.Register<DonutMenu, IBrush?>(nameof(DangerBrush), Brushes.IndianRed);++ /// <summary>Gap between slices in pixels (keeps the donut "full" while separating slices).</summary>+ private const double GapPixels = 3;+ private const double PopOut = 7;+ private const double OpenDuration = 0.42;+ private const double OpenStagger = 0.028;+ private const double DragStartDistance = 5;++ // Pencil (Material "edit") path in a 24×24 box.+ private static readonly Geometry PencilIcon = Geometry.Parse(+ "M3,17.25V21h3.75L17.81,9.94l-3.75-3.75L3,17.25z M20.71,7.04c0.39-0.39,0.39-1.02,0-1.41l-2.34-2.34c-0.39-0.39-1.02-0.39-1.41,0l-1.83,1.83l3.75,3.75L20.71,7.04z");++ private Spring[] _hover = [];+ private double[] _open = [];+ private Spring _centerPulse;+ private double _openClock = double.MaxValue;+ private TimeSpan? _lastFrame;+ private bool _animating;+ private Action? _closeCallback;+ private bool _closing;++ private int _hoverIndex = -1;+ private int _externalHighlight = -1;+ private bool _externalCenterHot;+ private int _dimmedIndex = -1;+ private int _dropTargetIndex = -1;++ // Edit mode drop preview: the slices make room where a dragged preset would land and a translucent slice shows+ // it there. Every slice's centre angle and width is a spring, so the others slide aside instead of jumping.+ private Spring[] _mid = [];+ private Spring[] _span = [];+ private Spring _previewMid;+ private Spring _previewSpan;+ private int _previewSlot = -1;+ private int _previewRemoved = -1;+ private string? _previewLabel;+ private (int Index, Point Start, PointerPressedEventArgs Args)? _press;++ static DonutMenu()+ {+ AffectsMeasure<DonutMenu>(OuterRadiusProperty, ReserveSubRingProperty);+ AffectsRender<DonutMenu>(HoleRatioProperty, SliceOpacityProperty, CenterTitleProperty, CenterSubtitleProperty,+ IsEditModeProperty, SliceBrushProperty, SliceBorderBrushProperty, CenterBrushProperty, AccentBrushProperty,+ OnAccentBrushProperty, ForegroundProperty, SecondaryForegroundProperty, SuccessBrushProperty, CornerRadiusProperty,+ CenterHintProperty, CenterHintWheelProperty);+ ItemsProperty.Changed.AddClassHandler<DonutMenu>((d, _) => d.OnItemsChanged());+ }++ public DonutMenu()+ {+ // A circle reads the same either way: slices keep their clockwise order in Arabic too, their labels are+ // shaped right to left (TextDirection).+ FlowDirection = FlowDirection.LeftToRight;+ ClipToBounds = false;+ Cursor = new Cursor(StandardCursorType.Hand);+ // The live click-mode donut handles Tab, arrows, Enter and Escape itself. It must be the focused control+ // after a context-menu/shortcut launch; otherwise Avalonia has no focused target to which the key events can+ // be routed. It is focused explicitly by RadialController, so it must not participate in normal Tab order.+ Focusable = true;+ IsTabStop = false;+ }++ public IReadOnlyList<DonutItem>? Items { get => GetValue(ItemsProperty); set => SetValue(ItemsProperty, value); }+ public double OuterRadius { get => GetValue(OuterRadiusProperty); set => SetValue(OuterRadiusProperty, value); }+ public double HoleRatio { get => GetValue(HoleRatioProperty); set => SetValue(HoleRatioProperty, value); }+ public double SliceOpacity { get => GetValue(SliceOpacityProperty); set => SetValue(SliceOpacityProperty, value); }+ public string? CenterTitle { get => GetValue(CenterTitleProperty); set => SetValue(CenterTitleProperty, value); }+ public string? CenterSubtitle { get => GetValue(CenterSubtitleProperty); set => SetValue(CenterSubtitleProperty, value); }++ /// <summary>Settings editor mode: shows ✎ on hover, raises drag and edit events instead of invoking slices.</summary>+ public bool IsEditMode { get => GetValue(IsEditModeProperty); set => SetValue(IsEditModeProperty, value); }++ /// <summary>Live toolbar in click mode: right-click on a slice raises <see cref="SegmentContextRequested"/>.</summary>+ public bool AllowContextEdit { get => GetValue(AllowContextEditProperty); set => SetValue(AllowContextEditProperty, value); }++ /// <summary>+ /// Leave room for a group's ring even before the slices are known (the drag window is placed before files arrive),+ /// so the window doesn't grow, and the donut move, when they do.+ /// </summary>+ public bool ReserveSubRing { get => GetValue(ReserveSubRingProperty); set => SetValue(ReserveSubRingProperty, value); }++ public CornerRadius CornerRadius { get => GetValue(CornerRadiusProperty); set => SetValue(CornerRadiusProperty, value); }++ public IBrush? SliceBrush { get => GetValue(SliceBrushProperty); set => SetValue(SliceBrushProperty, value); }+ public IBrush? SliceBorderBrush { get => GetValue(SliceBorderBrushProperty); set => SetValue(SliceBorderBrushProperty, value); }+ public IBrush? CenterBrush { get => GetValue(CenterBrushProperty); set => SetValue(CenterBrushProperty, value); }+ public IBrush? AccentBrush { get => GetValue(AccentBrushProperty); set => SetValue(AccentBrushProperty, value); }+ public IBrush? OnAccentBrush { get => GetValue(OnAccentBrushProperty); set => SetValue(OnAccentBrushProperty, value); }+ public IBrush? Foreground { get => GetValue(ForegroundProperty); set => SetValue(ForegroundProperty, value); }+ public IBrush? SecondaryForeground { get => GetValue(SecondaryForegroundProperty); set => SetValue(SecondaryForegroundProperty, value); }+ public IBrush? DangerBrush { get => GetValue(DangerBrushProperty); set => SetValue(DangerBrushProperty, value); }++ /// <summary>True while an external drag hovers the hole (drop = cancel).</summary>+ public bool IsCenterHot => _externalCenterHot;++ /// <summary>Currently emphasised slice (pointer hover or external highlight), or -1.</summary>+ public int ActiveIndex => _externalHighlight >= 0 ? _externalHighlight : _hoverIndex;++ /// <summary>A slice was clicked (live toolbar, click mode).</summary>+ public event EventHandler<int>? SegmentInvoked;++ /// <summary>A slice of a group's ring was clicked: (group, slice in the group).</summary>+ public event EventHandler<(int Group, int Sub)>? SubSegmentInvoked;++ /// <summary>The hovered slice of a group's ring, or -1. <see cref="ActiveIndexChanged"/> is raised when it changes.</summary>+ public int ActiveSubIndex => _subHover;++ /// <summary>Right-click or ✎ on a slice.</summary>+ public event EventHandler<int>? SegmentContextRequested;++ /// <summary>Right-click on a slice of a group's ring (live toolbar, click mode): (group, slice in the group).</summary>+ public event EventHandler<(int Group, int Sub)>? SubSegmentContextRequested;++ /// <summary>The hole was clicked.</summary>+ public event EventHandler? CenterInvoked;++ /// <summary>Edit mode: the user started dragging slice <c>Index</c>.</summary>+ public event EventHandler<(int Index, PointerEventArgs Args)>? SegmentDragStarted;++ /// <summary>The emphasised slice changed (-1 = none). Useful to update the centre text.</summary>+ public event EventHandler<int>? ActiveIndexChanged;++ private int Count => Items?.Count ?? 0;+ private Point Center => new(Bounds.Width / 2, Bounds.Height / 2);+ private double InnerRadius => OuterRadius * Math.Clamp(HoleRatio, 0.2, 0.75);++ // ───────────────────────── Public API ─────────────────────────++ /// <summary>Plays the "pop out from the centre" animation.</summary>+ public void PlayOpenAnimation()+ {+ ResetProgress();+ _closing = false;+ _closeCallback = null;+ if (!Motion.Enabled)+ {+ Array.Fill(_open, 1);+ InvalidateVisual();+ return;+ }+ Array.Fill(_open, 0);+ _openClock = 0;+ StartAnimation();+ }++ /// <summary>Shrinks the donut back into the centre, then calls <paramref name="done"/>.</summary>+ public void PlayCloseAnimation(Action done)+ {+ if (IsFlipping)+ FinishFlip();+ if (!Motion.Enabled || Count == 0)+ {+ done();+ return;+ }+ _closing = true;+ _closeCallback = done;+ _openClock = 0;+ StartAnimation();+ }++ /// <summary>Short "boing" of the centre, e.g. after a drop.</summary>+ public void PulseCenter()+ {+ if (!Motion.Enabled)+ return;+ _centerPulse.Velocity = 6;+ StartAnimation();+ }++ /// <summary>Highlights a slice from outside (drag-over in the live toolbar). -1 clears.</summary>+ public void SetExternalHighlight(int index, bool centerHot = false)+ {+ if (_externalHighlight == index && _externalCenterHot == centerHot)+ return;+ _externalHighlight = index;+ _externalCenterHot = centerHot;+ ActiveIndexChanged?.Invoke(this, ActiveIndex);+ StartAnimation();+ }++ /// <summary>How far slice <paramref name="index"/> is drawn lit up right now (0 to 1), for the drag log.</summary>+ public double LitAmount(int index) => index >= 0 && index < _hover.Length ? _hover[index].Value : 0;++ /// <summary>Edit mode: the slice being dragged is drawn faded.</summary>+ public void SetDimmedIndex(int index)+ {+ _dimmedIndex = index;+ InvalidateVisual();+ }++ /// <summary>Edit mode: highlights where a dragged item would land (-1 none, Count = empty ring).</summary>+ public void SetDropTarget(int index)+ {+ if (_dropTargetIndex == index)+ return;+ _dropTargetIndex = index;+ InvalidateVisual();+ }++ /// <summary>+ /// Edit mode: opens a gap at <paramref name="slot"/> (the position in the list after the drop) and shows a+ /// translucent slice labelled <paramref name="label"/> there. <paramref name="removed"/> is the slice being moved,+ /// which leaves its place. -1 closes the gap.+ /// </summary>+ public void SetDropPreview(int slot, string? label = null, int removed = -1)+ {+ if (_previewSlot == slot && _previewRemoved == removed && _previewLabel == label)+ return;+ if (_previewSlot < 0 && slot >= 0)+ {+ // The new slice grows out of nothing where it appears.+ _previewMid = new Spring { Value = DonutGeometry.MidAngle(slot, SlotCount(removed)) };+ _previewSpan = default;+ }+ _previewSlot = slot;+ _previewRemoved = removed;+ _previewLabel = label;+ StartAnimation();+ }++ /// <summary>The slot under <paramref name="p"/> when the donut has <paramref name="slots"/> slices; -1 off the ring.</summary>+ public int SlotAt(Point p, int slots)+ {+ var hit = DonutGeometry.HitTest(Center, p, InnerRadius, OuterRadius, Math.Max(slots, 1), PopOut);+ return hit.Kind == DonutHitKind.Segment ? hit.Index : -1;+ }++ /// <summary>Slices while previewing: the items, minus the one being moved, plus the preview.</summary>+ private int SlotCount(int removed) => Count + 1 - (removed >= 0 ? 1 : 0);++ /// <summary>Where slice <paramref name="i"/> belongs: its usual place, or shifted to make room for the preview.</summary>+ private (double Mid, double Span) LayoutTarget(int i)+ {+ var n = Count;+ if (_previewSlot < 0)+ return (DonutGeometry.MidAngle(i, n), DonutGeometry.Span(n));+ if (i == _previewRemoved)+ return (i < _mid.Length ? _mid[i].Value : DonutGeometry.MidAngle(i, n), 0); // it becomes the preview+ var slot = _previewRemoved >= 0 && i > _previewRemoved ? i - 1 : i;+ if (slot >= _previewSlot)+ slot++;+ var m = SlotCount(_previewRemoved);+ return (DonutGeometry.MidAngle(slot, m), DonutGeometry.Span(m));+ }++ /// <summary>Moves the slices and the preview towards their places. Returns true while they are still moving.</summary>+ private bool StepLayout(double dt, bool snap = false)+ {+ snap |= !Motion.Enabled;+ var active = false;+ for (var i = 0; i < _mid.Length; i++)+ {+ var (mid, span) = LayoutTarget(i);+ if (snap)+ {+ _mid[i] = new Spring { Value = mid };+ _span[i] = new Spring { Value = span };+ continue;+ }+ active |= _mid[i].Step(mid, dt, 420, 36);+ active |= _span[i].Step(span, dt, 420, 36);+ }+ var m = SlotCount(_previewRemoved);+ var previewMid = _previewSlot >= 0 ? DonutGeometry.MidAngle(_previewSlot, m) : _previewMid.Value;+ var previewSpan = _previewSlot >= 0 ? DonutGeometry.Span(m) : 0;+ if (snap)+ {+ _previewMid = new Spring { Value = previewMid };+ _previewSpan = new Spring { Value = previewSpan };+ return false;+ }+ active |= _previewMid.Step(previewMid, dt, 420, 36);+ active |= _previewSpan.Step(previewSpan, dt, 420, 36);+ return active;+ }++ /// <summary>Hit-tests a point in this control's coordinates.</summary>+ public DonutHit HitTest(Point p)+ {+ if (_progressMode)+ return HitTestProgress(p);+ if (IsEditMode && _hoverIndex >= 0 && _hoverIndex < Count &&+ Distance(p, EditButtonCenter(_hoverIndex)) <= 13)+ return new DonutHit(DonutHitKind.EditButton, _hoverIndex);+ var hit = DonutGeometry.HitTest(Center, p, InnerRadius, OuterRadius, Count, PopOut);+ if (ExpandedChildren is { } children)+ {+ var (inner, outer) = SubRadii;+ var parentMid = DonutGeometry.MidAngle(_expanded, Count);+ var subSpan = SubSpanOf(children.Count);+ var sub = DonutGeometry.SubIndexAt(Center, p, inner, outer, parentMid, children.Count, subSpan);+ if (sub >= 0)+ return new DonutHit(DonutHitKind.SubSegment, _expanded, sub);+ // On the way out to the ring the pointer crosses the gap before it: there it still belongs to the group, or+ // the ring would fold away (or the hint and the drag cursor flicker) just before it is reached. A neighbour's+ // outer half stays that neighbour, so a click or a drop there converts with it; TrackGroups keeps the ring+ // open over it (OnWayToRing).+ if (hit.Kind == DonutHitKind.Outside && Distance(p, Center) < inner && InFan(p, _expanded))+ return new DonutHit(DonutHitKind.Segment, _expanded);+ }+ return hit;+ }++ // ───────────────────────── Layout ─────────────────────────++ protected override Size MeasureOverride(Size availableSize)+ {+ var side = SideFor(OuterRadius, ReserveSubRing || (!IsEditMode && Items?.Any(i => i.IsGroup) == true));+ return new Size(side, side);+ }++ private void OnItemsChanged()+ {+ var n = Count;+ _hover = new Spring[n];+ _open = Enumerable.Repeat(1.0, n).ToArray();+ _hoverIndex = -1;+ _externalHighlight = -1;+ _dimmedIndex = -1;+ _dropTargetIndex = -1;+ // A drop changes the items into exactly what the preview showed: start there, without a jump.+ _previewSlot = -1;+ _previewRemoved = -1;+ _previewSpan = default;+ _mid = Enumerable.Range(0, n).Select(i => new Spring { Value = DonutGeometry.MidAngle(i, n) }).ToArray();+ _span = Enumerable.Range(0, n).Select(_ => new Spring { Value = DonutGeometry.Span(n) }).ToArray();+ _expanded = _shownExpanded = _subHover = -1;+ ClearPending();+ _expand = default;+ // New files (or none): a flip of the old ones is over. A flip's own swap keeps going (SwapFaces).+ if (!_swapping)+ CancelFlip();+ _lastExternalAt = null;+ // The window is reused: a keyboard hold from the last time it was open must not swallow the first moves now.+ _keyboardHold = _ringFromKeys = false;+ _keyAnchor = _lastPointer = null;+ InvalidateMeasure();+ InvalidateVisual();+ }++ // ───────────────────────── Input ─────────────────────────++ protected override void OnPointerMoved(PointerEventArgs e)+ {+ base.OnPointerMoved(e);+ var p = e.GetPosition(this);+ if (_progressMode)+ {+ OnProgressPointerMoved(p);+ return;+ }++ if (_press is { } press && IsEditMode && Distance(p, press.Start) > DragStartDistance && press.Index >= 0)+ {+ _press = null;+ SegmentDragStarted?.Invoke(this, (press.Index, e));+ return;+ }++ if (_keyboardHold)+ {+ if (_keyAnchor is not { } anchor)+ _keyAnchor = anchor = p;+ if (Distance(p, anchor) < KeyboardJitter)+ return;+ _keyboardHold = false;+ }+ _lastPointer = p;+ var hit = HitTest(p);+ if (IsFlipping)+ PointAtAngle(DonutGeometry.AngleOf(Center, p), hit.Kind is DonutHitKind.Segment or DonutHitKind.SubSegment);+ TrackGroups(hit, p);+ SetHover(hit.Kind switch+ {+ DonutHitKind.Segment or DonutHitKind.EditButton or DonutHitKind.SubSegment => hit.Index,+ _ => -1,+ });+ // On a group's ring, why that slice (not the group) is disabled.+ var hovered = hit.Kind == DonutHitKind.SubSegment ? Items![hit.Index].Children![hit.Sub]+ : _hoverIndex >= 0 ? Items![_hoverIndex] : null;+ ToolTip.SetTip(this, hovered is { IsEnabled: false } ? hovered.DisabledReason : null);+ }++ protected override void OnPointerExited(PointerEventArgs e)+ {+ base.OnPointerExited(e);+ if (_progressMode)+ {+ OnProgressPointerMoved(new Point(double.MaxValue / 4, 0));+ return;+ }+ if (_press is null && !LeftThroughSeam(e.GetPosition(this)))+ {+ CollapseGroup();+ SetHover(-1);+ }+ }++ protected override void OnPointerPressed(PointerPressedEventArgs e)+ {+ base.OnPointerPressed(e);+ var point = e.GetCurrentPoint(this);+ var hit = HitTest(point.Position);++ if (_progressMode)+ {+ if (point.Properties.IsLeftButtonPressed)+ {+ _press = (-1, point.Position, e);+ e.Handled = true;+ }+ return;+ }++ if (point.Properties.IsRightButtonPressed)+ {+ if (hit.Kind is DonutHitKind.Segment or DonutHitKind.EditButton && (IsEditMode || AllowContextEdit))+ {+ SegmentContextRequested?.Invoke(this, hit.Index);+ e.Handled = true;+ }+ else if (hit.Kind == DonutHitKind.SubSegment && AllowContextEdit)+ {+ SubSegmentContextRequested?.Invoke(this, (hit.Index, hit.Sub));+ e.Handled = true;+ }+ return;+ }++ if (point.Properties.IsLeftButtonPressed)+ {+ _press = (hit.Kind == DonutHitKind.Segment ? hit.Index : -1, point.Position, e);+ e.Handled = true;+ }+ }++ protected override void OnPointerReleased(PointerReleasedEventArgs e)+ {+ base.OnPointerReleased(e);+ if (_press is null)+ return;+ _press = null;++ if (_progressMode)+ {+ OnProgressPointerReleased(e.GetPosition(this));+ e.Handled = true;+ return;+ }++ var hit = HitTest(e.GetPosition(this));+ switch (hit.Kind)+ {+ case DonutHitKind.EditButton:+ SegmentContextRequested?.Invoke(this, hit.Index);+ break;+ case DonutHitKind.Segment when !IsEditMode && Items![hit.Index] is { IsEnabled: true, IsGroup: false }:+ SegmentInvoked?.Invoke(this, hit.Index);+ break;+ case DonutHitKind.Segment when !IsEditMode && Items![hit.Index].Children is { Count: > 0 }:+ Expand(hit.Index); // no waiting when clicked; a tap has no hover to rest on at all+ break;+ case DonutHitKind.Outside when !IsEditMode && _expanded >= 0:+ CollapseGroup(); // clicked past the ring+ break;+ case DonutHitKind.SubSegment when !IsEditMode && Items![hit.Index].Children![hit.Sub].IsEnabled:+ SubSegmentInvoked?.Invoke(this, (hit.Index, hit.Sub));+ break;+ case DonutHitKind.Center when !IsEditMode:+ CenterInvoked?.Invoke(this, EventArgs.Empty);+ break;+ }+ e.Handled = true;+ }++ private void SetHover(int index)+ {+ if (_hoverIndex == index)+ return;+ _hoverIndex = index;+ ActiveIndexChanged?.Invoke(this, ActiveIndex);+ StartAnimation();+ }++ // ───────────────────────── Animation ─────────────────────────++ /// <summary>Damping at which a spring of stiffness 320 settles without overshooting (2·√320).</summary>+ private const double CriticalDamping = 36;++ /// <summary>Underdamped spring: gives the soft "boing" when a slice pops out.</summary>+ private struct Spring+ {+ public double Value;+ public double Velocity;++ /// <summary>+ /// Longest time one integration step covers. With these stiffnesses a single step of a late frame (50 ms)+ /// overshoots more each frame instead of settling: slices stayed lit and flew apart on a busy machine.+ /// </summary>+ private const double MaxStep = 1 / 120.0;++ public bool Step(double target, double dt, double stiffness = 320, double damping = 20)+ {+ var steps = Math.Max(1, (int)Math.Ceiling(dt / MaxStep));+ var h = dt / steps;+ for (var i = 0; i < steps; i++)+ {+ var force = stiffness * (target - Value) - damping * Velocity;+ Velocity += force * h;+ Value += Velocity * h;+ }+ var settled = Math.Abs(target - Value) < 0.001 && Math.Abs(Velocity) < 0.01;+ if (settled)+ {+ Value = target;+ Velocity = 0;+ }+ return !settled;+ }+ }++ /// <summary>+ /// A frame loop that got no frame for this long is treated as stopped: a frame request can be lost (the window+ /// hidden in between, for one), and every later animation would wait for it, so the slice under a dragged file+ /// would never light up.+ /// </summary>+ internal const long StalledLoopMs = 250;++ private int _loop; // the current frame loop; frames of an older one are ignored+ private long _lastTick; // Environment.TickCount64 of the last frame or frame request++ /// <summary>Frame requests asked again before the animation is finished at once (see <see cref="CheckLoop"/>).</summary>+ internal const int FrameRetries = 2;++ private int _stalls; // times the current animation's frames stopped coming++ private void StartAnimation()+ {+ InvalidateVisual();+ if (_animating && Environment.TickCount64 - _lastTick < StalledLoopMs)+ return;+ _stalls = 0;+ StartLoop();+ }++ private void StartLoop()+ {+ var top = TopLevel.GetTopLevel(this);+ if (top is null)+ {+ _animating = false;+ return;+ }+ _animating = true;+ _lastFrame = null;+ _lastTick = Environment.TickCount64;+ var loop = ++_loop;+ top.RequestAnimationFrame(time => OnFrame(time, loop));+ Watch(loop);+ }++ private void Watch(int loop) =>+ DispatcherTimer.RunOnce(() =>+ {+ if (loop == _loop)+ CheckLoop();+ }, TimeSpan.FromMilliseconds(StalledLoopMs + 50));++ /// <summary>+ /// Watches the frame loop without waiting for another animation call. When its frames stop (a request lost+ /// while the window was hidden, or the renderer waking up after a long idle), the frame is asked for again; after+ /// <see cref="FrameRetries"/> stalls the animations jump to their end, so an opening donut always appears. Stalls+ /// are counted per animation: frames that trickle in once per retry would otherwise open the donut over seconds.+ /// </summary>+ internal void CheckLoop()+ {+ if (!_animating)+ return;+ if (Environment.TickCount64 - _lastTick < StalledLoopMs)+ {+ Watch(_loop); // frames are coming: keep watching until the loop ends+ return;+ }+ if (++_stalls <= FrameRetries)+ {+ StartLoop();+ return;+ }+ _animating = false;+ _loop++;+ FinishAnimations();+ }++ /// <summary>+ /// Sets the opening, the highlights and the slice layout to where they end (a closing donut closes). The progress+ /// ring keeps its own timers.+ /// </summary>+ internal void FinishAnimations()+ {+ for (var i = 0; i < _hover.Length; i++)+ _hover[i] = new Spring { Value = i == ActiveIndex ? 1 : 0 };+ _centerPulse = default;+ _expand = new Spring { Value = _expanded >= 0 ? 1 : 0 };+ if (_expanded < 0)+ _shownExpanded = -1;+ StepLayout(0, snap: true);+ FinishFlip();+ if (_openClock < double.MaxValue)+ {+ _openClock = double.MaxValue;+ Array.Fill(_open, _closing ? 0 : 1);+ if (_closing)+ FinishClose();+ }+ InvalidateVisual();+ }++ private void OnFrame(TimeSpan time, int loop)+ {+ if (loop != _loop)+ return; // a loop that was given up on as stalled, replaced by a newer one+ _lastTick = Environment.TickCount64;+ var dt = _lastFrame is { } last ? Math.Clamp((time - last).TotalSeconds, 0, 0.05) : 1 / 60.0;+ _lastFrame = time;+ var active = Advance(dt);++ InvalidateVisual();+ if (active && TopLevel.GetTopLevel(this) is { } top)+ top.RequestAnimationFrame(next => OnFrame(next, loop));+ else+ _animating = false;+ }++ /// <summary>+ /// Advances every animation by <paramref name="dt"/> seconds. Returns true while more frames are needed.+ /// Internal so tests can step time deterministically.+ /// </summary>+ internal bool Advance(double dt)+ {+ var active = false;++ if (!Motion.Enabled)+ {+ for (var i = 0; i < _hover.Length; i++)+ {+ _hover[i].Value = i == ActiveIndex ? 1 : 0;+ _hover[i].Velocity = 0;+ }+ Array.Fill(_open, _closing ? 0 : 1);+ _centerPulse = default;+ _expand = new Spring { Value = _expanded >= 0 ? 1 : 0 };+ if (_expanded < 0)+ _shownExpanded = -1;+ StepLayout(dt);+ FinishFlip(); // animations switched off halfway through a flip+ if (_closing)+ FinishClose();+ active |= StepProgress(dt); // hold timers still run without animation+ }+ else+ {+ // Popping out bounces; letting go settles without a bounce: one below zero would make the faded accent+ // flash once more on its way back.+ for (var i = 0; i < _hover.Length; i++)+ active |= i == ActiveIndex ? _hover[i].Step(1, dt) : _hover[i].Step(0, dt, 320, CriticalDamping);+ active |= _centerPulse.Step(0, dt, 260, 12);+ // A soft bounce opening, like the slices popping out; folding away settles without one. The bounce grows the+ // ring by about a pixel, well inside the room kept for it (SubRingSpace).+ active |= _expanded >= 0 ? _expand.Step(1, dt, 320, 24) : _expand.Step(0, dt, 320, CriticalDamping);+ if (_expanded < 0 && _expand.Value <= 0.001)+ _shownExpanded = -1;+ active |= StepProgress(dt);+ active |= StepLayout(dt);+ active |= StepFlip(dt);++ if (_openClock < double.MaxValue)+ {+ _openClock += dt;+ var done = true;+ for (var i = 0; i < _open.Length; i++)+ {+ var t = Math.Clamp((_openClock - i * (_closing ? 0.01 : OpenStagger)) / (_closing ? 0.16 : OpenDuration), 0, 1);+ _open[i] = _closing ? 1 - EaseInCubic(t) : EaseOutBack(t);+ done &= t >= 1;+ }+ if (done)+ {+ _openClock = double.MaxValue;+ if (_closing)+ FinishClose();+ }+ else+ {+ active = true;+ }+ }+ }++ return active;+ }++ private void FinishClose()+ {+ _closing = false;+ var callback = _closeCallback;+ _closeCallback = null;+ callback?.Invoke();+ }++ private static double EaseOutBack(double t)+ {+ const double c1 = 1.55;+ const double c3 = c1 + 1;+ return 1 + c3 * Math.Pow(t - 1, 3) + c1 * Math.Pow(t - 1, 2);+ }++ private static double EaseInCubic(double t) => t * t * t;++ // ───────────────────────── Rendering ─────────────────────────++ public override void Render(DrawingContext context)+ {+ var center = Center;+ var r2 = OuterRadius;+ var r1 = InnerRadius;+ var n = Count;+ var typeface = new Typeface(GetValue(TextElement.FontFamilyProperty), FontStyle.Normal, FontWeight.SemiBold);+ var typefaceRegular = new Typeface(GetValue(TextElement.FontFamilyProperty));++ if (_progressMode)+ {+ RenderProgress(context, center, r1, r2, typeface, typefaceRegular);+ return;+ }++ RenderRing(context, center, r1, r2, n, typeface, typefaceRegular);++ var reaching = _expanded >= 0 ? _expanded : _pendingGroup;+ if (!IsEditMode && reaching >= 0 && reaching < n && Items![reaching].Children is { Count: > 0 } reachable)+ DrawHitBackdrop(context, center, reaching, reachable.Count);+ if (!IsEditMode && _shownExpanded >= 0 && _shownExpanded < n && _expand.Value > 0.01)+ DrawSubRing(context, center, typeface, typefaceRegular);+ if (HasOldGroupRing)+ DrawOldSubRing(context, center, typeface, typefaceRegular);++ DrawCenter(context, center, r1, typeface, typefaceRegular);++ if (IsEditMode && _hoverIndex >= 0 && _hoverIndex < n && _dimmedIndex < 0 && !IsFlipping)+ DrawEditButton(context, EditButtonCenter(_hoverIndex));+ }++ /// <summary>The shadow, the slices and the edit mode's drop preview.</summary>+ private void RenderRing(DrawingContext context, Point center, double r1, double r2, int n, Typeface typeface, Typeface typefaceRegular)+ {+ DrawSoftShadow(context, center, r2);++ if (n == 0)+ {+ var ring = CreateRing(center, r1, r2);+ context.DrawGeometry(WithOpacity(SliceBrush, SliceOpacity), BorderPen(), ring);+ if (_dropTargetIndex >= 0)+ context.DrawGeometry(WithOpacity(AccentBrush, 0.35), null, ring);+ }++ for (var i = 0; i < n; i++)+ {+ if (IsFlipping && SliceFlipWidth(false, i) == 0)+ continue;+ var item = Items![i];+ var open = i < _open.Length ? _open[i] : 1;+ if (open <= 0.001)+ continue;++ var previewing = IsEditMode && i < _mid.Length;+ var hover = i < _hover.Length && _previewSlot < 0 ? _hover[i].Value : 0;+ var mid = previewing ? _mid[i].Value : DonutGeometry.MidAngle(i, n);+ var span = previewing ? _span[i].Value : DonutGeometry.Span(n);+ if (span < 0.01)+ continue;+ var offset = DonutGeometry.PointAt(new Point(0, 0), hover * PopOut, mid);++ // Open animation: scale up from the centre with a small twist.+ var scale = 0.55 + 0.45 * open;+ var rotate = (1 - Math.Min(open, 1)) * -0.35;+ var transform =+ Matrix.CreateTranslation(-center.X, -center.Y) *+ Matrix.CreateRotation(rotate) *+ Matrix.CreateScale(scale * (1 + hover * 0.025), scale * (1 + hover * 0.025)) *+ Matrix.CreateTranslation(center.X + offset.X, center.Y + offset.Y) *+ SliceFlipTransform(false, i);++ using (context.PushTransform(transform))+ using (context.PushOpacity(Math.Clamp(open, 0, 1) * (i == _dimmedIndex ? 0.3 : 1)))+ {+ var wedge = CreateWedge(center, r1, r2, mid, span);+ context.DrawGeometry(WithOpacity(SliceBrush, SliceOpacity * (item.IsEnabled ? 1 : 0.55)), BorderPen(), wedge);++ // The accent fades in and out with the highlight (no floor: a floor made it vanish with a jump).+ var emphasis = i == _dropTargetIndex ? 1.0 : hover;+ if (emphasis > 0.01 && item.IsEnabled)+ context.DrawGeometry(WithOpacity(AccentBrush, 0.82 * Math.Clamp(emphasis, 0, 1)), null, wedge);++ var hot = (i == ActiveIndex || i == _dropTargetIndex) && item.IsEnabled;+ DrawLabel(context, item, center, (r1 + r2) / 2, mid, span * (r1 + r2) / 2 - 10,+ r2 - r1 - 16, typeface, typefaceRegular, hot);+ }+ }++ if (_oldFace is { } old)+ for (var i = 0; i < old.Length; i++)+ {+ var slice = old[i];+ if (SliceFlipWidth(true, i) == 0 || slice.Open <= 0.001)+ continue;+ var offset = DonutGeometry.PointAt(new Point(0, 0), slice.Hover * PopOut, slice.Mid);+ var scale = 0.55 + 0.45 * slice.Open;+ var rotate = (1 - Math.Min(slice.Open, 1)) * -0.35;+ var transform = Matrix.CreateTranslation(-center.X, -center.Y) * Matrix.CreateRotation(rotate) *+ Matrix.CreateScale(scale * (1 + slice.Hover * 0.025), scale * (1 + slice.Hover * 0.025)) *+ Matrix.CreateTranslation(center.X + offset.X, center.Y + offset.Y) *+ SliceFlipTransform(true, i);+ using (context.PushTransform(transform))+ using (context.PushOpacity(Math.Clamp(slice.Open, 0, 1) * (slice.Dimmed ? 0.3 : 1)))+ {+ var wedge = CreateWedge(center, r1, r2, slice.Mid, slice.Span);+ context.DrawGeometry(WithOpacity(SliceBrush, SliceOpacity * (slice.Item.IsEnabled ? 1 : 0.55)), BorderPen(), wedge);+ if (slice.Emphasis > 0.01 && slice.Item.IsEnabled)+ context.DrawGeometry(WithOpacity(AccentBrush, 0.82 * Math.Clamp(slice.Emphasis, 0, 1)), null, wedge);+ DrawLabel(context, slice.Item, center, (r1 + r2) / 2, slice.Mid,+ slice.Span * (r1 + r2) / 2 - 10, r2 - r1 - 16, typeface, typefaceRegular,+ slice.Hot && slice.Item.IsEnabled);+ }+ }++ if (IsEditMode && _previewSpan.Value > 0.01)+ DrawPreview(context, center, r1, r2, typeface, typefaceRegular);+ }++ private void DrawSoftShadow(DrawingContext context, Point center, double r2)+ {+ // A radial gradient ring fakes a soft drop shadow without blur effects (cheap on any GPU).+ var shadowRadius = r2 + 14;+ var brush = new RadialGradientBrush+ {+ GradientStops =+ {+ new GradientStop(Color.FromArgb(0, 0, 0, 0), 0),+ new GradientStop(Color.FromArgb(0, 0, 0, 0), (r2 - 18) / shadowRadius),+ new GradientStop(Color.FromArgb(46, 0, 0, 0), (r2 - 2) / shadowRadius),+ new GradientStop(Color.FromArgb(0, 0, 0, 0), 1),+ },+ };+ var opening = _open.Length == 0 ? 1 : Math.Clamp(_open.Average(), 0, 1);+ using (context.PushOpacity(opening * ShadowCoverage))+ context.DrawEllipse(brush, null, new Point(center.X, center.Y + 4), shadowRadius, shadowRadius);+ }++ private void DrawCenter(DrawingContext context, Point center, double r1, Typeface bold, Typeface regular)+ {+ var pulse = 1 + _centerPulse.Value * 0.06;+ var radius = (r1 - 6) * pulse;+ var cancelHot = _externalCenterHot;+ context.DrawEllipse(CenterBrush, BorderPen(), center, radius, radius);+ if (cancelHot)+ context.DrawEllipse(WithOpacity(DangerBrush, 0.18), null, center, radius, radius);++ var maxWidth = radius * 1.6;+ var title = MakeText(CenterTitle ?? "", bold, 14, Foreground, maxWidth, maxLines: 2);+ var subtitle = MakeText(CenterSubtitle ?? "", regular, 11.5, cancelHot ? DangerBrush : SecondaryForeground, maxWidth, maxLines: 2);+ // "⟳ Tab back": small, under the rest, a little narrower (the hub is round), with room for its icons.+ var hintIcons = FlipArrowSize + (CenterHintWheel ? MouseWidth + MouseGap : 0) + IconGap;+ var hint = string.IsNullOrEmpty(CenterHint) ? null : MakeText(CenterHint, regular, 10.5, SecondaryForeground, maxWidth * 0.85 - hintIcons);+ var total = title.Height + (string.IsNullOrEmpty(CenterSubtitle) ? 0 : subtitle.Height + 2) + (hint is null ? 0 : hint.Height + 5);+ var y = center.Y - total / 2;+ DrawCentered(context, title, center.X, y);+ y += title.Height;+ if (!string.IsNullOrEmpty(CenterSubtitle))+ {+ DrawCentered(context, subtitle, center.X, y + 2);+ y += subtitle.Height + 2;+ }+ if (hint is not null)+ {+ using (context.PushOpacity(0.85))+ {+ // The flip arrow is drawn, not typed: a font without "↻" showed a box in its place (#554). A small mouse+ // comes first when the wheel flips and no key does. The icons stand at the start of the line: on its+ // left, or on its right in a right-to-left language, in reading order there too.+ var left = center.X - (hintIcons + hint.Width) / 2;+ var rtl = TextDirection == FlowDirection.RightToLeft;+ var textLeft = rtl ? left : left + hintIcons;+ var middle = y + 5 + hint.Height / 2;+ var x = rtl ? left + hint.Width + IconGap : left;+ var arrowFirst = rtl && CenterHintWheel;+ if (CenterHintWheel && !arrowFirst)+ {+ DrawMouse(context, new Rect(x, middle - 5, MouseWidth, 10), SecondaryForeground);+ x += MouseWidth + MouseGap;+ }+ DrawFlipArrow(context, new Point(x + FlipArrowSize / 2, middle), FlipArrowSize / 2, SecondaryForeground);+ x += FlipArrowSize + (arrowFirst ? MouseGap : IconGap);+ if (arrowFirst)+ DrawMouse(context, new Rect(x, middle - 5, MouseWidth, 10), SecondaryForeground);+ DrawCentered(context, hint, textLeft + hint.Width / 2, y + 5);+ }+ }+ }++ // The hub hint's icons: the flip arrow, the mouse (wheel only) and the room between them and before the text. The+ // arrow's head reaches a little past its circle towards the mouse, so that gap is wider.+ private const double FlipArrowSize = 9, MouseWidth = 7, IconGap = 4, MouseGap = 6;++ /// <summary>+ /// A small arrow turning clockwise round <paramref name="center"/>, the "flip" in the hub hint: most of a circle with+ /// its head at the end.+ /// </summary>+ internal static void DrawFlipArrow(DrawingContext context, Point center, double radius, IBrush? brush)+ {+ var pen = new Pen(brush, 1.2, lineCap: PenLineCap.Round, lineJoin: PenLineJoin.Round);+ // Angles in radians from 3 o'clock, growing clockwise on screen (y points down). From 1 o'clock almost round to+ // 11 o'clock, leaving a gap at the top where the head points into.+ const double start = -Math.PI / 3, sweep = Math.PI * 5 / 3;+ Point At(double angle) => new(center.X + radius * Math.Cos(angle), center.Y + radius * Math.Sin(angle));+ var end = start + sweep;+ var arc = new StreamGeometry();+ using (var g = arc.Open())+ {+ g.BeginFigure(At(start), false);+ g.ArcTo(At(end), new Size(radius, radius), 0, sweep > Math.PI, SweepDirection.Clockwise);+ g.EndFigure(false);+ }+ context.DrawGeometry(null, pen, arc);++ // The head: two strokes back from the end, along the circle's tangent there and either side of it.+ var tip = At(end);+ var along = new Vector(-Math.Sin(end), Math.Cos(end)); // clockwise+ var outward = new Vector(Math.Cos(end), Math.Sin(end));+ var head = radius * 0.75;+ var back = tip - along * head;+ context.DrawLine(pen, back + outward * head * 0.6, tip);+ context.DrawLine(pen, back - outward * head * 0.6, tip);+ }++ /// <summary>An outline of a mouse with its wheel, filling <paramref name="box"/>.</summary>+ private static void DrawMouse(DrawingContext context, Rect box, IBrush? brush)+ {+ var pen = new Pen(brush, 1.1);+ context.DrawRectangle(null, pen, box, box.Width / 2, box.Width / 2);+ context.DrawLine(pen, new Point(box.Center.X, box.Top + 2), new Point(box.Center.X, box.Top + 4.5));+ }++ private void DrawLabel(DrawingContext context, DonutItem item, Point center, double radius, double angle,+ double maxWidth, double maxHeight, Typeface bold, Typeface regular, bool hot)+ {+ var foreground = hot ? OnAccentBrush : item.IsEnabled ? Foreground : SecondaryForeground;+ var width = Math.Clamp(maxWidth, 30, 120);+ var text = KeepKoreanWords(item.Label);+ var label = MakeText(text, bold, LabelSize(text, bold, width), foreground, width, maxLines: 2);+ var showCaption = !string.IsNullOrEmpty(item.Caption) &&+ !string.Equals(item.Caption, item.Label, StringComparison.OrdinalIgnoreCase) &&+ label.Height + 14 < maxHeight;+ var caption = showCaption+ ? MakeCaption(item.Caption!, regular, hot ? OnAccentBrush : SecondaryForeground, width, label.Height, maxHeight)+ : null;++ var total = label.Height + (caption?.Height ?? 0);+ var anchor = DonutGeometry.PointAt(center, radius, angle);+ var y = anchor.Y - total / 2;+ DrawCentered(context, label, anchor.X, y);+ if (caption is not null)+ DrawCentered(context, caption, anchor.X, y + label.Height);+ }++ /// <summary>+ /// A slice's caption under its name: one line, or two where the slice is deep enough, so a caption wider than the+ /// slice ("Same format" on a small donut) wraps instead of ending in "Same for…".+ /// </summary>+ internal static FormattedText MakeCaption(string caption, Typeface typeface, IBrush? brush, double width,+ double labelHeight, double maxHeight) =>+ MakeText(caption, typeface, 10.5, brush, width, maxLines: labelHeight + 28 < maxHeight ? 2 : 1);++ private const double LabelFontSize = 13;+ private const double MinLabelFontSize = 10;+ private readonly Dictionary<(string Text, Typeface Typeface, double Width), double> _labelSizes = new();++ /// <summary>+ /// The size a slice's name is drawn at: 13, or smaller (down to 10) when one of its words is wider than the slice+ /// (<paramref name="width"/>), which would otherwise break in the middle ("Grayscal|e" on a thin slice). Words in+ /// Chinese or Japanese are left out: those break between any two characters.+ /// </summary>+ internal double LabelSize(string text, Typeface typeface, double width)+ {+ var line = Math.Round(width);+ var key = (text, typeface, line);+ if (_labelSizes.TryGetValue(key, out var size))+ return size;+ if (_labelSizes.Count >= MaxCachedWedges)+ _labelSizes.Clear();+ var widest = text.Split(' ', StringSplitOptions.RemoveEmptyEntries)+ .Where(word => !word.Any(IsHanOrKana))+ .Select(word => new FormattedText(word, CultureInfo.CurrentUICulture, TextDirection, typeface, LabelFontSize, null).Width)+ .DefaultIfEmpty(0)+ .Max();+ // A pixel to spare: a word exactly as wide as the line still wraps.+ size = widest < line ? LabelFontSize : Math.Max(MinLabelFontSize, LabelFontSize * (line - 1) / widest);+ return _labelSizes[key] = size;+ }++ /// <summary>Chinese characters, kana and the CJK symbols and full-width forms: a line may break between any two.</summary>+ private static bool IsHanOrKana(char c) =>+ c is >= '\u2E80' and <= '\u312F' or >= '\u3190' and <= '\u9FFF' or >= '\uF900' and <= '\uFAFF' or >= '\uFF00' and <= '\uFFEF';++ /// <summary>+ /// Korean is written with spaces between words and wraps there, but the text layout also breaks between any two+ /// Hangul syllables ("ZIP 하나|로"). A word joiner between them keeps each word on one line.+ /// </summary>+ internal static string KeepKoreanWords(string text)+ {+ if (!text.Any(IsHangul))+ return text;+ var kept = new System.Text.StringBuilder(text.Length * 2);+ for (var i = 0; i < text.Length; i++)+ {+ kept.Append(text[i]);+ if (i + 1 < text.Length && IsHangul(text[i]) && IsHangul(text[i + 1]))+ kept.Append('\u2060');+ }+ return kept.ToString();+ }++ private static bool IsHangul(char c) => c is >= '\uAC00' and <= '\uD7A3';++ private Point EditButtonCenter(int index)+ {+ var mid = DonutGeometry.MidAngle(index, Count);+ return DonutGeometry.PointAt(Center, OuterRadius - 14 + PopOut, mid);+ }++ private void DrawEditButton(DrawingContext context, Point at)+ {+ context.DrawEllipse(AccentBrush, new Pen(CenterBrush, 2), at, 12, 12);+ var bounds = PencilIcon.Bounds;+ var s = 13 / Math.Max(bounds.Width, bounds.Height);+ var matrix = Matrix.CreateTranslation(-bounds.Center.X, -bounds.Center.Y) * Matrix.CreateScale(s, s) * Matrix.CreateTranslation(at.X, at.Y);+ using (context.PushTransform(matrix))+ context.DrawGeometry(OnAccentBrush, null, PencilIcon);+ }++ /// <summary>+ /// Draws text horizontally centred on <paramref name="centerX"/>.+ /// The text is laid out with <see cref="TextAlignment.Center"/> inside a box of <see cref="FormattedText.MaxTextWidth"/>,+ /// so the box (not the measured <see cref="FormattedText.Width"/>) must be centred — otherwise short labels+ /// drift right by (box − text) / 2.+ /// </summary>+ internal static void DrawCentered(DrawingContext context, FormattedText text, double centerX, double top) =>+ context.DrawText(text, new Point(centerX - text.MaxTextWidth / 2, top));++ private Pen? BorderPen() => SliceBorderBrush is null ? null : new Pen(SliceBorderBrush, 1);++ private static FormattedText MakeText(string text, Typeface typeface, double size, IBrush? brush, double maxWidth, int maxLines = 1) =>+ new(text, CultureInfo.CurrentUICulture, TextDirection, typeface, size, brush)+ {+ MaxTextWidth = Math.Max(10, maxWidth),+ MaxLineCount = maxLines,+ Trimming = TextTrimming.CharacterEllipsis,+ TextAlignment = TextAlignment.Center,+ };++ private static FlowDirection TextDirection => CultureInfo.CurrentUICulture.TextInfo.IsRightToLeft+ ? FlowDirection.RightToLeft : FlowDirection.LeftToRight;++ private static IBrush? WithOpacity(IBrush? brush, double opacity) => brush switch+ {+ ISolidColorBrush solid => new SolidColorBrush(solid.Color, solid.Opacity * opacity),+ _ => brush,+ };++ private static double Distance(Point a, Point b) => Math.Sqrt(Math.Pow(a.X - b.X, 2) + Math.Pow(a.Y - b.Y, 2));++ /// <summary>The translucent slice where a dragged preset would land, with its name.</summary>+ private void DrawPreview(DrawingContext context, Point center, double r1, double r2, Typeface bold, Typeface regular)+ {+ var mid = _previewMid.Value;+ var span = _previewSpan.Value;+ var wedge = CreateWedge(center, r1, r2, mid, span);+ var outline = new Pen(WithOpacity(AccentBrush, 0.9), 1.5, new DashStyle([4, 3], 0));+ context.DrawGeometry(WithOpacity(AccentBrush, 0.22), outline, wedge);+ if (_previewLabel is null || span < 0.25)+ return;+ using (context.PushOpacity(Math.Clamp((span - 0.25) / 0.3, 0, 1) * 0.9))+ DrawLabel(context, new DonutItem { Id = "", Label = _previewLabel }, center, (r1 + r2) / 2, mid,+ span * (r1 + r2) / 2 - 10, r2 - r1 - 16, bold, regular, hot: false);+ }++ /// <summary>+ /// How round the slices' corners are: half the theme's softness (0 to 28), so the largest setting still leaves the+ /// slices clearly apart. <see cref="DonutGeometry.Wedge"/> shrinks it for slices too thin for it.+ /// </summary>+ internal double SliceCornerRadius => Math.Clamp(CornerRadius.TopLeft, 0, 28) * 0.5;++ private StreamGeometry CreateWedge(Point c, double r1, double r2, int index, int count) =>+ count == 1 ? CreateRing(c, r1, r2) : CreateWedge(c, r1, r2, DonutGeometry.MidAngle(index, count), DonutGeometry.Span(count));++ /// <summary>A rounded slice of <paramref name="span"/> radians centred on <paramref name="mid"/> (a ring when it is all of it).</summary>+ private StreamGeometry CreateWedge(Point c, double r1, double r2, double mid, double span) =>+ CreateWedge(c, r1, r2, mid, span, SliceCornerRadius);++ // Slices are drawn every frame while the donut animates, but their shapes only change with the size, the layout+ // or the softness: the shapes are kept and reused. Animations move them with transforms; only the edit mode's+ // sliding slices make new ones, and the cache starts over when it fills up.+ private readonly Dictionary<(Point C, double R1, double R2, double Mid, double Span, double Corner), StreamGeometry> _wedges = new();+ private const int MaxCachedWedges = 256;++ private StreamGeometry CreateWedge(Point c, double r1, double r2, double mid, double span, double cornerRadius)+ {+ var key = (c, r1, r2, mid, span, cornerRadius);+ if (_wedges.TryGetValue(key, out var cached))+ return cached;+ if (_wedges.Count >= MaxCachedWedges)+ _wedges.Clear();+ return _wedges[key] = BuildWedge(c, r1, r2, mid, span, cornerRadius);+ }++ /// <summary>A slice with a constant-width gap to its neighbours and corners rounded by <paramref name="cornerRadius"/>.</summary>+ private static StreamGeometry BuildWedge(Point c, double r1, double r2, double mid, double span, double cornerRadius)+ {+ if (span >= 2 * Math.PI - 0.001)+ return CreateRing(c, r1, r2);++ var outline = DonutGeometry.Wedge(c, r1, r2, mid, span, GapPixels, cornerRadius);+ var geometry = new StreamGeometry();+ using var ctx = geometry.Open();+ ctx.BeginFigure(outline.Start, true);+ foreach (var step in outline.Steps)+ {+ if (step.IsArc)+ ctx.ArcTo(step.To, new Size(step.ArcRadius, step.ArcRadius), 0, step.IsLargeArc,+ step.Clockwise ? SweepDirection.Clockwise : SweepDirection.CounterClockwise);+ else+ ctx.LineTo(step.To);+ }+ ctx.EndFigure(true);+ return geometry;+ }++ /// <summary>Full ring (used for a single slice and for the empty donut).</summary>+ private static StreamGeometry CreateRing(Point c, double r1, double r2)+ {+ var geometry = new StreamGeometry();+ using var ctx = geometry.Open();+ ctx.SetFillRule(FillRule.EvenOdd);+ foreach (var r in new[] { r2, r1 })+ {+ ctx.BeginFigure(new Point(c.X, c.Y - r), true);+ ctx.ArcTo(new Point(c.X, c.Y + r), new Size(r, r), 0, false, SweepDirection.Clockwise);+ ctx.ArcTo(new Point(c.X, c.Y - r), new Size(r, r), 0, false, SweepDirection.Clockwise);+ ctx.EndFigure(true);+ }+ return geometry;+ }+}diff --git a/RadialController.cs b/RadialController.csnew file mode 100644index 00000000..bfcd335b--- /dev/null+++ b/RadialController.cs@@ -0,0 +1,645 @@+// Opens, fills and closes the live donut toolbar.+//+// Drag mode (modifier + drag in Explorer):+// gesture detected → an invisible window waits at the cursor (not activated) → DragEnter brings the file list →+// the donut pops out → drop on a slice converts / drop in the hole or release elsewhere closes. Without files+// (text, a rubber-band selection) nothing ever shows.+// Files from a web browser (a picture, a link to a PDF) stand as placeholder paths named like the files will be, so the+// donut shows their slices at once; they are saved when the conversion starts (WebDrop, ConversionService).+// Click mode (keyboard shortcut, context menu, drop zone):+// files are known up front → donut appears activated → click a slice to convert, right-click to edit,+// Esc / click outside closes.+// The flip key (Tab) and the mouse wheel flip the open donut to its other face (DonutMenu.Flip.cs): in click mode the+// focused window gets them, in drag mode (no focus during an OS drag) the global hook reports them while the donut+// shows files.+// After a drop / click the donut becomes a progress ring at the same spot (DonutMenu.Progress.cs):+// finished quickly → ✓ pops up in the centre, then the ring fades out;+// still running after HandOffAfter, failed, Esc, click elsewhere or a new gesture → the toast takes over.++using System.ComponentModel;+using Avalonia;+using Avalonia.Threading;+using Filee.App.Controls;+using Filee.App.Services.Triggers;+using Filee.App.ViewModels;+using Filee.App.Views;+using Filee.Core.Conversion;+using Filee.Core.Platform;+using Filee.Core.Presets;+using Filee.Core.Profiles;+using Filee.Core.Settings;+using Filee.Core.Web;+using Microsoft.Extensions.Logging;++namespace Filee.App.Services;++public sealed class RadialController(+ RadialViewModel viewModel,+ ConversionService conversions,+ WindowService windows,+ UserDataStore store,+ IPlatformServices platform,+ TriggerService triggers,+ ILogger<RadialController> log)+{+ /// <summary>+ /// How long the ring shows a running job before the toast window takes over. Long enough for a typical office+ /// document (LibreOffice needs a few seconds), so the user sees it finish where they dropped it.+ /// </summary>+ private static readonly TimeSpan HandOffAfter = TimeSpan.FromSeconds(5);++ private RadialWindow? _window;+ private bool _visible;+ private bool _dropped;+ private bool _editing;+ private JobViewModel? _progressJob; // job currently shown by the ring (null once finished / handed off)+ private JobViewModel? _lastRingJob; // for "click the ✓ to open the folder"+ private IDisposable? _handOffTimer;+ private int _dragGeneration;+ private bool _dragReachedDonut;+ private bool _fileDragsAccepted;+ private readonly ActivationGrace _grace = new();++ /// <summary>A gesture over something that isn't a file drag (a rubber-band selection) is common: a line now and then.</summary>+ private static readonly LogThrottle Throttle = new(TimeSpan.FromMinutes(1));+ private bool _converted; // a conversion started from the files on the donut now+ private readonly HashSet<string> _formatRequestsOffered = new(StringComparer.OrdinalIgnoreCase);+ private WebDrop? _web; // the browser drop the click-mode donut's files stand for, until a conversion takes it++ /// <summary>+ /// How long a drag that never brought files may keep the invisible window up, in case the button release is+ /// missed (the system dropped the input hook, a UAC prompt took the desktop): the window catches clicks.+ /// </summary>+ private static readonly TimeSpan EmptyDragLimit = TimeSpan.FromSeconds(10);++ public bool IsVisible => _visible;++ internal RadialWindow? Window => _window;++ /// <summary>+ /// Drag gesture started at the given physical screen point. The window is placed under the cursor but stays+ /// invisible until files are dragged into it (FilesEntered); a gesture without files (text, a rubber-band+ /// selection, nothing at all) never shows anything and closes when the button is released.+ /// </summary>+ public void ShowForDrag(int x, int y)+ {+ ReleaseProgressToToast();+ _grace.Cancel();+ ReplaceWeb(null);+ var window = EnsureWindow();+ // A ring from an earlier conversion (finished or handed to the toast) must not keep this gesture's window up.+ window.DonutControl.LeaveProgressMode();+ _dropped = false;+ _dragReachedDonut = false;+ _converted = false;+ viewModel.ResetForDrag();+ window.DonutControl.AllowContextEdit = false;+ PlaceAndShow(window, x, y, activate: false);+ WatchFlipKey();++ var generation = ++_dragGeneration;+ DispatcherTimer.RunOnce(() =>+ {+ if (generation == _dragGeneration && _visible && !viewModel.HasFiles && !viewModel.IsClickMode)+ Close(animate: false);+ }, EmptyDragLimit);+ }++ /// <summary>+ /// Opens the donut for known files (click mode). Shortcuts among them stand for the files they point to.+ /// <paramref name="forAnotherProcess"/>: the files came from a later launch or the Services menu, so on macOS the+ /// donut may lose focus once while Filee becomes the active app. <paramref name="web"/>: the files are placeholders+ /// of this browser drop (the drop zone), which the donut now owns.+ /// </summary>+ public void ShowForFiles(int x, int y, IReadOnlyList<string> files, bool forAnotherProcess = false, WebDrop? web = null)+ {+ if (web is null)+ files = platform.ResolveShortcuts(files);+ if (files.Count == 0)+ {+ web?.Dispose();+ return;+ }+ ReleaseProgressToToast();+ ReplaceWeb(web);+ if (forAnotherProcess && OperatingSystem.IsMacOS())+ _grace.Start();+ else+ _grace.Cancel();+ var window = EnsureWindow();+ _dropped = false;+ _converted = false;+ viewModel.Load(files, clickMode: true);+ viewModel.FitToThisDonut();+ window.DonutControl.AllowContextEdit = true;+ PlaceAndShow(window, x, y, activate: true);+ WatchFlipKey();+ window.DonutControl.PlayOpenAnimation();+ }++ /// <summary>The mouse button of the drag gesture was released somewhere.</summary>+ public void OnDragGestureEnded()+ {+ if (!_visible || viewModel.IsClickMode)+ return;+ // No drag ever entered the donut's window: nothing was dragged (a rubber-band selection), or Windows kept+ // Explorer's drag out (Filee runs as administrator). Tells "the donut didn't react" reports apart.+ if (!_dragReachedDonut && Throttle.TryEnter("no-drag-enter", out var held))+ log.LogInformation("Drag gesture ended without a drag entering the donut{Elevation}{Held}",+ Program.Elevation.ShellCannotReachFilee ? " (Filee runs as administrator: Windows blocks drops from Explorer)" : "",+ LogThrottle.HeldText(held));+ // Nothing was brought to the donut: the window is invisible but catches clicks, so go right away.+ if (!viewModel.HasFiles && !_window!.DonutControl.IsInProgressMode)+ {+ Close(animate: false);+ return;+ }+ // A drop on the donut arrives around the same time as the button release; give it a moment.+ DispatcherTimer.RunOnce(() =>+ {+ if (_visible && !_dropped && !viewModel.IsClickMode)+ Close(animate: true);+ }, TimeSpan.FromMilliseconds(250));+ }++ public void Close(bool animate = true)+ {+ if (!_visible || _window is null)+ return;+ if (_window.DonutControl.IsInProgressMode)+ {+ // Esc / click elsewhere while the ring is showing: let the toast carry on (a finishing ✓ just fades).+ if (_progressJob is not null)+ {+ HandOffToToast();+ return;+ }+ if (_window.DonutControl.IsFinishingProgress)+ return;+ // A ring left over after it finished: nothing is showing any more, so close like any donut.+ _window.DonutControl.LeaveProgressMode();+ }+ _visible = false;+ WatchFlipKey();+ _grace.Cancel();+ ReplaceWeb(null);+ var window = _window;+ // A group about to open (its dwell timer running) must not open on a closing donut.+ window.DonutControl.CollapseGroup();+ if (animate)+ window.DonutControl.PlayCloseAnimation(() =>+ {+ if (!_visible)+ window.Hide();+ });+ else+ window.Hide();+ OfferFormatRequest();+ }++ /// <summary>+ /// The donut closed on files Filee can't read at all (".ncm"): offer to request the format, once per extension+ /// while Filee runs. Files it reads, even mixed with unknown ones, get a conversion and the toast instead.+ /// </summary>+ private void OfferFormatRequest()+ {+ if (_converted || viewModel.Files.Count == 0 || ProfileSelector.DetectFormats(viewModel.Files).Count > 0)+ return;+ var extensions = FormatRequest.UnknownExtensions(viewModel.Files).Where(_formatRequestsOffered.Add).ToList();+ if (extensions.Count == 0)+ return;+ log.LogInformation("Donut closed on files Filee can't read: {Extensions}", FormatRequest.Label(extensions));+ windows.ShowFormatRequestNotice(extensions);+ }++ private RadialWindow EnsureWindow()+ {+ if (_window is not null)+ return _window;++ var window = new RadialWindow { DataContext = viewModel };+ var donut = window.DonutControl;++ // On native Wayland, hiding an xdg_toplevel surface causes the compositor to destroy its surface,+ // and re-showing raises an InvalidOperationException. Track Closed to re-create on the next gesture.+ if (Filee.Platform.Linux.WaylandSupport.NativeWaylandRequested)+ {+ window.Closed += (_, _) =>+ {+ if (ReferenceEquals(_window, window))+ _window = null;+ };+ }++ window.DragEntered += () => _dragReachedDonut = true;+ // Tells "the drag reached the donut but brought no files" apart, with what it brought (file promises, say).+ window.DragWithoutFiles += formats =>+ {+ if (Throttle.TryEnter("drag-without-files", out var held))+ log.LogInformation("A drag without files Filee reads entered the donut; it offered: {Formats}{Held}",+ formats, LogThrottle.HeldText(held));+ };+ window.FilesEntered += files =>+ {+ if (viewModel.IsClickMode || SameFiles(files, viewModel.Files) || SameWebFiles(files, viewModel.Files))+ return;+ viewModel.Load(files, clickMode: false);+ donut.PlayOpenAnimation();+ WatchFlipKey();+ };+ window.Dropped += (hit, dropped) =>+ {+ _dropped = true;+ WatchFlipKey();+ if (hit.Kind is DonutHitKind.Segment or DonutHitKind.SubSegment)+ {+ Convert(hit.Index, hit.Sub, dropped.Files.Count > 0 ? dropped.Files : viewModel.Files, dropped.Web);+ }+ else+ {+ dropped.Web?.Dispose();+ Close();+ }+ };+ // One line per drag, to tell "the drag never reached the donut" from "it did but nothing lit up" when someone+ // reports a donut that doesn't react.+ window.DragSummary += (events, hit, lit) =>+ log.LogInformation("Drag over the donut: {Events} move event(s), ended on {Kind} {Index}, drawn lit {Lit:0.00}",+ events, hit.Kind, hit.Index, lit);+ window.EscapePressed += () => Close();+ window.Deactivated += (_, _) =>+ {+ if (!viewModel.IsClickMode || _editing)+ return;+ if (_grace.Forgives())+ {+ log.LogInformation("The donut lost focus as it opened for another app's request; it stays open");+ Dispatcher.UIThread.Post(() =>+ {+ if (_visible && viewModel.IsClickMode && !window.IsActive)+ window.Activate();+ });+ return;+ }+ Close();+ };++ donut.ActiveIndexChanged += (_, index) => viewModel.ShowHint(index, donut.ActiveSubIndex, donut.IsCenterHot);+ // Drag mode: the flip key and the wheel seen by the global hook (click mode gets them in the focused window).+ triggers.FlipKeyPressed += (_, _) =>+ {+ if (FlipsFromHook)+ donut.Flip();+ };+ triggers.FlipWheelTurned += (_, _) =>+ {+ if (FlipsFromHook)+ donut.FlipFromWheel(Environment.TickCount64);+ };+ donut.SegmentInvoked += (_, index) => Convert(index, -1, viewModel.Files, TakeWeb());+ donut.SubSegmentInvoked += (_, hit) => Convert(hit.Group, hit.Sub, viewModel.Files, TakeWeb());+ donut.CenterInvoked += (_, _) => Close();+ donut.SegmentContextRequested += async (_, index) => await EditPresetAsync(index);+ donut.SubSegmentContextRequested += async (_, hit) => await EditPresetAsync(hit.Group, hit.Sub);+ donut.ProgressCancelRequested += (_, _) => _progressJob?.CancelCommand.Execute(null);+ donut.ProgressClicked += (_, _) =>+ {+ if (_lastRingJob is { HasOutputs: true } job)+ job.OpenFolderCommand.Execute(null);+ };++ _window = window;+ return window;+ }++ /// <summary>+ /// Converts with slice <paramref name="index"/>, or with slice <paramref name="sub"/> of that group's ring.+ /// <paramref name="web"/>: the browser drop the files stand for, handed to the conversion (or disposed).+ /// </summary>+ private void Convert(int index, int sub, IReadOnlyList<string> files, WebDrop? web = null)+ {+ // Placeholders whose drop is gone (the drag listed files it didn't hand over in the end) can't be converted.+ var orphaned = web is null && files.Any(WebDrop.IsPlaceholder);+ if (viewModel.PresetAt(index, sub) is not { } preset || SourcesFor(preset, files) is not { Count: > 0 } sources || orphaned)+ {+ web?.Dispose();+ Close();+ return;+ }++ if (preset.IsTool)+ {+ var near = _window?.Position;+ Close(animate: false);+ if (web is null)+ windows.ShowTool(sources, preset, near);+ else+ _ = ShowToolForBrowserFilesAsync(web, preset, near);+ return;+ }++ // Merged PDFs, joined clips, slideshows and merged pictures follow the order the user picks.+ if ((preset.TargetFormat == "pdf" && preset.Pdf.MergeIntoSingle || preset.JoinsIntoOneMedia || preset.JoinsImages) && sources.Count > 1)+ {+ Close(animate: false);+ _ = MergeInOrderAsync(sources, preset.Clone(), web);+ return;+ }++ // "Ask every time" (#521): the save dialog first; the toast shows the job, the donut has closed for the dialog.+ // shortcut: files from a browser aren't asked about, they save into the download folder as "next to the source".+ if (preset.Output.AskEveryTime && web is null)+ {+ Close(animate: false);+ _ = AskThenConvertAsync(sources, preset);+ return;+ }++ log.LogInformation("Converting {Count} file(s) with preset {Preset}{Web}", sources.Count, preset.Id,+ web is null ? "" : " (from a browser)");+ var job = conversions.Start(sources, preset, showInToast: false, web);+ if (job is null || _window is null)+ {+ Close();+ return;+ }+ _converted = true;+ ShowProgress(job);+ }++ private async Task MergeInOrderAsync(IReadOnlyList<string> files, Preset preset, WebDrop? web)+ {+ try+ {+ var ordered = await windows.ChooseMergeOrderAsync(files, preset);+ if (ordered is not null && preset.JoinsImages)+ RememberMergeLayout(preset);+ if (ordered is not null && preset.Output.AskEveryTime && web is null)+ await AskThenConvertAsync(ordered, preset);+ else if (ordered is not null)+ {+ conversions.Start(ordered, preset, web: web);+ web = null; // the conversion owns the browser drop now+ }+ }+ catch (Exception ex) when (ex is not OutOfMemoryException)+ {+ log.LogError(ex, "Could not start the ordered merge");+ }+ finally+ {+ web?.Dispose();+ }+ }++ /// <summary>+ /// "Merge images": the layout chosen in the merge order window (<paramref name="chosen"/>, a copy of the preset)+ /// goes into the preset as saved, so the window opens with it next time.+ /// </summary>+ private void RememberMergeLayout(Preset chosen)+ {+ if (store.FindPreset(chosen.Id) is not { JoinsImages: true } saved)+ return;+ var image = saved.Image;+ if (image.JoinDirection == chosen.Image.JoinDirection && image.JoinFit == chosen.Image.JoinFit+ && image.JoinGap == chosen.Image.JoinGap && image.JoinBackground == chosen.Image.JoinBackground)+ return;+ image.JoinDirection = chosen.Image.JoinDirection;+ image.JoinFit = chosen.Image.JoinFit;+ image.JoinGap = chosen.Image.JoinGap;+ image.JoinBackground = chosen.Image.JoinBackground;+ try+ {+ store.SaveLibrary();+ }+ catch (Exception ex) when (ex is IOException or UnauthorizedAccessException)+ {+ log.LogWarning(ex, "Could not remember the layout of merged pictures");+ }+ }++ private async Task AskThenConvertAsync(IReadOnlyList<string> sources, Preset preset)+ {+ try+ {+ // Asked as it will run (a ZIP from Settings › General is a .zip), for one file or a folder as the job makes them.+ var running = store.Settings.WithDefaultOutput(preset);+ if (await windows.AskSaveLocationAsync(sources, running, AskedLocation.MakesOneResult(running, sources.Count)) is { } asked)+ {+ log.LogInformation("Converting {Count} file(s) with preset {Preset} where the user chose", sources.Count, preset.Id);+ conversions.Start(sources, asked);+ }+ }+ catch (Exception ex) when (ex is not OutOfMemoryException)+ {+ log.LogError(ex, "Could not ask where to save");+ }+ }++ /// <summary>A tool (crop, clip) on files from a browser: they are saved first, then it opens on them.</summary>+ private async Task ShowToolForBrowserFilesAsync(WebDrop web, Filee.Core.Presets.Preset preset, PixelPoint? near)+ {+ var files = await conversions.SaveBrowserFilesAsync(web, (placeholder, ex) =>+ log.LogWarning(ex, "Saving {File} from a browser for {Preset} failed", Path.GetFileName(placeholder), preset.Id));+ if (files.Count > 0)+ windows.ShowTool(files, preset, near);+ }++ /// <summary>+ /// What <paramref name="preset"/> converts of <paramref name="files"/>: folders only go into "Compress into one+ /// archive"; any other preset converts the files beside them (issue #186).+ /// </summary>+ internal static IReadOnlyList<string> SourcesFor(Preset preset, IReadOnlyList<string> files) =>+ preset.PacksIntoOneArchive ? files : [.. files.Where(path => !Directory.Exists(path))];++ // ───────── Progress ring ─────────++ private void ShowProgress(JobViewModel job)+ {+ var donut = _window!.DonutControl;+ _dropped = true;+ _progressJob = job;+ viewModel.ProgressJob = job;+ _lastRingJob = job;+ donut.BeginProgress();+ donut.SetProgress(job.Progress / 100);+ job.PropertyChanged += OnProgressJobChanged;+ _handOffTimer = DispatcherTimer.RunOnce(() =>+ {+ if (_progressJob == job && job.IsRunning)+ HandOffToToast();+ }, HandOffAfter);+ }++ private void OnProgressJobChanged(object? sender, PropertyChangedEventArgs e)+ {+ if (sender is not JobViewModel job || job != _progressJob || _window is null)+ return;+ var donut = _window.DonutControl;+ donut.SetProgress(job.Progress / 100);+ if (job.IsRunning || e.PropertyName != nameof(JobViewModel.IsRunning))+ return;++ var outcome = job.Job.State switch+ {+ JobState.Completed => DonutProgressOutcome.Succeeded,+ JobState.Cancelled => DonutProgressOutcome.Cancelled,+ _ => DonutProgressOutcome.Failed,+ };+ if (outcome == DonutProgressOutcome.Failed)+ conversions.ShowInToast(job); // the toast explains what went wrong+ DetachProgress();+ donut.CompleteProgress(outcome, HideWindow);+ }++ /// <summary>Hands the running job to the toast with a short "shrink away" of the ring.</summary>+ private void HandOffToToast()+ {+ if (_progressJob is null || _window is null)+ return;+ conversions.ShowInToast(_progressJob);+ DetachProgress();+ _window.DonutControl.HandOffProgress(HideWindow);+ }++ /// <summary>A new gesture needs the window right now: move the job to the toast without animation.</summary>+ private void ReleaseProgressToToast()+ {+ if (_progressJob is not null)+ conversions.ShowInToast(_progressJob);+ DetachProgress();+ }++ private void DetachProgress()+ {+ _handOffTimer?.Dispose();+ _handOffTimer = null;+ if (_progressJob is not null)+ _progressJob.PropertyChanged -= OnProgressJobChanged;+ _progressJob = null;+ viewModel.ProgressJob = null;+ }++ private void HideWindow()+ {+ _visible = false;+ WatchFlipKey();+ _window?.DonutControl.CollapseGroup();+ _window?.Hide();+ }++ /// <summary>Edits the preset of slice <paramref name="index"/>, or of slice <paramref name="sub"/> of its group's ring.</summary>+ private async Task EditPresetAsync(int index, int sub = -1)+ {+ if (_window is null || viewModel.PresetShownAt(index, sub) is not { } preset)+ return;+ _editing = true;+ try+ {+ if (await windows.EditPresetAsync(preset, _window))+ {+ store.SaveLibrary();+ viewModel.Load(viewModel.Files, viewModel.IsClickMode, viewModel.IsBackFace);+ }+ }+ finally+ {+ _editing = false;+ }+ if (_visible)+ _window.Activate();+ }++ /// <summary>+ /// Has the global hook report the flip key and the wheel only while a drag-mode donut shows files that could flip;+ /// they are left alone otherwise (see <see cref="TriggerService.WatchFlipKey"/>).+ /// </summary>+ private void WatchFlipKey()+ {+ triggers.WatchFlipKey = FlipsFromHook;+ // One source per press: the hook in drag mode, the window in click mode (#504).+ if (_window is not null)+ _window.DonutControl.FlipKeyFromHook = FlipsFromHook;+ }++ /// <summary>A drag-mode donut shows files and nothing was dropped yet: the hook's flip key and wheel flip it.</summary>+ private bool FlipsFromHook => _visible && !_dropped && !viewModel.IsClickMode && viewModel.HasFiles;++ /// <summary>+ /// Top-left corner of a <paramref name="sidePx"/> square window centred on <paramref name="cursor"/>, moved into+ /// <paramref name="area"/> when that would cross its edge. With group slices the window holds the ring they fan out+ /// (<see cref="DonutMenu.SideFor"/>), so near a screen edge the donut moves in far enough for every ring to fit.+ /// </summary>+ internal static PixelPoint WindowPosition(PixelPoint cursor, PixelRect? area, int sidePx)+ {+ var position = new PixelPoint(cursor.X - sidePx / 2, cursor.Y - sidePx / 2);+ if (area is not { } a)+ return position;+ return new PixelPoint(+ Math.Clamp(position.X, a.X, Math.Max(a.X, a.Right - sidePx)),+ Math.Clamp(position.Y, a.Y, Math.Max(a.Y, a.Bottom - sidePx)));+ }++ private void PlaceAndShow(RadialWindow window, int x, int y, bool activate)+ {+ var cursor = new PixelPoint(x, y);+ var screen = window.Screens.ScreenFromPoint(cursor) ?? window.Screens.Primary;+ var scaling = OperatingSystem.IsMacOS() ? 1 : screen?.Scaling ?? 1;++ // Window size follows the donut size (SizeToContent); compute it up front to centre on the cursor.+ var side = DonutMenu.SideFor(viewModel.OuterRadius, viewModel.ReserveSubRing);+ var sidePx = (int)Math.Ceiling(side * scaling);+ var position = WindowPosition(cursor, screen?.WorkingArea, sidePx);++ Motion.Refresh();+ window.Position = position;+ if (!window.IsVisible)+ window.Show();+ window.Position = position; // again, in case showing changed the DPI scale+ // Showing a window that is already marked topmost does not move it in the z-order, and Windows can push it+ // below normal windows while it keeps the mark (after the Photos app opened, for one). Then Explorer stays on+ // top of the donut and the drop never reaches it, so put it back on top every time.+ if (window.TryGetPlatformHandle()?.Handle is { } handle)+ {+ platform.RaiseTopmost(handle);+ if (!_fileDragsAccepted && OperatingSystem.IsMacOS() && platform is Filee.Platform.MacOS.MacOSPlatformServices mac)+ {+ mac.AcceptFileDrags(handle);+ _fileDragsAccepted = true;+ }+ }+ _visible = true;+ if (activate)+ {+ window.Activate();+ // ShowActivated is false because the same window is also used during an OS drag, where taking focus would+ // break Explorer's drag. Click mode is different: the donut owns the keyboard until it closes, so focus it+ // explicitly for Tab/arrow/Enter handling.+ window.DonutControl.Focus();+ }+ }++ private static bool SameFiles(IReadOnlyList<string> a, IReadOnlyList<string> b) =>+ a.Count == b.Count && a.SequenceEqual(b, FileSystemPaths.Comparer);++ /// <summary>The same browser files dragged in again: each entry makes new placeholders, with the same names.</summary>+ private static bool SameWebFiles(IReadOnlyList<string> a, IReadOnlyList<string> b) =>+ a.Count == b.Count && a.All(WebDrop.IsPlaceholder) && b.All(WebDrop.IsPlaceholder)+ && a.Select(Path.GetFileName).SequenceEqual(b.Select(Path.GetFileName), StringComparer.Ordinal);++ /// <summary>Hands the click-mode donut's browser drop to a conversion.</summary>+ private WebDrop? TakeWeb()+ {+ var web = _web;+ _web = null;+ return web;+ }++ /// <summary>The click-mode donut now stands for <paramref name="web"/>'s files (or local ones): the old drop is done.</summary>+ private void ReplaceWeb(WebDrop? web)+ {+ if (!ReferenceEquals(_web, web))+ _web?.Dispose();+ _web = web;+ }+}diff --git a/RadialControllerTests.cs b/RadialControllerTests.csnew file mode 100644index 00000000..ede1551c--- /dev/null+++ b/RadialControllerTests.cs@@ -0,0 +1,103 @@+// The drag-wait donut is an invisible, topmost window that catches clicks so a drag can reach it: it must close when+// the gesture ends without files, even after a conversion left the ring behind (issue: desktop icons stopped reacting+// to clicks until Filee quit).++using Avalonia.Headless;+using Avalonia.Headless.XUnit;+using Avalonia.Input;+using Filee.App.Controls;+using Filee.App.Services;+using Filee.Core.Presets;++namespace Filee.App.Tests;++public class RadialControllerTests+{+ /// <summary>A conversion ran through the donut and its ring finished: progress mode stays on, nothing is pending.</summary>+ private static void FinishARing(DonutMenu donut)+ {+ donut.BeginProgress();+ Motion.Set(false);+ try+ {+ donut.HandOffProgress(() => { });+ }+ finally+ {+ Motion.Set(true);+ }+ Assert.True(donut.IsInProgressMode);+ Assert.False(donut.IsFinishingProgress);+ }++ [AvaloniaFact]+ public void A_drag_without_files_after_a_conversion_closes_the_invisible_window()+ {+ TestServices.EnsureInitialized("en");+ var radial = AppHost.Get<RadialController>();+ radial.ShowForDrag(400, 400);+ FinishARing(radial.Window!.DonutControl);++ // A later Ctrl+drag that brings no files: a rubber-band selection on the desktop, a folder.+ radial.ShowForDrag(600, 500);+ Assert.False(radial.Window.DonutControl.IsInProgressMode);+ radial.OnDragGestureEnded();++ Assert.False(radial.IsVisible);+ Assert.False(radial.Window.IsVisible);+ }++ [AvaloniaFact]+ public void Esc_closes_a_donut_whose_ring_already_finished()+ {+ TestServices.EnsureInitialized("en");+ var radial = AppHost.Get<RadialController>();+ radial.ShowForDrag(400, 400);+ FinishARing(radial.Window!.DonutControl);++ radial.Close(animate: false);++ Assert.False(radial.IsVisible);+ Assert.False(radial.Window.IsVisible);+ }++ [AvaloniaFact]+ public void Click_mode_focuses_the_donut_for_tab_flip()+ {+ TestServices.EnsureInitialized("en");+ var radial = AppHost.Get<RadialController>();+ try+ {+ radial.ShowForFiles(400, 400, [@"C:\photos\a.jpg"]);+ var window = radial.Window!;++ Assert.True(window.DonutControl.IsFocused);+ window.KeyPress(Key.Tab, RawInputModifiers.None, PhysicalKey.Tab, null);+ Assert.True(AppHost.Get<Filee.App.ViewModels.RadialViewModel>().IsBackFace);+ }+ finally+ {+ radial.Close(animate: false);+ }+ }++ [Fact]+ public void Folders_only_go_into_one_archive()+ {+ var folder = Directory.CreateTempSubdirectory("filee-donut-folder-").FullName;+ try+ {+ var file = Path.Combine(folder, "1.png");+ var zip = new Preset { TargetFormat = "zip", Archive = { CombineIntoOne = true } };++ // Issue #186: a dragged folder goes into "Compress into one archive"; other presets take only the files.+ Assert.Equal([folder, file], RadialController.SourcesFor(zip, [folder, file]));+ Assert.Equal([file], RadialController.SourcesFor(new Preset { TargetFormat = "jpg" }, [folder, file]));+ Assert.Empty(RadialController.SourcesFor(new Preset { TargetFormat = "zip" }, [folder]));+ }+ finally+ {+ Directory.Delete(folder, recursive: true);+ }+ }+}