Struct Window 

pub struct Window { /* private fields */ }

A native window hosting a SwiftUI view built from Rust.

The root view can be replaced at any time with Window::set_root, which is how a Rust-driven interface updates after it is already on screen.

Implementations

impl Window

pub fn new(view: &ViewHandle, title: &str, width: f64, height: f64) -> Self

Create and show a window. Does not start the event loop.

Examples found in repository

examples/hot_reload.rs (line 362)

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));
        }
    }
}

pub fn set_root(&self, view: &ViewHandle)

Replace the displayed view. SwiftUI diffs it against the previous tree.

Examples found in repository

examples/hot_reload.rs (line 404)

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));
        }
    }
}

pub fn hosting(&self) -> &HostingView

The hosting view, for rendering or further configuration.

Examples found in repository

examples/hot_reload.rs (line 365)

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");
}

pub fn as_ptr(&self) -> *mut c_void

pub fn run(&self) -> !

Enter the AppKit event loop. Never returns.