Function render_hosting 

pub fn render_hosting(hv: &HostingView, width: u32, height: u32) -> Rendered

Render an existing hosting view — used when the root is swapped between frames.

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