colorscheme.c File Reference

Color scheme management implementation and early initialization. More...

Go to the source code of this file.

Macros
#define	NUM_BUILTIN_SCHEMES   (sizeof(BUILTIN_SCHEMES) / sizeof(BUILTIN_SCHEMES[0]))

Functions
asciichat_error_t	colorscheme_init (void)
void	colorscheme_cleanup_compiled (compiled_color_scheme_t *compiled)
void	colorscheme_destroy (void)
const color_scheme_t *	colorscheme_get_active_scheme (void)
asciichat_error_t	colorscheme_set_active_scheme (const char *name)
asciichat_error_t	colorscheme_load_builtin (const char *name, color_scheme_t *scheme)
asciichat_error_t	colorscheme_load_from_file (const char *path, color_scheme_t *scheme)
asciichat_error_t	parse_hex_color (const char *hex, uint8_t *r, uint8_t *g, uint8_t *b)
void	rgb_to_truecolor_ansi (uint8_t r, uint8_t g, uint8_t b, char *buf, size_t size)
asciichat_error_t	colorscheme_compile_scheme (const color_scheme_t *scheme, terminal_color_mode_t mode, terminal_background_t background, compiled_color_scheme_t *compiled)
asciichat_error_t	colorscheme_export_scheme (const char *scheme_name, const char *file_path)
terminal_background_t	detect_terminal_background (void)
asciichat_error_t	options_colorscheme_init_early (int argc, const char *const argv[])
	Initialize color scheme early (before logging)

Variables
mutex_t	g_colorscheme_mutex = PTHREAD_MUTEX_INITIALIZER

Detailed Description

Color scheme management implementation and early initialization.

Implements color scheme selection, loading, and compilation for ascii-chat. Supports built-in themes, TOML configuration files, and early initialization before logging starts.

Definition in file colorscheme.c.

Macro Definition Documentation

NUM_BUILTIN_SCHEMES

#define NUM_BUILTIN_SCHEMES   (sizeof(BUILTIN_SCHEMES) / sizeof(BUILTIN_SCHEMES[0]))

Definition at line 247 of file colorscheme.c.

Function Documentation

colorscheme_cleanup_compiled()

void colorscheme_cleanup_compiled

(

compiled_color_scheme_t *

compiled

)

Definition at line 313 of file colorscheme.c.

                                                                     {
  if (!compiled) {
    return;
  }
 
  /* Free allocated color code strings */
  for (int i = 0; i < 8; i++) {
    char *str_16 = (char *)compiled->codes_16[i];
    char *str_256 = (char *)compiled->codes_256[i];
    char *str_truecolor = (char *)compiled->codes_truecolor[i];
    /* Only free non-NULL pointers - protects against uninitialized data */
    if (str_16 != NULL) {
      SAFE_FREE(str_16);
    }
    if (str_256 != NULL) {
      SAFE_FREE(str_256);
    }
    if (str_truecolor != NULL) {
      SAFE_FREE(str_truecolor);
    }
  }
  memset(compiled, 0, sizeof(compiled_color_scheme_t));
}

Referenced by colorscheme_compile_scheme(), and log_cleanup_colors().

colorscheme_compile_scheme()

asciichat_error_t colorscheme_compile_scheme	(	const color_scheme_t *	scheme,
		terminal_color_mode_t	mode,
		terminal_background_t	background,
		compiled_color_scheme_t *	compiled
	)

Definition at line 539 of file colorscheme.c.

                                                                                                                  {
  if (!scheme || !compiled) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "NULL scheme or compiled pointer");
  }
 
  /* Note: mode parameter reserved for future use */
  (void)mode;
 
  /* Free any previously compiled strings before recompiling */
  /* This prevents memory leaks when the color scheme is recompiled */
  /* Only cleanup if we've actually compiled before (codes_16[0] != NULL means already compiled) */
  if (compiled->codes_16[0] != NULL) {
    colorscheme_cleanup_compiled(compiled);
  } else {
  }
 
  /* Select color array based on background */
  const rgb_pixel_t *colors = (background == TERM_BACKGROUND_LIGHT && scheme->has_light_variant)
                                  ? scheme->log_colors_light
                                  : scheme->log_colors_dark;
  /* Helper: allocate and format a color code string */
  char temp_buf[128];
 
  /* Compile for 16-color mode */
  for (int i = 0; i < 8; i++) {
    if (i == 7) {
      /* RESET */
      SAFE_STRNCPY(temp_buf, "\x1b[0m", sizeof(temp_buf));
    } else {
      uint8_t color_idx = rgb_to_16color(colors[i].r, colors[i].g, colors[i].b);
      /* ANSI color codes: 30-37 for normal, 90-97 for bright */
      if (color_idx < 8) {
        safe_snprintf(temp_buf, sizeof(temp_buf), "\x1b[%dm", 30 + color_idx);
      } else {
        safe_snprintf(temp_buf, sizeof(temp_buf), "\x1b[%dm", 90 + (color_idx - 8));
      }
    }
    /* Allocate string with SAFE_MALLOC and copy */
    size_t len = strlen(temp_buf) + 1;
    char *allocated = SAFE_MALLOC(len, char *);
    if (!allocated) {
      return SET_ERRNO(ERROR_MEMORY, "Failed to allocate color code string");
    }
    memcpy(allocated, temp_buf, len);
    compiled->codes_16[i] = allocated;
  }
  /* Compile for 256-color mode */
  for (int i = 0; i < 8; i++) {
    if (i == 7) {
      SAFE_STRNCPY(temp_buf, "\x1b[0m", sizeof(temp_buf));
    } else {
      uint8_t color_idx = rgb_to_256color(colors[i].r, colors[i].g, colors[i].b);
      safe_snprintf(temp_buf, sizeof(temp_buf), "\x1b[38;5;%dm", color_idx);
    }
    /* Allocate string with SAFE_MALLOC and copy */
    size_t len = strlen(temp_buf) + 1;
    char *allocated = SAFE_MALLOC(len, char *);
    if (!allocated) {
      return SET_ERRNO(ERROR_MEMORY, "Failed to allocate color code string");
    }
    memcpy(allocated, temp_buf, len);
    compiled->codes_256[i] = allocated;
  }
 
  /* Compile for truecolor mode */
  for (int i = 0; i < 8; i++) {
    if (i == 7) {
      SAFE_STRNCPY(temp_buf, "\x1b[0m", sizeof(temp_buf));
    } else {
      rgb_to_truecolor_ansi(colors[i].r, colors[i].g, colors[i].b, temp_buf, sizeof(temp_buf));
    }
    /* Allocate string with SAFE_MALLOC and copy */
    size_t len = strlen(temp_buf) + 1;
    char *allocated = SAFE_MALLOC(len, char *);
    if (!allocated) {
      return SET_ERRNO(ERROR_MEMORY, "Failed to allocate color code string");
    }
    memcpy(allocated, temp_buf, len);
    compiled->codes_truecolor[i] = allocated;
  }
 
  return ASCIICHAT_OK;
}

References colorscheme_cleanup_compiled(), rgb_to_16color(), rgb_to_256color(), rgb_to_truecolor_ansi(), and safe_snprintf().

Referenced by log_init_colors(), and log_set_color_scheme().

colorscheme_destroy()

void colorscheme_destroy

(

void

)

Definition at line 337 of file colorscheme.c.

                               {
  if (!g_colorscheme_initialized) {
    return;
  }
 
  mutex_lock(&g_colorscheme_mutex);
  memset(&g_active_scheme, 0, sizeof(color_scheme_t));
  g_colorscheme_initialized = false;
  mutex_unlock(&g_colorscheme_mutex);
 
  /* NOTE: Do NOT call mutex_destroy() on native POSIX because the mutex is statically
   * initialized with PTHREAD_MUTEX_INITIALIZER. Destroying a statically-initialized
   * mutex is undefined behavior. On Windows and Emscripten, we must destroy the mutex
   * because it was explicitly initialized in colorscheme_init(). */
#if defined(_WIN32) || defined(__EMSCRIPTEN__)
  mutex_destroy(&g_colorscheme_mutex);
#endif
}

References g_colorscheme_mutex, and mutex_destroy().

Referenced by asciichat_shared_destroy().

colorscheme_export_scheme()

asciichat_error_t colorscheme_export_scheme	(	const char *	scheme_name,
		const char *	file_path
	)

Definition at line 628 of file colorscheme.c.

                                                                                            {
  if (!scheme_name) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Scheme name is NULL");
  }
 
  color_scheme_t scheme = {0};
  asciichat_error_t result = colorscheme_load_builtin(scheme_name, &scheme);
  if (result != ASCIICHAT_OK) {
    return result;
  }
 
  /* Generate TOML content */
  char toml_content[8192] = {0};
  size_t offset = 0;
 
  /* Scheme header section */
  offset += safe_snprintf(toml_content + offset, sizeof(toml_content) - offset,
                          "[scheme]\n"
                          "name = \"%s\"\n"
                          "description = \"%s\"\n\n",
                          scheme.name, scheme.description);
 
  /* Dark mode colors */
  const char *color_names[] = {"dev", "debug", "warn", "info", "error", "fatal", "grey", "reset"};
  offset += safe_snprintf(toml_content + offset, sizeof(toml_content) - offset, "[colors.dark]\n");
 
  for (int i = 0; i < 8; i++) {
    offset +=
        safe_snprintf(toml_content + offset, sizeof(toml_content) - offset, "%s = \"#%02X%02X%02X\"\n", color_names[i],
                      scheme.log_colors_dark[i].r, scheme.log_colors_dark[i].g, scheme.log_colors_dark[i].b);
  }
 
  /* Light mode colors if available */
  if (scheme.has_light_variant) {
    offset += safe_snprintf(toml_content + offset, sizeof(toml_content) - offset, "\n[colors.light]\n");
    for (int i = 0; i < 8; i++) {
      offset += safe_snprintf(toml_content + offset, sizeof(toml_content) - offset, "%s = \"#%02X%02X%02X\"\n",
                              color_names[i], scheme.log_colors_light[i].r, scheme.log_colors_light[i].g,
                              scheme.log_colors_light[i].b);
    }
  }
 
  /* Write to file or stdout */
  if (file_path) {
    FILE *fp = platform_fopen(file_path, "w");
    if (!fp) {
      return SET_ERRNO_SYS(ERROR_FILE_OPERATION, "Cannot open %s for writing", file_path);
    }
    if (fputs(toml_content, fp) < 0) {
      fclose(fp);
      return SET_ERRNO_SYS(ERROR_FILE_OPERATION, "Failed to write to %s", file_path);
    }
    fclose(fp);
  } else {
    /* Write to stdout */
    if (fputs(toml_content, stdout) < 0) {
      return SET_ERRNO_SYS(ERROR_FILE_OPERATION, "Failed to write to stdout");
    }
    /* Flush to ensure piped output is written immediately */
    (void)fflush(stdout);
  }
 
  return ASCIICHAT_OK;
}

References colorscheme_load_builtin(), file_path, platform_fopen(), and safe_snprintf().

colorscheme_get_active_scheme()

const color_scheme_t * colorscheme_get_active_scheme

(

void

)

Definition at line 360 of file colorscheme.c.

                                                          {
  if (!g_colorscheme_initialized) {
    /* Lazy initialization of color system */
    colorscheme_init();
  }
 
  return &g_active_scheme;
}

References colorscheme_init().

Referenced by log_init_colors(), and options_init().

colorscheme_init()

asciichat_error_t colorscheme_init

(

void

)

Definition at line 278 of file colorscheme.c.

                                         {
  if (g_colorscheme_initialized) {
    return ASCIICHAT_OK;
  }
 
  /* NOTE: Mutex is already statically initialized on POSIX with PTHREAD_MUTEX_INITIALIZER.
   * On Windows and Emscripten/WASM, we initialize it here. Do NOT call mutex_init() on native POSIX
   * because double-initialization of pthread_mutex_t causes undefined behavior and deadlocks.
   * Emscripten with pthreads requires explicit initialization because PTHREAD_MUTEX_INITIALIZER
   * doesn't work correctly in threaded WASM builds. */
#if defined(_WIN32) || defined(__EMSCRIPTEN__)
  static bool mutex_initialized = false;
  if (!mutex_initialized) {
#ifdef __EMSCRIPTEN__
#else
#endif
    mutex_init(&g_colorscheme_mutex);
    mutex_initialized = true;
  } else {
  }
#else
#endif
 
  /* Load default scheme */
  const color_scheme_t *pastel = find_builtin_scheme("pastel");
  if (!pastel) {
    return SET_ERRNO(ERROR_CONFIG, "Failed to load default pastel scheme");
  }
 
  memcpy(&g_active_scheme, pastel, sizeof(color_scheme_t));
  g_colorscheme_initialized = true;
 
  return ASCIICHAT_OK;
}

References g_colorscheme_mutex, and mutex_init().

Referenced by colorscheme_get_active_scheme(), colorscheme_set_active_scheme(), and options_colorscheme_init_early().

colorscheme_load_builtin()

asciichat_error_t colorscheme_load_builtin	(	const char *	name,
		color_scheme_t *	scheme
	)

Definition at line 404 of file colorscheme.c.

                                                                                     {
  if (!name || !scheme) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "NULL name or scheme pointer");
  }
 
  const color_scheme_t *builtin = find_builtin_scheme(name);
  if (!builtin) {
    return SET_ERRNO(ERROR_CONFIG, "Unknown built-in color scheme: %s", name);
  }
 
  memcpy(scheme, builtin, sizeof(color_scheme_t));
  return ASCIICHAT_OK;
}

Referenced by colorscheme_export_scheme(), and main().

colorscheme_load_from_file()

asciichat_error_t colorscheme_load_from_file	(	const char *	path,
		color_scheme_t *	scheme
	)

Definition at line 418 of file colorscheme.c.

                                                                                       {
  if (!path || !scheme) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "NULL path or scheme pointer");
  }
 
  /* Check if file exists and is readable */
  struct stat sb;
  if (stat(path, &sb) != 0 || !S_ISREG(sb.st_mode)) {
    return SET_ERRNO(ERROR_FILE_NOT_FOUND, "Color scheme file not found or not readable: %s", path);
  }
 
  /* Parse TOML file */
  toml_result_t result = toml_parse_file_ex(path);
  if (!result.ok) {
    toml_free(result);
    return SET_ERRNO(ERROR_CONFIG, "Failed to parse color scheme file '%s': %s", path, result.errmsg);
  }
 
  /* Extract scheme information */
  memset(scheme, 0, sizeof(color_scheme_t));
 
  /* Get scheme section */
  toml_datum_t scheme_section = toml_get(result.toptab, "scheme");
  if (scheme_section.type == TOML_TABLE) {
    /* Get scheme name */
    toml_datum_t name_datum = toml_get(scheme_section, "name");
    if (name_datum.type == TOML_STRING) {
      SAFE_STRNCPY(scheme->name, name_datum.u.s, sizeof(scheme->name));
    }
 
    /* Get scheme description */
    toml_datum_t desc_datum = toml_get(scheme_section, "description");
    if (desc_datum.type == TOML_STRING) {
      SAFE_STRNCPY(scheme->description, desc_datum.u.s, sizeof(scheme->description));
    }
  }
 
  /* Get colors section */
  toml_datum_t colors_section = toml_get(result.toptab, "colors");
  if (colors_section.type == TOML_TABLE) {
    /* Parse dark mode colors */
    toml_datum_t dark_section = toml_get(colors_section, "dark");
    if (dark_section.type == TOML_TABLE) {
      const char *color_names[] = {"dev", "debug", "warn", "info", "error", "fatal", "grey", "reset"};
      for (int i = 0; i < 8; i++) {
        toml_datum_t color_value = toml_get(dark_section, color_names[i]);
        if (color_value.type == TOML_STRING) {
          parse_hex_color(color_value.u.s, &scheme->log_colors_dark[i].r, &scheme->log_colors_dark[i].g,
                          &scheme->log_colors_dark[i].b);
        }
      }
    }
 
    /* Parse light mode colors (optional) */
    toml_datum_t light_section = toml_get(colors_section, "light");
    if (light_section.type == TOML_TABLE) {
      scheme->has_light_variant = true;
      const char *color_names[] = {"dev", "debug", "warn", "info", "error", "fatal", "grey", "reset"};
      for (int i = 0; i < 8; i++) {
        toml_datum_t color_value = toml_get(light_section, color_names[i]);
        if (color_value.type == TOML_STRING) {
          parse_hex_color(color_value.u.s, &scheme->log_colors_light[i].r, &scheme->log_colors_light[i].g,
                          &scheme->log_colors_light[i].b);
        }
      }
    }
  }
 
  scheme->is_builtin = false;
  SAFE_STRNCPY(scheme->source_file, path, sizeof(scheme->source_file));
 
  toml_free(result);
  return ASCIICHAT_OK;
}

References parse_hex_color().

Referenced by colorscheme_set_active_scheme().

colorscheme_set_active_scheme()

asciichat_error_t colorscheme_set_active_scheme

(

const char *

name

)

Definition at line 369 of file colorscheme.c.

                                                                  {
  if (!name) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Scheme name is NULL");
  }
 
  /* Ensure color system is initialized */
  if (!g_colorscheme_initialized) {
    colorscheme_init();
  }
 
  color_scheme_t scheme = {0};
  asciichat_error_t result = ASCIICHAT_OK;
 
  /* Try loading as built-in scheme first */
  const color_scheme_t *builtin = find_builtin_scheme(name);
  if (builtin) {
    memcpy(&scheme, builtin, sizeof(color_scheme_t));
  } else if (strchr(name, '/') || strchr(name, '.')) {
    /* Try loading as file path if it contains / or . */
    result = colorscheme_load_from_file(name, &scheme);
    if (result != ASCIICHAT_OK) {
      return result;
    }
  } else {
    return SET_ERRNO(ERROR_CONFIG, "Unknown color scheme: %s (not a built-in scheme or valid file path)", name);
  }
 
  mutex_lock(&g_colorscheme_mutex);
  memcpy(&g_active_scheme, &scheme, sizeof(color_scheme_t));
  mutex_unlock(&g_colorscheme_mutex);
 
  log_debug("Switched to color scheme: %s", name);
  return ASCIICHAT_OK;
}

References colorscheme_init(), colorscheme_load_from_file(), and g_colorscheme_mutex.

Referenced by options_colorscheme_init_early(), and options_init().

detect_terminal_background()

terminal_background_t detect_terminal_background

(

void

)

Definition at line 697 of file colorscheme.c.

                                                       {
  /* Method 1: Check environment variable override (highest priority) */
  const char *term_bg = SAFE_GETENV("TERM_BACKGROUND");
  if (term_bg) {
    if (platform_strcasecmp(term_bg, "light") == 0) {
      return TERM_BACKGROUND_LIGHT;
    }
    if (platform_strcasecmp(term_bg, "dark") == 0) {
      return TERM_BACKGROUND_DARK;
    }
  }
 
  /* Method 2: Use OSC 11 query with luminance calculation + environment fallbacks
   * This automatically queries the terminal via OSC 11, calculates luminance,
   * and falls back to $COLORFGBG, $TERM_PROGRAM, etc. if query fails */
  bool is_dark = terminal_has_dark_background();
  return is_dark ? TERM_BACKGROUND_DARK : TERM_BACKGROUND_LIGHT;
}

References platform_strcasecmp(), and terminal_has_dark_background().

Referenced by log_init_colors(), and log_set_color_scheme().

options_colorscheme_init_early()

asciichat_error_t options_colorscheme_init_early	(	int	argc,
		const char *const	argv[]
	)

Initialize color scheme early (before logging)

Parameters

argc	Argument count
argv	Argument array

Returns

ASCIICHAT_OK on success, error code on failure (non-fatal)

This function is called from main() BEFORE log_init() to apply color scheme to logging before any log messages are printed.

Priority order:

1. –color-scheme CLI argument (highest priority)
2. ~/.config/ascii-chat/colors.toml config file
3. Built-in "pastel" default scheme (lowest priority)

Definition at line 793 of file colorscheme.c.

                                                                                     {
  /* Initialize the color system with defaults */
  asciichat_error_t result = colorscheme_init();
  if (result != ASCIICHAT_OK) {
    /* Non-fatal: use built-in defaults */
    return ASCIICHAT_OK;
  }
 
  /* Step 1: Try to load from config file (~/.config/ascii-chat/colors.toml) */
  color_scheme_t config_scheme = {0};
  asciichat_error_t config_result = load_config_color_scheme(&config_scheme);
  if (config_result == ASCIICHAT_OK) {
    /* Config file loaded successfully, apply it */
    colorscheme_set_active_scheme(config_scheme.name);
  }
 
  /* Step 2: CLI --color-scheme overrides config file */
  const char *cli_scheme = find_cli_color_scheme(argc, argv);
  if (cli_scheme) {
    asciichat_error_t cli_result = colorscheme_set_active_scheme(cli_scheme);
    if (cli_result != ASCIICHAT_OK) {
      /* Invalid scheme name from CLI, continue with current scheme */
      return cli_result;
    }
  }
 
  return ASCIICHAT_OK;
}

References colorscheme_init(), and colorscheme_set_active_scheme().

Referenced by main().

parse_hex_color()

asciichat_error_t parse_hex_color	(	const char *	hex,
		uint8_t *	r,
		uint8_t *	g,
		uint8_t *	b
	)

Definition at line 497 of file colorscheme.c.

                                                                                       {
  if (!hex || !r || !g || !b) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "NULL parameter");
  }
 
  /* Skip '#' prefix if present */
  if (hex[0] == '#') {
    hex++;
  }
 
  /* Validate hex string length */
  if (strlen(hex) != 6) {
    return SET_ERRNO(ERROR_CONFIG, "Invalid hex color (must be #RRGGBB): %s", hex);
  }
 
  /* Parse hex digits */
  unsigned int rgb = 0;
  if (SAFE_SSCANF(hex, "%6x", &rgb) != 1) {
    return SET_ERRNO(ERROR_CONFIG, "Invalid hex color format: %s", hex);
  }
 
  *r = (rgb >> 16) & 0xFF;
  *g = (rgb >> 8) & 0xFF;
  *b = rgb & 0xFF;
 
  return ASCIICHAT_OK;
}

Referenced by colorscheme_load_from_file().

rgb_to_truecolor_ansi()

void rgb_to_truecolor_ansi	(	uint8_t	r,
		uint8_t	g,
		uint8_t	b,
		char *	buf,
		size_t	size
	)

Definition at line 529 of file colorscheme.c.

                                                                                    {
  if (!buf || size < 20)
    return;
  safe_snprintf(buf, size, "\x1b[38;2;%d;%d;%dm", r, g, b);
}

References safe_snprintf().

Referenced by colorscheme_compile_scheme().

Variable Documentation

g_colorscheme_mutex

mutex_t g_colorscheme_mutex = PTHREAD_MUTEX_INITIALIZER

Definition at line 38 of file colorscheme.c.

Referenced by colorscheme_destroy(), colorscheme_init(), colorscheme_set_active_scheme(), log_init_colors(), and log_set_color_scheme().