Struct Context

pub struct Context<'a> { /* private fields */ }

Holds the state of the Canvas when painting to it.

This is used by the Canvas widget to draw shapes on the grid. It can be useful to think of this as similar to the Frame struct that is used to draw widgets on the terminal.

Implementations

impl<'a> Context<'a>

pub fn new( width: u16, height: u16, x_bounds: [f64; 2], y_bounds: [f64; 2], marker: Marker, ) -> Self

Create a new Context with the given width and height measured in terminal columns and rows respectively. The x and y bounds define the specific area of some coordinate system that will be drawn on the canvas. The marker defines the type of points used to draw the shapes.

Applications should not use this directly but rather use the Canvas widget. This will be created by the Canvas::paint method and passed to the closure that is used to draw on the canvas.

The x and y bounds should be specified as left/right and bottom/top respectively. For example, if you want to draw a map of the world, you might want to use the following bounds:

use ratatui::{symbols, widgets::canvas::Context};

let ctx = Context::new(
    100,
    100,
    [-180.0, 180.0],
    [-90.0, 90.0],
    symbols::Marker::Braille,
);

pub fn draw<S>(&mut self, shape: &S)

where S: Shape,

Draw the given Shape in this context

pub fn layer(&mut self)

Save the existing state of the grid as a layer.

Save the existing state as a layer to be rendered and reset the grid to its initial state for the next layer.

This allows the canvas to be drawn in multiple layers. This is useful if you want to draw multiple shapes on the Canvas in specific order.

pub fn print<T>(&mut self, x: f64, y: f64, line: T)

where T: Into<TextLine<'a>>,

Print a Text on the Canvas at the given position.

Note that the text is always printed on top of the canvas and is not affected by the layers.

Trait Implementations

impl<'a> Debug for Context<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a, 'b> From<&'a mut Context<'b>> for Painter<'a, 'b>

fn from(context: &'a mut Context<'b>) -> Self

Converts to this type from the input type.