text.h File Reference

Go to the source code of this file.

Macros
#define	UI_CLIPPED_TEXT_OVERHEAD   32

Enumerations
enum	ui_alignment_t { UI_ALIGN_LEFT , UI_ALIGN_RIGHT , UI_ALIGN_CENTER }

Functions
size_t	ui_text_cell (char *out, size_t capacity, const char *text, int width, ui_alignment_t alignment)
void	ui_text_values (char *out, size_t capacity, const char *text)
void	ui_text_values_style (char *out, size_t capacity, const char *text, log_color_t zero_color)
void	ui_text_render_values (frame_buffer_t *out, const char *text)
const char *	ui_text_color_prefix (log_color_t color)

Macro Definition Documentation

UI_CLIPPED_TEXT_OVERHEAD

#define UI_CLIPPED_TEXT_OVERHEAD   32

Extra clipping storage for ellipsis, ANSI resets, and the terminating NUL.

Definition at line 4 of file text.h.

Enumeration Type Documentation

ui_alignment_t

enum ui_alignment_t

Enumerator
UI_ALIGN_LEFT
UI_ALIGN_RIGHT
UI_ALIGN_CENTER

Definition at line 9 of file text.h.

{ UI_ALIGN_LEFT, UI_ALIGN_RIGHT, UI_ALIGN_CENTER } ui_alignment_t;

Function Documentation

ui_text_cell()

size_t ui_text_cell	(	char *	out,
		size_t	capacity,
		const char *	text,
		int	width,
		ui_alignment_t	alignment )

ANSI-aware, UTF-8-safe clipping/padding into caller-owned storage.

Definition at line 48 of file text.c.

                                                                                              {
  if (!out || !cap) {
    SET_ERRNO(ERROR_INVALID_PARAM, "UI text requires output storage");
    return 0;
  }
  out[0] = '\0';
  if (width <= 0)
    return 0;
  if (!text)
    text = "";
  int columns = 0;
  const char *end = text;
  while (*end) {
    if (end[0] == '\033' && end[1] == '[') {
      const char *escape = end + 2;
      while (*escape && !(*escape >= '@' && *escape <= '~'))
        ++escape;
      if (!*escape)
        break;
      end = escape + 1;
      continue;
    }
    if ((unsigned char)*end < 32)
      break;
    int bytes = utf8_next_char_bytes(end, strlen(end));
    if (bytes <= 0)
      break;
    int n = utf8_display_width_n(end, (size_t)bytes);
    if (n < 0 || columns + n > width)
      break;
    columns += n;
    end += bytes;
  }
  size_t used = 0;
  int pad = width - columns;
  int left = align == UI_ALIGN_RIGHT ? pad : align == UI_ALIGN_CENTER ? pad / 2 : 0;
  for (int i = 0; i < left; ++i)
    append(out, cap, &used, " ", 1);
  append(out, cap, &used, text, (size_t)(end - text));
  // A clipped styled cell must not bleed into the following column.
  if (memchr(text, '\033', (size_t)(end - text)))
    append(out, cap, &used, "\033[0m", 4);
  for (int i = left; i < pad; ++i)
    append(out, cap, &used, " ", 1);
  return used;
}

References ERROR_INVALID_PARAM, out, SET_ERRNO, UI_ALIGN_CENTER, UI_ALIGN_RIGHT, utf8_display_width_n(), utf8_next_char_bytes(), and width.

Referenced by ui_error_popup_preserve(), ui_error_popup_render(), ui_help_menu_render(), and ui_table_row().

ui_text_color_prefix()

const char * ui_text_color_prefix

(

log_color_t

color

)

Theme-aware prefix for incremental formatting, derived from colored_string().

Definition at line 18 of file text.c.

                                                    {
  static _Thread_local char buffers[LOG_COLOR_WHITE + 1][UI_TEXT_COLOR_BUFFER_SIZE];
  if (color < LOG_COLOR_DEV || color > LOG_COLOR_WHITE) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Invalid UI text color");
    return "";
  }
  char *out = buffers[color];
  const char *styled = colored_string(color, "!");
  const char *marker = strchr(styled, '!');
  size_t length = marker ? (size_t)(marker - styled) : 0;
  if (length >= sizeof(buffers[0]))
    length = sizeof(buffers[0]) - 1;
  memcpy(out, styled, length);
  out[length] = '\0';
  return out;
}

References colored_string(), ERROR_INVALID_PARAM, LOG_COLOR_WHITE, out, SET_ERRNO, and UI_TEXT_COLOR_BUFFER_SIZE.

Referenced by frame_buffer_render_divider(), tui_stats_render(), ui_error_popup_render(), and ui_table_render().

ui_text_render_values()

void ui_text_render_values	(	frame_buffer_t *	out,
		const char *	text )

Definition at line 146 of file text.c.

                                                                  {
  char styled[UI_TEXT_STYLED_BUFFER_SIZE];
  ui_text_values_style(styled, sizeof(styled), text, LOG_COLOR_FATAL);
  frame_buffer_append(out, styled, strlen(styled));
}

References frame_buffer_append(), LOG_COLOR_FATAL, out, UI_TEXT_STYLED_BUFFER_SIZE, and ui_text_values_style().

Referenced by tui_stats_render().

ui_text_values()

void ui_text_values	(	char *	out,
		size_t	capacity,
		const char *	text )

Theme-aware numeric/boolean styling; numeric suffixes retain default color.

Definition at line 142 of file text.c.

                                                             {
  ui_text_values_style(out, cap, text, LOG_COLOR_ERROR);
}

References LOG_COLOR_ERROR, out, and ui_text_values_style().

ui_text_values_style()

void ui_text_values_style	(	char *	out,
		size_t	capacity,
		const char *	text,
		log_color_t	zero_color )

Definition at line 95 of file text.c.

                                                                                           {
  if (!out || !cap) {
    SET_ERRNO(ERROR_INVALID_PARAM, "UI text requires output storage");
    return;
  }
  size_t used = 0;
  out[0] = '\0';
  if (!text)
    return;
  for (const char *p = text; *p;) {
    if (p[0] == '\033' && p[1] == '[') {
      const char *end = p + 2;
      while (*end && !(*end >= '@' && *end <= '~'))
        ++end;
      if (*end)
        ++end;
      append(out, cap, &used, p, (size_t)(end - p));
      p = end;
    } else if (isdigit((unsigned char)*p)) {
      char *end;
      double value = p[0] == '0' && p[1] == 'x' ? (double)strtoull(p, &end, 16) : strtod(p, &end);
      char number[UI_TEXT_NUMBER_BUFFER_SIZE];
      size_t length = (size_t)(end - p);
      if (length >= sizeof(number))
        length = sizeof(number) - 1;
      memcpy(number, p, length);
      number[length] = '\0';
      const char *styled = colored_string(value == 0 ? zero_color : LOG_COLOR_FATAL, number);
      append(out, cap, &used, styled, strlen(styled));
      p = end;
    } else if ((p == text || !isalnum((unsigned char)p[-1])) &&
               ((!strncmp(p, "enabled", 7) && !isalnum((unsigned char)p[7])) ||
                (!strncmp(p, "disabled", 8) && !isalnum((unsigned char)p[8])))) {
      bool enabled = *p == 'e';
      const char *styled = colored_string(enabled ? LOG_COLOR_INFO : LOG_COLOR_ERROR, enabled ? "enabled" : "disabled");
      append(out, cap, &used, styled, strlen(styled));
      p += enabled ? 7 : 8;
    } else {
      int bytes = utf8_next_char_bytes(p, strlen(p));
      if (bytes <= 0)
        break;
      append(out, cap, &used, p, (size_t)bytes);
      p += bytes;
    }
  }
}

References colored_string(), enabled, ERROR_INVALID_PARAM, LOG_COLOR_ERROR, LOG_COLOR_FATAL, LOG_COLOR_INFO, out, SET_ERRNO, UI_TEXT_NUMBER_BUFFER_SIZE, and utf8_next_char_bytes().

Referenced by ui_help_menu_render(), ui_text_render_values(), and ui_text_values().