Struct vga_framebuffer::FrameBuffer

pub struct FrameBuffer<T> where
    T: Hardware,  { /* fields omitted */ }

This structure represents the framebuffer - a 2D array of monochome pixels.

The framebuffer is stored as an array of horizontal lines, where each line is comprised of 8 bit words. This suits our timing needs as although the SPI peripheral on an LM4F120 which can emit 16 bits at a time, 8 proves easier to work with.

Methods

impl<T> FrameBuffer<T> where
    T: Hardware, 

pub const fn new() -> FrameBuffer<T>

Create a new FrameBuffer

pub fn init(&mut self, hw: T)

Initialise the hardware (by calling the configure callback).

pub fn frame(&self) -> usize

Returns the current frame number.

pub fn isr_sol(&mut self)

Call this at the start of every line.

pub fn clear(&mut self)

Clears the screen and resets the cursor to 0,0.

pub fn write_glyph_at(
    &mut self,
    glyph: Glyph,
    pos: Position,
    attr: Option<Attr>
)

Puts a glyph on screen at the specified place

pub fn write_glyph(&mut self, glyph: Glyph, attr: Option<Attr>)

Puts a glyph on screen at the current position.

pub fn set_attr(&mut self, attr: Attr) -> Attr

Change the current character attribute

pub fn get_attr(&mut self) -> Attr

Get the current character attribute

Trait Implementations

impl<T> Console for FrameBuffer<T> where
    T: Hardware, 

type Error = ()

fn get_width(&self) -> Col

Gets the last col on the screen.

fn get_height(&self) -> Row

Gets the last row on the screen.

fn set_col(&mut self, col: Col) -> Result<(), Self::Error>

Set the horizontal position for the next text output.

fn set_row(&mut self, row: Row) -> Result<(), Self::Error>

Set the vertical position for the next text output.

fn set_pos(&mut self, pos: Position) -> Result<(), Self::Error>

Set the horizontal and vertical position for the next text output.

fn get_pos(&self) -> Position

Get the current screen position.

fn set_control_char_mode(&mut self, mode: ControlCharMode)

Set the control char mode

fn get_control_char_mode(&self) -> ControlCharMode

Get the current control char mode

fn set_escape_char_mode(&mut self, mode: EscapeCharMode)

Set the escape char mode

fn get_escape_char_mode(&self) -> EscapeCharMode

Get the current escape char mode

fn scroll_screen(&mut self) -> Result<(), Self::Error>

Called when the screen needs to scroll up one row.

fn handle_escape(&mut self, escaped_char: char) -> bool

Handle an escape char. We take a, b, c, d, e, f, g, h as being a background colour and A..H as being a foreground colour. 'Z' means clear the screen.

fn write_char_at(&mut self, ch: char, pos: Position) -> Result<(), Self::Error>

Write a single Unicode char to the screen at the given position without updating the current position.

fn set_pos_unbounded(&mut self, pos: Position)

Set the horizontal and vertical position for the next text output. Don't bounds check the value, we've already done it.

fn write_string(&mut self, str: &str) -> Result<(), Self::Error>

Write a string to the screen at the given position. Updates the current position to the end of the string. Strings will wrap across the end of the screen and scroll the screen if they reach the bottom.

fn write_char(&mut self, ch: char) -> Result<(), Self::Error>

Write a single Unicode char to the screen at the current position.

fn write_string_at(
    &mut self,
    str: &str,
    pos: Position
) -> Result<(), Self::Error>

Write a string to the screen at the given position. Updates the current position to the end of the string. Strings will wrap across the end of the screen and scroll the screen if they reach the bottom.

fn move_cursor_right(&mut self) -> Result<(), Self::Error>

Move the current cursor right one position. Wraps at the end of the line. Returns Ok(true) if the screen needs to scroll, or Ok(false) if it does not.

fn is_special(&self, ch: char) -> Option<SpecialChar>

Check if a char is special

impl<T> Write for FrameBuffer<T> where
    T: Hardware, 

fn write_str(&mut self, s: &str) -> Result

Writes a slice of bytes into this writer, returning whether the write succeeded.

fn write_char(&mut self, c: char) -> Result<(), Error>

Writes a [char] into this writer, returning whether the write succeeded.

fn write_fmt(&mut self, args: Arguments) -> Result<(), Error>

Glue for usage of the [write!] macro with implementors of this trait.