session.h File Reference

Go to the source code of this file.

Data Structures
struct	ui_discovery_view_t
struct	ui_splash_view_t
struct	ui_session_view_t

Macros
#define	TUI_SESSION_SESSION_STRING_BUFFER_SIZE   256
#define	TUI_SESSION_UPDATE_NOTIFICATION_BUFFER_SIZE   1024
#define	TUI_SESSION_CONNECTION_TARGET_BUFFER_SIZE   512

Typedefs
typedef struct ui_session	ui_session_t
typedef void(*	ui_session_draw_fn) (frame_buffer_t *output, terminal_size_t size, const animation_sample_t *animation, void *context)
	The useful part of ui session view is in screen, minimum, dirty, clear: together they describe what is pending, who owns it, and how much data is valid. Keep the object with its parent operation and use the parent cleanup path.

Enumerations
enum	ui_session_action_t {   UI_ACTION_NONE , UI_ACTION_SETTINGS , UI_ACTION_HELP , UI_ACTION_CLOSE ,   UI_ACTION_SEEK_BACK , UI_ACTION_SEEK_FORWARD , UI_ACTION_PAUSE , UI_ACTION_VOLUME ,   UI_ACTION_DEBUG , UI_ACTION_LOGS , UI_ACTION_TOGGLE_MEDIA , UI_ACTION_QUIT ,   UI_ACTION_FORCE_QUIT }

Functions
void	ui_session_splash_render (frame_buffer_t *buf, terminal_size_t size, void *view)
char *	ui_session_help_render (terminal_size_t size, bool has_media, bool browser, terminal_size_t *minimum)
void	ui_session_help_free (char *text)
char *	ui_session_context_help_render (terminal_size_t size, ui_screen_t screen, terminal_size_t *minimum)
ui_session_action_t	ui_session_key (keyboard_key_t key, double *saved_volume)
terminal_size_t	ui_session_size (const ui_session_t *session)
int	ui_session_select_screen (uint32_t visible_screens)
const char *	ui_session_render (ui_session_t *session, const ui_session_view_t *view, uint64_t now_ns)
bool	ui_session_is_covered (const ui_session_t *session)
size_t	ui_session_frame_length (const ui_session_t *session)
uint64_t	ui_session_next_frame_ns (const ui_session_t *session)
ui_session_t *	ui_session_create (void)
void	ui_session_destroy (ui_session_t *session)
void	ui_session_resize (ui_session_t *session, int cols, int rows)
void	ui_session_loading (ui_session_t *session, bool loading, const char *message)
void	ui_session_log (ui_session_t *session, const char *message)
asciichat_error_t	ui_session_media (ui_session_t *session, const char *data, size_t length)
ui_session_action_t	ui_session_input (ui_session_t *session, keyboard_key_t key)
const char *	ui_session_tick (ui_session_t *session, uint64_t now_ns)
void	ui_session_clear (ui_session_t *session)
void	ui_session_redraw (ui_session_t *session)
void	ui_session_logs_render (frame_buffer_t *output, terminal_size_t size, ui_session_t *session)
bool	ui_session_logs_key (keyboard_key_t key)
void	ui_session_capture_logs (ui_session_t *session)

Macro Definition Documentation

TUI_SESSION_CONNECTION_TARGET_BUFFER_SIZE

#define TUI_SESSION_CONNECTION_TARGET_BUFFER_SIZE   512

Definition at line 6 of file include/ascii-chat/tui/session.h.

TUI_SESSION_SESSION_STRING_BUFFER_SIZE

#define TUI_SESSION_SESSION_STRING_BUFFER_SIZE   256

Definition at line 4 of file include/ascii-chat/tui/session.h.

TUI_SESSION_UPDATE_NOTIFICATION_BUFFER_SIZE

#define TUI_SESSION_UPDATE_NOTIFICATION_BUFFER_SIZE   1024

Definition at line 5 of file include/ascii-chat/tui/session.h.

Typedef Documentation

ui_session_draw_fn

typedef void(* ui_session_draw_fn) (frame_buffer_t *output, terminal_size_t size, const animation_sample_t *animation, void *context)

The useful part of ui session view is in screen, minimum, dirty, clear: together they describe what is pending, who owns it, and how much data is valid. Keep the object with its parent operation and use the parent cleanup path.

A borrowed view, valid for the duration of ui_session_render(). Hosts retain

The useful part of ui session view is in screen, minimum, dirty, clear: together they describe what is pending, who owns it, and how much data is valid. Keep the object with its parent operation and use the parent cleanup path. snapshots and serialize access to a session; callbacks must not recurse into its renderer. The runtime owns selection policy, transitions and animation.

Definition at line 64 of file include/ascii-chat/tui/session.h.

ui_session_t

typedef struct ui_session ui_session_t

Definition at line 56 of file include/ascii-chat/tui/session.h.

Enumeration Type Documentation

ui_session_action_t

enum ui_session_action_t

Enumerator
UI_ACTION_NONE
UI_ACTION_SETTINGS
UI_ACTION_HELP
UI_ACTION_CLOSE
UI_ACTION_SEEK_BACK
UI_ACTION_SEEK_FORWARD
UI_ACTION_PAUSE
UI_ACTION_VOLUME
UI_ACTION_DEBUG
UI_ACTION_LOGS
UI_ACTION_TOGGLE_MEDIA
UI_ACTION_QUIT
UI_ACTION_FORCE_QUIT

Definition at line 37 of file include/ascii-chat/tui/session.h.

             {
  UI_ACTION_NONE,
  UI_ACTION_SETTINGS,
  UI_ACTION_HELP,
  UI_ACTION_CLOSE,
  UI_ACTION_SEEK_BACK,
  UI_ACTION_SEEK_FORWARD,
  UI_ACTION_PAUSE,
  UI_ACTION_VOLUME,
  UI_ACTION_DEBUG,
  UI_ACTION_LOGS,
  UI_ACTION_TOGGLE_MEDIA,
  UI_ACTION_QUIT,
  UI_ACTION_FORCE_QUIT
} ui_session_action_t;

Function Documentation

ui_session_capture_logs()

void ui_session_capture_logs

(

ui_session_t *

session

)

Attach this instance to the module's existing C logger. Detaches on destruction.

Definition at line 375 of file lib/tui/session.c.

                                              {
  if (s)
    log_set_session_log_buffer(s->logs);
}

References log_set_session_log_buffer(), and ui_session::logs.

Referenced by SessionUiBinding::SessionUiBinding().

ui_session_clear()

void ui_session_clear

(

ui_session_t *

session

)

Definition at line 357 of file lib/tui/session.c.

                                       {
  if (s) {
    frame_buffer_reset(s->media);
    s->help = false;
    s->show_logs = false;
    s->dirty = true;
  }
}

References ui_session::dirty, frame_buffer_reset(), ui_session::help, ui_session::media, and ui_session::show_logs.

Referenced by SessionUiBinding::clear().

ui_session_context_help_render()

char * ui_session_context_help_render	(	terminal_size_t	size,
		ui_screen_t	screen,
		terminal_size_t *	minimum )

Definition at line 251 of file session_help.c.

                                                                                                         {
  if (!minimum) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Help minimum geometry output is required");
    return NULL;
  }
  static const ui_help_entry_t sync[] = {{"0 / Esc", "Close sync viewer"},
                                         {"Up / Down", "Select primitive"},
                                         {"Left / Right", "Previous/next page"},
                                         {"Home / End", "First/last primitive"},
                                         {"=", "Running app statistics"},
                                         {"]", "Log viewer"},
                                         {"?", "Close this help"}};
  static const ui_help_entry_t stats[] = {{"= / Esc", "Close statistics"},
                                          {"Tab / Left / Right", "Switch data page"},
                                          {"Up / Down", "Select and scroll rows"},
                                          {"Home / End", "First/last row"},
                                          {"0", "Sync primitives"},
                                          {"]", "Log viewer"},
                                          {"?", "Close this help"}};
  static const ui_help_entry_t errors[] = {
      {"` / Esc", "Close error stacks"}, {"Tab", "Current/history page"}, {"Up / Down", "Select and scroll errors"},
      {"s", "Change sort order"},        {"x", "Clear selected error"},   {"=", "Running app statistics"},
      {"0", "Sync primitives"},          {"?", "Close this help"}};
  static const ui_help_entry_t update[] = {{"F12 / Esc", "Close update checker"},
                                           {"Left / Right / Tab", "Select button"},
                                           {"Enter", "Activate selected button"},
                                           {"O", "Open release page"},
                                           {"R", "Check again"},
                                           {"?", "Close this help"}};
  static const ui_help_entry_t lan[] = {{"Up / Down / j / k", "Select LAN server"},
                                        {"0-9", "Enter server number"},
                                        {"Enter", "Connect to selected server"},
                                        {"Esc", "Cancel LAN selection"},
                                        {"=", "Running app statistics"},
                                        {"0", "Sync primitives"},
                                        {"?", "Close this help"}};
  static const ui_help_entry_t media[] = {
      {"Enter", "Play the entered paths or URLs"},  {"Esc / Ctrl-O", "Cancel media input"},
      {"Left / Right", "Move the text cursor"},     {"Home / End", "Beginning/end of input"},
      {"Backspace / Delete", "Delete a character"}, {"?", "Help when the input is empty"}};
  const ui_help_entry_t *entries = NULL;
  size_t count = 0;
  const char *title = NULL;
  switch (screen) {
  case UI_SCREEN_ERROR: {
    static const ui_help_entry_t popup[] = {{"Left / Right", "Previous / next error"},
                                            {"Home / End", "First / last error"},
                                            {"Up / Down", "Scroll error details"},
                                            {"PgUp / PgDn", "Scroll a page"},
                                            {"Enter / Esc", "Dismiss all errors"},
                                            {"q", "Dismiss all errors"},
                                            {"?", "Close this help"}};
    entries = popup;
    count = sizeof(popup) / sizeof(*popup);
    title = "Error Popup Keyboard Shortcuts";
    break;
  }
  case UI_SCREEN_SYNC:
    entries = sync;
    count = sizeof(sync) / sizeof(*sync);
    title = "Sync Viewer Keyboard Shortcuts";
    break;
  case UI_SCREEN_STATS:
    entries = stats;
    count = sizeof(stats) / sizeof(*stats);
    title = "Statistics Keyboard Shortcuts";
    break;
  case UI_SCREEN_ERRNO:
    entries = errors;
    count = sizeof(errors) / sizeof(*errors);
    title = "Error Stacks Keyboard Shortcuts";
    break;
  case UI_SCREEN_PROMPT:
    entries = media;
    count = sizeof(media) / sizeof(*media);
    title = "Media Input Keyboard Shortcuts";
    break;
  case UI_SCREEN_MDNS:
    entries = lan;
    count = sizeof(lan) / sizeof(*lan);
    title = "LAN Selection Keyboard Shortcuts";
    break;
  case UI_SCREEN_UPDATE:
    entries = update;
    count = sizeof(update) / sizeof(*update);
    title = "Update Checker Keyboard Shortcuts";
    break;
  default:
    return ui_session_help_render(size, GET_OPTION(media_file)[0] || GET_OPTION(media_url)[0], false, minimum);
  }
  char footer[TUI_SESSION_HELP_FOOTER_BUFFER_SIZE];
  snprintf(footer, sizeof(footer), "Press %s to close", colored_string(LOG_COLOR_WARN, "?"));
  ui_help_menu_t menu = {.title = title, .entries = entries, .count = count, .footer = footer, .top_margin = 0};
  *minimum = ui_help_menu_measure(&menu);
  frame_buffer_t *buffer = frame_buffer_create(size.rows, size.cols);
  if (!buffer)
    return NULL;
  ui_help_menu_render(buffer, size, &menu);
  size_t length = frame_buffer_get_length(buffer);
  char *result = SAFE_MALLOC(length + 1, char *);
  memcpy(result, frame_buffer_get_content(buffer), length);
  result[length] = '\0';
  frame_buffer_destroy(buffer);
  return result;
}

References colored_string(), ERROR_INVALID_PARAM, frame_buffer_create(), frame_buffer_destroy(), frame_buffer_get_content(), frame_buffer_get_length(), GET_OPTION, LOG_COLOR_WARN, SAFE_MALLOC, SET_ERRNO, TUI_SESSION_HELP_FOOTER_BUFFER_SIZE, ui_help_menu_measure(), ui_help_menu_render(), UI_SCREEN_ERRNO, UI_SCREEN_ERROR, UI_SCREEN_MDNS, UI_SCREEN_PROMPT, UI_SCREEN_STATS, UI_SCREEN_SYNC, UI_SCREEN_UPDATE, and ui_session_help_render().

Referenced by keyboard_help_toggle_terminal().

ui_session_create()

ui_session_t * ui_session_create

(

void

)

Definition at line 46 of file lib/tui/session.c.

                                      {
  ui_session_t *s = SAFE_CALLOC(1, sizeof(*s), ui_session_t *);
  if (!s)
    return NULL;
  s->frame = frame_buffer_create(24, 80);
  s->media = frame_buffer_create(24, 80);
  s->logs = log_get_history_buffer();
  s->owns_logs = !s->logs;
  if (s->owns_logs)
    s->logs = session_log_buffer_create();
  if (!s->frame || !s->media || !s->logs) {
    ui_session_destroy(s);
    return NULL;
  }
  s->started = time(NULL);
  log_search_init();
  s->size = (terminal_size_t){.cols = 80, .rows = 24};
  s->active = -1;
  s->saved_volume = 1;
  s->dirty = true;
  s->splash.use_colors = true;
  animation_init(&s->animation, "session_splash",
                 (animation_config_t){
                     .type = ANIMATION_SPLASH_RAINBOW, .fps = 60, .speed = 1, .hidden_policy = ANIMATION_HIDDEN_PAUSE});
  return s;
}

References ui_session::active, ui_session::animation, animation_init(), ui_session::dirty, ui_session::frame, frame_buffer_create(), log_get_history_buffer(), log_search_init(), ui_session::logs, ui_session::media, ui_session::owns_logs, SAFE_CALLOC, ui_session::saved_volume, session_log_buffer_create(), ui_session::size, ui_session::splash, ui_session::started, ui_session_destroy(), and ui_splash_view_t::use_colors.

Referenced by SessionUiBinding::SessionUiBinding().

ui_session_destroy()

void ui_session_destroy

(

ui_session_t *

session

)

Definition at line 73 of file lib/tui/session.c.

                                         {
  if (!s)
    return;
  if (log_get_session_log_buffer() == s->logs)
    log_clear_session_log_buffer();
  animation_destroy(&s->animation);
  frame_buffer_destroy(s->frame);
  frame_buffer_destroy(s->media);
  if (s->owns_logs)
    session_log_buffer_destroy(s->logs);
  SAFE_FREE(s);
}

References ui_session::animation, animation_destroy(), ui_session::frame, frame_buffer_destroy(), log_clear_session_log_buffer(), log_get_session_log_buffer(), ui_session::logs, ui_session::media, ui_session::owns_logs, SAFE_FREE, and session_log_buffer_destroy().

Referenced by ui_controller_shutdown(), ui_session_create(), and SessionUiBinding::~SessionUiBinding().

ui_session_frame_length()

size_t ui_session_frame_length

(

const ui_session_t *

session

)

Definition at line 165 of file lib/tui/session.c.

                                                      {
  size_t length = s ? frame_buffer_get_length(s->frame) : 0;
  return length ? length - 1 : 0;
}

References ui_session::frame, and frame_buffer_get_length().

ui_session_help_free()

void ui_session_help_free

(

char *

text

)

Release rendered help with the same allocator that created it.

Definition at line 33 of file session_help.c.

                                      {
  SAFE_FREE(text);
}

References SAFE_FREE.

Referenced by ui_session_tick().

ui_session_help_render()

char * ui_session_help_render	(	terminal_size_t	size,
		bool	has_media,
		bool	browser,
		terminal_size_t *	minimum )

Returns owned ANSI text, released with SAFE_FREE.

Definition at line 124 of file session_help.c.

                                                                                                           {
  if (!minimum) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Help minimum geometry output is required");
    return NULL;
  }
  const char *navigation[] = {
      "Navigation & Control:",
      "─────────────────────",
      "?      Toggle this help screen TUI",
      "q / Esc  Quit ascii-chat (Shift+Key to panic exit)",
      browser ? NULL : "v      Open from clipboard",
      browser ? NULL : "Paste  Queue dropped/pasted media",
      browser ? NULL : "< / >  Previous/next media (restart)",
      has_media ? "Space  Play/Pause (files only)" : NULL,
      has_media ? "[      Toggle Media Playback" : NULL,
      has_media ? (terminal_should_use_utf8(GET_OPTION(force_utf8)) ? "← / →  Seek backward/forward 30s"
                                                                    : "Left / Right  Seek backward/forward 30s")
                : NULL,
      "m / M  Mute/Unmute audio",
      terminal_should_use_utf8(GET_OPTION(force_utf8)) ? "↑ / ↓  Volume up/down (10%)"
                                                       : "Up / Down  Volume up/down (10%)",
      "c / C  Cycle color mode",
      "f / F  Cycle color filter",
      "x / X  Flip webcam horizontally",
      "y / Y  Flip webcam vertically",
      "w / W  Toggle Face Follow",
      "r / R  Cycle render mode",
      "-      FPS counter",
#if defined(ASCIICHAT_DIAGNOSTIC_UI)
      browser ? NULL : "`      Error stacks diagnostic TUI",
#endif
      browser ? NULL : "o      TUI to open media from path or url",
      "]      Live log viewer/searcher TUI",
      "F12    Version update checker TUI",
      browser ? NULL : "=      Running app statistics TUI",
#ifndef NDEBUG
      browser ? NULL : "0      C code sync primitives TUI",
#endif
  };
  char settings[TUI_SESSION_HELP_SETTINGS_COUNT][SESSION_HELP_SETTING_BUFFER_SIZE] = {"Current Settings:", ""};
  char volume_bar[TUI_SESSION_HELP_VOLUME_BAR_BUFFER_SIZE];
  format_volume_bar(GET_OPTION(speakers_volume), volume_bar, sizeof(volume_bar));
  snprintf(settings[2], sizeof(settings[2]), "Audio  : %s", status_indicator(GET_OPTION(audio_enabled)));
  snprintf(settings[3], sizeof(settings[3]), "Volume : %s", volume_bar);
  snprintf(settings[4], sizeof(settings[4]), "Color  : %s", color_mode_to_string(GET_OPTION(color_mode)));
  snprintf(settings[5], sizeof(settings[5]), "Filter : %s", color_filter_to_string(GET_OPTION(color_filter)));
  snprintf(settings[6], sizeof(settings[6]), "Render : %s", render_mode_to_string(GET_OPTION(render_mode)));
  snprintf(settings[7], sizeof(settings[7]), "Flip   : rows=%s cols=%s", status_indicator(GET_OPTION(flip_y)),
           status_indicator(GET_OPTION(flip_x)));
  snprintf(settings[8], sizeof(settings[8]), "Face Follow : %s", status_indicator(GET_OPTION(face_follow)));
  int settings_count = 9;
  snprintf(settings[settings_count++], sizeof(settings[0]), "Animations (number key toggle):");
  snprintf(settings[settings_count++], sizeof(settings[0]), "-------------------------------");
  snprintf(settings[settings_count++], sizeof(settings[0]), "(1) Matrix \"Digital Rain\" : %s",
           status_indicator(GET_OPTION(matrix_rain)));
  snprintf(settings[settings_count++], sizeof(settings[0]), "(2) Audio Waveform : %s",
           status_indicator(GET_OPTION(waveform)));
  snprintf(settings[settings_count++], sizeof(settings[0]), "(3) Audio Frequencies (FFT) : %s",
           status_indicator(GET_OPTION(fft)));
  snprintf(settings[settings_count++], sizeof(settings[0]), "(z) Zalgo intensity : %d", GET_OPTION(zalgo));
  snprintf(settings[settings_count++], sizeof(settings[0]), "(-) FPS Counter : %s",
           status_indicator(GET_OPTION(fps_counter)));
  bool server = !browser && (GET_OPTION(detected_mode) == MODE_SERVER || GET_OPTION(detected_mode) == MODE_MCP_SERVER);
  bool discovery = !browser && GET_OPTION(detected_mode) == MODE_DISCOVERY_SERVICE;
  ui_help_entry_t entries[SESSION_HELP_ENTRY_CAPACITY];
  char key_storage[TUI_SESSION_HELP_KEY_STORAGE_COUNT][SESSION_HELP_KEY_BUFFER_SIZE];
  size_t count = 0;
  for (size_t i = 0; i < sizeof(navigation) / sizeof(navigation[0]); ++i) {
    const char *line = navigation[i];
    if (!line || i == 1)
      continue;
    if (line[0] == '?' || line[0] == ']' || line[0] == '=' || line[0] == '0' || line[0] == '`' || line[0] == 'o' ||
        !strncmp(line, "F12", 3))
      continue;
    if ((server || discovery) && i > 1 && line[0] != '?' && strncmp(line, "Esc", 3) && line[0] != ']' &&
        line[0] != '=' && line[0] != '0' && line[0] != '`' && strncmp(line, "F12", 3))
      continue;
    const char *end = strstr(line, "  ");
    if (end) {
      size_t length = (size_t)(end - line);
      if (length >= sizeof(key_storage[0]))
        length = sizeof(key_storage[0]) - 1;
      memcpy(key_storage[count], line, length);
      key_storage[count][length] = '\0';
      while (*end == ' ')
        ++end;
      entries[count] = (ui_help_entry_t){.keys = key_storage[count], .description = end};
    } else
      entries[count] = (ui_help_entry_t){.description = line};
    ++count;
  }
  count += tui_shortcut_help(entries + count, 40 - count, server || discovery, browser);
  if (server || discovery) {
    settings_count = 4;
    snprintf(settings[0], sizeof(settings[0]), "%s", discovery ? "Discovery service:" : "Server:");
    snprintf(settings[1], sizeof(settings[1]), "Port : %d", GET_OPTION(port));
    snprintf(settings[2], sizeof(settings[2]), "Status screen : %s", status_indicator(GET_OPTION(status_screen)));
    snprintf(settings[3], sizeof(settings[3]), "Log level : %d", GET_OPTION(log_level));
  }
  const char *settings_text[TUI_SESSION_HELP_SETTINGS_COUNT];
  for (int i = 0; i < settings_count; ++i)
    settings_text[i] = settings[i];
  char footer[TUI_SESSION_HELP_FOOTER_BUFFER_SIZE];
  snprintf(footer, sizeof(footer), "Press %s to close", colored_string(LOG_COLOR_WARN, "?"));
  ui_help_menu_t menu = {.title = discovery ? "ascii-chat Discovery Service Keyboard Shortcuts"
                                  : server  ? "ascii-chat Server Keyboard Shortcuts"
                                            : "ascii-chat Keyboard Shortcuts",
                         .entries = entries,
                         .count = count,
                         .settings = settings_text,
                         .settings_count = (size_t)settings_count,
                         .footer = footer,
                         // Browser sessions draw a four-row animated logo above the popup.
                         .top_margin = browser ? 6 : 0};
  *minimum = ui_help_menu_measure(&menu);
  frame_buffer_t *output = frame_buffer_create(size.rows, size.cols);
  if (!output)
    return NULL;
  ui_help_menu_render(output, size, &menu);
  size_t length = frame_buffer_get_length(output);
  char *result = SAFE_MALLOC(length + 1, char *);
  memcpy(result, frame_buffer_get_content(output), length);
  result[length] = '\0';
  frame_buffer_destroy(output);
  return result;
}

References color_mode, color_mode_to_string(), colored_string(), ERROR_INVALID_PARAM, frame_buffer_create(), frame_buffer_destroy(), frame_buffer_get_content(), frame_buffer_get_length(), GET_OPTION, LOG_COLOR_WARN, MODE_DISCOVERY_SERVICE, MODE_MCP_SERVER, MODE_SERVER, render_mode_to_string(), SAFE_MALLOC, SESSION_HELP_ENTRY_CAPACITY, SESSION_HELP_KEY_BUFFER_SIZE, SESSION_HELP_SETTING_BUFFER_SIZE, SET_ERRNO, TUI_SESSION_HELP_FOOTER_BUFFER_SIZE, TUI_SESSION_HELP_KEY_STORAGE_COUNT, TUI_SESSION_HELP_SETTINGS_COUNT, TUI_SESSION_HELP_VOLUME_BAR_BUFFER_SIZE, tui_shortcut_help(), ui_help_menu_measure(), and ui_help_menu_render().

Referenced by ui_session_context_help_render(), and ui_session_tick().

ui_session_input()

ui_session_action_t ui_session_input	(	ui_session_t *	session,
		keyboard_key_t	key )

Definition at line 129 of file lib/tui/session.c.

                                                                          {
  if (!s)
    return UI_ACTION_NONE;
  if (s->show_logs && ui_session_logs_key_sized(key, s->size)) {
    s->dirty = true;
    return UI_ACTION_LOGS;
  }
  ui_session_action_t action = ui_session_key(key, &s->saved_volume);
  if (action == UI_ACTION_HELP) {
    s->help = !s->help;
    s->show_logs = false;
  } else if (action == UI_ACTION_LOGS) {
    s->show_logs = !s->show_logs;
    s->help = false;
  } else if (action == UI_ACTION_CLOSE && s->show_logs) {
    s->show_logs = false;
    action = UI_ACTION_LOGS;
  } else if (action == UI_ACTION_CLOSE && s->help) {
    s->help = false;
    action = UI_ACTION_HELP;
  }
  s->dirty |= action != UI_ACTION_NONE;
  return action;
}

References action, ui_session::dirty, ui_session::help, ui_session::saved_volume, ui_session::show_logs, ui_session::size, UI_ACTION_CLOSE, UI_ACTION_HELP, UI_ACTION_LOGS, UI_ACTION_NONE, and ui_session_key().

Referenced by SessionUiBinding::key().

ui_session_is_covered()

bool ui_session_is_covered

(

const ui_session_t *

session

)

Definition at line 161 of file lib/tui/session.c.

                                                  {
  return s && s->covered;
}

References ui_session::covered.

ui_session_key()

ui_session_action_t ui_session_key	(	keyboard_key_t	key,
		double *	saved_volume )

Mutates shared options for settings keys; returns an action for the host.

Definition at line 106 of file session_input.c.

                                                                             {
  switch ((int)key) {
  case 'q':
    return UI_ACTION_QUIT;
  case 'Q':
    return UI_ACTION_FORCE_QUIT;
  case KEY_QUESTION:
    return UI_ACTION_HELP;
  case '[':
    return UI_ACTION_TOGGLE_MEDIA;
  case ']':
    return UI_ACTION_LOGS;
  case KEY_ESCAPE:
    return UI_ACTION_CLOSE;
  case KEY_SHIFT_ESCAPE:
    return UI_ACTION_FORCE_QUIT;
  case KEY_LEFT:
    return UI_ACTION_SEEK_BACK;
  case KEY_RIGHT:
    return UI_ACTION_SEEK_FORWARD;
  case KEY_SPACE:
    return UI_ACTION_PAUSE;
  case KEY_BACKTICK:
    return UI_ACTION_DEBUG;
  // ===== VOLUME CONTROLS =====
  case KEY_DOWN: { // Decrease volume 10%
    double current_volume = GET_OPTION(speakers_volume);
    double new_volume = clamp_volume(current_volume - 0.1);
    options_adjust("speakers_volume", key == KEY_DOWN ? -0.1 : 0.1);
 
    double verify_volume = GET_OPTION(speakers_volume);
    log_info("Volume DOWN: %.0f%% → %.0f%% (verified: %.0f%%)", current_volume * 100.0, new_volume * 100.0,
             verify_volume * 100.0);
    return UI_ACTION_VOLUME;
  }
 
  case KEY_UP: { // Increase volume 10%
    double current_volume = GET_OPTION(speakers_volume);
    double new_volume = clamp_volume(current_volume + 0.1);
    options_adjust("speakers_volume", key == KEY_DOWN ? -0.1 : 0.1);
 
    double verify_volume = GET_OPTION(speakers_volume);
    log_info("Volume UP: %.0f%% → %.0f%% (verified: %.0f%%)", current_volume * 100.0, new_volume * 100.0,
             verify_volume * 100.0);
    return UI_ACTION_SETTINGS;
  }
 
  // ===== COLOR MODE CONTROL =====
  case KEY_C:
  case 'C': {
    int current_mode = (int)GET_OPTION(color_mode);
    int next_mode = next_color_mode(current_mode);
    options_cycle("color_mode", 4);
 
    const char *mode_names[] = {"Mono", "16-color", "256-color", "Truecolor"};
    if (next_mode >= 0 && next_mode <= 3) {
      log_info("Color mode: %s", mode_names[next_mode]);
    }
    return UI_ACTION_SETTINGS;
  }
 
  // ===== MUTE CONTROL =====
  case KEY_M:
  case 'M': {
    if (toggle_mute(saved_volume) != ASCIICHAT_OK)
      log_warn("Could not toggle mute");
 
    return UI_ACTION_SETTINGS;
  }
 
  // ===== RENDER MODE CONTROL =====
  case KEY_R:
  case 'R': {
    int current_mode = (int)GET_OPTION(render_mode);
    int next_mode = next_render_mode(current_mode);
    options_cycle("render_mode", 3);
 
    const char *mode_names[] = {"Foreground", "Background", "Half-block"};
    if (next_mode >= 0 && next_mode <= 2) {
      log_info("Render mode: %s", mode_names[next_mode]);
    }
    return UI_ACTION_SETTINGS;
  }
 
  // ===== COLOR FILTER CONTROL =====
  case KEY_F:
  case 'F': {
    int current_filter = (int)GET_OPTION(color_filter);
    int next_filter = next_color_filter(current_filter);
    options_cycle("color_filter", 13);
 
    if (next_filter >= 0 && next_filter < (int)COLOR_FILTER_COUNT) {
      log_info("Color filter: %s", COLOR_FILTER_NAMES[next_filter]);
    }
    return UI_ACTION_SETTINGS;
  }
 
  // ===== HORIZONTAL FLIP CONTROL =====
  case 'X':
  case 'x': {
    log_info("✓ X KEY PRESSED - handling horizontal flip");
    bool current_flip_x = (bool)GET_OPTION(flip_x);
    options_toggle("flip_x");
    log_info("Horizontal flip: %s (was: %s)", !current_flip_x ? "enabled" : "disabled",
             current_flip_x ? "enabled" : "disabled");
    return UI_ACTION_SETTINGS;
  }
 
  // ===== VERTICAL FLIP CONTROL =====
  case 'Y':
  case 'y': {
    bool current_flip_y = (bool)GET_OPTION(flip_y);
    options_toggle("flip_y");
    log_info("Vertical flip: %s", !current_flip_y ? "enabled" : "disabled");
    return UI_ACTION_SETTINGS;
  }
 
  // ===== MATRIX RAIN EFFECT CONTROL =====
  case KEY_1: {
    bool current_matrix = (bool)GET_OPTION(matrix_rain);
    if (options_toggle("matrix_rain") != ASCIICHAT_OK)
      return UI_ACTION_SETTINGS;
    log_info("Matrix rain effect: %s", !current_matrix ? "enabled" : "disabled");
    return UI_ACTION_SETTINGS;
  }
 
  case KEY_2: {
    if (!GET_OPTION(audio_enabled)) {
      log_info("Audio waveform requires audio to be enabled");
      return UI_ACTION_SETTINGS;
    }
    bool enabled = !GET_OPTION(waveform);
    if (options_toggle("waveform") != ASCIICHAT_OK)
      return UI_ACTION_SETTINGS;
    log_info("Audio waveform: %s", enabled ? "enabled" : "disabled");
    return UI_ACTION_SETTINGS;
  }
 
  case KEY_3: {
    if (!GET_OPTION(audio_enabled)) {
      log_info("Audio frequency display requires audio to be enabled");
      return UI_ACTION_SETTINGS;
    }
    bool enabled = !GET_OPTION(fft);
    if (enabled && audio_visualization_fft_init() != ASCIICHAT_OK) {
      log_error("Unable to initialize FFTW frequency display");
      return UI_ACTION_SETTINGS;
    }
    if (options_toggle("fft") != ASCIICHAT_OK)
      return UI_ACTION_SETTINGS;
    log_info("Audio frequency display: %s", enabled ? "enabled" : "disabled");
    return UI_ACTION_SETTINGS;
  }
 
  case 'w':
  case 'W': {
    if (options_toggle("face_follow") == ASCIICHAT_OK)
      log_info("Face follow: %s", GET_OPTION(face_follow) ? "enabled" : "disabled");
    return UI_ACTION_SETTINGS;
  }
 
  case 'z':
  case 'Z': {
    if (options_set_int("zalgo", GET_OPTION(zalgo) ? 0 : 8) == ASCIICHAT_OK)
      log_info("Zalgo intensity: %d", GET_OPTION(zalgo));
    return UI_ACTION_SETTINGS;
  }
 
  // ===== FPS COUNTER TOGGLE =====
  case KEY_MINUS: {
    bool current = (bool)GET_OPTION(fps_counter);
    options_toggle("fps_counter");
    log_info("FPS counter: %s", !current ? "enabled" : "disabled");
    return UI_ACTION_SETTINGS;
  }
 
  default:
    return UI_ACTION_NONE;
  }
}

References ASCIICHAT_OK, audio_visualization_fft_init(), color_mode, enabled, GET_OPTION, KEY_1, KEY_2, KEY_3, KEY_BACKTICK, KEY_C, KEY_DOWN, KEY_ESCAPE, KEY_F, KEY_LEFT, KEY_M, KEY_MINUS, KEY_QUESTION, KEY_R, KEY_RIGHT, KEY_SHIFT_ESCAPE, KEY_SPACE, KEY_UP, log_error, log_info, log_warn, options_adjust(), options_cycle(), options_set_int(), options_toggle(), UI_ACTION_CLOSE, UI_ACTION_DEBUG, UI_ACTION_FORCE_QUIT, UI_ACTION_HELP, UI_ACTION_LOGS, UI_ACTION_NONE, UI_ACTION_PAUSE, UI_ACTION_QUIT, UI_ACTION_SEEK_BACK, UI_ACTION_SEEK_FORWARD, UI_ACTION_SETTINGS, UI_ACTION_TOGGLE_MEDIA, and UI_ACTION_VOLUME.

Referenced by ui_session_input().

ui_session_loading()

void ui_session_loading	(	ui_session_t *	session,
		bool	loading,
		const char *	message )

Definition at line 97 of file lib/tui/session.c.

                                                                            {
  if (!s)
    return;
  if (loading != s->loading) {
    s->loading = loading;
    animation_reset(&s->animation);
    s->dirty = true;
  }
  if (message && strcmp(message, s->splash.connection_target)) {
    SAFE_STRNCPY(s->splash.connection_target, message, sizeof(s->splash.connection_target));
    s->dirty = true;
  }
}

References ui_session::animation, animation_reset(), ui_splash_view_t::connection_target, ui_session::dirty, ui_session::loading, SAFE_STRNCPY, and ui_session::splash.

Referenced by SessionUiBinding::loading().

ui_session_log()

void ui_session_log	(	ui_session_t *	session,
		const char *	message )

Definition at line 111 of file lib/tui/session.c.

                                                          {
  if (s && message) {
    session_log_buffer_append(s->logs, message);
    s->dirty = true;
  }
}

References ui_session::dirty, ui_session::logs, and session_log_buffer_append().

Referenced by SessionUiBinding::log().

ui_session_logs_key()

bool ui_session_logs_key

(

keyboard_key_t

key

)

Existing server log-search controls; true when consumed.

Definition at line 296 of file lib/tui/session.c.

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

References ui_controller_size().

ui_session_logs_render()

void ui_session_logs_render	(	frame_buffer_t *	output,
		terminal_size_t	size,
		ui_session_t *	session )

Shared live log view, used by the native adapter and browser compositor.

Definition at line 244 of file lib/tui/session.c.

                                                                                           {
  char detail[TUI_SESSION_DETAIL_BUFFER_SIZE];
  size_t offset = terminal_screen_logs_offset();
  char offset_text[TUI_SESSION_OFFSET_TEXT_BUFFER_SIZE];
  snprintf(offset_text, sizeof(offset_text), "%zu", offset);
  const char *colored_offset = colored_string(LOG_COLOR_FATAL, offset_text);
  snprintf(detail, sizeof(detail), "%s | %s rows from tail", ui_status_log_controls(), colored_offset);
  ui_status_t status = {.mode_name = "", .start_time = s->started, .detail = detail};
  terminal_screen_config_t config = {
      .fixed_header_lines = 4, .render_header = ui_status_render_header, .user_data = &status, .show_logs = true};
  terminal_screen_compose(output, size, &config, s->logs);
}

References colored_string(), LOG_COLOR_FATAL, ui_session::logs, ui_session::started, terminal_screen_compose(), terminal_screen_logs_offset(), TUI_SESSION_DETAIL_BUFFER_SIZE, TUI_SESSION_OFFSET_TEXT_BUFFER_SIZE, ui_status_log_controls(), and ui_status_render_header().

ui_session_media()

asciichat_error_t ui_session_media	(	ui_session_t *	session,
		const char *	data,
		size_t	length )

Definition at line 118 of file lib/tui/session.c.

                                                                                     {
  if (!s || !data || length > UI_CONTROLLER_MAX_FRAME_BYTES)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid session media frame");
  frame_buffer_reset(s->media);
  frame_buffer_append(s->media, data, length);
  s->dirty = true;
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, ui_session::dirty, ERROR_INVALID_PARAM, frame_buffer_append(), frame_buffer_reset(), ui_session::media, SET_ERRNO, and UI_CONTROLLER_MAX_FRAME_BYTES.

Referenced by SessionUiBinding::media().

ui_session_next_frame_ns()

uint64_t ui_session_next_frame_ns

(

const ui_session_t *

session

)

Next visible animation deadline, or UINT64_MAX while animation is paused/hidden.

Definition at line 170 of file lib/tui/session.c.

                                                         {
  return s && s->animation.started ? s->splash.animation.next_frame_ns : UINT64_MAX;
}

References ui_session::animation, ui_splash_view_t::animation, animation_sample_t::next_frame_ns, ui_session::splash, and animation_t::started.

ui_session_redraw()

void ui_session_redraw

(

ui_session_t *

session

)

Definition at line 370 of file lib/tui/session.c.

                                        {
  if (s)
    s->dirty = true;
}

References ui_session::dirty.

Referenced by SessionUiBinding::redraw(), and ui_controller_redraw().

ui_session_render()

const char * ui_session_render	(	ui_session_t *	session,
		const ui_session_view_t *	view,
		uint64_t	now_ns )

Present a host view through the same compositor used by ui_session_tick(). A screen of -1 hides presentation. NULL means no redraw is required.

Definition at line 174 of file lib/tui/session.c.

                                                                                               {
  if (!s || !view)
    return NULL;
  bool changed = s->active != view->screen;
  s->active = view->screen;
  bool covered = view->screen >= 0 && ui_too_small(s->size, view->minimum);
  bool transition = changed || covered != s->covered || s->size.cols != s->presented_size.cols ||
                    s->size.rows != s->presented_size.rows || view->minimum.cols != s->minimum.cols ||
                    view->minimum.rows != s->minimum.rows;
  s->covered = covered;
  bool visible =
      (view->screen == UI_SCREEN_SPLASH || view->screen == UI_SCREEN_HELP || view->screen == UI_SCREEN_MDNS) &&
      !covered;
  if (visible != s->animation.visible) {
    // Account for the elapsed interval under the old visibility before changing
    // it, so resuming after an idle modal does not advance a paused animation.
    if (animation_update(&s->animation, now_ns, &s->splash.animation) != ASCIICHAT_OK)
      return NULL;
    animation_set_visible(&s->animation, visible);
  }
  if (animation_update(&s->animation, now_ns, &s->splash.animation) != ASCIICHAT_OK)
    return NULL;
  if (view->screen < 0 || !view->draw)
    return NULL;
  bool animated = visible && s->splash.animation.changed;
  bool refresh = view->refresh_ns && now_ns - s->last_render_ns >= view->refresh_ns;
  if (covered ? !(transition || s->dirty) : !(transition || s->dirty || view->dirty || animated || refresh))
    return NULL;
  s->dirty = false;
  s->presented_size = s->size;
  s->minimum = view->minimum;
  s->last_render_ns = now_ns;
  frame_buffer_reset(s->frame);
  if (transition || view->clear) {
    frame_buffer_append(s->frame, "\033[0m", 4);
    frame_buffer_clear_screen(s->frame);
  }
  if (covered)
    ui_too_small_render(s->frame, s->size, view->minimum);
  else {
    if (view->screen == UI_SCREEN_HELP) {
      int top = (s->size.rows - view->minimum.rows) / 2;
      terminal_color_mode_t mode = GET_OPTION(color_mode);
      bool colors = mode != TERM_COLOR_NONE && GET_OPTION(color) != COLOR_SETTING_FALSE && !GET_OPTION(strip_ansi) &&
                    (mode != TERM_COLOR_AUTO ||
                     detect_terminal_capabilities(options_terminal_settings()).color_level != TERM_COLOR_NONE);
      frame_buffer_printf(s->frame, "\033[%d;1H", top + 2);
      invitation_render_logo(s->frame, s->size.cols, (int)(s->splash.animation.seconds * 60), colors, false);
    }
    view->draw(s->frame, s->size, &s->splash.animation, view->context);
  }
  frame_buffer_append(s->frame, "\0", 1);
  return frame_buffer_get_content(s->frame);
}

References ui_session::active, ui_session::animation, ui_splash_view_t::animation, animation_set_visible(), animation_update(), ASCIICHAT_OK, animation_sample_t::changed, ui_session_view_t::clear, color_mode, COLOR_SETTING_FALSE, colors, ui_session_view_t::context, ui_session::covered, ui_session::dirty, ui_session_view_t::dirty, ui_session_view_t::draw, ui_session::frame, frame_buffer_append(), frame_buffer_clear_screen(), frame_buffer_get_content(), frame_buffer_printf(), frame_buffer_reset(), GET_OPTION, invitation_render_logo(), ui_session::last_render_ns, ui_session::minimum, ui_session_view_t::minimum, options_terminal_settings, ui_session::presented_size, ui_session_view_t::refresh_ns, ui_session_view_t::screen, animation_sample_t::seconds, ui_session::size, ui_session::splash, UI_SCREEN_HELP, UI_SCREEN_MDNS, UI_SCREEN_SPLASH, ui_too_small(), ui_too_small_render(), and animation_t::visible.

Referenced by ui_session_tick().

ui_session_resize()

void ui_session_resize	(	ui_session_t *	session,
		int	cols,
		int	rows )

Definition at line 86 of file lib/tui/session.c.

                                                            {
  if (!s || cols < 1 || rows < 1 || cols > 4096 || rows > 4096) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Invalid TUI session or terminal dimensions");
    return;
  }
  if (cols != s->size.cols || rows != s->size.rows) {
    s->size = (terminal_size_t){.cols = cols, .rows = rows};
    s->dirty = true;
  }
}

References ui_session::dirty, ERROR_INVALID_PARAM, SET_ERRNO, and ui_session::size.

Referenced by SessionUiBinding::resize().

ui_session_select_screen()

int ui_session_select_screen

(

uint32_t

visible_screens

)

Highest visible screen from the common priority order, or -1.

Definition at line 154 of file lib/tui/session.c.

                                                       {
  for (int screen = UI_SCREEN_COUNT - 1; screen >= 0; --screen)
    if (visible_screens & (1u << screen))
      return screen;
  return -1;
}

References UI_SCREEN_COUNT.

Referenced by ui_session_tick().

ui_session_size()

terminal_size_t ui_session_size

(

const ui_session_t *

session

)

Definition at line 366 of file lib/tui/session.c.

                                                       {
  return s ? s->size : (terminal_size_t){.cols = 80, .rows = 24};
}

References ui_session::size.

Referenced by ui_controller_size().

ui_session_splash_render()

void ui_session_splash_render	(	frame_buffer_t *	buf,
		terminal_size_t	size,
		void *	view )

Definition at line 19 of file session_splash.c.

                                                                                               {
  const ui_splash_view_t *ctx = (const ui_splash_view_t *)user_data;
  if (!ctx) {
    return;
  }
  bool unicode = terminal_should_use_utf8(GET_OPTION(force_utf8));
 
  if (ctx->discovery.enabled) {
    invitation_render(buf, term_size, ctx->discovery.session_string, ctx->discovery.joining,
                      (int)(ctx->animation.seconds * 60), ctx->use_colors);
    return;
  }
 
  char tagline_with_version[TUI_SESSION_SPLASH_TAGLINE_WITH_VERSION_BUFFER_SIZE];
  snprintf(tagline_with_version, sizeof(tagline_with_version), "Video chat in your terminal + %s",
           ASCII_CHAT_VERSION_STRING);
  const char *tagline = tagline_with_version;
  frame_buffer_render_divider(buf, term_size.cols - 1, unicode, ctx->use_colors);
  invitation_render_logo(buf, term_size.cols - 1, (int)(ctx->animation.seconds * 60), ctx->use_colors, false);
 
  // Line 6: Tagline (centered, truncated if too long)
  char plain_tagline[TUI_SESSION_SPLASH_PLAIN_TAGLINE_BUFFER_SIZE];
  int tagline_len = (int)strlen(tagline);
  int tagline_pad = (term_size.cols - tagline_len) / 2;
  if (tagline_pad < 0) {
    tagline_pad = 0;
  }
 
  int tpos = 0;
  for (int j = 0; j < tagline_pad && tpos < (int)sizeof(plain_tagline) - 1; j++) {
    plain_tagline[tpos++] = ' ';
  }
  snprintf(plain_tagline + tpos, sizeof(plain_tagline) - tpos, "%s", tagline);
 
  // Check visible width and truncate if needed
  int tagline_visible_width = display_width(plain_tagline);
  if (tagline_visible_width < 0) {
    tagline_visible_width = (int)strlen(plain_tagline);
  }
  if (term_size.cols > 0 && tagline_visible_width >= term_size.cols) {
    plain_tagline[term_size.cols - 1] = '\0';
  }
 
  frame_buffer_printf(buf, "%s\n", plain_tagline);
 
  // Line 7: Update notification (if available)
  if (ctx->update_notification[0] != '\0') {
    char plain_update[TUI_SESSION_SPLASH_PLAIN_UPDATE_BUFFER_SIZE];
    int update_len = (int)strlen(ctx->update_notification);
    int update_pad = (term_size.cols - update_len) / 2;
    if (update_pad < 0) {
      update_pad = 0;
    }
 
    int upos = 0;
    for (int j = 0; j < update_pad && upos < (int)sizeof(plain_update) - 1; j++) {
      plain_update[upos++] = ' ';
    }
    snprintf(plain_update + upos, sizeof(plain_update) - upos, "%s", ctx->update_notification);
 
    // Check visible width and truncate if needed
    int update_visible_width = display_width(plain_update);
    if (update_visible_width < 0) {
      update_visible_width = (int)strlen(plain_update);
    }
    if (term_size.cols > 0 && update_visible_width >= term_size.cols) {
      plain_update[term_size.cols - 1] = '\0';
    }
 
    // Print in yellow/warning color
    frame_buffer_printf(buf, "%s\n", colored_string(LOG_COLOR_WARN, plain_update));
  }
 
  // Line 8 (or 7 if no update): Connection target (centered, truncated if too long)
  const char *connection_target = ctx->connection_target;
 
  char plain_connection[TUI_SESSION_SPLASH_PLAIN_CONNECTION_BUFFER_SIZE];
  int connection_len = (int)strlen(connection_target);
  int connection_pad = (term_size.cols - connection_len) / 2;
  if (connection_pad < 0) {
    connection_pad = 0;
  }
 
  int cpos = 0;
  for (int j = 0; j < connection_pad && cpos < (int)sizeof(plain_connection) - 1; j++) {
    plain_connection[cpos++] = ' ';
  }
  snprintf(plain_connection + cpos, sizeof(plain_connection) - cpos, "%s", connection_target);
 
  // Check visible width and truncate if needed
  int connection_visible_width = display_width(plain_connection);
  if (connection_visible_width < 0) {
    connection_visible_width = (int)strlen(plain_connection);
  }
  if (term_size.cols > 0 && connection_visible_width >= term_size.cols) {
    plain_connection[term_size.cols - 1] = '\0';
  }
 
  frame_buffer_printf(buf, "%s\n", plain_connection);
 
  if (update_banner_is_checking()) {
    static const char spin[] = "|/-\\";
    const char *text = "Checking for updates...";
    int pad = term_size.cols - (int)strlen(text) - 3;
    if (pad < 0)
      pad = 0;
    frame_buffer_printf(buf, "%*s%c %s\n", pad, "", spin[((int)(ctx->animation.seconds * 8)) % 4], text);
  }
 
  // Bottom border
  frame_buffer_render_divider(buf, term_size.cols - 1, unicode, ctx->use_colors);
}

References ui_splash_view_t::animation, colored_string(), ui_splash_view_t::connection_target, ui_splash_view_t::discovery, display_width(), ui_discovery_view_t::enabled, frame_buffer_printf(), frame_buffer_render_divider(), GET_OPTION, invitation_render(), invitation_render_logo(), ui_discovery_view_t::joining, LOG_COLOR_WARN, animation_sample_t::seconds, ui_discovery_view_t::session_string, TUI_SESSION_SPLASH_PLAIN_CONNECTION_BUFFER_SIZE, TUI_SESSION_SPLASH_PLAIN_TAGLINE_BUFFER_SIZE, TUI_SESSION_SPLASH_PLAIN_UPDATE_BUFFER_SIZE, TUI_SESSION_SPLASH_TAGLINE_WITH_VERSION_BUFFER_SIZE, update_banner_is_checking(), ui_splash_view_t::update_notification, and ui_splash_view_t::use_colors.

ui_session_tick()

const char * ui_session_tick	(	ui_session_t *	session,
		uint64_t	now_ns )

No sleeps or I/O. Returned frame remains valid until the next call. NULL means unchanged.

Definition at line 319 of file lib/tui/session.c.

                                                              {
  if (!s)
    return NULL;
  if (!s->dirty && !s->show_logs && !s->help && !s->loading && s->active == UI_SCREEN_MEDIA)
    return NULL;
  uint32_t visible = 1u << UI_SCREEN_MEDIA;
  if (s->loading)
    visible |= 1u << UI_SCREEN_SPLASH;
  if (s->show_logs)
    visible |= 1u << UI_SCREEN_LOGS;
  if (s->help)
    visible |= 1u << UI_SCREEN_HELP;
  ui_session_view_t view = {
      .screen = ui_session_select_screen(visible), .minimum = {1, 1}, .clear = !s->help, .context = s};
  char *help = NULL;
  if (view.screen == UI_SCREEN_HELP) {
    help = ui_session_help_render(s->size, true, true, &view.minimum);
    if (!help)
      return NULL;
    view.draw = draw_help;
    view.context = help;
  } else if (view.screen == UI_SCREEN_LOGS) {
    view.minimum = (terminal_size_t){.cols = 40, .rows = 6};
    view.refresh_ns = 100000000;
    view.draw = draw_logs;
  } else if (view.screen == UI_SCREEN_SPLASH) {
    view.minimum = (terminal_size_t){.cols = 52, .rows = 10};
    view.draw = draw_splash;
  } else {
    view.draw = draw_media;
    if (s->dirty && frame_buffer_get_length(s->media))
      s->presentation_times[s->presentation_index++ % 120] = now_ns;
  }
  const char *frame = ui_session_render(s, &view, now_ns);
  ui_session_help_free(help);
  return frame;
}

References ui_session::active, ui_session_view_t::context, ui_session::dirty, ui_session_view_t::draw, frame_buffer_get_length(), ui_session::help, ui_session::loading, ui_session::media, ui_session_view_t::minimum, ui_session::presentation_index, ui_session::presentation_times, ui_session_view_t::refresh_ns, ui_session_view_t::screen, ui_session::show_logs, ui_session::size, UI_SCREEN_HELP, UI_SCREEN_LOGS, UI_SCREEN_MEDIA, UI_SCREEN_SPLASH, ui_session_help_free(), ui_session_help_render(), ui_session_render(), and ui_session_select_screen().

Referenced by SessionUiBinding::tick().