Onek8/LNXCORE
1
0
Fork 0
Code Pull Requests Activity
Files
de9d602781c90e6a1f1ebb3e4d14bf65903ad343
LNXCORE/Kinc/Sources/kinc/libs/misc/dlo/dlo-lhp.c
Onek8 4c5e729485 Update Files
2025-01-22 17:22:38 +01:00

983 lines
24 KiB
C
Raw Blame History

/*
* 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 LHP layout
*
* The basic flow is logical elements exist in a stack as they are parsed, the
* job of lhp_displaylist_layout() is to translate these into a tree of DLOs,
* having parent-child relationships with (x,y) of the DLO box being an offset
* into a local origin formed from the DLO parent box (which in turn may be
* a child with its origin defined by its parent, etc).
*
* The element stack only exists while it and its parent elements are being
* parsed, it goes out of scope as the element ends. So we must create related
* DLOs by stream-parsing, while we still have everything relevant to hand.
*
* This gets us out of having to run around fixing up DLO (x,y) as we do the
* layout, since the DLO parent-child relationships are static even if their
* content size isn't.
*
*
*/
#include <private-lib-core.h>
#include "private-lib-drivers-display-dlo.h"
/*
* HTML Elements we can deal with for layout
*/
enum {
/* 0 is no match */
LHP_ELEM_BR = 1,
LHP_ELEM_DIV,
LHP_ELEM_TABLE,
LHP_ELEM_TR,
LHP_ELEM_TD,
LHP_ELEM_IMG,
};
static const struct {
const char *elem;
uint8_t elem_len;
} elems[] = {
{ "br", 2 },
{ "div", 3 },
{ "table", 5 },
{ "tr", 2 },
{ "td", 2 },
{ "img", 3 },
};
/*
* Newline moves the psb->cury to cover text that was already placed using the
* old psb->cury as to top of it. So a final newline on the last line of text
* does not create an extra blank line.
*/
static const lws_fx_t two = { 2,0 };
static void
newline(lhp_ctx_t *ctx, lhp_pstack_t *psb, lhp_pstack_t *ps,
lws_displaylist_t *dl)
{
int16_t group_baseline = 9999, group_height = 0;
lws_fx_t line_height = { 0, 0 }, w, add, ew, t1;
const struct lcsp_atr *a;
lws_dlo_t *dlo, *d, *d1;
int t = 0;
if (!psb || !ps) {
lwsl_err("%s: psb/ps NULL!\n", __func__);
return;
}
dlo = (lws_dlo_t *)psb->dlo;
lws_fx_add(&w, lws_csp_px(ps->css_padding[CCPAS_LEFT], ps),
lws_csp_px(ps->css_padding[CCPAS_RIGHT], ps));
if (lws_fx_comp(&w, &psb->widest) > 0)
psb->widest = w;
if (!dlo || !dlo->children.tail)
return;
d = lws_container_of(dlo->children.tail, lws_dlo_t, list);
/*
* We may be at the end of a line of text
*
* Figure out the biggest height on the line, and the total width
*/
while (d) {
t |= d->_destroy == lws_display_dlo_text_destroy;
/* find the "worst" height on the line */
if (lws_fx_comp(&d->box.h, &line_height) > 0)
line_height = d->box.h;
if (d->_destroy == lws_display_dlo_text_destroy) {
lws_dlo_text_t *text = lws_container_of(d,
lws_dlo_text_t, dlo.list);
if (text->font_y_baseline < group_baseline)
group_baseline = text->font_y_baseline;
if (text->font_height > group_height)
group_height = text->font_height;
}
if (!d->flag_runon)
break;
d = lws_container_of(d->list.prev, lws_dlo_t, list);
};
/* mark the related text dlos with information about group bl and h,
* offset box y to align to group baseline if necessary */
d1 = d;
while (d) {
if (d->_destroy == lws_display_dlo_text_destroy) {
lws_dlo_text_t *t1 = lws_container_of(d1,
lws_dlo_text_t, dlo.list);
lws_fx_t ft;
t1->group_height = group_height;
t1->group_y_baseline = group_baseline;
ft.whole = (t1->font_height - t1->font_y_baseline) -
(group_height - group_baseline);
ft.frac = 0;
lws_fx_sub(&t1->dlo.box.y, &t1->dlo.box.y, &ft);
}
if (!d1->list.next)
break;
d1 = lws_container_of(d1->list.next, lws_dlo_t, list);
};
w = psb->curx;
ew = ctx->ic.wh_px[0];
if (psb->css_width && psb->css_width->unit != LCSP_UNIT_NONE)
ew = *lws_csp_px(psb->css_width, psb);
lws_fx_sub(&ew, &ew, lws_csp_px(ps->css_margin[CCPAS_RIGHT], ps));
lws_fx_sub(&ew, &ew, lws_csp_px(ps->css_padding[CCPAS_RIGHT], ps));
if (lws_fx_comp(&w, &psb->widest) > 0)
psb->widest = w;
if (!t) /* no textual children to newline (eg, <div></div>) */
return;
/*
* now is our chance to fix up dlos that are part of the line for
* text-align rule of the container.
*/
a = lws_css_cascade_get_prop_atr(ctx, LCSP_PROP_TEXT_ALIGN);
if (a) {
switch (a->propval) {
case LCSP_PROPVAL_CENTER:
add = *lws_csp_px(ps->css_padding[CCPAS_LEFT], ps);
lws_fx_sub(&t1, &ew, &w);
lws_fx_div(&t1, &t1, &two);
lws_fx_add(&add, &add, &t1);
goto fixup;
case LCSP_PROPVAL_RIGHT:
lws_fx_sub(&add, &ew, &w);
lws_fx_sub(&add, &add, &d->box.x);
fixup:
lws_fx_add(&t1, &add, &w);
if (lws_fx_comp(&t1, &psb->widest) > 0)
psb->widest = t1;
do {
lws_fx_add(&d->box.x, &d->box.x, &add);
if (!d->list.next)
break;
d = lws_container_of(d->list.next, lws_dlo_t,
list);
} while (1);
break;
default:
break;
}
}
lws_fx_add(&psb->cury, &psb->cury, &line_height);
lws_fx_set(psb->curx, 0, 0);
psb->dlo_set_curx = NULL;
psb->dlo_set_cury = NULL;
psb->runon = 0;
}
void
lhp_set_dlo_padding_margin(lhp_pstack_t *ps, lws_dlo_t *dlo)
{
int n;
for (n = 0; n < 4; n ++) {
if (ps->css_margin[n])
dlo->margin[n] = *lws_csp_px(ps->css_margin[n], ps);
else
lws_fx_set(dlo->margin[n], 0, 0);
if (ps->css_padding[n])
dlo->padding[n] = *lws_csp_px(ps->css_padding[n], ps);
else
lws_fx_set(dlo->padding[n], 0, 0);
}
}
void
lhp_set_dlo_adjust_to_contents(lhp_pstack_t *ps)
{
lhp_pstack_t *psb = lws_container_of(ps->list.prev, lhp_pstack_t, list);
lws_dlo_dim_t dim;
lws_dlo_contents(ps->dlo, &dim);
lws_display_dlo_adjust_dims(ps->dlo, &dim);
if (lws_fx_comp(&dim.w, &psb->widest) > 0)
psb->widest = dim.w;
if (lws_fx_comp(&dim.h, &psb->deepest) > 0)
psb->deepest = dim.h;
}
static void
runon(lhp_pstack_t *ps, lws_dlo_t *dlo)
{
dlo->flag_runon = (uint8_t)(ps->runon & 1);
ps->runon = 1;
}
/*
* Handle end-of-div, table, tr, td retrospective dlo dimension adjustment
*/
int
lws_lhp_dlo_adjust_div_type_element(lhp_ctx_t *ctx, lhp_pstack_t *psb,
lhp_pstack_t *pst, lhp_pstack_t *ps,
int elem_match)
{
lws_dlo_rect_t *rect = (lws_dlo_rect_t *)ps->dlo;
lws_fx_t t1, w, wd;
char rd = 0;
/* need this to get bottom clearance for next block */
lws_fx_add(&ps->cury, &ps->cury,
lws_csp_px(ps->css_padding[CCPAS_BOTTOM], ps));
if (psb && ps->dlo &&
ps->css_margin[CCPAS_LEFT]->propval == LCSP_PROPVAL_AUTO &&
ps->css_margin[CCPAS_RIGHT]->propval == LCSP_PROPVAL_AUTO) {
lws_dlo_rect_t *re = (lws_dlo_rect_t *)ps->dlo;
/* h-center a div... find the available h space first */
w = ctx->ic.wh_px[LWS_LHPREF_WIDTH];
if (psb->css_width &&
psb->css_width->propval != LCSP_PROPVAL_AUTO)
w = *lws_csp_px(psb->css_width, psb);
lws_fx_sub(&t1, &w, &re->dlo.box.w);
lws_fx_div(&t1, &t1, &two);
lws_fx_sub(&wd, &t1, &re->dlo.box.x);
lws_fx_add(&re->dlo.box.x, &re->dlo.box.x, &wd);
}
/* fix up the dimensions of div rectangle */
if (!rect) {
lwsl_notice("%s: elem %d: NO RECT\n", __func__, elem_match);
return 1;
}
lhp_set_dlo_adjust_to_contents(ps);
/* if a td, deal with columnar changes in width */
if (ps->dlo->col_list.owner) {
lhp_table_col_t *tc = lws_container_of(
ps->dlo->col_list.owner,
lhp_table_col_t, col_dlos);
lws_fx_t wdelta, ow;
ow = tc->width;
lws_fx_set(tc->width, 0, 0);
/* discover the new width of column */
lws_start_foreach_dll(struct lws_dll2 *, c1,
lws_dll2_get_head(&tc->col_dlos)) {
lws_dlo_t *dloc = lws_container_of(c1,
lws_dlo_t, col_list);
if (lws_fx_comp(&dloc->box.w, &tc->width) > 0)
tc->width = dloc->box.w;
} lws_end_foreach_dll(c1);
/* new width - old column width */
lws_fx_sub(&wdelta, &tc->width, &ow);
/*
* Update all dlos in our column (except
* ourselves) with the increased column width
*/
lws_start_foreach_dll(struct lws_dll2 *, cold,
lws_dll2_get_head(&tc->col_dlos)) {
lws_dlo_t *dloc = lws_container_of(cold,
lws_dlo_t, col_list);
if (dloc != &rect->dlo)
/* we already did this for the
* affected dlo */
lws_fx_add(&dloc->box.w,
&dloc->box.w, &wdelta);
rd = 1;
/* ... and then all of their row-mates
* to the right also need their
* x adjusting then */
while (dloc->row_list.next) {
dloc = lws_container_of(
dloc->row_list.next,
lws_dlo_t, row_list);
lws_fx_add(&dloc->box.x,
&dloc->box.x, &wdelta);
}
} lws_end_foreach_dll(cold);
}
/* if a td, deal with row changes in height */
if (ps->dlo->row_list.owner) {
lhp_table_row_t *tr = lws_container_of(
ps->dlo->row_list.owner,
lhp_table_row_t, row_dlos);
lws_fx_t hdelta, oh;
oh = tr->height;
lws_fx_set(tr->height, 0, 0);
/* discover the new width of column */
lws_start_foreach_dll(struct lws_dll2 *, r1,
lws_dll2_get_head(&tr->row_dlos)) {
lws_dlo_t *dlor = lws_container_of(r1,
lws_dlo_t, row_list);
if (lws_fx_comp(&dlor->box.h, &tr->height) > 0)
tr->height = dlor->box.h;
} lws_end_foreach_dll(r1);
/* new height - old row height */
lws_fx_sub(&hdelta, &tr->height, &oh);
/*
* Update all dlos in our row (except
* ourselves) with the increased row height
*/
lws_start_foreach_dll(struct lws_dll2 *, rold,
lws_dll2_get_head(&tr->row_dlos)) {
lws_dlo_t *dlor = lws_container_of(rold,
lws_dlo_t, row_list);
if (dlor != &rect->dlo)
/* we already did this for the
* affected dlo */
lws_fx_add(&dlor->box.h,
&dlor->box.h, &hdelta);
/* ... so all of their col-mates below
* also need their y adjusting then */
while (dlor->col_list.next) {
dlor = lws_container_of(
dlor->col_list.next,
lws_dlo_t, col_list);
lws_fx_add(&dlor->box.y,
&dlor->box.y, &hdelta);
}
rd = 1;
} lws_end_foreach_dll(rold);
}
/*
* Row dimensions have to be reassessed?
*/
if (rd) {
lws_start_foreach_dll(struct lws_dll2 *, ro,
lws_dll2_get_head(&pst->dlo->children)) {
lws_dlo_t *dlo = lws_container_of(ro, lws_dlo_t, list);
lws_dlo_dim_t dim;
lws_dlo_contents(dlo, &dim);
lws_display_dlo_adjust_dims(dlo, &dim);
} lws_end_foreach_dll(ro);
}
if (psb && ps->css_position->propval != LCSP_PROPVAL_ABSOLUTE) {
/* parent should account for our margin */
if (elem_match == LHP_ELEM_DIV) {
lws_fx_add(&psb->curx, &psb->curx, &ps->widest);
/* now we applied ps->widest, reset it */
lws_fx_set(ps->widest, 0, 0);
psb->dlo_set_curx = ps->dlo;
} else {
/* needed for margin between table cells */
lws_fx_add(&psb->curx, &psb->curx, lws_csp_px(ps->css_margin[CCPAS_LEFT], ps));
lws_fx_add(&psb->curx, &psb->curx, lws_csp_px(ps->css_margin[CCPAS_RIGHT], ps));
}
if (elem_match != LHP_ELEM_TD) {
if (ps->css_display->propval != LCSP_PROPVAL_INLINE_BLOCK) {
lws_fx_add(&psb->cury, &psb->cury, &ps->dlo->box.h);
psb->dlo_set_cury = ps->dlo;
}
// lws_fx_add(&psb->cury, &psb->cury, &ps->dlo->margin[CCPAS_BOTTOM]);
} else
ps->widest = ps->dlo->box.w;
}
return 0;
}
/*
* Generic LHP displaylist object layout callback... converts html elements
* into DLOs on the display list
*/
lws_stateful_ret_t
lhp_displaylist_layout(lhp_ctx_t *ctx, char reason)
{
lhp_pstack_t *psb = NULL, *pst = NULL, *psp = NULL,
*ps = lws_container_of(ctx->stack.tail, lhp_pstack_t, list);
struct lws_context *cx = (struct lws_context *)ctx->user1;
lws_dl_rend_t *drt = (lws_dl_rend_t *)ctx->user;
lws_fx_t br[4], t1, indent, ox, w, h;
const lws_display_font_t *f = NULL;
lhp_table_col_t *tcol = NULL;
lhp_table_row_t *trow = NULL;
lws_dlo_t *abut_x, *abut_y;
uint32_t col = 0xff000000;
lws_dlo_text_t *txt;
const lcsp_atr_t *a;
lws_dlo_image_t u;
const char *pname;
char lastm = 0;
int elem_match;
lws_box_t box;
char url[128];
int n, s = 0;
/* default font choice */
lws_font_choice_t fc = {
.family_name = "term, serif",
.fixed_height = 16,
.weight = 400,
};
if (!ps->font) {
a = lws_css_cascade_get_prop_atr(ctx, LCSP_PROP_FONT_SIZE);
if (a)
fc.fixed_height = (uint16_t)a->u.i.whole;
a = lws_css_cascade_get_prop_atr(ctx, LCSP_PROP_FONT_FAMILY);
if (a)
fc.family_name = (const char *)&a[1];
a = lws_css_cascade_get_prop_atr(ctx, LCSP_PROP_FONT_WEIGHT);
if (a) {
switch (a->propval) {
case LCSP_PROPVAL_BOLD:
fc.weight = 700;
break;
case LCSP_PROPVAL_BOLDER:
fc.weight = 800;
break;
default:
if (a->u.i.whole)
fc.weight = (uint16_t)a->u.i.whole;
break;
}
}
ps->font = lws_font_choose(cx, &fc);
}
f = ps->font;
psb = lws_css_get_parent_block(ctx, ps);
elem_match = 0;
for (n = 0; n < (int)LWS_ARRAY_SIZE(elems); n++)
if (ctx->npos == elems[n].elem_len &&
!memcmp(ctx->buf, elems[n].elem, elems[n].elem_len))
elem_match = n + 1;
switch (reason) {
case LHPCB_CONSTRUCTED:
case LHPCB_DESTRUCTED:
case LHPCB_COMPLETE:
case LHPCB_FAILED:
break;
case LHPCB_ELEMENT_START:
switch (elem_match) {
case LHP_ELEM_BR:
newline(ctx, psb, ps, drt->dl);
break;
case LHP_ELEM_TR:
if (!psb)
break;
pst = ps;
while (pst && !pst->is_table)
pst = lws_css_get_parent_block(ctx, pst);
if (!pst) {
lwsl_err("%s: td: no table found\n", __func__);
break;
}
pst->curx.whole = 0;
pst->curx.frac = 0;
psb->dlo_set_curx = NULL;
trow = lws_zalloc(sizeof(*trow), __func__);
if (!trow) {
lwsl_err("%s: OOM\n", __func__);
return LWS_SRET_FATAL;
}
lws_dll2_add_tail(&trow->list, &pst->dlo->table_rows);
trow = NULL;
pst->td_idx = 0;
goto do_rect;
case LHP_ELEM_TD:
if (!psb) {
lwsl_err("%s: td: no psb found\n", __func__);
break;
}
pst = ps;
while (pst && !pst->is_table)
pst = lws_css_get_parent_block(ctx, pst);
if (!pst) {
lwsl_err("%s: td: no table found\n", __func__);
break;
}
if (pst->td_idx >= (int)pst->dlo->table_cols.count) {
tcol = lws_zalloc(sizeof(*tcol), __func__);
if (!tcol) {
lwsl_err("%s: OOM\n", __func__);
return LWS_SRET_FATAL;
}
lws_dll2_add_tail(&tcol->list, &pst->dlo->table_cols);
} else {
tcol = lws_container_of(pst->dlo->table_cols.head, lhp_table_col_t, list);
n = pst->td_idx;
while (n--)
tcol = lws_container_of(tcol->list.next, lhp_table_col_t, list);
}
if (pst->dlo->table_rows.tail)
trow = lws_container_of(pst->dlo->table_rows.tail, lhp_table_row_t, list);
goto do_rect;
case LHP_ELEM_TABLE:
ps->is_table = 1;
/* fallthru */
case LHP_ELEM_DIV:
do_rect:
lws_fx_set(box.x, 0, 0);
lws_fx_set(box.y, 0, 0);
lws_fx_set(box.h, 0, 0);
lws_fx_set(box.w, 0, 0);
abut_x = NULL;
abut_y = NULL;
if (ps->css_position->propval == LCSP_PROPVAL_ABSOLUTE) {
box.x = *lws_csp_px(ps->css_pos[CCPAS_LEFT], ps);
box.y = *lws_csp_px(ps->css_pos[CCPAS_TOP], ps);
} else {
if (psb) {
/* margin adjusts our child box origin */
lws_fx_add(&box.x, &psb->curx,
lws_csp_px(ps->css_margin[CCPAS_LEFT], ps));
box.y = psb->cury;
abut_x = psb->dlo_set_curx;
abut_y = psb->dlo_set_cury;
//lws_fx_add(&box.y, &psb->cury,
// lws_csp_px(ps->css_margin[CCPAS_TOP], ps));
}
}
/* If there's an explicit width, try to go with that */
if (ps->css_width &&
ps->css_width->unit != LCSP_UNIT_NONE &&
lws_fx_comp(lws_csp_px(ps->css_width, ps), &box.w) < 0)
box.w = *lws_csp_px(ps->css_width, ps);
/* !!! we rely on this being nonzero to not infinite loop at text layout */
lws_fx_add(&box.w, &box.w,
lws_csp_px(ps->css_padding[CCPAS_LEFT], ps));
lws_fx_add(&box.w, &box.w,
lws_csp_px(ps->css_padding[CCPAS_RIGHT], ps));
ps->drt.w = box.w;
ps->curx = *lws_csp_px(ps->css_padding[CCPAS_LEFT], ps);
ps->cury = *lws_csp_px(ps->css_padding[CCPAS_TOP], ps);
memset(br, 0, sizeof(br));
if (ps->css_border_radius[0])
br[0] = *lws_csp_px(ps->css_border_radius[0], ps);
if (ps->css_border_radius[1])
br[1] = *lws_csp_px(ps->css_border_radius[1], ps);
if (ps->css_border_radius[2])
br[2] = *lws_csp_px(ps->css_border_radius[2], ps);
if (ps->css_border_radius[3])
br[3] = *lws_csp_px(ps->css_border_radius[3], ps);
psp = lws_container_of(ps->list.prev, lhp_pstack_t, list);
ps->dlo = (lws_dlo_t *)lws_display_dlo_rect_new(drt->dl,
ps->css_position->propval == LCSP_PROPVAL_ABSOLUTE ? NULL : psp->dlo,
&box, br, ps->css_background_color ?
ps->css_background_color->u.rgba : 0);
if (!ps->dlo) {
lwsl_err("%s: FAILED to create rect\n", __func__);
return LWS_SRET_FATAL;
}
ps->dlo->abut_x = abut_x;
ps->dlo->abut_y = abut_y;
if (psb)
lws_fx_add(&psb->curx, &psb->curx,
lws_csp_px(ps->css_margin[CCPAS_RIGHT], ps));
if (tcol)
lws_dll2_add_tail(&ps->dlo->col_list, &tcol->col_dlos);
if (trow)
lws_dll2_add_tail(&ps->dlo->row_list, &trow->row_dlos);
lws_lhp_tag_dlo_id(ctx, ps, ps->dlo);
lhp_set_dlo_padding_margin(ps, ps->dlo);
break;
case LHP_ELEM_IMG:
pname = lws_html_get_atr(ps, "src", 3);
if (!psb)
break;
if (ps->css_position->propval == LCSP_PROPVAL_ABSOLUTE) {
box.x = *lws_csp_px(ps->css_pos[CCPAS_LEFT], ps);
box.y = *lws_csp_px(ps->css_pos[CCPAS_TOP], ps);
} else {
box.x = psb->curx;
box.y = psb->cury;
}
lws_fx_set(box.x, 0, 0);
lws_fx_set(box.y, 0, 0);
if (psb) {
lws_fx_add(&box.x, &box.x,
lws_csp_px(psb->css_margin[CCPAS_LEFT], psb));
lws_fx_add(&box.y, &box.y,
lws_csp_px(psb->css_margin[CCPAS_TOP], psb));
}
box.h = ctx->ic.wh_px[1]; /* placeholder */
lws_fx_sub(&box.w, &ctx->ic.wh_px[0], &box.x);
if (ps->css_width &&
lws_fx_comp(lws_csp_px(ps->css_width, ps), &box.w) > 0)
box.w = *lws_csp_px(ps->css_width, ps);
if (lws_http_rel_to_url(url, sizeof(url),
ctx->base_url, pname))
break;
if (lws_dlo_ss_find(cx, url, &u))
break;
lws_lhp_tag_dlo_id(ctx, ps, (lws_dlo_t *)(u.u.dlo_jpeg));
w = *lws_csp_px(lws_css_cascade_get_prop_atr(ctx,
LCSP_PROP_WIDTH), ps);
h = *lws_csp_px(lws_css_cascade_get_prop_atr(ctx,
LCSP_PROP_HEIGHT), ps);
if (!w.whole || !h.whole) {
w = ((lws_dlo_t *)(u.u.dlo_jpeg))->box.w;
h = ((lws_dlo_t *)(u.u.dlo_jpeg))->box.w;
}
if (psb) {
lws_fx_add(&psb->curx, &psb->curx, &w);
lws_fx_add(&psb->cury, &psb->cury, &h);
psb->dlo_set_curx = ps->dlo;
psb->dlo_set_cury = ps->dlo;
if (lws_fx_comp(&psb->curx, &psb->widest) > 0)
psb->widest = psb->curx;
}
break;
default:
break;
}
break;
case LHPCB_ELEMENT_END:
if (ctx->npos == 2 && ctx->buf[0] == 'h' &&
ctx->buf[1] > '0' && ctx->buf[1] <= '6') {
if (!psb)
break;
newline(ctx, psb, ps, drt->dl);
lws_fx_add(&psb->cury, &psb->cury,
lws_csp_px(ps->css_padding[CCPAS_BOTTOM], ps));
lws_fx_add(&psb->cury, &psb->cury,
lws_csp_px(ps->css_margin[CCPAS_BOTTOM], ps));
break;
}
switch (elem_match) {
case LHP_ELEM_TR:
pst = ps;
while (pst && !pst->is_table)
pst = lws_css_get_parent_block(ctx, pst);
if (!pst) {
lwsl_err("%s: /td: no table\n", __func__);
break;
}
pst->tr_idx++;
pst->td_idx = 0;
goto do_end_rect;
case LHP_ELEM_TD:
pst = ps;
while (pst && !pst->is_table)
pst = lws_css_get_parent_block(ctx, pst);
if (!pst) {
lwsl_err("%s: /td: no table\n", __func__);
break;
}
pst->td_idx++;
goto do_end_rect;
/* fallthru */
case LHP_ELEM_TABLE:
case LHP_ELEM_DIV:
do_end_rect:
ox = ps->curx;
if (lws_fx_comp(&ox, &ps->widest) > 0)
ps->widest = ox;
newline(ctx, ps, ps, drt->dl);
if (lws_lhp_dlo_adjust_div_type_element(ctx, psb, pst, ps, elem_match))
break;
if (lws_fx_comp(&ps->curx, &ps->widest) > 0)
ps->widest = ps->curx;
/* move parent on according to used area plus bottom margin */
if (psb && ps->css_position->propval != LCSP_PROPVAL_ABSOLUTE) {
switch (ps->css_display->propval) {
case LCSP_PROPVAL_BLOCK:
case LCSP_PROPVAL_TABLE:
case LCSP_PROPVAL_TABLE_ROW:
lws_fx_set(psb->curx, 0, 0);
psb->dlo_set_curx = NULL;
if (ps->css_display->propval == LCSP_PROPVAL_TABLE_ROW)
break;
lws_fx_add(&psb->cury, &psb->cury, lws_csp_px(ps->css_margin[CCPAS_BOTTOM], ps));
break;
case LCSP_PROPVAL_INLINE_BLOCK:
//lws_fx_add(&psb->cury, &psb->cury, lws_csp_px(ps->css_margin[CCPAS_BOTTOM], ps));
lws_fx_add(&psb->curx, &psb->curx, &ps->widest);
lws_fx_add(&psb->curx, &psb->curx, lws_csp_px(ps->css_margin[CCPAS_RIGHT], ps));
lws_fx_set(ps->widest, 0, 0);
psb->dlo_set_curx = ps->dlo;
psb->dlo_set_cury = ps->dlo;
break;
default:
lws_fx_add(&psb->curx, &psb->curx, &ps->widest);
psb->dlo_set_curx = ps->dlo;
break;
}
if (lws_fx_comp(&psb->curx, &psb->widest) > 0)
psb->widest = psb->curx;
}
ps->dlo = NULL;
break;
default:
break;
}
break;
case LHPCB_CONTENT:
if (!ps->css_display ||
ps->css_display->propval == LCSP_PROPVAL_NONE)
break;
if (ps->css_color)
col = ps->css_color->u.rgba;
a = lws_css_cascade_get_prop_atr(ctx, LCSP_PROP_FONT_SIZE);
if (a)
fc.fixed_height = (uint16_t)a->u.i.whole;
a = lws_css_cascade_get_prop_atr(ctx, LCSP_PROP_FONT_FAMILY);
if (a)
fc.family_name = (const char *)&a[1];
for (n = 0; n < ctx->npos; n++)
if (ctx->buf[n] == '\n')
s++;
if (s == ctx->npos)
return 0;
/*
* Let's not deal with things off the bottom of the display
* surface.
*/
if (psb && psb->cury.whole > ctx->ic.wh_px[LWS_LHPREF_HEIGHT].whole)
return 0;
if (!psb)
return 0;
f = lws_font_choose(cx, &fc);
n = s;
while (n < ctx->npos) {
int m;
lws_fx_set(box.x, 0, 0);
lws_fx_set(box.y, 0, 0);
lws_fx_set(box.w, 0, 0);
if (n == s && !(psb->runon & 1)) {
lws_fx_set(indent, 0, 0);
} else
indent = psb->curx;
lws_fx_add(&box.x, &indent,
lws_csp_px(ps->css_padding[CCPAS_LEFT], ps));
lws_fx_add(&box.y, &box.y, &psb->cury);
box.h.whole = (int32_t)f->choice.fixed_height;
box.h.frac = 0;
if (psb->css_width &&
(psb->css_width->propval == LCSP_PROPVAL_AUTO ||
ps->css_width->propval == LCSP_PROPVAL_AUTO)) {
//lws_fx_sub(&box.w, &ctx->ic.wh_px[0], &box.x);
box.w = ctx->ic.wh_px[0];
} else {
lws_fx_sub(&t1, &psb->drt.w,
lws_csp_px(psb->css_padding[CCPAS_LEFT], psb));
lws_fx_sub(&box.w, &t1,
lws_csp_px(psb->css_padding[CCPAS_RIGHT], psb));
}
if (!box.w.whole)
lws_fx_sub(&box.w, &ctx->ic.wh_px[0], &box.x);
assert(psb);
txt = lws_display_dlo_text_new(drt->dl,
(lws_dlo_t *)psb->dlo, &box, f);
if (!txt) {
lwsl_err("%s: failed to alloc text\n", __func__);
return 1;
}
runon(psb, &txt->dlo);
txt->flags |= LWSDLO_TEXT_FLAG_WRAP;
lhp_set_dlo_padding_margin(ps, &txt->dlo);
// a = lws_css_cascade_get_prop_atr(ctx, LCSP_PROP_TEXT_ALIGN);
//lwsl_hexdump_notice(ctx->buf + n, (size_t)(ctx->npos - n));
m = lws_display_dlo_text_update(txt, col, indent,
ctx->buf + n,
(size_t)(ctx->npos - n));
if (m < 0) {
lwsl_err("text_update ret %d\n", m);
break;
}
if (m == 2 && lastm)
return 0;
lastm = m == 2;
n = (int)((size_t)n + txt->text_len);
txt->dlo.box.w = txt->bounding_box.w;
txt->dlo.box.h = txt->bounding_box.h;
lws_fx_add(&psb->curx, &psb->curx, &txt->bounding_box.w);
psb->dlo_set_curx = &txt->dlo;
//lwsl_user("%s: bounding width %d, m: %d, text %.*s\n",
// __func__, txt->bounding_box.w.whole, m,
// ctx->npos, ctx->buf);
if (m > 0) { /* wrapping */
newline(ctx, psb, ps, drt->dl);
lws_fx_set(ps->curx, 0, 0);
lws_fx_set(psb->curx, 0, 0);
psb->dlo_set_curx = NULL;
lws_fx_add(&ps->cury, &ps->cury, &txt->bounding_box.h);
psb->dlo_set_cury = &txt->dlo;
}
}
break;
case LHPCB_COMMENT:
break;
}
return 0;
}
View Git Blame Copy Permalink