Struct Log 

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

The tail of messages that fits in the area it’s rendered into, oldest at top, newest at the bottom, each line clipped to area.width() via PrintLine.

offset (set via Log::offset, default 0) scrolls back through history: 0 shows the most recent messages, and each increment moves the window one message further into the past. Like Table’s state.offset(), this does not clamp offset: scrolling back past the start of messages shows fewer (or zero) lines rather than wrapping or panicking, and it’s the caller’s responsibility to stop incrementing offset past messages.len() if that’s undesired. This is a different windowing direction than Table’s (anchored to the start and counting forward), so it isn’t expressed as the same shared helper.

messages is a plain slice the caller owns and appends to (the same division of labor as ListState for selection): this widget only reads it. Rows beyond the available messages are left untouched: compose with fill_rect first for a solid background if one is wanted.

By default each message is truncated to one row via PrintLine, which clips anything past area.width(). Log::wrap (requires the egc feature) switches to word-wrapping each message across as many rows as it needs, via retroglyph_core::layout::wrap, while keeping offset counting messages rather than rows: the window still fills from the newest message backward, but a message is only included if all of its wrapped rows fit in what’s left of the surface, since there’s no supported way to render only the bottom rows of an overflowing wrapped message. A message that doesn’t fully fit is left out entirely, the same “rows beyond the available messages are left untouched” behavior as running out of messages.

Examples

use retroglyph_core::grid::Rect;
use retroglyph_core::text::Line;
use retroglyph_core::grid::Grid;
use retroglyph_ui::{Log, Surface, Widget};

let messages = [Line::raw("connected"), Line::raw("joined #general")];
let area = Rect::new(0, 0, 20, 2);
let mut grid = Grid::new(20, 2);
Log::new(&messages).render(&mut Surface::new(&mut grid, area, 0));

Implementations

impl<'a> Log<'a>

pub const fn new(messages: &'a [Line]) -> Self

A log tail over messages, starting at the most recent (offset 0).

pub const fn offset(self, offset: usize) -> Self

Scroll back offset messages from the most recent.

pub const fn wrap(self, wrap: bool) -> Self

Word-wraps each message across as many rows as it needs instead of clipping it to one row, via retroglyph_core::layout::wrap. See the struct docs for how this interacts with offset. Requires the egc feature.

Trait Implementations

impl<'a> Clone for Log<'a>

fn clone(&self) -> Log<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Log<'a>

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

Formats the value using the given formatter.

impl Measure for Log<'_>

fn height_for(&self, width: u16) -> u16

One row per message when not wrapped (width ignored); with Log::wrap set, the sum of each message’s wrapped row count at width. This is the height needed to show the full backlog, not just the current offset window.

impl Widget for Log<'_>

fn render(&self, surface: &mut Surface<'_>)

Draw this widget into surface, filling surface.area().

impl<'a> Copy for Log<'a>