LNXCORE/Kinc/Sources/kinc/libs/misc/dlo/dlo-text.c

/*
 * lws abstract display
 *
 * Copyright (C) 2019 - 2022 Andy Green <andy@warmcat.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
 * deal in the Software without restriction, including without limitation the
 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
 * sell copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
 * IN THE SOFTWARE.
 *
 * Display List Object: text
 */

#include <private-lib-core.h>
#include "private-lib-drivers-display-dlo.h"

size_t
utf8_bytes(uint8_t u)
{
	if ((u & 0x80) == 0)
		return 1;

	if ((u & 0xe0) == 0xc0)
		return 2;

	if ((u & 0xf0) == 0xe0)
		return 3;

	if ((u & 0xf8) == 0xf0)
		return 4;

	return 0;
}

static int
utf8_unicode(const char *utf8, size_t *utf8_len, uint32_t *unicode)
{
	size_t glyph_len = utf8_bytes((uint8_t)*utf8);
	size_t n;

	if (!glyph_len || glyph_len > *utf8_len) {
		(*utf8_len)--;
		return 1;
	}

	if (glyph_len == 1)
		*unicode = (uint32_t)*utf8++;
	else {
		*unicode = (uint32_t)((*utf8++) & (0x7f >> glyph_len));
		for (n = 1; n < glyph_len; n++)
			*unicode = (*unicode << 6) | ((*utf8++) & 0x3f);
	}

	*utf8_len -= glyph_len;

	return 0;
}

void
lws_display_dlo_text_destroy(struct lws_dlo *dlo)
{
	lws_dlo_text_t *text = lws_container_of(dlo, lws_dlo_text_t, dlo);

	lws_free_set_NULL(text->kern);
	lws_free_set_NULL(text->text);

	lwsac_free(&text->ac_glyphs);
}

int
lws_display_dlo_text_update(lws_dlo_text_t *text, lws_display_colour_t dc,
			    lws_fx_t indent, const char *utf8, size_t text_len)
{
	const char *last_utf8 = utf8, *outf8 = utf8;
	size_t last_bp_n = 0, tlen = text_len;
	lws_fx_t t1, eff, last_bp_eff, t2;
	uint8_t r = 0;
	char uc;

	if (text->kern)
		lws_free_set_NULL(text->kern);

	if (text->text)
		lws_free_set_NULL(text->text);

	lws_dll2_owner_clear(&text->glyphs);
	lwsac_free(&text->ac_glyphs);

	text->indent = indent;
	text->dlo.dc = dc;

	lws_fx_set(eff, 0, 0);

	/*
	 * Let's go through the new string glyph by glyph, we want to
	 * calculate effective kerned widths, and optionally deal with wrapping.
	 *
	 * But we don't want to instantiate the glyph objects until we are
	 * engaged with rendering them.  Otherwise we will carry around the
	 * whole page-worth's of glyphs at once needlessly, which won't scale
	 * for text-heavy pages.  lws_display_dlo_text_attach_glyphs() does the
	 * same flow as this but to create the glyphs and is called later
	 * as the text dlo becomes rasterized during rendering.
	 */

/*	{ char b1[22]; lwsl_err("eff %s\n", lws_fx_string(&eff, b1, sizeof(b1))); }
	{ char b1[22]; lwsl_err("indent %s\n", lws_fx_string(&indent, b1, sizeof(b1))); }
	{ char b1[22]; lwsl_err("boxw %s\n", lws_fx_string(&text->dlo.box.w, b1, sizeof(b1))); } */

	while (tlen &&
	       lws_fx_comp(lws_fx_add(&t1, &eff, &indent), &text->dlo.box.w) < 0) {
		size_t ot = tlen;
		uint32_t unicode;

		if (!utf8_unicode(utf8, &tlen, &unicode)) {
			text->font->image_glyph(text, unicode, 0);

			uc = *utf8;
			utf8 += (ot - tlen);

			if (uc == ' ') { /* act to snip it if used */
				last_utf8 = utf8;
				last_bp_n = tlen;
				last_bp_eff = eff;
			}

			if (!lws_display_font_mcufont_getcwidth(text, unicode, &t2))
				lws_fx_add(&eff, &eff, &t2);

			if (uc == '-' || uc == ',' || uc == ';' || uc == ':') {
				/* act to leave it in */
				last_utf8 = utf8;
				last_bp_n = tlen;
				last_bp_eff = eff;
			}
		} else
			lwsl_err("%s: missing glyph\n", __func__);
	}

	if (last_bp_n &&
	    lws_fx_comp(lws_fx_add(&t1, &eff, &indent), &text->dlo.box.w) >= 0) {
		eff = last_bp_eff;
		utf8 = last_utf8;
		tlen = last_bp_n;
		r = 1;
	}

	text->text_len = text_len - tlen;
	if (tlen == text_len) {
		lwsl_notice("we couldn't fit anything in there, newline\n");
		return 2;
	}

	text->text = lws_malloc(text->text_len + 1, __func__);
	if (!text->text)
		return -1;

	memcpy(text->text, outf8, text->text_len);
	text->text[text->text_len] = '\0';

	memset(&text->bounding_box, 0, sizeof(text->bounding_box));
	text->bounding_box.w = eff;
	text->bounding_box.h.whole = text->font_height;
	text->bounding_box.h.frac = 0;

	return r;
}

int
lws_display_dlo_text_attach_glyphs(lws_dlo_text_t *text)
{
	const char *utf8 = text->text;
	size_t tlen = text->text_len;
	lws_font_glyph_t *g = NULL;
	uint32_t unicode;
	lws_fx_t eff;
	uint8_t r = 0;

	lws_fx_set(eff, 0, 0);

	while (tlen) {
		size_t ot = tlen;

		g = NULL;
		if (!utf8_unicode(utf8, &tlen, &unicode))
			/* instantiate the glyphs this time */
			g = text->font->image_glyph(text, unicode, 1);
		if (g == NULL) {
			lwsl_warn("%s: no glyph for 0x%02X '%c'\n", __func__, (unsigned int)*utf8, *utf8);
			break;
		}

		utf8 += (ot - tlen);
		g->xpx = eff;
		lws_fx_add(&eff, &eff, &g->cwidth);
	}

	return r;
}

lws_dlo_text_t *
lws_display_dlo_text_new(lws_displaylist_t *dl, lws_dlo_t *dlo_parent,
			 lws_box_t *box, const lws_display_font_t *font)
{
	lws_dlo_text_t *text = lws_zalloc(sizeof(*text), __func__);

	if (!text)
		return NULL;

	text->dlo.render = font->renderer;
	text->dlo._destroy = lws_display_dlo_text_destroy;
	text->dlo.box = *box;
	text->font = font;

	lws_display_dlo_add(dl, dlo_parent, &text->dlo);

	return text;
}

static const char *
castrstr(const char *haystack, const char *needle)
{
	size_t sn = strlen(needle), h = strlen(haystack) - sn + 1, n;
	char c, c1;

	while (1) {
		for (n = 0; n < sn; n++) {
			c = (char)((haystack[h + n] >= 'A' && haystack[h + n] <= 'Z') ?
				haystack[h + n] + ('a' - 'A') : haystack[h + n]);
			c1 = (char)((needle[n] >= 'A' && needle[n] <= 'Z') ?
				needle[n] + ('a' - 'A') : needle[n]);
			if (c != c1)
				break;
		}
		if (n == sn)
			return &haystack[h];

		if (!h)
			break;
		h--;
	}

	return NULL;
}

int
lws_font_register(struct lws_context *cx, const uint8_t *data, size_t data_len)
{
	lws_display_font_t *a;

	if (lws_ser_ru32be(data) != LWS_FOURCC('M', 'C', 'U', 'F'))
		return 1;

	a = lws_zalloc(sizeof(*a), __func__);
	if (!a)
		return 1;

	a->choice.family_name = (const char *)data +
				lws_ser_ru32be(data + MCUFO_FOFS_FULLNAME);

	if (castrstr(a->choice.family_name, "serif") ||
	    castrstr(a->choice.family_name, "roman"))
		a->choice.generic_name = "serif";
	else
		a->choice.generic_name = "sans";

	if (castrstr(a->choice.family_name, "italic") ||
	    castrstr(a->choice.family_name, "oblique"))
		a->choice.style = 1;

	if (castrstr(a->choice.family_name, "extrabold") ||
	    castrstr(a->choice.family_name, "extra bold"))
		a->choice.weight = 900;
	else
		if (castrstr(a->choice.family_name, "bold"))
		    a->choice.weight = 700;
		else
			if (castrstr(a->choice.family_name, "extralight") ||
			    castrstr(a->choice.family_name, "extra light"))
				a->choice.weight = 200;
			else
				if (castrstr(a->choice.family_name, "light"))
					a->choice.weight = 300;
				else
					a->choice.weight = 400;

	a->choice.fixed_height = lws_ser_ru16be(data + MCUFO16_LINE_HEIGHT);

	a->data = data;
	a->data_len = data_len;
	a->renderer = lws_display_font_mcufont_render;
	a->image_glyph = lws_display_font_mcufont_image_glyph;

	{
		lws_dlo_text_t t;

		memset(&t, 0, sizeof(t));
		t.font = a;

		lws_display_font_mcufont_getcwidth(&t, 'm', &a->em);
		a->ex.whole = a->choice.fixed_height;
		a->ex.frac = 0;
	}

	lws_dll2_clear(&a->list);
	lws_dll2_add_tail(&a->list, &cx->fonts);

	return 0;
}

static int
lws_font_destroy(struct lws_dll2 *d, void *user)
{
	lws_free(d);
	return 0;
}

void
lws_fonts_destroy(struct lws_context *cx)
{
	lws_dll2_foreach_safe(&cx->fonts, NULL, lws_font_destroy);
}

struct track {
	const lws_font_choice_t 	*hints;
	const lws_display_font_t	*best;
	int				best_score;
};

static int
lws_fonts_score(struct lws_dll2 *d, void *user)
{
	const lws_display_font_t *f = lws_container_of(d, lws_display_font_t,
						       list);
	struct track *t = (struct track *)user;
	struct lws_tokenize ts;
	int score = 1000;

	if (t->hints->family_name) {
		memset(&ts, 0, sizeof(ts));
		ts.start = t->hints->family_name;
		ts.len = strlen(ts.start);
		ts.flags = LWS_TOKENIZE_F_COMMA_SEP_LIST;

		do {
			ts.e = (int8_t)lws_tokenize(&ts);
			if (ts.e == LWS_TOKZE_TOKEN) {
				if (!strncmp(f->choice.family_name, ts.token,
					     ts.token_len)) {
					score = 0;
					break;
				}

				if (f->choice.generic_name &&
				    !strncmp(f->choice.generic_name, ts.token,
							     ts.token_len)) {
					score -= 500;
					break;
				}

			}

		} while (ts.e > 0);
	}

	if (t->hints->weight)
		score += (t->hints->weight > f->choice.weight ?
			(t->hints->weight - f->choice.weight) :
			(f->choice.weight - t->hints->weight)) / 100;

	if (t->hints->style != f->choice.style)
		score += 100;

	if (t->hints->fixed_height)
		score += 10 * (t->hints->fixed_height > f->choice.fixed_height ?
				(t->hints->fixed_height - f->choice.fixed_height) :
				(f->choice.fixed_height - t->hints->fixed_height));

	if (score < t->best_score) {
		t->best_score = score;
		t->best = f;
	}

	return 0;
}

const lws_display_font_t *
lws_font_choose(struct lws_context *cx, const lws_font_choice_t *hints)
{
	struct track t;

	t.hints			= hints;
	t.best			= (const lws_display_font_t *)cx->fonts.head;
	t.best_score		= 99999999;

	if (t.hints)
		lws_dll2_foreach_safe(&cx->fonts, &t, lws_fonts_score);

	return t.best;
}