splash.c File Reference

Intro and status screen display implementation with animated rainbow effects. More...

Go to the source code of this file.

Data Structures
struct	splash_header_ctx_t
	Context data for splash header rendering. More...

Macros
#define	ASCII_LOGO_LINES   7
#define	ASCII_LOGO_WIDTH   36
#define	RAINBOW_COLOR_COUNT   7

Functions
bool	splash_should_display (bool is_intro)
int	splash_intro_start (session_display_ctx_t *ctx)
int	splash_intro_done (void)
int	splash_display_status (int mode)
void	splash_set_update_notification (const char *notification)

Detailed Description

Intro and status screen display implementation with animated rainbow effects.

Implements splash screen functionality including:

• TTY detection with stdin/stdout checks
• Animated rainbow color generation and cycling
• UTF-8 box drawing character support with ASCII fallback
• Non-blocking animation that runs while app initializes
• Clean integration with main frame rendering

Author

Zachary Fogg me@zf.nosp@m.o.gg

Date

February 2026

Definition in file splash.c.

Macro Definition Documentation

ASCII_LOGO_LINES

#define ASCII_LOGO_LINES   7

Definition at line 46 of file splash.c.

ASCII_LOGO_WIDTH

#define ASCII_LOGO_WIDTH   36

Definition at line 47 of file splash.c.

RAINBOW_COLOR_COUNT

#define RAINBOW_COLOR_COUNT   7

Definition at line 62 of file splash.c.

Function Documentation

splash_display_status()

int splash_display_status

(

int

mode

)

Definition at line 546 of file splash.c.

                                    {
  // Pre-checks
  if (!splash_should_display(false)) {
    return 0;
  }
 
  // Check mode validity
  if (mode != 0 && mode != 3) { // MODE_SERVER=0, MODE_DISCOVERY_SERVICE=3
    log_error("Status screen only for server/discovery modes");
    return 1; // ERROR
  }
 
  // Check terminal size
  int width = GET_OPTION(width);
  int height = GET_OPTION(height);
  if (width < 50 || height < 15) {
    log_debug("Terminal too small for status screen");
    return 0;
  }
 
  // Get terminal capabilities for UTF-8
  bool has_utf8 = (GET_OPTION(force_utf8) >= 0);
  (void)has_utf8; // Suppress unused warning
 
  // Build and display status box
  terminal_clear_screen();
 
  char buffer[4096] = {0};
  snprintf(buffer, sizeof(buffer), "\n");
 
  if (mode == 0) {
    // Server mode
    snprintf(buffer + strlen(buffer), sizeof(buffer) - strlen(buffer), "  Server Status\n");
    snprintf(buffer + strlen(buffer), sizeof(buffer) - strlen(buffer), "  Address: %s:%d\n", GET_OPTION(address),
             GET_OPTION(port));
    snprintf(buffer + strlen(buffer), sizeof(buffer) - strlen(buffer), "  Max clients: %d\n", GET_OPTION(max_clients));
    snprintf(buffer + strlen(buffer), sizeof(buffer) - strlen(buffer), "  Encryption: %s\n",
             GET_OPTION(no_encrypt) ? "Disabled" : "Enabled");
  } else if (mode == 3) {
    // Discovery service mode
    snprintf(buffer + strlen(buffer), sizeof(buffer) - strlen(buffer), "  Discovery Service\n");
    snprintf(buffer + strlen(buffer), sizeof(buffer) - strlen(buffer), "  Address: %s:%d\n", GET_OPTION(address),
             GET_OPTION(discovery_port));
  }
 
  // Add update notification if available
  static bool mutex_initialized_for_status = false;
  if (!mutex_initialized_for_status) {
    mutex_init(&g_update_notification_mutex);
    mutex_initialized_for_status = true;
  }
  mutex_lock(&g_update_notification_mutex);
  if (g_update_notification[0] != '\0') {
    snprintf(buffer + strlen(buffer), sizeof(buffer) - strlen(buffer), "\n  %s\n",
             colored_string(LOG_COLOR_WARN, g_update_notification));
  }
  mutex_unlock(&g_update_notification_mutex);
 
  snprintf(buffer + strlen(buffer), sizeof(buffer) - strlen(buffer), "\n");
 
  printf("%s", buffer);
  fflush(stdout);
 
  return 0; // ASCIICHAT_OK
}

References colored_string(), mutex_init(), and splash_should_display().

splash_intro_done()

int splash_intro_done

(

void

)

Definition at line 526 of file splash.c.

                            {
  // Signal animation thread to stop
  atomic_store(&g_splash_state.should_stop, true);
 
  // Wait for animation thread to finish
  if (atomic_load(&g_splash_state.is_running)) {
    asciichat_thread_join(&g_splash_state.anim_thread, NULL);
  }
 
  atomic_store(&g_splash_state.is_running, false);
 
  // Don't clear screen here - first frame will do it
  // Clearing here can cause a brief scroll artifact during transition
 
  // NOTE: Do NOT cleanup session_log_buffer here - it may be used by status screen
  // Status screen will call session_log_buffer_destroy() when appropriate
 
  return 0; // ASCIICHAT_OK
}

References asciichat_thread_join().

Referenced by display_disable_logging_for_first_frame(), and session_client_like_run().

splash_intro_start()

int splash_intro_start

(

session_display_ctx_t *

ctx

)

Definition at line 482 of file splash.c.

                                                   {
  (void)ctx; // Parameter not used currently
 
  // Pre-checks
  if (!splash_should_display(true)) {
    return 0; // ASCIICHAT_OK equivalent
  }
 
  // Don't initialize log buffer in non-interactive mode - logs go directly to stdout/stderr
  if (!terminal_is_interactive()) {
    return 0;
  }
 
  // Check terminal size
  int width = GET_OPTION(width);
  int height = GET_OPTION(height);
  if (width < 50 || height < 20) {
    return 0;
  }
 
  // Initialize log buffer for capturing logs during animation
  if (!session_log_buffer_init()) {
    log_warn("Failed to initialize splash log buffer");
    return 0;
  }
 
  // Clear screen
  terminal_clear_screen();
  fflush(stdout);
 
  // Set running flag
  atomic_store(&g_splash_state.is_running, true);
  atomic_store(&g_splash_state.should_stop, false);
  g_splash_state.frame = 0;
 
  // Start animation thread
  if (asciichat_thread_create(&g_splash_state.anim_thread, splash_animation_thread, NULL) != ASCIICHAT_OK) {
    log_warn("Failed to create splash animation thread");
    return 0;
  }
 
  return 0; // ASCIICHAT_OK
}

References asciichat_thread_create(), session_log_buffer_init(), splash_should_display(), and terminal_is_interactive().

Referenced by session_client_like_run().

splash_set_update_notification()

void splash_set_update_notification

(

const char *

notification

)

Definition at line 612 of file splash.c.

                                                              {
  static bool mutex_initialized = false;
  if (!mutex_initialized) {
    mutex_init(&g_update_notification_mutex);
    mutex_initialized = true;
  }
 
  mutex_lock(&g_update_notification_mutex);
 
  if (!notification || notification[0] == '\0') {
    g_update_notification[0] = '\0';
    log_debug("Cleared update notification for splash/status screens");
  } else {
    SAFE_STRNCPY(g_update_notification, notification, sizeof(g_update_notification));
    log_debug("Set update notification for splash/status screens: %s", notification);
  }
 
  mutex_unlock(&g_update_notification_mutex);
}

References mutex_init().

Referenced by main().

splash_should_display()

bool splash_should_display

(

bool

is_intro

)

Definition at line 372 of file splash.c.

                                          {
  // Check option flags (display splash if enabled, regardless of TTY for testing)
  if (is_intro) {
    // Allow splash in snapshot mode if loading from URL/file (has loading time)
    // Skip splash only for quick webcam snapshots
    bool is_snapshot = GET_OPTION(snapshot_mode);
    bool has_media = (GET_OPTION(media_url) && strlen(GET_OPTION(media_url)) > 0) ||
                     (GET_OPTION(media_file) && strlen(GET_OPTION(media_file)) > 0);
 
    // Show splash if:
    // 1. Not in snapshot mode, OR
    // 2. In snapshot mode but loading from URL/file (needs splash during load)
    return GET_OPTION(splash) && (!is_snapshot || has_media);
  } else {
    return GET_OPTION(status_screen);
  }
}

Referenced by splash_display_status(), and splash_intro_start().