Struct ascii_forge::window::Window

source · 
pub struct Window { /* private fields */ }
Expand description

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§

source§

impl Window

source

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.

source

pub fn new_inline(io: Stdout, height: u16) -> Result<Self>

Creates a new window built for inline using the given Stdout and height.

source

pub fn init_inline(height: u16) -> Result<Self>

Initializes a window that is prepared for inline rendering. Height is the number of columns that your terminal will need.

Examples found in repository?
examples/confirmation.rs (line 5)
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

pub fn confirmation() -> io::Result<bool> {
    let mut window = Window::init_inline(1)?;

    loop {
        render!(window, vec2(0, 0) => [ "Are You Sure? (`y` / `n`)" ]);

        if window.input().code(KeyCode::Char('y')) || window.input().code(KeyCode::Char('Y')) {
            return Ok(true);
        }
        if window.input().code(KeyCode::Char('n')) || window.input().code(KeyCode::Char('N')) {
            return Ok(false);
        }

        // Update the window
        window.update(Duration::from_millis(1000))?;
    }
}
More examples
Hide additional examples
examples/inline.rs (line 8)
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

fn progress_bar() -> io::Result<()> {
    let mut window = Window::init_inline(2)?;

    let timer = SystemTime::now();
    let duration = Duration::from_secs(3);

    // The Inline Render Loop
    loop {
        // Render's the Window and captures events
        window.update(Duration::ZERO)?;

        let amount_done = SystemTime::now().duration_since(timer).unwrap();

        let percent = amount_done.as_secs_f64() / duration.as_secs_f64();

        if percent >= 1.0 {
            break;
        }

        let x = (window.size().x as f64 * percent).round() as u16;

        // Create the progress bar text
        let text_green = "|".repeat(x as usize).green();
        let text_red = "|".repeat((window.size().x - x) as usize).red();

        // Render the Progress Bar
        render!(window,
            vec2(0, 1) => [ text_green ],
            vec2(x, 1) => [ text_red ],
            vec2(0, 0) => [ "Progress" ],
        );

        // End the loop if key is pressed early
        if window
            .input()
            .pressed(&KeyEvent::new(KeyCode::Char('c'), KeyModifiers::CONTROL))
        {
            break;
        }
    }

    window.restore()
}
source

pub fn init() -> Result<Self>

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

Examples found in repository?
examples/simple.rs (line 7)
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

fn main() -> io::Result<()> {
    // Will init the window for you, handling all required procedures.
    let mut window = Window::init()?;

    // Ask the system to handle panics for us.
    handle_panics();

    loop {
        // Ask the window to draw, handle events, and fix sizing issues.
        // Duration is the time for which to poll events before re-rendering.
        window.update(Duration::from_millis(200))?;

        // Render elements to the window
        render!(
            window,
            vec2(0, 0) => [ "Hello World!" ],
            vec2(0, 1) => [ "Press `Enter` to exit!".red() ],
            vec2(0, 2) => [
                "Render ".red(),
                "Multiple ".yellow(),
                "Elements ",
                "In one go!".to_string()
            ],
        );

        // Check if the Enter Key was pressed, and exit the app if it was.
        if window.input().code(KeyCode::Enter) {
            break;
        }
    }

    // Restore the window, enabling the window to function normally again
    // If nothing will be run after this, once the window is dropped, this will be run implicitly.
    window.restore()
}
source

pub fn buffer(&self) -> &Buffer

Returns the active Buffer, as a reference.

source

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

Returns the active Buffer, as a mutable reference.

source

pub fn swap_buffers(&mut self)

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

source

pub fn size(&self) -> Vec2

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

Examples found in repository?
examples/inline.rs (line 26)
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

fn progress_bar() -> io::Result<()> {
    let mut window = Window::init_inline(2)?;

    let timer = SystemTime::now();
    let duration = Duration::from_secs(3);

    // The Inline Render Loop
    loop {
        // Render's the Window and captures events
        window.update(Duration::ZERO)?;

        let amount_done = SystemTime::now().duration_since(timer).unwrap();

        let percent = amount_done.as_secs_f64() / duration.as_secs_f64();

        if percent >= 1.0 {
            break;
        }

        let x = (window.size().x as f64 * percent).round() as u16;

        // Create the progress bar text
        let text_green = "|".repeat(x as usize).green();
        let text_red = "|".repeat((window.size().x - x) as usize).red();

        // Render the Progress Bar
        render!(window,
            vec2(0, 1) => [ text_green ],
            vec2(x, 1) => [ text_red ],
            vec2(0, 0) => [ "Progress" ],
        );

        // End the loop if key is pressed early
        if window
            .input()
            .pressed(&KeyEvent::new(KeyCode::Char('c'), KeyModifiers::CONTROL))
        {
            break;
        }
    }

    window.restore()
}
source

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

Restores the window to it’s previous state from before the window’s init method. If the window is inline, restore the inline render

Examples found in repository?
examples/simple.rs (line 38)
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

fn main() -> io::Result<()> {
    // Will init the window for you, handling all required procedures.
    let mut window = Window::init()?;

    // Ask the system to handle panics for us.
    handle_panics();

    loop {
        // Ask the window to draw, handle events, and fix sizing issues.
        // Duration is the time for which to poll events before re-rendering.
        window.update(Duration::from_millis(200))?;

        // Render elements to the window
        render!(
            window,
            vec2(0, 0) => [ "Hello World!" ],
            vec2(0, 1) => [ "Press `Enter` to exit!".red() ],
            vec2(0, 2) => [
                "Render ".red(),
                "Multiple ".yellow(),
                "Elements ",
                "In one go!".to_string()
            ],
        );

        // Check if the Enter Key was pressed, and exit the app if it was.
        if window.input().code(KeyCode::Enter) {
            break;
        }
    }

    // Restore the window, enabling the window to function normally again
    // If nothing will be run after this, once the window is dropped, this will be run implicitly.
    window.restore()
}
More examples
Hide additional examples
examples/inline.rs (line 48)
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

fn progress_bar() -> io::Result<()> {
    let mut window = Window::init_inline(2)?;

    let timer = SystemTime::now();
    let duration = Duration::from_secs(3);

    // The Inline Render Loop
    loop {
        // Render's the Window and captures events
        window.update(Duration::ZERO)?;

        let amount_done = SystemTime::now().duration_since(timer).unwrap();

        let percent = amount_done.as_secs_f64() / duration.as_secs_f64();

        if percent >= 1.0 {
            break;
        }

        let x = (window.size().x as f64 * percent).round() as u16;

        // Create the progress bar text
        let text_green = "|".repeat(x as usize).green();
        let text_red = "|".repeat((window.size().x - x) as usize).red();

        // Render the Progress Bar
        render!(window,
            vec2(0, 1) => [ text_green ],
            vec2(x, 1) => [ text_red ],
            vec2(0, 0) => [ "Progress" ],
        );

        // End the loop if key is pressed early
        if window
            .input()
            .pressed(&KeyEvent::new(KeyCode::Char('c'), KeyModifiers::CONTROL))
        {
            break;
        }
    }

    window.restore()
}
source

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.

source

pub fn update(&mut self, poll: Duration) -> Result<()>

Handles events, and renders the screen.

Examples found in repository?
examples/confirmation.rs (line 18)
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

pub fn confirmation() -> io::Result<bool> {
    let mut window = Window::init_inline(1)?;

    loop {
        render!(window, vec2(0, 0) => [ "Are You Sure? (`y` / `n`)" ]);

        if window.input().code(KeyCode::Char('y')) || window.input().code(KeyCode::Char('Y')) {
            return Ok(true);
        }
        if window.input().code(KeyCode::Char('n')) || window.input().code(KeyCode::Char('N')) {
            return Ok(false);
        }

        // Update the window
        window.update(Duration::from_millis(1000))?;
    }
}
More examples
Hide additional examples
examples/simple.rs (line 15)
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

fn main() -> io::Result<()> {
    // Will init the window for you, handling all required procedures.
    let mut window = Window::init()?;

    // Ask the system to handle panics for us.
    handle_panics();

    loop {
        // Ask the window to draw, handle events, and fix sizing issues.
        // Duration is the time for which to poll events before re-rendering.
        window.update(Duration::from_millis(200))?;

        // Render elements to the window
        render!(
            window,
            vec2(0, 0) => [ "Hello World!" ],
            vec2(0, 1) => [ "Press `Enter` to exit!".red() ],
            vec2(0, 2) => [
                "Render ".red(),
                "Multiple ".yellow(),
                "Elements ",
                "In one go!".to_string()
            ],
        );

        // Check if the Enter Key was pressed, and exit the app if it was.
        if window.input().code(KeyCode::Enter) {
            break;
        }
    }

    // Restore the window, enabling the window to function normally again
    // If nothing will be run after this, once the window is dropped, this will be run implicitly.
    window.restore()
}
examples/inline.rs (line 16)
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

fn progress_bar() -> io::Result<()> {
    let mut window = Window::init_inline(2)?;

    let timer = SystemTime::now();
    let duration = Duration::from_secs(3);

    // The Inline Render Loop
    loop {
        // Render's the Window and captures events
        window.update(Duration::ZERO)?;

        let amount_done = SystemTime::now().duration_since(timer).unwrap();

        let percent = amount_done.as_secs_f64() / duration.as_secs_f64();

        if percent >= 1.0 {
            break;
        }

        let x = (window.size().x as f64 * percent).round() as u16;

        // Create the progress bar text
        let text_green = "|".repeat(x as usize).green();
        let text_red = "|".repeat((window.size().x - x) as usize).red();

        // Render the Progress Bar
        render!(window,
            vec2(0, 1) => [ text_green ],
            vec2(x, 1) => [ text_red ],
            vec2(0, 0) => [ "Progress" ],
        );

        // End the loop if key is pressed early
        if window
            .input()
            .pressed(&KeyEvent::new(KeyCode::Char('c'), KeyModifiers::CONTROL))
        {
            break;
        }
    }

    window.restore()
}
source

pub fn handle_event(&mut self, poll: Duration) -> Result<()>

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

source

pub fn input(&self) -> &Input

Examples found in repository?
examples/confirmation.rs (line 10)
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

pub fn confirmation() -> io::Result<bool> {
    let mut window = Window::init_inline(1)?;

    loop {
        render!(window, vec2(0, 0) => [ "Are You Sure? (`y` / `n`)" ]);

        if window.input().code(KeyCode::Char('y')) || window.input().code(KeyCode::Char('Y')) {
            return Ok(true);
        }
        if window.input().code(KeyCode::Char('n')) || window.input().code(KeyCode::Char('N')) {
            return Ok(false);
        }

        // Update the window
        window.update(Duration::from_millis(1000))?;
    }
}
More examples
Hide additional examples
examples/simple.rs (line 31)
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

fn main() -> io::Result<()> {
    // Will init the window for you, handling all required procedures.
    let mut window = Window::init()?;

    // Ask the system to handle panics for us.
    handle_panics();

    loop {
        // Ask the window to draw, handle events, and fix sizing issues.
        // Duration is the time for which to poll events before re-rendering.
        window.update(Duration::from_millis(200))?;

        // Render elements to the window
        render!(
            window,
            vec2(0, 0) => [ "Hello World!" ],
            vec2(0, 1) => [ "Press `Enter` to exit!".red() ],
            vec2(0, 2) => [
                "Render ".red(),
                "Multiple ".yellow(),
                "Elements ",
                "In one go!".to_string()
            ],
        );

        // Check if the Enter Key was pressed, and exit the app if it was.
        if window.input().code(KeyCode::Enter) {
            break;
        }
    }

    // Restore the window, enabling the window to function normally again
    // If nothing will be run after this, once the window is dropped, this will be run implicitly.
    window.restore()
}
examples/inline.rs (line 41)
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

fn progress_bar() -> io::Result<()> {
    let mut window = Window::init_inline(2)?;

    let timer = SystemTime::now();
    let duration = Duration::from_secs(3);

    // The Inline Render Loop
    loop {
        // Render's the Window and captures events
        window.update(Duration::ZERO)?;

        let amount_done = SystemTime::now().duration_since(timer).unwrap();

        let percent = amount_done.as_secs_f64() / duration.as_secs_f64();

        if percent >= 1.0 {
            break;
        }

        let x = (window.size().x as f64 * percent).round() as u16;

        // Create the progress bar text
        let text_green = "|".repeat(x as usize).green();
        let text_red = "|".repeat((window.size().x - x) as usize).red();

        // Render the Progress Bar
        render!(window,
            vec2(0, 1) => [ text_green ],
            vec2(x, 1) => [ text_red ],
            vec2(0, 0) => [ "Progress" ],
        );

        // End the loop if key is pressed early
        if window
            .input()
            .pressed(&KeyEvent::new(KeyCode::Char('c'), KeyModifiers::CONTROL))
        {
            break;
        }
    }

    window.restore()
}
source

pub fn input_mut(&mut self) -> &mut Input

source

pub fn mouse_pos(&self) -> Vec2

source

pub fn events(&self) -> &Vec<Event>

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

source

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

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

source

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

source

pub fn supports(&self) -> &Supports

Trait Implementations§

source§

impl AsMut<Buffer> for Window

source§

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

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

impl Default for Window

source§

fn default() -> Self

Returns the “default value” for a type. Read more
source§

impl Drop for Window

source§

fn drop(&mut self)

Executes the destructor for this type. Read more

Auto Trait Implementations§

Blanket Implementations§

source§

impl<T> Any for T
where T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for T
where U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.