Struct ascii_forge::window::Window

pub struct Window { /* private fields */ }

The main window behind the application. Represents the terminal window, allowing it to be used similar to a buffer, but has extra event handling.

use ascii_forge::prelude::*;

let mut window = Window::init()?;

render!(
    window,
    [
        (10, 10) => "Element Here!"
    ]
)

Implementations

impl Window

pub fn new(io: Stdout) -> Result<Self>

Creates a new window from the given stdout. Please prefer to use init as it will do all of the terminal init stuff.

pub fn init() -> Result<Self>

Initializes the window, and returns a new Window for your use.

pub fn buffer(&self) -> &Buffer

Returns the active Buffer, as a reference.

pub fn buffer_mut(&mut self) -> &mut Buffer

Returns the active Buffer, as a mutable reference.

pub fn swap_buffers(&mut self)

Swaps the buffers, clearing the old buffer. Used automatically by the window’s update method.

pub fn size(&self) -> Vec2

Returns the current known size of the buffer’s window.

Examples found in repository

examples/simple.rs (line 30)

    fn run(&mut self, window: &mut Window) -> Result<SceneResult, Box<dyn Error>> {
        // Set up a scene
        let mut ui_buffer = Buffer::new((6, 3));

        let chars = ['┌', '─', '┐', '│', ' ', '│', '└', '─', '┘'];
        let nine_slice = ui::NineSlice::new(chars, (6, 3));

        // Render Some elements to the buffer.
        render!(ui_buffer, [
            vec2(0, 0) => nine_slice,
            vec2(1, 1) => "QUIT".green()
        ]);

        // Loop the current scene.
        loop {
            window.update()?;

            // Renders some elements to the window.
            render!(window, [
                vec2(0, 0) => format!("{:?}", cursor::position()?),
                vec2(window.size().x / 2, window.size().y / 4) => ui_buffer,
            ]);

            // If the `q` key was pressed, quit the application by returning no scene.
            if window.code(KeyCode::Char('q')) {
                return Ok(None);
            }

            // If the buffer was clicked on, quit.
            if window.mouse(MouseEventKind::Down(MouseButton::Left))?
                && window.hover(
                    vec2(window.size().x / 2, window.size().y / 4),
                    ui_buffer.size(),
                )?
            {
                return Ok(None);
            }
        }
    }

pub fn restore(self) -> Result<()>

Restores the window to it’s previous state from before the window’s init method.

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

Renders the window to the screen. should really only be used by the update method, but if you need a custom system, you can use this.

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

Handles events, and renders the screen.

Examples found in repository

examples/simple.rs (line 25)

    fn run(&mut self, window: &mut Window) -> Result<SceneResult, Box<dyn Error>> {
        // Set up a scene
        let mut ui_buffer = Buffer::new((6, 3));

        let chars = ['┌', '─', '┐', '│', ' ', '│', '└', '─', '┘'];
        let nine_slice = ui::NineSlice::new(chars, (6, 3));

        // Render Some elements to the buffer.
        render!(ui_buffer, [
            vec2(0, 0) => nine_slice,
            vec2(1, 1) => "QUIT".green()
        ]);

        // Loop the current scene.
        loop {
            window.update()?;

            // Renders some elements to the window.
            render!(window, [
                vec2(0, 0) => format!("{:?}", cursor::position()?),
                vec2(window.size().x / 2, window.size().y / 4) => ui_buffer,
            ]);

            // If the `q` key was pressed, quit the application by returning no scene.
            if window.code(KeyCode::Char('q')) {
                return Ok(None);
            }

            // If the buffer was clicked on, quit.
            if window.mouse(MouseEventKind::Down(MouseButton::Left))?
                && window.hover(
                    vec2(window.size().x / 2, window.size().y / 4),
                    ui_buffer.size(),
                )?
            {
                return Ok(None);
            }
        }
    }

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

Handles events. Used automatically by the update method, so no need to use it unless update is being used.

pub fn mouse_pos(&self) -> Vec2

pub fn event(&self) -> &Option<Event>

Returns the current event for the frame, as a reference.

pub fn mouse(&self, event: MouseEventKind) -> Result<bool>

Returns true if the window had an event with the given mouse input

Examples found in repository

examples/simple.rs (line 39)

    fn run(&mut self, window: &mut Window) -> Result<SceneResult, Box<dyn Error>> {
        // Set up a scene
        let mut ui_buffer = Buffer::new((6, 3));

        let chars = ['┌', '─', '┐', '│', ' ', '│', '└', '─', '┘'];
        let nine_slice = ui::NineSlice::new(chars, (6, 3));

        // Render Some elements to the buffer.
        render!(ui_buffer, [
            vec2(0, 0) => nine_slice,
            vec2(1, 1) => "QUIT".green()
        ]);

        // Loop the current scene.
        loop {
            window.update()?;

            // Renders some elements to the window.
            render!(window, [
                vec2(0, 0) => format!("{:?}", cursor::position()?),
                vec2(window.size().x / 2, window.size().y / 4) => ui_buffer,
            ]);

            // If the `q` key was pressed, quit the application by returning no scene.
            if window.code(KeyCode::Char('q')) {
                return Ok(None);
            }

            // If the buffer was clicked on, quit.
            if window.mouse(MouseEventKind::Down(MouseButton::Left))?
                && window.hover(
                    vec2(window.size().x / 2, window.size().y / 4),
                    ui_buffer.size(),
                )?
            {
                return Ok(None);
            }
        }
    }

pub fn hover<I: Into<Vec2>>(&self, loc: I, size: I) -> Result<bool>

Returns true if the mouse cursor is hovering the given rect.

Examples found in repository

examples/simple.rs (lines 40-43)

    fn run(&mut self, window: &mut Window) -> Result<SceneResult, Box<dyn Error>> {
        // Set up a scene
        let mut ui_buffer = Buffer::new((6, 3));

        let chars = ['┌', '─', '┐', '│', ' ', '│', '└', '─', '┘'];
        let nine_slice = ui::NineSlice::new(chars, (6, 3));

        // Render Some elements to the buffer.
        render!(ui_buffer, [
            vec2(0, 0) => nine_slice,
            vec2(1, 1) => "QUIT".green()
        ]);

        // Loop the current scene.
        loop {
            window.update()?;

            // Renders some elements to the window.
            render!(window, [
                vec2(0, 0) => format!("{:?}", cursor::position()?),
                vec2(window.size().x / 2, window.size().y / 4) => ui_buffer,
            ]);

            // If the `q` key was pressed, quit the application by returning no scene.
            if window.code(KeyCode::Char('q')) {
                return Ok(None);
            }

            // If the buffer was clicked on, quit.
            if window.mouse(MouseEventKind::Down(MouseButton::Left))?
                && window.hover(
                    vec2(window.size().x / 2, window.size().y / 4),
                    ui_buffer.size(),
                )?
            {
                return Ok(None);
            }
        }
    }

pub fn key(&self, key: KeyEvent) -> bool

Returns true if the given key event is pressed.

pub fn code(&self, code: KeyCode) -> bool

Returns true if the given key code is pressed.

Examples found in repository

examples/simple.rs (line 34)

    fn run(&mut self, window: &mut Window) -> Result<SceneResult, Box<dyn Error>> {
        // Set up a scene
        let mut ui_buffer = Buffer::new((6, 3));

        let chars = ['┌', '─', '┐', '│', ' ', '│', '└', '─', '┘'];
        let nine_slice = ui::NineSlice::new(chars, (6, 3));

        // Render Some elements to the buffer.
        render!(ui_buffer, [
            vec2(0, 0) => nine_slice,
            vec2(1, 1) => "QUIT".green()
        ]);

        // Loop the current scene.
        loop {
            window.update()?;

            // Renders some elements to the window.
            render!(window, [
                vec2(0, 0) => format!("{:?}", cursor::position()?),
                vec2(window.size().x / 2, window.size().y / 4) => ui_buffer,
            ]);

            // If the `q` key was pressed, quit the application by returning no scene.
            if window.code(KeyCode::Char('q')) {
                return Ok(None);
            }

            // If the buffer was clicked on, quit.
            if window.mouse(MouseEventKind::Down(MouseButton::Left))?
                && window.hover(
                    vec2(window.size().x / 2, window.size().y / 4),
                    ui_buffer.size(),
                )?
            {
                return Ok(None);
            }
        }
    }

pub fn io(&mut self) -> &mut Stdout

Trait Implementations

impl AsMut<Buffer> for Window

fn as_mut(&mut self) -> &mut Buffer

Converts this type into a mutable reference of the (usually inferred) input type.

impl Default for Window

fn default() -> Self

Returns the “default value” for a type.