table.c File Reference

Go to the source code of this file.

Macros
#define	UI_TABLE_CLIPPED_BUFFER_SIZE   8192
#define	UI_TABLE_LINE_BUFFER_SIZE   8192
#define	UI_TABLE_CELL_CAPACITY   32

Functions
size_t	ui_table_row (char *out, size_t cap, const ui_table_column_t *cols, const char *const *cells, size_t count, int width, bool selectable, bool selected)
	When code needs to work with ui table, it keeps columns, column_count, row_count, viewport here instead of scattering it across globals. Initialization establishes the handles and sizes; teardown must release any allocation, lock, thread, or callback context recorded in those fields. terminal columns, never by bytes. The caller owns data and sorting.
void	ui_table_render (frame_buffer_t *out, ui_table_t *t, int row, int col, int width, int height)

Macro Definition Documentation

UI_TABLE_CELL_CAPACITY

#define UI_TABLE_CELL_CAPACITY   32

Definition at line 7 of file table.c.

Referenced by ui_table_render().

UI_TABLE_CLIPPED_BUFFER_SIZE

#define UI_TABLE_CLIPPED_BUFFER_SIZE   8192

Definition at line 3 of file table.c.

Referenced by ui_table_row().

UI_TABLE_LINE_BUFFER_SIZE

#define UI_TABLE_LINE_BUFFER_SIZE   8192

Definition at line 4 of file table.c.

Referenced by ui_table_render().

Function Documentation

ui_table_render()

void ui_table_render	(	frame_buffer_t *	out,
		ui_table_t *	table,
		int	row,
		int	column,
		int	width,
		int	height )

Rectangular table with a fixed header and independent page/scroll state.

Definition at line 76 of file table.c.

                                                                                                  {
  if (!out || !t || !t->columns || !t->column_count || t->column_count > 32 || !t->cells || width < 2 || height < 1 ||
      row < 1 || col < 1) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Invalid table output, data source or geometry");
    return;
  }
  char line[UI_TABLE_LINE_BUFFER_SIZE];
  if (t->header) {
    ui_table_row(line, sizeof(line), t->columns, NULL, t->column_count, width - 1, t->selectable, false);
    frame_buffer_printf(out, "\033[%d;%dH%s%s%s", row++, col, ui_text_color_prefix(LOG_COLOR_DEBUG), line,
                        ui_text_color_prefix(LOG_COLOR_RESET));
    --height;
  }
  if (height < 1)
    return;
  ui_viewport_range_t range = ui_viewport_update(&t->viewport, t->row_count, (size_t)height);
  for (int i = 0; i < height; ++i) {
    const char *cells[UI_TABLE_CELL_CAPACITY] = {0};
    if ((size_t)i < range.count) {
      t->cells(range.first + (size_t)i, cells, t->column_count, t->data);
      ui_table_row(line, sizeof(line), t->columns, cells, t->column_count, width - 1, t->selectable,
                   range.first + (size_t)i == t->viewport.selected);
    } else
      snprintf(line, sizeof(line), "%*s", width - 1, "");
    bool selected = t->selectable && (size_t)i < range.count && range.first + (size_t)i == t->viewport.selected;
    frame_buffer_printf(out, "\033[%d;%dH%s%s%s", row + i, col, selected ? "\033[7m" : "", line,
                        selected ? "\033[27m" : "");
  }
  ui_scrollbar_render(out, row, col + width - 1, height, range.page_count, (size_t)height, t->viewport.first_visible);
}

References cells, ui_table_t::cells, ui_table_t::column_count, ui_table_t::columns, ui_viewport_range_t::count, ui_table_t::data, ERROR_INVALID_PARAM, ui_viewport_range_t::first, ui_viewport_t::first_visible, frame_buffer_printf(), ui_table_t::header, height, LOG_COLOR_DEBUG, LOG_COLOR_RESET, out, ui_viewport_range_t::page_count, ui_table_t::row_count, ui_table_t::selectable, ui_viewport_t::selected, SET_ERRNO, ui_scrollbar_render(), UI_TABLE_CELL_CAPACITY, UI_TABLE_LINE_BUFFER_SIZE, ui_table_row(), ui_text_color_prefix(), ui_viewport_update(), ui_table_t::viewport, and width.

Referenced by tui_stats_render().

ui_table_row()

size_t ui_table_row	(	char *	out,
		size_t	capacity,
		const ui_table_column_t *	columns,
		const char *const *	cells,
		size_t	count,
		int	width,
		bool	selectable,
		bool	selected )

When code needs to work with ui table, it keeps columns, column_count, row_count, viewport here instead of scattering it across globals. Initialization establishes the handles and sizes; teardown must release any allocation, lock, thread, or callback context recorded in those fields. terminal columns, never by bytes. The caller owns data and sorting.

Format a complete row without allocation. Styled cells are clipped by

Definition at line 18 of file table.c.

                                                               {
  if (!out || !cap) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Table row requires output storage");
    return 0;
  }
  out[0] = '\0';
  if (!cols || !count || count > 32 || width <= 0) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Invalid table columns or width");
    return 0;
  }
  int64_t remaining = (int64_t)width - (selectable ? 1 : 0) - (int)(count - 1);
  size_t flexible = 0;
  for (size_t i = 0; i < count; ++i) {
    if (cols[i].width < 0) {
      SET_ERRNO(ERROR_INVALID_PARAM, "Table column width cannot be negative");
      return 0;
    }
    if (cols[i].width > 0)
      remaining -= cols[i].width;
    else
      ++flexible;
  }
  size_t used = 0;
  int available = width;
  if (selectable && cap > 1) {
    out[used++] = selected ? '>' : ' ';
    out[used] = '\0';
    --available;
  }
  for (size_t i = 0; i < count && available > 0; ++i) {
    if (i && used + 1 < cap) {
      out[used++] = ' ';
      out[used] = '\0';
      --available;
    }
    int cell_width = cols[i].width > 0 ? cols[i].width : flexible ? remaining / (int)flexible : 0;
    if (cell_width < 0)
      cell_width = 0;
    if (!cols[i].width && flexible) {
      remaining -= cell_width;
      --flexible;
    }
    if (cell_width > available)
      cell_width = available;
    const char *text = cells ? cells[i] : cols[i].heading;
    char clipped[UI_TABLE_CLIPPED_BUFFER_SIZE];
    if (text && cols[i].ellipsis && display_width(text) > cell_width) {
      truncate_with_ellipsis_mode(text, clipped, sizeof(clipped), cell_width,
                                  terminal_should_use_utf8(GET_OPTION(force_utf8)));
      text = clipped;
    }
    used += ui_text_cell(out + used, cap - used, text, cell_width, cols[i].alignment);
    available -= cell_width;
  }
  return used;
}

References cells, display_width(), ERROR_INVALID_PARAM, GET_OPTION, ui_table_column_t::heading, out, SET_ERRNO, truncate_with_ellipsis_mode(), UI_TABLE_CLIPPED_BUFFER_SIZE, ui_text_cell(), ui_table_column_t::width, and width.

Referenced by ui_sync_render(), and ui_table_render().