Struct DebugFreeze 

pub struct DebugFreeze<A> {
    pub enabled: bool,
    pub pending_capture: bool,
    pub snapshot: Option<Buffer>,
    pub snapshot_text: String,
    pub queued_actions: Vec<A>,
    pub message: Option<String>,
    pub overlay: Option<DebugOverlay>,
    pub mouse_capture_enabled: bool,
}

Debug freeze state for capturing and inspecting UI frames

Generic over the action type A to store queued actions while frozen.

Example

use tui_dispatch_core::debug::DebugFreeze;

// In your app state:
struct AppState {
    debug: DebugFreeze<MyAction>,
    // ... other fields
}

// Toggle freeze on F12:
fn handle_action(state: &mut AppState, action: MyAction) {
    match action {
        MyAction::ToggleDebug => {
            state.debug.toggle();
        }
        other if state.debug.enabled => {
            // Queue actions while frozen
            state.debug.queue(other);
        }
        // ... normal handling
    }
}

Fields

enabled: bool

Whether debug/freeze mode is enabled

pending_capture: bool

Flag to capture the next frame

snapshot: Option<Buffer>

The captured buffer snapshot

snapshot_text: String

Plain text version of snapshot (for clipboard)

queued_actions: Vec<A>

Actions queued while frozen

message: Option<String>

Feedback message to display

overlay: Option<DebugOverlay>

Currently displayed overlay

mouse_capture_enabled: bool

Whether mouse capture mode is enabled (for position inspection)

Implementations

impl<A> DebugFreeze<A>

pub fn new() -> Self

Create a new debug freeze state

pub fn toggle(&mut self)

Toggle freeze mode on/off

When enabling, sets pending_capture to capture the next frame. When disabling, clears the snapshot and queued actions.

pub fn enable(&mut self)

Enable freeze mode

pub fn disable(&mut self)

Disable freeze mode

pub fn capture(&mut self, buffer: &Buffer)

Capture the current buffer as a snapshot

pub fn request_capture(&mut self)

Request a new capture on the next frame

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

Queue an action to be processed when freeze is disabled

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

Take all queued actions, leaving the queue empty

pub fn set_message(&mut self, msg: impl Into<String>)

Set a feedback message

pub fn clear_message(&mut self)

Clear the feedback message

pub fn set_overlay(&mut self, overlay: DebugOverlay)

Set the current overlay

pub fn clear_overlay(&mut self)

Clear the current overlay

pub fn toggle_mouse_capture(&mut self)

Toggle mouse capture mode

Trait Implementations

impl<A: Debug> Debug for DebugFreeze<A>

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

Formats the value using the given formatter.

impl<A> Default for DebugFreeze<A>

fn default() -> Self

Returns the “default value” for a type.