Function render 

pub fn render(view: &ViewHandle, width: u32, height: u32) -> Rendered

Render a view offscreen at exactly width x height pixels.

Examples found in repository

examples/todo.rs (line 152)

fn main() {
    if std::env::args().any(|a| a == "--sim" || a == "device") {
        return simulator::main(&simulator::Bundle {
            example: "todo",
            bundle_id: "dev.rswift.Todo",
            executable: "Todo",
            display_name: "Todo",
            launch_args: &[],
        });
    }
    if std::env::args().any(|a| a == "--render") {
        let out = concat!(env!("CARGO_MANIFEST_DIR"), "/../../target/todo.png");
        swiftui_native::render::render(&content_view(), 420, 460).write_png(out);
        eprintln!("wrote {out}");
        return;
    }
    show_window(&content_view(), "Todo", 420.0, 460.0);
}

examples/inbox.rs (line 143)

fn main() {
    if std::env::args().any(|a| a == "--sim" || a == "device") {
        return simulator::main(&simulator::Bundle {
            example: "inbox",
            bundle_id: "dev.rswift.Inbox",
            executable: "Inbox",
            display_name: "Inbox",
            launch_args: &[],
        });
    }
    if std::env::args().any(|a| a == "--render") {
        let out = concat!(env!("CARGO_MANIFEST_DIR"), "/../../target/inbox.png");
        swiftui_native::render::render(&content_view(), 420, 520).write_png(out);
        eprintln!("wrote {out}");
        return;
    }
    show_window(&content_view(), "Inbox", 420.0, 520.0);
}

examples/settings.rs (line 141)

fn main() {
    if std::env::args().any(|a| a == "--sim" || a == "device") {
        return simulator::main(&simulator::Bundle {
            example: "settings",
            bundle_id: "dev.rswift.Settings",
            executable: "Settings",
            display_name: "Settings",
            launch_args: &[],
        });
    }
    if std::env::args().any(|a| a == "--render") {
        let out = concat!(env!("CARGO_MANIFEST_DIR"), "/../../target/settings.png");
        swiftui_native::render::render(&content_view(), 420, 640).write_png(out);
        eprintln!("wrote {out}");
        return;
    }
    show_window(&content_view(), "Settings", 420.0, 640.0);
}

examples/dashboard.rs (line 119)

fn main() {
    if std::env::args().any(|a| a == "--sim" || a == "device") {
        return simulator::main(&simulator::Bundle {
            example: "dashboard",
            bundle_id: "dev.rswift.Dashboard",
            executable: "Dashboard",
            display_name: "Dashboard",
            launch_args: &[],
        });
    }
    if std::env::args().any(|a| a == "--render") {
        let out = concat!(env!("CARGO_MANIFEST_DIR"), "/../../target/dashboard.png");
        swiftui_native::render::render(&content_view(), 420, 480).write_png(out);
        eprintln!("wrote {out}");
        return;
    }
    show_window(&content_view(), "Dashboard", 420.0, 480.0);
}

examples/swift_org_tutorial.rs (line 200)

fn main() {
    // `--sim` and `--device` build for iOS and run it there; see `common/simulator.rs`.
    if std::env::args().any(|a| a == "--sim" || a == "device" || a == "ipa") {
        return simulator::main(&simulator::Bundle {
            example: "swift_org_tutorial",
            bundle_id: "dev.rswift.WhyNotTry",
            executable: "WhyNotTry",
            display_name: "Why not try…",
            launch_args: &[],
        });
    }
    // `--render` draws one frame to a PNG instead of opening a window, so the
    // result can be looked at without a display.
    if std::env::args().any(|a| a == "--render") {
        let out = concat!(env!("CARGO_MANIFEST_DIR"), "/../../target/tutorial.png");
        let frame = swiftui_native::render::render(&content_view(), 420, 640);
        frame.write_png(out);
        eprintln!("wrote {out} ({} colours)", frame.distinct());
        return;
    }
    // `WindowGroup { ContentView() }` — the same tree the tutorial's `App` hosts.
    show_window(&content_view(), "Why not try…", 420.0, 640.0);
}

examples/dynamic_ui.rs (line 242)

fn repl() {
    use std::io::{BufRead, Write};
    eprintln!("Type a screen. Blank line renders it; Ctrl-D quits.");
    eprintln!("Names: {}", spec::NAMES.join(" "));
    let stdin = std::io::stdin();
    let mut buf = String::new();
    let mut n = 0usize;
    loop {
        eprint!("> ");
        let _ = std::io::stderr().flush();
        let mut line = String::new();
        match stdin.lock().read_line(&mut line) {
            Ok(0) => break,
            Ok(_) => {}
            Err(e) => {
                eprintln!("{e}");
                break;
            }
        }
        if line.trim().is_empty() {
            if buf.trim().is_empty() {
                continue;
            }
            match spec::parse(&buf).and_then(|nodes| spec::build(&nodes)) {
                Ok(v) => {
                    n += 1;
                    let out = format!(
                        "{}/../../target/dynamic_ui_repl_{n}.png",
                        env!("CARGO_MANIFEST_DIR")
                    );
                    let handle = v.into_handle();
                    eprintln!("  {}", swiftui_native::diag::type_name(
                        swiftui_native::views::meta_of(&handle)
                    ));
                    if swiftui_native::render::render(&handle, 420, 420).write_png(&out) {
                        eprintln!("  wrote {out}");
                    }
                }
                Err(e) => eprintln!("  {e}"),
            }
            buf.clear();
        } else {
            buf.push_str(&line);
        }
    }
}

/// Print the Swift type a spec builds.
///
/// The strongest short proof that this is real SwiftUI and not a lookalike: the
/// name comes from the Swift runtime's own metadata, and it is a different name
/// for every different spec.
fn print_type(arg: &str) -> i32 {
    match load(arg).and_then(|s| {
        spec::parse(&s).and_then(|nodes| spec::build(&nodes)).map(|v| v.into_handle())
    }) {
        Ok(h) => {
            println!(
                "{}",
                swiftui_native::diag::type_name(swiftui_native::views::meta_of(&h))
            );
            0
        }
        Err(e) => {
            eprintln!("{e}");
            1
        }
    }
}

#[cfg(target_os = "macos")]
fn main() {
    let args: Vec<String> = std::env::args().skip(1).collect();
    let flag = |f: &str| args.iter().any(|a| a == f);

    if flag("--names") {
        println!("{}", spec::NAMES.join("\n"));
        return;
    }
    if flag("--repl") {
        return repl();
    }
    if let Some(i) = args.iter().position(|a| a == "--type") {
        let Some(arg) = args.get(i + 1) else {
            eprintln!("--type wants a spec: a path, `-`, or a demo name");
            std::process::exit(2);
        };
        std::process::exit(print_type(arg));
    }
    if flag("--render") {
        // One PNG per built-in spec. Different text, different Swift type,
        // different picture — from one binary, in one process.
        for (name, src) in DEMOS {
            set_spec(src);
            // The spec's own view, for the type name: `content_view` wraps it
            // in the runtime-synthesised `RustView` that carries `@State`, and
            // that wrapper is the same whatever the spec says. What differs —
            // and what makes the point — is the type underneath it.
            let built = body().into_handle();
            let out = format!("{}/../../target/dynamic_ui_{name}.png", env!("CARGO_MANIFEST_DIR"));
            let ok = swiftui_native::render::render(&content_view(), 380, 420).write_png(&out);
            println!(
                "{name:10} {}\n           {}",
                swiftui_native::diag::type_name(swiftui_native::views::meta_of(&built)),
                if ok { out } else { "render failed".to_string() }
            );
        }
        return;
    }
    if flag("--sim") {
        return simulator::main(&simulator::Bundle {
            example: "dynamic_ui",
            bundle_id: "dev.rswift.DynamicUI",
            executable: "DynamicUI",
            display_name: "Dynamic UI",
            launch_args: &[],
        });
    }

    // A path or a demo name, else the first demo.
    if let Some(arg) = args.iter().find(|a| !a.starts_with("--")) {
        match load(arg) {
            Ok(s) => set_spec(&s),
            Err(e) => {
                eprintln!("{e}");
                std::process::exit(1);
            }
        }
    }
    show_window(&content_view(), "Dynamic UI", 380.0, 460.0);
}

Additional examples can be found in:

• examples/hot_reload.rs