summaryrefslogtreecommitdiff
path: root/macros/luatex/latex/showkerning/showkerning.lua
blob: b298a6fb22d0b5de6d12bd594e8f6da0a087c9ec (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
-- Copyright (c) 2022-2023 Thomas Kelkel kelkel@emaileon.de

-- This file may be distributed and/or modified under the
-- conditions of the LaTeX Project Public License, either
-- version 1.3c of this license or (at your option) any later
-- version. The latest version of this license is in

--    http://www.latex-project.org/lppl.txt

-- and version 1.3c or later is part of all distributions of
-- LaTeX version 2009/09/24 or later.

-- Version: 0.3

local ID = node.id
local GLYPH = ID ( "glyph" )
local DISC = ID ( "disc" )
local GLUE = ID ( "glue" )
local KERN = ID ( "kern" )
local WI = ID ( "whatsit" )
local HLIST = ID ( "hlist" )
local VLIST = ID ( "vlist" )

local PDF_LITERAL = table.swapped ( node.whatsits () )["pdf_literal"]

local NEW = node.new
local PREV = node.prev
local NEXT = node.next
local TAIL = node.tail
local INS_B = node.insert_before
local INS_A = node.insert_after
local HAS_GLYPH = node.has_glyph
local T = node.traverse
local T_ID = node.traverse_id

local FLOOR = math.floor
local ABS = math.abs

local ATC = luatexbase.add_to_callback

-----

local on_top = false
local DIR = PREV
local AB = INS_B
local f = 1

function showkerning_on_top ()
    on_top = true
    DIR = NEXT
    AB = INS_A
    f = - 1
end

local function round ( num, dec )
    return FLOOR ( num * 10^dec + 0.5 ) / 10^dec
end

local function calc_value ( value )
    value = round ( value / 65781, 3 )
    return value
end

local function find_first_last ( n, node_type, last )
    local d = NEXT
    if last then
        d = PREV
        n = TAIL ( n )
    end
    while true do
        if n and n.id == node_type then
            return n
        end
        if d ( n ) then
            n = d ( n )
        else
            return false
        end
    end
end

local function find_glyph ( n, d )
    local kern_value = 0
    if d ( n ) then
        n = d ( n )
        while not ( n.id == GLYPH or n.replace and HAS_GLYPH ( n.replace ) ) do
            if not d ( n ) then return false end
            if n.id == GLUE then
                kern_value = kern_value + n.width
            end
            n = d ( n )
        end
    else
        return false
    end
    local return_value = n
    if n.id == DISC then
        return_value = find_first_last ( n.replace, GLYPH, d == PREV )
        for kern_node in T_ID ( KERN, n.replace ) do
            kern_value = kern_value + kern_node.kern
        end
    end
    return return_value, n, kern_value
end

local function check_glyph ( n, d, has_prev_next_glyph, prev_next_glyph, insert_prev_next )
    local kern_value
    if find_glyph ( n, d ) then
        prev_next_glyph, insert_prev_next, kern_value = find_glyph ( n, d )
        has_prev_next_glyph = true
    end
    return has_prev_next_glyph, prev_next_glyph, insert_prev_next, kern_value
end

local function get_x_value ( n, x_value )
    local exp_fac = 1
    if n.expansion_factor then
        exp_fac = n.expansion_factor / 1000000 + 1
    end
    if n.width then
        x_value = x_value + calc_value ( n.width ) * exp_fac
    elseif n.kern then
        x_value = x_value + calc_value ( n.kern ) * exp_fac
    end
    return x_value
end

local function find_kern ( n, d )
    local kern_value = 0
    local disc = false
    if d ( n ) then
        n = d ( n )
        while n and not ( n.id == GLYPH or disc ) do
            if n.id == KERN then
                kern_value = get_x_value ( n, kern_value )
            elseif n.replace then
                local start_point = n.replace
                if d == PREV then
                    start_point = TAIL ( n.replace )
                end
                if start_point.id == KERN then
                    kern_value = get_x_value ( start_point, kern_value )
                end
                disc = true
            end
            if d ( n ) then
                n = d ( n )
            else
                break
            end
        end
        if not ( kern_value == 0 ) then
            return kern_value
        end
    end
    return false
end

local function make_rule ( head, n, kern_node, current_head, disc_list )
    local color = "0 0 0"
    local has_prev_glyph = false
    local has_next_glyph = false
    local prev_glyph = n
    local next_glyph = n
    local insert_prev = n
    local insert_next = n
    local insert_point = n
    local x_value = 0
    local height = 0
    local depth = 0
    local prev_kern_value = 0
    local next_kern_value = 0
    local thickness = calc_value ( kern_node.kern )
    has_prev_glyph, prev_glyph, insert_prev, prev_kern_value = check_glyph ( n, PREV, has_prev_glyph, prev_glyph, insert_prev )
    has_next_glyph, next_glyph, insert_next, next_kern_value = check_glyph ( n, NEXT, has_next_glyph, next_glyph, insert_next )
    if disc_list and not ( TAIL ( current_head ) == kern_node ) and not ( current_head == kern_node ) then
        has_prev_glyph, prev_glyph, insert_prev, prev_kern_value = check_glyph ( kern_node, PREV, has_prev_glyph, kern_node, kern_node )
        has_next_glyph, next_glyph, insert_next, next_kern_value = check_glyph ( kern_node, NEXT, has_next_glyph, kern_node, kern_node )
    end
    if not on_top and has_prev_glyph then
        insert_point = insert_prev
        x_value = get_x_value ( prev_glyph, x_value )
        x_value = x_value + calc_value ( prev_kern_value )
        if disc_list and HAS_GLYPH ( current_head ) and TAIL ( current_head ) == kern_node then
            for some_node in T ( current_head ) do
                if some_node == TAIL ( current_head ) then break end
                x_value = get_x_value ( some_node, x_value )
            end
        end
    elseif on_top then
        insert_point = insert_next
        if has_next_glyph then
            x_value = get_x_value ( next_glyph, x_value )
            x_value = x_value + calc_value ( next_kern_value )
        end
        if disc_list and HAS_GLYPH ( current_head ) and current_head == kern_node then
            local kern_counter = 0
            for some_node in T ( current_head ) do
                if some_node.id == KERN then
                    kern_counter = kern_counter + 1
                end
                if not ( some_node == current_head ) then
                    x_value = get_x_value ( some_node, x_value )
                end
            end
            if find_kern ( n, NEXT ) then
                x_value = x_value + find_kern ( n, NEXT )
            end
        end
    end
    if disc_list and HAS_GLYPH ( current_head ) then
        if TAIL ( current_head ) == kern_node then
            has_prev_glyph = false
            has_prev_glyph, prev_glyph = check_glyph ( kern_node, PREV, has_prev_glyph, prev_glyph, insert_prev )
        end
        if current_head == kern_node then
            has_next_glyph = false
            has_next_glyph, next_glyph = check_glyph ( kern_node, NEXT, has_next_glyph, next_glyph, insert_next )
        end
    end
    if has_prev_glyph then
        height = calc_value ( prev_glyph.height )
        depth = calc_value ( prev_glyph.depth )
        if has_next_glyph then
            if next_glyph.height > prev_glyph.height then height = calc_value ( next_glyph.height ) end
            if next_glyph.depth > prev_glyph.depth then depth = calc_value ( next_glyph.depth ) end
        end
    elseif has_next_glyph then
        height = calc_value ( next_glyph.height )
        depth = calc_value ( next_glyph.depth )
    end
    if find_kern ( n, PREV ) then
        thickness = thickness + find_kern ( n, PREV )
    end
    if thickness ~= 0 and thickness > calc_value ( tex.hsize ) * - 1 then
        if thickness > 0 then
            color = "0 1 0"
        else
            color = "1 0 0"
        end
        if disc_list and not ( TAIL ( current_head ) == kern_node ) and not ( current_head == kern_node ) then
            current_head = AB ( current_head, insert_point, NEW ( WI, PDF_LITERAL ) )
        else
            head = AB ( head, insert_point, NEW ( WI, PDF_LITERAL ) )
        end
        x_value = ( x_value + calc_value ( kern_node.expansion_factor ) + thickness * 0.5 ) * f
        DIR ( insert_point ).mode = 0
        DIR ( insert_point ).data = "q " .. ABS ( thickness )  .. " w " .. x_value .. " " .. - depth  .. " m  " .. x_value .. " " .. height .. " l " .. color .. " RG S Q"
    end
    return head, current_head
end

local function show_kerns ( head )
    for n in T ( head ) do
        if n.id == HLIST or n.id == VLIST then
            n.head = show_kerns ( n.head )
        elseif n.id == KERN and not find_kern ( n, NEXT ) then
            head = make_rule ( head, n, n, head, false )
        elseif n.replace then
            local REPLACE = n.replace
            for kern_node in T_ID ( KERN, REPLACE ) do
                if not find_kern ( kern_node, NEXT ) then
                    head, REPLACE = make_rule ( head , n, kern_node, REPLACE, true )
                end
            end
            n.replace = REPLACE
        end
    end
    return head
end

ATC ( "post_linebreak_filter", show_kerns, "show kerns in postline" )
ATC ( "hpack_filter", show_kerns, "show kerns in hpack" )