reflow_link.c

Go to the documentation of this file.

 
#include <stddef.h>
#include <stdint.h>
#include <string.h>
 
#include "ra8_attributes.h"
#include "ra8_check.h"
#include "ra8_err.h"
#include "reflow.h"

static const char* const s_tag_link = "ra8_link";
 
ra8_err_t reflow_hit_test_link(const reflow_t* engine,
                               uint32_t        page_idx,
                               int32_t         x,
                               int32_t         y,
                               uint32_t*       out_href_off,
                               uint32_t*       out_href_len)
{
  RA8_CHECK_NULL_PTR(engine, s_tag_link, "hit: null engine");
  RA8_CHECK_NULL_PTR(out_href_off, s_tag_link, "hit: null out_href_off");
  RA8_CHECK_NULL_PTR(out_href_len, s_tag_link, "hit: null out_href_len");
 
  for (uint32_t i = 0U; i < engine->link_rect_count; ++i) {
    const reflow_link_rect_t* rect = &engine->link_rects[i];
    if (rect->page_index != page_idx) {
      continue;
    }
    if ((x >= rect->x) && (x < (rect->x + rect->w)) && (y >= rect->y) &&
        (y < (rect->y + rect->h))) {
      const reflow_link_target_t* target = &engine->link_targets[rect->target];
      *out_href_off                      = target->href_off;
      *out_href_len                      = target->href_len;
      return k_ra8_ok;
    }
  }
  return k_ra8_err_not_found;
}
 
ra8_err_t reflow_hit_test_image(const reflow_t* engine,
                                uint32_t        page_idx,
                                int32_t         x,
                                int32_t         y,
                                uint32_t*       out_index)
{
  RA8_CHECK_NULL_PTR(engine, s_tag_link, "img hit: null engine");
  RA8_CHECK_NULL_PTR(out_index, s_tag_link, "img hit: null out_index");
 
  for (uint32_t i = 0U; i < engine->image_box_count; ++i) {
    const reflow_image_box_t* box = &engine->image_boxes[i];
    if (box->page_index != page_idx) {
      continue;
    }
    /* Decision: the point is inside the box (4 conditions, half-open on the
     * right/bottom edges so abutting figures never both claim a tap). */
    if ((x >= box->x) && (x < (box->x + box->w)) && (y >= box->y) && (y < (box->y + box->h))) {
      *out_index = i;
      return k_ra8_ok;
    }
  }
  return k_ra8_err_not_found;
}
 
ra8_err_t
reflow_find_anchor(const reflow_t* engine, const char* id, uint32_t id_len, uint32_t* out_page)
{
  RA8_CHECK_NULL_PTR(engine, s_tag_link, "anchor: null engine");
  RA8_CHECK_NULL_PTR(id, s_tag_link, "anchor: null id");
  RA8_CHECK_NULL_PTR(out_page, s_tag_link, "anchor: null out_page");
  if (id_len == 0U) {
    return k_ra8_err_invalid_arg;
  }
 
  for (uint32_t i = 0U; i < engine->anchor_count; ++i) {
    const reflow_anchor_t* anchor = &engine->anchors[i];
    bool                   equal  = anchor->id_len == id_len;
    for (uint32_t j = 0U; equal && (j < id_len); ++j) {
      if (engine->text_pool[anchor->id_off + j] != (uint8_t)id[j]) {
        equal = false;
      }
    }
    if (equal) {
      *out_page = anchor->page_index;
      return k_ra8_ok;
    }
  }
  return k_ra8_err_not_found;
}

RA8_INTERNAL
static bool internal_has_scheme(const char* href, uint32_t end)
{
  for (uint32_t i = 0U; i < end; ++i) {
    if (href[i] == '/') {
      return false;
    }
    if (href[i] == ':') {
      return true;
    }
  }
  return false;
}

RA8_INTERNAL
static void internal_href_classify(const char*         href,
                                   uint32_t            len,
                                   reflow_href_kind_t* out_kind,
                                   uint32_t*           out_path_len,
                                   uint32_t*           out_frag_off,
                                   uint32_t*           out_frag_len)
{
  uint32_t hash = len;
  for (uint32_t i = 0U; i < len; ++i) {
    if (href[i] == '#') {
      hash = i;
      break;
    }
  }
  if (internal_has_scheme(href, hash)) {
    *out_kind     = k_reflow_href_external;
    *out_path_len = len;
    return;
  }
  const bool has_frag = (hash < len);
  *out_path_len       = hash;
  if (has_frag) {
    *out_frag_off = hash + 1U;
    *out_frag_len = len - hash - 1U;
  }
  if (hash == 0U) {
    *out_kind = has_frag ? k_reflow_href_fragment : k_reflow_href_empty;
  } else {
    *out_kind = has_frag ? k_reflow_href_chapter_fragment : k_reflow_href_chapter;
  }
}
 
ra8_err_t reflow_href_split(const char*         href,
                            uint32_t            len,
                            reflow_href_kind_t* out_kind,
                            uint32_t*           out_path_len,
                            uint32_t*           out_frag_off,
                            uint32_t*           out_frag_len)
{
  RA8_CHECK_NULL_PTR(href, s_tag_link, "split: null href");
  RA8_CHECK_NULL_PTR(out_kind, s_tag_link, "split: null out_kind");
  RA8_CHECK_NULL_PTR(out_path_len, s_tag_link, "split: null out_path_len");
  RA8_CHECK_NULL_PTR(out_frag_off, s_tag_link, "split: null out_frag_off");
  RA8_CHECK_NULL_PTR(out_frag_len, s_tag_link, "split: null out_frag_len");
 
  *out_path_len = 0U;
  *out_frag_off = 0U;
  *out_frag_len = 0U;
  if (len == 0U) {
    *out_kind = k_reflow_href_empty;
    return k_ra8_ok;
  }
  internal_href_classify(href, len, out_kind, out_path_len, out_frag_off, out_frag_len);
  return k_ra8_ok;
}