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

local tonumber, rawget, type, next = tonumber, rawget, type, next
local match = string.match
local sort, tohash, insert, remove = table.sort, table.tohash, table.insert, table.remove
local settings_to_array, settings_to_hash = utilities.parsers.settings_to_array, utilities.parsers.settings_to_hash

local texgetcount  = tex.getcount

local context      = context
local ctx_testcase = commands.testcase

local data         = table.setmetatableindex("table")
local last         = 0
local pages        = structures.pages
local autolist     = { }
local report       = logs.reporter("pages","mark")

local trace        = false  trackers.register("pages.mark",function(v) trace = v end)

function pages.mark(name,list)
    local realpage = texgetcount("realpageno")
    if not list or list == "" then
        if trace then
            report("marking current page %i as %a",realpage,name)
        end
        data[realpage][name] = true
        return
    end
    if type(list) == "string" then
        list = settings_to_array(list)
    end
    if type(list) == "table" then
        for i=1,#list do
            local page = list[i]
            local sign = false
            if type(page) == "string" then
                local s, p = match(page,"([%+%-])(%d+)")
                if s then
                    sign, page = s, p
                end
            end
            page = tonumber(page)
            if page then
                if sign == "+" then
                    page = realpage + page
                end
                if sign == "-" then
                    report("negative page numbers are not supported")
                else
                    if trace then
                        report("marking page %i as %a",page,name)
                    end
                    data[page][name] = true
                end
            end
        end
    else
        if trace then
            report("marking current page %i as %a",realpage,name)
        end
        data[realpage][name] = true
    end
end

function pages.marked(name)
    local realpage = texgetcount("realpageno")
    for i=last,realpage-1 do
        data[i] = nil
    end
    local pagedata = rawget(data,realpage)
    return pagedata and pagedata[name]
end

local function toranges(marked)
    local list = { }
    local size = #marked
    if size > 0 then
        local first = marked[1]
        local last  = first
        for i=2,size do
            local page = marked[i]
            if page > last + 1 then
                list[#list+1] = { first, last }
                first = page
            end
            last = page
        end
        list[#list+1] = { first, last }
    end
    return list
end

pages.toranges = toranges

local function allmarked(list)
    if list then
        local collected = pages.collected
        if collected then
            if type(list) == "string" then
                list = settings_to_hash(list)
            elseif type(list) == "table" and #list > 0 then
                list = tohash(list)
            end
            if type(list) == "table" then
                local found = { }
                for name in next, list do
                    for page, list in next, data do
                        if list[name] and collected[page] then
                            found[#found+1] = page
                        end
                    end
                end
                if #found > 0 then
                    sort(found)
                    if trace then
                        local ranges = toranges(found)
                        for i=1,#ranges do
                            local range = ranges[i]
                            local first = range[1]
                            local last  = range[2]
                            if first == last then
                                report("marked page : %i",first)
                            else
                                report("marked range: %i upto %i",first,last)
                            end
                        end
                    end
                    return found
                end
            end
        end
    end
end

pages.allmarked = allmarked

-- An alternative is to use an attribute and identify the state by parsing the node
-- list but that's a bit overkill for a hardly used feature like this.

luatex.registerpageactions(function()
    local nofauto = #autolist
    if nofauto > 0 then
        local realpage = texgetcount("realpageno")
        for i=1,nofauto do
            local names = autolist[i]
            for j=1,#names do
                local name = names[j]
                data[realpage][name] = true
                if trace then
                    report("automatically marking page %i as %a",realpage,name)
                end
            end
        end
    end
end)

interfaces.implement {
    name      = "markpage",
    arguments = { "string", "string" },
    actions   = pages.mark
}

interfaces.implement {
    name      = "doifelsemarkedpage",
    arguments = "string",
    actions   = { marked, ctx_testcase }
}

interfaces.implement {
    name      = "markedpages",
    arguments = "string",
    actions   = function(name)
        local t = allmarked(name)
        if t then
            context("%,t",t)
        end
    end
}

interfaces.implement {
    name      = "startmarkpages",
    arguments = "string",
    actions   = function(name)
        insert(autolist,settings_to_array(name))
    end
}

interfaces.implement {
    name      = "stopmarkpages",
    arguments = "string",
    actions   = function(name)
        if #autolist > 0 then
            remove(autolist)
        end
    end
}