summaryrefslogtreecommitdiff
path: root/macros/luatex/generic/luaotfload/luaotfload-dvi.lua
blob: eeac1c71d005aaa5bb2c7bc5fd10ed2edb897cf1 (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
-------------------------------------------------------------------------------
--         FILE:  luaotfload-dvi.lua
--  DESCRIPTION:  part of luaotfload / DVI
-------------------------------------------------------------------------------


assert(luaotfload_module, "This is a part of luaotfload and should not be loaded independently") { 
    name          = "luaotfload-dvi",
    version       = "3.23",       --TAGVERSION
    date          = "2022-10-03", --TAGDATE
    description   = "luaotfload submodule / DVI",
    license       = "GPL v2.0",
    author        = "Marcel Krüger",
    copyright     = "Luaotfload Development Team",  
}

local getfont = font.getfont
local setfont = node.direct.setfont
local getdisc = node.direct.getdisc
local getlist = node.direct.getlist
local is_glyph = node.direct.is_glyph
local todirect = node.direct.todirect
local traverse_glyph = node.direct.traverse_glyph
local traverse_list = node.direct.traverse_list
local traverse_id = node.direct.traverse_id
local traverse = node.direct.traverse
local uses_font = node.direct.uses_font
local define_font = font.define
local hlist_t = node.id'hlist'
local vlist_t = node.id'vlist'
local disc_t = node.id'disc'
local glyph_t = node.id'glyph'

-- DVI output support
--
-- When writing DVI files, we can't assume that the DVI reader has access to our
-- font dictionaries, so we need an independent representation for our glyphs. The
-- approach we chose in coordination with the dvisvgm author is to create a DVI font
-- name which indicates the font filename and some essential backend parameters
-- (especially otential extend, shrink, embolden, etc. factors) and then use GIDs in
-- the page stream.
--
-- Normally we could easily implement this using virtual fonts, but because we are
-- dealing with DVI output, LuaTeX is not evaluating virtual fonts by itself.
-- So instead, we process the shaped output and replace all glyph nodes with glyph
-- nodes from special fonts which have the characteristics expected brom the DVI reader.

-- mapped_fonts maps fontids from the user to fontids used in the DVI file
local mapped_fonts = setmetatable({}, {__index = function(t, fid)
  local font = getfont(fid)
  print(fid, font and font.fullname)
  local mapped = font and font.backend_font or false
  t[fid] = mapped
  return mapped
end})

local full_hprocess
local function full_vprocess(head)
  for _, id, _, list in traverse_list(head) do
    if id == hlist_t then
      full_hprocess(list)
    elseif id == vlist_t then
      full_vprocess(list)
    else
      assert(false)
    end
  end
end

function full_hprocess(head)
  local last_f, last_mapping, last_mapped_font
  for n, id in traverse(head) do
    if id == hlist_t then
      full_hprocess(getlist(n))
    elseif id == vlist_t then
      full_vprocess(getlist(n))
    elseif id == disc_t then
      local _, _, rep = getdisc(n)
      for n, c, f in traverse_glyph(rep) do
        if f ~= last_f then
          last_f, last_mapping = f, mapped_fonts[f]
          last_mapped_font = last_mapping and last_mapping.font
        end
        if last_mapping then
          local mapped = last_mapping[c]
          if mapped then setfont(n, mapped_font, mapped) end
        end
      end
    elseif id == glyph_t then
      local c, f = is_glyph(n)
      if f ~= last_f then
        last_f, last_mapping = f, mapped_fonts[f]
        last_mapped_font = last_mapping and last_mapping.font
      end
      if last_mapping then
        local mapped = last_mapping[c]
        print(c, f, mapped)
        if mapped then setfont(n, last_mapped_font, mapped) end
      end
    end
  end
end

local function delayed_register_callback()
  luatexbase.add_to_callback('pre_shipout_filter', function(list)
    full_vprocess(todirect(list)) -- list should always be a single list node, so we can treat it as if it were a vlist with one node
    return true
  end, 'luaotfload.dvi')
  delayed_register_callback = function() end
end

local function process(head, font)
  local mapping = mapped_fonts[font]
  if not mapping then return head end
  local mapped_font = mapping.font
  for n, c, f in traverse_glyph(head) do if f == font then
    local mapped = mapping[c]
    if mapped then setfont(n, mapped_font, mapped) end
  end end
  for n in traverse_id(disc_t, head) do if uses_font(n, font) then
    local pre, post, rep = getdisc(n)
    for n, c, f in traverse_glyph(pre) do if f == font then
      local mapped = mapping[c]
      if mapped then setfont(n, mapped_font, mapped) end
    end end
    for n, c, f in traverse_glyph(post) do if f == font then
      local mapped = mapping[c]
      if mapped then setfont(n, mapped_font, mapped) end
    end end
    for n, c, f in traverse_glyph(rep) do if f == font then
      local mapped = mapping[c]
      if mapped then setfont(n, mapped_font, mapped) end
    end end
  end end
end
local function manipulate(tfmdata, _, dvi_kind)
  if dvi_kind ~= 'dvisvgm' then
    texio.write_nl(string.format('WARNING (luaotfload): Unsupported DVI backend %q, falling back to dvisvgm.', dvi_kind))
  end
  -- Legacy fonts can be written to the DVI file directly
  if 2 ~= (tfmdata.encodingbytes or ((tfmdata.format == 'truetype' or tfmdata.format == 'opentype') and 2 or 1)) then
    return
  end
  delayed_register_callback()
  local newfont = {}
  for k,v in pairs(tfmdata) do
    newfont[k] = v
  end
  local newchars = {}
  newfont.characters = newchars
  local lookup = {}
  for k,v in pairs(tfmdata.characters) do
    local newchar = {
      width = v.width, -- Only width should really be necessary
      height = v.height,
      depth = v.depth,
    }
    newchars[v.index or k] = newchar
    lookup[k] = v.index or k
  end
  newfont.checksum = string.unpack('>I4', 'LuaF') -- Use a magic checksum such that the reader
                                                  -- can uniquely identify these fonts.
  local name = '[' .. newfont.name .. ']:' -- TODO: Why .name? I would have expected .filename
  if newfont.subfont and newfont.subfont ~= 1 then
    name = name .. 'index=' .. tostring(math.tointeger(newfont.subfont-1)) .. ';'
  end
  if newfont.extend and newfont.extend ~= 1000 then
    name = name .. 'extend=' .. tostring(math.tointeger(math.round(newfont.extend*65.536))) .. ';'
  end
  if newfont.slant and newfont.slant ~= 0 then
    name = name .. 'slant=' .. tostring(math.tointeger(math.round(newfont.slant*65.536))) .. ';'
  end
  if newfont.mode == 2 and newfont.width and newfont.width ~= 0 then
    name = name .. 'embolden=' .. tostring(math.tointeger(math.round(newfont.width*65.78176))) .. ';'
  end
  newfont.name = name:sub(1,-2) -- Stri th trailing : or ;
  tfmdata.backend_font = lookup
  lookup.font = define_font(newfont)
end

fonts.constructors.features.otf.register {
  name = "dvifont",
  default = "dvisvgm",
  manipulators = {
    node = manipulate,
    base = manipulate,
  },
  processors = {
    node = process,
    base = process,
  },
}