Struct RectManager

pub struct RectManager { /* private fields */ }

An environment to manage and display character-based graphics in-console.

Example

use std::{thread, time};
use wrecked::{RectManager, ROOT};

let mut rectmanager = RectManager::new();
// rectmanager is initialized with top-level rect (id = ROOT) attached...
rectmanager.set_string(ROOT, 0, 0, "Hello World");

// draw the latest changes
rectmanager.render();

// wait 5 seconds (in order to see the screen)
let five_seconds = time::Duration::from_secs(5);
let now = time::Instant::now();
thread::sleep(five_seconds);

rectmanager.kill();

Implementations

impl RectManager

pub fn restore_console_state(&mut self)

impl RectManager

pub fn new() -> RectManager

Instantiate a new environment

Example

use wrecked::{RectManager, ROOT};
// Initialize the console; turn off echo and enable non-canonical input.
let mut rectmanager = RectManager::new();
// turn echo back on and return input to normal.
rectmanager.kill();

Examples found in repository

examples/blink.rs (line 6)

fn main() -> Result<(), wrecked::WreckedError> {
    let mut rectmanager = wrecked::RectManager::new();
    let (width, height) = rectmanager.get_rect_size(wrecked::ROOT).unwrap();
    let blinker = rectmanager.new_rect(wrecked::ROOT)?;
    rectmanager.set_fg_color(blinker, wrecked::Color::RED)?;
    rectmanager.set_bg_color(blinker, wrecked::Color::WHITE)?;
    rectmanager.resize(blinker, width / 2, height / 2)?;
    rectmanager.set_position(blinker, (width / 4) as isize, (height / 4) as isize)?;
    rectmanager.set_string(blinker, (width / 4) as isize - 3, 2, "BLINK!")?;

    for i in 0 .. 54 {
        if i % 2 == 0 {
            rectmanager.disable(blinker)?;
        } else {
            rectmanager.enable(blinker)?;
        }
        rectmanager.render()?;
        thread::sleep(Duration::new(0, 100_000_000));
    }

    rectmanager.kill()?;
    Ok(())
}

examples/wave.rs (line 7)

fn main() {
    let mut rectmanager = wrecked::RectManager::new();
    let (width, height) = rectmanager.get_rect_size(wrecked::ROOT).unwrap();
    let mut points = vec![];
    for x in 0 .. width {
        let rect_id = rectmanager.new_rect(wrecked::ROOT).ok().unwrap();
        rectmanager.set_bg_color(rect_id, wrecked::Color::YELLOW);
        rectmanager.set_character(rect_id, 0, 0, ' ');
        points.push(rect_id);
    }

    rectmanager.render();

    for x in 0 .. ((width * width)) {
        let rect_id = points[x % width];
        let y = (height as isize / 2 as isize) +
            ((2f64*PI * (x as f64 / (width - 1) as f64)).sin() * (height / 3) as f64) as isize;
        rectmanager.set_position(rect_id, (x % width) as isize, y);
        rectmanager.draw(rect_id);
        //thread::sleep(Duration::new(0, 100));
    }


    for rect in points.iter() {
        rectmanager.set_bg_color(*rect, wrecked::Color::BLUE);
    }

    for x in 0 .. ((width * width)) {
        let rect_id = points[x % width];
        let y = (height as isize / 2 as isize) +
            ((2f64*PI * (x as f64 / (width - 1) as f64)).sin() * (height / 3) as f64) as isize;
        rectmanager.set_position(rect_id, (x % width) as isize, y);
        rectmanager.render();
        //thread::sleep(Duration::new(0, 50000));
    }
    thread::sleep(Duration::new(1, 0));

    rectmanager.kill();
}

pub fn fit_to_terminal(&mut self) -> bool

If the ROOT rectangle dimensions to not match up to the console dimensions, then resize to fit. Returns true if a resize was made.

pub fn auto_resize(&mut self) -> bool

Deprecated. Use fit_to_terminal()

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

Render the visible portion of the rectmanager environment

Example

// Use ROOT to draw everything
use std::{thread, time};
use wrecked::{RectManager, ROOT};

let mut rectmanager = RectManager::new();
// rectmanager is initialized with top-level rect (id = ROOT) attached...
rectmanager.set_string(ROOT, 0, 0, "Hello World");

// draw the latest changes
rectmanager.render();

// wait 5 seconds (in order to see the screen)
let five_seconds = time::Duration::from_secs(5);
let now = time::Instant::now();
thread::sleep(five_seconds);

rectmanager.kill();

Examples found in repository

examples/blink.rs (line 21)

fn main() -> Result<(), wrecked::WreckedError> {
    let mut rectmanager = wrecked::RectManager::new();
    let (width, height) = rectmanager.get_rect_size(wrecked::ROOT).unwrap();
    let blinker = rectmanager.new_rect(wrecked::ROOT)?;
    rectmanager.set_fg_color(blinker, wrecked::Color::RED)?;
    rectmanager.set_bg_color(blinker, wrecked::Color::WHITE)?;
    rectmanager.resize(blinker, width / 2, height / 2)?;
    rectmanager.set_position(blinker, (width / 4) as isize, (height / 4) as isize)?;
    rectmanager.set_string(blinker, (width / 4) as isize - 3, 2, "BLINK!")?;

    for i in 0 .. 54 {
        if i % 2 == 0 {
            rectmanager.disable(blinker)?;
        } else {
            rectmanager.enable(blinker)?;
        }
        rectmanager.render()?;
        thread::sleep(Duration::new(0, 100_000_000));
    }

    rectmanager.kill()?;
    Ok(())
}

examples/wave.rs (line 17)

fn main() {
    let mut rectmanager = wrecked::RectManager::new();
    let (width, height) = rectmanager.get_rect_size(wrecked::ROOT).unwrap();
    let mut points = vec![];
    for x in 0 .. width {
        let rect_id = rectmanager.new_rect(wrecked::ROOT).ok().unwrap();
        rectmanager.set_bg_color(rect_id, wrecked::Color::YELLOW);
        rectmanager.set_character(rect_id, 0, 0, ' ');
        points.push(rect_id);
    }

    rectmanager.render();

    for x in 0 .. ((width * width)) {
        let rect_id = points[x % width];
        let y = (height as isize / 2 as isize) +
            ((2f64*PI * (x as f64 / (width - 1) as f64)).sin() * (height / 3) as f64) as isize;
        rectmanager.set_position(rect_id, (x % width) as isize, y);
        rectmanager.draw(rect_id);
        //thread::sleep(Duration::new(0, 100));
    }


    for rect in points.iter() {
        rectmanager.set_bg_color(*rect, wrecked::Color::BLUE);
    }

    for x in 0 .. ((width * width)) {
        let rect_id = points[x % width];
        let y = (height as isize / 2 as isize) +
            ((2f64*PI * (x as f64 / (width - 1) as f64)).sin() * (height / 3) as f64) as isize;
        rectmanager.set_position(rect_id, (x % width) as isize, y);
        rectmanager.render();
        //thread::sleep(Duration::new(0, 50000));
    }
    thread::sleep(Duration::new(1, 0));

    rectmanager.kill();
}

pub fn kill(&mut self) -> Result<(), WreckedError>

Return console state to normal

Example

use wrecked::RectManager;
// Initialize the console; turn off echo and enable non-canonical input.
let mut rectmanager = RectManager::new();
// turn echo back on and return input to normal.
rectmanager.kill();

Examples found in repository

examples/blink.rs (line 25)

fn main() -> Result<(), wrecked::WreckedError> {
    let mut rectmanager = wrecked::RectManager::new();
    let (width, height) = rectmanager.get_rect_size(wrecked::ROOT).unwrap();
    let blinker = rectmanager.new_rect(wrecked::ROOT)?;
    rectmanager.set_fg_color(blinker, wrecked::Color::RED)?;
    rectmanager.set_bg_color(blinker, wrecked::Color::WHITE)?;
    rectmanager.resize(blinker, width / 2, height / 2)?;
    rectmanager.set_position(blinker, (width / 4) as isize, (height / 4) as isize)?;
    rectmanager.set_string(blinker, (width / 4) as isize - 3, 2, "BLINK!")?;

    for i in 0 .. 54 {
        if i % 2 == 0 {
            rectmanager.disable(blinker)?;
        } else {
            rectmanager.enable(blinker)?;
        }
        rectmanager.render()?;
        thread::sleep(Duration::new(0, 100_000_000));
    }

    rectmanager.kill()?;
    Ok(())
}

examples/wave.rs (line 43)

fn main() {
    let mut rectmanager = wrecked::RectManager::new();
    let (width, height) = rectmanager.get_rect_size(wrecked::ROOT).unwrap();
    let mut points = vec![];
    for x in 0 .. width {
        let rect_id = rectmanager.new_rect(wrecked::ROOT).ok().unwrap();
        rectmanager.set_bg_color(rect_id, wrecked::Color::YELLOW);
        rectmanager.set_character(rect_id, 0, 0, ' ');
        points.push(rect_id);
    }

    rectmanager.render();

    for x in 0 .. ((width * width)) {
        let rect_id = points[x % width];
        let y = (height as isize / 2 as isize) +
            ((2f64*PI * (x as f64 / (width - 1) as f64)).sin() * (height / 3) as f64) as isize;
        rectmanager.set_position(rect_id, (x % width) as isize, y);
        rectmanager.draw(rect_id);
        //thread::sleep(Duration::new(0, 100));
    }


    for rect in points.iter() {
        rectmanager.set_bg_color(*rect, wrecked::Color::BLUE);
    }

    for x in 0 .. ((width * width)) {
        let rect_id = points[x % width];
        let y = (height as isize / 2 as isize) +
            ((2f64*PI * (x as f64 / (width - 1) as f64)).sin() * (height / 3) as f64) as isize;
        rectmanager.set_position(rect_id, (x % width) as isize, y);
        rectmanager.render();
        //thread::sleep(Duration::new(0, 50000));
    }
    thread::sleep(Duration::new(1, 0));

    rectmanager.kill();
}

pub fn get_height(&self) -> usize

Gets the height of the RectManager

pub fn get_width(&self) -> usize

Gets the width of the RectManager

pub fn new_orphan(&mut self) -> Result<usize, WreckedError>

Create a new rectangle, but don’t add it to the environment yet.

Example

use wrecked::RectManager;
let mut rectmanager = RectManager::new();

// Create a rectangle
let orphan_id = rectmanager.new_orphan().ok().unwrap();

assert!(!rectmanager.has_parent(orphan_id));

rectmanager.kill();

pub fn is_rect_enabled(&self, rect_id: usize) -> bool

Check if a given rectangle (and therefor its children) will be considered when drawing.

pub fn get_character( &self, rect_id: usize, x: isize, y: isize, ) -> Result<char, WreckedError>

Get the character at the given position of a rectangle. The rectangle’s default character (usually ’ ’) is returned if no character is found.

Example

use wrecked::{RectManager, ROOT};
let mut rectmanager = RectManager::new();
rectmanager.set_character(ROOT, 0, 0, 'X');
assert_eq!(rectmanager.get_character(ROOT, 0, 0).ok().unwrap(), 'X');
rectmanager.kill();

pub fn get_children(&self, rect_id: usize) -> Vec<usize>

pub fn get_absolute_offset(&self, rect_id: usize) -> Option<(isize, isize)>

Get the offset relative to the top-level rectangle in the RectManager.

Example

use wrecked::{RectManager, ROOT};
let mut rectmanager = RectManager::new();
let mut rect_a = rectmanager.new_rect(ROOT).ok().unwrap();
let mut rect_b = rectmanager.new_rect(rect_a).ok().unwrap();
// Move parent rect ...
rectmanager.set_position(rect_a, 5, 2);
// Move child rect ...
rectmanager.set_position(rect_b, 5, 2);

assert_eq!(rectmanager.get_absolute_offset(rect_b).unwrap(), (10, 4));

rectmanager.kill();

pub fn get_relative_offset(&self, rect_id: usize) -> Option<(isize, isize)>

Get the offset relative to the parent rectangle of the given rectangle.

Example

use wrecked::{RectManager, ROOT};
let mut rectmanager = RectManager::new();
let mut rect_a = rectmanager.new_rect(ROOT).ok().unwrap();
let mut rect_b = rectmanager.new_rect(rect_a).ok().unwrap();
// Move parent rect ...
rectmanager.set_position(rect_a, 10, 1);
// Move child rect ...
rectmanager.set_position(rect_b, 5, 2);

assert_eq!(rectmanager.get_relative_offset(rect_b).unwrap(), (5, 2));

rectmanager.kill();

pub fn get_rect_width(&self, rect_id: usize) -> usize

Get width of given rectangle

Example

use wrecked::{RectManager, ROOT};
let mut rectmanager = RectManager::new();
let mut rect = rectmanager.new_rect(ROOT).ok().unwrap();
rectmanager.resize(rect, 10, 10);
assert_eq!(rectmanager.get_rect_height(rect), 10);
rectmanager.kill();

pub fn get_rect_height(&self, rect_id: usize) -> usize

Get height of given rectangle

Example

use wrecked::{RectManager, ROOT};
let mut rectmanager = RectManager::new();
let mut rect = rectmanager.new_rect(ROOT).ok().unwrap();
rectmanager.resize(rect, 10, 10);
assert_eq!(rectmanager.get_rect_height(rect), 10);
rectmanager.kill();

pub fn get_rect_size(&self, rect_id: usize) -> Option<(usize, usize)>

Get dimensions of specified rectangle, if it exists

Example

use wrecked::{RectManager, ROOT};
let mut rectmanager = RectManager::new();
let rect_id = rectmanager.new_rect(ROOT).ok().unwrap();
// Resizing to make sure we know the size
rectmanager.resize(rect_id, 10, 10);
assert_eq!((10, 10), rectmanager.get_rect_size(rect_id).unwrap());

Examples found in repository

examples/blink.rs (line 7)

fn main() -> Result<(), wrecked::WreckedError> {
    let mut rectmanager = wrecked::RectManager::new();
    let (width, height) = rectmanager.get_rect_size(wrecked::ROOT).unwrap();
    let blinker = rectmanager.new_rect(wrecked::ROOT)?;
    rectmanager.set_fg_color(blinker, wrecked::Color::RED)?;
    rectmanager.set_bg_color(blinker, wrecked::Color::WHITE)?;
    rectmanager.resize(blinker, width / 2, height / 2)?;
    rectmanager.set_position(blinker, (width / 4) as isize, (height / 4) as isize)?;
    rectmanager.set_string(blinker, (width / 4) as isize - 3, 2, "BLINK!")?;

    for i in 0 .. 54 {
        if i % 2 == 0 {
            rectmanager.disable(blinker)?;
        } else {
            rectmanager.enable(blinker)?;
        }
        rectmanager.render()?;
        thread::sleep(Duration::new(0, 100_000_000));
    }

    rectmanager.kill()?;
    Ok(())
}

examples/wave.rs (line 8)

fn main() {
    let mut rectmanager = wrecked::RectManager::new();
    let (width, height) = rectmanager.get_rect_size(wrecked::ROOT).unwrap();
    let mut points = vec![];
    for x in 0 .. width {
        let rect_id = rectmanager.new_rect(wrecked::ROOT).ok().unwrap();
        rectmanager.set_bg_color(rect_id, wrecked::Color::YELLOW);
        rectmanager.set_character(rect_id, 0, 0, ' ');
        points.push(rect_id);
    }

    rectmanager.render();

    for x in 0 .. ((width * width)) {
        let rect_id = points[x % width];
        let y = (height as isize / 2 as isize) +
            ((2f64*PI * (x as f64 / (width - 1) as f64)).sin() * (height / 3) as f64) as isize;
        rectmanager.set_position(rect_id, (x % width) as isize, y);
        rectmanager.draw(rect_id);
        //thread::sleep(Duration::new(0, 100));
    }


    for rect in points.iter() {
        rectmanager.set_bg_color(*rect, wrecked::Color::BLUE);
    }

    for x in 0 .. ((width * width)) {
        let rect_id = points[x % width];
        let y = (height as isize / 2 as isize) +
            ((2f64*PI * (x as f64 / (width - 1) as f64)).sin() * (height / 3) as f64) as isize;
        rectmanager.set_position(rect_id, (x % width) as isize, y);
        rectmanager.render();
        //thread::sleep(Duration::new(0, 50000));
    }
    thread::sleep(Duration::new(1, 0));

    rectmanager.kill();
}

pub fn new_rect(&mut self, parent_id: usize) -> Result<usize, WreckedError>

Add a new rectangle to the environment

Example

use wrecked::{RectManager, ROOT};
let mut rectmanager = RectManager::new();

// Create a rectangle and attach it as a child to the top-level rectangle.
let first_rect_id = rectmanager.new_rect(ROOT).ok().unwrap();

// Create a child of the newly created rect...
let second_rect_id = rectmanager.new_rect(first_rect_id).ok().unwrap();

rectmanager.kill();

Examples found in repository

examples/blink.rs (line 8)

fn main() -> Result<(), wrecked::WreckedError> {
    let mut rectmanager = wrecked::RectManager::new();
    let (width, height) = rectmanager.get_rect_size(wrecked::ROOT).unwrap();
    let blinker = rectmanager.new_rect(wrecked::ROOT)?;
    rectmanager.set_fg_color(blinker, wrecked::Color::RED)?;
    rectmanager.set_bg_color(blinker, wrecked::Color::WHITE)?;
    rectmanager.resize(blinker, width / 2, height / 2)?;
    rectmanager.set_position(blinker, (width / 4) as isize, (height / 4) as isize)?;
    rectmanager.set_string(blinker, (width / 4) as isize - 3, 2, "BLINK!")?;

    for i in 0 .. 54 {
        if i % 2 == 0 {
            rectmanager.disable(blinker)?;
        } else {
            rectmanager.enable(blinker)?;
        }
        rectmanager.render()?;
        thread::sleep(Duration::new(0, 100_000_000));
    }

    rectmanager.kill()?;
    Ok(())
}

examples/wave.rs (line 11)

fn main() {
    let mut rectmanager = wrecked::RectManager::new();
    let (width, height) = rectmanager.get_rect_size(wrecked::ROOT).unwrap();
    let mut points = vec![];
    for x in 0 .. width {
        let rect_id = rectmanager.new_rect(wrecked::ROOT).ok().unwrap();
        rectmanager.set_bg_color(rect_id, wrecked::Color::YELLOW);
        rectmanager.set_character(rect_id, 0, 0, ' ');
        points.push(rect_id);
    }

    rectmanager.render();

    for x in 0 .. ((width * width)) {
        let rect_id = points[x % width];
        let y = (height as isize / 2 as isize) +
            ((2f64*PI * (x as f64 / (width - 1) as f64)).sin() * (height / 3) as f64) as isize;
        rectmanager.set_position(rect_id, (x % width) as isize, y);
        rectmanager.draw(rect_id);
        //thread::sleep(Duration::new(0, 100));
    }


    for rect in points.iter() {
        rectmanager.set_bg_color(*rect, wrecked::Color::BLUE);
    }

    for x in 0 .. ((width * width)) {
        let rect_id = points[x % width];
        let y = (height as isize / 2 as isize) +
            ((2f64*PI * (x as f64 / (width - 1) as f64)).sin() * (height / 3) as f64) as isize;
        rectmanager.set_position(rect_id, (x % width) as isize, y);
        rectmanager.render();
        //thread::sleep(Duration::new(0, 50000));
    }
    thread::sleep(Duration::new(1, 0));

    rectmanager.kill();
}

pub fn draw(&mut self, rect_id: usize) -> Result<(), WreckedError>

Render the rectangle (and all its children) specified. This will not update the Rects at higher levels and can lead to artifacts.

Example

// Use ROOT to draw everything
use std::{thread, time};
use wrecked::{RectManager, ROOT};

let mut rectmanager = RectManager::new();
let some_rect = rectmanager.new_rect(ROOT).ok().unwrap();
// Adjust the rectangle so it will fit the string
rectmanager.resize(some_rect, 16, 1);
// Give it some text
rectmanager.set_string(some_rect, 0, 0, "Hello World");

// draw the latest changes, but only those of some_rect
rectmanager.draw(some_rect);

// wait 5 seconds (in order to see the screen)
let five_seconds = time::Duration::from_secs(5);
let now = time::Instant::now();
thread::sleep(five_seconds);

rectmanager.kill();

Examples found in repository

examples/wave.rs (line 24)

fn main() {
    let mut rectmanager = wrecked::RectManager::new();
    let (width, height) = rectmanager.get_rect_size(wrecked::ROOT).unwrap();
    let mut points = vec![];
    for x in 0 .. width {
        let rect_id = rectmanager.new_rect(wrecked::ROOT).ok().unwrap();
        rectmanager.set_bg_color(rect_id, wrecked::Color::YELLOW);
        rectmanager.set_character(rect_id, 0, 0, ' ');
        points.push(rect_id);
    }

    rectmanager.render();

    for x in 0 .. ((width * width)) {
        let rect_id = points[x % width];
        let y = (height as isize / 2 as isize) +
            ((2f64*PI * (x as f64 / (width - 1) as f64)).sin() * (height / 3) as f64) as isize;
        rectmanager.set_position(rect_id, (x % width) as isize, y);
        rectmanager.draw(rect_id);
        //thread::sleep(Duration::new(0, 100));
    }


    for rect in points.iter() {
        rectmanager.set_bg_color(*rect, wrecked::Color::BLUE);
    }

    for x in 0 .. ((width * width)) {
        let rect_id = points[x % width];
        let y = (height as isize / 2 as isize) +
            ((2f64*PI * (x as f64 / (width - 1) as f64)).sin() * (height / 3) as f64) as isize;
        rectmanager.set_position(rect_id, (x % width) as isize, y);
        rectmanager.render();
        //thread::sleep(Duration::new(0, 50000));
    }
    thread::sleep(Duration::new(1, 0));

    rectmanager.kill();
}

pub fn resize( &mut self, rect_id: usize, width: usize, height: usize, ) -> Result<(), WreckedError>

Resize a rectangle

Example

use wrecked::{RectManager, ROOT};
let mut rectmanager = RectManager::new();
let rect_id = rectmanager.new_rect(ROOT).ok().unwrap();
// Resizing to make sure we know the size
rectmanager.resize(rect_id, 10, 10);
assert_eq!((10, 10), rectmanager.get_rect_size(rect_id).unwrap());

Examples found in repository

examples/blink.rs (line 11)

fn main() -> Result<(), wrecked::WreckedError> {
    let mut rectmanager = wrecked::RectManager::new();
    let (width, height) = rectmanager.get_rect_size(wrecked::ROOT).unwrap();
    let blinker = rectmanager.new_rect(wrecked::ROOT)?;
    rectmanager.set_fg_color(blinker, wrecked::Color::RED)?;
    rectmanager.set_bg_color(blinker, wrecked::Color::WHITE)?;
    rectmanager.resize(blinker, width / 2, height / 2)?;
    rectmanager.set_position(blinker, (width / 4) as isize, (height / 4) as isize)?;
    rectmanager.set_string(blinker, (width / 4) as isize - 3, 2, "BLINK!")?;

    for i in 0 .. 54 {
        if i % 2 == 0 {
            rectmanager.disable(blinker)?;
        } else {
            rectmanager.enable(blinker)?;
        }
        rectmanager.render()?;
        thread::sleep(Duration::new(0, 100_000_000));
    }

    rectmanager.kill()?;
    Ok(())
}

pub fn shift_contents( &mut self, rect_id: usize, x_offset: isize, y_offset: isize, ) -> Result<(), WreckedError>

Move all child rectangles, but not characters by the offsets specified

Example

use wrecked::{RectManager, ROOT};
let mut rectmanager = RectManager::new();
let mut rect_parent = rectmanager.new_rect(ROOT).ok().unwrap();
rectmanager.resize(rect_parent, 16, 5);

// Put a string at (0, 0)
rectmanager.set_string(rect_parent, 0, 0, "Hello world");
// Put a rect at (0, 1)
let rect_child = rectmanager.new_rect(rect_parent).ok().unwrap();
rectmanager.set_position(rect_child, 0, 1);
// Shift contents down one row ...
rectmanager.shift_contents(rect_parent, 0, 1);

assert_eq!(rectmanager.get_character(rect_parent, 0, 0).ok().unwrap(), 'H');
assert_eq!(rectmanager.get_relative_offset(rect_child).unwrap(), (0, 2));

rectmanager.kill();

pub fn set_position( &mut self, rect_id: usize, x: isize, y: isize, ) -> Result<(), WreckedError>

Set relative offset of given rectangle.

Example

use wrecked::{RectManager, ROOT};
let mut rectmanager = RectManager::new();
let mut rect_id = rectmanager.new_rect(ROOT).ok().unwrap();
rectmanager.set_position(rect_id, 4, 4);
assert_eq!(rectmanager.get_relative_offset(rect_id).unwrap(), (4, 4));

Examples found in repository

examples/blink.rs (line 12)

fn main() -> Result<(), wrecked::WreckedError> {
    let mut rectmanager = wrecked::RectManager::new();
    let (width, height) = rectmanager.get_rect_size(wrecked::ROOT).unwrap();
    let blinker = rectmanager.new_rect(wrecked::ROOT)?;
    rectmanager.set_fg_color(blinker, wrecked::Color::RED)?;
    rectmanager.set_bg_color(blinker, wrecked::Color::WHITE)?;
    rectmanager.resize(blinker, width / 2, height / 2)?;
    rectmanager.set_position(blinker, (width / 4) as isize, (height / 4) as isize)?;
    rectmanager.set_string(blinker, (width / 4) as isize - 3, 2, "BLINK!")?;

    for i in 0 .. 54 {
        if i % 2 == 0 {
            rectmanager.disable(blinker)?;
        } else {
            rectmanager.enable(blinker)?;
        }
        rectmanager.render()?;
        thread::sleep(Duration::new(0, 100_000_000));
    }

    rectmanager.kill()?;
    Ok(())
}

examples/wave.rs (line 23)

fn main() {
    let mut rectmanager = wrecked::RectManager::new();
    let (width, height) = rectmanager.get_rect_size(wrecked::ROOT).unwrap();
    let mut points = vec![];
    for x in 0 .. width {
        let rect_id = rectmanager.new_rect(wrecked::ROOT).ok().unwrap();
        rectmanager.set_bg_color(rect_id, wrecked::Color::YELLOW);
        rectmanager.set_character(rect_id, 0, 0, ' ');
        points.push(rect_id);
    }

    rectmanager.render();

    for x in 0 .. ((width * width)) {
        let rect_id = points[x % width];
        let y = (height as isize / 2 as isize) +
            ((2f64*PI * (x as f64 / (width - 1) as f64)).sin() * (height / 3) as f64) as isize;
        rectmanager.set_position(rect_id, (x % width) as isize, y);
        rectmanager.draw(rect_id);
        //thread::sleep(Duration::new(0, 100));
    }


    for rect in points.iter() {
        rectmanager.set_bg_color(*rect, wrecked::Color::BLUE);
    }

    for x in 0 .. ((width * width)) {
        let rect_id = points[x % width];
        let y = (height as isize / 2 as isize) +
            ((2f64*PI * (x as f64 / (width - 1) as f64)).sin() * (height / 3) as f64) as isize;
        rectmanager.set_position(rect_id, (x % width) as isize, y);
        rectmanager.render();
        //thread::sleep(Duration::new(0, 50000));
    }
    thread::sleep(Duration::new(1, 0));

    rectmanager.kill();
}

pub fn disable(&mut self, rect_id: usize) -> Result<(), WreckedError>

Do not draw the given rectangle or is descendents when draw() is called.

Examples found in repository

examples/blink.rs (line 17)

fn main() -> Result<(), wrecked::WreckedError> {
    let mut rectmanager = wrecked::RectManager::new();
    let (width, height) = rectmanager.get_rect_size(wrecked::ROOT).unwrap();
    let blinker = rectmanager.new_rect(wrecked::ROOT)?;
    rectmanager.set_fg_color(blinker, wrecked::Color::RED)?;
    rectmanager.set_bg_color(blinker, wrecked::Color::WHITE)?;
    rectmanager.resize(blinker, width / 2, height / 2)?;
    rectmanager.set_position(blinker, (width / 4) as isize, (height / 4) as isize)?;
    rectmanager.set_string(blinker, (width / 4) as isize - 3, 2, "BLINK!")?;

    for i in 0 .. 54 {
        if i % 2 == 0 {
            rectmanager.disable(blinker)?;
        } else {
            rectmanager.enable(blinker)?;
        }
        rectmanager.render()?;
        thread::sleep(Duration::new(0, 100_000_000));
    }

    rectmanager.kill()?;
    Ok(())
}

pub fn enable(&mut self, rect_id: usize) -> Result<(), WreckedError>

If a rectangle has been disabled, enable it.

Examples found in repository

examples/blink.rs (line 19)

fn main() -> Result<(), wrecked::WreckedError> {
    let mut rectmanager = wrecked::RectManager::new();
    let (width, height) = rectmanager.get_rect_size(wrecked::ROOT).unwrap();
    let blinker = rectmanager.new_rect(wrecked::ROOT)?;
    rectmanager.set_fg_color(blinker, wrecked::Color::RED)?;
    rectmanager.set_bg_color(blinker, wrecked::Color::WHITE)?;
    rectmanager.resize(blinker, width / 2, height / 2)?;
    rectmanager.set_position(blinker, (width / 4) as isize, (height / 4) as isize)?;
    rectmanager.set_string(blinker, (width / 4) as isize - 3, 2, "BLINK!")?;

    for i in 0 .. 54 {
        if i % 2 == 0 {
            rectmanager.disable(blinker)?;
        } else {
            rectmanager.enable(blinker)?;
        }
        rectmanager.render()?;
        thread::sleep(Duration::new(0, 100_000_000));
    }

    rectmanager.kill()?;
    Ok(())
}

pub fn clear_characters(&mut self, rect_id: usize) -> Result<(), WreckedError>

Remove all the text added to a rectangle.

Example

use wrecked::{RectManager, ROOT};
let mut rectmanager = RectManager::new();
// Add some Characters to ROOT rect
for x in 0 .. 10 {
    rectmanager.set_character(ROOT, x, 0, 'X');
}
// Now delete them all ...
rectmanager.clear_characters(ROOT);

rectmanager.kill();

pub fn clear_children(&mut self, rect_id: usize) -> Result<(), WreckedError>

Remove all children from a rectangle, deleting them.

Example

use wrecked::{RectManager, ROOT};
let mut rectmanager = RectManager::new();
// Add some children to ROOT rect
for _ in 0 .. 10 {
    rectmanager.new_rect(ROOT).ok().unwrap();
}
// Now delete them all ...
rectmanager.clear_children(ROOT);

rectmanager.kill();

pub fn clear_effects(&mut self, rect_id: usize) -> Result<(), WreckedError>

Remove all effects from the rectangle’s text. Does not apply recursively.

pub fn detach(&mut self, rect_id: usize) -> Result<(), WreckedError>

Remove a rectangle from its parent without destroying it, so it can be reattached later.

Example

use wrecked::{RectManager, ROOT};
let mut rectmanager = RectManager::new();
// Create a rectangle that is attached to ROOT.
let rect_a = rectmanager.new_rect(ROOT).ok().unwrap();
rectmanager.detach(rect_a);

assert!(!rectmanager.has_parent(rect_a));

rectmanager.kill();

pub fn attach( &mut self, rect_id: usize, new_parent_id: usize, ) -> Result<(), WreckedError>

Attach one rect as a child to another.

Example

use wrecked::{RectManager, ROOT};
let mut rectmanager = RectManager::new();
// Create a rectangle that is attached to ROOT.
let rect_a = rectmanager.new_rect(ROOT).ok().unwrap();
// Create an orphan rectangle to switch in.
let rect_b = rectmanager.new_orphan().ok().unwrap();
rectmanager.attach(rect_b, rect_a);

assert_eq!(rectmanager.get_parent_id(rect_b).unwrap(), rect_a);

rectmanager.kill();

pub fn set_string( &mut self, rect_id: usize, start_x: isize, start_y: isize, string: &str, ) -> Result<(), WreckedError>

Set a string of characters starting at the specified position of the given rectangle. Wraps automatically, but will throw error on y-overflow.

Example

use wrecked::{RectManager, ROOT};
let mut rectmanager = RectManager::new();
rectmanager.set_string(ROOT, 0, 0, "This Some Text");
rectmanager.kill();

Examples found in repository

examples/blink.rs (line 13)

fn main() -> Result<(), wrecked::WreckedError> {
    let mut rectmanager = wrecked::RectManager::new();
    let (width, height) = rectmanager.get_rect_size(wrecked::ROOT).unwrap();
    let blinker = rectmanager.new_rect(wrecked::ROOT)?;
    rectmanager.set_fg_color(blinker, wrecked::Color::RED)?;
    rectmanager.set_bg_color(blinker, wrecked::Color::WHITE)?;
    rectmanager.resize(blinker, width / 2, height / 2)?;
    rectmanager.set_position(blinker, (width / 4) as isize, (height / 4) as isize)?;
    rectmanager.set_string(blinker, (width / 4) as isize - 3, 2, "BLINK!")?;

    for i in 0 .. 54 {
        if i % 2 == 0 {
            rectmanager.disable(blinker)?;
        } else {
            rectmanager.enable(blinker)?;
        }
        rectmanager.render()?;
        thread::sleep(Duration::new(0, 100_000_000));
    }

    rectmanager.kill()?;
    Ok(())
}

pub fn set_character( &mut self, rect_id: usize, x: isize, y: isize, character: char, ) -> Result<(), WreckedError>

Set the character at the given position of a rectangle.

Example

use wrecked::{RectManager, ROOT};
let mut rectmanager = RectManager::new();
rectmanager.set_character(ROOT, 0, 0, 'X');
assert_eq!(rectmanager.get_character(ROOT, 0, 0).ok().unwrap(), 'X');
rectmanager.kill();

Examples found in repository

examples/wave.rs (line 13)

fn main() {
    let mut rectmanager = wrecked::RectManager::new();
    let (width, height) = rectmanager.get_rect_size(wrecked::ROOT).unwrap();
    let mut points = vec![];
    for x in 0 .. width {
        let rect_id = rectmanager.new_rect(wrecked::ROOT).ok().unwrap();
        rectmanager.set_bg_color(rect_id, wrecked::Color::YELLOW);
        rectmanager.set_character(rect_id, 0, 0, ' ');
        points.push(rect_id);
    }

    rectmanager.render();

    for x in 0 .. ((width * width)) {
        let rect_id = points[x % width];
        let y = (height as isize / 2 as isize) +
            ((2f64*PI * (x as f64 / (width - 1) as f64)).sin() * (height / 3) as f64) as isize;
        rectmanager.set_position(rect_id, (x % width) as isize, y);
        rectmanager.draw(rect_id);
        //thread::sleep(Duration::new(0, 100));
    }


    for rect in points.iter() {
        rectmanager.set_bg_color(*rect, wrecked::Color::BLUE);
    }

    for x in 0 .. ((width * width)) {
        let rect_id = points[x % width];
        let y = (height as isize / 2 as isize) +
            ((2f64*PI * (x as f64 / (width - 1) as f64)).sin() * (height / 3) as f64) as isize;
        rectmanager.set_position(rect_id, (x % width) as isize, y);
        rectmanager.render();
        //thread::sleep(Duration::new(0, 50000));
    }
    thread::sleep(Duration::new(1, 0));

    rectmanager.kill();
}

pub fn unset_character( &mut self, rect_id: usize, x: isize, y: isize, ) -> Result<(), WreckedError>

Delete a set character of a given rectangle at specified point

Example

use wrecked::{RectManager, ROOT};
let mut rectmanager = RectManager::new();
rectmanager.set_character(ROOT, 0, 0, 'X');
rectmanager.unset_character(ROOT, 0, 0);
assert_eq!(rectmanager.get_character(ROOT, 0, 0).ok().unwrap(), rectmanager.get_default_character(ROOT));
rectmanager.kill();

pub fn delete_rect(&mut self, rect_id: usize) -> Result<(), WreckedError>

Completely erase a rectangle & remove it from the RectManager’s tree.

Example

use wrecked::{RectManager, ROOT};
let mut rectmanager = RectManager::new();
let mut rect = rectmanager.new_rect(ROOT).ok().unwrap();

rectmanager.delete_rect(rect);
assert!(!rectmanager.has_rect(rect));

rectmanager.kill();

pub fn replace_with( &mut self, old_rect_id: usize, new_rect_id: usize, ) -> Result<(), WreckedError>

Swap out one rectangle with another.

Example

use wrecked::{RectManager, ROOT};
let mut rectmanager = RectManager::new();
// Create a rectangle that is attached to ROOT.
let rect_a = rectmanager.new_rect(ROOT).ok().unwrap();
// Create an orphan rectangle to switch in.
let rect_b = rectmanager.new_orphan().ok().unwrap();
rectmanager.replace_with(rect_a, rect_b);

assert!(rectmanager.has_parent(rect_b));
assert!(!rectmanager.has_parent(rect_a));

pub fn set_bold_flag(&mut self, rect_id: usize) -> Result<(), WreckedError>

Apply bold effect to text of given rect (does not apply recursively).

Example

use wrecked::{RectManager, ROOT};
let mut rectmanager = RectManager::new();
rectmanager.set_bold_flag(ROOT);
rectmanager.set_string(ROOT, 0, 0, "Some Bold Text");
rectmanager.kill();

pub fn unset_bold_flag(&mut self, rect_id: usize) -> Result<(), WreckedError>

Disable bold text effect

Example

use wrecked::{RectManager, ROOT};
let mut rectmanager = RectManager::new();
rectmanager.set_bold_flag(ROOT);
rectmanager.unset_bold_flag(ROOT);
rectmanager.set_string(ROOT, 0, 0, "Normal Text");
rectmanager.kill();

pub fn set_underline_flag(&mut self, rect_id: usize) -> Result<(), WreckedError>

Apply underline effect to text of given rect (does not apply recursively).

Example

use wrecked::{RectManager, ROOT};
let mut rectmanager = RectManager::new();
rectmanager.set_underline_flag(ROOT);
rectmanager.set_string(ROOT, 0, 0, "Some Underlined Text");
rectmanager.kill();

pub fn unset_underline_flag( &mut self, rect_id: usize, ) -> Result<(), WreckedError>

Disable underline text effect

Example

use wrecked::{RectManager, ROOT};
let mut rectmanager = RectManager::new();
rectmanager.set_underline_flag(ROOT);
rectmanager.unset_underline_flag(ROOT);
rectmanager.set_string(ROOT, 0, 0, "Normal Text");
rectmanager.kill();

pub fn set_invert_flag(&mut self, rect_id: usize) -> Result<(), WreckedError>

Invert the background and foreground colors of the text of the given rect (does not apply recursively).

Example

use wrecked::{RectManager, ROOT};
let mut rectmanager = RectManager::new();
rectmanager.set_invert_flag(ROOT);
rectmanager.set_string(ROOT, 0, 0, "Some Inverted Text");
rectmanager.kill();

pub fn unset_invert_flag(&mut self, rect_id: usize) -> Result<(), WreckedError>

Disable invert text effect

Example

use wrecked::{RectManager, ROOT};
let mut rectmanager = RectManager::new();
rectmanager.set_invert_flag(ROOT);
rectmanager.unset_invert_flag(ROOT);
rectmanager.set_string(ROOT, 0, 0, "Normal Text");
rectmanager.kill();

pub fn set_italics_flag(&mut self, rect_id: usize) -> Result<(), WreckedError>

Apply italics effect to text of given rect (does not apply recursively).

Example

use wrecked::{RectManager, ROOT};
let mut rectmanager = RectManager::new();
rectmanager.set_italics_flag(ROOT);
rectmanager.set_string(ROOT, 0, 0, "Some Italicized Text");
rectmanager.kill();

pub fn unset_italics_flag(&mut self, rect_id: usize) -> Result<(), WreckedError>

Disable italics text effect

Example

use wrecked::{RectManager, ROOT};
let mut rectmanager = RectManager::new();
rectmanager.set_italics_flag(ROOT);
rectmanager.unset_italics_flag(ROOT);
rectmanager.set_string(ROOT, 0, 0, "Normal Text");
rectmanager.kill();

pub fn set_strike_flag(&mut self, rect_id: usize) -> Result<(), WreckedError>

Apply strike effect to text of given rect (does not apply recursively).

Example

use wrecked::{RectManager, ROOT};
let mut rectmanager = RectManager::new();
rectmanager.set_strike_flag(ROOT);
rectmanager.set_string(ROOT, 0, 0, "Some Text With Strikethrough");
rectmanager.kill();

pub fn unset_strike_flag(&mut self, rect_id: usize) -> Result<(), WreckedError>

Disable strike text effect

Example

use wrecked::{RectManager, ROOT};
let mut rectmanager = RectManager::new();
rectmanager.set_strike_flag(ROOT);
rectmanager.unset_strike_flag(ROOT);
rectmanager.set_string(ROOT, 0, 0, "Normal Text");
rectmanager.kill();

pub fn set_blink_flag(&mut self, rect_id: usize) -> Result<(), WreckedError>

Apply blink effect to text of given rect (does not apply recursively).

Example

use wrecked::{RectManager, ROOT};
let mut rectmanager = RectManager::new();
rectmanager.set_blink_flag(ROOT);
rectmanager.set_string(ROOT, 0, 0, "Some Blinking Text");
rectmanager.kill();

pub fn unset_blink_flag(&mut self, rect_id: usize) -> Result<(), WreckedError>

Disable blink text effect

Example

use wrecked::{RectManager, ROOT};
let mut rectmanager = RectManager::new();
rectmanager.set_blink_flag(ROOT);
rectmanager.unset_blink_flag(ROOT);
rectmanager.set_string(ROOT, 0, 0, "Normal Text");
rectmanager.kill();

pub fn set_bg_color( &mut self, rect_id: usize, color: Color, ) -> Result<(), WreckedError>

Set color of background of given rect (does not apply recursively)

Example

use wrecked::{RectManager, ROOT, Color};
let mut rectmanager = RectManager::new();
// Give Top a Green background
rectmanager.set_fg_color(ROOT, Color::GREEN);

rectmanager.kill();

Examples found in repository

examples/blink.rs (line 10)

fn main() -> Result<(), wrecked::WreckedError> {
    let mut rectmanager = wrecked::RectManager::new();
    let (width, height) = rectmanager.get_rect_size(wrecked::ROOT).unwrap();
    let blinker = rectmanager.new_rect(wrecked::ROOT)?;
    rectmanager.set_fg_color(blinker, wrecked::Color::RED)?;
    rectmanager.set_bg_color(blinker, wrecked::Color::WHITE)?;
    rectmanager.resize(blinker, width / 2, height / 2)?;
    rectmanager.set_position(blinker, (width / 4) as isize, (height / 4) as isize)?;
    rectmanager.set_string(blinker, (width / 4) as isize - 3, 2, "BLINK!")?;

    for i in 0 .. 54 {
        if i % 2 == 0 {
            rectmanager.disable(blinker)?;
        } else {
            rectmanager.enable(blinker)?;
        }
        rectmanager.render()?;
        thread::sleep(Duration::new(0, 100_000_000));
    }

    rectmanager.kill()?;
    Ok(())
}

examples/wave.rs (line 12)

fn main() {
    let mut rectmanager = wrecked::RectManager::new();
    let (width, height) = rectmanager.get_rect_size(wrecked::ROOT).unwrap();
    let mut points = vec![];
    for x in 0 .. width {
        let rect_id = rectmanager.new_rect(wrecked::ROOT).ok().unwrap();
        rectmanager.set_bg_color(rect_id, wrecked::Color::YELLOW);
        rectmanager.set_character(rect_id, 0, 0, ' ');
        points.push(rect_id);
    }

    rectmanager.render();

    for x in 0 .. ((width * width)) {
        let rect_id = points[x % width];
        let y = (height as isize / 2 as isize) +
            ((2f64*PI * (x as f64 / (width - 1) as f64)).sin() * (height / 3) as f64) as isize;
        rectmanager.set_position(rect_id, (x % width) as isize, y);
        rectmanager.draw(rect_id);
        //thread::sleep(Duration::new(0, 100));
    }


    for rect in points.iter() {
        rectmanager.set_bg_color(*rect, wrecked::Color::BLUE);
    }

    for x in 0 .. ((width * width)) {
        let rect_id = points[x % width];
        let y = (height as isize / 2 as isize) +
            ((2f64*PI * (x as f64 / (width - 1) as f64)).sin() * (height / 3) as f64) as isize;
        rectmanager.set_position(rect_id, (x % width) as isize, y);
        rectmanager.render();
        //thread::sleep(Duration::new(0, 50000));
    }
    thread::sleep(Duration::new(1, 0));

    rectmanager.kill();
}

pub fn unset_bg_color(&mut self, rect_id: usize) -> Result<(), WreckedError>

Return background color to default

Example

use wrecked::{RectManager, ROOT, Color};
let mut rectmanager = RectManager::new();
// Give Top a Magenta background
rectmanager.set_bg_color(ROOT, Color::MAGENTA);

// Remove those colors...
rectmanager.unset_bg_color(ROOT);

rectmanager.kill();

pub fn set_fg_color( &mut self, rect_id: usize, color: Color, ) -> Result<(), WreckedError>

Set color of foreground (text) of given rect (does not apply recursively)

Example

use wrecked::{RectManager, ROOT, Color};
let mut rectmanager = RectManager::new();
// Give Top a YELLOW foreground
rectmanager.set_fg_color(ROOT, Color::YELLOW);

rectmanager.kill();

Examples found in repository

examples/blink.rs (line 9)

fn main() -> Result<(), wrecked::WreckedError> {
    let mut rectmanager = wrecked::RectManager::new();
    let (width, height) = rectmanager.get_rect_size(wrecked::ROOT).unwrap();
    let blinker = rectmanager.new_rect(wrecked::ROOT)?;
    rectmanager.set_fg_color(blinker, wrecked::Color::RED)?;
    rectmanager.set_bg_color(blinker, wrecked::Color::WHITE)?;
    rectmanager.resize(blinker, width / 2, height / 2)?;
    rectmanager.set_position(blinker, (width / 4) as isize, (height / 4) as isize)?;
    rectmanager.set_string(blinker, (width / 4) as isize - 3, 2, "BLINK!")?;

    for i in 0 .. 54 {
        if i % 2 == 0 {
            rectmanager.disable(blinker)?;
        } else {
            rectmanager.enable(blinker)?;
        }
        rectmanager.render()?;
        thread::sleep(Duration::new(0, 100_000_000));
    }

    rectmanager.kill()?;
    Ok(())
}

pub fn unset_fg_color(&mut self, rect_id: usize) -> Result<(), WreckedError>

Return foreground color to default

Example

use wrecked::{RectManager, ROOT, Color};
let mut rectmanager = RectManager::new();
// Give Top a White foreground
rectmanager.set_fg_color(ROOT, Color::WHITE);

// Remove those colors...
rectmanager.unset_fg_color(ROOT);

rectmanager.kill();

pub fn unset_color(&mut self, rect_id: usize) -> Result<(), WreckedError>

Return both background and foreground colors to default

Example

use wrecked::{RectManager, ROOT, Color};
let mut rectmanager = RectManager::new();
// Give Top a Blue background and a White foreground
rectmanager.set_bg_color(ROOT, Color::BLUE);
rectmanager.set_fg_color(ROOT, Color::WHITE);

// Remove those colors...
rectmanager.unset_color(ROOT);

rectmanager.kill();

pub fn get_default_character(&self, rect_id: usize) -> char

Get the fallback character that would be displayed where no character is set. Defaults to ’ ’.

pub fn get_parent_id(&self, rect_id: usize) -> Option<usize>

Get id of parent rectangle

Example

use wrecked::{RectManager, ROOT, Color}; let mut rectmanager = RectManager::new();

let mut rect = rectmanager.new_rect(ROOT); assert_eq!(rectmanager.get_parent_id(rect), Some(ROOT));

rectmanager.detach(rect); assert_eq!(rectmanager.get_parent_id(rect), None);

rectmanager.kill();

pub fn has_parent(&self, rect_id: usize) -> bool

Check if given Rect is connected to a parent.

Example

use wrecked::{RectManager, ROOT, Color};
let mut rectmanager = RectManager::new();
let mut rect = rectmanager.new_rect(ROOT).ok().unwrap();
assert!(rectmanager.has_parent(rect));

rectmanager.detach(rect);
assert!(!rectmanager.has_parent(rect));

rectmanager.kill();

pub fn has_rect(&self, rect_id: usize) -> bool

Check if the given id has an associated Rect within the RectManager.

pub fn is_transparent(&self, rect_id: usize) -> bool

Check if the given Rect displays its background where no characters are set.

pub fn set_transparency( &mut self, rect_id: usize, transparent: bool, ) -> Result<(), WreckedError>

Set the transparency of given Rect. Transparent Rects will show the content of the Rects behind them where no characters or children are set. Opaque Rects will display the default characters in the corresponding foreground and background colors.

Example

use wrecked::{RectManager, ROOT, Color};
let mut rectmanager = RectManager::new();
let rect = rectmanager.new_rect(ROOT).ok().unwrap();
rectmanager.set_transparency(rect, true);
rectmanager.kill();

pub fn get_fg_color(&self, rect_id: usize) -> Option<Color>

Get foreground color of given Rect

Example

use wrecked::{RectManager, ROOT, Color};
let mut rectmanager = RectManager::new();
assert_eq!(rectmanager.get_fg_color(ROOT), None);
rectmanager.set_fg_color(ROOT, Color::BLUE);
assert_eq!(rectmanager.get_fg_color(ROOT), Some(Color::BLUE));
// turn echo back on and return input to normal.
rectmanager.kill();

pub fn get_bg_color(&self, rect_id: usize) -> Option<Color>

Get background color of given rectangle

Example

use wrecked::{RectManager, ROOT, Color};
let mut rectmanager = RectManager::new();
assert_eq!(rectmanager.get_bg_color(ROOT), None);
rectmanager.set_bg_color(ROOT, Color::BLUE);
assert_eq!(rectmanager.get_bg_color(ROOT), Some(Color::BLUE));
// turn echo back on and return input to normal.
rectmanager.kill();