Add seek-bar event markers and a compact single-row control bar (#42)

* Add seek-bar event markers and a compact single-row control bar

Surface the event.json metadata that was previously unused and tighten the
playback chrome so the video gets more room.

- Event marker: a reason-colored tick on the seek bar at the moment the
  incident happened (Sentry/Honk events land near the clip end), with a hover
  tooltip. Jump to it via a flag button or the E key.
- Faint chunk-boundary ticks along the scrubber for at-a-glance structure.
- Collapse the two-row controls into one row (transport / jump / scrubber /
  time / speed) and trim the camera-tile bar, giving the video ~75px more height.
- "Select a clip to begin" hint replaces the blank idle panel.

Adds SeekOffsetConverter and VM state (EventMarkerPosition, HasEventMarker,
ChunkBoundaries, EventMarkerTooltip, JumpToEvent command) computed from the
existing clip data, with unit tests. No data-model or Flyleaf changes.

* Fix crash when hovering the scrubber

The thumb's grow-on-hover storyboard (in the Slider ControlTemplate.Triggers)
targeted ThumbScale by name, but ThumbScale lived inside the nested Thumb
template's name scope, so IsMouseOver threw InvalidOperationException:
"'ThumbScale' name cannot be found in the name scope of ControlTemplate".
Move the ScaleTransform onto the named Thumb element itself so it shares the
Slider template's name scope. Pre-existing since the #41 redesign.

Author: danielchalmers

SentryReplay.Tests/ConverterTests.cs

@@ -24,4 +24,37 @@ public void BoolToVisibilityConverter_CollapsesNonBooleanValues()
         converter.Convert(null, typeof(Visibility), null, null).ShouldBe(Visibility.Collapsed);
         converter.Convert("true", typeof(Visibility), null, null).ShouldBe(Visibility.Collapsed);
     }
+
+    [Fact]
+    public void SeekOffsetConverter_ReturnsLeftOffsetOfFractionTimesWidth()
+    {
+        var converter = new SeekOffsetConverter();
+
+        var result = (Thickness)converter.Convert([0.5, 200d], typeof(Thickness), null, null);
+
+        result.Left.ShouldBe(100);
+        result.Top.ShouldBe(0);
+    }
+
+    [Theory]
+    [InlineData(1.5, 200, 200)] // clamps above 1
+    [InlineData(-0.5, 200, 0)]  // clamps below 0
+    public void SeekOffsetConverter_ClampsFraction(double fraction, double width, double expectedLeft)
+    {
+        var converter = new SeekOffsetConverter();
+
+        var result = (Thickness)converter.Convert([fraction, width], typeof(Thickness), null, null);
+
+        result.Left.ShouldBe(expectedLeft);
+    }
+
+    [Fact]
+    public void SeekOffsetConverter_ZeroWidthYieldsZeroOffset()
+    {
+        var converter = new SeekOffsetConverter();
+
+        var result = (Thickness)converter.Convert([0.5, 0d], typeof(Thickness), null, null);
+
+        result.ShouldBe(new Thickness(0));
+    }
 }

SentryReplay.Tests/MainWindowViewModelTests.cs

@@ -16,6 +16,26 @@ private static CamClip ClipWithEvent(string name, string reason, string city, de
             [],
             new CamEvent { Reason = reason, City = city, EstLat = lat, EstLon = lon });
 
+    // A clip of one-minute chunks with an event at the given offset from the first chunk.
+    private static CamClip ClipWithChunksAndEvent(int chunkCount, TimeSpan eventOffset, string reason = "user_interaction_honk")
+    {
+        var start = new DateTime(2025, 1, 1, 12, 0, 0);
+        var chunks = Enumerable.Range(0, chunkCount)
+            .Select(i => new CamChunk(start.AddMinutes(i), []))
+            .ToList();
+        var camEvent = new CamEvent { Reason = reason, Timestamp = start + eventOffset };
+        return new CamClip(System.IO.Path.GetTempPath(), "Event Clip", start, chunks, camEvent);
+    }
+
+    private static CamClip ClipWithChunks(int chunkCount)
+    {
+        var start = new DateTime(2025, 1, 1, 12, 0, 0);
+        var chunks = Enumerable.Range(0, chunkCount)
+            .Select(i => new CamChunk(start.AddMinutes(i), []))
+            .ToList();
+        return new CamClip(System.IO.Path.GetTempPath(), "Chunked Clip", start, chunks, camEvent: null);
+    }
+
     [Fact]
     public void NewViewModel_DefaultsToFrontCamera_AndEmptyOverlay()
     {
@@ -404,6 +424,175 @@ public async Task FilteredClips_NoMatch_IsEmpty()
         vm.FilteredClips.ShouldBeEmpty();
     }
 
+    // --- Event marker: the moment the incident happened, mapped onto the 0..1 seek axis ---
+
+    [Fact]
+    public void EventMarker_NearClipEnd_MapsToHighFraction()
+    {
+        var vm = CreateViewModel();
+
+        // 10 one-minute chunks (600s modeled); event at 9m30s in -> 0.95.
+        vm.SelectedClip = ClipWithChunksAndEvent(10, TimeSpan.FromSeconds(570));
+
+        vm.HasEventMarker.ShouldBeTrue();
+        vm.EventMarkerPosition.ShouldBe(0.95, 0.0001);
+        vm.EventMarkerTooltip.ShouldStartWith("Honk · ");
+    }
+
+    [Fact]
+    public void EventMarker_AbsentWithoutEvent()
+    {
+        var vm = CreateViewModel();
+
+        vm.SelectedClip = ClipWithChunks(3);
+
+        vm.HasEventMarker.ShouldBeFalse();
+        vm.EventMarkerPosition.ShouldBe(0);
+        vm.EventMarkerTooltip.ShouldBeEmpty();
+    }
+
+    [Fact]
+    public void EventMarker_AbsentWhenEventTimestampIsDefault()
+    {
+        var vm = CreateViewModel();
+        var chunks = ClipWithChunks(3).Chunks;
+        var camEvent = new CamEvent { Reason = "user_interaction_honk" }; // Timestamp == default
+
+        vm.SelectedClip = new CamClip(System.IO.Path.GetTempPath(), "Default TS", new DateTime(2025, 1, 1, 12, 0, 0), chunks, camEvent);
+
+        vm.HasEventMarker.ShouldBeFalse();
+    }
+
+    [Fact]
+    public void EventMarker_AbsentWhenEventBeforeClipStart()
+    {
+        var vm = CreateViewModel();
+
+        // Clock skew: event five minutes before the first chunk -> fraction <= 0, no marker.
+        vm.SelectedClip = ClipWithChunksAndEvent(10, TimeSpan.FromMinutes(-5));
+
+        vm.HasEventMarker.ShouldBeFalse();
+    }
+
+    [Fact]
+    public void EventMarker_AbsentWhenEventBeyondModeledDuration()
+    {
+        var vm = CreateViewModel();
+
+        // 3 chunks = 180s modeled; an event at 200s is past the estimated end (fraction > 1).
+        vm.SelectedClip = ClipWithChunksAndEvent(3, TimeSpan.FromSeconds(200));
+
+        vm.HasEventMarker.ShouldBeFalse();
+    }
+
+    [Fact]
+    public void EventMarker_AbsentWhenNoChunks_NoDivideByZero()
+    {
+        var vm = CreateViewModel();
+        var camEvent = new CamEvent { Reason = "user_interaction_honk", Timestamp = new DateTime(2025, 1, 1, 12, 5, 0) };
+
+        vm.SelectedClip = new CamClip(System.IO.Path.GetTempPath(), "No Chunks", new DateTime(2025, 1, 1, 12, 0, 0), [], camEvent);
+
+        vm.HasEventMarker.ShouldBeFalse();
+        vm.EventMarkerPosition.ShouldBe(0);
+        vm.ChunkBoundaries.ShouldBeEmpty();
+    }
+
+    [Fact]
+    public void ChunkBoundaries_AreInteriorFractions()
+    {
+        var vm = CreateViewModel();
+
+        vm.SelectedClip = ClipWithChunks(3);
+
+        vm.ChunkBoundaries.Count.ShouldBe(2);
+        vm.ChunkBoundaries[0].ShouldBe(1.0 / 3, 0.0001);
+        vm.ChunkBoundaries[1].ShouldBe(2.0 / 3, 0.0001);
+    }
+
+    [Fact]
+    public void ChunkBoundaries_EmptyForSingleChunk()
+    {
+        var vm = CreateViewModel();
+
+        vm.SelectedClip = ClipWithChunks(1);
+
+        vm.ChunkBoundaries.ShouldBeEmpty();
+    }
+
+    [Fact]
+    public void ClearingSelection_ResetsEventMarkerAndChunks()
+    {
+        var vm = CreateViewModel();
+        vm.SelectedClip = ClipWithChunksAndEvent(10, TimeSpan.FromSeconds(570));
+        vm.HasEventMarker.ShouldBeTrue();
+
+        vm.SelectedClip = null;
+
+        vm.HasEventMarker.ShouldBeFalse();
+        vm.EventMarkerPosition.ShouldBe(0);
+        vm.ChunkBoundaries.ShouldBeEmpty();
+    }
+
+    [Fact]
+    public void JumpToEvent_CanExecute_FollowsHasEventMarker()
+    {
+        var vm = CreateViewModel();
+        vm.JumpToEventCommand.CanExecute(null).ShouldBeFalse();
+
+        vm.SelectedClip = ClipWithChunksAndEvent(10, TimeSpan.FromSeconds(570));
+
+        vm.JumpToEventCommand.CanExecute(null).ShouldBeTrue();
+    }
+
+    [Fact]
+    public async Task JumpToEvent_MovesSeekPositionToMarker()
+    {
+        var vm = CreateViewModel();
+        vm.SelectedClip = ClipWithChunksAndEvent(10, TimeSpan.FromSeconds(570));
+
+        await vm.JumpToEventCommand.ExecuteAsync(null);
+
+        vm.SeekPosition.ShouldBe(vm.EventMarkerPosition, 0.0001);
+    }
+
+    [Fact]
+    public async Task EventShortcut_JumpsToEvent_WhenMarkerPresent()
+    {
+        var vm = CreateViewModel();
+        vm.SelectedClip = ClipWithChunksAndEvent(10, TimeSpan.FromSeconds(570));
+
+        var handled = await vm.HandleKeyDownAsync(Key.E, ModifierKeys.None);
+
+        handled.ShouldBeTrue();
+        vm.SeekPosition.ShouldBe(vm.EventMarkerPosition, 0.0001);
+    }
+
+    [Fact]
+    public async Task EventShortcut_Ignored_WhenNoMarker()
+    {
+        var vm = CreateViewModel();
+        vm.SelectedClip = ClipWithChunks(3); // no event
+
+        var handled = await vm.HandleKeyDownAsync(Key.E, ModifierKeys.None);
+
+        handled.ShouldBeFalse();
+    }
+
+    [Fact]
+    public void SelectingClip_RaisesEventMarkerNotifications()
+    {
+        var vm = CreateViewModel();
+        var changed = new List<string>();
+        vm.PropertyChanged += (_, e) => changed.Add(e.PropertyName);
+
+        vm.SelectedClip = ClipWithChunksAndEvent(5, TimeSpan.FromSeconds(250));
+
+        changed.ShouldContain(nameof(MainWindowViewModel.EventMarkerPosition));
+        changed.ShouldContain(nameof(MainWindowViewModel.HasEventMarker));
+        changed.ShouldContain(nameof(MainWindowViewModel.ChunkBoundaries));
+    }
+
     // --- Playback: drive a real VideoPlayerController through FakeCameraPlayer (no Flyleaf/FFmpeg) ---
 
     [Fact]

SentryReplay/ClipConverters.cs

@@ -210,6 +210,29 @@ public object[] ConvertBack(object value, Type[] targetTypes, object parameter,
         => throw new NotSupportedException();
 }
 
+/// <summary>
+/// Left offset for a seek-bar overlay (event marker or chunk tick): a left <see cref="Thickness"/>
+/// of position × rail width. [0] fraction (0..1), [1] rail ActualWidth. Mirrors
+/// <see cref="SeekFillWidthConverter"/> so overlays track the played fill and reflow on resize.
+/// </summary>
+public sealed class SeekOffsetConverter : MarkupExtension, IMultiValueConverter
+{
+    public override object ProvideValue(IServiceProvider serviceProvider) => this;
+
+    public object Convert(object[] values, Type targetType, object parameter, CultureInfo culture)
+    {
+        if (values.Length == 2 && values[0] is double fraction && values[1] is double width && width > 0)
+        {
+            return new Thickness(Math.Clamp(fraction, 0, 1) * width, 0, 0, 0);
+        }
+
+        return new Thickness(0);
+    }
+
+    public object[] ConvertBack(object value, Type[] targetTypes, object parameter, CultureInfo culture)
+        => throw new NotSupportedException();
+}
+
 /// <summary>
 /// Visibility.Visible when the bound clip is the one currently playing.
 /// Multi-binding: [0] the clip, [1] the view-model's NowPlayingClip.