n_gui_md.c

Go to the documentation of this file.

/*
 * Nilorea Library
 * Copyright (C) 2005-2026 Castagnier Mickael
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
 * implied. See the License for the specific language governing
 * permissions and limitations under the License.
 *
 * SPDX-License-Identifier: Apache-2.0
 */

 
#include "nilorea/n_gui_md.h"
 
#include "nilorea/n_wrap.h"
 
#include <allegro5/allegro_primitives.h>
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MD_COLS_MAX 32

enum { MD_AT_SPACE = 1,
       MD_AT_NEWLINE = 2 };

typedef struct {
    ALLEGRO_FONT* font;
    const char* url;
    float w;
    unsigned char nbytes;
    unsigned char colid;
    unsigned char flags;
    char bytes[4];
} md_atom;

enum { MD_COL_TEXT = 0,
       MD_COL_LINK,
       MD_COL_CODE,
       MD_COL_HEADING,
       MD_COL_QUOTE };

typedef struct {
    float px, py;
    char* out;
    size_t cap;
    int found;
} md_hit;

enum { MD_MEASURE = 0,
       MD_DRAW,
       MD_HIT };
 
/* ---- helpers ------------------------------------------------------------ */

static int md_cp_len(const char* s, int i, int len) {
    int n = 1;
    if (i >= len)
        return 0;
    while (i + n < len && ((unsigned char)s[i + n] & 0xC0) == 0x80)
        n++;
    return n;
}

static ALLEGRO_FONT* md_font_for(const N_GUI_MD_FONTS* f, unsigned style) {
    ALLEGRO_FONT* r = f->regular;
    if (style & N_MARKDOWN_CODE)
        return f->mono ? f->mono : r;
    if ((style & N_MARKDOWN_BOLD) && (style & N_MARKDOWN_ITALIC))
        return f->bolditalic ? f->bolditalic : (f->bold ? f->bold : (f->italic ? f->italic : r));
    if (style & N_MARKDOWN_BOLD)
        return f->bold ? f->bold : r;
    if (style & N_MARKDOWN_ITALIC)
        return f->italic ? f->italic : r;
    return r;
}

static ALLEGRO_FONT* md_font_heading(const N_GUI_MD_FONTS* f, int level) {
    ALLEGRO_FONT* want = NULL;
    if (level <= 1)
        want = f->h1;
    else if (level == 2)
        want = f->h2;
    else
        want = f->h3;
    if (want)
        return want;
    return f->bold ? f->bold : f->regular;
}
 
static ALLEGRO_COLOR md_col(const N_GUI_MD_STYLE* st, unsigned char colid) {
    switch (colid) {
        case MD_COL_LINK:
            return st->link;
        case MD_COL_CODE:
            return st->code;
        case MD_COL_HEADING:
            return st->heading;
        case MD_COL_QUOTE:
            return st->quote;
        default:
            break;
    }
    return st->text;
}

static ALLEGRO_COLOR md_fade(ALLEGRO_COLOR c, float a) {
    c.r *= a;
    c.g *= a;
    c.b *= a;
    c.a *= a;
    return c;
}

static float md_lh(const N_GUI_MD_FONTS* f, ALLEGRO_FONT* font) {
    return (float)al_get_font_line_height(font ? font : f->regular);
}
 
/* ---- one flow of inline spans -------------------------------------------- */

static void md_wrap_of(const md_atom* a, n_wrap_item* w) {
    w->width = (double)a->w;
    w->flags = ((a->flags & MD_AT_SPACE) ? N_WRAP_SPACE : 0u) |
               ((a->flags & MD_AT_NEWLINE) ? N_WRAP_NEWLINE : 0u);
}

static int md_build_seg(md_atom* out, n_wrap_item* wrap, int cap, int na, const char* text, int len, ALLEGRO_FONT* font, unsigned char colid, const char* url, int hard_nl) {
    int i = 0;
    while (i < len && na < cap) {
        md_atom* a = &out[na];
        a->font = font;
        a->colid = colid;
        a->url = url;
        a->flags = 0;
        a->nbytes = 0;
        a->bytes[0] = '\0';
        if (text[i] == '\n' && !hard_nl) {
            /* A soft newline is a space: one the wrap may break at, and one
               that is drawn if it does not. */
            a->flags = MD_AT_SPACE;
            a->nbytes = 1;
            a->bytes[0] = ' ';
            a->bytes[1] = '\0';
            a->w = (float)al_get_text_width(font, " ");
            md_wrap_of(a, &wrap[na]);
            na++;
            i++;
            continue;
        }
        if (text[i] == '\n') {
            a->flags = MD_AT_NEWLINE;
            a->w = 0.0f;
            md_wrap_of(a, &wrap[na]);
            na++;
            i++;
            continue;
        }
        {
            int bl = md_cp_len(text, i, len);
            char g[8];
            if (bl > 4)
                bl = 4;
            memcpy(g, text + i, (size_t)bl);
            g[bl] = '\0';
            a->w = (float)al_get_text_width(font, g);
            a->nbytes = (unsigned char)bl;
            memcpy(a->bytes, g, (size_t)bl);
            if (text[i] == ' ' || text[i] == '\t')
                a->flags = MD_AT_SPACE;
            md_wrap_of(a, &wrap[na]);
            na++;
            i += bl;
        }
    }
    return na;
}

typedef struct {
    const md_atom* a;
    const N_GUI_MD_STYLE* st;
    float x, y, lh, avail;
    int mode;
    unsigned char align;
    md_hit* hit;
} md_line_ctx;

static void md_flush_line(const md_line_ctx* c, size_t from, size_t to, float y, float line_w) {
    char buf[1024];
    size_t k;
    int blen = 0;
    ALLEGRO_FONT* bfont = NULL;
    unsigned char bcol = 0;
    float x0 = c->x, rx, bx;
 
    /* Alignment is applied here rather than in the wrap, which reports the
     * line's own width precisely so that this can. */
    if (c->align == N_MARKDOWN_ALIGN_CENTER)
        x0 += (c->avail - line_w) * 0.5f;
    else if (c->align == N_MARKDOWN_ALIGN_RIGHT)
        x0 += c->avail - line_w;
    if (x0 < c->x)
        x0 = c->x;
    rx = x0;
    bx = x0;
 
    if (c->mode == MD_HIT) {
        for (k = from; k < to; k++) {
            const md_atom* at = &c->a[k];
            if (at->url && c->hit->px >= rx && c->hit->px < rx + at->w &&
                c->hit->py >= y && c->hit->py < y + c->lh) {
                if (c->hit->cap)
                    (void)snprintf(c->hit->out, c->hit->cap, "%s", at->url);
                c->hit->found = 1;
            }
            rx += at->w;
        }
        return;
    }
    for (k = from; k < to; k++) {
        const md_atom* at = &c->a[k];
        if (!at->nbytes)
            continue;
        if (blen && (at->font != bfont || at->colid != bcol ||
                     blen + at->nbytes >= (int)sizeof(buf))) {
            al_draw_text(bfont, md_col(c->st, bcol), bx, y, 0, buf);
            blen = 0;
        }
        if (blen == 0) {
            bfont = at->font;
            bcol = at->colid;
            bx = rx;
        }
        memcpy(buf + blen, at->bytes, at->nbytes);
        blen += at->nbytes;
        buf[blen] = '\0';
        rx += at->w;
    }
    if (blen)
        al_draw_text(bfont, md_col(c->st, bcol), bx, y, 0, buf);
}
 
// cppcheck-suppress constParameterCallback ; callback signature must match n_wrap_emit
static void md_emit_line(size_t first, size_t last, size_t line, double width, void* user) {
    const md_line_ctx* c = (const md_line_ctx*)user;
    md_flush_line(c, first, last, c->y + (float)line * c->lh, (float)width);
}

static float md_flow(const N_GUI_MD_FONTS* f, const N_GUI_MD_STYLE* st, const char* prefix, const n_markdown_span* spans, size_t nspans, float x, float y, float w, float lh, ALLEGRO_FONT* base_font, unsigned style_or, unsigned char colid, unsigned char align, int hard_nl, int mode, md_hit* hit) {
    size_t total = prefix ? strlen(prefix) : 0, i;
    md_atom* atoms;
    n_wrap_item* wrap;
    md_line_ctx ctx;
    int na = 0;
    size_t lines;
 
    for (i = 0; i < nspans; i++)
        total += spans[i].text ? strlen(spans[i].text) : 0;
    if (total == 0)
        return lh; /* an empty flow still occupies its line */
    if (w < 1.0f)
        w = 1.0f;
    /* One atom per codepoint at most, so the byte count bounds both arrays;
     * one allocation for the pair keeps the failure path single. */
    atoms = malloc(total * (sizeof(*atoms) + sizeof(*wrap)));
    if (!atoms)
        return lh;
    wrap = (n_wrap_item*)(void*)(atoms + total);
    if (prefix)
        na = md_build_seg(atoms, wrap, (int)total, na, prefix, (int)strlen(prefix),
                          base_font ? base_font : f->regular, colid, NULL, hard_nl);
    for (i = 0; i < nspans; i++) {
        unsigned sty = spans[i].style | style_or;
        int is_link = (sty & N_MARKDOWN_LINK) ? 1 : 0;
        int is_code = (sty & N_MARKDOWN_CODE) ? 1 : 0;
        unsigned char cid = colid;
        ALLEGRO_FONT* font;
        if (is_link)
            cid = MD_COL_LINK;
        else if (is_code)
            cid = MD_COL_CODE;
        if (!spans[i].text)
            continue;
        if (base_font)
            font = (is_code && f->mono) ? f->mono : base_font;
        else
            font = md_font_for(f, sty);
        na = md_build_seg(atoms, wrap, (int)total, na, spans[i].text,
                          (int)strlen(spans[i].text), font, cid,
                          is_link ? spans[i].url : NULL,
                          /* a code span keeps its own breaks whatever the
                             document asks for: it is preformatted text */
                          hard_nl || (sty & N_MARKDOWN_CODE) ? 1 : 0);
    }
 
    ctx.a = atoms;
    ctx.st = st;
    ctx.x = x;
    ctx.y = y;
    ctx.lh = lh;
    ctx.avail = w;
    ctx.mode = mode;
    ctx.align = align;
    ctx.hit = hit;
    lines = n_wrap_layout(wrap, (size_t)na, (double)w,
                          mode == MD_MEASURE ? NULL : md_emit_line, &ctx);
    free(atoms);
    return (float)lines * lh;
}

static float md_flow_width(const N_GUI_MD_FONTS* f, const n_markdown_span* spans, size_t nspans, unsigned style_or) {
    float sum = 0.0f;
    size_t i;
    for (i = 0; i < nspans; i++) {
        ALLEGRO_FONT* font = md_font_for(f, spans[i].style | style_or);
        const char* t = spans[i].text;
        int len = t ? (int)strlen(t) : 0;
        int j = 0;
        while (j < len) {
            int bl = md_cp_len(t, j, len);
            char g[8];
            if (bl > 4)
                bl = 4;
            memcpy(g, t + j, (size_t)bl);
            g[bl] = '\0';
            sum += (float)al_get_text_width(font, g);
            j += bl;
        }
    }
    return sum;
}
 
/* ---- tables -------------------------------------------------------------- */

static void md_table_cols(const N_GUI_MD_FONTS* f, const N_GUI_MD_STYLE* st, const n_markdown_block* b, float avail, float* out) {
    size_t cols = b->n_cols, rows = b->n_cols ? b->n_items / b->n_cols : 0;
    size_t c, r;
    float pad2 = st->cell_pad * 2.0f, sum = 0.0f;
 
    if (cols > MD_COLS_MAX)
        cols = MD_COLS_MAX;
    for (c = 0; c < cols; c++) {
        float want = 0.0f;
        for (r = 0; r < rows; r++) {
            const n_markdown_inline* cell = &b->items[r * b->n_cols + c];
            float cw = md_flow_width(f, cell->spans, cell->n_spans,
                                     r == 0 ? N_MARKDOWN_BOLD : 0u);
            if (cw > want)
                want = cw;
        }
        out[c] = want + pad2;
        sum += out[c];
    }
    if (sum <= avail || sum <= 0.0f)
        return;
    {
        float scaled = 0.0f;
        float k = avail / sum;
        for (c = 0; c < cols; c++) {
            out[c] *= k;
            if (out[c] < st->col_min)
                out[c] = st->col_min;
            scaled += out[c];
        }
        if (scaled > avail) {
            float each = avail / (float)cols;
            for (c = 0; c < cols; c++)
                out[c] = each;
        }
    }
}

static float md_table(const N_GUI_MD_FONTS* f, const N_GUI_MD_STYLE* st, const n_markdown_block* b, float x, float y, float w, int mode, md_hit* hit) {
    float widths[MD_COLS_MAX];
    size_t cols = b->n_cols, rows = b->n_cols ? b->n_items / b->n_cols : 0;
    size_t c, r;
    float used = 0.0f;
    float lh = md_lh(f, f->regular);
 
    if (!cols || !rows)
        return 0.0f;
    if (cols > MD_COLS_MAX)
        cols = MD_COLS_MAX;
    md_table_cols(f, st, b, w, widths);
 
    for (r = 0; r < rows; r++) {
        float cx = x, row_h = 0.0f;
        unsigned style_or = (r == 0) ? N_MARKDOWN_BOLD : 0u;
 
        /* The row's height comes from a measure pass over every cell, because
         * a cell cannot be drawn until the row's height is known and a cell's
         * own height is not known until it is laid out. */
        for (c = 0; c < cols; c++) {
            const n_markdown_inline* cell = &b->items[r * b->n_cols + c];
            float h = md_flow(f, st, NULL, cell->spans, cell->n_spans, 0.0f, 0.0f,
                              widths[c] - st->cell_pad * 2.0f, lh, NULL, style_or,
                              MD_COL_TEXT, N_MARKDOWN_ALIGN_LEFT, 0, MD_MEASURE, NULL);
            if (h > row_h)
                row_h = h;
        }
        if (mode != MD_MEASURE) {
            for (c = 0; c < cols; c++) {
                const n_markdown_inline* cell = &b->items[r * b->n_cols + c];
                unsigned char al = b->align && c < b->n_cols
                                       ? b->align[c]
                                       : (unsigned char)N_MARKDOWN_ALIGN_LEFT;
                (void)md_flow(f, st, NULL, cell->spans, cell->n_spans,
                              cx + st->cell_pad, y + used,
                              widths[c] - st->cell_pad * 2.0f, lh, NULL, style_or,
                              MD_COL_TEXT, al, 0, mode, hit);
                cx += widths[c];
            }
        }
        used += row_h;
        if (r == 0) {
            /* the rule under the header, which is what makes the rest read as
             * rows of a table rather than as three columns of loose words */
            float total = 0.0f;
            for (c = 0; c < cols; c++)
                total += widths[c];
            if (mode == MD_DRAW)
                al_draw_line(x, y + used + 1.0f, x + total, y + used + 1.0f, st->rule, 1.0f);
            used += 3.0f;
        }
    }
    return used;
}
 
/* ---- the document ------------------------------------------------------- */

static float md_run(const N_GUI_MD_FONTS* f, const N_GUI_MD_STYLE* st, float x, float y, float w, const char* text, int mode, md_hit* hit) {
    n_markdown_doc doc;
    float lh = md_lh(f, f->regular);
    float used = 0.0f;
    size_t bi, ii;
    int any = 0;
 
    if (!text)
        text = "";
    n_markdown_parse_ex(text, strlen(text), st->parse_flags, &doc);
    for (bi = 0; bi < doc.n_blocks; bi++) {
        const n_markdown_block* blk = &doc.blocks[bi];
        float by = y + used;
        any = 1;
        switch (blk->kind) {
            case N_MARKDOWN_HEADING: {
                ALLEGRO_FONT* hf = md_font_heading(f, blk->level);
                float hlh = md_lh(f, hf);
                float h;
                /* The heading face is imposed on every atom: md_font_heading
                 * has already fallen back to bold, or to regular, so what
                 * comes out is the most heading-like face there is. */
                h = md_flow(f, st, NULL, blk->inl.spans, blk->inl.n_spans, x, by, w, hlh,
                            hf, 0u, MD_COL_HEADING, N_MARKDOWN_ALIGN_LEFT, 0, mode, hit);
                used += h;
                if (blk->level <= 2) {
                    if (mode == MD_DRAW)
                        al_draw_line(x, by + h + 1.0f, x + w, by + h + 1.0f, st->rule, 1.0f);
                    used += 3.0f;
                }
                break;
            }
            case N_MARKDOWN_TABLE:
                used += md_table(f, st, blk, x, by, w, mode, hit);
                break;
            case N_MARKDOWN_QUOTE: {
                float h = md_flow(f, st, NULL, blk->inl.spans, blk->inl.n_spans,
                                  x + st->indent, by, w - st->indent, lh, NULL, 0u,
                                  MD_COL_QUOTE, N_MARKDOWN_ALIGN_LEFT,
                                  st->hard_breaks, MD_MEASURE, NULL);
                if (mode == MD_DRAW)
                    al_draw_filled_rectangle(x, by, x + 2.0f, by + h, st->quote);
                if (mode != MD_MEASURE)
                    (void)md_flow(f, st, NULL, blk->inl.spans, blk->inl.n_spans,
                                  x + st->indent, by, w - st->indent, lh, NULL, 0u,
                                  MD_COL_QUOTE, N_MARKDOWN_ALIGN_LEFT,
                                  st->hard_breaks, mode, hit);
                used += h;
                break;
            }
            case N_MARKDOWN_CODE_BLOCK: {
                n_markdown_span cs;
                float mlh = md_lh(f, f->mono ? f->mono : f->regular);
                float h;
                cs.text = blk->code ? blk->code : (char*)"";
                cs.url = NULL;
                cs.style = N_MARKDOWN_CODE;
                h = md_flow(f, st, NULL, &cs, 1, x + st->indent, by,
                            w - st->indent * 2.0f, mlh, NULL, 0u, MD_COL_CODE,
                            N_MARKDOWN_ALIGN_LEFT, 1, MD_MEASURE, NULL);
                if (mode == MD_DRAW)
                    al_draw_filled_rectangle(x, by - st->cell_pad, x + w,
                                             by + h + st->cell_pad, st->code_bg);
                if (mode != MD_MEASURE)
                    (void)md_flow(f, st, NULL, &cs, 1, x + st->indent, by,
                                  w - st->indent * 2.0f, mlh, NULL, 0u, MD_COL_CODE,
                                  N_MARKDOWN_ALIGN_LEFT, 1, mode, hit);
                used += h + st->cell_pad * 2.0f;
                break;
            }
            case N_MARKDOWN_UL:
            case N_MARKDOWN_OL:
                for (ii = 0; ii < blk->n_items; ii++) {
                    char bullet[32];
                    if (blk->kind == N_MARKDOWN_UL)
                        (void)snprintf(bullet, sizeof(bullet), "-  ");
                    else
                        (void)snprintf(bullet, sizeof(bullet), "%u. ", (unsigned)(ii + 1));
                    used += md_flow(f, st, bullet, blk->items[ii].spans,
                                    blk->items[ii].n_spans, x + st->indent, y + used,
                                    w - st->indent, lh, NULL, 0u, MD_COL_TEXT,
                                    N_MARKDOWN_ALIGN_LEFT, st->hard_breaks, mode, hit);
                }
                break;
            case N_MARKDOWN_PARA:
            default:
                used += md_flow(f, st, NULL, blk->inl.spans, blk->inl.n_spans, x, by, w,
                                lh, NULL, 0u, MD_COL_TEXT, N_MARKDOWN_ALIGN_LEFT, st->hard_breaks, mode,
                                hit);
                break;
        }
        used += st->block_gap;
    }
    n_markdown_free(&doc);
    if (!any)
        return 0.0f;
    return used - st->block_gap; /* trim the gap after the last block */
}
 
/* ---- public ------------------------------------------------------------- */
 
void n_gui_md_style_default(N_GUI_MD_STYLE* out, ALLEGRO_COLOR text, ALLEGRO_COLOR background, float line_height) {
    float level;
    if (!out)
        return;
    if (line_height < 1.0f)
        line_height = 16.0f;
    out->text = text;
    out->heading = text;
    out->link = al_map_rgb(120, 170, 245);
    out->code = text;
    out->quote = text;
    out->rule = text;
    /* The code panel is lifted off a dark background and dropped into a light
     * one, so it reads as a panel either way rather than vanishing into one of
     * the two. A faint wash rather than a mixed colour, because what it sits
     * on is the caller's business. */
    level = (background.r + background.g + background.b) / 3.0f;
    out->code_bg = level > 0.5f ? al_premul_rgba_f(0.0f, 0.0f, 0.0f, 0.06f)
                                : al_premul_rgba_f(1.0f, 1.0f, 1.0f, 0.10f);
    out->rule = md_fade(out->rule, 0.35f);
    out->quote = md_fade(out->quote, 0.80f);
    out->block_gap = line_height * 0.45f;
    out->indent = line_height * 0.8f;
    out->cell_pad = line_height * 0.35f;
    out->col_min = line_height * 2.5f;
    out->parse_flags = N_MARKDOWN_ALL;
    out->hard_breaks = 0;
}
 
float n_gui_md_height(const N_GUI_MD_FONTS* fonts, const N_GUI_MD_STYLE* style, float width, const char* text) {
    if (!fonts || !fonts->regular || !style)
        return 0.0f;
    return md_run(fonts, style, 0.0f, 0.0f, width, text, MD_MEASURE, NULL);
}
 
float n_gui_md_draw(const N_GUI_MD_FONTS* fonts, const N_GUI_MD_STYLE* style, float x, float y, float width, const char* text) {
    if (!fonts || !fonts->regular || !style)
        return 0.0f;
    return md_run(fonts, style, x, y, width, text, MD_DRAW, NULL);
}
 
int n_gui_md_link_at(const N_GUI_MD_FONTS* fonts, const N_GUI_MD_STYLE* style, float x, float y, float width, const char* text, float px, float py, char* url, size_t url_cap) {
    md_hit hit;
    if (!fonts || !fonts->regular || !style)
        return 0;
    hit.px = px;
    hit.py = py;
    hit.out = url;
    hit.cap = url_cap;
    hit.found = 0;
    if (url && url_cap)
        url[0] = '\0';
    (void)md_run(fonts, style, x, y, width, text, MD_HIT, &hit);
    return hit.found;
}