Struct Renderer 

pub struct Renderer<W: Write> { /* private fields */ }

A struct that outputs lines to a writer.

Implementations

impl<W: Write> Renderer<W>

pub fn new(writer: W) -> Self

Creates a new Renderer that writes to the given writer.

Examples found in repository

examples/input.rs (line 13)

fn main() -> std::io::Result<()> {
    let stdout = std::io::stdout().into_raw_mode()?;
    let mut r = Renderer::new(stdout);

    let mut name = String::new();

    let mut events = std::io::stdin().events();
    loop {
        r.clear()?;
        r.render((
            "Enter your name: ".into_element(),
            (name.into_element(), Cursor, Gap(1))
                .fixed_width(20)
                .truncated(Direction::Left)
                .with_style(Style::bg(240)),
        ))?;
        r.finish()?;

        let Some(event) = events.next().transpose()? else {
            break;
        };
        match event {
            Event::Key(Key::Char(ch)) if !ch.is_ascii_control() => name.push(ch),
            Event::Key(Key::Char('\n' | '\r')) => break,
            Event::Key(Key::Backspace) => {
                name.pop();
            }
            _ => {}
        }
    }

    r.clear()?;
    drop(r);
    println!("Your name is {name:?}");
    Ok(())
}

pub fn reset(&mut self) -> Result<&mut Self>

Resets the cursor position. This should be called before render.

pub fn clear(&mut self) -> Result<()>

Clears the rendering area, resetting the terminal back to its initial state.

Note that this function is automatically called when the Renderer is dropped.

Examples found in repository

examples/input.rs (line 19)

fn main() -> std::io::Result<()> {
    let stdout = std::io::stdout().into_raw_mode()?;
    let mut r = Renderer::new(stdout);

    let mut name = String::new();

    let mut events = std::io::stdin().events();
    loop {
        r.clear()?;
        r.render((
            "Enter your name: ".into_element(),
            (name.into_element(), Cursor, Gap(1))
                .fixed_width(20)
                .truncated(Direction::Left)
                .with_style(Style::bg(240)),
        ))?;
        r.finish()?;

        let Some(event) = events.next().transpose()? else {
            break;
        };
        match event {
            Event::Key(Key::Char(ch)) if !ch.is_ascii_control() => name.push(ch),
            Event::Key(Key::Char('\n' | '\r')) => break,
            Event::Key(Key::Backspace) => {
                name.pop();
            }
            _ => {}
        }
    }

    r.clear()?;
    drop(r);
    println!("Your name is {name:?}");
    Ok(())
}

pub fn render<E: Element>(&mut self, line: E) -> Result<&mut Self>

Renders a line.

Examples found in repository

examples/input.rs (lines 20-26)

fn main() -> std::io::Result<()> {
    let stdout = std::io::stdout().into_raw_mode()?;
    let mut r = Renderer::new(stdout);

    let mut name = String::new();

    let mut events = std::io::stdin().events();
    loop {
        r.clear()?;
        r.render((
            "Enter your name: ".into_element(),
            (name.into_element(), Cursor, Gap(1))
                .fixed_width(20)
                .truncated(Direction::Left)
                .with_style(Style::bg(240)),
        ))?;
        r.finish()?;

        let Some(event) = events.next().transpose()? else {
            break;
        };
        match event {
            Event::Key(Key::Char(ch)) if !ch.is_ascii_control() => name.push(ch),
            Event::Key(Key::Char('\n' | '\r')) => break,
            Event::Key(Key::Backspace) => {
                name.pop();
            }
            _ => {}
        }
    }

    r.clear()?;
    drop(r);
    println!("Your name is {name:?}");
    Ok(())
}

pub fn finish(&mut self) -> Result<()>

Finishes rendering. This should be called after render and before polling inputs.

Examples found in repository

examples/input.rs (line 27)

fn main() -> std::io::Result<()> {
    let stdout = std::io::stdout().into_raw_mode()?;
    let mut r = Renderer::new(stdout);

    let mut name = String::new();

    let mut events = std::io::stdin().events();
    loop {
        r.clear()?;
        r.render((
            "Enter your name: ".into_element(),
            (name.into_element(), Cursor, Gap(1))
                .fixed_width(20)
                .truncated(Direction::Left)
                .with_style(Style::bg(240)),
        ))?;
        r.finish()?;

        let Some(event) = events.next().transpose()? else {
            break;
        };
        match event {
            Event::Key(Key::Char(ch)) if !ch.is_ascii_control() => name.push(ch),
            Event::Key(Key::Char('\n' | '\r')) => break,
            Event::Key(Key::Backspace) => {
                name.pop();
            }
            _ => {}
        }
    }

    r.clear()?;
    drop(r);
    println!("Your name is {name:?}");
    Ok(())
}

Trait Implementations

impl<W: Write> Drop for Renderer<W>

fn drop(&mut self)

Executes the destructor for this type.