Struct bracket_terminal::prelude::SparseConsole

pub struct SparseConsole {
    pub width: u32,
    pub height: u32,
    pub tiles: Vec<SparseTile>,
    pub is_dirty: bool,
    pub offset_x: f32,
    pub offset_y: f32,
    pub scale: f32,
    pub scale_center: (i32, i32),
    pub extra_clipping: Option<Rect>,
    pub translation: CharacterTranslationMode,
    // some fields omitted
}

A sparse console. Rather than storing every cell on the screen, it stores just cells that have data.

Fields

width: u32

height: u32

tiles: Vec<SparseTile>

is_dirty: bool

offset_x: f32

offset_y: f32

scale: f32

scale_center: (i32, i32)

extra_clipping: Option<Rect>

translation: CharacterTranslationMode

Implementations

impl SparseConsole

pub fn init(width: u32, height: u32) -> Box<SparseConsole>

Initializes the console.

Trait Implementations

impl Console for SparseConsole

fn at(&self, x: i32, y: i32) -> usize

Translates x/y to an index entry. Not really useful.

fn cls(&mut self)

Clear the screen.

fn cls_bg(&mut self, _background: RGBA)

Clear the screen. Since we don’t HAVE a background, it doesn’t use it.

fn print(&mut self, x: i32, y: i32, output: &str)

Prints a string to an x/y position.

fn print_color(&mut self, x: i32, y: i32, fg: RGBA, bg: RGBA, output: &str)

Prints a string to an x/y position, with foreground and background colors.

fn set(&mut self, x: i32, y: i32, fg: RGBA, bg: RGBA, glyph: FontCharType)

Sets a single cell in the console

fn set_bg(&mut self, x: i32, y: i32, bg: RGBA)

Sets a single cell in the console’s background

fn draw_box(
    &mut self,
    sx: i32,
    sy: i32,
    width: i32,
    height: i32,
    fg: RGBA,
    bg: RGBA
)

Draws a box, starting at x/y with the extents width/height using CP437 line characters

fn draw_box_double(
    &mut self,
    sx: i32,
    sy: i32,
    width: i32,
    height: i32,
    fg: RGBA,
    bg: RGBA
)

Draws a box, starting at x/y with the extents width/height using CP437 double line characters

fn draw_hollow_box(
    &mut self,
    sx: i32,
    sy: i32,
    width: i32,
    height: i32,
    fg: RGBA,
    bg: RGBA
)

Draws a box, starting at x/y with the extents width/height using CP437 line characters

fn draw_hollow_box_double(
    &mut self,
    sx: i32,
    sy: i32,
    width: i32,
    height: i32,
    fg: RGBA,
    bg: RGBA
)

Draws a box, starting at x/y with the extents width/height using CP437 double line characters

fn fill_region(&mut self, target: Rect, glyph: FontCharType, fg: RGBA, bg: RGBA)

Fills a rectangle with the specified rendering information

fn draw_bar_horizontal(
    &mut self,
    sx: i32,
    sy: i32,
    width: i32,
    n: i32,
    max: i32,
    fg: RGBA,
    bg: RGBA
)

Draws a horizontal progress bar

fn draw_bar_vertical(
    &mut self,
    sx: i32,
    sy: i32,
    height: i32,
    n: i32,
    max: i32,
    fg: RGBA,
    bg: RGBA
)

Draws a vertical progress bar

fn print_centered(&mut self, y: i32, text: &str)

Prints text, centered to the whole console width, at vertical location y.

fn print_color_centered(&mut self, y: i32, fg: RGBA, bg: RGBA, text: &str)

Prints text in color, centered to the whole console width, at vertical location y.

fn print_centered_at(&mut self, x: i32, y: i32, text: &str)

Prints text, centered to the whole console width, at vertical location y.

fn print_color_centered_at(
    &mut self,
    x: i32,
    y: i32,
    fg: RGBA,
    bg: RGBA,
    text: &str
)

Prints text in color, centered to the whole console width, at vertical location y.

fn print_right(&mut self, x: i32, y: i32, text: &str)

Prints text right-aligned

fn print_color_right(&mut self, x: i32, y: i32, fg: RGBA, bg: RGBA, text: &str)

Prints colored text right-aligned

fn printer(
    &mut self,
    x: i32,
    y: i32,
    output: &str,
    align: TextAlign,
    background: Option<RGBA>
)

Print a colorized string with the color encoding defined inline. For example: printer(1, 1, “#[blue]This blue text contains a #[pink]pink#[] word”) You can get the same effect with a TextBlock, but this can be easier. Thanks to doryen_rs for the idea.

fn to_xp_layer(&self) -> XpLayer

Saves the layer to an XpFile structure

fn set_offset(&mut self, x: f32, y: f32)

Sets an offset to total console rendering, useful for layers that draw between tiles. Offsets are specified as a percentage of total character size; so -0.5 will offset half a character to the left/top.

fn set_clipping(&mut self, clipping: Option<Rect>)

Permits the creation of an arbitrary clipping rectangle. It’s a really good idea to make sure that this rectangle is entirely valid.

fn get_clipping(&self) -> Option<Rect>

Returns the current arbitrary clipping rectangle, None if there isn’t one.

fn set_all_fg_alpha(&mut self, alpha: f32)

Sets ALL tiles foreground alpha (only tiles that exist, in sparse consoles).

fn set_all_bg_alpha(&mut self, alpha: f32)

Sets ALL tiles background alpha (only tiles that exist, in sparse consoles).

fn set_all_alpha(&mut self, fg: f32, bg: f32)

Sets ALL tiles foreground alpha (only tiles that exist, in sparse consoles).

fn set_translation_mode(&mut self, mode: CharacterTranslationMode)

Sets the character translation mode

fn set_char_size(&mut self, width: u32, height: u32)

Sets the character size of the terminal

fn get_char_size(&self) -> (u32, u32)

Gets the dimensions of the console in characters

fn resize_pixels(&mut self, _width: u32, _height: u32)

fn set_scale(&mut self, scale: f32, center_x: i32, center_y: i32)

Specify a scale and center of the console. A scale above 1.0 will make the text larger. The center of the scale is at character position (center_x, center_y).

fn get_scale(&self) -> (f32, i32, i32)

Get the scale & center of the console. Returns (scale, center_x, center_y).

fn as_any(&self) -> &dyn Any

Produces the implementor as an Any that can be matched to determine type and access natively.

fn as_any_mut(&mut self) -> &mut dyn Any

Produces the implementor as an Any that can be matched to determine type and access natively.

fn clear_dirty(&mut self)

fn in_bounds(&self, x: i32, y: i32) -> bool

Returns true if an x/y coordinate is within the console bounds

fn try_at(&self, x: i32, y: i32) -> Option<usize>

Try to use a coordinate: return Some(the coordinate) if it is valid, None if it isn’t.