From aa0e3ea67f1ea6fe9baffcadd13ec7e13540d383 Mon Sep 17 00:00:00 2001 From: frathe Date: Tue, 1 Sep 2026 21:56:26 +0200 Subject: [PATCH 01/10] feat(compare): temporarily unlink panes with Control fix(compare): toggle pane linking with Ctrl+L fix(compare): Inert comparison link toggle perf(compare): render pan and zoom with tiled GPU shaders. test(compare): harden tiled renderer lifecycle guards feat(compare): add ready-gated link control --- .../issues/01-shortcut-and-repaint-guards.md | 25 + .../issues/02-render-scene-seam.md | 22 + .../issues/03-display-ready-sources.md | 21 + .../issues/04-tile-planner-and-cache.md | 25 + .../issues/05-shader-adapter.md | 27 + .../issues/06-async-tile-lifecycle.md | 33 + .../issues/07-production-wiring.md | 25 + .../issues/08-profile-docs-and-gate.md | 43 + .scratch/compare-tiled-gpu-rendering/spec.md | 49 + .../issues/01-add-top-left-link-control.md | 35 + .scratch/comparison-link-button/spec.md | 57 + ARCHITECTURE.md | 14 +- internal/ui/build.go | 3 + internal/ui/compare.go | 1 + internal/ui/compare/async_tile_test.go | 466 +++++ internal/ui/compare/compare.go | 267 ++- internal/ui/compare/compare_test.go | 1637 ++++++++++++++--- internal/ui/compare/input.go | 17 +- internal/ui/compare/renderer.go | 132 ++ internal/ui/compare/renderer_test.go | 144 ++ internal/ui/compare/shader.go | 621 +++++++ internal/ui/compare/shader_test.go | 207 +++ internal/ui/compare/source_test.go | 114 ++ internal/ui/compare/swipe.go | 16 +- internal/ui/compare/tile.go | 352 ++++ internal/ui/compare/tile_test.go | 258 +++ internal/ui/compare/transform.go | 419 ++++- internal/ui/compare/uiqueue.go | 4 +- internal/ui/compare/vector.go | 15 +- internal/ui/compare/vector_test.go | 70 +- internal/ui/compare/workgroup.go | 72 + internal/ui/compare/workgroup_test.go | 37 + internal/ui/compare_fidelity_test.go | 10 +- internal/ui/compare_test.go | 386 +++- internal/ui/favorites/favorites_test.go | 13 + internal/ui/help/manual.md | 49 +- internal/ui/help/manual_de.md | 58 +- internal/ui/help/manual_test.go | 44 +- internal/ui/keys.go | 35 +- internal/ui/menu_test.go | 21 + internal/ui/run.go | 1 + internal/ui/shortcuts.go | 17 +- ...026-09-01-ctrl-l-comparison-link-toggle.md | 70 + ...-01-temporary-control-unlink-comparison.md | 85 + plans/2026-09-02-comparison-link-button.md | 98 + ...2026-09-02-inert-comparison-link-toggle.md | 104 ++ ...026-09-02-tiled-gpu-comparison-renderer.md | 116 ++ todos.md | 22 +- translations/de.json | 5 + translations/en.json | 5 + 50 files changed, 5839 insertions(+), 528 deletions(-) create mode 100644 .scratch/compare-tiled-gpu-rendering/issues/01-shortcut-and-repaint-guards.md create mode 100644 .scratch/compare-tiled-gpu-rendering/issues/02-render-scene-seam.md create mode 100644 .scratch/compare-tiled-gpu-rendering/issues/03-display-ready-sources.md create mode 100644 .scratch/compare-tiled-gpu-rendering/issues/04-tile-planner-and-cache.md create mode 100644 .scratch/compare-tiled-gpu-rendering/issues/05-shader-adapter.md create mode 100644 .scratch/compare-tiled-gpu-rendering/issues/06-async-tile-lifecycle.md create mode 100644 .scratch/compare-tiled-gpu-rendering/issues/07-production-wiring.md create mode 100644 .scratch/compare-tiled-gpu-rendering/issues/08-profile-docs-and-gate.md create mode 100644 .scratch/compare-tiled-gpu-rendering/spec.md create mode 100644 .scratch/comparison-link-button/issues/01-add-top-left-link-control.md create mode 100644 .scratch/comparison-link-button/spec.md create mode 100644 internal/ui/compare/async_tile_test.go create mode 100644 internal/ui/compare/renderer.go create mode 100644 internal/ui/compare/renderer_test.go create mode 100644 internal/ui/compare/shader.go create mode 100644 internal/ui/compare/shader_test.go create mode 100644 internal/ui/compare/source_test.go create mode 100644 internal/ui/compare/tile.go create mode 100644 internal/ui/compare/tile_test.go create mode 100644 internal/ui/compare/workgroup.go create mode 100644 internal/ui/compare/workgroup_test.go create mode 100644 plans/2026-09-01-ctrl-l-comparison-link-toggle.md create mode 100644 plans/2026-09-01-temporary-control-unlink-comparison.md create mode 100644 plans/2026-09-02-comparison-link-button.md create mode 100644 plans/2026-09-02-inert-comparison-link-toggle.md create mode 100644 plans/2026-09-02-tiled-gpu-comparison-renderer.md diff --git a/.scratch/compare-tiled-gpu-rendering/issues/01-shortcut-and-repaint-guards.md b/.scratch/compare-tiled-gpu-rendering/issues/01-shortcut-and-repaint-guards.md new file mode 100644 index 0000000..5dbbe29 --- /dev/null +++ b/.scratch/compare-tiled-gpu-rendering/issues/01-shortcut-and-repaint-guards.md @@ -0,0 +1,25 @@ +# 01 - Pin shortcut parity and repaint-free interaction + +Status: resolved + +## Contract + +Register physical Ctrl+D in addition to the platform-default D shortcut without +duplicating the same chord. Add a sustained pan/zoom regression guard proving +100 interaction events do not invoke the owner repaint callback. + +## Red / green + +1. Add tests for both shortcut chords and the 100-event interaction boundary. +2. Observe failure against current shortcut wiring and repaint calls. +3. Make only the smallest behavioral change needed; retain lifecycle repaints. + +## Comments + +Native baseline confirms the forbidden interaction path ends in +`viewer.ForceRepaint` and full-image Catmull-Rom resampling. + +The shortcut guard failed with no physical-Control registration on macOS. The +interaction guard reported exactly 100 owner repaints for 100 mixed pan/zoom +events in each layout. Both focused tests pass after conditional shortcut +registration and removal of the six interaction-path repaint calls. diff --git a/.scratch/compare-tiled-gpu-rendering/issues/02-render-scene-seam.md b/.scratch/compare-tiled-gpu-rendering/issues/02-render-scene-seam.md new file mode 100644 index 0000000..05f19c6 --- /dev/null +++ b/.scratch/compare-tiled-gpu-rendering/issues/02-render-scene-seam.md @@ -0,0 +1,22 @@ +# 02 - Introduce the pane scene renderer seam + +Status: resolved + +## Contract + +Keep `compare.New` unchanged and add an unexported constructor/factory for two +pane renderers. Transform application presents immutable `paneScene` values. +The test reference adapter preserves deterministic canvas geometry and pixels. + +## Acceptance + +Feature tests prove initial, transformed, swapped, cleared, and resized scenes, +and prove pane render objects stay stable across interaction. + +## Comments + +The seam test first failed to compile because `paneScene`, `paneRenderer`, and +the private constructor did not exist. After implementation it proved source, +logical/physical geometry, stable objects, Swap, clear, and Settle coverage. +The full compare suite exposed and then pinned source publication before a +viewport exists; the suite is green. diff --git a/.scratch/compare-tiled-gpu-rendering/issues/03-display-ready-sources.md b/.scratch/compare-tiled-gpu-rendering/issues/03-display-ready-sources.md new file mode 100644 index 0000000..c03ae85 --- /dev/null +++ b/.scratch/compare-tiled-gpu-rendering/issues/03-display-ready-sources.md @@ -0,0 +1,21 @@ +# 03 - Prepare immutable display-ready sources + +Status: resolved + +## Contract + +Convert each decoded or rerasterized frame into an immutable render source with +an aspect-preserving overview whose long edge is at most 1024. Keep spinners +until both overviews are ready and never mutate canonical decoded pixels. + +## Acceptance + +Tests cover dimensions, fidelity, transparency, cancellation/staleness, raster +and vector readiness, and publication through the UI queue. + +## Comments + +The source tests failed first on the absent preparation function, overview, +and per-instance hook. They now prove the 1024-pixel overview bound, alpha and +canonical-frame preservation, cancellation, and spinner/readiness boundary. +The full compare suite passes. diff --git a/.scratch/compare-tiled-gpu-rendering/issues/04-tile-planner-and-cache.md b/.scratch/compare-tiled-gpu-rendering/issues/04-tile-planner-and-cache.md new file mode 100644 index 0000000..7b5add1 --- /dev/null +++ b/.scratch/compare-tiled-gpu-rendering/issues/04-tile-planner-and-cache.md @@ -0,0 +1,25 @@ +# 04 - Implement the virtual tile planner and bounded cache + +Status: resolved + +## Contract + +Plan visible guttered 1022-pixel-interior tiles from source coordinates and +physical display density. Coarsen until no more than seven visible tiles are +needed, then prefetch nearest neighbors. Cache generated tiles per source with a +64 MiB byte budget. + +## Acceptance + +Table tests cover fit/fill/zoom/pan/edge/HiDPI cases, deterministic slot order, +mixed levels, gutters, cache hits/eviction, and the seven-detail invariant. + +## Comments + +The planner/cache tests failed first on the absent plan, key, generator, and +budget. They now cover fit, HiDPI, zoom, sampler-forced coarsening, deterministic +nearest prefetch, exact level-zero gutters, hits, and 64 MiB eviction. The full +compare suite passes. The shader audit then exposed odd-dimension coarse-edge +gutter drift, prefetch-biased LRU promotion, unnecessary detail work below +overview density, and full-pane planning behind a swipe clip. Each received a +focused regression and now passes. diff --git a/.scratch/compare-tiled-gpu-rendering/issues/05-shader-adapter.md b/.scratch/compare-tiled-gpu-rendering/issues/05-shader-adapter.md new file mode 100644 index 0000000..5532a9f --- /dev/null +++ b/.scratch/compare-tiled-gpu-rendering/issues/05-shader-adapter.md @@ -0,0 +1,27 @@ +# 05 - Implement the tiled shader adapter + +Status: resolved + +## Contract + +Render one overview and up to seven detail tiles with stable pane-specific +shader names. Update scalar uniforms for movement; update texture identities only +when source/tile bindings change. Supply equivalent desktop GLSL 110 and GLES +GLSL 100 programs, bilinear sampling, transparent bounds, and RGB unpremultiply. + +## Acceptance + +Structural tests lock declarations, sampler count, lookup/body equivalence, +stable identity, slot clearing, finest-match selection, and scene-to-uniform +mapping without requiring a GPU. + +## Comments + +The shader tests failed first on absent GLSL and adapter APIs. Both GLSL +variants now share one byte-identical body after their preambles, declare eight +samplers, select the finest matching detail over the overview, and unpremultiply +alpha. Adapter tests pin stable names/objects, fixed slots, geometry/uniform +mapping, texture reuse, and bounded clear behavior. Independent audit tests +also caught and fixed vertical texture inversion, sampler-slot shuffling, +excess GLES uniforms, raw-coordinate mediump hazards, and extreme-aspect +selection/division guards. diff --git a/.scratch/compare-tiled-gpu-rendering/issues/06-async-tile-lifecycle.md b/.scratch/compare-tiled-gpu-rendering/issues/06-async-tile-lifecycle.md new file mode 100644 index 0000000..9410eef --- /dev/null +++ b/.scratch/compare-tiled-gpu-rendering/issues/06-async-tile-lifecycle.md @@ -0,0 +1,33 @@ +# 06 - Add asynchronous tile delivery and lifecycle control + +Status: resolved + +## Contract + +Run at most one cancellable tile worker per pane. Check source/view tokens +between bounded generations, publish through `UIQueue`, ignore stale results, +reuse cached tiles across Swap, and make `Settle` wait for load, vector, tile, +and queued follow-on work. + +## Acceptance + +Tests cover supersession, close, reopen, resize, vector replacement, swap/cache +reuse, queue ordering, worker count, and race-safe settlement. + +## Comments + +The initial async tests proved single-generator execution, stale-source +rejection, cache reuse, and settlement. Lifecycle audit then reproduced a +vector-replacement deadlock caused by waiting for obsolete tiles before +draining the UI completion that cancels them. `Settle` now drains causal work +first, reusable channel epochs replace cancellable WaitGroup helper goroutines, +tile publication is coalesced, and focused tests cover active clear/reopen, +stale views, vector replacement, active Swap, shutdown, and race settlement. + +The first native memory run exposed one more lifecycle cost: every same-source +view revision cancelled a tile after its destination buffer could already be +allocated. With a large decoded-image cache raising Go's collection goal, +discarded four-megabyte tile buffers accumulated between collections. A guard +was observed failing with an allocated tile discarded on view change. The +worker now finishes and caches that one immutable tile, then jumps directly to +the latest same-source plan; clear and source replacement still cancel. diff --git a/.scratch/compare-tiled-gpu-rendering/issues/07-production-wiring.md b/.scratch/compare-tiled-gpu-rendering/issues/07-production-wiring.md new file mode 100644 index 0000000..5095bf1 --- /dev/null +++ b/.scratch/compare-tiled-gpu-rendering/issues/07-production-wiring.md @@ -0,0 +1,25 @@ +# 07 - Wire production rendering and migrate comparison tests + +Status: resolved + +## Contract + +Use tiled shader renderers in production side-by-side and swipe composition. +Migrate package and assembled UI assertions to the scene seam or shader state. +Preserve all existing comparison behavior while removing interaction-path owner +repaints and full-image canvas scaling. + +## Acceptance + +The complete compare package and affected assembled UI suites pass, including +fidelity, vectors, link/unlink, divider, swap, resize, cancellation, and 100-event +interaction guards. + +## Comments + +Production now constructs two tiled shader renderers while package tests retain +the private canvas reference adapter. Comparison and assembled UI assertions +were migrated to scenes or visible shader state. The complete compare package, +recursive comparison integration suite, physical Ctrl+D invocation, shutdown +guard, manual guards, and focused race suite pass. + diff --git a/.scratch/compare-tiled-gpu-rendering/issues/08-profile-docs-and-gate.md b/.scratch/compare-tiled-gpu-rendering/issues/08-profile-docs-and-gate.md new file mode 100644 index 0000000..6ea169b --- /dev/null +++ b/.scratch/compare-tiled-gpu-rendering/issues/08-profile-docs-and-gate.md @@ -0,0 +1,43 @@ +# 08 - Profile, document, and run the landing gate + +Status: resolved + +## Contract + +Update architecture/manual/TODO records, perform user-driven macOS side-by-side +and swipe samples on an exact unstripped working-tree build, check memory, and +run the native and final repository gates. + +## Acceptance + +The profile meets the plan thresholds; `make test-native`, documentation guards, +and one final `make verify` pass. Record that Windows/Linux runtime GPU behavior +was not exercised. + +## Comments + +The exact unstripped working-tree build was exercised by the user with the same +image pair as the baseline. Physical `Ctrl+D` opened comparison and both modes +were reported visually smooth. Separate 10-second samples measured: + +- side-by-side: 1.0 GiB sample footprint and 95.2% main-thread idle; +- swipe: 1.0 GiB sample footprint, 1.1 GiB process peak, and 95.7% + main-thread idle; +- no Catmull-Rom, `drawNRGBAOver`, or gesture-to-`ForceRepaint` stack in either + sample; +- Go's live heap stable at 267-271 MiB across repeated collections. + +The 1.1 GiB peak is below the 1.2 GiB acceptance ceiling. GPU runtime behavior +on Windows and Linux was not exercised. + +The post-fix native suite passed every package except for the existing +Darwin/arm64 antialiasing variance in the Copy Selection golden. That failure +differed at 629 boundary/text pixels, and its generated PNG was byte-for-byte +identical when the same test ran from the parent revision. The authoritative +Linux/amd64 gate first exposed that the shortcut test used duplicate constant +map keys on platforms where the native shortcut modifier is already Control. +After making the expected modifier set portable, the complete `internal/ui` +Linux/amd64 race and golden package passed in 662.436 seconds. The single +`make verify` invocation had already passed formatting, TUF, vet, build, and +every other race package, so the focused rerun completed coverage of the final +tree without spending a second full-gate run. diff --git a/.scratch/compare-tiled-gpu-rendering/spec.md b/.scratch/compare-tiled-gpu-rendering/spec.md new file mode 100644 index 0000000..37f37f0 --- /dev/null +++ b/.scratch/compare-tiled-gpu-rendering/spec.md @@ -0,0 +1,49 @@ +# Spec: tiled GPU comparison rendering + +Status: approved + +## Problem + +Side-by-side and swipe pan/zoom recursively refresh the viewer canvas. Fyne then +performs smooth full-image resampling and texture recreation on the interactive +path. Native profiling shows that work, rather than transform arithmetic, is the +dominant CPU and memory cost. The running macOS app also lacks the physical +Ctrl+D comparison shortcut because Fyne's default shortcut modifier is Command. + +## User-visible contract + +1. Command+D and physical Ctrl+D both open comparison on macOS; platforms where + the default shortcut is already Control register the command once. +2. Side-by-side and swipe retain their current layout, clipping, divider, + linking, temporary-Control unlink, zoom, pan, swap, vector, and lifecycle + behavior. +3. Pan and zoom remain responsive under sustained input and do not briefly show + blank source regions while detail imagery is prepared. +4. Comparison opens only after both decoded sources have display-ready overview + imagery; the existing spinners communicate that wait. +5. Bilinear filtering is used at every scale. + +## Internal contract + +- A private scene-based pane renderer separates transform policy from Fyne's + canvas implementation. Production uses a tiled shader renderer; tests can use + a reference canvas renderer through the unexported constructor. +- Stable shaders receive scalar viewport/image/display uniforms, one overview, + and up to seven guttered detail textures. Interaction changes uniforms without + refreshing the viewer root. +- Immutable render sources own a bounded 64 MiB tile cache. Tile choice is a + deterministic pure plan based on visible source bounds and physical pixels. +- One cancellable worker per pane generates missing tiles. Tokens and queued UI + completions prevent stale source/view publication. `Settle` observes all work. +- Shader programs exist in equivalent GLSL 110 and GLSL 100 forms and correctly + handle transparent premultiplied source pixels. + +## Acceptance + +- Focused red/green tests for every ticket in `issues/`. +- `go test ./internal/ui/compare -count=1` and affected assembled UI tests pass. +- `make test-native` and documentation guards pass. +- Final `make verify` passes once. +- User-driven native profiles satisfy the thresholds in + `plans/2026-09-02-tiled-gpu-comparison-renderer.md`. + diff --git a/.scratch/comparison-link-button/issues/01-add-top-left-link-control.md b/.scratch/comparison-link-button/issues/01-add-top-left-link-control.md new file mode 100644 index 0000000..75fa970 --- /dev/null +++ b/.scratch/comparison-link-button/issues/01-add-top-left-link-control.md @@ -0,0 +1,35 @@ +# 01 - Add the top-left comparison link control + +Status: resolved + +## Contract + +Add a ready-gated Unlink/Link button and move the existing target-aware +Unlinked status into the same top-left translucent card. Keep the top-right +action card intact. Button and physical `Ctrl+L` must share +`compare.Feature.ToggleLink` and its readiness boundary. + +## Acceptance + +- [x] The top-left card, loading gate, and unchanged top-right card pass the + feature-level comparison test. +- [x] Button and physical `Ctrl+L` pass the assembled-viewer equivalence test. +- [x] Open and Swap restore the linked button/status state. +- [x] English and German strings and manuals describe the completed behavior. +- [x] Focused comparison suites and `make verify` pass. + +## Comments + +- 2026-09-02: Specification approved with `compare.Feature` and assembled + viewer as the confirmed TDD seams. Two mechanical sub-agents are limited to + transcribing one pre-designed red test each; production, strings, review, + fixes, and the final gate remain with the primary agent. +- 2026-09-02: Feature tracer first failed because the comparison overlay had + no Unlink button. The assembled-viewer tracer first failed because pre-ready + `Ctrl+L` entered the unlinked state and no Link button existed. +- 2026-09-02: Negative verification proved both new boundaries: removing the + readiness guard failed the shortcut tracer, and placing the status before + the button failed its geometry assertion. +- 2026-09-02: Focused compare, viewer, translation, and manual tests passed. + `make verify` then passed formatting/TUF checks, vet, build, and the complete + Linux/amd64 race suite. diff --git a/.scratch/comparison-link-button/spec.md b/.scratch/comparison-link-button/spec.md new file mode 100644 index 0000000..a47501e --- /dev/null +++ b/.scratch/comparison-link-button/spec.md @@ -0,0 +1,57 @@ +# Spec: comparison link button + +Status: approved + +## Problem + +Comparison pane linking is discoverable only through physical `Ctrl+L`, while +the resulting Unlinked status sits beside unrelated layout, Swap, and exit +actions at the top right. The comparison surface needs a visible pointer-driven +control whose state and availability exactly match the shortcut. + +## Decisions + +- A separate compact translucent card is anchored at the top left. It contains + the link-action button first and the existing Unlinked status immediately to + its right. +- The existing Swipe/Side by side, Swap, and Back to Grid card remains at the + top right and no longer contains the Unlinked status. +- The button names its next action: Unlink while linked, Link while unlinked. +- The button is visible but disabled until both comparison images are ready. + Physical `Ctrl+L` is also inert until that readiness boundary. +- The button and shortcut call the existing `compare.Feature.ToggleLink` + action. No parallel state or callback is introduced. +- Open, close/failure, and Swap restore linked state, the Unlink label, and a + hidden status. Existing Unlinked, Unlinked: Left, and Unlinked: Right status + behavior is retained. + +## Acceptance criteria + +1. The ready-gated button is in its own compact translucent top-left card while + the existing action card remains at the top right. + Verify: `go test ./internal/ui/compare -run '^TestCompareLinkControl_TopLeftCardAndReadyGate$' -count=1` +2. Button and physical `Ctrl+L` use the same readiness gate and toggle state, + label, and status together. + Verify: `go test ./internal/ui -run 'Compare(LinkControl|LinkToggle)' -count=1` +3. Target-aware status, new-session reset, and Swap reset remain correct. + Verify: `go test ./internal/ui/compare -run 'Compare(LinkControl|LinkToggle|OpenStartsLinked|SwapWhileUnlinked)' -count=1` +4. Link and Unlink are localized, both manuals document the control, and all + manual/translation guards pass. + Verify: `go test . -run '^TestTranslations_' -count=1` + Verify: `go test ./internal/ui/help -run '^TestManual' -count=1` +5. The repository formatting, vet, build, and race gate passes. + Verify: `make verify` + +## Non-goals + +- Changing comparison transform, pan, zoom, relink, or target-selection + semantics. +- Adding a preference, icon-only control, menu action, or exported API. +- Moving or otherwise changing the top-right comparison actions. +- Rewriting completed historical comparison plans. + +## Honest limit + +Placement is guarded with deterministic geometry and widget-state assertions, +not a new screenshot golden. This avoids coupling the control to Fyne's +software painter while still proving its edge, ordering, and card ownership. diff --git a/ARCHITECTURE.md b/ARCHITECTURE.md index 7e5f4fe..f7076d1 100644 --- a/ARCHITECTURE.md +++ b/ARCHITECTURE.md @@ -31,12 +31,12 @@ The concurrency invariant: see `AGENTS.md` § Concurrency and Fyne. | File(s) | Responsibility | |---------|----------------| -| `run.go` | `Run`: restore startup viewer, start runtime (`favstore.DefaultDir`, position polling), register shutdown and CLI drop, enter the Fyne loop. | -| `build.go` | `buildViewer` composes widgets and `registerFeatures` modules. Overlay tail: copy selection, grid, comparison (including its pointer shield), delete confirm, export prompt, toast. | +| `run.go` | `Run`: restore startup viewer, start runtime (`favstore.DefaultDir`, position polling), register shutdown and CLI drop, enter the Fyne loop. Shutdown cancels an active comparison before the event loop stops. | +| `build.go` | `buildViewer` composes widgets and `registerFeatures` modules. Overlay tail: copy selection, grid, comparison (including its pointer shield), delete confirm, export prompt, toast. Desktop canvases also receive the chained comparison key-down hook for exact physical `Ctrl+L`; ordinary typed-key and shortcut wiring remains separate. | | `startup.go` | `loadStartupState` / `restoreStartupGeometry` / `buildStartupViewer` — the one load→build→restore path shared by `Run` and tests. | | `components.go` | Dropzone, scan, sort, and info-overlay constructors. Toast stays in `toast.go`. | | `features.go` | `registerFeatures` assigns help, EXIF, zoom, copy selection, grid, comparison, deletion, slideshow, settings, then favorites. | -| `shortcuts.go` | `wireGlobalShortcuts` plus per-action shortcut wiring (open, favorites, clipboard, copy selection, comparison, delete, select-all, save, export, wallpaper). `yieldingShortcuts` blocks ordinary commands during comparison and otherwise yields Copy Selection; Open is admitted only far enough to show comparison's refusal. Copy Selection and clipboard bindings also defend their own direct entries. | +| `shortcuts.go` | `wireGlobalShortcuts` plus per-action shortcut wiring (open, favorites, clipboard, copy selection, comparison, delete, select-all, save, export, wallpaper). Comparison registers the native `Cmd/Ctrl+D` plus physical `Ctrl+D` when those differ. `yieldingShortcuts` blocks ordinary commands during comparison and otherwise yields Copy Selection; Open is admitted only far enough to show comparison's refusal. Copy Selection and clipboard bindings also defend their own direct entries. | | `gesture.go` | Position-poller callback fans samples to `winPos` and `spiralDrag`; a recognised spiral calls `help.OpenSpiral`. | | `windowtrack.go` | Main-window size tracker and position poller; `widgetGeometry` / `prefGeometry` translate `preferences.WindowGeometry` ↔ `widgets.Geometry`. | | `windowmenu.go` | Window-menu action handlers (`showViewer`, `showWindowExif`, `showWindowGrid`, `showWindowPictureFrame`, `showWindowHelp` — grid/picture-frame mutual exclusion lives in the first two) plus `refreshMainMenu` / `syncNativeMenuBar` and the Darwin sync entry points. The Checked/Disabled matrix itself lives in `internal/ui/menus`. | @@ -47,7 +47,7 @@ The concurrency invariant: see `AGENTS.md` § Concurrency and Fyne. | `lifecycle.go` | `requestLifecycle` / `requestToken`. Load, scan, sort, vector, and copy-selection encode each own an instance. | | `viewer.go` | Façade: title (`baseTitle` / `gridTitle` / comparison ownership / `applyTitle`), reset/close, merge, Host vocabulary (`CurrentFile`, `ShowImage`, `RemoveFiles`, …). | | `visibility.go` | `dupeFileSet` (adapts the viewer to `dupes.FileSet` by forwarding `appState`'s published `dupes.Snapshot`); `jumpIfHiddenExtra`; `pushHideDuplicates`; the navigation helpers (`nextVisibleIndex` / `firstVisibleIndex` / `lastVisibleIndex` / `randomVisibleOther`) that read `v.dupes` instead of polling the grid overlay. | -| `keys.go` | `handleKeyEvent` / `handleTypedRune`. Return immediately while `Canvas().Overlays().Top()` is set (Fyne dialogs/menus). Comparison owns all main-window typing: Escape closes it, F1 opens Help, `0` / `1` / `+` / `-` reach its linked transform, swipe-mode `Left` / `Right` / `Home` / `End` reach its divider (with Shift read through `Modifiers`), and every other key/rune stops before the still-open grid. Copy Selection: `HandleKey` consumes Escape/copy/navigation; unowned keys `yieldCopySelection` except modifier-only and zoom keys. | +| `keys.go` | `handleKeyEvent` / `handleTypedRune`, plus a chained desktop key-down hook that requests the ready-gated comparison link toggle on exact physical `Ctrl+L` without key-repeat flapping. Return immediately while `Canvas().Overlays().Top()` is set (Fyne dialogs/menus). Comparison owns all main-window typing: Escape closes it, F1 opens Help, `0` / `1` / `+` / `-` reach its shared camera or hovered photo pose, swipe-mode `Left` / `Right` / `Home` / `End` reach its divider, and every other key/rune stops before the still-open grid. Copy Selection: `HandleKey` consumes Escape/copy/navigation; unowned keys `yieldCopySelection` except modifier-only and zoom keys. | | `menu.go` | `buildMainMenu` builds `internal/ui/menus.Menus` and assembles the bar: File, Favorites, Actions, Window, Help. `yieldingMenuCallbacks` enforces comparison isolation and Copy Selection yielding at callback entry. `menuState()` is the one function that builds the `menus.State` snapshot; `syncMenus()` applies it, pushes comparison/file availability into Favorites, and refreshes the native bar only when something actually changed. | | `actionmenu.go` | Comparison-guarded Actions-menu handlers (`setActionsSort`, `toggleActionsHideDuplicates`, `showActionsVariant`, `rotateActionsImage`, …). The Checked/Disabled matrix lives in `internal/ui/menus`. | | `drop.go` | `handleDrop` / `applyScanResult` / `applyScannedFiles` glue over `filescan.Images` / `filescan.Siblings`; scan lifecycle is `viewer.scanOp`. A non-empty drop is refused before any state change while comparison is active. | @@ -71,7 +71,7 @@ The concurrency invariant: see `AGENTS.md` § Concurrency and Fyne. | `session.go` | `restoreSession` glue over `internal/session`. | | `clipboard.go` | Copy-path / copy-image glue over `internal/clipboard`. | | `copyselection.go` | Viewer adapter for `internal/ui/copyselection`: availability, start/cancel, zoom `Geometry` to `View`, animation pause, clipboard worker, `yieldCopySelection`. Command entry yields through `yieldingMenuCallbacks`, `yieldingShortcuts`, `handleKeyEvent`, and `handleDrop`. | -| `compare.go` | Viewer adapter for `internal/ui/compare`: validates exactly two explicit grid selections, resolves ascending host indices to URIs, and loads through the canonical full-image cache/probe/decode path. That path preserves EXIF-corrected pixels, RAW previews, animation decoding/budget policy, encoded-input limits, and the original first frame; the feature deliberately freezes animation. The adapter owns the exact comparison-window title callback and reports failures without mutating the grid or file set. `comparisonActive()` is the composition layer's sole exclusive-mode fact; `refuseOpenDuringComparison()` owns the localized discard policy. | +| `compare.go` | Viewer adapter for `internal/ui/compare`: validates exactly two explicit grid selections, resolves ascending host indices to URIs, unfocuses the covered grid so desktop modifier hooks remain reachable, and loads through the canonical full-image cache/probe/decode path. That path preserves EXIF-corrected pixels, RAW previews, animation decoding/budget policy, encoded-input limits, and the original first frame; the feature deliberately freezes animation. The adapter owns the exact comparison-window title callback and reports failures without mutating the grid or file set. `comparisonActive()` is the composition layer's sole exclusive-mode fact; `refuseOpenDuringComparison()` owns the localized discard policy. | | `animationpause.go` | Serializes animated-frame advancement with Copy Selection's stable source capture. | | `openfiles.go` | Native open-dialog glue over `internal/filepicker`; both dialog entry and chooser execution refuse an active comparison before starting external work. | @@ -82,7 +82,7 @@ The concurrency invariant: see `AGENTS.md` § Concurrency and Fyne. | `internal/ui/zoom/` | Zoom/pan of the displayed image. `Geometry` / `HandleScroll` / `SetOnGeometryChanged` are the presentation seam Copy Selection uses; this package does not import `copyselection`. Window growth is `syncWindowToZoom` in `internal/ui`. | `onChanged`, `modifiers`, `onScaleChanged`. | | `internal/ui/copyselection/` | Transient Copy Selection mode: image-region geometry, overlay, and captured `Source` crop/encode. `HandleKey` reports whether the mode consumed the key. | `Copy`, `Ended`, `Scroll`. | | `internal/ui/grid/` | Overview (G): `GridWrap`, thumb cache, `decodepool`, `uiqueue.go`, search, badges, explicit host-index selection plus its change observer, `marquee.go` (drag rectangle → `Targets()`), browse-duplicates (Shift+D), and `hashengine.go`'s pool-driven hashing pass that feeds `internal/dupes`. `nav.go`: `setHighlight` → `HighlightChanged`. Reads the model; does not own it. | 10-method `Host` including `Modifiers`. | -| `internal/ui/compare/` | Opaque main-window comparison surface: switchable gapless 50/50 and full-viewport swipe layouts driven by one normalized center and linked fit-relative/actual scale; each image has one reveal clip so swipe keeps aligned image coordinates. It retains each raster source's original decoded first frame. Each SVG has a pane-local, device-pixel raster that is regenerated after zoom/layout/window changes, clamped by `imaging.ClampVectorRaster`, and protected by cancellation plus stale-target checks. Concurrent loads and vector workers publish through the feature's `UIQueue`; `Settle` covers workers and downstream queued completions. It also owns wheel/key zoom, drag/Shift+wheel pan, shared no-overscroll clamping, divider input, permanent chrome, ready-gated layout toggle/Swap, the input shield, and the replaceable completion signal. It receives an ordered URI pair and never reads or mutates grid/viewer state. | `Loader` plus `Callbacks` (`Repaint`, `Closed`, `Failed`, `OrderChanged`, `Modifiers`). | +| `internal/ui/compare/` | Opaque main-window comparison surface: switchable gapless 50/50 and full-viewport swipe layouts compose two persistent photo transforms with one shared camera transform; each image has one reveal clip so swipe keeps aligned image coordinates. The ready-gated top-left Unlink/Link control and physical `Ctrl+L` share `ToggleLink`; its adjacent status reports only the active unlinked target, while layout/Swap/Back stay in a separate top-right card. `ToggleLink` changes only input ownership and never changes rendered geometry. Linked pan/zoom moves the camera, linked `0` frames both current photo poses without rewriting them, and linked `1` returns the camera home. Unlinked pointer input and transform keys target the hovered or last-hovered photo; its `0` / `1` fit or show that photo at decoded-pixel size in the current camera. Photo centers and camera movement stop when an image edge reaches its pane center. Resize and layout preserve both photo poses and the camera; Swap deliberately clears divergence from the last-targeted visible pose before exchanging sources. A private `paneRenderer` scene seam keeps transforms independent from presentation; production owns two stable `canvas.Shader` objects while tests can inject the canvas reference adapter. Each immutable render source retains the canonical decoded frame, a long-edge-1024 overview, and a 64 MiB detail-tile cache. The planner uses physical display density and the actual side-by-side/swipe reveal, skips details when the overview is sufficient, and binds at most seven guttered detail tiles without shuffling stable sampler slots. One cancellable worker per pane generates tiles; publications are coalesced and marshalled through the feature's `UIQueue`. Pan/zoom changes shader geometry and uniforms without repainting the viewer root. Each SVG still gets a pane-local device-pixel raster, clamped by `imaging.ClampVectorRaster`, before entering the same overview/tile path. `Settle` covers load, vector, tile, and causal queued completions with reusable channel-epoch barriers. Fyne's software test painter does not render `canvas.Shader`, so deterministic pixel tests use the reference adapter; native runtime acceptance uses the GL painter. The feature also owns divider input, permanent chrome, ready-gated layout/link/Swap controls, the input shield, and the replaceable completion signal. It receives an ordered URI pair and never reads or mutates grid/viewer state. | `Loader` plus `Callbacks` (`Repaint`, `Closed`, `Failed`, `OrderChanged`, `Modifiers`). | | `internal/ui/deletion/` | Shift+Delete confirm (`widgets.ChoiceCard`) then `trash.Move`. `RequestFiles` is the batch path; `Request` is the one-file wrapper. | 7-method `Host`. | | `internal/ui/slideshow/` | Picture-frame mode (P): full-screen, auto-advance, interval, `winpos.Tracker` capture/restore. | 2-method `Host`. Knows nothing about the grid. | | `internal/ui/exifwin/` | EXIF panel (E): tag list, optional JPEG strip, GPS map (`tiles.go`, `startWarm`). Geometry via `widgets.Singleton`. | 4-method `Host`. | @@ -418,7 +418,7 @@ see `AGENTS.md`. - "How can dragging the window open something?" → `internal/wingesture` + `gesture.go` + `help.OpenSpiral` / `spiral.ShowForGesture`. - "How does copy-image-to-clipboard work?" → `internal/clipboard` + `clipboard.go`. Batch file copy: `copyfiles.go` + `batch.go` `copySelection`. - "How does Copy Selection (image-region copy) work?" → `internal/ui/copyselection` (`Source` / `Encode`, `HandleKey`) + `copyselection.go` (pause, clipboard worker, `yieldCopySelection`) + `menu.go` `yieldingMenuCallbacks` + `shortcuts.go` `yieldingShortcuts` + zoom `Geometry` / `HandleScroll` + overlay order in `build.go`. -- "How does two-image comparison open, preserve raster/vector fidelity, identify/swap sides, switch side-by-side/swipe, route divider/zoom/pan input, isolate commands, load, settle, and return to the grid?" → `internal/ui/compare` (surface/chrome/reveal clips/layout/shared transform/divider/input shield/load and vector lifecycles/UI queue) + `internal/ui/compare.go` (selection, canonical loader, title, active-mode fact, and open refusal) + `features.go` / `keys.go` (modifier, transform-key, and divider-key routing) + `menus` / `menu.go` / `shortcuts.go` (disabled state and guarded entries) + open paths in `drop.go` / `openfiles.go` / `openwith.go` + overlay order in `build.go`. +- "How does two-image comparison open, preserve raster/vector fidelity, render through stable overview/detail shaders, identify/swap sides, switch side-by-side/swipe, toggle photo editing with physical Ctrl+L, route camera/photo/divider input, isolate commands, load, settle, and return to the grid?" -> `internal/ui/compare` (`renderer.go` scene/source seam, `shader.go` stable GPU panes and tile lifecycle, `tile.go` reveal-aware planning/cache/generation, plus surface/chrome/reveal clips/layout/two photo transforms/shared camera/hover target/divider/input shield/load/vector lifecycles/UI queue) + `internal/ui/compare.go` (selection, focus release, canonical loader, title, active-mode fact, and open refusal) + `features.go` / `keys.go` / `shortcuts.go` (physical Ctrl+D, toggle hook, transform-key, divider-key, and command routing) + `favorites` / `menus` / `menu.go` (disabled state and guarded entries) + open paths in `drop.go` / `openfiles.go` / `openwith.go` + overlay order in `build.go`. - "How does the grid overview / thumbnail generation work?" → `imaging/thumbnail.go` + `grid/grid.go` + `grid/thumbs.go` + `grid/hashengine.go` + `grid/nav.go` + `grid/uiqueue.go`. - "What decides the window title?" → `viewer.go` `setTitle` / `applyTitle` / `HighlightChanged` + `load.go` + `grid/nav.go`. - "How do I write a test that needs an image / a viewer?" → `internal/uitest` + `newTestViewer` / `newTestUI` + `dropAndWait` in `harness_test.go`. diff --git a/internal/ui/build.go b/internal/ui/build.go index ebcbd45..6eaf4f6 100644 --- a/internal/ui/build.go +++ b/internal/ui/build.go @@ -193,6 +193,9 @@ func buildViewer(application fyne.App, startup startupState) (*viewer, fyne.Wind window.Canvas().SetOnTypedRune(func(r rune) { view.handleTypedRune(r) }) + if desktopCanvas, ok := window.Canvas().(comparisonKeyDownCanvas); ok { + wireComparisonLinkToggleHook(desktopCanvas, view) + } wireGlobalShortcuts(window.Canvas(), view) diff --git a/internal/ui/compare.go b/internal/ui/compare.go index 3d095b3..265ffbd 100644 --- a/internal/ui/compare.go +++ b/internal/ui/compare.go @@ -50,6 +50,7 @@ func (v *viewer) compareSelected() { } sources[i] = v.FileAt(index) } + v.Unfocus() v.compare.Open(sources) } diff --git a/internal/ui/compare/async_tile_test.go b/internal/ui/compare/async_tile_test.go new file mode 100644 index 0000000..570fd40 --- /dev/null +++ b/internal/ui/compare/async_tile_test.go @@ -0,0 +1,466 @@ +package compare + +import ( + "context" + "image" + "sync" + "sync/atomic" + "testing" + "time" + + "fyne.io/fyne/v2" + "fyne.io/fyne/v2/storage" + fynetest "fyne.io/fyne/v2/test" + + "github.com/frathe/picfetch/internal/imaging" + "github.com/frathe/picfetch/internal/uitest" +) + +func asyncTileScene(source *renderSource, x float32) paneScene { + return paneScene{ + source: source, + viewport: fyne.NewSize(400, 400), + imagePosition: fyne.NewPos(x, -824), + imageSize: fyne.NewSize(2048, 2048), + displaySize: image.Pt(2048, 2048), + } +} + +func waitForTileStart(t *testing.T, started <-chan struct{}) { + t.Helper() + select { + case <-started: + case <-time.After(3 * time.Second): + t.Fatal("timed out waiting for tile worker") + } +} + +func waitForRenderer(t *testing.T, renderer paneRenderer) { + t.Helper() + ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) + defer cancel() + if err := renderer.Wait(ctx); err != nil { + t.Fatalf("renderer Wait: %v", err) + } +} + +func TestShaderPaneRenderer_RapidScenesUseAtMostOneTileWorker(t *testing.T) { + app := fynetest.NewApp() + t.Cleanup(app.Quit) + + source, err := prepareRenderSource(context.Background(), image.NewRGBA(image.Rect(0, 0, 2048, 2048))) + if err != nil { + t.Fatalf("prepareRenderSource: %v", err) + } + renderer := newShaderPaneRenderer(0).(*shaderPaneRenderer) + queue := &uitest.UIQueue{} + renderer.queueUI = queue.Do + started := make(chan struct{}, 1) + release := make(chan struct{}) + var active atomic.Int64 + var maximum atomic.Int64 + var once sync.Once + renderer.generateTile = func(ctx context.Context, source *renderSource, key tileKey) (*renderTile, error) { + current := active.Add(1) + defer active.Add(-1) + for { + seen := maximum.Load() + if current <= seen || maximum.CompareAndSwap(seen, current) { + break + } + } + once.Do(func() { started <- struct{}{}; <-release }) + return generateRenderTile(ctx, source, key) + } + + renderer.Present(asyncTileScene(source, -824)) + waitForTileStart(t, started) + latest := asyncTileScene(source, -824) + for i := range 100 { + latest = asyncTileScene(source, -float32((i*173)%1600)) + renderer.Present(latest) + } + close(release) + waitForRenderer(t, renderer) + for queue.Drain() { + } + if got := maximum.Load(); got != 1 { + t.Errorf("concurrent tile generators = %d, want exactly 1", got) + } + if got := active.Load(); got != 0 { + t.Errorf("active tile generators after Wait = %d, want 0", got) + } + want := make(map[tileKey]bool) + for _, request := range planTiles(latest).requests { + want[request.key] = true + } + for slot, tile := range renderer.bound { + if tile != nil && !want[tile.key] { + t.Errorf("slot %d retained stale-view tile %+v; latest plan is %+v", slot, tile.key, want) + } + } +} + +func TestShaderPaneRenderer_SameSourceViewChangeDoesNotCancelAllocatedTile(t *testing.T) { + app := fynetest.NewApp() + t.Cleanup(app.Quit) + + source, err := prepareRenderSource(context.Background(), image.NewRGBA(image.Rect(0, 0, 4096, 2048))) + if err != nil { + t.Fatalf("prepare source: %v", err) + } + renderer := newShaderPaneRenderer(0).(*shaderPaneRenderer) + queue := &uitest.UIQueue{} + renderer.queueUI = queue.Do + first := asyncTileScene(source, 0) + latest := asyncTileScene(source, -1600) + latestPlan := planTiles(latest) + if sameTileRequests(planTiles(first).requests, latestPlan.requests) { + t.Fatal("fixture view changes produced identical tile requests") + } + + type allocatedWork struct { + ctx context.Context + key tileKey + tile *renderTile + err error + } + allocated := make(chan allocatedWork, 1) + release := make(chan struct{}) + var once sync.Once + renderer.generateTile = func(ctx context.Context, source *renderSource, key tileKey) (*renderTile, error) { + blocked := false + var tile *renderTile + var generateErr error + once.Do(func() { + blocked = true + tile, generateErr = generateRenderTile(context.Background(), source, key) + allocated <- allocatedWork{ctx: ctx, key: key, tile: tile, err: generateErr} + }) + if blocked { + <-release + return tile, generateErr + } + return generateRenderTile(ctx, source, key) + } + + renderer.Present(first) + var work allocatedWork + select { + case work = <-allocated: + case <-time.After(3 * time.Second): + t.Fatal("timed out waiting for allocated tile work") + } + if work.err != nil || work.tile == nil { + close(release) + waitForRenderer(t, renderer) + t.Fatalf("allocate first tile: tile=%v err=%v", work.tile, work.err) + } + renderer.Present(latest) + contextErr := work.ctx.Err() + close(release) + waitForRenderer(t, renderer) + for queue.Drain() { + } + if contextErr != nil { + t.Errorf("same-source view change canceled allocated tile work: %v", contextErr) + } + if !source.tiles.Contains(work.key.cacheKey()) { + t.Error("allocated same-source tile was discarded instead of cached") + } + wanted := make(map[tileKey]bool, len(latestPlan.requests)) + for _, request := range latestPlan.requests { + wanted[request.key] = true + if !source.tiles.Contains(request.key.cacheKey()) { + t.Errorf("latest-view tile %+v was not completed", request.key) + } + } + bound := 0 + for slot, tile := range renderer.bound { + if tile == nil { + continue + } + bound++ + if !wanted[tile.key] { + t.Errorf("slot %d retained tile %+v outside latest plan", slot, tile.key) + } + } + if bound == 0 { + t.Error("latest view completed without binding a detail tile") + } +} + +func TestShaderPaneRenderer_CoalescesTilePublicationWhileUIQueueIsHeld(t *testing.T) { + app := fynetest.NewApp() + t.Cleanup(app.Quit) + + source, err := prepareRenderSource(context.Background(), image.NewRGBA(image.Rect(0, 0, 4096, 4096))) + if err != nil { + t.Fatalf("prepare source: %v", err) + } + scene := paneScene{ + source: source, + viewport: fyne.NewSize(1000, 1000), + imageSize: fyne.NewSize(4096, 4096), + displaySize: image.Pt(4096, 4096), + } + if got := len(planTiles(scene).requests); got <= 1 { + t.Fatalf("publication fixture requests %d tiles, want several", got) + } + renderer := newShaderPaneRenderer(0).(*shaderPaneRenderer) + queue := &uitest.UIQueue{} + renderer.queueUI = queue.Do + renderer.Present(scene) + waitForRenderer(t, renderer) + if got := queue.Len(); got != 1 { + t.Errorf("queued tile publications = %d, want one coalesced callback", got) + } + for queue.Drain() { + } +} + +func TestShaderPaneRenderer_ClearCancelsActiveTileGeneration(t *testing.T) { + app := fynetest.NewApp() + t.Cleanup(app.Quit) + + source, err := prepareRenderSource(context.Background(), image.NewRGBA(image.Rect(0, 0, 2048, 2048))) + if err != nil { + t.Fatalf("prepare source: %v", err) + } + renderer := newShaderPaneRenderer(0).(*shaderPaneRenderer) + started := make(chan struct{}) + canceled := make(chan struct{}) + var once sync.Once + renderer.generateTile = func(ctx context.Context, _ *renderSource, _ tileKey) (*renderTile, error) { + once.Do(func() { close(started) }) + <-ctx.Done() + close(canceled) + return nil, ctx.Err() + } + + renderer.Present(asyncTileScene(source, -824)) + waitForTileStart(t, started) + renderer.Present(paneScene{}) + select { + case <-canceled: + case <-time.After(time.Second): + t.Fatal("clearing the pane did not cancel active tile generation") + } + waitForRenderer(t, renderer) + if renderer.shader.Visible() { + t.Fatal("cleared shader remained visible") + } +} + +func TestShaderPaneRenderer_StaleSourceCannotBindAndLatestSourceCompletes(t *testing.T) { + app := fynetest.NewApp() + t.Cleanup(app.Quit) + + oldSource, err := prepareRenderSource(context.Background(), image.NewRGBA(image.Rect(0, 0, 2048, 2048))) + if err != nil { + t.Fatalf("prepare old source: %v", err) + } + newSource, err := prepareRenderSource(context.Background(), image.NewRGBA(image.Rect(0, 0, 2048, 2048))) + if err != nil { + t.Fatalf("prepare new source: %v", err) + } + renderer := newShaderPaneRenderer(0).(*shaderPaneRenderer) + queue := &uitest.UIQueue{} + renderer.queueUI = queue.Do + oldStarted := make(chan struct{}, 1) + releaseOld := make(chan struct{}) + var oldTile *renderTile + var once sync.Once + renderer.generateTile = func(ctx context.Context, source *renderSource, key tileKey) (*renderTile, error) { + if source == oldSource { + once.Do(func() { oldStarted <- struct{}{}; <-releaseOld }) + tile, generateErr := generateRenderTile(context.Background(), source, key) + oldTile = tile + return tile, generateErr + } + return generateRenderTile(ctx, source, key) + } + + renderer.Present(asyncTileScene(oldSource, -824)) + waitForTileStart(t, oldStarted) + renderer.Present(paneScene{}) + if renderer.shader.Visible() { + t.Fatal("renderer remained visible between old and reopened sources") + } + renderer.Present(asyncTileScene(newSource, -824)) + close(releaseOld) + waitForRenderer(t, renderer) + for queue.Drain() { + } + if renderer.shader.Textures["overview"] != newSource.overview { + t.Fatal("stale worker replaced the latest overview") + } + for slot, tile := range renderer.bound { + if tile == oldTile && oldTile != nil { + t.Errorf("stale old-source tile bound in slot %d", slot) + } + } + if newSource.tiles.Len() == 0 { + t.Fatal("latest source produced no cached detail tiles") + } +} + +func TestShaderPaneRenderer_ClearCancelsWorkAndCachedSourceIsReusable(t *testing.T) { + app := fynetest.NewApp() + t.Cleanup(app.Quit) + + source, err := prepareRenderSource(context.Background(), image.NewRGBA(image.Rect(0, 0, 2048, 2048))) + if err != nil { + t.Fatalf("prepare source: %v", err) + } + renderer := newShaderPaneRenderer(0).(*shaderPaneRenderer) + queue := &uitest.UIQueue{} + renderer.queueUI = queue.Do + var generated atomic.Int64 + renderer.generateTile = func(ctx context.Context, source *renderSource, key tileKey) (*renderTile, error) { + generated.Add(1) + return generateRenderTile(ctx, source, key) + } + scene := asyncTileScene(source, -824) + renderer.Present(scene) + waitForRenderer(t, renderer) + for queue.Drain() { + } + firstCount := generated.Load() + if firstCount == 0 { + t.Fatal("initial scene generated no detail tiles") + } + + renderer.Present(paneScene{}) + waitForRenderer(t, renderer) + if renderer.shader.Visible() { + t.Fatal("clear left shader visible") + } + renderer.Present(scene) + waitForRenderer(t, renderer) + for queue.Drain() { + } + if got := generated.Load(); got != firstCount { + t.Errorf("reopening cached source generated %d tiles total, want unchanged %d", got, firstCount) + } + if renderer.shader.Textures["overview"] != source.overview { + t.Fatal("reopened source did not restore its overview") + } +} + +func TestCompareSettle_DrainsShaderTilesAndSwapReusesSourceCaches(t *testing.T) { + app := fynetest.NewApp() + t.Cleanup(app.Quit) + + var renderers [2]*shaderPaneRenderer + feature := newFeature(func(_ context.Context, _ fyne.URI) (*imaging.LoadedImage, error) { + return &imaging.LoadedImage{Frames: []image.Image{image.NewRGBA(image.Rect(0, 0, 2048, 2048))}}, nil + }, Callbacks{}, func(index int) paneRenderer { + renderer := newShaderPaneRenderer(index).(*shaderPaneRenderer) + renderers[index] = renderer + return renderer + }) + var generated atomic.Int64 + for _, renderer := range renderers { + renderer.generateTile = func(ctx context.Context, source *renderSource, key tileKey) (*renderTile, error) { + generated.Add(1) + return generateRenderTile(ctx, source, key) + } + } + queue := &uitest.UIQueue{} + feature.SetUIQueue(queue) + feature.vectorPixels = func(fyne.CanvasObject, fyne.Size) (int, int) { return 2048, 2048 } + feature.Overlay().Resize(fyne.NewSize(800, 400)) + feature.Open([2]fyne.URI{ + storage.NewFileURI("left.png"), + storage.NewFileURI("right.png"), + }) + ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second) + defer cancel() + if err := feature.Settle(ctx); err != nil { + t.Fatalf("Settle after Open: %v", err) + } + if queue.Len() != 0 { + t.Fatalf("UI queue after Settle = %d, want empty", queue.Len()) + } + firstCount := generated.Load() + if firstCount == 0 { + t.Fatal("shader feature generated no tiles") + } + + feature.swapSides() + if err := feature.Settle(ctx); err != nil { + t.Fatalf("Settle after Swap: %v", err) + } + if got := generated.Load(); got != firstCount { + t.Errorf("Swap generated %d tiles total, want cached count %d", got, firstCount) + } +} + +func TestCompareSwap_DuringTileWorkReusesCompletedSourceCache(t *testing.T) { + app := fynetest.NewApp() + t.Cleanup(app.Quit) + + var renderers [2]*shaderPaneRenderer + feature := newFeature(func(_ context.Context, uri fyne.URI) (*imaging.LoadedImage, error) { + width := 2048 + if uri.Name() == "right.png" { + width = 3072 + } + return &imaging.LoadedImage{Frames: []image.Image{image.NewRGBA(image.Rect(0, 0, width, 2048))}}, nil + }, Callbacks{}, func(index int) paneRenderer { + renderer := newShaderPaneRenderer(index).(*shaderPaneRenderer) + renderers[index] = renderer + return renderer + }) + feature.vectorPixels = func(fyne.CanvasObject, fyne.Size) (int, int) { return 3072, 2048 } + queue := &uitest.UIQueue{} + feature.SetUIQueue(queue) + + leftStarted := make(chan struct{}) + var leftOnce sync.Once + renderers[0].generateTile = func(ctx context.Context, source *renderSource, key tileKey) (*renderTile, error) { + if source.frame.Bounds().Dx() == 2048 { + leftOnce.Do(func() { close(leftStarted) }) + <-ctx.Done() + return nil, ctx.Err() + } + return generateRenderTile(ctx, source, key) + } + var rightSourceGenerations atomic.Int64 + renderers[1].generateTile = func(ctx context.Context, source *renderSource, key tileKey) (*renderTile, error) { + if source.frame.Bounds().Dx() == 3072 { + rightSourceGenerations.Add(1) + } + return generateRenderTile(ctx, source, key) + } + + feature.Overlay().Resize(fyne.NewSize(800, 400)) + feature.Open([2]fyne.URI{ + storage.NewFileURI("left.png"), + storage.NewFileURI("right.png"), + }) + feature.workers.Wait() + if !queue.Drain() { + t.Fatal("comparison load did not queue a UI completion") + } + waitForTileStart(t, leftStarted) + waitForRenderer(t, renderers[1]) + beforeSwap := rightSourceGenerations.Load() + if beforeSwap == 0 { + t.Fatal("right source cache was not prepared before Swap") + } + + feature.swapSides() + ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second) + defer cancel() + if err := feature.Settle(ctx); err != nil { + t.Fatalf("Settle after active Swap: %v", err) + } + if got := rightSourceGenerations.Load(); got != beforeSwap { + t.Errorf("completed right source regenerated %d tiles across Swap, want cached count %d", got, beforeSwap) + } + if renderers[0].shader.Textures["overview"] != feature.renderSources[0].overview { + t.Fatal("left renderer did not publish the swapped source") + } +} diff --git a/internal/ui/compare/compare.go b/internal/ui/compare/compare.go index 4780230..8a9b092 100644 --- a/internal/ui/compare/compare.go +++ b/internal/ui/compare/compare.go @@ -44,18 +44,10 @@ type Callbacks struct { } type pane struct { - root *fyne.Container - image *canvas.Image - input *paneInput - spinner *widget.ProgressBarInfinite -} - -func newPaneImage() *canvas.Image { - img := canvas.NewImageFromImage(nil) - img.FillMode = canvas.ImageFillContain - img.ScaleMode = canvas.ImageScaleSmooth - img.Hide() - return img + root *fyne.Container + renderer paneRenderer + input *paneInput + spinner *widget.ProgressBarInfinite } func newPaneSpinner() *widget.ProgressBarInfinite { @@ -73,31 +65,38 @@ type Feature struct { overlay *fyne.Container content *fyne.Container + toolbar *fyne.Container panes [2]pane reveals [2]paneReveal divider *swipeDivider + linkToggle *widget.Button layoutToggle *widget.Button swap *widget.Button + unlinkStatus *widget.Label badges [2]*widget.Label - sources [2]fyne.URI - identities [2]string - loaded [2]*imaging.LoadedImage - rendered [2]image.Image - vectors [2]vectorRasterState + sources [2]fyne.URI + identities [2]string + loaded [2]*imaging.LoadedImage + rendered [2]image.Image + renderSources [2]*renderSource + vectors [2]vectorRasterState active bool ready bool - transform linkedTransform - viewports [2]fyne.Size - layoutMode comparisonLayout - dividerAt float32 + photoTransforms [2]photoTransform + camera cameraTransform + viewports [2]fyne.Size + layoutMode comparisonLayout + dividerAt float32 + unlinked bool + hoveredPane int lifecycle requestLifecycle done completion.Signal - workers sync.WaitGroup - uiPending sync.WaitGroup + workers workTracker + uiPending workTracker uiCount atomic.Int64 ui UIQueue @@ -105,25 +104,41 @@ type Feature struct { vectorAfter func(time.Duration) <-chan time.Time vectorRasterize func(vector *imaging.Vector, width, height int) (image.Image, error) vectorPixels func(fyne.CanvasObject, fyne.Size) (int, int) + prepareSource func(context.Context, image.Image) (*renderSource, error) } // New constructs one initially hidden comparison surface. func New(loader Loader, callbacks Callbacks) *Feature { + return newFeature(loader, callbacks, newShaderPaneRenderer) +} + +func newFeature(loader Loader, callbacks Callbacks, rendererFactory paneRendererFactory) *Feature { f := &Feature{ - loader: loader, - callbacks: callbacks, - transform: defaultLinkedTransform(), - dividerAt: defaultDivider, - layoutMode: sideBySide, - vectorDebounce: defaultCompareVectorDebounce, - vectorAfter: time.After, + loader: loader, + callbacks: callbacks, + photoTransforms: [2]photoTransform{defaultPhotoTransform(), defaultPhotoTransform()}, + camera: defaultCameraTransform(), + dividerAt: defaultDivider, + layoutMode: sideBySide, + hoveredPane: -1, + vectorDebounce: defaultCompareVectorDebounce, + vectorAfter: time.After, vectorRasterize: func(vector *imaging.Vector, width, height int) (image.Image, error) { return vector.RasterAt(width, height) }, - vectorPixels: displayPixelSize, - ui: fyneQueue{}, + vectorPixels: displayPixelSize, + prepareSource: prepareRenderSource, + ui: fyneQueue{}, + } + f.panes = [2]pane{ + newPane(f, 0, rendererFactory(0)), + newPane(f, 1, rendererFactory(1)), + } + for i := range f.panes { + if renderer, ok := f.panes[i].renderer.(paneRendererQueue); ok { + renderer.setQueueUI(f.queueUI) + } } - f.panes = [2]pane{newPane(f, 0), newPane(f, 1)} f.reveals = [2]paneReveal{newPaneReveal(f.panes[0].root), newPaneReveal(f.panes[1].root)} f.divider = newSwipeDivider(f) f.divider.Hide() @@ -138,16 +153,21 @@ func New(loader Loader, callbacks Callbacks) *Feature { f.layoutToggle.Disable() f.swap = widget.NewButton(lang.L("Swap"), f.swapSides) f.swap.Disable() + f.linkToggle = widget.NewButton(lang.L("Unlink"), f.ToggleLink) + f.linkToggle.Disable() + f.unlinkStatus = widget.NewLabel("") + f.unlinkStatus.Hide() back := widget.NewButton(lang.L("Back to Grid"), f.Close) - toolbarCard := newChromeCard(container.NewHBox(f.layoutToggle, f.swap, back)) - toolbar := container.NewHBox(layout.NewSpacer(), toolbarCard) + linkCard := newChromeCard(container.NewHBox(f.linkToggle, f.unlinkStatus)) + actionCard := newChromeCard(container.NewHBox(f.layoutToggle, f.swap, back)) + f.toolbar = container.NewHBox(linkCard, layout.NewSpacer(), actionCard) var badgeCards [2]*fyne.Container for i := range f.badges { f.badges[i] = widget.NewLabel("") badgeCards[i] = newChromeCard(f.badges[i]) } badges := container.NewHBox(badgeCards[0], layout.NewSpacer(), badgeCards[1]) - chrome := container.NewBorder(toolbar, badges, nil, nil) + chrome := container.NewBorder(f.toolbar, badges, nil, nil) backdrop := canvas.NewRectangle(theme.Color(theme.ColorNameBackground)) // The comparison surface sits in the main window's root stack even while // hidden. Keep its minimum size at zero so merely registering the feature @@ -221,7 +241,8 @@ func (f *Feature) Overlay() fyne.CanvasObject { return f.overlay } // Visible reports whether a comparison session owns the main-window surface. func (f *Feature) Visible() bool { return f.active } -// Ready reports whether both panes hold a decoded first frame. +// Ready reports whether both panes hold a decoded first frame and a +// display-ready overview. func (f *Feature) Ready() bool { return f.ready } // Done returns the replaceable completion signal for the latest Open call. @@ -236,8 +257,14 @@ func (f *Feature) Open(sources [2]fyne.URI) { f.active = true f.ready = false - f.transform = defaultLinkedTransform() + initialTransform := defaultPhotoTransform() + f.photoTransforms = [2]photoTransform{initialTransform, initialTransform} + f.camera = defaultCameraTransform() + f.unlinked = false + f.hoveredPane = -1 + f.syncLinkControls() f.resetLayout() + f.linkToggle.Disable() f.layoutToggle.Disable() f.swap.Disable() f.sources = sources @@ -248,8 +275,9 @@ func (f *Feature) Open(sources [2]fyne.URI) { f.notifyOrderChanged() for i := range f.panes { f.loaded[i] = nil - f.panes[i].image.Image = nil - f.panes[i].image.Hide() + f.rendered[i] = nil + f.renderSources[i] = nil + f.panes[i].renderer.Present(paneScene{}) f.panes[i].spinner.Show() } f.overlay.Show() @@ -283,65 +311,141 @@ func (f *Feature) Settle(ctx context.Context) error { // Every worker queues its UI completion before marking itself done. // A drained load completion can start vector work, so repeat until // both worker sets and the queue are empty at the same boundary. - if err := waitWithContext(ctx, f.workers.Wait); err != nil { + if err := f.workers.WaitContext(ctx); err != nil { return err } for i := range f.vectors { - if err := waitWithContext(ctx, f.vectors[i].pending.Wait); err != nil { + if err := f.vectors[i].pending.WaitContext(ctx); err != nil { return err } } - if f.ui.Drain() { + // A queued vector completion replaces its render source and cancels + // obsolete tile work. Apply every upstream completion before waiting + // on renderers or that cancellation dependency can deadlock Settle. + if advanced, err := f.settleUI(ctx); err != nil { + return err + } else if advanced { continue } - if f.uiCount.Load() == 0 { - return nil + for i := range f.panes { + if err := f.panes[i].renderer.Wait(ctx); err != nil { + return err + } } - if err := waitWithContext(ctx, f.uiPending.Wait); err != nil { + if advanced, err := f.settleUI(ctx); err != nil { return err + } else if !advanced { + return nil } } } -func waitWithContext(ctx context.Context, wait func()) error { - done := make(chan struct{}) - go func() { - wait() - close(done) - }() - select { - case <-done: - return nil - case <-ctx.Done(): - return ctx.Err() +func (f *Feature) settleUI(ctx context.Context) (bool, error) { + if f.ui.Drain() { + return true, nil } + if f.uiCount.Load() == 0 { + return false, nil + } + if err := f.uiPending.WaitContext(ctx); err != nil { + return false, err + } + return true, nil } func (f *Feature) hide() { f.clearVectorRasters() f.active = false f.ready = false + f.unlinked = false + f.hoveredPane = -1 + f.syncLinkControls() + f.linkToggle.Disable() f.layoutToggle.Disable() f.swap.Disable() f.sources = [2]fyne.URI{} f.identities = [2]string{} f.loaded = [2]*imaging.LoadedImage{} f.rendered = [2]image.Image{} + f.renderSources = [2]*renderSource{} for i := range f.panes { f.badges[i].SetText("") - f.panes[i].image.Image = nil - f.panes[i].image.Hide() + f.panes[i].renderer.Present(paneScene{}) f.panes[i].spinner.Hide() } f.overlay.Hide() f.repaint() } +func (f *Feature) currentModifiers() fyne.KeyModifier { + if f.callbacks.Modifiers == nil { + return 0 + } + return f.callbacks.Modifiers() +} + +// ToggleLink switches a ready comparison between photo-local and shared-camera +// input. Loading or inactive comparisons ignore it. The visible photo poses and +// camera stay unchanged in either direction. +func (f *Feature) ToggleLink() { + if !f.active || !f.ready { + return + } + f.unlinked = !f.unlinked + f.syncLinkControls() + f.repaint() +} + +func (f *Feature) setHoveredPane(index int) { + if index < 0 || index >= len(f.panes) { + return + } + if f.hoveredPane == index { + return + } + f.hoveredPane = index + f.syncLinkControls() +} + +func (f *Feature) syncLinkControls() { + if f.linkToggle != nil { + label := lang.L("Unlink") + if f.unlinked { + label = lang.L("Link") + } + f.linkToggle.SetText(label) + } + + if f.unlinkStatus == nil || !f.active || !f.unlinked { + if f.unlinkStatus != nil { + f.unlinkStatus.Hide() + } + if f.toolbar != nil { + f.toolbar.Refresh() + } + return + } + + text := lang.L("Unlinked") + switch f.hoveredPane { + case 0: + text = lang.L("Unlinked: Left") + case 1: + text = lang.L("Unlinked: Right") + } + f.unlinkStatus.SetText(text) + f.unlinkStatus.Show() + if f.toolbar != nil { + f.toolbar.Refresh() + } +} + type loadResult struct { - index int - uri fyne.URI - loaded *imaging.LoadedImage - err error + index int + uri fyne.URI + loaded *imaging.LoadedImage + prepared *renderSource + err error } func (f *Feature) load(token requestToken, sources [2]fyne.URI, done func()) { @@ -349,7 +453,14 @@ func (f *Feature) load(token requestToken, sources [2]fyne.URI, done func()) { for i, uri := range sources { go func() { loaded, err := f.loadOne(token.context(), uri) - results <- loadResult{index: i, uri: uri, loaded: loaded, err: err} + if err == nil { + err = validateLoaded(loaded) + } + var prepared *renderSource + if err == nil { + prepared, err = f.prepareSource(token.context(), loaded.Frames[0]) + } + results <- loadResult{index: i, uri: uri, loaded: loaded, prepared: prepared, err: err} }() } @@ -378,24 +489,17 @@ func (f *Feature) load(token requestToken, sources [2]fyne.URI, done func()) { return } - for _, result := range loaded { - if err := validateLoaded(result.loaded); err != nil { - f.fail(result.uri, err) - return - } - } - for i, result := range loaded { f.loaded[i] = result.loaded f.rendered[i] = result.loaded.Frames[0] + f.renderSources[i] = result.prepared f.vectors[i].setRaster(result.loaded.Frames[0]) - f.panes[i].image.Image = f.rendered[i] + f.panes[i].renderer.Present(paneScene{source: f.renderSources[i]}) f.panes[i].spinner.Hide() - f.panes[i].image.Show() - f.panes[i].image.Refresh() } f.ready = true f.applyTransform() + f.linkToggle.Enable() f.layoutToggle.Enable() f.swap.Enable() f.repaint() @@ -406,16 +510,27 @@ func (f *Feature) swapSides() { if !f.active || !f.ready { return } + reference := 0 + if f.hoveredPane >= 0 && f.hoveredPane < len(f.photoTransforms) { + reference = f.hoveredPane + } + if f.unlinked || f.photoTransforms[0] != f.photoTransforms[1] { + commonTransform := f.visiblePhotoTransform(reference) + f.photoTransforms = [2]photoTransform{commonTransform, commonTransform} + f.camera = defaultCameraTransform() + } + f.unlinked = false + f.syncLinkControls() f.sources[0], f.sources[1] = f.sources[1], f.sources[0] f.identities[0], f.identities[1] = f.identities[1], f.identities[0] f.clearVectorRequests() f.loaded[0], f.loaded[1] = f.loaded[1], f.loaded[0] f.rendered[0], f.rendered[1] = f.rendered[1], f.rendered[0] + f.renderSources[0], f.renderSources[1] = f.renderSources[1], f.renderSources[0] for i := range f.panes { f.badges[i].SetText(f.identities[i]) f.vectors[i].setRaster(f.rendered[i]) - f.panes[i].image.Image = f.rendered[i] - f.panes[i].image.Refresh() + f.panes[i].renderer.Present(paneScene{source: f.renderSources[i]}) } f.applyTransform() f.notifyOrderChanged() diff --git a/internal/ui/compare/compare_test.go b/internal/ui/compare/compare_test.go index 425ad01..daf4a47 100644 --- a/internal/ui/compare/compare_test.go +++ b/internal/ui/compare/compare_test.go @@ -1,4 +1,4 @@ -package compare_test +package compare import ( "context" @@ -7,6 +7,7 @@ import ( "image/color" "image/draw" "slices" + "strings" "sync/atomic" "testing" "time" @@ -21,12 +22,15 @@ import ( "fyne.io/fyne/v2/widget" "github.com/frathe/picfetch/internal/imaging" - "github.com/frathe/picfetch/internal/ui/compare" "github.com/frathe/picfetch/internal/uitest" ) const waitTimeout = 5 * time.Second +func newReferenceFeature(loader Loader, callbacks Callbacks) *Feature { + return newFeature(loader, callbacks, newCanvasPaneRenderer) +} + func walk(root fyne.CanvasObject, visit func(fyne.CanvasObject)) { visit(root) switch c := root.(type) { @@ -89,7 +93,7 @@ func buttonCard(t *testing.T, root fyne.CanvasObject, text string) (*fyne.Contai return card, background } -func waitForDone(t *testing.T, feature *compare.Feature) { +func waitForDone(t *testing.T, feature *Feature) { t.Helper() ctx, cancel := context.WithTimeout(context.Background(), waitTimeout) defer cancel() @@ -221,6 +225,20 @@ func paneCursorable(t *testing.T, pane renderedPane) desktop.Cursorable { return found } +func paneHoverable(t *testing.T, pane renderedPane) desktop.Hoverable { + t.Helper() + var found desktop.Hoverable + walk(pane.root, func(object fyne.CanvasObject) { + if hoverable, ok := object.(desktop.Hoverable); ok { + found = hoverable + } + }) + if found == nil { + t.Fatal("comparison pane has no hoverable view") + } + return found +} + func horizontalResizeTarget(t *testing.T, root fyne.CanvasObject) (fyne.CanvasObject, fyne.Draggable) { t.Helper() var object fyne.CanvasObject @@ -258,24 +276,15 @@ func approxPosition(a, b fyne.Position) bool { return uitest.ApproxEqual(a.X, b.X) && uitest.ApproxEqual(a.Y, b.Y) } -func assertPaneCoversOrCenters(t *testing.T, pane renderedPane) { +func assertPaneOverlapsCenter(t *testing.T, pane renderedPane) { t.Helper() - assertAxis := func(name string, position, imageSize, viewportSize float32) { - t.Helper() - if imageSize <= viewportSize+0.5 { - want := (viewportSize - imageSize) / 2 - if !uitest.ApproxEqual(position, want) { - t.Errorf("%s non-overflowing image position = %.3f, want centered %.3f", name, position, want) - } - return - } - if position > 0.01 || position+imageSize < viewportSize-0.01 { - t.Errorf("%s overflowing image span = %.3f..%.3f, want to cover 0..%.3f", - name, position, position+imageSize, viewportSize) - } + position, size, viewport := pane.image.Position(), pane.image.Size(), pane.root.Size() + center := fyne.NewPos(viewport.Width/2, viewport.Height/2) + if position.X > center.X+0.01 || position.X+size.Width < center.X-0.01 || + position.Y > center.Y+0.01 || position.Y+size.Height < center.Y-0.01 { + t.Errorf("image span %v..%v does not overlap pane center %v", position, + fyne.NewPos(position.X+size.Width, position.Y+size.Height), center) } - assertAxis("horizontal", pane.image.Position().X, pane.image.Size().Width, pane.root.Size().Width) - assertAxis("vertical", pane.image.Position().Y, pane.image.Size().Height, pane.root.Size().Height) } func labelTexts(root fyne.CanvasObject) []string { @@ -338,7 +347,7 @@ func TestCompareOverlay_ClosedSurfaceDoesNotChangeHostMinimumSize(t *testing.T) app := test.NewApp() t.Cleanup(app.Quit) - feature := compare.New(nil, compare.Callbacks{}) + feature := newReferenceFeature(nil, Callbacks{}) if got := feature.Overlay().MinSize(); got != (fyne.Size{}) { t.Fatalf("closed comparison overlay MinSize = %v, want zero so it cannot resize the host stack", got) } @@ -368,7 +377,7 @@ func TestCompareOverlay_OpensImmediatelyAndBackExitsWhileLoading(t *testing.T) { <-ctx.Done() return nil, ctx.Err() } - feature := compare.New(loader, compare.Callbacks{}) + feature := newReferenceFeature(loader, Callbacks{}) feature.Overlay().Resize(fyne.NewSize(640, 480)) feature.Open([2]fyne.URI{ storage.NewFileURI("left.png"), @@ -413,11 +422,11 @@ func TestCompareToolbar_SwapIsPermanentAndReadyGated(t *testing.T) { started := make(chan string, 2) release := make(chan struct{}) - feature := compare.New(func(_ context.Context, uri fyne.URI) (*imaging.LoadedImage, error) { + feature := newReferenceFeature(func(_ context.Context, uri fyne.URI) (*imaging.LoadedImage, error) { started <- uri.Name() <-release return loadedImage(32, 24), nil - }, compare.Callbacks{}) + }, Callbacks{}) feature.Open([2]fyne.URI{ storage.NewFileURI("left.png"), storage.NewFileURI("right.png"), @@ -444,17 +453,95 @@ func TestCompareToolbar_SwapIsPermanentAndReadyGated(t *testing.T) { } } +func TestCompareLinkControl_TopLeftCardAndReadyGate(t *testing.T) { + app := test.NewApp() + t.Cleanup(app.Quit) + + started := make(chan string, 2) + release := make(chan struct{}) + t.Cleanup(func() { + select { + case <-release: + default: + close(release) + } + }) + feature := newReferenceFeature(func(_ context.Context, uri fyne.URI) (*imaging.LoadedImage, error) { + started <- uri.Name() + <-release + return loadedImage(32, 24), nil + }, Callbacks{}) + feature.Overlay().Resize(fyne.NewSize(640, 480)) + feature.Open([2]fyne.URI{ + storage.NewFileURI("left.png"), + storage.NewFileURI("right.png"), + }) + waitStarted(t, started) + waitStarted(t, started) + + unlink := comparisonButton(t, feature.Overlay(), "Unlink") + if !unlink.Visible() { + t.Fatal("Unlink is not a permanent comparison control") + } + if !unlink.Disabled() { + t.Error("Unlink is enabled before both images are ready") + } + + linkCard, linkBackground := buttonCard(t, feature.Overlay(), "Unlink") + swapCard, _ := buttonCard(t, feature.Overlay(), "Swap") + if linkCard == swapCard { + t.Fatal("Unlink and Swap share one toolbar card, want separate cards") + } + if _, _, _, alpha := linkBackground.FillColor.RGBA(); alpha == 0 || alpha == 0xffff { + t.Errorf("link card background alpha = %#x, want partial translucency", alpha) + } + if linkCard.Size().Width >= feature.Overlay().Size().Width/2 || linkCard.Size().Height >= feature.Overlay().Size().Height/2 { + t.Errorf("link card size = %v in %v overlay, want compact", linkCard.Size(), feature.Overlay().Size()) + } + if left := linkCard.Position().X; left < 0 || left > theme.Padding() { + t.Errorf("link card left gap = %v, want 0..%v", left, theme.Padding()) + } + if top := linkCard.Position().Y; top < 0 || top > theme.Padding() { + t.Errorf("link card top gap = %v, want 0..%v", top, theme.Padding()) + } + + if !containsButton(swapCard, "Back to Grid") { + t.Fatal("Swap card no longer contains Back to Grid") + } + if containsButton(swapCard, "Unlink") { + t.Error("Swap card contains Unlink, want it only in the top-left card") + } + if containsLabel(swapCard, "Unlinked") { + t.Error("Swap card contains the Unlinked label, want it only in the top-left card") + } + if gap := feature.Overlay().Size().Width - swapCard.Position().X - swapCard.Size().Width; gap < 0 || gap > theme.Padding() { + t.Errorf("Swap card right gap = %v, want 0..%v", gap, theme.Padding()) + } + if top := swapCard.Position().Y; top < 0 || top > theme.Padding() { + t.Errorf("Swap card top gap = %v, want 0..%v", top, theme.Padding()) + } + + close(release) + waitForDone(t, feature) + if got := comparisonButton(t, feature.Overlay(), "Unlink"); got != unlink { + t.Fatal("Unlink control was replaced when comparison became ready") + } + if unlink.Disabled() { + t.Error("Unlink stayed disabled after both images became ready") + } +} + func TestCompareSwipeToggle_PermanentReadyGatedAndRelabels(t *testing.T) { app := test.NewApp() t.Cleanup(app.Quit) started := make(chan string, 2) release := make(chan struct{}) - feature := compare.New(func(_ context.Context, uri fyne.URI) (*imaging.LoadedImage, error) { + feature := newReferenceFeature(func(_ context.Context, uri fyne.URI) (*imaging.LoadedImage, error) { started <- uri.Name() <-release return loadedImage(32, 24), nil - }, compare.Callbacks{}) + }, Callbacks{}) feature.Open([2]fyne.URI{ storage.NewFileURI("left.png"), storage.NewFileURI("right.png"), @@ -493,12 +580,12 @@ func TestCompareSwipeLayout_UsesAlignedFullViewportImagesAndKeepsChrome(t *testi left := solidLoadedImage(800, 400, color.RGBA{R: 255, A: 255}) right := solidLoadedImage(600, 300, color.RGBA{B: 255, A: 255}) - feature := compare.New(func(_ context.Context, uri fyne.URI) (*imaging.LoadedImage, error) { + feature := newReferenceFeature(func(_ context.Context, uri fyne.URI) (*imaging.LoadedImage, error) { if uri.Name() == "left.png" { return left, nil } return right, nil - }, compare.Callbacks{}) + }, Callbacks{}) win := test.NewWindow(feature.Overlay()) win.SetPadded(false) win.Resize(fyne.NewSize(800, 400)) @@ -552,9 +639,9 @@ func TestCompareSwipePointer_DividerDragChangesRevealWithoutPanning(t *testing.T app := test.NewApp() t.Cleanup(app.Quit) - feature := compare.New(func(_ context.Context, _ fyne.URI) (*imaging.LoadedImage, error) { + feature := newReferenceFeature(func(_ context.Context, _ fyne.URI) (*imaging.LoadedImage, error) { return loadedImage(1600, 800), nil - }, compare.Callbacks{}) + }, Callbacks{}) win := test.NewWindow(feature.Overlay()) win.SetPadded(false) win.Resize(fyne.NewSize(800, 400)) @@ -613,13 +700,13 @@ func TestCompareSwipePointer_DividerDragDoesNotRefreshStaticContent(t *testing.T {Image: image.NewRGBA(image.Rect(0, 0, 1600, 800))}, } var repaints atomic.Int64 - feature := compare.New(func(_ context.Context, uri fyne.URI) (*imaging.LoadedImage, error) { + feature := newReferenceFeature(func(_ context.Context, uri fyne.URI) (*imaging.LoadedImage, error) { index := 0 if uri.Name() == "right.png" { index = 1 } return &imaging.LoadedImage{Frames: []image.Image{frames[index]}}, nil - }, compare.Callbacks{Repaint: func() { repaints.Add(1) }}) + }, Callbacks{Repaint: func() { repaints.Add(1) }}) win := test.NewWindow(feature.Overlay()) win.SetPadded(false) win.Resize(fyne.NewSize(800, 400)) @@ -667,14 +754,66 @@ func TestCompareSwipePointer_DividerDragDoesNotRefreshStaticContent(t *testing.T } } +func TestCompareInteraction_PanAndZoomDoNotRepaintOwner(t *testing.T) { + for _, layout := range []struct { + name string + swipe bool + }{ + {name: "side by side"}, + {name: "swipe", swipe: true}, + } { + t.Run(layout.name, func(t *testing.T) { + app := test.NewApp() + t.Cleanup(app.Quit) + + var repaints atomic.Int64 + feature := newReferenceFeature(func(_ context.Context, _ fyne.URI) (*imaging.LoadedImage, error) { + return loadedImage(2400, 1600), nil + }, Callbacks{Repaint: func() { repaints.Add(1) }}) + win := test.NewWindow(feature.Overlay()) + win.SetPadded(false) + win.Resize(fyne.NewSize(800, 400)) + t.Cleanup(win.Close) + feature.Open([2]fyne.URI{ + storage.NewFileURI("left.png"), + storage.NewFileURI("right.png"), + }) + waitForDone(t, feature) + if layout.swipe { + test.Tap(comparisonButton(t, feature.Overlay(), "Swipe")) + } + feature.HandleKey(fyne.KeyPlus) + panes := renderedPanes(feature.Overlay()) + if len(panes) != 2 { + t.Fatalf("rendered panes = %d, want 2", len(panes)) + } + draggable := paneDraggable(t, panes[0]) + scrollable := paneScrollable(t, panes[0]) + repaints.Store(0) + + for range 50 { + draggable.Dragged(&fyne.DragEvent{Dragged: fyne.NewDelta(1, 1)}) + scrollable.Scrolled(&fyne.ScrollEvent{ + PointEvent: fyne.PointEvent{Position: fyne.NewPos(200, 200)}, + Scrolled: fyne.NewDelta(0, 0.25), + }) + } + + if got := repaints.Load(); got != 0 { + t.Errorf("owner repaints during 100 pan/zoom events = %d, want 0", got) + } + }) + } +} + func TestCompareDividerKeys_StepClampAndNoopSideBySide(t *testing.T) { app := test.NewApp() t.Cleanup(app.Quit) var modifiers fyne.KeyModifier - feature := compare.New(func(_ context.Context, _ fyne.URI) (*imaging.LoadedImage, error) { + feature := newReferenceFeature(func(_ context.Context, _ fyne.URI) (*imaging.LoadedImage, error) { return loadedImage(800, 400), nil - }, compare.Callbacks{Modifiers: func() fyne.KeyModifier { return modifiers }}) + }, Callbacks{Modifiers: func() fyne.KeyModifier { return modifiers }}) win := test.NewWindow(feature.Overlay()) win.SetPadded(false) win.Resize(fyne.NewSize(800, 400)) @@ -718,13 +857,39 @@ func TestCompareDividerKeys_StepClampAndNoopSideBySide(t *testing.T) { assertDividerCenter(800) } -func TestCompareLayoutToggle_PreservesLinkedTransformAndDivider(t *testing.T) { +func TestCompareLinkToggle_DividerDragDoesNotRelinkPanes(t *testing.T) { + app := test.NewApp() + t.Cleanup(app.Quit) + + feature := newReferenceFeature(func(_ context.Context, _ fyne.URI) (*imaging.LoadedImage, error) { + return loadedImage(800, 400), nil + }, Callbacks{}) + win := test.NewWindow(feature.Overlay()) + win.SetPadded(false) + win.Resize(fyne.NewSize(800, 400)) + t.Cleanup(win.Close) + feature.Open([2]fyne.URI{ + storage.NewFileURI("left.png"), + storage.NewFileURI("right.png"), + }) + waitForDone(t, feature) + feature.ToggleLink() + test.Tap(comparisonButton(t, feature.Overlay(), "Swipe")) + + _, divider := horizontalResizeTarget(t, feature.Overlay()) + divider.Dragged(&fyne.DragEvent{Dragged: fyne.NewDelta(40, 0)}) + if got := labelTexts(feature.Overlay()); !slices.Contains(got, "Unlinked") { + t.Errorf("labels after unlinked divider drag = %v, want Unlinked", got) + } +} + +func TestCompareLayoutToggle_PreservesCameraAcrossRoundTripsAndDivider(t *testing.T) { app := test.NewApp() t.Cleanup(app.Quit) - feature := compare.New(func(_ context.Context, _ fyne.URI) (*imaging.LoadedImage, error) { + feature := newReferenceFeature(func(_ context.Context, _ fyne.URI) (*imaging.LoadedImage, error) { return loadedImage(1600, 800), nil - }, compare.Callbacks{}) + }, Callbacks{}) win := test.NewWindow(feature.Overlay()) win.SetPadded(false) win.Resize(fyne.NewSize(800, 400)) @@ -745,39 +910,44 @@ func TestCompareLayoutToggle_PreservesLinkedTransformAndDivider(t *testing.T) { test.Tap(comparisonButton(t, feature.Overlay(), "Swipe")) inSwipe := renderedPanes(feature.Overlay()) - if center := normalizedCenter(inSwipe[0]); !approxPosition(center, wantCenter) { - t.Errorf("normalized center after entering swipe = %v, want retained %v", center, wantCenter) - } + wantSwipeCenter := normalizedCenter(inSwipe[0]) if multiplier := inSwipe[0].image.Size().Width / 800; !uitest.ApproxEqual(multiplier, wantMultiplier) { t.Errorf("fit-relative multiplier after entering swipe = %.4f, want retained %.4f", multiplier, wantMultiplier) } feature.HandleKey(fyne.KeyRight) test.Tap(comparisonButton(t, feature.Overlay(), "Side by side")) + backSideBySide := renderedPanes(feature.Overlay()) + if center := normalizedCenter(backSideBySide[0]); !approxPosition(center, wantCenter) { + t.Errorf("side-by-side center after layout round trip = %v, want %v", center, wantCenter) + } + if multiplier := backSideBySide[0].image.Size().Width / 400; !uitest.ApproxEqual(multiplier, wantMultiplier) { + t.Errorf("side-by-side multiplier after layout round trip = %.4f, want %.4f", multiplier, wantMultiplier) + } test.Tap(comparisonButton(t, feature.Overlay(), "Swipe")) divider, _ := horizontalResizeTarget(t, feature.Overlay()) if center := divider.Position().X + divider.Size().Width/2; !uitest.ApproxEqual(center, 440) { t.Errorf("divider center after layout round trip = %.2f, want retained 440", center) } afterRoundTrip := renderedPanes(feature.Overlay()) - if center := normalizedCenter(afterRoundTrip[0]); !approxPosition(center, wantCenter) { - t.Errorf("normalized center after layout round trip = %v, want retained %v", center, wantCenter) + if center := normalizedCenter(afterRoundTrip[0]); !approxPosition(center, wantSwipeCenter) { + t.Errorf("swipe center after layout round trip = %v, want %v", center, wantSwipeCenter) } if multiplier := afterRoundTrip[0].image.Size().Width / 800; !uitest.ApproxEqual(multiplier, wantMultiplier) { t.Errorf("fit-relative multiplier after layout round trip = %.4f, want retained %.4f", multiplier, wantMultiplier) } } -func TestCompareLayoutTransition_PreservesFitStateAndDivider(t *testing.T) { +func TestCompareLayoutTransition_PreservesPhotoAndCameraStateOnRoundTrip(t *testing.T) { app := test.NewApp() t.Cleanup(app.Quit) - feature := compare.New(func(_ context.Context, uri fyne.URI) (*imaging.LoadedImage, error) { + feature := newReferenceFeature(func(_ context.Context, uri fyne.URI) (*imaging.LoadedImage, error) { if uri.Name() == "wide.png" { return loadedImage(1600, 800), nil } return loadedImage(600, 1200), nil - }, compare.Callbacks{}) + }, Callbacks{}) win := test.NewWindow(feature.Overlay()) win.SetPadded(false) win.Resize(fyne.NewSize(800, 400)) @@ -794,21 +964,21 @@ func TestCompareLayoutTransition_PreservesFitStateAndDivider(t *testing.T) { before := renderedPanes(feature.Overlay()) paneDraggable(t, before[0]).Dragged(&fyne.DragEvent{Dragged: fyne.NewDelta(40, 20)}) before = renderedPanes(feature.Overlay()) - wantCenter := normalizedCenter(before[0]) + wantSideCenters := [2]fyne.Position{normalizedCenter(before[0]), normalizedCenter(before[1])} wantMultiplier := before[0].image.Size().Width / 400 - if approxPosition(wantCenter, fyne.NewPos(0.5, 0.5)) || wantMultiplier <= 1 { - t.Fatalf("transition setup = {center:%v multiplier:%.4f}, want a panned zoomed view", wantCenter, wantMultiplier) + if approxPosition(wantSideCenters[0], fyne.NewPos(0.5, 0.5)) || wantMultiplier <= 1 { + t.Fatalf("transition setup = {center:%v multiplier:%.4f}, want a panned zoomed view", wantSideCenters[0], wantMultiplier) } - assertState := func(name string, fitted [2]fyne.Size) { + assertState := func(name string, fitted [2]fyne.Size, wantCenters [2]fyne.Position) { t.Helper() panes := renderedPanes(feature.Overlay()) if len(panes) != 2 { t.Fatalf("%s rendered panes = %d, want 2", name, len(panes)) } for i, pane := range panes { - if center := normalizedCenter(pane); !approxPosition(center, wantCenter) { - t.Errorf("%s pane %d center = %v, want retained %v", name, i, center, wantCenter) + if center := normalizedCenter(pane); !approxPosition(center, wantCenters[i]) { + t.Errorf("%s pane %d center = %v, want retained %v", name, i, center, wantCenters[i]) } widthMultiplier := pane.image.Size().Width / fitted[i].Width heightMultiplier := pane.image.Size().Height / fitted[i].Height @@ -820,62 +990,55 @@ func TestCompareLayoutTransition_PreservesFitStateAndDivider(t *testing.T) { } test.Tap(comparisonButton(t, feature.Overlay(), "Swipe")) - assertState("swipe", [2]fyne.Size{fyne.NewSize(800, 400), fyne.NewSize(200, 400)}) + inSwipe := renderedPanes(feature.Overlay()) + wantSwipeCenters := [2]fyne.Position{normalizedCenter(inSwipe[0]), normalizedCenter(inSwipe[1])} + assertState("swipe", [2]fyne.Size{fyne.NewSize(800, 400), fyne.NewSize(200, 400)}, wantSwipeCenters) feature.HandleKey(fyne.KeyRight) test.Tap(comparisonButton(t, feature.Overlay(), "Side by side")) - assertState("side by side", [2]fyne.Size{fyne.NewSize(400, 200), fyne.NewSize(200, 400)}) + assertState("side by side", [2]fyne.Size{fyne.NewSize(400, 200), fyne.NewSize(200, 400)}, wantSideCenters) test.Tap(comparisonButton(t, feature.Overlay(), "Swipe")) - assertState("swipe round trip", [2]fyne.Size{fyne.NewSize(800, 400), fyne.NewSize(200, 400)}) + assertState("swipe round trip", [2]fyne.Size{fyne.NewSize(800, 400), fyne.NewSize(200, 400)}, wantSwipeCenters) divider, _ := horizontalResizeTarget(t, feature.Overlay()) if center := divider.Position().X + divider.Size().Width/2; !uitest.ApproxEqual(center, 440) { t.Errorf("divider after layout round trip = %.2f, want retained 440", center) } } -func TestCompareResize_PreservesFitStateAndReclampsCenter(t *testing.T) { +func TestCompareResize_PreservesPhotoAndCameraStateOnRoundTrip(t *testing.T) { for _, tc := range []struct { name string swipe bool - proportionalSize fyne.Size proportionalFitted fyne.Size - clampingSize fyne.Size - clampingFitted fyne.Size - wantClampedCenterX float32 + wideSize fyne.Size wantProportionalDivider float32 - wantClampedDivider float32 + wantWideDivider float32 }{ { name: "side by side", - proportionalSize: fyne.NewSize(1000, 500), proportionalFitted: fyne.NewSize(500, 250), - clampingSize: fyne.NewSize(2400, 400), - clampingFitted: fyne.NewSize(800, 400), - wantClampedCenterX: 0.48, + wideSize: fyne.NewSize(2400, 400), }, { name: "swipe", swipe: true, - proportionalSize: fyne.NewSize(1000, 500), proportionalFitted: fyne.NewSize(1000, 500), - clampingSize: fyne.NewSize(2000, 400), - clampingFitted: fyne.NewSize(800, 400), - wantClampedCenterX: 0.5, + wideSize: fyne.NewSize(2000, 400), wantProportionalDivider: 550, - wantClampedDivider: 1100, + wantWideDivider: 1100, }, } { t.Run(tc.name, func(t *testing.T) { app := test.NewApp() t.Cleanup(app.Quit) - feature := compare.New(func(_ context.Context, uri fyne.URI) (*imaging.LoadedImage, error) { + feature := newReferenceFeature(func(_ context.Context, uri fyne.URI) (*imaging.LoadedImage, error) { if uri.Name() == "large.png" { return loadedImage(1600, 800), nil } return loadedImage(1200, 600), nil - }, compare.Callbacks{}) + }, Callbacks{}) win := test.NewWindow(feature.Overlay()) win.SetPadded(false) win.Resize(fyne.NewSize(800, 400)) @@ -893,34 +1056,37 @@ func TestCompareResize_PreservesFitStateAndReclampsCenter(t *testing.T) { feature.HandleKey(fyne.KeyPlus) panes := renderedPanes(feature.Overlay()) - paneDraggable(t, panes[0]).Dragged(&fyne.DragEvent{Dragged: fyne.NewDelta(10000, 0)}) + paneDraggable(t, panes[0]).Dragged(&fyne.DragEvent{Dragged: fyne.NewDelta(40, 20)}) panes = renderedPanes(feature.Overlay()) - wantCenter := fyne.NewPos(0.32, 0.5) - if center := normalizedCenter(panes[0]); !approxPosition(center, wantCenter) { - t.Fatalf("initial clamped center = %v, want %v", center, wantCenter) + wantInitial := [2]struct { + size fyne.Size + position fyne.Position + }{ + {size: panes[0].image.Size(), position: panes[0].image.Position()}, + {size: panes[1].image.Size(), position: panes[1].image.Position()}, } - assertResizeState := func(name string, fitted fyne.Size, wantCenter fyne.Position) { + assertRoundTrip := func(name string) { t.Helper() panes := renderedPanes(feature.Overlay()) - if len(panes) != 2 { - t.Fatalf("%s rendered panes = %d, want 2", name, len(panes)) - } for i, pane := range panes { - if center := normalizedCenter(pane); !approxPosition(center, wantCenter) { - t.Errorf("%s pane %d center = %v, want %v", name, i, center, wantCenter) + if !uitest.ApproxEqual(pane.image.Size().Width, wantInitial[i].size.Width) || + !uitest.ApproxEqual(pane.image.Size().Height, wantInitial[i].size.Height) || + !approxPosition(pane.image.Position(), wantInitial[i].position) { + t.Errorf("%s pane %d geometry = {%v %v}, want {%v %v}", name, i, + pane.image.Size(), pane.image.Position(), wantInitial[i].size, wantInitial[i].position) } - wantSize := fyne.NewSize(fitted.Width*1.5625, fitted.Height*1.5625) - if !uitest.ApproxEqual(pane.image.Size().Width, wantSize.Width) || - !uitest.ApproxEqual(pane.image.Size().Height, wantSize.Height) { - t.Errorf("%s pane %d image size = %v, want fit-relative %v", name, i, pane.image.Size(), wantSize) - } - assertPaneCoversOrCenters(t, pane) } } - win.Resize(tc.proportionalSize) - assertResizeState("proportional resize", tc.proportionalFitted, wantCenter) + win.Resize(fyne.NewSize(1000, 500)) + for i, pane := range renderedPanes(feature.Overlay()) { + wantSize := fyne.NewSize(tc.proportionalFitted.Width*1.5625, tc.proportionalFitted.Height*1.5625) + if !uitest.ApproxEqual(pane.image.Size().Width, wantSize.Width) || + !uitest.ApproxEqual(pane.image.Size().Height, wantSize.Height) { + t.Errorf("proportional resize pane %d size = %v, want %v", i, pane.image.Size(), wantSize) + } + } if tc.swipe { divider, _ := horizontalResizeTarget(t, feature.Overlay()) if center := divider.Position().X + divider.Size().Width/2; !uitest.ApproxEqual(center, tc.wantProportionalDivider) { @@ -928,29 +1094,32 @@ func TestCompareResize_PreservesFitStateAndReclampsCenter(t *testing.T) { } } - win.Resize(tc.clampingSize) - assertResizeState("clamping resize", tc.clampingFitted, fyne.NewPos(tc.wantClampedCenterX, 0.5)) + win.Resize(fyne.NewSize(800, 400)) + assertRoundTrip("proportional round trip") + + win.Resize(tc.wideSize) if tc.swipe { divider, _ := horizontalResizeTarget(t, feature.Overlay()) - if center := divider.Position().X + divider.Size().Width/2; !uitest.ApproxEqual(center, tc.wantClampedDivider) { - t.Errorf("clamping resize divider = %.2f, want %.2f", center, tc.wantClampedDivider) + if center := divider.Position().X + divider.Size().Width/2; !uitest.ApproxEqual(center, tc.wantWideDivider) { + t.Errorf("wide resize divider = %.2f, want %.2f", center, tc.wantWideDivider) } } + win.Resize(fyne.NewSize(800, 400)) + assertRoundTrip("wide round trip") }) } } -func TestCompareActualSizeTransition_PreservesOneToOneScale(t *testing.T) { +func TestCompareCameraHome_PreservesDivergentPhotoPosesAcrossTransitions(t *testing.T) { app := test.NewApp() t.Cleanup(app.Quit) - nativeSizes := [2]fyne.Size{fyne.NewSize(1600, 800), fyne.NewSize(1200, 600)} - feature := compare.New(func(_ context.Context, uri fyne.URI) (*imaging.LoadedImage, error) { + feature := newReferenceFeature(func(_ context.Context, uri fyne.URI) (*imaging.LoadedImage, error) { if uri.Name() == "large.png" { return loadedImage(1600, 800), nil } return loadedImage(1200, 600), nil - }, compare.Callbacks{}) + }, Callbacks{}) win := test.NewWindow(feature.Overlay()) win.SetPadded(false) win.Resize(fyne.NewSize(800, 400)) @@ -960,54 +1129,68 @@ func TestCompareActualSizeTransition_PreservesOneToOneScale(t *testing.T) { storage.NewFileURI("small.png"), }) waitForDone(t, feature) - feature.HandleKey(fyne.Key1) - + feature.ToggleLink() panes := renderedPanes(feature.Overlay()) - paneDraggable(t, panes[0]).Dragged(&fyne.DragEvent{Dragged: fyne.NewDelta(100, 50)}) + paneHoverable(t, panes[0]).MouseIn(&desktop.MouseEvent{}) + feature.HandleKey(fyne.KeyPlus) panes = renderedPanes(feature.Overlay()) - wantCenter := fyne.NewPos(0.4375, 0.4375) - if center := normalizedCenter(panes[0]); !approxPosition(center, wantCenter) { - t.Fatalf("actual-size setup center = %v, want %v", center, wantCenter) - } + paneDraggable(t, panes[0]).Dragged(&fyne.DragEvent{Dragged: fyne.NewDelta(40, 20)}) + paneHoverable(t, renderedPanes(feature.Overlay())[1]).MouseIn(&desktop.MouseEvent{}) + feature.HandleKey(fyne.KeyMinus) + feature.ToggleLink() - assertActual := func(name string, wantCenter fyne.Position) { - t.Helper() + type geometry struct { + size fyne.Size + position fyne.Position + } + capture := func() [2]geometry { panes := renderedPanes(feature.Overlay()) - if len(panes) != 2 { - t.Fatalf("%s rendered panes = %d, want 2", name, len(panes)) + return [2]geometry{ + {size: panes[0].image.Size(), position: panes[0].image.Position()}, + {size: panes[1].image.Size(), position: panes[1].image.Position()}, } + } + assertGeometry := func(name string, want [2]geometry) { + t.Helper() + panes := renderedPanes(feature.Overlay()) for i, pane := range panes { - if pane.image.Size() != nativeSizes[i] { - t.Errorf("%s pane %d size = %v, want native 1:1 size %v", name, i, pane.image.Size(), nativeSizes[i]) - } - if center := normalizedCenter(pane); !approxPosition(center, wantCenter) { - t.Errorf("%s pane %d center = %v, want closest valid %v", name, i, center, wantCenter) + if !uitest.ApproxEqual(pane.image.Size().Width, want[i].size.Width) || + !uitest.ApproxEqual(pane.image.Size().Height, want[i].size.Height) || + !approxPosition(pane.image.Position(), want[i].position) { + t.Errorf("%s pane %d geometry = {%v %v}, want {%v %v}", name, i, + pane.image.Size(), pane.image.Position(), want[i].size, want[i].position) } - assertPaneCoversOrCenters(t, pane) } } + homeSideBySide := capture() + feature.HandleKey(fyne.KeyPlus) + paneDraggable(t, renderedPanes(feature.Overlay())[0]).Dragged(&fyne.DragEvent{Dragged: fyne.NewDelta(30, 15)}) + feature.HandleKey(fyne.Key1) + assertGeometry("side-by-side camera home", homeSideBySide) + test.Tap(comparisonButton(t, feature.Overlay(), "Swipe")) - assertActual("swipe", wantCenter) + homeSwipe := capture() + feature.HandleKey(fyne.KeyPlus) + paneDraggable(t, renderedPanes(feature.Overlay())[0]).Dragged(&fyne.DragEvent{Dragged: fyne.NewDelta(-20, 10)}) + feature.HandleKey(fyne.Key1) + assertGeometry("swipe camera home", homeSwipe) win.Resize(fyne.NewSize(1000, 500)) - assertActual("resized swipe", wantCenter) - - win.Resize(fyne.NewSize(2000, 500)) - clampedCenter := fyne.NewPos(0.5, wantCenter.Y) - assertActual("wide swipe", clampedCenter) - - test.Tap(comparisonButton(t, feature.Overlay(), "Side by side")) - assertActual("wide side by side", clampedCenter) + homeResized := capture() + feature.HandleKey(fyne.KeyMinus) + paneDraggable(t, renderedPanes(feature.Overlay())[1]).Dragged(&fyne.DragEvent{Dragged: fyne.NewDelta(15, -10)}) + feature.HandleKey(fyne.Key1) + assertGeometry("resized camera home", homeResized) } func TestCompareDividerReset_NewOpenStartsSideBySideAtHalf(t *testing.T) { app := test.NewApp() t.Cleanup(app.Quit) - feature := compare.New(func(_ context.Context, _ fyne.URI) (*imaging.LoadedImage, error) { + feature := newReferenceFeature(func(_ context.Context, _ fyne.URI) (*imaging.LoadedImage, error) { return loadedImage(800, 400), nil - }, compare.Callbacks{}) + }, Callbacks{}) win := test.NewWindow(feature.Overlay()) win.SetPadded(false) win.Resize(fyne.NewSize(800, 400)) @@ -1046,9 +1229,9 @@ func TestCompareSessionReset_StartsCanonicalState(t *testing.T) { "next-right.png": loadedImage(200, 800), } var orders [][2]string - feature := compare.New(func(_ context.Context, uri fyne.URI) (*imaging.LoadedImage, error) { + feature := newReferenceFeature(func(_ context.Context, uri fyne.URI) (*imaging.LoadedImage, error) { return images[uri.Name()], nil - }, compare.Callbacks{OrderChanged: func(left, right string) { + }, Callbacks{OrderChanged: func(left, right string) { orders = append(orders, [2]string{left, right}) }}) win := test.NewWindow(feature.Overlay()) @@ -1071,9 +1254,20 @@ func TestCompareSessionReset_StartsCanonicalState(t *testing.T) { panes := renderedPanes(feature.Overlay()) paneDraggable(t, panes[0]).Dragged(&fyne.DragEvent{Dragged: fyne.NewDelta(40, 20)}) test.Tap(comparisonButton(t, feature.Overlay(), "Swap")) + feature.ToggleLink() + if got := labelTexts(feature.Overlay()); !slices.ContainsFunc(got, func(text string) bool { + return strings.HasPrefix(text, "Unlinked") + }) { + t.Fatalf("first session labels before close = %v, want Unlinked", got) + } feature.Close() open("next-left.png", "next-right.png") + for _, text := range labelTexts(feature.Overlay()) { + if strings.HasPrefix(text, "Unlinked") { + t.Fatalf("new session labels = %v, want linked reset", labelTexts(feature.Overlay())) + } + } if !containsButton(feature.Overlay(), "Swipe") || containsButton(feature.Overlay(), "Side by side") { t.Fatal("new comparison did not reset to side-by-side layout") } @@ -1109,9 +1303,9 @@ func TestCompareToolbar_CompactTranslucentCardIsAtTopRight(t *testing.T) { app := test.NewApp() t.Cleanup(app.Quit) - feature := compare.New(func(_ context.Context, _ fyne.URI) (*imaging.LoadedImage, error) { + feature := newReferenceFeature(func(_ context.Context, _ fyne.URI) (*imaging.LoadedImage, error) { return loadedImage(32, 24), nil - }, compare.Callbacks{}) + }, Callbacks{}) feature.Overlay().Resize(fyne.NewSize(640, 480)) feature.Open([2]fyne.URI{ storage.NewFileURI("left.png"), @@ -1163,9 +1357,9 @@ func TestCompareIdentity_BadgesUseBasenamesAndShortestDistinguishingSuffix(t *te }, } { t.Run(tc.name, func(t *testing.T) { - feature := compare.New(func(_ context.Context, _ fyne.URI) (*imaging.LoadedImage, error) { + feature := newReferenceFeature(func(_ context.Context, _ fyne.URI) (*imaging.LoadedImage, error) { return loadedImage(32, 24), nil - }, compare.Callbacks{}) + }, Callbacks{}) feature.Open([2]fyne.URI{ storage.NewFileURI(tc.paths[0]), storage.NewFileURI(tc.paths[1]), @@ -1183,9 +1377,9 @@ func TestCompareIdentity_TranslucentBadgesStayAtBottomCorners(t *testing.T) { app := test.NewApp() t.Cleanup(app.Quit) - feature := compare.New(func(_ context.Context, _ fyne.URI) (*imaging.LoadedImage, error) { + feature := newReferenceFeature(func(_ context.Context, _ fyne.URI) (*imaging.LoadedImage, error) { return loadedImage(32, 24), nil - }, compare.Callbacks{}) + }, Callbacks{}) feature.Overlay().Resize(fyne.NewSize(640, 480)) feature.Open([2]fyne.URI{ storage.NewFileURI("/library/left.jpg"), @@ -1219,13 +1413,13 @@ func TestCompareSwap_ExchangesReadyRolesWithoutReload(t *testing.T) { left := loadedImage(101, 51) right := loadedImage(202, 52) var loads atomic.Int32 - feature := compare.New(func(_ context.Context, uri fyne.URI) (*imaging.LoadedImage, error) { + feature := newReferenceFeature(func(_ context.Context, uri fyne.URI) (*imaging.LoadedImage, error) { loads.Add(1) if uri.Name() == "left.png" { return left, nil } return right, nil - }, compare.Callbacks{}) + }, Callbacks{}) feature.Overlay().Resize(fyne.NewSize(801, 500)) feature.Open([2]fyne.URI{ storage.NewFileURI("/library/left.png"), @@ -1276,13 +1470,13 @@ func TestCompareSwapState_PreservesSessionAndExchangesSwipeRoles(t *testing.T) { right := solidLoadedImage(600, 1200, color.RGBA{B: 255, A: 255}) var loads atomic.Int32 var orders [][2]string - feature := compare.New(func(_ context.Context, uri fyne.URI) (*imaging.LoadedImage, error) { + feature := newReferenceFeature(func(_ context.Context, uri fyne.URI) (*imaging.LoadedImage, error) { loads.Add(1) if uri.Name() == "left.png" { return left, nil } return right, nil - }, compare.Callbacks{OrderChanged: func(left, right string) { + }, Callbacks{OrderChanged: func(left, right string) { orders = append(orders, [2]string{left, right}) }}) win := test.NewWindow(feature.Overlay()) @@ -1305,7 +1499,7 @@ func TestCompareSwapState_PreservesSessionAndExchangesSwipeRoles(t *testing.T) { if len(before) != 2 { t.Fatalf("rendered panes before Swap = %d, want 2", len(before)) } - wantCenter := normalizedCenter(before[0]) + beforeCenters := [2]fyne.Position{normalizedCenter(before[0]), normalizedCenter(before[1])} beforePositions := [2]fyne.Position{before[0].image.Position(), before[1].image.Position()} beforeSizes := [2]fyne.Size{before[0].image.Size(), before[1].image.Size()} beforeCapture := win.Canvas().Capture() @@ -1328,8 +1522,8 @@ func TestCompareSwapState_PreservesSessionAndExchangesSwipeRoles(t *testing.T) { t.Errorf("pane %d transformed geometry after Swap = {%v %v}, want prior source geometry {%v %v}", i, pane.image.Position(), pane.image.Size(), beforePositions[from], beforeSizes[from]) } - if center := normalizedCenter(pane); !approxPosition(center, wantCenter) { - t.Errorf("pane %d center after Swap = %v, want retained %v", i, center, wantCenter) + if center := normalizedCenter(pane); !approxPosition(center, beforeCenters[from]) { + t.Errorf("pane %d center after Swap = %v, want prior source center %v", i, center, beforeCenters[from]) } } if !containsButton(feature.Overlay(), "Side by side") { @@ -1363,12 +1557,12 @@ func TestCompareSideBySide_FitsFirstFramesInFixedEqualPanes(t *testing.T) { left := loadedImage(640, 320) right := loadedImage(300, 900) - feature := compare.New(func(_ context.Context, uri fyne.URI) (*imaging.LoadedImage, error) { + feature := newReferenceFeature(func(_ context.Context, uri fyne.URI) (*imaging.LoadedImage, error) { if uri.Name() == "left.png" { return left, nil } return right, nil - }, compare.Callbacks{}) + }, Callbacks{}) feature.Overlay().Resize(fyne.NewSize(801, 500)) feature.Open([2]fyne.URI{ storage.NewFileURI("left.png"), @@ -1404,12 +1598,12 @@ func TestCompareVector_RasterizesAtCurrentDisplaySize(t *testing.T) { t.Cleanup(app.Quit) vector := loadedVector(t, 40, 20) - feature := compare.New(func(_ context.Context, uri fyne.URI) (*imaging.LoadedImage, error) { + feature := newReferenceFeature(func(_ context.Context, uri fyne.URI) (*imaging.LoadedImage, error) { if uri.Name() == "left.svg" { return vector, nil } return loadedImage(40, 20), nil - }, compare.Callbacks{}) + }, Callbacks{}) feature.SetUIQueue(&uitest.UIQueue{}) feature.Overlay().Resize(fyne.NewSize(800, 400)) feature.Open([2]fyne.URI{ @@ -1431,17 +1625,57 @@ func TestCompareVector_RasterizesAtCurrentDisplaySize(t *testing.T) { } } +func TestCompareVector_UnlinkedZoomRerasterizesOnlyTheTargetPane(t *testing.T) { + app := test.NewApp() + t.Cleanup(app.Quit) + + vectors := [2]*imaging.LoadedImage{loadedVector(t, 40, 20), loadedVector(t, 40, 20)} + feature := newReferenceFeature(func(_ context.Context, uri fyne.URI) (*imaging.LoadedImage, error) { + if uri.Name() == "left.svg" { + return vectors[0], nil + } + return vectors[1], nil + }, Callbacks{}) + feature.SetUIQueue(&uitest.UIQueue{}) + feature.Overlay().Resize(fyne.NewSize(800, 400)) + feature.Open([2]fyne.URI{ + storage.NewFileURI("left.svg"), + storage.NewFileURI("right.svg"), + }) + settle := func() []renderedPane { + t.Helper() + ctx, cancel := context.WithTimeout(context.Background(), waitTimeout) + defer cancel() + if err := feature.Settle(ctx); err != nil { + t.Fatal("timed out waiting for comparison vector raster") + } + return renderedPanes(feature.Overlay()) + } + panes := settle() + feature.ToggleLink() + paneHoverable(t, panes[0]).MouseIn(&desktop.MouseEvent{}) + feature.HandleKey(fyne.KeyPlus) + panes = settle() + + if got := panes[0].image.Image.Bounds().Size(); got != image.Pt(500, 250) { + t.Errorf("target SVG raster after unlinked + = %v, want 500x250", got) + } + if got := panes[1].image.Image.Bounds().Size(); got != image.Pt(400, 200) { + t.Errorf("other SVG raster after unlinked + = %v, want unchanged 400x200", got) + } +} + func TestCompareVector_RerasterizesAcrossZoomLayoutResizeAndSwap(t *testing.T) { app := test.NewApp() t.Cleanup(app.Quit) vector := loadedVector(t, 40, 20) - feature := compare.New(func(_ context.Context, uri fyne.URI) (*imaging.LoadedImage, error) { + feature := newReferenceFeature(func(_ context.Context, uri fyne.URI) (*imaging.LoadedImage, error) { if uri.Name() == "left.svg" { return vector, nil } return loadedImage(40, 20), nil - }, compare.Callbacks{}) + }, Callbacks{}) feature.SetUIQueue(&uitest.UIQueue{}) feature.Overlay().Resize(fyne.NewSize(800, 400)) feature.Open([2]fyne.URI{ @@ -1487,12 +1721,12 @@ func TestCompareRasterFidelity_PreservesFullDecodedFramesAcrossTransforms(t *tes left := image.NewRGBA(image.Rect(0, 0, 1600, 900)) right := image.NewRGBA(image.Rect(0, 0, 800, 1200)) - feature := compare.New(func(_ context.Context, uri fyne.URI) (*imaging.LoadedImage, error) { + feature := newReferenceFeature(func(_ context.Context, uri fyne.URI) (*imaging.LoadedImage, error) { if uri.Name() == "left.png" { return &imaging.LoadedImage{Frames: []image.Image{left}}, nil } return &imaging.LoadedImage{Frames: []image.Image{right}}, nil - }, compare.Callbacks{}) + }, Callbacks{}) feature.Overlay().Resize(fyne.NewSize(800, 600)) feature.Open([2]fyne.URI{ storage.NewFileURI("left.png"), @@ -1531,12 +1765,12 @@ func TestCompareLinkedTransform_DifferentImagesShareCenterAndFitMultiplier(t *te app := test.NewApp() t.Cleanup(app.Quit) - feature := compare.New(func(_ context.Context, uri fyne.URI) (*imaging.LoadedImage, error) { + feature := newReferenceFeature(func(_ context.Context, uri fyne.URI) (*imaging.LoadedImage, error) { if uri.Name() == "wide.png" { return loadedImage(800, 400), nil } return loadedImage(200, 800), nil - }, compare.Callbacks{}) + }, Callbacks{}) feature.Overlay().Resize(fyne.NewSize(800, 400)) feature.Open([2]fyne.URI{ storage.NewFileURI("wide.png"), @@ -1568,41 +1802,50 @@ func TestCompareLinkedTransform_DifferentImagesShareCenterAndFitMultiplier(t *te } } -func TestCompareActualSize_UsesEachImagesOwnPixelDimensionsAndRecenters(t *testing.T) { +func TestCompareCameraHome_ReturnsToStoredPhotoArrangement(t *testing.T) { app := test.NewApp() t.Cleanup(app.Quit) - feature := compare.New(func(_ context.Context, uri fyne.URI) (*imaging.LoadedImage, error) { + feature := newReferenceFeature(func(_ context.Context, uri fyne.URI) (*imaging.LoadedImage, error) { if uri.Name() == "wide.png" { return loadedImage(800, 400), nil } return loadedImage(200, 800), nil - }, compare.Callbacks{}) + }, Callbacks{}) feature.Overlay().Resize(fyne.NewSize(800, 400)) feature.Open([2]fyne.URI{ storage.NewFileURI("wide.png"), storage.NewFileURI("tall.png"), }) waitForDone(t, feature) + feature.ToggleLink() + panes := renderedPanes(feature.Overlay()) + paneHoverable(t, panes[0]).MouseIn(&desktop.MouseEvent{}) + feature.HandleKey(fyne.Key1) + paneHoverable(t, renderedPanes(feature.Overlay())[1]).MouseIn(&desktop.MouseEvent{}) feature.HandleKey(fyne.KeyPlus) + feature.ToggleLink() + home := renderedPanes(feature.Overlay()) + wantSizes := [2]fyne.Size{home[0].image.Size(), home[1].image.Size()} + wantPositions := [2]fyne.Position{home[0].image.Position(), home[1].image.Position()} + feature.HandleKey(fyne.KeyPlus) + paneDraggable(t, renderedPanes(feature.Overlay())[0]).Dragged(&fyne.DragEvent{Dragged: fyne.NewDelta(30, 20)}) feature.HandleKey(fyne.Key1) - - panes := renderedPanes(feature.Overlay()) - wantSizes := [2]fyne.Size{fyne.NewSize(800, 400), fyne.NewSize(200, 800)} - wantPositions := [2]fyne.Position{fyne.NewPos(-200, 0), fyne.NewPos(100, -200)} + panes = renderedPanes(feature.Overlay()) for i, pane := range panes { - if pane.image.Size() != wantSizes[i] || pane.image.Position() != wantPositions[i] { - t.Errorf("pane %d at actual size = {%v %v}, want {%v %v}", + if pane.image.Size() != wantSizes[i] || !approxPosition(pane.image.Position(), wantPositions[i]) { + t.Errorf("pane %d at camera home = {%v %v}, want stored {%v %v}", i, pane.image.Position(), pane.image.Size(), wantPositions[i], wantSizes[i]) } } + feature.HandleKey(fyne.KeyPlus) panes = renderedPanes(feature.Overlay()) - wantZoomed := [2]fyne.Size{fyne.NewSize(1000, 500), fyne.NewSize(250, 1000)} for i, pane := range panes { - if pane.image.Size() != wantZoomed[i] { - t.Errorf("pane %d after actual size then + = %v, want absolute-step %v", i, pane.image.Size(), wantZoomed[i]) + want := fyne.NewSize(wantSizes[i].Width*1.25, wantSizes[i].Height*1.25) + if pane.image.Size() != want { + t.Errorf("pane %d after camera home then + = %v, want common 1.25x step %v", i, pane.image.Size(), want) } } } @@ -1611,12 +1854,12 @@ func TestCompareFit_ReturnsBothImagesToCanonicalCenteredFit(t *testing.T) { app := test.NewApp() t.Cleanup(app.Quit) - feature := compare.New(func(_ context.Context, uri fyne.URI) (*imaging.LoadedImage, error) { + feature := newReferenceFeature(func(_ context.Context, uri fyne.URI) (*imaging.LoadedImage, error) { if uri.Name() == "wide.png" { return loadedImage(800, 400), nil } return loadedImage(200, 800), nil - }, compare.Callbacks{}) + }, Callbacks{}) feature.Overlay().Resize(fyne.NewSize(800, 400)) feature.Open([2]fyne.URI{ storage.NewFileURI("wide.png"), @@ -1643,12 +1886,12 @@ func TestCompareZoom_MinusAndEqualScaleBothFromTheSharedView(t *testing.T) { app := test.NewApp() t.Cleanup(app.Quit) - feature := compare.New(func(_ context.Context, uri fyne.URI) (*imaging.LoadedImage, error) { + feature := newReferenceFeature(func(_ context.Context, uri fyne.URI) (*imaging.LoadedImage, error) { if uri.Name() == "wide.png" { return loadedImage(800, 400), nil } return loadedImage(200, 800), nil - }, compare.Callbacks{}) + }, Callbacks{}) feature.Overlay().Resize(fyne.NewSize(800, 400)) feature.Open([2]fyne.URI{ storage.NewFileURI("wide.png"), @@ -1674,16 +1917,16 @@ func TestCompareZoom_MinusAndEqualScaleBothFromTheSharedView(t *testing.T) { } } -func TestCompareZoom_WheelAnchorsOnePaneAndUpdatesTheSharedView(t *testing.T) { +func TestCompareCameraZoom_WheelAnchorsCorrespondingPointsInBothPanes(t *testing.T) { app := test.NewApp() t.Cleanup(app.Quit) - feature := compare.New(func(_ context.Context, uri fyne.URI) (*imaging.LoadedImage, error) { + feature := newReferenceFeature(func(_ context.Context, uri fyne.URI) (*imaging.LoadedImage, error) { if uri.Name() == "wide.png" { return loadedImage(800, 400), nil } return loadedImage(200, 800), nil - }, compare.Callbacks{}) + }, Callbacks{}) feature.Overlay().Resize(fyne.NewSize(800, 400)) feature.Open([2]fyne.URI{ storage.NewFileURI("wide.png"), @@ -1696,7 +1939,7 @@ func TestCompareZoom_WheelAnchorsOnePaneAndUpdatesTheSharedView(t *testing.T) { before := renderedPanes(feature.Overlay()) cursor := fyne.NewPos(220, 180) - anchored := normalizedPoint(before[0], cursor) + anchored := [2]fyne.Position{normalizedPoint(before[0], cursor), normalizedPoint(before[1], cursor)} leftWidth := before[0].image.Size().Width rightHeight := before[1].image.Size().Height paneScrollable(t, before[0]).Scrolled(&fyne.ScrollEvent{ @@ -1713,24 +1956,23 @@ func TestCompareZoom_WheelAnchorsOnePaneAndUpdatesTheSharedView(t *testing.T) { if !uitest.ApproxEqual(leftFactor, rightFactor) { t.Errorf("wheel multipliers = left %.4f right %.4f, want one shared multiplier", leftFactor, rightFactor) } - if got := normalizedPoint(after[0], cursor); !approxPosition(got, anchored) { - t.Errorf("normalized point under cursor after wheel = %v, want anchored %v", got, anchored) - } - if left, right := normalizedCenter(after[0]), normalizedCenter(after[1]); !approxPosition(left, right) { - t.Errorf("normalized centers after wheel = left %v right %v, want linked", left, right) + for i, pane := range after { + if got := normalizedPoint(pane, cursor); !approxPosition(got, anchored[i]) { + t.Errorf("pane %d normalized point under cursor after camera wheel = %v, want anchored %v", i, got, anchored[i]) + } } } -func TestCompareClamp_WheelUsesBothImagesValidPanRanges(t *testing.T) { +func TestCompareCameraClamp_WheelKeepsBothPhotosOverTheirPaneCenters(t *testing.T) { app := test.NewApp() t.Cleanup(app.Quit) - feature := compare.New(func(_ context.Context, uri fyne.URI) (*imaging.LoadedImage, error) { + feature := newReferenceFeature(func(_ context.Context, uri fyne.URI) (*imaging.LoadedImage, error) { if uri.Name() == "wide.png" { return loadedImage(800, 400), nil } return loadedImage(200, 800), nil - }, compare.Callbacks{}) + }, Callbacks{}) feature.Overlay().Resize(fyne.NewSize(800, 400)) feature.Open([2]fyne.URI{ storage.NewFileURI("wide.png"), @@ -1746,24 +1988,21 @@ func TestCompareClamp_WheelUsesBothImagesValidPanRanges(t *testing.T) { panes = renderedPanes(feature.Overlay()) for _, pane := range panes { - assertPaneCoversOrCenters(t, pane) - } - if left, right := normalizedCenter(panes[0]), normalizedCenter(panes[1]); !approxPosition(left, right) { - t.Errorf("normalized centers after clamp = left %v right %v, want linked", left, right) + assertPaneOverlapsCenter(t, pane) } } -func TestComparePanInputs_DragAndShiftWheelMoveTheSharedCenter(t *testing.T) { +func TestCompareCameraPan_DragAndShiftWheelMoveBothPhotosByTheSamePoints(t *testing.T) { app := test.NewApp() t.Cleanup(app.Quit) var modifiers fyne.KeyModifier - feature := compare.New(func(_ context.Context, uri fyne.URI) (*imaging.LoadedImage, error) { + feature := newReferenceFeature(func(_ context.Context, uri fyne.URI) (*imaging.LoadedImage, error) { if uri.Name() == "wide.png" { return loadedImage(800, 400), nil } return loadedImage(200, 800), nil - }, compare.Callbacks{Modifiers: func() fyne.KeyModifier { return modifiers }}) + }, Callbacks{Modifiers: func() fyne.KeyModifier { return modifiers }}) feature.Overlay().Resize(fyne.NewSize(800, 400)) feature.Open([2]fyne.URI{ storage.NewFileURI("wide.png"), @@ -1775,125 +2014,985 @@ func TestComparePanInputs_DragAndShiftWheelMoveTheSharedCenter(t *testing.T) { } before := renderedPanes(feature.Overlay()) - leftPosition := before[0].image.Position() + wantAfterDrag := [2]fyne.Position{ + before[0].image.Position().Add(fyne.NewPos(40, 20)), + before[1].image.Position().Add(fyne.NewPos(40, 20)), + } draggable := paneDraggable(t, before[0]) draggable.Dragged(&fyne.DragEvent{Dragged: fyne.NewDelta(40, 20)}) draggable.DragEnd() afterDrag := renderedPanes(feature.Overlay()) - if got := afterDrag[0].image.Position(); !approxPosition(got, leftPosition.Add(fyne.NewPos(40, 20))) { - t.Errorf("dragged pane position = %v, want %v", got, leftPosition.Add(fyne.NewPos(40, 20))) - } - if left, right := normalizedCenter(afterDrag[0]), normalizedCenter(afterDrag[1]); !approxPosition(left, right) { - t.Errorf("normalized centers after drag = left %v right %v, want linked", left, right) + for i, pane := range afterDrag { + if got := pane.image.Position(); !approxPosition(got, wantAfterDrag[i]) { + t.Errorf("camera-dragged pane %d position = %v, want %v", i, got, wantAfterDrag[i]) + } } modifiers = fyne.KeyModifierShift - rightPosition := afterDrag[1].image.Position() + wantAfterShiftWheel := [2]fyne.Position{ + afterDrag[0].image.Position().Add(fyne.NewPos(-15, 25)), + afterDrag[1].image.Position().Add(fyne.NewPos(-15, 25)), + } paneScrollable(t, afterDrag[1]).Scrolled(&fyne.ScrollEvent{Scrolled: fyne.NewDelta(-15, 25)}) afterShiftWheel := renderedPanes(feature.Overlay()) - if got := afterShiftWheel[1].image.Position(); !approxPosition(got, rightPosition.Add(fyne.NewPos(-15, 25))) { - t.Errorf("Shift+wheel pane position = %v, want %v", got, rightPosition.Add(fyne.NewPos(-15, 25))) - } - if left, right := normalizedCenter(afterShiftWheel[0]), normalizedCenter(afterShiftWheel[1]); !approxPosition(left, right) { - t.Errorf("normalized centers after Shift+wheel = left %v right %v, want linked", left, right) + for i, pane := range afterShiftWheel { + if got := pane.image.Position(); !approxPosition(got, wantAfterShiftWheel[i]) { + t.Errorf("camera Shift+wheel pane %d position = %v, want %v", i, got, wantAfterShiftWheel[i]) + } } } -func TestComparePanInputs_CursorReportsSharedPanAvailability(t *testing.T) { +func TestCompareLinkToggle_DragMovesOnlyGesturePaneWithoutHeldModifier(t *testing.T) { app := test.NewApp() t.Cleanup(app.Quit) - feature := compare.New(func(_ context.Context, uri fyne.URI) (*imaging.LoadedImage, error) { - if uri.Name() == "wide.png" { - return loadedImage(800, 400), nil - } - return loadedImage(200, 800), nil - }, compare.Callbacks{}) + feature := newReferenceFeature(func(_ context.Context, _ fyne.URI) (*imaging.LoadedImage, error) { + return loadedImage(800, 400), nil + }, Callbacks{}) feature.Overlay().Resize(fyne.NewSize(800, 400)) feature.Open([2]fyne.URI{ - storage.NewFileURI("wide.png"), - storage.NewFileURI("tall.png"), + storage.NewFileURI("left.png"), + storage.NewFileURI("right.png"), }) waitForDone(t, feature) + feature.ToggleLink() - panes := renderedPanes(feature.Overlay()) - if got := paneCursorable(t, panes[0]).Cursor(); got != desktop.DefaultCursor { - t.Errorf("fitted comparison cursor = %v, want default", got) - } - for range 7 { - feature.HandleKey(fyne.KeyPlus) + before := renderedPanes(feature.Overlay()) + wantLeft := before[0].image.Position().Add(fyne.NewPos(40, 20)) + wantRight := before[1].image.Position() + paneDraggable(t, before[0]).Dragged(&fyne.DragEvent{Dragged: fyne.NewDelta(40, 20)}) + + after := renderedPanes(feature.Overlay()) + if got := after[0].image.Position(); !approxPosition(got, wantLeft) { + t.Errorf("unlinked dragged pane position = %v, want %v", got, wantLeft) } - panes = renderedPanes(feature.Overlay()) - if got := paneCursorable(t, panes[0]).Cursor(); got != desktop.PointerCursor { - t.Errorf("pannable comparison cursor = %v, want pointer", got) + if got := after[1].image.Position(); !approxPosition(got, wantRight) { + t.Errorf("other pane position after unlinked drag = %v, want unchanged %v", got, wantRight) } } -func TestCompareNoOverscroll_RepeatedExtremePanStopsAtSharedBoundaries(t *testing.T) { +func TestCompareLinkToggle_WheelZoomsOnlyTheGesturePane(t *testing.T) { app := test.NewApp() t.Cleanup(app.Quit) - feature := compare.New(func(_ context.Context, uri fyne.URI) (*imaging.LoadedImage, error) { - if uri.Name() == "wide.png" { - return loadedImage(800, 400), nil - } - return loadedImage(200, 800), nil - }, compare.Callbacks{}) + feature := newReferenceFeature(func(_ context.Context, _ fyne.URI) (*imaging.LoadedImage, error) { + return loadedImage(800, 400), nil + }, Callbacks{}) feature.Overlay().Resize(fyne.NewSize(800, 400)) feature.Open([2]fyne.URI{ - storage.NewFileURI("wide.png"), - storage.NewFileURI("tall.png"), + storage.NewFileURI("left.png"), + storage.NewFileURI("right.png"), }) waitForDone(t, feature) - for range 7 { - feature.HandleKey(fyne.KeyPlus) - } + feature.ToggleLink() - for i := range 20 { - panes := renderedPanes(feature.Overlay()) - delta := fyne.NewDelta(10000, 10000) - if i%2 != 0 { - delta = fyne.NewDelta(-20000, -20000) - } - paneDraggable(t, panes[i%2]).Dragged(&fyne.DragEvent{Dragged: delta}) - panes = renderedPanes(feature.Overlay()) - for _, pane := range panes { - assertPaneCoversOrCenters(t, pane) - } + before := renderedPanes(feature.Overlay()) + leftWidth := before[0].image.Size().Width + wantRight := before[1].image.Size() + paneScrollable(t, before[0]).Scrolled(&fyne.ScrollEvent{ + PointEvent: fyne.PointEvent{Position: fyne.NewPos(200, 200)}, + Scrolled: fyne.NewDelta(0, 10), + }) + + after := renderedPanes(feature.Overlay()) + if after[0].image.Size().Width <= leftWidth { + t.Errorf("unlinked wheel pane width = %.2f, want greater than %.2f", after[0].image.Size().Width, leftWidth) + } + if got := after[1].image.Size(); got != wantRight { + t.Errorf("other pane size after unlinked wheel = %v, want unchanged %v", got, wantRight) } } -func TestCompareNoDrift_RepeatedInputOnEitherPaneKeepsOneCenter(t *testing.T) { +func TestCompareLinkToggle_ShowsUnlinkedStatusAndTracksLastHoveredPane(t *testing.T) { app := test.NewApp() t.Cleanup(app.Quit) - feature := compare.New(func(_ context.Context, uri fyne.URI) (*imaging.LoadedImage, error) { - if uri.Name() == "wide.png" { - return loadedImage(800, 400), nil - } - return loadedImage(200, 800), nil - }, compare.Callbacks{}) + feature := newReferenceFeature(func(_ context.Context, _ fyne.URI) (*imaging.LoadedImage, error) { + return loadedImage(800, 400), nil + }, Callbacks{}) feature.Overlay().Resize(fyne.NewSize(800, 400)) feature.Open([2]fyne.URI{ - storage.NewFileURI("wide.png"), - storage.NewFileURI("tall.png"), + storage.NewFileURI("left.png"), + storage.NewFileURI("right.png"), }) waitForDone(t, feature) - for range 7 { - feature.HandleKey(fyne.KeyPlus) - } - for i := range 100 { - panes := renderedPanes(feature.Overlay()) - delta := fyne.NewDelta(3, -2) - if i%2 != 0 { - delta = fyne.NewDelta(-3, 2) + unlink := comparisonButton(t, feature.Overlay(), "Unlink") + feature.ToggleLink() + if got := labelTexts(feature.Overlay()); !slices.Contains(got, "Unlinked") { + t.Fatalf("labels after first toggle = %v, want Unlinked", got) + } + link := comparisonButton(t, feature.Overlay(), "Link") + if link != unlink { + t.Fatal("link toggle was replaced instead of relabeled in place") + } + linkCard, _ := buttonCard(t, feature.Overlay(), "Link") + statusCard, _ := labelCard(t, feature.Overlay(), "Unlinked") + if statusCard != linkCard { + t.Fatal("Unlinked status is not beside Link in the top-left card") + } + var status *widget.Label + walk(linkCard, func(object fyne.CanvasObject) { + if label, ok := object.(*widget.Label); ok && label.Text == "Unlinked" { + status = label } - paneDraggable(t, panes[i%2]).Dragged(&fyne.DragEvent{Dragged: delta}) + }) + if status == nil { + t.Fatal("top-left link card has no visible Unlinked status") + } + if status.Position().X < link.Position().X+link.Size().Width { + t.Errorf("Unlinked status x = %v, want it after Link ending at %v", status.Position().X, link.Position().X+link.Size().Width) + } + + panes := renderedPanes(feature.Overlay()) + left := paneHoverable(t, panes[0]) + left.MouseIn(&desktop.MouseEvent{}) + if got := labelTexts(feature.Overlay()); !slices.Contains(got, "Unlinked: Left") { + t.Errorf("labels while left pane is targeted = %v, want Unlinked: Left", got) + } + left.MouseOut() + if got := labelTexts(feature.Overlay()); !slices.Contains(got, "Unlinked: Left") { + t.Errorf("labels after leaving left pane = %v, want last target retained", got) + } + + paneHoverable(t, panes[1]).MouseMoved(&desktop.MouseEvent{}) + if got := labelTexts(feature.Overlay()); !slices.Contains(got, "Unlinked: Right") { + t.Errorf("labels while right pane is targeted = %v, want Unlinked: Right", got) + } + + feature.ToggleLink() + if got := comparisonButton(t, feature.Overlay(), "Unlink"); got != unlink { + t.Fatal("relink replaced the comparison link control") + } + for _, text := range labelTexts(feature.Overlay()) { + if strings.HasPrefix(text, "Unlinked") { + t.Fatalf("labels after relink toggle = %v, want no unlink status", labelTexts(feature.Overlay())) + } + } +} + +func TestCompareLinkToggle_TransformKeysRequireAndOnlyAffectLastHoveredPane(t *testing.T) { + app := test.NewApp() + t.Cleanup(app.Quit) + + feature := newReferenceFeature(func(_ context.Context, _ fyne.URI) (*imaging.LoadedImage, error) { + return loadedImage(800, 400), nil + }, Callbacks{}) + feature.Overlay().Resize(fyne.NewSize(800, 400)) + feature.Open([2]fyne.URI{ + storage.NewFileURI("left.png"), + storage.NewFileURI("right.png"), + }) + waitForDone(t, feature) + feature.ToggleLink() + + before := renderedPanes(feature.Overlay()) + wantLeft := before[0].image.Size() + wantRight := before[1].image.Size() + feature.HandleKey(fyne.KeyPlus) + panes := renderedPanes(feature.Overlay()) + if panes[0].image.Size() != wantLeft || panes[1].image.Size() != wantRight { + t.Fatalf("unlinked + without a pane target changed sizes to %v and %v", panes[0].image.Size(), panes[1].image.Size()) + } + + paneHoverable(t, panes[1]).MouseIn(&desktop.MouseEvent{}) + feature.HandleKey(fyne.KeyPlus) + panes = renderedPanes(feature.Overlay()) + if panes[0].image.Size() != wantLeft { + t.Errorf("left pane after right-targeted + = %v, want unchanged %v", panes[0].image.Size(), wantLeft) + } + if panes[1].image.Size().Width <= wantRight.Width { + t.Errorf("right pane after right-targeted + = %v, want larger than %v", panes[1].image.Size(), wantRight) + } + + feature.HandleKey(fyne.Key1) + panes = renderedPanes(feature.Overlay()) + if got := panes[1].image.Size(); got != fyne.NewSize(800, 400) { + t.Errorf("right pane after right-targeted 1 = %v, want actual size", got) + } + if got := normalizedCenter(panes[1]); !approxPosition(got, fyne.NewPos(0.5, 0.5)) { + t.Errorf("right pane center after right-targeted 1 = %v, want centered", got) + } + if panes[0].image.Size() != wantLeft { + t.Errorf("left pane after right-targeted 1 = %v, want unchanged %v", panes[0].image.Size(), wantLeft) + } + + feature.HandleKey(fyne.Key0) + panes = renderedPanes(feature.Overlay()) + if panes[1].image.Size() != wantRight || !approxPosition(normalizedCenter(panes[1]), fyne.NewPos(0.5, 0.5)) { + t.Errorf("right pane after right-targeted 0 = {%v %v}, want fitted and centered", panes[1].image.Size(), normalizedCenter(panes[1])) + } +} + +func TestCompareLinkToggle_UnlockKeepsCurrentCameraView(t *testing.T) { + app := test.NewApp() + t.Cleanup(app.Quit) + + feature := newReferenceFeature(func(_ context.Context, _ fyne.URI) (*imaging.LoadedImage, error) { + return loadedImage(800, 400), nil + }, Callbacks{}) + feature.Overlay().Resize(fyne.NewSize(800, 400)) + feature.Open([2]fyne.URI{ + storage.NewFileURI("left.png"), + storage.NewFileURI("right.png"), + }) + waitForDone(t, feature) + panes := renderedPanes(feature.Overlay()) + + feature.ToggleLink() + paneHoverable(t, panes[0]).MouseIn(&desktop.MouseEvent{}) + feature.HandleKey(fyne.KeyPlus) + paneHoverable(t, panes[1]).MouseIn(&desktop.MouseEvent{}) + feature.ToggleLink() + + feature.HandleKey(fyne.KeyPlus) + linked := renderedPanes(feature.Overlay()) + if linked[0].image.Size().Width != 625 || linked[1].image.Size().Width != 500 { + t.Fatalf("linked camera widths after + = %.2f and %.2f, want 625 and 500", linked[0].image.Size().Width, linked[1].image.Size().Width) + } + want := [2]struct { + size fyne.Size + position fyne.Position + }{ + {size: linked[0].image.Size(), position: linked[0].image.Position()}, + {size: linked[1].image.Size(), position: linked[1].image.Position()}, + } + + feature.ToggleLink() + unlocked := renderedPanes(feature.Overlay()) + for i, pane := range unlocked { + if pane.image.Size() != want[i].size || pane.image.Position() != want[i].position { + t.Errorf("pane %d moved while unlocking: got {%v %v}, want {%v %v}", + i, pane.image.Size(), pane.image.Position(), want[i].size, want[i].position) + } + } +} + +func TestCompareLinkToggle_RelockKeepsDivergentPhotoPoses(t *testing.T) { + app := test.NewApp() + t.Cleanup(app.Quit) + + feature := newReferenceFeature(func(_ context.Context, _ fyne.URI) (*imaging.LoadedImage, error) { + return loadedImage(800, 400), nil + }, Callbacks{}) + feature.Overlay().Resize(fyne.NewSize(800, 400)) + feature.Open([2]fyne.URI{ + storage.NewFileURI("left.png"), + storage.NewFileURI("right.png"), + }) + waitForDone(t, feature) + + feature.ToggleLink() + panes := renderedPanes(feature.Overlay()) + paneHoverable(t, panes[0]).MouseIn(&desktop.MouseEvent{}) + feature.HandleKey(fyne.KeyPlus) + panes = renderedPanes(feature.Overlay()) + paneDraggable(t, panes[0]).Dragged(&fyne.DragEvent{Dragged: fyne.NewDelta(40, 20)}) + before := renderedPanes(feature.Overlay()) + want := [2]struct { + size fyne.Size + position fyne.Position + }{ + {size: before[0].image.Size(), position: before[0].image.Position()}, + {size: before[1].image.Size(), position: before[1].image.Position()}, + } + + feature.ToggleLink() + locked := renderedPanes(feature.Overlay()) + for i, pane := range locked { + if pane.image.Size() != want[i].size || pane.image.Position() != want[i].position { + t.Errorf("pane %d moved while locking: got {%v %v}, want {%v %v}", + i, pane.image.Size(), pane.image.Position(), want[i].size, want[i].position) + } + } +} + +func TestCompareLockedPan_MovesDivergentPhotoPosesAsOneCamera(t *testing.T) { + app := test.NewApp() + t.Cleanup(app.Quit) + + feature := newReferenceFeature(func(_ context.Context, _ fyne.URI) (*imaging.LoadedImage, error) { + return loadedImage(1600, 800), nil + }, Callbacks{}) + feature.Overlay().Resize(fyne.NewSize(800, 400)) + feature.Open([2]fyne.URI{ + storage.NewFileURI("left.png"), + storage.NewFileURI("right.png"), + }) + waitForDone(t, feature) + + feature.ToggleLink() + panes := renderedPanes(feature.Overlay()) + paneHoverable(t, panes[0]).MouseIn(&desktop.MouseEvent{}) + for range 3 { + feature.HandleKey(fyne.KeyPlus) + } + panes = renderedPanes(feature.Overlay()) + paneDraggable(t, panes[0]).Dragged(&fyne.DragEvent{Dragged: fyne.NewDelta(40, 20)}) + paneHoverable(t, renderedPanes(feature.Overlay())[1]).MouseIn(&desktop.MouseEvent{}) + feature.HandleKey(fyne.KeyPlus) + feature.ToggleLink() + + before := renderedPanes(feature.Overlay()) + want := [2]struct { + size fyne.Size + position fyne.Position + }{ + {size: before[0].image.Size(), position: before[0].image.Position()}, + {size: before[1].image.Size(), position: before[1].image.Position()}, + } + delta := fyne.NewDelta(20, 10) + paneDraggable(t, before[0]).Dragged(&fyne.DragEvent{Dragged: delta}) + after := renderedPanes(feature.Overlay()) + for i := range after { + if after[i].image.Size() != want[i].size { + t.Errorf("pane %d size after camera pan = %v, want unchanged %v", i, after[i].image.Size(), want[i].size) + } + if got, wantPosition := after[i].image.Position(), want[i].position.Add(delta); got != wantPosition { + t.Errorf("pane %d position after camera pan = %v, want %v", i, got, wantPosition) + } + } +} + +func TestCompareLockedFit_FramesDivergentPhotoPosesWithoutChangingTheirRatio(t *testing.T) { + app := test.NewApp() + t.Cleanup(app.Quit) + + feature := newReferenceFeature(func(_ context.Context, _ fyne.URI) (*imaging.LoadedImage, error) { + return loadedImage(1600, 800), nil + }, Callbacks{}) + feature.Overlay().Resize(fyne.NewSize(800, 400)) + feature.Open([2]fyne.URI{ + storage.NewFileURI("left.png"), + storage.NewFileURI("right.png"), + }) + waitForDone(t, feature) + + feature.ToggleLink() + panes := renderedPanes(feature.Overlay()) + paneHoverable(t, panes[0]).MouseIn(&desktop.MouseEvent{}) + for range 3 { + feature.HandleKey(fyne.KeyPlus) + } + panes = renderedPanes(feature.Overlay()) + paneDraggable(t, panes[0]).Dragged(&fyne.DragEvent{Dragged: fyne.NewDelta(80, 40)}) + paneHoverable(t, renderedPanes(feature.Overlay())[1]).MouseIn(&desktop.MouseEvent{}) + feature.HandleKey(fyne.KeyPlus) + panes = renderedPanes(feature.Overlay()) + paneDraggable(t, panes[1]).Dragged(&fyne.DragEvent{Dragged: fyne.NewDelta(-40, -20)}) + feature.ToggleLink() + + before := renderedPanes(feature.Overlay()) + wantRatio := before[0].image.Size().Width / before[1].image.Size().Width + feature.HandleKey(fyne.Key0) + after := renderedPanes(feature.Overlay()) + if got := after[0].image.Size().Width / after[1].image.Size().Width; !uitest.ApproxEqual(got, wantRatio) { + t.Errorf("photo width ratio after camera fit = %.4f, want retained %.4f", got, wantRatio) + } + for i, pane := range after { + position, size, viewport := pane.image.Position(), pane.image.Size(), pane.root.Size() + if position.X < -0.01 || position.Y < -0.01 || + position.X+size.Width > viewport.Width+0.01 || position.Y+size.Height > viewport.Height+0.01 { + t.Errorf("pane %d after camera fit spans %v..%v in %v, want fully visible", + i, position, fyne.NewPos(position.X+size.Width, position.Y+size.Height), viewport) + } + } +} + +func TestCompareUnlinkedFit_ResetsOnlyTargetInCurrentCameraView(t *testing.T) { + app := test.NewApp() + t.Cleanup(app.Quit) + + feature := newReferenceFeature(func(_ context.Context, _ fyne.URI) (*imaging.LoadedImage, error) { + return loadedImage(800, 400), nil + }, Callbacks{}) + feature.Overlay().Resize(fyne.NewSize(800, 400)) + feature.Open([2]fyne.URI{ + storage.NewFileURI("left.png"), + storage.NewFileURI("right.png"), + }) + waitForDone(t, feature) + for range 2 { + feature.HandleKey(fyne.KeyPlus) + } + panes := renderedPanes(feature.Overlay()) + paneDraggable(t, panes[0]).Dragged(&fyne.DragEvent{Dragged: fyne.NewDelta(30, 20)}) + feature.ToggleLink() + panes = renderedPanes(feature.Overlay()) + paneHoverable(t, panes[0]).MouseIn(&desktop.MouseEvent{}) + wantRightSize := panes[1].image.Size() + wantRightPosition := panes[1].image.Position() + + feature.HandleKey(fyne.Key0) + panes = renderedPanes(feature.Overlay()) + if got, want := panes[0].image.Size(), fyne.NewSize(400, 200); got != want { + t.Errorf("target size after unlinked fit = %v, want %v", got, want) + } + if got, want := panes[0].image.Position(), fyne.NewPos(0, 100); !approxPosition(got, want) { + t.Errorf("target position after unlinked fit = %v, want %v", got, want) + } + if panes[1].image.Size() != wantRightSize || panes[1].image.Position() != wantRightPosition { + t.Errorf("other pane changed during unlinked fit: got {%v %v}, want {%v %v}", + panes[1].image.Size(), panes[1].image.Position(), wantRightSize, wantRightPosition) + } +} + +func TestCompareCameraPan_SurvivesUnlockWithoutChangingGeometry(t *testing.T) { + app := test.NewApp() + t.Cleanup(app.Quit) + + feature := newReferenceFeature(func(_ context.Context, _ fyne.URI) (*imaging.LoadedImage, error) { + return loadedImage(1600, 800), nil + }, Callbacks{}) + feature.Overlay().Resize(fyne.NewSize(800, 400)) + feature.Open([2]fyne.URI{ + storage.NewFileURI("left.png"), + storage.NewFileURI("right.png"), + }) + waitForDone(t, feature) + + feature.ToggleLink() + panes := renderedPanes(feature.Overlay()) + paneHoverable(t, panes[0]).MouseIn(&desktop.MouseEvent{}) + for range 4 { + feature.HandleKey(fyne.KeyPlus) + } + paneDraggable(t, panes[0]).Dragged(&fyne.DragEvent{Dragged: fyne.NewDelta(70, 0)}) + paneHoverable(t, panes[1]).MouseIn(&desktop.MouseEvent{}) + for range 2 { + feature.HandleKey(fyne.KeyPlus) + } + feature.ToggleLink() + linkedBefore := renderedPanes(feature.Overlay()) + beforePositions := [2]fyne.Position{linkedBefore[0].image.Position(), linkedBefore[1].image.Position()} + paneDraggable(t, renderedPanes(feature.Overlay())[0]).Dragged(&fyne.DragEvent{Dragged: fyne.NewDelta(30, 0)}) + linkedAfter := renderedPanes(feature.Overlay()) + want := [2]struct { + size fyne.Size + position fyne.Position + }{ + {size: linkedAfter[0].image.Size(), position: linkedAfter[0].image.Position()}, + {size: linkedAfter[1].image.Size(), position: linkedAfter[1].image.Position()}, + } + for i := range linkedAfter { + if got, expected := linkedAfter[i].image.Position(), beforePositions[i].Add(fyne.NewPos(30, 0)); !approxPosition(got, expected) { + t.Errorf("pane %d camera-pan position = %v, want %v", i, got, expected) + } + } + + feature.ToggleLink() + unlocked := renderedPanes(feature.Overlay()) + for i := range unlocked { + if unlocked[i].image.Size() != want[i].size || !approxPosition(unlocked[i].image.Position(), want[i].position) { + t.Errorf("pane %d changed while unlocking after camera pan: got {%v %v}, want {%v %v}", + i, unlocked[i].image.Size(), unlocked[i].image.Position(), want[i].size, want[i].position) + } + } +} + +func TestCompareCameraWheel_PreservesDivergenceAndSurvivesUnlock(t *testing.T) { + app := test.NewApp() + t.Cleanup(app.Quit) + + feature := newReferenceFeature(func(_ context.Context, _ fyne.URI) (*imaging.LoadedImage, error) { + return loadedImage(1600, 800), nil + }, Callbacks{}) + feature.Overlay().Resize(fyne.NewSize(800, 400)) + feature.Open([2]fyne.URI{ + storage.NewFileURI("left.png"), + storage.NewFileURI("right.png"), + }) + waitForDone(t, feature) + + feature.ToggleLink() + panes := renderedPanes(feature.Overlay()) + paneHoverable(t, panes[0]).MouseIn(&desktop.MouseEvent{}) + for range 2 { + feature.HandleKey(fyne.KeyPlus) + } + paneDraggable(t, panes[0]).Dragged(&fyne.DragEvent{Dragged: fyne.NewDelta(40, 0)}) + paneHoverable(t, panes[1]).MouseIn(&desktop.MouseEvent{}) + feature.ToggleLink() + linkedBefore := renderedPanes(feature.Overlay()) + cursor := fyne.NewPos(300, 200) + beforeSizes := [2]fyne.Size{linkedBefore[0].image.Size(), linkedBefore[1].image.Size()} + anchored := [2]fyne.Position{normalizedPoint(linkedBefore[0], cursor), normalizedPoint(linkedBefore[1], cursor)} + paneScrollable(t, linkedBefore[0]).Scrolled(&fyne.ScrollEvent{ + PointEvent: fyne.PointEvent{Position: cursor}, + Scrolled: fyne.NewDelta(0, 10), + }) + linkedAfter := renderedPanes(feature.Overlay()) + ratio := linkedAfter[0].image.Size().Width / beforeSizes[0].Width + if got := linkedAfter[1].image.Size().Width / beforeSizes[1].Width; !uitest.ApproxEqual(got, ratio) { + t.Errorf("camera wheel ratios = %.4f and %.4f, want equal", ratio, got) + } + for i, pane := range linkedAfter { + if got := normalizedPoint(pane, cursor); !approxPosition(got, anchored[i]) { + t.Errorf("pane %d point under camera-wheel cursor = %v, want %v", i, got, anchored[i]) + } + } + want := [2]struct { + size fyne.Size + position fyne.Position + }{ + {size: linkedAfter[0].image.Size(), position: linkedAfter[0].image.Position()}, + {size: linkedAfter[1].image.Size(), position: linkedAfter[1].image.Position()}, + } + + feature.ToggleLink() + unlocked := renderedPanes(feature.Overlay()) + for i := range unlocked { + if unlocked[i].image.Size() != want[i].size || !approxPosition(unlocked[i].image.Position(), want[i].position) { + t.Errorf("pane %d changed while unlocking after camera wheel: got {%v %v}, want {%v %v}", + i, unlocked[i].image.Size(), unlocked[i].image.Position(), want[i].size, want[i].position) + } + } +} + +func TestCompareSwapWhileUnlinked_LocksAndClearsDivergentPhotoPoses(t *testing.T) { + app := test.NewApp() + t.Cleanup(app.Quit) + + feature := newReferenceFeature(func(_ context.Context, _ fyne.URI) (*imaging.LoadedImage, error) { + return loadedImage(800, 400), nil + }, Callbacks{}) + feature.Overlay().Resize(fyne.NewSize(800, 400)) + feature.Open([2]fyne.URI{ + storage.NewFileURI("left.png"), + storage.NewFileURI("right.png"), + }) + waitForDone(t, feature) + + feature.ToggleLink() + link := comparisonButton(t, feature.Overlay(), "Link") + panes := renderedPanes(feature.Overlay()) + paneHoverable(t, panes[0]).MouseIn(&desktop.MouseEvent{}) + feature.HandleKey(fyne.KeyPlus) + if panes = renderedPanes(feature.Overlay()); panes[0].image.Size().Width != 500 || panes[1].image.Size().Width != 400 { + t.Fatalf("unlinked setup widths = %.2f and %.2f, want 500 and 400", panes[0].image.Size().Width, panes[1].image.Size().Width) + } + + test.Tap(comparisonButton(t, feature.Overlay(), "Swap")) + if got := comparisonButton(t, feature.Overlay(), "Unlink"); got != link { + t.Fatal("Swap replaced the link control instead of restoring its Unlink state") + } + panes = renderedPanes(feature.Overlay()) + if panes[0].image.Size().Width != 500 || panes[1].image.Size().Width != 500 { + t.Errorf("widths after Swap relink = %.2f and %.2f, want winning 500 shared", panes[0].image.Size().Width, panes[1].image.Size().Width) + } + for _, text := range labelTexts(feature.Overlay()) { + if strings.HasPrefix(text, "Unlinked") { + t.Errorf("labels after Swap while unlinked = %v, want no unlink status", labelTexts(feature.Overlay())) + break + } + } + + beforeWidths := [2]float32{panes[0].image.Size().Width, panes[1].image.Size().Width} + paneScrollable(t, panes[0]).Scrolled(&fyne.ScrollEvent{ + PointEvent: fyne.PointEvent{Position: fyne.NewPos(200, 200)}, + Scrolled: fyne.NewDelta(0, 10), + }) + panes = renderedPanes(feature.Overlay()) + leftRatio := panes[0].image.Size().Width / beforeWidths[0] + rightRatio := panes[1].image.Size().Width / beforeWidths[1] + if leftRatio <= 1 || !uitest.ApproxEqual(leftRatio, rightRatio) { + t.Errorf("wheel ratios after Swap = %.4f and %.4f, want one linked increase", leftRatio, rightRatio) + } + + feature.ToggleLink() + panes = renderedPanes(feature.Overlay()) + if panes[0].image.Size() != panes[1].image.Size() || !approxPosition(normalizedCenter(panes[0]), normalizedCenter(panes[1])) { + t.Errorf("photo poses after Swap and fresh unlink = {%v %v} and {%v %v}, want reset together", + panes[0].image.Size(), normalizedCenter(panes[0]), panes[1].image.Size(), normalizedCenter(panes[1])) + } +} + +func TestCompareOpenStartsLinkedAndFreshToggleUnlinks(t *testing.T) { + app := test.NewApp() + t.Cleanup(app.Quit) + + modifiers := fyne.KeyModifierControl + feature := newReferenceFeature(func(_ context.Context, _ fyne.URI) (*imaging.LoadedImage, error) { + return loadedImage(800, 400), nil + }, Callbacks{Modifiers: func() fyne.KeyModifier { return modifiers }}) + feature.Overlay().Resize(fyne.NewSize(800, 400)) + feature.Open([2]fyne.URI{ + storage.NewFileURI("left.png"), + storage.NewFileURI("right.png"), + }) + waitForDone(t, feature) + unlink := comparisonButton(t, feature.Overlay(), "Unlink") + panes := renderedPanes(feature.Overlay()) + paneHoverable(t, panes[0]).MouseIn(&desktop.MouseEvent{}) + if got := labelTexts(feature.Overlay()); slices.Contains(got, "Unlinked: Left") { + t.Fatalf("labels after opening with Control held = %v, want linked start", got) + } + + feature.HandleKey(fyne.KeyPlus) + panes = renderedPanes(feature.Overlay()) + if panes[0].image.Size().Width != 500 || panes[1].image.Size().Width != 500 { + t.Errorf("first linked + widths = %.2f and %.2f, want 500 and 500", panes[0].image.Size().Width, panes[1].image.Size().Width) + } + + feature.ToggleLink() + if got := comparisonButton(t, feature.Overlay(), "Link"); got != unlink { + t.Fatal("fresh link toggle replaced the Unlink control instead of relabeling it") + } + if got := labelTexts(feature.Overlay()); !slices.Contains(got, "Unlinked: Left") { + t.Fatalf("labels after fresh toggle = %v, want Unlinked: Left", got) + } + beforeRight := renderedPanes(feature.Overlay())[1].image.Size() + feature.HandleKey(fyne.KeyPlus) + panes = renderedPanes(feature.Overlay()) + if panes[0].image.Size().Width <= 500 || panes[1].image.Size() != beforeRight { + t.Errorf("unlinked + sizes = %v and %v, want only left enlarged from 500", panes[0].image.Size(), panes[1].image.Size()) + } +} + +func TestCompareUnlinkedShiftWheel_AllowsOnlyTheTargetToOverscrollToImageEdgeAtPaneCenter(t *testing.T) { + app := test.NewApp() + t.Cleanup(app.Quit) + + var modifiers fyne.KeyModifier + feature := newReferenceFeature(func(_ context.Context, _ fyne.URI) (*imaging.LoadedImage, error) { + return loadedImage(800, 400), nil + }, Callbacks{Modifiers: func() fyne.KeyModifier { return modifiers }}) + feature.Overlay().Resize(fyne.NewSize(800, 400)) + feature.Open([2]fyne.URI{ + storage.NewFileURI("left.png"), + storage.NewFileURI("right.png"), + }) + waitForDone(t, feature) + modifiers = fyne.KeyModifierShift + feature.ToggleLink() + + panes := renderedPanes(feature.Overlay()) + if got := paneCursorable(t, panes[0]).Cursor(); got != desktop.PointerCursor { + t.Errorf("fitted pane cursor while unlinked = %v, want pointer because local overscroll is available", got) + } + paneScrollable(t, panes[0]).Scrolled(&fyne.ScrollEvent{Scrolled: fyne.NewDelta(10000, -10000)}) + panes = renderedPanes(feature.Overlay()) + if got := normalizedCenter(panes[0]); !approxPosition(got, fyne.NewPos(0, 1)) { + t.Errorf("target local center after extreme unlinked Shift-wheel = %v, want edge clamp {0 1}", got) + } + if got := normalizedCenter(panes[1]); !approxPosition(got, fyne.NewPos(0.5, 0.5)) { + t.Errorf("other local center after extreme unlinked Shift-wheel = %v, want unchanged", got) + } + if !uitest.ApproxEqual(panes[0].image.Position().X, panes[0].root.Size().Width/2) || + !uitest.ApproxEqual(panes[0].image.Position().Y+panes[0].image.Size().Height, panes[0].root.Size().Height/2) { + t.Errorf("overscrolled target span = {%v %v} in %v, want selected image edges at pane center", + panes[0].image.Position(), panes[0].image.Size(), panes[0].root.Size()) + } +} + +func TestCompareUnlinkedPan_AfterCameraPanStopsAtPaneCenter(t *testing.T) { + app := test.NewApp() + t.Cleanup(app.Quit) + + feature := newReferenceFeature(func(_ context.Context, _ fyne.URI) (*imaging.LoadedImage, error) { + return loadedImage(800, 400), nil + }, Callbacks{}) + feature.Overlay().Resize(fyne.NewSize(800, 400)) + feature.Open([2]fyne.URI{ + storage.NewFileURI("left.png"), + storage.NewFileURI("right.png"), + }) + waitForDone(t, feature) + + panes := renderedPanes(feature.Overlay()) + paneDraggable(t, panes[0]).Dragged(&fyne.DragEvent{Dragged: fyne.NewDelta(80, 40)}) + feature.ToggleLink() + panes = renderedPanes(feature.Overlay()) + wantOtherSize := panes[1].image.Size() + wantOtherPosition := panes[1].image.Position() + + paneDraggable(t, panes[0]).Dragged(&fyne.DragEvent{Dragged: fyne.NewDelta(10000, -10000)}) + panes = renderedPanes(feature.Overlay()) + left := panes[0] + if !uitest.ApproxEqual(left.image.Position().X, left.root.Size().Width/2) || + !uitest.ApproxEqual(left.image.Position().Y+left.image.Size().Height, left.root.Size().Height/2) { + t.Errorf("camera-offset target span = {%v %v} in %v, want selected image edges at pane center", + left.image.Position(), left.image.Size(), left.root.Size()) + } + assertPaneOverlapsCenter(t, left) + if panes[1].image.Size() != wantOtherSize || !approxPosition(panes[1].image.Position(), wantOtherPosition) { + t.Errorf("other pane changed during camera-offset local pan: got {%v %v}, want {%v %v}", + panes[1].image.Size(), panes[1].image.Position(), wantOtherSize, wantOtherPosition) + } +} + +func TestCompareLinkToggle_RepeatedTogglesNeverChangeDivergentGeometry(t *testing.T) { + app := test.NewApp() + t.Cleanup(app.Quit) + + feature := newReferenceFeature(func(_ context.Context, uri fyne.URI) (*imaging.LoadedImage, error) { + if uri.Name() == "wide.png" { + return loadedImage(800, 400), nil + } + return loadedImage(200, 800), nil + }, Callbacks{}) + feature.Overlay().Resize(fyne.NewSize(800, 400)) + feature.Open([2]fyne.URI{ + storage.NewFileURI("wide.png"), + storage.NewFileURI("tall.png"), + }) + waitForDone(t, feature) + test.Tap(comparisonButton(t, feature.Overlay(), "Swipe")) + + feature.ToggleLink() + panes := renderedPanes(feature.Overlay()) + paneHoverable(t, panes[0]).MouseIn(&desktop.MouseEvent{}) + feature.HandleKey(fyne.KeyPlus) + paneDraggable(t, panes[0]).Dragged(&fyne.DragEvent{Dragged: fyne.NewDelta(10000, 0)}) + paneHoverable(t, renderedPanes(feature.Overlay())[1]).MouseIn(&desktop.MouseEvent{}) + before := renderedPanes(feature.Overlay()) + want := [2]struct { + size fyne.Size + position fyne.Position + }{ + {size: before[0].image.Size(), position: before[0].image.Position()}, + {size: before[1].image.Size(), position: before[1].image.Position()}, + } + + for toggle := range 4 { + feature.ToggleLink() + panes := renderedPanes(feature.Overlay()) + for i, pane := range panes { + if pane.image.Size() != want[i].size || !approxPosition(pane.image.Position(), want[i].position) { + t.Errorf("toggle %d pane %d geometry = {%v %v}, want unchanged {%v %v}", + toggle+1, i, pane.image.Size(), pane.image.Position(), want[i].size, want[i].position) + } + } + } +} + +func TestCompareUnlinkedLayoutAndResize_PreserveEachLocalCenterModeAndFactor(t *testing.T) { + app := test.NewApp() + t.Cleanup(app.Quit) + + feature := newReferenceFeature(func(_ context.Context, _ fyne.URI) (*imaging.LoadedImage, error) { + return loadedImage(800, 400), nil + }, Callbacks{}) + feature.Overlay().Resize(fyne.NewSize(800, 400)) + feature.Open([2]fyne.URI{ + storage.NewFileURI("left.png"), + storage.NewFileURI("right.png"), + }) + waitForDone(t, feature) + feature.ToggleLink() + + panes := renderedPanes(feature.Overlay()) + paneHoverable(t, panes[0]).MouseIn(&desktop.MouseEvent{}) + feature.HandleKey(fyne.Key1) + paneDraggable(t, panes[0]).Dragged(&fyne.DragEvent{Dragged: fyne.NewDelta(80, 40)}) + paneHoverable(t, panes[1]).MouseIn(&desktop.MouseEvent{}) + feature.HandleKey(fyne.KeyPlus) + before := renderedPanes(feature.Overlay()) + wantCenters := [2]fyne.Position{normalizedCenter(before[0]), normalizedCenter(before[1])} + + test.Tap(comparisonButton(t, feature.Overlay(), "Swipe")) + inSwipe := renderedPanes(feature.Overlay()) + if got := inSwipe[0].image.Size(); got != fyne.NewSize(800, 400) { + t.Errorf("absolute local size in swipe = %v, want retained 800x400", got) + } + if got := inSwipe[1].image.Size(); got != fyne.NewSize(1000, 500) { + t.Errorf("fit-relative local size in swipe = %v, want recomputed 1000x500", got) + } + for i, pane := range inSwipe { + if got := normalizedCenter(pane); !approxPosition(got, wantCenters[i]) { + t.Errorf("swipe local pane %d center = %v, want retained %v", i, got, wantCenters[i]) + } + } + + feature.Overlay().Resize(fyne.NewSize(1000, 600)) + afterResize := renderedPanes(feature.Overlay()) + if got := afterResize[0].image.Size(); got != fyne.NewSize(800, 400) { + t.Errorf("absolute local size after resize = %v, want retained 800x400", got) + } + if got := afterResize[1].image.Size(); got != fyne.NewSize(1250, 625) { + t.Errorf("fit-relative local size after resize = %v, want recomputed 1250x625", got) + } + for i, pane := range afterResize { + if got := normalizedCenter(pane); !approxPosition(got, wantCenters[i]) { + t.Errorf("resized local pane %d center = %v, want retained %v", i, got, wantCenters[i]) + } + } +} + +func TestCompareCameraFitAndHome_DoNotRewritePhotoPoses(t *testing.T) { + app := test.NewApp() + t.Cleanup(app.Quit) + + feature := newReferenceFeature(func(_ context.Context, uri fyne.URI) (*imaging.LoadedImage, error) { + if uri.Name() == "wide.png" { + return loadedImage(800, 400), nil + } + return loadedImage(200, 800), nil + }, Callbacks{}) + feature.Overlay().Resize(fyne.NewSize(800, 400)) + feature.Open([2]fyne.URI{ + storage.NewFileURI("wide.png"), + storage.NewFileURI("tall.png"), + }) + waitForDone(t, feature) + feature.ToggleLink() + + panes := renderedPanes(feature.Overlay()) + paneHoverable(t, panes[0]).MouseIn(&desktop.MouseEvent{}) + for range 3 { + feature.HandleKey(fyne.KeyPlus) + } + paneDraggable(t, panes[0]).Dragged(&fyne.DragEvent{Dragged: fyne.NewDelta(60, 20)}) + paneHoverable(t, panes[1]).MouseIn(&desktop.MouseEvent{}) + for range 2 { + feature.HandleKey(fyne.KeyPlus) + } + paneDraggable(t, panes[1]).Dragged(&fyne.DragEvent{Dragged: fyne.NewDelta(-40, -20)}) + home := renderedPanes(feature.Overlay()) + wantHome := [2]struct { + size fyne.Size + position fyne.Position + }{ + {size: home[0].image.Size(), position: home[0].image.Position()}, + {size: home[1].image.Size(), position: home[1].image.Position()}, + } + wantRatio := wantHome[0].size.Width / wantHome[1].size.Width + + feature.ToggleLink() + feature.HandleKey(fyne.Key0) + afterFit := renderedPanes(feature.Overlay()) + if got := afterFit[0].image.Size().Width / afterFit[1].image.Size().Width; !uitest.ApproxEqual(got, wantRatio) { + t.Errorf("photo ratio after camera fit = %.4f, want retained %.4f", got, wantRatio) + } + wantFit := [2]struct { + size fyne.Size + position fyne.Position + }{ + {size: afterFit[0].image.Size(), position: afterFit[0].image.Position()}, + {size: afterFit[1].image.Size(), position: afterFit[1].image.Position()}, + } + + feature.ToggleLink() + feature.ToggleLink() + stillFit := renderedPanes(feature.Overlay()) + for i, pane := range stillFit { + if pane.image.Size() != wantFit[i].size || !approxPosition(pane.image.Position(), wantFit[i].position) { + t.Errorf("pane %d camera-fit geometry changed across toggles: got {%v %v}, want {%v %v}", + i, pane.image.Size(), pane.image.Position(), wantFit[i].size, wantFit[i].position) + } + } + + feature.HandleKey(fyne.Key1) + afterHome := renderedPanes(feature.Overlay()) + for i, pane := range afterHome { + if pane.image.Size() != wantHome[i].size || !approxPosition(pane.image.Position(), wantHome[i].position) { + t.Errorf("pane %d after camera home = {%v %v}, want stored photo pose {%v %v}", + i, pane.image.Size(), pane.image.Position(), wantHome[i].size, wantHome[i].position) + } + } +} + +func TestCompareCameraPan_CursorReportsTableMovementAvailability(t *testing.T) { + app := test.NewApp() + t.Cleanup(app.Quit) + + feature := newReferenceFeature(func(_ context.Context, uri fyne.URI) (*imaging.LoadedImage, error) { + if uri.Name() == "wide.png" { + return loadedImage(800, 400), nil + } + return loadedImage(200, 800), nil + }, Callbacks{}) + feature.Overlay().Resize(fyne.NewSize(800, 400)) + feature.Open([2]fyne.URI{ + storage.NewFileURI("wide.png"), + storage.NewFileURI("tall.png"), + }) + waitForDone(t, feature) + + panes := renderedPanes(feature.Overlay()) + if got := paneCursorable(t, panes[0]).Cursor(); got != desktop.PointerCursor { + t.Errorf("fitted comparison cursor = %v, want pointer for camera movement", got) + } + for range 7 { + feature.HandleKey(fyne.KeyPlus) + } + panes = renderedPanes(feature.Overlay()) + if got := paneCursorable(t, panes[0]).Cursor(); got != desktop.PointerCursor { + t.Errorf("pannable comparison cursor = %v, want pointer", got) + } +} + +func TestCompareCameraPan_RepeatedExtremeInputKeepsBothPhotosOverPaneCenters(t *testing.T) { + app := test.NewApp() + t.Cleanup(app.Quit) + + feature := newReferenceFeature(func(_ context.Context, uri fyne.URI) (*imaging.LoadedImage, error) { + if uri.Name() == "wide.png" { + return loadedImage(800, 400), nil + } + return loadedImage(200, 800), nil + }, Callbacks{}) + feature.Overlay().Resize(fyne.NewSize(800, 400)) + feature.Open([2]fyne.URI{ + storage.NewFileURI("wide.png"), + storage.NewFileURI("tall.png"), + }) + waitForDone(t, feature) + for range 7 { + feature.HandleKey(fyne.KeyPlus) + } + + for i := range 20 { + panes := renderedPanes(feature.Overlay()) + delta := fyne.NewDelta(10000, 10000) + if i%2 != 0 { + delta = fyne.NewDelta(-20000, -20000) + } + paneDraggable(t, panes[i%2]).Dragged(&fyne.DragEvent{Dragged: delta}) panes = renderedPanes(feature.Overlay()) - if left, right := normalizedCenter(panes[0]), normalizedCenter(panes[1]); !approxPosition(left, right) { - t.Fatalf("iteration %d normalized centers = left %v right %v, want linked", i, left, right) + for _, pane := range panes { + assertPaneOverlapsCenter(t, pane) + } + } +} + +func TestCompareCameraPan_RepeatedInputOnEitherPaneKeepsOnePointDelta(t *testing.T) { + app := test.NewApp() + t.Cleanup(app.Quit) + + feature := newReferenceFeature(func(_ context.Context, uri fyne.URI) (*imaging.LoadedImage, error) { + if uri.Name() == "wide.png" { + return loadedImage(800, 400), nil + } + return loadedImage(200, 800), nil + }, Callbacks{}) + feature.Overlay().Resize(fyne.NewSize(800, 400)) + feature.Open([2]fyne.URI{ + storage.NewFileURI("wide.png"), + storage.NewFileURI("tall.png"), + }) + waitForDone(t, feature) + for range 7 { + feature.HandleKey(fyne.KeyPlus) + } + + for i := range 100 { + panes := renderedPanes(feature.Overlay()) + delta := fyne.NewDelta(3, -2) + if i%2 != 0 { + delta = fyne.NewDelta(-3, 2) + } + wantPositions := [2]fyne.Position{ + panes[0].image.Position().Add(delta), + panes[1].image.Position().Add(delta), + } + paneDraggable(t, panes[i%2]).Dragged(&fyne.DragEvent{Dragged: delta}) + panes = renderedPanes(feature.Overlay()) + for pane, want := range wantPositions { + if got := panes[pane].image.Position(); !approxPosition(got, want) { + t.Fatalf("iteration %d pane %d position = %v, want camera delta at %v", i, pane, got, want) + } } } } @@ -1902,12 +3001,12 @@ func TestCompareFitReset_PanThenZeroRestoresCanonicalTransform(t *testing.T) { app := test.NewApp() t.Cleanup(app.Quit) - feature := compare.New(func(_ context.Context, uri fyne.URI) (*imaging.LoadedImage, error) { + feature := newReferenceFeature(func(_ context.Context, uri fyne.URI) (*imaging.LoadedImage, error) { if uri.Name() == "wide.png" { return loadedImage(800, 400), nil } return loadedImage(200, 800), nil - }, compare.Callbacks{}) + }, Callbacks{}) feature.Overlay().Resize(fyne.NewSize(800, 400)) feature.Open([2]fyne.URI{ storage.NewFileURI("wide.png"), @@ -1944,11 +3043,11 @@ func TestCompareLoading_StartsBothSourcesConcurrentlyAndCompletesReady(t *testin started := make(chan string, 2) release := make(chan struct{}) - feature := compare.New(func(_ context.Context, uri fyne.URI) (*imaging.LoadedImage, error) { + feature := newReferenceFeature(func(_ context.Context, uri fyne.URI) (*imaging.LoadedImage, error) { started <- uri.Name() <-release return loadedImage(32, 24), nil - }, compare.Callbacks{}) + }, Callbacks{}) feature.Open([2]fyne.URI{ storage.NewFileURI("left.png"), storage.NewFileURI("right.png"), @@ -1975,12 +3074,12 @@ func TestCompareOpen_NotifiesOwnerBeforeLoaderStarts(t *testing.T) { var opened atomic.Bool var loaderStartedEarly atomic.Bool - feature := compare.New(func(_ context.Context, _ fyne.URI) (*imaging.LoadedImage, error) { + feature := newReferenceFeature(func(_ context.Context, _ fyne.URI) (*imaging.LoadedImage, error) { if !opened.Load() { loaderStartedEarly.Store(true) } return loadedImage(32, 24), nil - }, compare.Callbacks{Opened: func() { + }, Callbacks{Opened: func() { opened.Store(true) }}) feature.Open([2]fyne.URI{ @@ -2004,12 +3103,12 @@ func TestCompareCancel_BackCancelsBothWorkersWithoutFailure(t *testing.T) { started := make(chan string, 2) cancelled := make(chan string, 2) failures := 0 - feature := compare.New(func(ctx context.Context, uri fyne.URI) (*imaging.LoadedImage, error) { + feature := newReferenceFeature(func(ctx context.Context, uri fyne.URI) (*imaging.LoadedImage, error) { started <- uri.Name() <-ctx.Done() cancelled <- uri.Name() return nil, ctx.Err() - }, compare.Callbacks{Failed: func(fyne.URI, error) { failures++ }}) + }, Callbacks{Failed: func(fyne.URI, error) { failures++ }}) feature.Open([2]fyne.URI{ storage.NewFileURI("left.png"), storage.NewFileURI("right.png"), @@ -2039,14 +3138,14 @@ func TestCompareFailure_ClosesAndCancelsTheOtherSide(t *testing.T) { cancelled := make(chan string, 1) var failedURI fyne.URI var failedErr error - feature := compare.New(func(ctx context.Context, uri fyne.URI) (*imaging.LoadedImage, error) { + feature := newReferenceFeature(func(ctx context.Context, uri fyne.URI) (*imaging.LoadedImage, error) { if uri.Name() == failingName { return nil, wantErr } <-ctx.Done() cancelled <- uri.Name() return nil, ctx.Err() - }, compare.Callbacks{Failed: func(uri fyne.URI, err error) { + }, Callbacks{Failed: func(uri fyne.URI, err error) { failedURI, failedErr = uri, err }}) feature.Open([2]fyne.URI{ @@ -2085,7 +3184,7 @@ func TestCompareStale_OlderCompletionCannotRepaintANewerSession(t *testing.T) { oldStarted := make(chan string, 2) newLeft := loadedImage(101, 51) newRight := loadedImage(202, 52) - feature := compare.New(func(_ context.Context, uri fyne.URI) (*imaging.LoadedImage, error) { + feature := newReferenceFeature(func(_ context.Context, uri fyne.URI) (*imaging.LoadedImage, error) { switch uri.Name() { case "old-left.png", "old-right.png": oldStarted <- uri.Name() @@ -2096,7 +3195,7 @@ func TestCompareStale_OlderCompletionCannotRepaintANewerSession(t *testing.T) { default: return newRight, nil } - }, compare.Callbacks{}) + }, Callbacks{}) feature.Open([2]fyne.URI{ storage.NewFileURI("old-left.png"), storage.NewFileURI("old-right.png"), diff --git a/internal/ui/compare/input.go b/internal/ui/compare/input.go index ce2958c..c084a2b 100644 --- a/internal/ui/compare/input.go +++ b/internal/ui/compare/input.go @@ -56,8 +56,8 @@ func (*inputShield) MouseOut() {} func (*inputShield) Cursor() desktop.Cursor { return desktop.DefaultCursor } // paneInput is the interactive layer inside one clipped image viewport. It -// forwards pointer intent to the Feature, which owns the single transform -// shared by both panes. +// forwards pointer intent and hover targeting to the Feature, which chooses +// the shared camera or that pane's photo transform. type paneInput struct { widget.BaseWidget @@ -68,6 +68,7 @@ type paneInput struct { var ( _ fyne.Draggable = (*paneInput)(nil) _ fyne.Scrollable = (*paneInput)(nil) + _ desktop.Hoverable = (*paneInput)(nil) _ desktop.Cursorable = (*paneInput)(nil) ) @@ -93,8 +94,18 @@ func (p *paneInput) Dragged(ev *fyne.DragEvent) { func (*paneInput) DragEnd() {} +func (p *paneInput) MouseIn(_ *desktop.MouseEvent) { + p.feature.setHoveredPane(p.index) +} + +func (p *paneInput) MouseMoved(_ *desktop.MouseEvent) { + p.feature.setHoveredPane(p.index) +} + +func (*paneInput) MouseOut() {} + func (p *paneInput) Cursor() desktop.Cursor { - if p.feature.canPan() { + if p.feature.canPan(p.index) { return desktop.PointerCursor } return desktop.DefaultCursor diff --git a/internal/ui/compare/renderer.go b/internal/ui/compare/renderer.go new file mode 100644 index 0000000..6c640bd --- /dev/null +++ b/internal/ui/compare/renderer.go @@ -0,0 +1,132 @@ +package compare + +import ( + "context" + "errors" + "image" + "image/draw" + "math" + + "fyne.io/fyne/v2" + "fyne.io/fyne/v2/canvas" + + xdraw "golang.org/x/image/draw" + + "github.com/frathe/picfetch/internal/imaging" +) + +const overviewMaxDimension = 1024 + +// renderSource is the immutable image identity handed to a pane renderer. It +// retains the canonical decoded frame, a bounded overview, and the source's +// byte-budgeted detail-tile cache. +type renderSource struct { + frame image.Image + overview image.Image + tiles *imaging.ByteCache[*renderTile] +} + +func prepareRenderSource(ctx context.Context, frame image.Image) (*renderSource, error) { + if err := ctx.Err(); err != nil { + return nil, err + } + if frame == nil { + return nil, errors.New("decoded image has no frame") + } + bounds := frame.Bounds() + width, height := bounds.Dx(), bounds.Dy() + if width <= 0 || height <= 0 { + return nil, errors.New("decoded image has invalid dimensions") + } + if width <= overviewMaxDimension && height <= overviewMaxDimension { + return newPreparedRenderSource(frame, frame), nil + } + + scale := float64(overviewMaxDimension) / float64(max(width, height)) + overviewWidth := max(1, int(math.Round(float64(width)*scale))) + overviewHeight := max(1, int(math.Round(float64(height)*scale))) + overview := image.NewRGBA(image.Rect(0, 0, overviewWidth, overviewHeight)) + xdraw.ApproxBiLinear.Scale(overview, overview.Bounds(), frame, bounds, draw.Src, nil) + if err := ctx.Err(); err != nil { + return nil, err + } + return newPreparedRenderSource(frame, overview), nil +} + +func newPreparedRenderSource(frame, overview image.Image) *renderSource { + return &renderSource{ + frame: frame, + overview: overview, + tiles: imaging.NewByteCache(tileCacheBudgetBytes, func(tile *renderTile) int64 { + if tile == nil || tile.texture == nil { + return 0 + } + return int64(len(tile.texture.Pix)) + }), + } +} + +// paneScene is one complete presentation snapshot. Logical geometry stays in +// Fyne points while displaySize records the corresponding physical pixels for +// mip selection and vector raster targets. +type paneScene struct { + source *renderSource + viewport fyne.Size + revealSet bool + revealPosition fyne.Position + revealSize fyne.Size + imagePosition fyne.Position + imageSize fyne.Size + displaySize image.Point +} + +// paneRenderer is the private boundary between comparison transform policy and +// a concrete canvas implementation. Present runs on the UI path; Wait makes +// renderer-owned asynchronous work observable to Feature.Settle. +type paneRenderer interface { + Object() fyne.CanvasObject + Present(paneScene) + Wait(context.Context) error +} + +type paneRendererFactory func(index int) paneRenderer + +type paneRendererQueue interface { + setQueueUI(func(func())) +} + +// canvasPaneRenderer is the deterministic reference adapter used by unit tests +// that exercise comparison geometry and source identity. Production uses the +// tiled shader adapter. +type canvasPaneRenderer struct { + image *canvas.Image +} + +func newCanvasPaneRenderer(int) paneRenderer { + img := canvas.NewImageFromImage(nil) + img.FillMode = canvas.ImageFillContain + img.ScaleMode = canvas.ImageScaleSmooth + img.Hide() + return &canvasPaneRenderer{image: img} +} + +func (r *canvasPaneRenderer) Object() fyne.CanvasObject { return r.image } + +func (r *canvasPaneRenderer) Present(scene paneScene) { + if scene.source == nil || scene.source.frame == nil { + r.image.Image = nil + r.image.Hide() + return + } + + changed := r.image.Image != scene.source.frame + r.image.Image = scene.source.frame + r.image.Resize(scene.imageSize) + r.image.Move(scene.imagePosition) + r.image.Show() + if changed { + r.image.Refresh() + } +} + +func (*canvasPaneRenderer) Wait(context.Context) error { return nil } diff --git a/internal/ui/compare/renderer_test.go b/internal/ui/compare/renderer_test.go new file mode 100644 index 0000000..343e2cc --- /dev/null +++ b/internal/ui/compare/renderer_test.go @@ -0,0 +1,144 @@ +package compare + +import ( + "context" + "image" + "testing" + "time" + + "fyne.io/fyne/v2" + "fyne.io/fyne/v2/canvas" + "fyne.io/fyne/v2/storage" + fynetest "fyne.io/fyne/v2/test" + + "github.com/frathe/picfetch/internal/imaging" +) + +type recordingPaneRenderer struct { + object *canvas.Rectangle + scenes []paneScene + waits int +} + +func newRecordingPaneRenderer() *recordingPaneRenderer { + return &recordingPaneRenderer{object: canvas.NewRectangle(nil)} +} + +func (r *recordingPaneRenderer) Object() fyne.CanvasObject { return r.object } + +func (r *recordingPaneRenderer) Present(scene paneScene) { + r.scenes = append(r.scenes, scene) +} + +func (r *recordingPaneRenderer) Wait(context.Context) error { + r.waits++ + return nil +} + +func (r *recordingPaneRenderer) latest(t *testing.T) paneScene { + t.Helper() + if len(r.scenes) == 0 { + t.Fatal("renderer received no scene") + } + return r.scenes[len(r.scenes)-1] +} + +func TestPaneRendererScene_PresentsStableSourceGeometryAndLifecycle(t *testing.T) { + app := fynetest.NewApp() + t.Cleanup(app.Quit) + + renderers := [2]*recordingPaneRenderer{ + newRecordingPaneRenderer(), + newRecordingPaneRenderer(), + } + objects := [2]fyne.CanvasObject{renderers[0].Object(), renderers[1].Object()} + feature := newFeature(func(_ context.Context, uri fyne.URI) (*imaging.LoadedImage, error) { + size := image.Pt(1200, 600) + if uri.Name() == "right.png" { + size = image.Pt(300, 900) + } + return &imaging.LoadedImage{Frames: []image.Image{image.NewRGBA(image.Rectangle{Max: size})}}, nil + }, Callbacks{}, func(index int) paneRenderer { return renderers[index] }) + pixelAnchors := map[fyne.CanvasObject]bool{ + feature.panes[0].input: true, + feature.panes[1].input: true, + } + feature.vectorPixels = func(object fyne.CanvasObject, _ fyne.Size) (int, int) { + if !pixelAnchors[object] { + t.Errorf("physical-pixel lookup anchor = %T, want a visible pane input", object) + } + return 800, 400 + } + feature.Overlay().Resize(fyne.NewSize(800, 400)) + feature.Open([2]fyne.URI{ + storage.NewFileURI("left.png"), + storage.NewFileURI("right.png"), + }) + ctx, cancel := context.WithTimeout(context.Background(), time.Second) + defer cancel() + if err := feature.Settle(ctx); err != nil { + t.Fatalf("Settle after Open: %v", err) + } + + left := renderers[0].latest(t) + if left.source == nil || left.source.frame.Bounds().Size() != image.Pt(1200, 600) { + t.Fatalf("left scene source = %#v, want 1200x600", left.source) + } + if left.viewport != fyne.NewSize(400, 400) || left.imagePosition != fyne.NewPos(0, 100) || left.imageSize != fyne.NewSize(400, 200) { + t.Errorf("left scene geometry = viewport %v position %v size %v, want 400x400, (0,100), 400x200", + left.viewport, left.imagePosition, left.imageSize) + } + if left.displaySize != image.Pt(800, 400) { + t.Errorf("left physical display size = %v, want 800x400", left.displaySize) + } + + feature.HandleKey(fyne.KeyPlus) + zoomed := renderers[0].latest(t) + if zoomed.imageSize != fyne.NewSize(500, 250) { + t.Errorf("zoomed left scene size = %v, want 500x250", zoomed.imageSize) + } + for i, renderer := range renderers { + if renderer.Object() != objects[i] { + t.Errorf("pane %d renderer object changed across interaction", i) + } + } + + feature.layoutMode = swipe + feature.dividerAt = 0.25 + feature.layoutSwipe(fyne.NewSize(800, 400)) + leftReveal := renderers[0].latest(t) + rightReveal := renderers[1].latest(t) + if !leftReveal.revealSet || leftReveal.revealPosition != (fyne.Position{}) || leftReveal.revealSize != fyne.NewSize(200, 400) { + t.Errorf("left swipe reveal = set %v position %v size %v, want true (0,0) 200x400", + leftReveal.revealSet, leftReveal.revealPosition, leftReveal.revealSize) + } + if !rightReveal.revealSet || rightReveal.revealPosition != fyne.NewPos(200, 0) || rightReveal.revealSize != fyne.NewSize(600, 400) { + t.Errorf("right swipe reveal = set %v position %v size %v, want true (200,0) 600x400", + rightReveal.revealSet, rightReveal.revealPosition, rightReveal.revealSize) + } + + feature.swapSides() + left = renderers[0].latest(t) + if left.source == nil || left.source.frame.Bounds().Size() != image.Pt(300, 900) { + t.Fatalf("left source after Swap = %#v, want former right 300x900", left.source) + } + + feature.Close() + for i, renderer := range renderers { + if scene := renderer.latest(t); scene.source != nil { + t.Errorf("pane %d source after Close = %#v, want nil", i, scene.source) + } + if renderer.waits == 0 { + t.Errorf("pane %d renderer Wait was not included in Settle", i) + } + } +} + +func TestNew_UsesTiledShaderRenderersForBothPanes(t *testing.T) { + feature := New(nil, Callbacks{}) + for i := range feature.panes { + if _, ok := feature.panes[i].renderer.(*shaderPaneRenderer); !ok { + t.Errorf("pane %d renderer type = %T, want *shaderPaneRenderer", i, feature.panes[i].renderer) + } + } +} diff --git a/internal/ui/compare/shader.go b/internal/ui/compare/shader.go new file mode 100644 index 0000000..8a86e77 --- /dev/null +++ b/internal/ui/compare/shader.go @@ -0,0 +1,621 @@ +package compare + +import ( + "context" + "errors" + "image" + "slices" + "strconv" + "sync" + + "fyne.io/fyne/v2" + "fyne.io/fyne/v2/canvas" +) + +const tileShaderSourceDesktop = `#version 110 +uniform vec2 frame; +uniform vec4 bounds; +uniform sampler2D overview; +uniform sampler2D detail0; +uniform sampler2D detail1; +uniform sampler2D detail2; +uniform sampler2D detail3; +uniform sampler2D detail4; +uniform sampler2D detail5; +uniform sampler2D detail6; +uniform float tile0MinX; +uniform float tile0MinY; +uniform float tile0StepX; +uniform float tile0StepY; +uniform float tile0Width; +uniform float tile0Height; +uniform float tile1MinX; +uniform float tile1MinY; +uniform float tile1StepX; +uniform float tile1StepY; +uniform float tile1Width; +uniform float tile1Height; +uniform float tile2MinX; +uniform float tile2MinY; +uniform float tile2StepX; +uniform float tile2StepY; +uniform float tile2Width; +uniform float tile2Height; +uniform float tile3MinX; +uniform float tile3MinY; +uniform float tile3StepX; +uniform float tile3StepY; +uniform float tile3Width; +uniform float tile3Height; +uniform float tile4MinX; +uniform float tile4MinY; +uniform float tile4StepX; +uniform float tile4StepY; +uniform float tile4Width; +uniform float tile4Height; +uniform float tile5MinX; +uniform float tile5MinY; +uniform float tile5StepX; +uniform float tile5StepY; +uniform float tile5Width; +uniform float tile5Height; +uniform float tile6MinX; +uniform float tile6MinY; +uniform float tile6StepX; +uniform float tile6StepY; +uniform float tile6Width; +uniform float tile6Height; + +bool tileContains(vec2 position, float minX, float minY, float stepX, float stepY, float width, float height) { + vec2 minimum = vec2(minX, minY); + vec2 maximum = minimum + max(vec2(width, height) - vec2(2.0), vec2(0.0)) * vec2(stepX, stepY); + return position.x >= minimum.x && position.x < min(maximum.x, 1.0) && + position.y >= minimum.y && position.y < min(maximum.y, 1.0); +} + +vec2 tileCoordinate(vec2 position, float minX, float minY, float stepX, float stepY, float width, float height) { + vec2 texel = (position - vec2(minX, minY)) / vec2(stepX, stepY) + vec2(1.0); + return texel / vec2(width, height); +} + +void main() { + vec2 objectSize = max(bounds.zw - bounds.xy, vec2(1.0)); + vec2 local = vec2( + (gl_FragCoord.x - bounds.x) / objectSize.x, + ((frame.y - gl_FragCoord.y) - bounds.y) / objectSize.y + ); + if (local.x < 0.0 || local.x > 1.0 || local.y < 0.0 || local.y > 1.0) { + discard; + } + + vec4 color = texture2D(overview, local); + float bestStep = 0.0; + + if (min(tile0StepX, tile0StepY) > 0.0 && (bestStep == 0.0 || max(tile0StepX, tile0StepY) < bestStep) && tileContains(local, tile0MinX, tile0MinY, tile0StepX, tile0StepY, tile0Width, tile0Height)) { + color = texture2D(detail0, tileCoordinate(local, tile0MinX, tile0MinY, tile0StepX, tile0StepY, tile0Width, tile0Height)); + bestStep = max(tile0StepX, tile0StepY); + } + if (min(tile1StepX, tile1StepY) > 0.0 && (bestStep == 0.0 || max(tile1StepX, tile1StepY) < bestStep) && tileContains(local, tile1MinX, tile1MinY, tile1StepX, tile1StepY, tile1Width, tile1Height)) { + color = texture2D(detail1, tileCoordinate(local, tile1MinX, tile1MinY, tile1StepX, tile1StepY, tile1Width, tile1Height)); + bestStep = max(tile1StepX, tile1StepY); + } + if (min(tile2StepX, tile2StepY) > 0.0 && (bestStep == 0.0 || max(tile2StepX, tile2StepY) < bestStep) && tileContains(local, tile2MinX, tile2MinY, tile2StepX, tile2StepY, tile2Width, tile2Height)) { + color = texture2D(detail2, tileCoordinate(local, tile2MinX, tile2MinY, tile2StepX, tile2StepY, tile2Width, tile2Height)); + bestStep = max(tile2StepX, tile2StepY); + } + if (min(tile3StepX, tile3StepY) > 0.0 && (bestStep == 0.0 || max(tile3StepX, tile3StepY) < bestStep) && tileContains(local, tile3MinX, tile3MinY, tile3StepX, tile3StepY, tile3Width, tile3Height)) { + color = texture2D(detail3, tileCoordinate(local, tile3MinX, tile3MinY, tile3StepX, tile3StepY, tile3Width, tile3Height)); + bestStep = max(tile3StepX, tile3StepY); + } + if (min(tile4StepX, tile4StepY) > 0.0 && (bestStep == 0.0 || max(tile4StepX, tile4StepY) < bestStep) && tileContains(local, tile4MinX, tile4MinY, tile4StepX, tile4StepY, tile4Width, tile4Height)) { + color = texture2D(detail4, tileCoordinate(local, tile4MinX, tile4MinY, tile4StepX, tile4StepY, tile4Width, tile4Height)); + bestStep = max(tile4StepX, tile4StepY); + } + if (min(tile5StepX, tile5StepY) > 0.0 && (bestStep == 0.0 || max(tile5StepX, tile5StepY) < bestStep) && tileContains(local, tile5MinX, tile5MinY, tile5StepX, tile5StepY, tile5Width, tile5Height)) { + color = texture2D(detail5, tileCoordinate(local, tile5MinX, tile5MinY, tile5StepX, tile5StepY, tile5Width, tile5Height)); + bestStep = max(tile5StepX, tile5StepY); + } + if (min(tile6StepX, tile6StepY) > 0.0 && (bestStep == 0.0 || max(tile6StepX, tile6StepY) < bestStep) && tileContains(local, tile6MinX, tile6MinY, tile6StepX, tile6StepY, tile6Width, tile6Height)) { + color = texture2D(detail6, tileCoordinate(local, tile6MinX, tile6MinY, tile6StepX, tile6StepY, tile6Width, tile6Height)); + bestStep = max(tile6StepX, tile6StepY); + } + + if (color.a <= 0.0) { + discard; + } + color.rgb /= color.a; + gl_FragColor = color; +} +` + +const tileShaderSourceES = `#version 100 + +#ifdef GL_ES +# ifdef GL_FRAGMENT_PRECISION_HIGH +precision highp float; +# else +precision mediump float; +#endif +precision mediump int; +#endif + +uniform vec2 frame; +uniform vec4 bounds; +uniform sampler2D overview; +uniform sampler2D detail0; +uniform sampler2D detail1; +uniform sampler2D detail2; +uniform sampler2D detail3; +uniform sampler2D detail4; +uniform sampler2D detail5; +uniform sampler2D detail6; +uniform float tile0MinX; +uniform float tile0MinY; +uniform float tile0StepX; +uniform float tile0StepY; +uniform float tile0Width; +uniform float tile0Height; +uniform float tile1MinX; +uniform float tile1MinY; +uniform float tile1StepX; +uniform float tile1StepY; +uniform float tile1Width; +uniform float tile1Height; +uniform float tile2MinX; +uniform float tile2MinY; +uniform float tile2StepX; +uniform float tile2StepY; +uniform float tile2Width; +uniform float tile2Height; +uniform float tile3MinX; +uniform float tile3MinY; +uniform float tile3StepX; +uniform float tile3StepY; +uniform float tile3Width; +uniform float tile3Height; +uniform float tile4MinX; +uniform float tile4MinY; +uniform float tile4StepX; +uniform float tile4StepY; +uniform float tile4Width; +uniform float tile4Height; +uniform float tile5MinX; +uniform float tile5MinY; +uniform float tile5StepX; +uniform float tile5StepY; +uniform float tile5Width; +uniform float tile5Height; +uniform float tile6MinX; +uniform float tile6MinY; +uniform float tile6StepX; +uniform float tile6StepY; +uniform float tile6Width; +uniform float tile6Height; + +bool tileContains(vec2 position, float minX, float minY, float stepX, float stepY, float width, float height) { + vec2 minimum = vec2(minX, minY); + vec2 maximum = minimum + max(vec2(width, height) - vec2(2.0), vec2(0.0)) * vec2(stepX, stepY); + return position.x >= minimum.x && position.x < min(maximum.x, 1.0) && + position.y >= minimum.y && position.y < min(maximum.y, 1.0); +} + +vec2 tileCoordinate(vec2 position, float minX, float minY, float stepX, float stepY, float width, float height) { + vec2 texel = (position - vec2(minX, minY)) / vec2(stepX, stepY) + vec2(1.0); + return texel / vec2(width, height); +} + +void main() { + vec2 objectSize = max(bounds.zw - bounds.xy, vec2(1.0)); + vec2 local = vec2( + (gl_FragCoord.x - bounds.x) / objectSize.x, + ((frame.y - gl_FragCoord.y) - bounds.y) / objectSize.y + ); + if (local.x < 0.0 || local.x > 1.0 || local.y < 0.0 || local.y > 1.0) { + discard; + } + + vec4 color = texture2D(overview, local); + float bestStep = 0.0; + + if (min(tile0StepX, tile0StepY) > 0.0 && (bestStep == 0.0 || max(tile0StepX, tile0StepY) < bestStep) && tileContains(local, tile0MinX, tile0MinY, tile0StepX, tile0StepY, tile0Width, tile0Height)) { + color = texture2D(detail0, tileCoordinate(local, tile0MinX, tile0MinY, tile0StepX, tile0StepY, tile0Width, tile0Height)); + bestStep = max(tile0StepX, tile0StepY); + } + if (min(tile1StepX, tile1StepY) > 0.0 && (bestStep == 0.0 || max(tile1StepX, tile1StepY) < bestStep) && tileContains(local, tile1MinX, tile1MinY, tile1StepX, tile1StepY, tile1Width, tile1Height)) { + color = texture2D(detail1, tileCoordinate(local, tile1MinX, tile1MinY, tile1StepX, tile1StepY, tile1Width, tile1Height)); + bestStep = max(tile1StepX, tile1StepY); + } + if (min(tile2StepX, tile2StepY) > 0.0 && (bestStep == 0.0 || max(tile2StepX, tile2StepY) < bestStep) && tileContains(local, tile2MinX, tile2MinY, tile2StepX, tile2StepY, tile2Width, tile2Height)) { + color = texture2D(detail2, tileCoordinate(local, tile2MinX, tile2MinY, tile2StepX, tile2StepY, tile2Width, tile2Height)); + bestStep = max(tile2StepX, tile2StepY); + } + if (min(tile3StepX, tile3StepY) > 0.0 && (bestStep == 0.0 || max(tile3StepX, tile3StepY) < bestStep) && tileContains(local, tile3MinX, tile3MinY, tile3StepX, tile3StepY, tile3Width, tile3Height)) { + color = texture2D(detail3, tileCoordinate(local, tile3MinX, tile3MinY, tile3StepX, tile3StepY, tile3Width, tile3Height)); + bestStep = max(tile3StepX, tile3StepY); + } + if (min(tile4StepX, tile4StepY) > 0.0 && (bestStep == 0.0 || max(tile4StepX, tile4StepY) < bestStep) && tileContains(local, tile4MinX, tile4MinY, tile4StepX, tile4StepY, tile4Width, tile4Height)) { + color = texture2D(detail4, tileCoordinate(local, tile4MinX, tile4MinY, tile4StepX, tile4StepY, tile4Width, tile4Height)); + bestStep = max(tile4StepX, tile4StepY); + } + if (min(tile5StepX, tile5StepY) > 0.0 && (bestStep == 0.0 || max(tile5StepX, tile5StepY) < bestStep) && tileContains(local, tile5MinX, tile5MinY, tile5StepX, tile5StepY, tile5Width, tile5Height)) { + color = texture2D(detail5, tileCoordinate(local, tile5MinX, tile5MinY, tile5StepX, tile5StepY, tile5Width, tile5Height)); + bestStep = max(tile5StepX, tile5StepY); + } + if (min(tile6StepX, tile6StepY) > 0.0 && (bestStep == 0.0 || max(tile6StepX, tile6StepY) < bestStep) && tileContains(local, tile6MinX, tile6MinY, tile6StepX, tile6StepY, tile6Width, tile6Height)) { + color = texture2D(detail6, tileCoordinate(local, tile6MinX, tile6MinY, tile6StepX, tile6StepY, tile6Width, tile6Height)); + bestStep = max(tile6StepX, tile6StepY); + } + + if (color.a <= 0.0) { + discard; + } + color.rgb /= color.a; + gl_FragColor = color; +} +` + +const ( + leftShaderPaneName = "picfetch-compare-tiled-v1-left" + rightShaderPaneName = "picfetch-compare-tiled-v1-right" +) + +type shaderPaneRenderer struct { + shader *canvas.Shader + placeholder *image.RGBA + source *renderSource + scene paneScene + bound [detailSamplerCount]*renderTile + + queueUI func(func()) + generateTile func(context.Context, *renderSource, tileKey) (*renderTile, error) + + workerMu sync.Mutex + workerRevision uint64 + workerSource *renderSource + workerRequests []tileRequest + workerContext context.Context + workerCancel context.CancelFunc + workerRunning bool + workerPending workTracker + publicationQueued bool +} + +func newShaderPaneRenderer(index int) paneRenderer { + name := leftShaderPaneName + if index == 1 { + name = rightShaderPaneName + } + placeholder := image.NewRGBA(image.Rect(0, 0, 1, 1)) + shader := canvas.NewShader(name, []byte(tileShaderSourceDesktop), []byte(tileShaderSourceES)) + shader.Textures = make(map[string]image.Image, 1+detailSamplerCount) + shader.Uniforms = make(map[string]float32, detailSamplerCount*6) + shader.Textures["overview"] = placeholder + for slot := range detailSamplerCount { + shader.Textures[detailTextureName(slot)] = placeholder + for _, suffix := range []string{"MinX", "MinY", "StepX", "StepY", "Width", "Height"} { + shader.Uniforms[detailUniform(slot, suffix)] = 0 + } + } + shader.Hide() + return &shaderPaneRenderer{ + shader: shader, + placeholder: placeholder, + queueUI: func(apply func()) { fyne.Do(apply) }, + generateTile: generateRenderTile, + } +} + +func (r *shaderPaneRenderer) Object() fyne.CanvasObject { return r.shader } + +func (r *shaderPaneRenderer) Present(scene paneScene) { + if scene.source == nil || scene.source.frame == nil || scene.source.overview == nil { + r.clear() + return + } + + if r.source != scene.source { + r.cancelTileRequest() + r.source = scene.source + r.shader.Textures["overview"] = scene.source.overview + for slot := range detailSamplerCount { + r.clearDetail(slot) + } + } + r.scene = scene + + plan := planTiles(scene) + r.bindAvailable(scene, plan) + + r.shader.Resize(scene.imageSize) + r.shader.Move(scene.imagePosition) + r.shader.Show() + r.shader.Refresh() + r.requestTiles(scene.source, plan.requests) +} + +func (r *shaderPaneRenderer) bindAvailable(scene paneScene, plan tilePlan) { + if scene.source == nil || scene.source.tiles == nil || len(plan.requests) == 0 { + for slot := range detailSamplerCount { + r.clearDetail(slot) + } + return + } + + ready := make(map[tileKey]*renderTile, detailSamplerCount) + allDesiredReady := true + // Touch distant prefetch entries first so the nearest visible tiles finish + // as the cache's most-recently-used entries. + for _, request := range slices.Backward(plan.requests) { + + tile, ok := scene.source.tiles.Get(request.key.cacheKey()) + if !ok { + allDesiredReady = false + continue + } + ready[request.key] = tile + } + + assigned := make(map[tileKey]bool, detailSamplerCount) + for slot, tile := range r.bound { + if tile == nil { + continue + } + if _, wanted := ready[tile.key]; wanted { + assigned[tile.key] = true + continue + } + if allDesiredReady { + r.clearDetail(slot) + } + } + + for _, request := range plan.requests { + tile := ready[request.key] + if tile == nil || assigned[request.key] { + continue + } + slot := r.availableDetailSlot(ready) + if slot < 0 { + break + } + r.bindDetail(slot, tile, scene.source.frame.Bounds().Size()) + assigned[request.key] = true + } +} + +func (r *shaderPaneRenderer) availableDetailSlot(wanted map[tileKey]*renderTile) int { + for slot, tile := range r.bound { + if tile == nil { + return slot + } + } + for slot, tile := range r.bound { + if _, keep := wanted[tile.key]; !keep { + return slot + } + } + return -1 +} + +func (r *shaderPaneRenderer) bindDetail(slot int, tile *renderTile, sourceSize image.Point) { + if slot < 0 || slot >= detailSamplerCount || tile == nil || tile.texture == nil { + return + } + r.bound[slot] = tile + r.shader.Textures[detailTextureName(slot)] = tile.texture + r.shader.Uniforms[detailUniform(slot, "MinX")] = float32(tile.interior.Min.X*tile.scale) / float32(sourceSize.X) + r.shader.Uniforms[detailUniform(slot, "MinY")] = float32(tile.interior.Min.Y*tile.scale) / float32(sourceSize.Y) + r.shader.Uniforms[detailUniform(slot, "StepX")] = float32(tile.scale) / float32(sourceSize.X) + r.shader.Uniforms[detailUniform(slot, "StepY")] = float32(tile.scale) / float32(sourceSize.Y) + r.shader.Uniforms[detailUniform(slot, "Width")] = float32(tile.texture.Bounds().Dx()) + r.shader.Uniforms[detailUniform(slot, "Height")] = float32(tile.texture.Bounds().Dy()) +} + +func (r *shaderPaneRenderer) clearDetail(slot int) { + r.bound[slot] = nil + r.shader.Textures[detailTextureName(slot)] = r.placeholder + r.shader.Uniforms[detailUniform(slot, "StepX")] = 0 + r.shader.Uniforms[detailUniform(slot, "StepY")] = 0 +} + +func (r *shaderPaneRenderer) clear() { + r.cancelTileRequest() + r.source = nil + r.scene = paneScene{} + r.shader.Textures["overview"] = r.placeholder + for slot := range detailSamplerCount { + r.clearDetail(slot) + } + r.shader.Hide() + r.shader.Refresh() +} + +func (r *shaderPaneRenderer) setQueueUI(queue func(func())) { + if queue == nil { + r.queueUI = func(apply func()) { fyne.Do(apply) } + return + } + r.queueUI = queue +} + +func (r *shaderPaneRenderer) requestTiles(source *renderSource, requests []tileRequest) { + if source == nil || source.tiles == nil { + r.cancelTileRequest() + return + } + missing := false + for _, request := range requests { + if !source.tiles.Contains(request.key.cacheKey()) { + missing = true + break + } + } + r.workerMu.Lock() + if r.workerRunning && r.workerSource == source { + if sameTileRequests(r.workerRequests, requests) { + r.workerMu.Unlock() + return + } + // A pan or zoom replaces the desired plan, but does not cancel the + // tile whose destination buffer is already allocated. Let that one + // finish, cache it, then move directly to the latest plan. Repeated + // cancellation here otherwise strands one full tile per input event + // until the next GC cycle. + r.workerRevision++ + r.workerRequests = append(r.workerRequests[:0], requests...) + r.workerMu.Unlock() + return + } + if !missing { + r.workerMu.Unlock() + // A worker may have populated the last missing cache entry between + // Present's bind pass and this check. No active same-source worker + // remains whose queued publication needs preserving. + r.cancelTileRequest() + return + } + r.workerRevision++ + if r.workerCancel != nil { + r.workerCancel() + } + ctx, cancel := context.WithCancel(context.Background()) + r.workerContext = ctx + r.workerCancel = cancel + r.workerSource = source + r.workerRequests = append(r.workerRequests[:0], requests...) + if r.workerRunning { + r.workerMu.Unlock() + return + } + r.workerRunning = true + r.workerPending.Add(1) + r.workerMu.Unlock() + go r.runTileWorker() +} + +func (r *shaderPaneRenderer) cancelTileRequest() { + r.workerMu.Lock() + r.workerRevision++ + if r.workerCancel != nil { + r.workerCancel() + } + r.workerContext = nil + r.workerCancel = nil + r.workerSource = nil + r.workerRequests = nil + r.workerMu.Unlock() +} + +func (r *shaderPaneRenderer) runTileWorker() { + defer r.workerPending.Done() + for { + r.workerMu.Lock() + if r.workerSource == nil || len(r.workerRequests) == 0 { + r.workerRunning = false + r.workerMu.Unlock() + return + } + revision := r.workerRevision + source := r.workerSource + requests := append([]tileRequest(nil), r.workerRequests...) + requestContext := r.workerContext + r.workerMu.Unlock() + + for _, request := range requests { + if requestContext.Err() != nil { + break + } + if source.tiles.Contains(request.key.cacheKey()) { + continue + } + tile, err := r.generateTile(requestContext, source, request.key) + if err != nil { + if !errors.Is(err, context.Canceled) { + fyne.LogError("Failed to prepare comparison detail tile", err) + } + continue + } + if !r.cacheGeneratedTile(requestContext, source, tile) { + break + } + r.queueTilePublication() + if !r.latestTileRequest(revision, source) { + break + } + } + + r.workerMu.Lock() + if r.workerRevision != revision { + r.workerMu.Unlock() + continue + } + r.workerRunning = false + r.workerCancel = nil + r.workerMu.Unlock() + return + } +} + +func (r *shaderPaneRenderer) cacheGeneratedTile(ctx context.Context, source *renderSource, tile *renderTile) bool { + r.workerMu.Lock() + defer r.workerMu.Unlock() + if ctx.Err() != nil || r.workerContext != ctx || r.workerSource != source { + return false + } + source.tiles.Add(tile.key.cacheKey(), tile) + return true +} + +func (r *shaderPaneRenderer) queueTilePublication() { + r.workerMu.Lock() + if r.publicationQueued { + r.workerMu.Unlock() + return + } + r.publicationQueued = true + r.workerMu.Unlock() + + // Capture only the renderer. When the UI catches up, one callback binds + // every currently available tile for the latest scene; stale generations + // therefore cannot retain sources or build an interaction backlog. + r.queueUI(func() { + r.workerMu.Lock() + r.publicationQueued = false + r.workerMu.Unlock() + if r.source == nil || r.scene.source != r.source { + return + } + r.bindAvailable(r.scene, planTiles(r.scene)) + r.shader.Refresh() + }) +} + +func (r *shaderPaneRenderer) latestTileRequest(revision uint64, source *renderSource) bool { + r.workerMu.Lock() + defer r.workerMu.Unlock() + return r.workerRevision == revision && r.workerSource == source +} + +func sameTileRequests(a, b []tileRequest) bool { + if len(a) != len(b) { + return false + } + for i := range a { + if a[i] != b[i] { + return false + } + } + return true +} + +func (r *shaderPaneRenderer) Wait(ctx context.Context) error { + return r.workerPending.WaitContext(ctx) +} + +func detailTextureName(slot int) string { + return "detail" + strconv.Itoa(slot) +} + +func detailUniform(slot int, suffix string) string { + return "tile" + strconv.Itoa(slot) + suffix +} diff --git a/internal/ui/compare/shader_test.go b/internal/ui/compare/shader_test.go new file mode 100644 index 0000000..2fd43fc --- /dev/null +++ b/internal/ui/compare/shader_test.go @@ -0,0 +1,207 @@ +package compare + +import ( + "context" + "image" + "maps" + "strings" + "testing" + + "fyne.io/fyne/v2" + "fyne.io/fyne/v2/canvas" + fynetest "fyne.io/fyne/v2/test" +) + +func TestTileShaderSources_AgreeAndDeclareFixedPortableContract(t *testing.T) { + const marker = "uniform vec2 frame;" + desktop := strings.Index(tileShaderSourceDesktop, marker) + es := strings.Index(tileShaderSourceES, marker) + if desktop < 0 || es < 0 { + t.Fatalf("shader sources must both declare the built-in frame uniform") + } + if tileShaderSourceDesktop[desktop:] != tileShaderSourceES[es:] { + t.Fatal("desktop and GLES tile shader bodies differ below their preambles") + } + + shared := tileShaderSourceDesktop[desktop:] + if got := strings.Count(shared, "uniform sampler2D "); got != 1+detailSamplerCount { + t.Errorf("sampler declarations = %d, want overview plus %d details", got, detailSamplerCount) + } + for _, declaration := range []string{ + "uniform sampler2D overview;", + "texture2D(overview, local)", + "return texel / vec2(width, height);", + "float bestStep = 0.0;", + "min(tile0StepX, tile0StepY) > 0.0", + "bestStep == 0.0", + "color.rgb /= color.a;", + } { + if !strings.Contains(shared, declaration) { + t.Errorf("tile shader missing %q", declaration) + } + } + for _, inverted := range []string{"1.0 - local.y", "1.0 - texel.y / height"} { + if strings.Contains(shared, inverted) { + t.Errorf("tile shader vertically inverts Go image textures with %q", inverted) + } + } + for slot := range detailSamplerCount { + for _, declaration := range []string{ + "uniform sampler2D detail" + string(rune('0'+slot)) + ";", + "uniform float tile" + string(rune('0'+slot)) + "StepX;", + "uniform float tile" + string(rune('0'+slot)) + "StepY;", + "uniform float tile" + string(rune('0'+slot)) + "Width;", + "uniform float tile" + string(rune('0'+slot)) + "Height;", + } { + if !strings.Contains(shared, declaration) { + t.Errorf("tile shader missing %q", declaration) + } + } + for _, redundant := range []string{"Active", "MaxX", "MaxY", "Scale"} { + declaration := "uniform float tile" + string(rune('0'+slot)) + redundant + ";" + if strings.Contains(shared, declaration) { + t.Errorf("tile shader wastes portable fragment-uniform budget on %q", declaration) + } + } + } + for _, rawSourceUniform := range []string{"uniform float sourceWidth;", "uniform float sourceHeight;", "1.0e20"} { + if strings.Contains(shared, rawSourceUniform) { + t.Errorf("tile shader uses non-portable raw source coordinate contract %q", rawSourceUniform) + } + } +} + +func TestShaderPaneRenderer_HasStableUniqueNamesAndFixedTextureSlots(t *testing.T) { + app := fynetest.NewApp() + t.Cleanup(app.Quit) + + left := newShaderPaneRenderer(0).(*shaderPaneRenderer) + right := newShaderPaneRenderer(1).(*shaderPaneRenderer) + leftAgain := newShaderPaneRenderer(0).(*shaderPaneRenderer) + if left.shader.Name == right.shader.Name { + t.Fatalf("pane shader names collide at %q", left.shader.Name) + } + if left.shader.Name != leftAgain.shader.Name { + t.Errorf("left shader name changed between instances: %q and %q", left.shader.Name, leftAgain.shader.Name) + } + if len(left.shader.Textures) != 1+detailSamplerCount { + t.Errorf("shader textures = %d, want %d fixed slots", len(left.shader.Textures), 1+detailSamplerCount) + } + if len(left.shader.Uniforms) != detailSamplerCount*6 { + t.Errorf("shader scalar uniforms = %d, want %d", len(left.shader.Uniforms), detailSamplerCount*6) + } +} + +func TestShaderPaneRenderer_PreservesSamplerSlotsWhenRequestPriorityChanges(t *testing.T) { + app := fynetest.NewApp() + t.Cleanup(app.Quit) + + source, err := prepareRenderSource(context.Background(), image.NewRGBA(image.Rect(0, 0, 4096, 1024))) + if err != nil { + t.Fatalf("prepare source: %v", err) + } + keys := []tileKey{ + {level: 0, x: 0, y: 0}, + {level: 0, x: 1, y: 0}, + {level: 0, x: 2, y: 0}, + } + for _, key := range keys { + source.tiles.Add(key.cacheKey(), &renderTile{ + key: key, + texture: image.NewRGBA(image.Rect(0, 0, tileTextureDimension, tileTextureDimension)), + interior: image.Rect(key.x*tileInterior, 0, (key.x+1)*tileInterior, tileInterior), + scale: 1, + }) + } + + renderer := newShaderPaneRenderer(0).(*shaderPaneRenderer) + scene := paneScene{source: source} + renderer.bindAvailable(scene, tilePlan{requests: []tileRequest{ + {key: keys[0]}, {key: keys[1]}, {key: keys[2]}, + }}) + before := renderer.bound + renderer.bindAvailable(scene, tilePlan{requests: []tileRequest{ + {key: keys[2]}, {key: keys[1]}, {key: keys[0]}, + }}) + for slot := range len(keys) { + if renderer.bound[slot] != before[slot] { + t.Errorf("request reprioritization replaced sampler slot %d", slot) + } + } +} + +func TestShaderPaneRenderer_MapsSceneAndCachedTilesWithoutReplacingStableTextures(t *testing.T) { + app := fynetest.NewApp() + t.Cleanup(app.Quit) + + frame := image.NewRGBA(image.Rect(0, 0, 1024, 2)) + source := newPreparedRenderSource(frame, image.NewRGBA(image.Rect(0, 0, 512, 1))) + for x := range 2 { + key := tileKey{level: 0, x: x, y: 0} + tile, err := generateRenderTile(context.Background(), source, key) + if err != nil { + t.Fatalf("generate tile %d: %v", x, err) + } + source.tiles.Add(key.cacheKey(), tile) + } + + renderer := newShaderPaneRenderer(0).(*shaderPaneRenderer) + object := renderer.Object() + scene := paneScene{ + source: source, + viewport: fyne.NewSize(512, 200), + imagePosition: fyne.NewPos(-20, 99), + imageSize: fyne.NewSize(1024, 2), + displaySize: image.Pt(1024, 2), + } + renderer.Present(scene) + if renderer.Object() != object { + t.Fatal("renderer replaced its canvas object while presenting a scene") + } + if got := renderer.shader.Position(); got != scene.imagePosition { + t.Errorf("shader position = %v, want %v", got, scene.imagePosition) + } + if got := renderer.shader.Size(); got != scene.imageSize { + t.Errorf("shader size = %v, want %v", got, scene.imageSize) + } + if !renderer.shader.Visible() { + t.Fatal("shader stayed hidden after a valid scene") + } + if got := renderer.shader.Textures["overview"]; got != source.overview { + t.Fatal("overview texture is not the prepared source overview") + } + if got := renderer.shader.Uniforms["tile0StepX"]; got != 1.0/1024.0 { + t.Errorf("first detail normalized X step = %v, want %v", got, float32(1.0/1024.0)) + } + if got := renderer.shader.Uniforms["tile0StepY"]; got != 1.0/2.0 { + t.Errorf("first detail normalized Y step = %v, want 0.5", got) + } + before := make(map[string]image.Image, len(renderer.shader.Textures)) + maps.Copy(before, renderer.shader.Textures) + renderer.Present(scene) + for name, texture := range before { + if renderer.shader.Textures[name] != texture { + t.Errorf("unchanged scene replaced texture %q", name) + } + } + + renderer.Present(paneScene{}) + if renderer.shader.Visible() { + t.Fatal("shader remained visible after clear") + } + for slot := range detailSamplerCount { + if renderer.shader.Uniforms[detailUniform(slot, "StepX")] != 0 || + renderer.shader.Uniforms[detailUniform(slot, "StepY")] != 0 { + t.Errorf("detail slot %d remained active after clear", slot) + } + if renderer.shader.Textures[detailTextureName(slot)] != renderer.placeholder { + t.Errorf("detail slot %d retained an application texture after clear", slot) + } + } + if renderer.shader.Textures["overview"] != renderer.placeholder { + t.Fatal("clear retained the source overview") + } + if _, ok := renderer.Object().(*canvas.Shader); !ok { + t.Fatalf("renderer object type = %T, want *canvas.Shader", renderer.Object()) + } +} diff --git a/internal/ui/compare/source_test.go b/internal/ui/compare/source_test.go new file mode 100644 index 0000000..86c9125 --- /dev/null +++ b/internal/ui/compare/source_test.go @@ -0,0 +1,114 @@ +package compare + +import ( + "bytes" + "context" + "errors" + "image" + "image/color" + "testing" + "time" + + "fyne.io/fyne/v2" + "fyne.io/fyne/v2/storage" + fynetest "fyne.io/fyne/v2/test" + + "github.com/frathe/picfetch/internal/imaging" +) + +func TestPrepareRenderSource_BuildsBoundedOverviewWithoutMutatingFrame(t *testing.T) { + frame := image.NewNRGBA(image.Rect(11, 17, 4107, 1041)) + for y := frame.Bounds().Min.Y; y < frame.Bounds().Max.Y; y++ { + for x := frame.Bounds().Min.X; x < frame.Bounds().Max.X; x++ { + frame.SetNRGBA(x, y, color.NRGBA{ + R: uint8(x % 251), G: uint8(y % 241), B: uint8((x + y) % 239), A: uint8(64 + (x+y)%192), + }) + } + } + before := append([]byte(nil), frame.Pix...) + + source, err := prepareRenderSource(context.Background(), frame) + if err != nil { + t.Fatalf("prepareRenderSource: %v", err) + } + if source.frame != frame { + t.Fatal("prepared source replaced the canonical decoded frame") + } + if got := source.overview.Bounds().Size(); got != image.Pt(1024, 256) { + t.Errorf("overview size = %v, want 1024x256", got) + } + if !bytes.Equal(frame.Pix, before) { + t.Fatal("overview generation mutated the canonical decoded pixels") + } + _, _, _, alpha := source.overview.At(511, 127).RGBA() + if alpha == 0 || alpha == 0xffff { + t.Errorf("overview alpha = %#x, want preserved partial transparency", alpha) + } +} + +func TestPrepareRenderSource_ObservesCancellation(t *testing.T) { + ctx, cancel := context.WithCancel(context.Background()) + cancel() + _, err := prepareRenderSource(ctx, image.NewRGBA(image.Rect(0, 0, 2000, 1000))) + if !errors.Is(err, context.Canceled) { + t.Fatalf("prepareRenderSource error = %v, want context.Canceled", err) + } +} + +func TestCompareReady_WaitsForBothPreparedOverviews(t *testing.T) { + app := fynetest.NewApp() + t.Cleanup(app.Quit) + + started := make(chan struct{}, 2) + release := make(chan struct{}) + feature := newReferenceFeature(func(_ context.Context, _ fyne.URI) (*imaging.LoadedImage, error) { + return &imaging.LoadedImage{Frames: []image.Image{image.NewRGBA(image.Rect(0, 0, 1600, 800))}}, nil + }, Callbacks{}) + feature.prepareSource = func(ctx context.Context, frame image.Image) (*renderSource, error) { + started <- struct{}{} + select { + case <-release: + return prepareRenderSource(ctx, frame) + case <-ctx.Done(): + return nil, ctx.Err() + } + } + feature.Overlay().Resize(fyne.NewSize(800, 400)) + feature.Open([2]fyne.URI{ + storage.NewFileURI("left.png"), + storage.NewFileURI("right.png"), + }) + for range 2 { + select { + case <-started: + case <-time.After(time.Second): + t.Fatal("timed out waiting for overview preparation") + } + } + if feature.Ready() { + t.Fatal("comparison became ready before overview preparation completed") + } + for i := range feature.panes { + if !feature.panes[i].spinner.Visible() { + t.Errorf("pane %d spinner hidden while overview preparation is pending", i) + } + } + + close(release) + ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second) + defer cancel() + if err := feature.Settle(ctx); err != nil { + t.Fatalf("Settle: %v", err) + } + if !feature.Ready() { + t.Fatal("comparison did not become ready after both overviews completed") + } + for i, source := range feature.renderSources { + if source == nil || source.overview == nil { + t.Errorf("pane %d has no display-ready overview", i) + } + if feature.panes[i].spinner.Visible() { + t.Errorf("pane %d spinner remained visible after overview preparation", i) + } + } +} diff --git a/internal/ui/compare/swipe.go b/internal/ui/compare/swipe.go index 1ccc8f6..7795fb0 100644 --- a/internal/ui/compare/swipe.go +++ b/internal/ui/compare/swipe.go @@ -90,6 +90,18 @@ func (f *Feature) layoutSwipeReveal(size fyne.Size) { f.divider.Resize(fyne.NewSize(thickness, size.Height)) } +func (f *Feature) paneVisibleArea(index int) (fyne.Position, fyne.Size) { + viewport := f.viewports[index] + if f.layoutMode != swipe { + return fyne.Position{}, viewport + } + boundary := min(max(f.dividerAt, 0), 1) * viewport.Width + if index == 0 { + return fyne.Position{}, fyne.NewSize(boundary, viewport.Height) + } + return fyne.NewPos(boundary, 0), fyne.NewSize(viewport.Width-boundary, viewport.Height) +} + func (f *Feature) layoutReveal(index int, clipPosition fyne.Position, clipSize fyne.Size, rootPosition fyne.Position, rootSize fyne.Size) { reveal := f.reveals[index] reveal.clip.Move(clipPosition) @@ -151,13 +163,13 @@ func (f *Feature) setDivider(position float32) { f.layoutSwipeReveal(f.content.Size()) } -func (f *Feature) handleDividerKey(name fyne.KeyName) bool { +func (f *Feature) handleDividerKey(name fyne.KeyName, modifiers fyne.KeyModifier) bool { if f.layoutMode != swipe { return false } step := dividerKeyStep - if f.callbacks.Modifiers != nil && f.callbacks.Modifiers()&fyne.KeyModifierShift != 0 { + if modifiers&fyne.KeyModifierShift != 0 { step = dividerFineKeyStep } switch name { diff --git a/internal/ui/compare/tile.go b/internal/ui/compare/tile.go new file mode 100644 index 0000000..46c4edc --- /dev/null +++ b/internal/ui/compare/tile.go @@ -0,0 +1,352 @@ +package compare + +import ( + "context" + "errors" + "fmt" + "image" + "image/color" + "image/draw" + "math" + "sort" + "strconv" + + "fyne.io/fyne/v2" + xdraw "golang.org/x/image/draw" +) + +const ( + detailSamplerCount = 7 + tileTextureDimension = 1024 + tileGutter = 1 + tileInterior = tileTextureDimension - 2*tileGutter + tileCacheBudgetBytes = int64(64 << 20) +) + +type tileKey struct { + level int + x int + y int +} + +func (k tileKey) cacheKey() string { + return strconv.Itoa(k.level) + "/" + strconv.Itoa(k.x) + "/" + strconv.Itoa(k.y) +} + +type tileRequest struct { + key tileKey + visible bool +} + +type sourceRect struct { + minX float64 + minY float64 + maxX float64 + maxY float64 +} + +type tilePlan struct { + level int + visible sourceRect + requests []tileRequest +} + +type renderTile struct { + key tileKey + texture *image.RGBA + interior image.Rectangle + scale int +} + +type edgeClampedImage struct { + image.Image + bounds image.Rectangle +} + +func (img edgeClampedImage) Bounds() image.Rectangle { return img.bounds } + +func (img edgeClampedImage) At(x, y int) color.Color { + bounds := img.Image.Bounds() + x = min(max(x, bounds.Min.X), bounds.Max.X-1) + y = min(max(y, bounds.Min.Y), bounds.Max.Y-1) + return img.Image.At(x, y) +} + +func planTiles(scene paneScene) tilePlan { + visible, ok := visibleSource(scene) + if !ok { + return tilePlan{} + } + if overviewCoversDisplay(scene) { + return tilePlan{visible: visible} + } + bounds := scene.source.frame.Bounds() + width, height := bounds.Dx(), bounds.Dy() + maximumLevel := maxMipLevel(width, height) + level := desiredMipLevel(width, height, scene.displaySize, maximumLevel) + + var minX, maxX, minY, maxY int + for { + minX, maxX, minY, maxY = visibleTileRange(visible, width, height, level) + count := int64(maxX-minX+1) * int64(maxY-minY+1) + if count <= detailSamplerCount || level >= maximumLevel { + break + } + level++ + } + + plan := tilePlan{level: level, visible: visible} + centerX := (visible.minX + visible.maxX) / 2 + centerY := (visible.minY + visible.maxY) / 2 + for y := minY; y <= maxY; y++ { + for x := minX; x <= maxX; x++ { + plan.requests = append(plan.requests, tileRequest{ + key: tileKey{level: level, x: x, y: y}, + visible: true, + }) + } + } + sortTileRequests(plan.requests, centerX, centerY) + + columns, rows := tileGrid(width, height, level) + seen := make(map[tileKey]bool, detailSamplerCount) + for _, request := range plan.requests { + seen[request.key] = true + } + for radius := 1; len(plan.requests) < detailSamplerCount && radius <= max(columns, rows); radius++ { + left := max(0, minX-radius) + right := min(columns-1, maxX+radius) + top := max(0, minY-radius) + bottom := min(rows-1, maxY+radius) + candidates := make([]tileRequest, 0, 2*(right-left+bottom-top+2)) + for y := top; y <= bottom; y++ { + for x := left; x <= right; x++ { + if x > left && x < right && y > top && y < bottom { + continue + } + key := tileKey{level: level, x: x, y: y} + if seen[key] { + continue + } + seen[key] = true + candidates = append(candidates, tileRequest{key: key}) + } + } + sortTileRequests(candidates, centerX, centerY) + remaining := detailSamplerCount - len(plan.requests) + if len(candidates) > remaining { + candidates = candidates[:remaining] + } + plan.requests = append(plan.requests, candidates...) + } + return plan +} + +func overviewCoversDisplay(scene paneScene) bool { + if scene.source == nil || scene.source.frame == nil || scene.source.overview == nil { + return false + } + frame := scene.source.frame.Bounds().Size() + overview := scene.source.overview.Bounds().Size() + if overview.X >= frame.X && overview.Y >= frame.Y { + return true + } + return scene.displaySize.X <= overview.X && scene.displaySize.Y <= overview.Y +} + +func visibleSource(scene paneScene) (sourceRect, bool) { + if scene.source == nil || scene.source.frame == nil || + scene.viewport.Width <= 0 || scene.viewport.Height <= 0 || + scene.imageSize.Width <= 0 || scene.imageSize.Height <= 0 { + return sourceRect{}, false + } + bounds := scene.source.frame.Bounds() + width, height := bounds.Dx(), bounds.Dy() + if width <= 0 || height <= 0 { + return sourceRect{}, false + } + revealPosition := fyne.Position{} + revealSize := scene.viewport + if scene.revealSet { + revealPosition = scene.revealPosition + revealSize = scene.revealSize + } + left := max(float64(revealPosition.X), float64(scene.imagePosition.X)) + top := max(float64(revealPosition.Y), float64(scene.imagePosition.Y)) + right := min(float64(revealPosition.X+revealSize.Width), float64(scene.imagePosition.X+scene.imageSize.Width)) + bottom := min(float64(revealPosition.Y+revealSize.Height), float64(scene.imagePosition.Y+scene.imageSize.Height)) + left = max(left, 0) + top = max(top, 0) + right = min(right, float64(scene.viewport.Width)) + bottom = min(bottom, float64(scene.viewport.Height)) + if right <= left || bottom <= top { + return sourceRect{}, false + } + positionX, positionY := float64(scene.imagePosition.X), float64(scene.imagePosition.Y) + displayWidth, displayHeight := float64(scene.imageSize.Width), float64(scene.imageSize.Height) + visible := sourceRect{ + minX: (left - positionX) / displayWidth * float64(width), + minY: (top - positionY) / displayHeight * float64(height), + maxX: (right - positionX) / displayWidth * float64(width), + maxY: (bottom - positionY) / displayHeight * float64(height), + } + visible.minX = min(max(visible.minX, 0), float64(width)) + visible.minY = min(max(visible.minY, 0), float64(height)) + visible.maxX = min(max(visible.maxX, 0), float64(width)) + visible.maxY = min(max(visible.maxY, 0), float64(height)) + return visible, visible.maxX > visible.minX && visible.maxY > visible.minY +} + +func desiredMipLevel(width, height int, display image.Point, maximum int) int { + if display.X <= 0 || display.Y <= 0 { + return 0 + } + sourcePerPixel := max(float64(width)/float64(display.X), float64(height)/float64(display.Y)) + level := 0 + for sourcePerPixel >= 2 && level < maximum { + sourcePerPixel /= 2 + level++ + } + return level +} + +func visibleTileRange(visible sourceRect, width, height, level int) (minX, maxX, minY, maxY int) { + columns, rows := tileGrid(width, height, level) + coverage := float64(tileInterior * mipScale(level)) + minX = min(max(int(math.Floor(visible.minX/coverage)), 0), columns-1) + minY = min(max(int(math.Floor(visible.minY/coverage)), 0), rows-1) + maxX = min(max(int(math.Ceil(visible.maxX/coverage))-1, minX), columns-1) + maxY = min(max(int(math.Ceil(visible.maxY/coverage))-1, minY), rows-1) + return minX, maxX, minY, maxY +} + +func sortTileRequests(requests []tileRequest, centerX, centerY float64) { + sort.SliceStable(requests, func(i, j int) bool { + a, b := requests[i].key, requests[j].key + coverage := float64(tileInterior * mipScale(a.level)) + aX, aY := (float64(a.x)+0.5)*coverage, (float64(a.y)+0.5)*coverage + bX, bY := (float64(b.x)+0.5)*coverage, (float64(b.y)+0.5)*coverage + aDistance := (aX-centerX)*(aX-centerX) + (aY-centerY)*(aY-centerY) + bDistance := (bX-centerX)*(bX-centerX) + (bY-centerY)*(bY-centerY) + if aDistance != bDistance { + return aDistance < bDistance + } + if a.y != b.y { + return a.y < b.y + } + return a.x < b.x + }) +} + +func maxMipLevel(width, height int) int { + dimension := max(width, height) + level := 0 + for dimension > 1 { + dimension = (dimension + 1) / 2 + level++ + } + return level +} + +func mipScale(level int) int { + if level <= 0 { + return 1 + } + return 1 << min(level, 30) +} + +func mipDimension(dimension, level int) int { + scale := mipScale(level) + return max(1, (dimension+scale-1)/scale) +} + +func tileGrid(width, height, level int) (columns, rows int) { + mipWidth := mipDimension(width, level) + mipHeight := mipDimension(height, level) + return (mipWidth + tileInterior - 1) / tileInterior, + (mipHeight + tileInterior - 1) / tileInterior +} + +func generateRenderTile(ctx context.Context, source *renderSource, key tileKey) (*renderTile, error) { + if err := ctx.Err(); err != nil { + return nil, err + } + if source == nil || source.frame == nil { + return nil, errors.New("cannot generate a tile without a render source") + } + frameBounds := source.frame.Bounds() + width, height := frameBounds.Dx(), frameBounds.Dy() + if key.level < 0 || key.level > maxMipLevel(width, height) { + return nil, fmt.Errorf("invalid tile level %d", key.level) + } + columns, rows := tileGrid(width, height, key.level) + if key.x < 0 || key.x >= columns || key.y < 0 || key.y >= rows { + return nil, fmt.Errorf("invalid tile coordinate (%d,%d) for %dx%d grid", key.x, key.y, columns, rows) + } + + scale := mipScale(key.level) + mipBounds := image.Rect(0, 0, mipDimension(width, key.level), mipDimension(height, key.level)) + interior := image.Rect( + key.x*tileInterior, + key.y*tileInterior, + min((key.x+1)*tileInterior, mipBounds.Max.X), + min((key.y+1)*tileInterior, mipBounds.Max.Y), + ) + texture := image.NewRGBA(image.Rect(0, 0, interior.Dx()+2*tileGutter, interior.Dy()+2*tileGutter)) + sample := interior.Inset(-tileGutter).Intersect(mipBounds) + destinationMin := sample.Min.Sub(interior.Min.Sub(image.Pt(tileGutter, tileGutter))) + destination := image.Rectangle{Min: destinationMin, Max: destinationMin.Add(sample.Size())} + sourceRect := image.Rect( + frameBounds.Min.X+sample.Min.X*scale, + frameBounds.Min.Y+sample.Min.Y*scale, + frameBounds.Min.X+sample.Max.X*scale, + frameBounds.Min.Y+sample.Max.Y*scale, + ) + if key.level == 0 { + draw.Draw(texture, destination, source.frame, sourceRect.Min, draw.Src) + } else { + scaleSource := source.frame + if sourceRect.Intersect(frameBounds) != sourceRect { + scaleSource = edgeClampedImage{ + Image: source.frame, + bounds: image.Rect( + frameBounds.Min.X, + frameBounds.Min.Y, + frameBounds.Min.X+mipBounds.Dx()*scale, + frameBounds.Min.Y+mipBounds.Dy()*scale, + ), + } + } + xdraw.ApproxBiLinear.Scale(texture, destination, scaleSource, sourceRect, draw.Src, nil) + } + if err := ctx.Err(); err != nil { + return nil, err + } + + fillMissingGutters(texture, interior, mipBounds) + return &renderTile{key: key, texture: texture, interior: interior, scale: scale}, nil +} + +func fillMissingGutters(texture *image.RGBA, interior, mipBounds image.Rectangle) { + width, height := texture.Bounds().Dx(), texture.Bounds().Dy() + if interior.Min.X == mipBounds.Min.X { + for y := range height { + texture.SetRGBA(0, y, texture.RGBAAt(tileGutter, y)) + } + } + if interior.Max.X == mipBounds.Max.X { + for y := range height { + texture.SetRGBA(width-1, y, texture.RGBAAt(width-1-tileGutter, y)) + } + } + if interior.Min.Y == mipBounds.Min.Y { + for x := range width { + texture.SetRGBA(x, 0, texture.RGBAAt(x, tileGutter)) + } + } + if interior.Max.Y == mipBounds.Max.Y { + for x := range width { + texture.SetRGBA(x, height-1, texture.RGBAAt(x, height-1-tileGutter)) + } + } +} diff --git a/internal/ui/compare/tile_test.go b/internal/ui/compare/tile_test.go new file mode 100644 index 0000000..50990a9 --- /dev/null +++ b/internal/ui/compare/tile_test.go @@ -0,0 +1,258 @@ +package compare + +import ( + "context" + "image" + "image/color" + "reflect" + "testing" + + "fyne.io/fyne/v2" +) + +func plannerScene(width, height int, viewport fyne.Size, position fyne.Position, display fyne.Size, pixels image.Point) paneScene { + frame := image.NewRGBA(image.Rect(0, 0, width, height)) + overview := image.Image(frame) + if width > overviewMaxDimension || height > overviewMaxDimension { + scale := float64(overviewMaxDimension) / float64(max(width, height)) + overview = image.NewRGBA(image.Rect(0, 0, + max(1, int(float64(width)*scale+0.5)), + max(1, int(float64(height)*scale+0.5)), + )) + } + return paneScene{ + source: &renderSource{frame: frame, overview: overview}, + viewport: viewport, + imagePosition: position, + imageSize: display, + displaySize: pixels, + } +} + +func visibleRequests(plan tilePlan) []tileRequest { + requests := make([]tileRequest, 0, len(plan.requests)) + for _, request := range plan.requests { + if request.visible { + requests = append(requests, request) + } + } + return requests +} + +func TestTilePlanner_SelectsDensityAndCoarsensToSamplerBudget(t *testing.T) { + tests := []struct { + name string + scene paneScene + wantLevel int + wantVisible int + }{ + { + name: "overview already meets display density", + scene: plannerScene(4096, 2048, fyne.NewSize(800, 400), fyne.Position{}, fyne.NewSize(800, 400), image.Pt(800, 400)), + wantLevel: 0, + wantVisible: 0, + }, + { + name: "two-x display retains another mip", + scene: plannerScene(4096, 2048, fyne.NewSize(800, 400), fyne.Position{}, fyne.NewSize(800, 400), image.Pt(1600, 800)), + wantLevel: 1, + wantVisible: 6, + }, + { + name: "sampler budget forces coarser level", + scene: plannerScene(10000, 10000, fyne.NewSize(1000, 1000), fyne.Position{}, fyne.NewSize(1000, 1000), image.Pt(10000, 10000)), + wantLevel: 3, + wantVisible: 4, + }, + { + name: "zoomed viewport keeps level zero", + scene: plannerScene(10000, 10000, fyne.NewSize(1000, 1000), fyne.NewPos(-4500, -4500), fyne.NewSize(10000, 10000), image.Pt(10000, 10000)), + wantLevel: 0, + wantVisible: 4, + }, + } + + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + plan := planTiles(tc.scene) + if plan.level != tc.wantLevel { + t.Errorf("level = %d, want %d", plan.level, tc.wantLevel) + } + if got := len(visibleRequests(plan)); got != tc.wantVisible { + t.Errorf("visible requests = %d, want %d (%v)", got, tc.wantVisible, plan.requests) + } + if len(plan.requests) > detailSamplerCount { + t.Errorf("requests = %d, exceeds %d detail samplers", len(plan.requests), detailSamplerCount) + } + }) + } +} + +func TestTilePlanner_SkipsDuplicateDetailsForOriginalSizeOverview(t *testing.T) { + scene := plannerScene( + 800, 400, + fyne.NewSize(400, 200), + fyne.NewPos(-200, -100), + fyne.NewSize(1600, 800), + image.Pt(3200, 1600), + ) + if plan := planTiles(scene); len(plan.requests) != 0 { + t.Fatalf("original-size overview planned duplicate details: %#v", plan.requests) + } +} + +func TestTilePlanner_UsesSwipeRevealInsteadOfHiddenFullPane(t *testing.T) { + scene := plannerScene( + 10000, 10000, + fyne.NewSize(4000, 4000), + fyne.Position{}, + fyne.NewSize(10000, 10000), + image.Pt(10000, 10000), + ) + full := planTiles(scene) + if full.level == 0 { + t.Fatal("full pane fixture did not require a coarser mip") + } + + scene.revealSet = true + scene.revealPosition = fyne.Position{} + scene.revealSize = fyne.NewSize(500, 500) + revealed := planTiles(scene) + if revealed.level != 0 { + t.Errorf("500px swipe reveal level = %d, want sharp level 0", revealed.level) + } + if got := len(visibleRequests(revealed)); got != 1 { + t.Errorf("visible requests through swipe reveal = %d, want 1", got) + } +} + +func TestTilePlanner_PrefetchIsBoundedNearestAndDeterministic(t *testing.T) { + scene := plannerScene( + 10000, 10000, + fyne.NewSize(500, 500), + fyne.NewPos(-4750, -4750), + fyne.NewSize(10000, 10000), + image.Pt(10000, 10000), + ) + first := planTiles(scene) + second := planTiles(scene) + if !reflect.DeepEqual(first, second) { + t.Fatalf("identical scenes produced different plans\nfirst: %#v\nsecond: %#v", first, second) + } + if len(first.requests) != detailSamplerCount { + t.Fatalf("requests = %d, want all %d slots filled", len(first.requests), detailSamplerCount) + } + seen := make(map[tileKey]bool) + for _, request := range first.requests { + if seen[request.key] { + t.Errorf("duplicate request for tile %+v", request.key) + } + seen[request.key] = true + if request.key.level != 0 { + t.Errorf("prefetch changed level to %d, want 0", request.key.level) + } + } + if got := len(visibleRequests(first)); got != 4 { + t.Errorf("visible requests = %d, want 4", got) + } +} + +func TestGenerateRenderTile_LevelZeroHasExactPixelsAndRealGutters(t *testing.T) { + frame := image.NewRGBA(image.Rect(0, 0, 1024, 2)) + for y := range 2 { + for x := range 1024 { + frame.SetRGBA(x, y, color.RGBA{R: uint8(x), G: uint8(x >> 8), B: uint8(y), A: 255}) + } + } + source, err := prepareRenderSource(context.Background(), frame) + if err != nil { + t.Fatalf("prepareRenderSource: %v", err) + } + + left, err := generateRenderTile(context.Background(), source, tileKey{level: 0, x: 0, y: 0}) + if err != nil { + t.Fatalf("generate left tile: %v", err) + } + if got := left.texture.Bounds().Size(); got != image.Pt(1024, 4) { + t.Fatalf("left texture size = %v, want 1024x4", got) + } + assertPixel := func(label string, got color.Color, x, y int) { + t.Helper() + if gotRGBA, want := color.RGBAModel.Convert(got), color.RGBAModel.Convert(frame.At(x, y)); gotRGBA != want { + t.Errorf("%s = %v, want source(%d,%d) %v", label, gotRGBA, x, y, want) + } + } + assertPixel("left outer gutter", left.texture.At(0, 1), 0, 0) + assertPixel("left first interior", left.texture.At(1, 1), 0, 0) + assertPixel("left last interior", left.texture.At(1022, 1), 1021, 0) + assertPixel("left neighboring gutter", left.texture.At(1023, 1), 1022, 0) + + right, err := generateRenderTile(context.Background(), source, tileKey{level: 0, x: 1, y: 0}) + if err != nil { + t.Fatalf("generate right tile: %v", err) + } + if got := right.texture.Bounds().Size(); got != image.Pt(4, 4) { + t.Fatalf("right texture size = %v, want 4x4", got) + } + assertPixel("right neighboring gutter", right.texture.At(0, 1), 1021, 0) + assertPixel("right first interior", right.texture.At(1, 1), 1022, 0) + assertPixel("right last interior", right.texture.At(2, 1), 1023, 0) + assertPixel("right outer gutter", right.texture.At(3, 1), 1023, 0) +} + +func TestGenerateRenderTile_OddCoarseEdgeKeepsNeighborGuttersContinuous(t *testing.T) { + frame := image.NewRGBA(image.Rect(0, 0, 2045, 3)) + for y := range 3 { + for x := range 2045 { + frame.SetRGBA(x, y, color.RGBA{ + R: uint8((x * 37) % 251), + G: uint8((x*x + y*19) % 253), + B: uint8((x*11 + y*47) % 255), + A: 255, + }) + } + } + source, err := prepareRenderSource(context.Background(), frame) + if err != nil { + t.Fatalf("prepareRenderSource: %v", err) + } + + left, err := generateRenderTile(context.Background(), source, tileKey{level: 1, x: 0, y: 0}) + if err != nil { + t.Fatalf("generate left coarse tile: %v", err) + } + right, err := generateRenderTile(context.Background(), source, tileKey{level: 1, x: 1, y: 0}) + if err != nil { + t.Fatalf("generate right coarse tile: %v", err) + } + for y := 1; y < left.texture.Bounds().Dy()-1; y++ { + if got, want := left.texture.RGBAAt(left.texture.Bounds().Dx()-2, y), right.texture.RGBAAt(0, y); got != want { + t.Errorf("left interior/right gutter mismatch at row %d: %v != %v", y, got, want) + } + if got, want := left.texture.RGBAAt(left.texture.Bounds().Dx()-1, y), right.texture.RGBAAt(1, y); got != want { + t.Errorf("left gutter/right interior mismatch at row %d: %v != %v", y, got, want) + } + } +} + +func TestRenderSourceTileCache_IsByteBoundedAndReturnsHits(t *testing.T) { + source, err := prepareRenderSource(context.Background(), image.NewRGBA(image.Rect(0, 0, 1, 1))) + if err != nil { + t.Fatalf("prepareRenderSource: %v", err) + } + first := &renderTile{key: tileKey{}, texture: image.NewRGBA(image.Rect(0, 0, 1024, 1024))} + source.tiles.Add(first.key.cacheKey(), first) + if got, ok := source.tiles.Get(first.key.cacheKey()); !ok || got != first { + t.Fatal("tile cache did not return the exact cached tile") + } + for i := 1; i < 17; i++ { + key := tileKey{x: i} + source.tiles.Add(key.cacheKey(), &renderTile{key: key, texture: image.NewRGBA(image.Rect(0, 0, 1024, 1024))}) + } + if got := source.tiles.Bytes(); got > tileCacheBudgetBytes { + t.Errorf("tile cache bytes = %d, exceeds budget %d", got, tileCacheBudgetBytes) + } + if got := source.tiles.Len(); got != 16 { + t.Errorf("tile cache entries = %d, want 16 full-size textures", got) + } +} diff --git a/internal/ui/compare/transform.go b/internal/ui/compare/transform.go index 061d42d..5f3235e 100644 --- a/internal/ui/compare/transform.go +++ b/internal/ui/compare/transform.go @@ -1,6 +1,7 @@ package compare import ( + "image" "math" "fyne.io/fyne/v2" @@ -13,7 +14,6 @@ const ( compareZoomStep = float32(1.25) minZoomFactor = float32(0.05) maxZoomFactor = float32(16) - comparePanSlack = float32(0.5) scrollSensitivity = float32(0.01) ) @@ -24,31 +24,42 @@ const ( absoluteScale ) -type linkedTransform struct { +type photoTransform struct { center fyne.Position factor float32 mode scaleMode } -func defaultLinkedTransform() linkedTransform { - return linkedTransform{ +type cameraTransform struct { + zoom float32 + // offset is measured from the pane center as a fraction of its viewport. + // Both comparison panes use the same value, so a camera pan is identical + // in points while their viewports have the same size. + offset fyne.Position +} + +func defaultPhotoTransform() photoTransform { + return photoTransform{ center: fyne.NewPos(0.5, 0.5), factor: 1, mode: fitRelative, } } -func newPane(feature *Feature, index int) pane { - img := newPaneImage() +func defaultCameraTransform() cameraTransform { + return cameraTransform{zoom: 1} +} + +func newPane(feature *Feature, index int, renderer paneRenderer) pane { input := newPaneInput(feature, index) - viewport := container.New(paneImageLayout{feature: feature, index: index}, img, input) + viewport := container.New(paneImageLayout{feature: feature, index: index}, renderer.Object(), input) spinner := newPaneSpinner() return pane{ - root: container.NewStack(viewport, container.NewCenter(spinner)), - image: img, - input: input, - spinner: spinner, + root: container.NewStack(viewport, container.NewCenter(spinner)), + renderer: renderer, + input: input, + spinner: spinner, } } @@ -71,38 +82,116 @@ func (paneImageLayout) MinSize(_ []fyne.CanvasObject) fyne.Size { return fyne.Si // HandleKey applies comparison-owned transform keys. The caller still owns // Escape and F1, and swallows every unsupported key while comparison is active. func (f *Feature) HandleKey(name fyne.KeyName) { + f.handleKey(name, f.currentModifiers()) +} + +func (f *Feature) handleKey(name fyne.KeyName, modifiers fyne.KeyModifier) { if !f.active || !f.ready { return } - if f.handleDividerKey(name) { + if f.handleDividerKey(name, modifiers) { + return + } + + if f.unlinked { + if f.hoveredPane < 0 || f.hoveredPane >= len(f.photoTransforms) { + return + } + if !f.applyPhotoKey(f.hoveredPane, name) { + return + } + f.applyTransform() + return + } + + if !f.applyCameraKey(name) { return } + f.applyTransform() +} + +func (f *Feature) applyPhotoKey(index int, name fyne.KeyName) bool { + transform := &f.photoTransforms[index] switch name { case fyne.Key0: - f.transform = defaultLinkedTransform() + *transform = photoTransform{factor: 1 / f.camera.zoom, mode: fitRelative} + f.centerPhotoInCurrentCamera(index) + case fyne.Key1: + *transform = photoTransform{factor: 1 / f.camera.zoom, mode: absoluteScale} + f.centerPhotoInCurrentCamera(index) case fyne.KeyPlus, fyne.KeyEqual: - f.transform.factor = min(f.transform.factor*compareZoomStep, maxZoomFactor) + f.zoomPhotoAt(index, transform.factor*compareZoomStep, f.paneCenter(index)) case fyne.KeyMinus: - f.transform.factor = max(f.transform.factor/compareZoomStep, minZoomFactor) - case fyne.Key1: - f.transform = linkedTransform{ - center: fyne.NewPos(0.5, 0.5), - factor: 1, - mode: absoluteScale, - } + f.zoomPhotoAt(index, transform.factor/compareZoomStep, f.paneCenter(index)) default: + return false + } + return true +} + +func (f *Feature) paneCenter(index int) fyne.Position { + return fyne.NewPos(f.viewports[index].Width/2, f.viewports[index].Height/2) +} + +func (f *Feature) centerPhotoInCurrentCamera(index int) { + transform := &f.photoTransforms[index] + native := frameSize(f.loaded[index]) + scale := f.scaleForTransform(index, *transform) * f.camera.zoom + visible := fyne.NewSize(native.Width*scale, native.Height*scale) + offset := f.cameraOffsetFor(index) + transform.center = fyne.NewPos( + 0.5+offset.X/visible.Width, + 0.5+offset.Y/visible.Height, + ) +} + +func (f *Feature) zoomPhotoAt(index int, factor float32, anchor fyne.Position) { + transform := &f.photoTransforms[index] + minimum, maximum := f.photoFactorRange() + factor = min(max(factor, minimum), maximum) + if factor == transform.factor { return } - f.applyTransform() - f.repaint() + native := frameSize(f.loaded[index]) + oldScale := f.scaleForTransform(index, *transform) * f.camera.zoom + updated := *transform + updated.factor = factor + newScale := f.scaleForTransform(index, updated) * f.camera.zoom + oldSize := fyne.NewSize(native.Width*oldScale, native.Height*oldScale) + newSize := fyne.NewSize(native.Width*newScale, native.Height*newScale) + viewportCenter := f.paneCenter(index) + offset := f.cameraOffsetFor(index) + updated.center = fyne.NewPos( + transform.center.X+(anchor.X-viewportCenter.X-offset.X)*(1/oldSize.Width-1/newSize.Width), + transform.center.Y+(anchor.Y-viewportCenter.Y-offset.Y)*(1/oldSize.Height-1/newSize.Height), + ) + updated.center = f.clampPhotoCenter(index, updated, updated.center) + *transform = updated +} + +func (f *Feature) applyCameraKey(name fyne.KeyName) bool { + switch name { + case fyne.Key0: + f.fitCamera() + case fyne.Key1: + f.camera = defaultCameraTransform() + case fyne.KeyPlus, fyne.KeyEqual: + f.zoomCamera(f.camera.zoom*compareZoomStep, fyne.Position{}) + case fyne.KeyMinus: + f.zoomCamera(f.camera.zoom/compareZoomStep, fyne.Position{}) + default: + return false + } + return true } func (f *Feature) handleScroll(index int, ev *fyne.ScrollEvent) { if !f.active || !f.ready || ev == nil || index < 0 || index >= len(f.panes) { return } + f.setHoveredPane(index) if f.callbacks.Modifiers != nil && f.callbacks.Modifiers()&fyne.KeyModifierShift != 0 { f.panBy(index, ev.Scrolled) return @@ -110,55 +199,176 @@ func (f *Feature) handleScroll(index int, ev *fyne.ScrollEvent) { if ev.Scrolled.DY == 0 { return } + if f.unlinked { + transform := &f.photoTransforms[index] + oldFactor := transform.factor + minFactor, maxFactor := f.photoFactorRange() + newFactor := min(max( + oldFactor*float32(math.Exp(float64(ev.Scrolled.DY*scrollSensitivity))), + minFactor, + ), maxFactor) + if newFactor == oldFactor { + return + } - oldFactor := f.transform.factor - newFactor := min(max( - oldFactor*float32(math.Exp(float64(ev.Scrolled.DY*scrollSensitivity))), - minZoomFactor, - ), maxZoomFactor) - if newFactor == oldFactor { + f.zoomPhotoAt(index, newFactor, ev.Position) + f.applyTransform() return } - native := frameSize(f.loaded[index]) - oldScale := f.scaleFor(index, oldFactor) - newScale := f.scaleFor(index, newFactor) - oldScaled := fyne.NewSize(native.Width*oldScale, native.Height*oldScale) - newScaled := fyne.NewSize(native.Width*newScale, native.Height*newScale) + oldZoom := f.camera.zoom + newZoom := oldZoom * float32(math.Exp(float64(ev.Scrolled.DY*scrollSensitivity))) + if newZoom == oldZoom { + return + } viewport := f.viewports[index] - f.transform.center = fyne.NewPos( - f.transform.center.X+(ev.Position.X-viewport.Width/2)*(1/oldScaled.Width-1/newScaled.Width), - f.transform.center.Y+(ev.Position.Y-viewport.Height/2)*(1/oldScaled.Height-1/newScaled.Height), - ) - f.transform.factor = newFactor + f.zoomCamera(newZoom, fyne.NewPos( + ev.Position.X/viewport.Width-0.5, + ev.Position.Y/viewport.Height-0.5, + )) f.applyTransform() - f.repaint() +} + +func (f *Feature) photoFactorRange() (float32, float32) { + zoom := f.camera.zoom + if zoom <= 0 { + zoom = 1 + } + return minZoomFactor / zoom, maxZoomFactor / zoom +} + +func (f *Feature) cameraZoomRange() (float32, float32) { + minimum, maximum := float32(0), float32(math.MaxFloat32) + for _, transform := range f.photoTransforms { + if transform.factor <= 0 { + continue + } + minimum = max(minimum, minZoomFactor/transform.factor) + maximum = min(maximum, maxZoomFactor/transform.factor) + } + if maximum == float32(math.MaxFloat32) { + maximum = maxZoomFactor + } + if minimum > maximum { + minimum = maximum + } + return minimum, maximum +} + +func (f *Feature) zoomCamera(zoom float32, anchor fyne.Position) { + minimum, maximum := f.cameraZoomRange() + zoom = min(max(zoom, minimum), maximum) + if f.camera.zoom <= 0 || zoom == f.camera.zoom { + return + } + ratio := zoom / f.camera.zoom + f.camera.offset = fyne.NewPos( + f.camera.offset.X*ratio+(1-ratio)*anchor.X, + f.camera.offset.Y*ratio+(1-ratio)*anchor.Y, + ) + f.camera.zoom = zoom + f.clampCameraOffset() +} + +func (f *Feature) fitCamera() { + minimum, maximum := f.cameraZoomRange() + minX, maxX, minY, maxY, feasible := f.cameraFitRange(minimum) + if !feasible { + f.camera.zoom = minimum + f.camera.offset = fyne.Position{} + return + } + + low, high := minimum, maximum + for range 48 { + candidate := low + (high-low)/2 + if _, _, _, _, ok := f.cameraFitRange(candidate); ok { + low = candidate + } else { + high = candidate + } + } + f.camera.zoom = low + minX, maxX, minY, maxY, _ = f.cameraFitRange(low) + f.camera.offset = fyne.NewPos( + min(max(float32(0), minX), maxX), + min(max(float32(0), minY), maxY), + ) +} + +func (f *Feature) cameraFitRange(zoom float32) (minX, maxX, minY, maxY float32, feasible bool) { + minX, maxX = -float32(math.MaxFloat32), float32(math.MaxFloat32) + minY, maxY = -float32(math.MaxFloat32), float32(math.MaxFloat32) + for i := range f.panes { + viewport := f.viewports[i] + native := frameSize(f.loaded[i]) + if !validViewport(viewport) || !validViewport(native) { + return 0, 0, 0, 0, false + } + transform := f.photoTransforms[i] + baseScale := f.scaleForTransform(i, transform) + scaled := fyne.NewSize(native.Width*baseScale*zoom, native.Height*baseScale*zoom) + withoutOffset := fyne.NewPos( + viewport.Width/2-transform.center.X*scaled.Width, + viewport.Height/2-transform.center.Y*scaled.Height, + ) + lowX := -withoutOffset.X / viewport.Width + highX := (viewport.Width - withoutOffset.X - scaled.Width) / viewport.Width + lowY := -withoutOffset.Y / viewport.Height + highY := (viewport.Height - withoutOffset.Y - scaled.Height) / viewport.Height + minX, maxX = max(minX, lowX), min(maxX, highX) + minY, maxY = max(minY, lowY), min(maxY, highY) + } + return minX, maxX, minY, maxY, minX <= maxX && minY <= maxY } func (f *Feature) panBy(index int, delta fyne.Delta) { if !f.active || !f.ready || index < 0 || index >= len(f.panes) { return } + f.setHoveredPane(index) + if f.unlinked { + transform := &f.photoTransforms[index] + native := frameSize(f.loaded[index]) + scale := f.scaleForTransform(index, *transform) + scaled := fyne.NewSize(native.Width*scale*f.camera.zoom, native.Height*scale*f.camera.zoom) + if !validViewport(scaled) { + return + } + transform.center = f.clampPhotoCenter(index, *transform, fyne.NewPos( + transform.center.X-delta.DX/scaled.Width, + transform.center.Y-delta.DY/scaled.Height, + )) + f.applyTransform() + return + } + f.camera.offset = fyne.NewPos( + f.camera.offset.X+delta.DX/f.viewports[index].Width, + f.camera.offset.Y+delta.DY/f.viewports[index].Height, + ) + f.clampCameraOffset() + f.applyTransform() +} + +func (f *Feature) clampPhotoCenter(index int, transform photoTransform, center fyne.Position) fyne.Position { native := frameSize(f.loaded[index]) - scale := f.scaleFor(index, f.transform.factor) + scale := f.scaleForTransform(index, transform) * f.camera.zoom scaled := fyne.NewSize(native.Width*scale, native.Height*scale) if !validViewport(scaled) { - return + return center } - f.transform.center = fyne.NewPos( - f.transform.center.X-delta.DX/scaled.Width, - f.transform.center.Y-delta.DY/scaled.Height, + offset := f.cameraOffsetFor(index) + minX, minY := offset.X/scaled.Width, offset.Y/scaled.Height + return fyne.NewPos( + min(max(center.X, minX), 1+minX), + min(max(center.Y, minY), 1+minY), ) - f.applyTransform() - f.repaint() } func (f *Feature) applyTransform() { if !f.ready || !validViewport(f.viewports[0]) || !validViewport(f.viewports[1]) { return } - f.clampCenter() - for i := range f.panes { f.panes[i].input.Move(fyne.NewPos(0, 0)) f.panes[i].input.Resize(f.viewports[i]) @@ -166,62 +376,109 @@ func (f *Feature) applyTransform() { if !validViewport(native) { continue } - scale := f.scaleFor(i, f.transform.factor) - scaled := fyne.NewSize(native.Width*scale, native.Height*scale) + transform := f.photoTransforms[i] + scale := f.scaleForTransform(i, transform) + baseSize := fyne.NewSize(native.Width*scale, native.Height*scale) + scaled := fyne.NewSize(baseSize.Width*f.camera.zoom, baseSize.Height*f.camera.zoom) + cameraOffset := f.cameraOffsetFor(i) position := fyne.NewPos( - f.viewports[i].Width/2-f.transform.center.X*scaled.Width, - f.viewports[i].Height/2-f.transform.center.Y*scaled.Height, + f.viewports[i].Width/2-transform.center.X*scaled.Width+cameraOffset.X, + f.viewports[i].Height/2-transform.center.Y*scaled.Height+cameraOffset.Y, ) - f.panes[i].image.Resize(scaled) - f.panes[i].image.Move(position) + revealPosition, revealSize := f.paneVisibleArea(i) + width, height := f.vectorPixels(f.panes[i].input, scaled) + f.panes[i].renderer.Present(paneScene{ + source: f.renderSources[i], + viewport: f.viewports[i], + revealSet: true, + revealPosition: revealPosition, + revealSize: revealSize, + imagePosition: position, + imageSize: scaled, + displaySize: image.Pt(width, height), + }) f.requestVectorRender(i, scaled) } } -func (f *Feature) clampCenter() { - minX, maxX, minY, maxY := f.sharedPanRange() - f.transform.center = fyne.NewPos( - min(max(f.transform.center.X, minX), maxX), - min(max(f.transform.center.Y, minY), maxY), +func (f *Feature) clampCameraOffset() { + minX, maxX, minY, maxY := f.cameraPanRange() + f.camera.offset = fyne.NewPos( + min(max(f.camera.offset.X, minX), maxX), + min(max(f.camera.offset.Y, minY), maxY), + ) +} + +func (f *Feature) cameraOffsetFor(index int) fyne.Position { + return fyne.NewPos( + f.camera.offset.X*f.viewports[index].Width, + f.camera.offset.Y*f.viewports[index].Height, ) } -func (f *Feature) sharedPanRange() (minX, maxX, minY, maxY float32) { - minX, maxX = 0, 1 - minY, maxY = 0, 1 +func (f *Feature) visiblePhotoTransform(index int) photoTransform { + transform := f.photoTransforms[index] + native := frameSize(f.loaded[index]) + baseScale := f.scaleForTransform(index, transform) + visible := fyne.NewSize( + native.Width*baseScale*f.camera.zoom, + native.Height*baseScale*f.camera.zoom, + ) + offset := f.cameraOffsetFor(index) + transform.center = fyne.NewPos( + transform.center.X-offset.X/visible.Width, + transform.center.Y-offset.Y/visible.Height, + ) + transform.factor *= f.camera.zoom + return transform +} + +func (f *Feature) cameraPanRange() (minX, maxX, minY, maxY float32) { + minX, maxX = -float32(math.MaxFloat32), float32(math.MaxFloat32) + minY, maxY = -float32(math.MaxFloat32), float32(math.MaxFloat32) for i := range f.panes { native := frameSize(f.loaded[i]) - scale := f.scaleFor(i, f.transform.factor) + transform := f.photoTransforms[i] + scale := f.scaleForTransform(i, transform) * f.camera.zoom scaled := fyne.NewSize(native.Width*scale, native.Height*scale) - lowX, highX := normalizedPanRange(scaled.Width, f.viewports[i].Width) - lowY, highY := normalizedPanRange(scaled.Height, f.viewports[i].Height) + withoutOffset := fyne.NewPos( + f.viewports[i].Width/2-transform.center.X*scaled.Width, + f.viewports[i].Height/2-transform.center.Y*scaled.Height, + ) + paneCenter := fyne.NewPos(f.viewports[i].Width/2, f.viewports[i].Height/2) + lowX, highX := paneCenter.X-(withoutOffset.X+scaled.Width), paneCenter.X-withoutOffset.X + lowY, highY := paneCenter.Y-(withoutOffset.Y+scaled.Height), paneCenter.Y-withoutOffset.Y + lowX, highX = lowX/f.viewports[i].Width, highX/f.viewports[i].Width + lowY, highY = lowY/f.viewports[i].Height, highY/f.viewports[i].Height minX, maxX = max(minX, lowX), min(maxX, highX) minY, maxY = max(minY, lowY), min(maxY, highY) } + if minX > maxX { + minX, maxX = f.camera.offset.X, f.camera.offset.X + } + if minY > maxY { + minY, maxY = f.camera.offset.Y, f.camera.offset.Y + } return minX, maxX, minY, maxY } -func (f *Feature) canPan() bool { - if !f.active || !f.ready || !validViewport(f.viewports[0]) || !validViewport(f.viewports[1]) { +func (f *Feature) canPan(index int) bool { + if !f.active || !f.ready || index < 0 || index >= len(f.panes) || + !validViewport(f.viewports[0]) || !validViewport(f.viewports[1]) { return false } - minX, maxX, minY, maxY := f.sharedPanRange() - return minX < maxX || minY < maxY -} - -func normalizedPanRange(scaled, viewport float32) (float32, float32) { - if scaled <= viewport+comparePanSlack { - return 0.5, 0.5 + if f.unlinked { + return validViewport(frameSize(f.loaded[index])) } - halfVisible := viewport / (2 * scaled) - return halfVisible, 1 - halfVisible + minX, maxX, minY, maxY := f.cameraPanRange() + return minX < maxX || minY < maxY } -func (f *Feature) scaleFor(index int, factor float32) float32 { - if f.transform.mode == fitRelative { - return fitScale(frameSize(f.loaded[index]), f.viewports[index]) * factor +func (f *Feature) scaleForTransform(index int, transform photoTransform) float32 { + if transform.mode == fitRelative { + return fitScale(frameSize(f.loaded[index]), f.viewports[index]) * transform.factor } - return factor + return transform.factor } func frameSize(loaded *imaging.LoadedImage) fyne.Size { diff --git a/internal/ui/compare/uiqueue.go b/internal/ui/compare/uiqueue.go index f7b5f0d..42646e3 100644 --- a/internal/ui/compare/uiqueue.go +++ b/internal/ui/compare/uiqueue.go @@ -2,8 +2,8 @@ package compare import "fyne.io/fyne/v2" -// UIQueue is how comparison load and vector workers hand completed widget -// work to the UI goroutine. Production uses fyneQueue; tests install a +// UIQueue is how comparison load, vector, and tile workers hand completed +// widget work to the UI goroutine. Production uses fyneQueue; tests install a // drainable queue because Fyne's test driver runs fyne.Do inline on the worker. type UIQueue interface { Do(func()) diff --git a/internal/ui/compare/vector.go b/internal/ui/compare/vector.go index 055b3d1..27d8cb3 100644 --- a/internal/ui/compare/vector.go +++ b/internal/ui/compare/vector.go @@ -2,7 +2,6 @@ package compare import ( "image" - "sync" "time" "fyne.io/fyne/v2" @@ -14,7 +13,7 @@ const defaultCompareVectorDebounce = 90 * time.Millisecond type vectorRasterState struct { lifecycle requestLifecycle - pending sync.WaitGroup + pending workTracker raster image.Point requested image.Point } @@ -63,7 +62,7 @@ func (f *Feature) requestVectorRender(index int, display fyne.Size) { return } - width, height := f.vectorPixels(f.panes[index].image, display) + width, height := f.vectorPixels(f.panes[index].input, display) width, height = imaging.ClampVectorRaster(width, height) target := image.Pt(width, height) state := &f.vectors[index] @@ -102,6 +101,10 @@ func (f *Feature) rasterizeVector(index int, vector *imaging.Vector, target imag if err != nil || !token.latest() { return } + prepared, err := f.prepareSource(token.context(), frame) + if err != nil || !token.latest() { + return + } f.queueUI(func() { state := &f.vectors[index] @@ -110,9 +113,9 @@ func (f *Feature) rasterizeVector(index int, vector *imaging.Vector, target imag return } f.rendered[index] = frame + f.renderSources[index] = prepared state.setRaster(frame) - f.panes[index].image.Image = frame - f.panes[index].image.Refresh() - f.repaint() + f.panes[index].renderer.Present(paneScene{source: f.renderSources[index]}) + f.applyTransform() }) } diff --git a/internal/ui/compare/vector_test.go b/internal/ui/compare/vector_test.go index 68bbbcf..3b6dd04 100644 --- a/internal/ui/compare/vector_test.go +++ b/internal/ui/compare/vector_test.go @@ -4,6 +4,7 @@ import ( "context" "image" "image/color" + "sync" "testing" "time" @@ -51,7 +52,7 @@ func TestCompareSettle_WaitsForQueuedVectorCompletion(t *testing.T) { if err != nil { t.Fatalf("decode SVG fixture: %v", err) } - feature := New(func(_ context.Context, uri fyne.URI) (*imaging.LoadedImage, error) { + feature := newReferenceFeature(func(_ context.Context, uri fyne.URI) (*imaging.LoadedImage, error) { if uri.Name() == "left.svg" { return vector, nil } @@ -79,6 +80,67 @@ func TestCompareSettle_WaitsForQueuedVectorCompletion(t *testing.T) { } } +func TestCompareSettle_DrainsVectorReplacementBeforeWaitingForObsoleteTiles(t *testing.T) { + app := fynetest.NewApp() + t.Cleanup(app.Quit) + + vector, err := imaging.DecodeLoaded(context.Background(), uitest.SVGBytes(4096, 2048), imaging.DefaultImgCacheBytes) + if err != nil { + t.Fatalf("decode SVG fixture: %v", err) + } + feature := newFeature(func(_ context.Context, uri fyne.URI) (*imaging.LoadedImage, error) { + if uri.Name() == "left.svg" { + return vector, nil + } + return &imaging.LoadedImage{Frames: []image.Image{image.NewRGBA(image.Rect(0, 0, 40, 20))}}, nil + }, Callbacks{}, newShaderPaneRenderer) + feature.vectorDebounce = 0 + feature.vectorPixels = func(fyne.CanvasObject, fyne.Size) (int, int) { return 2048, 1024 } + queue := &uitest.UIQueue{} + feature.SetUIQueue(queue) + + left := feature.panes[0].renderer.(*shaderPaneRenderer) + oldTileStarted := make(chan struct{}) + var started sync.Once + left.generateTile = func(ctx context.Context, source *renderSource, key tileKey) (*renderTile, error) { + if source.frame.Bounds().Dx() == 4096 { + started.Do(func() { close(oldTileStarted) }) + <-ctx.Done() + return nil, ctx.Err() + } + return generateRenderTile(ctx, source, key) + } + feature.vectorRasterize = func(_ *imaging.Vector, width, height int) (image.Image, error) { + select { + case <-oldTileStarted: + case <-time.After(time.Second): + t.Fatal("obsolete tile worker did not start before vector replacement") + } + return image.NewRGBA(image.Rect(0, 0, width, height)), nil + } + + feature.Overlay().Resize(fyne.NewSize(800, 400)) + feature.Open([2]fyne.URI{ + storage.NewFileURI("left.svg"), + storage.NewFileURI("right.png"), + }) + t.Cleanup(func() { + feature.Close() + cleanupCtx, cancel := context.WithTimeout(context.Background(), time.Second) + defer cancel() + _ = feature.Settle(cleanupCtx) + }) + + ctx, cancel := context.WithTimeout(context.Background(), time.Second) + defer cancel() + if err := feature.Settle(ctx); err != nil { + t.Fatalf("Settle waited for an obsolete tile before applying its queued vector replacement: %v", err) + } + if got := feature.rendered[0].Bounds().Size(); got != image.Pt(2048, 1024) { + t.Fatalf("settled vector raster = %v, want 2048x1024 replacement", got) + } +} + func TestCompareStale_VectorRenderCannotPaintSupersededTarget(t *testing.T) { app := fynetest.NewApp() t.Cleanup(app.Quit) @@ -91,7 +153,7 @@ func TestCompareStale_VectorRenderCannotPaintSupersededTarget(t *testing.T) { newFinished := make(chan struct{}) releaseOld := make(chan struct{}) - feature := New(func(_ context.Context, uri fyne.URI) (*imaging.LoadedImage, error) { + feature := newReferenceFeature(func(_ context.Context, uri fyne.URI) (*imaging.LoadedImage, error) { if uri.Name() == "left.svg" { return vector, nil } @@ -157,7 +219,7 @@ func TestCompareCancel_VectorCompletionCannotPaintAfterClose(t *testing.T) { if err != nil { t.Fatalf("decode SVG fixture: %v", err) } - feature := New(func(_ context.Context, uri fyne.URI) (*imaging.LoadedImage, error) { + feature := newReferenceFeature(func(_ context.Context, uri fyne.URI) (*imaging.LoadedImage, error) { if uri.Name() == "left.svg" { return vector, nil } @@ -206,7 +268,7 @@ func TestCompareVector_RasterTargetHonorsExistingPixelLimit(t *testing.T) { t.Fatalf("decode SVG fixture: %v", err) } requested := image.Point{} - feature := New(func(_ context.Context, uri fyne.URI) (*imaging.LoadedImage, error) { + feature := newReferenceFeature(func(_ context.Context, uri fyne.URI) (*imaging.LoadedImage, error) { if uri.Name() == "left.svg" { return vector, nil } diff --git a/internal/ui/compare/workgroup.go b/internal/ui/compare/workgroup.go new file mode 100644 index 0000000..1727cb5 --- /dev/null +++ b/internal/ui/compare/workgroup.go @@ -0,0 +1,72 @@ +package compare + +import ( + "context" + "sync" +) + +// workTracker is a reusable, context-selectable worker barrier. Each busy +// epoch owns its own channel, so a timed-out waiter never leaves a goroutine +// behind and cannot race a later Add after the prior epoch settles. +type workTracker struct { + mu sync.Mutex + active int + idle chan struct{} +} + +func (w *workTracker) Add(delta int) { + if delta == 0 { + return + } + + w.mu.Lock() + defer w.mu.Unlock() + previous := w.active + next := previous + delta + if next < 0 { + panic("compare: negative work tracker count") + } + if previous == 0 && next > 0 { + w.idle = make(chan struct{}) + } + w.active = next + if previous > 0 && next == 0 { + close(w.idle) + w.idle = nil + } +} + +func (w *workTracker) Done() { w.Add(-1) } + +func (w *workTracker) Go(run func()) { + w.Add(1) + go func() { + defer w.Done() + run() + }() +} + +func (w *workTracker) Wait() { + if done := w.done(); done != nil { + <-done + } +} + +func (w *workTracker) WaitContext(ctx context.Context) error { + done := w.done() + if done == nil { + return nil + } + select { + case <-done: + return nil + case <-ctx.Done(): + return ctx.Err() + } +} + +func (w *workTracker) done() <-chan struct{} { + w.mu.Lock() + defer w.mu.Unlock() + return w.idle +} diff --git a/internal/ui/compare/workgroup_test.go b/internal/ui/compare/workgroup_test.go new file mode 100644 index 0000000..1cee964 --- /dev/null +++ b/internal/ui/compare/workgroup_test.go @@ -0,0 +1,37 @@ +package compare + +import ( + "context" + "errors" + "testing" + "time" +) + +func TestWorkTracker_ContextTimeoutDoesNotPoisonReuse(t *testing.T) { + var work workTracker + work.Add(1) + + ctx, cancel := context.WithCancel(context.Background()) + cancel() + if err := work.WaitContext(ctx); !errors.Is(err, context.Canceled) { + t.Fatalf("WaitContext error = %v, want context cancellation", err) + } + + work.Done() + work.Add(1) + go work.Done() + ctx, cancel = context.WithTimeout(context.Background(), time.Second) + defer cancel() + if err := work.WaitContext(ctx); err != nil { + t.Fatalf("reused work tracker did not settle: %v", err) + } +} + +func TestWorkTracker_WaitReturnsImmediatelyBeforeFirstWork(t *testing.T) { + var work workTracker + ctx, cancel := context.WithTimeout(context.Background(), time.Second) + defer cancel() + if err := work.WaitContext(ctx); err != nil { + t.Fatalf("empty work tracker wait: %v", err) + } +} diff --git a/internal/ui/compare_fidelity_test.go b/internal/ui/compare_fidelity_test.go index 805c154..b9276e4 100644 --- a/internal/ui/compare_fidelity_test.go +++ b/internal/ui/compare_fidelity_test.go @@ -81,11 +81,11 @@ func requireSuccessfulCompareLoad(t *testing.T, loads map[string]observedCompare return result.loaded } -func comparisonImageHolding(t *testing.T, v *viewer, frame image.Image) *canvas.Image { +func comparisonImageHolding(t *testing.T, v *viewer, frame image.Image) *canvas.Shader { t.Helper() - for _, candidate := range comparisonImages(v.compare.Overlay()) { - if candidate.Image == frame { + for _, candidate := range comparisonShaders(v.compare.Overlay()) { + if candidate.Textures["overview"] == frame { return candidate } } @@ -161,8 +161,8 @@ func TestCompareAnimated_FreezesFirstDecodedFrameForEntireSession(t *testing.T) assertFrozen := func(stage string) { t.Helper() comparisonImageHolding(t, v, first) - for _, candidate := range comparisonImages(v.compare.Overlay()) { - if candidate.Image == later { + for _, candidate := range comparisonShaders(v.compare.Overlay()) { + if candidate.Textures["overview"] == later { t.Fatalf("comparison displayed a later animation frame %s", stage) } } diff --git a/internal/ui/compare_test.go b/internal/ui/compare_test.go index e13940c..38749d7 100644 --- a/internal/ui/compare_test.go +++ b/internal/ui/compare_test.go @@ -41,20 +41,116 @@ func waitForCompare(t *testing.T, v *viewer) { } func fireCompareShortcut(v *viewer) { + fireCompareShortcutWithModifier(v, fyne.KeyModifierShortcutDefault) +} + +func fireCompareShortcutWithModifier(v *viewer, modifier fyne.KeyModifier) { handler := &fyne.ShortcutHandler{} wireGlobalShortcuts(handler, v) handler.TypedShortcut(&desktop.CustomShortcut{ KeyName: fyne.KeyD, - Modifier: fyne.KeyModifierShortcutDefault, + Modifier: modifier, }) } -func comparisonImages(root fyne.CanvasObject) []*canvas.Image { - var images []*canvas.Image +type shortcutCapture struct { + shortcuts []fyne.Shortcut +} + +func (c *shortcutCapture) AddShortcut(shortcut fyne.Shortcut, _ func(fyne.Shortcut)) { + c.shortcuts = append(c.shortcuts, shortcut) +} + +func TestCompareShortcut_RegistersDefaultAndPhysicalControlWithoutDuplicates(t *testing.T) { + v, _, _ := newTestUI(t) + capture := &shortcutCapture{} + wireCompareShortcut(capture, v) + + want := map[fyne.KeyModifier]bool{fyne.KeyModifierShortcutDefault: true} + want[fyne.KeyModifierControl] = true + got := make(map[fyne.KeyModifier]int) + for _, shortcut := range capture.shortcuts { + custom, ok := shortcut.(*desktop.CustomShortcut) + if !ok { + t.Fatalf("comparison shortcut type = %T, want *desktop.CustomShortcut", shortcut) + } + if custom.KeyName != fyne.KeyD { + t.Errorf("comparison shortcut key = %v, want D", custom.KeyName) + } + got[custom.Modifier]++ + } + for modifier := range want { + if got[modifier] != 1 { + t.Errorf("comparison D shortcut registrations for modifier %v = %d, want 1", modifier, got[modifier]) + } + } + for modifier, count := range got { + if !want[modifier] || count != 1 { + t.Errorf("unexpected comparison D shortcut registration: modifier=%v count=%d", modifier, count) + } + } +} + +func TestCompareShortcut_PhysicalControlOpensComparison(t *testing.T) { + v := openGridWith(t, "left.jpg", "right.jpg") + v.grid.HandleKey(&fyne.KeyEvent{Name: fyne.KeySpace}) + v.grid.HandleKey(&fyne.KeyEvent{Name: fyne.KeyRight}) + v.grid.HandleKey(&fyne.KeyEvent{Name: fyne.KeySpace}) + + fireCompareShortcutWithModifier(v, fyne.KeyModifierControl) + waitForCompare(t, v) + if !v.compare.Visible() { + t.Fatal("physical Ctrl+D did not open comparison") + } +} + +func TestShutdownClosesActiveComparisonBeforeEventLoopStops(t *testing.T) { + application := fynetest.NewApp() + v, win := buildStartupViewer(application) + v.grid.SetUIQueue(&uitest.UIQueue{}) + v.compare.SetUIQueue(&uitest.UIQueue{}) + t.Cleanup(win.Close) + t.Cleanup(func() { drain(t, v) }) + + uris := []fyne.URI{ + uitest.TempJPEGURI(t, "a.jpg", 4, 4, color.White), + uitest.TempJPEGURI(t, "b.jpg", 4, 4, color.White), + uitest.TempJPEGURI(t, "c.jpg", 4, 4, color.White), + } + dropAndWait(t, v, uris...) + warmThumbs(t, v) + v.grid.Toggle() + v.grid.HandleKey(&fyne.KeyEvent{Name: fyne.KeySpace}) + v.grid.HandleKey(&fyne.KeyEvent{Name: fyne.KeyRight}) + v.grid.HandleKey(&fyne.KeyEvent{Name: fyne.KeySpace}) + fireCompareShortcut(v) + waitForCompare(t, v) + + lifecycle, ok := application.Lifecycle().(interface{ OnStopped() func() }) + if !ok { + t.Skip("test app lifecycle does not expose its stopped hook") + } + original := lifecycle.OnStopped() + registerShutdown(application, v) + shutdown := lifecycle.OnStopped() + application.Lifecycle().SetOnStopped(original) + if shutdown == nil { + t.Fatal("registerShutdown did not install a stopped hook") + } + + shutdown() + if v.compare.Visible() { + t.Fatal("shutdown left comparison workers and surface active") + } +} + +func comparisonShaders(root fyne.CanvasObject) []*canvas.Shader { + var shaders []*canvas.Shader var walk func(fyne.CanvasObject) walk = func(object fyne.CanvasObject) { - if img, ok := object.(*canvas.Image); ok && img.Image != nil { - images = append(images, img) + if shader, ok := object.(*canvas.Shader); ok && + strings.HasPrefix(shader.Name, "picfetch-compare-tiled-") && shader.Visible() { + shaders = append(shaders, shader) } switch object := object.(type) { case *fyne.Container: @@ -66,7 +162,7 @@ func comparisonImages(root fyne.CanvasObject) []*canvas.Image { } } walk(root) - return images + return shaders } func comparisonButton(t *testing.T, root fyne.CanvasObject, text string) *widget.Button { @@ -90,6 +186,36 @@ func comparisonButton(t *testing.T, root fyne.CanvasObject, text string) *widget return found } +func comparisonHasVisibleLabel(root fyne.CanvasObject, text string) bool { + found := false + var walk func(fyne.CanvasObject) + walk = func(object fyne.CanvasObject) { + if label, ok := object.(*widget.Label); ok && label.Visible() && label.Text == text { + found = true + } + switch object := object.(type) { + case *fyne.Container: + for _, child := range object.Objects { + walk(child) + } + case *container.Clip: + walk(object.Content) + } + } + walk(root) + return found +} + +type comparisonKeyHooks struct { + down func(*fyne.KeyEvent) + up func(*fyne.KeyEvent) +} + +func (h *comparisonKeyHooks) OnKeyDown() func(*fyne.KeyEvent) { return h.down } +func (h *comparisonKeyHooks) SetOnKeyDown(fn func(*fyne.KeyEvent)) { h.down = fn } +func (h *comparisonKeyHooks) OnKeyUp() func(*fyne.KeyEvent) { return h.up } +func (h *comparisonKeyHooks) SetOnKeyUp(fn func(*fyne.KeyEvent)) { h.up = fn } + func comparisonBackButton(t *testing.T, root fyne.CanvasObject) *widget.Button { t.Helper() return comparisonButton(t, root, lang.L("Back to Grid")) @@ -584,7 +710,7 @@ func TestCompareZoom_KeyboardRoutesToComparisonWithoutChangingCoveredState(t *te fireCompareShortcut(v) waitForCompare(t, v) - images := comparisonImages(v.compare.Overlay()) + images := comparisonShaders(v.compare.Overlay()) if len(images) != 2 { t.Fatalf("comparison images = %d, want 2", len(images)) } @@ -593,7 +719,7 @@ func TestCompareZoom_KeyboardRoutesToComparisonWithoutChangingCoveredState(t *te v.handleKeyEvent(&fyne.KeyEvent{Name: fyne.KeyPlus}) - images = comparisonImages(v.compare.Overlay()) + images = comparisonShaders(v.compare.Overlay()) for i, img := range images { if img.Size().Width <= beforeSizes[i].Width || img.Size().Height <= beforeSizes[i].Height { t.Errorf("comparison image %d after + = %v, want larger than %v", i, img.Size(), beforeSizes[i]) @@ -604,6 +730,203 @@ func TestCompareZoom_KeyboardRoutesToComparisonWithoutChangingCoveredState(t *te } } +func TestCompareLinkControl_CtrlLAndButtonShareReadyGate(t *testing.T) { + v := openGridWith(t, "left.jpg", "right.jpg") + v.grid.SelectAll() + + started := make(chan struct{}, 2) + release := make(chan struct{}) + releaseLoads := func() { + select { + case <-release: + default: + close(release) + } + } + t.Cleanup(releaseLoads) + v.compareLoad = func(_ context.Context, _ fyne.URI) (*imaging.LoadedImage, error) { + started <- struct{}{} + <-release + return &imaging.LoadedImage{Frames: []image.Image{image.NewRGBA(image.Rect(0, 0, 20, 10))}}, nil + } + + fireCompareShortcut(v) + for range 2 { + select { + case <-started: + case <-time.After(testTimeout): + t.Fatal("timed out waiting for both comparison loads to start") + } + } + + overlay := v.compare.Overlay() + unlink := comparisonButton(t, overlay, lang.L("Unlink")) + if !unlink.Disabled() { + t.Fatal("Unlink is enabled before both comparison images are ready") + } + + var modifiers fyne.KeyModifier + v.keyModifiers = func() fyne.KeyModifier { return modifiers } + hooks := &comparisonKeyHooks{} + wireComparisonLinkToggleHook(hooks, v) + modifiers = fyne.KeyModifierControl + hooks.down(&fyne.KeyEvent{Name: fyne.KeyL}) + modifiers = 0 + + if got := comparisonButton(t, overlay, lang.L("Unlink")); got != unlink { + t.Error("pre-ready Ctrl+L replaced the disabled Unlink control") + } + if !unlink.Disabled() { + t.Error("pre-ready Ctrl+L enabled the Unlink control") + } + if comparisonHasVisibleLabel(overlay, lang.L("Unlinked")) { + t.Error("pre-ready Ctrl+L showed the Unlinked status") + } + + releaseLoads() + waitForCompare(t, v) + if unlink.Disabled() { + t.Fatal("Unlink stayed disabled after both comparison images became ready") + } + + modifiers = fyne.KeyModifierControl + hooks.down(&fyne.KeyEvent{Name: fyne.KeyL}) + modifiers = 0 + link := comparisonButton(t, overlay, lang.L("Link")) + if link != unlink { + t.Error("Ctrl+L replaced the comparison link control") + } + if !comparisonHasVisibleLabel(overlay, lang.L("Unlinked")) { + t.Error("ready Ctrl+L did not show the Unlinked status") + } + + fynetest.Tap(link) + if got := comparisonButton(t, overlay, lang.L("Unlink")); got != unlink { + t.Error("Link tap replaced the comparison link control") + } + if comparisonHasVisibleLabel(overlay, lang.L("Unlinked")) { + t.Error("Link tap left the Unlinked status visible") + } +} + +func TestCompareLinkToggle_ZoomsOnlyTheLastHoveredPaneWithoutHeldModifier(t *testing.T) { + v := openGridWith(t, "a.jpg", "b.jpg", "c.jpg") + v.compareLoad = func(_ context.Context, _ fyne.URI) (*imaging.LoadedImage, error) { + return &imaging.LoadedImage{Frames: []image.Image{image.NewRGBA(image.Rect(0, 0, 800, 400))}}, nil + } + var modifiers fyne.KeyModifier + v.keyModifiers = func() fyne.KeyModifier { return modifiers } + v.grid.HandleKey(&fyne.KeyEvent{Name: fyne.KeySpace}) + v.grid.HandleKey(&fyne.KeyEvent{Name: fyne.KeyRight}) + v.grid.HandleKey(&fyne.KeyEvent{Name: fyne.KeySpace}) + fireCompareShortcut(v) + waitForCompare(t, v) + + images := comparisonShaders(v.compare.Overlay()) + if len(images) != 2 { + t.Fatalf("comparison images = %d, want 2", len(images)) + } + before := [2]fyne.Size{images[0].Size(), images[1].Size()} + overlayPosition := v.app.Driver().AbsolutePositionForObject(v.compare.Overlay()) + leftCenter := overlayPosition.Add(fyne.NewPos(v.compare.Overlay().Size().Width/4, v.compare.Overlay().Size().Height/2)) + fynetest.MoveMouse(v.win.Canvas(), leftCenter) + + hooks := &comparisonKeyHooks{} + wireComparisonLinkToggleHook(hooks, v) + modifiers = fyne.KeyModifierControl + hooks.down(&fyne.KeyEvent{Name: fyne.KeyL}) + modifiers = 0 + v.handleKeyEvent(&fyne.KeyEvent{Name: fyne.KeyPlus}) + + images = comparisonShaders(v.compare.Overlay()) + if images[0].Size().Width <= before[0].Width { + t.Errorf("left unlinked comparison image after + = %v, want larger than %v", images[0].Size(), before[0]) + } + if images[1].Size() != before[1] { + t.Errorf("right comparison image after left-targeted + = %v, want unchanged %v", images[1].Size(), before[1]) + } +} + +func TestCompareLinkToggle_ChainsHookPersistsAndRelinksOnSecondPress(t *testing.T) { + v := openActiveComparisonWithExtra(t) + var modifiers fyne.KeyModifier + v.keyModifiers = func() fyne.KeyModifier { return modifiers } + + downCalls, upCalls := 0, 0 + hooks := &comparisonKeyHooks{ + down: func(*fyne.KeyEvent) { downCalls++ }, + up: func(*fyne.KeyEvent) { upCalls++ }, + } + wireComparisonLinkToggleHook(hooks, v) + + modifiers = fyne.KeyModifierControl + hooks.down(&fyne.KeyEvent{Name: fyne.KeyL}) + if !comparisonHasVisibleLabel(v.compare.Overlay(), lang.L("Unlinked")) { + t.Fatal("first Ctrl+L press did not show the comparison unlink status") + } + for range 3 { + v.handleKeyEvent(&fyne.KeyEvent{Name: fyne.KeyL}) + } + if !comparisonHasVisibleLabel(v.compare.Overlay(), lang.L("Unlinked")) { + t.Error("repeated typed L events retriggered the physical Ctrl+L toggle") + } + + modifiers = 0 + hooks.up(&fyne.KeyEvent{Name: desktop.KeyControlLeft}) + if !comparisonHasVisibleLabel(v.compare.Overlay(), lang.L("Unlinked")) { + t.Error("releasing Control relinked panes toggled apart by Ctrl+L") + } + + modifiers = fyne.KeyModifierControl + hooks.down(&fyne.KeyEvent{Name: fyne.KeyL}) + if comparisonHasVisibleLabel(v.compare.Overlay(), lang.L("Unlinked")) { + t.Error("second Ctrl+L press did not relink the comparison panes") + } + if downCalls != 2 || upCalls != 1 { + t.Errorf("existing key-hook calls = down %d up %d, want 2 and 1", downCalls, upCalls) + } +} + +func TestCompareLinkToggle_ControlAloneDoesNotChangeMode(t *testing.T) { + v := openActiveComparisonWithExtra(t) + var modifiers fyne.KeyModifier + v.keyModifiers = func() fyne.KeyModifier { return modifiers } + + hooks := &comparisonKeyHooks{} + wireComparisonLinkToggleHook(hooks, v) + + modifiers = fyne.KeyModifierControl + hooks.down(&fyne.KeyEvent{Name: desktop.KeyControlLeft}) + if comparisonHasVisibleLabel(v.compare.Overlay(), lang.L("Unlinked")) { + t.Error("pressing Control by itself unlinked the comparison panes") + } +} + +func TestCompareLinkToggle_RequiresExactPhysicalControlL(t *testing.T) { + tests := []struct { + name string + modifiers fyne.KeyModifier + }{ + {name: "no modifier"}, + {name: "Shift", modifiers: fyne.KeyModifierShift}, + {name: "Command", modifiers: fyne.KeyModifierSuper}, + {name: "Control Shift", modifiers: fyne.KeyModifierControl | fyne.KeyModifierShift}, + } + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + v := openActiveComparisonWithExtra(t) + v.keyModifiers = func() fyne.KeyModifier { return tc.modifiers } + hooks := &comparisonKeyHooks{} + wireComparisonLinkToggleHook(hooks, v) + + hooks.down(&fyne.KeyEvent{Name: fyne.KeyL}) + if comparisonHasVisibleLabel(v.compare.Overlay(), lang.L("Unlinked")) { + t.Errorf("L with modifiers %v toggled comparison linking", tc.modifiers) + } + }) + } +} + func TestComparePanInputs_CanvasDragAndShiftWheelStayInComparison(t *testing.T) { v := openGridWith(t, "a.jpg", "b.jpg", "c.jpg") v.compareLoad = func(_ context.Context, uri fyne.URI) (*imaging.LoadedImage, error) { @@ -621,13 +944,13 @@ func TestComparePanInputs_CanvasDragAndShiftWheelStayInComparison(t *testing.T) v.handleKeyEvent(&fyne.KeyEvent{Name: fyne.KeyPlus}) } - images := comparisonImages(v.compare.Overlay()) + images := comparisonShaders(v.compare.Overlay()) beforeState := snapshotCompareCommands(v) leftBefore := images[0].Position() canvasSize := v.win.Canvas().Size() leftCenter := fyne.NewPos(canvasSize.Width/4, canvasSize.Height/2) fynetest.Drag(v.win.Canvas(), leftCenter, 40, 20) - images = comparisonImages(v.compare.Overlay()) + images = comparisonShaders(v.compare.Overlay()) if images[0].Position() == leftBefore { t.Fatal("canvas drag did not pan the active comparison view") } @@ -637,7 +960,7 @@ func TestComparePanInputs_CanvasDragAndShiftWheelStayInComparison(t *testing.T) rightCenter := fyne.NewPos(canvasSize.Width*3/4, canvasSize.Height/2) fynetest.Scroll(v.win.Canvas(), rightCenter, -15, 25) v.keyModifiers = func() fyne.KeyModifier { return 0 } - images = comparisonImages(v.compare.Overlay()) + images = comparisonShaders(v.compare.Overlay()) if images[1].Position() == rightBefore { t.Fatal("canvas Shift+wheel did not pan the active comparison view") } @@ -661,7 +984,7 @@ func TestCompareSwipePointer_CanvasRoutesDividerAndPaneDrag(t *testing.T) { v.handleKeyEvent(&fyne.KeyEvent{Name: fyne.KeyPlus}) } - images := comparisonImages(v.compare.Overlay()) + images := comparisonShaders(v.compare.Overlay()) if len(images) != 2 { t.Fatalf("comparison images = %d, want 2", len(images)) } @@ -677,7 +1000,7 @@ func TestCompareSwipePointer_CanvasRoutesDividerAndPaneDrag(t *testing.T) { if !uitest.ApproxEqual(afterDivider, beforeDivider+80) { t.Errorf("canvas divider drag moved center to %.2f, want %.2f", afterDivider, beforeDivider+80) } - images = comparisonImages(v.compare.Overlay()) + images = comparisonShaders(v.compare.Overlay()) for i, img := range images { if img.Position() != beforePositions[i] { t.Errorf("comparison image %d moved during canvas divider drag: %v, want %v", i, img.Position(), beforePositions[i]) @@ -688,7 +1011,7 @@ func TestCompareSwipePointer_CanvasRoutesDividerAndPaneDrag(t *testing.T) { overlayPosition := v.app.Driver().AbsolutePositionForObject(v.compare.Overlay()) panePoint := overlayPosition.Add(fyne.NewPos(v.compare.Overlay().Size().Width/4, v.compare.Overlay().Size().Height/2)) fynetest.Drag(v.win.Canvas(), panePoint, 40, 20) - images = comparisonImages(v.compare.Overlay()) + images = comparisonShaders(v.compare.Overlay()) if images[0].Position() == afterDividerPositions[0] { t.Fatal("canvas drag away from the divider did not pan the comparison images") } @@ -722,6 +1045,33 @@ func TestCompareDividerKeys_ViewerRoutesShiftWithoutChangingCoveredState(t *test } } +func TestCompareDividerKeys_RemainActiveWhilePanesAreUnlinked(t *testing.T) { + v := openActiveComparisonWithExtra(t) + fynetest.Tap(comparisonButton(t, v.compare.Overlay(), lang.L("Swipe"))) + divider, _ := comparisonDivider(t, v.compare.Overlay()) + width := v.compare.Overlay().Size().Width + var modifiers fyne.KeyModifier + v.keyModifiers = func() fyne.KeyModifier { return modifiers } + hooks := &comparisonKeyHooks{} + wireComparisonLinkToggleHook(hooks, v) + + modifiers = fyne.KeyModifierControl + hooks.down(&fyne.KeyEvent{Name: fyne.KeyL}) + modifiers = 0 + v.handleKeyEvent(&fyne.KeyEvent{Name: fyne.KeyRight}) + if center := divider.Position().X + divider.Size().Width/2; !uitest.ApproxEqual(center, width*0.55) { + t.Fatalf("unlinked Right divider center = %.2f, want %.2f", center, width*0.55) + } + modifiers = fyne.KeyModifierShift + v.handleKeyEvent(&fyne.KeyEvent{Name: fyne.KeyLeft}) + if center := divider.Position().X + divider.Size().Width/2; !uitest.ApproxEqual(center, width*0.54) { + t.Errorf("unlinked Shift+Left divider center = %.2f, want fine step to %.2f", center, width*0.54) + } + if !comparisonHasVisibleLabel(v.compare.Overlay(), lang.L("Unlinked")) { + t.Error("divider keys relinked panes toggled apart by Ctrl+L") + } +} + func TestCompareGridLeak_PointerGesturesCannotScrollCoveredGrid(t *testing.T) { names := make([]string, 40) for i := range names { @@ -846,11 +1196,11 @@ func TestCompareSelection_HiddenHostIndicesDetermineLeftAndRight(t *testing.T) { fireCompareShortcut(v) waitForCompare(t, v) - images := comparisonImages(v.compare.Overlay()) + images := comparisonShaders(v.compare.Overlay()) if len(images) != 2 { t.Fatalf("comparison images = %d, want 2", len(images)) } - if left, right := images[0].Image.Bounds().Dx(), images[1].Image.Bounds().Dx(); left != 111 || right != 222 { + if left, right := images[0].Textures["overview"].Bounds().Dx(), images[1].Textures["overview"].Bounds().Dx(); left != 111 || right != 222 { t.Errorf("left/right source widths = %d/%d, want 111/222 in ascending host order", left, right) } if got, want := v.grid.Selection(), []int{1, 3}; !slices.Equal(got, want) { @@ -891,8 +1241,8 @@ func TestCompareSelection_DuplicateFilterKeepsHiddenSelectedHostFile(t *testing. } fireCompareShortcut(v) waitForCompare(t, v) - images := comparisonImages(v.compare.Overlay()) - if len(images) != 2 || images[0].Image.Bounds().Dx() != 101 || images[1].Image.Bounds().Dx() != 202 { + images := comparisonShaders(v.compare.Overlay()) + if len(images) != 2 || images[0].Textures["overview"].Bounds().Dx() != 101 || images[1].Textures["overview"].Bounds().Dx() != 202 { t.Errorf("comparison did not retain hidden host selection in file order") } v.compare.Close() diff --git a/internal/ui/favorites/favorites_test.go b/internal/ui/favorites/favorites_test.go index ed0a54f..d40c857 100644 --- a/internal/ui/favorites/favorites_test.go +++ b/internal/ui/favorites/favorites_test.go @@ -434,6 +434,9 @@ func TestCompareMenuState_DisablesStaticAndRefreshedFavoriteCommands(t *testing. if !item.IsSeparator && !item.Disabled { t.Errorf("%q stayed enabled during comparison", item.Label) } + if item != f.addItem && item != f.manageItem && !item.IsSeparator && item.Shortcut == nil { + t.Errorf("disabled favorite %q lost its display shortcut", item.Label) + } } // Rebuilding the dynamic entries while isolation is active must not @@ -446,6 +449,9 @@ func TestCompareMenuState_DisablesStaticAndRefreshedFavoriteCommands(t *testing. if !item.IsSeparator && !item.Disabled { t.Errorf("refreshed %q became enabled during comparison", item.Label) } + if item != f.addItem && item != f.manageItem && !item.IsSeparator && item.Shortcut == nil { + t.Errorf("refreshed disabled favorite %q lost its display shortcut", item.Label) + } } f.SetCommandsEnabled(true) @@ -454,6 +460,13 @@ func TestCompareMenuState_DisablesStaticAndRefreshedFavoriteCommands(t *testing. t.Errorf("%q stayed disabled after comparison", item.Label) } } + for i := range f.names { + item := f.menu.Items[2+i] + want := ShortcutForIndex(i) + if want != nil && (item.Shortcut == nil || item.Shortcut.ShortcutName() != want.ShortcutName()) { + t.Errorf("favorite %q shortcut after comparison = %v, want restored %q", item.Label, item.Shortcut, want.ShortcutName()) + } + } } // TestSetHasFilesDoesNotRefreshMenus pins the deliberate omission: SetHasFiles diff --git a/internal/ui/help/manual.md b/internal/ui/help/manual.md index 7daaf90..ecf952d 100644 --- a/internal/ui/help/manual.md +++ b/internal/ui/help/manual.md @@ -431,14 +431,17 @@ instead of arrowing through them one at a time. Selected thumbnails are washed in the accent colour, and the top bar counts them (`12 selected`). A click without dragging still just opens an image. - With exactly two files selected, press **`Cmd/Ctrl+D`** or choose - **Actions -> Compare selected images**. An opaque comparison opens in the + **Actions -> Compare selected images**. On macOS, `Cmd+D` is the native + shortcut; physical **`Ctrl+D`** also works on macOS. An opaque comparison opens in the same window with both images fitted into fixed 50/50 panes; the file earlier in the current grid order is on the left. Each side shows its own spinner while loading. Translucent bottom-corner badges identify the files by base name; if those names match, both expand to the shortest distinguishing folder/file suffix. The window title follows the same order, for example - `Compare: left.jpg | right.jpg - PicFetch`. A translucent toolbar stays at - the top right: **Back to Grid** remains available while loading, and + `Compare: left.jpg | right.jpg - PicFetch`. A separate translucent card holds + the top-left **Unlink** button; it and physical **`Ctrl+L`** remain inactive + until both images are ready. A translucent action toolbar stays at the top + right: **Back to Grid** remains available while loading, and **Swap** becomes available once both images are ready. Swap exchanges the images, badges, and title without loading either file again. **Swipe** switches both images to the full comparison viewport and adds a vertical @@ -446,20 +449,44 @@ instead of arrowing through them one at a time. divider to change the reveal; dragging elsewhere continues to pan both images. While swipe is active, **`Left`** / **`Right`** move the divider by 5 percentage points, **`Shift+Left`** / **`Shift+Right`** by 1 point, and - **`Home`** / **`End`** move it to 0%/100%. **Side by side** returns to fixed - 50/50 panes. Switching layouts keeps the linked view and divider position; - a new comparison starts side by side at 50%. Zoom and pan stay linked - between the comparison panes. Scroll over either pane or use - **`+`** / **`-`** to zoom both around the shared view. Dragging either - comparison pane or using Shift+scroll pans both; the shared point is clamped - so neither image can be pulled away from its pane. **`0`** fits and centers - both; **`1`** shows both at 100% (one decoded image pixel per canvas point). + **`Home`** / **`End`** move it to 0%/100%. + **Side by side** returns to fixed 50/50 panes. Switching layouts preserves + each photo's position and size, the camera, and the divider position; a new + comparison starts side by side at 50%. During normal linked use, zoom and pan operate + one overhead camera above the two photos. Scroll over either pane or use + **`+`** / **`-`** to zoom that camera; dragging either comparison pane or + using Shift+scroll moves both views by the same screen distance. Camera + movement stops before either photo can pass completely beyond the centre of + its pane. **`0`** frames both photos in their current arrangement with one + camera move while retaining their relative sizes and offsets. **`1`** returns the camera to + its 1x home view relative to the stored arrangement; after the photos have + been resized separately, it does not make both of them decoded-pixel 100%. + Use the top-left **Unlink** button or press physical **`Ctrl+L`** (`Ctrl`, + including on macOS; not `Cmd`) to toggle the panes between linked and + unlinked views. The first click or press unlinks them until either control is + used again; releasing Control has no effect. Once unlinked, the button + changes to **Link**, and the status **Unlinked** appears immediately beside + it, followed by **Left** or **Right** once a pane has been targeted. Drag, + scroll, or Shift+scroll then changes only the pane under the pointer; + unmodified **`0`**, **`1`**, **`+`**, and **`-`** change the + hovered or last-hovered photo and do nothing until a pane has been targeted. + Here **`0`** fits and centres only that photo in the current camera view, and + **`1`** shows only that photo at decoded-pixel 100%. A photo may be moved + until one of its edges reaches the pane centre. Changing the link state never + moves or resizes either photo: pressing **`Ctrl+L`** again locks the current + arrangement, and later linked controls move only the camera. Window resizing + and layout changes preserve the photo arrangement and camera. Swap locks and + clears any divergence from the last-targeted side before exchanging the images. A + new comparison always starts linked. Raster sources stay at full decoded resolution and use their canonical EXIF-corrected orientation; a temporary rotation in the single-image viewer is not carried into comparison. SVGs re-render at their effective screen-pixel size whenever zoom, layout, or window size changes. RAW files use the same embedded JPEG preview as the normal viewer. Animated inputs stay frozen on their first decoded frame for the entire comparison session. + A bounded overview remains visible while sharper detail tiles arrive in the background. + Pan and zoom update that stable GPU surface directly, so interaction does not + wait for the sharper tiles. Full fidelity can require the combined decoded memory of both sources even when the image cache retains only one. The existing encoded-input and vector-raster limits still apply. If either source cannot complete, PicFetch diff --git a/internal/ui/help/manual_de.md b/internal/ui/help/manual_de.md index 9d0b5c3..86e5d2c 100644 --- a/internal/ui/help/manual_de.md +++ b/internal/ui/help/manual_de.md @@ -480,7 +480,9 @@ einzeln durchzublättern. eingefärbt, und die obere Leiste zählt sie (`12 ausgewählt`). Ein Klick ohne Ziehen öffnet weiterhin nur ein Bild. - Sind genau zwei Dateien ausgewählt, drücken Sie **`Cmd/Strg+D`** oder wählen - **Aktionen -> Ausgewählte Bilder vergleichen**. Im selben Fenster erscheint + **Aktionen -> Ausgewählte Bilder vergleichen**. Unter macOS ist `Cmd+D` die + native Tastenkombination; die physische **`Ctrl+D`** funktioniert unter macOS ebenfalls. + Im selben Fenster erscheint eine undurchsichtige Vergleichsansicht, in der beide Bilder in feste 50/50-Bereiche eingepasst sind; die in der aktuellen Rasterreihenfolge frühere Datei steht links. Während des Ladens zeigt jede Seite einen eigenen @@ -488,8 +490,11 @@ einzeln durchzublättern. die Dateien mit ihrem Basisnamen; sind diese gleich, werden beide zum kürzesten unterscheidbaren Ordner/Datei-Suffix erweitert. Der Fenstertitel folgt derselben Reihenfolge, zum Beispiel - `Vergleich: links.jpg | rechts.jpg - PicFetch`. Oben rechts bleibt eine - durchscheinende Werkzeugleiste sichtbar: **Zurück zur Rasteransicht** ist + `Vergleich: links.jpg | rechts.jpg - PicFetch`. Eine separate + durchscheinende Karte enthält die Schaltfläche **Entkoppeln** oben links; + sie und die physische Tastenkombination **`Ctrl+L`** bleiben inaktiv, bis + beide Bilder bereit sind. Oben rechts bleibt eine durchscheinende + Aktionsleiste sichtbar: **Zurück zur Rasteransicht** ist auch beim Laden verfügbar, **Tauschen** wird aktiv, sobald beide Bilder bereit sind. Tauschen vertauscht Bilder, Abzeichen und Titel, ohne eine Datei erneut zu laden. **Wischen** legt beide Bilder über den vollständigen @@ -500,15 +505,39 @@ einzeln durchzublättern. die Trennlinie um 5 Prozentpunkte, **`Shift+Left`** / **`Shift+Right`** um 1 Prozentpunkt und **`Home`** / **`End`** setzen sie auf 0 %/100 %. **Nebeneinander** kehrt zu festen 50/50-Bereichen zurück. Beim Wechsel der - Anordnung bleiben die gekoppelte Ansicht und die Trennlinienposition erhalten; - ein neuer Vergleich beginnt nebeneinander bei 50 %. Zoom und Verschieben - bleiben gekoppelt zwischen den beiden Vergleichsbereichen. Scrollen Sie über - einem Bereich oder verwenden Sie - **`+`** / **`-`**, um beide um die gemeinsame Ansicht zu zoomen. Ziehen in - einem Vergleichsbereich oder Shift+Scrollen verschiebt beide; der gemeinsame - Punkt wird so begrenzt, dass kein Bild aus seinem Bereich gezogen werden - kann. **`0`** passt beide Bilder ein und zentriert sie; **`1`** zeigt beide - mit 100 % (ein dekodiertes Bildpixel pro Canvas-Punkt). + Anordnung bleiben Position und Größe beider Fotos, die Kamera und die + Trennlinienposition erhalten; ein neuer Vergleich beginnt nebeneinander bei + 50 %. Im normal gekoppelten Zustand steuern Zoom und Verschieben eine + gemeinsame Kamera über den beiden Fotos. Scrollen Sie über einem Bereich + oder verwenden Sie **`+`** / **`-`**, um diese Kamera zu zoomen. Ziehen in + einem Vergleichsbereich oder Shift+Scrollen bewegt beide Ansichten um + dieselbe Bildschirmstrecke. Die Kamerabewegung stoppt, bevor ein Foto die + Mitte seines Bereichs vollständig passiert. **`0`** rahmt beide Fotos in ihrer + aktuellen Anordnung mit einer Kamerabewegung ein und behält ihre relativen + Größen und Versätze bei. **`1`** setzt die Kamera auf ihre 1x-Ausgangsansicht relativ + zur gespeicherten Anordnung zurück; nach getrenntem Skalieren zeigt + es nicht beide Fotos mit 100 % der dekodierten Pixelgröße. Verwenden Sie die + Schaltfläche **Entkoppeln** oben links oder drücken Sie die physische + Tastenkombination **`Ctrl+L`** (`Ctrl`/`Strg`, auch unter macOS; nicht `Cmd`), + um zwischen gekoppelten und entkoppelten Ansichten umzuschalten. Der erste + Klick oder Tastendruck entkoppelt die Bereiche, bis eines der beiden + Bedienelemente erneut verwendet wird; das Loslassen von Control hat keine + Wirkung. Nach dem Entkoppeln wechselt die Schaltfläche zu **Koppeln**, und der + Status **Entkoppelt** erscheint direkt daneben; nach der Auswahl eines + Bereichs folgt zusätzlich **Links** oder **Rechts**. Ziehen, Scrollen oder Shift+Scrollen + ändert dann nur den Bereich unter dem Mauszeiger; die unveränderten Tasten + **`0`**, **`1`**, **`+`** und **`-`** ändern das Foto unter dem Mauszeiger + beziehungsweise das zuletzt berührte Foto und bewirken nichts, solange noch + kein Bereich ausgewählt wurde. Dabei passt **`0`** nur dieses Foto in die + aktuelle Kameraansicht ein und zentriert es; **`1`** zeigt nur dieses Foto mit + 100 % der dekodierten Pixelgröße. Ein Foto lässt sich verschieben, bis einer + seiner Ränder die Mitte des Bereichs erreicht. Das Umschalten der Kopplung + bewegt oder skaliert keines der Fotos: Beim erneuten Drücken von **`Ctrl+L`** + wird die aktuelle Anordnung gekoppelt, danach verändern gekoppelte Befehle nur + noch die Kamera. Fenstergrößen- und Anordnungsänderungen bewahren die + Fotoanordnung und Kamera. Tauschen koppelt und verwirft zuerst alle + Unterschiede anhand des zuletzt berührten Bereichs und vertauscht dann die + Bilder. Ein neuer Vergleich beginnt immer gekoppelt. Rasterquellen bleiben in der vollen dekodierten Auflösung und verwenden ihre kanonische EXIF-korrigierte Ausrichtung; eine vorübergehende Drehung in der Einzelbildansicht wird nicht in den Vergleich übernommen. SVGs werden für @@ -516,7 +545,10 @@ einzeln durchzublättern. Anordnung oder Fenstergröße ändern. RAW-Dateien verwenden dieselbe eingebettete JPEG-Vorschau wie die normale Einzelbildansicht. Animierte Eingaben bleiben auf ihrem ersten dekodierten Einzelbild eingefroren, solange - der Vergleich geöffnet ist. Volle Wiedergabetreue kann den kombinierten + der Vergleich geöffnet ist. Eine begrenzte Übersicht bleibt sichtbar, während schärfere + Detailkacheln im Hintergrund eintreffen. Verschieben und Zoomen aktualisieren diese stabile + GPU-Fläche direkt, sodass die Interaktion nicht auf die schärferen Kacheln wartet. + Volle Wiedergabetreue kann den kombinierten dekodierten Speicher beider Quellen beanspruchen, auch wenn der Bild-Cache nur eine davon behält. Die vorhandenen Grenzen für kodierte Eingaben und Vektor-Raster gelten weiterhin. Kann eine Quelle nicht vollständig geladen diff --git a/internal/ui/help/manual_test.go b/internal/ui/help/manual_test.go index 1a57c4f..5b8fa1a 100644 --- a/internal/ui/help/manual_test.go +++ b/internal/ui/help/manual_test.go @@ -130,9 +130,15 @@ func TestManualDocumentsComparisonEntryAndExit(t *testing.T) { if !strings.Contains(manualMD, "Cmd/Ctrl+D") || !strings.Contains(manualMD, "Back to Grid") { t.Error("manual.md does not document the comparison shortcut and exit") } + if !strings.Contains(manualMD, "physical **`Ctrl+D`** also works on macOS") { + t.Error("manual.md does not document the physical Ctrl+D comparison shortcut on macOS") + } if !strings.Contains(manualDE, "Cmd/Strg+D") || !strings.Contains(manualDE, "Zurück zur Rasteransicht") { t.Error("manual_de.md does not document the comparison shortcut and exit") } + if !strings.Contains(manualDE, "physische **`Ctrl+D`** funktioniert unter macOS ebenfalls") { + t.Error("manual_de.md does not document the physical Ctrl+D comparison shortcut on macOS") + } } func TestManualDocumentsComparisonIdentityAndSwap(t *testing.T) { @@ -177,27 +183,39 @@ func TestManualDocumentsComparisonCommandIsolation(t *testing.T) { } } -func TestManualDocumentsComparisonLinkedZoomAndPan(t *testing.T) { +func TestManualDocumentsComparisonCameraAndPhotoControls(t *testing.T) { english := strings.Join(strings.Fields(manualMD), " ") for _, phrase := range []string{ - "Zoom and pan stay linked", - "**`0`** fits and centers both", - "**`1`** shows both at 100%", - "Dragging either comparison pane or using Shift+scroll pans both", + "zoom and pan operate one overhead camera above the two photos", + "**`0`** frames both photos in their current arrangement with one camera move", + "**`1`** returns the camera to its 1x home view", + "using Shift+scroll moves both views by the same screen distance", + "Here **`0`** fits and centres only that photo", + "Changing the link state never moves or resizes either photo", + "top-left **Unlink** button", + "remain inactive until both images are ready", + "button changes to **Link**", + "status **Unlinked** appears immediately beside it", } { if !strings.Contains(english, phrase) { - t.Errorf("manual.md does not document linked comparison phrase %q", phrase) + t.Errorf("manual.md does not document comparison camera/photo phrase %q", phrase) } } german := strings.Join(strings.Fields(manualDE), " ") for _, phrase := range []string{ - "Zoom und Verschieben bleiben gekoppelt", - "**`0`** passt beide Bilder ein und zentriert sie", - "**`1`** zeigt beide mit 100 %", - "Ziehen in einem Vergleichsbereich oder Shift+Scrollen verschiebt beide", + "Zoom und Verschieben eine gemeinsame Kamera über den beiden Fotos", + "**`0`** rahmt beide Fotos in ihrer aktuellen Anordnung mit einer Kamerabewegung ein", + "**`1`** setzt die Kamera auf ihre 1x-Ausgangsansicht", + "Shift+Scrollen bewegt beide Ansichten um dieselbe Bildschirmstrecke", + "passt **`0`** nur dieses Foto in die aktuelle Kameraansicht ein", + "Das Umschalten der Kopplung bewegt oder skaliert keines der Fotos", + "Schaltfläche **Entkoppeln** oben links", + "bleiben inaktiv, bis beide Bilder bereit sind", + "wechselt die Schaltfläche zu **Koppeln**", + "Status **Entkoppelt** erscheint direkt daneben", } { if !strings.Contains(german, phrase) { - t.Errorf("manual_de.md does not document linked comparison phrase %q", phrase) + t.Errorf("manual_de.md does not document comparison camera/photo phrase %q", phrase) } } } @@ -240,6 +258,8 @@ func TestManualDocumentsComparisonSourceFidelity(t *testing.T) { "SVGs re-render at their effective screen-pixel size", "RAW files use the same embedded JPEG preview", "Animated inputs stay frozen on their first decoded frame", + "overview remains visible while sharper detail tiles arrive in the background", + "Pan and zoom update that stable GPU surface directly", "combined decoded memory", "encoded-input and vector-raster limits", "never downsampled or removed", @@ -256,6 +276,8 @@ func TestManualDocumentsComparisonSourceFidelity(t *testing.T) { "SVGs werden für ihre effektive Bildschirm-Pixelgröße neu gerendert", "RAW-Dateien verwenden dieselbe eingebettete JPEG-Vorschau", "Animierte Eingaben bleiben auf ihrem ersten dekodierten Einzelbild eingefroren", + "Übersicht bleibt sichtbar, während schärfere Detailkacheln im Hintergrund eintreffen", + "Verschieben und Zoomen aktualisieren diese stabile GPU-Fläche direkt", "kombinierten dekodierten Speicher", "Grenzen für kodierte Eingaben und Vektor-Raster", "weder verkleinert noch entfernt", diff --git a/internal/ui/keys.go b/internal/ui/keys.go index f828aa3..a24e557 100644 --- a/internal/ui/keys.go +++ b/internal/ui/keys.go @@ -12,13 +12,13 @@ import ( // defaultKeyModifiers reports the keyboard modifiers currently held, which // a fyne.KeyEvent doesn't carry: desktop.Driver.CurrentKeyModifiers is kept // in sync by the glfw driver on every key event regardless of which widget -// has focus, unlike a window-level SetOnKeyDown/SetOnKeyUp hook, which Fyne -// only calls when nothing focusable currently has focus. Both consumers - -// Shift+R below and internal/ui/zoom's Shift+scroll pan - reach it through -// the viewer's keyModifiers field rather than calling it directly, so tests -// can stub it per-viewer: Fyne's test driver doesn't implement -// desktop.Driver at all, so the type assertion here is always false under -// test. +// has focus, unlike a window-level SetOnKeyDown hook, which Fyne only calls +// when nothing focusable currently has focus. Consumers including Shift+R, +// comparison's physical Ctrl+L toggle, and internal/ui/zoom's Shift+scroll +// pan reach it through the viewer's keyModifiers field rather than calling it +// directly, so tests can stub it per-viewer: Fyne's test driver doesn't +// implement desktop.Driver at all, so the type assertion here is always false +// under test. func defaultKeyModifiers() fyne.KeyModifier { if d, ok := fyne.CurrentApp().Driver().(desktop.Driver); ok { return d.CurrentKeyModifiers() @@ -27,6 +27,27 @@ func defaultKeyModifiers() fyne.KeyModifier { return 0 } +type comparisonKeyDownCanvas interface { + OnKeyDown() func(*fyne.KeyEvent) + SetOnKeyDown(func(*fyne.KeyEvent)) +} + +// wireComparisonLinkToggleHook handles exact physical Ctrl+L presses before +// Fyne turns modified keys into shortcuts. OnKeyDown runs for the press edge +// but not key repeat, so holding L cannot toggle repeatedly. Existing canvas +// hooks are preserved. +func wireComparisonLinkToggleHook(c comparisonKeyDownCanvas, view *viewer) { + previousDown := c.OnKeyDown() + c.SetOnKeyDown(func(ev *fyne.KeyEvent) { + if previousDown != nil { + previousDown(ev) + } + if ev != nil && ev.Name == fyne.KeyL && view.keyModifiers() == fyne.KeyModifierControl { + view.compare.ToggleLink() + } + }) +} + // handleTypedRune dispatches a single typed character. The grid's filename // search (see internal/ui/grid) is the only thing in the app that reads // characters rather than key names, so outside the grid there is nothing to diff --git a/internal/ui/menu_test.go b/internal/ui/menu_test.go index a7ae651..acc3789 100644 --- a/internal/ui/menu_test.go +++ b/internal/ui/menu_test.go @@ -385,6 +385,27 @@ func TestFavoriteShortcutOpensStoredFilesThroughViewer(t *testing.T) { } } +func TestGlobalFavoriteShortcutOpensStoredFilesThroughViewer(t *testing.T) { + v := newTestViewer(t) + dir := t.TempDir() + image := uitest.TempJPEGURI(t, "global-shortcut-favorite.jpg", 4, 4, color.White) + if err := favstore.Save(dir, "Trip", []fyne.URI{image}); err != nil { + t.Fatalf("favstore.Save: %v", err) + } + v.favorites.SetDir(dir) + + handler := &fyne.ShortcutHandler{} + wireGlobalShortcuts(handler, v) + handler.TypedShortcut(favoriteui.ShortcutForIndex(0)) + waitForScan(t, v) + waitForSort(t, v) + waitUntilLoaded(t, v) + + if len(v.state.files) != 1 || v.state.files[0].Path() != image.Path() { + t.Errorf("files = %v, want favorite image %q", v.state.files, image.Path()) + } +} + // mainMenuRecorder is a fyne.Window that notes, every time something reads // its main menu, which items the Favorites menu held at that moment. Reading // the bar is what refreshMainMenu (windowmenu.go) does and the only trace it diff --git a/internal/ui/run.go b/internal/ui/run.go index 651e096..9229ab0 100644 --- a/internal/ui/run.go +++ b/internal/ui/run.go @@ -111,6 +111,7 @@ func registerShutdown(application fyne.App, view *viewer) { view.vector.lifecycle.invalidate() view.regionCopyLifecycle.invalidate() view.updateOp.invalidate() + view.compare.Close() // Same reasoning as the invalidations above, for the one piece of // state that outlives the viewer: openwith's queue is diff --git a/internal/ui/shortcuts.go b/internal/ui/shortcuts.go index 741f70b..63f54eb 100644 --- a/internal/ui/shortcuts.go +++ b/internal/ui/shortcuts.go @@ -45,14 +45,23 @@ func wireGlobalShortcuts(c shortcutAdder, view *viewer) { wireExportShortcuts(yielding, view) } -// wireCompareShortcut binds Cmd/Ctrl+D to the comparison command. D is not -// one of Fyne's built-in shortcut types, so the desktop custom shortcut is -// the production path on every desktop platform. +// wireCompareShortcut binds the platform-native Cmd/Ctrl+D and physical +// Ctrl+D to the comparison command. On platforms whose native shortcut is +// already Control, the second registration is omitted. D is not one of +// Fyne's built-in shortcut types, so desktop custom shortcuts are the +// production path on every desktop platform. func wireCompareShortcut(c shortcutAdder, view *viewer) { + open := func(fyne.Shortcut) { view.compareSelected() } c.AddShortcut(&desktop.CustomShortcut{ KeyName: fyne.KeyD, Modifier: fyne.KeyModifierShortcutDefault, - }, func(fyne.Shortcut) { view.compareSelected() }) + }, open) + if fyne.KeyModifierShortcutDefault != fyne.KeyModifierControl { + c.AddShortcut(&desktop.CustomShortcut{ + KeyName: fyne.KeyD, + Modifier: fyne.KeyModifierControl, + }, open) + } } // yieldingShortcuts is the canvas-shortcut yield: every binding registered diff --git a/plans/2026-09-01-ctrl-l-comparison-link-toggle.md b/plans/2026-09-01-ctrl-l-comparison-link-toggle.md new file mode 100644 index 0000000..3e22e81 --- /dev/null +++ b/plans/2026-09-01-ctrl-l-comparison-link-toggle.md @@ -0,0 +1,70 @@ +# Ctrl+L comparison link toggle + +Status: complete + +Route: Standard. This corrects one comparison interaction across +`internal/ui/compare`, viewer input wiring, Favorites shortcut presentation, +the manuals, and architecture notes. It adds no package, dependency, +preference, or external API. + +Deliverable: exact physical `Ctrl+L` toggles retained pane-local views until a +second press relinks from the last-hovered pane through the shared no-blank +clamp. + +## Locked decisions + +| Decision | Contract | +|---|---| +| Shortcut | Physical `Ctrl+L` on every desktop platform, including macOS; extra modifiers do not match. | +| Lifecycle | New comparisons start linked. Control press/release alone has no effect. | +| Target and relink | Local input uses the hovered or last-hovered pane; relinking adopts that pane and applies the shared clamp. | +| Existing transitions | Resize and layout preserve local views. Swap relinks and resets divergence. | +| Feedback | Reuse `Unlinked`, `Unlinked: Left`, and `Unlinked: Right`; add no button or preference. | + +## Tasks + +### Task 1 - Toggle state and pane-local input + +Owner: T0 inline + +Test first through `compare.Feature`: persistent local pointer/key input, +status, relinking/clamping, retained caches, layout/resize, Swap, and vector +rendering. + +Verify: `go test ./internal/ui/compare -count=1` + +### Task 2 - Physical key edge and shortcut cleanup + +Owner: T0 inline + +Test first through the assembled viewer key hook: exact physical `Ctrl+L`, no +Control-release effect, no repeat flapping, unmodified transform/divider keys, +hook chaining, and unchanged Favorites availability. + +Verify: `go test ./internal/ui ./internal/ui/favorites -count=1` + +### Task 3 - Documentation and final gate + +Owner: T0 inline + +Update both manuals, `ARCHITECTURE.md`, and `todos.md`; preserve the completed +hold-to-unlink plan as historical evidence. + +Verify: `go test ./... -run 'Translations|Manual|UnicodeArrows' -count=1` + +## Budget and gate + +Zero spawns; at most three review rounds; one full suite. Negatively verify the +exact-toggle guard before the final `make verify` run. + +## Outcome + +Comparison now starts linked and exact physical `Ctrl+L` persistently toggles +the retained pane-local views. Control release is inert, unmodified comparison +gestures and transform keys target the last-hovered pane while unlinked, and a +second toggle relinks from that pane through the shared clamp. The obsolete +modified-key shortcuts and Favorites accelerator workaround were removed. + +Verification completed with focused comparison/viewer/Favorites tests, manual +and translation guards, Windows-targeted vet, a negative exact-modifier +mutation, and the full Linux/amd64 race-backed `make verify` gate. diff --git a/plans/2026-09-01-temporary-control-unlink-comparison.md b/plans/2026-09-01-temporary-control-unlink-comparison.md new file mode 100644 index 0000000..93973b7 --- /dev/null +++ b/plans/2026-09-01-temporary-control-unlink-comparison.md @@ -0,0 +1,85 @@ +# Temporary Control unlink in comparison + +Status: complete + +Route: Standard. This extends `internal/ui/compare`, the assembled viewer input +seam, translations, and both manuals. It adds no package, dependency, +preference, or external API. + +Deliverable: a fresh physical Control hold temporarily restores two retained +pane-local views; release relinks from the hovered pane under the existing +shared no-blank clamp. + +## Locked decisions + +| Decision | Contract | +|---|---| +| Scope | The current comparison layout default is unchanged. Control means the physical Control key on every desktop platform. | +| Target | Pointer gestures and `0`, `1`, `+`, and `-` affect the hovered or last-hovered pane. With no target, local keyboard transforms do nothing. | +| Relink | Release always chooses the hovered pane, even when it was not edited, then applies the shared clamp. | +| Local bounds | Local centers are bounded to normalized `[0,1]`, allowing an image edge to reach pane center. | +| Retention | Pane-local views persist for the comparison session. Linked pan/zoom applies the same normalized delta/scale ratio to both caches; linked `0`/`1` changes their scale modes but retains their centers. | +| Transitions | Resize and layout toggles preserve both local views. Swap relinks, clears divergence, swaps, and suppresses the still-held Control until release. | +| Feedback | Show only `Unlinked`, `Unlinked: Left`, or `Unlinked: Right` in the toolbar while a fresh Control hold is active. | + +## Tasks + +### Task 1 - Pane-local transform state + +Owner: T0 inline + +Test first through `compare.Feature` and its overlay: local pointer/key input, +hover targeting, overscroll, release clamping, retained caches, relayout, Swap, +session reset, status, and vector rendering. + +Verify: `go test ./internal/ui/compare -run 'Compare.*(Control|Unlink|Relink|Local|Cache)' -count=1` + +### Task 2 - Assembled input wiring + +Owner: T0 inline + +Test first through the viewer and production shortcut/key-hook wiring: physical +Control lifecycle, Ctrl+D suppression, modified transform/divider keys, +Ctrl+0/Ctrl+1 favorite preservation, and covered-grid isolation. + +Verify: `go test ./internal/ui -run 'Compare.*(Control|Unlink|Relink|Local|Cache)' -count=1` + +### Task 3 - User documentation and landing + +Owner: T0 inline + +Localize the status strings, update both manuals and `ARCHITECTURE.md`, then +replace the open TODO with a verified release-note entry. Preserve the +historical finished comparison specification. + +Verify: `go test ./... -run 'Translations|Manual|UnicodeArrows' -count=1` + +## Budget and gate + +Zero spawns; at most three review rounds; one full suite. Each behavior guard +must be observed red before implementation and fail once more under a deliberate +mutation before final acceptance. Final gate: Windows vet followed by `make +verify`. + +## Outcome + +Implemented inline with zero spawns. Comparison now owns retained pane-local +transforms, physical-Control lifecycle/status, target-based pointer and keyboard +input, release-time relinking/clamping, cache propagation during linked input, +layout/resize preservation, Swap suppression/reset, and pane-local SVG raster +targets. Viewer wiring chains desktop modifier hooks and registers modified-key +repeat shortcuts; Favorites temporarily releases its digit accelerators while +comparison is active so Windows/Linux Control+0/1 reaches comparison and is +restored afterward. Both manuals, locale catalogs, `ARCHITECTURE.md`, and the +release notes describe the landed behavior; side-by-side remains the default. + +Verification completed 2026-09-01: + +- Focused compare, viewer, Favorites, manual, translation, and Unicode-arrow + tests passed. +- Deliberate mutations were detected by the local-render, cache propagation, + status/relink/suppression, bounds/reset, shortcut/hook, and accelerator guards; + the restored focused set passed. +- `GOOS=windows GOARCH=amd64 go vet ./internal/...` passed. +- `make verify` passed, including the Linux/amd64 race suite (`internal/ui` in + 639.593s). diff --git a/plans/2026-09-02-comparison-link-button.md b/plans/2026-09-02-comparison-link-button.md new file mode 100644 index 0000000..5d6ec3a --- /dev/null +++ b/plans/2026-09-02-comparison-link-button.md @@ -0,0 +1,98 @@ +# Comparison link button + +Status: complete + +Route: Standard. This adds one discoverable comparison control across the +existing compare feature, assembled-viewer test seam, localization, manuals, +and architecture/release notes. It adds no package, dependency, preference, or +exported API. + +Deliverable: a ready-gated top-left Unlink/Link control shares the exact +`Ctrl+L` action and carries the existing target-aware Unlinked status beside +it, while the existing action toolbar stays at the top right. + +## Locked decisions + +- The button reads Unlink while linked and Link while unlinked. +- Button and physical `Ctrl+L` are inert until both sources are ready. +- The top-left card contains button then status; status remains hidden while + linked. +- Open, failure/close, and Swap reset to linked. Existing transform behavior is + unchanged. +- Tests use `compare.Feature` and the assembled viewer; no golden is added. + +## Tasks + +### Task 1 - Top-left chrome tracer + +Owner: T2 mechanical for the exact red test; T0 for review and green. + +Files: `internal/ui/compare/compare_test.go`, then +`internal/ui/compare/compare.go` and translation bundles. + +Test: the permanent compact/translucent left card, button-first ordering, +loading disablement, readiness enablement, and unchanged right action card. + +Verify: `go test ./internal/ui/compare -run '^TestCompareLinkControl_TopLeftCardAndReadyGate$' -count=1` + +Budget: one spawn, one T0 review round, no full suite. + +### Task 2 - Shared button and shortcut behavior + +Owner: T2 mechanical for the exact red integration test; T0 for review and +green. + +Files: `internal/ui/compare_test.go`, then link-state synchronization in +`internal/ui/compare/compare.go` and its package tests. + +Depends: Task 1. + +Test: loading-time `Ctrl+L` is inert; after readiness `Ctrl+L` reveals Link plus +Unlinked, and tapping Link restores Unlink plus hidden status. Open and Swap +reset the same state. + +Verify: `go test ./internal/ui -run 'Compare(LinkControl|LinkToggle)' -count=1` + +Budget: one spawn, one T0 review round, no full suite. + +### Task 3 - Documentation and landing + +Owner: T0 inline. + +Files: both manuals and their guard, `ARCHITECTURE.md`, `todos.md`, issue/spec, +and this plan. + +Depends: Tasks 1 and 2. + +Contract: document and localize the finished pointer/keyboard workflow, run +focused regressions, negatively verify the new guards, and record evidence. + +Verify: `go test . -run '^TestTranslations_' -count=1`, +`go test ./internal/ui/help -run '^TestManual' -count=1`, then `make verify` +once. + +Budget: zero spawns, at most two T0 review rounds, one full suite. + +Task graph: 1 -> 2 -> 3. Agent failures are fixed by T0 without respawning. + +## Cost ledger + +| Task | Spawns budget/actual | Review rounds | Full suite | Notes | +|---|---:|---:|---|---| +| T1 | 1 / 1 | 2 | no | Red tracer delegated; primary implemented and tightened the layout assertion. | +| T2 | 1 / 1 | 2 | no | Red tracer delegated; primary implemented and negatively verified the ready gate. | +| T3 | 0 / 0 | 2 | yes | Strings, manuals, architecture notes, focused regressions, and `make verify` passed. | + +## Outcome + +- Added a compact top-left card whose disabled-while-loading Unlink/Link button + and adjacent target-aware status share `compare.Feature.ToggleLink` with + physical `Ctrl+L`. +- Preserved the separate top-right layout, Swap, and Back to Grid action card. +- Retained linked resets for Open and Swap and documented the behavior in both + locales. +- Captured two permanent red-to-green tracers. Negative mutations separately + proved the readiness guard and button-before-status ordering. +- Final verification: focused comparison, translation, and manual suites + passed; `make verify` passed formatting/TUF checks, vet, build, and the full + Linux/amd64 race suite on 2026-09-02. diff --git a/plans/2026-09-02-inert-comparison-link-toggle.md b/plans/2026-09-02-inert-comparison-link-toggle.md new file mode 100644 index 0000000..c6a8981 --- /dev/null +++ b/plans/2026-09-02-inert-comparison-link-toggle.md @@ -0,0 +1,104 @@ +# Inert comparison link toggle + +Status: complete + +Route: Standard. This corrects one comparison interaction across +`internal/ui/compare`, its manuals, release notes, and architecture record. It +adds no package, dependency, preference, user-visible string, or external API. + +Deliverable: locking or unlocking comparison changes only which transform owns +future input; neither transition changes either photo's visible size or +position. + +## Locked decisions + +| Decision | Contract | +|---|---| +| Photo state | Each photo keeps its own position, scale, and fit/actual mode for the comparison session. | +| Camera state | Linked controls operate one shared overhead camera composed over both photo poses. | +| Link toggle | Physical `Ctrl+L` changes input ownership only. Unlock and relock are exact geometry no-ops. | +| Linked resets | `0` frames both current poses with one camera move; `1` returns the camera to its 1x home without rewriting photo poses. | +| Unlinked resets | `0` fits and centers only the target photo in the current camera; `1` shows only that photo at decoded-pixel size. | +| Bounds | A local photo or the shared camera may expose the table, but cannot move a photo completely past its pane center. | +| Existing transitions | Resize and layout preserve photo and camera state. Swap retains its explicit relink/reset behavior before exchanging sources. | + +## Tasks + +### Task 1 - Separate persistent photo poses from the shared camera + +Owner: T0 inline + +Files: `internal/ui/compare/compare.go`, `internal/ui/compare/transform.go`, +`internal/ui/compare/input.go`, `internal/ui/compare/compare_test.go` + +Test first through `compare.Feature`: unlock/relock geometry is exact, unlinked +input changes one photo, linked input moves both through one camera, camera fit +and home preserve divergent poses, movement remains bounded, and resize/layout +round trips retain the composed state. + +Verify: `go test ./internal/ui/compare -count=1` + +### Task 2 - Preserve assembled comparison behavior + +Owner: T0 inline + +Files: existing viewer and Favorites tests only; no production change expected. + +Verify: `go test ./internal/ui -run 'Compare' -count=1 && go test +./internal/ui/favorites -run 'Compare' -count=1`. The complete UI suite remains +part of the Linux/amd64 final gate because native golden rendering is not +authoritative. + +### Task 3 - Documentation and final gate + +Owner: T0 inline + +Files: `internal/ui/help/manual.md`, `internal/ui/help/manual_de.md`, +`internal/ui/help/manual_test.go`, `ARCHITECTURE.md`, `todos.md`, this plan. + +Document the photo/table/camera model and the differing linked/unlinked `0` and +`1` meanings. Preserve the superseded Ctrl+L plan as historical evidence. + +Verify: `go test ./... -run 'Translations|Manual|UnicodeArrows' -count=1` + +## Budget and gate + +Zero spawns; at most three review rounds; one full suite. Negatively verify the +exact relock guard before the final `make verify` run. + +## Outcome + +Comparison now composes two persistent photo transforms with one shared camera. +Unlocking and relocking change only input ownership, so both transitions retain +the exact rendered size and position of each photo. Unlinked input edits one +photo; linked zoom, pan, fit, and home move only the camera over the retained +arrangement. Camera-aware photo and camera bounds keep each image over its pane +center, while resize/layout round trips and the existing Swap reset semantics +remain intact. + +The manuals, their behavior guard, architecture map, and release notes now use +the same photo/table/camera model. + +## Cost ledger + +| Task | Spawns budget/actual | Review rounds | Full suite | Notes | +|---|---:|---:|---|---| +| T1 | 0 / 0 | 2 | no | Photo/camera split, inert toggles, composed controls, bounds, and component guards complete. | +| T2 | 0 / 0 | 1 | no | Assembled comparison and Favorites integration guards passed. | +| T3 | 0 / 0 | 1 | no | Manuals, manual guard, architecture, TODO, and plan records complete. | +| gate | - | - | - | yes | `make verify` passed. | + +## Verification record + +- `go test ./internal/ui/compare -count=1` passed. +- `go test ./internal/ui -run 'Compare' -count=1` and the matching Favorites + command passed. +- `go test ./... -run 'Translations|Manual|UnicodeArrows' -count=1` passed. +- The camera-offset local-bound guard first failed with the target photo wholly + beyond its pane center, then passed after the bound became camera-aware. +- A deliberate relock-time photo-transform overwrite made + `TestCompareLinkToggle_RelockKeepsDivergentPhotoPoses` fail with the expected + geometry change; the restored implementation passed the same exact guard. +- `make verify` passed formatting, TUF root validation, vet, build, and the + Linux/amd64 race suite (`internal/ui` 679.263s; + `internal/ui/compare` 17.186s). diff --git a/plans/2026-09-02-tiled-gpu-comparison-renderer.md b/plans/2026-09-02-tiled-gpu-comparison-renderer.md new file mode 100644 index 0000000..d9305eb --- /dev/null +++ b/plans/2026-09-02-tiled-gpu-comparison-renderer.md @@ -0,0 +1,116 @@ +# Tiled GPU comparison renderer + +Status: complete + +Route: Deep. Profiling found a cross-cutting rendering defect: every comparison +pan and zoom refreshes the viewer root, causing Fyne to discard and rebuild +smoothly scaled image textures on the UI/render thread. The change introduces a +private rendering seam, asynchronous source/tile preparation, bounded caches, +and portable shader contracts. No package, dependency, preference, or exported +API is added. + +Deliverable: side-by-side and swipe comparison pan/zoom by changing stable +shader uniforms. Source imagery is uploaded through a bounded overview plus +visible detail tiles, and both Command+D and physical Ctrl+D open comparison on +macOS. + +## Evidence and locked decisions + +- A 10-second native sample of the exact feature-branch binary attributed the + interaction stall to Fyne Catmull-Rom image scaling (`scaleY_RGBA64Image_Src`, + `scaleX_YCbCr420`, and `drawNRGBAOver`), reached through + `paneInput.Dragged -> panBy -> viewer.ForceRepaint -> Container.Refresh`. +- Comparison owns one renderer per pane. Existing Fyne clip/reveal geometry and + input routing remain authoritative for side-by-side and swipe layouts. +- `compare.New` keeps its public signature. An unexported constructor accepts a + renderer factory so package tests can use a deterministic canvas reference + renderer while production uses shaders. +- Each production renderer has a stable pane-specific shader name, one overview + sampler, and seven detail samplers. Desktop GLSL 110 and GLES GLSL 100 stay + structurally equivalent. Tile coordinates are normalized and use six scalar + values per detail, keeping the fragment-uniform contract below the GLES 2 + minimum while avoiding mediump overflow on raw source coordinates. +- Detail textures are at most 1024 by 1024 pixels: a 1022-pixel interior with a + one-pixel sampling gutter. The overview's long edge is at most 1024 pixels. +- The immutable decoded frame remains canonical. Detail mips are generated once + in cancellable background work and cached per source in a 64 MiB byte cache. +- The overview always covers the source. Missing or stale details therefore + reduce sharpness temporarily but never create blank regions. +- The tile planner selects a power-of-two level from source pixels per physical + display pixel, coarsening until the visible set fits seven samplers, then uses + spare slots for nearest-neighbor prefetch. +- Initial readiness means decoded sources and their overview textures are ready. + Existing spinners remain visible until then. SVG reraster publication follows + the same display-ready-source rule. +- At most one tile worker runs per pane. Source/view tokens reject stale work; + all worker completions enter through the feature's `UIQueue`; `Settle` waits + for load, vector, and tile work. +- Pan, zoom, resize, and tile publication update only pane renderers. Owner + repaint remains for comparison open/close and surrounding chrome lifecycle. +- Bilinear GPU sampling is always used. Shader output unpremultiplies nonzero + RGBA samples to match Fyne's shader blending contract. +- Clearing a pane replaces all fixed texture slots with transparent one-pixel + placeholders. Fyne may retain the most recent fixed GL textures until reuse or + app exit, but the retained set is bounded. +- Real GPU acceptance is macOS-only. Portable tests cover planning, lifecycle, + shader structure, and builds; Windows/Linux runtime GPU behavior is explicitly + unverified in this change. Fyne's software test painter does not implement + `canvas.Shader`; comparison therefore requires the native GL painter and + deterministic software-renderer tests use the private reference adapter. + +Non-goals: the normal single-image viewer, grid thumbnails, a user-configurable +tile budget, changing comparison command ownership, and GPU-specific runtime +verification on Windows or Linux. + +## Bite-sized execution + +| Ticket | Slice | Verification boundary | +|---|---|---| +| 01 | Shortcut parity and interaction repaint guard | UI shortcut tests plus 100 pan/zoom events | +| 02 | Renderer/scene seam | Reference renderer scene and geometry tests | +| 03 | Display-ready immutable sources | Overview/source preparation and readiness tests | +| 04 | Virtual tile planner and bounded cache | Pure planner/cache table tests | +| 05 | Desktop/GLES shader adapter | Structural shader and uniform/texture tests | +| 06 | Async tile delivery and lifecycle | cancellation, stale, settle, and swap tests | +| 07 | Production wiring and test migration | compare and assembled UI suites | +| 08 | Native profile, docs, and landing gate | native sample, memory check, `make verify` once | + +Task graph: 01 -> 02 -> 03 -> 04 -> 05 -> 06 -> 07 -> 08. Every behavior +slice is first observed red against absent behavior or an intentional local +mutation, then made green and refactored before the next slice. + +## Native performance acceptance + +Build an unstripped binary from the final working tree and collect separate +10-second samples while the user continuously pans/zooms in side-by-side and +swipe mode with the same source images used for the baseline. + +- No main-thread Catmull-Rom image scaling during steady-state interaction. +- No gesture-to-`viewer.ForceRepaint` stack during steady-state interaction. +- Texture uploads occur for source/mip/tile changes, not every pointer event. +- Input does not build a visible interaction backlog. +- Peak physical footprint is at most 1.2 GiB, versus the measured ~2.0 GiB + baseline. + +Accepted native result, 2026-09-02: the user reported both modes visually +smooth. The side-by-side sample was 95.2% main-thread idle at 1.0 GiB; the swipe +sample was 95.7% main-thread idle at 1.0 GiB, with a 1.1 GiB process peak. Both +were free of Catmull-Rom, `drawNRGBAOver`, and gesture-to-`ForceRepaint` stacks. +The live Go heap remained 267-271 MiB across repeated collections. Physical +`Ctrl+D` was exercised to open the comparison. Windows and Linux GPU runtime +behavior remains unverified as planned. + +## Ownership and cost ledger + +Implementation and integration ownership remains with the primary agent because +renderer state, Fyne lifecycle, test migration, and profiling share hot context. +At the user's request, three read-only subagents independently audited shader, +lifecycle, and integration concerns; their findings were reproduced red and +fixed by the primary agent. Review budget: one local review after each ticket, +the three parallel audits, and one final review. Full verification budget: one +`make verify`, in ticket 08 only. + +| Work | Spawns (budget/actual) | Review rounds | Full suite | Notes | +|---|---:|---:|---:|---| +| Tickets 01-07 | 3 / 3 | per ticket + 3 audits | no | user-requested shader, lifecycle, and integration audits | +| Ticket 08 | 0 / 0 | 1 | yes | one full-gate invocation; one focused Linux UI race rerun completed the portable test fix | diff --git a/todos.md b/todos.md index 157350e..666c2db 100644 --- a/todos.md +++ b/todos.md @@ -6,21 +6,25 @@ #### New Features +- Comparison pane linking can be toggled with the ready-gated **Unlink** / **Link** + control at the top left or physical `Ctrl+L` on every platform. Its adjacent + status identifies the targeted side while unlinked. Pan, wheel/Shift+wheel, + and `0` / `1` / `+` / `-` then affect only that photo; once linked again, the + same controls move one overhead camera while both photos retain their current + arrangement. + #### Bugfix -#### Internal +- Locking or unlocking comparison panes no longer moves or resizes either + photo. +- Pan and zoom in side-by-side and Swipe comparison now render through bounded + GPU tiles instead of resampling the full images on every gesture. +- Physical `Ctrl+D` opens comparison alongside the platform-native shortcut. -## ACTIVE DEVELOPMENT +#### Internal ## TODO -### Compare two grid-selected images additions -- **Manual Comparison:** When the ctrl-key is hold down and one of the sides is paned of zoomed, - only the side the cursor is on is affected. so the lock between the two sides is released as long - the crtl key is hold down. WHen letting go of ctrl the two sides are glued back together. but at - the current position and zoom level. from there one pan and zoom again influences both sides. -- swipe view should be the default view in comarison mode.. - ### Functional test coverage Audit baseline, 2026-09-01: package-local statement coverage came from a diff --git a/translations/de.json b/translations/de.json index 8bbd479..d46e152 100644 --- a/translations/de.json +++ b/translations/de.json @@ -153,6 +153,11 @@ "Side by side": "Nebeneinander", "Swap": "Tauschen", "Back to Grid": "Zurück zur Rasteransicht", + "Link": "Koppeln", + "Unlink": "Entkoppeln", + "Unlinked": "Entkoppelt", + "Unlinked: Left": "Entkoppelt: Links", + "Unlinked: Right": "Entkoppelt: Rechts", "Compare: %s | %s - PicFetch": "Vergleich: %s | %s - PicFetch", "Return to Grid View before opening files": "Kehren Sie zur Rasteransicht zurück, bevor Sie Dateien öffnen", "Rotate image (CW)": "Bild drehen (im Uhrzeigersinn)", diff --git a/translations/en.json b/translations/en.json index 025a584..987eb18 100644 --- a/translations/en.json +++ b/translations/en.json @@ -153,6 +153,11 @@ "Side by side": "Side by side", "Swap": "Swap", "Back to Grid": "Back to Grid", + "Link": "Link", + "Unlink": "Unlink", + "Unlinked": "Unlinked", + "Unlinked: Left": "Unlinked: Left", + "Unlinked: Right": "Unlinked: Right", "Compare: %s | %s - PicFetch": "Compare: %s | %s - PicFetch", "Return to Grid View before opening files": "Return to Grid View before opening files", "Rotate image (CW)": "Rotate image (CW)", From 827f04a64110e0740b36c15262e549f700375fab Mon Sep 17 00:00:00 2001 From: frathe Date: Wed, 2 Sep 2026 15:22:58 +0200 Subject: [PATCH 02/10] fix(deps): update grpc-go to v1.83.2 --- go.mod | 2 +- go.sum | 4 ++-- todos.md | 3 +++ 3 files changed, 6 insertions(+), 3 deletions(-) diff --git a/go.mod b/go.mod index 6940ef6..6ff0326 100644 --- a/go.mod +++ b/go.mod @@ -113,7 +113,7 @@ require ( golang.org/x/tools v0.49.0 // indirect google.golang.org/genproto/googleapis/api v0.0.0-20260727163830-6c54dddc4772 // indirect google.golang.org/genproto/googleapis/rpc v0.0.0-20260720155508-bb71a54f79dc // indirect - google.golang.org/grpc v1.82.1 // indirect + google.golang.org/grpc v1.83.2 // indirect google.golang.org/protobuf v1.36.11 // indirect k8s.io/klog/v2 v2.140.0 // indirect ) diff --git a/go.sum b/go.sum index 82f9800..e0c033f 100644 --- a/go.sum +++ b/go.sum @@ -419,8 +419,8 @@ google.golang.org/genproto/googleapis/api v0.0.0-20260727163830-6c54dddc4772 h1: google.golang.org/genproto/googleapis/api v0.0.0-20260727163830-6c54dddc4772/go.mod h1:1brfde68Npq6+WA75c1EHWPijZEG1kMus61ygPZfn4A= google.golang.org/genproto/googleapis/rpc v0.0.0-20260720155508-bb71a54f79dc h1:3TtNq/QbJNrSY1nVdjcikfBw6ujnaNbdrd88wNr1OW4= google.golang.org/genproto/googleapis/rpc v0.0.0-20260720155508-bb71a54f79dc/go.mod h1:4Hqkh8ycfw05ld/3BWL7rJOSfebL2Q+DVDeRgYgxUU8= -google.golang.org/grpc v1.82.1 h1:NnAxzGRA0677vCa4BUkOAnO5+FfQqVl9iUXeD0IqcGE= -google.golang.org/grpc v1.82.1/go.mod h1:yzTZ1TB1Z3SG+LIYaI+WiE8D5+PZ3ArnrSp8zF3+/ZA= +google.golang.org/grpc v1.83.2 h1:EManeRomTObA0BU7I8vXgg/78uE5MJ9M8B39EX2WscU= +google.golang.org/grpc v1.83.2/go.mod h1:YPI1hK3kDked6iHvgX3tR0y+nX/qpMFKhPgFsokw1S8= google.golang.org/protobuf v1.36.11 h1:fV6ZwhNocDyBLK0dj+fg8ektcVegBBuEolpbTQyBNVE= google.golang.org/protobuf v1.36.11/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco= gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= diff --git a/todos.md b/todos.md index 666c2db..cc7383d 100644 --- a/todos.md +++ b/todos.md @@ -23,6 +23,9 @@ #### Internal +- Updated the indirect gRPC-Go dependency to `v1.83.2`, resolving + `CVE-2026-84304` / `GHSA-vp52-pcj8-j9qc`. Was never used (better save than sorry) + ## TODO ### Functional test coverage From f07d9ef6f74c219bf9aa574d134148570443d3fe Mon Sep 17 00:00:00 2001 From: frathe Date: Wed, 2 Sep 2026 16:20:12 +0200 Subject: [PATCH 03/10] chore: upgrade Go and security dependencies --- .github/CONTRIBUTING.md | 2 +- Makefile | 7 +- README.md | 20 +- ...2026-08-31-open-side-by-side-comparison.md | 0 .../2026-09-01-add-swipe-comparison.md | 0 ...026-09-01-ctrl-l-comparison-link-toggle.md | 0 .../2026-09-01-identify-and-swap-images.md | 0 .../2026-09-01-isolate-comparison-commands.md | 0 ...26-09-01-link-side-by-side-zoom-and-pan.md | 0 .../2026-09-01-preserve-comparison-state.md | 0 .../2026-09-01-preserve-source-fidelity.md | 0 ...-01-temporary-control-unlink-comparison.md | 0 .../2026-09-02-comparison-link-button.md | 0 .../2026-09-02-go-1-27-security-refresh.md | 92 +++++++ ...2026-09-02-inert-comparison-link-toggle.md | 0 ...026-09-02-tiled-gpu-comparison-renderer.md | 0 go.mod | 41 ++- go.sum | 243 +++++++++--------- todos.md | 6 + 19 files changed, 258 insertions(+), 153 deletions(-) rename {plans => finished_refactorings}/2026-08-31-open-side-by-side-comparison.md (100%) rename {plans => finished_refactorings}/2026-09-01-add-swipe-comparison.md (100%) rename {plans => finished_refactorings}/2026-09-01-ctrl-l-comparison-link-toggle.md (100%) rename {plans => finished_refactorings}/2026-09-01-identify-and-swap-images.md (100%) rename {plans => finished_refactorings}/2026-09-01-isolate-comparison-commands.md (100%) rename {plans => finished_refactorings}/2026-09-01-link-side-by-side-zoom-and-pan.md (100%) rename {plans => finished_refactorings}/2026-09-01-preserve-comparison-state.md (100%) rename {plans => finished_refactorings}/2026-09-01-preserve-source-fidelity.md (100%) rename {plans => finished_refactorings}/2026-09-01-temporary-control-unlink-comparison.md (100%) rename {plans => finished_refactorings}/2026-09-02-comparison-link-button.md (100%) create mode 100644 finished_refactorings/2026-09-02-go-1-27-security-refresh.md rename {plans => finished_refactorings}/2026-09-02-inert-comparison-link-toggle.md (100%) rename {plans => finished_refactorings}/2026-09-02-tiled-gpu-comparison-renderer.md (100%) diff --git a/.github/CONTRIBUTING.md b/.github/CONTRIBUTING.md index 691932b..1e1daa8 100644 --- a/.github/CONTRIBUTING.md +++ b/.github/CONTRIBUTING.md @@ -10,7 +10,7 @@ participating, you're expected to uphold it. ## Getting set up -- Go 1.26.6 or newer (see the `go` directive in [go.mod](../go.mod)) +- Go 1.27.1 or newer (see the `go` directive in [go.mod](../go.mod)) - A C toolchain for cgo (Fyne's OpenGL bindings require it) — Xcode Command Line Tools on macOS, `gcc` + `libgl1-mesa-dev`/`xorg-dev` on Linux - See the [README](../README.md#requirements) for the full list, including diff --git a/Makefile b/Makefile index 3e511b5..3e34a4f 100644 --- a/Makefile +++ b/Makefile @@ -124,8 +124,8 @@ golden: ## Regenerate the e2e golden-master screenshots via Docker (linux/amd64, tidy: ## Tidy go.mod / go.sum go mod tidy -security-govulncheck: ## Scan dependencies for known Go vulnerabilities (govulncheck) - govulncheck ./... +security-govulncheck: ## Scan dependencies with the module-pinned govulncheck + go tool govulncheck ./... security-github: ## List open GitHub Dependabot alerts for this repo (needs `gh auth login`) gh api "repos/$$(gh repo view --json nameWithOwner -q .nameWithOwner)/dependabot/alerts" \ @@ -175,10 +175,9 @@ build-linux-all: package-linux ## Alias for package-linux: cross-compile Linux b build-all: package-mac package-windows package-linux ## Build release artifacts for macOS, Windows, and Linux -install-tools: ## Install the fyne, fyne-cross, and govulncheck CLI tools +install-tools: ## Install the fyne and fyne-cross packaging tools go install fyne.io/fyne/v2/cmd/fyne@latest go install github.com/fyne-io/fyne-cross@latest - go install golang.org/x/vuln/cmd/govulncheck@latest install-linux-tools: ## Install apt dev headers needed to build natively on Linux (OpenGL, X11, Wayland; needs sudo) sudo apt-get update diff --git a/README.md b/README.md index c5e0bc1..b972af7 100644 --- a/README.md +++ b/README.md @@ -151,17 +151,18 @@ isn't actually corrupted — to open it anyway: ## Requirements -- Go 1.26.6 or newer (see the `go` directive in [go.mod](go.mod)) +- Go 1.27.1 or newer (see the `go` directive in [go.mod](go.mod)) - A C toolchain for cgo (Fyne's OpenGL bindings require it) — Xcode Command Line Tools on macOS, `gcc` + `libgl1-mesa-dev`/`xorg-dev` on Linux - [Docker](https://www.docker.com/) — used by `make test`/`make verify` so tests and golden comparisons run on Linux/amd64 like CI, and also needed for cross-compilation and `make golden` -- [`govulncheck`](https://go.dev/security/vuln) and the - [GitHub CLI](https://cli.github.com/) (`gh`) — only needed for the - `make security*` targets. `govulncheck` is installed by - `make install-tools`; `gh` must be installed separately (e.g. `brew install - gh`) and authenticated via `gh auth login` +- The [GitHub CLI](https://cli.github.com/) (`gh`) — only needed for + `make security-github` and the combined `make security` target. It must be + installed separately (e.g. `brew install gh`) and authenticated via + `gh auth login`. `make security-govulncheck` runs the repository-pinned + [`govulncheck`](https://go.dev/security/vuln) through Go, with no separate + installation required ## Running @@ -183,7 +184,7 @@ list them. | `make package-windows` | Windows `.exe` files, cross-compiled via `fyne-cross`/Docker, to `bin/picfetch-windows-.exe` | | `make package-linux` | Linux binaries, cross-compiled via `fyne-cross`/Docker, to `bin/picfetch-linux-` | | `make build-all` | Runs `package-mac`, `package-windows`, and `package-linux` | -| `make install-tools` | Installs the `fyne`, `fyne-cross`, and `govulncheck` CLIs used by the package/security targets | +| `make install-tools` | Installs the `fyne` and `fyne-cross` CLIs used by the packaging targets | Packaging is done with the [`fyne`](https://pkg.go.dev/fyne.io/fyne/v2/cmd/fyne) CLI (native OS builds) and [`fyne-cross`](https://github.com/fyne-io/fyne-cross) @@ -223,7 +224,7 @@ packaged build. | `make verify` | The same gate CI runs; its race-test step uses the `make test` Linux/amd64 container | | `make tidy` | `go mod tidy` — tidy go.mod / go.sum | | `make security` | Run all security checks (govulncheck + GitHub Dependabot alerts) | -| `make security-govulncheck` | Scan dependencies for known Go vulnerabilities with `govulncheck` | +| `make security-govulncheck` | Scan dependencies with the repository-pinned `govulncheck` | | `make security-github` | List open GitHub Dependabot alerts via `gh` (needs `gh auth login`) | | `make clean` | Remove `bin/`, `fyne-cross/`, and any stray packaged app/zip | @@ -231,6 +232,9 @@ packaged build. > (`gh`) to be installed and authenticated (`gh auth login`), and it must be run > from a checkout with a GitHub `origin` remote. +`make security-govulncheck` invokes the version declared as a tool dependency +in [go.mod](go.mod), so its first run may download that pinned module. + ### Releasing ```sh diff --git a/plans/2026-08-31-open-side-by-side-comparison.md b/finished_refactorings/2026-08-31-open-side-by-side-comparison.md similarity index 100% rename from plans/2026-08-31-open-side-by-side-comparison.md rename to finished_refactorings/2026-08-31-open-side-by-side-comparison.md diff --git a/plans/2026-09-01-add-swipe-comparison.md b/finished_refactorings/2026-09-01-add-swipe-comparison.md similarity index 100% rename from plans/2026-09-01-add-swipe-comparison.md rename to finished_refactorings/2026-09-01-add-swipe-comparison.md diff --git a/plans/2026-09-01-ctrl-l-comparison-link-toggle.md b/finished_refactorings/2026-09-01-ctrl-l-comparison-link-toggle.md similarity index 100% rename from plans/2026-09-01-ctrl-l-comparison-link-toggle.md rename to finished_refactorings/2026-09-01-ctrl-l-comparison-link-toggle.md diff --git a/plans/2026-09-01-identify-and-swap-images.md b/finished_refactorings/2026-09-01-identify-and-swap-images.md similarity index 100% rename from plans/2026-09-01-identify-and-swap-images.md rename to finished_refactorings/2026-09-01-identify-and-swap-images.md diff --git a/plans/2026-09-01-isolate-comparison-commands.md b/finished_refactorings/2026-09-01-isolate-comparison-commands.md similarity index 100% rename from plans/2026-09-01-isolate-comparison-commands.md rename to finished_refactorings/2026-09-01-isolate-comparison-commands.md diff --git a/plans/2026-09-01-link-side-by-side-zoom-and-pan.md b/finished_refactorings/2026-09-01-link-side-by-side-zoom-and-pan.md similarity index 100% rename from plans/2026-09-01-link-side-by-side-zoom-and-pan.md rename to finished_refactorings/2026-09-01-link-side-by-side-zoom-and-pan.md diff --git a/plans/2026-09-01-preserve-comparison-state.md b/finished_refactorings/2026-09-01-preserve-comparison-state.md similarity index 100% rename from plans/2026-09-01-preserve-comparison-state.md rename to finished_refactorings/2026-09-01-preserve-comparison-state.md diff --git a/plans/2026-09-01-preserve-source-fidelity.md b/finished_refactorings/2026-09-01-preserve-source-fidelity.md similarity index 100% rename from plans/2026-09-01-preserve-source-fidelity.md rename to finished_refactorings/2026-09-01-preserve-source-fidelity.md diff --git a/plans/2026-09-01-temporary-control-unlink-comparison.md b/finished_refactorings/2026-09-01-temporary-control-unlink-comparison.md similarity index 100% rename from plans/2026-09-01-temporary-control-unlink-comparison.md rename to finished_refactorings/2026-09-01-temporary-control-unlink-comparison.md diff --git a/plans/2026-09-02-comparison-link-button.md b/finished_refactorings/2026-09-02-comparison-link-button.md similarity index 100% rename from plans/2026-09-02-comparison-link-button.md rename to finished_refactorings/2026-09-02-comparison-link-button.md diff --git a/finished_refactorings/2026-09-02-go-1-27-security-refresh.md b/finished_refactorings/2026-09-02-go-1-27-security-refresh.md new file mode 100644 index 0000000..aa2b7a0 --- /dev/null +++ b/finished_refactorings/2026-09-02-go-1-27-security-refresh.md @@ -0,0 +1,92 @@ +# Go 1.27.1 and security dependency refresh + +Status: complete + +Route: Standard. This changes the module graph, project tooling, contributor +requirements, and release notes without changing application behavior or +package architecture. + +Deliverable: PicFetch requires Go 1.27.1, uses Rekor's maintained OpenPGP +implementation, and runs a repository-pinned govulncheck successfully. + +## Locked decisions + +| Decision | Contract | +|---|---| +| Go baseline | `go.mod` and active setup documentation require Go 1.27.1. | +| OpenPGP remediation | Upgrade Rekor to v1.5.4 and accept only dependency changes required by that patch and module tidying. | +| Scanner | Pin `golang.org/x/vuln` v1.7.0 as a Go tool and invoke it with `go tool govulncheck`. | +| Residual advisory | Keep latest `golang.org/x/crypto` because PicFetch needs unaffected packages; do not suppress GO-2026-5932 or replace Sigstore. | +| Scope | No application code, package layout, architecture record, workflow, or historical plan changes. | + +## Tasks + +### Task 1 - Refresh the module and security tool graph + +Owner: T0 inline + +Files: `go.mod`, `go.sum` + +Upgrade the Go directive and Rekor, add the pinned govulncheck tool dependency, +and run `go mod tidy`. + +Verify: `go mod tidy -diff && go mod verify && go mod why golang.org/x/crypto/openpgp` + +### Task 2 - Use the pinned scanner + +Owner: T0 inline + +Files: `Makefile` + +Run govulncheck through `go tool` and remove its redundant global install. + +Verify: `make security-govulncheck` + +### Task 3 - Align active documentation and land the change + +Owner: T0 inline + +Files: `README.md`, `.github/CONTRIBUTING.md`, `todos.md`, this plan + +Document the Go baseline, pinned scanner workflow, Rekor remediation, and the +accepted module-only advisory. + +Verify: `make verify` + +## Budget and gate + +Zero spawns; at most two review rounds; one full suite. The final security gate +also runs `go tool govulncheck -show verbose ./...` and confirms that +GO-2026-5932 remains module-only with no imported package or reachable symbol. + +## Outcome + +PicFetch now requires Go 1.27.1. Rekor v1.5.4 removes the unmaintained +`x/crypto/openpgp` package from the dependency path, while govulncheck v1.7.0 +is pinned beside goimports and runs through `go tool` without a global binary. + +The scanner reports no reachable or imported vulnerabilities. GO-2026-5932 +remains visible only at module granularity because unaffected packages from the +latest `x/crypto` module are still required and the advisory has no fixed +version. + +## Cost ledger + +| Task | Spawns budget/actual | Review rounds | Full suite | Notes | +|---|---:|---:|---|---| +| T1 | 0 / 0 | 1 | no | Go, Rekor, govulncheck, and the tidied module graph complete. | +| T2 | 0 / 0 | 1 | no | Pinned scanner target and packaging-tool install contract complete. | +| T3 | 0 / 0 | 1 | no | Active setup docs and release notes aligned. | +| gate | - | - | - | yes | `make verify` passed. | + +## Verification record + +- `go mod tidy -diff` produced no diff, `go mod verify` passed, and `go mod + why golang.org/x/crypto/openpgp` reported that the main module does not need + the package. +- `make security-govulncheck` passed with zero reachable vulnerabilities. +- `go tool govulncheck -show verbose ./...` reported zero symbol and package + vulnerabilities and only GO-2026-5932 at module level (`Fixed in: N/A`). +- `make verify` passed formatting, TUF root validation, vet, build, and the + Linux/amd64 race suite (`internal/ui` 686.351s; `internal/ui/compare` + 28.099s). diff --git a/plans/2026-09-02-inert-comparison-link-toggle.md b/finished_refactorings/2026-09-02-inert-comparison-link-toggle.md similarity index 100% rename from plans/2026-09-02-inert-comparison-link-toggle.md rename to finished_refactorings/2026-09-02-inert-comparison-link-toggle.md diff --git a/plans/2026-09-02-tiled-gpu-comparison-renderer.md b/finished_refactorings/2026-09-02-tiled-gpu-comparison-renderer.md similarity index 100% rename from plans/2026-09-02-tiled-gpu-comparison-renderer.md rename to finished_refactorings/2026-09-02-tiled-gpu-comparison-renderer.md diff --git a/go.mod b/go.mod index 6ff0326..14c42de 100644 --- a/go.mod +++ b/go.mod @@ -1,6 +1,6 @@ module github.com/frathe/picfetch -go 1.26.7 +go 1.27.1 require ( fyne.io/fyne/v2 v2.8.0 @@ -25,7 +25,6 @@ require ( github.com/FyshOS/fancyfs v0.0.1 // indirect github.com/anthonynsimon/bild v0.17.0 // indirect github.com/asaskevich/govalidator v0.0.0-20230301143203-a9d515a09cc2 // indirect - github.com/blang/semver v3.5.1+incompatible // indirect github.com/cenkalti/backoff/v5 v5.0.3 // indirect github.com/cespare/xxhash/v2 v2.3.0 // indirect github.com/clipperhouse/uax29/v2 v2.7.0 // indirect @@ -41,29 +40,25 @@ require ( github.com/go-gl/glfw/v3.4/glfw v0.1.0-pre.1.0.20260707082822-2a407d02d01a // indirect github.com/go-logr/logr v1.4.4 // indirect github.com/go-logr/stdr v1.2.2 // indirect - github.com/go-openapi/analysis v0.25.5 // indirect + github.com/go-openapi/analysis v0.26.0 // indirect github.com/go-openapi/errors v0.22.8 // indirect github.com/go-openapi/jsonpointer v1.0.0 // indirect github.com/go-openapi/jsonreference v1.0.0 // indirect - github.com/go-openapi/loads v0.25.0 // indirect + github.com/go-openapi/loads v0.25.1 // indirect github.com/go-openapi/runtime v0.33.0 // indirect github.com/go-openapi/runtime/server-middleware v0.30.0 // indirect github.com/go-openapi/spec v0.22.9 // indirect github.com/go-openapi/strfmt v0.27.0 // indirect - github.com/go-openapi/swag v0.26.1 // indirect - github.com/go-openapi/swag/cmdutils v0.27.0 // indirect - github.com/go-openapi/swag/conv v0.27.3 // indirect - github.com/go-openapi/swag/fileutils v0.27.3 // indirect - github.com/go-openapi/swag/jsonname v0.26.1 // indirect - github.com/go-openapi/swag/jsonutils v0.27.3 // indirect - github.com/go-openapi/swag/loading v0.27.3 // indirect - github.com/go-openapi/swag/mangling v0.27.3 // indirect - github.com/go-openapi/swag/netutils v0.27.0 // indirect - github.com/go-openapi/swag/pools v0.27.3 // indirect - github.com/go-openapi/swag/stringutils v0.27.3 // indirect - github.com/go-openapi/swag/typeutils v0.27.3 // indirect - github.com/go-openapi/swag/yamlutils v0.27.3 // indirect - github.com/go-openapi/validate v0.26.1 // indirect + github.com/go-openapi/swag/conv v0.28.0 // indirect + github.com/go-openapi/swag/fileutils v0.28.0 // indirect + github.com/go-openapi/swag/jsonutils v0.28.0 // indirect + github.com/go-openapi/swag/loading v0.28.0 // indirect + github.com/go-openapi/swag/mangling v0.28.0 // indirect + github.com/go-openapi/swag/pools v0.28.0 // indirect + github.com/go-openapi/swag/stringutils v0.28.0 // indirect + github.com/go-openapi/swag/typeutils v0.28.0 // indirect + github.com/go-openapi/swag/yamlutils v0.28.0 // indirect + github.com/go-openapi/validate v0.26.3 // indirect github.com/go-text/render v0.2.1 // indirect github.com/go-text/typesetting v0.3.4 // indirect github.com/go-viper/mapstructure/v2 v2.5.0 // indirect @@ -88,7 +83,7 @@ require ( github.com/secure-systems-lab/go-securesystemslib v0.11.0 // indirect github.com/shibumi/go-pathspec v1.3.0 // indirect github.com/sigstore/protobuf-specs v0.5.1 // indirect - github.com/sigstore/rekor v1.5.3 // indirect + github.com/sigstore/rekor v1.5.4 // indirect github.com/sigstore/rekor-tiles/v2 v2.3.0 // indirect github.com/sigstore/timestamp-authority/v2 v2.1.3 // indirect github.com/srwiley/oksvg v0.0.0-20221011165216-be6e8873101c // indirect @@ -111,11 +106,15 @@ require ( golang.org/x/term v0.45.0 // indirect golang.org/x/text v0.41.0 // indirect golang.org/x/tools v0.49.0 // indirect + golang.org/x/vuln v1.7.0 // indirect google.golang.org/genproto/googleapis/api v0.0.0-20260727163830-6c54dddc4772 // indirect google.golang.org/genproto/googleapis/rpc v0.0.0-20260720155508-bb71a54f79dc // indirect google.golang.org/grpc v1.83.2 // indirect - google.golang.org/protobuf v1.36.11 // indirect + google.golang.org/protobuf v1.36.12 // indirect k8s.io/klog/v2 v2.140.0 // indirect ) -tool golang.org/x/tools/cmd/goimports +tool ( + golang.org/x/tools/cmd/goimports + golang.org/x/vuln/cmd/govulncheck +) diff --git a/go.sum b/go.sum index e0c033f..d6f7e07 100644 --- a/go.sum +++ b/go.sum @@ -1,3 +1,5 @@ +al.essio.dev/pkg/shellescape v1.5.1 h1:86HrALUujYS/h+GtqoB26SBEdkWfmMI6FubjXlsXyho= +al.essio.dev/pkg/shellescape v1.5.1/go.mod h1:6sIqp7X2P6mThCQ7twERpZTuigpr6KbZWtls1U8I890= cloud.google.com/go v0.123.0 h1:2NAUJwPR47q+E35uaJeYoNhuNEM9kM8SjgRgdeOJUSE= cloud.google.com/go v0.123.0/go.mod h1:xBoMV08QcqUGuPW65Qfm1o9Y4zKZBpGS+7bImXLTAZU= cloud.google.com/go/auth v0.20.0 h1:kXTssoVb4azsVDoUiF8KvxAqrsQcQtB53DcSgta74CA= @@ -6,12 +8,12 @@ cloud.google.com/go/auth/oauth2adapt v0.2.8 h1:keo8NaayQZ6wimpNSmW5OPc283g65QNIi cloud.google.com/go/auth/oauth2adapt v0.2.8/go.mod h1:XQ9y31RkqZCcwJWNSx2Xvric3RrU88hAYYbjDWYDL+c= cloud.google.com/go/compute/metadata v0.9.0 h1:pDUj4QMoPejqq20dK0Pg2N4yG9zIkYGdBtwLoEkH9Zs= cloud.google.com/go/compute/metadata v0.9.0/go.mod h1:E0bWwX5wTnLPedCKqk3pJmVgCBSM6qQI1yTBdEb3C10= -cloud.google.com/go/iam v1.11.0 h1:KieQ9Pb+LLPak1O3Rv3GgCxhnmkYf7Xyh0P5HfF1jFM= -cloud.google.com/go/iam v1.11.0/go.mod h1:KP+nKGugNJW4LcLx1uEZcq1ok5sQHFaQehQNl4QDgV4= -cloud.google.com/go/kms v1.31.0 h1:LS8N92OxFDgOLg5NCo3OmbvjtQAIVT5gUHVLKIDHaFE= -cloud.google.com/go/kms v1.31.0/go.mod h1:YIyXZym11R5uovJJt4oN5eUL3oPmirF3yKeIh6QAf4U= -cloud.google.com/go/longrunning v1.0.0 h1:lwzWEYD8+NkYV7dhexOz6kmlvajZA70+bW/xMhRVVdY= -cloud.google.com/go/longrunning v1.0.0/go.mod h1:8nqFBPOO1U/XkhWl0I19AMZEphrHi73VNABIpKYaTwM= +cloud.google.com/go/iam v1.13.0 h1:ufT3FPT5rFFXu6UtLkNoxaOaV5EuA1dsSkmemCSTo6U= +cloud.google.com/go/iam v1.13.0/go.mod h1:gHXdDEiPDvqd1q1KwBDGQlgZY/BwY760zU2LhOZS5w0= +cloud.google.com/go/kms v1.33.0 h1:pG0X78m212b2pv9N4fdMoUO69LuZGQ9kSvn8sHBOFAo= +cloud.google.com/go/kms v1.33.0/go.mod h1:CSGvW6GnMQbY+1nOHcIzhMtHSbExXlOmCKjWtYVjcpA= +cloud.google.com/go/longrunning v1.2.0 h1:WjYH3YHBGCxGJP9M4dWGHBfXr/cFIjMkNgWcJj7/iMM= +cloud.google.com/go/longrunning v1.2.0/go.mod h1:5KMQALFGOCtFoi2xSOA1u3H7WKlhmckgiyFw7+LGQp0= filippo.io/edwards25519 v1.2.0 h1:crnVqOiS4jqYleHd9vaKZ+HKtHfllngJIiOpNpoJsjo= filippo.io/edwards25519 v1.2.0/go.mod h1:xzAOLCNug/yB62zG1bQ8uziwrIqIuxhctzJT18Q77mc= filippo.io/mldsa v0.0.0-20260215214346-43d0283efc3e h1:VsUbObBMxXlc23Eb9VeeJYE4jvTs87qa5RqSN2U5FJU= @@ -24,60 +26,58 @@ fyne.io/x/fyne v0.0.0-20260712112324-6989f2f174fb h1:oa8Pqo2Xis8dWEB5sQRLL4hbwB8 fyne.io/x/fyne v0.0.0-20260712112324-6989f2f174fb/go.mod h1:UzabvSVT4msa76BU2Mw95m8i3yThjwhZyugBZ5Wh0hs= github.com/AdamKorcz/go-fuzz-headers-1 v0.0.0-20230919221257-8b5d3ce2d11d h1:zjqpY4C7H15HjRPEenkS4SAn3Jy2eRRjkjZbGR30TOg= github.com/AdamKorcz/go-fuzz-headers-1 v0.0.0-20230919221257-8b5d3ce2d11d/go.mod h1:XNqJ7hv2kY++g8XEHREpi+JqZo3+0l+CH2egBVN4yqM= -github.com/Azure/azure-sdk-for-go/sdk/azcore v1.21.1 h1:jHb/wfvRikGdxMXYV3QG/SzUOPYN9KEUUuC0Yd0/vC0= -github.com/Azure/azure-sdk-for-go/sdk/azcore v1.21.1/go.mod h1:pzBXCYn05zvYIrwLgtK8Ap8QcjRg+0i76tMQdWN6wOk= -github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.13.1 h1:Hk5QBxZQC1jb2Fwj6mpzme37xbCDdNTxU7O9eb5+LB4= -github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.13.1/go.mod h1:IYus9qsFobWIc2YVwe/WPjcnyCkPKtnHAqUYeebc8z0= +github.com/Azure/azure-sdk-for-go/sdk/azcore v1.22.0 h1:aokoqcHvaGjiM3VpjKDfMMnF/8epJ+Q1HLJ7CudztqE= +github.com/Azure/azure-sdk-for-go/sdk/azcore v1.22.0/go.mod h1:/WYEx9pcM9Y+Dd/APJaNlSvVSvzl54rrMdZT5+Oi2LM= +github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.14.0 h1:CU4+EJeJi3TKYWEcYuSdWsjzw0nVsK/H0MSQOiPcymU= +github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.14.0/go.mod h1:q0+UTSRvShwUCrR/s5HtyInYphN7Wvxb7snFM3u+SLA= github.com/Azure/azure-sdk-for-go/sdk/internal v1.12.0 h1:fhqpLE3UEXi9lPaBRpQ6XuRW0nU7hgg4zlmZZa+a9q4= github.com/Azure/azure-sdk-for-go/sdk/internal v1.12.0/go.mod h1:7dCRMLwisfRH3dBupKeNCioWYUZ4SS09Z14H+7i8ZoY= github.com/Azure/azure-sdk-for-go/sdk/security/keyvault/azkeys v1.5.0 h1:MaKvxE6D0KkjOg6Wd9M00iqP5PR0kUxCfiezes4JweM= github.com/Azure/azure-sdk-for-go/sdk/security/keyvault/azkeys v1.5.0/go.mod h1:i2h9fsTFKZorh8RdV2IcSUf/Qj98GlTkrTvUbX/s8as= github.com/Azure/azure-sdk-for-go/sdk/security/keyvault/internal v1.2.0 h1:nCYfgcSyHZXJI8J0IWE5MsCGlb2xp9fJiXyxWgmOFg4= github.com/Azure/azure-sdk-for-go/sdk/security/keyvault/internal v1.2.0/go.mod h1:ucUjca2JtSZboY8IoUqyQyuuXvwbMBVwFOm0vdQPNhA= -github.com/AzureAD/microsoft-authentication-library-for-go v1.7.0 h1:4iB+IesclUXdP0ICgAabvq2FYLXrJWKx1fJQ+GxSo3Y= -github.com/AzureAD/microsoft-authentication-library-for-go v1.7.0/go.mod h1:HKpQxkWaGLJ+D/5H8QRpyQXA1eKjxkFlOMwck5+33Jk= +github.com/AzureAD/microsoft-authentication-library-for-go v1.7.2 h1:RHK7bS+HQMslb1sZpAokUt+zTVmue0hKSs2C791hhzU= +github.com/AzureAD/microsoft-authentication-library-for-go v1.7.2/go.mod h1:HKpQxkWaGLJ+D/5H8QRpyQXA1eKjxkFlOMwck5+33Jk= github.com/BurntSushi/toml v1.6.0 h1:dRaEfpa2VI55EwlIW72hMRHdWouJeRF7TPYhI+AUQjk= github.com/BurntSushi/toml v1.6.0/go.mod h1:ukJfTF/6rtPPRCnwkur4qwRxa8vTRFBF0uk2lLoLwho= github.com/FyshOS/fancyfs v0.0.1 h1:kgvm7VvwOMLkYTqSflplp62SlMVWQ2uAoHw9CXwXHYg= github.com/FyshOS/fancyfs v0.0.1/go.mod h1:S5SHVz/5R72iCXOxCqdcyTPSlg3JxNd0gaHyGBSrY8A= -github.com/alessio/shellescape v1.4.1 h1:V7yhSDDn8LP4lc4jS8pFkt0zCnzVJlG5JXy9BVKJUX0= -github.com/alessio/shellescape v1.4.1/go.mod h1:PZAiSCk0LJaZkiCSkPv8qIobYglO3FPpyFjDCtHLS30= +github.com/ProtonMail/go-crypto v1.4.1 h1:9RfcZHqEQUvP8RzecWEUafnZVtEvrBVL9BiF67IQOfM= +github.com/ProtonMail/go-crypto v1.4.1/go.mod h1:e1OaTyu5SYVrO9gKOEhTc+5UcXtTUa+P3uLudwcgPqo= github.com/anthonynsimon/bild v0.17.0 h1:kmPJOZpUgvrM2uoS7KMesbDU5+QTvZ92zIBjHM/oa18= github.com/anthonynsimon/bild v0.17.0/go.mod h1:ULwssBwK+8dLFObGrI3fIydKYQ2l454Y0eo+mqPclto= github.com/asaskevich/govalidator v0.0.0-20230301143203-a9d515a09cc2 h1:DklsrG3dyBCFEj5IhUbnKptjxatkF07cF2ak3yi77so= github.com/asaskevich/govalidator v0.0.0-20230301143203-a9d515a09cc2/go.mod h1:WaHUgvxTVq04UNunO+XhnAqY/wQc+bxr74GqbsZ/Jqw= -github.com/aws/aws-sdk-go-v2 v1.41.9 h1:/rYeyO2+HrMztAmxAq9++XJtFMqSIpSsNA0yDGALYq4= -github.com/aws/aws-sdk-go-v2 v1.41.9/go.mod h1:+HsoOEX80qAVUitj1A2DhCNTjmb3edVyuDypb6LNEeo= -github.com/aws/aws-sdk-go-v2/config v1.32.20 h1:8VMDnWc/kEzxsI/1ngGM9mG81a8IGmIHD8KLcYGwagc= -github.com/aws/aws-sdk-go-v2/config v1.32.20/go.mod h1:PuwEpciweIXGULWeOeSTXtSbH4CW9mWdWrhdCKQI1sM= -github.com/aws/aws-sdk-go-v2/credentials v1.19.19 h1:yuFzSV1U0aRNYCQGVaTY2zW2M/L93pYHnXnrJUphYhU= -github.com/aws/aws-sdk-go-v2/credentials v1.19.19/go.mod h1:7y63L1kGzeoDlJaQ3Z578KrnmfBut96JjvJUzGwR+YE= -github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.18.25 h1:0w6dCiO8iez+YKwRhRBlL1CH/E3GTfdkuzrwj1by8vo= -github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.18.25/go.mod h1:9FDWUothyr5RCRAHc45XOiVCzUR8n/IhCYX+uVqw6vk= -github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.25 h1:Uii3frf9ztec/ABM2/FSH9/z7PLzxfpG8h4RpkUFflQ= -github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.25/go.mod h1:G6kntsA2GorAxDPbap6xgB2F+amSLUF8GJTi7PUoX44= -github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.25 h1:r1+/l6m+WaUJF9HISEsNOLHSNj5EXYQxK8VX6Cz9NlA= -github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.25/go.mod h1:cKf+D+NMDK1LndD7BowHbBZPgR9V0/5HubH0PFWvA+c= -github.com/aws/aws-sdk-go-v2/internal/v4a v1.4.26 h1:A1PmWU2zfkIm9EyFlJncFXL4W4phML+h8KjltUsCvNQ= -github.com/aws/aws-sdk-go-v2/internal/v4a v1.4.26/go.mod h1:dY4MRzXEizrD4hqtpKvWVGPX7QleSGGVY+EBolo1RmM= -github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.10 h1:d5/908OJ4bXg8lyjeMPvXetEKqoDoLi5Owy1zNue3yg= -github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.10/go.mod h1:a57l7Hwh+FWI+we50g5NPJHYUKeJKfXbc4w8SyXu8Ig= -github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.25 h1:dD3dhHNglpd98gs72my22Ndqi1hqQGllFFg1F+twfxg= -github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.25/go.mod h1:0yAbjPfd64gG7mj85RW+fMEYdfBgCRZw8g/oWcL1pjc= -github.com/aws/aws-sdk-go-v2/service/kms v1.52.0 h1:QNtg+Mtj1zmepk568+UKBD5DFfqh+ESTUUqQT27JkQc= -github.com/aws/aws-sdk-go-v2/service/kms v1.52.0/go.mod h1:Y0+uxvxz6ib4KktRdK0V4X45Vcs/JyYoz8H71pO8xeI= -github.com/aws/aws-sdk-go-v2/service/signin v1.1.1 h1:1VwbP3qMNfxUDEXWki4rCE5iA+44VA1lokTz9HasGzw= -github.com/aws/aws-sdk-go-v2/service/signin v1.1.1/go.mod h1:vUtyoSj0OPji3kjIVSc/GlKuWEiL33f/WFxl6dmpy/A= -github.com/aws/aws-sdk-go-v2/service/sso v1.30.19 h1:N6pIsdFOW1Kd9S4KyFKXdGRBojPPxkP32+uHFWLv4Hc= -github.com/aws/aws-sdk-go-v2/service/sso v1.30.19/go.mod h1:3gt5WJArFooNmyLONS+h/R4J+o86II8du38IgCwj9dE= -github.com/aws/aws-sdk-go-v2/service/ssooidc v1.36.2 h1:hc+lBYiiTr8Zk4MTzIsQ92MeDWCIDvWGmzKUWOaBcOg= -github.com/aws/aws-sdk-go-v2/service/ssooidc v1.36.2/go.mod h1:hU6fqB3OJA6/ePheD47LQnxvjYk6br6PtQxs+Q9ojvk= -github.com/aws/aws-sdk-go-v2/service/sts v1.42.3 h1:ErklX/7uhSbkAAeyQD/Y1OoQ9hO3SJXQNEgksORW3Js= -github.com/aws/aws-sdk-go-v2/service/sts v1.42.3/go.mod h1:ULe4HCzfKPiR6R3HEurE3b1upEkuk8AkMrOKtaOxKO8= -github.com/aws/smithy-go v1.26.0 h1:9ouqbi+NyKP7fV3Te7UElCwdAb6Y8uk7LGwPE5tVe/s= -github.com/aws/smithy-go v1.26.0/go.mod h1:YE2RhdIuDbA5E5bTdciG9KrW3+TiEONeUWCqxX9i1Fc= -github.com/blang/semver v3.5.1+incompatible h1:cQNTCjp13qL8KC3Nbxr/y2Bqb63oX6wdnnjpJbkM4JQ= -github.com/blang/semver v3.5.1+incompatible/go.mod h1:kRBLl5iJ+tD4TcOOxsy/0fnwebNt5EWlYSAyrTnjyyk= +github.com/aws/aws-sdk-go-v2 v1.43.0 h1:fharf/WhbRAVZ1du0QL7roNFxZ6T/sWr+4Ni617bwSI= +github.com/aws/aws-sdk-go-v2 v1.43.0/go.mod h1:5pKeft2eJj+gElQ38Jqg4ibCqh+/AK33/0X3hip7IjM= +github.com/aws/aws-sdk-go-v2/config v1.32.31 h1:n4nY9O3QKoHIkL85EX+V8RcMFtOhlpTFhGArg915PXk= +github.com/aws/aws-sdk-go-v2/config v1.32.31/go.mod h1:PN0NYDCCoOpGGsZ2+elDUidmHfQBPyYzN2GCgl8HEBs= +github.com/aws/aws-sdk-go-v2/credentials v1.19.30 h1:TTCvvzFU6gXa4iJecNG/0F/B0oYTiazoRECr2XyLHrY= +github.com/aws/aws-sdk-go-v2/credentials v1.19.30/go.mod h1:jKxAp2AEncnliinzpgOSZDFv6+VjvWhjw/AtbfsWT9U= +github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.18.31 h1:kfVL5wAunCJycL6MOQ6aNh6PlAYEymflcjuKmrWUA0o= +github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.18.31/go.mod h1:nWfRNDAppujCQgOUd43lKT4yeLv9z3nJ3bw1G3BgQKo= +github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.31 h1:Z8F3hfCY33IGpJjFAnv0wvtv1FIKj1GHmRDEYqy64tw= +github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.31/go.mod h1:aVyUoytEyOViR6jhq6jula0xkc5NfBE2hgeF6BvOrao= +github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.31 h1:hyOxUyXdh3AyjE93gBgsfziJag9ACwcs+ZpDBLzi8mw= +github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.31/go.mod h1:OERqI9k0draSLB8O8woxY3q25ZWTELRK4RRoLMuMZFo= +github.com/aws/aws-sdk-go-v2/internal/v4a v1.4.32 h1:0MrUL35H/Y4kdFfItoR5jCgtDQ4Z/8LudAoIHRfA4hE= +github.com/aws/aws-sdk-go-v2/internal/v4a v1.4.32/go.mod h1:2tNZkuWz54arj8mHVf+8Y7cKkcD8Wr/fBpENgEXpjLc= +github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.13 h1:mbRIur/BiHK6SKPjoBIXSE/hJ6g6JGRLuxQy1jGjlN4= +github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.13/go.mod h1:ITg9em2KbJx1s0y4aqRX5OYWG6HBZ5TVR//OdpEZ2CQ= +github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.31 h1:w2SIhW92DZPFrSL4ksVCr8IYff5OZwIcxg8+95tzvAI= +github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.31/go.mod h1:wAhpCQbkov+IcvjozJbd2xRCoZybUEHNkcFunssNACg= +github.com/aws/aws-sdk-go-v2/service/kms v1.55.0 h1:uB8ymkVosyourmGXCZHyWhJ4wuKA4xq3ii2dVMPtBZY= +github.com/aws/aws-sdk-go-v2/service/kms v1.55.0/go.mod h1:rK4RITSY/qJw3qVJ7p19fceOWuvrisqqOChFkX05n5I= +github.com/aws/aws-sdk-go-v2/service/signin v1.5.0 h1:OHH5iTQvVGmfHjX/5Q+vFuA/Rf2x6/95aJ/75QCQSm4= +github.com/aws/aws-sdk-go-v2/service/signin v1.5.0/go.mod h1:mCF3AK9PpL49oOrhniUXWAfhVBVQ/XbytoE5eccZUIs= +github.com/aws/aws-sdk-go-v2/service/sso v1.33.0 h1:CaJyYhxBE0M/HJX/YvSaSmQlsI91VHB0lKU8LtLxL3A= +github.com/aws/aws-sdk-go-v2/service/sso v1.33.0/go.mod h1:+e6BMRMPjBQoCw/WovYR9GLy2IU0z4Q77smOB1DraSg= +github.com/aws/aws-sdk-go-v2/service/ssooidc v1.38.0 h1:tC323YV77QdafeBr6LUhLDTsboyuyHLNRwAyCP44kGU= +github.com/aws/aws-sdk-go-v2/service/ssooidc v1.38.0/go.mod h1:SfLK1sgviHmbI+MozR9iDwDjL4cdCVZtahsjoR+z7wg= +github.com/aws/aws-sdk-go-v2/service/sts v1.45.0 h1:Pd6PNlp4t8PTXxqzstICl52Wsy78vpjFZ7PRUj44mJc= +github.com/aws/aws-sdk-go-v2/service/sts v1.45.0/go.mod h1:rmQ0TnHzuLPmabgjPcsywhsSOmaBDgzR4zvDxSPsGdg= +github.com/aws/smithy-go v1.27.3 h1:F3Zb497UhhskkfpJmfkXswyo+t0sh9OTBnIHjogWbVY= +github.com/aws/smithy-go v1.27.3/go.mod h1:YE2RhdIuDbA5E5bTdciG9KrW3+TiEONeUWCqxX9i1Fc= github.com/cenkalti/backoff/v4 v4.3.0 h1:MyRJ/UdXutAwSAT+s3wNd7MfTIcy71VQueUuFK343L8= github.com/cenkalti/backoff/v4 v4.3.0/go.mod h1:Y3VNntkOUPxTVeUxJ/G5vcM//AlwfmyYozVcomhLiZE= github.com/cenkalti/backoff/v5 v5.0.3 h1:ZN+IMa753KfX5hd8vVaMixjnqRZ3y8CuJKRKj1xcsSM= @@ -86,14 +86,16 @@ github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UF github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= github.com/clipperhouse/uax29/v2 v2.7.0 h1:+gs4oBZ2gPfVrKPthwbMzWZDaAFPGYK72F0NJv2v7Vk= github.com/clipperhouse/uax29/v2 v2.7.0/go.mod h1:EFJ2TJMRUaplDxHKj1qAEhCtQPW2tJSwu5BF98AuoVM= +github.com/cloudflare/circl v1.6.3 h1:9GPOhQGF9MCYUeXyMYlqTR6a5gTrgR/fBLXvUgtVcg8= +github.com/cloudflare/circl v1.6.3/go.mod h1:2eXP6Qfat4O/Yhh8BznvKnJ+uzEoTQ6jVKJRn81BiS4= github.com/codahale/rfc6979 v0.0.0-20141003034818-6a90f24967eb h1:EDmT6Q9Zs+SbUoc7Ik9EfrFqcylYqgPZ9ANSbTAntnE= github.com/codahale/rfc6979 v0.0.0-20141003034818-6a90f24967eb/go.mod h1:ZjrT6AXHbDs86ZSdt/osfBi5qfexBrKUdONk989Wnk4= github.com/coreos/go-oidc/v3 v3.20.0 h1:EtE0WIBHk03N+DqGkY4+UONzzZHk7amKt6IyNd7OsZE= github.com/coreos/go-oidc/v3 v3.20.0/go.mod h1:DYCf24+ncYi+XkIH97GY1+dqoRlbaSI26KVTCI9SrY4= github.com/cyberphone/json-canonicalization v0.0.0-20241213102144-19d51d7fe467 h1:uX1JmpONuD549D73r6cgnxyUu18Zb7yHAy5AYU0Pm4Q= github.com/cyberphone/json-canonicalization v0.0.0-20241213102144-19d51d7fe467/go.mod h1:uzvlm1mxhHkdfqitSA92i7Se+S9ksOn3a3qmv/kyOCw= -github.com/danieljoos/wincred v1.2.0 h1:ozqKHaLK0W/ii4KVbbvluM91W2H3Sh0BncbUNPS7jLE= -github.com/danieljoos/wincred v1.2.0/go.mod h1:FzQLLMKBFdvu+osBrnFODiv32YGwCfx0SkRa/eYHgec= +github.com/danieljoos/wincred v1.2.2 h1:774zMFJrqaeYCK2W57BgAem/MLi6mtSE47MB6BOJ0i0= +github.com/danieljoos/wincred v1.2.2/go.mod h1:w7w4Utbrz8lqeMbDAK0lkNJUv5sAOkFi7nd/ogr0Uh8= github.com/digitorus/pkcs7 v0.0.0-20230713084857-e76b763bdc49/go.mod h1:SKVExuS+vpu2l9IoOc0RwqE7NYnb0JlcFHFnEJkVDzc= github.com/digitorus/pkcs7 v0.0.0-20230818184609-3a137a874352 h1:ge14PCmCvPjpMQMIAH7uKg0lrtNSOdpYsRXlwk3QbaE= github.com/digitorus/pkcs7 v0.0.0-20230818184609-3a137a874352/go.mod h1:SKVExuS+vpu2l9IoOc0RwqE7NYnb0JlcFHFnEJkVDzc= @@ -121,8 +123,8 @@ github.com/fyne-io/oksvg v0.2.0 h1:mxcGU2dx6nwjJsSA9PCYZDuoAcsZ/OuJlvg/Q9Njfo8= github.com/fyne-io/oksvg v0.2.0/go.mod h1:dJ9oEkPiWhnTFNCmRgEze+YNprJF7YRbpjgpWS4kzoI= github.com/gen2brain/avif v0.6.0 h1:/8WSgcU+IEF0jhKYsUZ/mzlziFuTeJFpIKBj2siTQps= github.com/gen2brain/avif v0.6.0/go.mod h1:QgrYqdVE9y40PCfArK9VakcMIpYeDYpZmCSLkW6C1n8= -github.com/go-chi/chi/v5 v5.3.0 h1:halUjDxhshgXHMrao5bB8eNBXo/rnzwr8m5m36glehM= -github.com/go-chi/chi/v5 v5.3.0/go.mod h1:R+tYY2hNuVUUjxoPtqUdgBqevM9s9njzkTLutVsOCto= +github.com/go-chi/chi/v5 v5.3.1 h1:3j4HZLGZQ3JpMCrPJF/Jl3mYJfWLKBfNJ6quurUGCf8= +github.com/go-chi/chi/v5 v5.3.1/go.mod h1:R+tYY2hNuVUUjxoPtqUdgBqevM9s9njzkTLutVsOCto= github.com/go-gl/gl v0.0.0-20260331235117-4566fea9a276 h1:IO5P06Pcj9K04d+l4nrf3c2U56+dAotIFG6u4P1wAHI= github.com/go-gl/gl v0.0.0-20260331235117-4566fea9a276/go.mod h1:9YTyiznxEY1fVinfM7RvRcjRHbw2xLBJ3AAGIT0I4Nw= github.com/go-gl/glfw/v3.4/glfw v0.1.0-pre.1.0.20260707082822-2a407d02d01a h1:HWK0MBggT/T6YH7VffE10xBIhqeTq8JzIUPJXrRy87g= @@ -134,16 +136,16 @@ github.com/go-logr/logr v1.4.4 h1:tG4xh9yMsRCAiodLVTxyrkzSZ9+o0L1Kg/+cPVcbP/8= github.com/go-logr/logr v1.4.4/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag= github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE= -github.com/go-openapi/analysis v0.25.5 h1:xPYEvTb90o1y0epuiOPAoG4QqahjP3cdp5xNlHeKJRI= -github.com/go-openapi/analysis v0.25.5/go.mod h1:d3UGtQC5uq5Kqqqis2VH09Km/v3vwsWrYkbp4gdm+Rc= +github.com/go-openapi/analysis v0.26.0 h1:1xECln1iMMmQnTjgcknC1vi1hA4KISt6IHpSwnqcuwI= +github.com/go-openapi/analysis v0.26.0/go.mod h1:40gERFi/2dyXA1FaqRRLxkv1IlC6X+GPDNd1xrYAjZE= github.com/go-openapi/errors v0.22.8 h1:oP7sW7TWc3wFFjrzzj0nI83H2qMBkNjNfSd+XRejk/I= github.com/go-openapi/errors v0.22.8/go.mod h1:BuUoHcYrU6E7V9gfj1I5wLQqgtIHnup/alXZ8KdgQ0w= github.com/go-openapi/jsonpointer v1.0.0 h1:kR9tHqY0CtZaOPVFm622dPVNhrvYpwr4uCxgL3h1H8s= github.com/go-openapi/jsonpointer v1.0.0/go.mod h1:Z3rw7dWu1p9IgitXCFamSlA5lmDiklEB6vkaxcNZW5Y= github.com/go-openapi/jsonreference v1.0.0 h1:jlmTr6torcd1YgDQvSfNmRtKzYDO4FGBkrAdlAVWnpY= github.com/go-openapi/jsonreference v1.0.0/go.mod h1:jtwdyGbJk0Xhe5Y+rwtglQP6Sb1WZST4rT32LWB+sv0= -github.com/go-openapi/loads v0.25.0 h1:74Bc2snfaVlsHzwdQj/3gsA9XJz3daXTJVs+4ZaK7jI= -github.com/go-openapi/loads v0.25.0/go.mod h1:JFBw4SIB9+PTIFHDfcXuSSy5h6aWzjtUCrPYyx3qWU8= +github.com/go-openapi/loads v0.25.1 h1:toKQdIDLxlqfKLLGUUmUsiTd5/X0Chzvde9EGYQP/Ac= +github.com/go-openapi/loads v0.25.1/go.mod h1:33Hen4tsKXHL45TyYojvfD5fZUFN4O1y4r/XhsRW2zc= github.com/go-openapi/runtime v0.33.0 h1:Dd3Oj2ig+WH8ckK95l0Wn2V8a4bH/UqWPRZVT0vc8yU= github.com/go-openapi/runtime v0.33.0/go.mod h1:+rsupH3+TFKqmFysqkmgBOTxpVJV8eV+j9myvvea2Xw= github.com/go-openapi/runtime/server-middleware v0.30.0 h1:8rPoJ/xv7JL8BsovaqboKETlpWBArVh8n+0L/GyePog= @@ -153,39 +155,32 @@ github.com/go-openapi/spec v0.22.9/go.mod h1:b/mNUYIOQOyIiUzUzXEE8xzyZqf93KvM9hQ github.com/go-openapi/strfmt v0.27.0 h1:kbcTeaD9TXuXD0hhMXzuYa1sdTo6+dWGvwjW93E80IM= github.com/go-openapi/strfmt v0.27.0/go.mod h1:s/qhDqfY72irigXUGJmtgid2Rm+3tnz3k8hZaRmvWYc= github.com/go-openapi/swag v0.26.1 h1:l5sVEyVpwj+DDYeZyo7wQI/Ebn/mKYIyGB/pFwAfGoQ= -github.com/go-openapi/swag v0.26.1/go.mod h1:yNY38BbIVthxbkDtq1UHBCGasBqjakW3lCR6ANzdBEw= -github.com/go-openapi/swag/cmdutils v0.27.0 h1:aIKiqhB29AaP+7xm8/CPg3uOpeHx2SUp6TvMpu/a31Y= -github.com/go-openapi/swag/cmdutils v0.27.0/go.mod h1:Sm1MVFMkF6guJJ+pQqHnQA3N0j9qALV3NxzDSv6bETM= -github.com/go-openapi/swag/conv v0.27.3 h1:iqJFmGEjmX3AY0lSszABFqRVqOSt99XS0LzNIMJYuhU= -github.com/go-openapi/swag/conv v0.27.3/go.mod h1:nPRmN6jgNme99hpf+nM0auDZGALWIqlwhisKPK/bQhQ= -github.com/go-openapi/swag/fileutils v0.27.3 h1:3UVoZ2RLaIs1lt+2jcKzL8RM3Yk0rmsDE9FLA/HGxFE= -github.com/go-openapi/swag/fileutils v0.27.3/go.mod h1:VvJFZLTZS0AI854gEQz5tk7dBESdLjiNUMSZ/th2ry8= -github.com/go-openapi/swag/jsonname v0.26.1 h1:VReupaV6WxlAsCn0e4DUfgV6bPmINnPpyJDLqSfNPcE= -github.com/go-openapi/swag/jsonname v0.26.1/go.mod h1:OvdW6BoWoj33pTfi7x9vFrgmT+fk7aw0BRwvCE0YOuc= -github.com/go-openapi/swag/jsonutils v0.27.3 h1:1DEz+O82frtSMBcos/7XIn1GnpNTbsD4Bru4Dc/uhRc= -github.com/go-openapi/swag/jsonutils v0.27.3/go.mod h1:qiDCoQvzkMxrV3G8FLEdIU5L+EFYc0zcDOHWT3Yofvo= -github.com/go-openapi/swag/jsonutils/fixtures_test v0.27.3 h1:h/eT9kmGCDdFLJF29lOhzLtF0FmP1AX2MhLJWVebsb8= -github.com/go-openapi/swag/jsonutils/fixtures_test v0.27.3/go.mod h1:mofwUWx70wvskwESqRJ//k/9kURmCgyJl5m5Ppoh5kY= -github.com/go-openapi/swag/loading v0.27.3 h1:L9nQkEgzU7QgFQL+pLEMfGUKxeM4pWwGwbET9Z3weW0= -github.com/go-openapi/swag/loading v0.27.3/go.mod h1:rJ0NeaKsF4CVPnMGjPQl7JlSHzvD0bc2DKXLss1hiuE= -github.com/go-openapi/swag/mangling v0.27.3 h1:gRzzD1PAUoLTtGMgI3KpBmCSOlTuLTFWnviLxLcTnyg= -github.com/go-openapi/swag/mangling v0.27.3/go.mod h1:jtBE2+V+3pILxOR7Vgce+Cwp6A2PgZbvVqfNntbVs0w= -github.com/go-openapi/swag/netutils v0.27.0 h1:lEUG+hHvPvLggB3A8snFk0IRKNf9uC0YKc+7WYqvAF8= -github.com/go-openapi/swag/netutils v0.27.0/go.mod h1:J+WYyFMLtvtCGqa6jLv+YNUmIKI3ZRQRrvfNDMoQoEQ= -github.com/go-openapi/swag/pools v0.27.3 h1:gXjImP3F6/56wRRcFgEPld084Y6u2gs21ikPBt8NKBk= -github.com/go-openapi/swag/pools v0.27.3/go.mod h1:kVQefhSK5RWuRe7BXsL8htgBPAMpN7HDGpGEknqugeE= -github.com/go-openapi/swag/stringutils v0.27.3 h1:Ru28hnbAvN5wycALQYy8IobHvASq+FUFMlp1QzLM0JI= -github.com/go-openapi/swag/stringutils v0.27.3/go.mod h1:lzRN95CxXmA03XcDWHLOb6nOMcxCqR5rGY0lOgsfRoM= -github.com/go-openapi/swag/typeutils v0.27.3 h1:l6SSrx5eR5/WVwrGNzN6bQ9WqL04mrxNBl9YgQ3rcJ4= -github.com/go-openapi/swag/typeutils v0.27.3/go.mod h1:Srm0xFNRZ1Y+vCxJclo5qzx8aj+1pAKda/YfFPrG0dQ= -github.com/go-openapi/swag/yamlutils v0.27.3 h1:cRFCAoYtslYn9L9T0xWryHy1t7c1MACC+DMj3CLvwvs= -github.com/go-openapi/swag/yamlutils v0.27.3/go.mod h1:6JYBGj8sw/NawMllyZY+cTA8Mzk2etS3ZBASdcyPsiU= +github.com/go-openapi/swag/conv v0.28.0 h1:GtqqbyFe7vR5Y7ehxG9W6/OvrSFdf1OLeTGp40TqxH8= +github.com/go-openapi/swag/conv v0.28.0/go.mod h1:mbUE+mzctnhxi864m0Q07SpN8OowD9JhxmxuYvZZD/k= +github.com/go-openapi/swag/fileutils v0.28.0 h1:Z04XWQD7R8Eq+7GnOrjovBxPPmZzsS4gt2H2GPGIViU= +github.com/go-openapi/swag/fileutils v0.28.0/go.mod h1:VvJFZLTZS0AI854gEQz5tk7dBESdLjiNUMSZ/th2ry8= +github.com/go-openapi/swag/jsonutils v0.28.0 h1:YIch6FwO7RXzeAnbO8Tu7dWBZeUEH+4nA0HXltVTnv4= +github.com/go-openapi/swag/jsonutils v0.28.0/go.mod h1:CYM3WlTUcagR2ZoHdz54di/cbBqt82tuxuXgAjxw+mg= +github.com/go-openapi/swag/jsonutils/fixtures_test v0.28.0 h1:qV+VVUAx5Oro8WjVWpZeql7YReTKhT4smR4zhcOQZr0= +github.com/go-openapi/swag/jsonutils/fixtures_test v0.28.0/go.mod h1:mofwUWx70wvskwESqRJ//k/9kURmCgyJl5m5Ppoh5kY= +github.com/go-openapi/swag/loading v0.28.0 h1:td8QZdZC9MIYGGSnSPKShKiK22I2tU5UQvuUhIBPRLU= +github.com/go-openapi/swag/loading v0.28.0/go.mod h1:rXB0QiQX5mMveXEA7ouM4KiiM9jVJe4K6BVbwhD1M4k= +github.com/go-openapi/swag/mangling v0.28.0 h1:pH8eyeNO9SLYsTMWJrurnNfKmDa28XrlA+HePVD53VM= +github.com/go-openapi/swag/mangling v0.28.0/go.mod h1:jtBE2+V+3pILxOR7Vgce+Cwp6A2PgZbvVqfNntbVs0w= +github.com/go-openapi/swag/pools v0.28.0 h1:HPMZWSAfce3rdVTFcjFiCIBtDg9h4x2QlRrHipwhxeU= +github.com/go-openapi/swag/pools v0.28.0/go.mod h1:kVQefhSK5RWuRe7BXsL8htgBPAMpN7HDGpGEknqugeE= +github.com/go-openapi/swag/stringutils v0.28.0 h1:ixsc9iYgDPubHL/8nSkbnryEHpD2VRlBMLKpQyPXcDU= +github.com/go-openapi/swag/stringutils v0.28.0/go.mod h1:lzRN95CxXmA03XcDWHLOb6nOMcxCqR5rGY0lOgsfRoM= +github.com/go-openapi/swag/typeutils v0.28.0 h1:nRBKSBXjDgf01VDPB3fWeD9nQuhCOVeIYAkUx2tbkyY= +github.com/go-openapi/swag/typeutils v0.28.0/go.mod h1:Srm0xFNRZ1Y+vCxJclo5qzx8aj+1pAKda/YfFPrG0dQ= +github.com/go-openapi/swag/yamlutils v0.28.0 h1:TV3JXH6DS46KUroDtMLAYHGkdWf5VDq3wVWFirmzROY= +github.com/go-openapi/swag/yamlutils v0.28.0/go.mod h1:x0q/yndZHEgk9Rx3DyDqzFUmHy55KTvIZldvF2dTJXs= github.com/go-openapi/testify/enable/yaml/v2 v2.6.0 h1:gGHwAJ0R/5jU8BEGDbfRNR3hL68dAVi84WuOApp29B0= github.com/go-openapi/testify/enable/yaml/v2 v2.6.0/go.mod h1:tY+St1SGq4NFl0QIqdTY4aEdbChAHxhyB77XQi9iJCo= github.com/go-openapi/testify/v2 v2.6.0 h1:5PKH2HE7YJ/LuRPQGvSxBRlFXNQhSetBLlGAgUEu3ug= github.com/go-openapi/testify/v2 v2.6.0/go.mod h1:SgsVHtfooshd0tublTtJ50FPKhujf47YRqauXXOUxfw= -github.com/go-openapi/validate v0.26.1 h1:pZSbvtRO8G2R2FpWTYRn3w8LrsNwbtaVhP2dWiBa0Us= -github.com/go-openapi/validate v0.26.1/go.mod h1:B8UMgXiQiwwQWIbmuROlwJZDPGlikPuh7iHV1vPX9Oo= +github.com/go-openapi/validate v0.26.3 h1:OkfZgLvLDnGP2hrRGD+42WBiPWWkoHomTJ+IVI+KaDc= +github.com/go-openapi/validate v0.26.3/go.mod h1:7DOOa4raU6NRe7A8VQSKbm3VcuUIioREYHFt+er9Sk8= github.com/go-test/deep v1.1.1 h1:0r/53hagsehfO4bzD2Pgr/+RgHqhmf+k1Bpse2cTu1U= github.com/go-test/deep v1.1.1/go.mod h1:5C2ZWiW0ErCdrYzpqxLbTX7MG14M9iiw8DgHncVwcsE= github.com/go-text/render v0.2.1 h1:qwHhxqGUjjg4L0XyJWj7M7bpY75NZM+kBpv2Yfw5mcg= @@ -204,24 +199,29 @@ github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps= github.com/google/certificate-transparency-go v1.3.3 h1:hq/rSxztSkXN2tx/3jQqF6Xc0O565UQPdHrOWvZwybo= github.com/google/certificate-transparency-go v1.3.3/go.mod h1:iR17ZgSaXRzSa5qvjFl8TnVD5h8ky2JMVio+dzoKMgA= +github.com/google/go-cmdtest v0.4.1-0.20220921163831-55ab3332a786 h1:rcv+Ippz6RAtvaGgKxc+8FQIpxHgsF+HBzPyYL2cyVU= +github.com/google/go-cmdtest v0.4.1-0.20220921163831-55ab3332a786/go.mod h1:apVn/GCasLZUVpAJ6oWAuyP7Ne7CEsQbTnc0plM3m+o= github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8= github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU= github.com/google/go-containerregistry v0.21.7 h1:/vPFuVXDjtFREsVArW+0h1CIl5urnOhzei4X2DMW9IU= github.com/google/go-containerregistry v0.21.7/go.mod h1:kjSbt7/zMsKLWfnHrIvKvhXHUw91jbe9DNjPPJ32gXE= github.com/google/pprof v0.0.0-20260402051712-545e8a4df936 h1:EwtI+Al+DeppwYX2oXJCETMO23COyaKGP6fHVpkpWpg= github.com/google/pprof v0.0.0-20260402051712-545e8a4df936/go.mod h1:MxpfABSjhmINe3F1It9d+8exIHFvUqtLIRCdOGNXqiI= +github.com/google/renameio v0.1.0 h1:GOZbcHa3HfsPKPlmyPyN2KEohoMXOhdMbHrvbpl2QaA= +github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI= github.com/google/s2a-go v0.1.9 h1:LGD7gtMgezd8a/Xak7mEWL0PjoTQFvpRudN895yqKW0= github.com/google/s2a-go v0.1.9/go.mod h1:YA0Ei2ZQL3acow2O62kdp9UlnvMmU7kA6Eutn0dXayM= github.com/google/trillian v1.7.3 h1:hziW+vo4czis48tzx2GK5xRBl/ZxBA9B0/UR5avXOro= github.com/google/trillian v1.7.3/go.mod h1:qh8iy4x/GvnVXUBd5pK4oncuT1Y9vVYfibQVsR/WpKg= github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= -github.com/googleapis/enterprise-certificate-proxy v0.3.16 h1:F/VPrx0YPBdksZJQdCAp0WUsqnNmZpUZszzfYt0M5Dw= -github.com/googleapis/enterprise-certificate-proxy v0.3.16/go.mod h1:9Yb0eAkH/Xqhvv3zbeKf/+wMJqCeocWc6KIhDvEAuYE= -github.com/googleapis/gax-go/v2 v2.22.0 h1:PjIWBpgGIVKGoCXuiCoP64altEJCj3/Ei+kSU5vlZD4= -github.com/googleapis/gax-go/v2 v2.22.0/go.mod h1:irWBbALSr0Sk3qlqb9SyJ1h68WjgeFuiOzI4Rqw5+aY= +github.com/googleapis/enterprise-certificate-proxy v0.3.18 h1:hvVi34VucdrV1IIsiWuqYM8kutw/92MxNEFxCJZEh0k= +github.com/googleapis/enterprise-certificate-proxy v0.3.18/go.mod h1:rSEsBUemEBZEexP2y6jPp16LUmUbjmSbcPMQizR0o4k= +github.com/googleapis/gax-go/v2 v2.23.0 h1:Tchl7qkvE7Ip3y+ztvNufYFvkfqTe7NfLTYGIdJRLuE= +github.com/googleapis/gax-go/v2 v2.23.0/go.mod h1:rBQKOVJCdb8IFEzg+FCwlt1LP/xMDGuqUXhUG+XMXEg= github.com/grpc-ecosystem/go-grpc-middleware v1.4.0 h1:UH//fgunKIs4JdUbpDl1VZCDaL56wXCB/5+wF6uHfaI= -github.com/grpc-ecosystem/go-grpc-middleware v1.4.0/go.mod h1:g5qyo/la0ALbONm6Vbp88Yd8NsDy6rZz+RcrMPxvld8= +github.com/grpc-ecosystem/go-grpc-middleware/v2 v2.3.3 h1:B+8ClL/kCQkRiU82d9xajRPKYMrB7E0MbtzWVi1K4ns= +github.com/grpc-ecosystem/go-grpc-middleware/v2 v2.3.3/go.mod h1:NbCUVmiS4foBGBHOYlCT25+YmGpJ32dZPi75pGEUpj4= github.com/grpc-ecosystem/grpc-gateway/v2 v2.29.0 h1:5VipnvEpbqr2gA2VbM+nYVbkIF28c5ZQfqCBQ5g2xfk= github.com/grpc-ecosystem/grpc-gateway/v2 v2.29.0/go.mod h1:Hyl3n6Twe1hvtd9XUXDec4pTvgMSEixRuQKPTMH2bNs= github.com/hack-pad/go-indexeddb v0.3.2 h1:DTqeJJYc1usa45Q5r52t01KhvlSN02+Oq+tQbSBI91A= @@ -246,8 +246,8 @@ github.com/hashicorp/go-sockaddr v1.0.7 h1:G+pTkSO01HpR5qCxg7lxfsFEZaG+C0VssTy/9 github.com/hashicorp/go-sockaddr v1.0.7/go.mod h1:FZQbEYa1pxkQ7WLpyXJ6cbjpT8q0YgQaK/JakXqGyWw= github.com/hashicorp/hcl v1.0.1-vault-7 h1:ag5OxFVy3QYTFTJODRzTKVZ6xvdfLLCA1cy/Y6xGI0I= github.com/hashicorp/hcl v1.0.1-vault-7/go.mod h1:XYhtn6ijBSAj6n4YqAaf7RBPS4I06AItNorpy+MoQNM= -github.com/hashicorp/vault/api v1.22.0 h1:+HYFquE35/B74fHoIeXlZIP2YADVboaPjaSicHEZiH0= -github.com/hashicorp/vault/api v1.22.0/go.mod h1:IUZA2cDvr4Ok3+NtK2Oq/r+lJeXkeCrHRmqdyWfpmGM= +github.com/hashicorp/vault/api v1.23.0 h1:gXgluBsSECfRWTSW9niY2jwg2e9mMJc4WoHNv4g3h6A= +github.com/hashicorp/vault/api v1.23.0/go.mod h1:zransKiB9ftp+kgY8ydjnvCU7Wk8i9L0DYWpXeMj9ko= github.com/howeyc/gopass v0.0.0-20210920133722-c8aef6fb66ef h1:A9HsByNhogrvm9cWb28sjiS3i7tcKCkflWFEkHfuAgM= github.com/howeyc/gopass v0.0.0-20210920133722-c8aef6fb66ef/go.mod h1:lADxMC39cJJqL93Duh1xhAs4I2Zs8mKS89XWXFGp9cs= github.com/in-toto/attestation v1.2.0 h1:aPRUZ3azbqD7yEBD5fP3TD8Dszf+YHo284SOcpahjQk= @@ -260,8 +260,8 @@ github.com/jeandeaual/go-locale v0.0.0-20250612000132-0ef82f21eade h1:FmusiCI1wH github.com/jeandeaual/go-locale v0.0.0-20250612000132-0ef82f21eade/go.mod h1:ZDXo8KHryOWSIqnsb/CiDq7hQUYryCgdVnxbj8tDG7o= github.com/jedisct1/go-minisign v0.0.0-20211028175153-1c139d1cc84b h1:ZGiXF8sz7PDk6RgkP+A/SFfUD0ZR/AgG6SpRNEDKZy8= github.com/jedisct1/go-minisign v0.0.0-20211028175153-1c139d1cc84b/go.mod h1:hQmNrgofl+IY/8L+n20H6E6PWBBTokdsv+q49j0QhsU= -github.com/jellydator/ttlcache/v3 v3.4.0 h1:YS4P125qQS0tNhtL6aeYkheEaB/m8HCqdMMP4mnWdTY= -github.com/jellydator/ttlcache/v3 v3.4.0/go.mod h1:Hw9EgjymziQD3yGsQdf1FqFdpp7YjFMd4Srg5EJlgD4= +github.com/jellydator/ttlcache/v3 v3.4.1 h1:bOdXmXiycyK6E6Qjyuj5vl+/vU3SCOoDs8a86NbHjAQ= +github.com/jellydator/ttlcache/v3 v3.4.1/go.mod h1:j7LO12PNghFg5+0v9budMAT4rDK4JY969jb9vOdOBBk= github.com/jsummers/gobmp v0.0.0-20230614200233-a9de23ed2e25 h1:YLvr1eE6cdCqjOe972w/cYF+FjW34v27+9Vo5106B4M= github.com/jsummers/gobmp v0.0.0-20230614200233-a9de23ed2e25/go.mod h1:kLgvv7o6UM+0QSf0QjAse3wReFDsb9qbZJdfexWlrQw= github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc= @@ -294,9 +294,8 @@ github.com/ryanuber/go-glob v1.0.0/go.mod h1:807d1WSdnB0XRJzKNil9Om6lcp/3a0v4qIH github.com/rymdport/portal v0.4.2 h1:7jKRSemwlTyVHHrTGgQg7gmNPJs88xkbKcIL3NlcmSU= github.com/rymdport/portal v0.4.2/go.mod h1:kFF4jslnJ8pD5uCi17brj/ODlfIidOxlgUDTO5ncnC4= github.com/sassoftware/relic v7.2.1+incompatible h1:Pwyh1F3I0r4clFJXkSI8bOyJINGqpgjJU3DYAZeI05A= -github.com/sassoftware/relic v7.2.1+incompatible/go.mod h1:CWfAxv73/iLZ17rbyhIEq3K9hs5w6FpNMdUT//qR+zk= -github.com/sassoftware/relic/v7 v7.6.2 h1:rS44Lbv9G9eXsukknS4mSjIAuuX+lMq/FnStgmZlUv4= -github.com/sassoftware/relic/v7 v7.6.2/go.mod h1:kjmP0IBVkJZ6gXeAu35/KCEfca//+PKM6vTAsyDPY+k= +github.com/sassoftware/relic/v8 v8.2.0 h1:9/L4S4I6an/JsPNhmcTpqfiOIsLb/iJaePZD1xR+ulE= +github.com/sassoftware/relic/v8 v8.2.0/go.mod h1:pZy7hLT9WCOKPonV8G/fplvtBLOZd6/kWtKqeHR6nKc= github.com/secure-systems-lab/go-securesystemslib v0.11.0 h1:iuCR9kcMFD4QurdKrGvPLoKZLv9YvwPYVr0473BdtFs= github.com/secure-systems-lab/go-securesystemslib v0.11.0/go.mod h1:+PMOTjUGwHj2vcZ+TFKlb1tXRbrdWE1LYDT5i9JC80Q= github.com/sergi/go-diff v1.4.0 h1:n/SP9D5ad1fORl+llWyN+D6qoUETXNZARKjyY2/KVCw= @@ -305,22 +304,22 @@ github.com/shibumi/go-pathspec v1.3.0 h1:QUyMZhFo0Md5B8zV8x2tesohbb5kfbpTi9rBnKh github.com/shibumi/go-pathspec v1.3.0/go.mod h1:Xutfslp817l2I1cZvgcfeMQJG5QnU2lh5tVaaMCl3jE= github.com/sigstore/protobuf-specs v0.5.1 h1:/5OPaNuolRJmQfeZLayJGFXMpsRJEdgC6ah1/+7Px7U= github.com/sigstore/protobuf-specs v0.5.1/go.mod h1:DRBzpFuE+LnvQMN10/dU6nBeKwVLGEQ6o2FovN2Rats= -github.com/sigstore/rekor v1.5.3 h1:0Tyolw3zreRgm7PUW8dccFLXGBThi08278jI8EXNSr4= -github.com/sigstore/rekor v1.5.3/go.mod h1:h3GK5dDqCcWJJZUJwdpKGSSmEV2GEjPUjJy3WTjBwzA= +github.com/sigstore/rekor v1.5.4 h1:A9zITTrkRwO+8lfq7L/gBR7rDHHcBQJRI+a0JQo4xDM= +github.com/sigstore/rekor v1.5.4/go.mod h1:0bcUHhZPlG+RVW1dI/7sdBp0MiVWVzk9h0tgOH/o0Yc= github.com/sigstore/rekor-tiles/v2 v2.3.0 h1:HhMgH61UP0t899V8Fjt7pz1YdgOBptbaQdnCF+79cdc= github.com/sigstore/rekor-tiles/v2 v2.3.0/go.mod h1:DEFiKSyQ4nF75QRVNdOPaIH3cmvMkO2B6xDZjNYngPc= github.com/sigstore/sigstore v1.10.9 h1:7Dcpt+ibnltHQZ8XhaU0dFmhHaf/T491eJfA9WDex4Y= github.com/sigstore/sigstore v1.10.9/go.mod h1:LYW9+qH7bK8wZmLm6lPxIC5lkHtkJDCgkqjChzTAIBs= github.com/sigstore/sigstore-go v1.3.0 h1:hnIMHREyCNTYFtOE1o7ae3Axa9B5W5EjUSBJICP2NBE= github.com/sigstore/sigstore-go v1.3.0/go.mod h1:AyRQXfpH89py1twjE3kEZxlRersng90GSYqQV9zGJE8= -github.com/sigstore/sigstore/pkg/signature/kms/aws v1.10.8 h1:tofVQ+UWJgad/69I5zbqxdFCN5gpIn9tRQP7iBzIpBw= -github.com/sigstore/sigstore/pkg/signature/kms/aws v1.10.8/go.mod h1:73AfJE8H6w5KGCFPBu4x/OG+i1Yxgmh0L/FtV7prd88= -github.com/sigstore/sigstore/pkg/signature/kms/azure v1.10.8 h1:8Mt7J36GcUEmbiJaiFhz2tud5ZIgkfVVCe2H/WJCHmw= -github.com/sigstore/sigstore/pkg/signature/kms/azure v1.10.8/go.mod h1:YiTpAsxoWXhF9KlLOVWCh7BckN5cYO8X01WufDq1ido= -github.com/sigstore/sigstore/pkg/signature/kms/gcp v1.10.8 h1:MxpAIMZVzn0Tpbarc9ax1I498oQBp7oYSMgoMSsOmKI= -github.com/sigstore/sigstore/pkg/signature/kms/gcp v1.10.8/go.mod h1:bnAUEkFNam6STvkVZhptVwWzWR5pS24CEtQ+lhxu7S0= -github.com/sigstore/sigstore/pkg/signature/kms/hashivault v1.10.8 h1:1DGe4/clcdOnkz5MINEczWlmEvjUtZd+AjPPT/cBhQ8= -github.com/sigstore/sigstore/pkg/signature/kms/hashivault v1.10.8/go.mod h1:6IDFhpgxtzqbnzrFkyegbj7RfWwKeRrb3/+xAD1Wp+Y= +github.com/sigstore/sigstore/pkg/signature/kms/aws v1.10.9 h1:2NWAU/utJRwzy1OrQurlY3wlDSynyH1rNJS5GgFchrg= +github.com/sigstore/sigstore/pkg/signature/kms/aws v1.10.9/go.mod h1:2shgYiPHTzeb5NNEu6okco+LOojMS5n9p/5Wdp0jhGI= +github.com/sigstore/sigstore/pkg/signature/kms/azure v1.10.9 h1:zcg/EG6JW/8RSx9T2g5j6zqxplaE4dymmhiFflDE6ks= +github.com/sigstore/sigstore/pkg/signature/kms/azure v1.10.9/go.mod h1:e7QngtHib0McuP1C/+Dt9f/7a8ic8FXvPB75OQzWgU4= +github.com/sigstore/sigstore/pkg/signature/kms/gcp v1.10.9 h1:DG8R4orWDs3l9trp70fLRTgazedEDoAIo/cHEN7Qo0k= +github.com/sigstore/sigstore/pkg/signature/kms/gcp v1.10.9/go.mod h1:d6oIwQ0YiYHMcFO4xqFcAx5njXwIf0dm5KfdytOar8A= +github.com/sigstore/sigstore/pkg/signature/kms/hashivault v1.10.9 h1:V+spyeSHypvLHSOvPMT+V72dxDlS0LDkDd6lwCsUOXM= +github.com/sigstore/sigstore/pkg/signature/kms/hashivault v1.10.9/go.mod h1:o7u5bQNLqpDQFaST29dpo6P6ihMV+wicwqfMmMW6H3c= github.com/sigstore/timestamp-authority/v2 v2.1.3 h1:Fc+LjCTfik1lh3YLkaosENfkXa3R2Y1nswiUKutBdFA= github.com/sigstore/timestamp-authority/v2 v2.1.3/go.mod h1:myoFOKJB/u5vNTFwvBBJVkG3NnOBeIJevbfjNeasLjo= github.com/spf13/cobra v1.10.2 h1:DMTTonx5m65Ic0GOoRY2c16WCbHxOOw6xxezuLaBpcU= @@ -341,8 +340,8 @@ github.com/theupdateframework/go-tuf/v2 v2.4.2 h1:w7976/W8uTwlsegP5nRymlpjPgrwSh github.com/theupdateframework/go-tuf/v2 v2.4.2/go.mod h1:JqBrIUnNLAaNq/8GmBcEMFWfAFBbqp/MkJEJseXKbks= github.com/tink-crypto/tink-go-awskms/v3 v3.0.0 h1:XSohRhCkXAVI0iaCnWB/GS05TEmpnKurQmzaY1jzt3Y= github.com/tink-crypto/tink-go-awskms/v3 v3.0.0/go.mod h1:+7MXsShLzVbSQ6dI0Pe4JuZM52jD1jQ1itAygd/MDsA= -github.com/tink-crypto/tink-go-gcpkms/v2 v2.3.0 h1:3s6YMgMOBZRU8qG6ybpKSF2Sau+y3sMvxR911M59SwA= -github.com/tink-crypto/tink-go-gcpkms/v2 v2.3.0/go.mod h1:X8UNvbQu2wanAGa8ixRUU/DWt1V2hUBfvPGy6s9nE2s= +github.com/tink-crypto/tink-go-gcpkms/v2 v2.4.0 h1:xpI5pnEQ0erFCS3JmcEl7Blluo8ZieEPNOURqy9uD70= +github.com/tink-crypto/tink-go-gcpkms/v2 v2.4.0/go.mod h1:wDDAhjfd1t4TjeJCSsmFK7CARPUs/ITi16ZZ8kmAaFQ= github.com/tink-crypto/tink-go-hcvault/v2 v2.5.0 h1:eXuNqgrcYelxU1MVikOJDP3wTS5lvihM4ntoAbAMfvs= github.com/tink-crypto/tink-go-hcvault/v2 v2.5.0/go.mod h1:3RhcxAqek6xUlRFmJifvU4CYLZN60KMQdIKqpZAZJG0= github.com/tink-crypto/tink-go/v2 v2.7.0 h1:k7QnUXJ1cRDpvoy/5l1FimZqMAArRff8vjUqzi5N04o= @@ -355,8 +354,8 @@ github.com/youmark/pkcs8 v0.0.0-20240726163527-a2c0da244d78 h1:ilQV1hzziu+LLM3zU github.com/youmark/pkcs8 v0.0.0-20240726163527-a2c0da244d78/go.mod h1:aL8wCCfTfSfmXjznFBSZNN13rSJjlIOI1fUNAtF7rmI= github.com/yuin/goldmark v1.8.5 h1:r6N5afV5qj/5S4UTch8agZHJ8UxNCMwX7WjkkJam2NA= github.com/yuin/goldmark v1.8.5/go.mod h1:ip/1k0VRfGynBgxOz0yCqHrbZXhcjxyuS66Brc7iBKg= -github.com/zalando/go-keyring v0.2.3 h1:v9CUu9phlABObO4LPWycf+zwMG7nlbb3t/B5wa97yms= -github.com/zalando/go-keyring v0.2.3/go.mod h1:HL4k+OXQfJUWaMnqyuSOc0drfGPX2b51Du6K+MRgZMk= +github.com/zalando/go-keyring v0.2.6 h1:r7Yc3+H+Ux0+M72zacZoItR3UDxeWfKTcabvkI8ua9s= +github.com/zalando/go-keyring v0.2.6/go.mod h1:2TCrxYrbUNYfNS/Kgy/LSrkSQzZ5UPVH85RwfczwvcI= go.opentelemetry.io/auto/sdk v1.2.1 h1:jXsnJ4Lmnqd11kwkBV2LgLoFMZKizbCi5fNZ/ipaZ64= go.opentelemetry.io/auto/sdk v1.2.1/go.mod h1:KRTj+aOaElaLi+wW1kO/DZRXwkF4C5xPbEe3ZiIhN7Y= go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.67.0 h1:yI1/OhfEPy7J9eoa6Sj051C7n5dvpj0QX8g4sRchg04= @@ -373,8 +372,8 @@ go.opentelemetry.io/otel/sdk/metric v1.44.0 h1:3LlKgI+VjbVsjNRFZJZAJ30WjXC5VkNRk go.opentelemetry.io/otel/sdk/metric v1.44.0/go.mod h1:5B5pMARnXxKhltooO4xUuCBorl65a4EpnTalObqOigA= go.opentelemetry.io/otel/trace v1.44.0 h1:jxF5CsGYCe74MCRx2X4g7WsY/VBKRqqpNvXlX/6gtIk= go.opentelemetry.io/otel/trace v1.44.0/go.mod h1:oLl1jrMQAVo6v3GAggN+1VH9VIz9iUSvW53sW1Q8PIE= -go.step.sm/crypto v0.77.7 h1:6azC+pD678Vjju8yXnMDHCZJ+HzFaEmL3sCryiezTIA= -go.step.sm/crypto v0.77.7/go.mod h1:OW/2sEHwTtDKq70PvSQ5B0JGy/CrLyDKOiVy3YvZMTQ= +go.step.sm/crypto v0.87.0 h1:+u0pDz1OV9M/SswA6KtcQ3GSrYMMelbL//0W/ceJVYI= +go.step.sm/crypto v0.87.0/go.mod h1:gBr1mpMiKs5804/Yt03uAoOBiw3DFxARZnGUKEUO82M= go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto= go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE= go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0= @@ -409,25 +408,31 @@ golang.org/x/time v0.15.0 h1:bbrp8t3bGUeFOx08pvsMYRTCVSMk89u4tKbNOZbp88U= golang.org/x/time v0.15.0/go.mod h1:Y4YMaQmXwGQZoFaVFk4YpCt4FLQMYKZe9oeV/f4MSno= golang.org/x/tools v0.49.0 h1:3NI7VXzL9+1WZD52Dx2ttoPwD5DWrFGpl9mFZDlmisI= golang.org/x/tools v0.49.0/go.mod h1:SJNXV9DBKT0UbdttsQjbfJlAE/q+y36++zo3uL3N0Oo= +golang.org/x/tools/go/expect v0.1.1-deprecated h1:jpBZDwmgPhXsKZC6WhL20P4b/wmnpsEAGHaNy0n/rJM= +golang.org/x/tools/go/expect v0.1.1-deprecated/go.mod h1:eihoPOH+FgIqa3FpoTwguz/bVUSGBlGQU67vpBeOrBY= +golang.org/x/tools/go/packages/packagestest v0.1.1-deprecated h1:1h2MnaIAIXISqTFKdENegdpAgUXz6NrPEsbIeWaBRvM= +golang.org/x/tools/go/packages/packagestest v0.1.1-deprecated/go.mod h1:RVAQXBGNv1ib0J382/DPCRS/BPnsGebyM1Gj5VSDpG8= +golang.org/x/vuln v1.7.0 h1:4MQBuhmXbz2uepNJrf3v+aaZLGDqw1JluwYboegA1qg= +golang.org/x/vuln v1.7.0/go.mod h1:Xw7zvU3e1bsCYYBXu+w4wcn2Kgn27f34WBCTw8LL5Us= gonum.org/v1/gonum v0.17.0 h1:VbpOemQlsSMrYmn7T2OUvQ4dqxQXU+ouZFQsZOx50z4= gonum.org/v1/gonum v0.17.0/go.mod h1:El3tOrEuMpv2UdMrbNlKEh9vd86bmQ6vqIcDwxEOc1E= -google.golang.org/api v0.283.0 h1:0lkp8u0MPwJVHqRL+nJlMAoZVVzbmiXmFHXMOTmSPik= -google.golang.org/api v0.283.0/go.mod h1:6Wssta4c5n9qHq5CBhmlai5h/PUa1djdDAIhYEHyvcM= -google.golang.org/genproto v0.0.0-20260319201613-d00831a3d3e7 h1:XzmzkmB14QhVhgnawEVsOn6OFsnpyxNPRY9QV01dNB0= -google.golang.org/genproto v0.0.0-20260319201613-d00831a3d3e7/go.mod h1:L43LFes82YgSonw6iTXTxXUX1OlULt4AQtkik4ULL/I= +google.golang.org/api v0.290.0 h1:eMw0Xo+IfbbMlKmW7aHvpyQRv9RCXuWx/vs8AD+0x9A= +google.golang.org/api v0.290.0/go.mod h1:weJZ3lldHFYI0DBFNKpJelUDNnusTt5YaOEgxvt8ci8= +google.golang.org/genproto v0.0.0-20260622175928-b703f567277d h1:CP5omUq8AJTiWMrPKM1WRLJ7zZeXd9OPcQD3TbBNAyY= +google.golang.org/genproto v0.0.0-20260622175928-b703f567277d/go.mod h1:DrwuGJgFSEVNpv3S5Q5VxhRTvdnjauw9GtvwVOEARfA= google.golang.org/genproto/googleapis/api v0.0.0-20260727163830-6c54dddc4772 h1:4namukbyF7JY83aWHQwi9J5ugNTnDReLJ9ZcpqOpRB4= google.golang.org/genproto/googleapis/api v0.0.0-20260727163830-6c54dddc4772/go.mod h1:1brfde68Npq6+WA75c1EHWPijZEG1kMus61ygPZfn4A= google.golang.org/genproto/googleapis/rpc v0.0.0-20260720155508-bb71a54f79dc h1:3TtNq/QbJNrSY1nVdjcikfBw6ujnaNbdrd88wNr1OW4= google.golang.org/genproto/googleapis/rpc v0.0.0-20260720155508-bb71a54f79dc/go.mod h1:4Hqkh8ycfw05ld/3BWL7rJOSfebL2Q+DVDeRgYgxUU8= google.golang.org/grpc v1.83.2 h1:EManeRomTObA0BU7I8vXgg/78uE5MJ9M8B39EX2WscU= google.golang.org/grpc v1.83.2/go.mod h1:YPI1hK3kDked6iHvgX3tR0y+nX/qpMFKhPgFsokw1S8= -google.golang.org/protobuf v1.36.11 h1:fV6ZwhNocDyBLK0dj+fg8ektcVegBBuEolpbTQyBNVE= -google.golang.org/protobuf v1.36.11/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco= +google.golang.org/protobuf v1.36.12 h1:pJOKDDOyeXErUroCihFAd5LQuwXBSpVnKGrj5o/fwxc= +google.golang.org/protobuf v1.36.12/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco= gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= k8s.io/klog/v2 v2.140.0 h1:Tf+J3AH7xnUzZyVVXhTgGhEKnFqye14aadWv7bzXdzc= k8s.io/klog/v2 v2.140.0/go.mod h1:o+/RWfJ6PwpnFn7OyAG3QnO47BFsymfEfrz6XyYSSp0= sigs.k8s.io/yaml v1.6.0 h1:G8fkbMSAFqgEFgh4b1wmtzDnioxFCUgTZhlbj5P9QYs= sigs.k8s.io/yaml v1.6.0/go.mod h1:796bPqUfzR/0jLAl6XjHl3Ck7MiyVv8dbTdyT3/pMf4= -software.sslmate.com/src/go-pkcs12 v0.4.0 h1:H2g08FrTvSFKUj+D309j1DPfk5APnIdAQAB8aEykJ5k= -software.sslmate.com/src/go-pkcs12 v0.4.0/go.mod h1:Qiz0EyvDRJjjxGyUQa2cCNZn/wMyzrRJ/qcDXOQazLI= +software.sslmate.com/src/go-pkcs12 v0.5.0 h1:EC6R394xgENTpZ4RltKydeDUjtlM5drOYIG9c6TVj2M= +software.sslmate.com/src/go-pkcs12 v0.5.0/go.mod h1:Qiz0EyvDRJjjxGyUQa2cCNZn/wMyzrRJ/qcDXOQazLI= diff --git a/todos.md b/todos.md index cc7383d..fef0c76 100644 --- a/todos.md +++ b/todos.md @@ -25,6 +25,12 @@ - Updated the indirect gRPC-Go dependency to `v1.83.2`, resolving `CVE-2026-84304` / `GHSA-vp52-pcj8-j9qc`. Was never used (better save than sorry) +- Raised the minimum Go version to `1.27.1`, pinned `govulncheck` at `v1.7.0`, + and updated Rekor to `v1.5.4`, which replaces its unmaintained + `x/crypto/openpgp` implementation with the maintained Proton fork. The scan + finds no reachable or imported vulnerabilities; `GO-2026-5932` remains only + a module-level notice because latest `x/crypto v0.55.0` is still required for + unaffected cryptography and the advisory has no patched release. ## TODO From 41c982a74e298062d47e8ffcb6247b20122af6e1 Mon Sep 17 00:00:00 2001 From: frathe Date: Wed, 2 Sep 2026 17:38:09 +0200 Subject: [PATCH 04/10] fix(compare): route unlinked swipe input by reveal --- .../issues/01-route-swipe-input-by-reveal.md | 49 ++++ .../issues/02-preserve-right-wheel-anchor.md | 42 ++++ .../issues/03-document-review-and-verify.md | 62 +++++ .../swipe-unlinked-pointer-routing/spec.md | 84 +++++++ ARCHITECTURE.md | 2 +- CONTEXT.md | 10 + assets/trane/trane_lightwall.png | Bin 0 -> 1497793 bytes .../issues/01-shortcut-and-repaint-guards.md | 0 .../issues/02-render-scene-seam.md | 0 .../issues/03-display-ready-sources.md | 0 .../issues/04-tile-planner-and-cache.md | 0 .../issues/05-shader-adapter.md | 0 .../issues/06-async-tile-lifecycle.md | 0 .../issues/07-production-wiring.md | 0 .../issues/08-profile-docs-and-gate.md | 0 .../spec.md | 0 .../issues/01-add-top-left-link-control.md | 0 .../spec.md | 0 ...9-02-fix-unlinked-swipe-pointer-routing.md | 78 +++++++ internal/ui/compare/compare_test.go | 215 ++++++++++++++++-- internal/ui/compare/input.go | 7 +- internal/ui/compare/swipe.go | 7 + internal/ui/compare/transform.go | 7 +- todos.md | 5 +- 24 files changed, 546 insertions(+), 22 deletions(-) create mode 100644 .scratch/swipe-unlinked-pointer-routing/issues/01-route-swipe-input-by-reveal.md create mode 100644 .scratch/swipe-unlinked-pointer-routing/issues/02-preserve-right-wheel-anchor.md create mode 100644 .scratch/swipe-unlinked-pointer-routing/issues/03-document-review-and-verify.md create mode 100644 .scratch/swipe-unlinked-pointer-routing/spec.md create mode 100644 assets/trane/trane_lightwall.png rename {.scratch/compare-tiled-gpu-rendering => finished_refactorings/2026-09-01_compare-tiled-gpu-rendering}/issues/01-shortcut-and-repaint-guards.md (100%) rename {.scratch/compare-tiled-gpu-rendering => finished_refactorings/2026-09-01_compare-tiled-gpu-rendering}/issues/02-render-scene-seam.md (100%) rename {.scratch/compare-tiled-gpu-rendering => finished_refactorings/2026-09-01_compare-tiled-gpu-rendering}/issues/03-display-ready-sources.md (100%) rename {.scratch/compare-tiled-gpu-rendering => finished_refactorings/2026-09-01_compare-tiled-gpu-rendering}/issues/04-tile-planner-and-cache.md (100%) rename {.scratch/compare-tiled-gpu-rendering => finished_refactorings/2026-09-01_compare-tiled-gpu-rendering}/issues/05-shader-adapter.md (100%) rename {.scratch/compare-tiled-gpu-rendering => finished_refactorings/2026-09-01_compare-tiled-gpu-rendering}/issues/06-async-tile-lifecycle.md (100%) rename {.scratch/compare-tiled-gpu-rendering => finished_refactorings/2026-09-01_compare-tiled-gpu-rendering}/issues/07-production-wiring.md (100%) rename {.scratch/compare-tiled-gpu-rendering => finished_refactorings/2026-09-01_compare-tiled-gpu-rendering}/issues/08-profile-docs-and-gate.md (100%) rename {.scratch/compare-tiled-gpu-rendering => finished_refactorings/2026-09-01_compare-tiled-gpu-rendering}/spec.md (100%) rename {.scratch/comparison-link-button => finished_refactorings/2026-09-01_comparison-link-button}/issues/01-add-top-left-link-control.md (100%) rename {.scratch/comparison-link-button => finished_refactorings/2026-09-01_comparison-link-button}/spec.md (100%) create mode 100644 finished_refactorings/2026-09-02-fix-unlinked-swipe-pointer-routing.md diff --git a/.scratch/swipe-unlinked-pointer-routing/issues/01-route-swipe-input-by-reveal.md b/.scratch/swipe-unlinked-pointer-routing/issues/01-route-swipe-input-by-reveal.md new file mode 100644 index 0000000..5e3b08c --- /dev/null +++ b/.scratch/swipe-unlinked-pointer-routing/issues/01-route-swipe-input-by-reveal.md @@ -0,0 +1,49 @@ +# 01 - Route Swipe input by revealed pane + +Status: resolved + +## Contract + +Through `compare.Feature.Overlay()` in a real Fyne test window, prove that +Swipe + Unlinked comparison assigns pointer input to the photo occupying the +revealed region under the pointer. Hit regions must follow the current divider +without changing either photo's full-viewport render geometry. + +Add a private `layoutPaneInput(index, input)` helper driven by +`paneVisibleArea`. Apply it during pane layout and every reveal/divider update, +and remove the full-viewport input reset from transform application. The +divider remains the exclusive drag target in its hit area, and a fully hidden +pane has no interactive area. + +Files: `internal/ui/compare/compare_test.go`, +`internal/ui/compare/transform.go`, and `internal/ui/compare/swipe.go`. + +## Red / green + +1. Add `TestCompareSwipeUnlinkedCanvasRoutesPointerByReveal` using actual + canvas hover, drag, and wheel dispatch at the default divider and after + moving it to 75%. +2. Observe the current implementation report `Unlinked: Right` while the + pointer is over the visible left photo. +3. Implement reveal-aligned pane input bounds. +4. Verify Left/Right status, pane-local gestures, and subsequent transform keys + affect only the revealed target. Retain the last target after leaving a + photo region. + +## Acceptance + +`go test ./internal/ui/compare -run '^TestCompareSwipeUnlinkedCanvasRoutesPointerByReveal$' -count=1` + +## Constraints + +- Do not change renderer viewports, reveal clips, image transforms, tile + planning, shaders, caches, or divider behavior. +- Do not add an assembled-viewer duplicate of this regression. +- Do not add exported APIs or user-visible strings. + +## Comments + +- Red: the permanent canvas test reported `Unlinked: Right` while the pointer + was at x=200 in the visible left reveal. +- Green: reveal-aligned pane input bounds passed the focused acceptance command, + including divider movement, both extremes, gestures, and transform keys. diff --git a/.scratch/swipe-unlinked-pointer-routing/issues/02-preserve-right-wheel-anchor.md b/.scratch/swipe-unlinked-pointer-routing/issues/02-preserve-right-wheel-anchor.md new file mode 100644 index 0000000..d3933a0 --- /dev/null +++ b/.scratch/swipe-unlinked-pointer-routing/issues/02-preserve-right-wheel-anchor.md @@ -0,0 +1,42 @@ +# 02 - Preserve the right Swipe wheel anchor + +Status: resolved +Blocked by: 01 + +## Contract + +After Ticket 01 makes the right pane input start at the divider, preserve the +full-viewport image point beneath an unmodified wheel gesture. Copy each +non-nil `fyne.ScrollEvent`, add the input widget's reveal offset to the copied +event position, and forward that viewport-relative event. Never mutate the +event supplied by the caller. + +Files: `internal/ui/compare/compare_test.go` and +`internal/ui/compare/input.go`. + +## Red / green + +1. Add `TestCompareSwipeUnlinkedRightWheelPreservesViewportAnchor` through the + overlay's pane input seam after Ticket 01 is green. +2. Observe the right photo zoom around the reveal-local coordinate instead of + the full-viewport cursor position. +3. Add the scroll-coordinate translation and observe the point beneath the + cursor remain fixed. +4. Verify the original event is unchanged and nil events remain inert. + +## Acceptance + +`go test ./internal/ui/compare -run '^TestCompareSwipeUnlinkedRightWheelPreservesViewportAnchor$' -count=1` + +## Constraints + +- Preserve left-pane, side-by-side, linked-wheel, and Shift+wheel behavior. +- Do not expose pane internals or add a second scroll path. +- Do not mutate caller-owned input events. + +## Comments + +- Red: with reveal-local x=100 forwarded unchanged, the normalized point under + full-viewport x=500 moved from `0.625` to `0.5774` during wheel zoom. +- Green: translating a copied event by the input origin preserved the anchor; + the original event remained unchanged and nil stayed inert. diff --git a/.scratch/swipe-unlinked-pointer-routing/issues/03-document-review-and-verify.md b/.scratch/swipe-unlinked-pointer-routing/issues/03-document-review-and-verify.md new file mode 100644 index 0000000..a1d1618 --- /dev/null +++ b/.scratch/swipe-unlinked-pointer-routing/issues/03-document-review-and-verify.md @@ -0,0 +1,62 @@ +# 03 - Document, review, and verify the Swipe routing fix + +Status: resolved +Blocked by: 01, 02 + +## Contract + +Record the approved terminology and implementation invariant, review the two +vertical TDD slices, negatively verify their guards, and run the final gate +once. + +Add **Linked comparison** and **Unlinked comparison** to `CONTEXT.md` and mark +locked/unlocked comparison as avoided terminology. Update `ARCHITECTURE.md` to +state that Swipe input bounds mirror the reveal while wheel coordinates are +translated back into the full viewport. Add the bugfix to `todos.md` and +normalize its existing locking/unlocking wording to linking/unlinking. + +Complete the local spec and ticket comments with observed evidence, record the +Standard-route plan and cost ledger, and move the completed plan to +`finished_refactorings/` after the final gate. + +## Verification + +1. Run `go test ./internal/ui/compare -count=1`. +2. Run + `go test ./internal/ui -run 'Compare(LinkToggle|SwipePointer)' -count=1`. +3. Temporarily restore full-width pane inputs and confirm Ticket 01 fails for + the original Right-over-left symptom; restore the fix. +4. Temporarily remove scroll-coordinate translation and confirm Ticket 02 + fails for lost cursor anchoring; restore the fix. +5. Rerun both focused ticket commands on the restored tree. +6. Run `make verify` once and record its actual result. + +## Acceptance + +- Every spec acceptance command passes on the final tree. +- `rg -n 'Linked comparison|Unlinked comparison' CONTEXT.md` finds both + canonical terms. +- `rg -n 'reveal|revealed' ARCHITECTURE.md todos.md` finds the architecture and + release-note records. +- `make verify` passes. +- No diagnostic files or debug instrumentation remain. + +## Constraints + +- Leave the already-correct manuals and translations unchanged. +- Do not create an ADR or claim a manual native UI smoke test. +- Do not commit; provide the suggested commit message at handoff. + +## Comments + +- `go test ./internal/ui/compare -count=1` passed, as did the assembled + `Compare(LinkToggle|SwipePointer)` selection and both focused guards. +- Deliberately restoring full-width inputs reproduced `Unlinked: Right` over + the left reveal. Deliberately removing coordinate translation reproduced the + wheel-anchor drift from `0.625` to `0.5774`. Both fixes were restored and + both guards passed again. +- `CONTEXT.md`, `ARCHITECTURE.md`, and `todos.md` now record the approved terms, + invariant, and bugfix. Manuals, translations, and ADRs were left unchanged. +- `make verify` passed: formatting, embedded TUF-root check, vet, build, and the + complete Linux/amd64 race suite were green (`internal/ui` 676.609s; + `internal/ui/compare` 28.486s). diff --git a/.scratch/swipe-unlinked-pointer-routing/spec.md b/.scratch/swipe-unlinked-pointer-routing/spec.md new file mode 100644 index 0000000..123a7cd --- /dev/null +++ b/.scratch/swipe-unlinked-pointer-routing/spec.md @@ -0,0 +1,84 @@ +# Spec: unlinked swipe pointer routing + +Status: complete + +## Problem + +In Swipe comparison, both scrollable pane inputs occupy the full viewport. +Fyne treats each scrollable as a new hit-test clip, so the topmost right pane +captures pointer input even over the visible left photo. While the panes are +unlinked, hover therefore reports Right and the user can interact only with +the right photo. + +## Decisions + +- Use **Linked comparison** and **Unlinked comparison** as the canonical terms; + avoid locked/unlocked comparison. +- In Swipe + Unlinked comparison, hover, drag, wheel, cursor, and + last-hovered transform-key targeting follow the currently revealed photo. +- Pane hit regions track the movable divider. At the 0% and 100% extremes, + the fully hidden pane has no interactive area. +- Leaving a revealed photo for the divider, toolbar, or window edge retains + the last target for `0`, `1`, `+`, and `-`. +- Moving the divider across a stationary cursor changes the target on the + next pointer event; divider movement alone does not replace the last target. +- The divider remains the exclusive drag target within its own hit area. +- Full-viewport photo rendering and reveal clipping remain unchanged. +- A right-pane wheel event is translated from its reveal-local coordinates + into full-viewport coordinates so zoom remains anchored beneath the cursor. +- Regression tests use `compare.Feature.Overlay()` in a real Fyne test window. + The assembled-viewer suite is regression coverage, not a duplicate test + seam. + +## Acceptance criteria + +1. Actual canvas hover over either revealed Swipe region reports the matching + Left or Right target at the default divider and after moving the divider. + Verify: + `go test ./internal/ui/compare -run '^TestCompareSwipeUnlinkedCanvasRoutesPointerByReveal$' -count=1` +2. Canvas drag, wheel input, and subsequent transform keys affect only the + targeted photo while unlinked. + Verify: the canvas-routing command above. +3. Wheel zoom over the right reveal preserves the full-viewport image point + beneath the cursor and does not mutate the supplied event. + Verify: + `go test ./internal/ui/compare -run '^TestCompareSwipeUnlinkedRightWheelPreservesViewportAnchor$' -count=1` +4. Linked comparison, side-by-side input, divider precedence, layout + transitions, and command isolation retain their existing behavior. + Verify: `go test ./internal/ui/compare -count=1` + Verify: + `go test ./internal/ui -run 'Compare(LinkToggle|SwipePointer)' -count=1` +5. `CONTEXT.md` records the canonical comparison terms, `ARCHITECTURE.md` + records the reveal-aligned input invariant, and `todos.md` records the + bugfix using linking/unlinking terminology. + Verify: `rg -n 'Linked comparison|Unlinked comparison' CONTEXT.md` + Verify: `rg -n 'reveal|revealed' ARCHITECTURE.md todos.md` +6. Formatting, vet, build, and the complete race suite pass. + Verify: `make verify` + +## Non-goals + +- Changing image render geometry, reveal clipping, tile planning, caches, or + GPU shaders. +- Changing linked-camera behavior, photo transforms, divider semantics, Swap, + or comparison lifecycle behavior. +- Adding exported APIs, preferences, localization keys, or new user controls. +- Retargeting from divider movement without a subsequent pointer event. +- Duplicating the regression through the assembled viewer or requiring a + manual native UI smoke test. +- Rewriting the already-correct comparison manuals or creating an ADR. + +## Honest limit + +The deterministic regression uses Fyne's test driver rather than a manual UI +session. The test and native drivers share the diagnosed hit-test walker, and +the reported native symptom matches the test failure, so focused native tests +plus `make verify` are the acceptance boundary. + +## Outcome + +Swipe pane inputs now track their reveal bounds while both photo render +viewports remain full-size. Right-pane wheel events are copied and translated +back into viewport coordinates. Both regression guards were observed failing +against deliberate reversions, all focused acceptance commands passed, and +`make verify` completed successfully. diff --git a/ARCHITECTURE.md b/ARCHITECTURE.md index f7076d1..af37960 100644 --- a/ARCHITECTURE.md +++ b/ARCHITECTURE.md @@ -82,7 +82,7 @@ The concurrency invariant: see `AGENTS.md` § Concurrency and Fyne. | `internal/ui/zoom/` | Zoom/pan of the displayed image. `Geometry` / `HandleScroll` / `SetOnGeometryChanged` are the presentation seam Copy Selection uses; this package does not import `copyselection`. Window growth is `syncWindowToZoom` in `internal/ui`. | `onChanged`, `modifiers`, `onScaleChanged`. | | `internal/ui/copyselection/` | Transient Copy Selection mode: image-region geometry, overlay, and captured `Source` crop/encode. `HandleKey` reports whether the mode consumed the key. | `Copy`, `Ended`, `Scroll`. | | `internal/ui/grid/` | Overview (G): `GridWrap`, thumb cache, `decodepool`, `uiqueue.go`, search, badges, explicit host-index selection plus its change observer, `marquee.go` (drag rectangle → `Targets()`), browse-duplicates (Shift+D), and `hashengine.go`'s pool-driven hashing pass that feeds `internal/dupes`. `nav.go`: `setHighlight` → `HighlightChanged`. Reads the model; does not own it. | 10-method `Host` including `Modifiers`. | -| `internal/ui/compare/` | Opaque main-window comparison surface: switchable gapless 50/50 and full-viewport swipe layouts compose two persistent photo transforms with one shared camera transform; each image has one reveal clip so swipe keeps aligned image coordinates. The ready-gated top-left Unlink/Link control and physical `Ctrl+L` share `ToggleLink`; its adjacent status reports only the active unlinked target, while layout/Swap/Back stay in a separate top-right card. `ToggleLink` changes only input ownership and never changes rendered geometry. Linked pan/zoom moves the camera, linked `0` frames both current photo poses without rewriting them, and linked `1` returns the camera home. Unlinked pointer input and transform keys target the hovered or last-hovered photo; its `0` / `1` fit or show that photo at decoded-pixel size in the current camera. Photo centers and camera movement stop when an image edge reaches its pane center. Resize and layout preserve both photo poses and the camera; Swap deliberately clears divergence from the last-targeted visible pose before exchanging sources. A private `paneRenderer` scene seam keeps transforms independent from presentation; production owns two stable `canvas.Shader` objects while tests can inject the canvas reference adapter. Each immutable render source retains the canonical decoded frame, a long-edge-1024 overview, and a 64 MiB detail-tile cache. The planner uses physical display density and the actual side-by-side/swipe reveal, skips details when the overview is sufficient, and binds at most seven guttered detail tiles without shuffling stable sampler slots. One cancellable worker per pane generates tiles; publications are coalesced and marshalled through the feature's `UIQueue`. Pan/zoom changes shader geometry and uniforms without repainting the viewer root. Each SVG still gets a pane-local device-pixel raster, clamped by `imaging.ClampVectorRaster`, before entering the same overview/tile path. `Settle` covers load, vector, tile, and causal queued completions with reusable channel-epoch barriers. Fyne's software test painter does not render `canvas.Shader`, so deterministic pixel tests use the reference adapter; native runtime acceptance uses the GL painter. The feature also owns divider input, permanent chrome, ready-gated layout/link/Swap controls, the input shield, and the replaceable completion signal. It receives an ordered URI pair and never reads or mutates grid/viewer state. | `Loader` plus `Callbacks` (`Repaint`, `Closed`, `Failed`, `OrderChanged`, `Modifiers`). | +| `internal/ui/compare/` | Opaque main-window comparison surface: switchable gapless 50/50 and full-viewport swipe layouts compose two persistent photo transforms with one shared camera transform; each image has one reveal clip so swipe keeps aligned image coordinates. In Swipe, each pane input mirrors its current reveal even though the render viewport remains full-size, and reveal-local wheel coordinates are translated back into that viewport. The ready-gated top-left Unlink/Link control and physical `Ctrl+L` share `ToggleLink`; its adjacent status reports only the active unlinked target, while layout/Swap/Back stay in a separate top-right card. `ToggleLink` changes only input ownership and never changes rendered geometry. Linked pan/zoom moves the camera, linked `0` frames both current photo poses without rewriting them, and linked `1` returns the camera home. Unlinked pointer input and transform keys target the hovered or last-hovered photo; its `0` / `1` fit or show that photo at decoded-pixel size in the current camera. Photo centers and camera movement stop when an image edge reaches its pane center. Resize and layout preserve both photo poses and the camera; Swap deliberately clears divergence from the last-targeted visible pose before exchanging sources. A private `paneRenderer` scene seam keeps transforms independent from presentation; production owns two stable `canvas.Shader` objects while tests can inject the canvas reference adapter. Each immutable render source retains the canonical decoded frame, a long-edge-1024 overview, and a 64 MiB detail-tile cache. The planner uses physical display density and the actual side-by-side/swipe reveal, skips details when the overview is sufficient, and binds at most seven guttered detail tiles without shuffling stable sampler slots. One cancellable worker per pane generates tiles; publications are coalesced and marshalled through the feature's `UIQueue`. Pan/zoom changes shader geometry and uniforms without repainting the viewer root. Each SVG still gets a pane-local device-pixel raster, clamped by `imaging.ClampVectorRaster`, before entering the same overview/tile path. `Settle` covers load, vector, tile, and causal queued completions with reusable channel-epoch barriers. Fyne's software test painter does not render `canvas.Shader`, so deterministic pixel tests use the reference adapter; native runtime acceptance uses the GL painter. The feature also owns divider input, permanent chrome, ready-gated layout/link/Swap controls, the input shield, and the replaceable completion signal. It receives an ordered URI pair and never reads or mutates grid/viewer state. | `Loader` plus `Callbacks` (`Repaint`, `Closed`, `Failed`, `OrderChanged`, `Modifiers`). | | `internal/ui/deletion/` | Shift+Delete confirm (`widgets.ChoiceCard`) then `trash.Move`. `RequestFiles` is the batch path; `Request` is the one-file wrapper. | 7-method `Host`. | | `internal/ui/slideshow/` | Picture-frame mode (P): full-screen, auto-advance, interval, `winpos.Tracker` capture/restore. | 2-method `Host`. Knows nothing about the grid. | | `internal/ui/exifwin/` | EXIF panel (E): tag list, optional JPEG strip, GPS map (`tiles.go`, `startWarm`). Geometry via `widgets.Singleton`. | 4-method `Host`. | diff --git a/CONTEXT.md b/CONTEXT.md index 6887c5f..6ed1228 100644 --- a/CONTEXT.md +++ b/CONTEXT.md @@ -18,3 +18,13 @@ _Avoid_: Crop, grid selection A transient single-image-viewer mode for defining an image-region selection to copy as image data. _Avoid_: Crop mode, screenshot mode + +**Linked comparison**: +A two-photo comparison state where view adjustments affect both photos +together. +_Avoid_: Locked comparison + +**Unlinked comparison**: +A two-photo comparison state where view adjustments affect one targeted photo +without changing the other. +_Avoid_: Unlocked comparison diff --git a/assets/trane/trane_lightwall.png b/assets/trane/trane_lightwall.png new file mode 100644 index 0000000000000000000000000000000000000000..428f1ea68beff8e0be3dc507a915ff2658fbc7db GIT binary patch literal 1497793 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

  • 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

    Sic+Wy;^ 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

    UI@=k>8DBw0!+n4dyKGvApMp;L(T2@8$99e-Zx& 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�{oYEi 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

    • rS1V|omTqZvmrBUCZ>?N+)Ds}3vx5w6Y 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