gramps
6bff21b234
Creator corrected the "loupe" zoom on 2026-10-08: the click anchors a fixed
capture region (box/2 centred on the click) and the box is a live 2x view of
that region — dragging the box never changes its content; it magnifies the
fully-composited frame (every layer, incl. webcam) and draws LAST (n+1).
Rectangle shape is 4:3 ("more of a 640x480 aspect").
- MainViewModel.Zoom.cs rewritten: ActivateZoom anchors CaptureX/CaptureY
(independently clamped); UpdateZoomMove relocates the box only; the per-frame
BuildZoomFrame/ZoomFrameBuilder path is gone.
- SceneCompositor: skips the active ZoomSceneElement in every layer loop and
BlitZooms it last via the new pure ZoomMagnifier (2x bilinear, temp snapshot
via ArrayPool, round clip).
- Preview: ZoomBox hoisted above CanvasGrid as a sibling; its brush samples the
whole composed preview at the fixed capture (2x).
- Tests: ZoomMagnifierTests (box-over-blue shows green capture at 2x incl. an
extra red "layer" — the loupe/backdrop-only regressions both fail it) +
round-clip; ZoomBoxInteractionTests rewritten (anchored capture, move-doesn't-
change-capture, 4:3/9:16/square). 404 pass, 2 known environment flakes.
181 lines
8.5 KiB
C#
181 lines
8.5 KiB
C#
using System;
|
|
using System.Linq;
|
|
using System.Windows;
|
|
using System.Windows.Controls;
|
|
using System.Windows.Media;
|
|
using System.Windows.Shapes;
|
|
using Microsoft.Data.Sqlite;
|
|
using Xunit;
|
|
using ytLive.Models;
|
|
using ytLive.ViewModels;
|
|
|
|
namespace ytLive.Tests;
|
|
|
|
/// <summary>
|
|
/// Verifies the zoom box created by a right-click in the live preview (creator-
|
|
/// corrected model, 2026-10-08): every ZoomView shape procures the right bounding
|
|
/// box CENTERED on the click and a FIXED capture window (the box/2 region centred
|
|
/// on the click). Dragging the box relocates it WITHOUT changing the capture — the
|
|
/// box always shows the same anchored content magnified 2x. The rectangle is 4:3
|
|
/// ("more of a 640x480 aspect ratio"). The box is a real composited layer drawn
|
|
/// LAST (a ZoomSceneElement placeholder sits at z-index 1 whose rect + capture
|
|
/// mirror the box; Kind flips Dynamic only while active), and the output crop
|
|
/// stays the tier (the box is never the crop source).
|
|
/// </summary>
|
|
[Collection("RealApp")]
|
|
public sealed class ZoomBoxInteractionTests
|
|
{
|
|
private readonly RealAppHost _app;
|
|
|
|
public ZoomBoxInteractionTests(RealAppHost app)
|
|
{
|
|
_app = app;
|
|
}
|
|
|
|
[Fact]
|
|
public void Zoom_Shape_Controls_Box_Aspect_Anchor_Layer_And_Render()
|
|
{
|
|
_app.Run(Run);
|
|
}
|
|
|
|
private void Run()
|
|
{
|
|
var tempDb = System.IO.Path.Combine(System.IO.Path.GetTempPath(), $"ytLlive-test-{Guid.NewGuid():N}.db");
|
|
MainViewModel.LayoutPathOverride = tempDb;
|
|
var window = new MainWindow();
|
|
var vm = (MainViewModel)window.DataContext;
|
|
try
|
|
{
|
|
window.Show();
|
|
window.UpdateLayout();
|
|
Assert.NotNull(vm.StagedScene);
|
|
// The healed zoom placeholder sits at z-index 1, inert.
|
|
var placeholder = (ZoomSceneElement)vm.StagedScene.Elements[1];
|
|
Assert.False(placeholder.IsZoomActive);
|
|
Assert.Equal(ElementKind.Static, placeholder.Kind);
|
|
|
|
vm.IsRecording = true;
|
|
var pane = (UserControl)window.FindName("PreviewPane")!;
|
|
var zoomBox = (Grid)pane.FindName("ZoomBox")!;
|
|
var rectOutline = (Rectangle)pane.FindName("ZoomRectOutline")!;
|
|
var circleOutline = (Ellipse)pane.FindName("ZoomCircleOutline")!;
|
|
|
|
// Circle: square box, click point is the CENTER of box AND capture.
|
|
vm.ZoomShape = ZoomShape.Circle;
|
|
vm.ActivateZoom(1000, 500);
|
|
Assert.True(vm.IsZoomActive);
|
|
Assert.Equal(vm.ZoomState.Width, vm.ZoomState.Height, 3);
|
|
Assert.Equal(1000 - vm.ZoomState.Width / 2, vm.ZoomState.X, 3);
|
|
Assert.Equal(500 - vm.ZoomState.Height / 2, vm.ZoomState.Y, 3);
|
|
Assert.Equal(1000 - vm.ZoomState.Width / 4, vm.ZoomState.CaptureX, 3);
|
|
Assert.Equal(500 - vm.ZoomState.Height / 4, vm.ZoomState.CaptureY, 3);
|
|
AssertTrueActiveLayer(vm);
|
|
|
|
window.UpdateLayout();
|
|
Assert.Equal(Visibility.Visible, zoomBox.Visibility);
|
|
Assert.IsType<EllipseGeometry>(zoomBox.Clip);
|
|
Assert.Equal(Visibility.Visible, circleOutline.Visibility);
|
|
Assert.Equal(Visibility.Collapsed, rectOutline.Visibility);
|
|
|
|
// Phone (vertical rectangle): tall 9:16 box; capture centred on the click.
|
|
vm.ZoomShape = ZoomShape.VerticalRectangle;
|
|
vm.ActivateZoom(960, 540);
|
|
Assert.True(vm.ZoomState.Height > vm.ZoomState.Width);
|
|
Assert.Equal(9.0 / 16.0, vm.ZoomState.Width / vm.ZoomState.Height, 3);
|
|
Assert.Equal(960 - vm.ZoomState.Width / 2, vm.ZoomState.X, 3);
|
|
Assert.Equal(540 - vm.ZoomState.Height / 2, vm.ZoomState.Y, 3);
|
|
Assert.Equal(960 - vm.ZoomState.Width / 4, vm.ZoomState.CaptureX, 3);
|
|
Assert.Equal(540 - vm.ZoomState.Height / 4, vm.ZoomState.CaptureY, 3);
|
|
AssertTrueActiveLayer(vm);
|
|
|
|
window.UpdateLayout();
|
|
Assert.Null(zoomBox.Clip);
|
|
Assert.Equal(Visibility.Collapsed, circleOutline.Visibility);
|
|
Assert.Equal(Visibility.Visible, rectOutline.Visibility);
|
|
|
|
// Tablet (horizontal rectangle): 4:3 wide box (creator: "more of a
|
|
// 640x480 aspect ratio" — the first-cut 16:9 read as a square).
|
|
vm.ZoomShape = ZoomShape.HorizontalRectangle;
|
|
vm.ActivateZoom(960, 540);
|
|
Assert.True(vm.ZoomState.Width > vm.ZoomState.Height);
|
|
Assert.Equal(4.0 / 3.0, vm.ZoomState.Width / vm.ZoomState.Height, 3);
|
|
Assert.Equal(960 - vm.ZoomState.Width / 2, vm.ZoomState.X, 3);
|
|
Assert.Equal(540 - vm.ZoomState.Height / 2, vm.ZoomState.Y, 3);
|
|
Assert.Equal(960 - vm.ZoomState.Width / 4, vm.ZoomState.CaptureX, 3);
|
|
Assert.Equal(540 - vm.ZoomState.Height / 4, vm.ZoomState.CaptureY, 3);
|
|
AssertTrueActiveLayer(vm);
|
|
|
|
window.UpdateLayout();
|
|
Assert.Null(zoomBox.Clip);
|
|
Assert.Equal(Visibility.Collapsed, circleOutline.Visibility);
|
|
Assert.Equal(Visibility.Visible, rectOutline.Visibility);
|
|
|
|
// THE core semantic: dragging the box moves only the box. The capture —
|
|
// and therefore the content the box shows — never changes. (Box is still
|
|
// the un-clamped tablet box [456,162] at this point with room to move.)
|
|
var boxX = vm.ZoomState.X;
|
|
var boxY = vm.ZoomState.Y;
|
|
var captureX = vm.ZoomState.CaptureX;
|
|
var captureY = vm.ZoomState.CaptureY;
|
|
vm.StartZoomMove(800, 400);
|
|
vm.UpdateZoomMove(1200, 600);
|
|
vm.EndZoomMove();
|
|
Assert.True(Math.Abs(vm.ZoomState.X - boxX) >= 100, "the box must have moved");
|
|
Assert.True(Math.Abs(vm.ZoomState.Y - boxY) >= 100, "the box must have moved");
|
|
Assert.Equal(captureX, vm.ZoomState.CaptureX);
|
|
Assert.Equal(captureY, vm.ZoomState.CaptureY);
|
|
var zoom = Assert.IsType<ZoomSceneElement>(vm.StagedScene.Elements[1]);
|
|
Assert.Equal(vm.ZoomState.X, zoom.X, 3);
|
|
Assert.Equal(vm.ZoomState.Y, zoom.Y, 3);
|
|
Assert.Equal(captureX, zoom.CaptureX, 3);
|
|
Assert.Equal(captureY, zoom.CaptureY, 3);
|
|
|
|
// Clamp keeps the box AND the capture fully inside the 1920x1080 master
|
|
// even for a corner click that would otherwise overhang both.
|
|
vm.ActivateZoom(2000, 2000);
|
|
const double frameW = 1920, frameH = 1080;
|
|
Assert.True(vm.ZoomState.X >= 0 && vm.ZoomState.Y >= 0);
|
|
Assert.True(vm.ZoomState.X + vm.ZoomState.Width <= frameW);
|
|
Assert.True(vm.ZoomState.Y + vm.ZoomState.Height <= frameH);
|
|
Assert.True(vm.ZoomState.CaptureX >= 0 && vm.ZoomState.CaptureY >= 0);
|
|
Assert.True(vm.ZoomState.CaptureX + vm.ZoomState.Width / 2 <= frameW);
|
|
Assert.True(vm.ZoomState.CaptureY + vm.ZoomState.Height / 2 <= frameH);
|
|
AssertTrueActiveLayer(vm);
|
|
|
|
// The box is a composited layer, NEVER the crop: output stays the tier.
|
|
var opts = vm.BuildCompositorOptions();
|
|
Assert.True(opts.SourceRectWidth > vm.ZoomState.Width);
|
|
Assert.Equal((int)Math.Round(vm.OutputRectWidth), opts.SourceRectWidth);
|
|
Assert.Equal((int)Math.Round(vm.OutputRectHeight), opts.SourceRectHeight);
|
|
|
|
// Dismiss restores the inert placeholder (Kind back to Static).
|
|
vm.DismissZoom();
|
|
Assert.False(vm.IsZoomActive);
|
|
Assert.False(placeholder.IsZoomActive);
|
|
Assert.False(placeholder.IsVisible);
|
|
Assert.Equal(ElementKind.Static, placeholder.Kind);
|
|
}
|
|
finally
|
|
{
|
|
window.Close();
|
|
MainViewModel.LayoutPathOverride = null;
|
|
SqliteConnection.ClearAllPools();
|
|
try { System.IO.File.Delete(tempDb); } catch { }
|
|
}
|
|
}
|
|
|
|
private static void AssertTrueActiveLayer(MainViewModel vm)
|
|
{
|
|
var zoom = Assert.IsType<ZoomSceneElement>(vm.StagedScene!.Elements[1]);
|
|
Assert.True(zoom.IsZoomActive);
|
|
Assert.True(zoom.IsVisible);
|
|
Assert.Equal(ElementKind.Dynamic, zoom.Kind);
|
|
Assert.Equal(vm.ZoomState.X, zoom.X, 3);
|
|
Assert.Equal(vm.ZoomState.Y, zoom.Y, 3);
|
|
Assert.Equal(vm.ZoomState.Width, zoom.Width, 3);
|
|
Assert.Equal(vm.ZoomState.Height, zoom.Height, 3);
|
|
Assert.Equal(vm.ZoomState.CaptureX, zoom.CaptureX, 3);
|
|
Assert.Equal(vm.ZoomState.CaptureY, zoom.CaptureY, 3);
|
|
Assert.Equal(vm.ZoomShape == ZoomShape.Circle ? ClipShape.Round : ClipShape.Traditional, zoom.ClipShape);
|
|
}
|
|
} |