From bb3bf9858b213aae2f43beadda56d9cbe098a7e4 Mon Sep 17 00:00:00 2001 From: Sameh Khamis Date: Wed, 18 Nov 2026 18:23:41 -0800 Subject: [PATCH] fix(click): the card or label on top takes the click in every layer Review fixes for #1781: - One rule for cards: the world-overlay host hands its hit test to the pick registry, and every click handler reads the topmost interactive card or label once per click (`clickCard`, `isUnderOtherCard` in src/data/pickRegistry.js), so all handlers agree in any listener order. A layer whose own card or label is on top acts on it whatever is drawn under it; a layer under another layer's card neither acts nor treats the click as empty space (a tracked aircraft stays tracked, a selection stays selected); Context names nothing under a card. A selected news card over a vessel no longer opens the link and selects the vessel. - With one rule, the per-owner arbitration options are no longer read and are removed: `passive`, `expanded` and `declinesClick` pick owners, `rememberClickPickActions`, `isActedOnByOtherLayer`, card backgrounds and `cardKeepsClick`. The dispatcher is unchanged from main. - A drag that ends on a quake disc, label or card does nothing; opening the USGS page or clearing the selection needs a clean click. - A click on the map under another layer's card opens no Street Level ground image. - A CCTV card that is going away is still not the scene under it. - Docs and changelog describe the new rule. --- changelog.d/1781-earthquake-click-details.md | 8 +- docs/CURRENT-STATE.md | 91 +++------ scripts/format-scope.json | 6 +- scripts/package-boundaries.json | 3 +- src/app/layers/earthquakes.js | 3 +- src/app/layers/streetLevel.js | 4 +- src/app/layers/submarineCables.js | 4 +- src/cameraHandoff.test.mjs | 12 +- src/data/aisLiveVessels.test.mjs | 123 ++++++------ src/data/bhoteKoshiEvent.js | 11 +- src/data/bhoteKoshiEvent.test.mjs | 10 +- src/data/bhoteKoshiLocator.js | 30 +-- src/data/bhoteKoshiLocator.test.mjs | 38 ++-- src/data/cctv.test.mjs | 4 +- src/data/directions.test.mjs | 54 ++++-- src/data/firmsInteraction.test.mjs | 91 +++++---- src/data/localGeojsonCore.js | 4 + src/data/localGeojsonDraw.test.mjs | 19 ++ src/data/pickOwnerExpanded.test.mjs | 180 ------------------ src/data/pickRegistry.js | 176 +++++------------ src/data/pickRegistry.test.mjs | 171 +++++------------ src/data/pickedContext.js | 28 +-- src/data/pickedContext.test.mjs | 74 +------ src/data/trailRenderer.js | 8 +- src/input/dispatcher.js | 9 +- src/layers/alpr/presentation.js | 4 + src/layers/alpr/presentation.test.mjs | 57 ++++++ src/layers/bikeshare/selection.js | 4 + src/layers/bikeshare/selection.test.mjs | 68 +++++++ src/layers/cctv/lifecycle.js | 117 ++++-------- src/layers/cctv/lifecycle.test.mjs | 97 ++++------ src/layers/cyclones/index.js | 72 +------ src/layers/cyclones/index.test.mjs | 64 ++----- src/layers/directions/index.js | 6 +- src/layers/droneAirspace/index.js | 22 +-- src/layers/droneAirspace/ownership.test.mjs | 26 +-- src/layers/earthquakes/index.js | 85 +++------ src/layers/earthquakes/selection.test.mjs | 156 +++++++++------ src/layers/firms/selection.js | 56 ++---- src/layers/flights/lifecycle.js | 14 -- src/layers/flights/ownership.test.mjs | 46 +++++ src/layers/flights/tracking.js | 6 +- src/layers/ghostMaps/index.js | 26 +-- src/layers/ghostMaps/lifecycle.test.mjs | 16 +- src/layers/installations/selection.js | 4 + src/layers/installations/selection.test.mjs | 25 +++ src/layers/launches/clickYield.test.mjs | 13 +- src/layers/launches/lifecycle.js | 22 +-- src/layers/localAdsb/index.js | 3 + src/layers/localAdsb/index.test.mjs | 41 +++- src/layers/military/lifecycle.js | 14 -- src/layers/military/ownership.test.mjs | 46 +++++ src/layers/military/tracking.js | 6 +- src/layers/news/index.js | 17 +- src/layers/news/layer.test.mjs | 28 ++- src/layers/perimeters/index.js | 29 ++- src/layers/perimeters/ownership.test.mjs | 26 +-- src/layers/radio/interaction.js | 27 +-- src/layers/radio/interaction.test.mjs | 73 +++---- src/layers/rail/follow.test.mjs | 20 ++ src/layers/rail/selection.js | 4 + src/layers/satellites/interaction.js | 6 +- src/layers/satellites/interaction.test.mjs | 65 +++++++ src/layers/shipwrecks/index.js | 23 +-- src/layers/shipwrecks/index.test.mjs | 8 +- src/layers/streetLevel/selection.js | 30 +-- src/layers/streetLevel/selection.test.mjs | 99 ++++++---- src/layers/submarineCables/index.js | 1 - src/layers/submarineCables/interaction.js | 32 +--- .../submarineCables/interaction.test.mjs | 32 +--- src/layers/transit/lifecycle.test.mjs | 25 +++ src/layers/transit/selection.js | 4 + src/layers/vessels/lifecycle.js | 6 +- src/layers/vessels/selection.js | 94 +++------ .../wildlifeSightings/ownership.test.mjs | 2 + src/layers/wildlifeSightings/selection.js | 15 +- .../wildlifeSightings/selection.test.mjs | 36 ++-- src/overlays/worldOverlay.js | 4 + src/scenes/interactions.js | 4 + src/scenes/interactionsView.test.mjs | 38 ++++ src/ui/applicationShell.js | 1 - src/ui/cockpitOrbitalFocus.js | 8 +- src/ui/cockpitOrbitalFocus.test.mjs | 18 ++ src/ui/entityContextBridge.js | 26 +-- src/ui/entityContextBridge.test.mjs | 92 ++++----- src/ui/wildlifeSightingCard.test.mjs | 2 + src/voice/analystAccessors.test.mjs | 1 - 87 files changed, 1398 insertions(+), 1775 deletions(-) delete mode 100644 src/data/pickOwnerExpanded.test.mjs create mode 100644 src/layers/alpr/presentation.test.mjs create mode 100644 src/layers/bikeshare/selection.test.mjs create mode 100644 src/layers/satellites/interaction.test.mjs diff --git a/changelog.d/1781-earthquake-click-details.md b/changelog.d/1781-earthquake-click-details.md index 8dc909f6d0..595083a3f1 100644 --- a/changelog.d/1781-earthquake-click-details.md +++ b/changelog.d/1781-earthquake-click-details.md @@ -1,7 +1,7 @@ - Make earthquake discs and magnitude labels selectable, with magnitude, USGS class, depth, location, time and source details. Labels also fly to the quake; - the selected disc shows a fading gradient and bounded contour animation. - Prevent dead or duplicate taps across the affected overlay cards, nearby - contacts and passive trails/routes, including radio and Street Level pick - windows, and keep the Context panel from taking a card's click + the selected disc shows a fading gradient and bounded contour animation. A + drag ending on a quake does nothing. The card or label painted on top now + takes a click in every layer: what is drawn under it neither acts nor loses + its selection, and the Context panel names nothing there (Manjunath, @manjunath22466, #1781). diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md index 57f59afdaa..1179ff36b6 100644 --- a/docs/CURRENT-STATE.md +++ b/docs/CURRENT-STATE.md @@ -2061,75 +2061,32 @@ the M6 framing. The package takes clicks, picking, context, focus, the ground height, the opener, the painter and the translator by injection (`src/app/layers/earthquakes.js`); without input and picking it draws and takes no clicks, and its labels stay non-interactive. -On a coarse pointer, a nearby FIRMS or CCTV icon that requires an exact hit -does not swallow a quake card or label tap, or a tap on a vessel's own card. -Owners that pick nearby contacts register as `expanded` pick owners: flights, -military aircraft, vessels, radio and Street Level, and a quake card or label -yields to one the shared touch contact (14 px) reaches. Flights, military and -vessels act on that contact, and so do radio and Street Level, which also pick -through their own windows (17 and 9 px). A station or Street Level item found -only through that window, not as the exact hit or the touch contact, yields to -another layer's card or label painted over it, so a quake card or label beside -one acts alone, with a mouse or a coarse pointer; under such a card, their own -touch contact stays theirs even when the window names another item. Fire and -CCTV cards in turn -yield to a touch contact whose layer acts on it. The aircraft a layer already -tracks and Street Level's position marker are passive picks, since a click on -either does nothing, and the aircraft layers decline a tap that drifts past -the click travel or comes in cockpit mode (`declinesClick`), as CCTV declines -any click that is not clean, so a card over them keeps that tap. The pick -registry records which owners act on a click's exact hit and touch contact -when the click first reads them (`rememberClickPickActions`), and every layer -asks that record for the rest of -the click, so an aircraft that starts tracking during the click does not leave -it to a later card handler as well. Fire, CCTV and vessel cards, like the -quake's, act over a passive owner's pick (a flight trail, the directions -route); with no card there, that pick still leaves a selection alone. The -Bhote Koshi trigger-record callout (`src/data/bhoteKoshiLocator.js`) opens its -source on a click, as its keyboard action does, and yields in the same way: to -a drag, and to a layer that acts on its exact pick or touch contact. Context -(`src/ui/entityContextBridge.js`) names what a click identifies, except under a -world-overlay card or label when the item's owner does not act on that hit -(`cardKeepsClick` in `src/data/pickedContext.js`): a passive route, or a fire -or camera reached only as a nearby contact. The card takes that click. +A press that travels past the tracking click limit is a drag, not a pick: the +quake handler ignores it, and opening the source or clearing the selection +also needs a short press (`src/data/trackingClickGesture.js`). Quake discs are deliberately not registered in the pick-ownership registry, like drone airspace and fire perimeters: sibling layers read a disc as empty -space, so their cards, near-miss taps and deselection work over a quake as -before. When another layer's card or label is painted over a disc (a fire card -on a large quake), the quake handler yields to it rather than selecting the -quake beneath. The same rule holds the other way: drone airspace and fire -perimeters do not select a zone or incident from a shape hit while another -layer's card or label is the topmost overlay entry, so a quake card or -magnitude label over one of them acts once, as the quake's. Items of layers -that never act on clicks (air-quality stations, traffic lines, OSM places) do -not block the quake card or labels. A bare area click with nothing painted on -top still selects the area and clears the quake selection. These rules hold in -any listener order because world-overlay hit rectangles are what is painted on -screen until the next paint: an overlay change (a click subscriber publishing -its selection card) no longer clears them mid-click, and a paint that draws -nothing clears them (`src/overlays/worldOverlay.js`). -Card consumers resolve the unfiltered top painted entry before acting, so a -covered vessel, fire, wildlife, news, CCTV, perimeter, ghost-map or shipwreck -card does not act alongside the card above it; drone-airspace shapes use the -same top-entry check (their cards are not interactive). A top news or wildlife -card still acts over another layer's scene item, as before, so a card over a -flight trail (registered as a no-op for every layer) or a directions route is -never a dead click. A click on another layer's card does not activate a covered -card of these layers or clear their selection; a marker of theirs under that -card is still theirs to select. Flight trails and the directions route line and -markers are passive pick owners (`registerPickOwner(…, { passive })`): still -not empty space (`isOwnedByOtherLayer`), but `isActedOnByOtherLayer` leaves -them out, so the quake card and magnitude labels act over them, as do fire, -vessel and CCTV cards. Directions selects only its maneuver steps, though any -other click still clears a selected step. Submarine cables and rocket -launches, whose own overlays are not -interactive, stand aside when any overlay entry is under the click, so a card -or label over a cable or a launch marker acts once. Layers whose shapes stand -aside like this (drone airspace, fire perimeters, quake discs, cables, -launches) register them with `registerCardBackground`, and a live top CCTV card -acts over any shape `isCardBackground` names; unknown identified objects and -registered foreign owners still block it. An empty-map click keeps its existing -deselection behavior. +space, so their near-miss taps and deselection work over a quake as before, +and a disc yields to another layer's registered pick (an aircraft) under it. +The card or label painted on top takes the click. The world-overlay host hands +its hit test to the pick registry (`setClickCardHitTest`), and every click +handler reads the topmost interactive card or label at the click through +`clickCard(click)`, once per click, so all of them agree in any listener order +(`src/data/pickRegistry.js`). A layer whose own card or label is on top acts +on it, whatever is drawn under it: an aircraft, a vessel, a fire, a camera, a +trail, a route. A layer under another layer's card or label +(`isUnderOtherCard`) does nothing: it neither acts on its item there nor +treats the click as empty space, so a tracked aircraft stays tracked and a +selection stays selected. Context (`src/ui/entityContextBridge.js`) names +nothing under a card. With no card on top, the scene rules are unchanged. +World-overlay hit rectangles are what is painted on screen until the next +paint: an overlay change (a click subscriber publishing its selection card) +no longer clears them mid-click, and a paint that draws nothing clears them +(`src/overlays/worldOverlay.js`). A click on the map under another layer's +card opens no Street Level ground image. The Bhote Koshi trigger-record +callout (`src/data/bhoteKoshiLocator.js`) opens its source on a click, as its +keyboard action does, and ignores a drag; its evidence cards act only when +they are the card on top. Air quality (`./layers/air-quality`) draws its station discs as one renderer draw set of ground-clamped fills and reads the view through the camera port; it diff --git a/scripts/format-scope.json b/scripts/format-scope.json index 993e64a297..31a3d35c5e 100644 --- a/scripts/format-scope.json +++ b/scripts/format-scope.json @@ -439,7 +439,6 @@ "src/layers/earthquakes/ownership.test.mjs", "src/layers/earthquakes/selection.test.mjs", "src/layers/submarineCables/interaction.test.mjs", - "src/data/pickOwnerExpanded.test.mjs", "src/ui/entityContextBridge.test.mjs", "src/layers/launches/clickYield.test.mjs", "src/app/layers/earthquakeRipples.js", @@ -1588,5 +1587,8 @@ "src/ui/layerFinder.test.mjs", "src/data/wikidataCities.js", "src/data/wikidataCities.test.mjs", - "scripts/build-wikidata-cities.mjs" + "scripts/build-wikidata-cities.mjs", + "src/layers/bikeshare/selection.test.mjs", + "src/layers/satellites/interaction.test.mjs", + "src/layers/alpr/presentation.test.mjs" ] diff --git a/scripts/package-boundaries.json b/scripts/package-boundaries.json index bc2440f299..cec3ad4fa6 100644 --- a/scripts/package-boundaries.json +++ b/scripts/package-boundaries.json @@ -2544,7 +2544,8 @@ "src/layers/earthquakes/model.js", "src/layers/earthquakes/source.js", "src/layers/earthquakes/records.js", - "src/time/worldClock.js" + "src/time/worldClock.js", + "src/data/trackingClickGesture.js" ], "external": ["cesium"] }, diff --git a/src/app/layers/earthquakes.js b/src/app/layers/earthquakes.js index 1862f4736e..87b79743d4 100644 --- a/src/app/layers/earthquakes.js +++ b/src/app/layers/earthquakes.js @@ -1,6 +1,5 @@ import { createEarthquakesLayer } from '../../layers/earthquakes/index.js'; import { overlayHost } from './overlayHost.js'; -import { hitTestWorldOverlay } from '../../overlays/worldOverlay.js'; import { inputFor } from '../../input/dispatcher.js'; import * as picking from '../../data/pickRegistry.js'; import * as context from '../../data/contextStore.js'; @@ -33,7 +32,7 @@ export const earthquakeCardText = Object.freeze({ */ export function createApplicationEarthquakes(options) { return createEarthquakesLayer({ - overlayHost: { ...overlayHost, hitTest: hitTestWorldOverlay }, + overlayHost, input: (viewer) => inputFor(viewer), picking, context, diff --git a/src/app/layers/streetLevel.js b/src/app/layers/streetLevel.js index 964d495300..3b7c7cc0b9 100644 --- a/src/app/layers/streetLevel.js +++ b/src/app/layers/streetLevel.js @@ -6,7 +6,6 @@ import { createPanoramaxProvider } from '../../layers/streetLevel/providers/pano import * as picking from '../../data/pickRegistry.js'; import * as scenePick from '../../data/scenePick.js'; import * as render from '../../renderGovernor.js'; -import { hitTestWorldOverlay } from '../../overlays/worldOverlay.js'; /** The browser Maps key the scene was started with (src/app/scene.js). */ const googleApiKey = () => globalThis.window?.__GOOGLE_MAPS_API_KEY__ || null; @@ -36,7 +35,6 @@ export function createApplicationStreetLevel({ }) { return createStreetLevelLayer({ providers, - // Hit-testing lets a card painted over a near miss keep its click. - services: { picking, scenePick, render, overlayHit: hitTestWorldOverlay }, + services: { picking, scenePick, render }, }); } diff --git a/src/app/layers/submarineCables.js b/src/app/layers/submarineCables.js index 5b19b8cf10..7b9299fc3c 100644 --- a/src/app/layers/submarineCables.js +++ b/src/app/layers/submarineCables.js @@ -1,12 +1,10 @@ import { createSubmarineCableLayer } from '../../layers/submarineCables/index.js'; import { overlayHost } from './overlayHost.js'; -import { hitTestWorldOverlay } from '../../overlays/worldOverlay.js'; import * as picking from '../../data/pickRegistry.js'; /** Wire cable source geometry to the application overlay host. */ export function createApplicationCables(options) { return createSubmarineCableLayer({ - // Hit-testing lets a card painted over a cable keep its click. - overlayHost: { ...overlayHost, hitTest: hitTestWorldOverlay }, + overlayHost, picking, mapStackEventTarget: typeof window !== 'undefined' ? window : null, ...options, diff --git a/src/cameraHandoff.test.mjs b/src/cameraHandoff.test.mjs index 747a2f0a97..36b3380afa 100644 --- a/src/cameraHandoff.test.mjs +++ b/src/cameraHandoff.test.mjs @@ -403,10 +403,11 @@ test('vessel and fire layers announce valid clicks and never fly cameras', () => 'vessel click', ); ordered(vesselClick, [ + 'clickCard?.(event)', + 'selectAndFocusVessel(carded)', "isOwnedByOtherLayer('ais-live-vessels', pickedId)", - '_vesselOverlayHost.hitTest?.(', 'selectAndFocusVessel(record)', - ], 'vessel sibling ownership'); + ], 'vessel card on top, then sibling ownership'); const vesselFocus = body( vessels, /function selectAndFocusVessel\(record\) \{([\s\S]*?)\n \}/, @@ -419,8 +420,9 @@ test('vessel and fire layers announce valid clicks and never fly cameras', () => 'fire click', ); ordered(fireClick, [ - 'isOwnedByOtherLayer(id, pickedId)', - 'overlayHost.hitTest?.(', + 'clickCard?.(event)', 'selectAndFocusFire(carded)', - ], 'fire sibling ownership'); + 'isOwnedByOtherLayer(id, pickedId)', + 'clearFireSelection()', + ], 'fire card on top, then sibling ownership'); }); diff --git a/src/data/aisLiveVessels.test.mjs b/src/data/aisLiveVessels.test.mjs index fc2c09a3f9..f2a604d359 100644 --- a/src/data/aisLiveVessels.test.mjs +++ b/src/data/aisLiveVessels.test.mjs @@ -32,7 +32,12 @@ import aisLiveVesselsLayer from './aisLiveVessels.js'; import { registerEntityContext, selectEntityContext } from './contextStore.js'; import { WORLD_FOCUS_REQUEST_EVENT } from '../worldFocus.js'; import { ensureGeoidReady, geoidHeight } from './geoid.js'; -import { registerPickOwner, unregisterPickOwner } from './pickRegistry.js'; +import { + isUnderOtherCard, + registerPickOwner, + setClickCardHitTest, + unregisterPickOwner, +} from './pickRegistry.js'; import { applyVesselOverlayPolicy } from './vesselLabels.js'; import { fakeInput } from '../input/testDoubles.mjs'; import { layerFeedState } from './manager.js'; @@ -490,7 +495,7 @@ test('first accepted position ends grace and warm data survives later open silen const clock = makeFakeAisRuntime(7000); const record = makeRecord(); _setAisRuntimeForTest(clock.runtime); - _setVesselOverlayHostForTest({ + useVesselHost({ setEntries() {}, setVisible() {}, clearSource() {}, @@ -540,7 +545,7 @@ test('first accepted position ends grace and warm data survives later open silen assert.equal(feed.error, 'awaiting usable AIS positions…'); } finally { _setVesselStateForTest({ enabled: false }); - _setVesselOverlayHostForTest(); + useVesselHost(); _setAisRuntimeForTest(); } }); @@ -1643,7 +1648,7 @@ test('vessel host publication preserves the shipped grid winner and separation s }, }, }); - _setVesselOverlayHostForTest({ + useVesselHost({ setEntries(sourceId, entries, options) { publications.push({ sourceId, entries, options }); }, @@ -1667,7 +1672,7 @@ test('vessel host publication preserves the shipped grid winner and separation s } finally { unbind(); _setVesselStateForTest({ enabled: false }); - _setVesselOverlayHostForTest(); + useVesselHost(); } }); @@ -1694,7 +1699,7 @@ test('vessel real layer lifecycle publishes protected selection and leaves no st globalThis.window.addEventListener('gev:world-request-focus', (event) => { focusRequests.push(event.detail); }); - _setVesselOverlayHostForTest(host); + useVesselHost(host); _setVesselStateForTest({ viewer: { get canvas() { @@ -1743,7 +1748,7 @@ test('vessel real layer lifecycle publishes protected selection and leaves no st ); } finally { _setVesselStateForTest({ enabled: false }); - _setVesselOverlayHostForTest(); + useVesselHost(); if (hadWindow) globalThis.window = priorWindow; else delete globalThis.window; globalThis.document = priorDocument; @@ -1849,6 +1854,15 @@ test('vessel interaction wire: a vessel with an id and no MMSI is selected by cl } }); +/** + * Hand the vessel layer an overlay host, and answer the pick registry's + * card-on-top question from the same host, as the application does. + */ +function useVesselHost(host) { + _setVesselOverlayHostForTest(host); + setClickCardHitTest(host ? (x, y) => host.hitTest(x, y) : null); +} + /** * Overlay-host recorder whose hitTest answers with one card id. The real host * only publishes rects for `interactive` entries, so a stub returning a hit is @@ -1880,9 +1894,7 @@ test('vessel interaction wire: clicking a card selects and transfers, like the s harness.windowTarget.addEventListener(WORLD_FOCUS_REQUEST_EVENT, (event) => requests.push(event.detail), ); - _setVesselOverlayHostForTest( - hostWithCardHit(`vessel:${harness.record.mmsi}`), - ); + useVesselHost(hostWithCardHit(`vessel:${harness.record.mmsi}`)); try { harness.handler.click({ position: { x: 10, y: 20 } }); assert.equal( @@ -1893,7 +1905,7 @@ test('vessel interaction wire: clicking a card selects and transfers, like the s assert.equal(requests[0].kind, 'vessel'); assert.equal(requests[0].id, harness.record.mmsi); } finally { - _setVesselOverlayHostForTest(null); + useVesselHost(null); harness.cleanup(); } }); @@ -1908,9 +1920,7 @@ test('vessel interaction wire: clicking the selected vessel card refocuses exact harness.windowTarget.addEventListener(WORLD_FOCUS_REQUEST_EVENT, (event) => requests.push(event.detail), ); - _setVesselOverlayHostForTest( - hostWithCardHit(`vessel:${harness.record.mmsi}`), - ); + useVesselHost(hostWithCardHit(`vessel:${harness.record.mmsi}`)); try { harness.handler.click({ position: { x: 10, y: 20 } }); assert.equal( @@ -1921,29 +1931,31 @@ test('vessel interaction wire: clicking the selected vessel card refocuses exact assert.equal(requests[0].id, harness.record.mmsi); assert.equal(harness.trail.clearCalls, 0); } finally { - _setVesselOverlayHostForTest(null); + useVesselHost(null); harness.cleanup(); } }); -test('vessel interaction wire: a covered card yields while a real vessel pick still focuses', () => { +// Another layer's card on top takes the click from the vessel card under it +// and from a vessel icon under it alike. +test('vessel interaction wire: a covered card and a covered vessel pick both yield', () => { for (const ownPick of [false, true]) { const harness = installWireHarness(ownPick ? { id: makeRecord().mmsi } : null); const requests = []; harness.windowTarget.addEventListener(WORLD_FOCUS_REQUEST_EVENT, (event) => requests.push(event.detail), ); - _setVesselOverlayHostForTest( + useVesselHost( hostWithCardHit(`vessel:${harness.record.mmsi}`, { sourceId: 'earthquakes', entryId: 'quake:cover', }), ); try { harness.handler.click({ position: { x: 10, y: 20 } }); - assert.equal(requests.length, ownPick ? 1 : 0); + assert.equal(requests.length, 0, `own pick: ${ownPick}`); assert.equal(aisLiveVesselsLayer.getSelectedInfo()?.mmsi, harness.record.mmsi); } finally { - _setVesselOverlayHostForTest(null); + useVesselHost(null); harness.cleanup(); } } @@ -1960,7 +1972,7 @@ test('vessel interaction wire: an unknown card id preserves selection and never requests.push(event.detail), ); // An evicted vessel's card id resolves to no live record. - _setVesselOverlayHostForTest(hostWithCardHit('vessel:999999999')); + useVesselHost(hostWithCardHit('vessel:999999999')); try { harness.handler.click({ position: { x: 10, y: 20 } }); assert.equal( @@ -1969,52 +1981,47 @@ test('vessel interaction wire: an unknown card id preserves selection and never ); assert.equal(requests.length, 0); } finally { - _setVesselOverlayHostForTest(null); + useVesselHost(null); harness.cleanup(); } }); -test('vessel interaction wire: a sibling-owned pick wins without selection mutation', () => { - // Another layer is already acting on this click; two camera commands is the - // worse failure, so the card is not consulted. +test('vessel interaction wire: the vessel card on top wins over a sibling-owned pick', () => { + // The card painted on top takes the click; the sibling (an aircraft) + // stands aside under it, so there is one camera command, not two. registerPickOwner('flights', (pickedId) => pickedId === 'a1b2c3'); const harness = installWireHarness({ id: 'a1b2c3' }); const requests = []; harness.windowTarget.addEventListener(WORLD_FOCUS_REQUEST_EVENT, (event) => requests.push(event.detail), ); - _setVesselOverlayHostForTest( - hostWithCardHit(`vessel:${harness.record.mmsi}`), - ); + useVesselHost(hostWithCardHit(`vessel:${harness.record.mmsi}`)); try { harness.handler.click({ position: { x: 10, y: 20 } }); assert.equal( aisLiveVesselsLayer.getSelectedInfo()?.mmsi, harness.record.mmsi, ); - assert.equal(requests.length, 0); + assert.equal(requests.length, 1); } finally { - _setVesselOverlayHostForTest(null); + useVesselHost(null); harness.cleanup(); unregisterPickOwner('flights'); } }); -// The aircraft layer runs first and starts tracking the plane under the -// vessel's card, making it passive. The card reads the owners that acted -// when the click resolved, so it still yields: one action. -test('vessel interaction wire: a card yields to an aircraft that starts tracking in the same click', (t) => { +// The aircraft layer runs first. Under the vessel's card it stands aside, so +// the card takes the click: one action. +test('vessel interaction wire: a card over an aircraft takes the click; the aircraft does not track', (t) => { let tracked = null; - registerPickOwner('test-planes', (pickedId) => pickedId === 'plane:9', { - expanded: true, - passive: (pickedId) => pickedId === tracked, - }); + registerPickOwner('test-planes', (pickedId) => pickedId === 'plane:9'); t.after(() => unregisterPickOwner('test-planes')); const harness = installWireHarness( { id: 'plane:9' }, { selectedRecord: null }, {}, (event) => { + if (isUnderOtherCard(event)) return; if (event.hit?.id === 'plane:9') tracked = 'plane:9'; }, ); @@ -2022,16 +2029,17 @@ test('vessel interaction wire: a card yields to an aircraft that starts tracking harness.windowTarget.addEventListener(WORLD_FOCUS_REQUEST_EVENT, (event) => requests.push(event.detail), ); - _setVesselOverlayHostForTest( - hostWithCardHit(`vessel:${harness.record.mmsi}`), - ); + useVesselHost(hostWithCardHit(`vessel:${harness.record.mmsi}`)); try { harness.handler.click({ position: { x: 10, y: 20 } }); - assert.equal(tracked, 'plane:9', 'the aircraft starts tracking'); - assert.equal(requests.length, 0, 'the vessel card yields'); - assert.equal(aisLiveVesselsLayer.getSelectedInfo()?.mmsi ?? null, null); + assert.equal(tracked, null, 'the aircraft does not track'); + assert.equal(requests.length, 1, 'the vessel card acts'); + assert.equal( + aisLiveVesselsLayer.getSelectedInfo()?.mmsi, + harness.record.mmsi, + ); } finally { - _setVesselOverlayHostForTest(null); + useVesselHost(null); harness.cleanup(); } }); @@ -2048,7 +2056,7 @@ test('vessel interaction wire: a card over a trail selects; a bare trail is a no harness.windowTarget.addEventListener(WORLD_FOCUS_REQUEST_EVENT, (event) => requests.push(event.detail), ); - _setVesselOverlayHostForTest( + useVesselHost( hostWithCardHit(carded ? `vessel:${harness.record.mmsi}` : null), ); try { @@ -2059,16 +2067,15 @@ test('vessel interaction wire: a card over a trail selects; a bare trail is a no carded ? harness.record.mmsi : null, ); } finally { - _setVesselOverlayHostForTest(null); + useVesselHost(null); harness.cleanup(); } } }); -// A coarse tap on the vessel's card finds a fire nearby through the shared -// touch contact. The fire layer acts only on exact hits, so the card keeps the -// tap; an exact fire pick under the card still belongs to the fire. -test('vessel interaction wire: a coarse near miss of an exact-only item keeps the card tap', (t) => { +// A coarse tap on the vessel's card over a fire, nearby or exact: the card on +// top keeps the tap. +test('vessel interaction wire: the card keeps a tap over a nearby or exact fire', (t) => { const previous = globalThis.matchMedia; globalThis.matchMedia = () => ({ matches: true }); t.after(() => { @@ -2088,18 +2095,16 @@ test('vessel interaction wire: a coarse near miss of an exact-only item keeps th harness.windowTarget.addEventListener(WORLD_FOCUS_REQUEST_EVENT, (event) => requests.push(event.detail), ); - _setVesselOverlayHostForTest( - hostWithCardHit(`vessel:${harness.record.mmsi}`), - ); + useVesselHost(hostWithCardHit(`vessel:${harness.record.mmsi}`)); try { harness.handler.click({ position: { x: 10, y: 20 } }); - assert.equal(requests.length, exact ? 0 : 1, `exact fire: ${exact}`); + assert.equal(requests.length, 1, `exact fire: ${exact}`); assert.equal( - aisLiveVesselsLayer.getSelectedInfo()?.mmsi ?? null, - exact ? null : harness.record.mmsi, + aisLiveVesselsLayer.getSelectedInfo()?.mmsi, + harness.record.mmsi, ); } finally { - _setVesselOverlayHostForTest(null); + useVesselHost(null); harness.cleanup(); } } @@ -2130,7 +2135,7 @@ for (const card of ['live', 'stale', 'absent', 'covered']) { ); return { sourceId: 'cctv', entryId: 'vessel:999999999' }; }; - _setVesselOverlayHostForTest(host); + useVesselHost(host); try { harness.handler.click({ position: { x: 10, y: 20 } }); assert.equal( @@ -2139,7 +2144,7 @@ for (const card of ['live', 'stale', 'absent', 'covered']) { ); assert.equal(requests.length, card === 'live' ? 1 : 0); } finally { - _setVesselOverlayHostForTest(null); + useVesselHost(null); harness.cleanup(); unregisterPickOwner('weather-cyclones'); } diff --git a/src/data/bhoteKoshiEvent.js b/src/data/bhoteKoshiEvent.js index b47dca8e2b..a2da738282 100644 --- a/src/data/bhoteKoshiEvent.js +++ b/src/data/bhoteKoshiEvent.js @@ -2959,11 +2959,12 @@ export function createBhoteKoshiEventLayer({ : Number.isFinite(clientY) && bounds ? clientY - bounds.top : Number.NaN; - const hit = overlayHost.hitTest?.(x, y, { - sourceId: BHOTE_KOSHI_OVERLAY_SOURCE_ID, - filter: (entry) => String(entry?.id || '').startsWith('evidence-card-'), - }); - if (typeof hit?.entry?.activate !== 'function') return; + // Only the card painted on top acts: an evidence card covered by + // another layer's card or label leaves the click to that card. + const hit = overlayHost.hitTest?.(x, y); + if (hit?.sourceId !== BHOTE_KOSHI_OVERLAY_SOURCE_ID) return; + if (!String(hit.entry?.id || '').startsWith('evidence-card-')) return; + if (typeof hit.entry.activate !== 'function') return; hit.entry.activate(); } diff --git a/src/data/bhoteKoshiEvent.test.mjs b/src/data/bhoteKoshiEvent.test.mjs index 5eb4b78634..d40bd9933f 100644 --- a/src/data/bhoteKoshiEvent.test.mjs +++ b/src/data/bhoteKoshiEvent.test.mjs @@ -2114,6 +2114,7 @@ test('Debris-Dammed Lake card opens its source and is armed for approved local v }; const viewer = eventViewer(); let activeCard = null; + let coveredBy = null; const layer = createBhoteKoshiEventLayer({ eventLoader: async () => event, imagerySpecFactory: async (url) => ({ url }), @@ -2131,9 +2132,11 @@ test('Debris-Dammed Lake card opens its source and is armed for approved local v }, setVisible() {}, clearSource() {}, + // As the host does: unfiltered, the topmost entry. hitTest(_x, _y, options) { + if (coveredBy && !options?.sourceId) return coveredBy; if (!activeCard || options?.filter?.(activeCard) === false) return null; - return { entry: activeCard }; + return { sourceId: 'bhote-koshi-witnesses', entry: activeCard }; }, }, renderHost: { request() {}, hold() {}, release() {} }, @@ -2160,6 +2163,11 @@ test('Debris-Dammed Lake card opens its source and is armed for approved local v } finally { releasePointer(lease); } + // Another layer's card painted over the evidence card takes the click. + coveredBy = { sourceId: 'earthquake-card', entryId: 'earthquake-card:q' }; + viewer._test.canvas.dispatch('click', { offsetX: 640, offsetY: 420 }); + assert.equal(opened.length, 0, 'a covered evidence card does not open'); + coveredBy = null; viewer._test.canvas.dispatch('click', { offsetX: 640, offsetY: 420 }); assert.deepEqual(opened, [[ event.evidenceSpine[1].media.sourceUrl, diff --git a/src/data/bhoteKoshiLocator.js b/src/data/bhoteKoshiLocator.js index 20598df4b7..d9aacfad4d 100644 --- a/src/data/bhoteKoshiLocator.js +++ b/src/data/bhoteKoshiLocator.js @@ -1,10 +1,9 @@ import { clearOverlaySource, - hitTestWorldOverlay, setOverlayEntries, } from '../overlays/worldOverlay.js'; import { inputFor } from '../input/dispatcher.js'; -import { isActedOnByOtherLayer, resolvePickId } from './pickRegistry.js'; +import { clickCard } from './pickRegistry.js'; import { isTrackingSelectionGesture } from './trackingClickGesture.js'; import { governorRequestRender } from '../renderGovernor.js'; import { drawOf, findCamera } from '../render/rendererOf.js'; @@ -284,7 +283,6 @@ export function createBhoteKoshiLocatorLayer({ scheduleDelay = (callback, delayMs) => setTimeout(callback, delayMs), cancelDelay = (handle) => clearTimeout(handle), input = inputFor, - hitTest = hitTestWorldOverlay, } = {}) { let _viewer = null; // The globe click that opens an actionable callout of ours on top. @@ -1153,9 +1151,8 @@ export function createBhoteKoshiLocatorLayer({ /** * An actionable callout of ours (the trigger record's) is a card painted * over the globe: a click on it opens its source, as its keyboard action - * does. Like the other cards, it leaves a drag alone and yields to a layer - * that acts on what is under it (an aircraft, a vessel): its exact pick, or - * a coarse tap's touch contact whose layer acts on nearby contacts. + * does. Like the other cards, it leaves a drag alone and, on top, takes the + * click over whatever is drawn under it. */ function installCalloutClick(viewer) { if (_removeClick) return; @@ -1168,26 +1165,9 @@ export function createBhoteKoshiLocatorLayer({ _removeClick = clicks?.onClick?.((event) => { if (!_enabled || !isTrackingSelectionGesture(event.gesture)) return; - const top = hitTest?.(event.screenPosition?.x, event.screenPosition?.y); + // The card painted on top, read once per click so every layer agrees. + const top = clickCard(event); if (top?.sourceId !== BHOTE_KOSHI_LOCATOR_OVERLAY_SOURCE_ID) return; - const exactId = resolvePickId(event.topHit ?? null); - if ( - exactId && - isActedOnByOtherLayer(BHOTE_KOSHI_LOCATOR_LAYER_ID, exactId, { - click: event, - }) - ) - return; - const contactId = resolvePickId(event.hit ?? null); - if ( - contactId && - contactId !== exactId && - isActedOnByOtherLayer(BHOTE_KOSHI_LOCATOR_LAYER_ID, contactId, { - expanded: true, - click: event, - }) - ) - return; if (typeof top.entry?.activate === 'function') top.entry.activate(); }) ?? null; } diff --git a/src/data/bhoteKoshiLocator.test.mjs b/src/data/bhoteKoshiLocator.test.mjs index 5c421ec6cb..523e669cd1 100644 --- a/src/data/bhoteKoshiLocator.test.mjs +++ b/src/data/bhoteKoshiLocator.test.mjs @@ -11,7 +11,11 @@ import { import { BHOTE_KOSHI_FLOOD_PATH } from './bhoteKoshiFloodPath.js'; import * as Cesium from 'cesium'; import { setLocale } from '../i18n/index.js'; -import { registerPickOwner, unregisterPickOwner } from './pickRegistry.js'; +import { + registerPickOwner, + setClickCardHitTest, + unregisterPickOwner, +} from './pickRegistry.js'; import { SceneDirector } from '../scenes/director.js'; import { createPlaybackClock } from '../director/clock.js'; import { createDefaultScenePacks } from '../scenes/packs/defaults.js'; @@ -1071,8 +1075,9 @@ test('a click on the locator callout runs its action', async () => { }; }, }), - hitTest: () => top, }); + // The card on top at a click, as the host answers the pick registry. + setClickCardHitTest(() => top); await layer.init(viewer); await layer.enable(viewer); const click = (extra = {}) => @@ -1103,34 +1108,19 @@ test('a click on the locator callout runs its action', async () => { }; click({ gesture: { travelPx: 30, durationMs: 80 } }); assert.deepEqual(activated, ['trigger'], 'a drag does not open it'); - // An aircraft under it is that layer's click, exact or a touch contact. - registerPickOwner('test-planes', (id) => id === 'plane:1', { - expanded: true, - }); + // On top, it takes the click over an aircraft or a camera under it, exact + // or a touch contact: those layers stand aside under a card. + registerPickOwner('test-planes', (id) => id === 'plane:1'); try { const plane = { set: 'planes:1', id: 'plane:1' }; + const cam = { set: 'cams:1', id: 'cam:1' }; click({ topHit: plane, hit: plane }); click({ topHit: null, hit: plane }); - assert.deepEqual(activated, ['trigger'], 'the aircraft takes it'); + click({ topHit: cam, hit: cam }); + assert.equal(activated.length, 4, 'the callout on top acts each time'); } finally { unregisterPickOwner('test-planes'); - } - // A layer that acts only on exact hits does not take a touch contact, and - // one that ignores this click (a long press on a camera) takes nothing: the - // callout keeps both. - registerPickOwner('test-cameras', (id) => id === 'cam:1', { - declinesClick: (event) => (event?.gesture?.durationMs ?? 0) > 400, - }); - try { - const cam = { set: 'cams:1', id: 'cam:1' }; - click({ topHit: null, hit: cam }); - assert.equal(activated.length, 2, 'a near miss of an exact-only camera'); - click({ topHit: cam, hit: cam, gesture: { travelPx: 0, durationMs: 900 } }); - assert.equal(activated.length, 3, 'a long press the camera ignores'); - click({ topHit: cam, hit: cam }); - assert.equal(activated.length, 3, 'a clean click on the camera is its own'); - } finally { - unregisterPickOwner('test-cameras'); + setClickCardHitTest(null); } await layer.disable(); assert.equal(onClick, null, 'disable removes the click handler'); diff --git a/src/data/cctv.test.mjs b/src/data/cctv.test.mjs index 4fb15c6903..fadac2e1d0 100644 --- a/src/data/cctv.test.mjs +++ b/src/data/cctv.test.mjs @@ -1020,7 +1020,7 @@ test('CCTV repeated in-world clicks dispatch focus only for the one real activat ); assert.match( componentFunctionSource(cctvLayer.init), - /_cctvOverlayHost\.hitTest/, + /clickCard\?\.\(event\)/, ); assert.match( componentFunctionSource(cctvLayer.init), @@ -1028,7 +1028,7 @@ test('CCTV repeated in-world clicks dispatch focus only for the one real activat ); assert.match( componentFunctionSource(cctvLayer.init), - /activateCctvCameraFromWorldClick\(cardId, setActiveCamera\)/, + /activateCctvCameraFromWorldClick\(\s*top\.entryId,/, ); }); diff --git a/src/data/directions.test.mjs b/src/data/directions.test.mjs index 6657c0a27e..1f004e1734 100644 --- a/src/data/directions.test.mjs +++ b/src/data/directions.test.mjs @@ -28,7 +28,7 @@ import { createApplicationDirectionsLayer, } from './directions.js'; import { GROUND_FLOOR_LIFT_M } from './groundFloor.js'; -import { isActedOnByOtherLayer, isOwnedByOtherLayer } from './pickRegistry.js'; +import { isOwnedByOtherLayer, setClickCardHitTest } from './pickRegistry.js'; import { fakeInput } from '../input/testDoubles.mjs'; import { instructionFor } from './routeSteps.js'; import { setLocale } from '../i18n/index.js'; @@ -467,10 +467,9 @@ function ownershipFixture(t) { }); } -// Directions acts only on its maneuver steps. The route line and the A/B -// markers are passive picks: still not empty space to other layers, but a -// card painted over them (a quake card) keeps its click. -test('enabled, directions owns its picks and acts only on its steps', (t) => { +// Directions owns its route, markers and steps while enabled: none of them +// is empty space to other layers. +test('enabled, directions owns its picks', (t) => { ownershipFixture(t); const viewer = { scene: { @@ -488,24 +487,45 @@ test('enabled, directions owns its picks and acts only on its steps', (t) => { 'directions:step:3', ]) assert.equal(isOwnedByOtherLayer('earthquakes', id), true, id); - assert.equal( - isActedOnByOtherLayer('earthquakes', 'directions:route'), - false, - ); - assert.equal( - isActedOnByOtherLayer('earthquakes', 'directions:marker:a'), - false, - ); - assert.equal( - isActedOnByOtherLayer('earthquakes', 'directions:step:3'), - true, - ); } finally { directionsLayer.disable(viewer); } assert.equal(isOwnedByOtherLayer('earthquakes', 'directions:route'), false); }); +// The card or label painted on top takes the click: directions does not even +// pick under another layer's card, so no step is selected or cleared there. +test("another layer's card over directions keeps the click", (t) => { + ownershipFixture(t); + let picks = 0; + const viewer = { + scene: { + pick: () => { + picks++; + return null; + }, + canvas: { clientWidth: 100, clientHeight: 100 }, + }, + }; + const input = fakeInput(viewer); + let top = { sourceId: 'earthquake-card', entryId: 'earthquake-card:ak1' }; + setClickCardHitTest(() => top); + t.after(() => { + setClickCardHitTest(null); + input.destroy(); + }); + directionsLayer.enable(viewer); + try { + input.tap({ x: 10, y: 10 }); + assert.equal(picks, 0, 'covered: the scene under the card is not picked'); + top = null; + input.tap({ x: 10, y: 10 }); + assert.ok(picks > 0, 'open map: the click reaches the scene'); + } finally { + directionsLayer.disable(viewer); + } +}); + test('placing an endpoint takes the pointer, and every exit path gives it back', (t) => { ownershipFixture(t); diff --git a/src/data/firmsInteraction.test.mjs b/src/data/firmsInteraction.test.mjs index 026be0a877..a04b172a23 100644 --- a/src/data/firmsInteraction.test.mjs +++ b/src/data/firmsInteraction.test.mjs @@ -11,7 +11,12 @@ import { buildCellCard, } from './firmsHeatmap.js'; import { fireDetectionKey } from './firmsLabels.js'; -import { registerPickOwner, unregisterPickOwner } from './pickRegistry.js'; +import { + isUnderOtherCard, + registerPickOwner, + setClickCardHitTest, + unregisterPickOwner, +} from './pickRegistry.js'; import { getSelectedEntityContext } from './contextStore.js'; import { setLocale } from '../i18n/index.js'; import { shownEntityLabel } from '../voice/speech.js'; @@ -80,21 +85,24 @@ function harness({ }; const published = []; + const overlayHost = { + setEntries: (sourceId, entries) => published.push(...entries), + setVisible() {}, + clearSource() {}, + hitTest: (_x, _y, { sourceId } = {}) => + !sourceId && topCard + ? topCard + : cardHit + ? { sourceId: 'firms', entryId: cardHit } + : null, + }; + // The card on top at a click, as the host answers the pick registry. + setClickCardHitTest((x, y) => overlayHost.hitTest(x, y)); const layer = createFirmsHeatmapLayer({ ...(feed ? { feed } : {}), id: 'firms-test', name: 'Fires', - overlayHost: { - setEntries: (sourceId, entries) => published.push(...entries), - setVisible() {}, - clearSource() {}, - hitTest: (_x, _y, { sourceId } = {}) => - !sourceId && topCard - ? topCard - : cardHit - ? { sourceId: 'firms', entryId: cardHit } - : null, - }, + overlayHost, }); const draw = fakeDrawPort(); @@ -171,6 +179,7 @@ function harness({ picked = next; }, cleanup() { + setClickCardHitTest(null); Cesium.SceneTransforms.worldToWindowCoordinates = priorProjection; if (hadWindow) globalThis.window = priorWindow; else delete globalThis.window; @@ -331,6 +340,10 @@ test('clicking a fire sprite selects it and requests the camera transfer', () => topCard: { sourceId: 'earthquakes', entryId: 'quake:cover' }, }); try { + // Under another layer's card the sprite is that card's click. + h.click(); + assert.equal(h.requests.length, 0, 'covered: the card takes it'); + h.cover(null); h.click(); assert.equal(h.requests.length, 1); assert.equal(h.requests[0].kind, 'fire'); @@ -435,9 +448,9 @@ test('a click on neither sprite nor card clears without moving the camera', () = } }); -// Sibling layers surface heterogeneous pick shapes. Reading `picked.id` -// directly recognized only bare strings, so an AIS sprite (or satellite, or -// entity) under a fire card let BOTH layers issue a camera command. +// Sibling layers surface heterogeneous pick shapes. Whatever is drawn under +// it, the fire card painted on top takes the click (those layers stand aside +// under another layer's card, so one click does one thing). const SIBLING_PICKS = [ ['flights', 'a1b2c3', { id: 'a1b2c3' }], ['flights', 'a1b2c3', { primitive: { id: 'a1b2c3' } }], @@ -447,7 +460,7 @@ const SIBLING_PICKS = [ ]; for (const [layerId, ownedId, picked] of SIBLING_PICKS) { - test(`a ${layerId} pick shaped ${JSON.stringify(picked)} wins over a card hit`, () => { + test(`a fire card wins over a ${layerId} pick shaped ${JSON.stringify(picked)}`, () => { const fire = makeFire(); registerPickOwner(layerId, (pickedId) => pickedId === ownedId); const h = harness({ @@ -457,11 +470,7 @@ for (const [layerId, ownedId, picked] of SIBLING_PICKS) { }); try { h.click(); - assert.equal( - h.requests.length, - 0, - `the ${layerId} layer is already acting on this click`, - ); + assert.equal(h.requests.length, 1, 'the card on top acts'); } finally { h.cleanup(); unregisterPickOwner(layerId); @@ -474,9 +483,7 @@ for (const [layerId, ownedId, picked] of SIBLING_PICKS) { // still not empty space, so the selection stays. test('a fire card acts over a passive pick; the bare pick leaves the selection', () => { const fire = makeFire(); - registerPickOwner('test-route', (pickedId) => pickedId === 'route:line', { - passive: true, - }); + registerPickOwner('test-route', (pickedId) => pickedId === 'route:line'); const carded = harness({ fires: [fire], picked: { id: 'route:line' }, @@ -505,9 +512,8 @@ test('a fire card acts over a passive pick; the bare pick leaves the selection', }); // A coarse tap on a fire card finds an aircraft nearby through the shared -// touch contact. The flights layer acts on that contact, so the card yields: -// one action, not two. -test('a fire card yields to a touch contact its layer acts on', (t) => { +// touch contact. The card on top takes it; the aircraft layer stands aside. +test('a fire card takes a tap over a touch contact its layer acts on', (t) => { const previous = globalThis.matchMedia; globalThis.matchMedia = () => ({ matches: true }); t.after(() => { @@ -515,9 +521,7 @@ test('a fire card yields to a touch contact its layer acts on', (t) => { else delete globalThis.matchMedia; }); const fire = makeFire(); - registerPickOwner('test-planes', (pickedId) => pickedId === 'plane:1', { - expanded: true, - }); + registerPickOwner('test-planes', (pickedId) => pickedId === 'plane:1'); t.after(() => unregisterPickOwner('test-planes')); const h = harness({ fires: [fire], @@ -526,8 +530,8 @@ test('a fire card yields to a touch contact its layer acts on', (t) => { }); try { h.click(); - assert.equal(h.requests.length, 0, 'the aircraft takes the tap'); - assert.equal(h.layer.getSelectedInfo(), null); + assert.equal(h.requests.length, 1, 'the card takes the tap'); + assert.ok(h.layer.getSelectedInfo()); } finally { h.cleanup(); } @@ -544,9 +548,7 @@ test('a fire card keeps a tap whose contact does not act; bare taps still clear' }); const fire = makeFire(); registerPickOwner('test-cameras', (pickedId) => pickedId === 'cam:1'); - registerPickOwner('test-planes', (pickedId) => pickedId === 'plane:1', { - expanded: true, - }); + registerPickOwner('test-planes', (pickedId) => pickedId === 'plane:1'); t.after(() => { unregisterPickOwner('test-cameras'); unregisterPickOwner('test-planes'); @@ -579,30 +581,27 @@ test('a fire card keeps a tap whose contact does not act; bare taps still clear' } }); -// The aircraft layer runs first and starts tracking the plane it was clicked -// on, which makes that plane passive. The fire card painted over it reads -// the owners that acted when the click resolved, so it still yields. -test('a fire card yields to an aircraft that starts tracking in the same click', (t) => { +// The aircraft layer runs first. Under the fire card painted over its plane +// it stands aside, so the card takes the click: one action, in either order. +test('a fire card over an aircraft takes the click; the aircraft does not track', (t) => { const fire = makeFire(); let tracked = null; - registerPickOwner('test-planes', (pickedId) => pickedId === 'plane:9', { - expanded: true, - passive: (pickedId) => pickedId === tracked, - }); + registerPickOwner('test-planes', (pickedId) => pickedId === 'plane:9'); t.after(() => unregisterPickOwner('test-planes')); const h = harness({ fires: [fire], picked: { id: 'plane:9' }, cardHit: `fire:${fireDetectionKey(fire)}`, firstClick: (event) => { + if (isUnderOtherCard(event)) return; if (event.hit?.id === 'plane:9') tracked = 'plane:9'; }, }); try { h.click(); - assert.equal(tracked, 'plane:9', 'the aircraft starts tracking'); - assert.equal(h.requests.length, 0, 'the fire card yields'); - assert.equal(h.layer.getSelectedInfo(), null); + assert.equal(tracked, null, 'the aircraft does not track'); + assert.equal(h.requests.length, 1, 'the fire card acts'); + assert.ok(h.layer.getSelectedInfo()); } finally { h.cleanup(); } diff --git a/src/data/localGeojsonCore.js b/src/data/localGeojsonCore.js index 88566bc6e5..da6028ed2a 100644 --- a/src/data/localGeojsonCore.js +++ b/src/data/localGeojsonCore.js @@ -22,6 +22,7 @@ import { import { createInfrastructureOverlayEntry } from './infrastructureOverlayEntry.js'; import { createGeojsonPins } from './geojsonPins.js'; import { inputFor as defaultInputFor } from '../input/dispatcher.js'; +import { isUnderOtherCard } from './pickRegistry.js'; import { selectInfraLod, applyInfraEvictionGrace, @@ -1114,6 +1115,9 @@ export function createLocalGeoJsonLayer( const input = inputFor(viewer); _clickSubscription = input.onClick((event) => { if (!_enabled || !_drawn) return; + // Another layer's card or label on top takes the click: the + // item under it neither acts nor reads as empty space. + if (isUnderOtherCard(event)) return; const hit = event.drawHit; if (!hit || !hit.set.startsWith(`${setPrefix}:`)) return; const part = _drawn.parts.get(hit.id); diff --git a/src/data/localGeojsonDraw.test.mjs b/src/data/localGeojsonDraw.test.mjs index bbb993f042..255fb5d522 100644 --- a/src/data/localGeojsonDraw.test.mjs +++ b/src/data/localGeojsonDraw.test.mjs @@ -6,6 +6,7 @@ import { } from './localGeojsonCore.js'; import { localGeoJsonServices } from '../app/localGeojsonServices.js'; import { getContextStore } from './contextStore.js'; +import { setClickCardHitTest } from './pickRegistry.js'; import { readEntityRecord } from './entityRecords.js'; import { bindFakeGroundRenderer } from '../testSupport/fakeGroundRenderer.mjs'; const feature = (id, geometry, properties = { name: `Feature ${id}` }) => ({ @@ -161,6 +162,24 @@ test('polygons fill the ground, lines drape, points stand on pins, all shown', a assert.equal(record?.label, 'Feature p'); }); +// The card or label painted on top takes the click: a feature under another +// layer's card is not selected. +test("another layer's card over a drawn part keeps the click", async (t) => { + const env = await enabledLayer(t, [ + feature('p', { type: 'Polygon', coordinates: square(0, 0) }), + ]); + let top = { sourceId: 'earthquake-card', entryId: 'earthquake-card:ak1' }; + setClickCardHitTest(() => top); + t.after(() => setClickCardHitTest(null)); + const fills = env.fake.set('fills'); + const at = { x: 5, y: 5 }; + env.click({ screenPosition: at, drawHit: { set: fills.spec.id, id: 'p' } }); + assert.equal(env.fake.flights.length, 0, 'covered: not selected'); + top = null; + env.click({ screenPosition: at, drawHit: { set: fills.spec.id, id: 'p' } }); + assert.equal(env.fake.flights.length, 1); +}); + test('a click on a drawn part selects its feature and flies above it', async (t) => { const env = await enabledLayer(t, [ feature('p', { type: 'Polygon', coordinates: square(0, 0) }), diff --git a/src/data/pickOwnerExpanded.test.mjs b/src/data/pickOwnerExpanded.test.mjs deleted file mode 100644 index ea013e7ef6..0000000000 --- a/src/data/pickOwnerExpanded.test.mjs +++ /dev/null @@ -1,180 +0,0 @@ -/** - * Which pick owners select nearby contacts. A coarse tap's shared contact - * hit (`pickContact`) can land on a contact near an exact miss; only owners - * whose click handlers act on such a hit, or on their own pick window, - * register `expanded`, so a quake card or label yields to them and not to - * exact-only owners (FIRMS, CCTV). Each case runs the layer's own - * registration code (its enable or install step) with stand-in services. - */ -import test from 'node:test'; -import assert from 'node:assert/strict'; -import { createLifecycle as createFlightLifecycle } from '../layers/flights/lifecycle.js'; -import { createLifecycle as createMilitaryLifecycle } from '../layers/military/lifecycle.js'; -import { createLifecycle as createVesselLifecycle } from '../layers/vessels/lifecycle.js'; -import { createInteraction as createRadioInteraction } from '../layers/radio/interaction.js'; -import { createSelection as createStreetSelection } from '../layers/streetLevel/selection.js'; -import { fakeInput } from '../input/testDoubles.mjs'; -import { STREET_LEVEL_LAYER_ID } from '../layers/streetLevel/policy.js'; -import * as picking from './pickRegistry.js'; - -/** - * A stand-in for any collaborator: every property is another stand-in and - * every call returns one, except the keys `given` names. Not a thenable. - */ -function stub(given = {}) { - return new Proxy(function stand() {}, { - get(target, key) { - if (key in given) return given[key]; - if (key === 'then' || typeof key === 'symbol') return undefined; - return stub(); - }, - set(target, key, value) { - given[key] = value; - return true; - }, - apply: () => stub(), - }); -} - -/** Picking services that record each registration's options. */ -function recordingPicking() { - const registered = new Map(); - return { - registered, - services: { - ...picking, - registerPickOwner(layerId, predicate, options) { - registered.set(layerId, options ?? {}); - picking.registerPickOwner(layerId, predicate, options); - }, - }, - }; -} - -function withDocument(t, { cockpit = () => false } = {}) { - const previous = globalThis.document; - globalThis.document = { - body: { - classList: { contains: (name) => name === 'cockpit-mode' && cockpit() }, - }, - addEventListener() {}, - removeEventListener() {}, - }; - t.after(() => { - if (previous === undefined) delete globalThis.document; - else globalThis.document = previous; - }); -} - -/** A quake card over `pickedId` reached as a nearby touch contact. */ -const actsOnNearbyHit = (pickedId) => - picking.isActedOnByOtherLayer('earthquakes', pickedId, { expanded: true }); - -for (const [name, layerId, create] of [ - ['flights', 'flights', createFlightLifecycle], - ['military', 'military', createMilitaryLifecycle], -]) { - test(`${name} registers its aircraft as acting on nearby touch hits`, (t) => { - let cockpit = false; - withDocument(t, { cockpit: () => cockpit }); - const { registered, services } = recordingPicking(); - const flightState = stub({ - _icons: { show: false, has: (id) => id === `${name}-1` }, - records: { geoidReady: true }, - timeline: null, - _trackedIcao: null, - }); - const { methods: lifecycle } = create({ - flightState, - services: stub({ picking: services }), - parts: stub(), - layer: stub(), - resolveAsset: () => '', - }); - t.after(() => picking.unregisterPickOwner(layerId)); - lifecycle.enable({}); - assert.equal(registered.get(layerId)?.expanded, true); - assert.equal(actsOnNearbyHit(`${name}-1`), true); - // The handler ignores a dragged tap and any tap in cockpit mode, so the - // aircraft acts on neither click. - const nearby = (gesture) => - picking.isActedOnByOtherLayer('earthquakes', `${name}-1`, { - expanded: true, - click: { gesture }, - }); - assert.equal(nearby({ travelPx: 0, durationMs: 80 }), true, 'a tap'); - assert.equal(nearby({ travelPx: 12, durationMs: 80 }), false, 'a drag'); - cockpit = true; - assert.equal(nearby({ travelPx: 0, durationMs: 80 }), false, 'cockpit'); - cockpit = false; - // A click on the aircraft already tracked is ignored, so it is passive. - flightState._trackedIcao = `${name}-1`; - assert.equal(actsOnNearbyHit(`${name}-1`), false); - }); -} - -test('vessels register their icons as acting on nearby touch hits', (t) => { - withDocument(t); - const { registered, services } = recordingPicking(); - const state = { - feed: { enabled: true, sessionId: 1 }, - records: { byId: new Map([['vessel-1', {}]]) }, - viewer: {}, - }; - const created = createVesselLifecycle({ - vesselState: stub({ state, _geoidReady: true }), - services: stub({ picking: services }), - parts: stub(), - }); - const lifecycle = created.methods ?? created; - t.after(() => picking.unregisterPickOwner('ais-live-vessels')); - lifecycle.enable({}); - assert.equal(registered.get('ais-live-vessels')?.expanded, true); - assert.equal(actsOnNearbyHit('vessel-1'), true); -}); - -test('radio registers its stations as acting on nearby touch hits', (t) => { - const { registered, services } = recordingPicking(); - const viewer = { scene: { canvas: new EventTarget(), pick: () => null } }; - const input = fakeInput(viewer); - const state = { _viewer: viewer, _clickSubscription: null }; - const interaction = createRadioInteraction({ - state, - services: { picking: services, overlays: stub() }, - parts: stub(), - }); - t.after(() => { - interaction.removeInteraction(); - input.destroy(); - }); - interaction.installInteraction(); - assert.equal(registered.get('radio')?.expanded, true); - assert.equal(actsOnNearbyHit('radio:kexp'), true); - interaction.removeInteraction(); - assert.equal(actsOnNearbyHit('radio:kexp'), false); -}); - -test('Street Level registers its picks as acting on nearby touch hits', (t) => { - withDocument(t); - const { registered, services } = recordingPicking(); - const viewer = { scene: { canvas: new EventTarget(), pick: () => null } }; - const input = fakeInput(viewer); - const state = { services: { picking: services }, clickSubscription: null }; - const selection = createStreetSelection({ - state, - parts: stub({ - router: { - ownsPick: (id) => id === 'mly:seq-1', - resolve: (id) => (id === 'mly:seq-1' ? { id, instance: {} } : null), - }, - }), - }); - t.after(() => { - state.clickSubscription?.(); - picking.unregisterPickOwner(STREET_LEVEL_LAYER_ID); - input.destroy(); - }); - selection.install(viewer); - assert.equal(registered.get(STREET_LEVEL_LAYER_ID)?.expanded, true); - assert.equal(actsOnNearbyHit('mly:seq-1'), true); -}); diff --git a/src/data/pickRegistry.js b/src/data/pickRegistry.js index 815aac0536..f11f6e8553 100644 --- a/src/data/pickRegistry.js +++ b/src/data/pickRegistry.js @@ -26,29 +26,6 @@ const isSurface = (hit) => !hit || hit.surface === true; /** @type {Map boolean>} layerId -> ownership predicate */ const _owners = new Map(); -/** - * Owners that claim picks but never act on a click on them (flight trails, a - * directions route line): `true` for all of an owner's picks, or a predicate - * naming which. Their picks are still not empty space to other layers. - * @type {Map boolean)>} - */ -const _passive = new Map(); -/** Owners whose click handlers also select nearby contacts. */ -const _expanded = new Set(); -/** - * Owners whose click handlers act on none of their picks for some clicks - * (aircraft layers ignore a dragged tap, or any tap in cockpit mode). - * @type {Map boolean>} - */ -const _declines = new Map(); -/** @type {WeakMap>} */ -const clickActions = new WeakMap(); -/** - * Layers whose shapes are background to any card painted over them: their - * click handlers stand aside under a card, so the card's layer may act there. - * @type {Map boolean>} - */ -const _cardBackgrounds = new Map(); /** * A hit's canonical pick id, for the ownership scan: its item's id. Layers' @@ -70,30 +47,11 @@ export function resolvePickId(hit) { * @param {string} layerId - Owning layer id (e.g. 'flights'). * @param {(pickedId: string) => boolean} predicate - Returns true when the * picked primitive/entity id belongs to this layer. - * @param {{passive?: boolean | ((pickedId: string) => boolean), expanded?: boolean, declinesClick?: (click: object) => boolean}} [options] - * `passive`: the layer never acts on a click on these picks (all of them, - * or those the predicate names). See {@link isActedOnByOtherLayer}. - * `expanded`: preserve precedence for handlers that select nearby contacts, - * through the shared contact hit or their own pick window. - * `declinesClick`: true for a click the layer's handler ignores whatever it - * picked (a dragged tap); for that click its picks act for nobody. * @returns {void} */ -export function registerPickOwner( - layerId, - predicate, - { passive, expanded = false, declinesClick } = {}, -) { +export function registerPickOwner(layerId, predicate) { if (!layerId || typeof predicate !== 'function') return; _owners.set(layerId, predicate); - if (typeof declinesClick === 'function') - _declines.set(layerId, declinesClick); - else _declines.delete(layerId); - if (expanded) _expanded.add(layerId); - else _expanded.delete(layerId); - if (passive === true || typeof passive === 'function') - _passive.set(layerId, passive); - else _passive.delete(layerId); } /** @@ -103,9 +61,6 @@ export function registerPickOwner( */ export function unregisterPickOwner(layerId) { _owners.delete(layerId); - _expanded.delete(layerId); - _declines.delete(layerId); - _passive.delete(layerId); } /** @@ -144,67 +99,6 @@ export function isOwnedByOtherLayer(layerId, pickedId) { return false; } -/** - * @param {string} pickedId - * @param {object} [click] The click being arbitrated, if any. - * @returns {Generator<[string, boolean]>} - */ -function* actingPickOwners(pickedId, click) { - for (const [ownerId, predicate] of _owners) { - try { - if (!predicate(pickedId)) continue; - if (click && _declines.get(ownerId)?.(click)) continue; - const passive = _passive.get(ownerId); - if (passive === true) continue; - if (typeof passive === 'function' && passive(pickedId)) continue; - yield [ownerId, _expanded.has(ownerId)]; - } catch { - // a broken predicate must never break click handling - } - } -} - -/** - * Hold the acting owners as soon as a click resolves a hit. A handler can - * start tracking the hit and make it passive before later handlers run. - * @param {object} click The shared dispatcher event. - * @param {import('../render/contract/query').Hit|null} hit The resolved hit. - */ -export function rememberClickPickActions(click, hit) { - const pickedId = resolvePickId(hit); - if (!pickedId) return; - let actions = clickActions.get(click); - if (!actions) clickActions.set(click, (actions = new Map())); - if (!actions.has(pickedId)) { - actions.set(pickedId, [...actingPickOwners(pickedId, click)]); - } -} - -/** - * True when some OTHER registered layer owns the picked id and acts on a - * click on it: {@link isOwnedByOtherLayer} without passive owners. A card - * painted over a passive pick (a flight trail) is still the card's click. - * @param {string} layerId - The asking layer's id (excluded from the scan). - * @param {string} pickedId - Picked primitive/entity id. - * @param {{expanded?: boolean, click?: object}} [options] For a nearby hit, - * only expanded owners take precedence. Pass the shared click to use the - * acting owners from when it first resolved this hit. - * @returns {boolean} - */ -export function isActedOnByOtherLayer( - layerId, - pickedId, - { expanded = false, click } = {}, -) { - if (!pickedId) return false; - const owners = - clickActions.get(click)?.get(pickedId) ?? actingPickOwners(pickedId, click); - for (const [ownerId, selectsNearby] of owners) { - if (ownerId !== layerId && (!expanded || selectsNearby)) return true; - } - return false; -} - /** * Resolve a moving-contact click without letting map tiles hide a nearby touch * target. Exact picks always win; only a coarse primary pointer may expand a @@ -253,41 +147,57 @@ export function pickContact(query, position, options = {}) { } /** - * Registers a layer's unowned shapes that stand aside for a card painted over - * them (its click handler returns when a world-overlay entry is on top). - * @param {string} layerId - Registering layer id. - * @param {(hit: import('../render/contract/query').Hit) => boolean} predicate - * True when a click's draw hit is one of this layer's shapes. + * The world overlay's hit test: the topmost interactive card or label painted + * at CSS-pixel coordinates, or null. Set by the overlay host while it runs. + * @type {((x: number, y: number) => {sourceId: string, entryId: string}|null)|null} + */ +let _overlayHitTest = null; +/** @type {WeakMap} */ +const clickCards = new WeakMap(); + +/** + * Sets (or with null, clears) the hit test that names the card or label + * painted at a click. The world-overlay host sets it while it runs. + * @param {((x: number, y: number) => object|null)|null} hitTest * @returns {void} */ -export function registerCardBackground(layerId, predicate) { - if (!layerId || typeof predicate !== 'function') return; - _cardBackgrounds.set(layerId, predicate); +export function setClickCardHitTest(hitTest) { + _overlayHitTest = typeof hitTest === 'function' ? hitTest : null; } /** - * Removes a layer's card-background predicate (call when its clicks stop). - * @param {string} layerId - Registering layer id. - * @returns {void} + * The topmost interactive card or label painted at a click, read once per + * click so every handler of it sees the same one whatever ran first. + * @param {{screenPosition?: {x: number, y: number}}|null|undefined} click + * @returns {{sourceId: string, entryId: string}|null} */ -export function unregisterCardBackground(layerId) { - _cardBackgrounds.delete(layerId); +export function clickCard(click) { + if (!click || typeof click !== 'object') return null; + if (clickCards.has(click)) return clickCards.get(click); + const at = click.screenPosition; + let card = null; + try { + card = _overlayHitTest?.(at?.x, at?.y) ?? null; + } catch { + // a broken hit test must never break click handling + } + clickCards.set(click, card); + return card; } /** - * True when a click's draw hit is a shape whose layer stands aside for a card - * painted over it, so that card may act on the click. - * @param {import('../render/contract/query').Hit|null|undefined} hit + * True when another layer's card or label is painted on top at a click. The + * card on top takes the click: a scene item under it does not act, and is + * not empty space either, so the layer leaves its selection alone. + * @param {object} click The shared dispatcher event. + * @param {Iterable} [ownSourceIds] The asking layer's overlay + * sources: its own card on top is its click. * @returns {boolean} */ -export function isCardBackground(hit) { - if (isSurface(hit)) return false; - for (const predicate of _cardBackgrounds.values()) { - try { - if (predicate(hit)) return true; - } catch { - // a broken predicate must never break click handling - } - } - return false; +export function isUnderOtherCard(click, ownSourceIds = []) { + const card = clickCard(click); + if (!card) return false; + for (const sourceId of ownSourceIds) + if (card.sourceId === sourceId) return false; + return true; } diff --git a/src/data/pickRegistry.test.mjs b/src/data/pickRegistry.test.mjs index 1a27752646..eb3347fe8c 100644 --- a/src/data/pickRegistry.test.mjs +++ b/src/data/pickRegistry.test.mjs @@ -15,13 +15,11 @@ import { registerPickOwner, unregisterPickOwner, isOwnedByOtherLayer, - isActedOnByOtherLayer, resolvePickId, pickContact, - findPickOwner, - registerCardBackground, - unregisterCardBackground, - isCardBackground, + clickCard, + isUnderOtherCard, + setClickCardHitTest, } from './pickRegistry.js'; // --------------------------------------------------------------------------- @@ -54,11 +52,8 @@ test('resolvePickId: the map and nothing → null', () => { // --------------------------------------------------------------------------- test('ownership: sibling layers recognize each other via String-coerced ids', () => { - const points = new Map([ - [25544, {}], - [43013, {}], - ]); // satellites: numeric keys - const vessels = new Map([['367123450', {}]]); // AIS: string id keys + const points = new Map([[25544, {}], [43013, {}]]); // satellites: numeric keys + const vessels = new Map([['367123450', {}]]); // AIS: string id keys registerPickOwner('satellites', (pickedId) => { const norad = Number(pickedId); return Number.isFinite(norad) && points.has(norad); @@ -66,15 +61,9 @@ test('ownership: sibling layers recognize each other via String-coerced ids', () registerPickOwner('ais-live-vessels', (pickedId) => vessels.has(pickedId)); try { // Flights asking about a satellite pick (raw numeric id → String upstream) - assert.equal( - isOwnedByOtherLayer('flights', resolvePickId(item('sat:1', '25544'))), - true, - ); + assert.equal(isOwnedByOtherLayer('flights', resolvePickId(item('sat:1', '25544'))), true); // Flights asking about a vessel pick (an icon row id: the vessel's id) - assert.equal( - isOwnedByOtherLayer('flights', resolvePickId(item('ais:1', '367123450'))), - true, - ); + assert.equal(isOwnedByOtherLayer('flights', resolvePickId(item('ais:1', '367123450'))), true); // A layer never owns its own pick via the sibling scan assert.equal(isOwnedByOtherLayer('satellites', '25544'), false); // Unknown ids belong to nobody @@ -87,9 +76,7 @@ test('ownership: sibling layers recognize each other via String-coerced ids', () }); test('ownership: a throwing predicate never breaks click handling', () => { - registerPickOwner('broken', () => { - throw new Error('boom'); - }); + registerPickOwner('broken', () => { throw new Error('boom'); }); registerPickOwner('cctv', (pickedId) => pickedId === 'atx-cam-3'); try { assert.equal(isOwnedByOtherLayer('flights', 'atx-cam-3'), true); @@ -137,83 +124,6 @@ function query(picked, drillPick = () => assert.fail('must not drill')) { }; } -test('ownership: passive owners still own their picks but act on none of them', () => { - registerPickOwner('test-trails', (id) => id.startsWith('trail:'), { - passive: true, - }); - registerPickOwner('test-route', (id) => id.startsWith('route:'), { - passive: (id) => !id.startsWith('route:step:'), - }); - registerPickOwner('test-plane', (id) => id === 'plane:1'); - registerPickOwner('test-broken', () => { - throw new Error('broken'); - }); - try { - assert.equal( - isOwnedByOtherLayer('cards', 'trail:9'), - true, - 'not empty space', - ); - assert.equal(isActedOnByOtherLayer('cards', 'trail:9'), false); - assert.equal(isActedOnByOtherLayer('cards', 'route:line'), false); - assert.equal(isActedOnByOtherLayer('cards', 'route:step:3'), true); - assert.equal(isActedOnByOtherLayer('cards', 'plane:1'), true); - assert.equal( - isActedOnByOtherLayer('cards', 'plane:1', { expanded: true }), - false, - ); - registerPickOwner('test-plane', (id) => id === 'plane:1', { - expanded: true, - }); - assert.equal( - isActedOnByOtherLayer('cards', 'plane:1', { expanded: true }), - true, - ); - registerPickOwner('test-plane', (id) => id === 'plane:1', { - expanded: true, - passive: true, - }); - assert.equal( - isActedOnByOtherLayer('cards', 'plane:1', { expanded: true }), - false, - ); - registerPickOwner('test-plane', (id) => id === 'plane:1'); - assert.equal( - isActedOnByOtherLayer('cards', 'plane:1', { expanded: true }), - false, - ); - registerPickOwner('test-plane', (id) => id === 'plane:1', { - expanded: true, - }); - unregisterPickOwner('test-plane'); - registerPickOwner('test-plane', (id) => id === 'plane:1'); - assert.equal( - isActedOnByOtherLayer('cards', 'plane:1', { expanded: true }), - false, - ); - - assert.equal( - isActedOnByOtherLayer('test-plane', 'plane:1'), - false, - 'never the asker', - ); - assert.equal(isActedOnByOtherLayer('cards', null), false); - // Registering again without the option makes the owner act. - registerPickOwner('test-trails', (id) => id.startsWith('trail:')); - assert.equal(isActedOnByOtherLayer('cards', 'trail:9'), true); - // Unregistering drops the option with the predicate. - registerPickOwner('test-trails', (id) => id.startsWith('trail:'), { - passive: true, - }); - unregisterPickOwner('test-trails'); - registerPickOwner('test-trails', (id) => id.startsWith('trail:')); - assert.equal(isActedOnByOtherLayer('cards', 'trail:9'), true); - } finally { - for (const id of ['test-trails', 'test-route', 'test-plane', 'test-broken']) - unregisterPickOwner(id); - } -}); - test('touch contact pick expands only a surface miss, bounded to 8 hits in 14 CSS pixels', (t) => { primaryPointer(t, true); contactOwners(t); @@ -234,14 +144,10 @@ test("touch contact pick uses the click's own pick and drill", (t) => { contactOwners(t); const contact = item('flights:1', 'civil'); const asked = []; - const found = pickContact( - query(null), - { x: 1, y: 1 }, - { - picked: null, - drill: (...args) => (asked.push(args), [contact]), - }, - ); + const found = pickContact(query(null), { x: 1, y: 1 }, { + picked: null, + drill: (...args) => (asked.push(args), [contact]), + }); assert.equal(found, contact); assert.deepEqual(asked, [[8, 14, 14]]); }); @@ -274,13 +180,7 @@ test('touch expansion stops at an unowned item and respects the drill bound', (t [...Array(8).fill(item('notes:1', 'x')), item('flights:1', 'civil')], [], ]) - assert.equal( - pickContact( - query(SURFACE, () => hits), - { x: 1, y: 1 }, - ), - SURFACE, - ); + assert.equal(pickContact(query(SURFACE, () => hits), { x: 1, y: 1 }), SURFACE); }); test('fine primary pointers keep the exact mouse pick without a drill', (t) => { @@ -301,22 +201,39 @@ test('touch picking tolerates a failing drill and preserves empty sky', (t) => { assert.equal(pickContact(query(null, drillPick), { x: 1, y: 1 }), null); }); -test('card backgrounds: a registered shape, never the map, and safe to break', () => { - const shape = { set: 'zones:1:fills', id: 'zone:1', surface: false }; - assert.equal(isCardBackground(shape), false); - registerCardBackground('test-zones', (hit) => hit.set === shape.set); - registerCardBackground('test-broken', () => { - throw new Error('broken predicate'); +test("the card on top is read once per click, and only another layer's card counts", () => { + let top = { sourceId: 'quake-card', entryId: 'q1' }; + let reads = 0; + setClickCardHitTest((x, y) => { + reads++; + assert.deepEqual([x, y], [4, 5]); + return top; }); try { - assert.equal(isCardBackground(shape), true); - assert.equal(isCardBackground({ ...shape, set: 'other:1' }), false); - assert.equal(isCardBackground({ surface: true }), false); - assert.equal(isCardBackground(null), false); - assert.equal(findPickOwner(shape.id), null, 'not an owner'); + const click = { screenPosition: { x: 4, y: 5 } }; + assert.equal(isUnderOtherCard(click, ['vessel-card']), true); + assert.equal(isUnderOtherCard(click, ['quake-card']), false, 'own card'); + // A card published later in the same click does not change it. + top = { sourceId: 'vessel-card', entryId: 'v1' }; + assert.equal(clickCard(click).sourceId, 'quake-card'); + assert.equal(reads, 1); + assert.equal(isUnderOtherCard({ screenPosition: { x: 4, y: 5 } }), true); + top = null; + assert.equal(isUnderOtherCard({ screenPosition: { x: 4, y: 5 } }), false); } finally { - unregisterCardBackground('test-zones'); - unregisterCardBackground('test-broken'); + setClickCardHitTest(null); + } + assert.equal( + isUnderOtherCard({ screenPosition: { x: 4, y: 5 } }), + false, + 'no host', + ); + setClickCardHitTest(() => { + throw new Error('broken'); + }); + try { + assert.equal(clickCard({ screenPosition: { x: 1, y: 1 } }), null); + } finally { + setClickCardHitTest(null); } - assert.equal(isCardBackground(shape), false); }); diff --git a/src/data/pickedContext.js b/src/data/pickedContext.js index 803075244a..8957c5a24b 100644 --- a/src/data/pickedContext.js +++ b/src/data/pickedContext.js @@ -1,10 +1,6 @@ import { getContextStore, isContextRecordActive } from './contextStore.js'; import { readEntityRecord } from './entityRecords.js'; -import { - findPickOwner, - isActedOnByOtherLayer, - resolvePickId, -} from './pickRegistry.js'; +import { findPickOwner, resolvePickId } from './pickRegistry.js'; /** * Resolve a pick (the contract's `Hit`, as `pickAt` in @@ -127,25 +123,3 @@ export function resolvePickedContext(picked, { dataManager = null } = {}) { altitudeM: finite(found?.altitudeM), }; } - -/** - * Whether a world-overlay card or label under a click keeps it from the item - * the click names, because that item's owner does not act on this hit: a - * passive owner (a directions route) acts on none, and an owner that acts - * only on exact hits (a fire, a camera) does not act on a coarse pointer's - * nearby contact (`hit` is not the exact `topHit`). The card's layer takes - * such a click (quake, fire, camera, vessel, news and wildlife cards act over - * it; an inert card, such as a selected drone-zone card, does nothing), so - * Context leaves the item; owners that act on it (an aircraft, a vessel, a - * directions step) still name it. - * @param {{hit?: object|null, topHit?: object|null}} click - * @param {boolean} underCard Whether a world-overlay entry is under it. - * @returns {boolean} - */ -export function cardKeepsClick(click, underCard) { - if (!underCard || !click?.hit) return false; - const pickId = resolvePickId(click.hit); - if (!pickId) return false; - const expanded = pickId !== resolvePickId(click.topHit ?? null); - return !isActedOnByOtherLayer('', pickId, { expanded, click }); -} diff --git a/src/data/pickedContext.test.mjs b/src/data/pickedContext.test.mjs index 6d147bfeaa..4b452e0cab 100644 --- a/src/data/pickedContext.test.mjs +++ b/src/data/pickedContext.test.mjs @@ -11,8 +11,8 @@ globalThis.CustomEvent ||= class CustomEvent { globalThis.dispatchEvent ||= () => true; const { registerEntityContext } = await import('./contextStore.js'); -const { registerPickOwner, unregisterPickOwner, findPickOwner, rememberClickPickActions } = await import('./pickRegistry.js'); -const { resolvePickedContext, pickedKindForLayer, cardKeepsClick } = await import('./pickedContext.js'); +const { registerPickOwner, unregisterPickOwner, findPickOwner } = await import('./pickRegistry.js'); +const { resolvePickedContext, pickedKindForLayer } = await import('./pickedContext.js'); function manager({ enabled = new Set(['flights', 'local-datacenters']), modules = {} } = {}) { return { @@ -97,73 +97,3 @@ test('disabled layers, trails and empty picks never resolve', () => { assert.equal(resolvePickedContext(hit('unknown'), { dataManager: manager() }), null); assert.equal(pickedKindForLayer('ais-live-vessels'), 'vessel'); }); - -test('a card keeps a click from items whose layer does not act on that hit', (t) => { - registerPickOwner('test-fires', (id) => id === 'fire:1'); - registerPickOwner('test-planes', (id) => id === 'plane:1', { - expanded: true, - }); - registerPickOwner('test-route', (id) => id.startsWith('route:'), { - passive: (id) => !id.startsWith('route:step:'), - }); - t.after(() => { - unregisterPickOwner('test-fires'); - unregisterPickOwner('test-planes'); - unregisterPickOwner('test-route'); - }); - const fire = { set: 'fires:1', id: 'fire:1' }; - const plane = { set: 'planes:1', id: 'plane:1' }; - const exact = (hit) => ({ topHit: { ...hit }, hit }); - // A coarse tap: nothing exact, the contact found nearby. - const near = (hit) => ({ topHit: null, hit }); - assert.equal( - cardKeepsClick(near(fire), true), - true, - 'fires act only on exact hits', - ); - assert.equal(cardKeepsClick(near(plane), true), false, 'aircraft act nearby'); - assert.equal( - cardKeepsClick(near(fire), false), - false, - 'open map: Context names it', - ); - assert.equal( - cardKeepsClick(exact(fire), true), - false, - "an exact fire is the fire's", - ); - const line = { set: 'route:1', id: 'route:line' }; - const step = { set: 'route:1', id: 'route:step:2' }; - // Every card layer acts over a passive route, so the card keeps the click. - assert.equal( - cardKeepsClick(exact(line), true), - true, - 'a route acts for nobody', - ); - assert.equal( - cardKeepsClick(exact(step), true), - false, - "a step is directions' own", - ); - assert.equal(cardKeepsClick({ topHit: null, hit: null }, true), false); -}); - -// An aircraft layer can start tracking the plane it was clicked on before -// Context runs, making that plane passive. Context reads the owners that -// acted when the click resolved, so the card over it does not keep the click. -test('a card keeps a click by the owners that acted when it resolved', (t) => { - let tracked = null; - registerPickOwner('test-planes', (id) => id === 'plane:9', { - expanded: true, - passive: (id) => id === tracked, - }); - t.after(() => unregisterPickOwner('test-planes')); - const plane = { set: 'planes:1', id: 'plane:9' }; - const click = { topHit: plane, hit: plane }; - rememberClickPickActions(click, plane); - tracked = 'plane:9'; - assert.equal(cardKeepsClick(click, true), false, 'the aircraft acted'); - // A click that resolves now sees the tracked plane as passive. - const later = { topHit: { ...plane }, hit: { ...plane } }; - assert.equal(cardKeepsClick(later, true), true); -}); diff --git a/src/data/trailRenderer.js b/src/data/trailRenderer.js index 1c8f6dc598..06c8581318 100644 --- a/src/data/trailRenderer.js +++ b/src/data/trailRenderer.js @@ -36,12 +36,8 @@ import { registerPickOwner } from './pickRegistry.js'; // plane being tracked. Claiming the 'gev-trail:' id namespace makes // isOwnedByOtherLayer() true for every layer — clicking a trail is a no-op // everywhere. Registered once at module load; the predicate is pure. -// Passive: no layer acts on a trail click, so a card painted over a trail -// still takes its click (isActedOnByOtherLayer). -registerPickOwner( - 'trails', - (pickedId) => String(pickedId).startsWith('gev-trail:'), - { passive: true }, +registerPickOwner('trails', (pickedId) => + String(pickedId).startsWith('gev-trail:'), ); /** @type {number} Uniquifier for trail set and line ids. */ diff --git a/src/input/dispatcher.js b/src/input/dispatcher.js index 6387a7a1c2..7d4ea04606 100644 --- a/src/input/dispatcher.js +++ b/src/input/dispatcher.js @@ -51,7 +51,6 @@ import { import { findPickOwner, pickContact, - rememberClickPickActions, resolvePickId, } from '../data/pickRegistry.js'; import { isPickedWorldPosition } from '../data/scenePick.js'; @@ -457,9 +456,7 @@ function createClickEvent(viewer, queryOf, at, gesture) { // The adapter's own pick of this click is the renderer's pass, held // now: read later, it would be another, of a scene drawn since. void native()?.native.pick; - const top = topHitOf(hit, () => native()?.foreign() ?? null); - rememberClickPickActions(this, top); - return top; + return topHitOf(hit, () => native()?.foreign() ?? null); }); }, get drawHit() { @@ -470,7 +467,7 @@ function createClickEvent(viewer, queryOf, at, gesture) { return once('hit', () => { const q = query(); if (!q) return this.topHit; - const hit = pickContact(q, position, { + return pickContact(q, position, { picked: this.topHit, // Everything drawn there, as the adapter sees it, so a contact // search stops at what is drawn over a contact outside the draw @@ -483,8 +480,6 @@ function createClickEvent(viewer, queryOf, at, gesture) { : this.drill(limit, width, height); }, }); - rememberClickPickActions(this, hit); - return hit; }); }, get id() { diff --git a/src/layers/alpr/presentation.js b/src/layers/alpr/presentation.js index 72aa334c5c..4df9f28305 100644 --- a/src/layers/alpr/presentation.js +++ b/src/layers/alpr/presentation.js @@ -1,5 +1,6 @@ import { isFollowing } from '../../data/followed.js'; import { inputFor } from '../../input/dispatcher.js'; +import { isUnderOtherCard } from '../../data/pickRegistry.js'; import { distance, fromDegrees, toLonLatH } from '../../geo/index.js'; import { LAYER_ID, @@ -581,6 +582,9 @@ export function createAlprPresentation({ state, services, source }) { if (state.clickSubscription) return; state.clickSubscription = inputFor(viewer).onClick((event) => { if (!state.enabled) return; + // Another layer's card or label painted on top takes the click: the item + // under it does not act, and the click is not empty space either. + if (isUnderOtherCard(event)) return; // The painted overlay answers first; the scene is picked only if not. const hit = event.drawHit; const id = diff --git a/src/layers/alpr/presentation.test.mjs b/src/layers/alpr/presentation.test.mjs new file mode 100644 index 0000000000..1232de5665 --- /dev/null +++ b/src/layers/alpr/presentation.test.mjs @@ -0,0 +1,57 @@ +import test from 'node:test'; +import assert from 'node:assert/strict'; +import { createAlprPresentation } from './presentation.js'; +import { fakeInput } from '../../input/testDoubles.mjs'; +import { setClickCardHitTest } from '../../data/pickRegistry.js'; + +// The card or label painted on top takes the click: ALPR does not even pick +// under another layer's card, so no camera is selected or released there. +test("another layer's card over an ALPR camera keeps the click", (t) => { + let picks = 0; + const viewer = { + scene: { + canvas: new EventTarget(), + pick: () => { + picks++; + return null; + }, + }, + }; + const input = fakeInput(viewer); + const noop = () => {}; + const state = { + enabled: true, + viewer, + clickSubscription: null, + markers: { icons: null }, + recordById: new Map(), + selectedId: null, + }; + const presentation = createAlprPresentation({ + state, + services: { + render: { governorRequestRender: noop }, + context: { + clearSelectedEntityContextForLayer: noop, + getSelectedEntityContext: () => null, + registerEntityContext: noop, + removeEntityContextsForLayer: noop, + selectEntityContext: noop, + }, + groundFloor: { cachedGroundFloor: () => null }, + }, + }); + presentation.installInteraction(viewer); + let top = { sourceId: 'earthquake-card', entryId: 'earthquake-card:ak1' }; + setClickCardHitTest(() => top); + t.after(() => { + setClickCardHitTest(null); + state.clickSubscription?.(); + input.destroy(); + }); + input.tap({ x: 10, y: 10 }); + assert.equal(picks, 0, 'covered: the scene under the card is not picked'); + top = null; + input.tap({ x: 10, y: 10 }); + assert.ok(picks > 0, 'open map: the click reaches the scene'); +}); diff --git a/src/layers/bikeshare/selection.js b/src/layers/bikeshare/selection.js index bbf962d8d3..caa3620717 100644 --- a/src/layers/bikeshare/selection.js +++ b/src/layers/bikeshare/selection.js @@ -1,5 +1,6 @@ import { t } from '../../i18n/index.js'; import { inputFor } from '../../input/dispatcher.js'; +import { isUnderOtherCard } from '../../data/pickRegistry.js'; import { BIKESHARE_SELECTED_OVERLAY_SOURCE_ID, BIKESHARE_SELECTED_OVERLAY_SOURCE_OPTIONS, @@ -143,6 +144,9 @@ export function createSelection({ if (layerState._clickSubscription) return; layerState._clickSubscription = inputFor(viewer).onClick((event) => { + // Another layer's card or label painted on top takes the click: the item + // under it does not act, and the click is not empty space either. + if (isUnderOtherCard(event)) return; const hit = event.drawHit; if (hit) { diff --git a/src/layers/bikeshare/selection.test.mjs b/src/layers/bikeshare/selection.test.mjs new file mode 100644 index 0000000000..e75dc93050 --- /dev/null +++ b/src/layers/bikeshare/selection.test.mjs @@ -0,0 +1,68 @@ +import test from 'node:test'; +import assert from 'node:assert/strict'; +import { createSelection } from './selection.js'; +import { fakeInput } from '../../input/testDoubles.mjs'; +import { setClickCardHitTest } from '../../data/pickRegistry.js'; + +/** A station layer's selection on a viewer whose pick is scripted. */ +function harness(t) { + const previousDocument = globalThis.document; + globalThis.document = new EventTarget(); + let picked = null; + const viewer = { scene: { canvas: new EventTarget(), pick: () => picked } }; + const input = fakeInput(viewer); + const noop = () => {}; + const state = { + _selectedKey: null, + _clickSubscription: null, + _stationRenderMap: new Map([['nyc:1', { position: { x: 1, y: 0, z: 0 } }]]), + _stationSet: { id: 'bikeshare:stations', upsert: noop }, + _selectedSet: { + id: 'bikeshare:selected', + set: noop, + size: () => 0, + clear: noop, + }, + _overlayHost: { setEntries: noop, clearSource: noop }, + }; + const selection = createSelection({ + state, + services: {}, + parts: { rendering: { stationItem: () => ({}) } }, + }); + selection._installClickHandler(viewer); + t.after(() => { + state._clickSubscription?.(); + input.destroy(); + if (previousDocument === undefined) delete globalThis.document; + else globalThis.document = previousDocument; + }); + return { + state, + click(hit) { + picked = hit ? { id: hit } : null; + input.tap({ x: 10, y: 10 }); + }, + }; +} + +// The card or label painted on top takes the click: a station under another +// layer's card is neither selected nor let go. +test("another layer's card over a station keeps the click", (t) => { + const h = harness(t); + let top = { sourceId: 'earthquake-card', entryId: 'earthquake-card:ak1' }; + setClickCardHitTest(() => top); + t.after(() => setClickCardHitTest(null)); + const station = { set: 'bikeshare:stations', id: 'nyc:1' }; + h.click(station); + assert.equal(h.state._selectedKey, null, 'covered: not selected'); + top = null; + h.click(station); + assert.equal(h.state._selectedKey, 'nyc:1'); + top = { sourceId: 'earthquake-card', entryId: 'earthquake-card:ak1' }; + h.click(null); + assert.equal(h.state._selectedKey, 'nyc:1', 'covered: kept'); + top = null; + h.click(null); + assert.equal(h.state._selectedKey, null, 'open map lets it go'); +}); diff --git a/src/layers/cctv/lifecycle.js b/src/layers/cctv/lifecycle.js index cd704d2617..e49b8a85bb 100644 --- a/src/layers/cctv/lifecycle.js +++ b/src/layers/cctv/lifecycle.js @@ -5,7 +5,6 @@ import { viewshedColors, cameraHue } from '../../data/cctvViewshed.js'; import { CCTV_OVERLAY_SOURCE_ID } from '../../data/cctvCards.js'; import { GIZMO_ID_PREFIX } from '../../data/cctvGizmo.js'; import { inputFor } from '../../input/dispatcher.js'; -import { isTrackingClickGesture } from '../../data/trackingClickGesture.js'; import { GROUND_PRIOR_INIT_WAIT_MS, CALIBRATION_RANGE_FLOOR_M, @@ -24,14 +23,8 @@ export function createLifecycle({ source, }) { const { activateCctvCameraFromWorldClick } = services.activation; - const { - resolvePickId, - registerPickOwner, - unregisterPickOwner, - isOwnedByOtherLayer, - isActedOnByOtherLayer, - isCardBackground, - } = services.picking; + const { resolvePickId, registerPickOwner, unregisterPickOwner, clickCard } = + services.picking; const { onFocusTargetAppear } = services.focus; const { releaseContinuousRender } = services.render; @@ -398,6 +391,20 @@ export function createLifecycle({ (event) => { if (!layerState._enabled) return; const picked = event.topHit; + // The card or label painted on top takes the click, read once per + // click so every layer agrees: a live card of ours acts whatever + // is drawn under it; another layer's is that layer's click. + const top = clickCard?.(event) ?? null; + if (top && top.sourceId !== CCTV_OVERLAY_SOURCE_ID) return; + if (top) { + // A card of ours that is going away is still not the scene. + if (layerState._recordById.has(top.entryId)) + activateCctvCameraFromWorldClick( + top.entryId, + parts.selection.setActiveCamera, + ); + return; + } const cameraId = parts.selection.extractPickedCameraId( event.drawHit ?? null, ); @@ -408,60 +415,11 @@ export function createLifecycle({ ); return; } - // Cards use the last-painted top hit, never an obscured card from - // our own source. Actual camera icons above keep their normal route. - const cardHit = layerState._cctvOverlayHost.hitTest( - event.screenPosition.x, - event.screenPosition.y, - {}, - ); - const cardId = - cardHit?.sourceId === CCTV_OVERLAY_SOURCE_ID && - layerState._recordById.has(cardHit.entryId) - ? cardHit.entryId - : null; - const pickedId = resolvePickId(picked); - const hit = event.drawHit; - // A live top CCTV card acts over shapes whose layers stand aside - // for a painted card (drone zones, fire perimeters, quake discs, - // cables, launch markers), as each registers them. Unknown - // identified objects and registered owners remain barriers. - const cardBackground = - cardId && - typeof pickedId === 'string' && - !isOwnedByOtherLayer?.('cctv', pickedId) && - Boolean(isCardBackground?.(hit)); - // A passive owner's pick (a flight trail, a directions route) acts - // for nobody, so a live top CCTV card over it keeps the click. - const passiveUnderCard = - cardId && - typeof pickedId === 'string' && - Boolean(isActedOnByOtherLayer) && - isOwnedByOtherLayer?.('cctv', pickedId) && - !isActedOnByOtherLayer('cctv', pickedId, { click: event }); - if (pickedId !== null && !cardBackground && !passiveUnderCard) return; - // A coarse tap's touch contact (not the exact pick) that its layer - // acts on (an aircraft, a vessel, a radio station) is that layer's - // click, even under a card of ours. - const contactId = resolvePickId(event.hit ?? null); - if ( - cardId && - contactId && - contactId !== pickedId && - isActedOnByOtherLayer?.('cctv', contactId, { - expanded: true, - click: event, - }) - ) - return; - if (cardHit && cardHit.sourceId !== CCTV_OVERLAY_SOURCE_ID) return; - if (cardId) { - activateCctvCameraFromWorldClick( - cardId, - parts.selection.setActiveCamera, - ); - return; - } + // Any identified scene object owns this click even if its layer + // does not register a shared pick predicate. This keeps selectable + // siblings ahead of the CCTV selection while ID-less globe, terrain + // and tile surfaces remain eligible for empty-space deselection. + if (resolvePickId(picked) !== null) return; if ( parts.selection.cctvEmptyClickDeselects(picked, { activeCameraId: layerState._activeCameraId, @@ -510,26 +468,19 @@ export function createLifecycle({ layerState._lastUpdate = Date.now(); // Pick-ownership (H2): camera icons use the camera id directly; // coverage polyline entities use `cctv--` entity ids. - registerPickOwner( - 'cctv', - (pickedId) => { - if (layerState._recordById.has(pickedId)) return true; - if ( - typeof pickedId === 'string' && - pickedId.startsWith(GIZMO_ID_PREFIX) - ) - return true; - const coverage = - /^cctv-(.+)-(?:ray-tl|ray-tr|ray-br|ray-bl|cap|plane|plane-label)$/.exec( - pickedId, - ); - return Boolean(coverage && layerState._recordById.has(coverage[1])); - }, - // The world click handler takes only clean clicks (see - // `bindCctvWorldClickGesture`), so a card over a camera keeps any - // other tap. - { declinesClick: (click) => !isTrackingClickGesture(click?.gesture) }, - ); + registerPickOwner('cctv', (pickedId) => { + if (layerState._recordById.has(pickedId)) return true; + if ( + typeof pickedId === 'string' && + pickedId.startsWith(GIZMO_ID_PREFIX) + ) + return true; + const coverage = + /^cctv-(.+)-(?:ray-tl|ray-tr|ray-br|ray-bl|cap|plane|plane-label)$/.exec( + pickedId, + ); + return Boolean(coverage && layerState._recordById.has(coverage[1])); + }); if (!layerState._activeCameraId && layerState._records.length) { layerState._activeCameraId = parts.navigation.openingCameraId(); layerState._autoHopSuspended = false; diff --git a/src/layers/cctv/lifecycle.test.mjs b/src/layers/cctv/lifecycle.test.mjs index 2ff86b0fff..a95c0b9ecd 100644 --- a/src/layers/cctv/lifecycle.test.mjs +++ b/src/layers/cctv/lifecycle.test.mjs @@ -77,7 +77,7 @@ test('the view listeners follow the camera port and let go on teardown', () => { assert.equal(state._viewListenerCamera, null); }); -test('world clicks respect the painted top card and registered card backgrounds', async (t) => { +test('the card painted on top takes world clicks, whatever is drawn under it', async (t) => { const noop = () => {}; const { viewer } = viewerWithCamera(); let picked = null; @@ -88,10 +88,11 @@ test('world clicks respect the painted top card and registered card backgrounds' }; let drilled = []; const input = fakeInput(viewer); - // An aircraft layer that runs before ours and starts tracking the plane - // it was clicked on, which makes that plane passive mid-click. + // An aircraft layer that runs before ours and tracks the plane it was + // clicked on, standing aside under another layer's card. let tracked = null; input.input.onClick((event) => { + if (picking.isUnderOtherCard(event)) return; if (event.hit?.id === 'plane:9') tracked = 'plane:9'; }); const ownCard = { sourceId: CCTV_OVERLAY_SOURCE_ID, entryId: 'cam-1' }; @@ -101,6 +102,8 @@ test('world clicks respect the painted top card and registered card backgrounds' }; let painted = []; const actions = []; + // The card on top at a click, as the host answers the pick registry. + picking.setClickCardHitTest(() => painted[0] ?? null); const state = { _cctvOverlayHost: { hitTest: (_x, _y, options = {}) => @@ -148,12 +151,12 @@ test('world clicks respect the painted top card and registered card backgrounds' state._clickSubscription?.(); lifecycle.detachViewListeners(); input.destroy(); + picking.setClickCardHitTest(null); picking.unregisterPickOwner('area-control'); picking.unregisterPickOwner('test-trails'); picking.unregisterPickOwner('test-planes'); picking.unregisterPickOwner('test-tracking'); picking.unregisterPickOwner('test-exact'); - picking.unregisterCardBackground('area-fixture'); }); await lifecycle.methods.init(viewer); state._enabled = true; @@ -184,36 +187,32 @@ test('world clicks respect the painted top card and registered card backgrounds' surface: false, }; const backgrounds = [drone, perimeter, quake, cable, launch]; - // Each of those layers registers its own shapes this way (their tests - // check the real predicates); CCTV only asks the registry. - picking.registerCardBackground('area-fixture', (hit) => - backgrounds.some((b) => b.set === hit.set && b.id === hit.id), - ); for (const area of backgrounds) { click(area, [ownCard], ['cam-1']); click(area, [], []); click(area, [foreignCard, ownCard], []); } + // The live top card acts over anything drawn under it; with no card an + // identified object is not empty map. for (const hit of [ { set: 'flights:1', id: 'aircraft', surface: false }, { set: '', id: 'unregistered-local-entity', surface: false }, - { set: '', id: '', surface: false }, { ...drone, set: 'unrelated:1:fills' }, { ...drone, id: 'unregistered-local-entity' }, - ]) - click(hit, [ownCard], []); - // A passive owner's pick (a trail, a route) acts for nobody: the live top - // card keeps the click, and with no card the pick is not empty map. + ]) { + click(hit, [ownCard], ['cam-1']); + click(hit, [], []); + } + // A trail under the live top card: the card keeps the click, and with no + // card the owned pick is not empty map. const trail = { set: 'trails:1', id: 'gev-trail:fl-1:head', surface: false }; - picking.registerPickOwner('test-trails', (id) => id === trail.id, { - passive: true, - }); + picking.registerPickOwner('test-trails', (id) => id === trail.id); click(trail, [ownCard], ['cam-1']); click(trail, [], []); click(trail, [foreignCard, ownCard], []); picking.unregisterPickOwner('test-trails'); // A coarse tap whose touch contact is an aircraft (a layer that acts on - // nearby contacts) is the aircraft's, even under a live CCTV card. + // nearby contacts) under a live CCTV card is the card's. const previousMatch = globalThis.matchMedia; const restoreMatch = () => { if (previousMatch) globalThis.matchMedia = previousMatch; @@ -223,11 +222,9 @@ test('world clicks respect the painted top card and registered card backgrounds' // failing assertion cannot leave the coarse pointer for later tests. t.after(restoreMatch); globalThis.matchMedia = () => ({ matches: true }); - picking.registerPickOwner('test-planes', (id) => id === 'plane:1', { - expanded: true, - }); + picking.registerPickOwner('test-planes', (id) => id === 'plane:1'); drilled = ['plane:1']; - click(null, [ownCard], []); + click(null, [ownCard], ['cam-1']); // With no card, the bare tap near the aircraft still deselects. click(null, [], ['clear']); // A contact whose layer acts only on exact hits leaves the card its tap. @@ -239,49 +236,29 @@ test('world clicks respect the painted top card and registered card backgrounds' click(null, [ownCard], ['cam-1']); picking.unregisterPickOwner('test-planes'); restoreMatch(); - // The live card reads the owners that acted when the click resolved, so it - // yields to the aircraft even though tracking made it passive meanwhile. - picking.registerPickOwner('test-tracking', (id) => id === 'plane:9', { - expanded: true, - passive: (id) => id === tracked, - }); - click({ set: 'flights:1', id: 'plane:9', surface: false }, [ownCard], []); - assert.equal(tracked, 'plane:9', 'the aircraft started tracking'); + // The live card over an aircraft takes the click; the aircraft layer, + // run first, stands aside and does not track. + picking.registerPickOwner('test-tracking', (id) => id === 'plane:9'); + click( + { set: 'flights:1', id: 'plane:9', surface: false }, + [ownCard], + ['cam-1'], + ); + assert.equal(tracked, null, 'the aircraft did not track'); picking.unregisterPickOwner('test-tracking'); picking.registerPickOwner('area-control', (id) => id === drone.id); - click(drone, [ownCard], []); + click(drone, [ownCard], ['cam-1']); picking.unregisterPickOwner('area-control'); click(null, [foreignCard, ownCard], []); click(null, [ownCard], ['cam-1']); click(null, [], ['clear']); click(drone, [{ ...ownCard, entryId: 'stale-camera' }], []); - click( - { set: 'cctv:fixture', id: 'cam-1' }, - [foreignCard, ownCard], - ['cam-1'], - ); - // CCTV takes only clean clicks, so for a long press or a drag its cameras - // act for nobody: a card painted over one keeps that tap. - // Enable's own work is beside the point here: only its registration. - Object.assign(parts.cards, { - refreshAmbientCards: noop, - startCardFrameLoop: noop, - }); - parts.frames = { refreshProjectionImage: noop }; - Object.assign(parts.geometryQueue, { startGeometryLoadQueue: noop }); - parts.navigation = { openingCameraId: () => 'cam-1' }; - Object.assign(parts.projection, { - ensureProjectionRuntime: noop, - startProjectionLoop: noop, - }); - state._cctvOverlayHost.setVisible ??= noop; - lifecycle.methods.enable(); - t.after(() => picking.unregisterPickOwner('cctv')); - const acted = (gesture) => - picking.isActedOnByOtherLayer('earthquakes', 'cam-1', { - click: { gesture }, - }); - assert.equal(acted({ travelPx: 0, durationMs: 80 }), true, 'a clean click'); - assert.equal(acted({ travelPx: 0, durationMs: 900 }), false, 'a long press'); - assert.equal(acted({ travelPx: 20, durationMs: 80 }), false, 'a drag'); + // A card of ours that is going away is still not the scene under it: no + // camera beneath it activates, and nothing clears. + const staleCard = { ...ownCard, entryId: 'stale-camera' }; + click({ set: 'cctv:fixture', id: 'cam-1' }, [staleCard], []); + click(null, [staleCard], []); + // A camera icon under another layer's card is that card's click. + click({ set: 'cctv:fixture', id: 'cam-1' }, [foreignCard, ownCard], []); + click({ set: 'cctv:fixture', id: 'cam-1' }, [], ['cam-1']); }); diff --git a/src/layers/cyclones/index.js b/src/layers/cyclones/index.js index 02c3b5cad3..1d81f94274 100644 --- a/src/layers/cyclones/index.js +++ b/src/layers/cyclones/index.js @@ -1,7 +1,6 @@ -import { hitTestWorldOverlay } from '../../overlays/worldOverlay.js'; -import { VESSEL_OVERLAY_SOURCE_ID } from '../../data/vesselLabels.js'; import { inputFor } from '../../input/dispatcher.js'; import { + clickCard, registerPickOwner, unregisterPickOwner, } from '../../data/pickRegistry.js'; @@ -79,7 +78,6 @@ const intensityText = (storm) => { /** Advisory status and coherent forecast geometry; selected through the shared row list. */ export function createCyclonesLayer({ feed, - hitTestOverlay = hitTestWorldOverlay, overlayHost, context = null, createRendering = createCycloneRendering, @@ -97,8 +95,7 @@ export function createCyclonesLayer({ selectionIntent = 'auto', navigationGeneration = 0, selectionOwner = null, - selectedContextStormId = null, - removeClickCapture = null; + selectedContextStormId = null; let enabled = false, loading = false, error = null, @@ -169,75 +166,28 @@ export function createCyclonesLayer({ rendering?.setSelection(id); } function installSelection() { - const canvas = canvasOf(viewer); - if (selectionOwner || !canvas) return; + if (selectionOwner || !canvasOf(viewer)) return; const owner = {}; selectionOwner = owner; - // Snapshot before sibling bubble listeners can rebuild the overlay hit - // rectangles. A vessel selection does that synchronously in the same click. - let capturedHit = null; - const overlayHit = (x, y) => { - const hit = hitTestOverlay(x, y); - return { sourceId: hit?.sourceId, entryId: hit?.entryId }; - }; - const capture = (event) => { - capturedHit = null; - const point = event.changedTouches?.[0] || event; - if (!Number.isFinite(point.clientX) || !Number.isFinite(point.clientY)) - return; - const rect = canvas.getBoundingClientRect(); - const x = point.clientX - rect.left, - y = point.clientY - rect.top; - capturedHit = { x, y, ...overlayHit(x, y) }; - }; - const resetCapture = () => { - capturedHit = null; - }; - const resetEvents = [ - 'pointerdown', - 'mousedown', - 'touchstart', - 'pointercancel', - 'touchcancel', - ]; - for (const type of resetEvents) - canvas.addEventListener?.(type, resetCapture, { capture: true }); - const events = ['pointerup', 'mouseup', 'touchend']; - for (const type of events) - canvas.addEventListener?.(type, capture, { capture: true }); - removeClickCapture = () => { - for (const type of events) - canvas.removeEventListener?.(type, capture, { capture: true }); - for (const type of resetEvents) - canvas.removeEventListener?.(type, resetCapture, { capture: true }); - capturedHit = null; - }; const unsubscribe = inputFor(viewer).onClick((event) => { - const nativeHit = capturedHit; - capturedHit = null; // Ambient selection yields to draw tools and Director (the dispatcher // skips a held pointer); it never claims the pointer, camera, or // tracking state. const position = event.screenPosition; if (!enabled || destroyed || selectionOwner !== owner || !position) return; - // AIS cards paint above the globe on a pointer-events:none canvas. The - // vessel handler resolves this same topmost hit before cyclone geometry. - const captureMatches = - nativeHit && - Math.abs(nativeHit.x - position.x) < 1 && - Math.abs(nativeHit.y - position.y) < 1; - const hit = captureMatches - ? nativeHit - : overlayHit(position.x, position.y); - if (hit.sourceId === VESSEL_OVERLAY_SOURCE_ID) return; + // The card or label painted on top, as it was when the click landed. + const card = clickCard(event); // Storm cards and lead-hour labels paint on the same canvas; a click on // one selects its storm. An id from a superseded advisory changes nothing. - if (hit.sourceId === CYCLONE_OVERLAY_SOURCE_ID) { - const id = cycloneStormIdFromEntryId(hit.entryId); + if (card?.sourceId === CYCLONE_OVERLAY_SOURCE_ID) { + const id = cycloneStormIdFromEntryId(card.entryId); if (id) layer.setParams({ stormId: id }); return; } + // Another layer's card on top takes the click: the storm under it does + // not act, and the click is not empty map either. + if (card) return; // A storm's own drawing names it; empty map (the globe, or 3D tiles) // clears the selection. const id = rendering?.pickStorm(event.drawHit); @@ -249,8 +199,6 @@ export function createCyclonesLayer({ function removeSelection() { const owner = selectionOwner; selectionOwner = null; - removeClickCapture?.(); - removeClickCapture = null; owner?.unsubscribe?.(); } const layer = { diff --git a/src/layers/cyclones/index.test.mjs b/src/layers/cyclones/index.test.mjs index a053531dc8..c6b64a6e1e 100644 --- a/src/layers/cyclones/index.test.mjs +++ b/src/layers/cyclones/index.test.mjs @@ -6,7 +6,10 @@ import { releasePointer, isPointerFree, } from '../../data/inputOwnership.js'; -import { isOwnedByOtherLayer } from '../../data/pickRegistry.js'; +import { + isOwnedByOtherLayer, + setClickCardHitTest, +} from '../../data/pickRegistry.js'; import { fakeInput } from '../../input/testDoubles.mjs'; import { bindFakeCesiumCamera } from '../../testSupport/fakeCameraPort.mjs'; @@ -77,7 +80,7 @@ const deferred = () => { return { promise, resolve }; }; -test('map selection yields to pointer owners and owns only its enabled handler', async () => { +test('map selection yields to pointer owners and owns only its enabled handler', async (t) => { const handlers = [], // A pick of an item in one of the layer's draw sets, and one of another // layer's set: the dispatcher hands each to pickStorm as a draw hit. @@ -109,11 +112,12 @@ test('map selection yields to pointer owners and owns only its enabled handler', const layer = createCyclonesLayer({ feed: { getSnapshot: async () => snapshot([storm(), storm('ep162026')]) }, createRendering: () => rendering, - hitTestOverlay: () => { - overlayTests++; - return overlayHit; - }, }); + setClickCardHitTest(() => { + overlayTests++; + return overlayHit; + }); + t.after(() => setClickCardHitTest(null)); const canvas = new EventTarget(); canvas.getBoundingClientRect = () => ({ left: 100, top: 200 }); const viewer = { @@ -180,41 +184,15 @@ test('map selection yields to pointer owners and owns only its enabled handler', 'foreground AIS card wins before scene picking', ); assert.equal(layer.getDiagnostics().selectedId, 'ep152026'); - // A native capture runs before an earlier sibling handler clears hit rects. - const up = new Event('pointerup'); - Object.assign(up, { clientX: 110, clientY: 220 }); - canvas.dispatchEvent(up); - overlayHit = null; + // Any other layer's card on top takes the click, not only a vessel's. + overlayHit = { sourceId: 'cctv', entryId: 'camera:1' }; handlers[0].click(click); assert.equal( layer.getDiagnostics().selectedId, 'ep152026', - 'captured AIS hit survives synchronous sibling overlay rebuild', + 'a camera card over the storm keeps the click', ); - // A captured background hit remains background even if a sibling adds a card. - canvas.dispatchEvent(up); - overlayHit = { sourceId: 'ais-live-vessels', entryId: 'vessel:123' }; - handlers[0].click(click); - assert.equal(layer.getDiagnostics().selectedId, 'ep162026'); - layer.setParams({ stormId: 'ep152026' }); - // A new gesture clears an unconsumed release snapshot. - canvas.dispatchEvent(up); - canvas.dispatchEvent(new Event('pointerdown')); overlayHit = null; - handlers[0].click(click); - assert.equal(layer.getDiagnostics().selectedId, 'ep162026'); - layer.setParams({ stormId: 'ep152026' }); - overlayHit = { sourceId: 'ais-live-vessels', entryId: 'vessel:123' }; - canvas.dispatchEvent(up); - overlayHit = null; - handlers[0].click({ position: { x: 15, y: 25 } }); - assert.equal( - layer.getDiagnostics().selectedId, - 'ep162026', - 'a different click cannot reuse the captured card', - ); - layer.setParams({ stormId: 'ep152026' }); - overlayHit = { sourceId: 'cctv', entryId: 'camera:1' }; const before = notices; handlers[0].click(click); assert.equal(layer.getDiagnostics().selectedId, 'ep162026'); @@ -264,13 +242,12 @@ test('map selection yields to pointer owners and owns only its enabled handler', assert.equal(layer.getDiagnostics().selectionActive, false); const afterDisable = picks; const afterDisableOverlay = overlayTests; - canvas.dispatchEvent(up); + handlers[0].click(click); assert.equal( overlayTests, afterDisableOverlay, - 'disable removes native capture listeners', + 'a disabled layer reads no card', ); - handlers[0].click(click); assert.equal(picks, afterDisable, 'queued disabled callback is inert'); layer.enable(); await layer.update(); @@ -289,7 +266,7 @@ test('map selection yields to pointer owners and owns only its enabled handler', ); assert.equal(handlers[1].destroyed, true); }); -test('a click on a storm card or lead-hour label selects that storm without picking', async () => { +test('a click on a storm card or lead-hour label selects that storm without picking', async (t) => { const handlers = []; let picks = 0, overlayHit = null, @@ -309,8 +286,9 @@ test('a click on a storm card or lead-hour label selects that storm without pick getDiagnostics: () => ({}), }; }, - hitTestOverlay: () => overlayHit, }); + setClickCardHitTest(() => overlayHit); + t.after(() => setClickCardHitTest(null)); const canvas = new EventTarget(); canvas.getBoundingClientRect = () => ({ left: 0, top: 0 }); const viewer = { @@ -343,15 +321,11 @@ test('a click on a storm card or lead-hour label selects that storm without pick overlayHit = { sourceId: 'weather-cyclones', entryId: 'storm:al019999' }; handlers[0].click(click); assert.equal(layer.getDiagnostics().selectedId, 'ep152026'); - // The native release snapshot carries the card identity too. - const up = new Event('pointerup'); - Object.assign(up, { clientX: 10, clientY: 20 }); overlayHit = { sourceId: 'weather-cyclones', entryId: 'storm:ep162026' }; - canvas.dispatchEvent(up); - overlayHit = null; handlers[0].click(click); assert.equal(layer.getDiagnostics().selectedId, 'ep162026'); assert.equal(picks, 0, 'card clicks never fall through to the scene'); + overlayHit = null; handlers[0].click(click); assert.equal(picks, 1); assert.equal(layer.getDiagnostics().selectedId, null, 'empty map clears'); diff --git a/src/layers/directions/index.js b/src/layers/directions/index.js index 873eac5041..53a68aa720 100644 --- a/src/layers/directions/index.js +++ b/src/layers/directions/index.js @@ -1584,6 +1584,9 @@ export function createDirectionsLayer({ services, source }) { // yields the moment a tool (this one included) owns the click. const offSelect = input.onClick((event) => { if (!_enabled) return; + // Another layer's card or label painted on top takes the click: the item + // under it does not act, and the click is not empty space either. + if (services.picking?.isUnderOtherCard?.(event)) return; let hit = null; try { hit = event.drawHit; @@ -1672,13 +1675,10 @@ export function createDirectionsLayer({ services, source }) { _overlayHost.setVisible(DIRECTIONS_STEP_OVERLAY_SOURCE_ID, true); _overlayHost.setVisible(DIRECTIONS_MARKER_OVERLAY_SOURCE_ID, true); _installClickHandler(viewer); - // Only the maneuver steps act on a click; the route line and the A/B - // markers are passive, so a card painted over them keeps its click. services.picking.registerPickOwner( 'directions', (pickedId) => typeof pickedId === 'string' && pickedId.startsWith('directions:'), - { passive: (pickedId) => !pickedId.startsWith('directions:step:') }, ); syncRenderHold(); }, diff --git a/src/layers/droneAirspace/index.js b/src/layers/droneAirspace/index.js index 1e359b8d9b..b83ccdaaf1 100644 --- a/src/layers/droneAirspace/index.js +++ b/src/layers/droneAirspace/index.js @@ -129,23 +129,12 @@ export function createDroneAirspaceLayer({ // so claiming these large ground polygons would make FIRMS/vessel/CCTV // cards inert anywhere over a zone. Unowned, our picks read as // "empty space" to siblings — the same contract as fire perimeters. - // Our shapes stand aside for a card painted over them (below), so that - // card's layer may act on the click; without a hit-test they cannot. - if (overlayHost?.hitTest) - picking?.registerCardBackground?.( - layer.id, - (hit) => pickedZoneId(hit) !== null, - ); _clickSubscription = inputFor(_viewer).onClick((event) => { - const cardHit = overlayHost.hitTest?.( - event.screenPosition?.x, - event.screenPosition?.y, - ); - // Only the top painted card owns the click; this area's shapes are - // background when another layer has painted a card or label over them. - if (cardHit && cardHit.sourceId !== DRONE_AIRSPACE_OVERLAY_SOURCE_ID) - return; - if (cardHit && cardHit.entryId === _selectedCardId) return; + // The card or label painted on top takes the click, read once per + // click so every layer agrees: this area's shapes are background to + // another layer's card or label painted over them, and a click on our + // own card leaves the selection as it is. + if (picking.clickCard?.(event)) return; const picked = event.topHit; const zoneId = picked ? pickedZoneId(event.drawHit) : null; if (zoneId) { @@ -167,7 +156,6 @@ export function createDroneAirspaceLayer({ function removeClickHandler() { _clickSubscription?.(); _clickSubscription = null; - picking?.unregisterCardBackground?.(layer.id); } function clearSelection() { diff --git a/src/layers/droneAirspace/ownership.test.mjs b/src/layers/droneAirspace/ownership.test.mjs index 306fd32c55..30045280a6 100644 --- a/src/layers/droneAirspace/ownership.test.mjs +++ b/src/layers/droneAirspace/ownership.test.mjs @@ -17,7 +17,6 @@ const liveSet = (draw, suffix) => function harness(source, { pick = () => null, cardHit = () => null } = {}) { const overlay = { entries: new Map(), visible: null }; const owners = new Map(); - const backgrounds = new Map(); const viewer = { scene: { pick } }; const { draw } = bindFakeDraw(viewer); const input = fakeInput(viewer); @@ -48,9 +47,9 @@ function harness(source, { pick = () => null, cardHit = () => null } = {}) { String(pickedId).startsWith('other-layer:'), registerPickOwner: (layerId, predicate) => owners.set(layerId, predicate), unregisterPickOwner: (layerId) => owners.delete(layerId), - registerCardBackground: (layerId, predicate) => - backgrounds.set(layerId, predicate), - unregisterCardBackground: (layerId) => backgrounds.delete(layerId), + // The card on top at a click, as the registry answers from the host. + clickCard: (click) => + cardHit(click.screenPosition?.x, click.screenPosition?.y, {}), }, }); layer.init(viewer); @@ -65,7 +64,6 @@ function harness(source, { pick = () => null, cardHit = () => null } = {}) { overlay, clicks, owners, - backgrounds, }; } @@ -284,21 +282,3 @@ test('a boundary change alone redraws the zone; identical geometry does not', as assert.notDeepEqual(redrawn.positions, first.positions); assert.ok(h.layer.getAnalystRecords()[0].lon > -76.6); }); - -// A card painted over the area may act there (a live CCTV card): the layer -// names its own drawn shapes, and only while it takes clicks. -test('enabled, the zone shapes register as card background', async () => { - const h = harness({ getSnapshot: async () => [row] }); - await h.layer.update(h.viewer); - const isBackground = h.backgrounds.get('drone-airspace'); - const own = { - set: h.fills().spec.id, - id: 'drone-airspace:310:0', - surface: false, - }; - assert.equal(isBackground(own), true); - assert.equal(isBackground({ ...own, set: 'other:1:fills' }), false); - assert.equal(isBackground({ ...own, id: 'other-layer:x' }), false); - h.layer.disable(h.viewer); - assert.equal(h.backgrounds.has('drone-airspace'), false); -}); diff --git a/src/layers/earthquakes/index.js b/src/layers/earthquakes/index.js index 1389662a74..58a657c901 100644 --- a/src/layers/earthquakes/index.js +++ b/src/layers/earthquakes/index.js @@ -1,6 +1,10 @@ import { fromDegrees } from '../../geo/ellipsoid.js'; import { drawOf } from '../../render/rendererOf.js'; import { worldClock } from '../../time/worldClock.js'; +import { + isTrackingClickGesture, + isTrackingSelectionGesture, +} from '../../data/trackingClickGesture.js'; import { EARTHQUAKE_OVERLAY_SOURCE_ID, EARTHQUAKE_OVERLAY_COHORT_LIMIT, @@ -58,15 +62,13 @@ let instances = 0; * without `input` and `picking` the discs are drawn but take no clicks. * @param {object} options * @param {object} options.source Snapshot source. - * @param {object} options.overlayHost World-overlay host (`hitTest` lets - * the card be clicked). + * @param {object} options.overlayHost World-overlay host. * @param {(viewer: object) => {onClick: Function}} [options.input] The * viewer's click dispatcher. * @param {{resolvePickId: Function, isOwnedByOtherLayer: Function, - * isActedOnByOtherLayer?: Function, registerCardBackground?: Function, - * unregisterCardBackground?: Function}} [options.picking] The pick - * registry; with the card-background pair, a card painted over a disc - * (a CCTV card) may act on the click. + * clickCard?: Function}} [options.picking] The pick + * registry; `clickCard` names the card or label painted on top of a + * click, which takes it (the quake card and labels need it to act). * @param {{registerEntityContext: Function, selectEntityContext: Function, * clearSelectedEntityContextForLayer: Function, * getContextStore: Function}} [options.context] Shared selection store. @@ -351,63 +353,39 @@ export function createEarthquakesLayer({ clicks = null; } if (!clicks) return; - // Our discs stand aside for another layer's card painted over them - // (below), so that card's layer may act on the click; without a - // hit-test they cannot. - if (overlayHost?.hitTest) - picking.registerCardBackground?.( - EARTHQUAKES_LAYER_ID, - (hit) => pickedEvent(hit) !== null, - ); _clickHandler = clicks.onClick((click) => { if (!_enabled || (pointer && !pointer.isPointerFree())) return; - const at = click.screenPosition; - // Another layer's card or label painted on top (a fire's card over a - // quake disc) is that layer's click: the disc under it is background. - const topEntry = overlayHost.hitTest?.(at?.x, at?.y); - if ( - topEntry && - topEntry.sourceId !== EARTHQUAKE_CARD_SOURCE_ID && - topEntry.sourceId !== EARTHQUAKE_OVERLAY_SOURCE_ID - ) - return; - // Another layer's pick that it acts on (an aircraft, a camera) is not - // this layer's, even under this layer's card or a magnitude label: - // that layer takes the click, and this card stays. A passive owner's - // pick (a flight trail, a directions route) acts for nobody, so the - // card or label over it keeps the click. - const hit = click.hit; - const pickId = picking.resolvePickId(hit); - const actedOn = - picking.isActedOnByOtherLayer ?? picking.isOwnedByOtherLayer; - // Exact-only handlers cannot act on a nearby touch hit. Compare ids, - // since the dispatcher may expose distinct objects for the same pick. - const expanded = - 'topHit' in click && picking.resolvePickId(click.topHit) !== pickId; - if (pickId && actedOn(EARTHQUAKES_LAYER_ID, pickId, { expanded, click })) - return; - const cardHit = overlayHost.hitTest?.(at?.x, at?.y, { - sourceId: EARTHQUAKE_CARD_SOURCE_ID, - }); - if (cardHit && cardHit.entryId === _selectedCardId) { + // A pan that ends near where it began still raises a click. As for the + // tracking layers and Context, a press that travelled is a drag, not a + // pick; opening the source and clearing also need a short press. + if (!isTrackingSelectionGesture(click.gesture)) return; + const clean = isTrackingClickGesture(click.gesture); + // The card or label painted on top takes the click, read once per + // click so every layer agrees: another layer's is that layer's click + // (the disc under it is background), and ours acts whatever is drawn + // under it. + const top = picking.clickCard?.(click) ?? null; + if (top?.sourceId === EARTHQUAKE_CARD_SOURCE_ID) { // The card's action, as its keyboard action: open the source, or // with none, fly to the quake. - if (_selectedLink) openExternal(_selectedLink); - else if (focus?.requestWorldFocus && _selectedId) + if (top.entryId !== _selectedCardId) return; + if (_selectedLink) { + if (clean) openExternal(_selectedLink); + } else if (focus?.requestWorldFocus && _selectedId) selectAndFocus(_selectedId); return; } // A magnitude label is what a far view (the whole globe) can click: // it selects the quake and flies to it. - const labelHit = overlayHost.hitTest?.(at?.x, at?.y, { - sourceId: EARTHQUAKE_OVERLAY_SOURCE_ID, - }); - if (labelHit && _eventById.has(labelHit.entryId)) { - selectAndFocus(labelHit.entryId); + if (top?.sourceId === EARTHQUAKE_OVERLAY_SOURCE_ID) { + if (_eventById.has(top.entryId)) selectAndFocus(top.entryId); return; } - // A passive owner's pick with nothing of ours over it is still not - // empty space: leave the selection alone, as every layer does. + if (top) return; + // Another layer's pick (an aircraft, a camera, a flight trail) is not + // empty space and not this layer's: leave the selection alone. + const hit = click.hit; + const pickId = picking.resolvePickId(hit); if (pickId && picking.isOwnedByOtherLayer(EARTHQUAKES_LAYER_ID, pickId)) return; const event = pickedEvent(hit); @@ -416,7 +394,7 @@ export function createEarthquakesLayer({ publishCard({ user: true }); return; } - clearSelection(); + if (clean) clearSelection(); }); } @@ -443,7 +421,6 @@ export function createEarthquakesLayer({ function removeClickHandler() { _clickHandler?.(); _clickHandler = null; - picking?.unregisterCardBackground?.(EARTHQUAKES_LAYER_ID); } const layer = { diff --git a/src/layers/earthquakes/selection.test.mjs b/src/layers/earthquakes/selection.test.mjs index 496908b19a..f336eaee0a 100644 --- a/src/layers/earthquakes/selection.test.mjs +++ b/src/layers/earthquakes/selection.test.mjs @@ -83,6 +83,8 @@ function harness( return hit && entry?.interactive === true ? hit : null; }, }; + // The card on top at a click, as the host answers the pick registry. + picking.setClickCardHitTest((x, y) => overlayHost.hitTest(x, y)); const layer = createEarthquakesLayer({ source: { getSnapshot: async () => snapshot }, overlayHost, @@ -128,13 +130,14 @@ function harness( snapshot = next; }, /** Click a quake's disc (by stable id), something else, or the map. */ - click(hit, resolvedHit = hit) { + click(hit, resolvedHit = hit, gesture = { travelPx: 0, durationMs: 0 }) { for (const { callback } of live()) callback({ screenPosition: { x: 10, y: 10 }, topHit: hit, hit: resolvedHit, drawHit: hit && !hit.surface ? hit : null, + gesture, }); }, clickDisc(id) { @@ -276,17 +279,12 @@ test('a refresh keeps the selected quake while it is in the feed', async () => { h.layer.destroy(); }); -test('disable removes the click handler, card background and the card', async () => { +test('disable removes the click handler and the card', async () => { const h = harness([quake('ak1')]); h.layer.enable(h.viewer); await h.layer.update(h.viewer); h.clickDisc('ak1'); - // A drawn disc is background to a card painted over it (a CCTV card). - const disc = { set: h.discs().spec.id, id: 'earthquake:ak1' }; - assert.equal(picking.isCardBackground(disc), true); - assert.equal(picking.isCardBackground({ ...disc, set: 'other:1' }), false); h.layer.disable(h.viewer); - assert.equal(picking.isCardBackground(disc), false); assert.deepEqual(h.lastCard(), []); assert.equal( h.handlers.every((handler) => handler.destroyed), @@ -673,7 +671,8 @@ test('a feed refresh neither retakes the selection nor restarts the contours', a h.layer.destroy(); }); -test("another layer's object over a magnitude label takes the click", async () => { +// The label painted on top takes the click: the object drawn under it does not. +test("a magnitude label takes the click over another layer's object", async () => { const h = harness([quake('ak1')]); h.layer.enable(h.viewer); await h.layer.update(h.viewer); @@ -684,12 +683,11 @@ test("another layer's object over a magnitude label takes the click", async () = set: 'flights:1', id: 'plane-9', }); - assert.equal(h.cards.length, 0, 'the quake is not selected'); - assert.equal(h.focused.length, 0, 'and the camera stays'); - // The label alone still selects and flies. - h.clickLabel('ak1'); - assert.equal(h.lastCard()[0].id, 'earthquake-card:ak1'); - assert.equal(h.focused.length, 1); + assert.equal(h.lastCard()[0].id, 'earthquake-card:ak1', 'selected'); + assert.equal(h.focused.length, 1, 'and the camera flies'); + // The plane alone, with no label over it, is not empty space. + h.click({ set: 'flights:1', id: 'plane-9' }); + assert.equal(h.lastCard()[0].id, 'earthquake-card:ak1', 'kept'); } finally { picking.unregisterPickOwner('test-plane'); h.layer.destroy(); @@ -709,21 +707,19 @@ test('a touch-expanded quake hit selects its disc without flying', async () => { } }); -test('a touch-expanded sibling hit takes precedence over a quake label', async () => { +test('a quake label takes the click over a touch-expanded sibling hit', async () => { const h = harness([quake('ak1'), quake('ak2')]); try { h.layer.enable(h.viewer); await h.layer.update(h.viewer); h.clickDisc('ak1'); - picking.registerPickOwner('test-plane', (id) => id === 'plane-9', { - expanded: true, - }); + picking.registerPickOwner('test-plane', (id) => id === 'plane-9'); h.clickOverlayWith(EARTHQUAKE_OVERLAY_SOURCE_ID, 'ak2', null, { set: 'flights:1', id: 'plane-9', }); - assert.equal(h.lastCard()[0].id, 'earthquake-card:ak1'); - assert.equal(h.focused.length, 0); + assert.equal(h.lastCard()[0].id, 'earthquake-card:ak2'); + assert.equal(h.focused.length, 1); } finally { picking.unregisterPickOwner('test-plane'); h.layer.destroy(); @@ -751,7 +747,7 @@ test("another layer's card over a quake disc takes the click, and the disc yield }); for (const coarse of [false, true]) { - test(`a quake card yields while an aircraft starts tracking (${coarse ? 'coarse' : 'exact'} hit)`, async (t) => { + test(`a quake card takes the click over an aircraft, which does not track (${coarse ? 'coarse' : 'exact'} hit)`, async (t) => { const previous = globalThis.matchMedia; globalThis.matchMedia = () => ({ matches: coarse }); t.after(() => { @@ -771,9 +767,10 @@ for (const coarse of [false, true]) { drillPick: () => (nearby ? [{ id: nearby }] : []), }; input = fakeInput(viewer); - // The aircraft layer runs first and changes its passive predicate - // synchronously after reading the dispatched hit. + // The aircraft layer runs first; like every layer, it leaves a + // click under another layer's card to that card. input.input.onClick((event) => { + if (picking.isUnderOtherCard(event)) return; const id = event.hit?.id; if (id !== plane.id || tracked === id) return; tracked = id; @@ -782,10 +779,7 @@ for (const coarse of [false, true]) { return input.input; }, }); - picking.registerPickOwner('test-plane', (id) => id === plane.id, { - expanded: true, - passive: (id) => id === tracked, - }); + picking.registerPickOwner('test-plane', (id) => id === plane.id); t.after(() => { picking.unregisterPickOwner('test-plane'); h.layer.destroy(); @@ -804,15 +798,18 @@ for (const coarse of [false, true]) { nearby = coarse ? plane : null; input.click(); - assert.equal(tracks, 1, 'the aircraft starts tracking'); - assert.deepEqual(h.opened, [], 'the quake card yields for the whole click'); - assert.equal(h.lastCard()[0].id, card.id, 'the card stays'); - - input.click(); - assert.equal(tracks, 1, 'already tracking the aircraft'); + assert.equal(tracks, 0, 'the aircraft under the card does not track'); assert.deepEqual(h.opened, [ 'https://earthquake.usgs.gov/earthquakes/eventpage/ak1', ]); + assert.equal(h.lastCard()[0].id, card.id, 'the card stays'); + + // Without the card the aircraft takes it, and the quake stays selected. + h.overlayHits.clear(); + input.click(); + assert.equal(tracks, 1, 'the bare aircraft tracks'); + assert.equal(h.opened.length, 1); + assert.equal(h.lastCard()[0].id, card.id); }); } @@ -853,6 +850,7 @@ for (const kind of ['card', 'label']) { paint(); input.click(); }; + picking.setClickCardHitTest((x, y) => host.hitTest(x, y)); const q = createEarthquakesLayer({ source: { getSnapshot: async () => [quake('ak1')] }, overlayHost: host, @@ -983,15 +981,12 @@ test('quake card and label work over pickable items no layer acts on', async () } }); -// Flight trails and a directions route line are registered owners that act -// on no click. Under the quake card or a magnitude label they must not make -// the click dead; a layer that acts (an aircraft) still takes it. -test('quake card and label act over a flight trail and a directions route', async () => { +// The quake card or a magnitude label on top takes the click over whatever is +// drawn under it: a flight trail, a route, a route step or an aircraft. +test('quake card and label act over trails, routes, steps and aircraft', async () => { const h = harness([quake('ak1'), quake('ak2', { mag: 4 })]); - picking.registerPickOwner( - 'test-directions', - (id) => String(id).startsWith('directions:'), - { passive: (id) => !id.startsWith('directions:step:') }, + picking.registerPickOwner('test-directions', (id) => + String(id).startsWith('directions:'), ); picking.registerPickOwner('test-plane', (id) => id === 'plane-9'); try { @@ -1006,19 +1001,19 @@ test('quake card and label act over a flight trail and a directions route', asyn assert.equal(h.opened.length, 2, 'the card opens USGS over both'); h.clickOverlayWith(EARTHQUAKE_OVERLAY_SOURCE_ID, 'ak2', trail); assert.equal(h.focused.at(-1)?.id, 'earthquake:ak2', 'the label flies'); - // A route step acts for directions: it takes the click. - const focusedBefore = h.focused.length; + // A route step under the label: the label still takes it. h.clickOverlayWith(EARTHQUAKE_OVERLAY_SOURCE_ID, 'ak1', { set: 'directions:1:steps', id: 'directions:step:2', }); - assert.equal(h.focused.length, focusedBefore, 'a step takes the click'); - // So does an aircraft under the card. + assert.equal(h.focused.at(-1)?.id, 'earthquake:ak1', 'over a step'); + // So does the card over an aircraft. + h.clickOverlayWith(EARTHQUAKE_OVERLAY_SOURCE_ID, 'ak2', null); h.clickOverlayWith(EARTHQUAKE_CARD_SOURCE_ID, 'earthquake-card:ak2', { set: 'flights:1', id: 'plane-9', }); - assert.equal(h.opened.length, 2); + assert.equal(h.opened.length, 3, 'over an aircraft'); // A plain click on a trail is still not empty space: the card stays. h.click(trail); assert.equal(h.lastCard()[0].id, 'earthquake-card:ak2'); @@ -1029,7 +1024,7 @@ test('quake card and label act over a flight trail and a directions route', asyn } }); -test('coarse FIRMS near-misses leave quake overlays actionable; exact fire hits act once', async (t) => { +test('quake overlays take the click over a nearby or exact fire; a bare fire acts once', async (t) => { const previous = globalThis.matchMedia; globalThis.matchMedia = () => ({ matches: true }); t.after(() => { @@ -1094,8 +1089,12 @@ test('coarse FIRMS near-misses leave quake overlays actionable; exact fire hits assert.equal(fireFocus.length, 0); sceneHit = fireHit; input.click(); - assert.equal(fireFocus.length, 1, 'exact fire hit acts'); - assert.equal(h.opened.length, 1, 'card yields to the exact fire'); + assert.equal(fireFocus.length, 0, 'an exact fire under the card does not'); + assert.equal(h.opened.length, 2, 'the card on top acts'); + h.overlayHits.clear(); + input.click(); + assert.equal(fireFocus.length, 1, 'the bare fire acts'); + assert.equal(h.opened.length, 2); } finally { selection.removeClickHandler(); picking.unregisterPickOwner('firms'); @@ -1104,9 +1103,9 @@ test('coarse FIRMS near-misses leave quake overlays actionable; exact fire hits } }); -// A tap that drifts more than the tracking click travel is ignored by the -// aircraft layers, so a quake card painted beside an aircraft keeps it. -test('a quake card keeps a dragged tap beside an aircraft that declines it', async (t) => { +// A tap that drifts more than the tracking click travel is a drag: the quake +// card ignores it, as the aircraft layers do. +test('a quake card takes a still tap beside an aircraft but not a dragged one', async (t) => { const previous = globalThis.matchMedia; globalThis.matchMedia = () => ({ matches: true }); t.after(() => { @@ -1127,10 +1126,7 @@ test('a quake card keeps a dragged tap beside an aircraft that declines it', asy return input.input; }, }); - picking.registerPickOwner('test-plane', (id) => id === plane.id, { - expanded: true, - declinesClick: (click) => (click?.gesture?.travelPx ?? 0) > 6, - }); + picking.registerPickOwner('test-plane', (id) => id === plane.id); t.after(() => { picking.unregisterPickOwner('test-plane'); h.layer.destroy(); @@ -1147,15 +1143,57 @@ test('a quake card keeps a dragged tap beside an aircraft that declines it', asy }); sceneHit = null; nearby = plane; - // A still tap: the aircraft acts on its contact, so the card yields. + // A still tap: the card on top takes it over the aircraft's contact. input.tap({ x: 10, y: 10 }); - assert.deepEqual(h.opened, []); + assert.equal(h.opened.length, 1); // A tap that drifts 10 px: the aircraft ignores it, so the card opens. input.down({ x: 10, y: 10 }); input.move({ x: 20, y: 10 }, { x: 10, y: 10 }); input.up({ x: 20, y: 10 }); input.click({ x: 20, y: 10 }); - assert.equal(h.opened.length, 1, 'the card keeps the dragged tap'); + assert.equal(h.opened.length, 1, 'a drag opens nothing'); +}); + +// A pan that ends near where it began still raises a click: it must not +// select a quake, fly to one, open its source or clear the selection. +test('a drag that ends on a quake does nothing; a long press selects but neither opens nor clears', async () => { + const drag = { travelPx: 12, durationMs: 120 }; + const hold = { travelPx: 0, durationMs: 900 }; + const h = harness([quake('ak1'), quake('ak2')]); + h.layer.enable(h.viewer); + await h.layer.update(h.viewer); + const disc = (id) => ({ set: h.discs().spec.id, id: `earthquake:${id}` }); + h.click(disc('ak1'), disc('ak1'), drag); + assert.equal(h.cards.length, 0, 'a drag over a disc selects nothing'); + h.overlayHits.set(EARTHQUAKE_OVERLAY_SOURCE_ID, { + sourceId: EARTHQUAKE_OVERLAY_SOURCE_ID, + entryId: 'ak2', + }); + h.click(null, null, drag); + h.overlayHits.clear(); + assert.equal(h.focused.length, 0, 'a drag over a label does not fly'); + h.click(disc('ak1'), disc('ak1'), hold); + const card = h.lastCard()[0]; + assert.ok(card, 'a long press on a disc selects it'); + h.overlayHits.set(EARTHQUAKE_CARD_SOURCE_ID, { + sourceId: EARTHQUAKE_CARD_SOURCE_ID, + entryId: card.id, + }); + h.click(null, null, hold); + h.overlayHits.clear(); + assert.deepEqual(h.opened, [], 'a long press does not open the source'); + const cardsBefore = h.cards.length; + h.click(null, null, drag); + h.click(null, null, hold); + assert.equal( + h.cards.length, + cardsBefore, + 'a drag or hold on the map keeps it', + ); + assert.ok(h.lastCard().length, 'still selected'); + h.click(null); + assert.deepEqual(h.lastCard(), [], 'a clean click on the map clears it'); + h.layer.destroy(); }); // A refresh that no longer carries the selected quake evicts it, as other diff --git a/src/layers/firms/selection.js b/src/layers/firms/selection.js index 6788cf64f4..54622bb4a2 100644 --- a/src/layers/firms/selection.js +++ b/src/layers/firms/selection.js @@ -13,8 +13,7 @@ export function createSelection({ config, feed, }) { - const { resolvePickId, isOwnedByOtherLayer, isActedOnByOtherLayer } = - services.picking; + const { resolvePickId, isOwnedByOtherLayer, clickCard } = services.picking; const { requestWorldFocus } = services.focus; const { selectEntityContext, @@ -22,7 +21,7 @@ export function createSelection({ getContextStore, registerEntityContext, } = services.context; - const { id, name, overlayHost } = config; + const { id, name } = config; /** * Install the LEFT_CLICK handler for fire selection (enable-time only, @@ -35,48 +34,25 @@ export function createSelection({ if (layerState._clickSubscription || !layerState._viewer) return; const input = inputFor(layerState._viewer); layerState._clickSubscription = input.onClick((event) => { - const picked = event.topHit; + // The card or label painted on top takes the click, read once per + // click so every layer agrees: ours acts whatever is drawn under it; + // another layer's is that layer's click. + const top = clickCard?.(event) ?? null; + if (top) { + if (top.sourceId !== FIRMS_OVERLAY_SOURCE_ID) return; + const carded = layerState._fireByCardId.get(top.entryId); + if (carded) selectAndFocusFire(carded); + return; + } const fire = pickedFire(event.drawHit); if (fire) { selectAndFocusFire(fire); return; } - // A pick that belongs to a sibling layer (e.g. an aircraft) is not - // "empty space" — leave the selection alone and let that layer handle it. - // A passive owner's pick (a flight trail, a directions route) acts for - // nobody, so a card of ours painted over it still takes the click. - let passivePick = false; - if (picked) { - const pickedId = resolvePickId(picked); - if (pickedId && isOwnedByOtherLayer(id, pickedId)) { - passivePick = - Boolean(isActedOnByOtherLayer) && - !isActedOnByOtherLayer(id, pickedId, { click: event }); - if (!passivePick) return; - } - } - const cardHit = overlayHost.hitTest?.( - event.screenPosition?.x, - event.screenPosition?.y, - ); - if (passivePick && cardHit?.sourceId !== FIRMS_OVERLAY_SOURCE_ID) return; - // A coarse tap's touch contact (not the exact pick) that its layer acts - // on (an aircraft, a vessel, a radio station) is that layer's click, - // even under a card of ours. - const contactId = resolvePickId(event.hit ?? null); - if ( - cardHit && - contactId && - contactId !== resolvePickId(picked ?? null) && - isActedOnByOtherLayer?.(id, contactId, { expanded: true, click: event }) - ) - return; - if (cardHit) { - if (cardHit.sourceId !== FIRMS_OVERLAY_SOURCE_ID) return; - const carded = layerState._fireByCardId.get(cardHit.entryId); - if (carded) selectAndFocusFire(carded); - return; - } + // A pick that belongs to a sibling layer (an aircraft, a flight trail) + // is not "empty space": leave the selection alone. + const pickedId = resolvePickId(event.topHit ?? null); + if (pickedId && isOwnedByOtherLayer(id, pickedId)) return; clearFireSelection(); }); } diff --git a/src/layers/flights/lifecycle.js b/src/layers/flights/lifecycle.js index fa25261e83..790aad1495 100644 --- a/src/layers/flights/lifecycle.js +++ b/src/layers/flights/lifecycle.js @@ -1,4 +1,3 @@ -import { isTrackingSelectionGesture } from '../../data/trackingClickGesture.js'; import { findCamera, findFrame } from '../../render/rendererOf.js'; import { loadFleetModelSet } from '../../data/fleetModels.js'; import { forgetPlacedAircraft } from './placed.js'; @@ -135,19 +134,6 @@ export function createLifecycle({ registerPickOwner( 'flights', (pickedId) => flightState._icons?.has(pickedId) === true, - { - expanded: true, - // A click on the aircraft already tracked is ignored: for that one - // plane the layer acts on nothing, so a card over it keeps the tap. - passive: (pickedId) => - Boolean(flightState._trackedIcao) && - pickedId === flightState._trackedIcao, - // The click handler ignores a dragged tap and any tap in cockpit - // mode, so a card over the aircraft keeps that tap. - declinesClick: (click) => - !isTrackingSelectionGesture(click?.gesture) || - Boolean(document.body?.classList.contains('cockpit-mode')), - }, ); const frame = findFrame(viewer); if (!flightState._preRenderRemove && frame) { diff --git a/src/layers/flights/ownership.test.mjs b/src/layers/flights/ownership.test.mjs index 3947a6999f..c5a7d1a340 100644 --- a/src/layers/flights/ownership.test.mjs +++ b/src/layers/flights/ownership.test.mjs @@ -4,6 +4,8 @@ import { createCivilFlightLayer } from './index.js'; import { createFlightState } from './state.js'; import { createEnrichment } from './enrichment.js'; import { createTracking } from './tracking.js'; +import { fakeInput } from '../../input/testDoubles.mjs'; +import * as picking from '../../data/pickRegistry.js'; import { LiveSourceError } from '../../sources/live/contract.js'; function services() { @@ -608,3 +610,47 @@ test('a route answer for a callsign the plane no longer flies is dropped', async assert.equal(meta.routeCallsign, 'UAL10'); flightState.lifetime.abort(); }); + +// The card or label painted on top takes the click: an aircraft under another +// layer's card is not even picked, so it is neither tracked nor released. +test("another layer's card over an aircraft keeps the click", (t) => { + const previousDocument = globalThis.document; + globalThis.document = Object.assign(new EventTarget(), { + body: { classList: { contains: () => false } }, + }); + let picks = 0; + const viewer = { + scene: { + canvas: new EventTarget(), + pick: () => { + picks++; + return null; + }, + }, + }; + const input = fakeInput(viewer); + const flightState = createFlightState({ services: services() }); + flightState._trackedEntityChangedRemove = () => {}; + const tracking = createTracking({ + flightState, + services: { ...services(), picking }, + parts: {}, + layer: {}, + }); + tracking._installClickHandler(viewer); + let top = { sourceId: 'earthquake-card', entryId: 'earthquake-card:ak1' }; + picking.setClickCardHitTest(() => top); + t.after(() => { + picking.setClickCardHitTest(null); + flightState._clickSubscription?.(); + input.destroy(); + flightState.lifetime.abort(); + if (previousDocument === undefined) delete globalThis.document; + else globalThis.document = previousDocument; + }); + input.tap({ x: 10, y: 10 }); + assert.equal(picks, 0, 'covered: the scene under the card is not picked'); + top = null; + input.tap({ x: 10, y: 10 }); + assert.ok(picks > 0, 'open map: the click reaches the scene'); +}); diff --git a/src/layers/flights/tracking.js b/src/layers/flights/tracking.js index 8017e05170..93c2d61b84 100644 --- a/src/layers/flights/tracking.js +++ b/src/layers/flights/tracking.js @@ -86,7 +86,8 @@ export function createTracking({ const { trackedLabelModelFromText, refreshTrackedReadout } = services.readout; const { FOLLOW_MIN_RANGE_M, SELECTION_FOLLOW_TRANSITION_S, followViewFrom } = services.camera; - const { resolvePickId, isOwnedByOtherLayer } = services.picking; + const { resolvePickId, isOwnedByOtherLayer, isUnderOtherCard } = + services.picking; const flightsLayer = layer; /** The tracked contact's billboard (an icon set on the draw port). */ const trackedIcon = createTrackedAircraftIcon({ @@ -1272,6 +1273,9 @@ export function createTracking({ // first-person reference. A globe click must not fall through to the // normal empty-space deselection path; cockpit has explicit exit controls. if (document.body.classList.contains('cockpit-mode')) return; + // Another layer's card or label painted on top takes the click: the item + // under it does not act, and the click is not empty space either. + if (isUnderOtherCard?.(event)) return; const picked = event.hit; if (picked) { diff --git a/src/layers/ghostMaps/index.js b/src/layers/ghostMaps/index.js index d2378de613..216e51b9b4 100644 --- a/src/layers/ghostMaps/index.js +++ b/src/layers/ghostMaps/index.js @@ -707,15 +707,19 @@ export function createGhostMapsLayer({ typeof pickedId === 'string' && pickedId.startsWith(PICK_PREFIX), ); _clickSubscription = inputFor(_viewer).onClick((event) => { - const cardHit = overlayHost.hitTest?.( - event.screenPosition?.x, - event.screenPosition?.y, - ); - if ( - cardHit?.sourceId === GHOSTMAPS_OVERLAY_SOURCE_ID && - cardHit.entryId === _selectedCardId - ) { - if (_selectedLink && openExternal) openExternal(_selectedLink); + // The card or label painted on top takes the click, read once per + // click so every layer agrees: ours opens its source whatever is drawn + // under it; another layer's is that layer's click, so the maps under + // it do not act and the selection stays. + const cardHit = picking.clickCard?.(event) ?? null; + if (cardHit) { + if ( + cardHit.sourceId === GHOSTMAPS_OVERLAY_SOURCE_ID && + cardHit.entryId === _selectedCardId && + _selectedLink && + openExternal + ) + openExternal(_selectedLink); return; } const picked = event.topHit; @@ -731,10 +735,6 @@ export function createGhostMapsLayer({ if (pickId && picking.isOwnedByOtherLayer(GHOSTMAPS_LAYER_ID, pickId)) return; } - // A covered card must neither open its source nor clear the selection. - // A marker of ours under that card was already selected by the pick - // check before this one. - if (cardHit) return; if (_selectedKey) { clearSelection(); render(); diff --git a/src/layers/ghostMaps/lifecycle.test.mjs b/src/layers/ghostMaps/lifecycle.test.mjs index ea4f99bed7..dd07ad4f96 100644 --- a/src/layers/ghostMaps/lifecycle.test.mjs +++ b/src/layers/ghostMaps/lifecycle.test.mjs @@ -664,7 +664,11 @@ test('a covered selected card yields while genuine GhostMaps markers still selec hitTest: (_x, _y, { sourceId } = {}) => painted.find((hit) => !sourceId || hit.sourceId === sourceId) ?? null, }, - picking: { resolvePickId: (picked) => picked }, + picking: { + resolvePickId: (picked) => picked, + // The card on top at a click, as the registry answers from the host. + clickCard: () => painted[0] ?? null, + }, openExternal: (url) => opened.push(url), }, }); @@ -679,13 +683,13 @@ test('a covered selected card yields while genuine GhostMaps markers still selec click(null); assert.deepEqual(opened, []); assert.equal(cards.at(-1)[0].id, first.id); + // A marker under another layer's card is that card's click too. + click('ghostmaps:cip:1:0'); + assert.equal(cards.at(-1)[0].id, first.id, 'a covered marker yields'); + painted = []; click('ghostmaps:cip:1:0'); const second = cards.at(-1)[0]; - assert.notEqual( - second.id, - first.id, - 'an actual marker still selects beneath the foreign card', - ); + assert.notEqual(second.id, first.id, 'a bare marker selects'); painted = [{ sourceId: 's2-ghostmaps', entryId: second.id }]; click(null); assert.deepEqual(opened, ['https://example.com/second']); diff --git a/src/layers/installations/selection.js b/src/layers/installations/selection.js index 323b7a1549..28a9301d0b 100644 --- a/src/layers/installations/selection.js +++ b/src/layers/installations/selection.js @@ -1,4 +1,5 @@ import { inputFor } from '../../input/dispatcher.js'; +import { isUnderOtherCard } from '../../data/pickRegistry.js'; import { LAYER_ID } from './policy.js'; export function createSelection({ @@ -52,6 +53,9 @@ export function createSelection({ const input = inputFor(viewer); layerState.clickSubscription = input.onClick((event) => { if (!layerState.enabled) return; + // Another layer's card or label painted on top takes the click: the item + // under it does not act, and the click is not empty space either. + if (isUnderOtherCard(event)) return; // A site's dot, outline or fill, or a named marker: each draw item // names its installation in its `meta`. const hit = event.drawHit; diff --git a/src/layers/installations/selection.test.mjs b/src/layers/installations/selection.test.mjs index ae6cc71fda..7844afb3ba 100644 --- a/src/layers/installations/selection.test.mjs +++ b/src/layers/installations/selection.test.mjs @@ -7,6 +7,7 @@ import { createRendering } from './rendering.js'; import { createNamedMarkers, namedPointId } from './namedMarkers.js'; import { bindFakeCesiumScene } from '../../testSupport/fakeCesiumScene.mjs'; import { fakeInput } from '../../input/testDoubles.mjs'; +import { setClickCardHitTest } from '../../data/pickRegistry.js'; function harness(t) { const previousWindow = globalThis.window; @@ -186,6 +187,30 @@ test('a click on a named marker point selects its site; again releases it', (t) h.assertSelected(false); }); +// The card or label painted on top takes the click: a site under another +// layer's card neither selects nor releases. +test("another layer's card over a site keeps the click", (t) => { + const h = harness(t); + let top = { sourceId: 'earthquake-card', entryId: 'earthquake-card:ak1' }; + setClickCardHitTest(() => top); + t.after(() => setClickCardHitTest(null)); + const setId = h.parts.namedMarkers.setId; + const item = h.draw.set(setId).items.get(namedPointId('base')); + const pointPick = { id: { set: setId, id: item.id, meta: item.meta } }; + h.click(pointPick); + h.assertSelected(true); + h.click(undefined); + h.assertSelected(true); + h.state.selectedId = null; + context.clearSelectedEntityContextForLayer('military-installations'); + h.parts.rendering.renderRecords(); + h.click(pointPick); + h.assertSelected(false); + top = null; + h.click(pointPick); + h.assertSelected(true); +}); + test('a click on a site dot or its outline selects the site; another set does not', (t) => { const h = harness(t); h.state.selectedId = null; diff --git a/src/layers/launches/clickYield.test.mjs b/src/layers/launches/clickYield.test.mjs index 9004e10c19..62dc8c31d4 100644 --- a/src/layers/launches/clickYield.test.mjs +++ b/src/layers/launches/clickYield.test.mjs @@ -28,8 +28,8 @@ test('a card painted over a launch marker keeps its click; with none the mission state, services: { render: { holdContinuousRender() {}, releaseContinuousRender() {} }, - overlays: { hitTestWorldOverlay: () => top }, - picking, + // The card on top at a click, as the registry answers from the host. + picking: { ...picking, clickCard: () => top }, }, parts: { panel: stubs(), @@ -61,15 +61,6 @@ test('a card painted over a launch marker keeps its click; with none the mission ['L1'], 'with no card on top, the mission selects', ); - // So a card on top (a live CCTV card) may act over the mission instead. - const mission = { set: 'launches:1:markers', id: 'mission:L1' }; - assert.equal(picking.isCardBackground(mission), true); - assert.equal(picking.isCardBackground({ ...mission, id: 'x' }), false); - state._enabled = false; - assert.equal(picking.isCardBackground(mission), false); - state._inputSubscription(); - state._enabled = true; - assert.equal(picking.isCardBackground(mission), false); } finally { state._inputSubscription?.(); input.destroy(); diff --git a/src/layers/launches/lifecycle.js b/src/layers/launches/lifecycle.js index dd9950dc96..77a999e047 100644 --- a/src/layers/launches/lifecycle.js +++ b/src/layers/launches/lifecycle.js @@ -4,8 +4,6 @@ import { canvasOf, findCamera, findFrame } from '../../render/rendererOf.js'; import { worldClock } from '../../time/worldClock.js'; const HOVER_PICK_INTERVAL_MS = 120; -/** Our id in the pick registry's card backgrounds. */ -const CARD_BACKGROUND_ID = 'rocket-launches'; /** * Bound hover picking independently of precise click selection. A move inside @@ -206,29 +204,12 @@ export function createLifecycle({ layerState._orbitMatches = 0; parts.overlays.clearMissionOverlaySources(); const input = inputFor(viewer); - // Our mission items stand aside for a card painted over them (below), - // so that card's layer may act on the click; without a hit-test they - // cannot. - if (services.overlays?.hitTestWorldOverlay) - services.picking?.registerCardBackground?.( - CARD_BACKGROUND_ID, - (hit) => - layerState._enabled && - parts.rendering.missionsShown() && - parts.rendering.launchIdFromPicks([hit]) !== null, - ); const unsubscribeClick = input.onClick((event) => { if (!layerState._enabled || !parts.rendering.missionsShown()) return; // Mission overlays are not interactive, so any overlay entry hit // here is another layer's card or label painted over the click: that // layer's click, not a mission's. - if ( - services.overlays?.hitTestWorldOverlay?.( - event.screenPosition?.x, - event.screenPosition?.y, - ) - ) - return; + if (services.picking?.clickCard?.(event)) return; // The click's pick position (CSS px), as the click picked it. const launchId = parts.rendering.launchIdFromPicks( parts.rendering.missionHitsAt(event.position, 12), @@ -248,7 +229,6 @@ export function createLifecycle({ layerState._inputSubscription = () => { unsubscribeClick(); unsubscribeHover(); - services.picking?.unregisterCardBackground?.(CARD_BACKGROUND_ID); }; // Apply horizon visibility before the renderer draws and picks. // A postRender write is one frame late and can remain visibly stale when diff --git a/src/layers/localAdsb/index.js b/src/layers/localAdsb/index.js index 22cd4a12f4..b30357865c 100644 --- a/src/layers/localAdsb/index.js +++ b/src/layers/localAdsb/index.js @@ -684,6 +684,9 @@ export function createLocalAdsbLayer({ if (clickSubscription || !viewer) return; clickSubscription = inputFor(viewer).onClick((event) => { if (!enabled) return; + // Another layer's card or label painted on top takes the click: the item + // under it does not act, and the click is not empty space either. + if (services.picking.isUnderOtherCard?.(event)) return; const target = clickTarget(event); // Clicking a local aircraft always (re)selects it and republishes its // card, including the one already selected: its card may have been diff --git a/src/layers/localAdsb/index.test.mjs b/src/layers/localAdsb/index.test.mjs index 5b29e91a2f..c2e05d9c3e 100644 --- a/src/layers/localAdsb/index.test.mjs +++ b/src/layers/localAdsb/index.test.mjs @@ -14,7 +14,11 @@ import { } from './index.js'; import { createLocalAdsbModels } from './models.js'; import { entityRecord, readEntityRecord } from '../../data/entityRecords.js'; -import { resolvePickId } from '../../data/pickRegistry.js'; +import { + isUnderOtherCard, + resolvePickId, + setClickCardHitTest, +} from '../../data/pickRegistry.js'; import { fromDegrees, toLonLatH } from '../../geo/ellipsoid.js'; import { fakeInput } from '../../input/testDoubles.mjs'; import { hexColor } from '../../render/color.js'; @@ -1172,6 +1176,41 @@ test('clicking the selected aircraft keeps it selected and republishes its card' assert.deepEqual(calls.cleared, []); }); +// The card or label painted on top takes the click: a local aircraft under +// another layer's card is neither selected nor released. +test("another layer's card over a local aircraft keeps the click", async (t) => { + const receiver = fakeReceiver({ mode: 'adsb', connected: true }); + const clock = { now: 100_000 }; + const harness = clickHarness(); + let top = { sourceId: 'earthquake-card', entryId: 'earthquake-card:ak1' }; + setClickCardHitTest(() => top); + t.after(() => setClickCardHitTest(null)); + const { layer, calls, draw } = await enabledLayer(receiver, clock, null, { + viewer: harness.viewer, + services: { + picking: { + registerPickOwner() {}, + unregisterPickOwner() {}, + resolvePickId, + isUnderOtherCard, + }, + }, + }); + t.after(() => layer.destroy()); + receiver.set({ aircraft: [record()] }); + await layer.update(); + harness.scene.pickResult = iconPick(draw, 'local-adsb:abc123'); + harness.click(); + assert.deepEqual(calls.selected, [], 'covered: not selected'); + top = null; + harness.click(); + assert.deepEqual(calls.selected, ['local-adsb:abc123']); + top = { sourceId: 'earthquake-card', entryId: 'earthquake-card:ak1' }; + harness.scene.pickResult = null; + harness.click(); + assert.deepEqual(calls.cleared, [], 'covered: the selection stays'); +}); + test('a click on a local aircraft under an unowned or trail pick still selects it', async (t) => { const receiver = fakeReceiver({ mode: 'adsb', connected: true }); const clock = { now: 100_000 }; diff --git a/src/layers/military/lifecycle.js b/src/layers/military/lifecycle.js index c7e667d4ff..0389ef3f02 100644 --- a/src/layers/military/lifecycle.js +++ b/src/layers/military/lifecycle.js @@ -1,4 +1,3 @@ -import { isTrackingSelectionGesture } from '../../data/trackingClickGesture.js'; import { findCamera, findFrame } from '../../render/rendererOf.js'; import { loadFleetModelSet } from '../../data/fleetModels.js'; import { forgetPlacedAircraft } from '../flights/placed.js'; @@ -116,19 +115,6 @@ export function createLifecycle({ registerPickOwner( 'military', (pickedId) => flightState._icons?.has(pickedId) === true, - { - expanded: true, - // A click on the aircraft already tracked is ignored: for that one - // plane the layer acts on nothing, so a card over it keeps the tap. - passive: (pickedId) => - Boolean(flightState._trackedIcao) && - pickedId === flightState._trackedIcao, - // The click handler ignores a dragged tap and any tap in cockpit - // mode, so a card over the aircraft keeps that tap. - declinesClick: (click) => - !isTrackingSelectionGesture(click?.gesture) || - Boolean(document.body?.classList.contains('cockpit-mode')), - }, ); // The flights layer suppresses its military duplicates while we render them setMilitaryLayerActive(true); diff --git a/src/layers/military/ownership.test.mjs b/src/layers/military/ownership.test.mjs index 3915f5d785..c8f90d0385 100644 --- a/src/layers/military/ownership.test.mjs +++ b/src/layers/military/ownership.test.mjs @@ -3,6 +3,8 @@ import assert from 'node:assert/strict'; import { createMilitaryFlightLayer } from './index.js'; import { createFlightState } from './state.js'; import { createTracking } from './tracking.js'; +import { fakeInput } from '../../input/testDoubles.mjs'; +import * as picking from '../../data/pickRegistry.js'; function services() { const names = [ @@ -294,3 +296,47 @@ test('a military layer without an icon set declines contact refreshes', () => { assert.equal(layer.refreshTr3b('abc123'), false); assert.equal(layer.trackById('abc123'), false); }); + +// The card or label painted on top takes the click: an aircraft under another +// layer's card is not even picked, so it is neither tracked nor released. +test("another layer's card over an aircraft keeps the click", (t) => { + const previousDocument = globalThis.document; + globalThis.document = Object.assign(new EventTarget(), { + body: { classList: { contains: () => false } }, + }); + let picks = 0; + const viewer = { + scene: { + canvas: new EventTarget(), + pick: () => { + picks++; + return null; + }, + }, + }; + const input = fakeInput(viewer); + const flightState = createFlightState({ services: services() }); + flightState._trackedEntityChangedRemove = () => {}; + const tracking = createTracking({ + flightState, + services: { ...services(), picking }, + parts: {}, + layer: {}, + }); + tracking._installClickHandler(viewer); + let top = { sourceId: 'earthquake-card', entryId: 'earthquake-card:ak1' }; + picking.setClickCardHitTest(() => top); + t.after(() => { + picking.setClickCardHitTest(null); + flightState._clickSubscription?.(); + input.destroy(); + flightState.lifetime.abort(); + if (previousDocument === undefined) delete globalThis.document; + else globalThis.document = previousDocument; + }); + input.tap({ x: 10, y: 10 }); + assert.equal(picks, 0, 'covered: the scene under the card is not picked'); + top = null; + input.tap({ x: 10, y: 10 }); + assert.ok(picks > 0, 'open map: the click reaches the scene'); +}); diff --git a/src/layers/military/tracking.js b/src/layers/military/tracking.js index ef8e7d8673..2998369c79 100644 --- a/src/layers/military/tracking.js +++ b/src/layers/military/tracking.js @@ -87,7 +87,8 @@ export function createTracking({ const { clearFocusTarget } = services.focus; const { FOLLOW_MIN_RANGE_M, SELECTION_FOLLOW_TRANSITION_S, followViewFrom } = services.camera; - const { resolvePickId, isOwnedByOtherLayer } = services.picking; + const { resolvePickId, isOwnedByOtherLayer, isUnderOtherCard } = + services.picking; /** The tracked contact's billboard (an icon set on the draw port). */ const trackedIcon = createTrackedAircraftIcon({ viewer: () => flightState._viewer, @@ -1191,6 +1192,9 @@ export function createTracking({ // first-person reference. Empty globe clicks are inert until the user // exits with C, Escape, or the dedicated button. if (document.body.classList.contains('cockpit-mode')) return; + // Another layer's card or label painted on top takes the click: the item + // under it does not act, and the click is not empty space either. + if (isUnderOtherCard?.(event)) return; const picked = event.hit; if (picked) { diff --git a/src/layers/news/index.js b/src/layers/news/index.js index 7e5e9a7eae..3c228d32c0 100644 --- a/src/layers/news/index.js +++ b/src/layers/news/index.js @@ -8,8 +8,8 @@ import { findFrame, rendererOf, } from '../../render/rendererOf.js'; -import { hitTestWorldOverlay } from '../../overlays/worldOverlay.js'; import { + clickCard, isOwnedByOtherLayer, registerPickOwner, resolvePickId, @@ -203,7 +203,6 @@ export function createNewsLayer({ inputFor = defaultInputFor, matchMedia = globalThis.matchMedia?.bind(globalThis), now = () => Date.now(), - hitTestOverlay = hitTestWorldOverlay, openUrl = (url) => globalThis.open?.(url, '_blank', 'noopener,noreferrer'), getViewCentre = viewCentre, registerCredit = registerDynamicCredit, @@ -1348,11 +1347,13 @@ export function createNewsLayer({ clickOff = inputFor(viewer).onClick((event) => { const at = event?.screenPosition; if (!enabled || destroyed || !isPointerFree() || !at) return; - // The topmost painted entry decides: our own card acts; one covered by - // another layer's card does not. - const card = hitTestOverlay(at.x, at.y); - if (card?.sourceId === NEWS_OVERLAY_SOURCE_ID && card.entry?.activate) { - card.entry.activate(); + // The card or label painted on top takes the click, read once per + // click so every layer agrees: our own card acts whatever is drawn + // under it; another layer's is that layer's click, so the pins under + // it do not act and the selection stays. + const card = clickCard(event); + if (card) { + if (card.sourceId === NEWS_OVERLAY_SOURCE_ID) card.entry?.activate?.(); return; } // What is on top under the click: a draw-set item, or null for the @@ -1408,8 +1409,6 @@ export function createNewsLayer({ return; } if (id && isOwnedByOtherLayer(NEWS_LAYER_ID, id)) return; - // Another layer's card on top is that layer's click, not empty map. - if (card) return; if (selectedId && !picked?.id) layer.setParams({ clear: true }); }); } diff --git a/src/layers/news/layer.test.mjs b/src/layers/news/layer.test.mjs index 7ad0d9a8a1..9a31dd9474 100644 --- a/src/layers/news/layer.test.mjs +++ b/src/layers/news/layer.test.mjs @@ -5,7 +5,12 @@ import { fromDegrees } from '../../geo/ellipsoid.js'; import { bindFakeDraw } from '../../testSupport/fakeDrawPort.mjs'; import { fakeCameraPort } from '../../testSupport/fakeCameraPort.mjs'; import { NEWS_KEY_PROVIDERS, createNewsLayer } from './index.js'; -import { findPickOwner } from '../../data/pickRegistry.js'; +import { + findPickOwner, + registerPickOwner, + setClickCardHitTest, + unregisterPickOwner, +} from '../../data/pickRegistry.js'; // Registers the shared `gev-trail:` no-op owner, as the app does. import '../../data/trailRenderer.js'; import { getSelectedEntityContext } from '../../data/contextStore.js'; @@ -141,11 +146,12 @@ function fixture( for (const fn of [...clickHandlers]) fn({ screenPosition: { x: 10, y: 10 }, topHit }); }; + // The card on top at a click, as the host answers the pick registry. + setClickCardHitTest((x, y) => hitTestOverlay(x, y)); const layer = createNewsLayer({ source, overlayHost, inputFor: () => input, - hitTestOverlay, now, matchMedia: () => ({ matches: reduced }), getViewCentre: () => centre(), @@ -162,6 +168,7 @@ function fixture( layer.attachShellServices({ runNavigation: (navigate) => navigate() }); t.after(() => { layer.destroy(); + setClickCardHitTest(null); unbind(); if (originalWindow === undefined) delete globalThis.window; else globalThis.window = originalWindow; @@ -1289,7 +1296,7 @@ test('a click on a marker selects its report, on a beacon chooses its hotspot, o assert.equal(clickHandlers.size, 0); }); -test('a covered news card yields; the top news card acts over a flight trail', async (t) => { +test('a covered news card and pin yield; the top news card acts over a trail or a vessel', async (t) => { let hits = []; const { layer, items, entries, click, flights } = fixture(t, { height: 500_000, @@ -1322,10 +1329,14 @@ test('a covered news card yields; the top news card acts over a flight trail', a assert.equal(layer.getRowControls().feed.selected.id, 'major'); assert.deepEqual(layer.getRowControls().feed.filters, before.filters); assert.equal(flights.length, flightCount); + // A news pin under another layer's card is that card's click too. layer.setParams({ clear: true }); click({ set: 'news:1:points', id: marker.id, surface: false }); + assert.equal(layer.getRowControls().feed.selected, null, 'covered pin'); + hits = []; + click({ set: 'news:1:points', id: marker.id, surface: false }); assert.equal(layer.getRowControls().feed.selected.id, 'major'); - hits.shift(); + hits = [{ sourceId: 'news', entry: card }]; click(null); assert.equal(activations, 1, 'the unobscured news card acts once'); // A flight trail is registered so every layer reads a click on it as a @@ -1338,6 +1349,15 @@ test('a covered news card yields; the top news card acts over a flight trail', a surface: false, }); assert.equal(activations, 2, 'the news card acts over a flight trail'); + // Over a vessel (a layer that acts on its pick) the card on top acts too; + // the vessel layer stands aside under it, so one click does one thing. + registerPickOwner('test-vessels', (id) => id === '353136000'); + try { + click({ set: 'vessels:1', id: '353136000', surface: false }); + assert.equal(activations, 3, 'the news card acts over a vessel'); + } finally { + unregisterPickOwner('test-vessels'); + } }); test('zoomed out, a hotspot is one beacon; off, nothing draws; destroyed, the sets go', async (t) => { diff --git a/src/layers/perimeters/index.js b/src/layers/perimeters/index.js index d973f8d6d7..8d0e1ab7ed 100644 --- a/src/layers/perimeters/index.js +++ b/src/layers/perimeters/index.js @@ -215,25 +215,21 @@ export function createFirePerimetersLayer({ // so claiming these large ground polygons would make FIRMS/vessel/CCTV // cards inert anywhere over a perimeter. Unowned, our picks read as // "empty space" to siblings — the pre-existing behavior for the globe. - // Our shapes stand aside for a card painted over them (below), so that - // card's layer may act on the click; without a hit-test they cannot. - if (overlayHost?.hitTest) - picking?.registerCardBackground?.( - layer.id, - (hit) => pickedIncidentId(hit) !== null, - ); _clickSubscription = inputFor(_viewer).onClick((event) => { // A click on the incident card itself opens its InciWeb page (when the // incident has one) and never disturbs the selection. - const cardHit = overlayHost.hitTest?.( - event.screenPosition?.x, - event.screenPosition?.y, - ); - // Only the top painted card owns the click; this area's shapes are - // background when another layer has painted a card or label over them. - if (cardHit && cardHit.sourceId !== PERIMETER_OVERLAY_SOURCE_ID) return; - if (cardHit && cardHit.entryId === _selectedCardId) { - if (_selectedLink && openExternal) openExternal(_selectedLink); + // The card or label painted on top takes the click, read once per + // click so every layer agrees: this area's shapes are background to + // another layer's card or label painted over them. + const cardHit = picking.clickCard?.(event) ?? null; + if (cardHit) { + if ( + cardHit.sourceId === PERIMETER_OVERLAY_SOURCE_ID && + cardHit.entryId === _selectedCardId && + _selectedLink && + openExternal + ) + openExternal(_selectedLink); return; } const picked = event.topHit; @@ -261,7 +257,6 @@ export function createFirePerimetersLayer({ function removeClickHandler() { _clickSubscription?.(); _clickSubscription = null; - picking?.unregisterCardBackground?.(layer.id); } function clearSelection() { diff --git a/src/layers/perimeters/ownership.test.mjs b/src/layers/perimeters/ownership.test.mjs index bd0533a28b..25584f535c 100644 --- a/src/layers/perimeters/ownership.test.mjs +++ b/src/layers/perimeters/ownership.test.mjs @@ -27,7 +27,6 @@ function harness( ) { const overlay = { entries: new Map(), visible: null }; const owners = new Map(); - const backgrounds = new Map(); const opened = []; const viewer = { scene: { pick } }; const { draw } = bindFakeDraw(viewer); @@ -59,9 +58,9 @@ function harness( String(pickedId).startsWith('other-layer:'), registerPickOwner: (layerId, predicate) => owners.set(layerId, predicate), unregisterPickOwner: (layerId) => owners.delete(layerId), - registerCardBackground: (layerId, predicate) => - backgrounds.set(layerId, predicate), - unregisterCardBackground: (layerId) => backgrounds.delete(layerId), + // The card on top at a click, as the registry answers from the host. + clickCard: (click) => + cardHit(click.screenPosition?.x, click.screenPosition?.y, {}), }, inciwebSource: inciwebIndex ? { getIndex: async () => inciwebIndex } @@ -81,7 +80,6 @@ function harness( overlay, clicks, owners, - backgrounds, opened, }; } @@ -694,21 +692,3 @@ test('a failed refresh after a stale snapshot reads as the failure, not stale', assert.equal(h.layer.getStats().stale, false); assert.equal(h.layer.getStats().error, 'WFIGS HTTP 502'); }); - -// A card painted over the area may act there (a live CCTV card): the layer -// names its own drawn shapes, and only while it takes clicks. -test('enabled, the perimeter shapes register as card background', async () => { - const h = harness({ getSnapshot: async () => [row] }); - await h.layer.update(h.viewer); - const isBackground = h.backgrounds.get('fire-perimeters'); - const own = { - set: h.fills().spec.id, - id: 'fire-perimeter:2026-NMGNF-000123:0', - surface: false, - }; - assert.equal(isBackground(own), true); - assert.equal(isBackground({ ...own, set: 'other:1:fills' }), false); - assert.equal(isBackground({ ...own, id: 'other-layer:x' }), false); - h.layer.disable(h.viewer); - assert.equal(h.backgrounds.has('fire-perimeters'), false); -}); diff --git a/src/layers/radio/interaction.js b/src/layers/radio/interaction.js index 154652aed3..41674fcf84 100644 --- a/src/layers/radio/interaction.js +++ b/src/layers/radio/interaction.js @@ -15,6 +15,7 @@ export function createInteraction({ const { resolvePickId, isOwnedByOtherLayer, + isUnderOtherCard, registerPickOwner, unregisterPickOwner, } = services.picking; @@ -29,6 +30,9 @@ export function createInteraction({ */ function pickedRadioStationAt(event) { if (!event) return null; + // Another layer's card or label painted on top is that layer's click, + // read once per click so every layer agrees: no station under it acts. + if (isUnderOtherCard?.(event, [RADIO_OVERLAY_SOURCE_ID])) return null; const stationFromPick = (picked) => { const stationId = parts.rendering.radioStationIdFromPick(picked); @@ -48,28 +52,11 @@ export function createInteraction({ RADIO_PICK_WINDOW_PX, )) { const stationId = stationFromPick(picked); - if (!stationId) continue; - // Found only through our wider window, not as the tap's touch contact: - // another layer's card or label painted here is that layer's click, - // since its handler never sees this window. A station of ours that is - // the contact is still ours: that card yields to it. - const contactStationId = stationFromPick(event.hit); - if (contactStationId !== stationId && foreignCardAt(event)) - return contactStationId; - return stationId; + if (stationId) return stationId; } return null; } - /** Whether another layer's world-overlay card or label is under a click. */ - function foreignCardAt(event) { - const top = services.overlays?.hitTestWorldOverlay?.( - event.screenPosition?.x, - event.screenPosition?.y, - ); - return Boolean(top) && top.sourceId !== RADIO_OVERLAY_SOURCE_ID; - } - function radioPresentationAllowed() { if (!layerState._managerLifecyclePresentation) return layerState._enabled; return ( @@ -97,9 +84,7 @@ export function createInteraction({ function installInteraction() { if (!layerState._viewer || layerState._clickSubscription) return; - registerPickOwner('radio', (id) => id.startsWith(RADIO_PREFIX), { - expanded: true, - }); + registerPickOwner('radio', (id) => id.startsWith(RADIO_PREFIX)); const viewer = layerState._viewer; layerState._clickSubscription = inputFor(viewer).onClick((event) => { if (!radioPresentationAllowed()) return; diff --git a/src/layers/radio/interaction.test.mjs b/src/layers/radio/interaction.test.mjs index e11dd61bdf..c776180f43 100644 --- a/src/layers/radio/interaction.test.mjs +++ b/src/layers/radio/interaction.test.mjs @@ -63,73 +63,48 @@ test('a direct hit needs no drill, and another layer’s contact keeps its click assert.equal(pickedRadioStationAt(other), null); }); -// A station found only through radio's wider window, not as the tap's own -// pick or its touch contact, sits under another layer's card or label: that -// layer acts and never sees this window, so radio leaves the click. -test('a window-only station yields to a card painted over it', () => { +// Another layer's card or label painted on top takes the click: no station +// under it acts, whether radio found it through its window, as the tap's touch +// contact or as the exact pick. Radio's own card on top is radio's click. +test("a station under another layer's card does not act", () => { let top = null; const radio = createInteraction({ - state: { _stationById: new Map([['kexp', {}]]) }, + state: { + _stationById: new Map([ + ['kexp', {}], + ['kuow', {}], + ]), + }, services: { picking: { resolvePickId: (picked) => picked?.id ?? null, isOwnedByOtherLayer: () => false, + // The card on top at a click, as the registry answers from the host. + isUnderOtherCard: (_click, own = []) => + Boolean(top) && !own.includes(top.sourceId), registerPickOwner() {}, unregisterPickOwner() {}, }, - overlays: { - setOverlaySourceVisible() {}, - hitTestWorldOverlay: () => top, - }, + overlays: { setOverlaySourceVisible() {} }, }, parts: { rendering: { radioStationIdFromPick } }, }); const station = hit('radio:kexp'); - const near = (contact = null) => ({ - ...clickEvent({ windowHits: [station] }), + const tap = (contact = null, pick = null) => ({ + ...clickEvent({ pick, windowHits: [station] }), hit: contact, screenPosition: { x: 5, y: 5 }, }); - assert.equal(radio.pickedRadioStationAt(near()), 'kexp', 'open map'); + assert.equal(radio.pickedRadioStationAt(tap()), 'kexp', 'open map'); top = { sourceId: 'earthquake-card', entryId: 'earthquake-card:ak1' }; - assert.equal(radio.pickedRadioStationAt(near()), null, 'under a quake card'); + assert.equal(radio.pickedRadioStationAt(tap()), null, 'window only'); + assert.equal(radio.pickedRadioStationAt(tap(station)), null, 'contact'); assert.equal( - radio.pickedRadioStationAt(near(station)), - 'kexp', - 'the touch contact: the card yielded to the station', + radio.pickedRadioStationAt(tap(hit('radio:kuow'))), + null, + 'another contact station', ); + assert.equal(radio.pickedRadioStationAt(tap(null, station)), null, 'exact'); top = { sourceId: 'radio', entryId: 'radio:kexp' }; - assert.equal(radio.pickedRadioStationAt(near()), 'kexp', 'our own card'); -}); - -// Under another layer's card, radio's window can name a different station -// from the tap's touch contact. The card yields to that contact, a station of -// ours, so radio acts on it instead of leaving the click dead. -test('under a card, the touch contact station is ours even when the window names another', () => { - const radio = createInteraction({ - state: { _stationById: new Map([['kexp', {}], ['kuow', {}]]) }, - services: { - picking: { - resolvePickId: (picked) => picked?.id ?? null, - isOwnedByOtherLayer: () => false, - registerPickOwner() {}, - unregisterPickOwner() {}, - }, - overlays: { - setOverlaySourceVisible() {}, - hitTestWorldOverlay: () => ({ - sourceId: 'earthquake-card', - entryId: 'earthquake-card:ak1', - }), - }, - }, - parts: { rendering: { radioStationIdFromPick } }, - }); - const tap = (contact) => ({ - ...clickEvent({ windowHits: [hit('radio:kexp')] }), - hit: contact, - screenPosition: { x: 5, y: 5 }, - }); - assert.equal(radio.pickedRadioStationAt(tap(hit('radio:kuow'))), 'kuow'); - assert.equal(radio.pickedRadioStationAt(tap(null)), null, 'no contact'); + assert.equal(radio.pickedRadioStationAt(tap()), 'kexp', 'our own card'); }); diff --git a/src/layers/rail/follow.test.mjs b/src/layers/rail/follow.test.mjs index 3d6aa1e1f2..2130bacebc 100644 --- a/src/layers/rail/follow.test.mjs +++ b/src/layers/rail/follow.test.mjs @@ -10,6 +10,7 @@ import { SELECTION_FOLLOW_TRANSITION_S, } from '../../data/trackedCamera.js'; import { fromDegrees } from '../../geo/ellipsoid.js'; +import { setClickCardHitTest } from '../../data/pickRegistry.js'; import { distance } from '../../geo/vector.js'; import { ACTIVATION_EXIT_ALTITUDE_M, @@ -203,6 +204,25 @@ test('a click on a train selects it; a click on the map lets it go', async (t) = assert.equal(app.state()._selectedKey, key); }); +// The card or label painted on top takes the click: a train under another +// layer's card is neither selected nor let go. +test("another layer's card over a train keeps the click", async (t) => { + const app = harness(t); + const key = await bringToMotion(app, 'mbta-rail', 'T1', BOSTON); + const icons = app.drawn('icons'); + let top = { sourceId: 'earthquake-card', entryId: 'earthquake-card:ak1' }; + setClickCardHitTest(() => top); + t.after(() => setClickCardHitTest(null)); + app.click({ set: icons.spec.id, id: key, surface: false }); + assert.equal(app.state()._selectedKey ?? null, null, 'covered: not selected'); + top = null; + app.click({ set: icons.spec.id, id: key, surface: false }); + assert.equal(app.state()._selectedKey, key); + top = { sourceId: 'earthquake-card', entryId: 'earthquake-card:ak1' }; + app.click(null); + assert.equal(app.state()._selectedKey, key, 'covered: kept'); +}); + test('a parked train, or one known from a single report, is flown to once', async (t) => { const app = harness(t); await bringToMotion(app, 'mbta-rail', 'T1', BOSTON); diff --git a/src/layers/rail/selection.js b/src/layers/rail/selection.js index 0fdee59bc8..d2663cf200 100644 --- a/src/layers/rail/selection.js +++ b/src/layers/rail/selection.js @@ -7,6 +7,7 @@ import { } from './policy.js'; import { getRegisteredRailFeed } from '../../data/railFeeds.js'; import { inputFor } from '../../input/dispatcher.js'; +import { isUnderOtherCard } from '../../data/pickRegistry.js'; import { t } from '../../i18n/index.js'; /** @@ -173,6 +174,9 @@ export function createSelection({ state, services, parts }) { if (!state._enabled) return; // A held train keeps the selection until its view lets it go. if (state._cockpitSubjectKey) return; + // Another layer's card or label painted on top takes the click: the item + // under it does not act, and the click is not empty space either. + if (isUnderOtherCard(event)) return; const key = trainKeyOf(event.drawHit); if (key) selectAndFocusTrain(key); else if (state._selectedKey) clearSelection(); diff --git a/src/layers/satellites/interaction.js b/src/layers/satellites/interaction.js index 643f637798..393fc072e7 100644 --- a/src/layers/satellites/interaction.js +++ b/src/layers/satellites/interaction.js @@ -7,7 +7,8 @@ export function createInteraction({ parts, source, }) { - const { resolvePickId, isOwnedByOtherLayer } = services.picking; + const { resolvePickId, isOwnedByOtherLayer, isUnderOtherCard } = + services.picking; function _onKeyDown(e) { // The Cockpit owns Escape while it rides the tracked satellite. @@ -50,6 +51,9 @@ export function createInteraction({ // The Cockpit camera rides the tracked satellite: a click on the // picture below must not untrack it or switch satellites. if (parts.cockpit?._cockpitHeld()) return; + // Another layer's card or label painted on top takes the click: the item + // under it does not act, and the click is not empty space either. + if (isUnderOtherCard?.(event)) return; const picked = event.topHit; const hit = event.drawHit; diff --git a/src/layers/satellites/interaction.test.mjs b/src/layers/satellites/interaction.test.mjs new file mode 100644 index 0000000000..163078e9ca --- /dev/null +++ b/src/layers/satellites/interaction.test.mjs @@ -0,0 +1,65 @@ +import test from 'node:test'; +import assert from 'node:assert/strict'; +import { createInteraction } from './interaction.js'; +import { fakeInput } from '../../input/testDoubles.mjs'; +import * as picking from '../../data/pickRegistry.js'; + +// The card or label painted on top takes the click: a satellite under another +// layer's card is neither tracked nor let go. +test("another layer's card over a satellite keeps the click", (t) => { + const previousDocument = globalThis.document; + globalThis.document = new EventTarget(); + let picked = null; + const viewer = { scene: { canvas: new EventTarget(), pick: () => picked } }; + const input = fakeInput(viewer); + const calls = []; + const state = { + _enabled: true, + _trackedNorad: null, + _clickSubscription: null, + _trackedEntityChangedRemove: () => {}, + _catalog: new Map([[25544, {}]]), + }; + const interaction = createInteraction({ + state, + services: { picking }, + parts: { + rendering: { + _hitIsTracked: () => false, + _hitPointId: (hit) => + hit?.set === 'satellites:dots' ? Number(hit.id) : null, + }, + tracking: { + _cancelPendingTrackingRestore() {}, + _trackSatellite: (id) => calls.push(['track', id]), + _clearTracking: () => calls.push(['clear']), + }, + }, + }); + interaction._installClickHandler(viewer); + let top = { sourceId: 'earthquake-card', entryId: 'earthquake-card:ak1' }; + picking.setClickCardHitTest(() => top); + t.after(() => { + picking.setClickCardHitTest(null); + state._clickSubscription?.(); + input.destroy(); + if (previousDocument === undefined) delete globalThis.document; + else globalThis.document = previousDocument; + }); + const click = (hit) => { + picked = hit ? { id: hit } : null; + input.tap({ x: 10, y: 10 }); + }; + const dot = { set: 'satellites:dots', id: '25544' }; + click(dot); + assert.deepEqual(calls, [], 'covered: not tracked'); + state._trackedNorad = 1; + click(null); + assert.deepEqual(calls, [], 'covered: tracking kept'); + top = null; + click(null); + assert.deepEqual(calls, [['clear']], 'open map lets it go'); + state._trackedNorad = null; + click(dot); + assert.deepEqual(calls.at(-1), ['track', 25544]); +}); diff --git a/src/layers/shipwrecks/index.js b/src/layers/shipwrecks/index.js index c8eff42cb7..8dcbe4bb7e 100644 --- a/src/layers/shipwrecks/index.js +++ b/src/layers/shipwrecks/index.js @@ -277,13 +277,18 @@ export function createShipwrecksLayer({ if (!clicks) return; _clickHandler = clicks.onClick((click) => { if (pointer && !pointer.isPointerFree()) return; - const at = click.screenPosition; - const cardHit = overlayHost.hitTest?.(at?.x, at?.y); - if ( - cardHit?.sourceId === SHIPWRECKS_OVERLAY_SOURCE_ID && - cardHit.entryId === _selectedCardId - ) { - if (_selectedLink) openExternal(_selectedLink); + // The card or label painted on top takes the click, read once per + // click so every layer agrees: ours opens its source whatever is drawn + // under it; another layer's is that layer's click, so the markers + // under it do not act and the selection stays. + const cardHit = picking.clickCard?.(click) ?? null; + if (cardHit) { + if ( + cardHit.sourceId === SHIPWRECKS_OVERLAY_SOURCE_ID && + cardHit.entryId === _selectedCardId && + _selectedLink + ) + openExternal(_selectedLink); return; } // A marker's item id is its pick id, `shipwreck:`. Read from what is @@ -300,10 +305,6 @@ export function createShipwrecksLayer({ } if (pickId && picking.isOwnedByOtherLayer(SHIPWRECKS_LAYER_ID, pickId)) return; - // A covered card must neither open its source nor clear the selection. - // A marker of ours under that card was already selected by the pick - // check before this one. - if (cardHit) return; if (_selectedId) { clearSelection(); render(); diff --git a/src/layers/shipwrecks/index.test.mjs b/src/layers/shipwrecks/index.test.mjs index 6209129caa..69e80f4eb2 100644 --- a/src/layers/shipwrecks/index.test.mjs +++ b/src/layers/shipwrecks/index.test.mjs @@ -47,6 +47,8 @@ function harness({ snapshots, now = () => 1, cardHit = () => null } = {}) { const { draw } = bindFakeDraw(viewer); const queue = [...(snapshots || [])]; const requests = []; + // The card on top at a click, as the host answers the pick registry. + picking.setClickCardHitTest((x, y) => cardHit(x, y)); const layer = createShipwrecksLayer({ source: { getSnapshot({ signal }) { @@ -394,7 +396,7 @@ test('the page deadline subtracts the newest available source age from the limit assert.equal(snapshotDeadline({ sources: both }, 0), 7 * DAY, 'defaults'); }); -test('a covered selected card yields while genuine wreck markers still select', async () => { +test('a covered selected card and covered markers yield; bare markers select', async () => { let painted = []; const h = harness({ snapshots: [ @@ -421,8 +423,12 @@ test('a covered selected card yields while genuine wreck markers still select', click(); assert.deepEqual(h.opened, []); assert.equal(h.lastCard()[0].id, first.id); + // A marker under another layer's card is that card's click too. h.pick('b'); click(); + assert.equal(h.lastCard()[0].id, first.id, 'a covered marker yields'); + painted = []; + click(); assert.equal(h.lastCard()[0].id, 'shipwreck-card:b'); painted = [{ sourceId: 'shipwrecks', entryId: 'shipwreck-card:b' }]; h.pick(null); diff --git a/src/layers/streetLevel/selection.js b/src/layers/streetLevel/selection.js index 9a7cfea8f5..409b0a9dce 100644 --- a/src/layers/streetLevel/selection.js +++ b/src/layers/streetLevel/selection.js @@ -23,29 +23,22 @@ export function createSelection({ state, parts }) { /** The id carries a provider's prefix: that provider handles the pick. */ function onClick(event) { if (!state.viewer || !state.enabled) return; + // Another layer's card or label painted on top takes the click, read once + // per click so every layer agrees: no image, sequence or ground under it + // opens. Street Level paints no cards of its own. + if (picking?.isUnderOtherCard?.(event)) return; const hit = event.windowHit(CLICK_PICK_WINDOW_PX, CLICK_PICK_WINDOW_PX); const windowId = pickIdOf(hit); // A coarse tap's touch contact (event.hit) reaches farther than this - // window; a card or label over it yields to our item there, so it is ours. + // window: an item of ours there is still ours. const contact = event.hit; const contactId = contact && !contact.surface ? pickIdOf({ drawHit: contact.set ? contact : null, id: event.id }) : null; - let route = parts.router.resolve(windowId); - // Found only through our window, not as the contact (which is the exact - // hit whenever there is one): another layer's card or label painted here - // is that layer's click, since its handler never sees this window. - // An item of ours that is the contact is still ours: that card yields - // to it. - if (route && windowId !== contactId) { - const at = event.screenPosition; - if (state.services.overlayHit?.(at?.x, at?.y)) { - route = contactId ? parts.router.resolve(contactId) : null; - if (!route) return; - } - } - if (!route && contactId) route = parts.router.resolve(contactId); + const route = + parts.router.resolve(windowId) ?? + (contactId ? parts.router.resolve(contactId) : null); // Not ours: the ground handler decides whether it is the map itself. if (!route) { parts.openAtGround?.({ surface: hit.surface, ground: groundOf(event) }); @@ -92,12 +85,7 @@ export function createSelection({ state, parts }) { if (state.clickSubscription) return; state.clickSubscription = inputFor(viewer).onClick(onClick); document.addEventListener('keydown', onKeyDown); - picking?.registerPickOwner?.(STREET_LEVEL_LAYER_ID, parts.router.ownsPick, { - expanded: true, - // The core's position marker is ours but selects nothing: a card over - // it keeps the tap. - passive: (id) => !parts.router.resolve(id)?.instance, - }); + picking?.registerPickOwner?.(STREET_LEVEL_LAYER_ID, parts.router.ownsPick); } function uninstall() { diff --git a/src/layers/streetLevel/selection.test.mjs b/src/layers/streetLevel/selection.test.mjs index db5304b8a0..f7647ec8e4 100644 --- a/src/layers/streetLevel/selection.test.mjs +++ b/src/layers/streetLevel/selection.test.mjs @@ -48,11 +48,13 @@ function harness({ ...sceneExtras, }, }; + // The card on top at a click, as the host answers the pick registry. + pickRegistry.setClickCardHitTest(services.overlayHit ?? null); const state = { viewer, enabled: true, clickSubscription: null, - services: { picking: null, input: null, ...services }, + services: { picking: pickRegistry, input: null, ...services }, providers: new Map([ [ 'mapillary', @@ -106,6 +108,7 @@ function harness({ return event; }, restore() { + pickRegistry.setClickCardHitTest(null); selection.uninstall(); globalThis.document = saved; }, @@ -315,26 +318,48 @@ test('an item found only in our window yields to a card painted over it', () => } }); -// A coarse tap's touch contact reaches farther than this window. A quake card -// or label over that contact yields to it, so Street Level takes it here. -test('a coarse touch contact beyond our window is ours to open', (t) => { +// The map itself under another layer's card or label is that card's click: +// a ground click there must not also open the nearest street image. +test("a click on the map under another layer's card opens no ground image", () => { + let top = null; + const h = harness({ services: { overlayHit: () => top } }); + try { + h.click(); + assert.equal( + h.groundClicks.length, + 1, + 'open map: the ground handler decides', + ); + top = { sourceId: 'earthquake-card', entryId: 'earthquake-card:ak1' }; + h.click(); + assert.equal(h.groundClicks.length, 1, 'under a card: the card keeps it'); + assert.deepEqual(h.opened, []); + } finally { + h.restore(); + } +}); + +// A coarse tap's touch contact reaches farther than this window: on open map +// Street Level takes it; under another layer's card the card does. +test('a coarse touch contact beyond our window is ours to open, unless a card is on top', (t) => { const previous = globalThis.matchMedia; globalThis.matchMedia = () => ({ matches: true }); t.after(() => { if (previous) globalThis.matchMedia = previous; else delete globalThis.matchMedia; }); + let top = { sourceId: 'earthquake-card', entryId: 'q' }; const h = harness({ - services: { - picking: pickRegistry, - overlayHit: () => ({ sourceId: 'earthquake-card', entryId: 'q' }), - }, + services: { picking: pickRegistry, overlayHit: () => top }, sceneExtras: { pick: () => null, drillPick: () => [{ id: 'mly:img:contact' }], }, }); try { + h.click(); + assert.deepEqual(h.opened, [], 'under a card: the card keeps it'); + top = null; h.click(); assert.deepEqual(h.opened, ['contact']); assert.equal(h.groundClicks.length, 0); @@ -343,22 +368,27 @@ test('a coarse touch contact beyond our window is ours to open', (t) => { } }); -// The exact hit or the touch contact is ours under a card too: a quake card -// or label yields to a Street Level owner's pick, so yielding back would -// leave the click dead. Line parts compare by the sequence they pick as. -test('an exact or contact hit on our line part acts under a card', (t) => { +// The exact hit or the touch contact on our line part under another layer's +// card is that card's click; on open map it selects the sequence its part +// picks as. +test('an exact or contact hit on our line part acts only with no card on top', (t) => { const part = { set: 'street-level:mapillary-coverage:1', id: 'mly:seq:abc#2', meta: { pick: 'mly:seq:abc' }, }; - const card = () => ({ sourceId: 'earthquake-card', entryId: 'q' }); + let top = { sourceId: 'earthquake-card', entryId: 'q' }; + const card = () => top; const exact = harness({ services: { overlayHit: card } }); try { exact.scene.under = part; exact.click(); + assert.deepEqual(exact.sequences.selects, [], 'under a card'); + top = null; + exact.click(); assert.deepEqual(exact.sequences.selects, ['abc'], 'mouse, exact part'); } finally { + top = { sourceId: 'earthquake-card', entryId: 'q' }; exact.restore(); } const previous = globalThis.matchMedia; @@ -375,6 +405,9 @@ test('an exact or contact hit on our line part acts under a card', (t) => { }, }); try { + contact.click(); + assert.deepEqual(contact.sequences.selects, [], 'coarse, under a card'); + top = null; contact.click(); assert.deepEqual(contact.sequences.selects, ['abc'], 'coarse contact'); } finally { @@ -383,7 +416,7 @@ test('an exact or contact hit on our line part acts under a card', (t) => { }); // Our window catching another layer's item says nothing about our own touch -// contact beyond it: that contact is still ours under a card. +// contact beyond it: that contact is still ours. test('a contact of ours acts even when our window finds another item', (t) => { const previous = globalThis.matchMedia; globalThis.matchMedia = () => ({ matches: true }); @@ -392,10 +425,7 @@ test('a contact of ours acts even when our window finds another item', (t) => { else delete globalThis.matchMedia; }); const h = harness({ - services: { - picking: pickRegistry, - overlayHit: () => ({ sourceId: 'earthquake-card', entryId: 'q' }), - }, + services: { picking: pickRegistry }, sceneExtras: { pick: (_position, width = 3) => width >= 9 ? { id: { set: 'flights:1', id: 'flight:9' } } : null, @@ -410,36 +440,18 @@ test('a contact of ours acts even when our window finds another item', (t) => { } }); -// The core's position marker is ours but selects nothing, so it is a passive -// pick: a card painted over it keeps the tap. Our images and lines act. -test('the position marker is a passive pick; our items act', () => { - const h = harness({ services: { picking: pickRegistry } }); - try { - const acted = (id) => - pickRegistry.isActedOnByOtherLayer('test-card', id, { expanded: true }); - assert.equal(pickRegistry.findPickOwner('sl:pos'), 'street-level'); - assert.equal(acted('sl:pos'), false, 'the marker acts for nobody'); - assert.equal(acted('mly:img:abc'), true, 'an image opens'); - } finally { - h.restore(); - } -}); - -// Under another layer's card, our window can name a different item from the -// tap's touch contact. The card yields to that contact, an item of ours, so -// Street Level opens it instead of leaving the click dead. -test('under a card, the touch contact item is ours even when the window names another', (t) => { +// Under another layer's card nothing of ours opens, whatever our window or the +// tap's touch contact names; on open map our window's item opens. +test('under a card, neither our window item nor our touch contact opens', (t) => { const previous = globalThis.matchMedia; globalThis.matchMedia = () => ({ matches: true }); t.after(() => { if (previous) globalThis.matchMedia = previous; else delete globalThis.matchMedia; }); + let top = { sourceId: 'earthquake-card', entryId: 'q' }; const h = harness({ - services: { - picking: pickRegistry, - overlayHit: () => ({ sourceId: 'earthquake-card', entryId: 'q' }), - }, + services: { picking: pickRegistry, overlayHit: () => top }, sceneExtras: { pick: (_position, width = 3) => width >= 9 ? { id: 'mly:img:window' } : null, @@ -448,8 +460,11 @@ test('under a card, the touch contact item is ours even when the window names an }); try { h.click(); - assert.deepEqual(h.opened, ['contact']); + assert.deepEqual(h.opened, []); assert.equal(h.groundClicks.length, 0); + top = null; + h.click(); + assert.deepEqual(h.opened, ['window']); } finally { h.restore(); } diff --git a/src/layers/submarineCables/index.js b/src/layers/submarineCables/index.js index de47082b0f..1f17a3d9de 100644 --- a/src/layers/submarineCables/index.js +++ b/src/layers/submarineCables/index.js @@ -24,7 +24,6 @@ export function createSubmarineCableLayer({ parts, source, inputFor, - overlayHost, picking, mapStackEventTarget, }; diff --git a/src/layers/submarineCables/interaction.js b/src/layers/submarineCables/interaction.js index 823020e16e..0ff20ddd7a 100644 --- a/src/layers/submarineCables/interaction.js +++ b/src/layers/submarineCables/interaction.js @@ -1,40 +1,18 @@ import { toRadians } from '../../geo/vector.js'; import { cameraOf } from '../../render/rendererOf.js'; -const CARD_BACKGROUND_ID = 'submarine-cables'; - -export function createInteraction({ - state, - parts, - inputFor, - overlayHost, - picking, -}) { +export function createInteraction({ state, parts, inputFor, picking }) { function beginInteraction(viewer) { if (state._clickSubscription) return; - // Our cables stand aside for a card painted over them (below), so that - // card's layer may act on the click; without a hit-test they cannot. - if (overlayHost?.hitTest) - picking?.registerCardBackground?.( - CARD_BACKGROUND_ID, - (hit) => state._enabled && Boolean(resolvePickRecord(hit)?.reference), - ); - const unsubscribe = inputFor(viewer).onClick((event) => { + state._clickSubscription = inputFor(viewer).onClick((event) => { if (!state._enabled) return; - // Cable labels are not interactive, so any overlay entry hit here is - // another layer's card or label painted over the cable: its click. - if ( - overlayHost?.hitTest?.(event.screenPosition?.x, event.screenPosition?.y) - ) - return; + // Cable labels are not interactive, so any card or label painted on + // top is another layer's, painted over the cable: its click. + if (picking?.clickCard?.(event)) return; const record = resolvePickRecord(event.drawHit); if (!record?.reference) return; flyToReference(viewer, record.reference); }); - state._clickSubscription = () => { - unsubscribe(); - picking?.unregisterCardBackground?.(CARD_BACKGROUND_ID); - }; } /** diff --git a/src/layers/submarineCables/interaction.test.mjs b/src/layers/submarineCables/interaction.test.mjs index 79282c02e8..44d9599610 100644 --- a/src/layers/submarineCables/interaction.test.mjs +++ b/src/layers/submarineCables/interaction.test.mjs @@ -25,6 +25,8 @@ function harness({ overlayTop = null } = {}) { }, }), overlayHost: { hitTest: () => top }, + // The card on top at a click, as the registry answers from the host. + picking: { clickCard: () => top }, }); interaction.beginInteraction({}); return { @@ -57,33 +59,3 @@ test('a card painted over a cable keeps its click; with none the cable reads the 'with no card on top, the cable reads its pick', ); }); - -// So a card on top (a live CCTV card) may act over the cable instead. -test('while it takes clicks, a drawn cable registers as card background', () => { - const state = { _enabled: true, _clickSubscription: null }; - const interaction = createInteraction({ - state, - parts: { - rendering: { - pickInfo: (hit) => - hit?.set === 'cables:1' ? { reference: { lon: 1, lat: 2 } } : null, - }, - }, - inputFor: () => ({ onClick: () => () => {} }), - overlayHost: { hitTest: () => null }, - picking, - }); - interaction.beginInteraction({}); - const cable = { set: 'cables:1', id: 'cable:0' }; - try { - assert.equal(picking.isCardBackground(cable), true); - assert.equal(picking.isCardBackground({ set: 'other:1', id: 'x' }), false); - state._enabled = false; - assert.equal(picking.isCardBackground(cable), false); - state._enabled = true; - state._clickSubscription(); - assert.equal(picking.isCardBackground(cable), false); - } finally { - state._clickSubscription?.(); - } -}); diff --git a/src/layers/transit/lifecycle.test.mjs b/src/layers/transit/lifecycle.test.mjs index 49a3e7f17a..441f049bf7 100644 --- a/src/layers/transit/lifecycle.test.mjs +++ b/src/layers/transit/lifecycle.test.mjs @@ -44,6 +44,7 @@ import { uninstallRenderGovernor, } from '../../renderGovernor.js'; import { fakeInput } from '../../input/testDoubles.mjs'; +import { setClickCardHitTest } from '../../data/pickRegistry.js'; import { fakeCameraPort } from '../../testSupport/fakeCameraPort.mjs'; import { fakeDrawPort } from '../../testSupport/fakeDrawPort.mjs'; import { bindRenderer, rendererOf } from '../../render/rendererOf.js'; @@ -3696,6 +3697,30 @@ test('click handler selects a migrated scripted billboard and prepares its drape assert.equal(entry.marker.show, true); }); +// The card or label painted on top takes the click: a vehicle under another +// layer's card is neither selected nor released. +test("another layer's card over a vehicle keeps the click", async (t) => { + const app = harness(t, { floorAt: () => undefined }); + let top = { sourceId: 'earthquake-card', entryId: 'earthquake-card:ak1' }; + setClickCardHitTest(() => top); + t.after(() => setClickCardHitTest(null)); + app.layer.enable(app.viewer); + app.layer._loadTransitFleetForTest(4, BOSTON, 70); + const [first, second] = app.vehicles(); + app.viewer.scene.pick = () => app.pickOf(first); + app.input.click(new Cesium.Cartesian2(500, 400)); + assert.equal(app.state()._selectedKey, null, 'covered: not selected'); + top = null; + app.input.click(new Cesium.Cartesian2(500, 400)); + assert.equal(app.state()._selectedKey, first.key); + top = { sourceId: 'earthquake-card', entryId: 'earthquake-card:ak1' }; + app.viewer.scene.pick = () => app.pickOf(second); + app.input.click(new Cesium.Cartesian2(500, 400)); + app.viewer.scene.pick = () => undefined; + app.input.click(new Cesium.Cartesian2(500, 400)); + assert.equal(app.state()._selectedKey, first.key, 'covered: kept'); +}); + test('intercepted scripted reports resolve their explicit floor and wake without a preRender bootstrap', async (t) => { const app = harness(t, { floorAt: () => undefined }); app.layer._setTransitFixtureFloorsForTest(['mbta:sim-straight'], 20); diff --git a/src/layers/transit/selection.js b/src/layers/transit/selection.js index 9566272eef..75a1c2b744 100644 --- a/src/layers/transit/selection.js +++ b/src/layers/transit/selection.js @@ -7,6 +7,7 @@ import { } from './policy.js'; import { getRegisteredTransitFeed } from '../../data/transitFeeds.js'; import { inputFor } from '../../input/dispatcher.js'; +import { isUnderOtherCard } from '../../data/pickRegistry.js'; import { t } from '../../i18n/index.js'; /** @@ -151,6 +152,9 @@ export function createSelection({ state, services, parts }) { collection: set === 'moving' ? 'animated' : set === 'still' ? 'stationary' : null, }; + // Another layer's card or label painted on top takes the click: the item + // under it does not act, and the click is not empty space either. + if (isUnderOtherCard(event)) return; if (key) { selectVehicle(key, { byUser: true }); return; diff --git a/src/layers/vessels/lifecycle.js b/src/layers/vessels/lifecycle.js index 5ebebd0970..c9c7d3e344 100644 --- a/src/layers/vessels/lifecycle.js +++ b/src/layers/vessels/lifecycle.js @@ -192,10 +192,8 @@ export function createLifecycle({ }); } // Pick-ownership (H2): a vessel icon's pick id is its row id, the record's id. - registerPickOwner( - 'ais-live-vessels', - (pickedId) => state.records.byId.has(pickedId), - { expanded: true }, + registerPickOwner('ais-live-vessels', (pickedId) => + state.records.byId.has(pickedId), ); // Vessels are asked for by view, so ask again when the view moves away. removeViewListener(); diff --git a/src/layers/vessels/selection.js b/src/layers/vessels/selection.js index 1aba2248b5..369054e3a8 100644 --- a/src/layers/vessels/selection.js +++ b/src/layers/vessels/selection.js @@ -10,8 +10,7 @@ export function createSelection({ options, }) { const { state } = vesselState; - const { isOwnedByOtherLayer, isActedOnByOtherLayer, resolvePickId } = - services.picking; + const { isOwnedByOtherLayer } = services.picking; const { requestWorldFocus } = services.worldFocus; const { selectEntityContext, @@ -31,8 +30,23 @@ export function createSelection({ // The bridge view owns the selection: a click on open water must not // deselect the vessel the camera is riding. if (state.cockpitSubjectId) return; + // The card or label painted on top takes the click, read once per + // click so every layer agrees: a card of ours acts whatever is drawn + // under it; another layer's is that layer's click. + const top = services.picking.clickCard?.(event) ?? null; + if (top) { + if (top.sourceId !== VESSEL_OVERLAY_SOURCE_ID) return; + const id = String(top.entryId || '').startsWith('vessel:') + ? top.entryId.slice('vessel:'.length) + : null; + const carded = id ? state.records.byId.get(id) || null : null; + // A stale card id is not empty terrain and must not clear a newer + // selection. The next paint will evict its hit rectangle. + if (carded) selectAndFocusVessel(carded); + return; + } const pickedId = event.id; - let record = pickedId ? state.records.byId.get(pickedId) : null; + const record = pickedId ? state.records.byId.get(pickedId) : null; // A vessel icon's pick is an item of the layer's icon set, whose id is // its row id: the record's id, or an unkeyed row's. Removing a row // removes its item, so an evicted vessel cannot be picked at all; a @@ -45,76 +59,18 @@ export function createSelection({ // An own-layer row without a live map key is a strict no-op (FB-1 // residual). Trails carry no layer identity and hug their contacts, so any - // `gev-trail:*` pick is also a no-op. Every other non-vessel pick — sibling - // unowned scene picks dismiss the current vessel inspection. + // `gev-trail:*` pick is also a no-op. A pick a sibling layer owns (an + // aircraft, a route, a cyclone) is that layer's: preserve the current + // vessel selection and do not compete with its camera command. Every + // other non-vessel pick dismisses the current vessel inspection. if (ownRecordPick && (!pickedId || !record)) return; - /** Whether this layer's own card is painted under the click. */ - const ownCardUnder = () => - vesselState._vesselOverlayHost.hitTest?.( - event.screenPosition?.x, - event.screenPosition?.y, - )?.sourceId === VESSEL_OVERLAY_SOURCE_ID; - // A passive owner's pick (a trail, a directions route) acts for nobody: - // a card of ours painted over it keeps the click; otherwise a no-op. - const passivePick = - Boolean(pickedId) && - !record && - (String(pickedId).startsWith('gev-trail:') || - (Boolean(isActedOnByOtherLayer) && - isOwnedByOtherLayer('ais-live-vessels', pickedId) && - !isActedOnByOtherLayer('ais-live-vessels', pickedId, { - click: event, - }))); - if (passivePick && !ownCardUnder()) return; - - // A sibling layer already owns this click. Preserve the current vessel - // selection and do not compete with its camera command. - const siblingOwned = - !passivePick && - pickedId && - isOwnedByOtherLayer('ais-live-vessels', pickedId); - // Cyclone geometry is ambient context behind painted cards. Its handler - // yields to the same foreground AIS hit. Keep moving-contact precedence - // unchanged: those handlers may issue their own camera command. - const cycloneBackground = - siblingOwned && !isOwnedByOtherLayer('weather-cyclones', pickedId); - if (siblingOwned && !cycloneBackground) { - // A coarse tap's nearby contact (not the exact pick) whose layer acts - // only on exact hits (a fire, a camera) does not take a tap on this - // layer's own card: that card keeps it. - const nearMissOfExactOnly = - isActedOnByOtherLayer && - resolvePickId?.(event.topHit ?? null) !== pickedId && - !isActedOnByOtherLayer('ais-live-vessels', pickedId, { - expanded: true, - click: event, - }); - if (!nearMissOfExactOnly || !ownCardUnder()) return; - } - - // Cards are painted on a pointer-events:none canvas, so the scene pick is - // usually terrain behind the card. Resolve against the host's current - // actionable hit rectangles before treating the click as empty space. - const cardHit = !record - ? vesselState._vesselOverlayHost.hitTest?.( - event.screenPosition?.x, - event.screenPosition?.y, - ) - : null; if ( - (cardHit && cardHit.sourceId !== VESSEL_OVERLAY_SOURCE_ID) || - (cycloneBackground && !cardHit) + !record && + pickedId && + (String(pickedId).startsWith('gev-trail:') || + isOwnedByOtherLayer('ais-live-vessels', pickedId)) ) return; - if (!record && cardHit) { - const id = String(cardHit.entryId || '').startsWith('vessel:') - ? cardHit.entryId.slice('vessel:'.length) - : null; - record = id ? state.records.byId.get(id) || null : null; - // A stale card id is not empty terrain and must not clear a newer - // selection. The next paint will evict its hit rectangle. - if (!record) return; - } if (record) { // A valid sprite or card click always transfers the camera exactly once, diff --git a/src/layers/wildlifeSightings/ownership.test.mjs b/src/layers/wildlifeSightings/ownership.test.mjs index ebe4b75e58..46e5b13b9d 100644 --- a/src/layers/wildlifeSightings/ownership.test.mjs +++ b/src/layers/wildlifeSightings/ownership.test.mjs @@ -221,6 +221,8 @@ function harness( unregisterPickOwner: (id) => owners.delete(id), resolvePickId: (pick) => pick?.id ?? pick?.primitive?.id, isOwnedByOtherLayer: (_layerId, id) => id?.startsWith('other:'), + // The card on top at a click, as the registry answers from the host. + clickCard: () => cardHit, }, sprites: { spriteDrawOrder: () => -9 }, render: { governorRequestRender: (reason) => renders.push(reason) }, diff --git a/src/layers/wildlifeSightings/selection.js b/src/layers/wildlifeSightings/selection.js index 368497c539..5156d6035a 100644 --- a/src/layers/wildlifeSightings/selection.js +++ b/src/layers/wildlifeSightings/selection.js @@ -482,12 +482,13 @@ export function createSelection({ state, services, parts }) { state.clickHandler = input.onClick((click) => { if (!state.enabled || services.pointer?.isPointerFree?.() === false) return; - const at = click.screenPosition; - // The topmost painted entry decides: our own card or label acts; one - // covered by another layer's card does not. - const hit = overlay?.hitTest?.(at?.x, at?.y); - if (hit && sourceIds.includes(hit.sourceId)) { - hit.entry?.activate?.(); + // The card or label painted on top takes the click, read once per + // click so every layer agrees: ours acts whatever is drawn under it; + // another layer's is that layer's click, so the sightings under it do + // not act and the selection stays. + const hit = services.picking?.clickCard?.(click) ?? null; + if (hit) { + if (sourceIds.includes(hit.sourceId)) hit.entry?.activate?.(); return; } // A sighting icon's item id is its pick id, `wildlife:`. @@ -509,8 +510,6 @@ export function createSelection({ state, services, parts }) { services.picking?.isOwnedByOtherLayer?.('wildlife-sightings', id) ) return; - // Another layer's card on top is that layer's click, not empty map. - if (hit) return; clearAndRebuild(); }); } diff --git a/src/layers/wildlifeSightings/selection.test.mjs b/src/layers/wildlifeSightings/selection.test.mjs index f7da089369..ccd4c11ad0 100644 --- a/src/layers/wildlifeSightings/selection.test.mjs +++ b/src/layers/wildlifeSightings/selection.test.mjs @@ -43,20 +43,17 @@ function fixture(sighting = row, extraServices = {}) { }, }; bindWildlifeViewer(state.viewer); + const overlayHost = { + setEntries: (id, value) => entries.set(id, value), + clearSource: (id) => entries.delete(id), + setVisible() {}, + hitTest: (_x, _y, { sourceId } = {}) => + sourceId ? (hit?.sourceId === sourceId ? hit : null) : coveringHit || hit, + }; const selection = createSelection({ state, services: { - overlayHost: { - setEntries: (id, value) => entries.set(id, value), - clearSource: (id) => entries.delete(id), - setVisible() {}, - hitTest: (_x, _y, { sourceId } = {}) => - sourceId - ? hit?.sourceId === sourceId - ? hit - : null - : coveringHit || hit, - }, + overlayHost, now: () => row.observedAt + 60_000, project: (_scene, anchor) => { projections++; @@ -71,6 +68,12 @@ function fixture(sighting = row, extraServices = {}) { }), eventTarget: new EventTarget(), ...extraServices, + // The card on top at a click, as the registry answers from the host. + picking: { + clickCard: (c) => + overlayHost.hitTest(c.screenPosition?.x, c.screenPosition?.y), + ...extraServices.picking, + }, }, parts: { rendering: { @@ -187,7 +190,7 @@ test('selected photo and name cards use the selected lane, select on click and n } }); -test('a covered sighting label yields; the top label acts over trails and other scene items', () => { +test('a covered sighting label and icon yield; the top label acts over trails and other scene items', () => { const f = fixture(row, { // Registered owners, as the app has them: an aircraft, and the flight // trails every layer reads as a no-op (src/data/trailRenderer.js). @@ -205,15 +208,16 @@ test('a covered sighting label yields; the top label acts over trails and other f.click(null); assert.equal(f.flights.length, 1); assert.equal(f.state.selectedRow, row); + // A sighting icon under another layer's card is that card's click too. f.click(); - assert.equal(f.flights.length, 2, 'an actual sighting remains selectable'); + assert.equal(f.flights.length, 1, 'a covered sighting does not act'); f.cover(null); // The top label acts over a flight trail: never a dead click. f.click('gev-trail:fl-a1b2c3:head'); - assert.equal(f.flights.length, 3, 'the label acts over a flight trail'); - // And over another layer's scene item, as on main. + assert.equal(f.flights.length, 2, 'the label acts over a flight trail'); + // And over another layer's scene item. f.click('other:aircraft'); - assert.equal(f.flights.length, 4, 'the top label acts'); + assert.equal(f.flights.length, 3, 'the top label acts'); assert.equal(f.state.selectedRow, row); f.selection.remove(); }); diff --git a/src/overlays/worldOverlay.js b/src/overlays/worldOverlay.js index bb0d2d33f1..31c31ec31f 100644 --- a/src/overlays/worldOverlay.js +++ b/src/overlays/worldOverlay.js @@ -1,4 +1,5 @@ import { WORLD_OVERLAY_OCCLUDER_SELECTORS } from './worldOverlayChrome.js'; +import { setClickCardHitTest } from '../data/pickRegistry.js'; export { WORLD_OVERLAY_OCCLUDER_SELECTORS } from './worldOverlayChrome.js'; import { createCyberSonarSampler, @@ -2869,6 +2870,8 @@ export function initWorldOverlay(viewer) { }; window.addEventListener('gev:cockpit-mode-changed', _cockpitModeHandler); _removePostRender = frame.on('postRender', () => drawWorldOverlay()); + // Click handlers read the card painted on top through the pick registry. + setClickCardHitTest(hitTestWorldOverlay); _removeMoveEnd = camera.on('moveEnd', () => invalidateHost()); installUiOccluderObservers(); // The backing store and the occluder inventory are both deferred to the @@ -2954,6 +2957,7 @@ export function destroyWorldOverlay() { _paintCount = 0; _paintRectCount = 0; _hitRectCount = 0; + setClickCardHitTest(null); _uiOcclusionRects.length = 0; _uiOcclusionRectPool.length = 0; _destroyed = hadHost || _destroyed; diff --git a/src/scenes/interactions.js b/src/scenes/interactions.js index a7c2d09eef..35d76b10bd 100644 --- a/src/scenes/interactions.js +++ b/src/scenes/interactions.js @@ -1,6 +1,7 @@ import { nextTick } from 'vue'; import { isPointerFree } from '../data/inputOwnership.js'; import { inputFor } from '../input/dispatcher.js'; +import { isUnderOtherCard } from '../data/pickRegistry.js'; import { createInteractionSession } from '../director/interactions/session.js'; import { t } from '../i18n/index.js'; import { useSceneInteractionsStore } from '../ui/stores/sceneInteractions.js'; @@ -119,6 +120,9 @@ export function createSceneInteractions( session.activate(items); unsubscribeClick = inputFor(viewer).onClick((event) => { if (panel?.owner !== owner || !shown() || !available()) return; + // Another layer's card or label painted on top takes the click: the item + // under it does not act, and the click is not empty space either. + if (isUnderOtherCard(event)) return; // A pack feature is its draw set's item (see dataPacks/presentation.js). const hit = event.drawHit; if (!hit) return; diff --git a/src/scenes/interactionsView.test.mjs b/src/scenes/interactionsView.test.mjs index 04b1e18262..99cb576766 100644 --- a/src/scenes/interactionsView.test.mjs +++ b/src/scenes/interactionsView.test.mjs @@ -10,6 +10,8 @@ import { createPinia } from 'pinia'; import { useSceneInteractionsStore } from '../ui/stores/sceneInteractions.js'; import SceneInteractions from '../ui/views/panels/SceneInteractions.vue'; import { createSceneInteractions } from './interactions.js'; +import { fakeInput } from '../input/testDoubles.mjs'; +import { setClickCardHitTest } from '../data/pickRegistry.js'; const target = (featureId) => ({ packId: 'qa', featureId }); const key = (featureId) => JSON.stringify(['qa', featureId]); @@ -192,3 +194,39 @@ test("an earlier owner leaves a later owner's panel alone", async (t) => { await settle(); assert.equal(later.getState().selected, 'fly'); }); + +// The card or label painted on top takes the click: a pack feature under +// another layer's card is not selected for its actions. +test("another layer's card over a pack feature keeps the click", async (t) => { + document.body.replaceChildren(); + const container = document.body.appendChild(document.createElement('div')); + const canvas = container.appendChild(document.createElement('canvas')); + const pinia = createPinia(); + const app = createApp(SceneInteractions).use(pinia); + app.mount(document.body.appendChild(document.createElement('div'))); + let picked = null; + const viewer = { container, scene: { canvas, pick: () => picked } }; + const input = fakeInput(viewer); + const store = useSceneInteractionsStore(pinia); + const interactions = createSceneInteractions(viewer, { + execute: async () => true, + store, + }); + let top = { sourceId: 'earthquake-card', entryId: 'earthquake-card:ak1' }; + setClickCardHitTest(() => top); + t.after(() => { + setClickCardHitTest(null); + interactions.destroy(); + input.destroy(); + app.unmount(); + }); + const feature = { set: 'qa:points', id: 'point' }; + interactions.activate(SHOT, new Map([[key('point'), feature]])); + await nextTick(); + picked = { id: feature, primitive: {} }; + input.tap({ x: 10, y: 10 }); + assert.deepEqual(store.panel?.outlined ?? [], [], 'covered: not selected'); + top = null; + input.tap({ x: 10, y: 10 }); + assert.deepEqual(store.panel.outlined, ['card', 'fly']); +}); diff --git a/src/ui/applicationShell.js b/src/ui/applicationShell.js index 3546f38008..3577513e07 100644 --- a/src/ui/applicationShell.js +++ b/src/ui/applicationShell.js @@ -199,7 +199,6 @@ export class StyleManager extends ShellFacade { pinia: applicationPinia(), pickWorld: services.pickWorldFromScreen, regionalBrief: services.fetchRegionalBrief, - overlayHit: services.hitTestWorldOverlay, }); this.mapStackController = mapStackController; this.placeSearch = placeSearch; diff --git a/src/ui/cockpitOrbitalFocus.js b/src/ui/cockpitOrbitalFocus.js index 5b97c34838..a7790ab102 100644 --- a/src/ui/cockpitOrbitalFocus.js +++ b/src/ui/cockpitOrbitalFocus.js @@ -10,6 +10,7 @@ */ import { fromDegrees } from '../geo/ellipsoid.js'; import { inputFor } from '../input/dispatcher.js'; +import { isUnderOtherCard } from '../data/pickRegistry.js'; import { findQuery } from '../render/rendererOf.js'; import { clampOrbitalLook, easeLook } from '../cockpitLook.js'; import { ORBITAL_EARTH_RADIUS_M } from '../cockpitOrbital.js'; @@ -286,7 +287,12 @@ export function routeSceneClick() { // A viewer with no input (headless tools, partial stubs) has no clicks. return () => {}; } - return input.onClick((event) => this.onOrbitalClick(event?.position)); + return input.onClick((event) => { + // Another layer's card or label painted on top takes the click: the site + // under it does not focus, and the click does not end a held focus. + if (isUnderOtherCard(event)) return; + this.onOrbitalClick(event?.position); + }); } /** diff --git a/src/ui/cockpitOrbitalFocus.test.mjs b/src/ui/cockpitOrbitalFocus.test.mjs index 73cc3505c7..e32c6f0fac 100644 --- a/src/ui/cockpitOrbitalFocus.test.mjs +++ b/src/ui/cockpitOrbitalFocus.test.mjs @@ -30,6 +30,7 @@ import CockpitView from './views/CockpitView.vue'; import ContextView from './views/ContextView.vue'; import IntelHudView from './views/IntelHudView.vue'; import { claimPointer, releasePointer } from '../data/inputOwnership.js'; +import { setClickCardHitTest } from '../data/pickRegistry.js'; import { ORBITAL_FOCUS_EASE_TAU_MS } from '../cockpitOrbitalFocus.js'; import { ORBITAL_HOP_MS } from '../cockpitOrbitalSatellites.js'; @@ -635,6 +636,23 @@ test('a click a tool owns is left alone', async (t) => { assert.equal(scene.cockpit.orbital.focus.key, SITES.alpha.id, 'kept while drawing'); }); +// The card or label painted on top takes the click: a site under another +// layer's card does not focus, and a click there does not end a held focus. +test('another layer\'s card over the orbital view keeps the click', async (t) => { + const scene = await inOrbit(t); + let top = { sourceId: 'earthquake-card', entryId: 'earthquake-card:ak1' }; + setClickCardHitTest(() => top); + t.after(() => setClickCardHitTest(null)); + scene.click(SITES.alpha.at); + assert.equal(scene.cockpit.orbital.focus ?? null, null, 'covered: no focus'); + top = null; + scene.click(SITES.alpha.at); + assert.equal(scene.cockpit.orbital.focus.key, SITES.alpha.id); + top = { sourceId: 'earthquake-card', entryId: 'earthquake-card:ak1' }; + scene.click(EMPTY_GROUND); + assert.equal(scene.cockpit.orbital.focus.key, SITES.alpha.id, 'covered: kept'); +}); + test('a double-click on a site focuses it and keeps the orbital view', async (t) => { const scene = await inOrbit(t); const { cockpit, viewer, handler } = scene; diff --git a/src/ui/entityContextBridge.js b/src/ui/entityContextBridge.js index cb1906f233..5c145ea842 100644 --- a/src/ui/entityContextBridge.js +++ b/src/ui/entityContextBridge.js @@ -1,4 +1,5 @@ -import { cardKeepsClick, resolvePickedContext } from '../data/pickedContext.js'; +import { resolvePickedContext } from '../data/pickedContext.js'; +import { clickCard } from '../data/pickRegistry.js'; import { followedOf, onFollowChanged } from '../data/followed.js'; import { fromDegreesInto } from '../geo/ellipsoid.js'; import { inputFor } from '../input/dispatcher.js'; @@ -45,8 +46,6 @@ const FOLLOWABLE = new Set(['flights', 'military', 'satellites']); * to the point under the camera without it. * @param {(lat: number, lon: number) => Promise} [options.regionalBrief] * The app's regional brief service, for the weather and news Context shows. - * @param {(x: number, y: number) => object|null} [options.overlayHit] - * The overlay card under a screen point, if any (a vessel's, a fire's). * @returns {() => void} disconnects */ export function installEntityContext({ @@ -55,7 +54,6 @@ export function installEntityContext({ pinia, pickWorld, regionalBrief, - overlayHit, }) { const store = useEntityCardStore(pinia); const omnibar = useOmnibarStore(pinia); @@ -311,16 +309,14 @@ export function installEntityContext({ // Cockpit has its own picks, and Context is hidden while it runs. A // camera drag never selects, even if it ends over something. if (inCockpit() || !isTrackingSelectionGesture(event.gesture)) return; + // A card or label painted on top is its layer's click, read once per + // click so every layer agrees: Context names nothing under it and keeps + // its own card as it is. + if (clickCard(event)) return; const identity = resolvePickedContext(event.hit, { dataManager: getDataManager(), }); if (identity) { - // A card or label painted over an item its layer does not act on here - // (a quake card beside a fire, or over a route) is the card's click. - const underCard = Boolean( - overlayHit?.(event.screenPosition?.x, event.screenPosition?.y), - ); - if (cardKeepsClick(event, underCard)) return; // These layers start following on their own click; following again // from here would fight them (the flights layer reads a second track // of the same plane as a click on empty map and lets go). @@ -330,14 +326,8 @@ export function installEntityContext({ // A click on open ground, sea or sky lets go of what was selected. A // click on something else Context cannot describe (a label, a trail) // leaves the card as it is. - // Only a clean click lets go, as the layers' own clicks do; a card - // painted on the overlay (a vessel's, a fire's) is not open map. - if ( - event.surface && - isTrackingClickGesture(event.gesture) && - !overlayHit?.(event.screenPosition?.x, event.screenPosition?.y) - ) - store.clear(); + // Only a clean click lets go, as the layers' own clicks do. + if (event.surface && isTrackingClickGesture(event.gesture)) store.clear(); }); // Layers that select through the context store (GeoJSON sites, fires, diff --git a/src/ui/entityContextBridge.test.mjs b/src/ui/entityContextBridge.test.mjs index 541350bd5a..025b23df57 100644 --- a/src/ui/entityContextBridge.test.mjs +++ b/src/ui/entityContextBridge.test.mjs @@ -6,14 +6,14 @@ import { useEntityCardStore } from './stores/entityCard.js'; import { fakeInput } from '../input/testDoubles.mjs'; import { registerPickOwner, + setClickCardHitTest, unregisterPickOwner, } from '../data/pickRegistry.js'; -// A coarse tap that misses everything exactly finds a fire within the shared -// touch window. On open map Context names it; under a quake card or label the -// card takes the tap, since the fire layer acts only on exact hits; an exact -// hit on the fire is the fire's, under a card or not. -test('Context leaves a near-missed exact-only item to a card painted over it', (t) => { +// The card or label painted on top takes the click: Context names nothing +// under it, exact or nearby, an acting owner's item or a passive one, and +// keeps its own card. On open map it names what the click found. +test('Context names nothing under a card painted on top, and keeps its card', (t) => { const previous = globalThis.matchMedia; globalThis.matchMedia = () => ({ matches: true }); t.after(() => { @@ -21,17 +21,31 @@ test('Context leaves a near-missed exact-only item to a card painted over it', ( else delete globalThis.matchMedia; }); const fire = { set: 'test-fires:1', id: 'fire:1' }; + const plane = { set: 'test-planes:1', id: 'plane:1' }; + const route = { set: 'test-route:1', id: 'route:line' }; registerPickOwner('test-fires', (id) => id === fire.id); - t.after(() => unregisterPickOwner('test-fires')); - let exact = false; + registerPickOwner('test-planes', (id) => id === plane.id); + registerPickOwner('test-route', (id) => id.startsWith('route:')); + let cardOnTop = false; + // The card on top at a click, as the host answers the pick registry. + setClickCardHitTest(() => + cardOnTop ? { sourceId: 'earthquake-card', entryId: 'q' } : null, + ); + t.after(() => { + setClickCardHitTest(null); + unregisterPickOwner('test-fires'); + unregisterPickOwner('test-planes'); + unregisterPickOwner('test-route'); + }); + let exact = null; + let near = null; const viewer = { scene: { - pick: () => (exact ? { id: fire } : null), - drillPick: () => [{ id: fire }], + pick: () => (exact ? { id: exact } : null), + drillPick: () => (near ? [{ id: near }] : []), }, }; const input = fakeInput(viewer); - let cardOnTop = false; const pinia = createPinia(); const disconnect = installEntityContext({ viewer, @@ -41,8 +55,6 @@ test('Context leaves a near-missed exact-only item to a card painted over it', ( getAll: () => [], }), pinia, - overlayHit: () => - cardOnTop ? { sourceId: 'earthquake-card', entryId: 'q' } : null, }); t.after(() => { disconnect(); @@ -50,52 +62,24 @@ test('Context leaves a near-missed exact-only item to a card painted over it', ( }); const store = useEntityCardStore(pinia); const named = []; + let clears = 0; store.select = (identity) => named.push(identity.id); - const tap = () => { + store.clear = () => clears++; + const tap = (hitExact, hitNear) => { + exact = hitExact; + near = hitNear; named.length = 0; input.click(); return [...named]; }; - assert.deepEqual(tap(), ['fire:1'], 'open map: Context names the fire'); + assert.deepEqual(tap(null, fire), ['fire:1'], 'open map: a near fire'); + assert.deepEqual(tap(route, null), ['route:line'], 'open map: a route'); cardOnTop = true; - assert.deepEqual(tap(), [], 'under a card: the card keeps the tap'); - exact = true; - assert.deepEqual(tap(), ['fire:1'], 'an exact hit is the fire’s'); -}); - -// Every card layer acts over a passive owner's pick (a directions route), so -// Context leaves an exact route hit under a card to that card, and names it on -// open map as before. -test('Context leaves an exact passive route under a card to the card', (t) => { - const route = { set: 'test-route:1', id: 'route:line' }; - registerPickOwner('test-route', (id) => id.startsWith('route:'), { - passive: true, - }); - t.after(() => unregisterPickOwner('test-route')); - const viewer = { scene: { pick: () => ({ id: route }) } }; - const input = fakeInput(viewer); - let cardOnTop = false; - const pinia = createPinia(); - const disconnect = installEntityContext({ - viewer, - getDataManager: () => ({ - isEnabled: () => true, - layers: new Map(), - getAll: () => [], - }), - pinia, - overlayHit: () => - cardOnTop ? { sourceId: 'earthquake-card', entryId: 'q' } : null, - }); - t.after(() => { - disconnect(); - input.destroy(); - }); - const named = []; - useEntityCardStore(pinia).select = (identity) => named.push(identity.id); - input.click(); - assert.deepEqual(named, ['route:line'], 'open map: Context names the route'); - cardOnTop = true; - input.click(); - assert.deepEqual(named, ['route:line'], 'under a card: the card keeps it'); + assert.deepEqual(tap(null, fire), [], 'under a card: a near fire'); + assert.deepEqual(tap(fire, fire), [], 'under a card: an exact fire'); + assert.deepEqual(tap(plane, plane), [], 'under a card: an aircraft'); + assert.deepEqual(tap(route, null), [], 'under a card: a route'); + const cleared = clears; + tap(null, null); + assert.equal(clears, cleared, 'a card over open map is not open map'); }); diff --git a/src/ui/wildlifeSightingCard.test.mjs b/src/ui/wildlifeSightingCard.test.mjs index 96f9d06c33..e38a6c4852 100644 --- a/src/ui/wildlifeSightingCard.test.mjs +++ b/src/ui/wildlifeSightingCard.test.mjs @@ -140,6 +140,8 @@ function fixture( }, }), focus: { requestWorldFocus: (value) => flights.push(value) }, + // The card on top at a click, as the registry answers from the host. + picking: { clickCard: () => hit }, }, parts: { rendering: { refreshSelection() {}, requestRender() {} }, diff --git a/src/voice/analystAccessors.test.mjs b/src/voice/analystAccessors.test.mjs index 05d9cd9735..ff50cba6cb 100644 --- a/src/voice/analystAccessors.test.mjs +++ b/src/voice/analystAccessors.test.mjs @@ -194,7 +194,6 @@ test('cyclones flatten the storm position and stay empty while off', async () => ownsPickId: () => false, getDiagnostics: () => ({}), }), - hitTestOverlay: () => null, }); const viewer = { scene: { canvas: new EventTarget(), pick: () => null },