/** Route Cockpit keys while preserving the active disclosure and form-control owner. */ import { isPointerFree } from '../data/inputOwnership.js'; /** How far from the followed track a double-click may land, CSS pixels. */ export const SUBJECT_DOUBLE_CLICK_RADIUS_PX = 32; /** * Whether a double-click landed on the followed track's mark. * @param {{x: number, y: number}|null} click Canvas position of the click. * @param {{x: number, y: number}|null|undefined} subject Canvas position of * the track, or nothing when it is off screen. * @param {number} [radiusPx] */ export function doubleClickHitsSubject( click, subject, radiusPx = SUBJECT_DOUBLE_CLICK_RADIUS_PX, ) { if (!click || !subject) return false; const distance = Math.hypot(click.x - subject.x, click.y - subject.y); return Number.isFinite(distance) && distance <= radiusPx; } /** Where the track `kind` would ride is drawn now, as a world position. */ function subjectWorldPosition(kind) { if (kind !== 'aircraft') return null; const target = this.host.current(); return target ? (this.host.position(target) ?? null) : null; } /** The followed track's canvas position now, or null off screen. */ function subjectCanvasPosition() { const kind = this.resolveEntryKind(); const world = kind ? subjectWorldPosition.call(this, kind) : null; return world ? this.host.canvasPosition(world) : null; } /** * Enter first person when the followed track itself is double-clicked: the * same entry, and the same gates, as C and the entry buttons. A * double-click anywhere else, or one a tool owns (drawing ends a shape with * one), is left alone. * @param {{x: number, y: number}|null|undefined} position Canvas position. * @returns {boolean} True when it landed on the followed track, entered or * refused by the gate: the caller does nothing else with it. */ export function onSceneDoubleClick(position) { if (this.active || this.destroyed || !isPointerFree()) return false; if (!Number.isFinite(position?.x) || !Number.isFinite(position?.y)) return false; if (!doubleClickHitsSubject(position, subjectCanvasPosition.call(this))) return false; this.enter(); return true; } /** * Take the scene's double-click through the Cockpit first: one on the * followed track is the Cockpit's, any other goes on to the engine's own * (cockpitHost.routeDoubleClick). * @returns {() => void} Stops routing. */ export function routeSceneDoubleClick() { return this.host.routeDoubleClick((position) => this.onSceneDoubleClick(position), ); } /** * The Cockpit's capture-phase keydown: Escape and C. * @param {KeyboardEvent} event */ export function onKeyDown(event) { if (this.destroyed) return false; if (event.repeat || event.isComposing) return; if (event.key === 'Escape' && this.active) { // The credit lightbox owns Escape while its Close control or links hold // focus. Its target handler closes the overlay and restores attribution // focus; Cockpit must stay active behind it. if (event.target?.closest?.('.cesium-credit-lightbox')) return; // An open Display or Radio popover takes Escape itself. if (this.isUtilityDisclosureOpen?.()) return; if (this.context?.contains(event.target) && !this.contextCollapsed) { event.preventDefault(); event.stopImmediatePropagation(); this.setContextCollapsed(true); if ( event.target === this.contextToggle || this.contextToggle?.contains?.(event.target) ) { this.contextToggle?.blur?.(); } else { this.contextToggle?.focus({ preventScroll: true }); } return; } if (this.signalStream?.contains(event.target) && !this.signalCollapsed) { event.preventDefault(); event.stopImmediatePropagation(); this.setSignalCollapsed(true, { user: true }); if ( event.target === this.signalToggle || this.signalToggle?.contains?.(event.target) ) { this.signalToggle?.blur?.(); } else { this.signalToggle?.focus({ preventScroll: true }); } return; } event.preventDefault(); event.stopImmediatePropagation(); this.exit(); return; } if (event.target?.closest?.('input, textarea, select, [contenteditable]')) return; const key = event.key?.toLowerCase(); if (key === 'c' && !event.metaKey && !event.ctrlKey && !event.altKey) { if (!this.active) { const cockpitAttempt = !!(this.readAircraftInfo() && this.host.current()); if (!cockpitAttempt) return; } event.preventDefault(); event.stopImmediatePropagation(); if (!this.active && !this.isEntryAllowed()) return; if (this.active) this.exit(); else this.enter(); return; } }