Convert toolbar minus datastore

exp_legacy/module/modules/data/toolbar.lua

@@ -0,0 +1,190 @@
+local Gui = require("modules/exp_gui")
+local ExpElement = require("modules/exp_gui/prototype")
+local PlayerData = require("modules.exp_legacy.expcore.player_data") --- @dep expcore.player_data
+
+-- Used to store the state of the toolbar when a player leaves
+local ToolbarState = PlayerData.Settings:combine("ToolbarState")
+ToolbarState:set_metadata{
+    stringify = function(value)
+        local buttons, favourites = 0, 0
+        for _, state in ipairs(value) do
+            buttons = buttons + 1
+            if state.favourite then
+                favourites = favourites + 1
+            end
+        end
+
+        return string.format("Buttons: %d, Favourites: %d", buttons, favourites)
+    end,
+}
+
+--- Set the default value for the datastore
+local datastore_id_map = {} --- @type table<string, ExpElement>
+local toolbar_default_state = {}
+ToolbarState:set_default(toolbar_default_state)
+
+--- Get the datastore id for this element define, to best of ability it should be unique between versions
+local function to_datastore_id(element_define)
+    -- First try to use the tooltip locale string
+    local tooltip = element_define.tooltip
+    if type(tooltip) == "table" then
+        return tooltip[1]:gsub("%.(.+)", "")
+    end
+
+    -- Then try to use the caption or sprite
+    return element_define.caption or element_define.sprite
+end
+
+--- For all top element, register an on click which will copy their style
+for index, element_define in ipairs(Gui.top_elements) do
+    -- Insert the element into the id map
+    datastore_id_map[to_datastore_id(element_define)] = element_define -- Backwards Compatibility
+    datastore_id_map[element_define.name] = element_define
+
+    -- Add the element to the default state
+    table.insert(toolbar_default_state, {
+        element = element_define.uid,
+        favourite = true,
+    })
+end
+
+--- Get the top order based on the players settings
+Gui.inject_top_flow_order(function(player)
+    local order = ToolbarState:get(player)
+
+    local elements = {}
+    for index, state in ipairs(order) do
+        elements[index] = Gui.defines[state.element]
+    end
+
+    return elements
+end)
+
+--- Get the left order based on the player settings, with toolbar menu first, and all remaining after
+Gui.inject_left_flow_order(function(player)
+    local order = Gui.get_top_flow_order(player)
+    local elements, element_map = { toolbar_container }, { [toolbar_container] = true }
+
+    -- Add the flows that have a top element
+    for _, element_define in ipairs(order) do
+        if element_define.left_flow_element then
+            table.insert(elements, element_define.left_flow_element)
+            element_map[element_define.left_flow_element] = true
+        end
+    end
+
+    -- Add the flows that dont have a top element
+    for _, element_define in ipairs(Gui.left_elements) do
+        if not element_map[element_define] then
+            table.insert(elements, element_define)
+        end
+    end
+
+    return elements
+end)
+
+--- Overwrite the default update top flow
+local _update_top_flow = Gui.update_top_flow
+function Gui.update_top_flow(player)
+    _update_top_flow(player) -- Call the original
+
+    local order = ToolbarState:get(player)
+    for index, state in ipairs(order) do
+        local element_define = Gui.defines[state.element]
+        local top_element = Gui.get_top_element(player, element_define)
+        top_element.visible = top_element.visible and state.favourite or false
+    end
+end
+
+--- Uncompress the data to be more useable
+ToolbarState:on_load(function(player_name, value)
+    -- If there is no value, do nothing
+    if value == nil then return end
+    --- @cast value [ string[], string[], string[], boolean ]
+
+    -- Create a hash map of the favourites
+    local favourites = {}
+    for _, id in ipairs(value[2]) do
+        favourites[id] = true
+    end
+
+    -- Read the order from the value
+    local elements = {}
+    local element_hash = {}
+    for index, id in ipairs(value[1]) do
+        local element = datastore_id_map[id]
+        if element and not element_hash[element.name] then
+            element_hash[element.name] = true
+            elements[index] = {
+                element = element,
+                favourite = favourites[id] or false,
+            }
+        end
+    end
+
+    -- Add any in the default state that are missing
+    for _, state in ipairs(toolbar_default_state) do
+        if not element_hash[state.element] then
+            table.insert(elements, table.deep_copy(state))
+        end
+    end
+
+    -- Create a hash map of the open left flows
+    local open_left_elements = {}
+    for _, id in ipairs(value[3]) do
+        local element = datastore_id_map[id]
+        local left_element = element.left_flow_element
+        if left_element then
+            open_left_elements[left_element] = true
+        end
+    end
+
+    -- Set the visible state of all left flows
+    local player = assert(game.get_player(player_name))
+    for left_element in pairs(Gui.left_elements) do
+        Gui.set_left_element_visible(left_element, player, open_left_elements[left_element] or false)
+    end
+
+    -- Set the toolbar visible state
+    Gui.set_top_flow_visible(player, value[4])
+
+    -- Set the data now and update now, ideally this would be on_update but that had too large of a latency
+    ToolbarState:raw_set(player_name, elements)
+    Gui.reorder_top_flow(player)
+    Gui.reorder_left_flow(player)
+    reorder_toolbar_menu(player)
+
+    return elements
+end)
+
+--- Save the current state of the players toolbar menu
+ToolbarState:on_save(function(player_name, value)
+    if value == nil then return nil end -- Don't save default
+    local order, favourites, left_flows = {}, {}, {}
+
+    local player = assert(game.get_player(player_name))
+    local top_flow_open = Gui.get_top_flow(player).parent.visible
+
+    for index, state in ipairs(value) do
+        -- Add the element to the order array
+        --- @diagnostic disable-next-line invisible
+        local element_define = ExpElement._elements[state.element]
+        local id = to_datastore_id(element_define)
+        order[index] = id
+
+        -- If its a favourite then insert it
+        if state.favourite then
+            table.insert(favourites, id)
+        end
+
+        -- If it has a left flow and its open then insert it
+        if element_define.left_flow_element then
+            local left_element = Gui.get_left_element(element_define.left_flow_element, player)
+            if left_element.visible then
+                table.insert(left_flows, id)
+            end
+        end
+    end
+
+    return { order, favourites, left_flows, top_flow_open }
+end)