Struct wrecked::RectManager[−][src]

pub struct RectManager { /* fields omitted */ }

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[src]

pub fn new() -> RectManager[src]

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();

pub fn fit_to_terminal(&mut self) -> bool[src]

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[src]

Deprecated. Use fit_to_terminal()

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

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();

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

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();

pub fn get_height(&self) -> usize[src]

Gets the height of the RectManager

pub fn get_width(&self) -> usize[src]

Gets the width of the RectManager

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

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[src]

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>[src]

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>[src]

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

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)>[src]

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[src]

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[src]

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)>[src]

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());

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

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();

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

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();

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

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());

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

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>[src]

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));

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

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

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

If a rectangle has been disabled, enable it.

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

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>[src]

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>[src]

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

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

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>[src]

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>[src]

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();

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

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();

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

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>[src]

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>[src]

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>[src]

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>[src]

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>[src]

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>[src]

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>[src]

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>[src]

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>[src]

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>[src]

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>[src]

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>[src]

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();

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();

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>[src]

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();

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

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>[src]

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();

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

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>[src]

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[src]

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>[src]

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[src]
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[src]
Check if the given id has an associated Rect within the RectManager.


pub fn is_transparent(&self, rect_id: usize) -> bool[src]
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>[src]
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>[src]
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>[src]
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();


Auto Trait Implementations
Blanket Implementations
impl<T> Any for T where
    T: 'static + ?Sized, [src]
impl<T> Borrow<T> for T where
    T: ?Sized, [src]
impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]
impl<T> From<T> for T[src]
impl<T, U> Into<U> for T where
    U: From<T>, [src]
impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]
type Error = Infallible
The type returned in the event of a conversion error.


impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.