Mòdul:Global infobox tools
Documentació del mòdul [ mostra ] [ modifica el codi ] [ mostra l'historial ] [ refresca ]
A continuació es mostra la documentació transclosa de la subpàgina /ús. [salta a la caixa de codi]
Mòdul per facilitar la creació de mòduls d'infotaules multilingües (o, dit d'altra forma, permeten la fàcil localització d'aquestes); i així adequar-se a qualsevol Viquipèdia.
Aquest mòdul utilitza, principalment, el Module:Multilang module tools, mòdul del qual hereta moltes propietats i funcions. "Multilang module tools" és de creació de plantilles multilingües; així aquest mòdul és una adequació a les infotaules.
Òbviament, aquest mòdul no presenta (per ell mateix) cap infotaula. Són els mòduls que l'utilitzen els que presenten (directa o indirectament) la infotaula.
Mireu AQUÍ per a més explicacions sobre el mòdul.
Per a proves utilitzeu Mòdul:Global infobox tools/prova.
En profunditat modifica
Variables modifica
Que podrien ser modificades des del mòdul principal, però llavors amb el canvi de l'abreviatura p -> MLITT.
| variable | Valor per defecte | Significat |
|---|---|---|
p.w_hint_txt |
true |
Uses ruby for infobox labels |
p.arg_prefix_l |
'l_' |
Prefix for label keys, since the label text can be modified. |
p.arg_suffix_equal |
'=...' |
Suffix for hint text, using ruby, at end of the nom del paràmetre. |
p.arg_prefix_val |
'val_' |
Prefix for value name to send to template |
p.lbl_prefix |
'lbl_' |
Prefix for label name to send to template |
Module to facilitate the creation of multilingual infobox modules (or, in other words, allow easy its localization); and so adapt to any Wikipedia.
This module mainly uses the Module:Multilang module tools, from which it inherits many properties and functions. "Multilang module tools" is the creation of multilingual templates; thus this module is an adaptation to infoboxes.
Obviously, this module does not (by itself) present any infoboxe. These are the modules that are used by those who present (directly or indirectly) the infobox. So the explanations that follow extend to these modules that use it.
Look at here for more explanations on the module.
In depth modifica
Variables modifica
They could be modified from the main module, but then with the change of the abbreviation p -> MLITT.
| variable | Valor per defecte | Significat |
|---|---|---|
p.w_hint_txt |
true |
Uses ruby for infobox labels |
p.arg_prefix_l |
'l_' |
Prefix for label keys, since the label text can be modified. |
p.arg_suffix_equal |
'=...' |
Suffix for hint text, using ruby, at end of the nom del paràmetre. |
p.arg_prefix_val |
'val_' |
Prefix for value name to send to template |
p.lbl_prefix |
'lbl_' |
Prefix for label name to send to template |
local p = {}
--Version 2020-07-30
local SA = require "Module:SimpleArgs"
local SD = require "Module:SimpleDebug"
local WD = require "Module:Wikidades"
local MLMT = require "Module:Multilang module tools"
local Infobox = require "Module:Infobox"
local II = require 'Module:InfoboxImage'
local GIBTi = require "Module:Global infobox tools/items"
local GIBTi18n = require (SA.I18nName ("Global infobox tools"))
--INITIALIZATION---
local ModuleAbbrev = 'GIBT'
local ModuleName = 'Global infobox tools'
SA.AcceptNone = true
MLMT.with_pos_col = true
MLMT.with_arg_prop = true
MLMT.uses_QP_for_labels = true
p.UsualListOpt = {
MLMT.LOpt.list,
MLMT.LOpt.params,
MLMT.LOpt.template,
MLMT.LOpt.labels,
}
----------------------------------------
-- Color functions --
----------------------------------------
local function CheckColorTab ()
for k, cc in pairs(GIBTi18n.colors) do
if (type(cc) ~= 'table') or (#cc ~= 2) or (type(cc[1]) ~= 'string') or (type(cc[2]) ~= 'string') then
SD.vtos (cc)
error ('In "'..k..'" of color table: '..SD.s..' is not a table with two colors, where two colors are strings',0)
end
end
end --CheckColorTab
CheckColorTab ()
function p._GetInfoboxColor (grp_color_key, n)
-- MLMT.ChkFunc ("GetInfoboxColor", {{"grp_color_key",grp_color_key,"xr"},{"n",n,"xi"},})
for _, v in pairs(GIBTi18n.lcol) do
if grp_color_key == v then
return GIBTi18n.colors[grp_color_key][n]
end
end
error ('Invalid color class ('..v..')',0) --Don't require translation
end --GetInfoboxColor
function p.GetInfoboxColor (frame)
local args = SA.GetArgs (frame)
return p._GetInfoboxColor (SA.RStr_Par (args, 1), SA.RPosInt_Par (args, 2, 1, 2))
end --DefaultColor
function p.DisplayTitleColors ()
-- It shows a table with all color pairs used in Catalan WP infoboxes
local res = '<table class="wikitable sortable">'
res = res..'<tr><th>Header</th><th>RGB</th><th>Subheader</th><th>RGB</th></tr>'
local function AddColor (c, n)
return '<td><span style="background-color:'..GIBTi18n.colors[c][n]..'"> '..c..' </td><td>'..GIBTi18n.colors[c][n]..'</td>'
end
for _,c in ipairs(GIBTi18n.col_idx) do
res = res..'<tr>'..AddColor(c,1)..AddColor(c,2)..'</tr>'
end
res = res..'</table>'
return res
end --DisplayTitleColors
----------------------------------------
-- Icon functions --
----------------------------------------
local function CheckIconTab ()
for k, v in pairs(GIBTi18n.icons) do
if type(v) ~= 'string' then
SD.vtos (v)
error ('In "'..k..'" of icon table: '..SD.s..' is not a string',0)
end
end
end --CheckIconTab
CheckIconTab ()
function p._GetIcon (icon_key)
local found = false
for _, v in pairs(GIBTi18n.licon) do
if icon_key == v then
return GIBTi18n.icons[icon_key]
end
end
error ('Invalid icon key ('..v..')',0) --Don't require translation
end --_GetIcon
function p.GetIcon (frame)
local args = SA.GetArgs (frame)
local name = SA.RStr_Par (args, 1)
return p._GetIcon (name)
end --GetIcon
function p.DisplayTitleIcons (frame)
-- It shows a table with all icons used in Catalan WP infoboxes
local args = SA.GetArgs (frame)
local with_lnk = SA.Bool_Par (args, 1)
local res = '<table class="wikitable sortable">'
res = res..'<th>Key</th><th>Icon name</th><th>Icon</th>'
for _,i in ipairs(GIBTi18n.icon_idx) do
local h = GIBTi18n.icons_headers[i]
if h ~= nil then
res = res..'<tr><td colspan="3"><b>'..h..'</b></td></tr>'
end
local iconf = GIBTi18n.icons[i]
local lnk = i
if with_lnk then
if string.sub (lnk,1,1) ~= '_' then
if lnk ~= GIBTi18n.licon.Taxobox then
lnk = 'Infobox '..lnk
end
lnk = '[[:en:Template:'..lnk..'|'..i..']]'
end
end
res = res..'<tr><td>'..lnk..'</td><td>[[:commons:File:'..iconf..'|'..iconf..']]</td><td>[[File:'..iconf..'|20px|'..i..']]</td></tr>'
end
return res..'</table>'
end --DisplayTitleIcons
----------------------------------------
function p.tableMerge (ModuleName, tab_main, tab_lang)
-- It returns tab_main table with the new items from tab_lang (located in i18n)
MLMT.ChkFunc ("tableMerge", {{"ModuleName",ModuleName,"xr"},{"tab_main",tab_main,"tr"},
{"tab_lang",tab_lang,"tr"},})
if tab_main[MLMT.k.Args][GIBTi.rk.name] == nil then
error ('"'..GIBTi.rk.name..'" not found in "'..MLMT.k.Args..'" of the table items of '..MLMT.MN(ModuleName), 0)
end
return MLMT.tableMerge (ModuleName, tab_main, tab_lang, true)
end --tableMerge
local function ErrorCheck (ModuleName, what, S)
error ('"'..SD.s..'" (for "'..S..'") is not a '..what..' (from '..ModuleName..')', 0) -- Translation not required
end
local function CheckIsStr (ModuleName, v, S)
-- returns a required "v" string for S, otherwise return error
if type(v) == "string" then
return v
else
SD.vtos (v)
ErrorCheck (ModuleName, 'string', S)
end
end --CheckIsStr
local function CheckIsBool (ModuleName, v, S)
-- returns a required "v" boolean for S, otherwise return error
if type(v) == "boolean" then
return v
else
SD.vtos (v)
ErrorCheck (ModuleName, 'boolean', S)
end
end --CheckIsBool
local function CheckIsInt (ModuleName, v, S, LimInf, LimSup)
-- returns a required "v" boolean for S, otherwise return error
if type(v) == "number" then
SA.CheckNumIsInt (v, S, LimInf, LimSup)
return v
else
SD.vtos (v)
ErrorCheck (ModuleName, 'positive integer', S)
end
end --CheckIsBool
local function title_without_disambig ()
-- returns the current page name without text between "()"
local s = mw.title.getCurrentTitle().baseText
s = mw.ustring.gsub(s,'%s%(.*%)','')
return s
end
local function CheckIsStrRs (key)
return CheckIsStr (MLMT.MNi18n(ModuleName), GIBTi18n.rs_val[key], key)
end
local function CheckIsBoolRs (key)
return CheckIsBool (MLMT.MNi18n(ModuleName), GIBTi18n.rs_val[key], key)
end
local function CheckIsIntRs (key, LimInf, LimSup)
return CheckIsInt (MLMT.MNi18n(ModuleName), GIBTi18n.rs_val[key], key, LimInf, LimSup)
end
p.rs = { --Values for reserved keys
--default colors
[GIBTi.rk.rs_colorbox] = "",
[GIBTi.rk.rs_color_tit_cllps] = "",
--styles
[GIBTi.rk.rs_bodystyle] = CheckIsStrRs (GIBTi.rk.rs_bodystyle),
[GIBTi.rk.rs_titlestyle] = CheckIsStrRs (GIBTi.rk.rs_titlestyle),
[GIBTi.rk.rs_headerstyle] = CheckIsStrRs (GIBTi.rk.rs_headerstyle),
[GIBTi.rk.rs_subheaderstyle] = CheckIsStrRs (GIBTi.rk.rs_subheaderstyle),
[GIBTi.rk.rs_imagestyle] = CheckIsStrRs (GIBTi.rk.rs_imagestyle),
[GIBTi.rk.rs_captionstyle] = CheckIsStrRs (GIBTi.rk.rs_captionstyle),
[GIBTi.rk.rs_labelstyle] = CheckIsStrRs (GIBTi.rk.rs_labelstyle),
[GIBTi.rk.rs_datastyle] = CheckIsStrRs (GIBTi.rk.rs_datastyle),
[GIBTi.rk.rs_belowstyle] = CheckIsStrRs (GIBTi.rk.rs_belowstyle),
--icon & default name
[GIBTi.rk.rs_icon] = "", --p.used_icon ~= SA.None
[GIBTi.rk.rs_icon_at_begin] = CheckIsBoolRs (GIBTi.rk.rs_icon_at_begin),
[GIBTi.rk.rs_icon_hint] = "",
[GIBTi.rk.rs_def_name] = title_without_disambig(),
--image
[GIBTi.rk.rs_image_max_num] = CheckIsIntRs (GIBTi.rk.rs_image_max_num, 1, 2),
[GIBTi.rk.rs_def_image_size] = CheckIsStrRs (GIBTi.rk.rs_def_image_size),
[GIBTi.rk.rs_send_img_preinfobox]= CheckIsBoolRs (GIBTi.rk.rs_send_img_preinfobox),
--referred to label/data content
[GIBTi.rk.rs_changeable_lbls] = CheckIsBoolRs (GIBTi.rk.rs_changeable_lbls),
[GIBTi.rk.rs_param_prefix_lbl] = CheckIsStrRs (GIBTi.rk.rs_param_prefix_lbl),
[GIBTi.rk.rs_def_charnum_cllps] = CheckIsIntRs (GIBTi.rk.rs_def_charnum_cllps, 1, 1000),
[GIBTi.rk.rs_error] = "_Q29485",
[GIBTi.rk.rs_below] = "",
}
local rs_wd_t = {
--[rs_key] = {value, argtype_displayed}
}
local rs_idx = { --index for reserved keys
--default colors
GIBTi.rk.rs_colorbox,
GIBTi.rk.rs_color_tit_cllps,
--styles
GIBTi.rk.rs_bodystyle,
GIBTi.rk.rs_titlestyle,
GIBTi.rk.rs_headerstyle,
GIBTi.rk.rs_subheaderstyle,
GIBTi.rk.rs_imagestyle,
GIBTi.rk.rs_captionstyle,
GIBTi.rk.rs_labelstyle,
GIBTi.rk.rs_datastyle,
GIBTi.rk.rs_belowstyle,
--icon
GIBTi.rk.rs_icon,
GIBTi.rk.rs_icon_at_begin,
GIBTi.rk.rs_icon_hint,
GIBTi.rk.rs_def_name,
--image
GIBTi.rk.rs_image_max_num,
GIBTi.rk.rs_def_image_size,
GIBTi.rk.rs_send_img_preinfobox,
--referred to label/data content
GIBTi.rk.rs_changeable_lbls,
GIBTi.rk.rs_param_prefix_lbl,
GIBTi.rk.rs_def_charnum_cllps,
GIBTi.rk.rs_error,
GIBTi.rk.rs_below,
}
local cat = { --category keys
[GIBTi.rk.rs_cat_arg_dupli] = "_Q89919289",
[GIBTi.rk.rs_cat_arg_error] = "",
[GIBTi.rk.rs_cat_wds_untranslat] = "",
[GIBTi.rk.rs_cat_no_image] = "",
}
local cat_idx = { --index for category keys
GIBTi.rk.rs_cat_arg_error,
GIBTi.rk.rs_cat_arg_dupli,
GIBTi.rk.rs_cat_wds_untranslat,
GIBTi.rk.rs_cat_no_image,
}
local rs_icon_where = 'left' --icon position related to title
local function GetWhereIcon ()
rs_icon_where = ''
local LangIsRTL = false -- TODO: currently not provided
if ((not LangIsRTL) and p.rs[GIBTi.rk.rs_icon_at_begin]) or (LangIsRTL and (not p.rs[GIBTi.rk.rs_icon_at_begin])) then
rs_icon_where = 'left'
else
rs_icon_where = 'right'
end
return rs_icon_where
end --GetWhereIcon
p.rss = { --reserved keys from specific toolbox
}
-- (not index is required, thus are none or few items
local function IsQuali (ModuleName, key, s)
--returns if s is a Wikidata qualifier or property for WD. All qualifiers or properties must be as Qnnn or Pnnn.
local Is = string.sub (s, 1, 1) == '_'
if Is then
local Ch = string.sub (s, 2, 2)
if (string.len(s) < 3) or ((Ch ~= 'P') and (Ch ~= 'Q')) or (not tonumber(string.sub (s,3,3))) then --Checks only first number
error ('For the key "'..key..'" (from '..ModuleName..'), "'..string.sub (s,2)..'" is invalid qualifier or property for WD', 0)
end
end
return Is
end --IsQuali
local function LabelFromWD (s)
s = string.sub (s, 2)
return WD.getLabel({s,['lang']=MLMT.lang})
end
local function perhaps (key, wd, typ)
if rs_wd_t[key] == nil then
rs_wd_t[key] = {wd, MLMT.item_type_req_vals_prep(typ)}
end
end
local function SetDef (ModuleName, tab)
local function GetStyleBg (key, color)
if tab[key] == nil then
p.rs[key] = 'background-color:'..color..';'..p.rs[key]
else
if tab[key] ~= "" then
local val = CheckIsStr (ModuleName, tab[key], key)
p.rs[key] = val
end
end
perhaps (key, '', MLMT.IT.s)
end --GetStyleBg
local function GetStr (key, def)
local val
local wd
if (p.rs[key] ~= nil) and IsQuali (ModuleName, key, p.rs[key]) then
wd = p.rs[key]
p.rs[key] = LabelFromWD (p.rs[key])
perhaps (key, wd, MLMT.IT.s)
end
if tab[key] ~= nil then
if tab[key] ~= "" then
val = CheckIsStr (ModuleName, tab[key], key)
elseif p.rs[key] == "" then
val = def
end
end
if val ~= nil then
if IsQuali (ModuleName, key, val) then
wd = val
val = LabelFromWD (val)
else
wd = ''
end
p.rs[key] = val
perhaps (key, wd, MLMT.IT.s)
end
end --GetStr
local function GetColor (key, def)
if SA.HasValue(tab[key]) then
local s = CheckIsStr (ModuleName, tab[key], key)
if s ~= '' then
SA.CheckSIsColor (s, 1)
end
p.rs[key] = s
elseif (def ~= nil) and (not SA.HasValue(p.rs[key])) then
p.rs[key] = def
end
perhaps (key, p.rs[key], MLMT.IT.s)
end --GetColor
local function GetInt (key, Lims, def)
if tab[key] ~= nil then
p.rs[key] = CheckIsInt (ModuleName, tab[key], key, Lims[1], Lims[2])
elseif def ~= nil then
p.rs[key] = def
end
perhaps (key, '', {MLMT.IT.i,Lims})
end --GetInt
local function GetBool (key, def)
if tab[key] ~= nil then
p.rs[key] = CheckIsBool (ModuleName, tab[key], key)
elseif def ~= nil then
p.rs[key] = def
end
perhaps (key, '', MLMT.IT.b)
end --GetBool
--BEGIN--
--default colors
GetColor (GIBTi.rk.rs_colorbox)
GetColor (GIBTi.rk.rs_color_tit_cllps, p.rs[GIBTi.rk.rs_colorbox])
--styles
GetStr (GIBTi.rk.rs_bodystyle)
GetStyleBg (GIBTi.rk.rs_titlestyle, p.rs[GIBTi.rk.rs_colorbox])
GetStyleBg (GIBTi.rk.rs_headerstyle, p.rs[GIBTi.rk.rs_colorbox])
GetStyleBg (GIBTi.rk.rs_subheaderstyle, p.rs[GIBTi.rk.rs_color_tit_cllps])
GetStr (GIBTi.rk.rs_imagestyle)
GetStr (GIBTi.rk.rs_captionstyle)
GetStr (GIBTi.rk.rs_labelstyle)
GetStr (GIBTi.rk.rs_datastyle)
GetStr (GIBTi.rk.rs_belowstyle)
--icon
GetStr (GIBTi.rk.rs_icon)
GetBool (GIBTi.rk.rs_icon_at_begin)
GetStr (GIBTi.rk.rs_icon_hint)
GetStr (GIBTi.rk.rs_def_name)
--image
GetInt (GIBTi.rk.rs_image_max_num, {0,2})
GetStr (GIBTi.rk.rs_def_image_size)
GetBool (GIBTi.rk.rs_send_img_preinfobox)
--referred to label/data content
GetBool (GIBTi.rk.rs_changeable_lbls)
GetStr (GIBTi.rk.rs_param_prefix_lbl)
GetInt (GIBTi.rk.rs_def_charnum_cllps, {1,1000})
GetStr (GIBTi.rk.rs_error)
GetStr (GIBTi.rk.rs_below)
end --SetDef
local function SetRsv_ToArgs (ModuleName, frame, rs_main, rsi18n, cat_list, rss_main, rssi18n, tab_lims)
local function SetRsv (tab, key)
local function GetStr (key)
local val
local wd
if tab[key] ~= nil then
if tab[key] ~= "" then
val = CheckIsStr (ModuleName, tab[key], key)
end
end
if val ~= nil then
if IsQuali (ModuleName, key, val) then
wd = val
val = LabelFromWD (val)
else
wd = ''
end
p.rss[key] = val
perhaps (key, wd, MLMT.IT.s)
end
end --GetStr
local function GetInt (key, Lims)
if tab[key] ~= nil then
SA.CheckSIsInt (tab[key], key, Lims[1], Lims[2])
p.rss[key] = tab[key]
end
perhaps (key, '', {MLMT.IT.i,Lims})
end --GetInt
local function GetPosInt (key)
if tab[key] ~= nil then
SA.CheckSIsPosInt (tab[key], key)
end
perhaps (key, '', MLMT.IT.ipos)
end --GetPosInt
local function GetNum (key, Lims)
if tab[key] ~= nil then
SA.CheckSIsNum (tab[key], key, Lims[1], Lims[2])
p.rss[key] = tab[key]
end
perhaps (key, '', {MLMT.IT.i,Lims})
end --GetNum
local function GetBool (key)
if tab[key] ~= nil then
p.rss[key] = CheckIsBool (ModuleName, tab[key], key)
end
perhaps (key, '', MLMT.IT.b)
end --GetBool
local function Not_supported (key, typ)
error ('Parameter type ('..typ..') not allowed for key "'..key..'"')
end
--BEGIN--
local arg_type, params
arg_type, required, params = MLMT.split_item_type_req_vals2 (tab_lims, key)
if required then
error ('Required values for reserved keys are not available, for "'..key..'"')
end
if (arg_type == MLMT.IT.s) or (arg_type == MLMT.IT.d) then
GetStr (key)
elseif arg_type == MLMT.IT.i then
if params == nil then
GetInt (key)
else
GetInt (key, params[1], params[2])
end
elseif arg_type == MLMT.IT.ipos then
GetPosInt (key)
elseif arg_type == MLMT.IT.n then
if params == nil then
GetNum (key)
else
GetNum (key, params[1], params[2])
end
elseif arg_type == MLMT.IT.npos then
Not_supported (key, MLMT.IT.npos)
elseif arg_type == MLMT.IT.b then
GetBool (key)
elseif arg_type == MLMT.IT.sz then
Not_supported (key, MLMT.IT.sz)
elseif arg_type == MLMT.IT.a then
Not_supported (key, MLMT.IT.a)
end
end --SetRsv
-- rss_main, rssi18n, tab_lims are optionals,
-- tab lims can content limits for specific reserved keys
local function OkTable (tab, name)
if tab ~= nil then
if #tab > 0 then
error ('Not numeric parameters are allowed for '..name)
else
for key, val in pairs(tab) do
if type(val) == table then
error ('The value of the key "'..key..'" is a table, for '..name)
end
end
end
end
end --OkTable
local function SetCatInLang (key, val)
if not string.find (val, '<sup>') then
cat[key] = val
end
end --SetCatInLang
local function SetIniCat ()
local function GetCateg (key, val)
if cat[key] == nil then
error ('Unknown key name for tracking category ("'..key..'")')
elseif IsQuali (ModuleName, key, val) then
local wd = val
val = LabelFromWD (wd)
perhaps (key, wd, MLMT.IT.s)
end
SetCatInLang (key, val)
end --GetCateg
for key, val in pairs (cat) do
if IsQuali (ModuleName, key, val) then
local wd = val
val = LabelFromWD (wd)
perhaps (key, wd, MLMT.IT.s)
SetCatInLang (key, val)
end
end
if cat_list ~= nil then --only in demo cat_list == nil
for key, val in pairs (cat_list) do
GetCateg (key, val)
end
end
end --SetIniCat
--BEGIN--
OkTable (rs_main, 'rs table of '..MLMT.MN(ModuleName))
OkTable (rsi18n, 'rs_val table of '..MLMT.MNi18n(ModuleName))
OkTable (cat_list, 'cat table of '..MLMT.MN(ModuleName))
OkTable (rss_main, 'rss table of '..MLMT.MN(ModuleName))
OkTable (rssi18n, 'rss_val table of '..MLMT.MN(ModuleName))
SetDef (MLMT.MN(ModuleName), rs_main)
SetDef (MLMT.MNi18n(ModuleName), rsi18n)
if SA.HasValue (rsi18n[GIBTi.rk.rs_colorbox]) then
local function SetC (key)
p.rs[key] = p.rs[key]..';background-color:'..rsi18n[GIBTi.rk.rs_colorbox]
end
if not SA.HasValue (rsi18n[GIBTi.rk.rs_titlestyle]) then
SetC (GIBTi.rk.rs_titlestyle)
end
if not SA.HasValue (rsi18n[GIBTi.rk.rs_headerstyle]) then
SetC (GIBTi.rk.rs_headerstyle)
end
if not SA.HasValue (rsi18n[GIBTi.rk.rs_color_tit_cllps]) then
SetC (GIBTi.rk.rs_subheaderstyle)
end
end
local has_rss = (rss_main ~= nil) and (SA.TableSize(rss_main) > 0)
if has_rss then
for key, val in pairs(rss_main) do
if tab_lims[key] == nil then
p.rss[key] = val
else
SetRsv (rss_main, key)
end
end
end
local has_rssi18n = (rss_main ~= nil) and (SA.TableSize(rss_main) > 0)
if (not has_rss) and has_rssi18n then
error ('Undefined rss table in '..MLMT.MN(ModuleName)..', when rss is defined in '..MLMT.MNi18n(ModuleName), 0)
elseif has_rss and has_rssi18n then
for key, val in pairs(rssi18n) do
if p.rss[key] == nil then
error ('Unknown key ('..key..') in rss_val of '..MLMT.MN(ModuleName)..', key found in rss of '..MLMT.MNi18n(ModuleName), 0)
else
if tab_lims[key] == nil then
p.rss[key] = val
else
SetRsv (rssi18n, key)
end
end
end
end
SetIniCat ()
if p.rs[GIBTi.rk.rs_icon_hint] == '' then
p.rs[GIBTi.rk.rs_icon_hint] = frame:getParent():getTitle()
end
end --SetRsv_ToArgs
local function SplitRsFromNsArgs (args)
local new_args = {}
local new_config = {}
for key, val in pairs(args) do
if MLMT.IsReserv (key) then
new_config[key] = val
else
new_args[key] = val
end
end
return new_args, new_config
end --SplitRsFromNsArgs
function p.SetRsv_1ToArgs (ModuleName, frame, args, rs_main, rsi18n, cat_list, rss_main, rssi18n, tab_lims)
MLMT.ChkFunc ("SetRsv_1ToArgs", {{"ModuleName",ModuleName,"xr"},{"frame",frame,"tr"},
{"args",args,"tr"},{"rs_main",rs_main,"tr"},{"rsi18n",rsi18n,"tr"},{"cat_list",cat_list,"t"},
{"rss_main",rss_main,"t"},{"rssi18n",rssi18n,"t"},{"tab_lims",tab_lims,"t"},})
SetRsv_ToArgs (ModuleName, frame, rs_main, rsi18n, cat_list, rss_main, rssi18n, tab_lims)
-- when the config arguments are modified from a template
local new_args, new_config = SplitRsFromNsArgs (args)
SetDef ('Parameters', new_config)
return new_args
end --SetRsv_1ToArgs
function p.SetRsv_2ToArgs (ModuleName, frame, pargs, args, rs_main, rsi18n, cat_list, rss_main, rssi18n, tab_lims)
MLMT.ChkFunc ("SetRsv_2ToArgs", {{"ModuleName",ModuleName,"xr"},{"frame",frame,"tr"},
{"pargs",pargs,"tr"},{"args",args,"tr"},{"rs_main",rs_main,"tr"},{"rsi18n",rsi18n,"tr"},
{"cat_list",cat_list,"t"},{"rss_main",rss_main,"t"},{"rssi18n",rssi18n,"t"},
{"tab_lims",tab_lims,"t"},})
SetRsv_ToArgs (ModuleName, frame, rs_main, rsi18n, cat_list, rss_main, rssi18n, tab_lims)
-- when the config arguments are modified from a template
local new_args1, new_config1 = SplitRsFromNsArgs (pargs)
SetDef ('Template', new_config1)
local new_args2, new_config2 = SplitRsFromNsArgs (args)
SetDef ('Parameters', new_config2)
for key, val in pairs (new_args1) do
new_args2[key] = val
end
return new_args2
end --SetRsv_2ToArgs
p.id = nil
p.demo = false -- if true, the argument name is set.
local function isSet(var)
return not ((var == nil) or (var == ''))
end
local function Init0 (args)
-- Get identification and demo
p.id = args.item
if not isSet(p.id) then
p.id = mw.wikibase.getEntityIdForCurrentPage()
end
p.demo = SA.Bool_Par (args, MLMT.arg.demo)
end --Init0
----------------------------------------
function p.CollapsibleText (S, MaxLength)
MLMT.ChkFunc ("CollapsibleText", {{"S",S,"sr"},{"MaxLength",MaxLength,"ir"},})
local Collapsed = ''
if SD._plain_len(S) > MaxLength then
Collapsed = '<div class="NavFrame collapsed" style="border:none; padding: 0;">'
end
return
Collapsed..
'<div class="NavHead" style="width:100%; background:transparent" align="left">'..
'</div>'..
'<div class="NavContent" style="text-align:left;">'..S..'</div></div>'
end --CollapsibleText
local function _TitCollapsibleText (args)
local S = args[1]
local max_num = SA.PosInt_Par (args, 2, 40)
local expand = SA.Bool_Par (args, 'expand')
local framestyle = args['framestyle']
local titlestyle = args['titlestyle']
local titlecolor = args['titlecolor']
local title = args['title']
local liststyle = args['liststyle']
local listcolor = args['listcolor']
local res = ''
if S ~= nil then
if expand == nil then
expand = SD._plain_len(S) > max_num
end
res= '<div class="mw-collapsible '
if expand then
res = res..'mw-collapsed'
end
res = res..'" style="'
if framestyle ~= nil then
res = res..framestyle
else
res = res..'border:none; padding: 0;'
end
res = res.. '">'
res = res.. '<div style="'
if titlestyle ~= nil then
res = res..titlestyle
else
if titlecolor == nil then
titlecolor = 'transparent'
end
res = res..'width:100%; background:'..titlecolor..'" align="left'
end
res = res..'">'
if title ~= nil then
res = res..title
else
res = res..WD.getLabel ({'Q27948'})
end
res = res..'</div>'
res = res..'<div class="mw-collapsible-content" style="'
if liststyle ~= nil then
res = res..liststyle
else
if listcolor == nil then
listcolor = 'transparent'
end
res = res..'background:'..listcolor..';text-align:left;'
end
res = res..'">'..S..'</div></div>'
end
return res
end --_TitCollapsibleText
function p.TitCollapsibleText (frame)
args = SA.GetArgs (frame)
return _TitCollapsibleText (args)
end
local function ToRed (s)
return '<span style="color:red"><b>'..s..'</b></span>'
end
local function CheckByItemA (ModuleName, tab, name)
-- It checks a item table
for key, val in pairs(tab[MLMT.k.Args]) do
local function error_h ()
error ('Expected a string or string table (from '..MLMT.MNi18n(ModuleName)') in '..name..', for "'..key..'"', 0)
end
if type(val) == 'string' then
elseif type(val) == 'table' then
for _,s in ipairs(val) do
if type(s) ~= 'string' then
error_h ()
end
end
else
error_h ()
end
end
end --CheckByItemA
local function CheckByItem (ModuleName, name, tab, what, n)
-- It checks a item table
if tab[what] == nil then return end
ModuleName = ModuleName..name
for key, val in pairs(tab[what]) do
local function msg (s)
error ('Expected '..s..' as value for "'..key..'" for "'..what..'" in the table of '..MLMT.MN(ModuleName), 0) --Don't translate, for debug
end
if ((type(val) ~= 'table') and (n == 2)) or ((type(val) == 'table') and (#val < 2)) then
msg ('table (with 2 or more items)') --Don't translate, for debug
elseif n == 2 then
if (type(val[1]) ~= 'string') and (type(val[1]) ~= 'table') then
msg ('1st item of the table a string or table with strings')
elseif type(val[1]) == 'table' then
local isOk = true
for _, s in ipairs(val[1]) do
if type(s) ~= 'string' then
isOk = false
break
end
end
if not isOk then
msg ('the table of the 1st item of the table with non-string items')
end
end
if type(val[2]) == 'string' then
IsQuali (ModuleName, key, val[2])
end
elseif n == 1 then
if type(val) == 'string' then
IsQuali (ModuleName, key, val)
else
msg ('string')
end
end
end
end --CheckByItem
local ArgNames = {} -- it will contain all parameter names, to check duplicate names
local function AddNames (tab, is_main)
-- It adds each possible parameter name assigned to previous "ArgNames",
-- and if a name exists make an error message.
if tab == nil then return end
for key, val in pairs(tab) do
local names = val
if is_main then
names = val[1]
end
local function CheckSet (S)
if S == '' then return end
if ArgNames[S] == nil then
ArgNames[S] = key
elseif ArgNames[S] ~= key then
error ('Duplicate parameter name, thus "'..S..'" exists with the keys: "'..key..'" and "'..ArgNames[S]..'"', 0)
end
end
if type(names) == 'string' then
CheckSet (names)
else
for _, name in ipairs(names) do
CheckSet (name)
end
end
end
end --AddNames
function p.CheckArgLab (ModuleName, tab_main, tab_i18n, omit_params, preset_params)
-- It checks the standard tables ("tab_main", "tab_i18n"; and, in lua, custom new items)
-- It checks "omit_params" and "preset_params"
-- Also deletes the items according to the content of the table "omit_params"
MLMT.ChkFunc ("CheckArgLab", {{"ModuleName",ModuleName,"xr"},{"tab_main",tab_main,"tr"},
{"tab_i18n",tab_i18n,"tr"},{"omit_params",omit_params,"t"},{"preset_params",preset_params,"t"}})
CheckByItem (ModuleName, '', tab_main, MLMT.k.Args, 2)
CheckByItem (ModuleName, '', tab_main, MLMT.k.Labels, 1)
CheckByItemA (ModuleName, tab_i18n, 'i18n')
CheckByItem (ModuleName, '/i18n', tab_i18n, MLMT.k.Labels, 1)
if omit_params ~= nil then
for key, val in ipairs(omit_params) do
if tab_main[MLMT.k.Args][val] == nil then
error ('Not found "'..val..'" in omit_params from '..MLMT.MNi18n(ModuleName), 0)
else
tab_main[MLMT.k.Args][val] = nil
tab_i18n[MLMT.k.Args][val] = nil
if tab_main[MLMT.k.Labels] ~= nil then
tab_main[MLMT.k.Labels][val] = nil
end
if tab_i18n[MLMT.k.Labels] ~= nil then
tab_i18n[MLMT.k.Labels][val] = nil
end
end
end
end
AddNames (tab_main[MLMT.k.Args], true)
AddNames (tab_i18n[MLMT.k.Args], false)
if preset_params ~= nil then
for key, val in pairs(preset_params) do
if tab_main[MLMT.k.Args][key] == nil then
error ('Not found "'..key..'" in preset_params of '..MLMT.MNi18n(ModuleName), 0)
else
if type(val) ~= 'number' then
SD.vtos (val)
error ('Invalid value assignment for "'..key..'" in preset_params (of '..MLMT.MNi18n(ModuleName)'): '..SD.s, 0)
end
end
end
end
return tab_main, tab_i18n
end --CheckArgLab
function p.CheckArgLabLua (ModuleName, tab_main, tab_i18n, tab_i18n_new, omit_params, preset_params)
MLMT.ChkFunc ("CheckArgLabLua", {{"ModuleName",ModuleName,"xr"},{"tab_main",tab_main,"tr"},
{"tab_i18n",tab_i18n,"tr"},{"tab_i18n_new",tab_i18n_new,"t"},{"omit_params",omit_params,"t"},
{"preset_params",preset_params,"t"},})
local function CheckByItemNew (tab, what, n) --used by lua
if (tab == nil) or (tab[what] == nil) then return end
CheckByItem (ModuleName, '/i18n', tab, what, n)
for key, i in pairs(tab[what]) do
if tab_main[what][key] ~= nil then
error ('The new key "'..key..'" (from '..MLMT.MNi18n(ModuleName)..') already exists in '..MLMT.MN(ModuleName)..' and "'..what..'"', 0)
end
end
end --CheckByItemNew
tab_main, tab_i18n = p.CheckArgLab (ModuleName, tab_main, tab_i18n, omit_params, preset_params)
CheckByItemNew (tab_i18n_new, MLMT.k.Args, 2) --used by lua
CheckByItemNew (tab_i18n_new, MLMT.k.Labels, 1) --used by lua
if tab_i18n_new ~= nil then
AddNames (tab_i18n_new[MLMT.k.Args], true)
end
return tab_main, tab_i18n
end --CheckArgLabLua
p.arglab_t = {
'al',
'L',
'l',
'a',
'-',
'cl',
}
function p.CheckIdx_arglab (ModuleName, idx, omit_params, for_lua)
-- It checks index "idx" where each item must content a type and a key i.g. {'al',p.k.name}
-- Also deletes from "idx" the keys contained in "omit_params"
MLMT.ChkFunc ("CheckIdx_arglab", {{"ModuleName",ModuleName,"xr"},{"idx",idx,"tr"},
{"omit_params",omit_params,"t"},{"for_lua",for_lua,"b"},})
local s = #idx
local pos = 0
local prior_key = ''
for _, key in ipairs(idx) do
pos = pos + 1
if (type(key) ~= 'table') or (#key ~= 2) then
SD.vtos (idx)
SD.vtos (key)
error ('Expected index table in '..ModuleName..' with {type,key} in position '..pos..' (after "'..prior_key..'"). Now: '..SD.s, 0) --Don't translate, for debug
else
prior_key = key[2]
end
end
local pos = 0
local old_val = ""
for _, key in ipairs(idx) do
pos = pos + 1
old_val = key[2]
end
ModuleName = '(from '..ModuleName..')'
if pos ~= #idx then
error ('Index table '..ModuleName..' error in the key after key "'..old_val..'"', 0) --Don't translate, for debug
end
for _, key in ipairs(idx) do
local z = 1
if for_lua then
z = 0
end
local found = false
for i = 1, #p.arglab_t-z do
if key[1] == p.arglab_t[i] then
found = true
break
end
end
if not found then
local list = ''
for i = 1, #p.arglab_t-z do
list = list..'"'..p.arglab_t[i]..'", '
end
error ('In index table '..ModuleName..' : Invalid type for key "'..key[2]..'" ("'..key[1]..'"). Type must be a value of {'..list..'}', 0)
end
end
if omit_params ~= nil then
local idx2 = {}
for _, key2 in ipairs(idx) do
local found = false
for _, key in ipairs(omit_params) do
if key2[2] == key then
found = true
break
end
end
if not found then
table.insert (idx2, key2)
end
end
idx = idx2
end
return idx
end --CheckIdx_arglab
function p.CheckIdx_arglabLua (ModuleName, idx, new_idx)
-- It checks index "idx" where each item must content a type and a key i.g. {'al',p.k.name}
-- Also, it checks "new_idx" if exists, and then replace "idx".
MLMT.ChkFunc ("CheckIdx_arglabLua", {{"ModuleName",ModuleName,"xr"},{"idx",idx,"tr"},
{"new_idx",new_idx,"t"},})
p.CheckIdx_arglab (MLMT.MNi(ModuleName), idx, nil, true)
if new_idx == nil then
return idx
else
p.CheckIdx_arglab (MLMT.MNi18n(ModuleName), new_idx, nil, true)
return new_idx
end
end -- CheckIdx_arglabLua
----------------------------------------
--Functions for read (from argument) or load (from Wikidata) and write as label or data
----------------------------------------
local infotable_pos = 1 --pos or label or data. I.e. if N = 3 then assign values in label3 and data3
function p.GetInfotablePos()
return infotable_pos
end
----------------------------------------
-- DEMO FUNCTIONS --
----------------------------------------
local function ArgNameForDemo0 (tab, key)
res = tab[MLMT.k.Args][key]
if res == nil then
error ('Not set value in table for "'..key..'"')
else
local arg = res[1]
if type(arg) == 'table' then
arg = arg[1]
end
return res, arg
end
end --ArgNameForDemo0
local nopropcolor = 'maroon'
function p.ArgNameForDemo (tab, key)
MLMT.ChkFunc ("ArgNameForDemo", {{"tab",tab,"tr"},{"key",key,"k"},})
local res, arg = ArgNameForDemo0 (tab, key)
local color
if res[2] == '' then
color = nopropcolor
else
color = 'blue'
end
res = '<span style="color:'..color..'">'..arg..'</span>'
return res
end --ArgNameForDemo
-----------------------------------------
-- Image parameters and functions
-----------------------------------------
local i_items1 = {
[MLMT.k.Args] = {
[GIBTi.ik.image] = {{"image","Image"}, "_P18"},
[GIBTi.ik.image_idx] = {"image_idx", ""},
[GIBTi.ik.alt] = {"alt", ""},
[GIBTi.ik.size] = {{"size","width"}, ""},
[GIBTi.ik.caption] = {{"caption","Caption"}, "_P18,P2096"},
},
}
local i_items2 = {
[MLMT.k.Args] = {
[GIBTi.ik.image1] = {{"image","Image",
"image1","Image1",}, "_P18"},
[GIBTi.ik.image_idx1] = {"image_idx1", ""},
[GIBTi.ik.alt1] = {{"alt","alt1"}, ""},
[GIBTi.ik.size1] = {{"size","width",
"size1","width1"}, ""},
[GIBTi.ik.caption1] = {{"caption","Caption",
"caption1","Caption1"}, "_P18,P2096"},
[GIBTi.ik.image2] = {{"image2","Image2"}, ""},
[GIBTi.ik.image_idx2] = {"image_idx2", ""},
[GIBTi.ik.alt2] = {"alt2", ""},
[GIBTi.ik.size2] = {{"size2","width2"}, ""},
[GIBTi.ik.caption2] = {{"caption2","Caption2"}, ""},
},
}
p.i_itemsM = {}
local i_with2 = false
local i_has_capt = -1
function p.i_LoadI18n ()
if p.rs[GIBTi.rk.rs_image_max_num] == 1 then
CheckByItemA (ModuleName, GIBTi18n.i_items1, 'i_items1')
MLMT.CheckLims (ModuleName, GIBTi.i_arg_lims1, true)
p.i_itemsM = MLMT.tableMerge (ModuleName, i_items1, GIBTi18n.i_items1, true)
else
i_with2 = true
CheckByItemA (ModuleName, GIBTi18n.i_items2, 'i_items2')
MLMT.CheckLims (ModuleName, GIBTi.i_arg_lims2, true)
p.i_itemsM = MLMT.tableMerge (ModuleName, i_items2, GIBTi18n.i_items2, true)
end
MLMT.add_mod_used (ModuleAbbrev, ModuleName)
end --i_LoadI18n
local function i_arg_items (option)
if i_with2 then
for _, i in ipairs(GIBTi.i_idx2) do
i = i[2] --since only exists args
MLMT.add_arg_item (option, ModuleAbbrev, i, i_items2, GIBTi18n.i_items2, GIBTi.i_arg_lims2)
end
else
for _, i in ipairs(GIBTi.i_idx1) do
i = i[2] --since only exists args
MLMT.add_arg_item (option, ModuleAbbrev, i, i_items1, GIBTi18n.i_items1, GIBTi.i_arg_lims1)
end
end
end --i_arg_items
local function i_arglab_items ()
if i_with2 then
for _, i in ipairs(GIBTi.i_idx2) do
i = i[2] --since only exists args
p.add_arglab_item (ModuleAbbrev, i, i_items2, GIBTi18n.i_items2, GIBTi.i_arg_lims2)
end
else
for _, i in ipairs(GIBTi.i_idx1) do
i = i[2] --since only exists args
p.add_arglab_item (ModuleAbbrev, i, i_items1, GIBTi18n.i_items1, GIBTi.i_arg_lims1)
end
end
end --i_arglab_items
local i_tab = {}
local i_used_hand = 0 --number of used images entered manually
local i_used_WD = 0 --number of used images from WD
local i_caption = 0 --number of captions (to detect images without captions)
function p.i_main (frame, args)
MLMT.ChkFunc ("i_main", {{"frame",frame,"tr"},{"args",args,"tr"},})
local function clean_img (img)
local brd = string.find (img, '<span data')
if brd ~= nil then
img = string.sub (img, 1, brd-1)
end
return img
end
local imgWD
local captionWD = {'', ''}
local img_fromWD = {false, false}
local function readWD (ini_num)
local sep = '==='
imgWD = WD.claim ({
item=p.id,
property='P18',
qualifier='P2096',
lang=MLMT.lang,
formatting = 'table',
list='true',
separator = sep,
rowformat='$0<br/>$1',
editicon='false',
})
if imgWD ~= nil then
imgWD = mw.text.split(imgWD, sep)
imgWD[#imgWD] = clean_img(imgWD[#imgWD])
for i = 1, #imgWD do
local j = imgWD[i]
local p = string.find (j, '<br/>')
imgWD[i] = string.sub (j, 1, p-1)
img_fromWD[i] = true
captionWD[i] = mw.text.trim(string.sub (j, p+5))
end
end
end --readWD
local function fromWD (idx)
if imgWD == nil then
return nil, ''
else
if idx > #imgWD then
error ('invalid "image_idx", bigger than '..#imgWD)
else
return imgWD[idx], captionWD[idx]
end
end
end --fromWD
local pencil_added = false
local function pencil (i)
if img_fromWD[i] then
pencil_added = true
return ' <span data-bridge-edit-flow="overwrite">'
.. "[[File:Arbcom ru editing.svg|10px|baseline|"
.. mw.message.new('Editlink'):inLanguage(SA.lang_to_use):plain()
.. "|link=https://www.wikidata.org/wiki/" .. p.id .. "?uselang=" .. SA.lang_to_use .. "#P18]]"
.. "</span>"
else
return ''
end
end --pencil
local DIS = p.rs[GIBTi.rk.rs_def_image_size]
local hide = false
if i_with2 then
local img = {nil, nil}
local img_idx = {-1, -1}
local altfnd = {'', ''}
local size = {DIS, DIS}
local caption = {'', ''}
local first2 = 2
if p.demo then
for i = 1, 2 do
img[i] = p.ArgNameForDemo (p.i_itemsM, GIBTi.ik.image..i)
altfnd[i] = p.ArgNameForDemo (p.i_itemsM, GIBTi.ik.alt..i)
caption[i] = p.ArgNameForDemo (p.i_itemsM, GIBTi.ik.caption..i)
end
else
local read_wd_req = false
for i = 1, 2 do
img[i] = SA.Str_Par (args, p.i_itemsM[MLMT.k.Args][GIBTi.ik.image..i][1])
if img[i] == SA.None then
if i == 1 then
hide = true
break
end
else
img_idx[i] = SA.Int_Par (args, p.i_itemsM[MLMT.k.Args][GIBTi.ik.image_idx..i][1], -1)
if (img[i] == nil) and (img_idx[i] ~= 0) then
read_wd_req = true
end
altfnd[i] = SA.Str_Par (args, p.i_itemsM[MLMT.k.Args][GIBTi.ik.alt..i][1], '')
size[i] = SA.Str_Par (args, p.i_itemsM[MLMT.k.Args][GIBTi.ik.size..i][1], size[i])
caption[i] = SA.Str_Par (args, p.i_itemsM[MLMT.k.Args][GIBTi.ik.caption..i][1], '')
end
end
if read_wd_req and (not hide) then
readWD ()
if img[1] ~= nil then
first2 = 1
end
end
end
if not hide then
local img1 = img[1]
local caption1 = caption[1]
local same_img = false
for i = 1, 2 do
if img[i] ~= nil then
if img[i] ~= SA.None then
img[i] = II.InfoboxImage ({args={["image"]=img[i], ["size"]=size[i], ["alt"]=altfnd[i]}})
i_used_hand = i_used_hand + 1
end
elseif imgWD ~= nil then
if (((i == 1) and (imgWD[1] ~= nil)) or ((i == 2) and (imgWD[first2] ~= nil))) and (img_idx[i] ~= 0) then
local imgX, captX
local ii = img_idx[i]
if img_idx[i] == -1 then
if i == 2 then
ii = first2
else
ii = i
end
end
imgX, captX = fromWD (ii)
same_img = imgX == img1
if (i == 2) and (
(same_img and (captX == '')) or
-- two images are equals and not legend in WD
((img1 ~= '') and (caption1 ~= '') and (img_idx[2] < 1) and (captX == ''))
-- the infobox has been edited manually adding one image with complete information, but new image don't has caption
)
then
-- WD image is not used -> not second image is added
else
img[i] = imgX
if img[i] ~= nil then
img[i] = '[[File:'..img[i]..'|'..size[i]..'px|alt='..altfnd[i]..']]'
i_used_WD = i_used_WD + 1
end
if captX ~= '' then
caption[i] = captX
end
end
end
end
end
if same_img and (caption[1] == '') and (caption[2] ~= '') then --exists a explanation in second same img, usually from WD
img[2] = nil
caption[1] = caption[2]
elseif (caption[1] == '') and (caption[2] ~= '') then
local img2 = img[2]
local caption2 = caption[2]
img[2] = img[1]
caption[2] = caption[1]
img[1] = img2
caption[1] = caption2
end
for i = 2, 1, -1 do
if img[i] ~= nil then
pencil_added = false
if caption[i] == '' then
img[i] = img[i]..pencil (i)
i_has_capt = -1
elseif caption[i] ~= nil then
caption[i] = caption[i]..pencil (i)
i_has_capt = i
i_caption = i_caption + 1
end
if pencil_added then
break
end
end
end
for i = 1, 2 do
if img[i] == nil then
break
else
i_tab["image"..i] = img[i]
if caption[i] ~= nil then
i_tab["caption"..i] = caption[i]
end
end
end
end
else
local img = nil
local img_idx = -1
local altfnd = ''
local size = DIS
local caption = ''
if p.demo then
img = p.ArgNameForDemo (p.i_itemsM, GIBTi.ik.image)
altfnd = p.ArgNameForDemo (p.i_itemsM, GIBTi.ik.alt)
caption = p.ArgNameForDemo (p.i_itemsM, GIBTi.ik.caption)
else
img = SA.Str_Par (args, p.i_itemsM[MLMT.k.Args][GIBTi.ik.image][1])
if img == SA.None then
hide = true
else
img_idx = SA.Int_Par (args, p.i_itemsM[MLMT.k.Args][GIBTi.ik.image_idx][1]) or -1
if p.i_itemsM[MLMT.k.Args][GIBTi.ik.alt] ~= nil then
altfnd = SA.Str_Par (args, p.i_itemsM[MLMT.k.Args][GIBTi.ik.alt][1]) or ''
end
size = SA.Str_Par (args, p.i_itemsM[MLMT.k.Args][GIBTi.ik.size][1], size)
end
end
if not hide then
if img ~= nil then
if not p.demo then
altfnd = SA.Str_Par (args, p.i_itemsM[MLMT.k.Args][GIBTi.ik.alt][1], '')
caption = SA.Str_Par (args, p.i_itemsM[MLMT.k.Args][GIBTi.ik.caption][1])
end
img = II.InfoboxImage ({args={["image"]=img, ["size"]=size, ["alt"]=altfnd}})
i_used_hand = i_used_hand + 1
else
local captX
if img_idx == -1 then
readWD ()
if imgWD ~= nil then
img, captX = fromWD (1)
end
elseif img_idx > 0 then
readWD ()
if imgWD ~= nil then
img, captX = fromWD (img_idx)
end
end
if img ~= nil then
img = '[[File:'..img..'|'..size..'px|alt='..altfnd..']]'
i_used_WD = i_used_WD + 1
if (caption == nil) and (captX == '') then
img = img..pencil (1)
elseif SA.HasValue (caption) then
caption = caption..pencil (1)
i_caption = 1
elseif captX ~= '' then
caption = captX..pencil (1)
i_caption = 1
end
end
end
if img ~= nil then
if SA.HasValue (caption) then
i_has_capt = 0
i_tab["caption"] = caption
else
img = img..pencil (1)
end
i_tab["image"] = img
end
end
end
for k, v in pairs (i_tab) do --used in only-lua infoboxes
p.tab[k] = v
end
return i_has_capt
end --i_main
----------------------------------------
-- LIST (& TemplateData) FUNCTIONS --
----------------------------------------
local function add_arglab_item (mod_abbrev, key, wd_lang_l, lnk, wd_main_a, wd_lang_a, prop, item_type_req)
MLMT.add_mod_used_in_class (mod_abbrev)
local row = ''
row = MLMT.add_pos (row)
--labels
row = row..'<td>'..MLMT.PerhapsDsplKeyMode(key)..'</td>'
row = MLMT.append_mod_item (mod_abbrev, row)
if lnk ~= '' then
local lnk1 = lnk
if string.sub (lnk,1,1) == 'P' then
lnk1 = 'Property:'..lnk1
end
row = row..'<td>[[:wikidata:'..lnk1..'|'..lnk..']]</td><td>'..WD.getLabel({lnk, ['lang']=MLMT.lang})..'</td>'
else
row = row..'<td></td><td></td>'
end
row = row..'<td>'..wd_lang_l..'</td>'
--arguments
local item_type, required, values = MLMT.split_item_type_req_vals_forList (item_type_req)
local function concat_wd (A)
if type(A) == 'table' then
for i, j in pairs(A) do
if type(j) == 'table' then
SD.vtos (j)
error ('Error in table design and key = "'..key..'":'..SD.s..' must be a string') --for debug
end
end
A = table.concat (A, ', ')
end
if A == nil then
error ('Not set variable for key = "'..key..'"') --for debug
end
return A
end
wd_main_a = concat_wd(wd_main_a)
wd_lang_a = concat_wd(wd_lang_a)
row = row..'<td>'..wd_main_a..'</td><td>'..wd_lang_a..'</td>'
if SA.HasValue (prop) then
if prop == true then
row = row..'<td>true</td><td></td>'
elseif prop == false then
row = row..'<td>false</td><td></td>'
elseif type(prop) == 'table' then
local props = prop["property"]
if props == nil then
--Prop contains a pattern to format a manual value
row = row..'<td></td><td></td>'
else
local sep = ''
if string.find(props, ' OR ') then
sep = ' OR '
props = mw.text.split (props,sep)
sep = '<small>'..sep..'</small>'
elseif string.find(props, '/') then
sep = '/'
props = mw.text.split (props,sep)
end
if type(props) == 'table' then
local trans = {}
for k, w in ipairs(props) do
props[k] = '[[:wikidata:Property:'..w..'|'..w..']]'
local wd = WD.getLabel({w, ['lang']=MLMT.lang})
if wd ~= nil then
table.insert (trans, wd)
end
end
row = row..'<td><span style="font-size:50%">WD </span>'..table.concat(props,sep)..'</td><td>'..table.concat(trans,', ')..'</td>'
else
local wd = WD.getLabel({props, ['lang']=MLMT.lang})
row = row..'<td><span style="font-size:50%">WD </span>'..props..'</td><td>'..wd..'</td>'
end
end
elseif string.sub (prop,1,1) == '_' then
local props = mw.text.split(string.sub (prop,2), '-')
local trans = {}
for k, w in ipairs(props) do
if string.sub (w,1,1) == 'Q' then
props[k] = '[[:wikidata:'..w..'|'..w..']]'
else
props[k] = '[[:wikidata:Property:'..w..'|'..w..']]'
end
local wd = WD.getLabel({w, ['lang']=MLMT.lang})
if wd ~= nil then
table.insert (trans, wd)
end
end
row = row..'<td><span style="font-size:50%">WD </span>'..table.concat(props,',')..'</td><td>'..table.concat(trans,', ')..'</td>'
elseif string.sub (prop,1,5) == 'Color:' then
local color = string.sub (prop,6)
row = row..'<td><span style="background-color:'..color..'">'..color..'</span></td><td></td>'
else
row = row..'<td>'..prop..'</td><td></td>'
end
else
row = row..'<td></td><td></td>'
end
if wd_main_a == '' then
item_type = ''
elseif item_type == nil then
item_type = 's'
end
MLMT.add_arg_types_used (item_type)
item_type = MLMT.IT_required_vals (item_type, required, values)
MLMT.ins_tab_row (row..'<td>'..item_type..'</td>')
end --add_arglab_item
local function blank (val)
if val == nil then
return ''
else
return val
end
end --blank
function p.add_arglab_item (mod_abbrev, key, tab_main, tab_lang, lims)
MLMT.ChkFunc ("add_arglab_item", {{"mod_abbrev",mod_abbrev,"xr"},{"key",key,"k"},
{"tab_main",tab_main,"tr"},{"tab_lang",tab_lang,"tr"},{"lims",lims,"t"},})
local wd_main_l, wd_lang_l, lnk
if tab_main[MLMT.k.Labels] == nil then --only exists arguments
lnk = ''
wd_lang_l = ''
else
wd_main_l = tab_main[MLMT.k.Labels][key]
if wd_main_l == nil then
lnk = ''
else
wd_main_l, lnk = MLMT.GetLabelL2 (wd_main_l, key)
end
wd_lang_l = blank (tab_lang[MLMT.k.Labels][key])
end
local wd_main_a = tab_main[MLMT.k.Args][key]
local prop = nil
local item_type_req = ''
if wd_main_a == nil then
wd_main_a = ''
else
prop = wd_main_a[2]
item_type_req = MLMT.GetITRFromLims (lims, key)
wd_main_a = wd_main_a[1]
end
wd_lang_a = tab_lang[MLMT.k.Args][key]
if wd_lang_a == nil then
wd_lang_a = ''
end
add_arglab_item (mod_abbrev, key, wd_lang_l, lnk, wd_main_a, wd_lang_a, prop, item_type_req)
end --add_arglab_item
function p.add_arglab_item_grp (mod_abbrev, grp, key, tab_main, tab_lang, lims)
MLMT.ChkFunc ("add_arglab_item_grp", {{"mod_abbrev",mod_abbrev,"xr"},{"grp",grp,"xr"},{"key",key,"k"},
{"tab_main",tab_main,"tr"},{"tab_lang",tab_lang,"tr"},{"lims",lims,"t"},})
local wd_main_l, wd_lang_l, lnk
if (tab_main[MLMT.k.Labels] == nil) or (tab_main[MLMT.k.Labels][grp] == nil) then --only exists arguments
wd_main_l = ''
lnk = ''
else
wd_main_l = tab_main[MLMT.k.Labels][grp][key]
if wd_main_l == nil then
lnk = ''
else
wd_main_l, lnk = MLMT.GetLabelL2 (wd_main_l, key)
end
wd_lang_l = blank (tab_lang[MLMT.k.Labels][grp][key])
end
local wd_main_a = tab_main[MLMT.k.Args][grp][key]
local prop = nil
local item_type_req = ''
if wd_main_a == nil then
wd_main_a = ''
else
item_type_req = MLMT.GetITRFromLimsGr (lims, grp, key)
prop = wd_main_a[2]
wd_main_a = wd_main_a[1]
end
wd_lang_a = tab_lang[MLMT.k.Args][grp][key]
if wd_lang_a == nil then
wd_lang_a = ''
end
add_arglab_item (mod_abbrev, grMLMT..'.'..key, wd_lang_l, lnk, wd_main_a, wd_lang_a, prop, item_type_req)
end --add_arglab_item_grp
local function show_arglab_items (idx, func, tab_modname_func)
local row = ''
local pos = 1
table.insert (MLMT.tab_items, '<table class="wikitable sortable">')
MLMT.ins_tab_row ('<th>P.</th><th>Key</th><th>Value</th><th>WD</th><th>T.</th>')
local wd = ''
local typ = ''
local function wd_type (i)
if rs_wd_t[i] ~= nil then
wd = rs_wd_t[i][1]
typ = rs_wd_t[i][2]
if string.sub (wd,1,1) == '_' then
wd = string.sub (wd,2)
if string.sub (wd,1,1) == 'Q' then
wd = '[[:wikidata:'..wd..'|'..wd..']]'
else
wd = '[[:wikidata:Property:'..wd..'|'..wd..']]'
end
end
else
wd = ''
typ = MLMT.IT.s
end
return wd, typ
end --wd_type
for _, key in ipairs (rs_idx) do
wd, typ = wd_type (key)
row = '<td>'..pos..'</td><td>'..key..'</td><td>'..tostring(p.rs[key])..'</td><td>'..wd..'</td><td>'..typ..'</td>'
MLMT.ins_tab_row (row)
pos = pos + 1
end
for _, key in ipairs (cat_idx) do
if cat[key] ~= nil then
wd = wd_type (key)
row = '<td>'..pos..'</td><td>'..key..'</td><td>'..cat[key]..'</td><td>'..wd..'</td><td>s</td>'
MLMT.ins_tab_row (row)
pos = pos + 1
end
end
for key, val in pairs (p.rss) do
wd, typ = wd_type (key)
row = '<td>'..pos..'</td><td>'..key..'</td><td>'..tostring(val)..'</td><td>'..wd..'</td><td>'..typ..'</td>'
MLMT.ins_tab_row (row)
pos = pos + 1
end
table.insert (MLMT.tab_items, '</table>')
table.insert (MLMT.tab_items, '<table class="wikitable sortable">')
row = ''
--begin & labels
row = MLMT.begin_headers()..row
row = row.. '<th>WD</th><th>WD content ('..SA.lang_to_use..')</th>'..
'<th>Localization (i18n)</th>'
--arguments
row = row.. '<th>Default names</th><th>Localized names (i18n)</th>'..
'<th>Values</th><th>WD content ('..SA.lang_to_use..')</th>'..
'<th>T.</th>'
local row0 = ''
if #MLMT.mod_used > 1 then
row0 = row0..'<th></th>'
end
row0 = row0..'<th></th>'
MLMT.ins_tab_row (row0..'<th></th><th colspan="3">Labels</th><th colspan="5">Arguments</th>')
MLMT.ins_tab_row (row)
MLMT.CheckIdx (idx)
if idx[SA.HasChild] == nil then
for _, key in ipairs(idx) do
if key[1] == '-' then
key = key[2]
for _, j in ipairs (tab_modname_func) do
if (j[1] == "") or (j[1] == key) then
j[2](key)
break
end
end
else
local mod_abbrev, key, tab_main, tab_lang, lims = func (key[2])
p.add_arglab_item (mod_abbrev, key, tab_main, tab_lang, lims)
end
end
else
for _, grp in ipairs(idx[SA.HasChild]) do
for _, key in ipairs(idx[grp]) do
if key[1] == '-' then
key = key[2]
for _, j in ipairs (tab_modname_func) do
if (j[1] == "") or (j[1] == key) then
j[2](grp, key)
break
end
end
else
local mod_abbrev, key, tab_main, tab_lang, lims = func (grp, key[2])
p.add_arglab_item_grp (mod_abbrev, grp, key, tab_main, tab_lang, lims)
end
end
end
end
return MLMT.foot_for_args ()
end --show_arglab_items
function p.CheckFuncs (funcs)
--Checks function local_func of i18n
local local_func_name = '"function local_func"'
if funcs == nil then
elseif type(funcs) ~= 'table' then
error (local_func_name..' must return a table, perhaps you are deleted "vals = {}" or "return vals"') --don't translate
else
for h, i in ipairs(funcs) do
if (type(i) ~= 'table') or (#i ~= 2) then
error ('The item '..h..' returned from '..local_func_name..' is not a table with two items: the target parameter and its value') --don't translate
elseif i[1] == nil then
error ('The item '..h..' returned from '..local_func_name..' has not a valid target param, check its name') --don't translate
end
end
end
end -- CheckFuncs
----------------------------------------
-- SHARED PREINFOBOX AND ONLY-LUA INFOBOX
----------------------------------------
function p.SetColorsAndIcon (ModuleName, color_gr, icon_key)
MLMT.ChkFunc ("SetColorsAndIcon", {{"ModuleName",ModuleName,"xr"},{"color_gr",color_gr,"xr"},{"icon_key",icon_key,"x"},})
--Set values to usual reserved variables: colors and icon
p.rs[GIBTi.rk.rs_colorbox] = p._GetInfoboxColor (CheckIsStr(ModuleName,color_gr,GIBTi.rk.rs_colorbox), 1)
p.rs[GIBTi.rk.rs_color_tit_cllps] = p._GetInfoboxColor (color_gr, 2)
if icon_key ~= nil then -- only in demos icon_key == nil (not used)
p.rs[GIBTi.rk.rs_icon] = p._GetIcon (CheckIsStr(ModuleName,icon_key,GIBTi.rk.rs_icon))
end
end --SetColorsAndIcon
function p.CheckLims (ModuleName, tab)
MLMT.ChkFunc ("CheckLims", {{"ModuleName",ModuleName,"xr"},{"tab",tab,"tr"},})
MLMT.CheckLims0 (ModuleName, tab)
end
function p.Checki18nLims (ModuleName, tab)
MLMT.ChkFunc ("CheckLims", {{"ModuleName",ModuleName,"xr"},{"tab",tab,"tr"},})
MLMT.CheckLims0 (ModuleName..'/i18n', tab)
end
local OtherArgs = {'lang','item','name','demo','proof_params'}
--Uses ruby for infobox labels
p.w_hint_txt = true
--Suffix for hint text, using ruby, at end of the argument name.
p.arg_suffix_equal = '=...'
local function Arg1NameOfKey (tab, key, with_error)
local ArgOrArgs = tab[MLMT.k.Args][key]
if (ArgOrArgs == nil) and with_error then
error ('Not found parameter name/s for "'..key..'"')
elseif ArgOrArgs == nil then
else
ArgOrArgs = ArgOrArgs[1]
if type(ArgOrArgs) == 'table' then
ArgOrArgs = ArgOrArgs[1]
end
return ArgOrArgs
end
end --Arg1NameOfKey
function p.label_of_key_w_hint_txt (args, tab, key, lab_no_ruby)
--A text label with its key (with "lbl_"). The text label contains a hint text if its key is not in table of "lab_no_ruby".
--The text label is a preset label or a customized label for an article using "l_" as prefix for argument.
MLMT.ChkFunc ("label_of_key_w_hint_txt", {{"args",args,"tr"},{"tab",tab,"tr"},{"key",key,"k"},
{"lab_no_ruby",lab_no_ruby,"t"},})
local k = tab[MLMT.k.Args][key]
local z
if k ~= nil then
if type (k[1]) == 'table' then
local tab2 = {}
for _, j in ipairs(k[1]) do
z = p.rs[GIBTi.rk.rs_param_prefix_lbl]..j
table.insert (tab2, z)
table.insert (OtherArgs, z)
end
k = tab2
else
k = p.rs[GIBTi.rk.rs_param_prefix_lbl]..k[1]
table.insert (OtherArgs, k)
end
k = SA.Str_Par (args, k)
else
z = p.rs[GIBTi.rk.rs_param_prefix_lbl]..key
table.insert (OtherArgs, z)
k = SA.Str_Par (args, z)
end
if k == nil then
local l = MLMT.GetLabel (tab, key)
if (l ~= nil) and string.find (l, 'File:') then
return l
elseif p.w_hint_txt then
local ruby = true
if lab_no_ruby ~= nil then
for _, i in ipairs (lab_no_ruby) do
if i == key then
ruby = false
break
end
end
end
if ruby then
local lnk_arg_name = Arg1NameOfKey (tab,key,false)
local param_n = ''
if lnk_arg_name == nil then
param_n = p.rs[GIBTi.rk.rs_param_prefix_lbl]..key..'='..l
else
param_n = p.rs[GIBTi.rk.rs_param_prefix_lbl]..lnk_arg_name..'='..l..' '..lnk_arg_name..p.arg_suffix_equal
end
return '<ruby title="'..param_n..'">'..l..'</ruby>'
else
return l
end
else
return l
end
else
return k
end
end --label_of_key_w_hint_txt
function p.label_of_key_w_hint_txts (args, tab, key, keys)
MLMT.ChkFunc ("label_of_key_w_hint_txts", {{"args",args,"tr"},{"tab",tab,"tr"},
{"key",key,"k"},{"keys",keys,"ar"}})
local custom_lab_name = p.rs[GIBTi.rk.rs_param_prefix_lbl]..key
table.insert (OtherArgs, custom_lab_name)
local custom_lab = SA.Str_Par (args, custom_lab_name)
if custom_lab == nil then
local l = MLMT.GetLabel (tab, key)
if type (keys) == 'table' then
for i, j in ipairs(keys) do
keys[i] = Arg1NameOfKey (tab,j,true)..p.arg_suffix_equal
end
keys = table.concat (keys, ', ')
else
keys = Arg1NameOfKey (tab,keys,true)..p.arg_suffix_equal
end
return '<ruby title="'..custom_lab_name..'='..l..' '..keys..'">'..l..'</ruby>'
else
return custom_lab
end
end --label_of_key_w_hint_txts
p.images = 'images' -- also used as index item
function p.ItemList_or_TempData (args,
ModuleAbbrev, -- Abbreviation for ModuleName
ModuleName, -- Main module name
tab_main, -- parameter and label table (i18n) from main module
tab_lang, -- parameter and label table (i18n) from main module/i18n
idx, -- item index table
lims, -- restriction table for a main module parameters
other_arglab, other_arg, other_lab -- optional tables (to hook parameters and/or labels from other shared modules)
-- with 1 {{name,function}} or 2 items {{name1,function1},{name2,function2}}
)
-- Returns
-- * item list or TemplateData code according to |list=p.UsualListOpt, or
-- * nothing, if |list= is not set
MLMT.ChkFunc ("ItemList_or_TempData", {{"args",args,"tr"},{"ModuleAbbrev",ModuleAbbrev,"xr"},
{"ModuleName",ModuleName,"xr"},{"tab_main",tab_main,"tr"},{"tab_lang",tab_lang,"tr"},
{"idx", idx,"tr"},{"lims",lims,"t"},
{"other_arglab",other_arglab,"t"},{"other_arg",other_arg,"t"},{"other_lab",other_lab,"t"},})
local function Check (tab, what)
--Checks that other_arglab and other_arg are correct
--Don't translate the messages, are for debug
for _, j in ipairs(tab) do
if type(j) == 'table' then
local function typer_error (w_type)
error ('The item n. '..i..' of '..what..' must be a '..w_type)
end
if type(j[1]) ~= 'string' then
typer_error ('string')
end
if type(j[2]) ~= 'function' then
typer_error ('function')
end
else
SD.vtos (tab)
SD.vtos (j)
error ('In "'..what..'", '..SD.s..' must be a table')
end
end
end --Check
local function arg_label_from_key (key)
return ModuleAbbrev, key, tab_main, tab_lang, lims
end
local function label_from_key (key)
return MLMT.GetLabelX (ModuleAbbrev, key, tab_main, tab_lang)
end
local function f_arg_names_types_from_keys (key)
return ModuleAbbrev, tab_main, tab_lang, lims
end
local function ArgImg (option)
return i_arg_items (option)
end
local option = MLMT.all_items_opt (args, p.UsualListOpt)
local res = nil
if option ~= nil then
MLMT.add_mod_used (ModuleAbbrev, ModuleName)
if option == MLMT.LOpt.list then
local tabs = {{p.images, i_arglab_items}}
if other_arglab ~= nil then
Check (other_arglab, 'other_arglab')
for _, tab in ipairs (other_arglab) do
table.insert (tabs, tab)
end
end
res = show_arglab_items (idx, arg_label_from_key, tabs)
elseif (option == MLMT.LOpt.params) or (option == MLMT.LOpt.template) then
local tabs = {{p.images, ArgImg}}
if other_arg ~= nil then
Check (other_arg, 'other_arg')
for _, tab in ipairs (other_arg) do
table.insert (tabs, tab)
end
end
res = MLMT.show_arg_items (option, idx, f_arg_names_types_from_keys, tabs)
elseif option == MLMT.LOpt.labels then
if other_lab == nil then
res = MLMT.show_lab_items (idx, label_from_key)
else
Check (other_lab, 'other_lab')
res = MLMT.show_lab_items (idx, label_from_key, other_lab)
end
end
end
return res
end --ItemList_or_TempData
----------------------------------------
-- LUA-INFOBOX FUNCTIONS --
----------------------------------------
p.tab = {}
--each item contains, e.g. ['name_1'] = {2, 'data for name 1'}.
-- where 2 is the position in infobox.data2 = 'data for name 1'
local values = {}
--ordered according to items displayed in infobox, each item contains e.g.
-- {'name_1', ''} for a normal item and
-- {'header_1', 'h'} for a header
local keys = {}
local untrans_arg = false
local BeginLangStr = ''
local function DoneLang ()
if MLMT.LangsDifWriteDirect () then
return '</div>'
else
return ''
end
end --DoneLang
function p.IniLua (args, tab)
MLMT.ChkFunc ("IniLua", {{"args",args,"tr"},{"tab",tab,"tr"},})
if MLMT.LangsDifWriteDirect () then
BeginLangStr = '<div lang="'..MLMT.lang..'" dir="'..MLMT.WriteDirect()..'">'
end
Init0 (args)
---
p.tab["bodystyle"] = p.rs[GIBTi.rk.rs_bodystyle]
p.tab["titlestyle"] = p.rs[GIBTi.rk.rs_titlestyle]
p.tab["headerstyle"] = p.rs[GIBTi.rk.rs_headerstyle]
p.tab["subheaderstyle"] = p.rs[GIBTi.rk.rs_subheaderstyle]
p.tab["imagestyle"] = p.rs[GIBTi.rk.rs_imagestyle]
p.tab["captionstyle"] = p.rs[GIBTi.rk.rs_captionstyle]
p.tab["labelstyle"] = p.rs[GIBTi.rk.rs_labelstyle]
p.tab["datastyle"] = p.rs[GIBTi.rk.rs_datastyle]
p.tab["belowstyle"] = p.rs[GIBTi.rk.rs_belowstyle]
local Name = SA.Str_Par (args, tab[MLMT.k.Args][GIBTi.rk.name][1])
if not isSet(Name) then
if isSet(p.id) then
Name = WD.getLabel({p.id,['lang']=MLMT.lang})
end
if not isSet(Name) then
Name = p.rs[GIBTi.rk.rs_def_name]
end
end
if (p.rs[GIBTi.rk.rs_icon] == '') or (p.rs[GIBTi.rk.rs_icon] == SA.None) then
p.tab["title"] = Name
else
p.tab["title"] = '<span style="float:'..GetWhereIcon()..';margin:1.5px">[[File:'..p.rs[GIBTi.rk.rs_icon]..'|'..p.rs[GIBTi.rk.rs_icon_hint]..'|22px]]</span>'..Name
end
end --IniLua
function p.AddLocalAdminItems (tab_main, tab_i18n_new)
MLMT.ChkFunc ("AddLocalAdminItems", {{"tab_main",tab_main,"tr"},{"tab_i18n_new",tab_i18n_new,"tr"},})
local function Add (what)
for key, i in pairs(tab_i18n_new[what]) do
tab_main[what][key] = i
end
end --Add
Add (MLMT.k.Args)
Add (MLMT.k.Labels)
return tab_main
end --AddLocalAdminItems
function p.CheckAddLocalAdminLims (ModuleName, main, new)
MLMT.ChkFunc ("CheckAddLocalAdminLims", {{"ModuleName",ModuleName,"xr"},{"main",main,"tr"},
{"new",new,"t"},})
p.CheckLims (ModuleName, main)
if new ~= nil then
p.Checki18nLims (ModuleName, new)
for key, j in pairs(new) do
if main[key] ~= nil then
local i = main[key]
if (type (j) == 'table') and (j[1] == MLMT.IT.a) then
--sometimes the array limits are updated in i18n due to translation
if (type (i) == 'table') and (i[1] == MLMT.IT.a) then
else
error ('Incompatible parameter types for the key "'..j[1]..'" (probably the new limit in i18n)')
end
else
error ('The limit (probably the new limit in i18n) for the key "'..j[1]..'" already exists"')
end
end
main[key] = j
end
end
return main
end --CheckAddLocalAdminLims
function p.load_key (args, tab, key, lims, untrans_arg_list)
-- It read the preset values (in demo mode) or the values entered manually or read from WD, as appropriate.
-- and return the found or set value
MLMT.ChkFunc ("load_key", {{"args",args,"tr"},{"tab",tab,"tr"},{"key",key,"k"},{"lims",lims,"t"},
{"untrans_arg_list",untrans_arg_list,"t"},})
if tab[MLMT.k.Args][key] == nil then
error ('Not found "'..key..'" in "'..MLMT.k.Args..'"')
end
local Prop = tab[MLMT.k.Args][key][2]
local function GetValNoProp (val)
if Prop["formatting"] == nil then
error ('When a value is not called from WD but a second value is defined in a table, the "formatting" is required, in key "'..key..'"') --Don't translate, for debug
else
val, n = mw.ustring.gsub (Prop["formatting"], '$1', {['$1'] = val})
end
return val
end --GetValNoProp
local val, untranslated
if p.demo then
if (Prop ~= nil) and (type(Prop) == "table") and (Prop["property"] == nil) then
--Prop contains a pattern to format value
local res, arg = ArgNameForDemo0 (tab, key)
val = '<span style="color:'..nopropcolor..'">'..GetValNoProp (arg)..'</span>'
else
val = p.ArgNameForDemo (tab, key)
end
return val, true
else
if type(Prop) ~= "table" then
if string.sub (Prop,1,1) == '_' then
Prop = string.sub (Prop,2)
else
Prop = nil
end
end
local arg_type, required, params = MLMT.split_item_type_req_vals2 (lims, key)
local ParId = tab[MLMT.k.Args][key][1]
if (ParId == nil) or (ParId == '') then
-- the value is only read from WD and never manually
else
val = MLMT.ParamVal (args, ParId, arg_type, required, nil, params)
end
if val == SA.None then
val = nil
elseif (val == nil) and (Prop ~= nil) then
for i = 2, #tab[MLMT.k.Args][key] do
Prop = tab[MLMT.k.Args][key][i]
if type(Prop) == "table" then
Prop["item"] = p.id
Prop["lang"] = MLMT.lang
Prop["query"] = 'untranslated'
val, untranslated = WD.claim (Prop)
else
val, untranslated = WD.claim ({item=p.id, lang=MLMT.lang, property=Prop, query='untranslated'})
end
if val ~= nil then
local function found_in_list ()
for _, i in ipairs(untrans_arg_list) do
if i == key then
return true
end
end
return false
end
if untranslated and (untrans_arg_list ~= nil) and found_in_list() then
untrans_arg = true
end
break
end
end
elseif (val ~= nil) and (Prop ~= nil) then
if (Prop["formatting"] ~= nil) and (string.find(Prop["formatting"],'$2') == nil) and
(string.find(val,'<span') == nil) and (string.find(val,'%[') == nil)
then
val = string.gsub (Prop["formatting"], '$1', val)
elseif (type(Prop) == "table") and (Prop["property"] == nil) then
--Prop contains a pattern to format a manual value
val = GetValNoProp (val)
end
end
end
return val, val ~= nil
end --load_key
local function DataToStr (data)
if type(data) == 'number' then
return tostring (data)
elseif type(data) == 'string' then
return data
else
SD.vtos (data)
error ('Invalid data type to convert to string, found: '..SD.s)
end
end --DataToStr
local function SetData (key, val)
p.tab['data'..infotable_pos] = DataToStr (val)
end
local function GetLabelLua (args, tab, key)
if p.rs[GIBTi.rk.rs_changeable_lbls] then
return p.label_of_key_w_hint_txt (args, tab, key)
else
return MLMT.GetLabel (tab, key)
end
end --GetLabelLua
local function set_val (key, val)
values[key] = {infotable_pos, val}
table.insert (keys, {key,''})
infotable_pos = infotable_pos + 1
end --set_val
function p.show (args, tab, key, val)
-- It adds to the infobox the the label and/or value (from the value val) for a key
MLMT.ChkFunc ("show", {{"args",args,"tr"},{"tab",tab,"tr"},{"key",key,"k"},})
if val ~= nil then
p.tab['label'..infotable_pos] = GetLabelLua (args, tab, key)
SetData (key, val)
end
set_val (key, val)
return val ~= nil
end --show
local function show_direct (key, label, val)
p.tab['label'..infotable_pos] = label
SetData (key, val)
set_val (key, val)
end
function p.load_show_key (args, tab, key, lims, untrans_arg_list)
-- It adds to the infobox the the label and/or value for a key
-- taking the values, as appropriate, from:
-- the preset values (in demo mode) or entered manually or read from WD.
MLMT.ChkFunc ("load_show_key", {{"args",args,"tr"},{"tab",tab,"tr"},{"key",key,"k"},
{"lims",lims,"t"},{"untrans_arg_list",untrans_arg_list,"t"},})
local val = p.load_key (args, tab, key, lims, untrans_arg_list)
return p.show (args, tab, key, val)
end --load_show_key
local function AddTitCollapsibleText (args, tab, key, val, where, color)
local res =
p.TitCollapsibleText ({val, p.rs[GIBTi.rk.rs_def_charnum_cllps],
title = " <b>"..GetLabelLua (args,tab,key).."</b>",
titlecolor = color,})
p.tab['data'..where] = res
infotable_pos = infotable_pos + 1
end --AddTitCollapsibleText
function p.AddTitCollapsibleText (args, tab, key, val)
-- It adds a subheader with collapsible text
if val ~= nil then
MLMT.ChkFunc ("AddTitCollapsibleText", {{"args",args,"tr"},{"tab",tab,"tr"},{"key",key,"k"},
{"val",val,"ar"},})
val = DataToStr (val)
AddTitCollapsibleText (args, tab, key, val, infotable_pos, p.rs[GIBTi.rk.rs_color_tit_cllps])
end
set_val (key, val)
return val ~= nil
end --AddTitCollapsibleText
function p.AddHeader (args, tab, key)
-- It adds a simple header
MLMT.ChkFunc ("AddHeader", {{"args",args,"tr"},{"tab",tab,"tr"},{"key",key,"k"},})
local label = GetLabelLua (args, tab, key)
values[key] = {infotable_pos, label}
p.tab['header'..infotable_pos] = label
table.insert (keys, {key,'h'})
infotable_pos = infotable_pos + 1
end --AddHeader
function p.AddHeaderArg (args, tab, key, val, collapsible)
-- It adds a header with associated val
MLMT.ChkFunc ("AddHeaderArg", {{"args",args,"tr"},{"tab",tab,"tr"},{"key",key,"k"},
{"val",val,"a"},{"collapsible",collapsible,"br"},})
val = DataToStr (val)
if collapsible then
AddTitCollapsibleText (args, tab, key, val, p.rs[GIBTi.rk.rs_colorbox])
else
p.AddHeader (args, tab, key)
p.tab['data'..infotable_pos] = val
infotable_pos = infotable_pos + 1
end
end --AddHeaderArg
function p.ExecFuncs_SetHeaders (frame, tab, local_func, n_last_capt)
MLMT.ChkFunc ("ExecFuncs_SetHeaders", {{"frame",frame,"tr"},{"tab",tab,"tr"},
{"local_func",local_func,"f"},{"n_last_capt",n_last_capt,"ir"},})
-- 1. Execute the functions send from "local_func"
if local_func ~= nil then
local function args_f (key)
local found = false
for k, j in pairs(tab[MLMT.k.Args]) do
if k == key then
found = true
break
end
end
if not found then
error ('Invalid key from local_func: "'..key..'"')
end
return values[key][2] or ''
end --args_f
local funcs = local_func (frame, args_f)
p.CheckFuncs (funcs)
if funcs ~= nil then
for h, i in ipairs(funcs) do
local val = i[2]
val = DataToStr (val)
val = mw.text.trim (val)
local key = i[1]
if (val ~= '') and (values[key] ~= nil) then
p.tab['data'..values[key][1]] = val
end
end
end
end
-- 2. Set group headers if they contain any item in the group
local has_items = false
for h = #keys, 1, -1 do
if keys[h][2] == 'h' then
if has_items then
has_items = false
else
p.tab['header'..values[keys[h][1]][1]] = nil
end
else
if values[keys[h][1]][2] ~= nil then
has_items = true
end
end
end
if has_items and (n_last_capt > -1) then
if n_last_capt == 0 then
n_last_capt = ''
end
-- Now it displays the last caption followed by a bar if there are elements of
--- 1. a first group without a header.
--- 2. any element if no groups exist.
-- The color of the bar is less apparent than the color corresponding to a heading
p.tab[GIBTi.ik.caption..n_last_capt] = p.tab[GIBTi.ik.caption..n_last_capt]..
'<span style="display:inline-block;width:100%;height:1.0em;background:'..p.rs[GIBTi.rk.rs_color_tit_cllps]..';position:relative;top:0.4em;"></span>'
end
end --ExecFuncs_SetHeaders
function p.HasAnyValue (keys)
-- Used i.g. for change the header group caption if exists any items of a subgroup defined in "keys"
MLMT.ChkFunc ("HasAnyValue", {{"keys",keys,"tr"},})
for _, i in ipairs(keys) do
if (values[i] ~= nil) and (values[i][2] ~= nil) then
return true
end
end
return false
end --HasAnyValue
function p.HasNValues (keys)
-- It returns the item number of the subgroup "keys" that have a value
MLMT.ChkFunc ("HasNValues", {{"keys",keys,"tr"},})
local count = 0
for _, i in ipairs(keys) do
if (values[i] ~= nil) and (values[i][2] ~= nil) then
count = count + 1
end
end
return count
end --HasNValues
function p.HasAllValues (keys)
-- It returns true if all items of the subgroup "keys" have a value
MLMT.ChkFunc ("HasAllValues", {{"keys",keys,"tr"},})
for _, i in ipairs(keys) do
if (values[i] == nil) or (values[i][2] == nil) then
return false
end
end
return true
end --HasAllValues
function p.SetOtherHeader (target_key, label)
-- To change a header tag
MLMT.ChkFunc ("SetOtherHeader", {{"target_key",target_key,"k"},{"label",label,"xr"},})
p.tab['header'..values[target_key][1]] = label
end
function p.SetOtherLabel (target_key, label)
-- To change a label text
MLMT.ChkFunc ("SetOtherLabel", {{"target_key",target_key,"k"},{"label",label,"xr"},})
p.tab['label'..values[target_key][1]] = label
end
function p.SetOtherData (target_key, val)
-- To change a val content
MLMT.ChkFunc ("SetOtherData", {{"target_key",target_key,"k"},{"val",val,"ar"},})
p.tab['data'..values[target_key][1]] = DataToStr (val)
end
function p.GetData (key)
-- It returns the value of a key
MLMT.ChkFunc ("GetData", {{"key",key,"k"},})
return p.tab['data'..values[key][1]] or ''
end
function p.CheckShowParams (frame, args, ArgsPoss)
--Check that all parameters are valid
MLMT.ChkFunc ("CheckShowParams", {{"frame",frame,"tr"},{"args",args,"tr"},{"ArgsPoss",ArgsPoss,"tr"},})
MLMT.CheckParams (args, ArgsPoss, OtherArgs, true, true)
local res, has_error, has_dupli = MLMT.ErrorMsgs (frame, args) -- TODO: it was MLMT.ErrorMsgs(frame, args, tab), apparently tab is not needed
local cat = ''
if res ~= nil then
local key = ArgsPoss[1]
show_direct (key, ToRed (p.rs[GIBTi.rk.rs_error]), ToRed (res))
end
if has_error and (cat[GIBTi.rk.rs_cat_arg_error] ~= nil) then
cat = ' [['..cat[GIBTi.rk.rs_cat_arg_error]..']]'
end
if has_dupli and (cat[GIBTi.rk.rs_cat_arg_dupli] ~= nil) then
cat = cat..' [['..cat[GIBTi.rk.rs_cat_arg_dupli]..']]'
end
if untrans_arg and (cat[GIBTi.rk.rs_cat_wds_untranslat] ~= nil) then
cat = cat..' [['..cat[GIBTi.rk.rs_cat_wds_untranslat]..']]'
end
return cat
end --CheckShowParams
function p.InfoboxWithItsValues ()
--Main return of only-lua infobox
return BeginLangStr..Infobox.infobox (p.tab)..DoneLang()
end
----------------------------------------
-- PREINFOBOX FUNCTIONS --
----------------------------------------
--Variables--
--Prefix for value name to send to template
p.arg_prefix_val = 'val_'
--Prefix for label name to send to template
p.lbl_prefix = 'lbl_'
--table with the parameters (arguments and labels) to send to template.
local args_t = {}
function p.GetParamNFromT (ModuleName, i18nM, i18n, idx, new_args, new_pos)
--[[
Used in preinfoboxes,
it adds non-standard items (and returned in "i18nM" and "i18n"), after checking them.
Non-standard items are defined in "new_args"
"new_args" is a table with i.g. ["name_1"] = {"name_1","Name_1"}, ... and
their optional position ("new_pos") in standard table, are returned in "idx".
"new_pos" is a table with i.g. {"new_1", "prior_standard_item_name"}, ...
--]]
MLMT.ChkFunc ("GetParamNFromT", {{"ModuleName",ModuleName,"xr"},{"i18nM",i18nM,"tr"},
{"i18n",i18n,"tr"},{"idx",idx,"tr"},{"new_args",new_args,"t"},{"new_pos",new_pos,"t"},})
if new_args == nil then
else
local function in_new_args ()
return ', in new_args (from '..MLMT.MNi18n(ModuleName)..')'
end
for k, j in pairs(new_args) do
if i18nM[MLMT.k.Args][k] ~= nil then
error ('The key "'..k..'" already exists, you try to add it as a new parameter'..in_new_args(), 0)
end
if (type(j) ~= 'string') and (type(j) ~= 'table') then
error ('The value for a new key "'..k..'" must be a string or string table'..in_new_args(), 0)
end
if type (j) == 'table' then
for _, item in ipairs(j) do
if type (item) ~= 'string' then
error ('All values for the new key "'..k..'" must be a string'..in_new_args(), 0)
end
end
end
i18nM[MLMT.k.Args][k] = {j, ''}
i18n[MLMT.k.Args][k] = {j, ''}
end
if (new_pos == nil) or (#new_pos == 0) then
for k, j in pairs(new_args) do
table.insert (idx, {'a',k})
end
else
local function in_new_pos ()
return 'new_pos (of '..MLMT.MNi18n(ModuleName)..')'
end
for i, kk in ipairs(new_pos) do
if type(kk) ~= 'table' then
SD.vtos (kk)
error ('The item '..i..' from '..in_new_pos()..' does not contain a table. Now: '..SD.s, 0)
elseif (#kk ~= 2) or (type(kk[1]) ~= 'string') or (type(kk[2]) ~= 'string') then
SD.vtos (kk)
error ('The item '..i..' from '..in_new_pos()..' must contains a table with two keys. Now: '..SD.s, 0)
else
local found = false
for k, j in pairs(new_args) do
if k == kk[1] then
found = true
break
end
end
if not found then
error ('Not found "'..kk[1]..'"'..in_new_args(), 0)
end
found = false
for where, k in ipairs(idx) do
if k[2] == kk[2] then
table.insert (idx, where+1, {'a',kk[1]})
found = true
break
end
end
if not found then
error ('Not found "'..kk[2]..'" from '..in_new_pos()..' in idx of '..MLMT.MNi(ModuleName), 0)
end
end
end
end
end
AddNames (new_args, false)
return i18nM, i18n, idx
end --GetParamNFromT
--Functions for send arguments and labels to template infotable--
function p.val_of_key (key, val)
MLMT.ChkFunc ("val_of_key", {{"key",key,"k"},{"val",val,"a"},})
if val ~= nil then
args_t[key] = val
end
end --val_of_key
function p.valval_of_key (key, val)
MLMT.ChkFunc ("valval_of_key", {{"key",key,"k"},{"val",val,"a"},})
if val ~= nil then
args_t[p.arg_prefix_val..key] = val
end
end --valval_of_key
function p.rsval_of_key (key, val) --for reserved arguments, ie rs_colorbox
MLMT.ChkFunc ("rsval_of_key", {{"key",key,"k"},{"val",val,"a"},})
if val ~= nil then
args_t[key] = val
end
end --rsval_of_key
function p.lbl_of_key (key, val)
MLMT.ChkFunc ("lbl_of_key", {{"key",key,"k"},{"val",val,"xr"},})
args_t[p.lbl_prefix..key] = val
end
----------------------------------------
-- proof params is a list of parameter keys to use as example for test the infobox
local use_proof_params = false
local proof_params = {}
function p.arg_of_key (args, tab, key, lims, DefVal)
-- Send a string value of a normal argument with its key (with "val_" prefix).
-- In demo mode send the preferred name for the key. Accept "NONE" value.
MLMT.ChkFunc ("arg_of_key", {{"args",args,"tr"},{"tab",tab,"tr"},{"key",key,"k"},
{"lims",lims,"t"},{"DefVal",DefVal,"a"},})
if tab[MLMT.k.Args][key] == nil then --added new key, incompletly
error ('Undefined key ('..key..') in [MLMT.k.Args] of parent module')
end
local res = nil
local Args = tab[MLMT.k.Args][key][1]
if use_proof_params then --only used in demo
for _, i in ipairs(proof_params) do
if i == key then
return
end
end
if tab[MLMT.k.Args][key][3] ~= '' then
args_t[p.arg_prefix_val..key] = SA.None
end
return nil
end
if Args == SA.None then
res = SA.None
elseif p.demo then
res = p.ArgNameForDemo (tab, key)
else
local arg_type, required, params = MLMT.split_item_type_req_vals2 (lims, key)
res = MLMT.ParamVal (args, Args, arg_type, required, DefVal, params)
end
if res ~= nil then
p.valval_of_key (key, res)
return res
end
end --arg_of_key
function p.lcfirst (S)
--returns lowercase first character
MLMT.ChkFunc ("lcfirst", {{"S",S,"s"},})
if (S == nil) or (S == '') then
return nil
elseif string.len(S) == 1 then
return string.lower(S)
else
return string.lower(string.sub(S,1,1))..string.sub(S,2)
end
end --lcfirst
function p.arg_label_of_key (args, tab, key, lims, DefVal) --Usual
-- It adds to the table args_t the the label and/or value for a key
-- taking the values entered manually or read from WD, as appropriate.
MLMT.ChkFunc ("arg_label_of_key", {{"args",args,"tr"},{"tab",tab,"tr"},{"key",key,"k"},
{"lims",lims,"t"},{"DefVal",DefVal,"a"},})
p.lbl_of_key (key, p.label_of_key_w_hint_txt (args, tab, key))
return p.arg_of_key (args, tab, key, lims, DefVal)
end
function p.std_lab_arg_to_tab (frame, args, tab, idx, lims, local_func, lab_no_ruby, omit_params)
-- It adds to the table args_t the label and/or value for each item according to the index
-- taking the values as test, entered manually or read from WD, as appropriate.
local function i_second ()
local function ReadPar (key, def)
args_t[p.arg_prefix_val..key] = SA.Str_Par (args, p.i_itemsM[MLMT.k.Args][key][1], def)
end
local function ReadParI (key, i, def)
args_t[p.arg_prefix_val..key..i] = SA.Str_Par (args, p.i_itemsM[MLMT.k.Args][key..i][1], def)
end
local DIS = p.rs[GIBTi.rk.rs_def_image_size]
if i_with2 then
if p.demo then
for i = 1, 2 do
args_t[p.arg_prefix_val..GIBTi.ik.image..i] = p.ArgNameForDemo (p.i_itemsM, GIBTi.ik.image..i)
args_t[p.arg_prefix_val..GIBTi.ik.alt..i] = p.ArgNameForDemo (p.i_itemsM, GIBTi.ik.alt..i)
args_t[p.arg_prefix_val..GIBTi.ik.caption..i] = p.ArgNameForDemo (p.i_itemsM, GIBTi.ik.caption..i)
end
else
for i = 1, 2 do
ReadParI (GIBTi.ik.image, i)
args_t[p.arg_prefix_val..GIBTi.ik.image_idx..i] = SA.Int_Par (args, p.i_itemsM[MLMT.k.Args][GIBTi.ik.image_idx..i][1], -1)
ReadParI (GIBTi.ik.alt, i)
ReadParI (GIBTi.ik.size, i, DIS)
ReadParI (GIBTi.ik.caption, i)
end
end
else
if p.demo then
args_t[p.arg_prefix_val..GIBTi.ik.image] = p.ArgNameForDemo (p.i_itemsM, GIBTi.ik.image)
args_t[p.arg_prefix_val..GIBTi.ik.alt] = p.ArgNameForDemo (p.i_itemsM, GIBTi.ik.alt)
args_t[p.arg_prefix_val..GIBTi.ik.caption] = p.ArgNameForDemo (p.i_itemsM, GIBTi.ik.caption)
else
ReadPar (GIBTi.ik.image)
args_t[p.arg_prefix_val..GIBTi.ik.image_idx] = SA.Int_Par (args, p.i_itemsM[MLMT.k.Args][GIBTi.ik.image_idx][1], -1)
ReadPar (GIBTi.ik.alt)
ReadPar (GIBTi.ik.size, DIS)
ReadPar (GIBTi.ik.caption)
end
end
end -- i_second
--Inizialization--
MLMT.ChkFunc ("std_lab_arg_to_tab", {{"frame",frame,"tr"},{"args",args,"tr"},{"tab",tab,"tr"},
{"idx",idx,"tr"},{"lims",lims,"t"},{"local_func",local_func,"fr"},
{"lab_no_ruby",lab_no_ruby,"t"},{"omit_params",omit_params,"t"},})
--Functions--
local function label_of_key_w_hint_txt (key)
--A text label with its key (with "lbl_"). The text label contains a hint text if its key is not in table of "lab_no_ruby".
--The text label is a preset label or a customized label for an article using "l_" as prefix for argument.
return p.label_of_key_w_hint_txt (args, tab, key, lab_no_ruby)
end
local function label_of_key (key) --Usual
--Send a text label, the normal use.
p.lbl_of_key (key, label_of_key_w_hint_txt (key))
end
local function label_lc_of_key (key) --lc = lowercase first character
--Send a text label, but if its value is read from Wikidata the first character is lowercase (lc).
p.lbl_of_key (key, p.lcfirst (label_of_key_w_hint_txt (key)))
end
local function arg_label_of_key (key) --Usual
label_of_key (key)
return p.arg_of_key (args, tab, key, lims)
end
--begin--
argsC = {}
if p.rs[GIBTi.rk.rs_send_img_preinfobox] then
p.i_main (frame, args)
for k, v in pairs (i_tab) do
args_t[p.arg_prefix_val..k] = v
end
args_t[p.arg_prefix_val..GIBTi.ik.rs_img_used_hand] = i_used_hand
args_t[p.arg_prefix_val..GIBTi.ik.rs_img_used_WD] = i_used_WD
args_t[p.arg_prefix_val..GIBTi.ik.rs_img_caption] = i_caption
else
i_second ()
end
for i, k in ipairs(idx) do
local res = nil
if k[1] == 'a' then
res = p.arg_of_key (args, tab, k[2], lims)
elseif k[1] == 'L' then
label_of_key (k[2])
elseif k[1] == 'al' then
res = arg_label_of_key (k[2])
elseif k[1] == 'l' then
label_lc_of_key (k[2])
end
if res ~= nil then
argsC[k[2]] = res
end
end
if omit_params ~= nil then
for _, key in ipairs(omit_params) do
args_t[p.arg_prefix_val..key] = SA.None
end
end
local function args_f (key)
local found = false
for k, j in pairs(tab[MLMT.k.Args]) do
if k == key then
found = true
break
end
end
if not found then
error ('Invalid key from local_func: "'..key..'"')
end
return argsC[key] or ''
end --args_f
funcs = local_func (frame, args_f)
p.CheckFuncs (funcs)
if funcs ~= nil then
for h, i in ipairs(funcs) do
local val = mw.text.trim (i[2])
if val ~= '' then
args_t[p.arg_prefix_val..i[1]] = val
end
end
end
MLMT.CheckParams (args, {tab, p.i_itemsM}, OtherArgs, true, true)
end --std_lab_arg_to_tab
----------
function p.arg_of_str (args, key)
-- Send a string value of a special argument with its key (without "val_" prefix). I.e. used for lang or item
MLMT.ChkFunc ("arg_of_str", {{"args",args,"tr"},{"key",key,"k"},})
p.val_of_key (key, SA.Str_Par (args, key))
end
function p.arg_of_rskey (args, key)
-- Send a string value of a reserved (rs) argument with its key (without its "rs_" prefix and with "val_" prefix)
MLMT.ChkFunc ("arg_of_rskey", {{"args",args,"tr"},{"key",key,"k"},})
p.rsval_of_key (key, SA.Str_Par (args, key, p.rs[key]))
end
function p.arg_of_rsbool (args, key)
-- Send a boolean value of a reserved (rs) argument with its key (without its "rs_" prefix and with "val_" prefix)
MLMT.ChkFunc ("arg_of_rsbool", {{"args",args,"tr"},{"key",key,"k"},})
p.rsval_of_key (key, SA.Bool_Par (args, key, p.rs[key]))
end
function p.IniPreinfo (args, tab, preset_params)
--Prepare the values to send to template:
--* if exist: lang, item, proof_params, preset_params
--* reserved words,
--* tracking categories
MLMT.ChkFunc ("IniPreinfo", {{"args",args,"tr"},{"tab",tab,"tr"},{"preset_params",preset_params,"t"},})
Init0 (args)
p.arg_of_str (args, MLMT.arg.lang)
p.arg_of_str (args, MLMT.arg.item)
local p_f = args[GIBTi.rk.rs_proof_params]
if p_f ~= nil then
use_proof_params = true
local p_f = mw.text.split(p_f,',')
for i, j in ipairs(p_f) do
p_f[i] = mw.text.trim (j)
found = false
for key, k in pairs(tab[MLMT.k.Args]) do
if type(k[1]) == 'table' then
for _, W in ipairs(k[1]) do
if W == p_f[i] then
found = true
break
end
end
else
if k == p_f[i] then
found = true
end
end
if found then
table.insert (proof_params, key)
break
end
end
if not found then
error ('Invalid parameter key to proof the infobox, (with the name: '..p_f[i]..'), passed with "'..GIBTi.rk.rs_proof_params..'"', 0)
end
end
end
local rs_idx = { --index for reserved keys
--default colors
GIBTi.rk.rs_colorbox,
GIBTi.rk.rs_color_tit_cllps,
--styles
GIBTi.rk.rs_bodystyle,
GIBTi.rk.rs_titlestyle,
GIBTi.rk.rs_headerstyle,
GIBTi.rk.rs_subheaderstyle,
GIBTi.rk.rs_imagestyle,
GIBTi.rk.rs_captionstyle,
GIBTi.rk.rs_labelstyle,
GIBTi.rk.rs_datastyle,
GIBTi.rk.rs_belowstyle,
--icon & default name
GIBTi.rk.rs_icon,
GIBTi.rk.rs_icon_at_begin,
GIBTi.rk.rs_icon_hint,
GIBTi.rk.rs_def_name,
--image
--GIBTi.rk.rs_image_max_num,
--GIBTi.rk.rs_def_image_size,
--referred to label/data content
--GIBTi.rk.rs_changeable_lbls,
--GIBTi.rk.rs_param_prefix_lbl,
--GIBTi.rk.rs_def_charnum_cllps,
GIBTi.rk.rs_error,
GIBTi.rk.rs_below,
}
for _, key in ipairs(rs_idx) do
p.rsval_of_key (key, p.rs[key])
end
local cat_idx = { --index for category keys
GIBTi.rk.rs_cat_arg_error,
GIBTi.rk.rs_cat_arg_dupli,
--GIBTi.rk.rs_cat_wds_untranslat,
GIBTi.rk.rs_cat_no_image,
}
for _, key in ipairs (cat_idx) do
p.rsval_of_key (key, cat[key])
end
for key, val in pairs (p.rss) do
p.rsval_of_key (key, val)
end
if preset_params ~= nil then
for key, val in pairs(preset_params) do
args_t[p.arg_prefix_val..key] = val
end
end
end --IniPreinfo
function p.SendToTemplate (frame, args, tab, TemplateN)
-- Send to TemplateN all contained values in the table args_t,
-- having previously added the found errors made by editor
MLMT.ChkFunc ("SendToTemplate", {{"frame",frame,"tr"},{"args",args,"tr"},{"tab",tab,"tr"},
{"TemplateN",TemplateN,"xr"},})
--if use_proof_params then
local res, has_error, has_dupli = MLMT.ErrorMsgs (frame, args, tab)
local cat = ''
if (p.rs[GIBTi.rk.rs_icon] ~= '') and (p.rs[GIBTi.rk.rs_icon] ~= SA.None) then
args_t['rs_icon_where'] = GetWhereIcon ()
end
if res ~= nil then
args_t['rs_error'] = ToRed (p.rs[GIBTi.rk.rs_error])
args_t['val_errors'] = ToRed (res)
end
if has_error and (cat_arg_error ~= nil) then
cat = ' [['..cat_arg_error..']]'
end
if has_dupli and (cat_arg_dupli ~= nil) then
cat = cat..' [['..cat_arg_dupli..']]'
end
return frame:expandTemplate {
title = TemplateN,
args = args_t,}..cat
end --SendToTemplate
----------------------------------------
return p