Struct Canvas 

pub struct Canvas { /* private fields */ }

Shapes and text drawn in world coordinates, as ratatui’s Canvas.

• The bounds (x_bounds, y_bounds) are the world’s edges: x grows to the right and y upwards. They default to 0..1; empty, reversed or infinite bounds draw nothing.
• It fills the height it is given (a Layout region, an intuiTUIve node), or is height rows when that is set, or 10 rows; and it is as wide as the width it is given (or width).
• background styles the cells nothing drew in, and goes under what is drawn.
• paint runs a closure once and records what it draws, so the canvas renders the same every time and can be cloned.
• Marker::Braille (the default) draws 2×4 dots a cell. An ASCII-only console gets one glyph a cell instead.

use rich::Console;
use rich_ext::chart::{Canvas, Marker};

let console = Console::builder().width(12).color_system(None).build();
let canvas = Canvas::new()
    .x_bounds(0.0, 11.0)
    .y_bounds(0.0, 3.0)
    .height(4)
    .marker(Marker::Ascii('#'))
    .paint(|p| {
        p.rect(0.0, 0.0, 11.0, 3.0, "blue");
        p.line(0.0, 0.0, 11.0, 3.0, "red");
        p.print(2.0, 2.0, "hi", "bold");
    });
assert_eq!(
    console.render_export(&canvas),
    concat!(
        "############\n",
        "# hi  #### #\n",
        "# ####     #\n",
        "############\n",
    )
);

// Braille: 2×4 dots a cell.
let braille = Canvas::new()
    .x_bounds(0.0, 3.0)
    .y_bounds(0.0, 3.0)
    .height(1)
    .width(2)
    .paint(|p| {
        p.line(0.0, 0.0, 3.0, 3.0, "");
    });
assert_eq!(console.render_export(&braille), "⡠⠊\n");

Implementations

impl Canvas

pub fn new() -> Self

A blank canvas over 0..1 × 0..1.

pub fn x_bounds(self, left: f64, right: f64) -> Self

The world’s left and right edges.

pub fn y_bounds(self, bottom: f64, top: f64) -> Self

The world’s bottom and top edges.

pub fn width(self, width: usize) -> Self

Width in cells (default: the width it is given).

pub fn height(self, rows: usize) -> Self

Height in rows (at most 65535), whatever height it is given. Without it, the canvas fills the height it is given, or takes 10 rows.

pub fn background(self, style: impl Into<String>) -> Self

The style of the cells nothing drew in, and under what is drawn: a theme key or a definition. A style with only a foreground colour ("navy_blue") is taken as that background ("on navy_blue").

pub fn marker(self, marker: Marker) -> Self

The marker the first layer draws with (default Marker::Braille); CanvasPainter::marker changes it.

pub fn paint(self, draw: impl FnOnce(&mut CanvasPainter)) -> Self

Run draw once and keep what it draws. Each call adds to what earlier calls drew, in a new layer.

Trait Implementations

impl AccessibleText for Canvas

Canvas, x from -180 to 180, y from -90 to 90: a world map, 4 points, 3 lines, then the text printed on it (Text: London, Paris). A canvas holds shapes rather than data, so it says what it drew.

fn accessible_text(&self, _width: usize) -> String

The content as plain lines, laid out for width where layout matters.

impl Clone for Canvas

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Canvas

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

Formats the value using the given formatter.

impl Default for Canvas

fn default() -> Self

Returns the “default value” for a type.

impl Draw for Canvas

fn draw( &self, console: &Console, options: &ConsoleOptions, screen: &mut Screen, rect: Rect, )

Draw into rect of screen, rendered with options (its width and height are the rectangle’s): the cells screen.write_lines(rect, &console.render_lines(self, options, false)) would give.

impl PartialEq for Canvas

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Renderable for Canvas

fn rich_render( &self, console: &Console, options: &ConsoleOptions, ) -> Vec<Segment>

fn measure(&self, _console: &Console, options: &ConsoleOptions) -> Measurement

The (minimum, maximum) cell width this renderable wants. Port of __rich_measure__. The default is what upstream’s Measurement.get returns for a renderable without one: anything from nothing to the whole width, (0, max_width).

fn fit_to_measurement(&self) -> bool

Whether a top-level Console::print shrinks this renderable to its measured width. Upstream renders every top-level renderable at the full console width, so the default is false; an extension may opt in.

fn vertical(&self) -> Option<VerticalAlign>

The vertical alignment a Table cell holding this renderable uses in place of its column’s. Upstream reads getattr(renderable, "vertical", None); Align sets it.

fn print_end_line(&self, _options: &ConsoleOptions) -> bool

Whether a top-level print ends this renderable’s last line. This port’s renderables separate lines, where upstream’s end each line with "\n", so a print adds the final line break. A renderable whose upstream output stops without one (Screen, LiveRender, a Rule whose end has no newline) returns false, and the next output continues its last line. options are the print’s options.

impl StructuralPartialEq for Canvas