reflow_layout.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"

bool priv_reflow_internal_is_indent_tag(uint8_t tag)
{
  return (tag == (uint8_t)k_reflow_tag_li) || (tag == (uint8_t)k_reflow_tag_blockquote);
}

bool priv_reflow_internal_right_overflow_break(int32_t cursor_x,
                                               int32_t advance,
                                               int32_t right_limit,
                                               uint8_t line_has_content)
{
  return ((cursor_x + advance) > right_limit) && (line_has_content != 0U);
}

bool priv_reflow_internal_xhtml_invalid(const void* xhtml_buf, size_t xhtml_len)
{
  return (xhtml_buf == nullptr) || (xhtml_len == 0U);
}

bool priv_reflow_internal_final_page_needed(uint32_t page_count, uint32_t token_count)
{
  return (page_count == 0U) && (token_count > 0U);
}

void priv_reflow_layout_byte_zero(uint8_t* dst, size_t n)
{
  for (size_t i = 0U; i < n; ++i) {
    dst[i] = 0U;
  }
}
 
/* ===========================================================================
 * Helpers
 *
 * The internal sizing constants (`priv_layout_consts_t`) and the mutable
 * layout cursor (`priv_cursor_t`) are shared across the layout translation
 * units and live in `reflow_layout_internal.h`.
 * ===========================================================================
 */

ra8_err_t priv_reflow_layout_init_font(const reflow_t* engine, stbtt_fontinfo* out_font)
{
  const int32_t offset = stbtt_GetFontOffsetForIndex(engine->font_data, 0);
  if (offset < 0) {
    return k_ra8_err_validation_failed;
  }
  if (stbtt_InitFont(out_font, engine->font_data, (int)engine->font_len, offset) == 0) {
    return k_ra8_err_validation_failed;
  }
  return k_ra8_ok;
}

uint16_t priv_reflow_layout_line_height(uint16_t font_px)
{
  const uint32_t lh =
    ((uint32_t)font_px * (uint32_t)k_reflow_line_spacing_num) / (uint32_t)k_reflow_line_spacing_den;
  return (uint16_t)lh;
}

RA8_INTERNAL
static uint16_t internal_block_font_px(uint16_t body_px, reflow_html_tag_t tag)
{
  uint32_t pct = k_reflow_pct_full;
  switch (tag) {
    case k_reflow_tag_h1:
      pct = k_reflow_h1_scale_pct;
      break;
    case k_reflow_tag_h2:
      pct = k_reflow_h2_scale_pct;
      break;
    case k_reflow_tag_h3:
      pct = k_reflow_h3_scale_pct;
      break;
    case k_reflow_tag_h4:
      pct = k_reflow_h4_scale_pct;
      break;
    case k_reflow_tag_h5:
      pct = k_reflow_h5_scale_pct;
      break;
    case k_reflow_tag_h6:
      pct = k_reflow_h6_scale_pct;
      break;
    default:
      pct = k_reflow_pct_full;
      break;
  }
  return (uint16_t)(((uint32_t)body_px * pct) / k_reflow_pct_full);
}

int32_t priv_reflow_layout_glyph_advance(const stbtt_fontinfo* font, uint16_t font_px, int32_t cp)
{
  const float scale         = stbtt_ScaleForPixelHeight(font, (float)font_px);
  int         advance_units = 0;
  int         lsb           = 0;
  stbtt_GetCodepointHMetrics(font, cp, &advance_units, &lsb);
  return (int32_t)((float)advance_units * scale);
}

bool priv_reflow_layout_push_glyph(reflow_t* engine,
                                   int32_t   x,
                                   int32_t   y,
                                   int32_t   cp,
                                   uint16_t  font_px,
                                   uint8_t   style,
                                   uint32_t  color,
                                   uint8_t   link_id)
{
  if (engine->glyph_count >= k_reflow_max_glyphs) {
    return false;
  }
  reflow_glyph_t* g = &engine->glyphs[engine->glyph_count];
  g->x              = x;
  g->y              = y;
  g->cp             = cp;
  g->color          = color;
  g->font_px        = font_px;
  g->style          = style;
  g->reserved       = link_id; /* 1-based `<a>` link id (0 = not a link) */
  engine->glyph_count++;
  return true;
}

bool priv_reflow_layout_finish_page(reflow_t* engine, priv_cursor_t* cur)
{
  if (engine->page_count >= k_reflow_max_pages) {
    return false;
  }
  const uint32_t count = engine->glyph_count - cur->page_first_glyph;
  reflow_page_t* page  = &engine->pages[engine->page_count];
  page->glyph_first    = cur->page_first_glyph;
  page->glyph_count    = count;
  engine->page_count++;
  cur->page_first_glyph = engine->glyph_count;
  cur->page_first_image = engine->image_box_count;
  cur->line_first_glyph = engine->glyph_count;
  cur->y                = (int32_t)k_reflow_margin_px;
  cur->line_top         = cur->y;
  cur->x                = (int32_t)k_reflow_margin_px + (int32_t)cur->indent_px;
  cur->line_has_content = 0U;
  return true;
}

RA8_INTERNAL
static void internal_justify_glyphs(reflow_t* engine, uint32_t lo, uint32_t hi, int32_t slack)
{
  uint32_t spaces = 0U;
  for (uint32_t i = lo; i < hi; ++i) {
    if (engine->glyphs[i].cp == (int32_t)' ') {
      spaces++;
    }
  }
  if (spaces == 0U) {
    return;
  }
  const int32_t per   = slack / (int32_t)spaces;
  const int32_t rem   = slack % (int32_t)spaces;
  int32_t       added = 0;
  uint32_t      seen  = 0U;
  for (uint32_t i = lo; i < hi; ++i) {
    engine->glyphs[i].x += added;
    if (engine->glyphs[i].cp == (int32_t)' ') {
      added += per;
      if ((int32_t)seen < rem) {
        added += 1;
      }
      seen++;
    }
  }
}

RA8_INTERNAL
static void internal_finish_line(reflow_t* engine, priv_cursor_t* cur, bool allow_justify)
{
  if (cur->align == (uint8_t)k_reflow_align_left) {
    return;
  }
  const uint32_t lo = cur->line_first_glyph;
  uint32_t       hi = engine->glyph_count;
  if (hi <= lo) {
    return;
  }
  int32_t content_right = cur->x;
  if (engine->glyphs[hi - 1U].cp == (int32_t)' ') {
    content_right = engine->glyphs[hi - 1U].x;
    hi--;
  }
  const int32_t right_limit = (int32_t)engine->viewport_w - (int32_t)k_reflow_margin_px;
  const int32_t slack       = right_limit - content_right;
  if ((hi <= lo) || (slack <= 0)) {
    return;
  }
  if (cur->align == (uint8_t)k_reflow_align_justify) {
    if (allow_justify) {
      internal_justify_glyphs(engine, lo, hi, slack);
    }
    return;
  }
  const int32_t offset = (cur->align == (uint8_t)k_reflow_align_center) ? (slack / 2) : slack;
  for (uint32_t i = lo; i < hi; ++i) {
    engine->glyphs[i].x += offset;
  }
}

bool priv_reflow_layout_newline(reflow_t* engine, priv_cursor_t* cur, bool allow_justify)
{
  internal_finish_line(engine, cur, allow_justify);
  cur->y += (int32_t)cur->line_height_px;
  cur->line_top         = cur->y;
  cur->x                = (int32_t)k_reflow_margin_px + (int32_t)cur->indent_px;
  cur->line_has_content = 0U;
  cur->line_first_glyph = engine->glyph_count;
 
  const int32_t bottom_limit = (int32_t)engine->viewport_h - (int32_t)k_reflow_margin_px;
  if (cur->y + (int32_t)cur->line_height_px > bottom_limit) {
    if (!priv_reflow_layout_finish_page(engine, cur)) {
      return false;
    }
  }
  return true;
}

RA8_INTERNAL
static ra8_err_t internal_emit_char(reflow_t*             engine,
                                    priv_cursor_t*        cur,
                                    const stbtt_fontinfo* font,
                                    int32_t               cp,
                                    uint32_t              color,
                                    uint8_t               link_id)
{
  const int32_t advance = priv_reflow_layout_glyph_advance(font, cur->active_font_px, cp);
  const int32_t advance_clamped =
    (advance < (int32_t)k_priv_min_word_w_px) ? (int32_t)k_priv_min_word_w_px : advance;
 
  const int32_t right_limit = (int32_t)engine->viewport_w - (int32_t)k_reflow_margin_px;
  if (priv_reflow_internal_right_overflow_break(cur->x,
                                                advance_clamped,
                                                right_limit,
                                                cur->line_has_content)) {
    if (!priv_reflow_layout_newline(engine, cur, true)) { /* wrap -> previous line may justify */
      return k_ra8_err_no_mem;
    }
  }
  if (!priv_reflow_layout_push_glyph(engine,
                                     cur->x,
                                     cur->y,
                                     cp,
                                     cur->active_font_px,
                                     cur->active_style,
                                     color,
                                     link_id)) {
    return k_ra8_err_no_mem;
  }
  cur->x += advance_clamped;
  cur->line_has_content = 1U;
  return k_ra8_ok;
}

RA8_INTERNAL
static ra8_err_t internal_layout_text(reflow_t*             engine,
                                      priv_cursor_t*        cur,
                                      const stbtt_fontinfo* font,
                                      const reflow_token_t* tok)
{
  const uint8_t* base    = &engine->text_pool[tok->text_off];
  const uint32_t len     = tok->text_len;
  const uint8_t  link_id = tok->reserved; /* 1-based `<a>` link id (0 = none) */
  /* Colour precedence: an explicit CSS `color` (#140) wins; otherwise a link run
   * uses the link colour and ordinary text the body colour. Link colour is keyed
   * on actual link membership, not the underline style bit, so CSS
   * `text-decoration: underline` (#111) on non-link text keeps the body colour. */
  const uint32_t fallback = (link_id != 0U) ? engine->link_color : engine->body_color;
  const uint32_t color = (tok->color != (uint32_t)k_reflow_color_inherit) ? tok->color : fallback;
 
  /* Pre-scan to find each word boundary. Greedy: if word_w + cursor_x
   * exceeds the right margin AND the line already has content, break
   * before emitting the word. */
  uint32_t i = 0U;
  while (i < len) {
    /* Emit any leading whitespace as one space (already collapsed by
     * the parser). */
    if (base[i] == (uint8_t)' ') {
      ra8_err_t err = internal_emit_char(engine, cur, font, ' ', color, link_id);
      if (err != k_ra8_ok) {
        return err;
      }
      ++i;
      continue;
    }
 
    /* Word: bytes up to the next space. Pre-measure for greedy break. */
    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, cur->active_font_px, (int32_t)base[word_end]);
      ++word_end;
    }
    const int32_t right_limit = (int32_t)engine->viewport_w - (int32_t)k_reflow_margin_px;
    if (priv_reflow_internal_right_overflow_break(cur->x,
                                                  word_w,
                                                  right_limit,
                                                  cur->line_has_content)) {
      if (!priv_reflow_layout_newline(engine, cur, true)) { /* wrap -> previous line may justify */
        return k_ra8_err_no_mem;
      }
    }
    while (i < word_end) {
      ra8_err_t err = internal_emit_char(engine, cur, font, (int32_t)base[i], color, link_id);
      if (err != k_ra8_ok) {
        return err;
      }
      ++i;
    }
  }
  return k_ra8_ok;
}

RA8_INTERNAL
static bool internal_open_block(reflow_t* engine, priv_cursor_t* cur, const reflow_token_t* tok)
{
  if (cur->line_has_content != 0U) {
    if (!priv_reflow_layout_newline(engine, cur, false)) {
      return false;
    }
  }
  /* The block's text alignment travels in the block-start token's reserved byte
   * (set by the tokenizer from `style="text-align:..."`). */
  cur->align = tok->reserved;
  /* Record an `id=` anchor (carried in the block-start token's slice) at this
   * block's page + top, for same-chapter `#fragment` jumps. */
  if ((tok->text_len > 0U) && (engine->anchor_count < (uint32_t)k_reflow_max_anchors)) {
    reflow_anchor_t* anchor = &engine->anchors[engine->anchor_count];
    anchor->id_off          = tok->text_off;
    anchor->id_len          = tok->text_len;
    anchor->page_index      = engine->page_count;
    anchor->y               = cur->y;
    engine->anchor_count++;
  }
  /* CSS `font-size` (#140) on the block-start token wins; else the UA default
   * (body size or heading scale). 0 = no CSS font, so unstyled content is
   * byte-identical. */
  cur->active_font_px = (tok->css_font_px != 0U)
                          ? tok->css_font_px
                          : internal_block_font_px(engine->font_px, (reflow_html_tag_t)tok->tag);
  cur->line_height_px = priv_reflow_layout_line_height(cur->active_font_px);
  if (priv_reflow_internal_is_indent_tag((uint8_t)tok->tag)) {
    cur->indent_px = k_reflow_indent_px;
    cur->x         = (int32_t)k_reflow_margin_px + (int32_t)cur->indent_px;
  }
  return true;
}

RA8_INTERNAL
static bool internal_close_block(reflow_t* engine, priv_cursor_t* cur, const reflow_token_t* tok)
{
  if (cur->line_has_content != 0U) {
    if (!priv_reflow_layout_newline(engine, cur, false)) {
      return false;
    }
  }
  /* Paragraph gap. */
  cur->y += (int32_t)k_reflow_paragraph_gap_px;
  cur->line_top = cur->y;
  cur->x        = (int32_t)k_reflow_margin_px;
  if (priv_reflow_internal_is_indent_tag((uint8_t)tok->tag)) {
    cur->indent_px = 0U;
  }
  cur->active_font_px = engine->font_px;
  cur->line_height_px = priv_reflow_layout_line_height(cur->active_font_px);
 
  const int32_t bottom_limit = (int32_t)engine->viewport_h - (int32_t)k_reflow_margin_px;
  if (cur->y + (int32_t)cur->line_height_px > bottom_limit) {
    if (!priv_reflow_layout_finish_page(engine, cur)) {
      return false;
    }
  }
  return true;
}

RA8_INTERNAL
static bool internal_apply_rule(reflow_t* engine, priv_cursor_t* cur)
{
  if (cur->line_has_content != 0U) {
    if (!priv_reflow_layout_newline(engine, cur, false)) {
      return false;
    }
  }
  cur->y += (int32_t)k_priv_hr_thickness_px;
  cur->line_top = cur->y;
  return true;
}

RA8_INTERNAL
static void internal_emit_link_rect(reflow_t*             engine,
                                    const stbtt_fontinfo* font,
                                    uint32_t              lo,
                                    uint32_t              hi,
                                    uint8_t               link,
                                    uint32_t              page)
{
  if (engine->link_rect_count >= (uint32_t)k_reflow_max_link_rects) {
    return;
  }
  const reflow_glyph_t* gfirst = &engine->glyphs[lo];
  const reflow_glyph_t* glast  = &engine->glyphs[hi - 1U];
  const int32_t         fpx    = (int32_t)gfirst->font_px;
  const int32_t x1 = glast->x + priv_reflow_layout_glyph_advance(font, glast->font_px, glast->cp);
  reflow_link_rect_t* rect = &engine->link_rects[engine->link_rect_count];
  rect->x                  = gfirst->x;
  rect->y                  = gfirst->y - fpx;
  rect->w                  = (x1 > gfirst->x) ? (x1 - gfirst->x) : 1;
  rect->h                  = fpx + (fpx / 2);
  rect->target             = (uint32_t)link - 1U; /* 1-based -> 0-based */
  rect->page_index         = page;
  engine->link_rect_count++;
}

void priv_reflow_layout_build_link_rects(reflow_t* engine, const stbtt_fontinfo* font)
{
  for (uint32_t p = 0U; p < engine->page_count; ++p) {
    const reflow_page_t* page = &engine->pages[p];
    const uint32_t       base = page->glyph_first;
    uint32_t             k    = 0U;
    while (k < page->glyph_count) {
      const uint8_t link = engine->glyphs[base + k].reserved;
      if (link == 0U) {
        ++k;
        continue;
      }
      const int32_t y = engine->glyphs[base + k].y;
      uint32_t      e = k + 1U;
      while ((e < page->glyph_count) && (engine->glyphs[base + e].reserved == link) &&
             (engine->glyphs[base + e].y == y)) {
        ++e;
      }
      internal_emit_link_rect(engine, font, base + k, base + e, link, p);
      k = e;
    }
  }
}

ra8_err_t priv_reflow_layout_apply_token(reflow_t*             engine,
                                         priv_cursor_t*        cur,
                                         const stbtt_fontinfo* font,
                                         const reflow_token_t* tok)
{
  /* Pack the per-run embedded-face index (stamped on the token by the cascade,
   * #109) into the free high nibble of the style stamp; bits 0-2 keep the
   * bold/italic/underline emphasis. Single-face content carries face 0, so the
   * style byte is unchanged. */
  cur->active_style =
    (uint8_t)(tok->style | (uint8_t)(((uint32_t)tok->reserved16 & (uint32_t)k_reflow_face_mask)
                                     << (uint32_t)k_reflow_face_shift));
  switch (tok->kind) {
    case k_reflow_tok_block_start:
      return internal_open_block(engine, cur, tok) ? k_ra8_ok : k_ra8_err_no_mem;
    case k_reflow_tok_block_end:
      return internal_close_block(engine, cur, tok) ? k_ra8_ok : k_ra8_err_no_mem;
    case k_reflow_tok_text:
      return internal_layout_text(engine, cur, font, tok);
    case k_reflow_tok_break:
      return priv_reflow_layout_newline(engine, cur, false) ? k_ra8_ok : k_ra8_err_no_mem;
    case k_reflow_tok_rule:
      return internal_apply_rule(engine, cur) ? k_ra8_ok : k_ra8_err_no_mem;
    case k_reflow_tok_image:
      return priv_reflow_layout_apply_image(engine, cur, tok) ? k_ra8_ok : k_ra8_err_no_mem;
    default:
      return k_ra8_ok;
  }
}