colorscheme.h File Reference

Go to the source code of this file.

Data Structures
struct	color_scheme_t
	Color scheme definition. More...
struct	compiled_color_scheme_t
	Compiled ANSI escape codes for a color scheme. More...

Typedefs
typedef struct color_scheme_t	color_scheme_t
	Color scheme definition.

Enumerations
enum	terminal_background_t { TERM_BACKGROUND_UNKNOWN = 0 , TERM_BACKGROUND_LIGHT = 1 , TERM_BACKGROUND_DARK = 2 }
	Terminal theme detection result. More...

Functions
asciichat_error_t	colorscheme_init (void)
	Initialize the color system.
void	colorscheme_destroy (void)
	Shutdown the color system.
const color_scheme_t *	colorscheme_get_active_scheme (void)
	Get currently active color scheme.
asciichat_error_t	colorscheme_set_active_scheme (const char *name)
	Set the active color scheme.
asciichat_error_t	colorscheme_load_builtin (const char *name, color_scheme_t *scheme)
	Load a built-in color scheme.
asciichat_error_t	colorscheme_load_from_file (const char *path, color_scheme_t *scheme)
	Load a color scheme from a TOML file.
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)
	Compile a color scheme to ANSI codes.
void	colorscheme_cleanup_compiled (compiled_color_scheme_t *compiled)
	Clean up allocated strings in a compiled color scheme.
asciichat_error_t	colorscheme_export_scheme (const char *scheme_name, const char *file_path)
	Export a color scheme to TOML format.
asciichat_error_t	parse_hex_color (const char *hex, uint8_t *r, uint8_t *g, uint8_t *b)
	Parse a hex color string.
void	rgb_to_truecolor_ansi (uint8_t r, uint8_t g, uint8_t b, char *buf, size_t size)
	Generate truecolor ANSI escape code.
terminal_background_t	detect_terminal_background (void)
	Detect terminal background (light or dark)
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
	Shared mutex for color scheme compilation.

Typedef Documentation

color_scheme_t

typedef struct color_scheme_t color_scheme_t

Color scheme definition.

Defines a color scheme with RGB colors for logging levels. Supports both dark and light mode variants.

Enumeration Type Documentation

terminal_background_t

enum terminal_background_t

Terminal theme detection result.

Represents the detected or selected terminal theme (color background preference). Used to choose appropriate color schemes and contrast levels.

Enumerator
TERM_BACKGROUND_UNKNOWN	Theme not detected or auto-detect disabled
TERM_BACKGROUND_LIGHT	Light theme: light/white background, use dark text colors
TERM_BACKGROUND_DARK	Dark theme: dark/black background, use light text colors

Definition at line 50 of file colorscheme.h.

             {
  TERM_BACKGROUND_UNKNOWN = 0, 
  TERM_BACKGROUND_LIGHT = 1,   
  TERM_BACKGROUND_DARK = 2     
} terminal_background_t;

Function Documentation

colorscheme_cleanup_compiled()

void colorscheme_cleanup_compiled

(

compiled_color_scheme_t *

compiled

)

Clean up allocated strings in a compiled color scheme.

Parameters

compiled

Compiled color scheme to clean (NULL-safe)

Frees all allocated color code strings and zeros the structure.

Definition at line 316 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));
}

References compiled_color_scheme_t::codes_16, compiled_color_scheme_t::codes_256, compiled_color_scheme_t::codes_truecolor, and SAFE_FREE.

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
	)

Compile a color scheme to ANSI codes.

Parameters

scheme	Source scheme (must not be NULL)
mode	Terminal color mode (16, 256, or truecolor)
background	Terminal background (light or dark)
compiled	Output compiled codes (must not be NULL)

Returns

ASCIICHAT_OK on success, error code on failure

Compiles RGB colors to ANSI escape codes for the specified terminal mode and background. Applies background-appropriate color variant (light/dark).

Definition at line 545 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 ASCIICHAT_OK, compiled_color_scheme_t::codes_16, compiled_color_scheme_t::codes_256, compiled_color_scheme_t::codes_truecolor, colorscheme_cleanup_compiled(), ERROR_INVALID_PARAM, ERROR_MEMORY, color_scheme_t::has_light_variant, color_scheme_t::log_colors_dark, color_scheme_t::log_colors_light, rgb_to_16color(), rgb_to_256color(), rgb_to_truecolor_ansi(), SAFE_MALLOC, safe_snprintf(), SAFE_STRNCPY, SET_ERRNO, and TERM_BACKGROUND_LIGHT.

Referenced by log_init_colors(), and log_set_color_scheme().

colorscheme_destroy()

void colorscheme_destroy

(

void

)

Shutdown the color system.

Frees all allocated resources. Call at program shutdown.

Definition at line 340 of file colorscheme.c.

                               {
  if (!lifecycle_is_initialized(&g_colorscheme_lifecycle)) {
    return;
  }
 
  mutex_lock(&g_colorscheme_mutex);
  memset(&g_active_scheme, 0, sizeof(color_scheme_t));
 
  /* Mark as uninitialized */
  lifecycle_shutdown(&g_colorscheme_lifecycle);
 
  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, lifecycle_is_initialized(), lifecycle_shutdown(), mutex_destroy(), mutex_lock, and mutex_unlock.

Referenced by asciichat_shared_destroy().

colorscheme_export_scheme()

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

Export a color scheme to TOML format.

Parameters

scheme_name	Name of scheme to export
file_path	Output file path (NULL = stdout)

Returns

ASCIICHAT_OK on success, error code on failure

Exports a color scheme to TOML format. If file_path is NULL, writes to stdout.

Definition at line 634 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_stream", 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 ASCIICHAT_OK, rgb_pixel_t::b, colorscheme_load_builtin(), color_scheme_t::description, ERROR_FILE_OPERATION, ERROR_INVALID_PARAM, file_path, rgb_pixel_t::g, color_scheme_t::has_light_variant, color_scheme_t::log_colors_dark, color_scheme_t::log_colors_light, color_scheme_t::name, platform_fopen(), rgb_pixel_t::r, safe_snprintf(), SET_ERRNO, and SET_ERRNO_SYS.

colorscheme_get_active_scheme()

const color_scheme_t * colorscheme_get_active_scheme

(

void

)

Get currently active color scheme.

Returns

Pointer to active color scheme (must not be freed)

Returns the currently active color scheme. Default is "pastel" if not set.

Definition at line 366 of file colorscheme.c.

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

References colorscheme_init(), and lifecycle_is_initialized().

Referenced by log_init_colors(), and options_init().

colorscheme_init()

asciichat_error_t colorscheme_init

(

void

)

Initialize the color system.

Returns

ASCIICHAT_OK on success, error code on failure

Must be called once at program startup before using any color functions.

Definition at line 279 of file colorscheme.c.

                                         {
  if (lifecycle_is_initialized(&g_colorscheme_lifecycle)) {
    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, "colorscheme");
    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));
 
  /* Mark as initialized */
  lifecycle_init(&g_colorscheme_lifecycle, "colorscheme");
 
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, ERROR_CONFIG, g_colorscheme_mutex, lifecycle_init(), lifecycle_is_initialized(), mutex_init(), and SET_ERRNO.

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
	)

Load a built-in color scheme.

Parameters

name	Scheme name
scheme	Pointer to store loaded scheme

Returns

ASCIICHAT_OK on success, error code if not found

Loads a built-in color scheme by name. "default" is aliased to "pastel".

Definition at line 410 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;
}

References ASCIICHAT_OK, ERROR_CONFIG, ERROR_INVALID_PARAM, and SET_ERRNO.

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
	)

Load a color scheme from a TOML file.

Parameters

path	Path to TOML file
scheme	Pointer to store loaded scheme

Returns

ASCIICHAT_OK on success, error code on failure

Loads a color scheme from a TOML configuration file. See docs/colors.toml for format specification.

Definition at line 424 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 ASCIICHAT_OK, rgb_pixel_t::b, color_scheme_t::description, ERROR_CONFIG, ERROR_FILE_NOT_FOUND, ERROR_INVALID_PARAM, rgb_pixel_t::g, color_scheme_t::has_light_variant, color_scheme_t::is_builtin, color_scheme_t::log_colors_dark, color_scheme_t::log_colors_light, color_scheme_t::name, parse_hex_color(), rgb_pixel_t::r, SAFE_STRNCPY, SET_ERRNO, and color_scheme_t::source_file.

Referenced by colorscheme_set_active_scheme().

colorscheme_set_active_scheme()

asciichat_error_t colorscheme_set_active_scheme

(

const char *

name

)

Set the active color scheme.

Parameters

name	Scheme name (e.g., "pastel", "nord", "solarized-dark")

Returns

ASCIICHAT_OK on success, error code if scheme not found

Changes the active color scheme. Scheme must be either built-in or previously loaded from a TOML file.

Definition at line 375 of file colorscheme.c.

                                                                  {
  if (!name) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Scheme name is NULL");
  }
 
  /* Ensure color system is initialized */
  if (!lifecycle_is_initialized(&g_colorscheme_lifecycle)) {
    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 ASCIICHAT_OK, colorscheme_init(), colorscheme_load_from_file(), ERROR_CONFIG, ERROR_INVALID_PARAM, g_colorscheme_mutex, lifecycle_is_initialized(), log_debug, mutex_lock, mutex_unlock, and SET_ERRNO.

Referenced by options_colorscheme_init_early(), and options_init().

detect_terminal_background()

terminal_background_t detect_terminal_background

(

void

)

Detect terminal background (light or dark)

Returns

Detected terminal background

Uses multiple methods to detect terminal background:

1. TERM_BACKGROUND environment variable
2. COLORFGBG environment variable
3. OSC 11 terminal query (if supported)
4. Defaults to DARK

Detect terminal background (light or dark)

Determines the terminal's color background theme to adapt color schemes accordingly. The detection uses a priority-based approach:

1. Environment variable override (TERM_BACKGROUND="light" or "dark")
2. Automatic detection via terminal_has_dark_background():
   • OSC 11 escape query with luminance calculation (modern terminals)
   • Environment variables and terminal type hints (fallback)

Returns

The detected theme: TERM_BACKGROUND_LIGHT or TERM_BACKGROUND_DARK

Definition at line 715 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 terminal_has_dark_background() for automatic theme detection
   * This checks OSC 11 background color, environment variables, and terminal type */
  bool is_dark = terminal_has_dark_background();
  return is_dark ? TERM_BACKGROUND_DARK : TERM_BACKGROUND_LIGHT;
}

References platform_strcasecmp(), SAFE_GETENV, TERM_BACKGROUND_DARK, TERM_BACKGROUND_LIGHT, 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	Command-line argument count
argv	Command-line arguments

Returns

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

Called from main() BEFORE log_init() to apply color scheme to logging. Scans for –color-scheme and loads ~/.config/ascii-chat/colors.toml.

Priority: –color-scheme CLI > colors.toml > built-in default

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 810 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 ASCIICHAT_OK, colorscheme_init(), colorscheme_set_active_scheme(), and color_scheme_t::name.

Referenced by main().

parse_hex_color()

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

Parse a hex color string.

Parameters

hex	Hex color string (e.g., "#FF0000" or "FF0000")
r	Pointer to store red channel
g	Pointer to store green channel
b	Pointer to store blue channel

Returns

ASCIICHAT_OK on success, error code on failure

Parses hex color strings in #RRGGBB or RRGGBB format.

Definition at line 503 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;
}

References ASCIICHAT_OK, ERROR_CONFIG, ERROR_INVALID_PARAM, SAFE_SSCANF, and SET_ERRNO.

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
	)

Generate truecolor ANSI escape code.

Parameters

r	Red channel (0-255)
g	Green channel (0-255)
b	Blue channel (0-255)
buf	Output buffer for escape code
size	Buffer size (minimum 20 bytes)

Generates ANSI truecolor escape code: \x1b[38;2;R;G;Bm

Definition at line 535 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

extern

Shared mutex for color scheme compilation.

Used by lib/options/colorscheme.c and lib/log/logging.c to synchronize color scheme compilation. Defined in colorscheme.c and declared here for use by logging.c.

Definition at line 39 of file colorscheme.c.

{.impl = PTHREAD_MUTEX_INITIALIZER, .name = NULL}; /* POSIX pthread_mutex_t */

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