summaryrefslogtreecommitdiff
path: root/tex/context/base/typo-drp.lua
blob: ec1b526992a2788199f8f85ac7fafdcff9fb23d2 (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
if not modules then modules = { } end modules ['typo-drp'] = {
    version   = 1.001,
    comment   = "companion to typo-drp.mkiv",
    author    = "Hans Hagen, PRAGMA-ADE, Hasselt NL",
    copyright = "PRAGMA ADE / ConTeXt Development Team",
    license   = "see context related readme files"
}

-- This ons is sensitive for order (e.g. when combined with first line
-- processing.

local tonumber, type, next = tonumber, type, next
local ceil = math.ceil
local settings_to_hash = utilities.parsers.settings_to_hash

local trace_initials    = false  trackers.register("typesetters.initials", function(v) trace_initials = v end)
local report_initials   = logs.reporter("nodes","initials")

local initials          = typesetters.paragraphs or { }
typesetters.initials    = initials or { }

local nodes             = nodes
local tasks             = nodes.tasks

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

local getnext           = nuts.getnext
local getprev           = nuts.getprev
local getchar           = nuts.getchar
local getid             = nuts.getid
local getsubtype        = nuts.getsubtype
local getfield          = nuts.getfield
local setfield          = nuts.setfield
local getattr           = nuts.getattr
local setattr           = nuts.setattr

local hpack_nodes       = nuts.hpack

local nodecodes         = nodes.nodecodes
local whatsitcodes      = nodes.whatsitcodes

local nodepool          = nuts.pool
local new_kern          = nodepool.kern

local insert_before     = nuts.insert_before
local insert_after      = nuts.insert_after
local remove_node       = nuts.remove
local traverse_id       = nuts.traverse_id
local traverse          = nuts.traverse
local free_node         = nuts.free

local variables         = interfaces.variables
local v_default         = variables.default
local v_margin          = variables.margin
local v_auto            = variables.auto
local v_first           = variables.first
local v_last            = variables.last

local texget            = tex.get
local texsetattribute   = tex.setattribute
local unsetvalue        = attributes.unsetvalue

local glyph_code        = nodecodes.glyph
local hlist_code        = nodecodes.hlist
local glue_code         = nodecodes.glue
local kern_code         = nodecodes.kern
local whatsit_code      = nodecodes.whatsit
local localpar_code     = whatsitcodes.localpar

local actions           = { }
initials.actions        = actions

local a_initial         = attributes.private("initial")
local a_color           = attributes.private('color')
local a_transparency    = attributes.private('transparency')
local a_colorspace      = attributes.private('colormodel')

local category          = characters.category

local settings          = nil

function initials.set(specification)
    settings = specification or { }
    settings.enabled = true
    tasks.enableaction("processors","typesetters.initials.handler")
    if trace_initials then
        report_initials("enabling initials")
    end
    texsetattribute(a_initial,1)
end

commands.setinitial = initials.set

-- dropped caps experiment (will be done properly when luatex
-- stores the state in the local par node) .. btw, search still
-- works with dropped caps, as does an export

-- we need a 'par' attribute and in fact for dropped caps we don't need
-- need an attribute ... dropit will become s state counter (or end up
-- in the localpar user data

-- for the moment, each paragraph gets a number as id (attribute) ..problem
-- with nesting .. or anyhow, needed for tagging anyway

-- todo: prevent linebreak .. but normally a initial ends up at the top of
-- a page so this has a low priority

-- actions[v_default] = function(head,setting)
--     local done = false
--     if getid(head) == whatsit_code and getsubtype(head) == localpar_code then
--         -- begin of par
--         local first = getnext(head)
--         -- parbox .. needs to be set at 0
--         if first and getid(first) == hlist_code then
--             first = getnext(first)
--         end
--         -- we need to skip over kerns and glues (signals)
--         while first and getid(first) ~= glyph_code do
--             first = getnext(first)
--         end
--         if first and getid(first) == glyph_code then
--             local char = getchar(first)
--             local prev = getprev(first)
--             local next = getnext(first)
--          -- if getid(prev) == hlist_code then
--          --     -- set the width to 0
--          -- end
--             if next and getid(next) == kern_code then
--                 setfield(next,"kern",0)
--             end
--             if setting.font then
--                 setfield(first,"font",setting.font)
--             end
--             if setting.dynamic > 0 then
--                 setattr(first,0,setting.dynamic)
--             end
--             -- can be a helper
--             local ma = setting.ma or 0
--             local ca = setting.ca
--             local ta = setting.ta
--             if ca and ca > 0 then
--                 setattr(first,a_colorspace,ma == 0 and 1 or ma)
--                 setattr(first,a_color,ca)
--             end
--             if ta and ta > 0 then
--                 setattr(first,a_transparency,ta)
--             end
--             --
--             local width     = getfield(first,"width")
--             local height    = getfield(first,"height")
--             local depth     = getfield(first,"depth")
--             local distance  = setting.distance or 0
--             local voffset   = setting.voffset or 0
--             local hoffset   = setting.hoffset or 0
--             local parindent = tex.parindent
--             local baseline  = texget("baselineskip").width
--             local lines     = tonumber(setting.n) or 0
--             --
--             setfield(first,"xoffset",- width  - hoffset - distance - parindent)
--             setfield(first,"yoffset",- voffset) -- no longer - height here
--             -- We pack so that successive handling cannot touch the dropped cap. Packaging
--             -- in a hlist is also needed because we cannot locally adapt e.g. parindent (not
--             -- yet stored in with localpar).
--             setfield(first,"prev",nil)
--             setfield(first,"next",nil)
--             local h = hpack_nodes(first)
--             setfield(h,"width",0)
--             setfield(h,"height",0)
--             setfield(h,"depth",0)
--             setfield(prev,"next",h)
--             setfield(next,"prev",h)
--             setfield(h,"next",next)
--             setfield(h,"prev",prev)
--             first = h
--             -- end of packaging
--             if setting.location == v_margin then
--                 -- okay
--             else
--                 if lines == 0 then -- safeguard, not too precise
--                     lines = ceil((height+voffset) / baseline)
--                 end
--                 -- We cannot set parshape yet ... when we can I'll add a slope
--                 -- option (positive and negative, in emwidth).
--                 local hangafter  = - lines
--                 local hangindent = width + distance + parindent
--                 if trace_initials then
--                     report_initials("setting hangafter to %i and hangindent to %p",hangafter,hangindent)
--                 end
--                 tex.hangafter  = hangafter
--                 tex.hangindent = hangindent
--                 if parindent ~= 0 then
--                     insert_after(first,first,new_kern(-parindent))
--                 end
--             end
--             done = true
--         end
--     end
--     return head, done
-- end

actions[v_default] = function(head,setting)
    local done = false
    if getid(head) == whatsit_code and getsubtype(head) == localpar_code then
        -- begin of par
        local first  = getnext(head)
        local indent = false
        -- parbox .. needs to be set at 0
        if first and getid(first) == hlist_code then
            first  = getnext(first)
            indent = true
        end
        -- we need to skip over kerns and glues (signals)
        while first and getid(first) ~= glyph_code do
            first = getnext(first)
        end
        if first and getid(first) == glyph_code then
            local ma        = setting.ma or 0
            local ca        = setting.ca
            local ta        = setting.ta
            local last      = first
            local distance  = setting.distance or 0
            local voffset   = setting.voffset or 0
            local hoffset   = setting.hoffset or 0
            local parindent = tex.parindent
            local baseline  = texget("baselineskip").width
            local lines     = tonumber(setting.n) or 0
            local dynamic   = setting.dynamic
            local font      = setting.font
            local method    = settings_to_hash(setting.method)
            local length    = tonumber(setting.m) or 1
            --
            -- 1 char | n chars | skip first quote | ignore punct | keep punct
            --
            if getattr(first,a_initial) then
                for current in traverse(getnext(first)) do
                    if getattr(current,a_initial) then
                        last = current
                    else
                        break
                    end
                end
            elseif method[v_auto] then
                local char = getchar(first)
                local kind = category(char)
                if kind == "po" or kind == "pi" then
                    if method[v_first] then
                        -- remove quote etc before initial
                        local next = getnext(first)
                        if not next then
                            -- don't start with a quote or so
                            return head, false
                        end
                        last = nil
                        for current in traverse_id(glyph_code,next) do
                            head, first = remove_node(head,first,true)
                            first = current
                            last = first
                            break
                        end
                        if not last then
                            -- no following glyph or so
                            return head, false
                        end
                    else
                        -- keep quote etc with initial
                        local next = getnext(first)
                        if not next then
                            -- don't start with a quote or so
                            return head, false
                        end
                        for current in traverse_id(glyph_code,next) do
                            last = current
                            break
                        end
                        if last == first then
                            return head, false
                        end
                    end
                elseif kind == "pf" then
                    -- error: final quote
                else
                    -- okay
                end
                -- maybe also: get all A. B. etc
                local next = getnext(first)
                if next then
                    for current in traverse_id(glyph_code,next) do
                        local char = getchar(current)
                        local kind = category(char)
                        if kind == "po" then
                            if method[v_last] then
                                -- remove period etc after initial
                                remove_node(head,current,true)
                            else
                                -- keep period etc with initial
                                last = current
                            end
                        end
                        break
                    end
                end
            else
                for current in traverse_id(glyph_code,first) do
                    last = current
                    if length <= 1 then
                        break
                    else
                        length = length - 1
                    end
                end
            end
            local current = first
            while true do
                local id = getid(current)
                if id == kern_code then
                    setfield(current,"kern",0)
                elseif id == glyph_code then
                    local next = getnext(current)
                    if font then
                        setfield(current,"font",font)
                    end
                    if dynamic > 0 then
                        setattr(current,0,dynamic)
                    end
-- apply font

-- local g = nodes.copy(tonode(current))
-- g.subtype = 0
-- nodes.handlers.characters(g)
-- nodes.handlers.protectglyphs(g)
-- setfield(current,"char",g.char)
-- nodes.free(g)

                    -- can be a helper
                    if ca and ca > 0 then
                        setattr(current,a_colorspace,ma == 0 and 1 or ma)
                        setattr(current,a_color,ca)
                    end
                    if ta and ta > 0 then
                        setattr(current,a_transparency,ta)
                    end
                    --
                end
                if current == last then
                    break
                else
                    current = getnext(current)
                end
            end
            -- We pack so that successive handling cannot touch the dropped cap. Packaging
            -- in a hlist is also needed because we cannot locally adapt e.g. parindent (not
            -- yet stored in with localpar).
            local prev = getprev(first)
            local next = getnext(last)
            --
            setfield(first,"prev",nil)
            setfield(last,"next",nil)
            local dropper = hpack_nodes(first)
            local width   = getfield(dropper,"width")
            local height  = getfield(dropper,"height")
            local depth   = getfield(dropper,"depth")
            setfield(dropper,"width",0)
            setfield(dropper,"height",0)
            setfield(dropper,"depth",0)
            --
            setfield(prev,"next",dropper)
            if next then
                setfield(next,"prev",dropper)
            end
            setfield(dropper,"next",next)
            setfield(dropper,"prev",prev)
            --
            if next then
                local current = next
                while current do
                    local id = getid(current)
                    if id == glue_code or id == kern_code then
                        local next = getnext(current)
                     -- remove_node(current,current,true) -- created an invalid next link and dangling remains
                        remove_node(head,current,true)
                        current = next
                    else
                        break
                    end
                end
            end
            --
            local hoffset = width + hoffset + distance + (indent and parindent or 0)
            for current in traverse_id(glyph_code,first) do
                setfield(current,"xoffset",- hoffset )
                setfield(current,"yoffset",- voffset) -- no longer - height here
                if current == last then
                    break
                end
            end
            --
            first = dropper
            --
            if setting.location == v_margin then
                -- okay
            else
                if lines == 0 then -- safeguard, not too precise
                    lines = ceil((height+voffset) / baseline)
                end
                -- We cannot set parshape yet ... when we can I'll add a slope
                -- option (positive and negative, in emwidth).
                local hangafter  = - lines
                local hangindent = width + distance
                if trace_initials then
                    report_initials("setting hangafter to %i and hangindent to %p",hangafter,hangindent)
                end
                tex.hangafter  = hangafter
                tex.hangindent = hangindent
            end
            if indent then
                insert_after(first,first,new_kern(-parindent))
            end
            done = true
        end
    end
    return head, done
end

function initials.handler(head)
    head = tonut(head)
    local start = head
    local attr  = nil
    while start do
        attr = getattr(start,a_initial)
        if attr then
            break
        elseif getid(start) == glyph then
            break
        else
            start = getnext(start)
        end
    end
    if attr then
        -- here as we can process nested boxes first so we need to keep state
        tasks.disableaction("processors","typesetters.initials.handler")
     -- texsetattribute(attribute,unsetvalue)
        local alternative = settings.alternative or v_default
        local action = actions[alternative] or actions[v_default]
        if action then
            if trace_initials then
                report_initials("processing initials, alternative %a",alternative)
            end
            local head, done = action(head,settings)
            return tonode(head), done
        end
    end
    return tonode(head), false
end