Struct Key 

pub struct Key {
    pub name: String,
    pub text: Option<String>,
    pub ctrl: bool,
    pub alt: bool,
    pub shift: bool,
    pub meta: bool,
}

One key press, or a paste (name "paste" with its text).

Fields

name: String

The key: a lowercase character ("a", "é"), "space", a named key ("enter", "up", "f5", …) or "paste".

text: Option<String>

What the key types, when it types something.

ctrl: bool

Control held.

alt: bool

Alt (Option) held.

shift: bool

Shift held.

meta: bool

Cmd on macOS, Super elsewhere.

Implementations

impl Key

pub fn named(name: impl Into<String>) -> Self

A key without modifiers or text.

pub fn is(&self, chord: &str) -> bool

Whether this is the chord chord: modifiers and a name joined by + ("ctrl+c", "shift+tab", "escape", "ctrl++"), every modifier matching exactly.

Example

use tern_sdk::keys::Key;

let key = Key { ctrl: true, ..Key::named("c") };
assert!(key.is("ctrl+c"));
assert!(!key.is("c"));

Examples found in repository

examples/progress.rs (line 95)

fn wait(session: &mut Session, time: Duration) -> Result<bool, tern_sdk::Error> {
	let until = Instant::now() + time;
	loop {
		let left = until.saturating_duration_since(Instant::now());
		match session.next(Some(left))? {
			None => return Ok(false),
			Some(Input::Key(key)) if key.is("ctrl+c") => return Ok(true),
			Some(_) => {},
		}
	}
}

examples/chat.rs (line 139)

fn main() -> Result<(), tern_sdk::Error> {
	let Some(mut session) = Session::connect(Options::new().feature(feature::SEND))? else {
		println!("chat needs a terminal that speaks TSP (Tern).");
		return Ok(());
	};
	let sf = session.open(SurfaceOptions::inline().title("chat"))?;
	let mut chat = Chat::default();
	session.render(sf, chat.view())?;
	session.focus(sf, Some(EDITOR))?;
	while let Some(input) = session.next(None)? {
		match input {
			Input::Key(key) => {
				if key.is("escape") || key.is("ctrl+c") || key.is("ctrl+d") {
					break;
				}
				match key.name.as_str() {
					"enter" if !key.shift && !key.alt => {
						let text = std::mem::take(&mut chat.draft);
						chat.cursor = 0;
						chat.send(text);
					},
					"enter" => chat.insert("\n"),
					"backspace" if chat.cursor > 0 => {
						let at = chat.byte(chat.cursor - 1);
						chat.draft.remove(at);
						chat.cursor -= 1;
					},
					"delete" if chat.cursor < chat.draft.chars().count() => {
						let at = chat.byte(chat.cursor);
						chat.draft.remove(at);
					},
					"left" => chat.cursor = chat.cursor.saturating_sub(1),
					"right" => chat.cursor = (chat.cursor + 1).min(chat.draft.chars().count()),
					"home" => chat.cursor = 0,
					"end" => chat.cursor = chat.draft.chars().count(),
					"paste" => chat.insert(key.text.as_deref().unwrap_or_default()),
					_ => match key.typed() {
						Some(text) => chat.insert(text),
						None => continue,
					},
				}
			},
			Input::Msg(Msg::Send(text), _) => chat.send(text),
			Input::Msg(Msg::Focus, _) => session.focus(sf, Some(EDITOR))?,
			Input::Event(_) => continue,
		}
		session.render(sf, chat.view())?;
	}
	session.close()?;
	println!("Chat closed after {} messages.", chat.transcript.len());
	Ok(())
}

pub fn typed(&self) -> Option<&str>

Whether the key types text without Control, Alt or Meta held.

Examples found in repository

examples/chat.rs (line 163)

fn main() -> Result<(), tern_sdk::Error> {
	let Some(mut session) = Session::connect(Options::new().feature(feature::SEND))? else {
		println!("chat needs a terminal that speaks TSP (Tern).");
		return Ok(());
	};
	let sf = session.open(SurfaceOptions::inline().title("chat"))?;
	let mut chat = Chat::default();
	session.render(sf, chat.view())?;
	session.focus(sf, Some(EDITOR))?;
	while let Some(input) = session.next(None)? {
		match input {
			Input::Key(key) => {
				if key.is("escape") || key.is("ctrl+c") || key.is("ctrl+d") {
					break;
				}
				match key.name.as_str() {
					"enter" if !key.shift && !key.alt => {
						let text = std::mem::take(&mut chat.draft);
						chat.cursor = 0;
						chat.send(text);
					},
					"enter" => chat.insert("\n"),
					"backspace" if chat.cursor > 0 => {
						let at = chat.byte(chat.cursor - 1);
						chat.draft.remove(at);
						chat.cursor -= 1;
					},
					"delete" if chat.cursor < chat.draft.chars().count() => {
						let at = chat.byte(chat.cursor);
						chat.draft.remove(at);
					},
					"left" => chat.cursor = chat.cursor.saturating_sub(1),
					"right" => chat.cursor = (chat.cursor + 1).min(chat.draft.chars().count()),
					"home" => chat.cursor = 0,
					"end" => chat.cursor = chat.draft.chars().count(),
					"paste" => chat.insert(key.text.as_deref().unwrap_or_default()),
					_ => match key.typed() {
						Some(text) => chat.insert(text),
						None => continue,
					},
				}
			},
			Input::Msg(Msg::Send(text), _) => chat.send(text),
			Input::Msg(Msg::Focus, _) => session.focus(sf, Some(EDITOR))?,
			Input::Event(_) => continue,
		}
		session.render(sf, chat.view())?;
	}
	session.close()?;
	println!("Chat closed after {} messages.", chat.transcript.len());
	Ok(())
}

Trait Implementations

impl Clone for Key

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Key

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

Formats the value using the given formatter.

impl Default for Key

fn default() -> Self

Returns the “default value” for a type.

impl Display for Key

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

Formats the value using the given formatter.

impl Eq for Key

impl PartialEq for Key

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for Key

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Key