reflow_layout_table.c

Go to the documentation of this file.

 
#include <stddef.h>
#include <stdint.h>
 
#include "ra8_attributes.h"
#include "ra8_err.h"
#include "reflow.h"
#include "reflow_internal.h"
#include "reflow_layout_internal.h"
#include "stb_truetype.h"
 
/* ===========================================================================
 * Table layout (#107): equal-column grid, per-cell text flow, row page-break
 * ===========================================================================
 */

RA8_INTERNAL
static uint32_t internal_match_block_end(const reflow_t* engine, uint32_t start, uint32_t limit)
{
  const uint8_t tag   = engine->tokens[start].tag;
  int32_t       depth = 1;
  for (uint32_t i = start + 1U; i < limit; ++i) {
    const reflow_token_t* tok = &engine->tokens[i];
    if (tok->tag != tag) {
      continue;
    }
    if (tok->kind == (uint8_t)k_reflow_tok_block_start) {
      depth++;
    } else if (tok->kind == (uint8_t)k_reflow_tok_block_end) {
      depth--;
      if (depth == 0) {
        return i;
      }
    } else {
      /* Other token kinds do not change the matching-block depth. */
    }
  }
  return limit;
}

RA8_INTERNAL
static bool internal_is_cell_start(const reflow_t* engine, uint32_t i)
{
  const reflow_token_t* tok = &engine->tokens[i];
  return (tok->kind == (uint8_t)k_reflow_tok_block_start) &&
         ((tok->tag == (uint8_t)k_reflow_tag_td) || (tok->tag == (uint8_t)k_reflow_tag_th));
}

RA8_INTERNAL
static bool internal_is_row_start(const reflow_t* engine, uint32_t i)
{
  const reflow_token_t* tok = &engine->tokens[i];
  return (tok->kind == (uint8_t)k_reflow_tok_block_start) && (tok->tag == (uint8_t)k_reflow_tag_tr);
}

RA8_INTERNAL
static uint32_t internal_table_columns(const reflow_t* engine, uint32_t start, uint32_t end)
{
  uint32_t cols = 0U;
  uint32_t i    = start + 1U;
  while (i < end) {
    if (!internal_is_row_start(engine, i)) {
      i++;
      continue;
    }
    const uint32_t tr_end = internal_match_block_end(engine, i, end);
    uint32_t       cells  = 0U;
    for (uint32_t j = i + 1U; j < tr_end; ++j) {
      if (internal_is_cell_start(engine, j)) {
        cells++;
      }
    }
    if (cells > cols) {
      cols = cells;
    }
    i = tr_end + 1U;
  }
  return cols;
}

RA8_INTERNAL
static void internal_cell_text(reflow_t*             engine,
                               const stbtt_fontinfo* font,
                               const reflow_token_t* tok,
                               int32_t               cell_x,
                               int32_t               cell_right,
                               uint16_t              font_px,
                               uint32_t              color,
                               int32_t*              cx,
                               int32_t*              cy,
                               uint32_t*             lines)
{
  const int32_t  line_h = (int32_t)priv_reflow_layout_line_height(font_px);
  const uint8_t* base   = &engine->text_pool[tok->text_off];
  const uint32_t len    = tok->text_len;
  uint32_t       i      = 0U;
  while (i < len) {
    if (base[i] == (uint8_t)' ') {
      const int32_t adv = priv_reflow_layout_glyph_advance(font, font_px, (int32_t)' ');
      /* mcdc-deactivated: priv_reflow_tok_stash_run collapses leading whitespace of every text run (last_ws starts true), so a cell text token never begins with a space, and the pen always advances past cell_x after a word is emitted; a space is therefore only ever seen with *cx > cell_x, making the (*cx > cell_x) false arm unreachable. */
      if ((*cx > cell_x) && ((*cx + adv) <= cell_right)) {
        (void)priv_reflow_layout_push_glyph(engine, *cx, *cy, (int32_t)' ', font_px, 0U, color, 0U);
        *cx += adv;
      }
      ++i;
      continue;
    }
    uint32_t word_end = i;
    int32_t  word_w   = 0;
    while ((word_end < len) && (base[word_end] != (uint8_t)' ')) {
      word_w += priv_reflow_layout_glyph_advance(font, font_px, (int32_t)base[word_end]);
      ++word_end;
    }
    if (((*cx + word_w) > cell_right) && (*cx > cell_x)) {
      *cx = cell_x;
      *cy += line_h;
      (*lines)++;
    }
    while (i < word_end) {
      const int32_t adv = priv_reflow_layout_glyph_advance(font, font_px, (int32_t)base[i]);
      (void)
        priv_reflow_layout_push_glyph(engine, *cx, *cy, (int32_t)base[i], font_px, 0U, color, 0U);
      *cx += adv;
      ++i;
    }
  }
}

RA8_INTERNAL
static uint32_t internal_layout_cell(reflow_t*             engine,
                                     const stbtt_fontinfo* font,
                                     int32_t               cell_x,
                                     int32_t               cell_w,
                                     int32_t               top_y,
                                     uint32_t              color,
                                     uint32_t              tstart,
                                     uint32_t              tend)
{
  const int32_t  cell_right = cell_x + cell_w;
  const uint16_t font_px    = engine->font_px;
  int32_t        cx         = cell_x;
  int32_t        cy         = top_y;
  uint32_t       lines      = 1U;
  for (uint32_t t = tstart; t < tend; ++t) {
    const reflow_token_t* tok = &engine->tokens[t];
    if (tok->kind == (uint8_t)k_reflow_tok_text) {
      internal_cell_text(engine, font, tok, cell_x, cell_right, font_px, color, &cx, &cy, &lines);
    }
  }
  return lines;
}

RA8_INTERNAL
static uint32_t internal_row_cells(reflow_t*             engine,
                                   const stbtt_fontinfo* font,
                                   uint32_t              tr_start,
                                   uint32_t              tr_end,
                                   int32_t               col_w,
                                   int32_t               row_y)
{
  const int32_t  pad   = (int32_t)k_priv_cell_pad_px;
  const uint32_t color = engine->body_color;
  uint32_t       rows  = 1U;
  uint32_t       col   = 0U;
  uint32_t       i     = tr_start + 1U;
  while (i < tr_end) {
    if (!internal_is_cell_start(engine, i)) {
      i++;
      continue;
    }
    const uint32_t cell_end = internal_match_block_end(engine, i, tr_end);
    const int32_t  cell_x   = (int32_t)k_reflow_margin_px + ((int32_t)col * col_w) + pad;
    const int32_t  cell_w   = col_w - (2 * pad);
    const uint32_t lines =
      internal_layout_cell(engine, font, cell_x, cell_w, row_y, color, i + 1U, cell_end);
    if (lines > rows) {
      rows = lines;
    }
    col++;
    i = cell_end + 1U;
  }
  return rows;
}

RA8_INTERNAL
static uint32_t internal_layout_row(reflow_t*             engine,
                                    priv_cursor_t*        cur,
                                    const stbtt_fontinfo* font,
                                    uint32_t              tr_start,
                                    uint32_t              table_end,
                                    int32_t               col_w)
{
  const uint32_t tr_end       = internal_match_block_end(engine, tr_start, table_end);
  const int32_t  line_h       = (int32_t)priv_reflow_layout_line_height(engine->font_px);
  const int32_t  bottom_limit = (int32_t)engine->viewport_h - (int32_t)k_reflow_margin_px;
 
  const uint32_t glyphs_before = engine->glyph_count;
  uint32_t       row_lines     = internal_row_cells(engine, font, tr_start, tr_end, col_w, cur->y);
  int32_t        row_h         = (int32_t)row_lines * line_h;
 
  if (((cur->y + row_h) > bottom_limit) && (cur->y > (int32_t)k_reflow_margin_px)) {
    engine->glyph_count = glyphs_before; /* roll the row back ... */
    (void)priv_reflow_layout_finish_page(engine,
                                         cur); /* ... flush the page (cur->y -> margin) ... */
    /* ... re-lay it */
    row_lines = internal_row_cells(engine, font, tr_start, tr_end, col_w, cur->y);
    row_h     = (int32_t)row_lines * line_h;
  }
  cur->y += row_h + (int32_t)k_priv_row_gap_px;
  return tr_end + 1U;
}
 
ra8_err_t priv_reflow_layout_table(reflow_t*             engine,
                                   priv_cursor_t*        cur,
                                   const stbtt_fontinfo* font,
                                   uint32_t              start,
                                   uint32_t*             out_next)
{
  if (cur->line_has_content != 0U) {
    if (!priv_reflow_layout_newline(engine, cur, false)) {
      return k_ra8_err_no_mem;
    }
  }
  const uint32_t end  = internal_match_block_end(engine, start, engine->token_count);
  const uint32_t cols = internal_table_columns(engine, start, end);
  if (cols == 0U) {
    *out_next = (end < engine->token_count) ? (end + 1U) : engine->token_count;
    return k_ra8_ok;
  }
  const int32_t content_w = (int32_t)engine->viewport_w - (2 * (int32_t)k_reflow_margin_px);
  const int32_t col_w     = content_w / (int32_t)cols;
 
  uint32_t i = start + 1U;
  while (i < end) {
    if (internal_is_row_start(engine, i)) {
      i = internal_layout_row(engine, cur, font, i, end, col_w);
    } else {
      i++;
    }
  }
 
  /* Resume linear flow below the table. */
  cur->x                = (int32_t)k_reflow_margin_px + (int32_t)cur->indent_px;
  cur->align            = (uint8_t)k_reflow_align_left;
  cur->line_has_content = 0U;
  cur->y += (int32_t)k_reflow_paragraph_gap_px;
  cur->line_top         = cur->y;
  cur->line_first_glyph = engine->glyph_count;
  *out_next             = (end < engine->token_count) ? (end + 1U) : engine->token_count;
  return k_ra8_ok;
}