Change settings localization, add group name and description

files/builtin_scripts/scripts/omw/settings/common.lua

@@ -57,7 +57,7 @@ local function getSetting(groupKey, settingKey)
     if not group then
         error('Unknown group')
     end
-    local setting = group[settingKey]
+    local setting = group.settings[settingKey]
     if not setting then
         error('Unknown setting')
     end

files/builtin_scripts/scripts/omw/settings/player.lua

@@ -8,10 +8,11 @@ render.registerRenderer('text', function(value, set, arg)
     return {
         type = ui.TYPE.TextEdit,
         props = {
-            size = util.vector2(arg and arg.size or 300, 100),
+            size = util.vector2(arg and arg.size or 300, 30),
             text = value,
             textColor = util.color.rgb(1, 1, 1),
-            textSize = 30,
+            textSize = 15,
+            textAlignV = ui.ALIGNMENT.Center,
         },
         events = {
             textChanged = async:callback(function(s) set(s) end),
@@ -26,7 +27,6 @@ return {
         SCOPE = common.SCOPE,
         getGroup = common.getGroup,
         registerRenderer = render.registerRenderer,
-        localizeGroup = render.localizeGroup,
     },
     engineHandlers = {
         onLoad = function(saved)

files/builtin_scripts/scripts/omw/settings/register.lua

@@ -26,34 +26,70 @@ local function validateSettingOptions(options)
     if type(options.renderer) ~= 'string' then
         error('Setting must have a renderer')
     end
+    if type(options.name) ~= 'string' then
+        error('Setting must have a name localization key')
+    end
+    if type(options.description) ~= 'string' then
+        error('Setting must have a descripiton localization key')
+    end
 end
 
-local function addSetting(group, options)
+local function addSetting(settings, options)
     validateSettingOptions(options)
-    if group[options.key] then
+    if settings[options.key] then
         error(('Duplicate setting key %s'):format(options.key))
     end
-    group[options.key] = {
+    settings[options.key] = {
         key = options.key,
         scope = options.scope or SCOPE.Global,
         default = options.default,
         renderer = options.renderer,
         argument = options.argument,
+
+        name = options.name,
+        description = options.description,
     }
 end
 
-local function registerGroup(groupName, list)
+local function validateGroupOptions(options)
-    if groups:get(groupName) then
+    if type(options.key) ~= 'string' then
-        print(('Overwriting group %s'):format(groupName))
+        error('Group must have a key')
     end
-    local settings = {}
+    if type(options.localization) ~= 'string' then
-    for _, opt in ipairs(list) do
+        error('Group must have a localization context')
-        addSetting(settings, opt)
     end
-    groups:set(groupName, settings)
+    if type(options.name) ~= 'string' then
+        error('Group must have a name localization key')
+    end
+    if type(options.description) ~= 'string' then
+        error('Group must have a description localization key')
+    end
+    if type(options.settings) ~= 'table' then
+        error('Group must have a table of settings')
+    end
+end
+
+local function registerGroup(options)
+    validateGroupOptions(options)
+    if groups:get(options.key) then
+        print(('Overwriting group %s'):format(options.key))
+    end
+    local group = {
+        key = options.key,
+        localization = options.localization,
+
+        name = options.name,
+        description = options.description,
+
+        settings = {},
+    }
+    for _, opt in ipairs(options.settings) do
+        addSetting(group.settings, opt)
+    end
+    groups:set(options.key, group)
     for _, a in ipairs(world.activeActors) do
         if a.type == types.Player and a:isValid() then
-            a:sendEvent(common.EVENTS.GroupRegistered, groupName)
+            a:sendEvent(common.EVENTS.GroupRegistered, options.key)
         end
     end
 end

files/builtin_scripts/scripts/omw/settings/render.lua

@@ -1,6 +1,7 @@
 local ui = require('openmw.ui')
 local util = require('openmw.util')
 local async = require('openmw.async')
+local core = require('openmw.core')
 
 local common = require('scripts.omw.settings.common')
 
@@ -10,84 +11,122 @@ local function registerRenderer(name, renderFunction)
 end
 
 local groupOptions = {}
-local localization = {}
+
+
+local padding = function(size)
+    return {
+        props = {
+            size = util.vector2(size, size),
+        }
+    }
+end
+
+local header = {
+    props = {
+        textColor = util.color.rgb(1, 1, 1),
+        textSize = 30,
+    },
+}
+
+local normal = {
+    props = {
+        textColor = util.color.rgb(1, 1, 1),
+        textSize = 25,
+    },
+}
 
 local function renderSetting(groupKey, setting, value)
     local renderFunction = renderers[setting.renderer]
     if not renderFunction then
         error(('Setting %s of %s has unknown renderer %s'):format(setting.key, groupKey, setting.renderer))
     end
-    local settingName = localization[groupKey]
+    local group = common.getGroup(groupKey)
-        and localization[groupKey].settings[setting.key].name
+    value = value or group:get(setting.key)
-        or setting.key
     local set = function(value)
-        local group = common.getGroup(groupKey)
         group:set(setting.key, value)
         renderSetting(groupKey, setting, value)
     end
     local element = groupOptions[groupKey].element
+    local localization = groupOptions[groupKey].localization
     local settingsLayout = element.layout.content.settings
     settingsLayout.content[setting.key] = {
         name = setting.key,
         type = ui.TYPE.Flex,
-        props = {
-            horizontal = true,
-            align = ui.ALIGNMENT.Start,
-            arrange = ui.ALIGNMENT.Center,
-        },
         content = ui.content {
             {
-                type = ui.TYPE.Text,
+                type = ui.TYPE.Flex,
                 props = {
-                    text = settingName .. ':',
+                    horizontal = true,
-                    textColor = util.color.rgb(1, 1, 1),
+                    align = ui.ALIGNMENT.Start,
-                    textSize = 30,
+                    arrange = ui.ALIGNMENT.End,
-                },
+                },
-            },
+                content = ui.content {
-            renderFunction(value or setting.default, set, setting.argument),
+                    {
-            {
+                        type = ui.TYPE.Text,
-                type = ui.TYPE.Text,
+                        template = normal,
-                props = {
+                        props = {
-                    text = 'Reset',
+                            text = localization(setting.name),
-                    textColor = util.color.rgb(1, 1, 1),
+                        },
-                    textSize = 30,
+                    },
-                },
+                    padding(10),
-                events = {
+                    renderFunction(value, set, setting.argument),
-                    mouseClick = async:callback(function()
+                    padding(10),
-                        set(setting.default)
+                    {
-                    end),
+                        type = ui.TYPE.Text,
+                        template = normal,
+                        props = {
+                            text = 'Reset',
+                        },
+                        events = {
+                            mouseClick = async:callback(function()
+                                set(setting.default)
+                            end),
+                        },
+                    },
                 },
             },
+            padding(20),
         },
     }
     element:update()
 end
 
-local function updateLocalization(groupKey)
+local function renderGroup(groupKey)
-    local loc = localization[groupKey]
-    local options = groupOptions[groupKey]
-    if not options or not loc then return end
-    local searchHints = { loc.name, loc.description }
-    options.name = loc.name
-    options.searchHints = table.concat(searchHints, ' ')
-    local layout = options.element.layout
-    layout.content.header.props.text = loc.description
-end
-
-local function onGroupRegistered(groupKey)
     local group = common.groups:get(groupKey)
-    local layout = {
+    local element = groupOptions[groupKey].element
+    local localization = groupOptions[groupKey].localization
+    element.layout = {
         type = ui.TYPE.Flex,
         content = ui.content {
+            padding(10),
             {
-                name = 'header',
+                type = ui.TYPE.Flex,
-                type = ui.TYPE.Text,
                 props = {
-                    text = '',
+                    horizontal = true,
-                    textSize = 30,
+                    align = ui.ALIGNMENT.Start,
-                    textColor = util.color.rgb(1, 1, 1),
+                    arrange = ui.ALIGNMENT.Center,
+                },
+                content = ui.content {
+                    {
+                        name = 'name',
+                        type = ui.TYPE.Text,
+                        template = header,
+                        props = {
+                            text = localization(group.name),
+                        },
+                    },
+                    padding(10),
+                    {
+                        name = 'description',
+                        type = ui.TYPE.Text,
+                        template = normal,
+                        props = {
+                            text = localization(group.description),
+                        },
+                    },
                 },
             },
+            padding(50),
             {
                 name = 'settings',
                 type = ui.TYPE.Flex,
@@ -95,28 +134,28 @@ local function onGroupRegistered(groupKey)
             },
         },
     }
-    local options = {
+    local settingsContent = element.layout.content.settings.content
-        name = groupKey,
+    for _, setting in pairs(group.settings) do
-        element = ui.create(layout),
+        settingsContent:add({ name = setting.key })
-        searchHints = '',
+        renderSetting(groupKey, setting)
-    }
-    groupOptions[groupKey] = options
-    for _, setting in pairs(group) do
-        layout.content.settings.content:add({ name = setting.key })
-        renderSetting(groupKey, setting, setting.default)
     end
-    updateLocalization(groupKey)
+    element:update()
-    print(('registering group %s'):format(groupKey))
-    ui.registerSettingsPage(options)
 end
 
-local function localizeGroup(groupKey, loc)
+local function onGroupRegistered(groupKey)
-    localization[groupKey] = loc
+    local group = common.groups:get(groupKey)
-    updateLocalization(groupKey)
+    local options = {
+        name = groupKey,
+        element = ui.create{},
+        searchHints = '',
+        localization = core.l10n(group.localization),
+    }
+    groupOptions[groupKey] = options
+    renderGroup(groupKey)
+    ui.registerSettingsPage(options)
 end
 
 return {
     onGroupRegistered = onGroupRegistered,
     registerRenderer = registerRenderer,
-    localizeGroup = localizeGroup,
 }