Struct TerminalUI 

pub struct TerminalUI {
    pub(super) state: UIState,
    pub(super) chat_mode: ChatMode,
    pub(super) log_mode: LogMode,
    pub(super) event_rx: UnboundedReceiver<UIEvent>,
    pub(super) action_tx: UnboundedSender<UIAction>,
    pub(super) node: Option<Arc<Node>>,
    pub(super) log_buffer: Option<Arc<LogBuffer>>,
}

Manages the terminal user interface, including state, rendering, and event handling.

Fields

state: UIState

The current state of the user interface.

chat_mode: ChatMode

The chat mode specific logic and state.

log_mode: LogMode

The log mode specific logic and state.

event_rx: UnboundedReceiver<UIEvent>

Receiver for UI events from various parts of the application.

action_tx: UnboundedSender<UIAction>

Sender for dispatching UI actions.

node: Option<Arc<Node>>

An optional reference to the application’s core Node.

log_buffer: Option<Arc<LogBuffer>>

An optional reference to the LogBuffer.

Implementations

impl TerminalUI

pub fn new( event_rx: UnboundedReceiver<UIEvent>, action_tx: UnboundedSender<UIAction>, ) -> Self

Creates a new TerminalUI instance.

Arguments

• event_rx - The receiver for UIEvents.
• action_tx - The sender for UIActions.

pub fn set_node(&mut self, node: Arc<Node>)

Sets the application’s core Node.

pub fn set_log_buffer(&mut self, log_buffer: Arc<LogBuffer>)

Sets the LogBuffer for the UI.

pub fn update_friends(&mut self, friends: Vec<String>)

Updates the list of friends in the chat mode’s completer.

pub fn update_discovered_peers(&mut self, peers: Vec<String>)

Updates the list of discovered peers in the chat mode’s completer.

pub fn preload_messages(&mut self, messages: Vec<Message>)

Preloads initial messages into the UI state.

This is typically used to display recent message history on startup.

Arguments

• messages - A Vec of Messages to preload.

pub async fn run(&mut self) -> Result<()>

Runs the main event loop for the terminal UI.

This function continuously listens for UI events, handles them, and re-renders the terminal display.

Errors

Returns an error if terminal initialization fails or if an unrecoverable error occurs within the event handling or rendering loop.

impl TerminalUI

pub(super) async fn handle_event(&mut self, event: UIEvent) -> Result<()>

Handles an incoming UIEvent, updating the UI state accordingly.

This function processes various types of events such as new messages, log batches, key presses, and terminal resizes.

Arguments

• event - The UIEvent to handle.

Errors

Returns an error if handling a key event fails.

async fn handle_key_event(&mut self, key: KeyEvent) -> Result<()>

Handles a keyboard KeyEvent.

This function processes key presses, handling special key combinations for mode switching or exiting the application, and then delegates regular key presses to the current UI mode’s handler.

Arguments

• key - The KeyEvent to handle.

Errors

Returns an error if the current UI mode’s key handler fails.

impl TerminalUI

pub(super) fn initialize_terminal(&mut self) -> Result<()>

Initializes the terminal for TUI mode.

This function enables raw mode, enters the alternate screen, hides the cursor, and captures the initial terminal size.

Errors

Returns an error if terminal setup fails.

pub fn cleanup(&mut self) -> Result<()>

Cleans up the terminal, restoring it to its original state.

This function disables raw mode, leaves the alternate screen, and shows the cursor.

Errors

Returns an error if terminal cleanup fails.

impl TerminalUI

pub(super) fn render(&mut self) -> Result<()>

Renders the entire terminal UI.

This function clears the screen, then renders the appropriate main view (chat or logs), the status line, and the input area.

Arguments

• stdout - A mutable reference to the output stream.

Errors

Returns an error if writing to the output stream fails.

fn render_status_line( &self, stdout: &mut impl Write, row: u16, width: u16, ) -> Result<()>

Renders the status line at the bottom of the message area.

This line displays the current UI mode, connected peer count, and mode-specific tips.

Arguments

• stdout - A mutable reference to the output stream.
• row - The row where the status line should be rendered.
• width - The width of the terminal.

Errors

Returns an error if writing to the output stream fails.

fn render_input_area( &self, stdout: &mut impl Write, row: u16, width: u16, height: u16, ) -> Result<()>

Renders the input area where the user types commands or messages.

This includes the input prompt, the current input buffer, and any autocompletion suggestions. Also renders help text.

Arguments

• stdout - A mutable reference to the output stream.
• row - The starting row for the input area.
• width - The width of the terminal.
• height - The height of the input area.

Errors

Returns an error if writing to the output stream fails.

Trait Implementations

impl Drop for TerminalUI

fn drop(&mut self)

Cleans up the terminal when the TerminalUI instance is dropped.