|
|
| (2 versions intermédiaires par 2 utilisateurs non affichées) |
| Ligne 1 : |
Ligne 1 : |
| local p = {} | | local p = {} |
| local lang = 'fr'
| | function p.infobox( f ) |
| | | local args = require( 'Module:ProcessArgs' ).merge( true ) |
| local item = nil -- l'élément Wikidata lié | | local titleObject = mw.title.getCurrentTitle() |
| local localdata = {}-- données concernant les paramètres passés au modèle
| | local title = args.title or titleObject.baseText |
| local page = { -- données concernant la page où est affichée l'infobox
| | |
| name = mw.title.getCurrentTitle().prefixedText,
| | local imageArea = args.imagearea |
| namespace = mw.title.getCurrentTitle().namespace | | if not imageArea and imageArea ~= 'none' then |
| }
| | local images = {} |
| local maincolor, secondcolor, thirdcolor = '#E1E1E1', '#E1E1E1', '#000000' | | local invImages = {} |
| -- l'objet principal à retourner
| | local defaultImageSize = args.defaultimagesize or '150px' |
| local infobox = mw.html.create('div')
| | args.image1 = args.image1 or args.image or 'title' |
| | | args.image1size = args.image1size or args.imagesize |
| -- objets secondaires à retourner
| | args.invimage1 = args.invimage1 or args.invimage or 'title' |
| local maintenance = '' -- chaîne retournée avec le module : cats de maintenance | | |
| local externaltext = '' -- par exemple coordonnées en titre
| | local imgCount = {} |
| -- modules importés
| | local invImgCount = {} |
| local linguistic = require "wiki/Module:Linguistique" | | for k, v in pairs( args ) do |
| local wd = require 'Module:Wikidata' | | if type( k ) == 'string' then |
| local valueexpl = wd.translate("activate-query") | | local image, num = k:match( '^(image)(%d+)$' ) |
| | | local invImage, invNum = k:match( '^(invimage)(%d+)$' ) |
| local i18n = {
| | if v:lower() ~= 'none' then |
| ['see doc'] = 'Documentation du modèle',
| | if image then |
| ['edit'] = 'modifier',
| | table.insert( imgCount, tonumber( num ) ) |
| ['edit code'] = 'modifier le code',
| | elseif invImage then |
| ['edit item'] = 'modifier Wikidata',
| | table.insert( invImgCount, tonumber( invNum ) ) |
| ['tracking cat'] = "Page utilisant des données de Wikidata",
| | end |
| ['invalid block type'] = "Bloc de données invalide dans le module d'infobox",
| | end |
| ['default cat'] = "Maintenance des infobox",
| |
| } | |
| | |
| local function addWikidataCat(prop)
| |
| maintenance = maintenance .. wd.addTrackingCat(prop)
| |
| end
| |
| | |
| local function expandQuery(query)
| |
| local value, number -- valeur à retourner, nombre de valeurs pour accorder le libellé
| |
| if not query.entity then
| |
| query.entity = localdata.item
| |
| end
| |
| if not query.conjtype then
| |
| query.conjtype = 'comma'
| |
| end
| |
| local claims = wd.getClaims(query)
| |
| if (not claims) then
| |
| return nil
| |
| end
| |
| return wd.formatAndCat(query), #claims -- pour l'accord au pluriel
| |
| end
| |
| | |
| local function getWikidataValue(params, wikidataparam) | |
| -- Récupère la valeur Wikidata pour la valeur, soit dans le paramètre "wikidata" soit dans le paramètre "property"
| |
| if not localdata.item then
| |
| return nil
| |
| end
| |
| | |
| if params.blockers then -- blockers are local parameters that disable the wikidata query
| |
| local blockers = params.blockers
| |
| if (type(blockers) == 'string') then
| |
| blockers = {blockers}
| |
| end
| |
| for i, blocker in ipairs(blockers) do
| |
| if localdata[blocker] then
| |
| return nil | |
| end | | end |
| end | | end |
| end
| | |
| | | table.sort( imgCount ) |
| local v, valnum -- la valeur à retourner, et le nombre de de valeurs (pour l'accord grammatical)
| | local animate |
|
| | for k, v in ipairs( imgCount ) do |
| if not wikidataparam then -- par défaut la valeur wikidata est dans le paramètre "wikidata" mais dans les structures composées comme "title", il y a plusieurs paramètres wikidata
| | local image = args['image' .. v] |
| wikidataparam = 'wikidata'
| | local size = args['image' .. v .. 'size'] or defaultImageSize |
| end
| | |
| | | if image == 'title' then |
| if params[wikidataparam] then
| | local imageTitle = mw.title.new( 'Media:' .. title .. '.png' ) |
| if type(params[wikidataparam]) == 'function' then
| | if imageTitle and imageTitle.exists then |
| v, valnum = params[wikidataparam](localdata.item)
| | image = '[[File:' .. title .. '.png|' .. size .. ']]' |
| elseif type(params[wikidataparam]) == 'table' then
| | elseif titleObject.namespace == 0 then |
| v, valnum = expandQuery(params[wikidataparam])
| | image = '[[File:No image.svg|' .. size .. '|link=File:' .. title .. '.png|Upload ' .. title .. '.png]]' |
| else
| | else |
| v, valnum = params[wikidataparam]
| | image = '[[File:No image.svg|' .. size .. '|link=]]' |
| end
| | end |
| end
| | elseif image:match( ';' ) then |
| if not v then
| | if not animate then |
| return nil
| | animate = require( 'Module:Animate' ).animate |
| end
| | end |
| v = linguistic.ucfirst(v)
| | image = animate{ image, size } |
| return v, valnum
| | else |
| end | | image = '[[File:' .. image .. '|' .. size .. ']]' |
| | |
| local function getValue(val, params)
| |
| if type(val) == 'string' then
| |
| return localdata[val]
| |
| elseif type(val) == 'function' then
| |
| return val(localdata, localdata.item, params)
| |
| elseif type(val) == 'table' then
| |
| for i, j in pairs(val) do -- si plusieurs paramètres possibles (legacy de vieux code), prendre le premier non vide
| |
| if localdata[j] then
| |
| return localdata[j]
| |
| end | | end |
| | |
| | table.insert( images, '<div>' .. image .. '</div>' ) |
| end | | end |
| end
| | images = table.concat( images, '\n' ) |
| end
| | |
| | | if #invImgCount > 0 then |
| local function addMaintenanceCat(cat, sortkey)
| | table.sort( invImgCount ) |
| if page.namespace ~= 0 then
| | local slot |
| return '' | | local invIds = mw.loadData( 'Module:InvSprite' ).ids |
| end
| | local invAliases = mw.loadData( 'Module:Inventory slot/Aliases' ) |
| if cat then
| | for k, v in ipairs( invImgCount ) do |
| maintenance = maintenance .. '[[Category:' .. cat .. '|' .. (sortkey or page.name) .. ']]'
| | local image = args['invimage' .. v] |
| end
| | if image == 'title' then |
| end
| | if invIds[title] or invAliases[title] then |
| | | image = title |
| function p.separator(params)
| | else |
| local style = params['separator style'] or {}
| | image = false |
| style.height = style.height or '2px'
| |
| style['background-color'] = style['background-color'] or maincolor
| |
|
| |
| return mw.html.create('hr'):css( style )
| |
| end
| |
| | |
| function p.buildtitle(params)
| |
| local text = getValue(params.value, params) or params.textdefaultvalue or getWikidataValue(params) or mw.title.getCurrentTitle().text
| |
| local subtext = getValue(params.subtitle) or getWikidataValue(params, 'wikidatasubtitle') or params.subtitledefaultvalue
| |
| if subtext and (subtext ~= text) then
| |
| text = text .. '<br /><small>' .. subtext .. '</small>' | |
| end
| |
| local icon = params.icon or ''
| |
| if icon ~= '' and icon ~= 'defaut' then
| |
| text = text .. mw.getCurrentFrame():extensionTag('templatestyles', '', {src = 'Infobox/Pictogramme/' .. mw.text.trim(icon) .. '.css'})
| |
| if not params.large then
| |
| icon = 'icon ' .. icon | |
| end
| |
| end
| |
| local class = 'entete ' .. icon
| |
|
| |
| -- overwrites with those provided in the module
| |
| local style = {}
| |
| style['background-color'] = maincolor
| |
| style['color'] = thirdcolor
| |
| if params.style then
| |
| for i, j in pairs(params.style) do
| |
| style[i] = j | |
| end
| |
| end
| |
| local title = mw.html.create('div')
| |
| :addClass(class)
| |
| :css(style)
| |
| :tag('div')
| |
| :wikitext(text) | |
| :allDone()
| |
| return title
| |
| end
| |
| p.buildTitle = p.buildtitle
| |
| | |
| function p.buildnavbox(params)
| |
|
| |
| -- définition du style
| |
| local class = "overflow nav " .. (params.class or '')
| |
| local style = params.style or {}
| |
| | |
| if params.separated then -- options pour ajouter une ligne de séparation au dessus
| |
| class = class .. ' bordered'
| |
| style['border-top'] = '1px solid' .. maincolor
| |
| end
| |
| | |
| -- ajustement des paramètres de données
| |
| params.previousval = params.previousval or params.previousparameter -- nom de paramètre obsolète
| |
| params.nextval = params.nextval or params.nextparameter
| |
|
| |
| if params.previousproperty then
| |
| params.previouswikidata = {property = params.previousproperty}
| |
| end
| |
| if params.nextproperty then
| |
| params.nextwikidata = {property = params.nextproperty}
| |
| end
| |
|
| |
| | |
| local previousval = getValue(params.previousval, params) or getWikidataValue(params, 'previouswikidata')
| |
| local nextval = getValue(params.nextval, params) or getWikidataValue(params, 'nextwikidata')
| |
|
| |
| local navbox
| |
| if params.inner then -- pour celles qui sont à l'intérieur d'une table
| |
| navbox = mw.html.create('tr'):tag('th'):attr('colspan', 2)
| |
| style['font-weight'] = style['font-weight'] or 'normal'
| |
| else
| |
| navbox = mw.html.create('div')
| |
| end
| |
|
| |
| navbox
| |
| :addClass(class)
| |
| :css(style)
| |
| :tag('div')
| |
| :addClass('prev_bloc') | |
| :wikitext(previousval)
| |
| :done()
| |
| :tag('div')
| |
| :addClass('next_bloc')
| |
| :wikitext(nextval)
| |
| :done()
| |
| :allDone()
| |
| return navbox
| |
| end
| |
| p.buildNavbox = p.buildnavbox
| |
| | |
| function p.buildimages(params)
| |
| local images = {}
| |
| local upright, link, caption, alt, size -- size is deprecated
| |
| if type(params.imageparameters) == 'string' then
| |
| params.imageparameters = {params.imageparameters}
| |
| end
| |
| if not params.imageparameters then -- s'il n'y a pas de paramètre image, continuer, peut-être y a-t-il une image par défaut définie dans le module d'infobox
| |
| params.imageparameters = {}
| |
| end
| |
| for j, k in ipairs(params.imageparameters) do
| |
| table.insert(images, localdata[k])
| |
| end
| |
| -- Images de Wikidata
| |
| if #images == 0 and localdata.item then
| |
| if params.property then
| |
| params.wikidata = {entity = localdata.item, property = params.property}
| |
| end
| |
| if params.wikidata then
| |
| local wdq = params.wikidata
| |
| wdq.excludespecial = true
| |
| if type(wdq) == 'table' then
| |
| wdq.entity = wdq.entity or localdata.item
| |
| wdq.numval = wdq.numval or params.numval or 1
| |
| images = wd.getClaims(wdq) | |
| end
| |
| if type(wdq) == 'function' then
| |
| images = params.wikidata()
| |
| if type(images) == 'string' then
| |
| return images | |
| end --c'est probablement une erreur dans la requête => afficher le message
| |
| end
| |
| if (not images) then
| |
| images = {}
| |
| end
| |
| if (#images > 0) and (params.wikidata.property) then
| |
| addWikidataCat(params.wikidata.property)
| |
| end
| |
| | |
| if type(images[1]) == 'table' then
| |
| for i, image in pairs(images) do
| |
| if image.mainsnak.snaktype ~= 'value' then | |
| return
| |
| end | | end |
| if #images == 1 then -- si une seule image, on utilise la légende (si deux plusieurs images, comment mettre en forme ?)
| | end |
| caption = wd.getFormattedQualifiers(images[i], {'P2096'}, {isinlang = 'fr'}) or wd.getFormattedQualifiers(images[i], {'P805'})
| | |
| | if image == '----' then |
| | table.insert( invImages, '</div><div style="padding-top:.5em">' ) |
| | elseif image then |
| | if not slot then |
| | slot = require( 'Module:Inventory slot' ).slot |
| end | | end |
| images[i] = image.mainsnak.datavalue.value | | table.insert( invImages, slot{ image, link = 'none' } ) |
| end | | end |
| end | | end |
| end
| | |
| end
| | if slot and #invImages > 0 then |
| | | invImages = '<div class="infobox-invimages"><div>' .. table.concat( invImages, '' ) .. '</div></div>' |
| -- Images par défaut
| | else |
| if #images == 0 then
| | invImages = '' |
| if params.maintenancecat then
| |
| addMaintenanceCat(params.maintenancecat, params.sortkey)
| |
| end
| |
| if params.defaultimages then
| |
| images = params.defaultimages | |
| if type(images) == 'string' then
| |
| images = {images}
| |
| end | | end |
| upright = params.defaultimageupright
| | else |
| caption = params.defaultimagecaption
| | invImages = '' |
| link = params.defaultimagelink
| |
| alt = params.defaultimagealt
| |
| if not alt and ( images[1] == 'Defaut.svg' or images[1] == 'Defaut 2.svg' ) then
| |
| alt = 'une illustration sous licence libre serait bienvenue'
| |
| end
| |
| end
| |
| end
| |
| if #images == 0 then
| |
| return nil | |
| end
| |
|
| |
| upright = upright or getValue(params.uprightparameter) or params.defaultupright or "1.2"
| |
| link = link or getValue(params.linkparameter) or params.defaultlink
| |
| caption = caption or getValue(params.captionparameter) or params.defaultcaption
| |
| alt = alt or getValue( params.altparameter) or params.defaultalt
| |
| | |
| -- taille avec "size" (obsolète)
| |
| size = size or getValue(params.sizeparameter) or params.defaultsize -- deprecated
| |
| if size then
| |
| local numsize = size:gsub('px', '')
| |
| numsize = mw.ustring.gsub(numsize, 'x.*', '')
| |
| numsize = tonumber(numsize)
| |
| if type(numsize) ~= 'number' or numsize > 280 then
| |
| addMaintenanceCat("taille d'image invalide")
| |
| end
| |
| if tonumber(size) then
| |
| size = size .. 'px'
| |
| end
| |
| size = '|' .. size
| |
| else
| |
| size = ''
| |
| end
| |
|
| |
| if tonumber(upright) then
| |
| upright = tostring(tonumber(upright) ) / #images
| |
| end
| |
| if tonumber(size) then
| |
| size = tostring(tonumber(size) ) / #images
| |
| end
| |
| | |
| local style = params.style or {padding ='2px 0',}
| |
| | |
| -- Partie image
| |
| | |
| local imagesString = ''
| |
| for i,image in pairs(images) do
| |
| if image == '-' then
| |
| return
| |
| end
| |
| imagesString = imagesString .. '[[Fichier:' .. image .. size .. '|frameless'
| |
| if alt then
| |
| imagesString = imagesString .. '|alt=' .. alt
| |
| end
| |
| if link then
| |
| imagesString = imagesString .. '|link=' .. link
| |
| end
| |
| if upright then
| |
| imagesString = imagesString .. '|upright=' .. upright
| |
| elseif #images > 1 then
| |
| imagesString = imagesString .. '|upright=' .. ( 1 / #images )
| |
| end
| |
| imagesString = imagesString .. ']]'
| |
| end
| |
| | |
| local image = mw.html.create('div')
| |
| :addClass("images")
| |
| :css(style)
| |
| :wikitext(imagesString)
| |
| | |
| -- Partie légende
| |
| local captionobj
| |
| if caption then
| |
| captionobj = mw.html.create('div')
| |
| :wikitext(caption)
| |
| :css(params.legendstyle or {}) | |
| :addClass("legend")
| |
| :done()
| |
| end
| |
|
| |
| -- séparateur
| |
| local separator
| |
| if params.separator then
| |
| separator = separator(params)
| |
| end
| |
| return mw.html.create('div')
| |
| :node(image)
| |
| :node(captionobj)
| |
| :node(separator)
| |
| :done()
| |
| end
| |
| p.buildImages = p.buildimages
| |
| | |
| function p.buildtext(params)
| |
| local class = params.class or ''
| |
| local style = {
| |
| ['text-align'] = 'center',
| |
| ['font-weight'] = 'bold'
| |
| }
| |
| if params.style then
| |
| for i, j in pairs(params.style) do
| |
| style[i] = j
| |
| end
| |
| end
| |
| local text = getValue(params.value, params) or getWikidataValue(params) or params.defaultvalue
| |
| if text == '-' then
| |
| return
| |
| end
| |
| if not text then
| |
| addMaintenanceCat(params.maintenancecat, params.sortkey)
| |
| return nil
| |
| end
| |
| local formattedtext = mw.html.create('p')
| |
| :addClass(class)
| |
| :css(style)
| |
| :wikitext(text)
| |
| :done()
| |
| return formattedtext
| |
| end
| |
| p.buildText = p.buildtext
| |
| | |
| function p.buildrow(params)
| |
| local class = params.class or ''
| |
| local style = params.style or {}
| |
| local value, number = getValue(params.value, params)
| |
| if (value == valueexpl) then
| |
| value = nil
| |
| params.wikidata.expl = false
| |
| end
| |
| if (not value) then
| |
| value, number = getWikidataValue(params, 'wikidata')
| |
| end
| |
| if (not value) and (params.property) then
| |
| value, number = expandQuery{ property = params.property, ucfirst = params.ucfirst }
| |
| end
| |
| if not value then
| |
| value = params.defaultvalue
| |
| end
| |
| if value == '-' then
| |
| return nil
| |
| end
| |
| if not number then
| |
| number = 0 -- == indéfini
| |
| end
| |
| | |
| if not value then
| |
| if params.maintenancecat then
| |
| local maintenancecat = getValue(params.maintenancecat, params)
| |
| addMaintenanceCat(maintenancecat, params.sortkey)
| |
| end | | end |
| return nil
| |
| end
| |
|
| |
| local label = params.label
| |
| if number > 1 and (params.plurallabel) then
| |
| label = params.plurallabel
| |
| elseif number == 1 and (params.singularlabel) then
| |
| label = params.singularlabel
| |
| end
| |
| if type(label) == 'function' then
| |
| label = label(localdata, localdata.item)
| |
| end
| |
|
| |
| -- format
| |
| local formattedvalue = mw.html.create('div')
| |
| :wikitext('\n' .. value) -- Le '\n' est requis lorsque value est une liste commençant par '*' ou '#'
| |
|
| |
| if (params.hidden == true)then
| |
| formattedvalue
| |
| :attr({class="NavContent", style="display: none; text-align: left;"})
| |
| formattedvalue = mw.html.create('div')
| |
| :attr({class="NavFrame", title="[Afficher]/[Masquer]", style="border: none; padding: 0;"})
| |
| :node(formattedvalue)
| |
| end
| |
| formattedvalue = mw.html.create('td')
| |
| :node(formattedvalue)
| |
| :allDone()
| |
|
| |
| local formattedlabel
| |
| if label then
| |
| formattedlabel = mw.html.create('th')
| |
| :attr('scope', 'row')
| |
| :wikitext(label)
| |
| :done()
| |
| end
| |
| local row = mw.html.create('tr')
| |
| :addClass(class)
| |
| :css(style)
| |
| :node(formattedlabel)
| |
| :node(formattedvalue)
| |
| :done()
| |
|
| |
| return row
| |
| end
| |
| p.buildRow = p.buildrow
| |
|
| |
| function p.buildsuccession(params)
| |
| if not params.value then
| |
| return nil
| |
| end
| |
|
| |
| --local style = params.style or {}
| |
| --style['text-align'] = style['text-align'] or 'center'
| |
| --style['color'] = style['color'] or '#000000'
| |
| --style['background-color'] = style['background-color'] or '#F9F9F9'
| |
|
| |
| local rowI = mw.html.create('tr')
| |
|
| |
| local colspan = '2'
| |
| cellI = mw.html.create('td')
| |
| :attr({colspan = colspan})
| |
| :attr({align = 'center'})
| |
|
| |
| local styleT = {}
| |
| styleT['background-color'] = 'transparent'
| |
| styleT['width'] = '100%'
| |
| tabC = mw.html.create('table')
| |
| :attr({cellspacing = '0'})
| |
| :addClass('navigation-not-searchable')
| |
| :css(styleT)
| |
|
| |
| local row = mw.html.create('tr')
| |
|
| |
| local color = params.color
| |
|
| |
| local style = {}
| |
| local arrowLeft
| |
| local arrowRight
| |
|
| |
| if color == 'default' then
| |
| style['background-color'] = '#E6E6E6'
| |
| arrowLeft = '[[Fichier:Fleche-defaut-gauche.png|13px|alt=Précédent|link=]]'
| |
| arrowRight = '[[Fichier:Fleche-defaut-droite.png|13px|alt=Précédent|link=]]'
| |
| else
| |
| style['background-color'] = color
| |
| arrowLeft = '[[Fichier:Fleche-defaut-gauche-gris-32.png|13px|alt=Suivant|link=]]'
| |
| arrowRight = '[[Fichier:Fleche-defaut-droite-gris-32.png|13px|alt=Suivant|link=]]'
| |
| end
| |
|
| |
| local styleTrans = {}
| |
| styleTrans['background-color'] = '#F9F9F9'
| |
|
| |
| local values = params.value
| |
| local before = values['before']
| |
| local center = values['center']
| |
| local after = values['after']
| |
|
| |
| local widthCell = '44%'
| |
| if center then
| |
| widthCenter = '28%'
| |
| widthCell = '29%'
| |
| end
| |
|
| |
| local formattedbefore
| |
| if before then
| |
| formattedbefore = mw.html.create('td')
| |
| :attr({valign = 'middle'})
| |
| :attr({align = 'left'})
| |
| :attr({width = '5%'})
| |
| :css(style)
| |
| :wikitext(arrowLeft)
| |
| :done()
| |
| row:node(formattedbefore)
| |
| formattedbefore = mw.html.create('td')
| |
| :attr({width = '1%'})
| |
| :css(style)
| |
| :wikitext('')
| |
| :done()
| |
| row:node(formattedbefore)
| |
| formattedbefore = mw.html.create('td')
| |
| :attr({align = 'left'})
| |
| :attr({valign = 'middle'})
| |
| :attr({width = widthCell})
| |
| :css(style)
| |
| :wikitext(before)
| |
| :done()
| |
| row:node(formattedbefore)
| |
| else
| |
| formattedbefore = mw.html.create('td')
| |
| :attr({valign = 'middle'})
| |
| :attr({align = 'left'})
| |
| :attr({width = '5%'})
| |
| :css(styleTrans)
| |
| :wikitext('')
| |
| :done()
| |
| row:node(formattedbefore)
| |
| formattedbefore = mw.html.create('td')
| |
| :attr({width = '1%'})
| |
| :css(styleTrans)
| |
| :wikitext('')
| |
| :done()
| |
| row:node(formattedbefore)
| |
| formattedbefore = mw.html.create('td')
| |
| :attr({align = 'left'})
| |
| :attr({valign = 'middle'})
| |
| :attr({width = widthCell})
| |
| :css(styleTrans)
| |
| :wikitext('')
| |
| :done()
| |
| row:node(formattedbefore)
| |
| end
| |
|
| |
| local formattedcenter
| |
| formattedcenter = mw.html.create('td')
| |
| :attr({width = '1%'})
| |
| :css(styleTrans)
| |
| :wikitext('')
| |
| :done()
| |
| row:node(formattedcenter)
| |
|
| |
| if center then
| |
| formattedcenter = mw.html.create('td')
| |
| :attr({align = 'center'})
| |
| :attr({valign = 'middle'})
| |
| :attr({width = widthCenter})
| |
| :css(style)
| |
| :wikitext(center)
| |
| :done()
| |
| row:node(formattedcenter)
| |
| formattedcenter = mw.html.create('td')
| |
| :attr({width = '1%'})
| |
| :css(styleTrans)
| |
| :wikitext('')
| |
| :done()
| |
| row:node(formattedcenter)
| |
| end
| |
|
| |
| local formattedafter
| |
| if after then
| |
| formattedafter = mw.html.create('td')
| |
| :attr({align = 'right'})
| |
| :attr({valign = 'middle'})
| |
| :attr({width = widthCell})
| |
| :css(style)
| |
| :wikitext(after)
| |
| :done()
| |
| row:node(formattedafter)
| |
| formattedbefore = mw.html.create('td')
| |
| :attr({width = '1%'})
| |
| :css(style)
| |
| :wikitext('')
| |
| :done()
| |
| row:node(formattedbefore)
| |
| formattedafter = mw.html.create('td')
| |
| :attr({align = 'right'})
| |
| :attr({valign = 'middle'})
| |
| :attr({width = '5%'})
| |
| :css(style)
| |
| :wikitext(arrowRight)
| |
| :done()
| |
| row:node(formattedafter)
| |
| else
| |
| formattedafter = mw.html.create('td')
| |
| :attr({align = 'right'})
| |
| :attr({valign = 'middle'})
| |
| :attr({width = widthCell})
| |
| :css(styleTrans)
| |
| :wikitext('')
| |
| :done()
| |
| row:node(formattedafter)
| |
| formattedbefore = mw.html.create('td')
| |
| :attr({width = '1%'})
| |
| :css(styleTrans)
| |
| :wikitext('')
| |
| :done()
| |
| row:node(formattedbefore)
| |
| formattedafter = mw.html.create('td')
| |
| :attr({align = 'right'})
| |
| :attr({valign = 'middle'})
| |
| :attr({width = '5%'})
| |
| :css(styleTrans)
| |
| :wikitext('')
| |
| :done()
| |
| row:node(formattedafter)
| |
| end
| |
|
| |
| row:done()
| |
| tabC:node(row)
| |
| tabC:done()
| |
| cellI:node(tabC)
| |
| cellI:done()
| |
| rowI:node(cellI)
| |
| rowI:allDone()
| |
|
| |
| return rowI
| |
| end
| |
| p.buildSuccession = p.buildsuccession
| |
|
| |
| function p.buildrow1col(params)
| |
|
| |
| if not params.value then
| |
| return nil
| |
| end
| |
| | | |
| --local style = params.style or {}
| | if images ~= '' or invImages ~= '' then |
| --style['text-align'] = style['text-align'] or 'center'
| | imageArea = images .. '\n' .. invImages |
| --style['color'] = style['color'] or '#000000'
| |
| --style['background-color'] = style['background-color'] or '#F9F9F9'
| |
| local class = params.class
| |
| local rowcolor
| |
| if params.color == 'secondcolor' then
| |
| rowcolor = secondcolor
| |
| else
| |
| rowcolor = params.color
| |
| end
| |
|
| |
| local style = {}
| |
| style['padding'] = '4px'
| |
| style['text-align'] = 'center'
| |
| style['background-color'] = rowcolor or '#F9F9F9'
| |
| style['color'] = '#000000'
| |
|
| |
| local text = params.value
| |
| | |
| local colspan ='2'
| |
| | |
| local formattedlabel
| |
| formattedlabel = mw.html.create('th')
| |
| :attr({colspan = colspan})
| |
| :css(style)
| |
| :wikitext(text)
| |
| :done()
| |
| | |
| local row = mw.html.create('tr')
| |
| :addClass(class)
| |
| :css(style)
| |
| :node(formattedlabel)
| |
| :done()
| |
|
| |
| return row
| |
| end
| |
| p.buildRow1Col = p.buildrow1col
| |
| | |
| function p.buildtable(params)
| |
| local tab = mw.html.create('table'):css(params.style or {})
| |
| | |
| local rows = params.rows
| |
|
| |
| -- expand parameters so that we have a list of tables
| |
| local i = 1
| |
| | |
| while (i <= #rows) do
| |
| local l = rows[i]
| |
| if type(l) == 'function' then
| |
| l = l(localdata, localdata.item) | |
| end
| |
| if (type(l) == 'table') and (l.type == 'multi') then
| |
| table.remove(rows, i)
| |
| for j, row in ipairs(l.rows) do
| |
| table.insert(rows, i + j - 1, row)
| |
| end
| |
| elseif type(l) == 'nil' then
| |
| table.remove(rows, i)
| |
| elseif type(l) ~= 'table' then
| |
| return error('les lignes d\'infobox ("rows") doivent être des tables, est ' .. type(l))
| |
| else | | else |
| i = i + 1 | | imageArea = 'none' |
| end | | end |
| end
| |
|
| |
| -- CREATE ROW
| |
| local expandedrows = {}
| |
| for k, row in ipairs(rows) do
| |
| local v = p.buildblock(row)
| |
| if v then
| |
| table.insert(expandedrows, v)
| |
| end
| |
| end
| |
| if (#expandedrows == 0) then
| |
| return nil
| |
| end
| |
| rows = expandedrows
| |
|
| |
| -- ADD TITLE
| |
| local title
| |
| if params.title or params.singulartitle or params.pluraltitle then
| |
| local text
| |
| if #rows > 1 and params.pluraltitle then
| |
| text = params.pluraltitle
| |
| elseif #rows == 1 and params.singulartitle then
| |
| text = params.singulartitle
| |
| else
| |
| text = params.title
| |
| end
| |
|
| |
| local style = params.titlestyle or {}
| |
| style['text-align'] = style['text-align'] or 'center'
| |
| style['color'] = style['color'] or thirdcolor
| |
| style['background-color'] = style['background-color'] or maincolor
| |
|
| |
| local colspan ='2'
| |
| title = mw.html.create('caption')
| |
| :attr({colspan = colspan})
| |
| :css(style)
| |
| :wikitext(text)
| |
| :done()
| |
| end
| |
|
| |
| if title then
| |
| tab:node(title)
| |
| end
| |
|
| |
| for i, j in pairs (rows) do
| |
| tab:node(j)
| |
| end
| |
|
| |
| if params.separator then
| |
| local separator = p.separator(params)
| |
| tab:node(separator)
| |
| end | | end |
| tab:allDone()
| | if imageArea and imageArea ~= 'none' then |
| return tab
| | imageArea = '<div class="infobox-imagearea animated-container">' .. imageArea .. '</div>' |
| end
| |
| p.buildTable = p.buildtable
| |
| | |
| function p.buildinvalidblock(args)
| |
| addMaintenanceCat(defaultcat)
| |
| local text = ''
| |
| if type(args) ~= 'table' then | |
| text = "Les blocs d'infobox doivent être des tables" | |
| else | | else |
| text = i18n["invalid block type"] .. ' : ' .. (args.type or '??') | | imageArea = '' |
| end
| |
| return text
| |
| end
| |
| p.buildInvalidBlock = p.buildinvalidblock
| |
| | |
| function p.buildmap(params)
| |
| | |
| -- paramètre d'affichage
| |
| local maplist = getValue(params.maps)
| |
| local pointtype = params.pointtype
| |
| local maptype = params.maptype -- choisit le type de carte le plus approprié (relief, administratif, etc.)
| |
| if type(maplist) == 'function' then
| |
| maplist = maplist(localdata, localdata.item)
| |
| end
| |
| local width = tonumber(params.width) or 280
| |
| if width > 280 then
| |
| addMaintenanceCat("Erreur d'Infobox/Image trop grande")
| |
| return 'image trop grande, la largeur doit être inférieure ou égale à 280px'
| |
| end
| |
| | |
| -- récupération des données locales
| |
| local pointtable = {}
| |
| local globe = params.globe
| |
| if params.latitude then
| |
| local lat, long
| |
| if type(params.latitude) == 'function' then
| |
| lat, long = params.latitude(localdata, localdata.item), params.longitude(localdata, localdata.item)
| |
| else
| |
| lat, long = localdata[params.latitude], localdata[params.longitude]
| |
| end
| |
| if lat then
| |
| table.insert(pointtable, {latitude = lat, longitude = long})
| |
| end
| |
| end
| |
| | |
| -- récupération des données wikidata
| |
| local function processWDval(claim, displayformat)
| |
| if not claim then
| |
| return nil
| |
| end
| |
| local val = wd.formatSnak( claim.mainsnak )
| |
| return {latitude = val.latitude, longitude = val.longitude, globe = val.globe, marker = displayformat.marker}
| |
| end
| |
|
| |
| local function getWDvals(query)
| |
| query.excludespecial = true
| |
| query.numval = query.numval or 1
| |
| query.entity = query.entity or localdata.item
| |
| local claims = wd.getClaims(query)
| |
| if (not claims) then
| |
| return
| |
| end
| |
| for i, claim in ipairs(claims) do
| |
| claim = processWDval(claim, query)
| |
| table.insert(pointtable, claim)
| |
| end
| |
| end
| |
|
| |
| if (#pointtable == 0) and localdata.item and params.wikidata and (params.wikidata ~= '-') then
| |
| for i, query in ipairs(params.wikidata) do
| |
| if type(query) == 'function' then
| |
| query = query()
| |
| end
| |
| if query then
| |
| getWDvals(query)
| |
| end
| |
| end
| |
| end
| |
|
| |
| if (not pointtable) or (#pointtable == 0) then
| |
| return nil
| |
| end | | end |
| | | |
| local newparams = {maplist = maplist, pointtype = pointtype, maptype = maptype, width = width, item = localdata.item, pointtable = pointtable, globe = globe, marker=params.marker, default_zoom=params.default_zoom, ids = params.ids, markercolor = params.markercolor, shapecolor = params.shapecolor } | | local footer = args.footer |
| if params.params and type(params.params) == 'table' then -- paramètres additionnels | | if footer then |
| for i, j in pairs(params.params) do | | footer = '| class="infobox-footer" colspan="2" | ' .. footer |
| newparams[i] = j
| |
| end
| |
| end
| |
| return require('Module:Carte').multimap(newparams)
| |
| end
| |
| p.buildMap = p.buildmap
| |
| | |
| function p.buildexternaltext(params)
| |
| local value = getValue(params.value)
| |
| if value and (type(value) == 'string') then
| |
| externaltext = externaltext .. value
| |
| end
| |
| end
| |
| p.buildExternalText = p.buildexternaltext
| |
| | |
| function p.buildfooter(params)
| |
| if not params then
| |
| params = {}
| |
| end | | end |
| | | |
| local class = 'navbar noprint bordered ' .. (params.class or '') | | local html = { |
| local style = params.style or {}
| | '<div class="notaninfobox">', |
| style['border-top'] = style['border-top'] or '1px solid ' .. maincolor
| | '<div class="mcwiki-header infobox-title">' .. title .. '</div>', |
|
| | imageArea, |
| local backlinkstr = '[' .. tostring( mw.uri.fullUrl( page.name, 'veaction=edit§ion=0' ) ) .. ' ' .. i18n['edit'] .. ']'
| | '{| class="infobox-rows" cellspacing="1" cellpadding="4"', |
| .. ' - [' .. tostring( mw.uri.fullUrl( page.name, 'action=edit§ion=0' ) ) .. ' ' .. i18n['edit code'] .. ']' | | '|-', |
| | | args.rows or '', |
| local itemlinkstr
| | footer or '', |
| if localdata.item then
| | '|}', |
| itemlinkstr = '[[d:' .. localdata.item.id .. '|' .. i18n['edit item'] .. ']]'
| | '</div>' |
| end
| |
| local editstr = backlinkstr
| |
| if itemlinkstr then
| |
| editstr = editstr .. ' - ' .. itemlinkstr
| |
| end
| |
| local editlinkspan = mw.html.create('span')
| |
| :css({['text-align'] = "left"})
| |
| :addClass('plainlinks')
| |
| :wikitext(editstr)
| |
| :done()
| |
| local doclinkstr = '[[Image:Info Simple.svg|12px|link=' .. localdata.templatename .. '|' .. i18n['see doc'] .. ']]'
| |
| -- si ce lien ne marche pas toujours, il faut ajouter un variable pour le nom de l'infobox récupéré par le frame
| |
| local doclinkspan = mw.html.create('span')
| |
| :css({['text-align'] = "right"})
| |
| :wikitext(doclinkstr)
| |
| :done()
| |
|
| |
| local footer = mw.html.create('p')
| |
| :addClass(class)
| |
| :css(style)
| |
| :node(editlinkspan)
| |
| :node(doclinkspan)
| |
| return footer
| |
| end
| |
| p.buildFooter = p.buildfooter
| |
| | |
| function p.buildblock(block)
| |
| if type(block) == 'function' then
| |
| block = block( localdata )
| |
| end
| |
| | |
| local blocktypes = { -- list of functions for block buildings
| |
| ['invalid'] = p.buildinvalidblock,
| |
| ['external text'] = p.buildexternaltext,
| |
| ['footer'] = p.buildfooter,
| |
| ['images'] = p.buildimages,
| |
| ['map']= p.buildmap,
| |
| ['mixed'] = p.buildrow,
| |
| ['navbox'] = p.buildnavbox,
| |
| ['table'] = p.buildtable,
| |
| ['row'] = p.buildrow,
| |
| ['row1col'] = p.buildrow1col,
| |
| ['succession'] = p.buildnavbox,
| |
| ['text'] = p.buildtext,
| |
| ['title'] = p.buildtitle, | |
| } | | } |
| if type(block) ~= 'table' or (not block.type) or (not blocktypes[block.type]) then
| |
| return blocktypes['invalid'](block)
| |
| end
| |
| return blocktypes[block.type](block)
| |
| end
| |
| p.buildBlock = p.buildblock
| |
|
| |
| function p.build()
| |
| | | |
| localdata = require( 'Module:Infobox/Localdata' ) | | return table.concat( html, '\n' ) |
| item = localdata.item
| |
| | |
| -- assign rank to the infobox, "secondary" means special formatting like no displaytitle for coordinates
| |
| local infoboxrank = 'main' -- main infobox of the page, with coordinates displayed in title etc.
| |
| if page.namespace ~= 0 then
| |
| infoboxrank = 'secondary'
| |
| end
| |
| -- if infobox is linked to another item: rank = secondary
| |
| if localdata.item then
| |
| local itemlink = mw.wikibase.sitelink(localdata.item.id)
| |
| local pagetitle = mw.title.getCurrentTitle().text
| |
| if (itemlink or '') ~= pagetitle then
| |
| infoboxrank = 'secondary'
| |
| end
| |
| end
| |
| localdata.infoboxrank = infoboxrank
| |
| | |
| -- load infobox module page
| |
| local moduledata = require('Module:Infobox/' .. localdata.modulename)
| |
| moduledata.name = localdata.modulename
| |
| -- defines main color
| |
| maincolor = localdata['couleur infobox'] or localdata['couleur boîte'] or moduledata.maincolor or maincolor
| |
| secondcolor = moduledata.secondcolor or secondcolor
| |
| thirdcolor = localdata['texte noir'] or localdata['couleur texte'] or moduledata.thirdcolor or thirdcolor
| |
| if maincolor:match( '^%x%x%x%x%x%x$' ) or maincolor:match( '^%x%x%x$' ) then
| |
| maincolor = '#' .. maincolor
| |
| end
| |
| if thirdcolor:match ('oui') or thirdcolor:match( 'true' ) then
| |
| thirdcolor = '#000'
| |
| end
| |
| if thirdcolor:match ('non') or thirdcolor:match( 'false' ) then
| |
| thirdcolor = '#fff'
| |
| end
| |
|
| |
| -- class
| |
| local class = 'infobox_v3 large'
| |
| if moduledata.class then
| |
| class = class .. ' ' .. moduledata.class
| |
| end
| |
|
| |
| -- style
| |
| local style = moduledata.style or {}
| |
|
| |
| -- build infobox
| |
| infobox :addClass(class)
| |
| :css(style)
| |
| for i, j in pairs( moduledata.parts ) do
| |
| infobox:node( p.buildblock(j) )
| |
| end
| |
| infobox :node(p.buildfooter(moduledata.footer))
| |
| :done()
| |
| | |
| return tostring(infobox) .. externaltext, maintenance
| |
| end | | end |
|
| |
|
| return p | | return p |