table.h File Reference

Go to the source code of this file.

Data Structures
struct	ui_table_column_t
struct	ui_table_t
	The useful part of ui table column is in heading, width, alignment, ellipsis: together they describe what is pending, who owns it, and how much data is valid. Keep the object with its parent operation and use the parent cleanup path. More...

Typedefs
typedef void(*	ui_table_cells_fn) (size_t row, const char **cells, size_t columns, void *data)

Functions
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.
void	ui_table_render (frame_buffer_t *out, ui_table_t *table, int row, int column, int width, int height)

Typedef Documentation

ui_table_cells_fn

typedef void(* ui_table_cells_fn) (size_t row, const char **cells, size_t columns, void *data)

Definition at line 18 of file table.h.

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