mirror of https://github.com/koreader/koreader
You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
809 lines
27 KiB
Lua
809 lines
27 KiB
Lua
local BD = require("ui/bidi")
|
|
local Button = require("ui/widget/button")
|
|
local CenterContainer = require("ui/widget/container/centercontainer")
|
|
local ConfirmBox = require("ui/widget/confirmbox")
|
|
local Device = require("device")
|
|
local Event = require("ui/event")
|
|
local Font = require("ui/font")
|
|
local GestureRange = require("ui/gesturerange")
|
|
local Geom = require("ui/geometry")
|
|
local InfoMessage = require("ui/widget/infomessage")
|
|
local InputContainer = require("ui/widget/container/inputcontainer")
|
|
local Menu = require("ui/widget/menu")
|
|
local UIManager = require("ui/uimanager")
|
|
local logger = require("logger")
|
|
local util = require("util")
|
|
local _ = require("gettext")
|
|
local Screen = Device.screen
|
|
local T = require("ffi/util").template
|
|
|
|
local ReaderToc = InputContainer:new{
|
|
toc = nil,
|
|
toc_depth = nil,
|
|
ticks = nil,
|
|
ticks_flattened = nil,
|
|
toc_indent = " ",
|
|
collapsed_toc = {},
|
|
collapse_depth = 2,
|
|
expanded_nodes = {},
|
|
toc_menu_title = _("Table of contents"),
|
|
alt_toc_menu_title = _("Table of contents *"),
|
|
}
|
|
|
|
function ReaderToc:init()
|
|
if Device:hasKeyboard() then
|
|
self.key_events = {
|
|
ShowToc = {
|
|
{ "T" },
|
|
doc = "show Table of Content menu" },
|
|
}
|
|
end
|
|
self:resetToc()
|
|
self.ui.menu:registerToMainMenu(self)
|
|
end
|
|
|
|
function ReaderToc:cleanUpTocTitle(title)
|
|
return (title:gsub("\13", ""))
|
|
end
|
|
|
|
function ReaderToc:onSetDimensions(dimen)
|
|
self.dimen = dimen
|
|
end
|
|
|
|
function ReaderToc:resetToc()
|
|
self.toc = nil
|
|
self.toc_depth = nil
|
|
self.ticks = nil
|
|
self.ticks_flattened = nil
|
|
self.collapsed_toc = {}
|
|
self.collapse_depth = 2
|
|
self.expanded_nodes = {}
|
|
end
|
|
|
|
function ReaderToc:onUpdateToc()
|
|
self:resetToc()
|
|
self.ui:handleEvent(Event:new("TocReset"))
|
|
|
|
--- @note: Let this propagate, plugins/statistics uses it to react to changes in document pagination
|
|
--return true
|
|
end
|
|
|
|
function ReaderToc:onPageUpdate(pageno)
|
|
if UIManager.FULL_REFRESH_COUNT == -1 or G_reader_settings:isTrue("refresh_on_chapter_boundaries") then
|
|
local flash_on_second = G_reader_settings:nilOrFalse("no_refresh_on_second_chapter_page")
|
|
local paging_forward, paging_backward
|
|
if flash_on_second then
|
|
if self.pageno then
|
|
if pageno > self.pageno then
|
|
paging_forward = true
|
|
elseif pageno < self.pageno then
|
|
paging_backward = true
|
|
end
|
|
end
|
|
end
|
|
|
|
if paging_backward and self:isChapterEnd(pageno) then
|
|
UIManager:setDirty(nil, "full")
|
|
elseif self:isChapterStart(pageno) then
|
|
UIManager:setDirty(nil, "full")
|
|
elseif paging_forward and self:isChapterSecondPage(pageno) then
|
|
UIManager:setDirty(nil, "full")
|
|
end
|
|
end
|
|
|
|
self.pageno = pageno
|
|
end
|
|
|
|
function ReaderToc:onPosUpdate(pos, pageno)
|
|
if pageno then
|
|
self.pageno = pageno
|
|
end
|
|
end
|
|
|
|
function ReaderToc:fillToc()
|
|
if self.toc then return end
|
|
if self.ui.document:canHaveAlternativeToc() then
|
|
if self.ui.doc_settings:readSetting("alternative_toc") then
|
|
-- (if the document has a cache, the previously built alternative
|
|
-- TOC was saved and has been reloaded, and this will be avoided)
|
|
if not self.ui.document:isTocAlternativeToc() then
|
|
self:resetToc()
|
|
self.ui.document:buildAlternativeToc()
|
|
end
|
|
end
|
|
end
|
|
self.toc = self.ui.document:getToc()
|
|
self:validateAndFixToc()
|
|
end
|
|
|
|
function ReaderToc:validateAndFixToc()
|
|
-- Our code expects (rightfully) the TOC items to be ordered and to have
|
|
-- increasing page numbers, but we may occasionally not get that from the
|
|
-- engines (usually, because of bugs or duplicated IDs in the document).
|
|
local toc = self.toc
|
|
local first = 1
|
|
local last = #toc
|
|
|
|
-- For testing: shuffle a bit a valid TOC and make it randomely invalid
|
|
-- for i = first, last do
|
|
-- toc[i].page = toc[i].page + math.random(10) - 5
|
|
-- end
|
|
|
|
-- Do a cheap quick scan first
|
|
logger.dbg("validateAndFixToc(): quick scan")
|
|
local has_bogus
|
|
local cur_page = 0
|
|
for i = first, last do
|
|
local page = toc[i].page
|
|
if page < cur_page then
|
|
has_bogus = true
|
|
break
|
|
end
|
|
cur_page = page
|
|
end
|
|
if not has_bogus then -- no TOC items, or all are valid
|
|
logger.dbg("validateAndFixToc(): TOC is fine")
|
|
return
|
|
end
|
|
logger.dbg("validateAndFixToc(): TOC needs fixing")
|
|
|
|
-- Bad ordering previously noticed: try to fix the wrong items' page
|
|
-- by setting it to the previous or next good item page.
|
|
local nb_bogus = 0
|
|
local nb_fixed_pages = 0
|
|
-- We fix only one bogus item per loop, taking the option that
|
|
-- changes the least nb of items.
|
|
-- Sample cases, *N* being the page noticed as bogus:
|
|
-- 1 4 57 *6* 9 13 24 best to reset 57 to 4 (or 6, or 5)
|
|
-- 1 4 57 *6* 79 84 96 best to reset 6 to 57 (or 79 or 68)
|
|
-- 1 4 55 56 57 *6* 7 8 9 10 best to reset 55,56,57 to 4
|
|
-- 1 4 55 56 57 *6* 7 60 62 best to reset 6,7 to 57
|
|
-- (These cases are met in the following code with cur_page=57 and page=6)
|
|
cur_page = 0
|
|
for i = first, last do
|
|
local page = toc[i].fixed_page or toc[i].page
|
|
if page >= cur_page then
|
|
cur_page = page
|
|
else
|
|
-- Bogus page (or bogus previous page)
|
|
nb_bogus = nb_bogus + 1
|
|
-- See how many pages we'd need fixing on either side
|
|
local nb_prev = 0
|
|
local nb_prev_main = 0
|
|
for j = i-1, first, -1 do
|
|
local ppage = toc[j].fixed_page or toc[j].page
|
|
if ppage <= page then
|
|
break
|
|
else
|
|
nb_prev = nb_prev + 1
|
|
if self.ui.document:getPageFlow(ppage) == 0 then
|
|
nb_prev_main = nb_prev_main + 1
|
|
end
|
|
end
|
|
end
|
|
local nb_next = 0
|
|
local nb_next_main = 0
|
|
for j = i, last do
|
|
local npage = toc[j].fixed_page or toc[j].page
|
|
if npage >= cur_page then
|
|
break
|
|
else
|
|
nb_next = nb_next + 1
|
|
if self.ui.document:getPageFlow(npage) == 0 then
|
|
nb_next_main = nb_next_main + 1
|
|
end
|
|
end
|
|
end
|
|
logger.dbg("BOGUS TOC:", i, page, "<", i-1, cur_page, "-", nb_prev, nb_next)
|
|
-- Note: by comparing only the entries that belong to the main (linear) flow
|
|
-- we give priority to moving non-linear bogus entries
|
|
if nb_prev_main <= nb_next_main then -- less changes when fixing previous pages
|
|
local fixed_page
|
|
if i-nb_prev-1 >= 1 then
|
|
fixed_page = toc[i-nb_prev-1].fixed_page or toc[i-nb_prev-1].page
|
|
else
|
|
fixed_page = 1
|
|
end
|
|
for j = i-1, i-nb_prev, -1 do
|
|
toc[j].fixed_page = fixed_page
|
|
logger.dbg(" fix prev", j, toc[j].page, "=>", fixed_page)
|
|
end
|
|
else
|
|
local fixed_page = cur_page -- (might be better to use next one, but not safer)
|
|
for j = i, i+nb_next-1 do
|
|
toc[j].fixed_page = fixed_page
|
|
logger.dbg(" fix next", j, toc[j].page, "=>", fixed_page)
|
|
end
|
|
end
|
|
cur_page = toc[i].fixed_page or toc[i].page
|
|
end
|
|
end
|
|
if nb_bogus > 0 then
|
|
for i = first, last do
|
|
if toc[i].fixed_page and toc[i].fixed_page ~= toc[i].page then
|
|
toc[i].orig_page = toc[i].page -- keep the original one, for display only
|
|
toc[i].page = toc[i].fixed_page
|
|
nb_fixed_pages = nb_fixed_pages + 1
|
|
end
|
|
end
|
|
end
|
|
logger.info(string.format("TOC had %d bogus page numbers: fixed %d items to keep them ordered.", nb_bogus, nb_fixed_pages))
|
|
end
|
|
|
|
function ReaderToc:getTocIndexByPage(pn_or_xp)
|
|
self:fillToc()
|
|
if #self.toc == 0 then return end
|
|
local pageno = pn_or_xp
|
|
if type(pn_or_xp) == "string" then
|
|
return self:getAccurateTocIndexByXPointer(pn_or_xp)
|
|
end
|
|
local pre_index = 1
|
|
for _k,_v in ipairs(self.toc) do
|
|
if _v.page > pageno then
|
|
break
|
|
end
|
|
pre_index = _k
|
|
end
|
|
return pre_index
|
|
end
|
|
|
|
function ReaderToc:getAccurateTocIndexByXPointer(xptr)
|
|
local pageno = self.ui.document:getPageFromXPointer(xptr)
|
|
-- get toc entry(index) on for the current page
|
|
-- we don't get infinite loop, because the this call is not
|
|
-- with xpointer, but with page
|
|
local index = self:getTocIndexByPage(pageno)
|
|
if not index or not self.toc[index] then return end
|
|
local initial_comparison = self.ui.document:compareXPointers(self.toc[index].xpointer, xptr)
|
|
if initial_comparison and initial_comparison < 0 then
|
|
local i = index - 1
|
|
while self.toc[i] do
|
|
local toc_xptr = self.toc[i].xpointer
|
|
local cmp = self.ui.document:compareXPointers(toc_xptr, xptr)
|
|
if cmp and cmp >= 0 then -- toc_xptr is before xptr(xptr >= toc_xptr)
|
|
return i
|
|
end
|
|
i = i - 1
|
|
end
|
|
else
|
|
local i = index + 1
|
|
while self.toc[i] do
|
|
local toc_xptr = self.toc[i].xpointer
|
|
local cmp = self.ui.document:compareXPointers(toc_xptr, xptr)
|
|
if cmp and cmp < 0 then -- toc_xptr is after xptr(xptr < toc_xptr)
|
|
return i - 1
|
|
end
|
|
i = i + 1
|
|
end
|
|
end
|
|
return index
|
|
end
|
|
|
|
function ReaderToc:getTocTitleByPage(pn_or_xp)
|
|
local index = self:getTocIndexByPage(pn_or_xp)
|
|
if index then
|
|
return self:cleanUpTocTitle(self.toc[index].title)
|
|
else
|
|
return ""
|
|
end
|
|
end
|
|
|
|
function ReaderToc:getTocTitleOfCurrentPage()
|
|
if self.pageno then
|
|
return self:getTocTitleByPage(self.pageno)
|
|
end
|
|
end
|
|
|
|
function ReaderToc:getMaxDepth()
|
|
if self.toc_depth then return self.toc_depth end
|
|
|
|
-- Not cached yet, compute it
|
|
self:fillToc()
|
|
local max_depth = 0
|
|
for _, v in ipairs(self.toc) do
|
|
if v.depth > max_depth then
|
|
max_depth = v.depth
|
|
end
|
|
end
|
|
self.toc_depth = max_depth
|
|
return self.toc_depth
|
|
end
|
|
|
|
--[[
|
|
The ToC ticks is a list of page numbers in ascending order of ToC nodes at a particular depth level.
|
|
A positive level returns nodes at that depth level (top-level is 1, depth always matches level. Higher values mean deeper nesting.)
|
|
A negative level does the same, but computes the depth level in reverse (i.e., -1 is the most deeply nested one).
|
|
Omitting the level argument returns the full hierarchical table.
|
|
--]]
|
|
function ReaderToc:getTocTicks(level)
|
|
-- Handle negative levels
|
|
if level and level < 0 then
|
|
level = self:getMaxDepth() + level + 1
|
|
end
|
|
|
|
if level then
|
|
if self.ticks and self.ticks[level] then
|
|
return self.ticks[level]
|
|
end
|
|
else
|
|
if self.ticks then
|
|
return self.ticks
|
|
end
|
|
end
|
|
|
|
-- Build ToC ticks if not found
|
|
self:fillToc()
|
|
self.ticks = {}
|
|
|
|
if #self.toc > 0 then
|
|
-- Start by building a simple hierarchical ToC tick table
|
|
for _, v in ipairs(self.toc) do
|
|
if not self.ticks[v.depth] then
|
|
self.ticks[v.depth] = {}
|
|
end
|
|
table.insert(self.ticks[v.depth], v.page)
|
|
end
|
|
|
|
-- Normally the ticks are already sorted, but in rare cases,
|
|
-- ToC nodes may be not in ascending order
|
|
for k, _ in ipairs(self.ticks) do
|
|
table.sort(self.ticks[k])
|
|
end
|
|
end
|
|
|
|
if level then
|
|
return self.ticks[level]
|
|
else
|
|
return self.ticks
|
|
end
|
|
end
|
|
|
|
--[[
|
|
Returns a flattened list of ToC ticks, without duplicates
|
|
]]
|
|
function ReaderToc:getTocTicksFlattened()
|
|
if self.ticks_flattened then return self.ticks_flattened end
|
|
|
|
-- It hasn't been cached yet, compute it.
|
|
local ticks = self:getTocTicks()
|
|
local ticks_flattened = {}
|
|
|
|
-- Keep track of what we add to avoid duplicates (c.f., https://stackoverflow.com/a/20067270)
|
|
local hash = {}
|
|
for _, v in ipairs(ticks) do
|
|
for depth, page in ipairs(v) do
|
|
if not hash[page] then
|
|
table.insert(ticks_flattened, page)
|
|
hash[page] = true
|
|
end
|
|
end
|
|
end
|
|
|
|
-- And finally, sort it again
|
|
table.sort(ticks_flattened)
|
|
|
|
self.ticks_flattened = ticks_flattened
|
|
return self.ticks_flattened
|
|
end
|
|
|
|
function ReaderToc:getNextChapter(cur_pageno)
|
|
local ticks = self:getTocTicksFlattened()
|
|
local next_chapter = nil
|
|
for _, page in ipairs(ticks) do
|
|
if page > cur_pageno then
|
|
next_chapter = page
|
|
break
|
|
end
|
|
end
|
|
return next_chapter
|
|
end
|
|
|
|
function ReaderToc:getPreviousChapter(cur_pageno)
|
|
local ticks = self:getTocTicksFlattened()
|
|
local previous_chapter = nil
|
|
for _, page in ipairs(ticks) do
|
|
if page >= cur_pageno then
|
|
break
|
|
end
|
|
previous_chapter = page
|
|
end
|
|
return previous_chapter
|
|
end
|
|
|
|
function ReaderToc:isChapterStart(cur_pageno)
|
|
local ticks = self:getTocTicksFlattened()
|
|
local _start = false
|
|
for _, page in ipairs(ticks) do
|
|
if page == cur_pageno then
|
|
_start = true
|
|
break
|
|
end
|
|
end
|
|
return _start
|
|
end
|
|
|
|
function ReaderToc:isChapterSecondPage(cur_pageno)
|
|
local ticks = self:getTocTicksFlattened()
|
|
local _second = false
|
|
for _, page in ipairs(ticks) do
|
|
if page + 1 == cur_pageno then
|
|
_second = true
|
|
break
|
|
end
|
|
end
|
|
return _second
|
|
end
|
|
|
|
function ReaderToc:isChapterEnd(cur_pageno)
|
|
local ticks = self:getTocTicksFlattened()
|
|
local _end = false
|
|
for _, page in ipairs(ticks) do
|
|
if page - 1 == cur_pageno then
|
|
_end = true
|
|
break
|
|
end
|
|
end
|
|
return _end
|
|
end
|
|
|
|
function ReaderToc:getChapterPagesLeft(pageno)
|
|
if self.ui.document:hasHiddenFlows() then
|
|
-- Count pages until new chapter
|
|
local pages_left = 0
|
|
local test_page = self.ui.document:getNextPage(pageno)
|
|
while test_page > 0 do
|
|
pages_left = pages_left + 1
|
|
if self:isChapterStart(test_page) then
|
|
return pages_left - 1
|
|
end
|
|
test_page = self.ui.document:getNextPage(test_page)
|
|
end
|
|
else
|
|
local next_chapter = self:getNextChapter(pageno)
|
|
if next_chapter then
|
|
next_chapter = next_chapter - pageno - 1
|
|
end
|
|
return next_chapter
|
|
end
|
|
end
|
|
|
|
function ReaderToc:getChapterPagesDone(pageno)
|
|
if self:isChapterStart(pageno) then return 0 end
|
|
if self.ui.document:hasHiddenFlows() then
|
|
-- Count pages until chapter start
|
|
local pages_done = 0
|
|
local test_page = self.ui.document:getPrevPage(pageno)
|
|
while test_page > 0 do
|
|
pages_done = pages_done + 1
|
|
if self:isChapterStart(test_page) then
|
|
return pages_done
|
|
end
|
|
test_page = self.ui.document:getPrevPage(test_page)
|
|
end
|
|
else
|
|
local previous_chapter = self:getPreviousChapter(pageno)
|
|
if previous_chapter then
|
|
previous_chapter = pageno - previous_chapter
|
|
end
|
|
return previous_chapter
|
|
end
|
|
end
|
|
|
|
function ReaderToc:updateCurrentNode()
|
|
if #self.collapsed_toc > 0 and self.pageno then
|
|
for i, v in ipairs(self.collapsed_toc) do
|
|
if v.page > self.pageno then
|
|
self.collapsed_toc.current = i > 1 and i - 1 or 1
|
|
return
|
|
end
|
|
end
|
|
self.collapsed_toc.current = #self.collapsed_toc
|
|
end
|
|
end
|
|
|
|
function ReaderToc:expandParentNode(index)
|
|
if index then
|
|
local nodes_to_expand = {}
|
|
local depth = self.toc[index].depth
|
|
for i = index - 1, 1, -1 do
|
|
if depth > self.toc[i].depth then
|
|
depth = self.toc[i].depth
|
|
table.insert(nodes_to_expand, i)
|
|
end
|
|
if depth == 1 then break end
|
|
end
|
|
for i = #nodes_to_expand, 1, -1 do
|
|
self:expandToc(nodes_to_expand[i])
|
|
end
|
|
end
|
|
end
|
|
|
|
function ReaderToc:onShowToc()
|
|
self:fillToc()
|
|
-- build menu items
|
|
if #self.toc > 0 and not self.toc[1].text then
|
|
for _,v in ipairs(self.toc) do
|
|
v.text = self.toc_indent:rep(v.depth-1)..self:cleanUpTocTitle(v.title)
|
|
v.mandatory = v.page
|
|
if self.ui.document:hasHiddenFlows() then
|
|
local flow = self.ui.document:getPageFlow(v.page)
|
|
if v.orig_page then -- bogus page fixed: show original page number
|
|
-- This is an ugly piece of code, which can result in an ugly TOC,
|
|
-- but it shouldn't be needed very often, only when bogus page numbers
|
|
-- are fixed, and then showing everything gets complicated
|
|
local orig_flow = self.ui.document:getPageFlow(v.orig_page)
|
|
if flow == 0 and orig_flow == flow then
|
|
v.mandatory = T("(%1) %2", self.ui.document:getPageNumberInFlow(v.orig_page), self.ui.document:getPageNumberInFlow(v.page))
|
|
elseif flow == 0 and orig_flow ~= flow then
|
|
v.mandatory = T("[%1]%2", self.ui.document:getPageNumberInFlow(v.orig_page), self.ui.document:getPageFlow(v.orig_page))
|
|
elseif flow > 0 and orig_flow == flow then
|
|
v.mandatory = T("[(%1) %2]%3", self.ui.document:getPageNumberInFlow(v.orig_page),
|
|
self.ui.document:getPageNumberInFlow(v.page), self.ui.document:getPageFlow(v.page))
|
|
else
|
|
v.mandatory = T("([%1]%2) [%3]%4", self.ui.document:getPageNumberInFlow(v.orig_page), self.ui.document:getPageFlow(v.orig_page),
|
|
self.ui.document:getPageNumberInFlow(v.page), self.ui.document:getPageFlow(v.page))
|
|
end
|
|
else
|
|
-- Plain numbers for the linear entries,
|
|
-- for non-linear entries we use the same syntax as in the Go to dialog
|
|
if flow == 0 then
|
|
v.mandatory = self.ui.document:getPageNumberInFlow(v.page)
|
|
else
|
|
v.mandatory = T("[%1]%2", self.ui.document:getPageNumberInFlow(v.page), self.ui.document:getPageFlow(v.page))
|
|
end
|
|
end
|
|
elseif v.orig_page then -- bogus page fixed: show original page number
|
|
v.mandatory = T("(%1) %2", v.orig_page, v.page)
|
|
end
|
|
if self.ui.pagemap and self.ui.pagemap:wantsPageLabels() then
|
|
v.mandatory = self.ui.pagemap:getXPointerPageLabel(v.xpointer)
|
|
end
|
|
end
|
|
end
|
|
|
|
-- Estimate expand/collapse icon size
|
|
local items_per_page = G_reader_settings:readSetting("items_per_page") or 14
|
|
-- *2/5 to acount for Menu top title and bottom icons, and add some air between consecutive icons
|
|
local icon_size = math.floor(Screen:getHeight() / items_per_page * 2/5)
|
|
local button_width = icon_size * 2
|
|
self.expand_button = Button:new{
|
|
icon = "control.expand",
|
|
icon_rotation_angle = BD.mirroredUILayout() and 180 or 0,
|
|
width = button_width,
|
|
icon_width = icon_size,
|
|
icon_height = icon_size,
|
|
bordersize = 0,
|
|
show_parent = self,
|
|
}
|
|
|
|
self.collapse_button = Button:new{
|
|
icon = "control.collapse",
|
|
width = button_width,
|
|
icon_width = icon_size,
|
|
icon_height = icon_size,
|
|
bordersize = 0,
|
|
show_parent = self,
|
|
}
|
|
|
|
-- update collapsible state
|
|
if #self.toc > 0 and #self.collapsed_toc == 0 then
|
|
local depth = 0
|
|
for i = #self.toc, 1, -1 do
|
|
local v = self.toc[i]
|
|
-- node v has child node(s)
|
|
if v.depth < depth then
|
|
v.state = self.expand_button:new{
|
|
callback = function() self:expandToc(i) end,
|
|
indent = self.toc_indent:rep(v.depth-1),
|
|
}
|
|
end
|
|
if v.depth < self.collapse_depth then
|
|
table.insert(self.collapsed_toc, 1, v)
|
|
end
|
|
depth = v.depth
|
|
end
|
|
end
|
|
|
|
local button_size = self.expand_button:getSize()
|
|
local toc_menu = Menu:new{
|
|
title = _("Table of Contents"),
|
|
item_table = self.collapsed_toc,
|
|
state_size = button_size,
|
|
ui = self.ui,
|
|
is_borderless = true,
|
|
is_popout = false,
|
|
width = Screen:getWidth(),
|
|
height = Screen:getHeight(),
|
|
cface = Font:getFace("x_smallinfofont"),
|
|
single_line = true,
|
|
align_baselines = true,
|
|
perpage = items_per_page,
|
|
line_color = require("ffi/blitbuffer").COLOR_WHITE,
|
|
on_close_ges = {
|
|
GestureRange:new{
|
|
ges = "two_finger_swipe",
|
|
range = Geom:new{
|
|
x = 0, y = 0,
|
|
w = Screen:getWidth(),
|
|
h = Screen:getHeight(),
|
|
},
|
|
direction = BD.flipDirectionIfMirroredUILayout("west")
|
|
}
|
|
}
|
|
}
|
|
|
|
local menu_container = CenterContainer:new{
|
|
dimen = Screen:getSize(),
|
|
covers_fullscreen = true, -- hint for UIManager:_repaint()
|
|
toc_menu,
|
|
}
|
|
|
|
function toc_menu:onMenuSelect(item, pos)
|
|
-- if toc item has expand/collapse state and tap select on the left side
|
|
-- the state switch action is triggered, otherwise goto the linked page
|
|
local do_toggle_state = false
|
|
if item.state and pos and pos.x then
|
|
if BD.mirroredUILayout() then
|
|
do_toggle_state = pos.x > 0.7
|
|
else
|
|
do_toggle_state = pos.x < 0.3
|
|
end
|
|
end
|
|
if do_toggle_state then
|
|
item.state.callback()
|
|
else
|
|
toc_menu:close_callback()
|
|
self.ui.link:addCurrentLocationToStack()
|
|
self.ui:handleEvent(Event:new("GotoPage", item.page))
|
|
end
|
|
end
|
|
|
|
function toc_menu:onMenuHold(item)
|
|
-- Trim toc_indent
|
|
local trimmed_text = util.ltrim(item.text)
|
|
local infomessage = InfoMessage:new{
|
|
show_icon = false,
|
|
text = trimmed_text,
|
|
}
|
|
UIManager:show(infomessage)
|
|
return true
|
|
end
|
|
|
|
toc_menu.close_callback = function()
|
|
UIManager:close(menu_container)
|
|
end
|
|
|
|
toc_menu.show_parent = menu_container
|
|
|
|
self.toc_menu = toc_menu
|
|
|
|
self:updateCurrentNode()
|
|
-- auto expand the parent node of current page
|
|
self:expandParentNode(self:getTocIndexByPage(self.pageno))
|
|
-- auto goto page of the current toc entry
|
|
self.toc_menu:switchItemTable(nil, self.collapsed_toc, self.collapsed_toc.current or -1)
|
|
|
|
UIManager:show(menu_container)
|
|
|
|
return true
|
|
end
|
|
|
|
-- expand TOC node of index in raw toc table
|
|
function ReaderToc:expandToc(index)
|
|
for k, v in ipairs(self.expanded_nodes) do
|
|
if v == index then return end
|
|
end
|
|
table.insert(self.expanded_nodes, index)
|
|
local cur_node = self.toc[index]
|
|
local cur_depth = cur_node.depth
|
|
local collapsed_index = nil
|
|
for i, v in ipairs(self.collapsed_toc) do
|
|
if v.page == cur_node.page and v.depth == cur_depth
|
|
and v.text == cur_node.text then
|
|
collapsed_index = i
|
|
break
|
|
end
|
|
end
|
|
-- either the toc entry of index has no child nodes
|
|
-- or it's parent nodes are not expanded yet
|
|
if not collapsed_index then return end
|
|
for i = index + 1, #self.toc do
|
|
local v = self.toc[i]
|
|
if v.depth == cur_depth + 1 then
|
|
collapsed_index = collapsed_index + 1
|
|
table.insert(self.collapsed_toc, collapsed_index, v)
|
|
elseif v.depth <= cur_depth then
|
|
break
|
|
end
|
|
end
|
|
-- change state of current node to expanded
|
|
cur_node.state = self.collapse_button:new{
|
|
callback = function() self:collapseToc(index) end,
|
|
indent = self.toc_indent:rep(cur_depth-1),
|
|
}
|
|
self:updateCurrentNode()
|
|
self.toc_menu:switchItemTable(nil, self.collapsed_toc, -1)
|
|
end
|
|
|
|
-- collapse TOC node of index in raw toc table
|
|
function ReaderToc:collapseToc(index)
|
|
for k, v in ipairs(self.expanded_nodes) do
|
|
if v == index then
|
|
table.remove(self.expanded_nodes, k)
|
|
break
|
|
end
|
|
end
|
|
local cur_node = self.toc[index]
|
|
local cur_depth = cur_node.depth
|
|
local i = 1
|
|
local is_child_node = false
|
|
while i <= #self.collapsed_toc do
|
|
local v = self.collapsed_toc[i]
|
|
if v.page > cur_node.page and v.depth <= cur_depth then
|
|
is_child_node = false
|
|
end
|
|
if is_child_node then
|
|
table.remove(self.collapsed_toc, i)
|
|
else
|
|
i = i + 1
|
|
end
|
|
if v.page == cur_node.page and v.depth == cur_depth
|
|
and v.text == cur_node.text then
|
|
is_child_node = true
|
|
end
|
|
end
|
|
-- change state of current node to collapsed
|
|
cur_node.state = self.expand_button:new{
|
|
callback = function() self:expandToc(index) end,
|
|
indent = self.toc_indent:rep(cur_depth-1),
|
|
}
|
|
self:updateCurrentNode()
|
|
self.toc_menu:switchItemTable(nil, self.collapsed_toc, -1)
|
|
end
|
|
|
|
function ReaderToc:addToMainMenu(menu_items)
|
|
-- insert table to main reader menu
|
|
menu_items.table_of_contents = {
|
|
text_func = function()
|
|
return self.ui.document:isTocAlternativeToc() and self.alt_toc_menu_title or self.toc_menu_title
|
|
end,
|
|
callback = function()
|
|
self:onShowToc()
|
|
end,
|
|
}
|
|
if self.ui.document:canHaveAlternativeToc() then
|
|
menu_items.table_of_contents.hold_callback = function(touchmenu_instance)
|
|
if self.ui.document:isTocAlternativeToc() then
|
|
UIManager:show(ConfirmBox:new{
|
|
text = _("The table of content for this book is currently an alternative one built from the document headings.\nDo you want to get back the original table of content? (The book will be reloaded.)"),
|
|
ok_callback = function()
|
|
touchmenu_instance:closeMenu()
|
|
self.ui.doc_settings:delSetting("alternative_toc")
|
|
self.ui.document:invalidateCacheFile()
|
|
-- Allow for ConfirmBox to be closed before showing
|
|
-- "Opening file" InfoMessage
|
|
UIManager:scheduleIn(0.5, function ()
|
|
self.ui:reloadDocument()
|
|
end)
|
|
end,
|
|
})
|
|
else
|
|
UIManager:show(ConfirmBox:new{
|
|
text = _("Do you want to use an alternative table of content built from the document headings?"),
|
|
ok_callback = function()
|
|
touchmenu_instance:closeMenu()
|
|
self:resetToc()
|
|
self.ui.document:buildAlternativeToc()
|
|
self.ui.doc_settings:saveSetting("alternative_toc", true)
|
|
self:onShowToc()
|
|
self.view.footer:setTocMarkers(true)
|
|
self.view.footer:onUpdateFooter()
|
|
end,
|
|
})
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
return ReaderToc
|