Modul:Vorlage:Infobox Sendeanlage/Aufbereitung

aus Wikipedia, der freien Enzyklopädie
-- Auslesen der Deteils zu Regionen ueber Wiki-Vorlage
function REG( Level, Info, DatenWL, frame )
	--[[ Rueckgabewert erzeugt 'Info ISO-3166-2' fuer den Parser. Muster:
		 - REG2: '{{Info ISO-3166-2|code={{{REGION-ISO|}}}|name}}'
		 - REG1: '{{Info ISO-3166-2|code={{Info ISO-3166-2|code={{{REGION-ISO|}}}|upper}}|name}}'
		 - REG0: '{{Info ISO-3166-2|code={{Info ISO-3166-2|code={{{REGION-ISO|}}}|top}}|name}}'
	]]
	
	local VR = {
		REGION_ISO = { I = mw.getCurrentFrame():getParent().args["REGION-ISO"] },
		title = "Info ISO-3166-2"
	}
	if (VR.REGION_ISO.I == "" or VR.REGION_ISO.I == nil) then VR.REGION_ISO.I = frame.args["REGION-ISO"] end
	if (VR.REGION_ISO.I == "" or VR.REGION_ISO.I == nil) then VR.REGION_ISO.I = DatenWL["REGION-ISO"] end
	if VR.REGION_ISO.I == "" then VR.REGION_ISO.I = nil end
	VR.code = { II = VR.REGION_ISO.I }
	VR.code.Y = { O = "top", I = "upper" }
	VR.code.X = VR.code.Y[Level] or ""
	VR.code.I = frame:expandTemplate{ title = "Info ISO-3166-2", args = { VR.code.X, code = VR.code.II } }
	VR.code.O = VR.code.I
	VR.args = {
		Info,
		code = VR.code[Level]
	}
	return frame:expandTemplate{ title = VR.title, args = VR.args }
end

-- Zaehlung, wie viele Parameter vorhanden sind
function ZDS( ZG, Zmax )
	local Aussage = false
	local max = 0
	for ZGk, ZGv in pairs( ZG ) do
		if ZGv[2] then max = max + 1 end
	end
	if max > Zmax then Aussage = true end
	return Aussage
end

local p = {}

--	Ausgabe einer Fehlermeldung
p.Fehler = function ( Meldung )
	local Text = tostring( Meldung ) or "\'\'Fehlertext fehlt!\'\'"
	local Anzeige = mw.html.create( "div" )
		:attr( "class", "error rahmenfarbe3 hintergrundfarbe8" ) 
		:css( "font-size", "120%" )
		:css( "font-weight", "bold" )
		:css( "text-align", "center" )
		:css( "border-style", "solid" )
		:css( "border-width", "2px" )
		:css( "padding", ".5em" )
		:css( "margin", ".25em" )
		:wikitext( Text )
	return tostring( Anzeige )
end

--	Anzeige Rahmen
p.Rahmen = function ( TXT, Ue )
	local LA = { { " rahmenfarbe2", " border-width:1px; border-style:solid;", "" }, { "", "", "\n! colspan=\"2\" class=\"hintergrundfarbe9\" style=\"text-align:center;\" | " .. tostring( Ue ) } }
	local Text = { { "Anzuzeigende Eigenschaft", "Anzuzeigender Text" } }
	local Einheit = ""
	local Un = 1
	if Ue then Un = 2 end
	if type( TXT ) == "table" then Text = TXT end
	local Inhalt = "\n{| class=\"toptextcells" .. LA[Un][1] .. "\" style=\"font-size:90%; text-align:left; width:90%; margin:0em auto;" .. LA[Un][2] .. "\"" .. LA[Un][3]
	for TXTi, TXTv in pairs(Text) do
		if (type( TXTv ) == "table" ) then
			if (TXTv[2] and TXTv[2] ~= "") then
				Einheit = TXTv[3] or ""
				Inhalt = Inhalt .. "\n|-\n| " .. tostring( TXTv[1] ) .. ":\n| " .. tostring( TXTv[2] .. Einheit )
			end
		end
	end
	Inhalt = Inhalt .. "\n|}\n"
	return Inhalt
end

--	Werte aus Artikel in Daten einsortieren und splitten
p.AufarbStand = function ( Datensatz, DSZusatz, Kategorie, frame )
	local DS = Datensatz --         zu bearbeitender Datensatz
	local Kategorien = Kategorie -- Speicher fuer Kategorien
	DS.TMP = { } --                 temporaerer Speicher
	DS.WertZeile = mw.getCurrentFrame():getParent().args[DS.Name]
	if (DS.WertZeile == "" or DS.WertZeile == nil) then DS.WertZeile = frame.args[DS.Name] end
	if (DS.WertZeile == "" or DS.WertZeile == nil) then DS.WertZeile = DSZusatz.DatenWL[DS.Name] end
	if DS.Standard then
		if (DS.WertZeile == "" or DS.WertZeile == nil) then DS.WertZeile = DS.Standard[DSZusatz.Typ] end
		if (DS.WertZeile == "" or DS.WertZeile == nil) then DS.WertZeile = DS.Standard[1] end
	end
	if DS.WertZeile == nil then DS.WertZeile = "" end
	DS.WertSplit = mw.text.split( DS.WertZeile, "/" )
	if DS.WertZeile == "" then DS.WertZeile = nil end
	if DS.WertSplit[1] == "" then DS.WertSplit[1] = nil end
	DS.AnzSplit = table.maxn( DS.WertSplit )
	
	--	Auswahl der Bezeichnung 'Typ' zu 'BauTyp'
	DS.TMP.Z = DS.Typ or { "Zeile" }
	DS.BauTyp = DS.TMP.Z[DSZusatz.Typ] or DS.TMP.Z[1]
	
	--	Textverlinkung und Einheitsanbindung
	DS.TMP.EHT = { "", "" } -- Formatierung der Einheiten zur Wiedergabe
	DS.TMP.LIZ = ""         -- resultierende Einheiten(-verlinkung)
	DS.TMP.LTR = DSZusatz.Aufzaehler[DS.BauTyp] or "/" -- Trennzeichen bei Aufsplittung
	DS.TMP.AFZ = DSZusatz.Aufzaehlung[DS.Name] or { } --  Aufzaehlung
	DS.TMP.Liste = "" --       Auflistung der Werte
	DS.TMP.AZ = { } --         Aufzaehler als Tabelle aller, z.B. 'VERW'
	DS.TMP.WSL = { } --        WertSplitLink als Tabelle
	
		--	Einheiten-Auswaehler
	if DS.Einheit then
		if (type( DS.Einheit[1] ) == "string" and DS.Einheit[1] ~= "") then
			DS.TMP.EHT[1] = " " .. DS.Einheit[1]
			DS.TMP.EHT[2] = DS.TMP.EHT[1]
			if (type( DS.Einheit[2] ) == "string" and DS.Einheit[2] ~= "") then
				DS.TMP.EHT[2] = " [[" .. DS.Einheit[2] .. "|" .. DS.Einheit[1] .. "]]"
			end
		end
	end
	
		--	Durchlauf Zaehlinstanz
	for j, ZS in pairs(DS.WertSplit) do
			-- Standardsetzung entsprechend Bauwerktyp
		DS.TMP.tf = true
		if DS.TMP.AFZ[ZS] then
			DS.TMP.AFZ[ZS][1] = DS.TMP.AFZ[ZS][1] or { }
			DS.TMP.AFZ[ZS][2] = DS.TMP.AFZ[ZS][2] or { }
			DS.TMP.AFZ[ZS][3] = DS.TMP.AFZ[ZS][3] or { }
			DS.TMP.AFZ[ZS][4] = DS.TMP.AFZ[ZS]["CatTyp"] or { }
			if DS.TMP.AFZ[ZS][1][DSZusatz.Typ] == false then DS.TMP.tf = false end
		end
		if DS.TMP.tf == false then DS.TMP.AFZ[ZS] = nil end
		
			-- Durchzaehler fuer Werte in VERW + T_HOCH etc.
		if DS.TMP.AFZ[ZS] then
			DS.TMP.STAZ = { "\'\Wert unbekannt\'\'", "\'\Wert unbekannt\'\'" }
			for k=1, 4, 1 do -- Ermittlung Standardwerte
				DS.TMP.STAZ[k] = DS.TMP.AFZ[ZS][k][DSZusatz.Typ] or DS.TMP.AFZ[ZS][k][1]
			end
			if (type( DS.TMP.STAZ[3] ) == "string" and DS.TMP.STAZ[3] ~= "" ) then
				table.insert( Kategorien, { DS.TMP.STAZ[3], DS.TMP.AFZ[ZS]["Geo"], DS.TMP.STAZ[4], Name = DS.Name .. DS.TMP.STAZ[1] } )
			end
			DS.TMP.AZ[j] = DS.TMP.STAZ
		else
			DS.TMP.AZ[j] = { ZS, ZS, nil }
		end
		if j < 2 then
			DS.TMP.LIZ = DS.TMP.EHT[2]
		else
			DS.TMP.Liste = DS.TMP.Liste .. DS.TMP.LTR
			DS.TMP.LIZ = DS.TMP.EHT[1]
		end
		if DS.WertZeile then DS.TMP.Liste = DS.TMP.Liste .. DS.TMP.AZ[j][2] .. DS.TMP.LIZ end
		DS.TMP.WSL[j] = DS.TMP.AZ[j][2]
	end
	DS.WertSplitLink = DS.TMP.WSL
	if DSZusatz.Aufzaehler[DS.BauTyp] then DS.WertZeile = DS.TMP.Liste end
	if DS.WertZeile == "" then DS.WertZeile = nil end
	
	--	Eigenschaften beschriften (Einzahl / Mehrzahl / Typ)
	DS.TMP.EW = DS.Label -- Eigenschaften-Werte
	if DS.TMP.EW then
		DS.TMP.EW = DS.Label[DSZusatz.Typ]
		if not DS.TMP.EW then DS.TMP.EW = DS.Label[1] end
		if not DS.TMP.EW then DS.TMP.EW = { "" } end
		DS.TMP.EW[2] = DS.TMP.EW[2] or DS.TMP.EW[1]
		if DS.AnzSplit > 1 then
			DS.AnzLabel = DS.TMP.EW[2]
		else
			DS.AnzLabel = DS.TMP.EW[1]
		end
	else
		DS.AnzLabel = ""
	end
	
	DS.TMP = nil
	return { DS = DS, Kategorien = Kategorien }
end

p.DSIB = {}
	-- NAME Festlegen
p.DSIB.NAME = function ( DN, DSZusatz, Kategorien, frame )
	DN.NAME.WertZeile = DSZusatz.NNAME
	return DN
end

	-- Ueberschrift der Infobox
p.DSIB.UE1 = function ( DN, DSZusatz, Kategorien, frame )
	local DSMB = {}
	DSMB.Bezeichner = mw.html.create( "div" )
		:css( "width", "100%" )
		:wikitext( DN.NAME.WertZeile )
	DSMB[1] = tostring( DSMB.Bezeichner )
	
	DSMB.Bezeichner = mw.html.create( "div" )
		:css( "font-size", "90%" )
		:css( "width", "100%" )
		:wikitext( tostring( DN.OFZ_NAME.WertZeile ) )
	DSMB[2] = tostring( DSMB.Bezeichner )
	
	DSMB.Bezeichner = mw.html.create( "div" )
		:css( "font-size", "70%" )
		:css( "font-style", "italic" )
		:css( "width", "100%" )
		:wikitext( tostring( DN.FUNK_NAME.WertZeile ) )
	DSMB[3] = tostring( DSMB.Bezeichner )
	
	if not DN.OFZ_NAME.WertZeile then DSMB[2] = nil end
	if not DN.FUNK_NAME.WertZeile then DSMB[3] = nil end
	if not DSMB[2] then
		DSMB[2] = DSMB[3]
		DSMB[3] = nil
	end
	
	DN.UE1.WertSplit = { DSMB[1], DSMB[2], DSMB[3] }
	DN.UE1.AnzSplit = table.maxn( DN.UE1.WertSplit )
	DN.UE1.WertZeile = ""
	for DSMBk, DSMBv in pairs( DN.UE1.WertSplit ) do
		DN.UE1.WertZeile = DN.UE1.WertZeile .. DSMBv
	end
	
	return DN
end

	-- Anzeige Bild
p.DSIB.IBBild = function ( DN, DSZusatz, Kategorien, frame )
	local DSMB = { BILD = { }, TMP = { } }
	DSMB.BILD = {
		Bmax = 360,
		Hmax = 500,
		Amax = 48000,
		Titel = ""
	}
	DSMB.BILD.Datei = DN.BILD.WertZeile or "kein Bild"
	DSMB.BILD.Datei = DSMB.BILD.Datei:gsub("[%[%]]", "")
	DSMB.BILD.Beschreibung = DN.BILD_BES.WertZeile or ""
	if mw.title.new( DSMB.BILD.Datei, 6 ) then 
		DSMB.BILD.B = mw.title.new( DSMB.BILD.Datei, 6 ).file.width
		DSMB.BILD.H = mw.title.new( DSMB.BILD.Datei, 6 ).file.height
	end
	DN.TMP_KAT = { } -- Zwischenspeicher fuer Kategorien
	
	--	Bilderwunsch aus Wiki-Vorlage generieren
	DSMB.BW = {
		title = "Bilderwunsch/encode",
		args = {
			Ort = DN.ORT.WertZeile,
			Name = DSZusatz.NNAME,
			KoordLat = "",
			KoordLon = ""
		}
	}
	if (type(DN.NS.WertZeile) == "string" and type(DN.NS.WertSplit[1]) == "number") then DSMB.BW.args.KoordLat = tostring( DN.NS.WertSplit[1] ) end
	if (type(DN.EW.WertZeile) == "string" and type(DN.EW.WertSplit[1]) == "number") then DSMB.BW.args.KoordLon = tostring( DN.EW.WertSplit[1] ) end
	DSMB.BILDERWUNSCH = frame:expandTemplate{ title = DSMB.BW.title, args = DSMB.BW.args } or ""
	
	--	'WertZeile' bereitstellen
	if (DN.BILD.WertZeile == "kein" or DN.BILD.WertZeile == "keine" or DN.BILD.WertZeile == "nein" or DN.BILD.WertZeile == "no" or DN.BILD.WertZeile == "none" or DN.BILD.WertZeile == "aus" or DN.BILD.WertZeile == "ohne") then
		table.insert( DN.TMP_KAT, { "Wikipedia:Bilderwunsch unterdrückt", Name = "istversteckt" } )
	elseif (not DN.BILD.WertZeile and not DN.ABR_DEKADE.WertZeile ) then
		DN.IBBild.WertZeile = "[[Datei:Photo-request.svg|64px|link=Wikipedia:Bilderwünsche/Anleitung]]<br />[[Wikipedia:Bilderwünsche/Anleitung|Bild&nbsp;gesucht]]"
		if DSZusatz.NSP == 0 then DN.IBBild.WertZeile = DN.IBBild.WertZeile .. "\n" .. DSMB.BILDERWUNSCH end
	elseif not (DSMB.BILD.B and DSMB.BILD.H) then
		if not DN.ABR_DEKADE.WertZeile then DN.IBBild.WertZeile = DSZusatz.Aufbereitung.Fehler( "Angegebene Bilddatei „" .. DSMB.BILD.Datei .. "“ ist nicht verfügbar." ) end
	elseif DN.BILD.WertZeile then
		DSMB.BILD.A = DSMB.BILD.B * DSMB.BILD.H  --                    Flaeche
		DSMB.BILD.SV = DSMB.BILD.B / DSMB.BILD.H --                    Seitenverhaeltnis
		DSMB.BILD.Borg = math.sqrt( DSMB.BILD.Amax * DSMB.BILD.SV ) -- Breite gem. SV
		DSMB.BILD.Horg = DSMB.BILD.Borg / DSMB.BILD.SV --              Hoehe gem. SV
		if DSMB.BILD.Borg > DSMB.BILD.Bmax then
			DSMB.BILD.BBild = DSMB.BILD.Bmax
			DSMB.BILD.HBild = DSMB.BILD.BBild / DSMB.BILD.SV
		elseif DSMB.BILD.Horg > DSMB.BILD.Hmax then
			DSMB.BILD.HBild = DSMB.BILD.Hmax
			DSMB.BILD.BBild = DSMB.BILD.HBild * DSMB.BILD.SV
		else
			DSMB.BILD.BBild = DSMB.BILD.Borg
			DSMB.BILD.HBild = DSMB.BILD.Horg
		end
		DSMB.BILD.BBild = math.floor( DSMB.BILD.BBild )
		DSMB.BILD.HBild = math.floor( DSMB.BILD.HBild )
		
		-- Anpassung Titel
		DSMB.TMP.html = {
			{ "<br />", " " },
			{ "<small>", "" },
			{ "</small>", "" }
		}
		DSMB.BILD.Titel = DSMB.BILD.Beschreibung
		if DSMB.BILD.Titel == "" then DSMB.BILD.Titel = "Datei:" .. DSMB.BILD.Datei end
		for HTMLk, HTMLv in pairs( DSMB.TMP.html ) do
			DSMB.TMP.Text = ""
			DSMB.TMP.Split = mw.text.split( DSMB.BILD.Titel, HTMLv[1] )
			for BITk, BITv in pairs( DSMB.TMP.Split ) do
				if BITk > 1 then DSMB.TMP.Text = DSMB.TMP.Text .. HTMLv[2] end
				DSMB.TMP.Text = DSMB.TMP.Text .. BITv
			end
			DSMB.BILD.Titel = DSMB.TMP.Text
		end
		
		-- Anzeige des Bildes
		DSMB.Anzeige = mw.html.create( "div" )
			:css( "font-size", "85%" )
			:wikitext( "[[Datei:" .. DSMB.BILD.Datei .. "|" .. DSMB.BILD.BBild .. "x" .. DSMB.BILD.HBild ..  "px|center|" .. DSMB.BILD.Titel .. "|alt=Bild des Objektes]]" .. DSMB.BILD.Beschreibung )
		DN.IBBild.WertZeile = tostring( DSMB.Anzeige )
	end
	
	return DN
end

	-- Regionen
p.DSIB.Regionen = function ( DN, DSZusatz, Kategorien, frame )
	local DSMB = ""
	if DSZusatz.REGION["0"] then
		DN.REGION_0.WertZeile = "[[" .. DSZusatz.REGION["0"]["lemma"] .. "|" .. DSZusatz.REGION["0"]["name"] .. "]]"
	else
		DN.REGION_0.BauTyp = "Feld"
		DN.REGION_0.AnzLabel = ""
		if DN["REGION-ISO"]["WertZeile"] then
			DSMB = "Es ist ein falscher"
		else
			DSMB = "Es ist kein"
		end
		DN.REGION_0.WertZeile = DSZusatz.Aufbereitung.Fehler( DSMB .. " Wert für den Parameter „REGION-ISO“ eingetragen!<br />→&nbsp;[[ISO-3166-1-Kodierliste|siehe Kodierliste]]" )
	end
	if DSZusatz.REGION["1"] then
		DN.REGION_1.AnzLabel = DSZusatz.REGION["1"]["admtype"]
		DN.REGION_1.WertZeile = "[[" .. DSZusatz.REGION["1"]["lemma"] .. "|" .. DSZusatz.REGION["1"]["name"] .. "]]"
	end
	if DSZusatz.REGION["2"] then
		DN.REGION_2.AnzLabel = DSZusatz.REGION["2"]["admtype"]
		DN.REGION_2.WertZeile = "[[" .. DSZusatz.REGION["2"]["lemma"] .. "|" .. DSZusatz.REGION["2"]["name"] .. "]]"
	end
	
	return DN
end
	-- Hoehenlage
p.DSIB.LAGEPUNKT = function ( DN, DSZusatz, Kategorien, frame )
	local DSMB = DN.LAGEPUNKT.WertZeile or ""
	DN.LAGEPUNKT.WertSplit[1] = tonumber( DN.LAGEPUNKT.WertSplit[1] ) or DN.LAGEPUNKT.WertSplit[1]
	if not DN.LAGEPUNKT.WertSplit[2] then
		if DSZusatz.REGION["0"] then
			DN.LAGEPUNKT.WertSplit[2] = DSZusatz.REGION["0"]["acronym"]
		else
			DN.LAGEPUNKT.WertSplit[2] = ""
		end
	end
	if DN.LAGEPUNKT.WertSplit[2] == "CH" then DN.LAGEPUNKT.WertSplit[2] = "CH-m" end
	if DN.LAGEPUNKT.WertSplit[2] == "LI" then DN.LAGEPUNKT.WertSplit[2] = "LI-m" end
	DN.LAGEPUNKT.WertZeile = frame:expandTemplate{ title = "Höhe", args = { tostring( DN.LAGEPUNKT.WertSplit[1] ), DN.LAGEPUNKT.WertSplit[2] } }
	if DSMB == "" then DN.LAGEPUNKT.WertZeile = nil end
	if DN.LAGEPUNKT.WertSplit[2] == "" then DN.LAGEPUNKT.WertSplit[2] = nil end
	
	return DN
end

	-- Zugaenglichkeit
p.DSIB.ZUGANG = function ( DN, DSZusatz, Kategorien, frame )
	local DSMB = DSZusatz.Bezeichner[DSZusatz.Typ] or DSZusatz.Bezeichner[DSZusatz.Bezeichner[1]]
	if DN.ZUGANG.WertZeile == "ja" then
		DN.ZUGANG.WertZeile = DSMB .. " öffentlich zugänglich"
	elseif DN.ZUGANG.WertZeile == "jein" then
		DN.ZUGANG.WertZeile = DSMB .. " nach Voranmeldung zugänglich"
	elseif DN.ZUGANG.WertZeile == "nein" then
		DN.ZUGANG.WertZeile = DSMB .. " öffentlich nicht zugänglich"
	end
	if ( DN.ABR_DEKADE.WertZeile and DSZusatz.Typ ~= "Anlage") then DN.ZUGANG.BauTyp = "Ausblenden" end
	
	return DN
end

	-- Zusammenfassung fuer Turmbau
p.DSIB.IBTBau = function ( DN, DSZusatz, Kategorien, frame )
	local DSMB = { }
	DSMB.Tabelle = {
		{ DN.T_BAU_KOST.AnzLabel, DN.T_BAU_KOST.WertZeile },
		{ DN.T_BAU_HERR.AnzLabel, DN.T_BAU_HERR.WertZeile },
		{ DN.T_BAU_ARCH.AnzLabel, DN.T_BAU_ARCH.WertZeile },
		{ DN.T_BAU_ST.AnzLabel, DN.T_BAU_ST.WertZeile }
	}
	if DN.T_BAU_ZEIT.WertZeile then
		DN.IBTBau.ausklappen = "Weitere Baudaten"
	else
		DN.IBTBau.AnzLabel = "Baudaten:"
	end
	DSMB.Anzeige = ZDS( DSMB.Tabelle, 1 )
	if DSMB.Anzeige == true then
		DN.IBTBau.WertZeile = DSZusatz.Aufbereitung.Rahmen( DSMB.Tabelle )
		DN.T_BAU_KOST.BauTyp = "Ausblenden"
		DN.T_BAU_HERR.BauTyp = "Ausblenden"
		DN.T_BAU_ARCH.BauTyp = "Ausblenden"
		DN.T_BAU_ST.BauTyp = "Ausblenden"
	else
		DN.IBTBau.BauTyp = "Ausblenden"
	end
	
	return DN
end

	-- Zusammenfassung fuer Turm-Einzelhoehen
p.DSIB.IBTHoch = function ( DN, DSZusatz, Kategorien, frame )
	local DSMB = { }
	DSMB.Tabelle = {
		{ DN.T_HOCH_AUS.AnzLabel, DN.T_HOCH_AUS.WertZeile },
		{ DN.T_HOCH_RES.AnzLabel, DN.T_HOCH_RES.WertZeile },
		{ DN.T_HOCH_BET.AnzLabel, DN.T_HOCH_BET.WertZeile }
	}
	if DN.T_HOCH_GES.WertZeile then
		DN.IBTHoch.ausklappen = "Weitere Höhenwerte"
	else
		DN.IBTHoch.AnzLabel = "Höhenwerte im Detail:"
	end
	DSMB.Anzeige = ZDS( DSMB.Tabelle, 1 )
	if DSMB.Anzeige == true then
		DN.IBTHoch.WertZeile = DSZusatz.Aufbereitung.Rahmen( DSMB.Tabelle )
		DN.T_HOCH_AUS.BauTyp = "Ausblenden"
		DN.T_HOCH_RES.BauTyp = "Ausblenden"
		DN.T_HOCH_BET.BauTyp = "Ausblenden"
	else
		DN.IBTHoch.BauTyp = "Ausblenden"
	end
	
	return DN
end

	-- Zusammenfassung fuer Sendeanlagen-Einzelheiten
p.DSIB.IBSHoch = function ( DN, DSZusatz, Kategorien, frame )
	DN.IBSHoch.ausklappen = "Daten zu den einzelnen Sendetürmen/Sendemasten"
	local DSMB = { }
	DSMB.Tabelle = {
		{ "Höhe", DN.S_HOCH_GES.WertZeile, DN.S_HOCH_GES.WertSplit, DN.S_HOCH_GES.AnzSplit, Name = "S_HOCH_GES", Einheit = "&nbsp;m" },
		{ "Bauzeit", DN.S_BAU_ZEIT.WertZeile, DN.S_BAU_ZEIT.WertSplit, DN.S_BAU_ZEIT.AnzSplit, Name = "S_BAU_ZEIT" },
		{ "Betriebszeit", DN.S_BET_ZEIT.WertZeile, DN.S_BET_ZEIT.WertSplit, DN.S_BET_ZEIT.AnzSplit, Name = "S_BET_ZEIT" },
		{ "Umbau Antenne", DN.S_ANT_BAU.WertZeile, DN.S_ANT_BAU.WertSplit, DN.S_ANT_BAU.AnzSplit, Name = "S_ANT_BAU" },
		{ "Umbau Sender", DN.S_UMBAU.WertZeile, DN.S_UMBAU.WertSplit, DN.S_UMBAU.AnzSplit, Name = "S_UMBAU" },
		{ "Stilllegung Sender", DN.S_STILL.WertZeile, DN.S_STILL.WertSplit, DN.S_STILL.AnzSplit, Name = "S_STILL" }
	}
	
	--	Maximale Datensatz-Anzahl:
	DSMB.max = 0 --     Ermittlung maximale Turmanzahl, Einzel
	DSMB.SatzMax = 0 -- Ermittlung maximale Turmanzahl, Gesamt
	for maxK, maxV in pairs( DSMB.Tabelle ) do
		if maxV[2] == "" then DSMB.max = 0 else DSMB.max = maxV[4] end 
		DSMB.SatzMax = math.max( DSMB.SatzMax, DSMB.max )
	end
	
	--	Sortierung nach Turm/Mast:
	local Einheit = ""
	DSMB.Komplett = { } -- Komplett-Zusammenstellung nach Turm/Mast
	DSMB.leer = "style=\"text-align:center;\" | –"
	for ZZ=1, DSMB.SatzMax, 1 do
		DSMB.Komplett[ZZ] = { }
		for ZZk, ZZv in pairs( DSMB.Tabelle ) do
			Einheit = ZZv.Einheit or ""
			DSMB.Komplett[ZZ][ZZk] = { ZZv[1], DSMB.leer, Einheit }
			if ZZv[3] == nil then ZZv[3] = { } end
			if (ZZv[3][ZZ] and ZZv[3][ZZ] ~= "") then DSMB.Komplett[ZZ][ZZk][2] = ZZv[3][ZZ] end
		end
	end
	
	--	Leere erkennen
	DSMB.Grundsatz = { }
	DSMB.Box = false
	DSMB.DSHoch = 1
	for dslMk, dslMv in pairs( DSMB.Tabelle ) do
		if dslMv["Name"] == "S_HOCH_GES" then DSMB.DSHoch = dslMk end
		if (DN[dslMv["Name"]]["WertZeile"] and DN[dslMv["Name"]]["BauTyp"] == "Liste" and (DSMB.Tabelle[dslMk][4] > 1 or dslMv["Name"] == "S_HOCH_GES")) then
			DSMB.Grundsatz[dslMk] = true
			if dslMv["Name"] ~= "S_HOCH_GES" then
				DN[dslMv["Name"]]["BauTyp"] = "Ausblenden"
				DSMB.Box = true
			end
		else
			DSMB.Grundsatz[dslMk] = false
		end
	end
	if (DSMB.Box == false or DN[DSMB.Tabelle[DSMB.DSHoch]["Name"]]["BauTyp"] ~= "Liste") then
		DSMB.Grundsatz[DSMB.DSHoch] = false
	else
		DN[DSMB.Tabelle[DSMB.DSHoch]["Name"]]["BauTyp"] = "Ausblenden"
	end
	for ZX=1, DSMB.SatzMax, 1 do -- leere aussortieren
		for ZXk, ZXv in pairs( DSMB.Komplett[ZX] ) do
			if DSMB.Grundsatz[ZXk] == false then ZXv[2] = nil end
		end
	end
	
	--	Liste anzeigen:
	if DSMB.Box == true then
		DN.S_ANZAHL_T.BauTyp = "Ausblenden"
		for XX=1, DSMB.SatzMax, 1 do
				if XX == 1 then
					DN.IBSHoch.WertZeile = ""
				else
					DN.IBSHoch.WertZeile = DN.IBSHoch.WertZeile .. "\n"
				end
				DN.IBSHoch.WertZeile = DN.IBSHoch.WertZeile .. DSZusatz.Aufbereitung.Rahmen( DSMB.Komplett[XX], "Turm/Mast " .. tostring( XX ) )
		end
	else
		DN.IBSHoch.BauTyp = "Ausblenden"
	end
	if DN.IBSHoch.WertZeile == "" then DN.IBSHoch.WertZeile = nil end
	
	return DN
end
	-- Gueltigkeitspruefung 'KOORDINATEN'
p.DSIB.KOORDINATEN = function ( DN, DSZusatz, Kategorien, frame )
	local DSMB = { }
	DSMB.KO = { { "NS", P = "N", N = "S" } , { "EW", P = "E", N = "W" } }
	DSMB.ZeilenSpeicher = { }
	DSMB.ist = { NS = true, EW = true }
	
	for KONk, KONv in pairs( DSMB.KO ) do
		DSMB.ZeilenSpeicher.Komma = 0
		for WKk, WKv in pairs( DN[KONv[1]]["WertSplit"] ) do
			if (tonumber( WKv ) and WKk < 4 ) then
				DSMB.ZeilenSpeicher.Komma = DSMB.ZeilenSpeicher.Komma + tonumber( WKv ) / (60 ^ ( WKk - 1 ))
			elseif ( WKv == KONv.P and WKk > 1 and WKk < 5 ) then
				DSMB.ZeilenSpeicher.Komma = DSMB.ZeilenSpeicher.Komma * 1
			elseif ( WKv == KONv.N and WKk > 1 and WKk < 5 ) then
				DSMB.ZeilenSpeicher.Komma = DSMB.ZeilenSpeicher.Komma * -1
			else
				DSMB.ist[KONv[1]] = false
			end
		end
		if not DN[KONv[1]]["WertSplit"][1] then DSMB.ist[KONv[1]] = false end
		if DSMB.ist[KONv[1]] == true then
			if ( (DSMB.ZeilenSpeicher.Komma * 10^8 - math.floor( DSMB.ZeilenSpeicher.Komma * 10^8 )) * 10 ) < 5 then
				DSMB.ZeilenSpeicher.Komma = math.floor( DSMB.ZeilenSpeicher.Komma * 10^8 ) / ( 10^8 )
			else
				DSMB.ZeilenSpeicher.Komma = math.floor( DSMB.ZeilenSpeicher.Komma * 10^8 + 1 ) / ( 10^8 )
			end
			if (( DSMB.ZeilenSpeicher.Komma > 90 * KONk) or ( DSMB.ZeilenSpeicher.Komma < -90 * KONk) ) then DSMB.ist[KONv[1]] = false end
			DN[KONv[1]]["WertSplit"][1] = DSMB.ZeilenSpeicher.Komma
			DN[KONv[1]]["AnzSplit"] = 1
			if DSMB.ist[KONv[1]] == true then
				DN[KONv[1]]["WertZeile"] = tostring( DSMB.ZeilenSpeicher.Komma )
			else
				DN[KONv[1]]["WertZeile"] = nil
			end
		else
			DN[KONv[1]]["WertSplit"][1] = DN[KONv[1]]["WertZeile"]
			DN[KONv[1]]["WertZeile"] = nil
			DN[KONv[1]]["AnzSplit"] = 1
		end
		if not DN[KONv[1]]["WertSplit"][1] then DN[KONv[1]]["AnzSplit"] = 0 end
	end
	
	return DN
end

	-- Positionskarte 'POSKARTE'
p.DSIB.POSKARTE = function ( DN, DSZusatz, Kategorien, frame )
	local DSMB = { Karte = { }, TMP = { } }
	if (DN.POSKARTE.WertZeile == "kein" or DN.POSKARTE.WertZeile == "keine" or DN.POSKARTE.WertZeile == "nein" or DN.POSKARTE.WertZeile == "no" or DN.POSKARTE.WertZeile == "aus" or DN.POSKARTE.WertZeile == "ohne") then
		DSMB.anzeigen = false
	else
		DSMB.anzeigen = true
	end
	
	-- Anzeige Positionskarte
	if (DSZusatz.REGION["0"] and DN.NS.WertZeile and DN.EW.WertZeile and DSMB.anzeigen == true) then
		DSMB.PK = {
			title = "Positionskarte",
			args = {
				"Welt",
				border = "none",
				float = "inline",
				width = "360",
				maptype = "relief",
				label = DSZusatz.NNAME,
				label_size = "75%",
				background = "#fff4d5",
				lat = tostring( DN.NS.WertSplit[1] ),
				long = tostring( DN.EW.WertSplit[1] ),
				type = "building",
				name = DSZusatz.NNAME,
				region = DN["REGION-ISO"]["WertZeile"],
				Breite = nil
			}
		}
		DSMB.TMP.DL = 1
		DSMB.Karte[1] = {
			G = "Welt",
			Bmax = 360,
			Hmax = 1000,
			Amax = 48000
		}
		if DSZusatz.REGION["0"] then DSMB.Karte[1]["G"] = DSZusatz.REGION["0"]["map"] or DSMB.Karte[1]["G"] end
		if DSZusatz.REGION["1"] then DSMB.Karte[1]["G"] = DSZusatz.REGION["1"]["map"] or DSMB.Karte[1]["G"] end
		if DSZusatz.REGION["2"] then DSMB.Karte[1]["G"] = DSZusatz.REGION["2"]["map"] or DSMB.Karte[1]["G"] end
		if DN.POSKARTE.WertSplit[1] then
			if mw.getCurrentFrame():callParserFunction( "#ifexist", { "Vorlage:Positionskarte " .. DN.POSKARTE.WertSplit[1], "1", "0" } ) == "1" then
				DSMB.Karte[1]["G"] = DN.POSKARTE.WertSplit[1]
			end
		end
		DSMB.Karte.obige = frame:expandTemplate{ title = "Obige Karte", args = { DSMB.Karte[1]["G"] } }
		--	Sonderfestlegung
		if DSMB.Karte.obige == "USA" then DSMB.Karte.obige = "USA 48" end
		if DSZusatz.REGION["1"] then
			if DSZusatz.REGION["0"]["acronym"] == "RU" then
				if (DSZusatz.REGION["1"]["continent"] == "Europa" or DSZusatz.REGION["1"]["continent"] == "Eurasien") then DSMB.Karte.obige = "Russland Europäischer Teil" end
			end
		end
		--	Anpassung 'obige Karte'
		for OPKk, OPKv in pairs( DSZusatz.OPK ) do
			if OPKv[1] == DSMB.Karte[1]["G"] then DSMB.Karte.obige = OPKv[2] end
			DSMB.Karte.obige = DSMB.Karte.obige or "Welt"
		end
		
		if (DSMB.Karte.obige ~= "Welt" and DSMB.Karte.obige ~= "") then
			DSMB.Karte[2] = {
				G = DSMB.Karte.obige
			}
			DSMB.Karte[1]["Amax"] = DSMB.Karte[1]["Amax"] * 1.25
			DSMB.TMP.DL = 2
		end
		for DL = 1, DSMB.TMP.DL, 1 do
			DSMB.Karte[DL]["img"] = frame:expandTemplate{ title = "Positionskarte " .. DSMB.Karte[DL]["G"], args = { "image", "relief" } }
			DSMB.Karte[DL]["Borg"] = mw.title.new( DSMB.Karte[DL]["img"], 6 ).file.width
			DSMB.Karte[DL]["Horg"] = mw.title.new( DSMB.Karte[DL]["img"], 6 ).file.height
			DSMB.Karte[DL]["Aorg"] = DSMB.Karte[DL]["Borg"] * DSMB.Karte[DL]["Horg"]
			DSMB.Karte[DL]["SV"] = DSMB.Karte[DL]["Borg"] / DSMB.Karte[DL]["Horg"]
			DSMB.Karte[DL]["Bgr"] = math.sqrt( DSMB.Karte[DL]["Amax"] * DSMB.Karte[DL]["SV"] )
			DSMB.Karte[DL]["Hgr"] = DSMB.Karte[DL]["Bgr"] / DSMB.Karte[DL]["SV"]
			if DSMB.Karte[DL]["Bgr"] > DSMB.Karte[DL]["Bmax"] then
				DSMB.Karte[DL]["B"] = DSMB.Karte[DL]["Bmax"]
				DSMB.Karte[DL]["H"] = DSMB.Karte[DL]["B"] / DSMB.Karte[DL]["SV"]
			elseif DSMB.Karte[DL]["Hgr"] > DSMB.Karte[DL]["Hmax"] then
				DSMB.Karte[DL]["H"] = DSMB.Karte[DL]["Hmax"]
				DSMB.Karte[DL]["B"] = DSMB.Karte[DL]["H"] * DSMB.Karte[DL]["SV"]
			else
				DSMB.Karte[DL]["B"] = DSMB.Karte[DL]["Bgr"]
				DSMB.Karte[DL]["H"] = DSMB.Karte[DL]["Hgr"]
			end
			DSMB.Karte[DL]["A"] = DSMB.Karte[DL]["B"] * DSMB.Karte[DL]["H"]
			if (DL == 1 and DSMB.TMP.DL == 2) then
				DSMB.Karte[2]["Bmax"] = DSMB.Karte[1]["B"]
				DSMB.Karte[2]["Hmax"] = DSMB.Karte[1]["H"]
				DSMB.Karte[2]["Amax"] = DSMB.Karte[1]["A"] / 5
			end
			if DL == 2 then
				DSMB.PK.args["Karte in einer Ecke"] = DSMB.Karte[2]["G"]
				DSMB.PK.args.Breite = tostring( math.floor( DSMB.Karte[2]["B"] ) )
			end
		end
		DSMB.PK.args[1] = DSMB.Karte[1]["G"]
		DSMB.PK.args.width = tostring( math.floor( DSMB.Karte[1]["B"] ) )
		DSMB.VKarte = frame:expandTemplate{ title = DSMB.PK.title, args = DSMB.PK.args } or ""
		DN.POSKARTE.WertZeile = DSMB.VKarte
	else
		DN.POSKARTE.WertZeile = ""
	end
	
	if DN.POSKARTE.WertZeile == "" then DN.POSKARTE.WertZeile = nil end
	return DN
end

	-- Anzeige Koordinaten 'KoordKarte'
p.DSIB.KoordKarte = function ( DN, DSZusatz, Kategorien, frame )
	local DSMB = { }
	
	--	Variable für die Wiki-Vorlage
	DSMB.Artikel = false -- sollen Koordinaten im Artikel oben angezeigt werden
	DSMB.Anzeige = true --  sollen Koordinaten in der Infobox angezeigt werden
	DSMB.Rahmen = true --   soll die Anzeige mit einem Rahmen versehen werden
	DSMB.brF = false --     Absatz vor DSMB.Fehler
	DSMB.Fehler = { --      Speicher fuer Fehlermeldung
		GZNS = "Gradzahl-Fehler:<br />\'\'[[Vorlage:Coordinate#NS und EW|NS]]\'\': keine Zahl",
		GZEW = "Gradzahl-Fehler:<br />\'\'[[Vorlage:Coordinate#NS und EW|EW]]\'\': keine Zahl",
		GBNS = "Gültigkeitsbereich Breitengrad: „" .. tostring( DN.NS.WertSplit[1] ) .. "“",
		GBEW = "Gültigkeitsbereich Längengrad: „" .. tostring( DN.EW.WertSplit[1] ) .. "“"
	}
	DSMB.NS = DN.NS.WertSplit[1] or ""
	DSMB.EW = DN.EW.WertSplit[1] or ""
	DSMB.KOA = {
		title = "Coordinate",
		args = {
			NS = tostring( DSMB.NS ),
			EW = tostring( DSMB.EW ),
			type = "building",
			region = DN["REGION-ISO"]["WertZeile"],
			name = DSZusatz.NNAME,
			dim = "250"
		}
	}
	
	--	Zuweisung fuer Rahmen
	if ((DN.NS.WertZeile and DN.EW.WertZeile) or (DN.NS.AnzSplit == 0 and DN.EW.AnzSplit == 0)) then DSMB.Rahmen = false end
	if not DSZusatz.REGION["0"] then
		DSMB.KOA.args["type"] = "building"
		if (DN.NS.WertSplit[1] and DN.EW.WertSplit[1]) then
			DSMB.Rahmen = true
			DSMB.brF = true
		end
	end
	if ((DN.NS.WertZeile and type( DN.NS.WertSplit[1] ) == "number" and DN.EW.WertSplit[1] == nil) or (DN.EW.WertZeile and type( DN.EW.WertSplit[1] ) == "number" and DN.NS.WertSplit[1] == nil)) then
		DSMB.Rahmen = nil
	end
	
	--	Zuweisung zur Anzeige
	if DN.SONDER.WertZeile == "Nebenbox" then
		DSMB.Artikel = false
	elseif DN.SONDER.WertZeile == "Weiterleitung" then
		DSMB.Artikel = true
	elseif DSZusatz.NSP == 0 then
		DSMB.Artikel = true
	end
	
	--	Zuweisung zur Wiki-Vorlage
	if DSMB.Artikel == true then
		DSMB.KOA.args.article = "/"
		if ((DN.NS.WertZeile and DN.EW.WertZeile) or (DN.NS.AnzSplit == 0 and DN.EW.AnzSplit == 0) or (DN.NS.WertZeile and DN.EW.AnzSplit == 0) or (DN.NS.AnzSplit == 0 and DN.EW.WertZeile)) then
			DSMB.Anzeige = false
		end
		if (DSZusatz.REGION["0"] == nil and DN.NS.WertZeile and DN.EW.WertZeile) then DSMB.Anzeige = true end
	else
		DSMB.KOA.args.text = "/"
	end
	if DSMB.Anzeige == false then
		DN.KoordKarte.BauTyp = "Feld"
		DN.KoordKarte.AnzLabel = ""
	end
	
	--	Generierung Vorlage:Coordinate und Fehlertexte
	DN.KoordKarte.WertZeile = frame:expandTemplate{ title = DSMB.KOA.title, args = DSMB.KOA.args }
	if (type( DN.NS.WertSplit[1] ) ~= "number" or type( DN.NS.WertZeile ) == "string") then DSMB.Fehler.GBNS = nil end
	if (type( DN.EW.WertSplit[1] ) ~= "number" or type( DN.EW.WertZeile ) == "string") then DSMB.Fehler.GBEW = nil end
	if DN.NS.AnzSplit > 0 then DSMB.Fehler.GZEW = nil end
	if DN.EW.AnzSplit > 0 then DSMB.Fehler.GZNS = nil end
	if type( DN.NS.WertSplit[1] ) ~= "string" then DSMB.Fehler.GZNS = nil end
	if type( DN.EW.WertSplit[1] ) ~= "string" then DSMB.Fehler.GZEW = nil end
	if (DSMB.Fehler.GZNS and DSMB.Fehler.GZEW) then
		DSMB.Fehler.GZNS = nil
		DSMB.Fehler.GZEW = nil
		DSMB.brF = true
	end
	for Gk, Gv in pairs( DSMB.Fehler ) do
		if DSMB.brF == true then
			DN.KoordKarte.WertZeile = DN.KoordKarte.WertZeile .. "<br />"
		else
			DSMB.brF = true
		end
		if type( Gv ) == "string" then 	DN.KoordKarte.WertZeile = DN.KoordKarte.WertZeile .. Gv end
	end
	if DSMB.Rahmen == true then DN.KoordKarte.WertZeile = DSZusatz.Aufbereitung.Fehler( DN.KoordKarte.WertZeile ) end
	
	return DN
end

--	Region-ISO in Feld
p.DSFI = function ( DatenWL, frame )
	local DSFz = ""
	local DSFD = { }
	DSFD["0"] = { }
	DSFD["0"]["level"] = 0
	DSFD["0"]["continent"] = REG( "O", "continent", DatenWL, frame )
	DSFD["0"]["acronym"] = REG( "O", "acronym", DatenWL, frame )
	DSFD["0"]["admtype"] = REG( "O", "admtype", DatenWL, frame )
	DSFD["0"]["admname"] = REG( "O", "admname", DatenWL, frame )
	DSFD["0"]["name"] = REG( "O", "name", DatenWL, frame )
	DSFD["0"]["lemma"] = REG( "O", "lemma", DatenWL, frame )
	DSFD["0"]["map"] = REG( "O", "map", DatenWL, frame )
	DSFD["0"]["flag"] = REG( "O", "flag", DatenWL, frame )
	DSFD["0"]["Lin"] = "in " .. tostring( DSFD["0"]["name"] )
	DSFz = REG( "O", "in", DatenWL, frame )
	if DSFz ~= "" then DSFD["0"]["Lin"] = DSFz end
	DSFD["1"] = { }
	DSFD["1"]["level"] = 1
	DSFD["1"]["continent"] = REG( "I", "continent", DatenWL, frame )
	DSFD["1"]["acronym"] = REG( "I", "acronym", DatenWL, frame )
	DSFD["1"]["admtype"] = REG( "I", "admtype", DatenWL, frame )
	DSFD["1"]["admname"] = REG( "I", "admname", DatenWL, frame )
	DSFD["1"]["name"] = REG( "I", "name", DatenWL, frame )
	DSFD["1"]["lemma"] = REG( "I", "lemma", DatenWL, frame )
	DSFD["1"]["map"] = REG( "I", "map", DatenWL, frame )
	DSFD["1"]["flag"] = REG( "I", "flag", DatenWL, frame )
	DSFD["1"]["Lin"] = "in " .. tostring( DSFD["1"]["name"] )
	DSFz = REG( "I", "in", DatenWL, frame )
	if DSFz ~= "" then DSFD["1"]["Lin"] = DSFz end
	DSFD["2"] = { }
	DSFD["2"]["continent"] = REG( "II", "continent", DatenWL, frame )
	DSFD["2"]["level"] = REG( "II", "level", DatenWL, frame )
	DSFD["2"]["acronym"] = REG( "II", "acronym", DatenWL, frame )
	DSFD["2"]["admtype"] = REG( "II", "admtype", DatenWL, frame )
	DSFD["2"]["admname"] = REG( "II", "admname", DatenWL, frame )
	DSFD["2"]["name"] = REG( "II", "name", DatenWL, frame )
	DSFD["2"]["lemma"] = REG( "II", "lemma", DatenWL, frame )
	DSFD["2"]["map"] = REG( "II", "map", DatenWL, frame )
	DSFD["2"]["flag"] = REG( "II", "flag", DatenWL, frame )
	DSFD["2"]["Lin"] = "in " .. tostring( DSFD["2"]["name"] )
	DSFz = REG( "II", "in", DatenWL, frame )
	if DSFz ~= "" then DSFD["2"]["Lin"] = DSFz end
	if DSFD["0"]["acronym"] == "NL" then
		if (DSFD["2"]["acronym"] == "AW" or DSFD["2"]["acronym"] == "CW" or DSFD["2"]["acronym"] == "SX") then
			DSFD["0"]["Lin"] = "im Königreich der Niederlande"
		else
			DSFD["0"]["Lin"] = "in den Niederlanden"
		end
	end
	if DSFD["2"]["level"] == "2" then
		if DSFD["0"]["acronym"] == DSFD["1"]["acronym"] then
			DSFD["1"] = DSFD["2"]
			DSFD["1"]["level"] = 2
			DSFD["2"] = nil
		else
			DSFD["2"]["level"] = 2
		end
	elseif DSFD["2"]["level"] == "1" then
		DSFD["1"] = DSFD["2"]
		DSFD["1"]["level"] = 1
		DSFD["2"] = nil
	elseif DSFD["2"]["level"] == "0" then
		DSFD["0"] = DSFD["2"]
		DSFD["0"]["level"] = 0
		DSFD["1"] = nil
		DSFD["2"] = nil
	else
		DSFD["0"] = nil
		DSFD["1"] = nil
		DSFD["2"] = nil
	end
	return DSFD
end

--	Regionen fuer Geo-Regionen auswaehlen
p.GeoVERW = function ( Art, Ort, KFSv, REGION, DCSTADT )
	local REGIO = REGION or { }
	local DSTADT = DCSTADT or ""
	local KFS = KFSv or "Stuttgart"
	if REGIO[KFS] == nil then REGIO[KFS] = { } end
	local VXW = {
		CSTADT = {
			tostring( DSTADT ),
			"nicht " .. tostring( DSTADT ),
			Gastronomiebetrieb = "(" .. tostring( KFS ) .. ")"
		},
		REG = {
			tostring( REGIO[KFS]["Lin"] ),
			"nicht " .. tostring( REGIO[KFS]["Lin"] ),
			Gastronomiebetrieb = "(" .. tostring( REGIO[KFS]["name"] ) .. ")"
		}
	}
	local LOC = VXW["CSTADT"][1]
	if (Ort ~= nil and Ort ~= "") then
		LOC = VXW[Ort][1]
		if (Art ~= nil and Art ~= "") then
			if (VXW[Ort][Art] ~= nil and VXW[Ort][Art] ~= "") then
				LOC = VXW[Ort][Art]
			end
		end
	end
	return LOC
end

-- 	Datenermittlung bei Weiterleitung
p.DatenWeiterleitung = function ( Daten, frame )

	-- 	Ziel definieren
	local Ziel = {
		Name = mw.getCurrentFrame():getParent().args.ZIEL or frame.args.ZIEL
	}
	Ziel.Splitten1 = { }
	Ziel.Splitten2 = { }
	Ziel.NSP = 0
	if Ziel.Name then Ziel.Splitten1 = mw.text.split( Ziel.Name, "#" ) end
	if Ziel.Splitten1[1] then Ziel.Splitten2 = mw.text.split( Ziel.Splitten1[1], ":" ) end
	if Ziel.Splitten2[2] then Ziel.NSP = Ziel.Splitten2[1] end
	Ziel.Seite = Ziel.Splitten2[2] or Ziel.Splitten2[1]
	Ziel.Abschnitt = Ziel.Splitten1[2]
	if Ziel.Seite == "" then Ziel.Seite = nil end
	if Ziel.Abschnitt == "" then Ziel.Abschnitt = nil end
	if Ziel.Seite then Ziel.Inhalt = mw.title.new( Ziel.Seite, Ziel.NSP ):getContent() end
	Ziel.Splitten1 = nil
	Ziel.Splitten2 = nil
	
	-- 	Infobox extrahieren
	if Ziel.Inhalt then
		Ziel.Inhalt = string.gsub( Ziel.Inhalt, "Infobox Sendeanlage", "XXXTA" )
		Ziel.Inhalt = string.gsub( Ziel.Inhalt, " SONDER", " XXXTE" )
		Ziel.Inhalt = string.gsub( Ziel.Inhalt, "|SONDER", "| XXXTE" )
		Ziel.Splitten = mw.text.split( Ziel.Inhalt, "XXXTA" )
		Ziel.Inhalt = Ziel.Splitten[2]
	end
	if Ziel.Inhalt then
		Ziel.Splitten = mw.text.split( Ziel.Inhalt, "XXXTE" )
		if Ziel.Splitten[2] then
			Ziel.Inhalt = Ziel.Splitten[1]
		else
			Ziel.Inhalt = nil
		end
	end
	
	-- 	Parameter bestimmen
	if Ziel.Inhalt then
		for PEk, PEv in pairs( Daten ) do
			Ziel.Inhalt = string.gsub( Ziel.Inhalt, " " .. PEv.Name, " XXXPEA" .. PEv.Name )
			Ziel.Inhalt = string.gsub( Ziel.Inhalt, "|" .. PEv.Name, "| XXXPEA" .. PEv.Name )
		end
		Ziel.Inhalt = string.gsub( Ziel.Inhalt, " REGION", " XXXPEAREGION" )
		Ziel.Inhalt = string.gsub( Ziel.Inhalt, "|REGION", "| XXXPEAREGION" )
		Ziel.Inhalt = string.gsub( Ziel.Inhalt, " CAT_TYP", " XXXPEACAT_TYP" )
		Ziel.Inhalt = string.gsub( Ziel.Inhalt, "|CAT_TYP", "| XXXPEACAT_TYP" )
		Ziel.Inhalt = string.gsub( Ziel.Inhalt, " CAT_NAME", " XXXPEACAT_NAME" )
		Ziel.Inhalt = string.gsub( Ziel.Inhalt, "|CAT_NAME", "| XXXPEACAT_NAME" )
		Ziel.Inhalt = string.gsub( Ziel.Inhalt, " CAT_STADT", " XXXPEACAT_STADT" )
		Ziel.Inhalt = string.gsub( Ziel.Inhalt, "|CAT_STADT", "| XXXPEACAT_STADT" )
		Ziel.Splitten = nil
		Ziel.Splitten = string.find( Ziel.Inhalt, "XXXPEA" )
		if not Ziel.Splitten then Ziel.Inhalt = nil end
	end
	
	-- 	Datensaetze extrahieren
	if Ziel.Inhalt then
		Ziel.Splitten =  mw.text.split( Ziel.Inhalt, "XXXPEA" )
		Ziel.vorTabelle = { }
		for DSEk, DSEv in pairs( Ziel.Splitten ) do
			if DSEk > 1 then
				Ziel.ZTL = string.len( DSEv )
				Ziel.ZTZ1 = string.sub( DSEv, Ziel.ZTL )
				Ziel.ZTZ2 = string.sub( DSEv, Ziel.ZTL - 1 )
				if Ziel.ZTZ2 == "| " then
					table.insert( Ziel.vorTabelle, string.sub( DSEv, 0, Ziel.ZTL - 3 ) )
				elseif Ziel.ZTZ1 == "|" then
					table.insert( Ziel.vorTabelle, string.sub( DSEv, 0, Ziel.ZTL - 2 ) )
				end
			end
		end
	end
	
	-- 	Datensaetze aufteilen
	if Ziel.vorTabelle then
		Ziel.ZwischenTabelle, Ziel.Splitten = { }, { }
		for DSF1k, DSF1v in pairs( Ziel.vorTabelle ) do
			Ziel.ZwischenTabelle[DSF1k] = { }
			Ziel.Splitten = mw.text.split( DSF1v, "=" )
			for DSF2k, DSF2v in pairs( Ziel.Splitten ) do
				if DSF2k < 3 then
					Ziel.ZwischenTabelle[DSF1k][DSF2k] = DSF2v
				elseif DSF2k == 2 then
					Ziel.ZwischenTabelle[DSF1k][2] = Ziel.ZwischenTabelle[DSF1k][2] .. DSF2v
				end
			end
			Ziel.ZwischenTabelle[DSF1k][1] = mw.text.trim( Ziel.ZwischenTabelle[DSF1k][1] )
			Ziel.ZwischenTabelle[DSF1k][2] = mw.text.trim( Ziel.ZwischenTabelle[DSF1k][2] )
			if Ziel.ZwischenTabelle[DSF1k][1] == "" then Ziel.ZwischenTabelle[DSF1k][1] = "blind" end
			if Ziel.ZwischenTabelle[DSF1k][2] == "" then Ziel.ZwischenTabelle[DSF1k][2] = nil end
		end
	end
	-- 	Tabelle erzeugen
	Ziel.Tabelle = { false }
	if Ziel.ZwischenTabelle then
		Ziel.Tabelle[1] = true
		for TABk, TABv in pairs( Ziel.ZwischenTabelle ) do
			Ziel.Tabelle[TABv[1]] = TABv[2]
		end
		Ziel.Tabelle.ZIEL = Ziel.Name
		Ziel.Tabelle.ZIELNSP = Ziel.NSP
		Ziel.Tabelle.ZIELSeite = Ziel.Seite
		Ziel.Tabelle.ZIELAbschnitt = Ziel.Abschnitt
	end
	
	return Ziel.Tabelle
end

return p