2019-12-06 21:55:39 +00:00
|
|
|
local BD = require("ui/bidi")
|
2014-10-30 18:42:18 +00:00
|
|
|
local Device = require("device")
|
2016-12-03 13:19:35 +00:00
|
|
|
local DocSettings = require("docsettings")
|
2018-05-13 11:07:23 +00:00
|
|
|
local DocumentRegistry = require("document/documentregistry")
|
2018-10-14 06:49:00 +00:00
|
|
|
local OpenWithDialog = require("ui/widget/openwithdialog")
|
|
|
|
local ConfirmBox = require("ui/widget/confirmbox")
|
2017-02-20 14:08:35 +00:00
|
|
|
local Font = require("ui/font")
|
2017-04-29 08:38:09 +00:00
|
|
|
local Menu = require("ui/widget/menu")
|
|
|
|
local UIManager = require("ui/uimanager")
|
|
|
|
local ffi = require("ffi")
|
|
|
|
local lfs = require("libs/libkoreader-lfs")
|
2018-10-14 06:49:00 +00:00
|
|
|
local ffiUtil = require("ffi/util")
|
|
|
|
local T = ffiUtil.template
|
2014-09-10 04:21:07 +00:00
|
|
|
local _ = require("gettext")
|
2019-08-24 21:06:06 +00:00
|
|
|
local N_ = _.ngettext
|
2017-04-29 08:38:09 +00:00
|
|
|
local Screen = Device.screen
|
2018-10-14 06:49:00 +00:00
|
|
|
local util = require("util")
|
|
|
|
local getFileNameSuffix = util.getFileNameSuffix
|
|
|
|
local getFriendlySize = util.getFriendlySize
|
2017-04-29 08:38:09 +00:00
|
|
|
|
2013-10-18 20:38:07 +00:00
|
|
|
local FileChooser = Menu:extend{
|
2017-04-29 08:38:09 +00:00
|
|
|
cface = Font:getFace("smallinfofont"),
|
2014-03-13 13:52:43 +00:00
|
|
|
no_title = true,
|
|
|
|
path = lfs.currentdir(),
|
2018-08-01 15:02:34 +00:00
|
|
|
show_path = true,
|
2014-03-13 13:52:43 +00:00
|
|
|
parent = nil,
|
|
|
|
show_hidden = nil,
|
2021-03-06 21:44:18 +00:00
|
|
|
-- NOTE: Input is *always* a relative entry name
|
|
|
|
exclude_dirs = {
|
|
|
|
-- KOReader / Kindle
|
|
|
|
"%.sdr$",
|
|
|
|
-- Kobo
|
|
|
|
"^%.adobe%-digital%-editions$",
|
2021-08-19 15:01:36 +00:00
|
|
|
"^certificates$",
|
|
|
|
"^custom%-dict$",
|
|
|
|
"^dict$",
|
|
|
|
"^iink$",
|
|
|
|
"^kepub$",
|
|
|
|
"^markups$",
|
|
|
|
"^webstorage$",
|
2021-03-06 21:44:18 +00:00
|
|
|
"^%.kobo%-images$",
|
|
|
|
-- macOS
|
|
|
|
"^%.fseventsd$",
|
|
|
|
"^%.Trashes$",
|
|
|
|
"^%.Spotlight%-V100$",
|
|
|
|
-- *nix
|
|
|
|
"^%.Trash$",
|
|
|
|
"^%.Trash%-%d+$",
|
|
|
|
-- Windows
|
|
|
|
"^RECYCLED$",
|
|
|
|
"^RECYCLER$",
|
|
|
|
"^%$Recycle%.Bin$",
|
|
|
|
"^System Volume Information$",
|
|
|
|
-- Plato
|
|
|
|
"^%.thumbnail%-previews$",
|
|
|
|
"^%.reading%-states$",
|
|
|
|
},
|
|
|
|
exclude_files = {
|
2021-08-19 15:01:36 +00:00
|
|
|
-- Kobo
|
|
|
|
"^BookReader%.sqlite",
|
|
|
|
"^KoboReader%.sqlite",
|
|
|
|
"^device%.salt%.conf$",
|
2021-03-06 21:44:18 +00:00
|
|
|
-- macOS
|
|
|
|
"^%.DS_Store$",
|
|
|
|
-- *nix
|
|
|
|
"^%.directory$",
|
|
|
|
-- Windows
|
|
|
|
"^Thumbs%.db$",
|
|
|
|
-- Calibre
|
|
|
|
"^driveinfo%.calibre$",
|
|
|
|
"^metadata%.calibre$",
|
|
|
|
-- Plato
|
|
|
|
"^%.fat32%-epoch$",
|
|
|
|
"^%.metadata%.json$",
|
|
|
|
},
|
2014-10-30 14:41:49 +00:00
|
|
|
collate = "strcoll", -- or collate = "access",
|
|
|
|
reverse_collate = false,
|
2021-03-06 21:44:18 +00:00
|
|
|
path_items = {}, -- store last browsed location (item index) for each path
|
2018-02-09 21:33:15 +00:00
|
|
|
goto_letter = true,
|
2012-05-27 21:43:00 +00:00
|
|
|
}
|
|
|
|
|
2020-08-29 16:25:30 +00:00
|
|
|
-- Cache of content we knew of for directories that are not readable
|
|
|
|
-- (i.e. /storage/emulated/ on Android that we can meet when coming
|
|
|
|
-- from readable /storage/emulated/0/ - so we know it contains "0/")
|
|
|
|
local unreadable_dir_content = {}
|
|
|
|
|
2021-07-18 18:21:39 +00:00
|
|
|
function FileChooser:show_dir(dirname)
|
|
|
|
for _, pattern in ipairs(self.exclude_dirs) do
|
|
|
|
if dirname:match(pattern) then return false end
|
2014-09-10 04:21:07 +00:00
|
|
|
end
|
2021-07-18 18:21:39 +00:00
|
|
|
return true
|
|
|
|
end
|
|
|
|
|
|
|
|
function FileChooser:show_file(filename)
|
|
|
|
for _, pattern in ipairs(self.exclude_files) do
|
|
|
|
if filename:match(pattern) then return false end
|
2021-03-06 21:44:18 +00:00
|
|
|
end
|
2021-07-18 18:21:39 +00:00
|
|
|
return true
|
|
|
|
end
|
|
|
|
|
|
|
|
function FileChooser:init()
|
|
|
|
self.width = Screen:getWidth()
|
2020-02-05 18:32:07 +00:00
|
|
|
self.list = function(path, dirs, files, count_only)
|
2016-04-14 21:13:53 +00:00
|
|
|
-- lfs.dir directory without permission will give error
|
|
|
|
local ok, iter, dir_obj = pcall(lfs.dir, path)
|
|
|
|
if ok then
|
2020-08-29 16:25:30 +00:00
|
|
|
unreadable_dir_content[path] = nil
|
2016-04-14 21:13:53 +00:00
|
|
|
for f in iter, dir_obj do
|
2020-02-05 18:32:07 +00:00
|
|
|
if count_only then
|
2021-03-06 21:44:18 +00:00
|
|
|
if ((not self.show_hidden and not util.stringStartsWith(f, "."))
|
|
|
|
or (self.show_hidden and f ~= "." and f ~= ".." and not util.stringStartsWith(f, "._")))
|
2021-07-18 18:21:39 +00:00
|
|
|
and self:show_dir(f)
|
|
|
|
and self:show_file(f)
|
2020-02-11 14:13:20 +00:00
|
|
|
then
|
2020-02-05 18:32:07 +00:00
|
|
|
table.insert(dirs, true)
|
|
|
|
end
|
2021-03-06 21:44:18 +00:00
|
|
|
elseif self.show_hidden or not util.stringStartsWith(f, ".") then
|
2016-04-14 21:13:53 +00:00
|
|
|
local filename = path.."/"..f
|
|
|
|
local attributes = lfs.attributes(filename)
|
|
|
|
if attributes ~= nil then
|
2020-02-05 02:14:21 +00:00
|
|
|
if attributes.mode == "directory" and f ~= "." and f ~= ".." then
|
2021-07-18 18:21:39 +00:00
|
|
|
if self:show_dir(f) then
|
2017-02-12 02:55:31 +00:00
|
|
|
table.insert(dirs, {name = f,
|
|
|
|
suffix = getFileNameSuffix(f),
|
|
|
|
fullpath = filename,
|
|
|
|
attr = attributes})
|
2016-04-14 21:13:53 +00:00
|
|
|
end
|
2020-02-05 02:14:21 +00:00
|
|
|
-- Always ignore macOS resource forks.
|
|
|
|
elseif attributes.mode == "file" and not util.stringStartsWith(f, "._") then
|
2021-07-18 18:21:39 +00:00
|
|
|
if self:show_file(f) then
|
2021-03-06 21:44:18 +00:00
|
|
|
if self.file_filter == nil or self.file_filter(filename) or self.show_unsupported then
|
|
|
|
local percent_finished = 0
|
|
|
|
if self.collate == "percent_unopened_first" or self.collate == "percent_unopened_last" then
|
|
|
|
if DocSettings:hasSidecarFile(filename) then
|
|
|
|
local docinfo = DocSettings:open(filename)
|
|
|
|
percent_finished = docinfo.data.percent_finished
|
|
|
|
if percent_finished == nil then
|
|
|
|
percent_finished = 0
|
|
|
|
end
|
2018-01-19 23:01:09 +00:00
|
|
|
end
|
2018-01-17 19:10:25 +00:00
|
|
|
end
|
2021-03-06 21:44:18 +00:00
|
|
|
table.insert(files, {name = f,
|
|
|
|
suffix = getFileNameSuffix(f),
|
|
|
|
fullpath = filename,
|
|
|
|
attr = attributes,
|
|
|
|
percent_finished = percent_finished })
|
2018-01-17 19:10:25 +00:00
|
|
|
end
|
2016-04-14 21:13:53 +00:00
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
2020-08-29 16:25:30 +00:00
|
|
|
else -- error, probably "permission denied"
|
|
|
|
if unreadable_dir_content[path] then
|
|
|
|
-- Add this dummy item that will be replaced with a message
|
|
|
|
-- by genItemTableFromPath()
|
|
|
|
table.insert(dirs, {
|
|
|
|
name = "./.",
|
|
|
|
fullpath = path,
|
2020-08-30 03:27:17 +00:00
|
|
|
attr = lfs.attributes(path),
|
2020-08-29 16:25:30 +00:00
|
|
|
})
|
|
|
|
-- If we knew about some content (if we had come up from them
|
|
|
|
-- to this directory), have them shown
|
|
|
|
for k, v in pairs(unreadable_dir_content[path]) do
|
|
|
|
if v.attr and v.attr.mode == "directory" then
|
|
|
|
table.insert(dirs, v)
|
|
|
|
else
|
|
|
|
table.insert(files, v)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
2016-04-14 21:13:53 +00:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2014-03-13 13:52:43 +00:00
|
|
|
self.item_table = self:genItemTableFromPath(self.path)
|
|
|
|
Menu.init(self) -- call parent's init()
|
2012-05-27 21:43:00 +00:00
|
|
|
end
|
|
|
|
|
2021-07-18 18:21:39 +00:00
|
|
|
function FileChooser:getSortingFunction(collate, reverse_collate)
|
2017-02-12 02:55:31 +00:00
|
|
|
local sorting
|
2021-07-18 18:21:39 +00:00
|
|
|
if collate == "strcoll" then
|
2017-02-12 02:55:31 +00:00
|
|
|
sorting = function(a, b)
|
2020-10-05 14:34:46 +00:00
|
|
|
return ffiUtil.strcoll(a.name, b.name)
|
2017-02-12 02:55:31 +00:00
|
|
|
end
|
2021-07-18 18:21:39 +00:00
|
|
|
elseif collate == "access" then
|
2017-02-12 02:55:31 +00:00
|
|
|
sorting = function(a, b)
|
|
|
|
return a.attr.access > b.attr.access
|
2014-11-16 18:10:37 +00:00
|
|
|
end
|
2021-07-18 18:21:39 +00:00
|
|
|
elseif collate == "modification" then
|
2014-10-30 14:41:49 +00:00
|
|
|
sorting = function(a, b)
|
2017-02-12 02:55:31 +00:00
|
|
|
return a.attr.modification > b.attr.modification
|
|
|
|
end
|
2021-07-18 18:21:39 +00:00
|
|
|
elseif collate == "change" then
|
2017-02-12 02:55:31 +00:00
|
|
|
sorting = function(a, b)
|
|
|
|
if DocSettings:hasSidecarFile(a.fullpath) and not DocSettings:hasSidecarFile(b.fullpath) then
|
|
|
|
return false
|
|
|
|
end
|
|
|
|
if not DocSettings:hasSidecarFile(a.fullpath) and DocSettings:hasSidecarFile(b.fullpath) then
|
|
|
|
return true
|
|
|
|
end
|
|
|
|
return a.attr.change > b.attr.change
|
|
|
|
end
|
2021-07-18 18:21:39 +00:00
|
|
|
elseif collate == "size" then
|
2017-02-12 02:55:31 +00:00
|
|
|
sorting = function(a, b)
|
|
|
|
return a.attr.size < b.attr.size
|
|
|
|
end
|
2021-07-18 18:21:39 +00:00
|
|
|
elseif collate == "type" then
|
2017-02-12 02:55:31 +00:00
|
|
|
sorting = function(a, b)
|
|
|
|
if a.suffix == nil and b.suffix == nil then
|
2020-10-05 14:34:46 +00:00
|
|
|
return ffiUtil.strcoll(a.name, b.name)
|
2014-10-30 14:41:49 +00:00
|
|
|
else
|
2020-10-05 14:34:46 +00:00
|
|
|
return ffiUtil.strcoll(a.suffix, b.suffix)
|
2014-10-30 14:41:49 +00:00
|
|
|
end
|
|
|
|
end
|
2021-07-18 18:21:39 +00:00
|
|
|
elseif collate == "percent_unopened_first" or collate == "percent_unopened_last" then
|
2018-01-17 19:10:25 +00:00
|
|
|
sorting = function(a, b)
|
|
|
|
if DocSettings:hasSidecarFile(a.fullpath) and not DocSettings:hasSidecarFile(b.fullpath) then
|
2021-07-18 18:21:39 +00:00
|
|
|
if collate == "percent_unopened_first" then
|
2018-01-17 19:10:25 +00:00
|
|
|
return false
|
|
|
|
else
|
|
|
|
return true
|
|
|
|
end
|
|
|
|
end
|
|
|
|
if not DocSettings:hasSidecarFile(a.fullpath) and DocSettings:hasSidecarFile(b.fullpath) then
|
2021-07-18 18:21:39 +00:00
|
|
|
if collate == "percent_unopened_first" then
|
2018-01-17 19:10:25 +00:00
|
|
|
return true
|
|
|
|
else
|
|
|
|
return false
|
|
|
|
end
|
|
|
|
end
|
|
|
|
if not DocSettings:hasSidecarFile(a.fullpath) and not DocSettings:hasSidecarFile(b.fullpath) then
|
|
|
|
return a.name < b.name
|
|
|
|
end
|
|
|
|
|
|
|
|
if a.attr.mode == "directory" then return a.name < b.name end
|
|
|
|
if b.attr.mode == "directory" then return a.name < b.name end
|
|
|
|
|
|
|
|
return a.percent_finished < b.percent_finished
|
|
|
|
end
|
2021-07-18 18:21:39 +00:00
|
|
|
elseif collate == "natural" then
|
2020-07-18 11:04:39 +00:00
|
|
|
-- adapted from: http://notebook.kulchenko.com/algorithms/alphanumeric-natural-sorting-for-humans-in-lua
|
|
|
|
local function addLeadingZeroes(d)
|
|
|
|
local dec, n = string.match(d, "(%.?)0*(.+)")
|
|
|
|
return #dec > 0 and ("%.12f"):format(d) or ("%s%03d%s"):format(dec, #n, n)
|
|
|
|
end
|
|
|
|
sorting = function(a, b)
|
|
|
|
return tostring(a.name):gsub("%.?%d+", addLeadingZeroes)..("%3d"):format(#b.name)
|
|
|
|
< tostring(b.name):gsub("%.?%d+",addLeadingZeroes)..("%3d"):format(#a.name)
|
|
|
|
end
|
2017-02-12 02:55:31 +00:00
|
|
|
else
|
|
|
|
sorting = function(a, b)
|
|
|
|
return a.name < b.name
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2021-07-18 18:21:39 +00:00
|
|
|
if reverse_collate then
|
2017-02-12 02:55:31 +00:00
|
|
|
local sorting_unreversed = sorting
|
|
|
|
sorting = function(a, b) return sorting_unreversed(b, a) end
|
2014-10-30 14:41:49 +00:00
|
|
|
end
|
|
|
|
|
2021-07-18 18:21:39 +00:00
|
|
|
return sorting
|
|
|
|
end
|
|
|
|
|
|
|
|
function FileChooser:genItemTableFromPath(path)
|
|
|
|
local dirs = {}
|
|
|
|
local files = {}
|
|
|
|
local up_folder_arrow = BD.mirroredUILayout() and BD.ltr("../ ⬆") or "⬆ ../"
|
|
|
|
|
|
|
|
self.list(path, dirs, files)
|
|
|
|
|
|
|
|
local sorting = self:getSortingFunction(self.collate, self.reverse_collate)
|
|
|
|
|
2018-08-10 20:26:07 +00:00
|
|
|
if self.collate ~= "strcoll_mixed" then
|
|
|
|
table.sort(dirs, sorting)
|
|
|
|
table.sort(files, sorting)
|
|
|
|
end
|
2021-07-23 13:47:02 +00:00
|
|
|
if path ~= "/" and not (G_reader_settings:isTrue("lock_home_folder") and
|
|
|
|
path == G_reader_settings:readSetting("home_dir")) then
|
|
|
|
table.insert(dirs, 1, {name = ".."})
|
|
|
|
end
|
2018-08-06 18:59:01 +00:00
|
|
|
if self.show_current_dir_for_hold then table.insert(dirs, 1, {name = "."}) end
|
2012-05-27 21:43:00 +00:00
|
|
|
|
2014-03-13 13:52:43 +00:00
|
|
|
local item_table = {}
|
2014-09-10 04:21:07 +00:00
|
|
|
for i, dir in ipairs(dirs) do
|
2016-04-19 07:59:02 +00:00
|
|
|
-- count sume of directories and files inside dir
|
|
|
|
local sub_dirs = {}
|
|
|
|
local dir_files = {}
|
2016-02-16 06:34:28 +00:00
|
|
|
local subdir_path = self.path.."/"..dir.name
|
2020-02-05 18:32:07 +00:00
|
|
|
self.list(subdir_path, sub_dirs, dir_files, true)
|
2016-12-25 07:43:58 +00:00
|
|
|
local num_items = #sub_dirs + #dir_files
|
2019-08-24 21:06:06 +00:00
|
|
|
local istr = ffiUtil.template(N_("1 item", "%1 items", num_items), num_items)
|
2018-08-06 18:59:01 +00:00
|
|
|
local text
|
2019-12-06 21:55:39 +00:00
|
|
|
local bidi_wrap_func
|
2018-08-06 18:59:01 +00:00
|
|
|
if dir.name == ".." then
|
2018-08-10 20:26:07 +00:00
|
|
|
text = up_folder_arrow
|
2018-08-06 18:59:01 +00:00
|
|
|
elseif dir.name == "." then -- possible with show_current_dir_for_hold
|
2021-08-24 20:19:07 +00:00
|
|
|
text = _("Long-press to choose current folder")
|
2020-08-29 16:25:30 +00:00
|
|
|
elseif dir.name == "./." then -- added as content of an unreadable directory
|
2021-02-28 09:18:00 +00:00
|
|
|
text = _("Current folder not readable. Some content may not be shown.")
|
2018-08-06 18:59:01 +00:00
|
|
|
else
|
|
|
|
text = dir.name.."/"
|
2019-12-06 21:55:39 +00:00
|
|
|
bidi_wrap_func = BD.directory
|
2018-08-06 18:59:01 +00:00
|
|
|
end
|
2014-09-25 14:21:25 +00:00
|
|
|
table.insert(item_table, {
|
2018-08-06 18:59:01 +00:00
|
|
|
text = text,
|
2019-12-06 21:55:39 +00:00
|
|
|
bidi_wrap_func = bidi_wrap_func,
|
2014-09-25 14:21:25 +00:00
|
|
|
mandatory = istr,
|
2017-10-13 16:43:02 +00:00
|
|
|
path = subdir_path,
|
|
|
|
is_go_up = dir.name == ".."
|
2014-09-25 14:21:25 +00:00
|
|
|
})
|
2014-03-13 13:52:43 +00:00
|
|
|
end
|
2016-12-25 07:43:09 +00:00
|
|
|
|
2016-12-27 06:52:53 +00:00
|
|
|
-- set to false to show all files in regular font
|
|
|
|
-- set to "opened" to show opened files in bold
|
|
|
|
-- otherwise, show new files in bold
|
|
|
|
local show_file_in_bold = G_reader_settings:readSetting("show_file_in_bold")
|
2016-12-25 07:43:09 +00:00
|
|
|
|
2020-02-08 10:45:26 +00:00
|
|
|
for i = 1, #files do
|
|
|
|
local file = files[i]
|
2014-10-30 14:41:49 +00:00
|
|
|
local full_path = self.path.."/"..file.name
|
2014-09-25 14:21:25 +00:00
|
|
|
local file_size = lfs.attributes(full_path, "size") or 0
|
2017-10-20 15:48:32 +00:00
|
|
|
local sstr = getFriendlySize(file_size)
|
2016-12-27 06:52:53 +00:00
|
|
|
local file_item = {
|
2014-10-30 14:41:49 +00:00
|
|
|
text = file.name,
|
2019-12-06 21:55:39 +00:00
|
|
|
bidi_wrap_func = BD.filename,
|
2014-09-25 14:21:25 +00:00
|
|
|
mandatory = sstr,
|
|
|
|
path = full_path
|
2016-12-27 06:52:53 +00:00
|
|
|
}
|
|
|
|
if show_file_in_bold ~= false then
|
2017-02-08 18:37:36 +00:00
|
|
|
file_item.bold = DocSettings:hasSidecarFile(full_path)
|
2016-12-27 06:52:53 +00:00
|
|
|
if show_file_in_bold ~= "opened" then
|
|
|
|
file_item.bold = not file_item.bold
|
|
|
|
end
|
|
|
|
end
|
|
|
|
table.insert(item_table, file_item)
|
2014-09-25 14:21:25 +00:00
|
|
|
end
|
2018-08-10 20:26:07 +00:00
|
|
|
|
|
|
|
if self.collate == "strcoll_mixed" then
|
|
|
|
sorting = function(a, b)
|
|
|
|
if b.text == up_folder_arrow then return false end
|
2020-10-05 14:34:46 +00:00
|
|
|
return ffiUtil.strcoll(a.text, b.text)
|
2018-08-10 20:26:07 +00:00
|
|
|
end
|
|
|
|
if self.reverse_collate then
|
|
|
|
local sorting_unreversed = sorting
|
|
|
|
sorting = function(a, b) return sorting_unreversed(b, a) end
|
|
|
|
end
|
|
|
|
table.sort(item_table, sorting)
|
|
|
|
end
|
2016-12-25 07:43:58 +00:00
|
|
|
-- lfs.dir iterated node string may be encoded with some weird codepage on
|
|
|
|
-- Windows we need to encode them to utf-8
|
2014-09-25 14:21:25 +00:00
|
|
|
if ffi.os == "Windows" then
|
|
|
|
for k, v in pairs(item_table) do
|
|
|
|
if v.text then
|
2018-10-14 06:49:00 +00:00
|
|
|
v.text = ffiUtil.multiByteToUTF8(v.text) or ""
|
2014-09-25 14:21:25 +00:00
|
|
|
end
|
|
|
|
end
|
2014-03-13 13:52:43 +00:00
|
|
|
end
|
2013-08-22 04:01:00 +00:00
|
|
|
|
2014-03-13 13:52:43 +00:00
|
|
|
return item_table
|
2013-08-14 09:19:01 +00:00
|
|
|
end
|
2012-05-27 21:43:00 +00:00
|
|
|
|
2014-11-23 10:06:20 +00:00
|
|
|
function FileChooser:updateItems(select_number)
|
|
|
|
Menu.updateItems(self, select_number) -- call parent's updateItems()
|
2015-02-01 17:36:49 +00:00
|
|
|
self.path_items[self.path] = (self.page - 1) * self.perpage + (select_number or 1)
|
2014-11-23 10:06:20 +00:00
|
|
|
end
|
|
|
|
|
2014-09-10 04:21:07 +00:00
|
|
|
function FileChooser:refreshPath()
|
2017-10-21 17:53:56 +00:00
|
|
|
local itemmatch = nil
|
2018-03-21 19:10:35 +00:00
|
|
|
|
2018-10-14 06:49:00 +00:00
|
|
|
local _, folder_name = util.splitFilePathName(self.path)
|
2018-03-21 19:10:35 +00:00
|
|
|
Screen:setWindowTitle(folder_name)
|
|
|
|
|
2017-10-21 17:53:56 +00:00
|
|
|
if self.focused_path then
|
|
|
|
itemmatch = {path = self.focused_path}
|
|
|
|
-- We use focused_path only once, but remember it
|
|
|
|
-- for CoverBrower to re-apply it on startup if needed
|
|
|
|
self.prev_focused_path = self.focused_path
|
|
|
|
self.focused_path = nil
|
|
|
|
end
|
2018-03-21 19:10:35 +00:00
|
|
|
|
2017-10-21 17:53:56 +00:00
|
|
|
self:switchItemTable(nil, self:genItemTableFromPath(self.path), self.path_items[self.path], itemmatch)
|
2014-09-10 04:21:07 +00:00
|
|
|
end
|
|
|
|
|
2017-10-13 16:43:02 +00:00
|
|
|
function FileChooser:changeToPath(path, focused_path)
|
2018-10-14 06:49:00 +00:00
|
|
|
path = ffiUtil.realpath(path)
|
2014-03-13 13:52:43 +00:00
|
|
|
self.path = path
|
2018-03-21 19:10:35 +00:00
|
|
|
|
2017-10-13 16:43:02 +00:00
|
|
|
if focused_path then
|
2017-10-21 17:53:56 +00:00
|
|
|
self.focused_path = focused_path
|
2020-08-29 16:25:30 +00:00
|
|
|
-- We know focused_path is a child of path. In case path is
|
|
|
|
-- not a readable directory, we can have focused_path shown,
|
|
|
|
-- to allow the user to go back in it
|
|
|
|
if not unreadable_dir_content[path] then
|
|
|
|
unreadable_dir_content[path] = {}
|
|
|
|
end
|
|
|
|
if not unreadable_dir_content[path][focused_path] then
|
|
|
|
unreadable_dir_content[path][focused_path] = {
|
|
|
|
name = focused_path:sub(#path+2),
|
|
|
|
fullpath = focused_path,
|
2020-08-30 03:27:17 +00:00
|
|
|
attr = lfs.attributes(focused_path),
|
2020-08-29 16:25:30 +00:00
|
|
|
}
|
|
|
|
end
|
2017-10-13 16:43:02 +00:00
|
|
|
end
|
2018-03-21 19:10:35 +00:00
|
|
|
|
2017-10-21 17:53:56 +00:00
|
|
|
self:refreshPath()
|
2016-07-05 00:38:04 +00:00
|
|
|
self:onPathChanged(path)
|
2014-01-22 18:23:23 +00:00
|
|
|
end
|
|
|
|
|
2020-07-12 18:47:49 +00:00
|
|
|
function FileChooser:onFolderUp()
|
2021-07-23 13:47:02 +00:00
|
|
|
if not (G_reader_settings:isTrue("lock_home_folder") and
|
|
|
|
self.path == G_reader_settings:readSetting("home_dir")) then
|
|
|
|
self:changeToPath(string.format("%s/..", self.path), self.path)
|
|
|
|
end
|
2020-07-12 18:47:49 +00:00
|
|
|
end
|
|
|
|
|
2017-10-13 16:43:02 +00:00
|
|
|
function FileChooser:changePageToPath(path)
|
|
|
|
if not path then return end
|
|
|
|
for num, item in ipairs(self.item_table) do
|
|
|
|
if item.path == path then
|
|
|
|
local page = math.floor((num-1) / self.perpage) + 1
|
|
|
|
if page ~= self.page then
|
|
|
|
self:onGotoPage(page)
|
|
|
|
end
|
|
|
|
break
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2013-08-25 04:00:06 +00:00
|
|
|
function FileChooser:toggleHiddenFiles()
|
2014-03-13 13:52:43 +00:00
|
|
|
self.show_hidden = not self.show_hidden
|
2014-09-10 04:21:07 +00:00
|
|
|
self:refreshPath()
|
2013-08-25 04:00:06 +00:00
|
|
|
end
|
|
|
|
|
2019-07-20 15:36:41 +00:00
|
|
|
function FileChooser:toggleUnsupportedFiles()
|
|
|
|
self.show_unsupported = not self.show_unsupported
|
|
|
|
self:refreshPath()
|
|
|
|
end
|
|
|
|
|
2014-10-30 14:41:49 +00:00
|
|
|
function FileChooser:setCollate(collate)
|
|
|
|
self.collate = collate
|
|
|
|
self:refreshPath()
|
|
|
|
end
|
|
|
|
|
|
|
|
function FileChooser:toggleReverseCollate()
|
|
|
|
self.reverse_collate = not self.reverse_collate
|
|
|
|
self:refreshPath()
|
|
|
|
end
|
|
|
|
|
2012-06-10 15:36:19 +00:00
|
|
|
function FileChooser:onMenuSelect(item)
|
2014-06-04 11:13:41 +00:00
|
|
|
-- parent directory of dir without permission get nil mode
|
|
|
|
-- we need to change to parent path in this case
|
|
|
|
if lfs.attributes(item.path, "mode") == "file" then
|
2014-03-13 13:52:43 +00:00
|
|
|
self:onFileSelect(item.path)
|
2014-06-04 11:13:41 +00:00
|
|
|
else
|
2017-10-13 16:43:02 +00:00
|
|
|
self:changeToPath(item.path, item.is_go_up and self.path)
|
2014-03-13 13:52:43 +00:00
|
|
|
end
|
|
|
|
return true
|
2012-05-27 22:14:08 +00:00
|
|
|
end
|
2012-06-10 15:36:19 +00:00
|
|
|
|
2014-01-18 15:15:44 +00:00
|
|
|
function FileChooser:onMenuHold(item)
|
2014-03-13 13:52:43 +00:00
|
|
|
self:onFileHold(item.path)
|
|
|
|
return true
|
2014-01-18 15:15:44 +00:00
|
|
|
end
|
|
|
|
|
2012-06-10 15:36:19 +00:00
|
|
|
function FileChooser:onFileSelect(file)
|
2014-03-13 13:52:43 +00:00
|
|
|
UIManager:close(self)
|
|
|
|
return true
|
2012-06-10 15:36:19 +00:00
|
|
|
end
|
2013-10-18 20:38:07 +00:00
|
|
|
|
2014-01-18 15:15:44 +00:00
|
|
|
function FileChooser:onFileHold(file)
|
2014-03-13 13:52:43 +00:00
|
|
|
return true
|
2014-01-18 15:15:44 +00:00
|
|
|
end
|
|
|
|
|
2016-07-05 00:38:04 +00:00
|
|
|
function FileChooser:onPathChanged(path)
|
|
|
|
return true
|
|
|
|
end
|
|
|
|
|
2018-05-13 11:07:23 +00:00
|
|
|
function FileChooser:getNextFile(curr_file)
|
|
|
|
local next_file
|
|
|
|
for index, data in pairs(self.item_table) do
|
|
|
|
if data.path == curr_file then
|
|
|
|
if index+1 <= #self.item_table then
|
|
|
|
next_file = self.item_table[index+1].path
|
|
|
|
if lfs.attributes(next_file, "mode") == "file" and DocumentRegistry:hasProvider(next_file) then
|
|
|
|
break
|
|
|
|
else
|
|
|
|
next_file = nil
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
return next_file
|
|
|
|
end
|
|
|
|
|
2021-05-10 22:49:35 +00:00
|
|
|
function FileChooser:showSetProviderButtons(file, filemanager_instance, one_time_providers)
|
|
|
|
local ReaderUI = require("apps/reader/readerui")
|
|
|
|
|
2018-10-14 06:49:00 +00:00
|
|
|
local __, filename_pure = util.splitFilePathName(file)
|
|
|
|
local filename_suffix = util.getFileNameSuffix(file)
|
|
|
|
|
|
|
|
local buttons = {}
|
|
|
|
local radio_buttons = {}
|
2019-10-23 21:15:30 +00:00
|
|
|
local filetype_provider = G_reader_settings:readSetting("provider") or {}
|
2018-10-14 06:49:00 +00:00
|
|
|
local providers = DocumentRegistry:getProviders(file)
|
2019-10-23 21:15:30 +00:00
|
|
|
if providers ~= nil then
|
|
|
|
for ___, provider in ipairs(providers) do
|
|
|
|
-- we have no need for extension, mimetype, weights, etc. here
|
|
|
|
provider = provider.provider
|
|
|
|
table.insert(radio_buttons, {
|
|
|
|
{
|
|
|
|
text = provider.provider_name,
|
|
|
|
checked = DocumentRegistry:getProvider(file) == provider,
|
|
|
|
provider = provider,
|
|
|
|
},
|
|
|
|
})
|
|
|
|
end
|
|
|
|
else
|
|
|
|
local provider = DocumentRegistry:getProvider(file)
|
2018-10-14 06:49:00 +00:00
|
|
|
table.insert(radio_buttons, {
|
|
|
|
{
|
2019-10-23 21:15:30 +00:00
|
|
|
-- @translators %1 is the provider name, such as Cool Reader Engine or MuPDF.
|
|
|
|
text = T(_("%1 ~Unsupported"), provider.provider_name),
|
|
|
|
checked = true,
|
2018-10-14 06:49:00 +00:00
|
|
|
provider = provider,
|
|
|
|
},
|
|
|
|
})
|
|
|
|
end
|
2020-08-29 16:25:38 +00:00
|
|
|
if one_time_providers and #one_time_providers > 0 then
|
|
|
|
for ___, provider in ipairs(one_time_providers) do
|
|
|
|
provider.one_time_provider = true
|
|
|
|
table.insert(radio_buttons, {
|
|
|
|
{
|
|
|
|
text = provider.provider_name,
|
|
|
|
provider = provider,
|
|
|
|
},
|
|
|
|
})
|
|
|
|
end
|
|
|
|
end
|
2018-10-14 06:49:00 +00:00
|
|
|
|
|
|
|
table.insert(buttons, {
|
|
|
|
{
|
|
|
|
text = _("Cancel"),
|
|
|
|
callback = function()
|
|
|
|
UIManager:close(self.set_provider_dialog)
|
|
|
|
end,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
text = _("Open"),
|
|
|
|
is_enter_default = true,
|
|
|
|
callback = function()
|
|
|
|
local provider = self.set_provider_dialog.radio_button_table.checked_button.provider
|
2020-08-29 16:25:38 +00:00
|
|
|
if provider.one_time_provider then
|
|
|
|
UIManager:close(self.set_provider_dialog)
|
|
|
|
provider.callback()
|
|
|
|
return
|
|
|
|
end
|
2018-10-14 06:49:00 +00:00
|
|
|
|
|
|
|
-- always for this file
|
|
|
|
if self.set_provider_dialog._check_file_button.checked then
|
|
|
|
UIManager:show(ConfirmBox:new{
|
|
|
|
text = T(_("Always open '%2' with %1?"),
|
2019-12-06 21:55:39 +00:00
|
|
|
provider.provider_name, BD.filename(filename_pure)),
|
2018-10-14 06:49:00 +00:00
|
|
|
ok_text = _("Always"),
|
|
|
|
ok_callback = function()
|
|
|
|
DocumentRegistry:setProvider(file, provider, false)
|
|
|
|
|
2021-05-10 22:49:35 +00:00
|
|
|
ReaderUI:showReader(file, provider)
|
2018-10-14 06:49:00 +00:00
|
|
|
UIManager:close(self.set_provider_dialog)
|
|
|
|
end,
|
|
|
|
})
|
|
|
|
-- always for all files of this file type
|
|
|
|
elseif self.set_provider_dialog._check_global_button.checked then
|
|
|
|
UIManager:show(ConfirmBox:new{
|
|
|
|
text = T(_("Always open %2 files with %1?"),
|
|
|
|
provider.provider_name, filename_suffix),
|
|
|
|
ok_text = _("Always"),
|
|
|
|
ok_callback = function()
|
|
|
|
DocumentRegistry:setProvider(file, provider, true)
|
|
|
|
|
2021-05-10 22:49:35 +00:00
|
|
|
ReaderUI:showReader(file, provider)
|
2018-10-14 06:49:00 +00:00
|
|
|
UIManager:close(self.set_provider_dialog)
|
|
|
|
end,
|
|
|
|
})
|
|
|
|
else
|
|
|
|
-- just once
|
2021-05-10 22:49:35 +00:00
|
|
|
ReaderUI:showReader(file, provider)
|
2018-10-14 06:49:00 +00:00
|
|
|
UIManager:close(self.set_provider_dialog)
|
|
|
|
end
|
|
|
|
end,
|
|
|
|
},
|
|
|
|
})
|
|
|
|
|
2019-10-23 21:15:30 +00:00
|
|
|
if filetype_provider[filename_suffix] ~= nil then
|
|
|
|
table.insert(buttons, {
|
|
|
|
{
|
|
|
|
text = _("Reset default"),
|
|
|
|
callback = function()
|
|
|
|
filetype_provider[filename_suffix] = nil
|
|
|
|
G_reader_settings:saveSetting("provider", filetype_provider)
|
|
|
|
UIManager:close(self.set_provider_dialog)
|
|
|
|
end,
|
|
|
|
},
|
|
|
|
})
|
|
|
|
end
|
|
|
|
|
2018-10-14 06:49:00 +00:00
|
|
|
self.set_provider_dialog = OpenWithDialog:new{
|
2019-12-06 21:55:39 +00:00
|
|
|
title = T(_("Open %1 with:"), BD.filename(filename_pure)),
|
2018-10-14 06:49:00 +00:00
|
|
|
radio_buttons = radio_buttons,
|
|
|
|
buttons = buttons,
|
|
|
|
}
|
|
|
|
UIManager:show(self.set_provider_dialog)
|
|
|
|
end
|
|
|
|
|
2013-10-18 20:38:07 +00:00
|
|
|
return FileChooser
|