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 tui_dispatch::debug::DebugLayer;

// Minimal setup with sensible defaults (F12 toggle key)
let mut debug = DebugLayer::simple()
    .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 simple() -> Self

Create a debug layer with sensible defaults (F12 toggle key).

pub fn simple_with_toggle_key(toggle_key: KeyCode) -> Self

Create a debug layer with a custom toggle key.

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_banner_position(self, position: BannerPosition) -> Self

Set the initial banner position.

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 toggle_enabled(&mut self) -> Option<DebugSideEffect<A>>

Toggle debug mode on/off and return any side effects.

Returns None when the layer is inactive or no side effects are needed.

pub fn set_enabled(&mut self, enabled: bool) -> Option<DebugSideEffect<A>>

Set debug mode on/off and return any side effects.

Returns None when the layer is inactive or already in the requested state.

pub fn set_banner_position(&mut self, position: BannerPosition)

Update the banner position (top/bottom) and request a new capture.

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 render_with_state<F>(&mut self, frame: &mut Frame<'_>, render_fn: F)

where F: FnOnce(&mut Frame<'_>, Rect, bool) -> Option<DebugTableOverlay>,

Render with optional state capture for the state overlay.

render_fn receives the frame, app area, and a wants_state hint that is true when debug mode is active and state data may be requested. Return Some(DebugTableOverlay) to update the cached state overlay.

pub fn render_state<S: DebugState, F>( &mut self, frame: &mut Frame<'_>, state: &S, render_fn: F, )

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

Render with a DebugState reference and automatic state table generation.

This is a convenience wrapper around render_with_state.

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 handle_event(&mut self, event: &EventKind) -> DebugOutcome<A>

Handle a debug event with a single call and return a summary outcome.

pub fn handle_event_with_state<S: DebugState>( &mut self, event: &EventKind, state: &S, ) -> DebugOutcome<A>

Handle a debug event with access to state (for the state overlay).

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 intercepts_with_effects_and_state<S: DebugState>( &mut self, event: &EventKind, state: &S, ) -> Option<Vec<DebugSideEffect<A>>>

Check if debug layer intercepts an event with access to app state.

Use this to populate the state overlay when S is pressed.

pub fn intercepts_with_state<S: DebugState>( &mut self, event: &EventKind, state: &S, ) -> bool

Check if debug layer intercepts an event with access to app state.

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.