Struct DebugLayer 

pub struct DebugLayer<A> { /* private fields */ }

High-level debug layer with minimal configuration.

Provides automatic freeze/unfreeze with pause/resume of tasks and subscriptions.

Example

use crossterm::event::KeyCode;
use tui_dispatch::debug::DebugLayer;

// Minimal setup - just the toggle key
let mut debug = DebugLayer::new(KeyCode::F(12))
    .with_task_manager(&tasks)
    .with_subscriptions(&subs)
    .active(args.debug);

// In event loop
if debug.intercepts(&event) {
    continue;
}

// In render
debug.render(frame, |f, area| {
    app.render(f, area);
});

// Log actions for the action log feature
debug.log_action(&action);

Implementations

impl<A: Action> DebugLayer<A>

pub fn new(toggle_key: KeyCode) -> Self

Create a new debug layer with the given toggle key.

Example

use crossterm::event::KeyCode;

let debug = DebugLayer::new(KeyCode::F(12));

pub fn active(self, active: bool) -> Self

Set whether the debug layer is active.

When inactive (false), all methods become no-ops with zero overhead.

pub fn with_action_log_capacity(self, capacity: usize) -> Self

Set the action log capacity.

pub fn with_style(self, style: DebugStyle) -> Self

Set custom style.

pub fn is_active(&self) -> bool

Check if the debug layer is active.

pub fn is_enabled(&self) -> bool

Check if debug mode is enabled (and layer is active).

pub fn is_state_overlay_visible(&self) -> bool

Check if the state overlay is currently visible.

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 log_action<T: ActionParams>(&mut self, action: &T)

Log an action to the action log.

Call this when dispatching actions to record them for the debug overlay.

pub fn action_log(&self) -> &ActionLog

Get the action log.

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

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

Render with automatic debug handling.

When debug mode is disabled, simply calls render_fn with the full frame area. When enabled, captures/paints the frozen snapshot and renders debug overlay.

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

Split area for manual layout control.

pub fn intercepts(&mut self, event: &EventKind) -> bool

Check if debug layer intercepts an event.

Call this before your normal event handling. If it returns true, the event was consumed by the debug layer.

Example

if debug.intercepts(&event) {
    continue;
}
// Normal event handling

pub fn intercepts_with_effects( &mut self, event: &EventKind, ) -> Option<Vec<DebugSideEffect<A>>>

Check if debug layer intercepts an event, returning any side effects.

Returns None if the event was not consumed, Some(effects) if it was.

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

Show state overlay using a DebugState implementor.

pub fn show_action_log(&mut self)

Show action log overlay.

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

Queue an action to be processed when debug mode is disabled.

pub fn take_queued_actions(&mut self) -> Vec<A>

Take any queued actions (from task manager resume).

Call this after intercepts() returns effects to get queued actions that should be dispatched.

Trait Implementations

impl<A> Debug for DebugLayer<A>

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

Formats the value using the given formatter.