mirror of
https://github.com/koreader/koreader
synced 2024-11-04 12:00:25 +00:00
223 lines
8.3 KiB
Lua
223 lines
8.3 KiB
Lua
--[[--
|
|
This module is responsible for constructing the KOReader menu based on a list of
|
|
menu_items and a separate menu order.
|
|
]]
|
|
|
|
local DataStorage = require("datastorage")
|
|
local FFIUtil = require("ffi/util")
|
|
local lfs = require("libs/libkoreader-lfs")
|
|
local logger = require("logger")
|
|
local _ = require("gettext")
|
|
|
|
local separator_id = "----------------------------"
|
|
|
|
local MenuSorter = {
|
|
orphaned_prefix = _("NEW: "),
|
|
separator = {
|
|
id = separator_id,
|
|
text = "KOMenu:separator",
|
|
},
|
|
}
|
|
|
|
function MenuSorter:readMSSettings(config_prefix)
|
|
if config_prefix then
|
|
local menu_order = string.format(
|
|
"%s/%s_menu_order", DataStorage:getSettingsDir(), config_prefix)
|
|
|
|
if lfs.attributes(menu_order..".lua") then
|
|
return require(menu_order) or {}
|
|
end
|
|
end
|
|
return {}
|
|
end
|
|
|
|
function MenuSorter:mergeAndSort(config_prefix, item_table, order)
|
|
local user_order = self:readMSSettings(config_prefix)
|
|
if user_order then
|
|
for user_order_id, user_order_item in pairs(user_order) do
|
|
order[user_order_id] = user_order_item
|
|
end
|
|
end
|
|
return self:sort(item_table, order)
|
|
end
|
|
|
|
--- Sorts a flat table of menu items into a hierarchical menu based on supplied order.
|
|
---- @tparam table item_table menu item table
|
|
---- @tparam table order sorting order
|
|
---- @treturn table the sorted menu item table
|
|
function MenuSorter:sort(item_table, order)
|
|
local menu_table = {}
|
|
local sub_menus = {}
|
|
-- the actual sorting of menu items
|
|
for order_id, order_item in pairs(order) do
|
|
-- user might define non-existing menu item
|
|
if item_table[order_id] ~= nil then
|
|
local tmp_menu_table = {}
|
|
menu_table[order_id] = item_table[order_id]
|
|
menu_table[order_id].id = order_id
|
|
for order_number, order_number_id in ipairs(order_item) do
|
|
-- this is a submenu, mark it for later
|
|
if item_table[order_number_id] ~= nil and order[order_number_id] then
|
|
table.insert(sub_menus, order_number_id)
|
|
tmp_menu_table[order_number] = {
|
|
id = order_number_id,
|
|
}
|
|
-- regular, just insert a menu action
|
|
else
|
|
if order_number_id == separator_id then
|
|
-- it's a separator
|
|
tmp_menu_table[order_number] = self.separator
|
|
elseif item_table[order_number_id] ~= nil then
|
|
item_table[order_number_id].id = order_number_id
|
|
tmp_menu_table[order_number] = item_table[order_number_id]
|
|
-- remove reference from item_table so it won't show up as orphaned
|
|
item_table[order_number_id] = nil
|
|
end
|
|
end
|
|
end
|
|
-- compress menus
|
|
-- if menu_items were missing we might have a table with gaps
|
|
-- but ipairs doesn't like that and quits when it hits nil
|
|
local i = 1
|
|
local new_index = 1
|
|
while i <= table.maxn(tmp_menu_table) do
|
|
local v = tmp_menu_table[i]
|
|
if v then
|
|
if v.id == separator_id then
|
|
new_index = new_index - 1
|
|
-- ignore separator if the menu starts with it
|
|
if new_index > 0 then
|
|
menu_table[order_id][new_index].separator = true
|
|
end
|
|
else
|
|
-- fix the index
|
|
menu_table[order_id][new_index] = tmp_menu_table[i]
|
|
end
|
|
|
|
new_index = new_index + 1
|
|
end
|
|
i = i + 1
|
|
end
|
|
else
|
|
if order_id ~= "KOMenu:disabled" and order_id ~="plus_menu" then
|
|
--"plus_menu" break an assumption of the menu_sorter, but it's ok, so ignore it.
|
|
--See : https://github.com/koreader/koreader/pull/3844#issuecomment-383092219
|
|
logger.warn("menu id not found:", order_id)
|
|
end
|
|
end
|
|
end
|
|
|
|
-- We should not rely on Lua to magically order the items as we expected:
|
|
-- Some menu items cannot be referred until its parent menu item is inserted into
|
|
-- menu_table["KOMenu:menu_buttons"].
|
|
-- So we loop until nothing changed anymore.
|
|
local changed = true
|
|
while changed do
|
|
changed = false
|
|
-- now do the submenus
|
|
for i, sub_menu in ipairs(sub_menus) do
|
|
if menu_table[sub_menu] ~= nil then
|
|
local sub_menu_position = self:findById(menu_table["KOMenu:menu_buttons"], sub_menu)
|
|
if sub_menu_position then
|
|
changed = true
|
|
local sub_menu_content = menu_table[sub_menu]
|
|
sub_menu_position.text = sub_menu_content.text
|
|
sub_menu_position.hold_callback = sub_menu_content.hold_callback
|
|
sub_menu_position.sub_item_table = sub_menu_content
|
|
-- remove reference from top level output
|
|
menu_table[sub_menu] = nil
|
|
-- remove reference from input so it won't show up as orphaned
|
|
item_table[sub_menu] = nil
|
|
end
|
|
end
|
|
end
|
|
end
|
|
-- cleanup, top-level items shouldn't have sub_item_table
|
|
-- they should, however have one going in
|
|
-- Also, compress the menu table.
|
|
local menu_buttons_offset = 0
|
|
for i, top_menu in ipairs(menu_table["KOMenu:menu_buttons"]) do
|
|
local menu_button = menu_table["KOMenu:menu_buttons"][i].sub_item_table
|
|
menu_table["KOMenu:menu_buttons"][i] = nil
|
|
if menu_button then
|
|
menu_table["KOMenu:menu_buttons"][i-menu_buttons_offset] = menu_button
|
|
else
|
|
menu_buttons_offset = menu_buttons_offset + 1
|
|
end
|
|
end
|
|
-- handle disabled
|
|
if order["KOMenu:disabled"] then
|
|
for _, item in ipairs(order["KOMenu:disabled"]) do
|
|
if item_table[item] then
|
|
-- remove reference from input so it won't show up as orphaned
|
|
item_table[item] = nil
|
|
end
|
|
end
|
|
end
|
|
|
|
-- remove top level reference before orphan handling
|
|
item_table["KOMenu:menu_buttons"] = nil
|
|
|
|
-- attach orphans based on sorting_hint, or with a NEW prefix in the first menu if none found
|
|
for k, v in FFIUtil.orderedPairs(item_table) do
|
|
local sorting_hint = v.sorting_hint
|
|
|
|
-- normally there should be menu text but check to be sure
|
|
if v.text and v.new ~= true then
|
|
v.id = k
|
|
if not sorting_hint then v.text = self.orphaned_prefix .. v.text end
|
|
-- prevent text being prepended to item on menu reload, i.e., on switching between reader and filemanager
|
|
v.new = true
|
|
-- deal with orphaned submenus
|
|
if #v > 0 then
|
|
v.sub_item_table = {}
|
|
for i=1, #v do
|
|
v.sub_item_table[i] = v[i]
|
|
end
|
|
end
|
|
end
|
|
if sorting_hint then
|
|
local sorting_hint_menu = self:findById(menu_table["KOMenu:menu_buttons"], sorting_hint)
|
|
sorting_hint_menu = sorting_hint_menu.sub_item_table or sorting_hint_menu
|
|
table.insert(sorting_hint_menu, v)
|
|
else
|
|
table.insert(menu_table["KOMenu:menu_buttons"][1], v)
|
|
end
|
|
end
|
|
return menu_table["KOMenu:menu_buttons"]
|
|
end
|
|
|
|
--- Returns a menu item by ID.
|
|
---- @tparam table tbl Lua table
|
|
---- @tparam string needle_id Menu item ID string
|
|
---- @treturn table a reference to the table item if found
|
|
function MenuSorter:findById(tbl, needle_id)
|
|
local items = {}
|
|
|
|
for _, item in pairs(tbl) do
|
|
if item ~= "KOMenu:menu_buttons" then
|
|
table.insert(items, item)
|
|
end
|
|
end
|
|
|
|
local k, v
|
|
k, v = next(items, nil)
|
|
while k do
|
|
local id_match = v.id == needle_id
|
|
local sub_table = v.sub_item_table or type(v) == "table" and v
|
|
|
|
if id_match then
|
|
return v
|
|
elseif sub_table then
|
|
for _, item in pairs(sub_table) do
|
|
if type(item) == "table" and item.id then
|
|
table.insert(items, item)
|
|
end
|
|
end
|
|
end
|
|
k, v = next(items, k)
|
|
end
|
|
end
|
|
|
|
return MenuSorter
|