1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
|
import strutils
import unicode
import css/cascade
import css/sheet
import css/values
import html/dom
import io/cell
import io/term
import layout/box
import layout/engine
import utils/twtstr
func formatFromWord(word: InlineWord): Formatting =
result.fgcolor = word.color.cellColor()
if word.fontstyle in { FONT_STYLE_ITALIC, FONT_STYLE_OBLIQUE }:
result.italic = true
if word.fontweight > 500:
result.bold = true
if word.textdecoration == TEXT_DECORATION_UNDERLINE:
result.underline = true
if word.textdecoration == TEXT_DECORATION_OVERLINE:
result.overline = true
if word.textdecoration == TEXT_DECORATION_LINE_THROUGH:
result.strike = true
proc setRowWord(lines: var FlexibleGrid, word: InlineWord, x, y: int, term: TermAttributes) =
var r: Rune
let y = y div term.ppl
var x = x div term.ppc
var i = 0
while x < 0:
fastRuneAt(word.str, i, r)
x += r.width()
let linestr = word.str.substr(i)
i = 0
while lines.len <= y:
lines.addLine()
var cx = 0
while cx < x and i < lines[y].str.len:
fastRuneAt(lines[y].str, i, r)
cx += r.width()
let ostr = lines[y].str.substr(i)
let oformats = lines[y].formats.subformats(i)
lines[y].setLen(i)
lines.addFormat(y, i, word.formatFromWord(), word.node)
var nx = cx
if nx < x:
lines[y].str &= ' '.repeat(x - nx)
nx = x
lines[y].str &= linestr
nx += linestr.width()
i = 0
while cx < nx and i < ostr.len:
fastRuneAt(ostr, i, r)
cx += r.width()
if i < ostr.len:
let oline = FlexibleLine(str: ostr.substr(i), formats: oformats.subformats(i))
lines[y].add(oline)
proc renderBlockContext(grid: var FlexibleGrid, ctx: BlockContext, x, y: int, term: TermAttributes)
proc renderInlineContext(grid: var FlexibleGrid, ctx: InlineContext, x, y: int, term: TermAttributes) =
for row in ctx.rows:
let x = x + row.relx
let y = y + row.rely + row.height
for atom in row.atoms:
# This aligns atoms with the baseline.
# (other alignment types in progress)
let y = y - atom.height
if atom of BlockContext:
let ctx = BlockContext(atom)
grid.renderBlockContext(ctx, x + ctx.relx, y + ctx.rely, term)
elif atom of InlineWord:
let word = InlineWord(atom)
grid.setRowWord(word, x + word.relx, y, term)
proc renderBlockContext(grid: var FlexibleGrid, ctx: BlockContext, x, y: int, term: TermAttributes) =
var x = x
var y = y
if ctx.inline != nil:
assert ctx.nested.len == 0
grid.renderInlineContext(ctx.inline, x + ctx.inline.relx, y, term)
else:
for ctx in ctx.nested:
grid.renderBlockContext(ctx, x + ctx.relx, y + ctx.rely, term)
const css = staticRead"res/ua.css"
let uastyle = css.parseStylesheet()
proc renderDocument*(document: Document, term: TermAttributes, userstyle: CSSStylesheet, layout: var Viewport): FlexibleGrid =
document.applyStylesheets(uastyle, userstyle)
layout.renderLayout(document)
result.setLen(0)
result.renderBlockContext(layout.root.bctx, 0, 0, term)
if result.len == 0:
result.addLine()
|