summaryrefslogtreecommitdiff
path: root/Master/texmf-dist/tex/context/base/node-inj.lua
blob: 402403529c6028571573f957638e0a18660efad7 (plain)
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
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
if not modules then modules = { } end modules ['node-inj'] = {
    version   = 1.001,
    comment   = "companion to node-ini.mkiv",
    author    = "Hans Hagen, PRAGMA-ADE, Hasselt NL",
    copyright = "PRAGMA ADE / ConTeXt Development Team",
    license   = "see context related readme files",
}

-- This is very experimental (this will change when we have luatex > .50 and
-- a few pending thingies are available. Also, Idris needs to make a few more
-- test fonts. Some optimizations can go away when we have faster machines.

-- todo: ignore kerns between disc and glyph

local next = next
local utfchar = utf.char

local trace_injections = false  trackers.register("nodes.injections", function(v) trace_injections = v end)

local report_injections = logs.reporter("nodes","injections")

local attributes, nodes, node = attributes, nodes, node

fonts                    = fonts
local fontdata           = fonts.hashes.identifiers

nodes.injections         = nodes.injections or { }
local injections         = nodes.injections

local nodecodes          = nodes.nodecodes
local glyph_code         = nodecodes.glyph
local kern_code          = nodecodes.kern

local nuts               = nodes.nuts
local nodepool           = nuts.pool

local newkern            = nodepool.kern

local tonode             = nuts.tonode
local tonut              = nuts.tonut

local getfield           = nuts.getfield
local getnext            = nuts.getnext
local getprev            = nuts.getprev
local getid              = nuts.getid
local getattr            = nuts.getattr
local getfont            = nuts.getfont
local getsubtype         = nuts.getsubtype
local getchar            = nuts.getchar

local setfield           = nuts.setfield
local setattr            = nuts.setattr

local traverse_id        = nuts.traverse_id
local insert_node_before = nuts.insert_before
local insert_node_after  = nuts.insert_after

local a_kernpair = attributes.private('kernpair')
local a_ligacomp = attributes.private('ligacomp')
local a_markbase = attributes.private('markbase')
local a_markmark = attributes.private('markmark')
local a_markdone = attributes.private('markdone')
local a_cursbase = attributes.private('cursbase')
local a_curscurs = attributes.private('curscurs')
local a_cursdone = attributes.private('cursdone')

local unsetvalue = attributes.unsetvalue

-- This injector has been tested by Idris Samawi Hamid (several arabic fonts as well as
-- the rather demanding Husayni font), Khaled Hosny (latin and arabic) and Kaj Eigner
-- (arabic, hebrew and thai) and myself (whatever font I come across). I'm pretty sure
-- that this code is not 100% okay but examples are needed to figure things out.

function injections.installnewkern(nk)
    newkern = nk or newkern
end

local cursives = { }
local marks    = { }
local kerns    = { }

-- Currently we do gpos/kern in a bit inofficial way but when we have the extra fields in
-- glyphnodes to manipulate ht/dp/wd explicitly I will provide an alternative; also, we
-- can share tables.

-- For the moment we pass the r2l key ... volt/arabtype tests .. idris: this needs
-- checking with husayni (volt and fontforge).

function injections.reset(n)
--     if getattr(n,a_kernpair) then
--         setattr(n,a_kernpair,unsetvalue)
--     end
--     if getattr(n,a_markdone) then
--         setattr(n,a_markbase,unsetvalue)
--         setattr(n,a_markmark,unsetvalue)
--         setattr(n,a_markdone,unsetvalue)
--     end
--     if getattr(n,a_cursdone) then
--         setattr(n,a_cursbase,unsetvalue)
--         setattr(n,a_curscurs,unsetvalue)
--         setattr(n,a_cursdone,unsetvalue)
--     end
--     if getattr(n,a_ligacomp) then
--         setattr(n,a_ligacomp,unsetvalue)
--     end
end

function injections.setligaindex(n,index)
    setattr(n,a_ligacomp,index)
end

function injections.getligaindex(n,default)
    return getattr(n,a_ligacomp) or default
end

function injections.setcursive(start,nxt,factor,rlmode,exit,entry,tfmstart,tfmnext)
    local dx, dy = factor*(exit[1]-entry[1]), factor*(exit[2]-entry[2])
    local ws, wn = tfmstart.width, tfmnext.width
    local bound = #cursives + 1
    setattr(start,a_cursbase,bound)
    setattr(nxt,a_curscurs,bound)
    cursives[bound] = { rlmode, dx, dy, ws, wn }
    return dx, dy, bound
end

function injections.setpair(current,factor,rlmode,r2lflag,spec,tfmchr)
    local x, y, w, h = factor*spec[1], factor*spec[2], factor*spec[3], factor*spec[4]
    -- dy = y - h
    if x ~= 0 or w ~= 0 or y ~= 0 or h ~= 0 then
        local bound = getattr(current,a_kernpair)
        if bound then
            local kb = kerns[bound]
            -- inefficient but singles have less, but weird anyway, needs checking
            kb[2], kb[3], kb[4], kb[5] = (kb[2] or 0) + x, (kb[3] or 0) + y, (kb[4] or 0)+ w, (kb[5] or 0) + h
        else
            bound = #kerns + 1
            setattr(current,a_kernpair,bound)
            kerns[bound] = { rlmode, x, y, w, h, r2lflag, tfmchr.width }
        end
        return x, y, w, h, bound
    end
    return x, y, w, h -- no bound
end

function injections.setkern(current,factor,rlmode,x,tfmchr)
    local dx = factor*x
    if dx ~= 0 then
        local bound = #kerns + 1
        setattr(current,a_kernpair,bound)
        kerns[bound] = { rlmode, dx }
        return dx, bound
    else
        return 0, 0
    end
end

function injections.setmark(start,base,factor,rlmode,ba,ma) -- ba=baseanchor, ma=markanchor
    local dx, dy = factor*(ba[1]-ma[1]), factor*(ba[2]-ma[2])
    local bound = getattr(base,a_markbase)
    local index = 1
    if bound then
        local mb = marks[bound]
        if mb then
         -- if not index then index = #mb + 1 end
            index = #mb + 1
            mb[index] = { dx, dy, rlmode }
            setattr(start,a_markmark,bound)
            setattr(start,a_markdone,index)
            return dx, dy, bound
        else
            report_injections("possible problem, %U is base mark without data (id %a)",getchar(base),bound)
        end
    end
    index = index or 1
    bound = #marks + 1
    setattr(base,a_markbase,bound)
    setattr(start,a_markmark,bound)
    setattr(start,a_markdone,index)
    marks[bound] = { [index] = { dx, dy, rlmode } }
    return dx, dy, bound
end

local function dir(n)
    return (n and n<0 and "r-to-l") or (n and n>0 and "l-to-r") or "unset"
end

local function trace(head)
    report_injections("begin run")
    for n in traverse_id(glyph_code,head) do
        if getsubtype(n) < 256 then
            local kp = getattr(n,a_kernpair)
            local mb = getattr(n,a_markbase)
            local mm = getattr(n,a_markmark)
            local md = getattr(n,a_markdone)
            local cb = getattr(n,a_cursbase)
            local cc = getattr(n,a_curscurs)
            local char = getchar(n)
            report_injections("font %s, char %U, glyph %c",getfont(n),char,char)
            if kp then
                local k = kerns[kp]
                if k[3] then
                    report_injections("  pairkern: dir %a, x %p, y %p, w %p, h %p",dir(k[1]),k[2],k[3],k[4],k[5])
                else
                    report_injections("  kern: dir %a, dx %p",dir(k[1]),k[2])
                end
            end
            if mb then
                report_injections("  markbase: bound %a",mb)
            end
            if mm then
                local m = marks[mm]
                if mb then
                    local m = m[mb]
                    if m then
                        report_injections("  markmark: bound %a, index %a, dx %p, dy %p",mm,md,m[1],m[2])
                    else
                        report_injections("  markmark: bound %a, missing index",mm)
                    end
                else
                    m = m[1]
                    report_injections("  markmark: bound %a, dx %p, dy %p",mm,m and m[1],m and m[2])
                end
            end
            if cb then
                report_injections("  cursbase: bound %a",cb)
            end
            if cc then
                local c = cursives[cc]
                report_injections("  curscurs: bound %a, dir %a, dx %p, dy %p",cc,dir(c[1]),c[2],c[3])
            end
        end
    end
    report_injections("end run")
end

-- todo: reuse tables (i.e. no collection), but will be extra fields anyway
-- todo: check for attribute

-- We can have a fast test on a font being processed, so we can check faster for marks etc
-- but I'll make a context variant anyway.

local function show_result(head)
    local current = head
    local skipping = false
    while current do
        local id = getid(current)
        if id == glyph_code then
            report_injections("char: %C, width %p, xoffset %p, yoffset %p",
                getchar(current),getfield(current,"width"),getfield(current,"xoffset"),getfield(current,"yoffset"))
            skipping = false
        elseif id == kern_code then
            report_injections("kern: %p",getfield(current,"kern"))
            skipping = false
        elseif not skipping then
            report_injections()
            skipping = true
        end
        current = getnext(current)
    end
end

function injections.handler(head,where,keep)
    head = tonut(head)
    local has_marks, has_cursives, has_kerns = next(marks), next(cursives), next(kerns)
    if has_marks or has_cursives then
        if trace_injections then
            trace(head)
        end
        -- in the future variant we will not copy items but refs to tables
        local done, ky, rl, valid, cx, wx, mk, nofvalid = false, { }, { }, { }, { }, { }, { }, 0
        if has_kerns then -- move outside loop
            local nf, tm = nil, nil
            for n in traverse_id(glyph_code,head) do -- only needed for relevant fonts
                if getsubtype(n) < 256 then
                    nofvalid = nofvalid + 1
                    valid[nofvalid] = n
                    local f = getfont(n)
                    if f ~= nf then
                        nf = f
                        tm = fontdata[nf].resources.marks -- other hash in ctx
                    end
                    if tm then
                        mk[n] = tm[getchar(n)]
                    end
                    local k = getattr(n,a_kernpair)
                    if k then
                        local kk = kerns[k]
                        if kk then
                            local x, y, w, h = kk[2] or 0, kk[3] or 0, kk[4] or 0, kk[5] or 0
                            local dy = y - h
                            if dy ~= 0 then
                                ky[n] = dy
                            end
                            if w ~= 0 or x ~= 0 then
                                wx[n] = kk
                            end
                            rl[n] = kk[1] -- could move in test
                        end
                    end
                end
            end
        else
            local nf, tm = nil, nil
            for n in traverse_id(glyph_code,head) do
                if getsubtype(n) < 256 then
                    nofvalid = nofvalid + 1
                    valid[nofvalid] = n
                    local f = getfont(n)
                    if f ~= nf then
                        nf = f
                        tm = fontdata[nf].resources.marks -- other hash in ctx
                    end
                    if tm then
                        mk[n] = tm[getchar(n)]
                    end
                end
            end
        end
        if nofvalid > 0 then
            -- we can assume done == true because we have cursives and marks
            local cx = { }
            if has_kerns and next(ky) then
                for n, k in next, ky do
                    setfield(n,"yoffset",k)
                end
            end
            -- todo: reuse t and use maxt
            if has_cursives then
                local p_cursbase, p = nil, nil
                -- since we need valid[n+1] we can also use a "while true do"
                local t, d, maxt = { }, { }, 0
                for i=1,nofvalid do -- valid == glyphs
                    local n = valid[i]
                    if not mk[n] then
                        local n_cursbase = getattr(n,a_cursbase)
                        if p_cursbase then
                            local n_curscurs = getattr(n,a_curscurs)
                            if p_cursbase == n_curscurs then
                                local c = cursives[n_curscurs]
                                if c then
                                    local rlmode, dx, dy, ws, wn = c[1], c[2], c[3], c[4], c[5]
                                    if rlmode >= 0 then
                                        dx = dx - ws
                                    else
                                        dx = dx + wn
                                    end
                                    if dx ~= 0 then
                                        cx[n] = dx
                                        rl[n] = rlmode
                                    end
                                --  if rlmode and rlmode < 0 then
                                        dy = -dy
                                --  end
                                    maxt = maxt + 1
                                    t[maxt] = p
                                    d[maxt] = dy
                                else
                                    maxt = 0
                                end
                            end
                        elseif maxt > 0 then
                            local ny = getfield(n,"yoffset")
                            for i=maxt,1,-1 do
                                ny = ny + d[i]
                                local ti = t[i]
                                setfield(ti,"yoffset",getfield(ti,"yoffset") + ny)
                            end
                            maxt = 0
                        end
                        if not n_cursbase and maxt > 0 then
                            local ny = getfield(n,"yoffset")
                            for i=maxt,1,-1 do
                                ny = ny + d[i]
                                local ti = t[i]
                                setfield(ti,"yoffset",ny) -- maybe add to current yoffset
                            end
                            maxt = 0
                        end
                        p_cursbase, p = n_cursbase, n
                    end
                end
                if maxt > 0 then
                    local ny = getfield(n,"yoffset") -- hm, n unset ?
                    for i=maxt,1,-1 do
                        ny = ny + d[i]
                        local ti = t[i]
                        setfield(ti,"yoffset",ny)
                    end
                    maxt = 0
                end
                if not keep then
                    cursives = { }
                end
            end
            if has_marks then
                for i=1,nofvalid do
                    local p = valid[i]
                    local p_markbase = getattr(p,a_markbase)
                    if p_markbase then
                        local mrks      = marks[p_markbase]
                        local nofmarks  = #mrks
                        for n in traverse_id(glyph_code,getnext(p)) do
                            local n_markmark = getattr(n,a_markmark)
                            if p_markbase == n_markmark then
                                local index = getattr(n,a_markdone) or 1
                                local d = mrks[index]
                                if d then
                                    local rlmode = d[3]
                                    --
                                    local k = wx[p]
                                    local px = getfield(p,"xoffset")
                                    local ox = 0
                                    if k then
                                        local x = k[2]
                                        local w = k[4]
                                        if w then
                                            if rlmode and rlmode >= 0 then
                                                -- kern(x) glyph(p) kern(w-x) mark(n)
                                                ox = px - getfield(p,"width") + d[1] - (w-x)
                                             -- report_injections("l2r case 1: %p",ox)
                                            else
                                                -- kern(w-x) glyph(p) kern(x) mark(n)
                                                ox = px - d[1] - x
                                             -- report_injections("r2l case 1: %p",ox)
                                            end
                                        else
                                            if rlmode and rlmode >= 0 then
                                                -- okay for husayni
                                                ox = px - getfield(p,"width") + d[1]
                                             -- report_injections("r2l case 2: %p",ox)
                                            else
                                                -- needs checking: is x ok here?
                                                ox = px - d[1] - x
                                             -- report_injections("r2l case 2: %p",ox)
                                            end
                                        end
                                    else
                                     -- if rlmode and rlmode >= 0 then
                                     --     ox = px - getfield(p,"width") + d[1]
                                     --  -- report_injections("l2r case 3: %p",ox)
                                     -- else
                                     --     ox = px - d[1]
                                     --  -- report_injections("r2l case 3: %p",ox)
                                     -- end
                                        --
                                        -- we need to deal with fonts that have marks with width
                                        --
                                        local wp = getfield(p,"width")
                                        local wn = getfield(n,"width") -- in arial marks have widths
                                        if rlmode and rlmode >= 0 then
                                            ox = px - wp + d[1]
                                         -- report_injections("l2r case 3: %p",ox)
                                        else
                                            ox = px - d[1]
                                         -- report_injections("r2l case 3: %p",ox)
                                        end
                                        if wn ~= 0 then
                                            -- bad: we should center
                                            insert_node_before(head,n,newkern(-wn/2))
                                            insert_node_after(head,n,newkern(-wn/2))
                                         -- wx[n] = { 0, -wn/2, 0, -wn }
                                        end
                                        -- so far
                                    end
                                    setfield(n,"xoffset",ox)
                                    --
                                    local py = getfield(p,"yoffset")
                                    local oy = 0
                                    if mk[p] then
                                        oy = py + d[2]
                                    else
                                        oy = getfield(n,"yoffset") + py + d[2]
                                    end
                                    setfield(n,"yoffset",oy)
                                    --
                                    if nofmarks == 1 then
                                        break
                                    else
                                        nofmarks = nofmarks - 1
                                    end
                                end
                            elseif not n_markmark then
                                break -- HH: added 2013-09-12: no need to deal with non marks
                            else
                                -- KE: there can be <mark> <mkmk> <mark> sequences in ligatures
                            end
                        end
                    end
                end
                if not keep then
                    marks = { }
                end
            end
            -- todo : combine
            if next(wx) then
                for n, k in next, wx do
                 -- only w can be nil (kernclasses), can be sped up when w == nil
                    local x = k[2]
                    local w = k[4]
                    if w then
                        local rl = k[1] -- r2l = k[6]
                        local wx = w - x
                        if rl < 0 then	-- KE: don't use r2l here
                            if wx ~= 0 then
                                insert_node_before(head,n,newkern(wx)) -- type 0/2
                            end
                            if x ~= 0 then
                                insert_node_after (head,n,newkern(x))  -- type 0/2
                            end
                        else
                            if x ~= 0 then
                                insert_node_before(head,n,newkern(x))  -- type 0/2
                            end
                            if wx ~= 0 then
                                insert_node_after (head,n,newkern(wx)) -- type 0/2
                            end
                        end
                    elseif x ~= 0 then
                        -- this needs checking for rl < 0 but it is unlikely that a r2l script
                        -- uses kernclasses between glyphs so we're probably safe (KE has a
                        -- problematic font where marks interfere with rl < 0 in the previous
                        -- case)
                        insert_node_before(head,n,newkern(x)) -- a real font kern, type 0
                    end
                end
            end
            if next(cx) then
                for n, k in next, cx do
                    if k ~= 0 then
                        local rln = rl[n]
                        if rln and rln < 0 then
                            insert_node_before(head,n,newkern(-k)) -- type 0/2
                        else
                            insert_node_before(head,n,newkern(k))  -- type 0/2
                        end
                    end
                end
            end
            if not keep then
                kerns = { }
            end
         -- if trace_injections then
         --     show_result(head)
         -- end
            return tonode(head), true
        elseif not keep then
            kerns, cursives, marks = { }, { }, { }
        end
    elseif has_kerns then
        if trace_injections then
            trace(head)
        end
        for n in traverse_id(glyph_code,head) do
            if getsubtype(n) < 256 then
                local k = getattr(n,a_kernpair)
                if k then
                    local kk = kerns[k]
                    if kk then
                        local rl, x, y, w = kk[1], kk[2] or 0, kk[3], kk[4]
                        if y and y ~= 0 then
                            setfield(n,"yoffset",y) -- todo: h ?
                        end
                        if w then
                            -- copied from above
                         -- local r2l = kk[6]
                            local wx = w - x
                            if rl < 0 then  -- KE: don't use r2l here
                                if wx ~= 0 then
                                    insert_node_before(head,n,newkern(wx))
                                end
                                if x ~= 0 then
                                    insert_node_after (head,n,newkern(x))
                                end
                            else
                                if x ~= 0 then
                                    insert_node_before(head,n,newkern(x))
                                end
                                if wx ~= 0 then
                                    insert_node_after(head,n,newkern(wx))
                                end
                            end
                        else
                            -- simple (e.g. kernclass kerns)
                            if x ~= 0 then
                                insert_node_before(head,n,newkern(x))
                            end
                        end
                    end
                end
            end
        end
        if not keep then
            kerns = { }
        end
     -- if trace_injections then
     --     show_result(head)
     -- end
        return tonode(head), true
    else
        -- no tracing needed
    end
    return tonode(head), false
end