Back to Home

ESO Lua File v100022

libraries/globals/localization.lua

[◄ back to folders ]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
ESO_NumberFormats = {}
local strArgs = {}
function zo_strformat(formatString, ...)
    for i = 1, select("#", ...) do
        local currentArg = select(i, ...)
        if type(currentArg) == "number" then
            local str = ""
            local numFmt = "d"
            local num, frac = zo_decimalsplit(currentArg)
            
            local width = 0
            local digits = 1
            local unsigned = false
            if ESO_NumberFormats[formatString] ~= nil and ESO_NumberFormats[formatString][i] ~= nil then
                width = ESO_NumberFormats[formatString][i].width or width
                digits = ESO_NumberFormats[formatString][i].digits or digits
                unsigned = ESO_NumberFormats[formatString][i].unsigned or unsigned
            end
            if width > 0 then
                str = string.format("0%d", width)
            end
            if frac ~= 0 then
                numFmt = "f"
                str = str..string.format(".%d", digits)
            elseif unsigned == true then
                numFmt = "u"
            end
            str = string.format("%%%s%s", str, numFmt)
            strArgs[i] = string.format(str, currentArg)
        elseif type(currentArg) == "string" then
            strArgs[i] = currentArg
        else
            strArgs[i] = ""
        end
    end
    if type(formatString) == "number" then
        formatString = GetString(formatString)
    end
    return LocalizeString(formatString, unpack(strArgs))
end
do
    -- zo_strformat elegantly handles the case where we pass in a param as the "formatter" (e.g.: collectible descriptions).
    -- However, in order to avoid having each string generate its own cache table, the ZO_CachedStrFormat function need to be explicitely told "I have no formatter"
    -- so it can add all of them to one table. This cuts down on overhead, with the downside that it loses slight parity with zo_strformat.
    -- However, the fact that we do this whole no param thing at all is exploiting a quirk in the grammar to get around a bug in the grammar anyway so
    -- it's a relatively rare scenario
    ZO_CACHED_STR_FORMAT_NO_FORMATTER = ""
    local g_cachedStringsByFormatter = 
    {
        [ZO_CACHED_STR_FORMAT_NO_FORMATTER] = {} --Used for strings that need to run through grammar without a formatter
    }
    function ZO_CachedStrFormat(formatter, ...)
        formatter = formatter or ZO_CACHED_STR_FORMAT_NO_FORMATTER
        local formatterCache = g_cachedStringsByFormatter[formatter]
        if not formatterCache then
            formatterCache = {}
            g_cachedStringsByFormatter[formatter] = formatterCache
        end
        
        local cachedString
        if formatter == ZO_CACHED_STR_FORMAT_NO_FORMATTER then
            --"No formatter" only works with 1 param
            local rawString = ...
            local hashKey = HashString(rawString)
            cachedString = formatterCache[hashKey]
            if not cachedString then
                cachedString = zo_strformat(rawString)
                formatterCache[hashKey] = cachedString
            end
        else
            local concatParams = table.concat({ ... })
            local hashKey = HashString(concatParams)
            cachedString = formatterCache[hashKey]
            if not cachedString then
                cachedString = zo_strformat(formatter, ...)
                formatterCache[hashKey] = cachedString
            end
        end
        return cachedString
    end
        if g_cachedStringsByFormatter[formatter] then
            g_cachedStringsByFormatter[formatter] = nil
        end
    end
end
function zo_strtrim(str)
    -- The extra parentheses are used to discard the additional return value (which is the total number of matches)
    return(zo_strgsub(str, "^%s*(.-)%s*$", "%1"))
end
do
    -- Use the English thousands and decimal marks. The grammar library will convert them to the current language.
    local DIGIT_GROUP_REPLACER = ","
    local DIGIT_GROUP_DECIMAL_REPLACER = "."
    local DIGIT_GROUP_REPLACER_THRESHOLD = zo_pow(10, GetDigitGroupingSize())
    
    function ZO_CommaDelimitNumber(amount)
        if amount < DIGIT_GROUP_REPLACER_THRESHOLD then
            return tostring(amount)
        end
        return FormatIntegerWithDigitGrouping(amount, DIGIT_GROUP_REPLACER, GetDigitGroupingSize())
    end
    function ZO_LocalizeDecimalNumber(amount)
        local amountString = tostring(amount)
        if amount >= DIGIT_GROUP_REPLACER_THRESHOLD then
            -- We have a number like 10000.5, so localize the non-decimal digit group separators (e.g., 10000 becomes 10,000)
            local decimalSeparatorIndex = zo_strfind(amountString, "%"..DIGIT_GROUP_DECIMAL_REPLACER) -- Look for the literal separator
            local decimalPartString = decimalSeparatorIndex and zo_strsub(amountString, decimalSeparatorIndex) or ""
            local wholePartString = zo_strsub(amountString, 1, decimalSeparatorIndex and decimalSeparatorIndex - 1)
            amountString = ZO_CommaDelimitNumber(tonumber(wholePartString))..decimalPartString
        end
        return amountString
    end
end
function ZO_GenerateCommaSeparatedList(argumentTable)
    if argumentTable ~= nil and #argumentTable > 0 then
        local numArguments = #argumentTable
        -- If there's only one item in the list, the string is just the first item
        if numArguments == 1 then
            return argumentTable[1]
        else
            -- loop through the first through the second to last element adding commas in between
            -- don't add the last since we will use a different separator for it
            local listString = table.concat(argumentTable, GetString(SI_LIST_COMMA_SEPARATOR), 1, numArguments - 1)
            -- add the last element of the array to the list using the ", and" separator
            local finalSeparator = SI_LIST_COMMA_AND_SEPARATOR
            -- if there are only two items in the list, we want to use "and" without a comma
            if numArguments == 2 then
                finalSeparator = SI_LIST_AND_SEPARATOR
            end
            listString = string.format('%s%s%s', listString, GetString(finalSeparator), argumentTable[numArguments])
            return listString
        end
    else
        return ""
    end
end
function ZO_GenerateCommaSeparatedListWithoutAnd(argumentTable)
    if argumentTable ~= nil then
        return table.concat(argumentTable, GetString(SI_LIST_COMMA_SEPARATOR))
    else
        return ""
    end
end