input.h File Reference

Go to the source code of this file.

Data Structures
struct	tui_input_events_t

Macros
#define	TUI_INPUT_PASTE_BUFFER_SIZE   8192

Functions
void	ui_input_poll_sync (void)
keyboard_key_t	ui_input_read_key (ui_screen_t screen)
keyboard_key_t	ui_input_wait_key (ui_screen_t screen, unsigned timeout_ms)
void	ui_input_shutdown (void)
uint64_t	ui_input_deadline (unsigned seconds)
bool	ui_input_expired (uint64_t deadline)
void	ui_input_timeout_report (unsigned seconds, const char *consequence)
asciichat_error_t	ui_input_prompt (const char *prompt, char *buffer, size_t max_len, prompt_opts_t opts)
asciichat_error_t	ui_input_take_paste (char *buffer, size_t capacity)
asciichat_error_t	ui_input_prompt_prefilled (const char *prompt, char *buffer, size_t max_len, prompt_opts_t opts)
asciichat_error_t	ui_input_media_begin (const char *text)
asciichat_error_t	ui_input_media_take (char *output, size_t capacity)
asciichat_error_t	ui_input_password (const char *target, char *buffer, size_t capacity, bool incorrect)
keyboard_key_t	tui_input_events_read (tui_input_events_t *state, keyboard_key_t(*read_key)(void), bool(*classify_paste)(const char *))

Macro Definition Documentation

TUI_INPUT_PASTE_BUFFER_SIZE

#define TUI_INPUT_PASTE_BUFFER_SIZE   8192

Definition at line 7 of file tui/input.h.

Function Documentation

tui_input_events_read()

keyboard_key_t tui_input_events_read	(	tui_input_events_t *	state,
		keyboard_key_t(*	read_key )(void),
		bool(*	classify_paste )(const char *) )

Collect paste boundaries and optional application-classified text bursts. Once ready, the caller consumes/clears paste before reading another event.

Definition at line 80 of file tui/input.c.

                                                                           {
  if (s->ready)
    return KEY_NONE;
  for (unsigned i = 0; i < 1024; ++i) {
    bool buffered = s->count != 0;
    keyboard_key_t key = buffered ? s->keys[s->head++] : read_key();
    if (buffered)
      --s->count;
    if (key == KEY_NONE)
      return KEY_NONE;
    if (key == KEY_PASTE_BEGIN) {
      s->pasting = true;
      s->invalid = false;
      s->length = 0;
      continue;
    }
    if (key == KEY_PASTE_END) {
      if (!s->pasting)
        continue;
      s->pasting = false;
      s->paste[s->length] = '\0';
      s->ready = true;
      return KEY_PASTE;
    }
    char text[UTF8_BUFFER_SIZE];
    size_t bytes = keyboard_text_encode(key, text);
    if (s->pasting) {
      // Paste payloads remain raw UTF-8 bytes until whole-paste validation.
      if (key >= 128 && key <= 255) {
        text[0] = (char)key;
        bytes = 1;
      }
      if (!bytes || (key < 32 && key != '\r' && key != '\n' && key != '\t') || key == 127 ||
          bytes >= sizeof(s->paste) - s->length)
        s->invalid = true;
      else {
        memcpy(s->paste + s->length, text, bytes);
        s->length += bytes;
      }
      continue;
    }
    if (buffered || !bytes || key < 32 || key == 127)
      return key;
    s->head = 0;
    s->keys[0] = key;
    size_t count = 1;
    keyboard_key_t next;
    while (count < 8192 && (next = read_key()) != KEY_NONE) {
      s->keys[count++] = next;
      if (next == KEY_PASTE_BEGIN || next == KEY_PASTE_END)
        break;
    }
    bool boundary = s->keys[count - 1] == KEY_PASTE_BEGIN || s->keys[count - 1] == KEY_PASTE_END;
    size_t consumed = boundary ? count - 1 : count;
    size_t text_count = consumed;
    while (text_count && (s->keys[text_count - 1] == '\r' || s->keys[text_count - 1] == '\n'))
      --text_count;
    char burst[TUI_INPUT_BURST_BUFFER_SIZE];
    size_t length = 0;
    bool valid = true;
    for (size_t n = 0; n < text_count; ++n) {
      bytes = keyboard_text_encode(s->keys[n], text);
      if (!bytes || s->keys[n] < 32 || s->keys[n] == 127 || bytes >= sizeof(burst) - length) {
        valid = false;
        break;
      }
      memcpy(burst + length, text, bytes);
      length += bytes;
    }
    burst[length] = '\0';
    if (text_count > 1 && classify_paste && classify_paste(burst)) {
      // Keep the delimiter queued so the following payload remains framed.
      s->head = consumed;
      s->count = count - consumed;
      s->invalid = !valid;
      s->length = valid ? length : 0;
      memcpy(s->paste, burst, s->length);
      s->paste[s->length] = '\0';
      s->ready = true;
      return KEY_PASTE;
    }
    s->head = 1;
    s->count = count - 1;
    return key;
  }
  return KEY_NONE;
}

References tui_input_events_t::count, tui_input_events_t::head, tui_input_events_t::invalid, KEY_NONE, KEY_PASTE, KEY_PASTE_BEGIN, KEY_PASTE_END, keyboard_text_encode(), tui_input_events_t::keys, tui_input_events_t::length, tui_input_events_t::paste, tui_input_events_t::pasting, tui_input_events_t::ready, TUI_INPUT_BURST_BUFFER_SIZE, UTF8_BUFFER_SIZE, and valid.

ui_input_deadline()

uint64_t ui_input_deadline

(

unsigned

seconds

)

Absolute monotonic deadline; user activity never extends it.

Definition at line 48 of file tui/input.c.

                                             {
  return time_get_ns() + (uint64_t)seconds * NS_PER_SEC_INT;
}

References NS_PER_SEC_INT.

Referenced by ui_input_media_begin(), and ui_mdns_select().

ui_input_expired()

bool ui_input_expired

(

uint64_t

deadline

)

Definition at line 52 of file tui/input.c.

                                         {
  return time_get_ns() >= deadline;
}

Referenced by ui_input_read_key().

ui_input_media_begin()

asciichat_error_t ui_input_media_begin

(

const char *

text

)

Begin media text entry without blocking capture or network processing.

Definition at line 773 of file tui/input.c.

                                                         {
  if (!text || !utf8_is_valid(text) || strlen(text) >= sizeof(g_media_editor.buffer) || !input_initialize())
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid media prompt text");
  mutex_lock(&g_input_mutex);
  memset(&g_media_editor, 0, sizeof(g_media_editor));
  memcpy(g_media_editor.buffer, text, strlen(text) + 1);
  g_media_editor.length = g_media_editor.cursor = strlen(text);
  g_media_editor.deadline = ui_input_deadline(120);
  asciichat_error_t result =
      ui_prompt_present_kind("Open media: files or URLs\nDrop more files to queue; Enter plays; Esc cancels",
                             g_media_editor.buffer, g_media_editor.cursor, false, UI_PROMPT_MEDIA_INPUT);
  g_media_editor.active = result == ASCIICHAT_OK;
  input_unlock();
  return result;
}

References ASCIICHAT_OK, ERROR_INVALID_PARAM, SET_ERRNO, ui_input_deadline(), ui_prompt_present_kind(), and utf8_is_valid().

Referenced by session_handle_keyboard_input().

ui_input_media_take()

asciichat_error_t ui_input_media_take	(	char *	output,
		size_t	capacity )

Consume the value signaled by KEY_MEDIA_SUBMIT.

Definition at line 789 of file tui/input.c.

                                                                     {
  if (!output || !input_initialize())
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid media prompt destination");
  mutex_lock(&g_input_mutex);
  asciichat_error_t result = ASCIICHAT_OK;
  if (!g_media_editor.submitted || g_media_editor.length >= capacity)
    result = SET_ERRNO(ERROR_INVALID_STATE, "No submitted media prompt");
  else {
    memcpy(output, g_media_editor.buffer, g_media_editor.length + 1);
    asciichat_errno_scope_t scope = errno_scope_begin();
    media_playlist_t playlist = {0};
    if (media_playlist_parse(output, &playlist) == ASCIICHAT_OK) {
      bool file = false, url = false;
      for (size_t i = 0; i < playlist.count; ++i) {
        file |= !playlist.urls[i];
        url |= playlist.urls[i];
      }
      if (file)
        ascii_otel_ui_usage("media_input_prompt", "source_file", 0);
      if (url)
        ascii_otel_ui_usage("media_input_prompt", "source_url", 0);
      ascii_otel_ui_usage("media_input_prompt", "queue_submitted", 0);
    } else {
      ascii_otel_ui_usage("media_input_prompt", "rejected", 0);
    }
    errno_scope_end(scope, ASCIICHAT_ERRNO_DISMISSED);
  }
  g_media_editor.submitted = false;
  input_unlock();
  return result;
}

References ascii_otel_ui_usage(), ASCIICHAT_ERRNO_DISMISSED, ASCIICHAT_OK, media_playlist_t::count, errno_scope_begin(), errno_scope_end(), ERROR_INVALID_PARAM, ERROR_INVALID_STATE, media_playlist_parse(), SET_ERRNO, and media_playlist_t::urls.

Referenced by session_handle_keyboard_input().

ui_input_password()

asciichat_error_t ui_input_password	(	const char *	target,
		char *	buffer,
		size_t	capacity,
		bool	incorrect )

Server password dialog; cancellation requests normal application shutdown.

Definition at line 750 of file tui/input.c.

                                                                                                       {
  if (!target || !buffer || capacity < 2)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid password dialog");
  sodium_memzero(buffer, capacity);
  if (env_pop_prompt_response(buffer, capacity))
    return ASCIICHAT_OK;
  if (!platform_is_interactive())
    return SET_ERRNO(ERROR_CRYPTO_AUTH, "Server password requires an interactive terminal or --password");
  asciichat_error_t result = input_prompt(target, buffer, capacity, PROMPT_OPTS_PASSWORD, true, incorrect);
  if (result != ASCIICHAT_OK) {
    shutdown_request();
    APP_CALLBACK_VOID(signal_exit);
    return SET_ERRNO(ERROR_CRYPTO_AUTH, "Password entry cancelled");
  }
  return result;
}

References APP_CALLBACK_VOID, ASCIICHAT_OK, env_pop_prompt_response(), ERROR_CRYPTO_AUTH, ERROR_INVALID_PARAM, SET_ERRNO, shutdown_request(), and signal_exit().

Referenced by session_connection_establish().

ui_input_poll_sync()

void ui_input_poll_sync

(

void

)

Poll debug controls without waiting for another input reader.

Definition at line 282 of file tui/input.c.

                              {
#ifndef NDEBUG
  if (atomic_load(&g_input_lifecycle.state) == LIFECYCLE_INITIALIZING || !input_initialize() || !input_ready() ||
      mutex_trylock(&g_input_mutex) != 0)
    return;
  if (g_switch_pending) {
    input_unlock();
    return;
  }
  int screen = ui_controller_current_screen();
  if (screen >= 0 && screen <= UI_SCREEN_SYNC && !ui_controller_is_blocked()) {
    keyboard_key_t key = input_read_event();
    if (key != KEY_PASTE && !log_search_is_entering())
      key = ui_sync_handle_key(key);
    if (key && g_sync_key_count < TUI_SYNC_KEY_CAPACITY) {
      g_sync_keys[(g_sync_key_head + g_sync_key_count++) % 256] = key;
      g_switch_pending = input_switch_key(key);
    }
  }
  input_unlock();
#endif
}

References KEY_PASTE, log_search_is_entering(), TUI_SYNC_KEY_CAPACITY, ui_controller_current_screen(), ui_controller_is_blocked(), UI_SCREEN_SYNC, and ui_sync_handle_key().

ui_input_prompt()

asciichat_error_t ui_input_prompt	(	const char *	prompt,
		char *	buffer,
		size_t	max_len,
		prompt_opts_t	opts )

Definition at line 767 of file tui/input.c.

                                                                                                        {
  if (buffer && max_len)
    buffer[0] = '\0';
  return ui_input_prompt_prefilled(prompt, buffer, max_len, opts);
}

References ui_input_prompt_prefilled().

ui_input_prompt_prefilled()

asciichat_error_t ui_input_prompt_prefilled	(	const char *	prompt,
		char *	buffer,
		size_t	max_len,
		prompt_opts_t	opts )

Editable prompt initialized with buffer contents.

Definition at line 746 of file tui/input.c.

                                                                                                                  {
  return input_prompt(prompt, buffer, max_len, opts, false, false);
}

Referenced by ui_input_prompt().

ui_input_read_key()

keyboard_key_t ui_input_read_key

(

ui_screen_t

screen

)

Input policy is separate from presentation. Covered controls are consumed and discarded.

Definition at line 353 of file tui/input.c.

                                                     {
  if (!input_initialize())
    return KEY_NONE;
  if (!input_ready()) {
    // Once recovery has an empty input queue, the next key is a fresh action.
    if (atomic_load(&g_discarding_covered_input) && !ui_controller_state().covered)
      atomic_store(&g_discarding_covered_input, false);
    return KEY_NONE;
  }
  mutex_lock(&g_input_mutex);
  ui_presentation_state_t state = ui_controller_state();
  // The previous event has now been dispatched by the session. Background
  // polling must not overtake a pending switch with the next shortcut.
  g_switch_pending = false;
  if (input_discard_covered(state.covered)) {
    input_unlock();
    return KEY_NONE;
  }
  if (state.screen == UI_SCREEN_HELP &&
      (ui_error_popup_visible() || keyboard_help_parent_screen() == UI_SCREEN_ERROR)) {
    keyboard_key_t key = keyboard_help_check_signal_cancel() ? KEY_ESCAPE : input_next_key();
    if (key == KEY_ESCAPE || key == KEY_QUESTION)
      keyboard_help_toggle_terminal(ui_controller_active_fd());
    if (key == KEY_PASTE)
      g_events.ready = false;
    input_unlock();
    return KEY_NONE;
  }
  if (state.screen == UI_SCREEN_ERROR && terminal_screen_logs_help_open()) {
    keyboard_key_t key = input_next_key();
    if (key != KEY_NONE)
      terminal_screen_logs_handle_key(key);
    if (key == KEY_PASTE)
      g_events.ready = false;
    input_unlock();
    return KEY_NONE;
  }
  if (state.screen == UI_SCREEN_ERROR) {
    keyboard_key_t key = input_next_key();
    if (key == KEY_QUESTION)
      keyboard_help_toggle_terminal(ui_controller_active_fd());
    else if (key != KEY_NONE && key != KEY_PASTE && key != 3) {
      ui_error_popup_key(key);
      /* The first q dismisses the modal error.  Only a later q, after the
       * final error is gone, is allowed to reach the session exit handler. */
      if (key == 'q' && !ui_error_popup_visible()) {
        input_unlock();
        return key;
      }
    }
    if (key == KEY_PASTE)
      g_events.ready = false;
    input_unlock();
    return key == 3 ? key : KEY_NONE;
  }
  if (state.screen == UI_SCREEN_NOTICE) {
    g_events.ready = false;
    g_sync_key_count = 0;
    keyboard_key_t notice_key = input_read_event();
    if (notice_key == KEY_PASTE)
      g_events.ready = false;
    bool first_use = ui_controller_first_use_key(notice_key);
    if (!first_use &&
        (notice_key == KEY_ESCAPE || notice_key == '\r' || notice_key == '\n' || notice_key == 'q' || notice_key == 3))
      ui_controller_remove(UI_SCREEN_NOTICE);
    input_unlock();
    return notice_key == 'q' || notice_key == 3 ? notice_key : KEY_NONE;
  }
  if (state.screen == UI_SCREEN_UPDATE && update_banner_is_overlay_open()) {
    keyboard_key_t update_key = input_read_event();
    if (update_key == '=' || update_key == KEY_0 || update_key == KEY_QUESTION || update_key == ']') {
      if (update_key != KEY_QUESTION)
        update_banner_toggle_overlay();
      if (update_key == KEY_QUESTION) {
        keyboard_help_toggle_terminal(ui_controller_active_fd());
      } else {
        update_key = input_common_key(update_key, UI_SCREEN_UPDATE);
        (void)ui_sync_handle_key(update_key);
      }
    } else if (update_key != KEY_NONE)
      (void)update_banner_handle_key(update_key);
    input_unlock();
    return KEY_NONE;
  }
  if (screen == UI_SCREEN_MEDIA && g_media_editor.active && state.screen == UI_SCREEN_PROMPT) {
    keyboard_key_t key = input_next_key();
    bool switch_screen = input_switch_key(key) && key != '=' && (g_media_editor.length == 0 || key == 15);
#ifndef NDEBUG
    switch_screen |= key == KEY_0 && g_media_editor.length == 0;
#endif
    if (switch_screen) {
      // Keep the old prompt on screen until its replacement is published.
      if (key != KEY_QUESTION)
        g_media_editor.active = false;
      if (key == KEY_0)
        key = ui_sync_handle_key(key);
      key = input_common_key(key, state.screen);
      g_switch_pending = input_switch_key(key);
      input_unlock();
      return key;
    }
    if (key == KEY_ESCAPE || key == 3 || ui_input_expired(g_media_editor.deadline)) {
      if (key == KEY_PASTE)
        g_events.ready = false;
      ascii_otel_ui_usage("media_input_prompt", ui_input_expired(g_media_editor.deadline) ? "timed_out" : "cancelled",
                          0);
      g_media_editor.active = false;
      ui_prompt_remove();
    } else if (key == '\r' || key == '\n') {
      g_media_editor.active = false;
      g_media_editor.submitted = true;
      ascii_otel_ui_usage("media_input_prompt", "submitted", 0);
      input_unlock();
      return KEY_MEDIA_SUBMIT;
    } else if (key != KEY_NONE) {
      if (key == KEY_PASTE)
        ascii_otel_ui_usage("media_input_prompt", "paste", 0);
      if (key == KEY_PASTE) {
        if (!g_events.invalid && utf8_is_valid(g_events.paste)) {
          media_playlist_t items = {0}, added = {0};
          bool valid = !g_media_editor.length || media_playlist_parse(g_media_editor.buffer, &items) == ASCIICHAT_OK;
          valid = valid && media_playlist_parse(g_events.paste, &added) == ASCIICHAT_OK;
          if (valid) {
            for (size_t i = 0; i < added.count && valid; ++i)
              valid = media_playlist_append(&items, added.paths[i], added.urls[i]) == ASCIICHAT_OK;
            char formatted[sizeof(g_media_editor.buffer)];
            valid = valid && media_playlist_format(&items, formatted, sizeof(formatted)) == ASCIICHAT_OK;
            if (valid) {
              memcpy(g_media_editor.buffer, formatted, strlen(formatted) + 1);
              g_media_editor.length = g_media_editor.cursor = strlen(formatted);
            }
          }
          if (valid)
            ascii_otel_ui_usage("media_input_prompt", "queue_changed", 0);
          CLEAR_ERRNO();
        }
        g_events.ready = false;
        g_media_editor.pasted = true;
      } else if (!(key == ' ' && g_media_editor.pasted && g_media_editor.cursor == g_media_editor.length)) {
        g_media_editor.pasted = false;
        ui_input_edit_key(g_media_editor.buffer, sizeof(g_media_editor.buffer), &g_media_editor.length,
                          &g_media_editor.cursor, key);
      }
      if (ui_prompt_present_kind("Open media: files or URLs\nDrop more files to queue; Enter plays; Esc cancels",
                                 g_media_editor.buffer, g_media_editor.cursor, false,
                                 UI_PROMPT_MEDIA_INPUT) != ASCIICHAT_OK) {
        g_media_editor.active = false;
        ui_prompt_remove();
        CLEAR_ERRNO();
      }
    }
    input_unlock();
    return KEY_NONE;
  }
  bool primary =
      screen == UI_SCREEN_MEDIA || screen == UI_SCREEN_SPLASH || screen == UI_SCREEN_STATUS || screen == UI_SCREEN_MDNS;
  bool server = GET_OPTION(detected_mode) == MODE_SERVER || GET_OPTION(detected_mode) == MODE_DISCOVERY_SERVICE ||
                GET_OPTION(detected_mode) == MODE_MCP_SERVER;
  bool server_owner = screen == UI_SCREEN_STATS && server && !ui_controller_screen_live(UI_SCREEN_STATUS);
  bool active = state.screen < 0 || state.screen == (int)screen ||
                ((primary || server_owner) && state.screen <= UI_SCREEN_SYNC && state.screen != UI_SCREEN_STATS);
  keyboard_key_t key = KEY_NONE;
  if (active) {
    if (g_sync_key_count) {
      key = g_sync_keys[g_sync_key_head];
      g_sync_key_head = (g_sync_key_head + 1) % 256;
      --g_sync_key_count;
    }
    if (key == KEY_NONE)
      key = state.screen == UI_SCREEN_HELP && keyboard_help_check_signal_cancel() ? KEY_QUESTION : input_read_event();
    if (key == KEY_F12) {
      // Synchronous prompts own their input, including function keys.
      // Opening the update checker here would suspend credential entry.
      if (screen != UI_SCREEN_PROMPT)
        update_banner_handle_key(key);
      key = KEY_NONE;
    }
    if (screen != UI_SCREEN_PROMPT) {
      key = input_common_key(key, state.screen);
      if (key != KEY_PASTE && !log_search_is_entering() &&
          !(screen == UI_SCREEN_MDNS && state.screen == UI_SCREEN_MDNS))
        key = ui_sync_handle_key(key);
    }
  }
  if (key == KEY_PASTE && log_search_is_entering()) {
    if (!g_events.invalid)
      (void)log_search_insert_text(g_events.paste);
    g_events.ready = false;
    key = KEY_NONE;
  }
  if (key == KEY_PASTE && screen != UI_SCREEN_MEDIA && screen != UI_SCREEN_PROMPT) {
    g_events.ready = false;
    key = KEY_NONE;
  }
  if (screen != UI_SCREEN_PROMPT && key != KEY_NONE && update_banner_handle_key(key))
    key = KEY_NONE;
  g_switch_pending |= input_switch_key(key);
  input_unlock();
  return key;
}

References ascii_otel_ui_usage(), ASCIICHAT_OK, CLEAR_ERRNO, GET_OPTION, KEY_0, KEY_ESCAPE, KEY_F12, KEY_MEDIA_SUBMIT, KEY_NONE, KEY_PASTE, KEY_QUESTION, keyboard_help_check_signal_cancel(), keyboard_help_parent_screen(), keyboard_help_toggle_terminal(), log_search_insert_text(), log_search_is_entering(), media_playlist_append(), media_playlist_format(), media_playlist_parse(), MODE_DISCOVERY_SERVICE, MODE_MCP_SERVER, MODE_SERVER, media_playlist_t::paths, terminal_screen_logs_handle_key(), terminal_screen_logs_help_open(), ui_controller_active_fd(), ui_controller_first_use_key(), ui_controller_remove(), ui_controller_screen_live(), ui_controller_state(), ui_error_popup_key(), ui_error_popup_visible(), ui_input_edit_key(), ui_input_expired(), ui_prompt_present_kind(), ui_prompt_remove(), UI_SCREEN_ERROR, UI_SCREEN_HELP, UI_SCREEN_MDNS, UI_SCREEN_MEDIA, UI_SCREEN_NOTICE, UI_SCREEN_PROMPT, UI_SCREEN_SPLASH, UI_SCREEN_STATS, UI_SCREEN_STATUS, UI_SCREEN_SYNC, UI_SCREEN_UPDATE, ui_sync_handle_key(), update_banner_handle_key(), update_banner_is_overlay_open(), update_banner_toggle_overlay(), utf8_is_valid(), and valid.

Referenced by display_poll_keyboard(), session_render_loop(), ui_input_wait_key(), and ui_status_display_interactive().

ui_input_shutdown()

void ui_input_shutdown

(

void

)

Definition at line 565 of file tui/input.c.

                             {
  if (!lifecycle_destroy_once(&g_input_lifecycle))
    return;
  mutex_destroy(&g_input_prompt_mutex);
  mutex_destroy(&g_input_mutex);
  NAMED_UNREGISTER(&g_input_lifecycle.state);
  lifecycle_destroy_commit(&g_input_lifecycle);
}

References NAMED_UNREGISTER.

Referenced by asciichat_shared_destroy().

ui_input_take_paste()

asciichat_error_t ui_input_take_paste	(	char *	buffer,
		size_t	capacity )

Copy a complete paste event. Invalid/oversized payloads fail without truncation.

Definition at line 266 of file tui/input.c.

                                                                     {
  if (!buffer || !capacity || !input_initialize())
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid paste buffer");
  mutex_lock(&g_input_mutex);
  asciichat_error_t result = ASCIICHAT_OK;
  if (g_events.invalid || g_events.length >= capacity || !utf8_is_valid(g_events.paste))
    result = SET_ERRNO(ERROR_INVALID_PARAM, "Paste media paths or URLs without terminal controls (maximum 8191 bytes)");
  else
    memcpy(buffer, g_events.paste, g_events.length + 1);
  g_events.length = 0;
  sodium_memzero(g_events.paste, sizeof(g_events.paste));
  g_events.ready = false;
  input_unlock();
  return result;
}

References ASCIICHAT_OK, ERROR_INVALID_PARAM, SET_ERRNO, and utf8_is_valid().

Referenced by session_handle_keyboard_input().

ui_input_timeout_report()

void ui_input_timeout_report	(	unsigned	seconds,
		const char *	consequence )

Definition at line 56 of file tui/input.c.

                                                                        {
  char message[TUI_INPUT_MESSAGE_BUFFER_SIZE];
  int length = snprintf(message, sizeof(message), "\nPrompt timed out after %u seconds; %s.\n", seconds, consequence);
  // This diagnostic must remain visible even while a background screen owns the terminal.
  if (length > 0)
    platform_write_all(STDERR_FILENO, message, (size_t)length < sizeof(message) ? (size_t)length : sizeof(message) - 1);
  SET_ERRNO(ERROR_PROMPT_TIMEOUT, "Prompt timed out after %u seconds: %s", seconds, consequence);
}

References ERROR_PROMPT_TIMEOUT, platform_write_all(), SET_ERRNO, and TUI_INPUT_MESSAGE_BUFFER_SIZE.

ui_input_wait_key()

keyboard_key_t ui_input_wait_key	(	ui_screen_t	screen,
		unsigned	timeout_ms )

Definition at line 554 of file tui/input.c.

                                                                          {
  uint64_t deadline = time_get_ns() + (uint64_t)timeout_ms * NS_PER_MS_INT;
  do {
    keyboard_key_t key = ui_input_read_key(screen);
    if (key != KEY_NONE || shutdown_is_requested())
      return key;
    platform_sleep_ns(NS_PER_MS_INT);
  } while (time_get_ns() < deadline);
  return KEY_NONE;
}

References KEY_NONE, NS_PER_MS_INT, shutdown_is_requested(), and ui_input_read_key().

Referenced by update_banner_show_prompt().