Struct App 

pub struct App { /* private fields */ }

Running retained-UI terminal host.

Implementations

impl App

pub const fn ui(&self) -> &Ui

Borrows the retained UI.

Examples found in repository

examples/gallery/main.rs (line 134)

async fn main() -> io::Result<()> {
	let mut app = AppOptions::new()
		.mouse()
		.quit([Key::Ctrl('c'), Key::Ctrl('q')])
		.start(|env| build_ui(env.viewport, env.ctx))
		.await?;
	// The picker tab opens with the first model's details, like the chat
	// overlay does.
	picker::show_detail_on(app.ui_mut(), Some(0));

	let mut synced = String::new();
	let mut lab = anim::Lab::new();
	let mut layers = Layers::default();
	let mut next_step = tokio::time::Instant::now() + anim::AUTOPLAY_STEP;

	loop {
		let event = tokio::select! {
			event = app.next() => match event? {
				Some(event) => event,
				None => break,
			},
			() = tokio::time::sleep_until(next_step) => {
				if lab.autoplay && active_tab(app.ui()) == "Anim" {
					lab.advance(app.ui_mut());
				}
				next_step += anim::AUTOPLAY_STEP;
				continue;
			},
		};
		match event {
			AppEvent::Resized(viewport) => {
				for pane in render::PANE_IDS {
					app.ui_mut().set_height(pane, render::pane_height(viewport));
				}
			},
			AppEvent::Key(key) => match active_tab(app.ui()).as_str() {
				"Anim" => lab.handle_key(key, app.ui_mut()),
				"Overlay" => match key {
					Key::Ctrl('k') if layers.picker.is_none() => {
						layers.picker = Some(overlay::show_picker(app.ui_mut()));
					},
					Key::Ctrl('g') => match layers.help.take() {
						Some(id) => {
							app.ui_mut().close_overlay(id);
						},
						None => layers.help = Some(overlay::show_help(app.ui_mut())),
					},
					_ => {},
				},
				_ => {},
			},
			// The Overlay tab's modal select committed a model.
			AppEvent::Changed { id, value } if id == "model" => {
				if let Some(overlay) = layers.picker.take() {
					let label = overlay::MODELS
						.iter()
						.find(|(short, ..)| *short == value)
						.map_or(value.as_str(), |(_, label, _)| label);
					app.ui_mut().set_text("status", format!("model: {label}"));
					app.ui_mut().close_overlay(overlay);
				}
			},
			// The Picker tab's select moved: mirror the chat picker's
			// facts-and-chips detail line.
			AppEvent::Highlighted { id, value } if id == "models" => {
				picker::show_detail_on(app.ui_mut(), value.as_str().parse().ok());
			},
			AppEvent::Filtered { id, value, .. } if id == "models" => {
				let model = value.and_then(|value| value.as_str().parse().ok());
				picker::show_detail_on(app.ui_mut(), model);
			},
			AppEvent::OverlayClosed(id) => {
				if layers.picker == Some(id) {
					layers.picker = None;
				}
				if layers.help == Some(id) {
					layers.help = None;
				}
			},
			_ => {},
		}
		render::sync_preview(app.ui_mut(), &mut synced);
		// Reserve the Overlay tab's chords only while it is showing, so the
		// focused composer can't spend Ctrl+K on kill-line — and the Live
		// tab's editor keeps it.
		let chords: &[Key] = if active_tab(app.ui()) == "Overlay" {
			&[Key::Ctrl('k'), Key::Ctrl('g')]
		} else {
			&[]
		};
		app.set_hotkeys(chords.iter().copied());
	}
	Ok(())
}

pub const fn ui_mut(&mut self) -> &mut Ui

Mutably borrows the retained UI between host events.

Examples found in repository

examples/companies.rs (line 164)

fn show_stats(app: &mut App, chosen: Option<&str>) {
	let caps = app.caps();
	let stats = app.last_stats();
	let pixels = caps.cell_px.map_or_else(
		|| "cell-px ?".to_owned(),
		|(width, height)| format!("cell-px {width}×{height}"),
	);
	let login = chosen.map_or(String::new(), |id| format!("login: {id} · "));
	app.ui_mut().set_text(
		HUD_ID,
		format!(
			"{login}{} · {} · {} · repaint: {} cells",
			graphics_label(caps.graphics),
			caps.id,
			pixels,
			stats.changed_cells,
		),
	);
}

fn forced_from_args(caps: &TerminalCaps) -> Option<Graphics> {
	let mut forced = None;
	for argument in std::env::args().skip(1) {
		forced = match argument.as_str() {
			"--cells" => Some(Graphics::Cells),
			"--kitty" if caps.kitty_placeholders => Some(Graphics::KittyPlaceholders),
			"--kitty" => Some(Graphics::KittyDirect),
			"--kitty-placeholders" => Some(Graphics::KittyPlaceholders),
			"--sixel" => Some(Graphics::Sixel),
			_ => forced,
		};
	}
	forced
}

#[tokio::main]
async fn main() -> io::Result<()> {
	let mut app = AppOptions::new()
		.mouse()
		.probe(Duration::from_millis(150))
		.graphics_with(forced_from_args)
		.start(|env| build_ui(env.viewport, env.ctx))
		.await?;
	if app.caps().graphics != Graphics::Cells {
		for (index, provider) in PROVIDERS.iter().enumerate() {
			let png = tokio::fs::read(format!("{ASSET_DIR}/{}.png", provider.id)).await?;
			app.renderer_mut().register_image(
				u32::try_from(index + 1).expect("provider count fits image IDs"),
				png,
			)?;
		}
		app.ui_mut().invalidate(SCROLL_ID);
	}
	show_stats(&mut app, None);
	let mut chosen: Option<String> = None;
	while let Some(event) = app.next().await? {
		match event {
			AppEvent::Resized(viewport) => {
				app.ui_mut().set_height(SCROLL_ID, scroll_height(viewport));
			},
			AppEvent::Pressed(id) => chosen = Some(id.to_string()),
			_ => {},
		}
		show_stats(&mut app, chosen.as_deref());
	}
	Ok(())
}

examples/gallery/main.rs (line 120)

async fn main() -> io::Result<()> {
	let mut app = AppOptions::new()
		.mouse()
		.quit([Key::Ctrl('c'), Key::Ctrl('q')])
		.start(|env| build_ui(env.viewport, env.ctx))
		.await?;
	// The picker tab opens with the first model's details, like the chat
	// overlay does.
	picker::show_detail_on(app.ui_mut(), Some(0));

	let mut synced = String::new();
	let mut lab = anim::Lab::new();
	let mut layers = Layers::default();
	let mut next_step = tokio::time::Instant::now() + anim::AUTOPLAY_STEP;

	loop {
		let event = tokio::select! {
			event = app.next() => match event? {
				Some(event) => event,
				None => break,
			},
			() = tokio::time::sleep_until(next_step) => {
				if lab.autoplay && active_tab(app.ui()) == "Anim" {
					lab.advance(app.ui_mut());
				}
				next_step += anim::AUTOPLAY_STEP;
				continue;
			},
		};
		match event {
			AppEvent::Resized(viewport) => {
				for pane in render::PANE_IDS {
					app.ui_mut().set_height(pane, render::pane_height(viewport));
				}
			},
			AppEvent::Key(key) => match active_tab(app.ui()).as_str() {
				"Anim" => lab.handle_key(key, app.ui_mut()),
				"Overlay" => match key {
					Key::Ctrl('k') if layers.picker.is_none() => {
						layers.picker = Some(overlay::show_picker(app.ui_mut()));
					},
					Key::Ctrl('g') => match layers.help.take() {
						Some(id) => {
							app.ui_mut().close_overlay(id);
						},
						None => layers.help = Some(overlay::show_help(app.ui_mut())),
					},
					_ => {},
				},
				_ => {},
			},
			// The Overlay tab's modal select committed a model.
			AppEvent::Changed { id, value } if id == "model" => {
				if let Some(overlay) = layers.picker.take() {
					let label = overlay::MODELS
						.iter()
						.find(|(short, ..)| *short == value)
						.map_or(value.as_str(), |(_, label, _)| label);
					app.ui_mut().set_text("status", format!("model: {label}"));
					app.ui_mut().close_overlay(overlay);
				}
			},
			// The Picker tab's select moved: mirror the chat picker's
			// facts-and-chips detail line.
			AppEvent::Highlighted { id, value } if id == "models" => {
				picker::show_detail_on(app.ui_mut(), value.as_str().parse().ok());
			},
			AppEvent::Filtered { id, value, .. } if id == "models" => {
				let model = value.and_then(|value| value.as_str().parse().ok());
				picker::show_detail_on(app.ui_mut(), model);
			},
			AppEvent::OverlayClosed(id) => {
				if layers.picker == Some(id) {
					layers.picker = None;
				}
				if layers.help == Some(id) {
					layers.help = None;
				}
			},
			_ => {},
		}
		render::sync_preview(app.ui_mut(), &mut synced);
		// Reserve the Overlay tab's chords only while it is showing, so the
		// focused composer can't spend Ctrl+K on kill-line — and the Live
		// tab's editor keeps it.
		let chords: &[Key] = if active_tab(app.ui()) == "Overlay" {
			&[Key::Ctrl('k'), Key::Ctrl('g')]
		} else {
			&[]
		};
		app.set_hotkeys(chords.iter().copied());
	}
	Ok(())
}

pub fn set_hotkeys(&mut self, chords: impl IntoIterator<Item = Key>)

Replaces the reserved host chords, scoping AppOptions::hotkeys to the screen that is actually showing.

Examples found in repository

examples/gallery/main.rs (line 202)

async fn main() -> io::Result<()> {
	let mut app = AppOptions::new()
		.mouse()
		.quit([Key::Ctrl('c'), Key::Ctrl('q')])
		.start(|env| build_ui(env.viewport, env.ctx))
		.await?;
	// The picker tab opens with the first model's details, like the chat
	// overlay does.
	picker::show_detail_on(app.ui_mut(), Some(0));

	let mut synced = String::new();
	let mut lab = anim::Lab::new();
	let mut layers = Layers::default();
	let mut next_step = tokio::time::Instant::now() + anim::AUTOPLAY_STEP;

	loop {
		let event = tokio::select! {
			event = app.next() => match event? {
				Some(event) => event,
				None => break,
			},
			() = tokio::time::sleep_until(next_step) => {
				if lab.autoplay && active_tab(app.ui()) == "Anim" {
					lab.advance(app.ui_mut());
				}
				next_step += anim::AUTOPLAY_STEP;
				continue;
			},
		};
		match event {
			AppEvent::Resized(viewport) => {
				for pane in render::PANE_IDS {
					app.ui_mut().set_height(pane, render::pane_height(viewport));
				}
			},
			AppEvent::Key(key) => match active_tab(app.ui()).as_str() {
				"Anim" => lab.handle_key(key, app.ui_mut()),
				"Overlay" => match key {
					Key::Ctrl('k') if layers.picker.is_none() => {
						layers.picker = Some(overlay::show_picker(app.ui_mut()));
					},
					Key::Ctrl('g') => match layers.help.take() {
						Some(id) => {
							app.ui_mut().close_overlay(id);
						},
						None => layers.help = Some(overlay::show_help(app.ui_mut())),
					},
					_ => {},
				},
				_ => {},
			},
			// The Overlay tab's modal select committed a model.
			AppEvent::Changed { id, value } if id == "model" => {
				if let Some(overlay) = layers.picker.take() {
					let label = overlay::MODELS
						.iter()
						.find(|(short, ..)| *short == value)
						.map_or(value.as_str(), |(_, label, _)| label);
					app.ui_mut().set_text("status", format!("model: {label}"));
					app.ui_mut().close_overlay(overlay);
				}
			},
			// The Picker tab's select moved: mirror the chat picker's
			// facts-and-chips detail line.
			AppEvent::Highlighted { id, value } if id == "models" => {
				picker::show_detail_on(app.ui_mut(), value.as_str().parse().ok());
			},
			AppEvent::Filtered { id, value, .. } if id == "models" => {
				let model = value.and_then(|value| value.as_str().parse().ok());
				picker::show_detail_on(app.ui_mut(), model);
			},
			AppEvent::OverlayClosed(id) => {
				if layers.picker == Some(id) {
					layers.picker = None;
				}
				if layers.help == Some(id) {
					layers.help = None;
				}
			},
			_ => {},
		}
		render::sync_preview(app.ui_mut(), &mut synced);
		// Reserve the Overlay tab's chords only while it is showing, so the
		// focused composer can't spend Ctrl+K on kill-line — and the Live
		// tab's editor keeps it.
		let chords: &[Key] = if active_tab(app.ui()) == "Overlay" {
			&[Key::Ctrl('k'), Key::Ctrl('g')]
		} else {
			&[]
		};
		app.set_hotkeys(chords.iter().copied());
	}
	Ok(())
}

pub fn handle(&self) -> UiHandle

Creates a remote that can update or stop this host.

Examples found in repository

examples/tml.rs (line 59)

async fn main() -> io::Result<()> {
	let path = std::env::args()
		.nth(1)
		.unwrap_or_else(|| "example.tml".into());
	let source = std::fs::read_to_string(&path)?;

	let mut ctx = None;
	let mut app = AppOptions::new()
		.quit([Key::Ctrl('c'), Key::Char('q'), Key::Esc])
		.start(|env| {
			let ui = build(&source, env.viewport.width, &env.ctx);
			ctx = Some(env.ctx);
			ui
		})
		.await?;
	let ctx = ctx.expect("start ran the builder");

	let handle = app.handle();
	tokio::spawn(async move {
		let mut seen = modified(path.as_ref());
		loop {
			tokio::time::sleep(Duration::from_millis(150)).await;
			let stamp = modified(path.as_ref());
			if stamp == seen {
				continue;
			}
			seen = stamp;
			let Ok(source) = std::fs::read_to_string(&path) else {
				continue;
			};
			let ctx = ctx.clone();
			handle.update(move |ui| *ui = build(&source, ui.frame().size().width, &ctx));
		}
	});

	while app.next().await?.is_some() {}
	Ok(())
}

pub const fn renderer_mut(&mut self) -> &mut Renderer<TtyOut>

Mutably borrows the renderer for image registration and output policy.

Examples found in repository

examples/companies.rs (line 202)

async fn main() -> io::Result<()> {
	let mut app = AppOptions::new()
		.mouse()
		.probe(Duration::from_millis(150))
		.graphics_with(forced_from_args)
		.start(|env| build_ui(env.viewport, env.ctx))
		.await?;
	if app.caps().graphics != Graphics::Cells {
		for (index, provider) in PROVIDERS.iter().enumerate() {
			let png = tokio::fs::read(format!("{ASSET_DIR}/{}.png", provider.id)).await?;
			app.renderer_mut().register_image(
				u32::try_from(index + 1).expect("provider count fits image IDs"),
				png,
			)?;
		}
		app.ui_mut().invalidate(SCROLL_ID);
	}
	show_stats(&mut app, None);
	let mut chosen: Option<String> = None;
	while let Some(event) = app.next().await? {
		match event {
			AppEvent::Resized(viewport) => {
				app.ui_mut().set_height(SCROLL_ID, scroll_height(viewport));
			},
			AppEvent::Pressed(id) => chosen = Some(id.to_string()),
			_ => {},
		}
		show_stats(&mut app, chosen.as_deref());
	}
	Ok(())
}

pub const fn terminal_mut(&mut self) -> &mut Terminal

Mutably borrows the terminal for titles, progress, and appearance hooks.

pub const fn caps(&self) -> TerminalCaps

Returns the resolved terminal capabilities.

Examples found in repository

examples/companies.rs (line 157)

fn show_stats(app: &mut App, chosen: Option<&str>) {
	let caps = app.caps();
	let stats = app.last_stats();
	let pixels = caps.cell_px.map_or_else(
		|| "cell-px ?".to_owned(),
		|(width, height)| format!("cell-px {width}×{height}"),
	);
	let login = chosen.map_or(String::new(), |id| format!("login: {id} · "));
	app.ui_mut().set_text(
		HUD_ID,
		format!(
			"{login}{} · {} · {} · repaint: {} cells",
			graphics_label(caps.graphics),
			caps.id,
			pixels,
			stats.changed_cells,
		),
	);
}

fn forced_from_args(caps: &TerminalCaps) -> Option<Graphics> {
	let mut forced = None;
	for argument in std::env::args().skip(1) {
		forced = match argument.as_str() {
			"--cells" => Some(Graphics::Cells),
			"--kitty" if caps.kitty_placeholders => Some(Graphics::KittyPlaceholders),
			"--kitty" => Some(Graphics::KittyDirect),
			"--kitty-placeholders" => Some(Graphics::KittyPlaceholders),
			"--sixel" => Some(Graphics::Sixel),
			_ => forced,
		};
	}
	forced
}

#[tokio::main]
async fn main() -> io::Result<()> {
	let mut app = AppOptions::new()
		.mouse()
		.probe(Duration::from_millis(150))
		.graphics_with(forced_from_args)
		.start(|env| build_ui(env.viewport, env.ctx))
		.await?;
	if app.caps().graphics != Graphics::Cells {
		for (index, provider) in PROVIDERS.iter().enumerate() {
			let png = tokio::fs::read(format!("{ASSET_DIR}/{}.png", provider.id)).await?;
			app.renderer_mut().register_image(
				u32::try_from(index + 1).expect("provider count fits image IDs"),
				png,
			)?;
		}
		app.ui_mut().invalidate(SCROLL_ID);
	}
	show_stats(&mut app, None);
	let mut chosen: Option<String> = None;
	while let Some(event) = app.next().await? {
		match event {
			AppEvent::Resized(viewport) => {
				app.ui_mut().set_height(SCROLL_ID, scroll_height(viewport));
			},
			AppEvent::Pressed(id) => chosen = Some(id.to_string()),
			_ => {},
		}
		show_stats(&mut app, chosen.as_deref());
	}
	Ok(())
}

pub const fn viewport(&self) -> Size

Returns the latest settled terminal geometry.

pub const fn last_stats(&self) -> PaintStats

Returns statistics from the most recent present or rebuild.

Examples found in repository

examples/companies.rs (line 158)

fn show_stats(app: &mut App, chosen: Option<&str>) {
	let caps = app.caps();
	let stats = app.last_stats();
	let pixels = caps.cell_px.map_or_else(
		|| "cell-px ?".to_owned(),
		|(width, height)| format!("cell-px {width}×{height}"),
	);
	let login = chosen.map_or(String::new(), |id| format!("login: {id} · "));
	app.ui_mut().set_text(
		HUD_ID,
		format!(
			"{login}{} · {} · {} · repaint: {} cells",
			graphics_label(caps.graphics),
			caps.id,
			pixels,
			stats.changed_cells,
		),
	);
}

pub const fn set_stable_rows(&mut self, rows: u16)

Sets the immutable leading-row boundary used for presentation.

pub const fn hold_alt(&mut self, hold: bool)

Requests or releases a persistent alternate-screen hold.

Fullscreen scenes — a welcome screen, a pager — hold the alternate screen for their lifetime: frames paint there with mouse tracking active while the inline transcript stays untouched underneath. Every visible modal overlay holds it automatically; this covers scenes without one. Non-modal layers (crate::OverlayOptions::non_modal) never hold: they composite into the live inline viewport while the document keeps committing to native scrollback. Release restores the main screen, rebuilding history only when geometry changed while held. Takes effect on the next App::next call.

pub async fn next(&mut self) -> Result<Option<AppEvent>>

Flushes pending damage, waits for one host event, and routes it.

None means shutdown; subsequent calls continue returning None.

Errors

Propagates terminal input, geometry, and renderer failures.

Examples found in repository

examples/companies.rs (line 211)

async fn main() -> io::Result<()> {
	let mut app = AppOptions::new()
		.mouse()
		.probe(Duration::from_millis(150))
		.graphics_with(forced_from_args)
		.start(|env| build_ui(env.viewport, env.ctx))
		.await?;
	if app.caps().graphics != Graphics::Cells {
		for (index, provider) in PROVIDERS.iter().enumerate() {
			let png = tokio::fs::read(format!("{ASSET_DIR}/{}.png", provider.id)).await?;
			app.renderer_mut().register_image(
				u32::try_from(index + 1).expect("provider count fits image IDs"),
				png,
			)?;
		}
		app.ui_mut().invalidate(SCROLL_ID);
	}
	show_stats(&mut app, None);
	let mut chosen: Option<String> = None;
	while let Some(event) = app.next().await? {
		match event {
			AppEvent::Resized(viewport) => {
				app.ui_mut().set_height(SCROLL_ID, scroll_height(viewport));
			},
			AppEvent::Pressed(id) => chosen = Some(id.to_string()),
			_ => {},
		}
		show_stats(&mut app, chosen.as_deref());
	}
	Ok(())
}

examples/tml.rs (line 77)

async fn main() -> io::Result<()> {
	let path = std::env::args()
		.nth(1)
		.unwrap_or_else(|| "example.tml".into());
	let source = std::fs::read_to_string(&path)?;

	let mut ctx = None;
	let mut app = AppOptions::new()
		.quit([Key::Ctrl('c'), Key::Char('q'), Key::Esc])
		.start(|env| {
			let ui = build(&source, env.viewport.width, &env.ctx);
			ctx = Some(env.ctx);
			ui
		})
		.await?;
	let ctx = ctx.expect("start ran the builder");

	let handle = app.handle();
	tokio::spawn(async move {
		let mut seen = modified(path.as_ref());
		loop {
			tokio::time::sleep(Duration::from_millis(150)).await;
			let stamp = modified(path.as_ref());
			if stamp == seen {
				continue;
			}
			seen = stamp;
			let Ok(source) = std::fs::read_to_string(&path) else {
				continue;
			};
			let ctx = ctx.clone();
			handle.update(move |ui| *ui = build(&source, ui.frame().size().width, &ctx));
		}
	});

	while app.next().await?.is_some() {}
	Ok(())
}

examples/gallery/main.rs (line 129)

async fn main() -> io::Result<()> {
	let mut app = AppOptions::new()
		.mouse()
		.quit([Key::Ctrl('c'), Key::Ctrl('q')])
		.start(|env| build_ui(env.viewport, env.ctx))
		.await?;
	// The picker tab opens with the first model's details, like the chat
	// overlay does.
	picker::show_detail_on(app.ui_mut(), Some(0));

	let mut synced = String::new();
	let mut lab = anim::Lab::new();
	let mut layers = Layers::default();
	let mut next_step = tokio::time::Instant::now() + anim::AUTOPLAY_STEP;

	loop {
		let event = tokio::select! {
			event = app.next() => match event? {
				Some(event) => event,
				None => break,
			},
			() = tokio::time::sleep_until(next_step) => {
				if lab.autoplay && active_tab(app.ui()) == "Anim" {
					lab.advance(app.ui_mut());
				}
				next_step += anim::AUTOPLAY_STEP;
				continue;
			},
		};
		match event {
			AppEvent::Resized(viewport) => {
				for pane in render::PANE_IDS {
					app.ui_mut().set_height(pane, render::pane_height(viewport));
				}
			},
			AppEvent::Key(key) => match active_tab(app.ui()).as_str() {
				"Anim" => lab.handle_key(key, app.ui_mut()),
				"Overlay" => match key {
					Key::Ctrl('k') if layers.picker.is_none() => {
						layers.picker = Some(overlay::show_picker(app.ui_mut()));
					},
					Key::Ctrl('g') => match layers.help.take() {
						Some(id) => {
							app.ui_mut().close_overlay(id);
						},
						None => layers.help = Some(overlay::show_help(app.ui_mut())),
					},
					_ => {},
				},
				_ => {},
			},
			// The Overlay tab's modal select committed a model.
			AppEvent::Changed { id, value } if id == "model" => {
				if let Some(overlay) = layers.picker.take() {
					let label = overlay::MODELS
						.iter()
						.find(|(short, ..)| *short == value)
						.map_or(value.as_str(), |(_, label, _)| label);
					app.ui_mut().set_text("status", format!("model: {label}"));
					app.ui_mut().close_overlay(overlay);
				}
			},
			// The Picker tab's select moved: mirror the chat picker's
			// facts-and-chips detail line.
			AppEvent::Highlighted { id, value } if id == "models" => {
				picker::show_detail_on(app.ui_mut(), value.as_str().parse().ok());
			},
			AppEvent::Filtered { id, value, .. } if id == "models" => {
				let model = value.and_then(|value| value.as_str().parse().ok());
				picker::show_detail_on(app.ui_mut(), model);
			},
			AppEvent::OverlayClosed(id) => {
				if layers.picker == Some(id) {
					layers.picker = None;
				}
				if layers.help == Some(id) {
					layers.help = None;
				}
			},
			_ => {},
		}
		render::sync_preview(app.ui_mut(), &mut synced);
		// Reserve the Overlay tab's chords only while it is showing, so the
		// focused composer can't spend Ctrl+K on kill-line — and the Live
		// tab's editor keeps it.
		let chords: &[Key] = if active_tab(app.ui()) == "Overlay" {
			&[Key::Ctrl('k'), Key::Ctrl('g')]
		} else {
			&[]
		};
		app.set_hotkeys(chords.iter().copied());
	}
	Ok(())
}

Trait Implementations

impl Drop for App

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.