terminal_screen.h File Reference

Reusable "fixed header + scrolling logs" terminal screen abstraction. More...

Go to the source code of this file.

Data Structures
struct	terminal_screen_config_t
	Configuration for terminal screen rendering. More...

Typedefs
typedef void(*	terminal_screen_header_fn) (frame_buffer_t *buf, terminal_size_t term_size, void *user_data)
	Configuration for terminal screen rendering.

Functions
void	terminal_screen_render (const terminal_screen_config_t *config)
	Render a terminal screen with fixed header and scrolling logs.
void	terminal_screen_compose (frame_buffer_t *output, terminal_size_t size, const terminal_screen_config_t *config, session_log_buffer_t *logs)
void	terminal_screen_cleanup (void)
	Clean up terminal screen resources.
session_log_buffer_t *	terminal_screen_log_init (void)
	Initialize session log buffer for terminal screens.
void	terminal_screen_log_destroy (void)
	Standard log cleanup for terminal screens.
void	terminal_screen_log_clear (void)
	Clear buffered logs for terminal screens.
session_log_buffer_t *	terminal_screen_get_log_buffer (void)
	Get the current session log buffer.
void	terminal_screen_set_output_fd (int fd)
	Set output file descriptor for terminal screens (splash/status).
bool	terminal_screen_logs_handle_key (int key)
bool	terminal_screen_logs_handle_key_sized (int key, terminal_size_t size)
void	terminal_screen_logs_reset (void)
size_t	terminal_screen_logs_offset (void)
void	terminal_screen_logs_set_offset (size_t rows)
size_t	terminal_screen_logs_retain_position (uint64_t tail_sequence, size_t appended_rows, size_t maximum_offset)
uint64_t	terminal_screen_logs_last_tail_sequence (void)
bool	terminal_screen_logs_help_open (void)
bool	terminal_screen_logs_help_too_small (void)
void	terminal_screen_logs_render_help (frame_buffer_t *output, terminal_size_t size)

Detailed Description

Reusable "fixed header + scrolling logs" terminal screen abstraction.

Provides a common pattern for rendering terminal screens with:

• Fixed header area (caller-defined via callback)
• Scrolling log feed below header (automatically managed)
• Physical terminal dimensions supplied by the UI controller
• ANSI-aware line wrapping using display_width()
• Latest log at bottom (standard terminal behavior)

Definition in file terminal_screen.h.

Typedef Documentation

terminal_screen_header_fn

typedef void(* terminal_screen_header_fn) (frame_buffer_t *buf, terminal_size_t term_size, void *user_data)

Configuration for terminal screen rendering.

Callback to render the fixed header portion of the screen

Parameters

buf	Frame buffer to write header content into (via frame_buffer_printf, etc.)
term_size	Current physical terminal dimensions
user_data	Caller-provided context data

The callback should:

• Append exactly the number of lines specified in terminal_screen_config_t.fixed_header_lines
• Use display_width() to ensure lines don't exceed term_size.cols
• Write to buf parameter (frame_buffer_printf, frame_buffer_append)
• NOT clear the screen (terminal_screen_render does that)
• NOT print the final newline if it would be line N+1 (causes scroll)

Definition at line 40 of file terminal_screen.h.

Function Documentation

terminal_screen_cleanup()

void terminal_screen_cleanup

(

void

)

Clean up terminal screen resources.

Destroys the internal static frame buffer allocated by terminal_screen_render(). Call at program exit or when terminal screen rendering is no longer needed. If a render is active, destruction is deferred until that render returns; cleanup never waits for blocked terminal output.

Definition at line 307 of file terminal_screen.c.

                                   {
  for (;;) {
    int state = atomic_load_int(&g_screen_state);
    if (state == SCREEN_CLEANUP_PENDING || state == SCREEN_CLEANING)
      return;
    int next = state == SCREEN_RENDERING ? SCREEN_CLEANUP_PENDING : SCREEN_CLEANING;
    if (!atomic_cas_int(&g_screen_state, &state, next))
      continue;
    if (next == SCREEN_CLEANING) {
      terminal_screen_free_buffer();
      atomic_store_int(&g_screen_state, SCREEN_IDLE);
    }
    return;
  }
}

References SCREEN_CLEANING, SCREEN_CLEANUP_PENDING, SCREEN_IDLE, and SCREEN_RENDERING.

Referenced by asciichat_shared_destroy().

terminal_screen_compose()

void terminal_screen_compose	(	frame_buffer_t *	output,
		terminal_size_t	size,
		const terminal_screen_config_t *	config,
		session_log_buffer_t *	logs )

Compose the existing status/splash UI without terminal I/O.

Definition at line 262 of file session_status.c.

                                                         {
  if (!output || !config || !config->render_header || size.cols < 1 || size.rows < 1)
    return;
  if (config->show_logs)
    log_search_process_pending();
  frame_buffer_t *body = frame_buffer_create(size.rows, size.cols);
  if (!body)
    return;
  config->render_header(body, size, config->user_data);
 
  // Measure the actual header, including wrapped lines, as the native status UI does.
  int header_rows = 0;
  const char *line = frame_buffer_get_content(body);
  const char *end = line + frame_buffer_get_length(body);
  for (const char *cursor = line; cursor < end; ++cursor) {
    if (*cursor == '\n') {
      char text[TUI_SESSION_STATUS_TEXT_BUFFER_SIZE];
      size_t length = (size_t)(cursor - line);
      if (length >= sizeof(text))
        length = sizeof(text) - 1;
      memcpy(text, line, length);
      text[length] = '\0';
      int height = display_height(text, size.cols);
      header_rows += height > 0 ? height : 1;
      line = cursor + 1;
    }
  }
  if (!header_rows)
    header_rows = config->fixed_header_lines;
  bool entering = config->show_logs && log_search_is_entering();
  // Search owns the final row for its prompt. Otherwise logs fill it.
  int available = size.rows - header_rows - (entering ? 1 : 0);
  bool compact_startup = config->screen == UI_SCREEN_SPLASH;
  session_log_entry_t *entries = NULL;
  size_t count = 0;
  size_t scroll_total = 0, scroll_offset = 0;
  if (config->show_logs && available > 0) {
    if (log_search_is_active())
      log_search_filter_buffer(logs, &entries, &count);
    else {
      entries = SAFE_MALLOC(SESSION_LOG_BUFFER_SIZE * sizeof(*entries), session_log_entry_t *);
      if (entries)
        count = session_log_buffer_get_recent(logs, entries, SESSION_LOG_BUFFER_SIZE);
    }
    log_row_ref_t *rows = SAFE_MALLOC((size_t)available * sizeof(*rows), log_row_ref_t *);
    if (rows) {
      size_t total_rows = 0;
      uint64_t previous_tail_sequence = 0;
      size_t appended_rows = 0;
      for (size_t entry = 0; entry < count; ++entry) {
        size_t height = (size_t)log_message_rows(entries[entry].message, size.cols, compact_startup);
        if (SIZE_MAX - total_rows < height)
          total_rows = SIZE_MAX;
        else
          total_rows += height;
      }
      uint64_t tail_sequence = count ? entries[count - 1].sequence : 0;
      previous_tail_sequence = terminal_screen_logs_last_tail_sequence();
      if (previous_tail_sequence && tail_sequence > previous_tail_sequence) {
        for (size_t entry = 0; entry < count; ++entry) {
          if (entries[entry].sequence > previous_tail_sequence)
            appended_rows += (size_t)log_message_rows(entries[entry].message, size.cols, compact_startup);
        }
      }
      size_t max_offset = total_rows ? total_rows - 1 : 0;
      size_t skip = terminal_screen_logs_retain_position(tail_sequence, appended_rows, max_offset);
      scroll_total = total_rows;
      scroll_offset = total_rows > (size_t)available + skip ? total_rows - (size_t)available - skip : 0;
      size_t row_count = 0;
      for (size_t entry = count; entry && row_count < (size_t)available; --entry) {
        int height = log_message_rows(entries[entry - 1].message, size.cols, compact_startup);
        if (skip >= (size_t)height) {
          skip -= (size_t)height;
          continue;
        }
        int row = height - 1 - (int)skip;
        skip = 0;
        for (; row >= 0 && row_count < (size_t)available; --row)
          rows[row_count++] = (log_row_ref_t){.entry = entry - 1, .row = row};
      }
      for (size_t row = row_count; row; --row)
        append_log_row(body, entries[rows[row - 1].entry].message, rows[row - 1].row, size.cols, compact_startup);
      while (row_count++ < (size_t)available)
        frame_buffer_printf(body, "\n");
      SAFE_FREE(rows);
    }
  }
  SAFE_FREE(entries);
 
  // Preserve the existing repaint-in-place behavior, also supplying CR for browser terminals.
  bool log_help_open = config->show_logs && terminal_screen_logs_help_open();
  bool hide_cursor = log_help_open || (!entering && (config->hide_cursor || config->show_logs));
  frame_buffer_printf(output, "\033[H%s", hide_cursor ? "\033[?25l" : "\033[?25h");
  const char *content = frame_buffer_get_content(body);
  size_t length = frame_buffer_get_length(body);
  for (size_t i = 0; i < length; ++i) {
    // Normalize CRLF before erasing the line; erasing after CR removes its text.
    if (content[i] == '\r' && i + 1 < length && content[i + 1] == '\n')
      continue;
    if (content[i] == '\n') {
      frame_buffer_printf(output, "\033[K\r");
      // Do not advance past the bottom row when the idle log view fills it.
      if (config->show_logs && !entering && i + 1 == length)
        continue;
    }
    frame_buffer_append(output, content + i, 1);
  }
  if (config->show_logs && available > 0 && scroll_total > (size_t)available)
    ui_scrollbar_render(output, header_rows + 1, size.cols, available, scroll_total, (size_t)available, scroll_offset);
  if (entering) {
    mutex_t *mutex = log_search_get_mutex();
    mutex_lock(mutex);
    const char *pattern = log_search_get_input_buffer();
    int cursor = log_search_get_cursor_position();
    // Keep the edit cursor visible even when a pattern exceeds the viewport.
    int offset = cursor >= size.cols - 2 ? cursor - (size.cols - 3) : 0;
    frame_buffer_printf(output, "\033[%d;1H/%.*s\033[K\033[%d;%dH", size.rows, size.cols - 2,
                        pattern ? pattern + offset : "", size.rows, cursor - offset + 2);
    mutex_unlock(mutex);
  }
  if (log_help_open) {
    terminal_screen_logs_render_help(output, size);
  } else if (config->show_logs && terminal_screen_logs_help_too_small()) {
    frame_buffer_printf(output, "\033[%d;1H%s", size.rows, "Help needs at least 12 terminal rows");
  }
  frame_buffer_destroy(body);
}

References display_height(), terminal_screen_config_t::fixed_header_lines, frame_buffer_append(), frame_buffer_create(), frame_buffer_destroy(), frame_buffer_get_content(), frame_buffer_get_length(), frame_buffer_printf(), height, terminal_screen_config_t::hide_cursor, log_search_filter_buffer(), log_search_get_cursor_position(), log_search_get_input_buffer(), log_search_get_mutex(), log_search_is_active(), log_search_is_entering(), log_search_process_pending(), terminal_screen_config_t::render_header, SAFE_FREE, SAFE_MALLOC, terminal_screen_config_t::screen, session_log_entry_t::sequence, session_log_buffer_get_recent(), SESSION_LOG_BUFFER_SIZE, terminal_screen_config_t::show_logs, terminal_screen_logs_help_open(), terminal_screen_logs_help_too_small(), terminal_screen_logs_last_tail_sequence(), terminal_screen_logs_render_help(), terminal_screen_logs_retain_position(), TUI_SESSION_STATUS_TEXT_BUFFER_SIZE, UI_SCREEN_SPLASH, ui_scrollbar_render(), and terminal_screen_config_t::user_data.

Referenced by ui_session_logs_render().

terminal_screen_get_log_buffer()

session_log_buffer_t * terminal_screen_get_log_buffer

(

void

)

Get the current session log buffer.

Returns the log buffer owned by this module, or NULL if not initialized. Used by splash/status screens to register with the logger.

Returns

Pointer to log buffer, or NULL

Definition at line 363 of file terminal_screen.c.

                                                           {
  return g_session_log_buffer;
}

terminal_screen_log_clear()

void terminal_screen_log_clear

(

void

)

Clear buffered logs for terminal screens.

Clears all previously captured log entries from the buffer. Useful when transitioning between screens to start fresh.

Definition at line 356 of file terminal_screen.c.

                                     {
  // Process history survives splash/status transitions.
  if (g_session_log_buffer && g_owns_log_buffer) {
    session_log_buffer_clear(g_session_log_buffer);
  }
}

References session_log_buffer_clear().

Referenced by splash_log_clear(), ui_mdns_log_clear(), and ui_status_log_clear().

terminal_screen_log_destroy()

void terminal_screen_log_destroy

(

void

)

Standard log cleanup for terminal screens.

Destroys the session log buffer after screens are done rendering.

Definition at line 339 of file terminal_screen.c.

                                       {
  ui_controller_remove(UI_SCREEN_STATUS);
  ui_controller_remove(UI_SCREEN_SPLASH);
  NAMED_UNREGISTER(&g_screen_state);
  if (g_session_log_buffer) {
    if (g_owns_log_buffer)
      session_log_buffer_destroy(g_session_log_buffer);
    g_session_log_buffer = NULL;
  }
  terminal_screen_logs_reset();
  int expected = LOG_VIEWER_MUTEX_READY;
  if (atomic_cas_int(&g_log_viewer_mutex_state, &expected, LOG_VIEWER_MUTEX_DESTROYING)) {
    mutex_destroy(&g_log_viewer_mutex);
    atomic_store_int(&g_log_viewer_mutex_state, LOG_VIEWER_MUTEX_UNINITIALIZED);
  }
}

References LOG_VIEWER_MUTEX_DESTROYING, LOG_VIEWER_MUTEX_READY, LOG_VIEWER_MUTEX_UNINITIALIZED, NAMED_UNREGISTER, session_log_buffer_destroy(), terminal_screen_logs_reset(), ui_controller_remove(), UI_SCREEN_SPLASH, and UI_SCREEN_STATUS.

Referenced by splash_log_destroy(), ui_mdns_log_destroy(), and ui_status_log_destroy().

terminal_screen_log_init()

session_log_buffer_t * terminal_screen_log_init

(

void

)

Initialize session log buffer for terminal screens.

Creates a new session log buffer owned by this module. Splash and status screens use this buffer to display logs.

Returns

Pointer to created buffer, or NULL on failure

Definition at line 323 of file terminal_screen.c.

                                                     {
  log_search_init();
  if (!terminal_screen_logs_mutex_init())
    return NULL;
  if (g_session_log_buffer) {
    return g_session_log_buffer; // Already initialized
  }
 
  NAMED_REGISTER_ATOMIC(&g_screen_state, "terminal_screen_state", NULL);
  g_session_log_buffer = log_get_history_buffer();
  g_owns_log_buffer = !g_session_log_buffer;
  if (g_owns_log_buffer)
    g_session_log_buffer = session_log_buffer_create();
  return g_session_log_buffer;
}

References log_get_history_buffer(), log_search_init(), NAMED_REGISTER_ATOMIC, and session_log_buffer_create().

Referenced by splash_log_init(), ui_mdns_log_init(), and ui_status_log_init().

terminal_screen_logs_handle_key()

bool terminal_screen_logs_handle_key

(

int

key

)

Handle a key while the live log viewer owns the terminal.

Definition at line 255 of file terminal_screen.c.

                                              {
  return terminal_screen_logs_handle_key_sized(key, ui_controller_size());
}

References terminal_screen_logs_handle_key_sized(), and ui_controller_size().

Referenced by ui_input_read_key().

terminal_screen_logs_handle_key_sized()

bool terminal_screen_logs_handle_key_sized	(	int	key,
		terminal_size_t	size )

Browser/embedded sessions supply their own viewport instead of a native controller.

Definition at line 178 of file terminal_screen.c.

                                                                          {
  if (!terminal_screen_logs_mutex_init())
    return false;
  bool redraw = false;
  mutex_lock(&g_log_viewer_mutex);
  if (g_log_help) {
    if (key == KEY_ESCAPE || key == '?') {
      g_log_help = false;
      redraw = true;
    }
    mutex_unlock(&g_log_viewer_mutex);
    if (redraw)
      ui_controller_redraw();
    return true;
  }
  if (key == '?') {
    g_log_help_too_small = size.rows < 12 || size.cols < 8;
    g_log_help = !g_log_help_too_small;
    redraw = true;
    mutex_unlock(&g_log_viewer_mutex);
    ui_controller_redraw();
    return true;
  }
  int direction = 0;
  if (key == KEY_UP || key == 'k')
    direction = 1;
  else if (key == KEY_DOWN || key == 'j')
    direction = -1;
  else if (key == KEY_PAGEUP)
    direction = 1000000;
  else if (key == KEY_PAGEDOWN)
    direction = -1000000;
  else if (key == KEY_HOME) {
    g_log_scroll_rows = SIZE_MAX;
    g_log_help_too_small = false;
    mutex_unlock(&g_log_viewer_mutex);
    ui_controller_redraw();
    return true;
  } else if (key == KEY_END) {
    g_log_scroll_rows = 0;
    g_log_help_too_small = false;
    mutex_unlock(&g_log_viewer_mutex);
    ui_controller_redraw();
    return true;
  } else if (key == KEY_LEFT || key == 21)
    direction = 1000000;
  else if (key == KEY_RIGHT || key == 4)
    direction = -1000000;
  else {
    g_log_help_too_small = false;
    mutex_unlock(&g_log_viewer_mutex);
    return false;
  }
 
  ascii_otel_ui_usage("logs", direction > 0 ? "scroll_older" : "scroll_newer", 0);
  size_t step = 1;
  if (direction == 1 || direction == -1) {
    /* Arrow keys move by one complete log entry, including wrapped rows. */
    step = terminal_screen_log_step_locked(size.cols);
  } else {
    int rows = size.rows;
    step = (size_t)(rows > 6 ? (rows - 5) / 2 : 1);
  }
  if (direction > 0) {
    if (SIZE_MAX - g_log_scroll_rows < step)
      g_log_scroll_rows = SIZE_MAX;
    else
      g_log_scroll_rows += step;
  } else {
    g_log_scroll_rows = g_log_scroll_rows > step ? g_log_scroll_rows - step : 0;
  }
  g_log_help_too_small = false;
  mutex_unlock(&g_log_viewer_mutex);
  ui_controller_redraw();
  return true;
}

References ascii_otel_ui_usage(), KEY_DOWN, KEY_END, KEY_ESCAPE, KEY_HOME, KEY_LEFT, KEY_PAGEDOWN, KEY_PAGEUP, KEY_RIGHT, KEY_UP, and ui_controller_redraw().

Referenced by terminal_screen_logs_handle_key().

terminal_screen_logs_help_open()

bool terminal_screen_logs_help_open

(

void

)

True while the log-viewer's own shortcut dialog is displayed.

Definition at line 259 of file terminal_screen.c.

                                          {
  if (!terminal_screen_logs_mutex_init())
    return false;
  mutex_lock(&g_log_viewer_mutex);
  bool help_open = g_log_help;
  mutex_unlock(&g_log_viewer_mutex);
  return help_open;
}

Referenced by terminal_screen_compose(), and ui_input_read_key().

terminal_screen_logs_help_too_small()

bool terminal_screen_logs_help_too_small

(

void

)

True when help was requested but the current terminal cannot display it.

Definition at line 268 of file terminal_screen.c.

                                               {
  if (!terminal_screen_logs_mutex_init())
    return false;
  mutex_lock(&g_log_viewer_mutex);
  bool too_small = g_log_help_too_small;
  mutex_unlock(&g_log_viewer_mutex);
  return too_small;
}

Referenced by terminal_screen_compose().

terminal_screen_logs_last_tail_sequence()

uint64_t terminal_screen_logs_last_tail_sequence

(

void

)

Sequence number at the live tail from the previous composition.

Definition at line 147 of file terminal_screen.c.

                                                       {
  if (!terminal_screen_logs_mutex_init())
    return 0;
  mutex_lock(&g_log_viewer_mutex);
  uint64_t sequence = g_log_last_tail_sequence;
  mutex_unlock(&g_log_viewer_mutex);
  return sequence;
}

Referenced by terminal_screen_compose().

terminal_screen_logs_offset()

size_t terminal_screen_logs_offset

(

void

)

Number of rendered rows currently held above the live tail.

Definition at line 110 of file terminal_screen.c.

                                         {
  if (!terminal_screen_logs_mutex_init())
    return g_log_scroll_rows;
  mutex_lock(&g_log_viewer_mutex);
  size_t offset = g_log_scroll_rows;
  mutex_unlock(&g_log_viewer_mutex);
  return offset;
}

Referenced by ui_session_logs_render().

terminal_screen_logs_render_help()

void terminal_screen_logs_render_help	(	frame_buffer_t *	output,
		terminal_size_t	size )

Recompose log-viewer help above modal error notifications.

Definition at line 391 of file session_status.c.

                                                                                    {
  const ui_help_entry_t entries[] = {{"Down", "newer log"},    {"Up", "older log"},        {"PageDown", "newer page"},
                                     {"PageUp", "older page"}, {"End", "newest log"},      {"Home", "oldest log"},
                                     {"/", "search logs"},     {"q / Esc", "close viewer"}};
  char footer[TUI_SESSION_STATUS_FOOTER_BUFFER_SIZE], keys[TUI_SESSION_STATUS_KEYS_BUFFER_SIZE];
  ui_help_keys(keys, sizeof(keys), "? / Esc");
  snprintf(footer, sizeof(footer), "%s closes this help", keys);
  ui_help_menu_t menu = {.title = "Log Viewer Keyboard Controls",
                         .entries = entries,
                         .count = sizeof(entries) / sizeof(*entries),
                         .footer = footer};
  (void)ui_help_menu_render(output, size, &menu);
}

References TUI_SESSION_STATUS_FOOTER_BUFFER_SIZE, TUI_SESSION_STATUS_KEYS_BUFFER_SIZE, ui_help_keys(), and ui_help_menu_render().

Referenced by terminal_screen_compose().

terminal_screen_logs_reset()

void terminal_screen_logs_reset

(

void

)

Reset the retained log-viewer position when the viewer is closed.

Definition at line 100 of file terminal_screen.c.

                                      {
  if (!terminal_screen_logs_mutex_init()) {
    terminal_screen_logs_reset_locked();
    return;
  }
  mutex_lock(&g_log_viewer_mutex);
  terminal_screen_logs_reset_locked();
  mutex_unlock(&g_log_viewer_mutex);
}

Referenced by terminal_screen_log_destroy(), and ui_controller_hide_logs().

terminal_screen_logs_retain_position()

size_t terminal_screen_logs_retain_position	(	uint64_t	tail_sequence,
		size_t	appended_rows,
		size_t	maximum_offset )

Retain the selected history row while new entries arrive, then clamp it.

Definition at line 129 of file terminal_screen.c.

                                                                                                                 {
  if (!terminal_screen_logs_mutex_init())
    return 0;
  mutex_lock(&g_log_viewer_mutex);
  if (g_log_scroll_rows && g_log_last_tail_sequence && tail_sequence > g_log_last_tail_sequence) {
    if (SIZE_MAX - g_log_scroll_rows < appended_rows)
      g_log_scroll_rows = SIZE_MAX;
    else
      g_log_scroll_rows += appended_rows;
  }
  g_log_last_tail_sequence = tail_sequence;
  if (g_log_scroll_rows > maximum_offset)
    g_log_scroll_rows = maximum_offset;
  size_t offset = g_log_scroll_rows;
  mutex_unlock(&g_log_viewer_mutex);
  return offset;
}

Referenced by terminal_screen_compose().

terminal_screen_logs_set_offset()

void terminal_screen_logs_set_offset

(

size_t

rows

)

Clamp the retained position after the available history changes.

Definition at line 119 of file terminal_screen.c.

                                                  {
  if (!terminal_screen_logs_mutex_init()) {
    g_log_scroll_rows = rows;
    return;
  }
  mutex_lock(&g_log_viewer_mutex);
  g_log_scroll_rows = rows;
  mutex_unlock(&g_log_viewer_mutex);
}

terminal_screen_render()

void terminal_screen_render

(

const terminal_screen_config_t *

config

)

Render a terminal screen with fixed header and scrolling logs.

Renders a screen following the pattern:

1. Clear screen and move cursor to home (both stdout and stderr)
2. Call render_header() callback to draw fixed header
3. Calculate log area: rows - fixed_header_lines - 1 (prevent scroll)
4. Fetch recent logs from session_log_buffer
5. Calculate which logs fit (working backwards, accounting for wrapping)
6. Display logs chronologically (oldest to newest, latest at bottom)
7. Fill remaining lines to prevent terminal scroll
8. Flush stdout

Parameters

config

Screen configuration (header callback, line count, etc.)

Copies the header data and submits it to the UI controller. The controller owns size checks, terminal writes, and resize refreshes.

Definition at line 382 of file terminal_screen.c.

                                                                    {
  if (!config || !config->render_header || !config->user_data || !config->user_data_size)
    return;
  size_t bytes = sizeof(screen_snapshot_t) + config->user_data_size;
  screen_snapshot_t *snapshot = SAFE_MALLOC(bytes, screen_snapshot_t *);
  if (!snapshot)
    return;
  snapshot->config = *config;
  memcpy(snapshot->header, config->user_data, config->user_data_size);
  terminal_size_t minimum = {.cols = config->minimum_cols,
                             .rows = config->fixed_header_lines + (log_search_is_entering() ? 4 : 2)};
  (void)ui_controller_submit(config->screen, config->output_fd, minimum, render_screen_snapshot, snapshot, bytes);
  SAFE_FREE(snapshot);
}

References screen_snapshot_t::config, terminal_screen_config_t::fixed_header_lines, screen_snapshot_t::header, log_search_is_entering(), terminal_screen_config_t::minimum_cols, terminal_screen_config_t::output_fd, terminal_screen_config_t::render_header, SAFE_FREE, SAFE_MALLOC, terminal_screen_config_t::screen, ui_controller_submit(), terminal_screen_config_t::user_data, and terminal_screen_config_t::user_data_size.

Referenced by ui_status_display(), and ui_status_display_interactive().

terminal_screen_set_output_fd()

void terminal_screen_set_output_fd

(

int

fd

)

Set output file descriptor for terminal screens (splash/status).

Parameters

fd	File descriptor (STDOUT_FILENO for TTY, STDERR_FILENO for piped)

Configures where splash and status screens write their output. Should be called before terminal_screen_render() to control output destination.

Definition at line 367 of file terminal_screen.c.

                                           {
  frame_buffer_set_screen_output_fd(fd);
}

References frame_buffer_set_screen_output_fd().

Referenced by splash_intro_start(), and ui_status_display().