Struct ClipperBuffer 

pub struct ClipperBuffer<'a, W>
where
    W: Eq + Clone + Hash,
{ /* private fields */ }

Second stage: render widgets to the temporary buffer.

Implementations

impl<'a, W> ClipperBuffer<'a, W>

where W: Eq + Hash + Clone,

pub fn is_visible(&self, widget: W) -> bool

Is the widget visible.

pub fn render_label<FN>(&mut self, widget: W, render_fn: FN) -> bool

where FN: FnOnce(&Option<Cow<'static, str>>, Rect, &mut Buffer),

Render the label for the given widget.

pub fn render_widget<FN, WW>(&mut self, widget: W, render_fn: FN) -> bool

where FN: FnOnce() -> WW, WW: Widget,

Render a stateless widget and its label.

pub fn render<FN, WW, SS>( &mut self, widget: W, render_fn: FN, state: &mut SS, ) -> bool

where FN: FnOnce() -> WW, WW: StatefulWidget<State = SS>, SS: RelocatableState,

Render a stateful widget and its label.

pub fn render2<FN, WW, SS, R>( &mut self, widget: W, render_fn: FN, state: &mut SS, ) -> Option<R>

where FN: FnOnce() -> (WW, R), WW: StatefulWidget<State = SS>, SS: RelocatableState,

Render a stateful widget and its label.

This expects a pair of StatefulWidgets, of which the first will be rendered and the second will be returned.

This is for rendering widgets that split in two parts, the main widget and a popup. The popup must be rendered later to be ‘above’ all other widgets. Use [render_pop] for this.

pub fn render_popup<FN, WW, SS>( &mut self, widget: W, render_fn: FN, state: &mut SS, ) -> bool

where FN: FnOnce() -> Option<WW>, WW: StatefulWidget<State = SS>, SS: RelocatableState,

Render an additional popup widget for the given main widget.

Doesn’t call relocate() at all.

pub fn locate_widget(&self, widget: W) -> Option<Rect>

Get the buffer coordinates for the given widget.

pub fn locate_label(&self, widget: W) -> Option<Rect>

Get the buffer coordinates for the label of the given widget.

pub fn locate_area(&self, area: Rect) -> Option<Rect>

Relocate the area from layout coordinates to buffer coordinates, which is a noop as those are aligned.

But this will return None if the given area is outside the buffer.

pub fn relocate<S>(&self, widget: W, state: &mut S)

where S: RelocatableState,

After rendering the widget to the buffer it may have stored areas in its state. These will be in buffer coordinates instead of screen coordinates.

Call this function to correct this after rendering.

Note:

This is only necessary if you do some manual rendering of stateful widgets. If you use [render] this will happen automatically

Parameter:

widget: The visibility of this widget will determine if the areas in state are shifted or hidden altogether.

pub fn buffer(&mut self) -> &mut Buffer

Return a reference to the buffer.

pub fn finish(self, tgt_buf: &mut Buffer, state: &mut ClipperState<W>)

Trait Implementations

impl<'a, W> Debug for ClipperBuffer<'a, W>

where W: Eq + Clone + Hash + Debug,

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

Formats the value using the given formatter.

impl<'a, W> Drop for ClipperBuffer<'a, W>

where W: Eq + Hash + Clone,

fn drop(&mut self)

Executes the destructor for this type.