use std::collections::HashMap;
use std::sync::Arc;
use std::time::Instant;
use uzor::RenderBackend;
use uzor_render_hub::{RenderHub, WindowRenderState};
use winit::application::ApplicationHandler;
use winit::event::{DeviceEvent, DeviceId, WindowEvent};
use winit::event_loop::{ActiveEventLoop, ControlFlow, EventLoop};
use winit::window::WindowId as WinitWindowId;
use super::clipboard::NativeClipboard;
use super::executor::{self, ExecutorFollowUp};
use super::paint::paint_frame;
use super::screenshot::{capture_screenshot, encode_png};
use super::single_instance::{self, SingleInstanceGuard};
use super::tray::{TrayBuilder, TrayEvent, TrayHandle, TraySpec};
use super::window::NativeWindow;
use super::window_create::{build_hub, create_window, geometry_echo};
use crate::runtime::{Runtime, RuntimeConfig};
use crate::types::bus::{
HostCaps, HostEvent, InputEnvelope, InputEvent, PointerInput, RenderInfo, WindowInput,
};
use crate::types::error::FrameworkError;
use crate::types::frame::Wake;
use crate::types::ids::{Seconds, WindowId};
use crate::types::window::{RenderCmd, WindowCommand, WindowSpec};
use crate::{App, Spec, Waker};
#[derive(Debug, Clone, Copy)]
pub enum HostWake {
Wake,
#[cfg(feature = "automation")]
Automation,
}
pub struct NativeHost<S: Spec, A: App<Spec = S>> {
runtime: Runtime<S, A>,
windows: HashMap<WinitWindowId, NativeWindow>,
by_id: HashMap<WindowId, WinitWindowId>,
hub: RenderHub,
clipboard: NativeClipboard,
tray: Option<TrayHandle>,
tray_spec: Option<TraySpec>,
pending: Vec<(WindowId, WindowSpec)>,
start: Instant,
exit: bool,
raw_delta: bool,
#[cfg(feature = "automation")]
auto: AutoState,
}
#[cfg(feature = "automation")]
#[derive(Default)]
struct AutoState {
port: Option<crate::automation::AutomationPort>,
after_paint: Vec<(crate::automation::AutoReplyTx, WindowId)>,
queries: Vec<crate::automation::AutoJob>,
waits: crate::automation::FrameWaits,
background: HashMap<WindowId, u32>,
}
impl<S: Spec, A: App<Spec = S>> NativeHost<S, A> {
fn now(&self) -> Seconds {
Seconds(self.start.elapsed().as_secs_f64())
}
fn caps() -> HostCaps {
HostCaps {
multi_window: true,
#[cfg(target_os = "windows")]
os_resize_bezel: true,
#[cfg(not(target_os = "windows"))]
os_resize_bezel: false,
clipboard_async: false,
}
}
fn push(&mut self, window: WindowId, event: InputEvent) {
#[cfg(feature = "automation")]
if let Some(port) = &self.auto.port {
crate::automation::tap_input(port, &self.runtime, window, &event);
}
self.runtime.push_input(InputEnvelope {
window,
t: self.now(),
event,
});
}
fn execute_all(&mut self, el: &ActiveEventLoop, cmds: Vec<(WindowId, WindowCommand)>) {
for (id, cmd) in cmds {
self.execute_one(el, id, cmd);
}
}
fn execute_one(&mut self, el: &ActiveEventLoop, id: WindowId, cmd: WindowCommand) {
match &cmd {
WindowCommand::Spawn(spec) => {
let spec = spec.clone();
match create_window(el, &self.hub, id, spec) {
Ok(nw) => {
let (size, dpr, position) = geometry_echo(&nw.window);
let wid = nw.winit_id();
self.windows.insert(wid, nw);
self.by_id.insert(id, wid);
self.push(
id,
InputEvent::Window(WindowInput::Created {
size,
dpr,
position,
caps: Self::caps(),
}),
);
if self.tray.is_none() {
if let Some(spec) = self.tray_spec.take() {
match TrayBuilder::from_spec(spec).build() {
Ok(t) => self.tray = Some(t),
Err(e) => log::warn!("tray build failed: {e}"),
}
}
}
}
Err(e) => {
log::warn!("spawn window {id:?} failed: {e}");
eprintln!("[uzor] spawn window {id:?} failed: {e}");
}
}
return;
}
WindowCommand::ExitApp => {
self.exit = true;
el.exit();
return;
}
_ => {}
}
let Some(&wid) = self.by_id.get(&id) else {
log::warn!("execute: unknown window {id:?}");
return;
};
let follow = {
let Some(nw) = self.windows.get_mut(&wid) else {
return;
};
let mut os = nw.as_os();
executor::execute(&mut os, cmd)
};
let Some(follow) = follow else {
return;
};
match follow {
ExecutorFollowUp::ClipboardWrite(text) => self.clipboard.write(&text),
ExecutorFollowUp::ClipboardWriteImage(img) => self.clipboard.write_image(&img),
ExecutorFollowUp::ClipboardRead(ticket) => {
let result = self.clipboard.read(ticket);
let image = if result.text.is_none() { self.clipboard.read_image() } else { None };
self.push(id, InputEvent::Clipboard(result));
if let Some(img) = image {
self.push(id, InputEvent::ClipboardImage(img));
}
}
ExecutorFollowUp::Screenshot(ticket) => self.take_screenshot(id, ticket),
ExecutorFollowUp::Spawn(spec) => {
let _ = spec;
}
ExecutorFollowUp::Close => {
if let Some(wid) = self.by_id.remove(&id) {
self.windows.remove(&wid);
self.push(id, InputEvent::Window(WindowInput::Destroyed));
}
if self.windows.is_empty() {
self.exit = true;
el.exit();
}
}
ExecutorFollowUp::ExitApp => {
self.exit = true;
el.exit();
}
ExecutorFollowUp::Render(cmd) => self.apply_render(cmd),
ExecutorFollowUp::OuterRectEcho { position, size } => {
self.push(
id,
InputEvent::Window(WindowInput::OuterRect { position, size }),
);
}
}
}
fn apply_render(&mut self, cmd: RenderCmd) {
match cmd {
RenderCmd::SetBackend(b) => {
if let Err(e) = self.hub.set_active(b) {
log::warn!("set_backend failed: {e}");
}
}
RenderCmd::SetFpsLimit(fps) => self.hub.set_fps_limit(fps),
RenderCmd::SetMsaa(n) => self.hub.set_msaa(n),
RenderCmd::SetVsync(on) => self.hub.set_vsync(on),
}
}
fn take_screenshot(&mut self, id: WindowId, ticket: crate::types::ids::Ticket) {
let Some(&wid) = self.by_id.get(&id) else {
return;
};
let Some(nw) = self.windows.get_mut(&wid) else {
return;
};
let Some((device, queue, surface)) = nw.render_state.gpu_handles() else {
log::warn!("screenshot: no GPU surface for {id:?}");
return;
};
let Some((pixels, w, h)) = capture_screenshot(device, queue, surface, None) else {
return;
};
let Some(png) = encode_png(&pixels, w, h) else {
return;
};
self.push(
id,
InputEvent::Host(HostEvent::Screenshot {
ticket,
png: Arc::<[u8]>::from(png),
}),
);
}
#[cfg(feature = "automation")]
fn automation_intake(&mut self) {
use crate::automation::{resolve_window, AutoCmd, AutoError, AutoReply};
let Some(port) = self.auto.port.clone() else {
return;
};
for (cmd, reply) in port.drain() {
match cmd {
AutoCmd::Input { win, events } => match resolve_window(&self.runtime, win) {
Some(w) => {
for ev in events {
self.push(w, ev);
}
self.auto.after_paint.push((reply, w));
}
None => {
let _ = reply.send(AutoReply::Error(AutoError::NoWindow));
}
},
other => {
if let Some(job) = self.auto.waits.take(other, reply) {
self.auto.queries.push(job);
}
}
}
}
}
#[cfg(feature = "automation")]
fn automation_answer(&mut self) -> bool {
use crate::automation::{answer_plain, resolve_window, AutoCmd, AutoError, AutoReply, ShotSource};
let frame = self.auto.waits.frames;
for (reply, window) in std::mem::take(&mut self.auto.after_paint) {
let _ = reply.send(AutoReply::InputDone { window, frame });
}
let dprs: HashMap<WindowId, f64> = self
.by_id
.iter()
.filter_map(|(id, wid)| self.windows.get(wid).map(|nw| (*id, nw.window.scale_factor())))
.collect();
let backgrounds = self.auto.background.clone();
let dpr_of = |w: WindowId| dprs.get(&w).copied().unwrap_or(1.0);
let bg_of = |w: WindowId| backgrounds.get(&w).copied().unwrap_or(0xffffffff);
for (cmd, reply) in std::mem::take(&mut self.auto.queries) {
let answer = match cmd {
AutoCmd::Screenshot { win, source } if source != ShotSource::Offscreen => {
match resolve_window(&self.runtime, win) {
None => AutoReply::Error(AutoError::NoWindow),
Some(w) => match (self.window_readback(w), source) {
(Some(shot), _) => AutoReply::Shot(shot),
(None, ShotSource::Window) => {
AutoReply::Error(AutoError::Unsupported("window readback on this surface"))
}
(None, _) => {
let c = AutoCmd::Screenshot { win: Some(w), source: ShotSource::Offscreen };
answer_plain(&mut self.runtime, &c, &dpr_of, &bg_of)
.unwrap_or(AutoReply::Error(AutoError::Unsupported("screenshot")))
}
},
}
}
other => answer_plain(&mut self.runtime, &other, &dpr_of, &bg_of)
.unwrap_or(AutoReply::Error(AutoError::Unsupported("command"))),
};
let _ = reply.send(answer);
}
false
}
#[cfg(feature = "automation")]
fn window_readback(&mut self, id: WindowId) -> Option<crate::automation::AutoShot> {
let wid = *self.by_id.get(&id)?;
let nw = self.windows.get_mut(&wid)?;
let (pixels, w, h) = if let Some((device, queue, surface)) = nw.render_state.gpu_handles() {
capture_screenshot(device, queue, surface, None)?
} else {
nw.render_state.software_readback()?
};
let png = encode_png(&pixels, w, h)?;
Some(crate::automation::AutoShot { window: id, png, width: w, height: h, source: "window" })
}
fn drain_tray(&mut self) {
let mut events = Vec::new();
if let Some(tray) = self.tray.as_ref() {
while let Some(ev) = tray.next_event() {
events.push(ev);
}
}
for ev in events {
if let TrayEvent::MenuClick(id) = ev {
if let Some((&win, _)) = self.by_id.iter().next() {
self.push(win, InputEvent::Host(HostEvent::Tray { id }));
}
}
}
}
fn paint_due(&mut self, frames: Vec<crate::types::frame::FrameRequest>) {
for req in frames {
let Some(&wid) = self.by_id.get(&req.window) else {
continue;
};
let Some(mut nw) = self.windows.remove(&wid) else {
continue;
};
let mut req = req;
if nw.transparent {
req.background = 0;
}
#[cfg(feature = "automation")]
{
self.auto.waits.painted();
self.auto.background.insert(req.window, req.background);
}
if let Err(e) = paint_frame(&mut self.runtime, &mut self.hub, &mut nw.render_state, &req)
{
log::warn!("paint failed: {e}");
}
flush_x11(&nw.window);
if std::env::var_os("UZOR_TRACE_PAINT").is_some() {
eprintln!("[paint] {:?} t={:.3}", req.window, self.now().get());
}
let m = *self.hub.metrics();
let info = RenderInfo {
backend: Some(self.hub.active()),
available: self.hub.available_backends(),
fps_ema: 0.0,
frame_ms: m.submit_us as f64 / 1000.0,
frame_count: 0,
};
self.windows.insert(wid, nw);
self.push(req.window, InputEvent::Host(HostEvent::RenderInfo(info)));
}
}
}
impl<S: Spec, A: App<Spec = S>> ApplicationHandler<HostWake> for NativeHost<S, A> {
fn resumed(&mut self, el: &ActiveEventLoop) {
let pending = std::mem::take(&mut self.pending);
for (id, spec) in pending {
self.execute_one(el, id, WindowCommand::Spawn(spec));
}
}
fn window_event(&mut self, el: &ActiveEventLoop, id: WinitWindowId, ev: WindowEvent) {
let Some(nw) = self.windows.get_mut(&id) else {
return;
};
let framework_id = nw.id;
if let WindowEvent::ScaleFactorChanged { scale_factor, .. } = &ev {
let _ = nw.mapper.map(&ev);
let (size, _, _) = geometry_echo(&nw.window);
self.push(
framework_id,
InputEvent::Window(WindowInput::Resized {
size,
dpr: *scale_factor,
}),
);
return;
}
if let WindowEvent::Resized(size) = &ev {
resize_render_surface(&mut nw.render_state, size.width, size.height);
nw.window.request_redraw();
let maximized = nw.window.is_maximized();
if nw.maximized != Some(maximized) {
nw.maximized = Some(maximized);
self.push(framework_id, InputEvent::Window(WindowInput::Maximized(maximized)));
}
let Some(nw) = self.windows.get_mut(&id) else {
return;
};
let events = nw.mapper.map(&ev);
for e in events {
self.push(framework_id, e);
}
return;
}
if matches!(ev, WindowEvent::RedrawRequested) {
el.set_control_flow(ControlFlow::Poll);
return;
}
match &ev {
WindowEvent::HoveredFile(_) | WindowEvent::DroppedFile(_) => {
if let Some(p) = query_pointer(&nw.window) {
nw.dnd_hover = matches!(ev, WindowEvent::HoveredFile(_)).then_some(p);
let pos = crate::Point::new(p.0, p.1);
self.push(framework_id, InputEvent::Pointer(PointerInput::Moved { pos, mods: Default::default() }));
} else {
nw.dnd_hover = None;
}
}
WindowEvent::HoveredFileCancelled => nw.dnd_hover = None,
_ => {}
}
let Some(nw) = self.windows.get_mut(&id) else {
return;
};
let events = nw.mapper.map(&ev);
for e in events {
self.push(framework_id, e);
}
}
fn device_event(&mut self, _el: &ActiveEventLoop, _id: DeviceId, event: DeviceEvent) {
if !self.raw_delta {
return;
}
if let DeviceEvent::MouseMotion { delta } = event {
if let Some((&win, _)) = self.by_id.iter().next() {
self.push(
win,
InputEvent::Pointer(PointerInput::RawDelta {
dx: delta.0,
dy: delta.1,
}),
);
}
}
}
fn user_event(&mut self, _el: &ActiveEventLoop, _event: HostWake) {
}
fn about_to_wait(&mut self, el: &ActiveEventLoop) {
self.drain_tray();
#[cfg(feature = "automation")]
self.automation_intake();
let (moved, dnd) = dnd_moves(self.windows.values_mut());
for (id, p) in moved {
self.push(id, InputEvent::Pointer(PointerInput::Moved { pos: crate::Point::new(p.0, p.1), mods: Default::default() }));
}
let out = self.runtime.tick(self.now());
let mut reveal = Vec::new();
for (wid, nw) in &mut self.windows {
if nw.defer_show {
nw.defer_show = false;
reveal.push(*wid);
}
}
self.execute_all(el, out.window_commands);
for wid in reveal {
if let Some(nw) = self.windows.get(&wid) {
nw.window.set_visible(true);
}
}
if std::env::var_os("UZOR_TRACE_PAINT").is_some() {
eprintln!("[tick] frames {} wake {:?}", out.frames.len(), out.wake);
}
self.paint_due(out.frames);
#[cfg(feature = "automation")]
let auto_busy = self.automation_answer();
#[cfg(not(feature = "automation"))]
let auto_busy = false;
if self.exit || self.runtime.should_exit() {
el.exit();
return;
}
let wake = if self.runtime.take_paint_wants_tick() || auto_busy { Wake::Immediate } else { out.wake };
el.set_control_flow(match wake {
Wake::Idle => ControlFlow::Wait,
Wake::Immediate => ControlFlow::Poll,
Wake::At(t) => {
let now = self.now().get();
let target = t.get();
if target <= now {
ControlFlow::Poll
} else {
let dur = std::time::Duration::from_secs_f64(target - now);
ControlFlow::WaitUntil(Instant::now() + dur)
}
}
});
if dnd && !matches!(wake, Wake::Immediate) {
el.set_control_flow(ControlFlow::WaitUntil(Instant::now() + std::time::Duration::from_millis(40)));
}
}
}
fn dnd_moves<'a>(windows: impl Iterator<Item = &'a mut super::window::NativeWindow>) -> (Vec<(crate::WindowId, (f64, f64))>, bool) {
let mut moved = Vec::new();
let mut any = false;
for nw in windows {
let Some(last) = nw.dnd_hover else { continue };
any = true;
if let Some(p) = query_pointer(&nw.window) {
if p != last {
nw.dnd_hover = Some(p);
moved.push((nw.id, p));
}
}
}
(moved, any)
}
#[cfg(all(unix, not(any(target_os = "macos", target_os = "ios", target_os = "android"))))]
fn query_pointer(window: &winit::window::Window) -> Option<(f64, f64)> {
use std::sync::OnceLock;
use winit::raw_window_handle::{HasDisplayHandle, HasWindowHandle, RawDisplayHandle, RawWindowHandle};
static XLIB: OnceLock<Option<x11_dl::xlib::Xlib>> = OnceLock::new();
let xlib = XLIB.get_or_init(|| x11_dl::xlib::Xlib::open().ok()).as_ref()?;
let RawDisplayHandle::Xlib(dh) = window.display_handle().ok()?.as_raw() else { return None };
let d = dh.display?.as_ptr().cast();
let win = match window.window_handle().ok()?.as_raw() {
RawWindowHandle::Xlib(w) => w.window,
RawWindowHandle::Xcb(w) => w.window.get() as _,
_ => return None,
};
let (mut root, mut child) = (0, 0);
let (mut rx, mut ry, mut wx, mut wy, mut mask) = (0, 0, 0, 0, 0);
let ok = unsafe { (xlib.XQueryPointer)(d, win, &mut root, &mut child, &mut rx, &mut ry, &mut wx, &mut wy, &mut mask) };
if ok == 0 {
return None;
}
let k = window.scale_factor();
Some((wx as f64 / k, wy as f64 / k))
}
#[cfg(not(all(unix, not(any(target_os = "macos", target_os = "ios", target_os = "android")))))]
fn query_pointer(_window: &winit::window::Window) -> Option<(f64, f64)> {
None
}
#[derive(Clone, Copy, Debug, Default)]
pub struct RenderPreference {
pub backend: Option<RenderBackend>,
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct DevControlConfig {
pub app_dir: String,
pub app: String,
pub headless: bool,
}
impl DevControlConfig {
pub fn new(app_dir: &str, app: &str) -> Self {
Self { app_dir: app_dir.to_string(), app: app.to_string(), headless: false }
}
pub fn from_args_env(app_dir: &str, app: &str, env_var: &str) -> Option<Self> {
Self::from_parts(app_dir, app, std::env::args().skip(1), std::env::var(env_var).ok())
}
fn from_parts(app_dir: &str, app: &str, args: impl Iterator<Item = String>, env: Option<String>) -> Option<Self> {
let (mut dev, mut headless) = (false, false);
for a in args {
match a.as_str() {
"--dev" => dev = true,
"--headless" => headless = true,
_ => {}
}
}
let env = env.unwrap_or_default();
headless |= env == "headless";
dev |= !env.is_empty() && env != "0";
(dev || headless).then(|| Self { headless, ..Self::new(app_dir, app) })
}
}
#[derive(Clone, Debug, Default)]
pub struct NativeOptions {
pub single_instance: Option<String>,
pub tray: Option<TraySpec>,
pub render: RenderPreference,
#[cfg(feature = "automation")]
pub automation: Option<crate::automation::AutomationPort>,
pub dev_control: Option<DevControlConfig>,
#[cfg(target_os = "android")]
pub android_app: Option<winit::platform::android::activity::AndroidApp>,
}
pub fn run_native<S, A>(
app: A,
cfg: RuntimeConfig,
native: NativeOptions,
) -> Result<(), FrameworkError>
where
S: Spec,
A: App<Spec = S>,
{
let _guard: Option<SingleInstanceGuard> = native
.single_instance
.as_deref()
.map(single_instance::single_instance);
#[cfg(feature = "dev-control")]
let mut native = native;
#[cfg(feature = "dev-control")]
let _dev = native.dev_control.clone().and_then(|c| {
let (client, port) = crate::automation::channel();
match crate::dev_control::start(&c.app_dir, &c.app, client) {
Ok(d) => {
eprintln!("{}: dev control on 127.0.0.1:{} (discovery file {})", c.app, d.port(), d.discovery_path().display());
native.automation = Some(port);
Some(d)
}
Err(e) => {
eprintln!("{}: dev control did not start: {e}", c.app);
None
}
}
});
#[cfg(not(feature = "dev-control"))]
if let Some(c) = native.dev_control.as_ref() {
if c.headless {
return Err(FrameworkError::Host(format!("{}: --headless needs a build with dev control", c.app)));
}
eprintln!("{}: this build cannot be driven remotely; ignored", c.app);
}
#[cfg(feature = "dev-control")]
if let Some(c) = native.dev_control.as_ref().filter(|c| c.headless) {
let Some(port) = native.automation.clone().filter(|_| _dev.is_some()) else {
return Err(FrameworkError::Host(format!("{}: headless without dev control is unreachable; not starting", c.app)));
};
eprintln!("{}: headless (no window, offscreen screenshots)", c.app);
crate::host::run_headless(app, cfg, 1.0, port);
return Ok(());
}
#[cfg_attr(not(target_os = "android"), allow(unused_mut))]
let mut builder = EventLoop::<HostWake>::with_user_event();
#[cfg(target_os = "android")]
{
use winit::platform::android::EventLoopBuilderExtAndroid;
let Some(app) = native.android_app.clone() else {
return Err(FrameworkError::Host("android: NativeOptions::android_app is not set".into()));
};
builder.with_android_app(app);
}
let event_loop = builder
.build()
.map_err(|e| FrameworkError::Host(format!("event loop: {e}")))?;
let proxy = event_loop.create_proxy();
#[cfg(feature = "automation")]
if let Some(port) = native.automation.as_ref() {
let proxy = proxy.clone();
port.set_waker(move || {
let _ = proxy.send_event(HostWake::Automation);
});
}
let waker = Waker::new(move || {
let _ = proxy.send_event(HostWake::Wake);
});
let (runtime, _handle) = Runtime::new(app, cfg, waker);
let hub = build_hub(native.render.backend);
let mut host = NativeHost {
runtime,
windows: HashMap::new(),
by_id: HashMap::new(),
hub,
clipboard: NativeClipboard::new(),
tray: None,
tray_spec: native.tray,
pending: Vec::new(),
start: Instant::now(),
exit: false,
raw_delta: false,
#[cfg(feature = "automation")]
auto: AutoState { port: native.automation.clone(), ..Default::default() },
};
let out = host.runtime.tick(host.now());
for (id, cmd) in out.window_commands {
if let WindowCommand::Spawn(spec) = cmd {
host.pending.push((id, spec));
}
}
event_loop
.run_app(&mut host)
.map_err(|e| FrameworkError::Host(format!("event loop run: {e}")))?;
Ok(())
}
pub fn run_native_default<S, A>(app: A, cfg: RuntimeConfig) -> Result<(), FrameworkError>
where
S: Spec,
A: App<Spec = S>,
{
run_native(app, cfg, NativeOptions::default())
}
pub(crate) fn resize_render_surface(rs: &mut WindowRenderState, width: u32, height: u32) {
if width == 0 || height == 0 {
return;
}
rs.resize_surface(width, height);
}
#[cfg(all(unix, not(any(target_os = "macos", target_os = "ios", target_os = "android"))))]
fn flush_x11(window: &winit::window::Window) {
use std::sync::OnceLock;
use winit::raw_window_handle::{HasDisplayHandle, RawDisplayHandle};
static XLIB: OnceLock<Option<x11_dl::xlib::Xlib>> = OnceLock::new();
let Ok(h) = window.display_handle() else { return };
if let RawDisplayHandle::Xlib(x) = h.as_raw() {
if let (Some(d), Some(xlib)) = (x.display, XLIB.get_or_init(|| x11_dl::xlib::Xlib::open().ok())) {
unsafe { (xlib.XFlush)(d.as_ptr().cast()) };
}
}
}
#[cfg(not(all(unix, not(any(target_os = "macos", target_os = "ios", target_os = "android")))))]
fn flush_x11(_window: &winit::window::Window) {}
#[cfg(test)]
mod dev_config_tests {
use super::DevControlConfig;
fn parse(args: &[&str], env: Option<&str>) -> Option<DevControlConfig> {
DevControlConfig::from_parts("d", "a", args.iter().map(|s| s.to_string()), env.map(str::to_string))
}
#[test]
fn flags_and_env() {
assert_eq!(parse(&[], None), None);
assert_eq!(parse(&[], Some("0")), None);
assert!(!parse(&["--dev"], None).unwrap().headless);
assert!(parse(&["--dev", "--headless"], None).unwrap().headless);
assert!(parse(&["--headless"], None).unwrap().headless);
assert!(parse(&[], Some("headless")).unwrap().headless);
assert!(!parse(&[], Some("1")).unwrap().headless);
}
}