Enum ClipboardRead 

pub enum ClipboardRead {
    Smart,
    Text,
}

Scope of one background clipboard read.

Variants

Smart

Smart content: image, then copied file paths, then text (read_clipboard).

Text

Plain text only (read_clipboard_text) — the Ctrl+Shift+V verbatim-insert contract, no image or file-URL interpretation.

Implementations

impl ClipboardRead

pub const fn for_key(key: Key) -> Option<Self>

The read a paste chord requests: Key::Paste smart, Key::PasteRaw text-only, anything else none.

Examples found in repository

examples/chat/main.rs (line 209)

async fn chat<'a>(
	terminal: &'a mut Terminal,
	renderer: &'a mut Renderer<TtyOut>,
	ctx: &'a UiContext,
) -> io::Result<()> {
	let mut viewport = terminal.size()?;
	if !run_welcome(terminal, renderer, ctx.charset, &mut viewport).await? {
		return Ok(());
	}
	// The welcome scene held the alternate screen; releasing it restores the
	// untouched shell and the chat pushes inline from a clean slate.
	terminal.leave_alt()?;

	let mut demo = Demo::new(ctx);
	let mut overlay: Option<Overlay> = None;
	let mut current_model = 0_usize;
	let started = Instant::now();
	let mut sidebar = Sidebar::new(MODELS[current_model].name, ctx);
	demo.set_right_inset(sidebar.reserved(viewport));
	{
		let rendered = demo.render(viewport);
		let layers = rail_layers(&mut sidebar, viewport, started.elapsed());
		present(renderer, rendered, viewport, &layers)?;
	}

	// Alternate-screen ownership for the chat scene: a resize gesture borrows
	// it for throwaway drag frames, an open overlay holds it for its lifetime.
	let mut drag_alt = false;
	let mut overlay_stale = false;
	let mut resize = None;
	// At most one in-flight background clipboard read (Ctrl+V/Ctrl+Shift+V).
	let mut paste_read: Option<PasteRead> = None;
	let mut next_frame = Instant::now() + FRAME_INTERVAL;
	loop {
		let paste_deadline = paste_read.as_ref().map(|read| read.abandon_at);
		tokio::select! {
			// The terminal branch pauses while a clipboard read is in flight:
			// the event mailbox buffers input in order, so an Enter typed
			// right after Ctrl+V lands *after* the paste instead of
			// submitting an empty prompt. The read below is bounded, so the
			// pause is too; retained App hosts get the finer-grained
			// per-event queue instead.
			event = terminal.next(), if paste_read.is_none() => match event? {
				TerminalEvent::Resize => {
					let now = Instant::now();
					let resized = observe_resize(terminal, &mut viewport, &mut resize, now)?;
					demo.set_right_inset(sidebar.reserved(viewport));
					if overlay.is_some() && resized {
						overlay_stale = true;
					}
				},
				TerminalEvent::Debug(_) => {},
				TerminalEvent::Closed => return Ok(()),
				TerminalEvent::Input(event) => {
					let Some(event) = user_event(terminal, renderer, event)? else {
						continue;
					};
					match event {
					InputEvent::Key(key) => {
						if overlay.is_some() {
							if key == Key::Ctrl('c') {
								break;
							}
							let event = overlay
								.as_mut()
								.expect("overlay checked above")
								.handle_key(key);
							if apply_overlay_event(
								event,
								&mut overlay,
								&mut current_model,
								terminal,
								renderer,
								&mut demo,
								&mut sidebar,
								viewport,
								started.elapsed(),
								&mut overlay_stale,
								&mut resize,
								ctx,
							)? {
								break;
							}
						} else if key == Key::Ctrl('b') {
							sidebar.toggle();
							demo.set_right_inset(sidebar.reserved(viewport));
						} else if key == Key::Ctrl('k') {
							overlay = Some(Overlay::Palette(CommandPalette::open(ctx)));
							open_overlay(
								terminal,
								renderer,
								&mut demo,
								overlay.as_mut().expect("palette just opened"),
								&mut sidebar,
								viewport,
								started.elapsed(),
								&mut drag_alt,
								&mut overlay_stale,
								&mut resize,
							)?;
						} else if sidebar.focused() {
							if key == Key::Ctrl('c') {
								break;
							}
							sidebar.handle_key(key);
						} else if key == Key::Ctrl('p') || key == Key::Alt('p') {
							overlay = Some(Overlay::Picker(ModelPicker::open(current_model, ctx)));
							open_overlay(
								terminal,
								renderer,
								&mut demo,
								overlay.as_mut().expect("picker just opened"),
								&mut sidebar,
								viewport,
								started.elapsed(),
								&mut drag_alt,
								&mut overlay_stale,
								&mut resize,
							)?;
						} else if let Some(scope) = ClipboardRead::for_key(key) {
							// The terminal did not claim the chord; read the
							// system clipboard off-thread, preferring images
							// unless the raw spelling asked for text only. A
							// failed spawn closes the channel, so the receive
							// branch below recovers input immediately.
							paste_read = Some(PasteRead::start(scope));
						} else {
							let quit = demo.handle_key(key);
							if demo.take_switch_request() {
								overlay = Some(Overlay::Picker(ModelPicker::open(current_model, ctx)));
								open_overlay(
									terminal,
									renderer,
									&mut demo,
									overlay.as_mut().expect("picker just opened"),
									&mut sidebar,
									viewport,
									started.elapsed(),
									&mut drag_alt,
									&mut overlay_stale,
									&mut resize,
								)?;
							}
							if quit {
								break;
							}
						}
						next_frame = Instant::now();
					},
					InputEvent::Paste(text) => {
						let event = overlay.as_mut().map(|active| active.handle_paste(&text));
						match event {
							Some(event) => {
								if apply_overlay_event(
									event,
									&mut overlay,
									&mut current_model,
									terminal,
									renderer,
									&mut demo,
									&mut sidebar,
									viewport,
									started.elapsed(),
									&mut overlay_stale,
									&mut resize,
									ctx,
								)? {
									break;
								}
							},
							None if sidebar.focused() => {},
							None => demo.handle_paste(&text),
						}
						next_frame = Instant::now();
					},
					InputEvent::Mouse(report) => {
						// An open overlay owns pointer input — hover, wheel,
						// and clicks route through the compositor's band,
						// never the occluded editor beneath.
						let event = overlay
							.as_mut()
							.map(|active| active.handle_mouse(report.col, report.row, report.kind, viewport));
						match event {
							Some(event) => {
								if apply_overlay_event(
									event,
									&mut overlay,
									&mut current_model,
									terminal,
									renderer,
									&mut demo,
									&mut sidebar,
									viewport,
									started.elapsed(),
									&mut overlay_stale,
									&mut resize,
									ctx,
								)? {
									break;
								}
							},
							None => {
								if !sidebar.handle_mouse(report.col, report.row, report.kind, viewport)
								{
									demo.handle_mouse(&report);
								}
							},
						}
						next_frame = Instant::now();
					},
					InputEvent::Focus(_) | InputEvent::Response(_) => {},
				}
				},
			},
			clipboard = async { (&mut paste_read.as_mut().expect("branch gated on Some").clipboard).await },
				if paste_read.is_some() =>
			{
				let read = paste_read.take().expect("branch gated on Some");
				// A closed channel (the reader thread never spawned) reads
				// as an empty clipboard.
				if let Ok(Some(clipboard)) = clipboard
					&& let Some(text) = clipboard_paste_text(clipboard)
					&& overlay.is_none()
					&& !sidebar.focused()
				{
					// Ctrl+Shift+V inserts verbatim: no attachment staging,
					// no large-paste collapse.
					match read.scope {
						ClipboardRead::Text => demo.handle_paste_raw(&text),
						ClipboardRead::Smart => demo.handle_paste(&text),
					}
					next_frame = Instant::now();
				}
			},
			// The deadline is absolute, so the frame tick recreating this
			// branch's future cannot reset it: a hung reader is abandoned and
			// terminal input re-enables. Dropping the receiver makes the
			// reader's eventual send fail; the detached thread dies with the
			// process instead of stalling shutdown.
			() = deadline(paste_deadline) => {
				paste_read = None;
			},
			() = deadline(Some(next_frame)) => {
				let now = Instant::now();
				let resized = observe_resize(terminal, &mut viewport, &mut resize, now)?;
				demo.set_right_inset(sidebar.reserved(viewport));
				if overlay.is_some() && resized {
					overlay_stale = true;
				}
				if resize.is_some() {
					// Drag frames compose exactly one viewport tail at the
					// new geometry — O(viewport) per frame; the O(history)
					// transcript reflow waits for the settle rebuild (or the
					// overlay close). Without an overlay, a width change
					// borrows the alternate screen (the inline transcript
					// rewraps underneath) while height-only churn repaints
					// in place — alt toggling on a height echo can
					// self-sustain.
					let preview = demo.render_resize_preview(viewport);
					if let Some(active) = overlay.as_mut() {
								  let mut layers = rail_layers(&mut sidebar, viewport, started.elapsed());
								  layers.push(active.layer(viewport));
								  renderer.preview_overlaid(&preview, &layers, viewport.height, "")?;
							  } else {
								  let width_changed =
									  resize.is_some_and(|state| state.width_changed);
								  let alt_enter = if drag_alt || !width_changed {
									  None
								  } else {
									  let staged = terminal.stage_alt_enter(AltScreenUse::Resize);
									  drag_alt = staged.is_some();
									  staged
								  };
								  let layers = rail_layers(&mut sidebar, viewport, started.elapsed());
								  renderer.preview_overlaid(
									  &preview,
									  &layers,
									  viewport.height,
									  alt_enter.as_deref().unwrap_or(""),
								  )?;
							  }
				} else if let Some(active) = overlay.as_mut() {
					let rendered = demo.render(viewport);
					let mut layers = rail_layers(&mut sidebar, viewport, started.elapsed());
					layers.push(active.layer(viewport));
					renderer.preview_overlaid(rendered.frame, &layers, viewport.height, "")?;
				} else {
					let rendered = demo.render(viewport);
					let layers = rail_layers(&mut sidebar, viewport, started.elapsed());
					present(renderer, rendered, viewport, &layers)?;
				}
				next_frame = now + FRAME_INTERVAL;
			},
			() = deadline(resize.map(ResizeState::deadline)) => {
				let now = Instant::now();
				if !resize.is_some_and(|state| state.settled(now)) {
					continue;
				}
				if overlay.is_some() {
					// The overlay keeps holding the alternate screen; the
					// transcript reflows once at close.
					overlay_stale = true;
					resize = None;
					continue;
				}
				demo.set_right_inset(sidebar.reserved(viewport));
				let rendered = demo.render(viewport);
				let alt_exit = if drag_alt {
					drag_alt = false;
					terminal.stage_alt_leave().unwrap_or("")
				} else {
					""
				};
				renderer.rebuild(
					rendered.frame.clone(),
					viewport.height,
					rendered.stable_rows,
					alt_exit,
				)?;
				// The rebuild repainted the raw document; recomposite the
				// rail on top without touching the fresh history.
				let layers = rail_layers(&mut sidebar, viewport, started.elapsed());
				if !layers.is_empty() {
					renderer.present_overlaid(
						rendered.frame,
						&[],
						viewport.height,
						rendered.stable_rows,
						&layers,
					)?;
				}
				resize = None;
				next_frame = now + FRAME_INTERVAL;
			},
		}
	}
	Ok(())
}

Trait Implementations

impl Clone for ClipboardRead

fn clone(&self) -> ClipboardRead

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for ClipboardRead

impl Debug for ClipboardRead

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

Formats the value using the given formatter.

impl Eq for ClipboardRead

impl PartialEq for ClipboardRead

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for ClipboardRead