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...
struct	colorscheme_palette_t

Macros
#define	OPTIONS_COLORSCHEME_NAME_BUFFER_SIZE   64
#define	OPTIONS_COLORSCHEME_DESCRIPTION_BUFFER_SIZE   256
#define	OPTIONS_COLORSCHEME_FOREGROUND_16_BUFFER_SIZE   16
#define	OPTIONS_COLORSCHEME_FOREGROUND_256_BUFFER_SIZE   24
#define	OPTIONS_COLORSCHEME_FOREGROUND_TRUECOLOR_BUFFER_SIZE   32
#define	COLORSCHEME_LOG_COLOR_COUNT   8
#define	COLORSCHEME_SGR_BUFFER_SIZE   32

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 }
	Color scheme definition. More...

Functions
void	colorscheme_current_palette (colorscheme_palette_t *palette, terminal_color_mode_t mode)
terminal_background_t	colorscheme_current_background (void)
uint8_t	colorscheme_highlight_background (void)
void	colorscheme_apply (const color_scheme_t *scheme)
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.

Macro Definition Documentation

COLORSCHEME_LOG_COLOR_COUNT

#define COLORSCHEME_LOG_COLOR_COUNT   8

Definition at line 40 of file colorscheme.h.

Referenced by colorscheme_current_palette().

COLORSCHEME_SGR_BUFFER_SIZE

#define COLORSCHEME_SGR_BUFFER_SIZE   32

Definition at line 41 of file colorscheme.h.

Referenced by colorscheme_current_palette().

OPTIONS_COLORSCHEME_DESCRIPTION_BUFFER_SIZE

#define OPTIONS_COLORSCHEME_DESCRIPTION_BUFFER_SIZE   256

Definition at line 34 of file colorscheme.h.

OPTIONS_COLORSCHEME_FOREGROUND_16_BUFFER_SIZE

#define OPTIONS_COLORSCHEME_FOREGROUND_16_BUFFER_SIZE   16

Definition at line 35 of file colorscheme.h.

OPTIONS_COLORSCHEME_FOREGROUND_256_BUFFER_SIZE

#define OPTIONS_COLORSCHEME_FOREGROUND_256_BUFFER_SIZE   24

Definition at line 36 of file colorscheme.h.

OPTIONS_COLORSCHEME_FOREGROUND_TRUECOLOR_BUFFER_SIZE

#define OPTIONS_COLORSCHEME_FOREGROUND_TRUECOLOR_BUFFER_SIZE   32

Definition at line 37 of file colorscheme.h.

OPTIONS_COLORSCHEME_NAME_BUFFER_SIZE

#define OPTIONS_COLORSCHEME_NAME_BUFFER_SIZE   64

Definition at line 33 of file colorscheme.h.

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

Color scheme definition.

Compiled ANSI escape codes for a color scheme

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 64 of file colorscheme.h.

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

Function Documentation

colorscheme_apply()

void colorscheme_apply

(

const color_scheme_t *

scheme

)

Publish a complete scheme for all logging and UI consumers.

Definition at line 982 of file colorscheme.c.

                                                     {
  if (!scheme)
    return;
  colorscheme_get_active_scheme();
  mutex_lock(&g_colorscheme_mutex);
  memmove(&g_active_scheme, scheme, sizeof(g_active_scheme));
  atomic_fetch_add(&g_scheme_revision, 1);
  mutex_unlock(&g_colorscheme_mutex);
}

References colorscheme_get_active_scheme(), and g_colorscheme_mutex.

Referenced by log_set_color_scheme().

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 332 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().

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 577 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;
  // Slot 7 stores the scheme's neutral RGB value, although log entries compile
  // that slot as an ANSI reset. Notices need its actual foreground color.
  rgb_pixel_t foreground = colors[7];
  uint8_t foreground_index = rgb_to_16color(foreground.r, foreground.g, foreground.b);
  safe_snprintf(compiled->foreground_16, sizeof(compiled->foreground_16), "\033[%dm",
                foreground_index < 8 ? 30 + foreground_index : 90 + foreground_index - 8);
  safe_snprintf(compiled->foreground_256, sizeof(compiled->foreground_256), "\033[38;5;%dm",
                rgb_to_256color(foreground.r, foreground.g, foreground.b));
  rgb_to_truecolor_ansi(foreground.r, foreground.g, foreground.b, compiled->foreground_truecolor,
                        sizeof(compiled->foreground_truecolor));
  /* Helper: allocate and format a color code string */
  char temp_buf[OPTIONS_COLORSCHEME_TEMP_BUFFER_SIZE];
 
  /* 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, rgb_pixel_t::b, compiled_color_scheme_t::codes_16, compiled_color_scheme_t::codes_256, compiled_color_scheme_t::codes_truecolor, colors, colorscheme_cleanup_compiled(), ERROR_INVALID_PARAM, ERROR_MEMORY, compiled_color_scheme_t::foreground_16, compiled_color_scheme_t::foreground_256, compiled_color_scheme_t::foreground_truecolor, rgb_pixel_t::g, color_scheme_t::has_light_variant, color_scheme_t::log_colors_dark, color_scheme_t::log_colors_light, OPTIONS_COLORSCHEME_TEMP_BUFFER_SIZE, rgb_pixel_t::r, rgb_to_16color(), rgb_to_256color(), rgb_to_truecolor_ansi(), SAFE_MALLOC, safe_snprintf(), SAFE_STRNCPY, SET_ERRNO, and TERM_BACKGROUND_LIGHT.

colorscheme_current_background()

terminal_background_t colorscheme_current_background

(

void

)

Definition at line 920 of file colorscheme.c.

                                                           {
  return current_background();
}

Referenced by colorscheme_highlight_background(), and render_file_create().

colorscheme_current_palette()

void colorscheme_current_palette	(	colorscheme_palette_t *	palette,
		terminal_color_mode_t	mode )

Resolve the active scheme and current terminal theme/depth. Queries are asynchronous and coalesced across threads for 250ms. The returned palette uses the latest decoded reply and never waits for input. Terminal replies and ordinary keyboard input share the keyboard decoder.

Definition at line 924 of file colorscheme.c.

                                                                                             {
  if (!palette)
    return;
  if (g_resolving_palette)
    return;
  memset(palette, 0, sizeof(*palette));
  g_resolving_palette = true;
  palette->background = current_background();
  static _Thread_local colorscheme_palette_t cached;
  static _Thread_local terminal_color_mode_t cached_mode;
  static _Thread_local uint64_t cached_revision;
  uint64_t revision = atomic_load(&g_scheme_revision);
  if (cached_revision == revision && cached_mode == mode && cached.background == palette->background) {
    *palette = cached;
    g_resolving_palette = false;
    return;
  }
  const color_scheme_t *active = colorscheme_get_active_scheme();
  rgb_pixel_t colors[COLORSCHEME_LOG_COLOR_COUNT];
  memcpy(colors,
         palette->background == TERM_BACKGROUND_LIGHT && active->has_light_variant ? active->log_colors_light
                                                                                   : active->log_colors_dark,
         sizeof(colors));
  for (int i = 0; i < 9; ++i) {
    char *code = i == 8 ? palette->foreground : palette->codes[i];
    rgb_pixel_t rgb = colors[i == 8 ? 7 : i];
    if (mode == TERM_COLOR_NONE)
      continue;
    if (i < 8) {
      char *background = palette->background_codes[i];
      if (i == 7)
        safe_snprintf(background, COLORSCHEME_SGR_BUFFER_SIZE, "\033[49m");
      else if (mode >= TERM_COLOR_TRUECOLOR)
        safe_snprintf(background, COLORSCHEME_SGR_BUFFER_SIZE, "\033[48;2;%u;%u;%um", rgb.r, rgb.g, rgb.b);
      else if (mode >= TERM_COLOR_256)
        safe_snprintf(background, COLORSCHEME_SGR_BUFFER_SIZE, "\033[48;5;%dm", rgb_to_256color(rgb.r, rgb.g, rgb.b));
      else {
        unsigned index = rgb_to_16color(rgb.r, rgb.g, rgb.b);
        safe_snprintf(background, COLORSCHEME_SGR_BUFFER_SIZE, "\033[%um", index < 8 ? 40 + index : 100 + index - 8);
      }
    }
    if (i == 7)
      safe_snprintf(code, COLORSCHEME_SGR_BUFFER_SIZE, "\033[0m");
    else if (mode >= TERM_COLOR_TRUECOLOR)
      rgb_to_truecolor_ansi(rgb.r, rgb.g, rgb.b, code, 32);
    else if (mode >= TERM_COLOR_256)
      safe_snprintf(code, COLORSCHEME_SGR_BUFFER_SIZE, "\033[38;5;%dm", rgb_to_256color(rgb.r, rgb.g, rgb.b));
    else {
      unsigned index = rgb_to_16color(rgb.r, rgb.g, rgb.b);
      safe_snprintf(code, COLORSCHEME_SGR_BUFFER_SIZE, "\033[%um", index < 8 ? 30 + index : 90 + index - 8);
    }
  }
  cached = *palette;
  cached_mode = mode;
  cached_revision = revision;
  g_resolving_palette = false;
}

References rgb_pixel_t::b, colorscheme_palette_t::background, colorscheme_palette_t::background_codes, colorscheme_palette_t::codes, colors, colorscheme_get_active_scheme(), COLORSCHEME_LOG_COLOR_COUNT, COLORSCHEME_SGR_BUFFER_SIZE, colorscheme_palette_t::foreground, rgb_pixel_t::g, color_scheme_t::has_light_variant, index, color_scheme_t::log_colors_dark, color_scheme_t::log_colors_light, rgb_pixel_t::r, rgb_to_16color(), rgb_to_256color(), rgb_to_truecolor_ansi(), safe_snprintf(), and TERM_BACKGROUND_LIGHT.

Referenced by log_get_color_array(), log_level_color_for_output(), and ui_buttons_render().

colorscheme_destroy()

void colorscheme_destroy

(

void

)

Shutdown the color system.

Frees all allocated resources. Call at program shutdown.

Definition at line 356 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));
  atomic_fetch_add(&g_scheme_revision, 1);
 
  /* 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.

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 676 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[OPTIONS_COLORSCHEME_TOML_CONTENT_BUFFER_SIZE] = {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", "info", "warn", "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);
    }
    defer(fclose(fp));
    if (fputs(toml_content, fp) < 0) {
      return SET_ERRNO_SYS(ERROR_FILE_OPERATION, "Failed to write to %s", file_path);
    }
  } 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, OPTIONS_COLORSCHEME_TOML_CONTENT_BUFFER_SIZE, 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 383 of file colorscheme.c.

                                                          {
  if (!lifecycle_is_initialized(&g_colorscheme_lifecycle)) {
    /* Lazy initialization of color system */
    colorscheme_init();
  }
 
  static _Thread_local color_scheme_t snapshot;
  static _Thread_local uint64_t revision;
  if (revision != atomic_load(&g_scheme_revision)) {
    mutex_lock(&g_colorscheme_mutex);
    memcpy(&snapshot, &g_active_scheme, sizeof(snapshot));
    revision = atomic_load(&g_scheme_revision);
    mutex_unlock(&g_colorscheme_mutex);
  }
  return &snapshot;
}

References colorscheme_init(), and g_colorscheme_mutex.

Referenced by colorscheme_apply(), colorscheme_current_palette(), and log_init_colors().

colorscheme_highlight_background()

uint8_t colorscheme_highlight_background

(

void

)

Theme-adaptive neutral search highlight, with contrast against the last RGB reply.

Definition at line 992 of file colorscheme.c.

                                               {
  bool dark = colorscheme_current_background() == TERM_BACKGROUND_DARK;
  uint8_t grey = dark ? 70 : 200;
#if !defined(__EMSCRIPTEN__)
  uint8_t r, g, b;
  if (keyboard_is_initialized() && keyboard_stream_background(&r, &g, &b) && abs((int)((r + g + b) / 3) - grey) < 40)
    grey = dark ? 0 : 255;
#endif
  return grey;
}

References colorscheme_current_background(), keyboard_is_initialized(), keyboard_stream_background(), and TERM_BACKGROUND_DARK.

Referenced by ui_buttons_render().

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 290 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));
  atomic_fetch_add(&g_scheme_revision, 1);
 
  /* Mark as initialized */
  lifecycle_init(&g_colorscheme_lifecycle, "colorscheme");
#if !defined(_WIN32) && !defined(__EMSCRIPTEN__)
  // Register the statically initialized mutex without initializing its pthread storage again.
  g_colorscheme_mutex.name = NAMED_REGISTER_MUTEX(&g_colorscheme_mutex, "colorscheme", NULL);
#endif
 
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, ERROR_CONFIG, g_colorscheme_mutex, NAMED_REGISTER_MUTEX, 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 436 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 450 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", "info", "warn", "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", "info", "warn", "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 400 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));
  atomic_fetch_add(&g_scheme_revision, 1);
  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, log_debug, and SET_ERRNO.

Referenced by options_colorscheme_init_early().

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 756 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 SAFE_GETENV, TERM_BACKGROUND_DARK, and TERM_BACKGROUND_LIGHT.

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 851 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 529 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);
  }
 
  for (size_t i = 0; i < 6; ++i) {
    if (!((hex[i] >= '0' && hex[i] <= '9') || (hex[i] >= 'a' && hex[i] <= 'f') || (hex[i] >= 'A' && hex[i] <= 'F'))) {
      return SET_ERRNO(ERROR_CONFIG, "Invalid hex color format: %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 567 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(), and colorscheme_current_palette().

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 50 of file colorscheme.c.

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

Referenced by colorscheme_apply(), colorscheme_destroy(), colorscheme_get_active_scheme(), colorscheme_init(), and colorscheme_set_active_scheme().