[−][src]Struct terminal::Terminal
A simple interface to perform operations on the terminal. It also allows terminal values to be queried.
Examples
use terminal::{Clear, Action, Value, Retrieved, error}; pub fn main() -> error::Result<()> { let terminal = terminal::stdout(); // perform an single action. terminal.act(Action::ClearTerminal(Clear::All))?; // batch multiple actions. for i in 0..100 { terminal.batch(Action::MoveCursorTo(0, i))?; } // execute batch. terminal.flush_batch(); // get an terminal value. if let Retrieved::TerminalSize(x, y) = terminal.get(Value::TerminalSize)? { println!("x: {}, y: {}", x, y); } Ok(()) }
Notes
Methods
impl<W: Write> Terminal<W>
[src]
ⓘImportant traits for Terminal<W>pub fn custom(buffer: W) -> Terminal<W>
[src]
Creates a custom buffered Terminal with the given buffer.
pub fn lock_mut(&self) -> Result<TerminalLock<W>>
[src]
Locks this Terminal, returning a mutable lock guard. A deadlock is not possible, instead an error will be returned if a lock is already in use. Make sure this lock is only used at one place. The lock is released when the returned lock goes out of scope.
pub fn act(&self, action: Action) -> Result<()>
[src]
Performs an action on the terminal.
Note
Acquires an lock for underlying mutability, this can be prevented with lock_mut.
pub fn batch(&self, action: Action) -> Result<()>
[src]
Batches an action for later execution. You can flush/execute the batched actions with batch.
Note
Acquires an lock for underlying mutability, this can be prevented with lock_mut.
pub fn flush_batch(&self) -> Result<()>
[src]
Flushes the batched actions, this executes the actions in the order that they were batched. You can batch an action with batch.
Note
Acquires an lock for underlying mutability, this can be prevented with lock_mut.
pub fn get(&self, value: Value) -> Result<Retrieved>
[src]
Gets an value from the terminal.
Trait Implementations
impl<'a, W: Write> Write for Terminal<W>
[src]
fn write(&mut self, buf: &[u8]) -> Result<usize>
[src]
fn flush(&mut self) -> Result<()>
[src]
fn write_vectored(&mut self, bufs: &[IoSlice]) -> Result<usize, Error>
1.36.0[src]
fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>
1.0.0[src]
fn write_fmt(&mut self, fmt: Arguments) -> Result<(), Error>
1.0.0[src]
fn by_ref(&mut self) -> &mut Self
1.0.0[src]
Auto Trait Implementations
impl<W> RefUnwindSafe for Terminal<W>
impl<W> Send for Terminal<W> where
W: Send,
W: Send,
impl<W> Sync for Terminal<W> where
W: Send + Sync,
W: Send + Sync,
impl<W> Unpin for Terminal<W> where
W: Unpin,
W: Unpin,
impl<W> UnwindSafe for Terminal<W>
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
fn borrow_mut(&mut self) -> &mut T
[src]
impl<T, A> ExecutableCommand<A> for T where
A: Display,
T: Write,
[src]
A: Display,
T: Write,
fn execute(
&mut self,
command: impl Command<AnsiType = A>
) -> Result<&mut T, ErrorKind>
[src]
&mut self,
command: impl Command<AnsiType = A>
) -> Result<&mut T, ErrorKind>
Executes the given command directly.
The given command its ANSI escape code will be written and flushed onto Self
.
Arguments
-
The command that you want to execute directly.
Example
use std::io::{Write, stdout}; use crossterm::{Result, ExecutableCommand, style::Print}; fn main() -> Result<()> { // will be executed directly stdout() .execute(Print("sum:\n".to_string()))? .execute(Print(format!("1 + 1= {} ", 1 + 1)))?; Ok(()) // ==== Output ==== // sum: // 1 + 1 = 2 }
Have a look over at the Command API for more details.
Notes
- In the case of UNIX and Windows 10, ANSI codes are written to the given 'writer'.
- In case of Windows versions lower than 10, a direct WinApi call will be made.
The reason for this is that Windows versions lower than 10 do not support ANSI codes,
and can therefore not be written to the given
writer
. Therefore, there is no difference between execute and queue for those old Windows versions.
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T, A> QueueableCommand<A> for T where
A: Display,
T: Write,
[src]
A: Display,
T: Write,
fn queue(
&mut self,
command: impl Command<AnsiType = A>
) -> Result<&mut T, ErrorKind>
[src]
&mut self,
command: impl Command<AnsiType = A>
) -> Result<&mut T, ErrorKind>
Queues the given command for further execution.
Queued commands will be executed in the following cases:
- When
flush
is called manually on the given type implementingio::Write
. - The terminal will
flush
automatically if the buffer is full. - Each line is flushed in case of
stdout
, because it is line buffered.
Arguments
-
The command that you want to queue for later execution.
Examples
use std::io::{Write, stdout}; use crossterm::{Result, QueueableCommand, style::Print}; fn main() -> Result<()> { let mut stdout = stdout(); // `Print` will executed executed when `flush` is called. stdout .queue(Print("foo 1\n".to_string()))? .queue(Print("foo 2".to_string()))?; // some other code (no execution happening here) ... // when calling `flush` on `stdout`, all commands will be written to the stdout and therefore executed. stdout.flush()?; Ok(()) // ==== Output ==== // foo 1 // foo 2 }
Have a look over at the Command API for more details.
Notes
- In the case of UNIX and Windows 10, ANSI codes are written to the given 'writer'.
- In case of Windows versions lower than 10, a direct WinApi call will be made.
The reason for this is that Windows versions lower than 10 do not support ANSI codes,
and can therefore not be written to the given
writer
. Therefore, there is no difference between execute and queue for those old Windows versions.
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,