Function pump_events 

pub fn pump_events(seconds: f64)

Run a real event loop for seconds, dequeuing and dispatching NSEvents.

pump turns the run loop, which is enough for SwiftUI’s clock and for display, but it never touches the application’s event queue — so an event posted with postEvent:atStart: just sits there and a gesture never fires. This is the loop that delivers them.

Use pump for anything that only needs time to pass; use this when something has to receive input.

Examples found in repository

examples/hot_reload.rs (line 397)

fn drive() {
    let p = path();
    std::fs::write(&p, STARTER).expect("write starter");
    reload(&p);
    watch(p.clone());

    let window = swiftui_native::Window::new(&content_view(), "Hot reload", 360.0, 420.0);
    let shot = |n: &str| {
        let out = format!("{}/../../target/hot_reload_live_{n}.png", env!("CARGO_MANIFEST_DIR"));
        let r = swiftui_native::render::render_hosting(window.hosting(), 360, 420);
        r.write_png(&out);
        (out, r)
    };

    // Pixels differing *above* the status strip.
    //
    // The strip reports the generation, so it changes on every reload whether
    // or not the screen did — comparing whole frames would make "the screen
    // survived a file that does not parse" indistinguishable from "the screen
    // changed".
    fn screen_diff(
        a: &swiftui_native::render::Rendered,
        b: &swiftui_native::render::Rendered,
    ) -> u32 {
        if a.width != b.width || a.height != b.height {
            return u32::MAX;
        }
        // Measured, not estimated: with a 420-point capture the strip's own
        // pixels start at row 294, so everything from 290 down is excluded.
        // Guessing 90 left part of the strip in the comparison and reported a
        // screen that had not moved as having moved.
        const SCREEN_ROWS: u32 = 290;
        let keep = (SCREEN_ROWS.min(a.height) * a.width * 4) as usize;
        a.pixels[..keep]
            .chunks_exact(4)
            .zip(b.pixels[..keep].chunks_exact(4))
            .filter(|(x, y)| x != y)
            .count() as u32
    }

    // Let the window settle before the first capture, or it is caught blank.
    swiftui_native::render::pump_events(1.0);
    let (first_path, first) = shot("1_start");

    // A user changes the toggle. Everything after this checks it stays
    // changed, which is what separates reloading from restarting.
    spec::set_flag("dark", true);
    swiftui_native::state::refresh();
    window.set_root(&content_view());
    swiftui_native::render::pump_events(0.4);

    /// One edit, and whether the screen should follow it.
    struct Edit {
        name: &'static str,
        src: &'static str,
        /// `false` for a spec that does not parse: the screen must *not*
        /// change, because the last good one has to stay put.
        expect_change: bool,
    }

    let edits = &[
        Edit {
            name: "2_edited",
            src: "vstack spacing=10 pad=20 align=leading {\n  \
                  text \"Edited while running\" style=title bold color=red\n  \
                  text \"the process never restarted\" color=secondary size=12\n  \
                  toggle \"Dark mode\" @dark\n  \
                  gauge 0.9 label=\"reloaded\"\n}",
            expect_change: true,
        },
        Edit {
            name: "3_restructured",
            src: "zstack align=center frame=300x200 {\n  \
                  color #223344 frame=280x180 corner=14\n  \
                  text \"a different shape entirely\" color=white size=14\n}",
            expect_change: true,
        },
        Edit {
            // Mid-edit: a brace that is never closed. The screen must survive.
            name: "4_broken",
            src: "zstack align=center frame=300x200 {\n  color #223344",
            expect_change: false,
        },
    ];

    let mut shots = vec![(first_path, first)];
    let mut ok = true;
    for e in edits {
        std::fs::write(&p, e.src).expect("write edit");
        let deadline = std::time::Instant::now() + Duration::from_secs(4);
        while !PENDING.load(Ordering::Relaxed) && std::time::Instant::now() < deadline {
            swiftui_native::render::pump_events(0.05);
        }
        if !PENDING.swap(false, Ordering::Relaxed) {
            eprintln!("{}: the watcher never fired", e.name);
            std::process::exit(1);
        }
        swiftui_native::state::refresh();
        window.set_root(&content_view());
        swiftui_native::render::pump_events(0.6);
        let (path_now, shot_now) = shot(e.name);

        let (prev_path, prev) = shots.last().expect("a previous shot");
        let d = screen_diff(prev, &shot_now);
        println!("{prev_path}\n  -> {path_now}\n     {d} pixels differ above the status strip");
        match (e.expect_change, d) {
            (true, 0) => {
                eprintln!("     the window did not follow the edit");
                ok = false;
            }
            (false, n) if n > 0 => {
                eprintln!("     a file that does not parse replaced the screen");
                ok = false;
            }
            _ => {}
        }
        shots.push((path_now, shot_now));
    }

    // …and the toggle is still on, after every reload and a broken file.
    let dark = spec::slot_summary().into_iter().find(|(k, _)| k == "dark").map(|(_, v)| v);
    println!("slot `dark` after every reload: {dark:?}");
    if dark.as_deref() != Some("true") {
        eprintln!("  a reload reset the slot");
        ok = false;
    }

    std::fs::write(&p, STARTER).expect("restore spec");
    if !ok {
        std::process::exit(1);
    }
    println!("followed every valid edit, survived an invalid one, kept its state");
}

#[cfg(target_os = "macos")]
fn main() {
    let p = path();
    if std::env::args().any(|a| a == "--frames") {
        return frames();
    }
    if std::env::args().any(|a| a == "--drive") {
        return drive();
    }

    if !std::path::Path::new(&p).exists() {
        std::fs::write(&p, STARTER).expect("write starter");
        eprintln!("wrote {p}");
    }
    reload(&p);
    watch(p.clone());
    eprintln!("watching {p} — edit it and save");

    // `Window::run` enters AppKit's loop and never comes back, which leaves
    // nowhere to notice the file changed. Pumping the loop in slices instead
    // keeps the window live *and* gives this thread a turn between them —
    // `state::refresh` has to happen on the main thread, so the watcher only
    // raises a flag and the work is done here.
    let window = swiftui_native::Window::new(&content_view(), "Hot reload", 360.0, 420.0);
    loop {
        swiftui_native::render::pump_events(0.05);
        if PENDING.swap(false, Ordering::Relaxed) {
            // Two mechanisms, because the screen may be either shape: the
            // synthesised root re-evaluates its body on `refresh`, and
            // `set_root` hands SwiftUI a fresh tree to diff against. The first
            // alone leaves a structural change — a `VStack` becoming a
            // `ZStack` — with nothing to diff.
            swiftui_native::state::refresh();
            window.set_root(&content_view());
            eprintln!("reloaded (generation {})", GENERATION.load(Ordering::Relaxed));
        }
    }
}