Struct Style 

pub struct Style { /* private fields */ }

Canonical visual attributes for one or more cells.

Implementations

impl Style

pub const fn new() -> Self

Creates an unstyled terminal style.

Examples found in repository

examples/footers.rs (line 399)

const fn ink(color: Color) -> Style {
	Style::new().fg(color)
}

fn width_of(text: &str) -> u16 {
	u16::try_from(xutf::width_str(text)).unwrap_or(u16::MAX)
}

/// [`TITLE`] truncated to at most `max` cells, ellipsized when it cannot
/// fit whole.
fn fit_title(scene: &Scene, max: u16) -> Str {
	if width_of(TITLE) <= max {
		return Str::new_static(TITLE);
	}
	let ellipsis = match scene.charset {
		Charset::Ascii => "...",
		_ => "…",
	};
	let budget = max.saturating_sub(width_of(ellipsis));
	let mut used = 0_u16;
	let mut end = 0_usize;
	for grapheme in xutf::graphemes_str(TITLE) {
		let cells = width_of(grapheme);
		if used.saturating_add(cells) > budget {
			break;
		}
		used = used.saturating_add(cells);
		end += grapheme.len();
	}
	if end == 0 {
		return Str::default();
	}
	fmts!("{}{ellipsis}", TITLE[..end].trim_end())
}

/// Total cells a powerline band with `segments` occupies, mirroring the
/// `<status>` component's measurement.
fn band_width(scene: &Scene, segments: &[Seg]) -> u16 {
	let (left_cap, separator, right_cap) = band_chrome(scene.charset);
	let text = segments
		.iter()
		.map(|segment| width_of(&segment.label))
		.fold(0_u16, u16::saturating_add);
	let separators = u16::try_from(segments.len().saturating_sub(1))
		.unwrap_or(u16::MAX)
		.saturating_mul(width_of(separator).saturating_add(2));
	text
		.saturating_add(separators)
		.saturating_add(width_of(left_cap))
		.saturating_add(2)
		.saturating_add(width_of(right_cap))
}

/// Paints a powerline band at `x`: cap, padded segments, cap.
fn draw_band(frame: &mut Frame, x: u16, y: u16, scene: &Scene, segments: &[Seg]) {
	let (left_cap, separator, right_cap) = band_chrome(scene.charset);
	let base = Style::new().fg(TEXT).bg(BAND_BG);
	let edge = ink(BAND_BG);
	let mut column = frame.put(x, y, left_cap, edge);
	column = frame.put(column, y, " ", base);
	for (index, segment) in segments.iter().enumerate() {
		if index > 0 {
			column = frame.put(column, y, " ", base.dim());
			column = frame.put(column, y, separator, base.dim());
			column = frame.put(column, y, " ", base.dim());
		}
		column = frame.put(column, y, &segment.label, base.fg(segment.color));
	}
	column = frame.put(column, y, " ", base);
	frame.put(column, y, right_cap, edge);
}

examples/chat/demo.rs (line 1868)

fn draw_submission_text(
	frame: &mut Frame,
	x: u16,
	y: u16,
	width: u16,
	line: &str,
	charset: Charset,
) {
	let icon = charset.icon(Icon::Image);
	let mut chips: SmallVec<(usize, usize, String, usize), 4> = SmallVec::new();
	let mut base = 0;
	while let Some((start, end, marker)) = next_ref_tag(&line[base..]) {
		chips.push((base + start, base + end, format!("{icon} #{marker}"), marker));
		base += end;
	}
	let mut spans: SmallVec<Span<'_>, 8> = SmallVec::new();
	let mut at = 0;
	for (start, end, label, marker) in &chips {
		if *start > at {
			spans.push(Span::new(&line[at..*start], ink(TEXT)));
		}
		spans.push(Span::new(label, Style::new().fg(PANEL).bg(attachment_color(*marker)).bold()));
		at = *end;
	}
	if at < line.len() {
		spans.push(Span::new(&line[at..], ink(TEXT)));
	}
	draw_line(frame, x, y, width, &spans);
}

/// Chrome outside a panel is transparent: no `bg`, so the terminal's own
/// background (and any image or blur behind it) shows through. Only the
/// panel boxes below opt into a fill.
const fn base_style() -> Style {
	Style::new().fg(TEXT)
}

const fn panel_style() -> Style {
	Style::new().fg(TEXT).bg(PANEL)
}

const fn ink(color: Color) -> Style {
	Style::new().fg(color)
}

const fn panel_ink(color: Color) -> Style {
	Style::new().fg(color).bg(PANEL)
}

const fn prose_style() -> Style {
	Style::new().fg(MUTED).italic()
}

const fn code_style() -> Style {
	Style::new().fg(GREEN)
}

examples/chat/welcome.rs (line 276)

	fn draw_backdrop(&mut self, viewport: Size, clock: Duration, elapsed: f32) {
		let interval = ambient_interval(clock, BACKDROP_IDLE_INTERVAL);
		if self
			.backdrop_at
			.is_none_or(|rendered_at| clock.saturating_sub(rendered_at) >= interval)
		{
			let fade = smooth((elapsed / BACKDROP_FADE).clamp(0.0, 1.0));
			self
				.backdrop_frame
				.fill(Rect::new(0, 0, viewport.width, viewport.height), Style::default());
			let frame = &mut self.backdrop_frame;
			let mut buffer = [0_u8; 4];
			let dim = |color: Color| Color::Rgb(0, 0, 0).lerp(color, fade);
			self.surface.render(
				&mut self.backdrop,
				clock,
				viewport.width,
				viewport.height,
				|x, y, glyph, fg, bg| {
					let style = Style::new().fg(dim(fg));
					let style = match bg {
						Some(bg) => style.bg(dim(bg)),
						None => style,
					};
					frame.put(x, y, glyph.encode_utf8(&mut buffer), style);
				},
			);
			self.backdrop_at = Some(clock);
		}
		self.frame.clone_from(&self.backdrop_frame);
	}

	fn draw_card(&mut self, cols: u16, left: u16, top: u16, elapsed: f32, hover: f32) {
		let full = cols == CARD_COLS;
		let logo_left = if full {
			left + 3
		} else {
			left + (cols - LOGO_COLS as u16) / 2
		};
		self.logo_origin = (logo_left, top + 2);
		// Pointer-tracking border glow: the brand gradient sampled by angle
		// around the card center (the disk's own palette), strongest near
		// the pointer, scaled by the eased hover amount.
		let pointer = self.pointer;
		let center =
			(f32::from(left) + f32::from(cols) / 2.0, f32::from(top) + f32::from(CARD_ROWS) / 2.0);
		let edge_at = move |x: u16, y: u16| -> Style {
			let Some((px, py)) = pointer.filter(|_| hover > 0.02) else {
				return on_card(CARD_BORDER);
			};
			let dx = (f32::from(x) - f32::from(px)) * 0.5;
			let dy = f32::from(y) - f32::from(py);
			let glow = hover * (-(dx * dx + dy * dy) / 34.0).exp();
			if glow < 0.02 {
				return on_card(CARD_BORDER);
			}
			let angle = (f32::from(y) - center.1).atan2((f32::from(x) - center.0) * 0.5);
			let brand = vec3_color(gradient(angle - elapsed * 0.5));
			on_card(CARD_BORDER.lerp(brand, glow))
		};
		let frame = &mut self.frame;
		frame.fill(Rect::new(left, top, cols, CARD_ROWS), on_card(TEXT));

		let right = left + cols - 1;
		let bottom = top + CARD_ROWS - 1;
		let divider = bottom - 2;
		let (tl, tr, bl, br, horizontal, vertical) = self.charset.border(Border::Round);
		let grid = self.charset.grid();
		let mut glyph = [0_u8; 4];
		frame.put(left, top, tl.encode_utf8(&mut glyph), edge_at(left, top));
		frame.put(right, top, tr.encode_utf8(&mut glyph), edge_at(right, top));
		frame.put(left, divider, grid.middle.0.encode_utf8(&mut glyph), edge_at(left, divider));
		frame.put(right, divider, grid.middle.2.encode_utf8(&mut glyph), edge_at(right, divider));
		frame.put(left, bottom, bl.encode_utf8(&mut glyph), edge_at(left, bottom));
		frame.put(right, bottom, br.encode_utf8(&mut glyph), edge_at(right, bottom));
		for x in left + 1..right {
			frame.put(x, top, horizontal.encode_utf8(&mut glyph), edge_at(x, top));
			frame.put(x, divider, horizontal.encode_utf8(&mut glyph), edge_at(x, divider));
			frame.put(x, bottom, horizontal.encode_utf8(&mut glyph), edge_at(x, bottom));
		}
		for y in top + 1..bottom {
			if y != divider {
				frame.put(left, y, vertical.encode_utf8(&mut glyph), edge_at(left, y));
				frame.put(right, y, vertical.encode_utf8(&mut glyph), edge_at(right, y));
			}
		}

		frame.put(left + 2, top, self.title.as_str(), on_card(TEXT_STRONG));
		if full {
			frame.put(left + 34, top, " SESSION ORBIT ", on_card(FAINT));
			draw_dust(frame, left, top, elapsed);
			draw_sessions(frame, left, top, self.charset);
			draw_beam(frame, left, top, elapsed);
		}

		blit_logo(frame, &self.logo, logo_left, top + 2, CARD_BG);

		let footer = divider + 1;
		frame.fill(Rect::new(left + 1, footer, cols - 2, 1), on_footer(TEXT));
		if full {
			frame.put(left + 3, divider, " SHORTCUTS ", on_card(FAINT));
			let dot = fmts!(" {} ", self.charset.icon(Icon::Enabled));
			let x = frame.put(left + cols - 21, top, &dot, on_card(GREEN));
			frame.put(x, top, "rust-analyzer ", on_card(MUTED));
			draw_full_hints(frame, left, footer);
		} else {
			draw_smol_hints(frame, left, cols, footer);
		}
	}
}

impl Default for Welcome {
	fn default() -> Self {
		Self::new(Charset::NerdFont)
	}
}

fn draw_dust(frame: &mut Frame, left: u16, top: u16, elapsed: f32) {
	for &(x, y, offset) in &DUST {
		let pulse = 0.5 + 0.5 * (elapsed * 1.4 + offset).sin();
		let color = FAINT.lerp(CYAN, pulse * 0.28);
		frame.put(left + x, top + y, "·", on_card(color));
	}
	frame.put(left + 1, top + 7, HORIZON, on_card(FAINT.lerp(INDIGO, 0.16)));
	frame.put(left + 14, top + 1, "+Z", on_card(FAINT));
}

fn draw_beam(frame: &mut Frame, left: u16, top: u16, elapsed: f32) {
	let phase = (elapsed * 9.0) as usize % BEAM.len();
	for (index, &(x, y, glyph)) in BEAM.iter().enumerate() {
		let direct = index.abs_diff(phase);
		let distance = direct.min(BEAM.len() - direct);
		let color = match distance {
			0 => TEXT_STRONG,
			1 => CYAN,
			_ => FAINT.lerp(INDIGO, 0.34),
		};
		frame.put(left + x, top + y, glyph, on_card(color));
	}
}

fn draw_sessions(frame: &mut Frame, left: u16, top: u16, charset: Charset) {
	let (_, _, _, _, _, vertical) = charset.border(Border::Round);
	let mut glyph = [0_u8; 4];
	let panel_x = left + 36;
	frame.put(panel_x, top + 2, "RECENT SESSIONS", on_card(MUTED));
	frame.put(left + CARD_COLS - 14, top + 2, "4 / LOCAL", on_card(FAINT));
	for y in top + 4..=top + 10 {
		frame.put(panel_x, y, vertical.encode_utf8(&mut glyph), on_card(FAINT.lerp(INDIGO, 0.18)));
	}
	for (index, (label, age)) in SESSIONS.iter().enumerate() {
		let y = top + 4 + index as u16 * 2;
		if index == 0 {
			frame.fill(Rect::new(panel_x - 2, y, CARD_COLS - 35, 1), on_selected(TEXT));
			frame.put(panel_x - 2, y, charset.rail(), on_selected(GREEN));
			frame.put(panel_x, y, charset.radio(true), on_selected(GREEN));
			frame.put(panel_x + 2, y, age, on_selected(GREEN));
			frame.put(panel_x + 7, y, label, on_selected(TEXT_STRONG));
		} else {
			frame.put(panel_x, y, charset.radio(false), on_card(FAINT));
			frame.put(panel_x + 2, y, age, on_card(FAINT));
			frame.put(panel_x + 7, y, label, on_card(MUTED));
		}
	}
}

fn draw_full_hints(frame: &mut Frame, left: u16, y: u16) {
	frame.put(left + 3, y, "#", on_footer(CYAN));
	frame.put(left + 5, y, "actions", on_footer(MUTED));
	frame.put(left + 14, y, "/", on_footer(GREEN));
	frame.put(left + 16, y, "commands", on_footer(MUTED));
	frame.put(left + 27, y, "!", on_footer(AMBER));
	frame.put(left + 29, y, "shell", on_footer(MUTED));
	frame.put(left + 37, y, "$", on_footer(VIOLET));
	frame.put(left + 39, y, "python", on_footer(MUTED));
	frame.put(left + CARD_COLS - 23, y, "↑↓ move", on_footer(FAINT));
	frame.put(left + CARD_COLS - 13, y, "↵ resume", on_footer(TEXT_STRONG));
}

fn draw_smol_hints(frame: &mut Frame, left: u16, cols: u16, y: u16) {
	frame.put(left + 3, y, "#", on_footer(CYAN).bold());
	frame.put(left + 5, y, "/", on_footer(CYAN).bold());
	frame.put(left + 7, y, "!", on_footer(AMBER).bold());
	frame.put(left + 9, y, "$", on_footer(GREEN).bold());
	frame.put(left + cols - 14, y, "enter", on_footer(FAINT));
	frame.put(left + cols - 8, y, "resume", on_footer(TEXT_STRONG).bold());
}

fn blit_logo(frame: &mut Frame, logo: &LogoGrid, left: u16, top: u16, background: Color) {
	let mut buffer = [0_u8; 4];
	for (row, cells) in logo.iter().enumerate() {
		for (column, cell) in cells.iter().enumerate() {
			let Some((glyph, color)) = cell else { continue };
			let style = Style::new().fg(*color).bg(background);
			frame.put(left + column as u16, top + row as u16, glyph.encode_utf8(&mut buffer), style);
		}
	}
}

const fn on_card(fg: Color) -> Style {
	Style::new().fg(fg).bg(CARD_BG)
}

const fn on_footer(fg: Color) -> Style {
	Style::new().fg(fg).bg(FOOTER_BG)
}

const fn on_selected(fg: Color) -> Style {
	Style::new().fg(fg).bg(SELECTED_BG)
}

pub const fn fg(self, color: Color) -> Self

Sets the foreground color.

Examples found in repository

examples/footers.rs (line 399)

const fn ink(color: Color) -> Style {
	Style::new().fg(color)
}

fn width_of(text: &str) -> u16 {
	u16::try_from(xutf::width_str(text)).unwrap_or(u16::MAX)
}

/// [`TITLE`] truncated to at most `max` cells, ellipsized when it cannot
/// fit whole.
fn fit_title(scene: &Scene, max: u16) -> Str {
	if width_of(TITLE) <= max {
		return Str::new_static(TITLE);
	}
	let ellipsis = match scene.charset {
		Charset::Ascii => "...",
		_ => "…",
	};
	let budget = max.saturating_sub(width_of(ellipsis));
	let mut used = 0_u16;
	let mut end = 0_usize;
	for grapheme in xutf::graphemes_str(TITLE) {
		let cells = width_of(grapheme);
		if used.saturating_add(cells) > budget {
			break;
		}
		used = used.saturating_add(cells);
		end += grapheme.len();
	}
	if end == 0 {
		return Str::default();
	}
	fmts!("{}{ellipsis}", TITLE[..end].trim_end())
}

/// Total cells a powerline band with `segments` occupies, mirroring the
/// `<status>` component's measurement.
fn band_width(scene: &Scene, segments: &[Seg]) -> u16 {
	let (left_cap, separator, right_cap) = band_chrome(scene.charset);
	let text = segments
		.iter()
		.map(|segment| width_of(&segment.label))
		.fold(0_u16, u16::saturating_add);
	let separators = u16::try_from(segments.len().saturating_sub(1))
		.unwrap_or(u16::MAX)
		.saturating_mul(width_of(separator).saturating_add(2));
	text
		.saturating_add(separators)
		.saturating_add(width_of(left_cap))
		.saturating_add(2)
		.saturating_add(width_of(right_cap))
}

/// Paints a powerline band at `x`: cap, padded segments, cap.
fn draw_band(frame: &mut Frame, x: u16, y: u16, scene: &Scene, segments: &[Seg]) {
	let (left_cap, separator, right_cap) = band_chrome(scene.charset);
	let base = Style::new().fg(TEXT).bg(BAND_BG);
	let edge = ink(BAND_BG);
	let mut column = frame.put(x, y, left_cap, edge);
	column = frame.put(column, y, " ", base);
	for (index, segment) in segments.iter().enumerate() {
		if index > 0 {
			column = frame.put(column, y, " ", base.dim());
			column = frame.put(column, y, separator, base.dim());
			column = frame.put(column, y, " ", base.dim());
		}
		column = frame.put(column, y, &segment.label, base.fg(segment.color));
	}
	column = frame.put(column, y, " ", base);
	frame.put(column, y, right_cap, edge);
}

examples/chat/demo.rs (line 1868)

fn draw_submission_text(
	frame: &mut Frame,
	x: u16,
	y: u16,
	width: u16,
	line: &str,
	charset: Charset,
) {
	let icon = charset.icon(Icon::Image);
	let mut chips: SmallVec<(usize, usize, String, usize), 4> = SmallVec::new();
	let mut base = 0;
	while let Some((start, end, marker)) = next_ref_tag(&line[base..]) {
		chips.push((base + start, base + end, format!("{icon} #{marker}"), marker));
		base += end;
	}
	let mut spans: SmallVec<Span<'_>, 8> = SmallVec::new();
	let mut at = 0;
	for (start, end, label, marker) in &chips {
		if *start > at {
			spans.push(Span::new(&line[at..*start], ink(TEXT)));
		}
		spans.push(Span::new(label, Style::new().fg(PANEL).bg(attachment_color(*marker)).bold()));
		at = *end;
	}
	if at < line.len() {
		spans.push(Span::new(&line[at..], ink(TEXT)));
	}
	draw_line(frame, x, y, width, &spans);
}

/// Chrome outside a panel is transparent: no `bg`, so the terminal's own
/// background (and any image or blur behind it) shows through. Only the
/// panel boxes below opt into a fill.
const fn base_style() -> Style {
	Style::new().fg(TEXT)
}

const fn panel_style() -> Style {
	Style::new().fg(TEXT).bg(PANEL)
}

const fn ink(color: Color) -> Style {
	Style::new().fg(color)
}

const fn panel_ink(color: Color) -> Style {
	Style::new().fg(color).bg(PANEL)
}

const fn prose_style() -> Style {
	Style::new().fg(MUTED).italic()
}

const fn code_style() -> Style {
	Style::new().fg(GREEN)
}

examples/chat/welcome.rs (line 276)

	fn draw_backdrop(&mut self, viewport: Size, clock: Duration, elapsed: f32) {
		let interval = ambient_interval(clock, BACKDROP_IDLE_INTERVAL);
		if self
			.backdrop_at
			.is_none_or(|rendered_at| clock.saturating_sub(rendered_at) >= interval)
		{
			let fade = smooth((elapsed / BACKDROP_FADE).clamp(0.0, 1.0));
			self
				.backdrop_frame
				.fill(Rect::new(0, 0, viewport.width, viewport.height), Style::default());
			let frame = &mut self.backdrop_frame;
			let mut buffer = [0_u8; 4];
			let dim = |color: Color| Color::Rgb(0, 0, 0).lerp(color, fade);
			self.surface.render(
				&mut self.backdrop,
				clock,
				viewport.width,
				viewport.height,
				|x, y, glyph, fg, bg| {
					let style = Style::new().fg(dim(fg));
					let style = match bg {
						Some(bg) => style.bg(dim(bg)),
						None => style,
					};
					frame.put(x, y, glyph.encode_utf8(&mut buffer), style);
				},
			);
			self.backdrop_at = Some(clock);
		}
		self.frame.clone_from(&self.backdrop_frame);
	}

	fn draw_card(&mut self, cols: u16, left: u16, top: u16, elapsed: f32, hover: f32) {
		let full = cols == CARD_COLS;
		let logo_left = if full {
			left + 3
		} else {
			left + (cols - LOGO_COLS as u16) / 2
		};
		self.logo_origin = (logo_left, top + 2);
		// Pointer-tracking border glow: the brand gradient sampled by angle
		// around the card center (the disk's own palette), strongest near
		// the pointer, scaled by the eased hover amount.
		let pointer = self.pointer;
		let center =
			(f32::from(left) + f32::from(cols) / 2.0, f32::from(top) + f32::from(CARD_ROWS) / 2.0);
		let edge_at = move |x: u16, y: u16| -> Style {
			let Some((px, py)) = pointer.filter(|_| hover > 0.02) else {
				return on_card(CARD_BORDER);
			};
			let dx = (f32::from(x) - f32::from(px)) * 0.5;
			let dy = f32::from(y) - f32::from(py);
			let glow = hover * (-(dx * dx + dy * dy) / 34.0).exp();
			if glow < 0.02 {
				return on_card(CARD_BORDER);
			}
			let angle = (f32::from(y) - center.1).atan2((f32::from(x) - center.0) * 0.5);
			let brand = vec3_color(gradient(angle - elapsed * 0.5));
			on_card(CARD_BORDER.lerp(brand, glow))
		};
		let frame = &mut self.frame;
		frame.fill(Rect::new(left, top, cols, CARD_ROWS), on_card(TEXT));

		let right = left + cols - 1;
		let bottom = top + CARD_ROWS - 1;
		let divider = bottom - 2;
		let (tl, tr, bl, br, horizontal, vertical) = self.charset.border(Border::Round);
		let grid = self.charset.grid();
		let mut glyph = [0_u8; 4];
		frame.put(left, top, tl.encode_utf8(&mut glyph), edge_at(left, top));
		frame.put(right, top, tr.encode_utf8(&mut glyph), edge_at(right, top));
		frame.put(left, divider, grid.middle.0.encode_utf8(&mut glyph), edge_at(left, divider));
		frame.put(right, divider, grid.middle.2.encode_utf8(&mut glyph), edge_at(right, divider));
		frame.put(left, bottom, bl.encode_utf8(&mut glyph), edge_at(left, bottom));
		frame.put(right, bottom, br.encode_utf8(&mut glyph), edge_at(right, bottom));
		for x in left + 1..right {
			frame.put(x, top, horizontal.encode_utf8(&mut glyph), edge_at(x, top));
			frame.put(x, divider, horizontal.encode_utf8(&mut glyph), edge_at(x, divider));
			frame.put(x, bottom, horizontal.encode_utf8(&mut glyph), edge_at(x, bottom));
		}
		for y in top + 1..bottom {
			if y != divider {
				frame.put(left, y, vertical.encode_utf8(&mut glyph), edge_at(left, y));
				frame.put(right, y, vertical.encode_utf8(&mut glyph), edge_at(right, y));
			}
		}

		frame.put(left + 2, top, self.title.as_str(), on_card(TEXT_STRONG));
		if full {
			frame.put(left + 34, top, " SESSION ORBIT ", on_card(FAINT));
			draw_dust(frame, left, top, elapsed);
			draw_sessions(frame, left, top, self.charset);
			draw_beam(frame, left, top, elapsed);
		}

		blit_logo(frame, &self.logo, logo_left, top + 2, CARD_BG);

		let footer = divider + 1;
		frame.fill(Rect::new(left + 1, footer, cols - 2, 1), on_footer(TEXT));
		if full {
			frame.put(left + 3, divider, " SHORTCUTS ", on_card(FAINT));
			let dot = fmts!(" {} ", self.charset.icon(Icon::Enabled));
			let x = frame.put(left + cols - 21, top, &dot, on_card(GREEN));
			frame.put(x, top, "rust-analyzer ", on_card(MUTED));
			draw_full_hints(frame, left, footer);
		} else {
			draw_smol_hints(frame, left, cols, footer);
		}
	}
}

impl Default for Welcome {
	fn default() -> Self {
		Self::new(Charset::NerdFont)
	}
}

fn draw_dust(frame: &mut Frame, left: u16, top: u16, elapsed: f32) {
	for &(x, y, offset) in &DUST {
		let pulse = 0.5 + 0.5 * (elapsed * 1.4 + offset).sin();
		let color = FAINT.lerp(CYAN, pulse * 0.28);
		frame.put(left + x, top + y, "·", on_card(color));
	}
	frame.put(left + 1, top + 7, HORIZON, on_card(FAINT.lerp(INDIGO, 0.16)));
	frame.put(left + 14, top + 1, "+Z", on_card(FAINT));
}

fn draw_beam(frame: &mut Frame, left: u16, top: u16, elapsed: f32) {
	let phase = (elapsed * 9.0) as usize % BEAM.len();
	for (index, &(x, y, glyph)) in BEAM.iter().enumerate() {
		let direct = index.abs_diff(phase);
		let distance = direct.min(BEAM.len() - direct);
		let color = match distance {
			0 => TEXT_STRONG,
			1 => CYAN,
			_ => FAINT.lerp(INDIGO, 0.34),
		};
		frame.put(left + x, top + y, glyph, on_card(color));
	}
}

fn draw_sessions(frame: &mut Frame, left: u16, top: u16, charset: Charset) {
	let (_, _, _, _, _, vertical) = charset.border(Border::Round);
	let mut glyph = [0_u8; 4];
	let panel_x = left + 36;
	frame.put(panel_x, top + 2, "RECENT SESSIONS", on_card(MUTED));
	frame.put(left + CARD_COLS - 14, top + 2, "4 / LOCAL", on_card(FAINT));
	for y in top + 4..=top + 10 {
		frame.put(panel_x, y, vertical.encode_utf8(&mut glyph), on_card(FAINT.lerp(INDIGO, 0.18)));
	}
	for (index, (label, age)) in SESSIONS.iter().enumerate() {
		let y = top + 4 + index as u16 * 2;
		if index == 0 {
			frame.fill(Rect::new(panel_x - 2, y, CARD_COLS - 35, 1), on_selected(TEXT));
			frame.put(panel_x - 2, y, charset.rail(), on_selected(GREEN));
			frame.put(panel_x, y, charset.radio(true), on_selected(GREEN));
			frame.put(panel_x + 2, y, age, on_selected(GREEN));
			frame.put(panel_x + 7, y, label, on_selected(TEXT_STRONG));
		} else {
			frame.put(panel_x, y, charset.radio(false), on_card(FAINT));
			frame.put(panel_x + 2, y, age, on_card(FAINT));
			frame.put(panel_x + 7, y, label, on_card(MUTED));
		}
	}
}

fn draw_full_hints(frame: &mut Frame, left: u16, y: u16) {
	frame.put(left + 3, y, "#", on_footer(CYAN));
	frame.put(left + 5, y, "actions", on_footer(MUTED));
	frame.put(left + 14, y, "/", on_footer(GREEN));
	frame.put(left + 16, y, "commands", on_footer(MUTED));
	frame.put(left + 27, y, "!", on_footer(AMBER));
	frame.put(left + 29, y, "shell", on_footer(MUTED));
	frame.put(left + 37, y, "$", on_footer(VIOLET));
	frame.put(left + 39, y, "python", on_footer(MUTED));
	frame.put(left + CARD_COLS - 23, y, "↑↓ move", on_footer(FAINT));
	frame.put(left + CARD_COLS - 13, y, "↵ resume", on_footer(TEXT_STRONG));
}

fn draw_smol_hints(frame: &mut Frame, left: u16, cols: u16, y: u16) {
	frame.put(left + 3, y, "#", on_footer(CYAN).bold());
	frame.put(left + 5, y, "/", on_footer(CYAN).bold());
	frame.put(left + 7, y, "!", on_footer(AMBER).bold());
	frame.put(left + 9, y, "$", on_footer(GREEN).bold());
	frame.put(left + cols - 14, y, "enter", on_footer(FAINT));
	frame.put(left + cols - 8, y, "resume", on_footer(TEXT_STRONG).bold());
}

fn blit_logo(frame: &mut Frame, logo: &LogoGrid, left: u16, top: u16, background: Color) {
	let mut buffer = [0_u8; 4];
	for (row, cells) in logo.iter().enumerate() {
		for (column, cell) in cells.iter().enumerate() {
			let Some((glyph, color)) = cell else { continue };
			let style = Style::new().fg(*color).bg(background);
			frame.put(left + column as u16, top + row as u16, glyph.encode_utf8(&mut buffer), style);
		}
	}
}

const fn on_card(fg: Color) -> Style {
	Style::new().fg(fg).bg(CARD_BG)
}

const fn on_footer(fg: Color) -> Style {
	Style::new().fg(fg).bg(FOOTER_BG)
}

const fn on_selected(fg: Color) -> Style {
	Style::new().fg(fg).bg(SELECTED_BG)
}

pub const fn bg(self, color: Color) -> Self

Sets the background color.

Examples found in repository

examples/footers.rs (line 454)

fn draw_band(frame: &mut Frame, x: u16, y: u16, scene: &Scene, segments: &[Seg]) {
	let (left_cap, separator, right_cap) = band_chrome(scene.charset);
	let base = Style::new().fg(TEXT).bg(BAND_BG);
	let edge = ink(BAND_BG);
	let mut column = frame.put(x, y, left_cap, edge);
	column = frame.put(column, y, " ", base);
	for (index, segment) in segments.iter().enumerate() {
		if index > 0 {
			column = frame.put(column, y, " ", base.dim());
			column = frame.put(column, y, separator, base.dim());
			column = frame.put(column, y, " ", base.dim());
		}
		column = frame.put(column, y, &segment.label, base.fg(segment.color));
	}
	column = frame.put(column, y, " ", base);
	frame.put(column, y, right_cap, edge);
}

examples/chat/demo.rs (line 1868)

fn draw_submission_text(
	frame: &mut Frame,
	x: u16,
	y: u16,
	width: u16,
	line: &str,
	charset: Charset,
) {
	let icon = charset.icon(Icon::Image);
	let mut chips: SmallVec<(usize, usize, String, usize), 4> = SmallVec::new();
	let mut base = 0;
	while let Some((start, end, marker)) = next_ref_tag(&line[base..]) {
		chips.push((base + start, base + end, format!("{icon} #{marker}"), marker));
		base += end;
	}
	let mut spans: SmallVec<Span<'_>, 8> = SmallVec::new();
	let mut at = 0;
	for (start, end, label, marker) in &chips {
		if *start > at {
			spans.push(Span::new(&line[at..*start], ink(TEXT)));
		}
		spans.push(Span::new(label, Style::new().fg(PANEL).bg(attachment_color(*marker)).bold()));
		at = *end;
	}
	if at < line.len() {
		spans.push(Span::new(&line[at..], ink(TEXT)));
	}
	draw_line(frame, x, y, width, &spans);
}

/// Chrome outside a panel is transparent: no `bg`, so the terminal's own
/// background (and any image or blur behind it) shows through. Only the
/// panel boxes below opt into a fill.
const fn base_style() -> Style {
	Style::new().fg(TEXT)
}

const fn panel_style() -> Style {
	Style::new().fg(TEXT).bg(PANEL)
}

const fn ink(color: Color) -> Style {
	Style::new().fg(color)
}

const fn panel_ink(color: Color) -> Style {
	Style::new().fg(color).bg(PANEL)
}

examples/chat/welcome.rs (line 278)

	fn draw_backdrop(&mut self, viewport: Size, clock: Duration, elapsed: f32) {
		let interval = ambient_interval(clock, BACKDROP_IDLE_INTERVAL);
		if self
			.backdrop_at
			.is_none_or(|rendered_at| clock.saturating_sub(rendered_at) >= interval)
		{
			let fade = smooth((elapsed / BACKDROP_FADE).clamp(0.0, 1.0));
			self
				.backdrop_frame
				.fill(Rect::new(0, 0, viewport.width, viewport.height), Style::default());
			let frame = &mut self.backdrop_frame;
			let mut buffer = [0_u8; 4];
			let dim = |color: Color| Color::Rgb(0, 0, 0).lerp(color, fade);
			self.surface.render(
				&mut self.backdrop,
				clock,
				viewport.width,
				viewport.height,
				|x, y, glyph, fg, bg| {
					let style = Style::new().fg(dim(fg));
					let style = match bg {
						Some(bg) => style.bg(dim(bg)),
						None => style,
					};
					frame.put(x, y, glyph.encode_utf8(&mut buffer), style);
				},
			);
			self.backdrop_at = Some(clock);
		}
		self.frame.clone_from(&self.backdrop_frame);
	}

	fn draw_card(&mut self, cols: u16, left: u16, top: u16, elapsed: f32, hover: f32) {
		let full = cols == CARD_COLS;
		let logo_left = if full {
			left + 3
		} else {
			left + (cols - LOGO_COLS as u16) / 2
		};
		self.logo_origin = (logo_left, top + 2);
		// Pointer-tracking border glow: the brand gradient sampled by angle
		// around the card center (the disk's own palette), strongest near
		// the pointer, scaled by the eased hover amount.
		let pointer = self.pointer;
		let center =
			(f32::from(left) + f32::from(cols) / 2.0, f32::from(top) + f32::from(CARD_ROWS) / 2.0);
		let edge_at = move |x: u16, y: u16| -> Style {
			let Some((px, py)) = pointer.filter(|_| hover > 0.02) else {
				return on_card(CARD_BORDER);
			};
			let dx = (f32::from(x) - f32::from(px)) * 0.5;
			let dy = f32::from(y) - f32::from(py);
			let glow = hover * (-(dx * dx + dy * dy) / 34.0).exp();
			if glow < 0.02 {
				return on_card(CARD_BORDER);
			}
			let angle = (f32::from(y) - center.1).atan2((f32::from(x) - center.0) * 0.5);
			let brand = vec3_color(gradient(angle - elapsed * 0.5));
			on_card(CARD_BORDER.lerp(brand, glow))
		};
		let frame = &mut self.frame;
		frame.fill(Rect::new(left, top, cols, CARD_ROWS), on_card(TEXT));

		let right = left + cols - 1;
		let bottom = top + CARD_ROWS - 1;
		let divider = bottom - 2;
		let (tl, tr, bl, br, horizontal, vertical) = self.charset.border(Border::Round);
		let grid = self.charset.grid();
		let mut glyph = [0_u8; 4];
		frame.put(left, top, tl.encode_utf8(&mut glyph), edge_at(left, top));
		frame.put(right, top, tr.encode_utf8(&mut glyph), edge_at(right, top));
		frame.put(left, divider, grid.middle.0.encode_utf8(&mut glyph), edge_at(left, divider));
		frame.put(right, divider, grid.middle.2.encode_utf8(&mut glyph), edge_at(right, divider));
		frame.put(left, bottom, bl.encode_utf8(&mut glyph), edge_at(left, bottom));
		frame.put(right, bottom, br.encode_utf8(&mut glyph), edge_at(right, bottom));
		for x in left + 1..right {
			frame.put(x, top, horizontal.encode_utf8(&mut glyph), edge_at(x, top));
			frame.put(x, divider, horizontal.encode_utf8(&mut glyph), edge_at(x, divider));
			frame.put(x, bottom, horizontal.encode_utf8(&mut glyph), edge_at(x, bottom));
		}
		for y in top + 1..bottom {
			if y != divider {
				frame.put(left, y, vertical.encode_utf8(&mut glyph), edge_at(left, y));
				frame.put(right, y, vertical.encode_utf8(&mut glyph), edge_at(right, y));
			}
		}

		frame.put(left + 2, top, self.title.as_str(), on_card(TEXT_STRONG));
		if full {
			frame.put(left + 34, top, " SESSION ORBIT ", on_card(FAINT));
			draw_dust(frame, left, top, elapsed);
			draw_sessions(frame, left, top, self.charset);
			draw_beam(frame, left, top, elapsed);
		}

		blit_logo(frame, &self.logo, logo_left, top + 2, CARD_BG);

		let footer = divider + 1;
		frame.fill(Rect::new(left + 1, footer, cols - 2, 1), on_footer(TEXT));
		if full {
			frame.put(left + 3, divider, " SHORTCUTS ", on_card(FAINT));
			let dot = fmts!(" {} ", self.charset.icon(Icon::Enabled));
			let x = frame.put(left + cols - 21, top, &dot, on_card(GREEN));
			frame.put(x, top, "rust-analyzer ", on_card(MUTED));
			draw_full_hints(frame, left, footer);
		} else {
			draw_smol_hints(frame, left, cols, footer);
		}
	}
}

impl Default for Welcome {
	fn default() -> Self {
		Self::new(Charset::NerdFont)
	}
}

fn draw_dust(frame: &mut Frame, left: u16, top: u16, elapsed: f32) {
	for &(x, y, offset) in &DUST {
		let pulse = 0.5 + 0.5 * (elapsed * 1.4 + offset).sin();
		let color = FAINT.lerp(CYAN, pulse * 0.28);
		frame.put(left + x, top + y, "·", on_card(color));
	}
	frame.put(left + 1, top + 7, HORIZON, on_card(FAINT.lerp(INDIGO, 0.16)));
	frame.put(left + 14, top + 1, "+Z", on_card(FAINT));
}

fn draw_beam(frame: &mut Frame, left: u16, top: u16, elapsed: f32) {
	let phase = (elapsed * 9.0) as usize % BEAM.len();
	for (index, &(x, y, glyph)) in BEAM.iter().enumerate() {
		let direct = index.abs_diff(phase);
		let distance = direct.min(BEAM.len() - direct);
		let color = match distance {
			0 => TEXT_STRONG,
			1 => CYAN,
			_ => FAINT.lerp(INDIGO, 0.34),
		};
		frame.put(left + x, top + y, glyph, on_card(color));
	}
}

fn draw_sessions(frame: &mut Frame, left: u16, top: u16, charset: Charset) {
	let (_, _, _, _, _, vertical) = charset.border(Border::Round);
	let mut glyph = [0_u8; 4];
	let panel_x = left + 36;
	frame.put(panel_x, top + 2, "RECENT SESSIONS", on_card(MUTED));
	frame.put(left + CARD_COLS - 14, top + 2, "4 / LOCAL", on_card(FAINT));
	for y in top + 4..=top + 10 {
		frame.put(panel_x, y, vertical.encode_utf8(&mut glyph), on_card(FAINT.lerp(INDIGO, 0.18)));
	}
	for (index, (label, age)) in SESSIONS.iter().enumerate() {
		let y = top + 4 + index as u16 * 2;
		if index == 0 {
			frame.fill(Rect::new(panel_x - 2, y, CARD_COLS - 35, 1), on_selected(TEXT));
			frame.put(panel_x - 2, y, charset.rail(), on_selected(GREEN));
			frame.put(panel_x, y, charset.radio(true), on_selected(GREEN));
			frame.put(panel_x + 2, y, age, on_selected(GREEN));
			frame.put(panel_x + 7, y, label, on_selected(TEXT_STRONG));
		} else {
			frame.put(panel_x, y, charset.radio(false), on_card(FAINT));
			frame.put(panel_x + 2, y, age, on_card(FAINT));
			frame.put(panel_x + 7, y, label, on_card(MUTED));
		}
	}
}

fn draw_full_hints(frame: &mut Frame, left: u16, y: u16) {
	frame.put(left + 3, y, "#", on_footer(CYAN));
	frame.put(left + 5, y, "actions", on_footer(MUTED));
	frame.put(left + 14, y, "/", on_footer(GREEN));
	frame.put(left + 16, y, "commands", on_footer(MUTED));
	frame.put(left + 27, y, "!", on_footer(AMBER));
	frame.put(left + 29, y, "shell", on_footer(MUTED));
	frame.put(left + 37, y, "$", on_footer(VIOLET));
	frame.put(left + 39, y, "python", on_footer(MUTED));
	frame.put(left + CARD_COLS - 23, y, "↑↓ move", on_footer(FAINT));
	frame.put(left + CARD_COLS - 13, y, "↵ resume", on_footer(TEXT_STRONG));
}

fn draw_smol_hints(frame: &mut Frame, left: u16, cols: u16, y: u16) {
	frame.put(left + 3, y, "#", on_footer(CYAN).bold());
	frame.put(left + 5, y, "/", on_footer(CYAN).bold());
	frame.put(left + 7, y, "!", on_footer(AMBER).bold());
	frame.put(left + 9, y, "$", on_footer(GREEN).bold());
	frame.put(left + cols - 14, y, "enter", on_footer(FAINT));
	frame.put(left + cols - 8, y, "resume", on_footer(TEXT_STRONG).bold());
}

fn blit_logo(frame: &mut Frame, logo: &LogoGrid, left: u16, top: u16, background: Color) {
	let mut buffer = [0_u8; 4];
	for (row, cells) in logo.iter().enumerate() {
		for (column, cell) in cells.iter().enumerate() {
			let Some((glyph, color)) = cell else { continue };
			let style = Style::new().fg(*color).bg(background);
			frame.put(left + column as u16, top + row as u16, glyph.encode_utf8(&mut buffer), style);
		}
	}
}

const fn on_card(fg: Color) -> Style {
	Style::new().fg(fg).bg(CARD_BG)
}

const fn on_footer(fg: Color) -> Style {
	Style::new().fg(fg).bg(FOOTER_BG)
}

const fn on_selected(fg: Color) -> Style {
	Style::new().fg(fg).bg(SELECTED_BG)
}

pub const fn bold(self) -> Self

Enables bold intensity.

Examples found in repository

examples/chat/welcome.rs (line 437)

fn draw_smol_hints(frame: &mut Frame, left: u16, cols: u16, y: u16) {
	frame.put(left + 3, y, "#", on_footer(CYAN).bold());
	frame.put(left + 5, y, "/", on_footer(CYAN).bold());
	frame.put(left + 7, y, "!", on_footer(AMBER).bold());
	frame.put(left + 9, y, "$", on_footer(GREEN).bold());
	frame.put(left + cols - 14, y, "enter", on_footer(FAINT));
	frame.put(left + cols - 8, y, "resume", on_footer(TEXT_STRONG).bold());
}

examples/chat/demo.rs (line 1398)

fn draw_command_box(frame: &mut Frame, rect: Rect, charset: Charset) {
	draw_box(frame, rect, ink(FAINT), panel_style(), charset);
	if rect.width < 4 || rect.height < 4 {
		return;
	}

	let content_x = rect.x + 2;
	let content_width = rect.width.saturating_sub(4);
	let header = [
		Span::new(" PARALLEL TEST RUN ", panel_ink(GREEN).bold()),
		Span::new("results append below · live rows in the bottom panel", panel_ink(MUTED)),
	];
	draw_line(frame, content_x, rect.y + 1, content_width, &header);
	let command = [
		Span::new("$ ", panel_ink(MUTED)),
		Span::new("bun test --parallel=8", panel_ink(CYAN)),
		Span::new(" --timeout=30000 --all-workspaces", panel_ink(TEXT)),
	];
	draw_line(frame, content_x, rect.y + 2, content_width, &command);
}

/// The live band's shard panel: twelve mutable rows that repaint in place
/// every frame and never enter native scrollback.
fn draw_live_panel(
	frame: &mut Frame,
	rows: &mut [LiveRowCache; LIVE_SHARD_ROWS as usize],
	label_scratch: &mut StrMut,
	rect: Rect,
	repaint_chrome: bool,
	emitted_shards: u16,
	animation_frame: u64,
	charset: Charset,
) -> bool {
	let mut changed = repaint_chrome;
	if repaint_chrome {
		draw_box(frame, rect, ink(FAINT), panel_style(), charset);
	}
	if rect.width < 4 || rect.height < 3 {
		return changed;
	}

	if repaint_chrome {
		let title = [
			Span::new(" LIVE SHARDS ", panel_ink(GREEN).bold()),
			Span::new("mutable rows repaint in place ", panel_ink(MUTED)),
		];
		draw_line(frame, rect.x + 2, rect.y, rect.width.saturating_sub(4), &title);
	}
	let content_x = rect.x + 2;
	let content_width = rect.width.saturating_sub(4);
	for row in 0..rect.height.saturating_sub(2) {
		let shard = emitted_shards.saturating_add(row).saturating_add(1);
		let phase = (u64::from(row) + animation_frame) % 11;
		let (prefix_phase, symbol, state, state_style, progress) = match phase {
			0 => (
				0,
				"⠼",
				"running",
				panel_ink(GREEN).bold(),
				(u64::from(row) * 17 + animation_frame * 7) % 100,
			),
			1..=7 => {
				(1, "·", "working", panel_ink(MUTED), (u64::from(row) * 17 + animation_frame * 7) % 100)
			},
			_ => (2, "·", "queued ", panel_ink(FAINT), 0),
		};
		let row_y = rect.y + 1 + row;
		let right = content_x
			.saturating_add(content_width)
			.min(frame.size().width);
		let cache = &mut rows[usize::from(row)];
		let prefix_changed = repaint_chrome
			|| !cache.prefix_valid
			|| cache.prefix_shard != shard
			|| cache.prefix_phase != prefix_phase;
		changed |= prefix_changed;
		let label_x = if prefix_changed {
			let prefix = fmts!(" {symbol} shard {shard:03} ");
			let prefix_width = prefix.len().saturating_sub(symbol.len()).saturating_add(1);
			let next_x = content_x
				.saturating_add(u16::try_from(prefix_width).unwrap_or(u16::MAX))
				.saturating_add(u16::try_from(state.len()).unwrap_or(u16::MAX))
				.saturating_add(2)
				.min(right);
			if !repaint_chrome && cache.label_x != next_x {
				clear_cached_label(frame, cache, row_y, right);
			}
			let next_x = draw_line(frame, content_x, row_y, content_width, &[
				Span::new(prefix.as_str(), state_style),
				Span::new(state, state_style),
				Span::new("  ", panel_ink(FAINT)),
			]);
			cache.prefix_shard = shard;
			cache.prefix_phase = prefix_phase;
			cache.prefix_valid = true;
			next_x
		} else {
			cache.label_x
		};
		let moved = cache.label_x != label_x;
		let label_changed = repaint_chrome
			|| moved
			|| !cache.label_valid
			|| cache.label_shard != shard
			|| cache.label_progress != progress;
		changed |= label_changed;
		if label_changed {
			label_scratch.truncate(0);
			write!(label_scratch, "workspace-{shard:03}.test.ts  [{progress:>3}%]")
				.expect("shard label formatting is infallible");
			let resized = cache.label.len() != label_scratch.len();
			if !repaint_chrome && resized && !moved {
				clear_cached_label(frame, cache, row_y, right);
			}
			let width = right.saturating_sub(label_x);
			if repaint_chrome || moved || resized {
				frame.put_clipped(label_x, row_y, width, label_scratch.as_str(), panel_ink(MUTED));
			} else {
				draw_ascii_changes(
					frame,
					label_x,
					row_y,
					width,
					cache.label.as_str(),
					label_scratch.as_str(),
					panel_ink(MUTED),
				);
			}
			std::mem::swap(&mut cache.label, label_scratch);
			cache.label_shard = shard;
			cache.label_progress = progress;
			cache.label_valid = true;
		}
		cache.label_x = label_x;
	}
	changed
}

fn clear_cached_label(frame: &mut Frame, cache: &LiveRowCache, y: u16, right: u16) {
	if cache.label.is_empty() {
		return;
	}
	let width = u16::try_from(cache.label.len())
		.unwrap_or(u16::MAX)
		.min(right.saturating_sub(cache.label_x));
	frame.fill(Rect::new(cache.label_x, y, width, 1), panel_style());
}

/// Repaints only changed byte runs within an equal-length ASCII label.
fn draw_ascii_changes(
	frame: &mut Frame,
	x: u16,
	y: u16,
	width: u16,
	previous: &str,
	next: &str,
	style: Style,
) {
	if width == 0 || previous == next {
		return;
	}
	if previous.len() != next.len() || !previous.is_ascii() || !next.is_ascii() {
		frame.put_clipped(x, y, width, next, style);
		return;
	}
	let previous = previous.as_bytes();
	let next_bytes = next.as_bytes();
	let limit = previous.len().min(usize::from(width));
	let mut index = 0;
	while index < limit {
		while index < limit && previous[index] == next_bytes[index] {
			index += 1;
		}
		let start = index;
		while index < limit && previous[index] != next_bytes[index] {
			index += 1;
		}
		if start < index {
			let offset = u16::try_from(start).unwrap_or(u16::MAX);
			frame.put_clipped(
				x.saturating_add(offset),
				y,
				u16::try_from(index - start).unwrap_or(u16::MAX),
				&next[start..index],
				style,
			);
		}
	}
}

fn draw_edit_box(frame: &mut Frame, rect: Rect, charset: Charset) {
	draw_box(frame, rect, ink(FAINT), panel_style(), charset);
	if rect.width < 8 || rect.height < EDIT_BOX_HEIGHT {
		return;
	}

	let title = [
		Span::new(" Live ", panel_ink(GREEN).bold()),
		Span::new("band · selection semantics ", panel_ink(CYAN)),
	];
	draw_line(frame, rect.x + 2, rect.y, rect.width.saturating_sub(4), &title);
	draw_line(frame, rect.x + 2, rect.y + 1, rect.width.saturating_sub(4), &[
		Span::new(charset.check(), panel_ink(GREEN).bold()),
		Span::new(" ", panel_ink(GREEN)),
		Span::new("Transcript selections ride with the text", panel_ink(TEXT)),
	]);
	draw_line(frame, rect.x + 2, rect.y + 2, rect.width.saturating_sub(4), &[Span::new(
		"  margin commits pin the band on kitty-class terminals",
		panel_ink(MUTED),
	)]);
}

/// Paints a submitted message: the prompt gutter, then the rendered
/// Markdown document blitted beside it (or the raw lines when the text
/// isn't renderable as Markdown).
fn draw_submission(frame: &mut Frame, y: u16, submission: &Submission, charset: Charset) {
	if frame.size().width < 4 {
		return;
	}
	let Some(view) = &submission.view else {
		for (offset, line) in submission.text.split('\n').enumerate() {
			let Ok(offset) = u16::try_from(offset) else {
				break;
			};
			let row = y.saturating_add(offset);
			if row >= frame.size().height {
				break;
			}
			let prompt = if offset == 0 { charset.cursor() } else { "  " };
			let text_x = frame.put(1, row, prompt, ink(GREEN).bold());
			let width = frame
				.size()
				.width
				.saturating_sub(1)
				.saturating_sub(text_x.saturating_sub(1));
			draw_submission_text(frame, text_x, row, width, line, charset);
		}
		return;
	};
	frame.put(1, y, charset.cursor(), ink(GREEN).bold());
	frame.blit(view.frame(), 0, view.height(), 3, y);
}
fn explicit_line_count(text: &str) -> u16 {
	u16::try_from(
		text
			.bytes()
			.filter(|byte| *byte == b'\n')
			.count()
			.saturating_add(1),
	)
	.unwrap_or(u16::MAX)
}

/// Paints a rounded panel box through the tier's border glyphs.
fn draw_box(frame: &mut Frame, rect: Rect, border: Style, fill: Style, charset: Charset) {
	if rect.width == 0 || rect.height == 0 {
		return;
	}
	let (tl, tr, _, _, horizontal, vertical) = charset.border(Border::Round);
	frame.fill(rect, fill);
	let mut glyph = [0_u8; 4];
	if rect.width == 1 {
		frame.put(rect.x, rect.y, vertical.encode_utf8(&mut glyph), border);
		return;
	}

	let right = rect.x + rect.width - 1;
	let bottom = rect.y + rect.height - 1;
	frame.put(rect.x, rect.y, tl.encode_utf8(&mut glyph), border);
	frame.put(right, rect.y, tr.encode_utf8(&mut glyph), border);
	for x in rect.x + 1..right {
		frame.put(x, rect.y, horizontal.encode_utf8(&mut glyph), border);
	}

	if rect.height > 1 {
		draw_box_bottom(frame, rect, border, charset);
	}
	for row in rect.y + 1..bottom {
		frame.put(rect.x, row, vertical.encode_utf8(&mut glyph), border);
		frame.put(right, row, vertical.encode_utf8(&mut glyph), border);
	}
}

fn draw_box_bottom(frame: &mut Frame, rect: Rect, border: Style, charset: Charset) {
	if rect.width < 2 || rect.height < 2 {
		return;
	}
	let (_, _, bl, br, horizontal, _) = charset.border(Border::Round);
	let mut glyph = [0_u8; 4];
	let right = rect.x + rect.width - 1;
	let bottom = rect.y + rect.height - 1;
	frame.put(rect.x, bottom, bl.encode_utf8(&mut glyph), border);
	frame.put(right, bottom, br.encode_utf8(&mut glyph), border);
	for x in rect.x + 1..right {
		frame.put(x, bottom, horizontal.encode_utf8(&mut glyph), border);
	}
}

fn draw_line(frame: &mut Frame, x: u16, y: u16, width: u16, spans: &[Span<'_>]) -> u16 {
	let right = x.saturating_add(width).min(frame.size().width);
	let mut column = x;
	for span in spans {
		column = frame.put_clipped(column, y, right.saturating_sub(column), span.text, span.style);
		if column >= right {
			break;
		}
	}
	column
}

/// Flows `spans` grapheme-exact across the rect like a bare terminal,
/// preserving all whitespace and flagging each exactly-filled row boundary
/// soft so native selection copies the paragraph as one unbroken line.
/// Returns the rows used.
fn draw_flowed(frame: &mut Frame, rect: Rect, spans: &[Span<'_>]) -> u16 {
	if rect.width == 0 || rect.height == 0 {
		return 0;
	}
	let full_row = rect.x == 0 && rect.width == frame.size().width;
	let mut row = 0_u16;
	let mut column = 0_u16;
	let mut drew_anything = false;

	for span in spans {
		for grapheme in xutf::graphemes_str(span.text) {
			let grapheme_width = visible_width(grapheme);
			if grapheme_width == 0 || grapheme_width > rect.width {
				continue;
			}
			if column.saturating_add(grapheme_width) > rect.width {
				// Only an exactly-filled row is byte-joinable by autowrap.
				if full_row && column == rect.width {
					frame.set_soft_wrap(rect.y.saturating_add(row));
				}
				row += 1;
				column = 0;
			}
			if row >= rect.height {
				return rect.height;
			}
			frame.put(rect.x + column, rect.y + row, grapheme, span.style);
			column += grapheme_width;
			drew_anything = true;
		}
	}

	if drew_anything { row + 1 } else { 0 }
}

fn visible_width(text: &str) -> u16 {
	u16::try_from(xutf::width_str(text)).unwrap_or(u16::MAX)
}

/// Finds the first `<ref image=N/>` tag in submitted text: its byte range
/// plus the marker number `N`.
fn next_ref_tag(text: &str) -> Option<(usize, usize, usize)> {
	const HEAD: &str = "<ref image=";
	let mut from = 0;
	while let Some(at) = text[from..].find(HEAD) {
		let start = from + at;
		let body = &text[start + HEAD.len()..];
		let digits = body.bytes().take_while(u8::is_ascii_digit).count();
		if digits > 0 && body[digits..].starts_with("/>") {
			let marker = body[..digits].parse().unwrap_or(usize::MAX);
			return Some((start, start + HEAD.len() + digits + 2, marker));
		}
		from = start + HEAD.len();
	}
	None
}

/// Splits one composer input row into base-styled text and attachment
/// chips, chip styling winning over any overlapping XML run.
///
/// Chips are located through the buffer's atomic ranges — like the XML
/// pass, styling happens at paint time, and typed lookalike text is never
/// recolored.
fn push_row_spans<'a>(
	editor: &Editor,
	row: &'a str,
	runs: &[SyntaxRun],
	spans: &mut SmallVec<Span<'a>, 16>,
) {
	let text = editor.text();
	let buffer_start = text.as_ptr() as usize;
	let row_start = (row.as_ptr() as usize).saturating_sub(buffer_start);
	let row_end = row_start + row.len();
	// Chip segments clipped to this row; style derives from the FULL atom
	// text, so a chip wrapped across rows keeps its color on every row.
	let mut chips: SmallVec<(usize, usize, Style), 4> = SmallVec::new();
	for (start, end) in editor.atom_ranges() {
		let from = start.max(row_start);
		let to = end.min(row_end);
		if from < to {
			chips.push((from - row_start, to - row_start, chip_style(&text[start..end])));
		}
	}
	// The style and extent of the base segment covering `at`: its XML run,
	// or plain text up to the next run.
	let base = |at: usize| {
		runs
			.iter()
			.find(|run| run.start <= at && at < run.end)
			.map_or_else(
				|| {
					let next = runs
						.iter()
						.map(|run| run.start)
						.filter(|start| *start > at)
						.min()
						.unwrap_or(row.len());
					(next, base_style())
				},
				|run| (run.end, run.style),
			)
	};
	fn emit<'a>(
		row: &'a str,
		base: &impl Fn(usize) -> (usize, Style),
		from: usize,
		to: usize,
		spans: &mut SmallVec<Span<'a>, 16>,
	) {
		let mut at = from;
		while at < to {
			let (run_end, style) = base(at);
			let end = run_end.min(to);
			spans.push(Span::new(&row[at..end], style));
			at = end;
		}
	}
	let mut at = 0;
	for (start, end, style) in chips {
		emit(row, &base, at, start, spans);
		spans.push(Span::new(&row[start..end], style));
		at = end;
	}
	emit(row, &base, at, row.len(), spans);
}

/// Style for one atomic chip: a trailing `#N` selects the marker's
/// identity color; other atoms stay plain.
fn chip_style(chip: &str) -> Style {
	let Some(hash) = chip.rfind('#') else {
		return base_style();
	};
	let digits = &chip[hash + 1..];
	if digits.is_empty() || !digits.bytes().all(|byte| byte.is_ascii_digit()) {
		return base_style();
	}
	match digits.parse::<usize>() {
		Ok(marker) if marker > 0 => ink(attachment_color(marker)).bold(),
		_ => base_style(),
	}
}

/// Paints one transcript line, rendering each `<ref image=N/>` tag as a
/// compact `<icon> #N` pill filled with the attachment's identity color.
fn draw_submission_text(
	frame: &mut Frame,
	x: u16,
	y: u16,
	width: u16,
	line: &str,
	charset: Charset,
) {
	let icon = charset.icon(Icon::Image);
	let mut chips: SmallVec<(usize, usize, String, usize), 4> = SmallVec::new();
	let mut base = 0;
	while let Some((start, end, marker)) = next_ref_tag(&line[base..]) {
		chips.push((base + start, base + end, format!("{icon} #{marker}"), marker));
		base += end;
	}
	let mut spans: SmallVec<Span<'_>, 8> = SmallVec::new();
	let mut at = 0;
	for (start, end, label, marker) in &chips {
		if *start > at {
			spans.push(Span::new(&line[at..*start], ink(TEXT)));
		}
		spans.push(Span::new(label, Style::new().fg(PANEL).bg(attachment_color(*marker)).bold()));
		at = *end;
	}
	if at < line.len() {
		spans.push(Span::new(&line[at..], ink(TEXT)));
	}
	draw_line(frame, x, y, width, &spans);
}

examples/footers.rs (line 207)

fn compose(scene: &Scene) -> Frame {
	let height = STUDIES
		.iter()
		.map(|study| study.rows + 3)
		.fold(3_u16, u16::saturating_add);
	let mut frame = Frame::new(Size::new(scene.width, height));
	frame.fill(Rect::new(0, 0, scene.width, height), ink(TEXT));

	let column = frame.put(1, 0, "composer footer studies", ink(TEXT).bold());
	frame.put(
		column.saturating_add(2),
		0,
		"split + air gap, six session-title placements",
		ink(MUTED),
	);
	frame.put(1, 1, "↑/↓ scroll · PgUp/PgDn page · Home/End jump · q quits", ink(FAINT));

	let mut y = 3_u16;
	for (index, study) in STUDIES.iter().enumerate() {
		let number = fmts!("{:>2} ", index + 1);
		let mut column = frame.put(1, y, &number, ink(GOLD).bold());
		column = frame.put(column, y, study.title, ink(TEXT).bold());
		column = frame.put(column, y, "  ", ink(FAINT));
		frame.put(column, y, study.note, ink(MUTED));
		(study.draw)(&mut frame, y + 1, scene);
		y = y.saturating_add(study.rows + 3);
	}
	frame
}

// ── studies ─────────────────────────────────────────────────────────────────

/// 1: the pi layout verbatim — a bordered composer whose top border
/// carries the session band on the left and the title on the right, with
/// the spinner narrating intent on its own row above the box.
fn study_pi_parity(frame: &mut Frame, y: u16, scene: &Scene) {
	draw_working_spin(frame, 1, y, scene);
	let (tl, tr, bl, br, horizontal, vertical) = border_glyphs(scene.charset);
	let right = scene.right_edge();
	draw_border_row(frame, y + 1, scene, tl, tr, horizontal);
	let segments = [model(scene), omp_brand(scene), git(scene), context(scene), cost()];
	draw_band(frame, 2, y + 1, scene, &segments);
	let band_end = 2_u16.saturating_add(band_width(scene, &segments));
	draw_border_title(frame, y + 1, scene, band_end.saturating_add(2));
	frame.put(0, y + 2, vertical, ink(FAINT));
	frame.put(2, y + 2, beam(scene.charset), ink(TEXT));
	frame.put(right, y + 2, vertical, ink(FAINT));
	draw_border_row(frame, y + 3, scene, bl, br, horizontal);
}

/// 2: split + air gap as picked, with the title moving into the air row
/// so the breathing space doubles as identity.
fn study_gap_title(frame: &mut Frame, y: u16, scene: &Scene) {
	draw_working(frame, 1, y, scene);
	let title = fit_title(scene, scene.width.saturating_sub(2));
	let x = scene
		.width
		.saturating_sub(width_of(&title).saturating_add(1));
	frame.put(x, y + 1, &title, ink(FAINT).italic());
	draw_split_bands(frame, y + 2, scene);
	draw_input(frame, 0, y + 3, scene);
}

/// 3: the title joins the left band beside the brand segment, so the
/// band row itself answers "what session is this"; session facts keep
/// the right cap.
fn study_band_title(frame: &mut Frame, y: u16, scene: &Scene) {
	draw_working(frame, 1, y, scene);
	let right = [model(scene), git(scene), context(scene), Seg::new(COST_SHORT, PURPLE)];
	let right_width = band_width(scene, &right);
	let brand_seg = brand(scene);
	let (_, separator, _) = band_chrome(scene.charset);
	let fixed = band_width(scene, std::slice::from_ref(&brand_seg))
		.saturating_add(width_of(separator).saturating_add(2));
	let budget = scene
		.width
		.saturating_sub(right_width.saturating_add(2))
		.saturating_sub(fixed);
	let left = [brand_seg, Seg::new(fit_title(scene, budget), TEXT)];
	draw_band(frame, 0, y + 2, scene, &left);
	draw_band(frame, scene.width.saturating_sub(right_width), y + 2, scene, &right);
	draw_input(frame, 0, y + 3, scene);
}

/// 4: split + air untouched; the title borrows the prompt row's right
/// edge and would yield to long input lines.
fn study_prompt_title(frame: &mut Frame, y: u16, scene: &Scene) {
	draw_working(frame, 1, y, scene);
	draw_split_bands(frame, y + 2, scene);
	draw_input(frame, 0, y + 3, scene);
	let title = fit_title(scene, scene.width.saturating_sub(8));
	let x = scene
		.width
		.saturating_sub(width_of(&title).saturating_add(1));
	frame.put(x, y + 3, &title, ink(FAINT).italic());
}

/// 5: the title gets its own dim row above the narration, heading the
/// whole live block like a section title.
fn study_crown(frame: &mut Frame, y: u16, scene: &Scene) {
	let title = fit_title(scene, scene.width.saturating_sub(2));
	frame.put(1, y, &title, ink(MUTED).bold());
	draw_working(frame, 1, y + 1, scene);
	draw_split_bands(frame, y + 3, scene);
	draw_input(frame, 0, y + 4, scene);
}

pub const fn dim(self) -> Self

Enables faint intensity.

Examples found in repository

examples/footers.rs (line 460)

fn draw_band(frame: &mut Frame, x: u16, y: u16, scene: &Scene, segments: &[Seg]) {
	let (left_cap, separator, right_cap) = band_chrome(scene.charset);
	let base = Style::new().fg(TEXT).bg(BAND_BG);
	let edge = ink(BAND_BG);
	let mut column = frame.put(x, y, left_cap, edge);
	column = frame.put(column, y, " ", base);
	for (index, segment) in segments.iter().enumerate() {
		if index > 0 {
			column = frame.put(column, y, " ", base.dim());
			column = frame.put(column, y, separator, base.dim());
			column = frame.put(column, y, " ", base.dim());
		}
		column = frame.put(column, y, &segment.label, base.fg(segment.color));
	}
	column = frame.put(column, y, " ", base);
	frame.put(column, y, right_cap, edge);
}

examples/chat/demo.rs (line 465)

	fn paint(&mut self, pc: &mut PaintCtx<'_>, rect: Rect) {
		pc.hits
			.push(Hit { rect, slot: self.slot, tag: HitTag::Press });
		let editor = self.editor.borrow();
		let input_x = rect.x.saturating_add(Self::input_offset());
		let input_width = Self::input_width(rect.width);
		let input_height = editor.input_height_for(input_width);
		let theme = Theme::default();
		let mut in_comment = false;
		for (offset, row) in editor.view(input_width).iter().enumerate() {
			let row_y = rect
				.y
				.saturating_add(u16::try_from(offset).unwrap_or(u16::MAX));
			if row_y >= pc.clip {
				break;
			}
			if offset == 0 {
				pc.frame
					.put(rect.x, row_y, &Self::input_prompt(pc.ctx.charset), ink(FAINT));
			}
			let mut spans: SmallVec<Span<'_>, 16> = SmallVec::new();
			if editor.options().xml {
				let (runs, next) = highlight_xml(row.text, &theme, in_comment);
				in_comment = next;
				push_row_spans(&editor, row.text, &runs, &mut spans);
			} else {
				push_row_spans(&editor, row.text, &[], &mut spans);
			}
			draw_line(pc.frame, input_x, row_y, input_width, &spans);
			if let Some(cursor_column) = row.cursor_column {
				if cursor_column >= visible_width(row.text)
					&& let Some(hint) = editor.inline_hint()
				{
					let hint_x = input_x.saturating_add(cursor_column).saturating_add(1);
					let width = input_width.saturating_sub(cursor_column.saturating_add(1));
					draw_line(pc.frame, hint_x, row_y, width, &[Span::new(
						hint.as_str(),
						ink(MUTED).dim(),
					)]);
				}
				pc.frame.set_cursor(
					input_x
						.saturating_add(cursor_column)
						.min(rect.x.saturating_add(rect.width.saturating_sub(2))),
					row_y,
				);
			}
		}
		Self::paint_picker(pc, rect, rect.y.saturating_add(input_height), &editor);
	}

pub const fn italic(self) -> Self

Enables italics.

Examples found in repository

examples/footers.rs (line 257)

fn study_gap_title(frame: &mut Frame, y: u16, scene: &Scene) {
	draw_working(frame, 1, y, scene);
	let title = fit_title(scene, scene.width.saturating_sub(2));
	let x = scene
		.width
		.saturating_sub(width_of(&title).saturating_add(1));
	frame.put(x, y + 1, &title, ink(FAINT).italic());
	draw_split_bands(frame, y + 2, scene);
	draw_input(frame, 0, y + 3, scene);
}

/// 3: the title joins the left band beside the brand segment, so the
/// band row itself answers "what session is this"; session facts keep
/// the right cap.
fn study_band_title(frame: &mut Frame, y: u16, scene: &Scene) {
	draw_working(frame, 1, y, scene);
	let right = [model(scene), git(scene), context(scene), Seg::new(COST_SHORT, PURPLE)];
	let right_width = band_width(scene, &right);
	let brand_seg = brand(scene);
	let (_, separator, _) = band_chrome(scene.charset);
	let fixed = band_width(scene, std::slice::from_ref(&brand_seg))
		.saturating_add(width_of(separator).saturating_add(2));
	let budget = scene
		.width
		.saturating_sub(right_width.saturating_add(2))
		.saturating_sub(fixed);
	let left = [brand_seg, Seg::new(fit_title(scene, budget), TEXT)];
	draw_band(frame, 0, y + 2, scene, &left);
	draw_band(frame, scene.width.saturating_sub(right_width), y + 2, scene, &right);
	draw_input(frame, 0, y + 3, scene);
}

/// 4: split + air untouched; the title borrows the prompt row's right
/// edge and would yield to long input lines.
fn study_prompt_title(frame: &mut Frame, y: u16, scene: &Scene) {
	draw_working(frame, 1, y, scene);
	draw_split_bands(frame, y + 2, scene);
	draw_input(frame, 0, y + 3, scene);
	let title = fit_title(scene, scene.width.saturating_sub(8));
	let x = scene
		.width
		.saturating_sub(width_of(&title).saturating_add(1));
	frame.put(x, y + 3, &title, ink(FAINT).italic());
}

examples/chat/demo.rs (line 1384)

	fn draw_session_title(frame: &mut Frame, y: u16, right_inset: u16) {
		let width = frame.size().width.saturating_sub(right_inset);
		let title_width = visible_width(SESSION_TITLE);
		if y >= frame.size().height || width < title_width.saturating_add(2) {
			return;
		}
		let x = width.saturating_sub(title_width.saturating_add(1));
		draw_line(frame, x, y, title_width, &[Span::new(SESSION_TITLE, ink(FAINT).italic())]);
	}
}

/// The closed four-row command box that opens the transcript.
fn draw_command_box(frame: &mut Frame, rect: Rect, charset: Charset) {
	draw_box(frame, rect, ink(FAINT), panel_style(), charset);
	if rect.width < 4 || rect.height < 4 {
		return;
	}

	let content_x = rect.x + 2;
	let content_width = rect.width.saturating_sub(4);
	let header = [
		Span::new(" PARALLEL TEST RUN ", panel_ink(GREEN).bold()),
		Span::new("results append below · live rows in the bottom panel", panel_ink(MUTED)),
	];
	draw_line(frame, content_x, rect.y + 1, content_width, &header);
	let command = [
		Span::new("$ ", panel_ink(MUTED)),
		Span::new("bun test --parallel=8", panel_ink(CYAN)),
		Span::new(" --timeout=30000 --all-workspaces", panel_ink(TEXT)),
	];
	draw_line(frame, content_x, rect.y + 2, content_width, &command);
}

/// The live band's shard panel: twelve mutable rows that repaint in place
/// every frame and never enter native scrollback.
fn draw_live_panel(
	frame: &mut Frame,
	rows: &mut [LiveRowCache; LIVE_SHARD_ROWS as usize],
	label_scratch: &mut StrMut,
	rect: Rect,
	repaint_chrome: bool,
	emitted_shards: u16,
	animation_frame: u64,
	charset: Charset,
) -> bool {
	let mut changed = repaint_chrome;
	if repaint_chrome {
		draw_box(frame, rect, ink(FAINT), panel_style(), charset);
	}
	if rect.width < 4 || rect.height < 3 {
		return changed;
	}

	if repaint_chrome {
		let title = [
			Span::new(" LIVE SHARDS ", panel_ink(GREEN).bold()),
			Span::new("mutable rows repaint in place ", panel_ink(MUTED)),
		];
		draw_line(frame, rect.x + 2, rect.y, rect.width.saturating_sub(4), &title);
	}
	let content_x = rect.x + 2;
	let content_width = rect.width.saturating_sub(4);
	for row in 0..rect.height.saturating_sub(2) {
		let shard = emitted_shards.saturating_add(row).saturating_add(1);
		let phase = (u64::from(row) + animation_frame) % 11;
		let (prefix_phase, symbol, state, state_style, progress) = match phase {
			0 => (
				0,
				"⠼",
				"running",
				panel_ink(GREEN).bold(),
				(u64::from(row) * 17 + animation_frame * 7) % 100,
			),
			1..=7 => {
				(1, "·", "working", panel_ink(MUTED), (u64::from(row) * 17 + animation_frame * 7) % 100)
			},
			_ => (2, "·", "queued ", panel_ink(FAINT), 0),
		};
		let row_y = rect.y + 1 + row;
		let right = content_x
			.saturating_add(content_width)
			.min(frame.size().width);
		let cache = &mut rows[usize::from(row)];
		let prefix_changed = repaint_chrome
			|| !cache.prefix_valid
			|| cache.prefix_shard != shard
			|| cache.prefix_phase != prefix_phase;
		changed |= prefix_changed;
		let label_x = if prefix_changed {
			let prefix = fmts!(" {symbol} shard {shard:03} ");
			let prefix_width = prefix.len().saturating_sub(symbol.len()).saturating_add(1);
			let next_x = content_x
				.saturating_add(u16::try_from(prefix_width).unwrap_or(u16::MAX))
				.saturating_add(u16::try_from(state.len()).unwrap_or(u16::MAX))
				.saturating_add(2)
				.min(right);
			if !repaint_chrome && cache.label_x != next_x {
				clear_cached_label(frame, cache, row_y, right);
			}
			let next_x = draw_line(frame, content_x, row_y, content_width, &[
				Span::new(prefix.as_str(), state_style),
				Span::new(state, state_style),
				Span::new("  ", panel_ink(FAINT)),
			]);
			cache.prefix_shard = shard;
			cache.prefix_phase = prefix_phase;
			cache.prefix_valid = true;
			next_x
		} else {
			cache.label_x
		};
		let moved = cache.label_x != label_x;
		let label_changed = repaint_chrome
			|| moved
			|| !cache.label_valid
			|| cache.label_shard != shard
			|| cache.label_progress != progress;
		changed |= label_changed;
		if label_changed {
			label_scratch.truncate(0);
			write!(label_scratch, "workspace-{shard:03}.test.ts  [{progress:>3}%]")
				.expect("shard label formatting is infallible");
			let resized = cache.label.len() != label_scratch.len();
			if !repaint_chrome && resized && !moved {
				clear_cached_label(frame, cache, row_y, right);
			}
			let width = right.saturating_sub(label_x);
			if repaint_chrome || moved || resized {
				frame.put_clipped(label_x, row_y, width, label_scratch.as_str(), panel_ink(MUTED));
			} else {
				draw_ascii_changes(
					frame,
					label_x,
					row_y,
					width,
					cache.label.as_str(),
					label_scratch.as_str(),
					panel_ink(MUTED),
				);
			}
			std::mem::swap(&mut cache.label, label_scratch);
			cache.label_shard = shard;
			cache.label_progress = progress;
			cache.label_valid = true;
		}
		cache.label_x = label_x;
	}
	changed
}

fn clear_cached_label(frame: &mut Frame, cache: &LiveRowCache, y: u16, right: u16) {
	if cache.label.is_empty() {
		return;
	}
	let width = u16::try_from(cache.label.len())
		.unwrap_or(u16::MAX)
		.min(right.saturating_sub(cache.label_x));
	frame.fill(Rect::new(cache.label_x, y, width, 1), panel_style());
}

/// Repaints only changed byte runs within an equal-length ASCII label.
fn draw_ascii_changes(
	frame: &mut Frame,
	x: u16,
	y: u16,
	width: u16,
	previous: &str,
	next: &str,
	style: Style,
) {
	if width == 0 || previous == next {
		return;
	}
	if previous.len() != next.len() || !previous.is_ascii() || !next.is_ascii() {
		frame.put_clipped(x, y, width, next, style);
		return;
	}
	let previous = previous.as_bytes();
	let next_bytes = next.as_bytes();
	let limit = previous.len().min(usize::from(width));
	let mut index = 0;
	while index < limit {
		while index < limit && previous[index] == next_bytes[index] {
			index += 1;
		}
		let start = index;
		while index < limit && previous[index] != next_bytes[index] {
			index += 1;
		}
		if start < index {
			let offset = u16::try_from(start).unwrap_or(u16::MAX);
			frame.put_clipped(
				x.saturating_add(offset),
				y,
				u16::try_from(index - start).unwrap_or(u16::MAX),
				&next[start..index],
				style,
			);
		}
	}
}

fn draw_edit_box(frame: &mut Frame, rect: Rect, charset: Charset) {
	draw_box(frame, rect, ink(FAINT), panel_style(), charset);
	if rect.width < 8 || rect.height < EDIT_BOX_HEIGHT {
		return;
	}

	let title = [
		Span::new(" Live ", panel_ink(GREEN).bold()),
		Span::new("band · selection semantics ", panel_ink(CYAN)),
	];
	draw_line(frame, rect.x + 2, rect.y, rect.width.saturating_sub(4), &title);
	draw_line(frame, rect.x + 2, rect.y + 1, rect.width.saturating_sub(4), &[
		Span::new(charset.check(), panel_ink(GREEN).bold()),
		Span::new(" ", panel_ink(GREEN)),
		Span::new("Transcript selections ride with the text", panel_ink(TEXT)),
	]);
	draw_line(frame, rect.x + 2, rect.y + 2, rect.width.saturating_sub(4), &[Span::new(
		"  margin commits pin the band on kitty-class terminals",
		panel_ink(MUTED),
	)]);
}

/// Paints a submitted message: the prompt gutter, then the rendered
/// Markdown document blitted beside it (or the raw lines when the text
/// isn't renderable as Markdown).
fn draw_submission(frame: &mut Frame, y: u16, submission: &Submission, charset: Charset) {
	if frame.size().width < 4 {
		return;
	}
	let Some(view) = &submission.view else {
		for (offset, line) in submission.text.split('\n').enumerate() {
			let Ok(offset) = u16::try_from(offset) else {
				break;
			};
			let row = y.saturating_add(offset);
			if row >= frame.size().height {
				break;
			}
			let prompt = if offset == 0 { charset.cursor() } else { "  " };
			let text_x = frame.put(1, row, prompt, ink(GREEN).bold());
			let width = frame
				.size()
				.width
				.saturating_sub(1)
				.saturating_sub(text_x.saturating_sub(1));
			draw_submission_text(frame, text_x, row, width, line, charset);
		}
		return;
	};
	frame.put(1, y, charset.cursor(), ink(GREEN).bold());
	frame.blit(view.frame(), 0, view.height(), 3, y);
}
fn explicit_line_count(text: &str) -> u16 {
	u16::try_from(
		text
			.bytes()
			.filter(|byte| *byte == b'\n')
			.count()
			.saturating_add(1),
	)
	.unwrap_or(u16::MAX)
}

/// Paints a rounded panel box through the tier's border glyphs.
fn draw_box(frame: &mut Frame, rect: Rect, border: Style, fill: Style, charset: Charset) {
	if rect.width == 0 || rect.height == 0 {
		return;
	}
	let (tl, tr, _, _, horizontal, vertical) = charset.border(Border::Round);
	frame.fill(rect, fill);
	let mut glyph = [0_u8; 4];
	if rect.width == 1 {
		frame.put(rect.x, rect.y, vertical.encode_utf8(&mut glyph), border);
		return;
	}

	let right = rect.x + rect.width - 1;
	let bottom = rect.y + rect.height - 1;
	frame.put(rect.x, rect.y, tl.encode_utf8(&mut glyph), border);
	frame.put(right, rect.y, tr.encode_utf8(&mut glyph), border);
	for x in rect.x + 1..right {
		frame.put(x, rect.y, horizontal.encode_utf8(&mut glyph), border);
	}

	if rect.height > 1 {
		draw_box_bottom(frame, rect, border, charset);
	}
	for row in rect.y + 1..bottom {
		frame.put(rect.x, row, vertical.encode_utf8(&mut glyph), border);
		frame.put(right, row, vertical.encode_utf8(&mut glyph), border);
	}
}

fn draw_box_bottom(frame: &mut Frame, rect: Rect, border: Style, charset: Charset) {
	if rect.width < 2 || rect.height < 2 {
		return;
	}
	let (_, _, bl, br, horizontal, _) = charset.border(Border::Round);
	let mut glyph = [0_u8; 4];
	let right = rect.x + rect.width - 1;
	let bottom = rect.y + rect.height - 1;
	frame.put(rect.x, bottom, bl.encode_utf8(&mut glyph), border);
	frame.put(right, bottom, br.encode_utf8(&mut glyph), border);
	for x in rect.x + 1..right {
		frame.put(x, bottom, horizontal.encode_utf8(&mut glyph), border);
	}
}

fn draw_line(frame: &mut Frame, x: u16, y: u16, width: u16, spans: &[Span<'_>]) -> u16 {
	let right = x.saturating_add(width).min(frame.size().width);
	let mut column = x;
	for span in spans {
		column = frame.put_clipped(column, y, right.saturating_sub(column), span.text, span.style);
		if column >= right {
			break;
		}
	}
	column
}

/// Flows `spans` grapheme-exact across the rect like a bare terminal,
/// preserving all whitespace and flagging each exactly-filled row boundary
/// soft so native selection copies the paragraph as one unbroken line.
/// Returns the rows used.
fn draw_flowed(frame: &mut Frame, rect: Rect, spans: &[Span<'_>]) -> u16 {
	if rect.width == 0 || rect.height == 0 {
		return 0;
	}
	let full_row = rect.x == 0 && rect.width == frame.size().width;
	let mut row = 0_u16;
	let mut column = 0_u16;
	let mut drew_anything = false;

	for span in spans {
		for grapheme in xutf::graphemes_str(span.text) {
			let grapheme_width = visible_width(grapheme);
			if grapheme_width == 0 || grapheme_width > rect.width {
				continue;
			}
			if column.saturating_add(grapheme_width) > rect.width {
				// Only an exactly-filled row is byte-joinable by autowrap.
				if full_row && column == rect.width {
					frame.set_soft_wrap(rect.y.saturating_add(row));
				}
				row += 1;
				column = 0;
			}
			if row >= rect.height {
				return rect.height;
			}
			frame.put(rect.x + column, rect.y + row, grapheme, span.style);
			column += grapheme_width;
			drew_anything = true;
		}
	}

	if drew_anything { row + 1 } else { 0 }
}

fn visible_width(text: &str) -> u16 {
	u16::try_from(xutf::width_str(text)).unwrap_or(u16::MAX)
}

/// Finds the first `<ref image=N/>` tag in submitted text: its byte range
/// plus the marker number `N`.
fn next_ref_tag(text: &str) -> Option<(usize, usize, usize)> {
	const HEAD: &str = "<ref image=";
	let mut from = 0;
	while let Some(at) = text[from..].find(HEAD) {
		let start = from + at;
		let body = &text[start + HEAD.len()..];
		let digits = body.bytes().take_while(u8::is_ascii_digit).count();
		if digits > 0 && body[digits..].starts_with("/>") {
			let marker = body[..digits].parse().unwrap_or(usize::MAX);
			return Some((start, start + HEAD.len() + digits + 2, marker));
		}
		from = start + HEAD.len();
	}
	None
}

/// Splits one composer input row into base-styled text and attachment
/// chips, chip styling winning over any overlapping XML run.
///
/// Chips are located through the buffer's atomic ranges — like the XML
/// pass, styling happens at paint time, and typed lookalike text is never
/// recolored.
fn push_row_spans<'a>(
	editor: &Editor,
	row: &'a str,
	runs: &[SyntaxRun],
	spans: &mut SmallVec<Span<'a>, 16>,
) {
	let text = editor.text();
	let buffer_start = text.as_ptr() as usize;
	let row_start = (row.as_ptr() as usize).saturating_sub(buffer_start);
	let row_end = row_start + row.len();
	// Chip segments clipped to this row; style derives from the FULL atom
	// text, so a chip wrapped across rows keeps its color on every row.
	let mut chips: SmallVec<(usize, usize, Style), 4> = SmallVec::new();
	for (start, end) in editor.atom_ranges() {
		let from = start.max(row_start);
		let to = end.min(row_end);
		if from < to {
			chips.push((from - row_start, to - row_start, chip_style(&text[start..end])));
		}
	}
	// The style and extent of the base segment covering `at`: its XML run,
	// or plain text up to the next run.
	let base = |at: usize| {
		runs
			.iter()
			.find(|run| run.start <= at && at < run.end)
			.map_or_else(
				|| {
					let next = runs
						.iter()
						.map(|run| run.start)
						.filter(|start| *start > at)
						.min()
						.unwrap_or(row.len());
					(next, base_style())
				},
				|run| (run.end, run.style),
			)
	};
	fn emit<'a>(
		row: &'a str,
		base: &impl Fn(usize) -> (usize, Style),
		from: usize,
		to: usize,
		spans: &mut SmallVec<Span<'a>, 16>,
	) {
		let mut at = from;
		while at < to {
			let (run_end, style) = base(at);
			let end = run_end.min(to);
			spans.push(Span::new(&row[at..end], style));
			at = end;
		}
	}
	let mut at = 0;
	for (start, end, style) in chips {
		emit(row, &base, at, start, spans);
		spans.push(Span::new(&row[start..end], style));
		at = end;
	}
	emit(row, &base, at, row.len(), spans);
}

/// Style for one atomic chip: a trailing `#N` selects the marker's
/// identity color; other atoms stay plain.
fn chip_style(chip: &str) -> Style {
	let Some(hash) = chip.rfind('#') else {
		return base_style();
	};
	let digits = &chip[hash + 1..];
	if digits.is_empty() || !digits.bytes().all(|byte| byte.is_ascii_digit()) {
		return base_style();
	}
	match digits.parse::<usize>() {
		Ok(marker) if marker > 0 => ink(attachment_color(marker)).bold(),
		_ => base_style(),
	}
}

/// Paints one transcript line, rendering each `<ref image=N/>` tag as a
/// compact `<icon> #N` pill filled with the attachment's identity color.
fn draw_submission_text(
	frame: &mut Frame,
	x: u16,
	y: u16,
	width: u16,
	line: &str,
	charset: Charset,
) {
	let icon = charset.icon(Icon::Image);
	let mut chips: SmallVec<(usize, usize, String, usize), 4> = SmallVec::new();
	let mut base = 0;
	while let Some((start, end, marker)) = next_ref_tag(&line[base..]) {
		chips.push((base + start, base + end, format!("{icon} #{marker}"), marker));
		base += end;
	}
	let mut spans: SmallVec<Span<'_>, 8> = SmallVec::new();
	let mut at = 0;
	for (start, end, label, marker) in &chips {
		if *start > at {
			spans.push(Span::new(&line[at..*start], ink(TEXT)));
		}
		spans.push(Span::new(label, Style::new().fg(PANEL).bg(attachment_color(*marker)).bold()));
		at = *end;
	}
	if at < line.len() {
		spans.push(Span::new(&line[at..], ink(TEXT)));
	}
	draw_line(frame, x, y, width, &spans);
}

/// Chrome outside a panel is transparent: no `bg`, so the terminal's own
/// background (and any image or blur behind it) shows through. Only the
/// panel boxes below opt into a fill.
const fn base_style() -> Style {
	Style::new().fg(TEXT)
}

const fn panel_style() -> Style {
	Style::new().fg(TEXT).bg(PANEL)
}

const fn ink(color: Color) -> Style {
	Style::new().fg(color)
}

const fn panel_ink(color: Color) -> Style {
	Style::new().fg(color).bg(PANEL)
}

const fn prose_style() -> Style {
	Style::new().fg(MUTED).italic()
}

pub const fn underline(self) -> Self

Enables underlining.

pub const fn underline_color(self, color: Color) -> Self

Sets the underline color (SGR 58); Color::Default leaves the terminal’s underline color untouched.

pub const fn reverse(self) -> Self

Enables reverse video.

pub const fn strikethrough(self) -> Self

Enables strikethrough.

pub fn link(self, url: &str) -> Self

Attaches a terminal hyperlink target to this style.

The URL is interned once and only its typed identity rides on rich-text runs and frame cells. Empty targets are ignored.

pub const fn inherit(self, parent: Self) -> Self

CSS-like cascade: unset properties adopt the parent’s. A Color::Default foreground counts as unset and attribute flags OR together. The background never inherits — ancestor fills reach descendants through the paint underlay instead.

pub const fn foreground_color(&self) -> Color

The foreground color, for callers deriving accents from a style.

pub const fn background_color(&self) -> Color

The background color, for callers deciding whether to fill a region.

Trait Implementations

impl Clone for Style

fn clone(&self) -> Style

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for Style

impl Debug for Style

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Style

fn default() -> Style

Returns the “default value” for a type.

impl Eq for Style

impl PartialEq for Style

fn eq(&self, other: &Style) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for Style