systemless 0.70.0

High-Level Emulation for classic Macintosh applications
Documentation
//! Self-driving window-system qualification, available only in test-support builds.
//! Requests go through the real host window; observations use native events
//! and, for macOS event-free cursor warps, an AppKit pointer-position query.
//! The cursor packet is injected at the owned-snapshot boundary: driver tests
//! separately prove guest instruction -> retained warp -> matching acknowledgement.
use super::*;
use std::time::{Duration, Instant};
use winit::window::Window;

struct Probe {
    app: App,
    report: PathBuf,
    started: Instant,
    phase_started: Instant,
    phase: usize,
    helper: Option<Window>,
    focused: bool,
    lost_focus: bool,
    returned_focus: bool,
    resized: bool,
    moved: Option<(f64, f64)>,
    expected_cursor: Option<(f64, f64)>,
    expected_guest: Option<(i16, i16)>,
    #[cfg(target_os = "macos")]
    cursor_input_sent: bool,
    sequence: u64,
    checks: Vec<&'static str>,
    complete: bool,
}

pub(super) fn run(event_loop: EventLoop<()>, app: App, report: PathBuf) {
    let now = Instant::now();
    let mut probe = Probe {
        app,
        report,
        started: now,
        phase_started: now,
        phase: 0,
        helper: None,
        focused: false,
        lost_focus: false,
        returned_focus: false,
        resized: false,
        moved: None,
        expected_cursor: None,
        expected_guest: None,
        #[cfg(target_os = "macos")]
        cursor_input_sent: false,
        sequence: 0,
        checks: Vec::new(),
        complete: false,
    };
    event_loop
        .run_app(&mut probe)
        .expect("native probe event loop");
    probe.complete = probe.phase == 10 && probe.app.runtime_error.is_none();
    if let Some(owner) = probe.app.owner.as_mut() {
        probe.complete &= owner.join_finished().expect("owner teardown");
    }
    if probe.complete {
        probe
            .checks
            .push("production close completes owner teardown");
    }
    probe.write_report();
    assert!(
        probe.complete,
        "native window probe incomplete at phase {}",
        probe.phase
    );
}

impl Probe {
    fn write_report(&self) {
        let report = serde_json::json!({
            "passed": self.complete, "phase": self.phase, "checks": self.checks,
            "elapsed_seconds": self.started.elapsed().as_secs_f64(),
            "os": std::env::consts::OS,
            "backend": if self.app.owner.is_some() { "thread" } else { "inline-or-stopped" },
            "cursor_scope": if cfg!(target_os = "macos") {
                "owned snapshot -> OS pointer query; separate mapped input-command round trip; guest origin covered by driver tests"
            } else {
                "owned snapshot -> actual native cursor event -> guest input round trip; guest origin covered by driver tests"
            },
            "runtime_error": self.app.runtime_error,
            "window": self.app.window.as_ref().map(|w| serde_json::json!({
                "width": w.inner_size().width, "height": w.inner_size().height,
                "fullscreen": w.fullscreen().is_some(), "focused": self.focused,
                "resized_event": self.resized, "cursor_event": self.moved,
                "expected_cursor": self.expected_cursor,
                "guest_mouse": self.app.frame.mouse_position,
                "expected_guest": self.expected_guest,
            })),
        });
        std::fs::write(&self.report, serde_json::to_vec_pretty(&report).unwrap()).unwrap();
    }
    fn advance(&mut self, check: &'static str) {
        self.checks.push(check);
        eprintln!("[NATIVE-PROBE] PASS {check}");
        self.phase += 1;
        self.phase_started = Instant::now();
        self.resized = false;
    }
    fn step(&mut self, event_loop: &ActiveEventLoop) {
        if self.started.elapsed() > Duration::from_secs(90) {
            self.write_report();
            panic!("native probe timed out at phase {}", self.phase);
        }
        assert!(self.app.runtime_error.is_none(), "native runtime failed");
        let Some(window) = self.app.window.as_ref().cloned() else {
            return;
        };
        #[cfg(target_os = "macos")]
        if self.phase == 9 {
            // CGWarpMouseCursorPosition intentionally generates no event:
            // https://developer.apple.com/documentation/coregraphics/cgwarpmousecursorposition(_:)
            self.moved = macos_cursor_position(&window);
            if !self.cursor_input_sent
                && self
                    .moved
                    .zip(self.expected_cursor)
                    .is_some_and(|(a, b)| (a.0 - b.0).abs() < 2.0 && (a.1 - b.1).abs() < 2.0)
            {
                let (x, y) = self.moved.unwrap();
                let (v, h) = self.app.host_mouse_to_mac(x, y);
                self.expected_guest = Some((v, h));
                self.app
                    .send_command(runtime_protocol::GuiCommand::MouseMove { v, h });
                self.cursor_input_sent = true;
            }
        }
        let settled = self.phase_started.elapsed() > Duration::from_secs(2);
        match self.phase {
            0 if self.app.frame.sequence > 2 => {
                window.focus_window();
                self.advance("guest frames reach real window");
            }
            1 if self.focused && settled => {
                let _ = window.request_inner_size(winit::dpi::PhysicalSize::new(700, 500));
                self.advance("initial native focus");
            }
            2 if self.resized
                && window.inner_size() == winit::dpi::PhysicalSize::new(700, 500)
                && settled =>
            {
                window.set_fullscreen(Some(winit::window::Fullscreen::Borderless(None)));
                self.advance("native resize observed");
            }
            3 if self.resized && window.fullscreen().is_some() && settled => {
                let monitor = window.current_monitor().expect("fullscreen monitor");
                if window.inner_size() != monitor.size() {
                    return;
                }
                window.set_fullscreen(None);
                self.advance("fullscreen entry reaches monitor dimensions");
            }
            4 if self.resized && window.fullscreen().is_none() && settled => {
                let size = window.inner_size();
                let monitor = window.current_monitor().expect("window monitor").size();
                if size.width == 0 || size.height == 0 || size == monitor {
                    return;
                }
                // AppKit may restore its remembered standard (zoom) frame.
                // Verify windowed bounds, then require an exact resize after exit.
                eprintln!("[NATIVE-PROBE] restored normal size={size:?}");
                let _ = window.request_inner_size(winit::dpi::PhysicalSize::new(700, 500));
                self.advance("fullscreen exit returns to normal window bounds");
            }
            5 if window.inner_size() == winit::dpi::PhysicalSize::new(700, 500) && settled => {
                let helper = event_loop
                    .create_window(
                        Window::default_attributes()
                            .with_title("Systemless focus probe")
                            .with_inner_size(winit::dpi::PhysicalSize::new(240, 160)),
                    )
                    .unwrap();
                self.lost_focus = false;
                helper.focus_window();
                self.helper = Some(helper);
                self.advance("exact resize works after fullscreen exit");
            }
            6 if self.lost_focus && settled => {
                self.returned_focus = false;
                window.focus_window();
                self.advance("native focus loss observed");
            }
            7 if self.returned_focus && settled => {
                self.helper = None;
                self.sequence = self.app.frame.sequence;
                self.advance("native focus return observed");
            }
            8 if self.app.frame.sequence > self.sequence + 2 && settled => {
                let size = window.inner_size();
                let target = self
                    .app
                    .physical_to_mac(f64::from(size.width) * 0.4, f64::from(size.height) * 0.4);
                self.app.guest_state.warp = Some(runtime_protocol::CursorWarp {
                    serial: u64::MAX,
                    position: target,
                });
                self.expected_guest = Some(target);
                self.moved = None;
                self.app.sync_guest_cursor_warp();
                assert!(
                    self.app.guest_state.warp.is_none(),
                    "warp packet not consumed"
                );
                assert_eq!(self.app.mouse_guest_offset, (0, 0), "native warp fell back");
                self.expected_cursor = Some(self.app.mouse_physical);
                self.advance("frame delivery continues after focus return");
            }
            9 if self
                .moved
                .zip(self.expected_cursor)
                .is_some_and(|(a, b)| (a.0 - b.0).abs() < 2.0 && (a.1 - b.1).abs() < 2.0)
                && Some(self.app.frame.mouse_position) == self.expected_guest
                && settled =>
            {
                self.advance("native cursor position and guest input round trip verified");
                self.app
                    .window_event(event_loop, window.id(), WindowEvent::CloseRequested);
            }
            _ => {}
        }
    }
}
impl ApplicationHandler for Probe {
    fn resumed(&mut self, event_loop: &ActiveEventLoop) {
        self.app.resumed(event_loop);
    }
    fn user_event(&mut self, event_loop: &ActiveEventLoop, event: ()) {
        self.app.user_event(event_loop, event);
    }
    fn window_event(&mut self, event_loop: &ActiveEventLoop, id: WindowId, event: WindowEvent) {
        if self.app.window.as_ref().is_none_or(|w| w.id() != id) {
            return;
        }
        match &event {
            WindowEvent::Focused(value) => {
                eprintln!("[NATIVE-PROBE] phase={} focus={value}", self.phase);
                self.focused = *value;
                if !value {
                    self.lost_focus = true;
                }
                if *value && self.lost_focus {
                    self.returned_focus = true;
                }
            }
            WindowEvent::Resized(size) => {
                eprintln!("[NATIVE-PROBE] phase={} resize={size:?}", self.phase);
                self.resized = true;
            }
            WindowEvent::CursorMoved { position, .. } => {
                self.moved = Some((position.x, position.y))
            }
            _ => {}
        }
        self.app.window_event(event_loop, id, event);
    }
    fn about_to_wait(&mut self, event_loop: &ActiveEventLoop) {
        self.app.about_to_wait(event_loop);
        self.step(event_loop);
        event_loop.set_control_flow(ControlFlow::WaitUntil(
            Instant::now() + Duration::from_millis(16),
        ));
    }
}

#[cfg(target_os = "macos")]
fn macos_cursor_position(window: &Window) -> Option<(f64, f64)> {
    let handle = window.window_handle().ok()?;
    let RawWindowHandle::AppKit(handle) = handle.as_raw() else {
        return None;
    };
    // SAFETY: the main-thread event loop owns this live winit NSView/NSWindow.
    // These are read-only AppKit queries; no event injection or global hooks.
    unsafe {
        let view: &NSObject = handle.ns_view.cast().as_ref();
        let native_window: *mut NSObject = msg_send![view, window];
        let native_window = native_window.as_ref()?;
        let point: objc2_foundation::CGPoint =
            msg_send![native_window, mouseLocationOutsideOfEventStream];
        let local: objc2_foundation::CGPoint =
            msg_send![view, convertPoint: point fromView: std::ptr::null::<NSObject>()];
        let bounds: objc2_foundation::CGRect = msg_send![view, bounds];
        let flipped: bool = msg_send![view, isFlipped];
        let y = if flipped {
            local.y - bounds.origin.y
        } else {
            bounds.origin.y + bounds.size.height - local.y
        };
        let scale = window.scale_factor();
        Some(((local.x - bounds.origin.x) * scale, y * scale))
    }
}