Merge d51ee84d20 into 87c85bf94d

frontend/apps/filemanager/filemanager.lua

@@ -520,6 +520,17 @@ function FileManager:tapPlus()
         title = actions_enabled and T(N_("1 file selected", "%1 files selected", select_count), select_count)
             or _("No files selected")
         buttons = {
+            {
+                {
+                    text = _("Add to collections"),
+                    enabled = actions_enabled,
+                    callback = function()
+                        UIManager:close(self.file_dialog)
+                        self.collections:onShowCollList(self.selected_files)
+                        self:onToggleSelectMode()
+                    end,
+                },
+            },
             {
                 {
                     text = _("Show selected files list"),

frontend/apps/filemanager/filemanagercollection.lua

@@ -1,19 +1,26 @@
 local BD = require("ui/bidi")
 local ButtonDialog = require("ui/widget/buttondialog")
+local ConfirmBox = require("ui/widget/confirmbox")
 local Device = require("device")
 local DocSettings = require("docsettings")
-local DocumentRegistry = require("document/documentregistry")
 local FileManagerBookInfo = require("apps/filemanager/filemanagerbookinfo")
+local InfoMessage = require("ui/widget/infomessage")
+local InputDialog = require("ui/widget/inputdialog")
 local Menu = require("ui/widget/menu")
 local ReadCollection = require("readcollection")
+local SortWidget = require("ui/widget/sortwidget")
 local UIManager = require("ui/uimanager")
 local WidgetContainer = require("ui/widget/container/widgetcontainer")
 local Screen = require("device").screen
 local filemanagerutil = require("apps/filemanager/filemanagerutil")
 local _ = require("gettext")
+local T = require("ffi/util").template
+local util = require("util")
 
 local FileManagerCollection = WidgetContainer:extend{
-    title = _("Favorites"),
+    title = _("Collections"),
+    default_collection_title = _("Favorites"),
+    checkmark = "\u{2713}",
 }
 
 function FileManagerCollection:init()
@@ -22,20 +29,66 @@ end
 
 function FileManagerCollection:addToMainMenu(menu_items)
     menu_items.collections = {
-        text = self.title,
+        text = self.default_collection_title,
         callback = function()
             self:onShowColl()
         end,
     }
 end
 
-function FileManagerCollection:updateItemTable()
+-- collection
+
+function FileManagerCollection:getCollectionTitle(collection_name)
+    return collection_name == ReadCollection.default_collection_name
+        and self.default_collection_title -- favorites
+         or collection_name
+end
+
+function FileManagerCollection:onShowColl(collection_name)
+    collection_name = collection_name or ReadCollection.default_collection_name
+    self.coll_menu = Menu:new{
+        ui = self.ui,
+        covers_fullscreen = true, -- hint for UIManager:_repaint()
+        is_borderless = true,
+        is_popout = false,
+        -- item and book cover thumbnail dimensions in Mosaic and Detailed list display modes
+        -- must be equal in File manager, History and Collection windows to avoid image scaling
+        title_bar_fm_style = true,
+        title_bar_left_icon = "appbar.menu",
+        onLeftButtonTap = function() self:showCollDialog() end,
+        onMenuChoice = self.onMenuChoice,
+        onMenuHold = self.onMenuHold,
+        onSetRotationMode = self.MenuSetRotationModeHandler,
+        _manager = self,
+        collection_name = collection_name,
+    }
+    self.coll_menu.close_callback = function()
+        if self.files_updated then
+            if self.ui.file_chooser then
+                self.ui.file_chooser:refreshPath()
+            end
+            self.files_updated = nil
+        end
+        UIManager:close(self.coll_menu)
+        self.coll_menu = nil
+    end
+    self:updateItemTable()
+    UIManager:show(self.coll_menu)
+    return true
+end
+
+function FileManagerCollection:updateItemTable(show_last_item)
     local item_table = {}
     for _, item in pairs(ReadCollection.coll[self.coll_menu.collection_name]) do
         table.insert(item_table, item)
     end
-    table.sort(item_table, function(v1, v2) return v1.order < v2.order end)
-    self.coll_menu:switchItemTable(self.title, item_table, -1)
+    if #item_table > 1 then
+        table.sort(item_table, function(v1, v2) return v1.order < v2.order end)
+    end
+    local title = self:getCollectionTitle(self.coll_menu.collection_name)
+    title = T("%1 (%2)", title, #item_table)
+    local item_number = show_last_item and #item_table or -1
+    self.coll_menu:switchItemTable(title, item_table, item_number)
 end
 
 function FileManagerCollection:onMenuChoice(item)
@@ -92,7 +145,7 @@ function FileManagerCollection:onMenuHold(item)
     table.insert(buttons, {
         filemanagerutil.genResetSettingsButton(doc_settings_or_file, close_dialog_update_callback, is_currently_opened),
         {
-            text = _("Remove from favorites"),
+            text = _("Remove from collection"),
             callback = function()
                 UIManager:close(self.collfile_dialog)
                 ReadCollection:removeItem(file, self.collection_name)
@@ -124,79 +177,37 @@ function FileManagerCollection:onMenuHold(item)
     return true
 end
 
-function FileManagerCollection:MenuSetRotationModeHandler(rotation)
-    if rotation ~= nil and rotation ~= Screen:getRotationMode() then
-        UIManager:close(self._manager.coll_menu)
-        if self._manager.ui.view and self._manager.ui.view.onSetRotationMode then
-            self._manager.ui.view:onSetRotationMode(rotation)
-        elseif self._manager.ui.onSetRotationMode then
-            self._manager.ui:onSetRotationMode(rotation)
-        else
-            Screen:setRotationMode(rotation)
-        end
-        self._manager:onShowColl()
-    end
-    return true
-end
-
-function FileManagerCollection:onShowColl(collection_name)
-    collection_name = collection_name or ReadCollection.default_collection_name
-    self.coll_menu = Menu:new{
-        ui = self.ui,
-        covers_fullscreen = true, -- hint for UIManager:_repaint()
-        is_borderless = true,
-        is_popout = false,
-        -- item and book cover thumbnail dimensions in Mosaic and Detailed list display modes
-        -- must be equal in File manager, History and Collection windows to avoid image scaling
-        title_bar_fm_style = true,
-        title_bar_left_icon = "appbar.menu",
-        onLeftButtonTap = function() self:showCollDialog() end,
-        onMenuChoice = self.onMenuChoice,
-        onMenuHold = self.onMenuHold,
-        onSetRotationMode = self.MenuSetRotationModeHandler,
-        _manager = self,
-        collection_name = collection_name,
-    }
-    self.coll_menu.close_callback = function()
-        if self.files_updated then
-            if self.ui.file_chooser then
-                self.ui.file_chooser:refreshPath()
-            end
-            self.files_updated = nil
-        end
-        UIManager:close(self.coll_menu)
-        self.coll_menu = nil
-    end
-    self:updateItemTable()
-    UIManager:show(self.coll_menu)
-    return true
-end
-
 function FileManagerCollection:showCollDialog()
     local coll_dialog
     local buttons = {
         {{
-            text = _("Sort favorites"),
+            text = _("Collections"),
+            callback = function()
+                UIManager:close(coll_dialog)
+                self.coll_menu.close_callback()
+                self:onShowCollList()
+            end,
+        }},
+        {}, -- separator
+        {{
+            text = _("Sort collection"),
             callback = function()
                 UIManager:close(coll_dialog)
                 self:sortCollection()
             end,
         }},
         {{
-            text = _("Add a book to favorites"),
+            text = _("Add a book to collection"),
             callback = function()
                 UIManager:close(coll_dialog)
                 local PathChooser = require("ui/widget/pathchooser")
                 local path_chooser = PathChooser:new{
                     path = G_reader_settings:readSetting("home_dir"),
                     select_directory = false,
-                    file_filter = function(file)
-                        return DocumentRegistry:hasProvider(file)
-                    end,
                     onConfirm = function(file)
-                        if not ReadCollection:hasFile(file) then
+                        if not ReadCollection:isFileInCollection(file, self.coll_menu.collection_name) then
                             ReadCollection:addItem(file, self.coll_menu.collection_name)
-                            self:updateItemTable()
+                            self:updateItemTable(true) -- show added item
                         end
                     end,
                 }
@@ -205,19 +216,20 @@ function FileManagerCollection:showCollDialog()
         }},
     }
     if self.ui.document then
-        local has_file = ReadCollection:hasFile(self.ui.document.file)
+        local file = self.ui.document.file
+        local is_in_collection = ReadCollection:isFileInCollection(file, self.coll_menu.collection_name)
         table.insert(buttons, {{
             text_func = function()
-                return has_file and _("Remove current book from favorites") or _("Add current book to favorites")
+                return is_in_collection and _("Remove current book from collection") or _("Add current book to collection")
             end,
             callback = function()
                 UIManager:close(coll_dialog)
-                if has_file then
-                    ReadCollection:removeItem(self.ui.document.file)
+                if is_in_collection then
+                    ReadCollection:removeItem(file, self.coll_menu.collection_name)
                 else
-                    ReadCollection:addItem(self.ui.document.file, self.coll_menu.collection_name)
+                    ReadCollection:addItem(file, self.coll_menu.collection_name)
                 end
-                self:updateItemTable()
+                self:updateItemTable(not is_in_collection)
             end,
         }})
     end
@@ -228,12 +240,10 @@ function FileManagerCollection:showCollDialog()
 end
 
 function FileManagerCollection:sortCollection()
-    local item_table = ReadCollection:getOrderedCollection(self.coll_menu.collection_name)
-    local SortWidget = require("ui/widget/sortwidget")
     local sort_widget
     sort_widget = SortWidget:new{
-        title = _("Sort favorites"),
-        item_table = item_table,
+        title = _("Sort collection"),
+        item_table = ReadCollection:getOrderedCollection(self.coll_menu.collection_name),
         callback = function()
             ReadCollection:updateCollectionOrder(self.coll_menu.collection_name, sort_widget.item_table)
             self:updateItemTable()
@@ -242,10 +252,269 @@ function FileManagerCollection:sortCollection()
     UIManager:show(sort_widget)
 end
 
+function FileManagerCollection:MenuSetRotationModeHandler(rotation)
+    if rotation ~= nil and rotation ~= Screen:getRotationMode() then
+        UIManager:close(self._manager.coll_menu)
+        if self._manager.ui.view and self._manager.ui.view.onSetRotationMode then
+            self._manager.ui.view:onSetRotationMode(rotation)
+        elseif self._manager.ui.onSetRotationMode then
+            self._manager.ui:onSetRotationMode(rotation)
+        else
+            Screen:setRotationMode(rotation)
+        end
+        self._manager:onShowColl()
+    end
+    return true
+end
+
 function FileManagerCollection:onBookMetadataChanged()
     if self.coll_menu then
         self.coll_menu:updateItems()
     end
 end
 
+-- collection list
+
+function FileManagerCollection:onShowCollList(file_or_files)
+    self.selected_colections = nil
+    if file_or_files then
+        -- mark collections containing the file; do not mark any collection if group of selected files passed
+        self.selected_colections = type(file_or_files) == "string" and ReadCollection:getCollectionsWithFile(file_or_files) or {}
+    end
+    self.coll_list = Menu:new{
+        subtitle = "",
+        covers_fullscreen = true,
+        is_borderless = true,
+        is_popout = false,
+        title_bar_fm_style = true,
+        title_bar_left_icon = file_or_files and "check" or "appbar.menu",
+        onLeftButtonTap = function() self:onLeftButtonTap(file_or_files) end,
+        onMenuChoice = self.onCollListChoice,
+        onMenuHold = self.onCollListHold,
+        onSetRotationMode = self.MenuSetRotationModeHandler,
+        _manager = self,
+    }
+    self.coll_list.close_callback = function(force_close)
+        if force_close or self.selected_colections == nil then
+            UIManager:close(self.coll_list)
+            self.coll_list = nil
+        end
+    end
+    self:updateCollListItemTable(true) -- init
+    UIManager:show(self.coll_list)
+    return true
+end
+
+function FileManagerCollection:updateCollListItemTable(do_init, item_number)
+    local item_table
+    if do_init then
+        item_table = {}
+        for name, coll in pairs(ReadCollection.coll) do
+            local mandatory
+            if self.selected_colections then
+                mandatory = self.selected_colections[name] and self.checkmark or "  "
+                self.coll_list.items_mandatory_font_size = self.coll_list.font_size
+            else
+                mandatory = util.tableSize(coll)
+            end
+            table.insert(item_table, {
+                text      = self:getCollectionTitle(name),
+                mandatory = mandatory,
+                name      = name,
+                order     = ReadCollection.coll_order[name],
+            })
+        end
+        if #item_table > 1 then
+            table.sort(item_table, function(v1, v2) return v1.order < v2.order end)
+        end
+    else
+        item_table = self.coll_list.item_table
+    end
+    local title = T(_("Collections (%1)"), #item_table)
+    local subtitle
+    if self.selected_colections then
+        local selected_nb = util.tableSize(self.selected_colections)
+        subtitle = self.selected_colections and T(_("Selected collections: %1"), selected_nb)
+        if do_init and selected_nb > 0 then -- show first collection containing the long-pressed book
+            for i, item in ipairs(item_table) do
+                if self.selected_colections[item.name] then
+                    item_number = i
+                    break
+                end
+            end
+        end
+    end
+    self.coll_list:switchItemTable(title, item_table, item_number or -1, nil, subtitle)
+end
+
+function FileManagerCollection:onCollListChoice(item)
+    if self._manager.selected_colections then
+        if item.mandatory == self._manager.checkmark then
+            self.item_table[item.idx].mandatory = "  "
+            self._manager.selected_colections[item.name] = nil
+        else
+            self.item_table[item.idx].mandatory = self._manager.checkmark
+            self._manager.selected_colections[item.name] = true
+        end
+        self._manager:updateCollListItemTable()
+    else
+        self._manager:onShowColl(item.name)
+    end
+end
+
+function FileManagerCollection:onCollListHold(item)
+    if item.name == ReadCollection.default_collection_name -- Favorites non-editable
+            or self._manager.selected_colections then -- select mode
+        return
+    end
+
+    local button_dialog
+    local buttons = {
+        {
+            {
+                text = _("Remove collection"),
+                callback = function()
+                    UIManager:close(button_dialog)
+                    self._manager:removeCollection(item)
+                end
+            },
+            {
+                text = _("Rename collection"),
+                callback = function()
+                    UIManager:close(button_dialog)
+                    self._manager:renameCollection(item)
+                end
+            },
+        },
+    }
+    button_dialog = ButtonDialog:new{
+        title = item.text,
+        title_align = "center",
+        buttons = buttons,
+    }
+    UIManager:show(button_dialog)
+    return true
+end
+
+function FileManagerCollection:onLeftButtonTap(file_or_files)
+    if file_or_files then
+        if type(file_or_files) == "string" then
+            ReadCollection:addRemoveItemMultiple(file_or_files, self.selected_colections)
+        else -- selected files
+            ReadCollection:addItemsMultiple(file_or_files, self.selected_colections)
+        end
+        self.coll_list.close_callback(true)
+    else
+        local button_dialog
+        local buttons = {
+            {
+                {
+                    text = _("Sort collections"),
+                    callback = function()
+                        UIManager:close(button_dialog)
+                        self:sortCollections()
+                    end,
+                },
+            },
+            {
+                {
+                    text = _("New collection"),
+                    callback = function()
+                        UIManager:close(button_dialog)
+                        self:addCollection()
+                    end,
+                },
+            },
+        }
+        button_dialog = ButtonDialog:new{
+            buttons = buttons,
+        }
+        UIManager:show(button_dialog)
+    end
+end
+
+function FileManagerCollection:editCollectionName(editCallback, old_name)
+    local input_dialog
+    input_dialog = InputDialog:new{
+        title =  _("Enter collection name"),
+        input = old_name,
+        input_hint = old_name,
+        buttons = {{
+            {
+                text = _("Cancel"),
+                id = "close",
+                callback = function()
+                    UIManager:close(input_dialog)
+                end,
+            },
+            {
+                text = _("Save"),
+                callback = function()
+                    local new_name = input_dialog:getInputText()
+                    if new_name == "" or new_name == old_name then return end
+                    if ReadCollection.coll[new_name] then
+                        UIManager:show(InfoMessage:new{
+                            text = T(_("Collection already exists: %1"), new_name),
+                        })
+                    else
+                        UIManager:close(input_dialog)
+                        editCallback(new_name)
+                    end
+                end,
+            },
+        }},
+    }
+    UIManager:show(input_dialog)
+    input_dialog:onShowKeyboard()
+end
+
+function FileManagerCollection:addCollection()
+    local editCallback = function(name)
+        ReadCollection:addCollection(name)
+        table.insert(self.coll_list.item_table, {
+            text      = name,
+            mandatory = 0,
+            name      = name,
+            order     = ReadCollection.coll_order[name],
+        })
+        self:updateCollListItemTable(false, #self.coll_list.item_table) -- show added item
+    end
+    self:editCollectionName(editCallback)
+end
+
+function FileManagerCollection:renameCollection(item)
+    local editCallback = function(name)
+        ReadCollection:renameCollection(item.name, name)
+        self.coll_list.item_table[item.idx].text = name
+        self.coll_list.item_table[item.idx].name = name
+        self:updateCollListItemTable()
+    end
+    self:editCollectionName(editCallback, item.name)
+end
+
+function FileManagerCollection:removeCollection(item)
+    UIManager:show(ConfirmBox:new{
+        text = _("Remove collection?") .. "\n\n" .. item.text,
+        ok_text = _("Remove"),
+        ok_callback = function()
+            ReadCollection:removeCollection(item.name)
+            table.remove(self.coll_list.item_table, item.idx)
+            self:updateCollListItemTable()
+        end,
+    })
+end
+
+function FileManagerCollection:sortCollections()
+    local sort_widget
+    sort_widget = SortWidget:new{
+        title = _("Sort collections"),
+        item_table = util.tableDeepCopy(self.coll_list.item_table),
+        callback = function()
+            ReadCollection:updateCollectionListOrder(sort_widget.item_table)
+            self:updateCollListItemTable(true) -- init
+        end,
+    }
+    UIManager:show(sort_widget)
+end
+
 return FileManagerCollection

frontend/apps/filemanager/filemanagerutil.lua

@@ -235,20 +235,13 @@ function filemanagerutil.genResetSettingsButton(doc_settings_or_file, caller_cal
 end
 
 function filemanagerutil.genAddRemoveFavoritesButton(file, caller_callback, button_disabled)
-    local ReadCollection = require("readcollection")
-    local has_file = ReadCollection:hasFile(file)
     return {
-        text_func = function()
-            return has_file and _("Remove from favorites") or _("Add to favorites")
-        end,
+        text = _("Book in collections"),
         enabled = not button_disabled,
         callback = function()
             caller_callback()
-            if has_file then
-                ReadCollection:removeItem(file)
-            else
-                ReadCollection:addItem(file)
-            end
+            local ui = require("apps/filemanager/filemanager").instance or require("apps/reader/readerui").instance
+            ui.collections:onShowCollList(file)
         end,
     }
 end

frontend/dispatcher.lua

@@ -53,7 +53,8 @@ local settingsList = {
     open_previous_document = {category="none", event="OpenLastDoc", title=_("Open previous document"), general=true},
     history = {category="none", event="ShowHist", title=_("History"), general=true},
     history_search = {category="none", event="SearchHistory", title=_("History search"), general=true},
-    favorites = {category="none", event="ShowColl", arg="favorites", title=_("Favorites"), general=true},
+    favorites = {category="none", event="ShowColl", title=_("Favorites"), general=true},
+    collections = {category="none", event="ShowCollList", title=_("Collections"), general=true},
     filemanager = {category="none", event="Home", title=_("File browser"), general=true, separator=true},
     ----
     dictionary_lookup = {category="none", event="ShowDictionaryLookup", title=_("Dictionary lookup"), general=true},
@@ -272,6 +273,7 @@ local dispatcher_menu_order = {
     "history",
     "history_search",
     "favorites",
+    "collections",
     "filemanager",
     ----
     "dictionary_lookup",

frontend/readcollection.lua

@@ -8,11 +8,14 @@ local util = require("util")
 local collection_file = DataStorage:getSettingsDir() .. "/collection.lua"
 
 local ReadCollection = {
-    coll = {},
+    coll = nil, -- hash table
+    coll_order = nil, -- hash table
     last_read_time = 0,
     default_collection_name = "favorites",
 }
 
+-- read, write
+
 local function buildEntry(file, order, mandatory)
     file = FFIUtil.realpath(file)
     if not file then return end
@@ -41,6 +44,7 @@ function ReadCollection:_read()
     end
     logger.dbg("ReadCollection: reading from collection file")
     self.coll = {}
+    self.coll_order = {}
     for coll_name, collection in pairs(collections.data) do
         local coll = {}
         for _, v in ipairs(collection) do
@@ -50,14 +54,23 @@ function ReadCollection:_read()
             end
         end
         self.coll[coll_name] = coll
+        if not collection.settings then -- favorites, first run
+            collection.settings = { order = 1 }
+        end
+        self.coll_order[coll_name] = collection.settings.order
     end
 end
 
 function ReadCollection:write(collection_name)
     local collections = LuaSettings:open(collection_file)
+    for coll_name in pairs(collections.data) do
+        if not self.coll[coll_name] then
+            collections:delSetting(coll_name)
+        end
+    end
     for coll_name, coll in pairs(self.coll) do
         if not collection_name or coll_name == collection_name then
-            local data = {}
+            local data = { settings = { order = self.coll_order[coll_name] } }
             for _, item in pairs(coll) do
                 table.insert(data, { file = item.file, order = item.order })
             end
@@ -68,20 +81,32 @@ function ReadCollection:write(collection_name)
     collections:flush()
 end
 
-function ReadCollection:getFileCollectionName(file, collection_name)
+-- info
+
+function ReadCollection:isFileInCollection(file, collection_name)
     file = FFIUtil.realpath(file) or file
-    for coll_name, coll in pairs(self.coll) do
-        if not collection_name or coll_name == collection_name then
-            if coll[file] then
-                return coll_name, file
-            end
+    return self.coll[collection_name][file] and true or false
+end
+
+function ReadCollection:isFileInCollections(file)
+    file = FFIUtil.realpath(file) or file
+    for _, coll in pairs(self.coll) do
+        if coll[file] then
+            return true
         end
     end
+    return false
 end
 
-function ReadCollection:hasFile(file, collection_name)
-    local coll_name = self:getFileCollectionName(file, collection_name)
-    return coll_name and true or false
+function ReadCollection:getCollectionsWithFile(file)
+    file = FFIUtil.realpath(file) or file
+    local collections = {}
+    for coll_name, coll in pairs(self.coll) do
+        if coll[file] then
+            collections[coll_name] = true
+        end
+    end
+    return collections
 end
 
 function ReadCollection:getCollectionMaxOrder(collection_name)
@@ -94,61 +119,74 @@ function ReadCollection:getCollectionMaxOrder(collection_name)
     return max_order
 end
 
-function ReadCollection:getOrderedCollection(collection_name)
-    local ordered_coll = {}
-    for _, item in pairs(self.coll[collection_name]) do
-        table.insert(ordered_coll, item)
-    end
-    table.sort(ordered_coll, function(v1, v2) return v1.order < v2.order end)
-    return ordered_coll
-end
-
-function ReadCollection:updateCollectionOrder(collection_name, ordered_coll)
-    local coll = self.coll[collection_name]
-    for i, item in ipairs(ordered_coll) do
-        coll[item.file].order = i
-    end
-    self:write(collection_name)
-end
+-- manage items
 
 function ReadCollection:addItem(file, collection_name)
-    collection_name = collection_name or self.default_collection_name
     local max_order = self:getCollectionMaxOrder(collection_name)
     local item = buildEntry(file, max_order + 1)
     self.coll[collection_name][item.file] = item
     self:write(collection_name)
 end
 
-function ReadCollection:addItems(files, collection_name) -- files = { filepath = true, }
-    collection_name = collection_name or self.default_collection_name
-    local coll = self.coll[collection_name]
-    local max_order = self:getCollectionMaxOrder(collection_name)
-    local do_write
-    for file in pairs(files) do
-        if not self:hasFile(file) then
-            max_order = max_order + 1
-            local item = buildEntry(file, max_order)
-            coll[item.file] = item
-            do_write = true
+function ReadCollection:addRemoveItemMultiple(file, collections_to_add)
+    file = FFIUtil.realpath(file) or file
+    for coll_name, coll in pairs(self.coll) do
+        if collections_to_add[coll_name] then
+            if not coll[file] then
+                local max_order = self:getCollectionMaxOrder(coll_name)
+                coll[file] = buildEntry(file, max_order + 1)
+            end
+        else
+            if coll[file] then
+                coll[file] = nil
+            end
         end
     end
-    if do_write then
-        self:write(collection_name)
+    self:write()
+end
+
+function ReadCollection:addItemsMultiple(files, collections_to_add)
+    for file in pairs(files) do
+        file = FFIUtil.realpath(file) or file
+        for coll_name in pairs(collections_to_add) do
+            local coll = self.coll[coll_name]
+            if not coll[file] then
+                local max_order = self:getCollectionMaxOrder(coll_name)
+                coll[file] = buildEntry(file, max_order + 1)
+            end
+        end
     end
+    self:write()
 end
 
-function ReadCollection:removeItem(file, collection_name, no_write)
-    local coll_name, file_name = self:getFileCollectionName(file, collection_name)
-    if coll_name then
-        self.coll[coll_name][file_name] = nil
-        if not no_write then
-            self:write(coll_name)
+function ReadCollection:removeItem(file, collection_name, no_write) -- FM: delete file; FMColl: remove file
+    file = FFIUtil.realpath(file) or file
+    if collection_name then
+        if self.coll[collection_name][file] then
+            self.coll[collection_name][file] = nil
+            if not no_write then
+                self:write(collection_name)
+            end
+            return true
+        end
+    else
+        local do_write
+        for _, coll in pairs(self.coll) do
+            if coll[file] then
+                coll[file] = nil
+                do_write = true
+            end
+        end
+        if do_write then
+            if not no_write then
+                self:write()
+            end
+            return true
         end
-        return true
     end
 end
 
-function ReadCollection:removeItems(files) -- files = { filepath = true, }
+function ReadCollection:removeItems(files) -- FM: delete files
     local do_write
     for file in pairs(files) do
         if self:removeItem(file, nil, true) then
@@ -160,12 +198,12 @@ function ReadCollection:removeItems(files) -- files = { filepath = true, }
     end
 end
 
-function ReadCollection:removeItemsByPath(path)
+function ReadCollection:removeItemsByPath(path) -- FM: delete folder
     local do_write
     for coll_name, coll in pairs(self.coll) do
         for file_name in pairs(coll) do
             if util.stringStartsWith(file_name, path) then
-                self.coll[coll_name][file_name] = nil
+                coll[file_name] = nil
                 do_write = true
             end
         end
@@ -185,21 +223,29 @@ function ReadCollection:_updateItem(coll_name, file_name, new_filepath, new_path
     coll[item.file] = item
 end
 
-function ReadCollection:updateItem(file, new_filepath)
-    local coll_name, file_name = self:getFileCollectionName(file)
-    if coll_name then
-        self:_updateItem(coll_name, file_name, new_filepath)
-        self:write(coll_name)
+function ReadCollection:updateItem(file, new_filepath) -- FM: rename file, move file
+    file = FFIUtil.realpath(file) or file
+    local do_write
+    for coll_name, coll in pairs(self.coll) do
+        if coll[file] then
+            self:_updateItem(coll_name, file, new_filepath)
+            do_write = true
+        end
+    end
+    if do_write then
+        self:write()
     end
 end
 
-function ReadCollection:updateItems(files, new_path) -- files = { filepath = true, }
+function ReadCollection:updateItems(files, new_path) -- FM: move files
     local do_write
     for file in pairs(files) do
-        local coll_name, file_name = self:getFileCollectionName(file)
-        if coll_name then
-            self:_updateItem(coll_name, file_name, nil, new_path)
-            do_write = true
+        file = FFIUtil.realpath(file) or file
+        for coll_name, coll in pairs(self.coll) do
+            if coll[file] then
+                self:_updateItem(coll_name, file, nil, new_path)
+                do_write = true
+            end
         end
     end
     if do_write then
@@ -207,7 +253,7 @@ function ReadCollection:updateItems(files, new_path) -- files = { filepath = tru
     end
 end
 
-function ReadCollection:updateItemsByPath(path, new_path)
+function ReadCollection:updateItemsByPath(path, new_path) -- FM: rename folder, move folder
     local len = #path
     local do_write
     for coll_name, coll in pairs(self.coll) do
@@ -223,6 +269,58 @@ function ReadCollection:updateItemsByPath(path, new_path)
     end
 end
 
+function ReadCollection:getOrderedCollection(collection_name)
+    local ordered_coll = {}
+    for _, item in pairs(self.coll[collection_name]) do
+        table.insert(ordered_coll, item)
+    end
+    table.sort(ordered_coll, function(v1, v2) return v1.order < v2.order end)
+    return ordered_coll
+end
+
+function ReadCollection:updateCollectionOrder(collection_name, ordered_coll)
+    local coll = self.coll[collection_name]
+    for i, item in ipairs(ordered_coll) do
+        coll[item.file].order = i
+    end
+    self:write(collection_name)
+end
+
+-- manage collections
+
+function ReadCollection:addCollection(coll_name)
+    local max_order = 0
+    for _, order in pairs(self.coll_order) do
+        if max_order < order then
+            max_order = order
+        end
+    end
+    self.coll_order[coll_name] = max_order + 1
+    self.coll[coll_name] = {}
+    self:write(coll_name)
+end
+
+function ReadCollection:renameCollection(coll_name, new_name)
+    self.coll_order[new_name] = self.coll_order[coll_name]
+    self.coll[new_name] = self.coll[coll_name]
+    self.coll_order[coll_name] = nil
+    self.coll[coll_name] = nil
+    self:write(new_name)
+end
+
+function ReadCollection:removeCollection(coll_name)
+    self.coll_order[coll_name] = nil
+    self.coll[coll_name] = nil
+    self:write()
+end
+
+function ReadCollection:updateCollectionListOrder(ordered_coll)
+    for i, item in ipairs(ordered_coll) do
+        self.coll_order[item.name] = i
+    end
+    self:write()
+end
+
 ReadCollection:_read()
 
 return ReadCollection