Struct DebugLayer 

pub struct DebugLayer<A, C: BindingContext> { /* private fields */ }

High-level debug layer with sensible defaults

Wraps DebugFreeze and provides automatic rendering with:

• 1-line status bar at bottom when debug mode is active
• Frame capture/restore with dimming
• Modal overlays for state inspection

Type Parameters

• A: The application’s action type (for queuing actions while frozen)
• C: The keybinding context type

Example

use tui_dispatch::debug::{DebugLayer, DebugConfig};

// In your app:
struct App {
    debug: DebugLayer<MyAction, MyContext>,
    // ...
}

// In render loop:
app.debug.render(frame, |f, area| {
    // Render your normal UI here
    app.render_main(f, area);
});

Implementations

impl<A, C: BindingContext> DebugLayer<A, C>

pub fn new(config: DebugConfig<C>) -> Self

Create a new debug layer with the given configuration

pub fn is_enabled(&self) -> bool

Check if debug mode is enabled

pub fn freeze(&self) -> &DebugFreeze<A>

Get a reference to the underlying freeze state

pub fn freeze_mut(&mut self) -> &mut DebugFreeze<A>

Get a mutable reference to the underlying freeze state

pub fn config(&self) -> &DebugConfig<C>

Get the configuration

pub fn config_mut(&mut self) -> &mut DebugConfig<C>

Get mutable configuration

pub fn render<F>(&mut self, frame: &mut Frame<'_>, render_fn: F)

where F: FnOnce(&mut Frame<'_>, Rect),

Render with automatic debug handling (primary API)

When debug mode is disabled, simply calls render_fn with the full frame area.

When debug mode is enabled:

• Reserves 1 line at bottom for the debug banner
• Captures the frame on first render or when requested
• Paints the frozen snapshot with dimming
• Renders debug overlay (banner + modal if open)

Example

terminal.draw(|frame| {
    app.debug.render(frame, |f, area| {
        render_main_ui(f, area, &app.state);
    });
})?;

pub fn split_area(&self, area: Rect) -> (Rect, Rect)

Split area for manual layout control (escape hatch)

Returns (app_area, debug_banner_area). When debug mode is disabled, returns the full area and an empty rect.

Example

let (app_area, banner_area) = debug.split_area(frame.area());

// Custom layout
let chunks = Layout::vertical([...]).split(app_area);
app.render_main(frame, chunks[0]);
app.render_status(frame, chunks[1]);

// Let debug layer render its UI
if debug.is_enabled() {
    debug.render_overlay(frame, app_area);
    debug.render_banner(frame, banner_area);
}

pub fn render_overlay(&self, frame: &mut Frame<'_>, app_area: Rect)

Render just the debug overlay (modal + dimming)

Use this with split_area for manual layout control.

pub fn render_banner(&self, frame: &mut Frame<'_>, banner_area: Rect)

Render just the debug banner

Use this with split_area for manual layout control.

pub fn render_banner_with_status( &self, frame: &mut Frame<'_>, banner_area: Rect, status_items: &[(&str, &str)], )

Render the debug banner with custom status items

Use this if you need to add dynamic status items to the banner. The status_items slice must outlive this call.

pub fn handle_action( &mut self, action: DebugAction, ) -> Option<DebugSideEffect<A>>

Handle a debug action

Returns a side effect if the app needs to take action (clipboard, mouse capture, etc).

pub fn handle_mouse(&mut self, mouse: MouseEvent) -> Option<DebugSideEffect<A>>

Handle a mouse event in debug mode

Returns true if the event was consumed by debug handling.

pub fn show_state_overlay<S: DebugState>(&mut self, state: &S)

Show state overlay using a DebugState implementor

pub fn show_state_overlay_with_title<S: DebugState>( &mut self, state: &S, title: &str, )

Show state overlay with custom title

pub fn queue_action(&mut self, action: A)

Queue an action to be processed when debug mode is disabled

Trait Implementations

impl<A, C: BindingContext> Debug for DebugLayer<A, C>

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

Formats the value using the given formatter.