<?xml version="1.0"?>
<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:xlink="http://www.w3.org/TR/xlink" xmlns="http://www.w3.org/1999/xhtml" xmlns:html="http://www.w3.org/1999/xhtml" xmlns:stf="http://www.statistik.at/xml/stf/StML-1" xmlns:stl="http://www.statistik.at/xml/stf/Styles-1" xmlns:stt="http://www.statistik.at/xml/stf/StyleTemplate-1" version="1.18">
	<xsl:output method="xml" encoding="iso-8859-1" doctype-public="-//W3C//DTD XHTML 1.0 Strict//EN" doctype-system="http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd" indent="yes"/>
	<!--<xsl:output method="xml" encoding="iso-8859-1" doctype-public="-//W3C//DTD XHTML 1.0 Transitional//EN" doctype-system="http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd" indent="yes"/>-->
	<!-- Solange die id() funktion mit xslt1.0 und xml-schema nicht funktioniert,
	     holen wir uns alle Knoten, die eine ID haben, um sie spaeter einfach
			 zu ersetzen -->
	<xsl:key name="key" match="//*" use="@id"/>

	<!-- Legt fest, welche Parameterdatei verwendet werden soll. -->
	<xsl:param name="p_parameterFile">stf-html-param.xml</xsl:param>
	<xsl:param name="p_userStyleFile">false</xsl:param>


	<!-- Externe Dateien (werden nur einmal geparst) -->
	<xsl:variable name="parameterFile" 				select="document(string($p_parameterFile))//*"/>
	<xsl:variable name="styleFileAdditional" 	select="document($parameterFile//param[@name='p_UseExternalStyleTemplateAdditional']/@value)//*"/>

	<!-- Globale Konstanten -->
	<xsl:variable name="p_showClassification" 	 			select="$parameterFile//param[@name='p_showClassification']/@value"/>
	<xsl:variable name="p_showClassXHTML" 			 			select="$parameterFile//param[@name='p_showClassXHTML']/@value"/>
	<xsl:variable name="p_showMetaInformationGlobal" 	select="$parameterFile//param[@name='p_showMetaInformationGlobal']/@value"/>
	<xsl:variable name="p_showMetaInformationTable" 	select="$parameterFile//param[@name='p_showMetaInformationTable']/@value"/>
	<xsl:variable name="p_showDublinCoreGlobal" 			select="$parameterFile//param[@name='p_showDublinCoreGlobal']/@value"/>
	<xsl:variable name="p_showDublinCoreTable" 				select="$parameterFile//param[@name='p_showDublinCoreTable']/@value"/>
	<xsl:variable name="p_showUnitInformationGlobal" 	select="$parameterFile//param[@name='p_showUnitInformationGlobal']/@value"/>
	<xsl:variable name="p_showUnitInformationTable" 	select="$parameterFile//param[@name='p_showUnitInformationTable']/@value"/>
	
	<xsl:variable name="p_showHotTip" 	select="$parameterFile//param[@name='p_showHotTip']/@value"/>

	<xsl:variable name="p_Fact_notYetAvailable" 	select="$parameterFile//param[@name='p_Fact_notYetAvailable']/@value"/>
	<xsl:variable name="p_Fact_atZero" 						select="$parameterFile//param[@name='p_Fact_atZero']/@value"/>
	<xsl:variable name="p_Fact_notAppropriate" 		select="$parameterFile//param[@name='p_Fact_notAppropriate']/@value"/>
	<xsl:variable name="p_Fact_samplingError" 		select="$parameterFile//param[@name='p_Fact_samplingError']/@value"/>
	<xsl:variable name="p_Fact_secret" 						select="$parameterFile//param[@name='p_Fact_secret']/@value"/>

	<xsl:variable name="p_NoOfTable" 								select="number($parameterFile//param[@name='p_NoOfTable']/@value)"/>
	<xsl:variable name="p_Language" 								select="$parameterFile//param[@name='p_Language']/@value"/>

	<xsl:variable name="p_FootNote_superScript" 		select="$parameterFile//param[@name='p_FootNote_superScript']/@value"/>
	<xsl:variable name="p_UseExternalStyleTemplate" select="$parameterFile//param[@name='p_UseExternalStyleTemplate']/@value"/>
	<xsl:variable name="p_UseStyle" 								select="$parameterFile//param[@name='p_UseStyle']/@value"/>
	<xsl:variable name="p_Language_default" 				select="$parameterFile//param[@name='p_Language_default']/@value"/>

	<!-- Komma und Zahlengruppe -->
	<xsl:variable name="p_grouping_seperator" 			select="$parameterFile//param[@name='p_grouping_seperator']/@value"/>
	<xsl:variable name="p_comma_seperator" 					select="$parameterFile//param[@name='p_comma_seperator']/@value"/>
	<xsl:variable name="p_use_comma_group" 					select="$parameterFile//param[@name='p_use_comma_group']/@value"/>
	
	<!-- Textkonstanten -->
	<xsl:variable name="p_txt_Link_Sign" 			select="$parameterFile//param[@name='p_txt_Link_Sign']/@value"/>
	<xsl:variable name="p_txt_Gbl_Ref" 				select="$parameterFile//param[@name='p_txt_Gbl_Ref']/@value"/>
	<xsl:variable name="p_txt_Tbl_Ref" 				select="$parameterFile//param[@name='p_txt_Tbl_Ref']/@value"/>

	<xsl:variable name="p_txt_Lst_Header" 			select="$parameterFile//param[@name='p_txt_Lst_Header']/@value"/>
	<xsl:variable name="p_txt_Gbl_Info_Header" 	select="$parameterFile//param[@name='p_txt_Gbl_Info_Header']/@value"/>
	<xsl:variable name="p_txt_Gbl_Class" 				select="$parameterFile//param[@name='p_txt_Gbl_Class']/@value"/>
	<xsl:variable name="p_txt_Class_Head1" 			select="$parameterFile//param[@name='p_txt_Class_Head1']/@value"/>
	<xsl:variable name="p_txt_Class_Head2" 			select="$parameterFile//param[@name='p_txt_Class_Head2']/@value"/>
	<xsl:variable name="p_txt_Class_Head3" 			select="$parameterFile//param[@name='p_txt_Class_Head3']/@value"/>

	<xsl:variable name="p_txt_Gbl_Dbl_Core" 		select="$parameterFile//param[@name='p_txt_Gbl_Dbl_Core']/@value"/>
	<xsl:variable name="p_txt_Tbl_Dbl_Core" 		select="$parameterFile//param[@name='p_txt_Tbl_Dbl_Core']/@value"/>
	<xsl:variable name="p_txt_Dbl_Core_Head1" 	select="$parameterFile//param[@name='p_txt_Dbl_Core_Head1']/@value"/>
	<xsl:variable name="p_txt_Dbl_Core_Head2" 	select="$parameterFile//param[@name='p_txt_Dbl_Core_Head2']/@value"/>

	<xsl:variable name="p_txt_Gbl_Meta" 				select="$parameterFile//param[@name='p_txt_Gbl_Meta']/@value"/>
	<xsl:variable name="p_txt_Tbl_Meta" 				select="$parameterFile//param[@name='p_txt_Tbl_Meta']/@value"/>
	<xsl:variable name="p_txt_Meta_Head1" 			select="$parameterFile//param[@name='p_txt_Meta_Head1']/@value"/>
	<xsl:variable name="p_txt_Meta_Head2" 			select="$parameterFile//param[@name='p_txt_Meta_Head2']/@value"/>
	<xsl:variable name="p_txt_Meta_Head3" 			select="$parameterFile//param[@name='p_txt_Meta_Head3']/@value"/>
	<xsl:variable name="p_txt_Meta_Head4" 			select="$parameterFile//param[@name='p_txt_Meta_Head4']/@value"/>

	<xsl:variable name="p_txt_Gbl_Unit" 				select="$parameterFile//param[@name='p_txt_Gbl_Unit']/@value"/>
	<xsl:variable name="p_txt_Tbl_Unit" 				select="$parameterFile//param[@name='p_txt_Tbl_Unit']/@value"/>
	<xsl:variable name="p_txt_Unit_Head1" 			select="$parameterFile//param[@name='p_txt_Unit_Head1']/@value"/>
	<xsl:variable name="p_txt_Unit_Head2" 			select="$parameterFile//param[@name='p_txt_Unit_Head2']/@value"/>

	<xsl:variable name="p_txt_Doc_Info_Head" 	select="$parameterFile//param[@name='p_txt_Doc_Info_Head']/@value"/>
	<xsl:variable name="p_txt_Doc_Info" 			select="$parameterFile//param[@name='p_txt_Doc_Info']/node()"/>

	<!-- Dublin Core Texte -->
	<xsl:variable name="p_txt_Dbl_Core_Title" 			select="$parameterFile//param[@name='p_txt_Dbl_Core_Title']/@value"/>
	<xsl:variable name="p_txt_Dbl_Core_Creator" 		select="$parameterFile//param[@name='p_txt_Dbl_Core_Creator']/@value"/>
	<xsl:variable name="p_txt_Dbl_Core_Subject" 		select="$parameterFile//param[@name='p_txt_Dbl_Core_Subject']/@value"/>
	<xsl:variable name="p_txt_Dbl_Core_Description" select="$parameterFile//param[@name='p_txt_Dbl_Core_Description']/@value"/>
	<xsl:variable name="p_txt_Dbl_Core_Publisher" 	select="$parameterFile//param[@name='p_txt_Dbl_Core_Publisher']/@value"/>
	<xsl:variable name="p_txt_Dbl_Core_Contributor" select="$parameterFile//param[@name='p_txt_Dbl_Core_Contributor']/@value"/>
	<xsl:variable name="p_txt_Dbl_Core_Date" 				select="$parameterFile//param[@name='p_txt_Dbl_Core_Date']/@value"/>
	<xsl:variable name="p_txt_Dbl_Core_Type" 				select="$parameterFile//param[@name='p_txt_Dbl_Core_Type']/@value"/>
	<xsl:variable name="p_txt_Dbl_Core_Format" 			select="$parameterFile//param[@name='p_txt_Dbl_Core_Format']/@value"/>
	<xsl:variable name="p_txt_Dbl_Core_Identifier" 	select="$parameterFile//param[@name='p_txt_Dbl_Core_Identifier']/@value"/>
	<xsl:variable name="p_txt_Dbl_Core_Source" 			select="$parameterFile//param[@name='p_txt_Dbl_Core_Source']/@value"/>
	<xsl:variable name="p_txt_Dbl_Core_Language" 		select="$parameterFile//param[@name='p_txt_Dbl_Core_Language']/@value"/>
	<xsl:variable name="p_txt_Dbl_Core_Relation" 		select="$parameterFile//param[@name='p_txt_Dbl_Core_Relation']/@value"/>
	<xsl:variable name="p_txt_Dbl_Core_Coverage" 		select="$parameterFile//param[@name='p_txt_Dbl_Core_Coverage']/@value"/>
	<xsl:variable name="p_txt_Dbl_Core_Rights" 	  	select="$parameterFile//param[@name='p_txt_Dbl_Core_Rights']/@value"/>

	<!--  ########################################################################################### -->
	<!--  #######                         M A I N                                             ####### -->
	<!--  ########################################################################################### -->
	<xsl:template match="/stf:STF">
		<xsl:element name="html">
			<xsl:element name="head">
				<xsl:element name="title">Statistik Austria</xsl:element>
			</xsl:element>
			<xsl:element name="body">
				<!-- Eine Liste aller Tabellen anzeigen -->
				<xsl:if test="string($p_NoOfTable) = 'NaN' and count(//stf:TableView)>1">
					<xsl:element name="div">
						<xsl:call-template name="createStyleAttributeForExternStyle">
							<xsl:with-param name="styleName" select="'S_Txt_Lvl1'"/>
						</xsl:call-template>
						<xsl:value-of select="$p_txt_Lst_Header"/>
					</xsl:element>
					<xsl:element name="ul">
						<xsl:element name="div">
							<xsl:call-template name="createStyleAttributeForExternStyle">
								<xsl:with-param name="styleName" select="'S_Txt_Ref'"/>
							</xsl:call-template>
							<xsl:for-each select="//stf:TableView">
								<xsl:element name="li">
									<xsl:element name="a">
										<xsl:variable name="tableName" select="./@name"/>
										<xsl:if test="string-length(string($tableName)) != 0">
											<xsl:attribute name="href">#TableView<xsl:value-of select="./@name"/></xsl:attribute>
											<xsl:value-of select="./@name"/>
										</xsl:if>
										<xsl:if test="string-length(string($tableName)) = 0">
											<xsl:attribute name="href">#TableView<xsl:value-of select="position()"/></xsl:attribute>
											<xsl:value-of select="'Tabelle'"/>
										</xsl:if>
									</xsl:element>
								</xsl:element>
							</xsl:for-each>
						</xsl:element>
					</xsl:element>
					<xsl:element name="hr"/>
				</xsl:if>
		
				<!-- Zeige jede TableView -->
				<xsl:if test="string($p_NoOfTable) = 'NaN'">
					<xsl:for-each select="//stf:TableView">
						<xsl:call-template name="showTableView">
							<xsl:with-param name="tableView" select="."/>
						</xsl:call-template>
					</xsl:for-each>
				</xsl:if>
				<!-- Zeige eine bestimmte TableView-->
				<xsl:if test="string($p_NoOfTable) != 'NaN'">
					<xsl:call-template name="showTableView">
						<xsl:with-param name="tableView" select="/stf:STF/stf:TableView[$p_NoOfTable]"/>
					</xsl:call-template>
				</xsl:if>

				<!-- Zeige globale Daten (Dublin Core, Metainformation, Classification) -->
				<xsl:if test="string($p_showDublinCoreGlobal)='true' or string($p_showMetaInformationGlobal)='true' or string($p_showUnitInformationGlobal)='true' or string($p_showClassification)='true'">
					<!-- Ein Link zu den allgemeinen Infos -->
					<xsl:element name="hr"/>
					<xsl:element name="div">
						<xsl:element name="a">
							<xsl:attribute name="name">Ref_Gbl</xsl:attribute>
						</xsl:element>
					</xsl:element>
					<xsl:element name="div">
						<xsl:call-template name="createStyleAttributeForExternStyle">
							<xsl:with-param name="styleName" select="'S_Txt_Lvl1'"/>
						</xsl:call-template>
						<xsl:value-of select="$p_txt_Gbl_Info_Header"/>
					</xsl:element>
					<xsl:if test="string($p_showDublinCoreGlobal)='true'">
						<xsl:element name="div">
							<xsl:element name="br"/>
						</xsl:element>
						<xsl:element name="div">
							<xsl:call-template name="createStyleAttributeForExternStyle">
								<xsl:with-param name="styleName" select="'S_Txt_Lvl2'"/>
							</xsl:call-template>
							<xsl:value-of select="$p_txt_Gbl_Dbl_Core"/>
						</xsl:element>
						<xsl:call-template name="showDublinCore">
							<xsl:with-param name="description" select="/stf:STF/stf:Description"/>
						</xsl:call-template>
					</xsl:if> 
					<xsl:if test="string($p_showMetaInformationGlobal)='true'">
						<xsl:element name="div">
							<xsl:element name="br"/>
						</xsl:element>
						<xsl:element name="div">
							<xsl:call-template name="createStyleAttributeForExternStyle">
								<xsl:with-param name="styleName" select="'S_Txt_Lvl2'"/>
							</xsl:call-template>
							<xsl:value-of select="$p_txt_Gbl_Meta"/>
						</xsl:element>
						<xsl:call-template name="showMetaInformation">
							<xsl:with-param name="metaInformation" select="/stf:STF/stf:MetaInformation"/>
						</xsl:call-template>
					</xsl:if>
					<xsl:if test="string($p_showUnitInformationGlobal)='true'">
						<xsl:element name="div">
							<xsl:element name="br"/>
						</xsl:element>
						<xsl:element name="div">
							<xsl:call-template name="createStyleAttributeForExternStyle">
								<xsl:with-param name="styleName" select="'S_Txt_Lvl2'"/>
							</xsl:call-template>
							<xsl:value-of select="$p_txt_Gbl_Unit"/>
						</xsl:element>
						<xsl:call-template name="showUnitInformation">
							<xsl:with-param name="metaInformation" select="/stf:STF/stf:MetaInformation"/>
						</xsl:call-template>
					</xsl:if>
					<xsl:if test="string($p_showClassification)='true'">
						<xsl:element name="div">
							<xsl:element name="br"/>
						</xsl:element>
						<xsl:element name="div">
							<xsl:call-template name="createStyleAttributeForExternStyle">
								<xsl:with-param name="styleName" select="'S_Txt_Lvl2'"/>
							</xsl:call-template>
							<xsl:value-of select="$p_txt_Gbl_Class"/>
						</xsl:element>
						<xsl:call-template name="showClassification"/>
					</xsl:if>

						<xsl:element name="div">
							<xsl:element name="br"/>
						</xsl:element>
					<xsl:element name="div">
						<xsl:call-template name="createStyleAttributeForExternStyle">
							<xsl:with-param name="styleName" select="'S_Txt_Lvl2'"/>
						</xsl:call-template>
						<xsl:value-of select="$p_txt_Doc_Info_Head"/>
					</xsl:element>
					<xsl:element name="div">
						<xsl:call-template name="createStyleAttributeForExternStyle">
							<xsl:with-param name="styleName" select="'S_Txt_Lvl3'"/>
						</xsl:call-template>
						<xsl:copy-of select="$p_txt_Doc_Info"/>
					</xsl:element>
					
				</xsl:if>
			</xsl:element>
		</xsl:element>
	</xsl:template>

	<!--  ########################################################################################### -->
	<!--  ##  showTableView																																		####### -->
	<!--  ##  Zeigt den Inhalt der TableView an und danach die Zusatzinformationen						####### -->
	<!--  ##  tableView: Ein Element(TableView)																								####### -->
	<!--  ########################################################################################### -->
	<xsl:template name="showTableView">
		<xsl:param name="tableView"/>

		<!-- Einen Anker fuer diese Table definieren -->
		<xsl:element name="div">
		<xsl:element name="a">
			<xsl:variable name="tableName" select="./@name"/>
			<xsl:if test="string-length(string($tableName)) != 0">
				<xsl:attribute name="name">TableView<xsl:value-of select="./@name"/></xsl:attribute>
			</xsl:if>
			<xsl:if test="string-length(string($tableName)) = 0">
				<xsl:attribute name="name">TableView<xsl:value-of select="position()"/></xsl:attribute>
			</xsl:if>
		</xsl:element>
		</xsl:element>
		<!-- Einen Querverweis zu den Globalen Informationen setzen -->
		<xsl:if test="string($p_showDublinCoreGlobal)='true' or string($p_showMetaInformationGlobal)='true' or string($p_showUnitInformationGlobal)='true' or string($p_showClassification)='true'">
			<xsl:element name="div">
				<xsl:call-template name="createStyleAttributeForExternStyle">
					<xsl:with-param name="styleName" select="'S_Txt_Ref2'"/>
				</xsl:call-template>
				<xsl:element name="a">
					<xsl:attribute name="href">#Ref_Gbl</xsl:attribute>
						<xsl:value-of select="$p_txt_Gbl_Ref"/>
				</xsl:element>
			</xsl:element>
		</xsl:if>
		<!-- Einen Querverweis zu den Tabellen Informationen setzen -->
		<xsl:if test="string($p_showDublinCoreTable)='true' or string($p_showMetaInformationTable)='true' or string($p_showUnitInformationTable)='true'">
			<xsl:element name="div">
				<xsl:call-template name="createStyleAttributeForExternStyle">
					<xsl:with-param name="styleName" select="'S_Txt_Ref2'"/>
				</xsl:call-template>
				<xsl:element name="a">
					<xsl:attribute name="href">#Ref_Gbl_<xsl:value-of select="./@name"/></xsl:attribute>
					<xsl:value-of select="$p_txt_Tbl_Ref"/>
				</xsl:element>
			</xsl:element>
		</xsl:if>

		<xsl:element name="table">
			<xsl:attribute name="cellspacing"><xsl:value-of select="'0'"/></xsl:attribute>
			<xsl:attribute name="cellpadding"><xsl:value-of select="'1'"/></xsl:attribute>
			<!--<xsl:attribute name="bordercolor"><xsl:value-of select="'#000000'"/></xsl:attribute>-->
			<xsl:attribute name="style"><xsl:value-of select="'border-collapse:collapse;border-color:black;'"/></xsl:attribute>
			<xsl:call-template name="processColumns">
				<xsl:with-param name="column" select="./stf:Column"/>
			</xsl:call-template>
			<!-- Jede Zeile der Tabelle verarbeiten -->
			<xsl:for-each select="$tableView/stf:Table/stf:Row">
				<xsl:element name="tr">
					<xsl:if test="./@height">
						<xsl:attribute name="style"><xsl:value-of select="concat('height:', ./@height ,'cm;')"/></xsl:attribute>
					</xsl:if>
					<!-- Wenn keine Zellen in der Zeile sind, zumindestens eine leere Zelle ausgeben -->
					<xsl:if test="count(./stf:Cell)=0">
						<xsl:element name="td"/>
					</xsl:if>
					<xsl:for-each select="stf:Cell">
						<xsl:call-template name="doProcessCell">
							<xsl:with-param name="node" select="."/>
							<xsl:with-param name="refIdents" select="../@refIdent"/>
						</xsl:call-template>
					</xsl:for-each>
				</xsl:element>
			</xsl:for-each>
		</xsl:element>

		<!-- Einen Anker fuer die Tabellen Informationen setzen -->
		<xsl:if test="string($p_showDublinCoreTable)='true' or string($p_showMetaInformationTable)='true'  or string($p_showUnitInformationTable)='true'">
			<xsl:element name="div">
				<xsl:element name="a">
					<xsl:attribute name="name">Ref_Gbl_<xsl:value-of select="./@name"/></xsl:attribute>
				</xsl:element>
			</xsl:element>
		</xsl:if>
		<xsl:if test="string($p_showDublinCoreTable)='true'">
			<xsl:element name="div">
				<xsl:element name="br"/>
			</xsl:element>
			<xsl:element name="div">
				<xsl:call-template name="createStyleAttributeForExternStyle">
					<xsl:with-param name="styleName" select="'S_Txt_Lvl2'"/>
				</xsl:call-template>
				<xsl:value-of select="$p_txt_Tbl_Dbl_Core"/>
			</xsl:element>
			<xsl:call-template name="showDublinCore">
				<xsl:with-param name="description" select="$tableView/stf:Description"/>
			</xsl:call-template>
		</xsl:if> 

		<xsl:if test="string($p_showMetaInformationTable)='true'">
			<xsl:element name="div">
				<xsl:element name="br"/>
			</xsl:element>
			<xsl:element name="div">
				<xsl:call-template name="createStyleAttributeForExternStyle">
					<xsl:with-param name="styleName" select="'S_Txt_Lvl2'"/>
				</xsl:call-template>
				<xsl:value-of select="$p_txt_Tbl_Meta"/>
			</xsl:element>
			<xsl:call-template name="showMetaInformation">
				<xsl:with-param name="metaInformation" select="$tableView/stf:MetaInformation"/>
			</xsl:call-template>
		</xsl:if>
		<xsl:if test="string($p_showUnitInformationTable)='true'">
			<xsl:element name="div">
				<xsl:element name="br"/>
			</xsl:element>
			<xsl:element name="div">
				<xsl:call-template name="createStyleAttributeForExternStyle">
					<xsl:with-param name="styleName" select="'S_Txt_Lvl2'"/>
				</xsl:call-template>
				<xsl:value-of select="$p_txt_Tbl_Unit"/>
			</xsl:element>
			<xsl:call-template name="showUnitInformation">
				<xsl:with-param name="metaInformation" select="$tableView/stf:MetaInformation"/>
			</xsl:call-template>
		</xsl:if>
		<xsl:element name="div">
			<xsl:element name="br"/>
		</xsl:element>
	
	</xsl:template>
	
	<!--  ########################################################################################### -->
	<!--  ##  processColumns																																	####### -->
	<!--  ##  Verarbeitet die vordefinierten Spalten der Tabelle															####### -->
	<!--  ##  column: Die Spalten der Tabelle													 												####### -->
	<!--  ########################################################################################### -->
	<xsl:template name="processColumns">
		<xsl:param name="column"/>
		<xsl:for-each select="$column">
			<xsl:element name="col">
				<xsl:if test="./@width">
					<xsl:attribute name="style"><xsl:value-of select="concat('width:', ./@width ,'cm;')"/></xsl:attribute>
				</xsl:if>
			</xsl:element>
		</xsl:for-each>
	</xsl:template>

	<xsl:template name="addDummyTD">
		<xsl:param name="node"/>
		<xsl:param name="cnt"/>

		<xsl:if test="$cnt>0">
			<xsl:element name="td">
				<xsl:if test="string($p_UseStyle)='true'">
			<!--		<xsl:call-template name="makeStyleAttributes">
						<xsl:with-param name="node" select="$node"/>
					</xsl:call-template>  -->
				</xsl:if>
				<xsl:text>&#160;</xsl:text>
			</xsl:element>
			<xsl:call-template name="addDummyTD">
				<xsl:with-param name="cnt" select="$cnt - 1"/>
			</xsl:call-template>
		</xsl:if>
	</xsl:template>
	

	<!--  ########################################################################################### -->
	<!--  ##  doProcessCell																																		####### -->
	<!-- 	##  verarbeitet die daten in der zelle 																							####### -->
	<!--  ##  node: Ein Element(Cell)								 									 												####### -->
	<!--  ########################################################################################### -->
	<xsl:template name="doProcessCell">
		<xsl:param name="node"/>
		<xsl:param name="refIdents"/>

		<xsl:if test="./@index">
			<xsl:choose>
				  <xsl:when test="preceding-sibling::*[@index]">    <!-- Es gibt eine Zelle mit einem index vorher -->

					<!-- ALGORITHMUS

						Suche alle Knoten zwischen aktueller Zelle und vorheriger Zelle (mit Index)
						und berechne index und colspan
						
						aktuelle Zelle Index - voherige Zelle index - summe zellen mit @colspan - anzahl voriger knoten + knoten mit @colspan

						Achtung: Es dürfen immer nur die Knoten zwischen den Zellen mit den Indexen betrachtet werden!!
					
					-->
					<!--	????? Funktioniert nicht - Grund suchen
							
						<xsl:call-template name="addDummyTD">
							<xsl:with-param name="node" select="$node"/>
							<xsl:with-param name="cnt" select="./@index 
										- (preceding-sibling::*[@index])[last()]/@index	
										- sum(preceding-sibling::*[position() > (preceding-sibling::*[@index])[last()]][@colSpan]/@colSpan)
										- count(preceding-sibling::*[position() > count((preceding-sibling::*[@index])[last()]/preceding-sibling::*)])
										+ count(preceding-sibling::*[position() > (preceding-sibling::*[@index])[last()]][@colSpan])"/>
						</xsl:call-template>   -->

					
					</xsl:when>
					<xsl:otherwise>   <!-- Es gibt KEINE Zelle mit einem Index vorher -->
						<xsl:if test="contains(./@refIdent,'Istub')">  
							<!-- Speziell fuer Tabellen von Rudi wird der Index ausgewertet. Ansonsten funktioniert die Abfrage NICHT!,
								   da Rowspan von vorigen Zeilen beruecksichtigt werden muessen! -->
							<xsl:call-template name="addDummyTD">
								<xsl:with-param name="node" select="$node"/>
								<xsl:with-param name="cnt" select="./@index - 1 - sum(./preceding-sibling::*/@colSpan)-count(./preceding-sibling::*)+count(./preceding-sibling::*[@colSpan])"/>
							</xsl:call-template>
						</xsl:if>
					</xsl:otherwise>
			</xsl:choose>
		</xsl:if>

		<xsl:element name="td">
			<xsl:if test="$node/@colSpan">
				<xsl:attribute name="colspan"><xsl:value-of select="$node/@colSpan"/></xsl:attribute>
			</xsl:if>
			<xsl:if test="$node/@rowSpan">
				<xsl:attribute name="rowspan"><xsl:value-of select="$node/@rowSpan"/></xsl:attribute>
			</xsl:if>
			<xsl:if test="string($p_UseStyle)='true'">
				<xsl:call-template name="makeStyleAttributes">
					<xsl:with-param name="node" select="."/>
				</xsl:call-template>
			</xsl:if>
			<xsl:call-template name="doProcessData">
				<xsl:with-param name="node" select="./stf:Data"/>
				<xsl:with-param name="refIdents" select="concat(./@refIdent ,$refIdents)"/>
			</xsl:call-template>
			<xsl:call-template name="createRefMetLinks">
				<xsl:with-param name="node" select="."/>
			</xsl:call-template>
		</xsl:element>
	</xsl:template>

	<!--  ########################################################################################### -->
	<!--  ##  doProcessData																																		####### -->
	<!-- 	##  verarbeitet die daten innerhalb der zelle 																			####### -->
	<!--  ##  node: Ein Element(Data)								 									 												####### -->
	<!--  ########################################################################################### -->
	<xsl:template name="doProcessData">
		<xsl:param name="node"/>
		<xsl:param name="refIdents"/>

		<xsl:variable name="work4">
			<xsl:if test="name($node)='Data'">
				<xsl:call-template name="getPossibleTypeOfElement">
					<xsl:with-param name="node" select="$node"/>
				</xsl:call-template>
			</xsl:if>
		</xsl:variable>
		<xsl:if test="string-length(string($work4)) != 0">
			<xsl:value-of select="$work4"/>
		</xsl:if>
		<xsl:if test="string-length(string($work4)) = 0">
			<xsl:call-template name="getTextOfNodeFullFeature">
				<xsl:with-param name="node" select="$node"/>
				<xsl:with-param name="mode" select="'fullTxt'"/>
				<xsl:with-param name="refIdents" select="$refIdents"/>
			</xsl:call-template>
		</xsl:if>
			<xsl:if test="$node/@refUnit">
				<xsl:call-template name="createLink">
					<xsl:with-param name="node" select="key('key',$node/@refUnit)"/>
					<xsl:with-param name="prefix" select="'#'"/>
				</xsl:call-template>
			</xsl:if> 
	</xsl:template>

	<!--  ########################################################################################### -->
	<!--  ##  getTextOfNodeFullFeature																												####### -->
	<!--  ##  Holt sich den Text vom Knoten nach den definierten Regeln in Stml-Zusatz        ####### -->
	<!--  ##  node: Ein Element, von welchem der Text ausgegeben wird 												####### -->
	<!--  ##  node: siehe getCTText																														####### -->
	<!--  ########################################################################################### -->
	<xsl:template name="getTextOfNodeFullFeature">
		<xsl:param name="node"/>
		<xsl:param name="mode"/>
		<xsl:param name="refIdents"/>

		<xsl:variable name="work">
			<xsl:call-template name="getAlternativelyText">
				<xsl:with-param name="node" select="$node"/>
			</xsl:call-template>
		</xsl:variable>
		<xsl:if test="string-length(string($work)) != 0">
			<xsl:value-of select="$work"/>
		</xsl:if>
		<!-- es wurde kein alternativer Text gefunden. CT-Element Kinder auswerten -->
		<xsl:if test="string-length(string($work)) = 0">
			<xsl:choose>
				<xsl:when test="name($node)='Value'">
					<xsl:call-template name="getTextOfNodeFullFeature">
						<xsl:with-param name="node" select="$node/stf:ValData"/>
						<xsl:with-param name="mode" select="$mode"/>
						<xsl:with-param name="refIdents" select="$refIdents"/>
					</xsl:call-template>
				</xsl:when>
				<xsl:otherwise>
					<xsl:variable name="work4">
						<xsl:if test="name($node)='Fact'">
							<xsl:call-template name="getPossibleTypeOfElement">
								<xsl:with-param name="node" select="$node"/>
							</xsl:call-template>
						</xsl:if>
					</xsl:variable>
					<xsl:if test="string-length(string($work4)) != 0">
						<xsl:value-of select="$work4"/>
					</xsl:if>
					<xsl:if test="string-length(string($work4)) = 0">
						<xsl:variable name="work2">
							<xsl:call-template name="getGroupText">
								<xsl:with-param name="node" select="$node"/>
								<xsl:with-param name="mode" select="$mode"/>
								<xsl:with-param name="refIdents" select="$refIdents"/>
							</xsl:call-template>
						</xsl:variable>
						<xsl:if test="string-length(string($work2)) != 0">
							<xsl:copy-of select="$work2"/>
						</xsl:if>
						<!-- es wurden keine KindElemente(CT) gefunden Text vom Element direkt holen -->
					<!--	<xsl:if test="string-length(string($work2)) = 0"> -->
						<xsl:if test="count($node/stf:CT) = 0"> 
							<xsl:variable name="work3" select="$node/text()"/>
							<xsl:if test="string-length(string($work3)) != 0">
								<xsl:if test="$mode !='refTxtAsTxt' and $mode !='refTxt'">
									<xsl:value-of select="$work3"/>
								</xsl:if>
							</xsl:if>
							<!-- es wurde kein Text beim Element gefunden. Referenzierten Text holen -->
							<xsl:if test="string-length(string($work3)) = 0">
								<xsl:if test="$node/@ref">
									<xsl:call-template name="getTextOfNodeFullFeature">
										<xsl:with-param name="node" select="key('key',$node/@ref)"/>
										<xsl:with-param name="refIdents" select="$refIdents"/>
									</xsl:call-template>
								</xsl:if>
							</xsl:if>
						</xsl:if>
					</xsl:if>
				</xsl:otherwise>
			</xsl:choose>
		</xsl:if>

		<xsl:call-template name="createRefMetLinks">
			<xsl:with-param name="node" select="$node"/>
		</xsl:call-template>
	</xsl:template>

	<!--  ########################################################################################### -->
	<!--  ##  getAlternativelyText																														#######	-->
	<!--  ##  Holt sich den alternativen Text vom Knoten 																			####### -->
	<!--  ##  node: Ein Element, von welchem der alternative Text geholt wird									####### -->
	<!--  ########################################################################################### -->
	<xsl:template name="getAlternativelyText">
		<xsl:param name="node"/>
		
		<xsl:if test="$node[@refMet]">
			<xsl:call-template name="idrefSplitter">
				<xsl:with-param name="function" select="'getAlternativelyTextofMeta'"/>
				<xsl:with-param name="key" select="'key'"/>
				<xsl:with-param name="ids_string" select="$node/@refMet"/>
			</xsl:call-template>
		</xsl:if>
	</xsl:template>
	
	<!--  ########################################################################################### -->
	<!--  ##  getGroupText																																		####### -->
	<!-- 	##  Holt sich den Text fuer eine Group d.h Text, boolean, int,... 									####### -->
	<!--  ##  node: Ein Element, von welchem der Text ausgegeben wird 												####### -->
	<!--  ##  mode: siehe getCTText																														####### -->
	<!--  ########################################################################################### -->
	<xsl:template name="getGroupText">
		<xsl:param name="node"/>
		<xsl:param name="mode"/>
		<xsl:param name="refIdents"/>

		<!-- Testen, ob ein Text im Knoten ist -->
		<xsl:if test="$node/stf:CT[1]">
			<xsl:call-template name="getCTText">
				<xsl:with-param name="node" select="$node"/>
				<xsl:with-param name="mode" select="$mode"/>
			</xsl:call-template>
		</xsl:if>
		<xsl:if test="not($node/stf:CT[1])">
			<xsl:for-each select="$node/*">
				<xsl:if test="not(string($p_use_comma_group)='true')">
					<xsl:apply-templates select="." mode="rdgroup"/>
				</xsl:if>
				<xsl:if test="string($p_use_comma_group)='true'">
					<xsl:variable name="work2">
						<xsl:if test="((name(.)='Double') or (name(.)='Int')) and (contains($refIdents, 'body') or contains($refIdents, 'Body') or (string-length($refIdents)=0))">
							<xsl:choose>
								<xsl:when test="$p_grouping_seperator=','">
									<xsl:number value="floor(./text())" grouping-size="3" grouping-separator=','/>
								</xsl:when>
								<xsl:when test="$p_grouping_seperator='.'">
									<xsl:number value="floor(./text())" grouping-size="3" grouping-separator='.'/>
								</xsl:when>
								<xsl:when test="$p_grouping_seperator=' '">
									<xsl:number value="floor(./text())" grouping-size="3" grouping-separator=' '/>
								</xsl:when>
								<xsl:otherwise>
									<xsl:number value="floor(./text())" grouping-size="3" grouping-separator='?'/>
								</xsl:otherwise>
							</xsl:choose>
							<xsl:if test="string-length(substring-after(./text(),'.')) != 0">
								<xsl:value-of select="$p_comma_seperator"/>
								<xsl:value-of select="substring-after(./text(),'.')"/>
							</xsl:if>
						</xsl:if>
					</xsl:variable>

					<xsl:if test="string-length(string($work2)) != 0">
						<xsl:value-of select="$work2"/>
					</xsl:if>
				
					<xsl:if test="string-length(string($work2)) = 0">
						<xsl:apply-templates select="." mode="rdgroup"/>
					</xsl:if>
				</xsl:if>
				
			</xsl:for-each>
		</xsl:if>
	</xsl:template>

	<!-- gibt den Text der rdgroup (int, boolean, date,...) aus -->
	<xsl:template match="stf:*" mode="rdgroup">
		<xsl:value-of select="."/>
	</xsl:template>

	<xsl:template name="getCTContent">
		<xsl:param name="node"/>
		<xsl:param name="mode"/>

				<xsl:for-each select="./*">
					<xsl:choose>
						<xsl:when test="name(.) = 'Txt'">
							<xsl:choose>
								<xsl:when test="key('key',./@refStyle)">
									<xsl:variable name="style" select="key('key',./@refStyle)"/>
									<xsl:element name="span">
										
										<xsl:if test="string($p_UseExternalStyleTemplate)=''">
											<xsl:attribute name="style">
												<xsl:call-template name="parseStyle">
													<xsl:with-param name="style" select="$style"/>
												</xsl:call-template>
											</xsl:attribute>
										</xsl:if>
										<xsl:choose>
											<xsl:when test="$style/stl:Font/@verticalAlign='subscript'">
												<xsl:element name="sub">
													<xsl:value-of select="./text()"/>
												</xsl:element>
											</xsl:when>
											<xsl:when test="$style/stl:Font/@verticalAlign='superscript'">
												<xsl:element name="sup">
													<xsl:value-of select="./text()"/>
												</xsl:element>
											</xsl:when>
											<xsl:otherwise>
												<xsl:value-of select="./text()"/>
											</xsl:otherwise>
										</xsl:choose>
									</xsl:element>
								</xsl:when>
								<xsl:otherwise>
									<xsl:value-of select="./text()"/>
								</xsl:otherwise>
							</xsl:choose>
						</xsl:when>
						<xsl:when test="name(.) = 'IntLink'">
							<xsl:if test="./@show='keyTxt'">
								<xsl:call-template name="getTextOfNodeFullFeature">
									<xsl:with-param name="node" select="key('key',./@ref)"/>
									<xsl:with-param name="mode" select="'keyTxt'"/>
								</xsl:call-template>
							</xsl:if>
							<xsl:if test="./@show='refTxt'">
								<xsl:variable name="outputAsLink">
									<xsl:call-template name="checkIfRefOutputAsFootNote">
										<xsl:with-param name="node" select="../."/>
										<xsl:with-param name="name" select="./@ref"/>
									</xsl:call-template>
								</xsl:variable>
								<xsl:choose>
									<xsl:when test="string-length(string($outputAsLink)) = 0 and string($p_FootNote_superScript)='true'">
										<xsl:element name="sup">
											<xsl:element name="a">
											  <!-- Meta ref -->
												<xsl:attribute name="href">#<xsl:value-of select="./@ref"/></xsl:attribute>
												<xsl:if test="string($p_showHotTip)='true'">
													<xsl:attribute name="title">
														<xsl:call-template name="getTextOfNodeFullFeature">
															<xsl:with-param name="node" select="key('key',./@ref)"/>
															<xsl:with-param name="mode" select="'fullTxt'"/>
														</xsl:call-template>
													</xsl:attribute>
												</xsl:if>
												<xsl:value-of select="key('key',./@ref)/stf:CT/stf:RefTxt/text()"/>
											</xsl:element>
										</xsl:element>
									</xsl:when>
									<xsl:when test="string-length(string($outputAsLink)) = 0">
										<xsl:element name="a">
											  <!-- Meta ref -->
											<xsl:attribute name="href">#<xsl:value-of select="./@ref"/></xsl:attribute>
												<xsl:if test="string($p_showHotTip)='true'">
													<xsl:attribute name="title">
														<xsl:call-template name="getTextOfNodeFullFeature">
															<xsl:with-param name="node" select="key('key',./@ref)"/>
															<xsl:with-param name="mode" select="'fullTxt'"/>
														</xsl:call-template>
													</xsl:attribute>
												</xsl:if>
											<xsl:value-of select="key('key',./@ref)/stf:CT/stf:RefTxt/text()"/>
										</xsl:element>
									</xsl:when>
									<xsl:when test="string-length(string($outputAsLink)) > 0 and string($p_FootNote_superScript)='true'">
										<xsl:element name="sup">
											<xsl:element name="a">
												<!-- Meta anker -->
												<xsl:attribute name="name"><xsl:value-of select="./@ref"/></xsl:attribute>
												<xsl:value-of select="key('key',./@ref)/stf:CT/stf:RefTxt/text()"/>
											</xsl:element>
										</xsl:element>
									</xsl:when>
									<xsl:when test="string-length(string($outputAsLink)) > 0">
										<xsl:element name="a">
											<!-- Meta anker -->
											<xsl:attribute name="name"><xsl:value-of select="./@ref"/></xsl:attribute>
											<xsl:value-of select="key('key',./@ref)/stf:CT/stf:RefTxt/text()"/>
										</xsl:element>
									</xsl:when>
								</xsl:choose>
							</xsl:if>
							<xsl:if test="not(./@show) or ./@show='fullTxt'">
								<xsl:call-template name="getTextOfNodeFullFeature">
									<xsl:with-param name="node" select="key('key',@ref)"/>
									<xsl:with-param name="mode" select="'fullTxt'"/>
								</xsl:call-template>
							</xsl:if>
						</xsl:when>
						<xsl:when test="name(.) = 'Link'">
							<xsl:element name="a">
								<xsl:attribute name="href"><xsl:value-of select="./@xlink:href"/></xsl:attribute>
								<xsl:value-of select="./@xlink:title"/>
							</xsl:element>
						</xsl:when>
					</xsl:choose>
				</xsl:for-each>
				<!-- paragraph position alt -->
	</xsl:template>
	
	<!--  ########################################################################################### -->
	<!--  ##  getCTText																																				####### -->
	<!--  ##  Holt sich vom Knoten, alle CT-Elemente mit der richtigen Sprache und            ####### -->
	<!--  ##	von denen widerum den benoetigten Text 																					####### -->
	<!--  ##  node: Ein Element(CT), von welchem der Text ausgegeben wird											####### -->
	<!--  ##  mode: Welche Art von Text ausgegeben werden soll.                               ####### -->
	<!--  ##        fullTxt, der komplette Text des node's                                    ####### -->
	<!--  ##        refTxt, nur das Element RefTxt als Link												            ####### -->
	<!--  ##        refTxtAsTxt, das Element RefTxt als Text 																	####### -->
	<!--  ########################################################################################### -->
	<xsl:template name="getCTText">
		<xsl:param name="node"/>
		<xsl:param name="mode"/>
		
		<!-- TODO: Sprache selektieren -->
		<xsl:if test="($mode='') or ($mode='fullTxt')">
			<xsl:for-each select="$node/*[local-name()='CT']">
				<xsl:if test="contains(concat(./@*,''),'paragraph')">
				<!--<xsl:if test="./@*='paragraph'">-->
					<!-- show paragraph only, if not first element -->
					<xsl:if test="./preceding-sibling::*">
						<xsl:element name="br"/>
					</xsl:if>
				</xsl:if>
				<xsl:choose>
					<!--<xsl:when test="./@*='preformatted'">-->
					<xsl:when test="contains(concat(./@*,''),'preformatted')">
						<xsl:element name="pre">
							<xsl:attribute name="style">font-family:Courier,;</xsl:attribute>
							<xsl:call-template name="getCTContent">
								<xsl:with-param name="node" select="."/>
								<xsl:with-param name="mode" select="$mode"/>
							</xsl:call-template>
						</xsl:element>
					</xsl:when>
					<xsl:otherwise>
						<xsl:call-template name="getCTContent">
							<xsl:with-param name="node" select="."/>
							<xsl:with-param name="mode" select="$mode"/>
						</xsl:call-template>
					</xsl:otherwise>
				</xsl:choose>
			</xsl:for-each>
		</xsl:if>
		<xsl:if test="$mode='keyTxt'">
			<xsl:value-of select="$node/*[local-name()='CT']/*[local-name()='KeyTxt']/text()"/>
		</xsl:if>
		<xsl:if test="$mode='refTxtAsTxt'">
			<xsl:value-of select="$node/*[local-name()='CT']/*[local-name()='RefTxt']/text()"/>
		</xsl:if>
		<xsl:if test="$mode='refTxt'">
			<xsl:element name="a">
				<!-- Meta Ref-->
				<xsl:attribute name="href">#<xsl:value-of select="$node/@id"/></xsl:attribute>
				<xsl:value-of select="$node/*[local-name()='CT']/*[local-name()='RefTxt']/text()"/>
			</xsl:element>
		</xsl:if>
	</xsl:template>

	<!--  ########################################################################################### -->
	<!--  ##  getAlternativelyTextofMeta																											####### -->
	<!--  ##  Testet, ob das Meta-Element vom Typ Alternativ ist und 													####### -->
	<!--  ##	wenn ja, wird der text von dort geholt. 																				####### -->
	<!--  ##  node: Ein Element(Meta), von welchem der Text ausgegeben geholt wird						####### -->
	<!--  ########################################################################################### -->
	<xsl:template name="getAlternativelyTextofMeta">
		<xsl:param name="node"/>
		<xsl:if test="$node/@type='alternatively'">
			<xsl:call-template name="getTextOfNodeFullFeature">
				<xsl:with-param name="node" select="$node"/>
			</xsl:call-template>
		</xsl:if>
	</xsl:template>

	<!--  ########################################################################################### -->
	<!--  ##  checkIfRefOutputAsFootNote																											####### -->
	<!--  ##  Versucht!! herauszufinden, ob die Ausgabe innerhalb der Fussnote erfolgt. 			####### -->
	<!--  ##  node: Ein Vater Element(es kommen viele Element in Frage) von Intlink						####### -->
	<!--  ##  name: Id eines Elementes, welches ausgegeben werden soll 												####### -->
	<!--  ########################################################################################### -->
	<xsl:template name="checkIfRefOutputAsFootNote">
		<xsl:param name="node"/>
		<xsl:param name="name"/>
	
		<xsl:variable name="nodes" select="$node/*[@ref=$name]"/>
		<xsl:for-each select="$nodes">
			<xsl:if test="not(./@show)">
				<xsl:value-of select="'ausgabe als fussnote'"/>
			</xsl:if>
		</xsl:for-each>
	</xsl:template>

	<!--  ########################################################################################### -->
	<!--  ## getPossibleTypeOfElement																							  					####### -->
	<!--  ## Holt sich wenn der Fact/FactGroup/Data einen Typ besitzt (geheim, null,..) den		####### -->
	<!--  ## entsprechenden Text 																															####### -->
	<!--  ## node: Ein Element(Fact,FactGroup,Data) von welchem der Type gesucht wird	  			####### -->
	<!--  ########################################################################################### -->
	<xsl:template name="getPossibleTypeOfElement">
		<xsl:param name="node"/>

		<xsl:choose>
			<xsl:when test="$node/@type='notYetAvailable'">
				<xsl:value-of select="$p_Fact_notYetAvailable"/>
			</xsl:when>
			<xsl:when test="$node/@type='atZero'">
				<xsl:value-of select="$p_Fact_atZero"/>
			</xsl:when>
			<xsl:when test="$node/@type='notAppropriate'">
				<xsl:value-of select="$p_Fact_notAppropriate"/>
			</xsl:when>
			<xsl:when test="$node/@type='samplingError'">
				<xsl:value-of select="$p_Fact_samplingError"/>
			</xsl:when>
			<xsl:when test="$node/@type='secret'">
				<xsl:value-of select="$p_Fact_secret"/>
			</xsl:when>
			<xsl:when test="$node/@type='user'">
				<xsl:value-of select="$node/@class"/>
			</xsl:when>
			<xsl:otherwise>
				<xsl:if test="(name($node)='Fact') or (name($node)='FactGroup')">
					<xsl:call-template name="getPossibleTypeOfElement">
						<xsl:with-param name="node" select="$node/.."/>
					</xsl:call-template>
				</xsl:if>
			</xsl:otherwise>
		</xsl:choose>
	</xsl:template>

	<!--  ########################################################################################### -->
	<!--  ##  makeStyleAttributes																															####### -->
	<!--  ##  Sucht sich bei der uebergebenen Zelle alle Styles und erstellt dementsprechent  ####### -->
	<!--  ##  ein style attribut. dieses Template muss also innerhalb von einem xsl:element   ####### -->
	<!--  ##  node: ein Element(Cell), welches Styles als Parameter enthaelt.									####### -->
	<!--  ########################################################################################### -->
	<xsl:template name="makeStyleAttributes">
		<xsl:param name="node"/>

		<xsl:if test="string($p_UseExternalStyleTemplate)!=''">
			<!-- Hier werden die externen Styles verarbeitet -->
			<xsl:attribute name="style">
				<xsl:variable name="useStyle">
				<!-- Style vom Identifizierten Bereich der Zelle -->
				<xsl:if test="$node/@refIdent">
					<xsl:call-template name="idrefSplitter">
						<xsl:with-param name="function" select="'makeStyleAttributeForExternalStyle'"/>
						<xsl:with-param name="key" select="'key'"/>
						<xsl:with-param name="ids_string" select="$node/@refIdent"/>
						<xsl:with-param name="actOnlyAsStrSplitter" select="'true'"/>
					</xsl:call-template>
				</xsl:if>
				<!-- Style vom Identifizierten Bereich der Zeile -->
				<xsl:if test="$node/../@refIdent">
					<xsl:call-template name="idrefSplitter">
						<xsl:with-param name="function" select="'makeStyleAttributeForExternalStyle'"/>
						<xsl:with-param name="key" select="'key'"/>
						<xsl:with-param name="ids_string" select="$node/../@refIdent"/>
						<xsl:with-param name="actOnlyAsStrSplitter" select="'true'"/>
					</xsl:call-template>
					</xsl:if>
				<!-- Style fuer nicht identifizierten Bereiche also body bereiche -->
				<xsl:if test="not($node/../@refIdent) and not($node/@refIdent)">
					<!-- Zelle und Zeile sind nicht identifiziert also ist es ein body -->
					<xsl:variable name="styleName" select="'body.1'"/>
					<xsl:if test="$p_userStyleFile='false'">
						<xsl:variable name="style" select="document(string($p_UseExternalStyleTemplate))//stl:Style[@name=string($styleName)]"/>
						<xsl:call-template name="parseStyle">
							<xsl:with-param name="style" select="$style"/>
						</xsl:call-template>
					</xsl:if>
					<xsl:if test="$p_userStyleFile!='false'">
						<xsl:variable name="style" select="document(string($p_userStyleFile))//stl:Style[@name=string($styleName)]"/>
						<xsl:call-template name="parseStyle">
							<xsl:with-param name="style" select="$style"/>
						</xsl:call-template>
					</xsl:if>
				</xsl:if>
			</xsl:variable>
			<!-- Wenn irgend ein Style angewendet wurde, muss auch der Default Style angewendet werden. -->
			<xsl:if test="string-length($useStyle)!=0">
				<xsl:value-of select="$useStyle"/>
				<xsl:if test="$p_userStyleFile='false'">
					<xsl:variable name="style" select="document(string($p_UseExternalStyleTemplate))//stl:Style[@type='default']"/>
					<xsl:call-template name="parseStyle">
						<xsl:with-param name="style" select="$style"/>
					</xsl:call-template>
				</xsl:if>
				<xsl:if test="$p_userStyleFile!='false'">
					<xsl:variable name="style" select="document(string($p_userStyleFile))//stl:Style[@type='default']"/>
					<xsl:call-template name="parseStyle">
						<xsl:with-param name="style" select="$style"/>
					</xsl:call-template>
				</xsl:if>
			</xsl:if>
			</xsl:attribute>
		</xsl:if>
		<xsl:if test="string($p_UseExternalStyleTemplate)=''">
			<xsl:attribute name="style">
				<!-- Style vom Element selbst wird ignoriert -->
				<!-- Style der Zelle -->
				<xsl:variable name="useStyle">
					<xsl:if test="$node/@refStyle">
						<xsl:call-template name="parseStyle">
							<xsl:with-param name="style" select="key('key',$node/@refStyle)"/>
						</xsl:call-template>
					</xsl:if>
					<!-- Style der Zeile -->
					<xsl:if test="$node/../@refStyle">
						<xsl:call-template name="parseStyle">
							<xsl:with-param name="style" select="key('key',$node/@refStyle)"/>
						</xsl:call-template>
					</xsl:if>
					<!-- Style der Spalte wird ignoriert -->
					<!-- Style vom Identifizierten Bereich der Zelle -->
					<xsl:if test="$node/@refIdent and key('key',$node/@refIdent)/@refStyle">
						<xsl:call-template name="idrefSplitter">
							<xsl:with-param name="function" select="'makeStyleAttributeForInternalStyle'"/>
							<xsl:with-param name="key" select="'key'"/>
							<xsl:with-param name="ids_string" select="$node/@refIdent"/>
							<xsl:with-param name="actOnlyAsStrSplitter" select="'true'"/>
						</xsl:call-template>
					</xsl:if>
					<!-- Style vom Identifizierten Bereich der Zeile -->
					<xsl:if test="$node/../@refIdent and key('key',$node/../@refIdent)/@refStyle">
						<xsl:call-template name="idrefSplitter">
							<xsl:with-param name="function" select="'makeStyleAttributeForInternalStyle'"/>
							<xsl:with-param name="key" select="'key'"/>
							<xsl:with-param name="ids_string" select="$node/../@refIdent"/>
							<xsl:with-param name="actOnlyAsStrSplitter" select="'true'"/>
						</xsl:call-template>
					</xsl:if>
					<!-- Style fuer nicht identifizierten Bereiche also body bereiche -->
					<xsl:if test="not($node/../@refIdent) and not($node/@refIdent)">
					<!-- Zelle und Zeile sind nicht identifiziert also ist es ein body -->
						<xsl:if test="//stf:Identification[@type='body' and @refStyle]">
							<xsl:call-template name="parseStyle">
								<xsl:with-param name="style" select="key('key',//stf:Identification[@type='body' and @refStyle]/@refStyle)"/>
							</xsl:call-template>
						</xsl:if>
					</xsl:if>
				</xsl:variable>
				<!-- Wenn irgend ein Style angewendet wurde, muss auch der Default Style angewendet werden. -->
				<xsl:if test="string-length($useStyle)!=0">
					<xsl:value-of select="$useStyle"/>
					<xsl:if test="//stl:Style/@type='default'">
						<xsl:call-template name="parseStyle">
							<xsl:with-param name="style" select="//stl:Style[@type='default']"/>
						</xsl:call-template>
					</xsl:if>
				</xsl:if>
			</xsl:attribute>
		</xsl:if>
	</xsl:template>

	<!--  ########################################################################################### -->
	<!--  ##  parseStyle																																			####### -->
	<!--  ##  Parst das Style Element und generiert entsprechende XHTML Anweisungen           ####### -->
	<!--  ##  Dieses Template muss innerhalb eines Style-Attributes aufgerufen werden.        ####### -->
	<!--  ##  style: Ein Style Element																												####### -->
	<!--  ########################################################################################### -->
	<xsl:template name="parseStyle">
		<xsl:param name="style"/>

		<xsl:for-each select="$style//*">
			<xsl:choose>
				<!--                               B O R D E R                                                -->
				<xsl:when test="name(.)='stl:Border'">
					<xsl:text>border-</xsl:text>
					<xsl:value-of select="./@position"/>
					<xsl:text>: </xsl:text>
					<xsl:choose>
						<xsl:when test="./@lineStyle='continuous'">
							<xsl:text> solid </xsl:text>
						</xsl:when>
						<xsl:when test="./@lineStyle='dash'">
							<xsl:text> dashed </xsl:text>
						</xsl:when>
						<xsl:when test="./@lineStyle='dot'">
							<xsl:text> dotted </xsl:text>
						</xsl:when>
						<xsl:when test="./@lineStyle='double'">
							<xsl:text> double </xsl:text>
						</xsl:when>
						<xsl:when test="./@lineStyle='none'">
							<xsl:text> none </xsl:text>
						</xsl:when>
					</xsl:choose>
					<xsl:value-of select="./@weight"/>
					<xsl:text>cm;</xsl:text>
				</xsl:when>
				<!--                               I N T E R I O R                                            -->
				<xsl:when test="name(.)='stl:Interior'">
					<xsl:if test="./@color">
						<xsl:value-of select="concat('background-color:', ./@color ,';')"/>
					</xsl:if>
				</xsl:when>
				<!--                               F O R M A T                                               -->
				<xsl:when test="name(.)='stl:Format'">
					<xsl:if test="./@writeSpaced">
						<xsl:value-of select="concat('letter-spacing:', ./@writeSpaced ,'cm;')"/>
					</xsl:if>
				</xsl:when>
				<!--                               F O N T                                                -->
				<xsl:when test="name(.)='stl:Font'">
					<xsl:if test="./@bold='true'">
						<xsl:value-of select="'font-weight:bold;'"/>
					</xsl:if>
					<xsl:if test="./@size">
						<xsl:value-of select="concat('font-size:', ./@size ,'cm;')"/>
					</xsl:if>
					<xsl:if test="./@italic='true'">
						<xsl:value-of select="concat('font-style:', 'italic;')"/>
					</xsl:if>
					<xsl:if test="./@underline">
						<xsl:value-of select="concat('text-decoration:', 'underline;')"/>
					</xsl:if>
					<xsl:if test="./@family or ./@fontName">
						<xsl:value-of select="concat('font-family:', ./@fontName, ',', ./@family, ';')"/>
					</xsl:if>
					<xsl:if test="./@color">
						<xsl:value-of select="concat('color: ', ./@color ,';')"/>
					</xsl:if>
				</xsl:when>
				<!--                               A L I G N M E N T                                                -->
				<xsl:when test="name(.)='stl:Alignment'">
					<xsl:if test="./@indent">
						<xsl:value-of select="concat('padding-left:', ./@indent ,'cm;')"/>
					<!--	<xsl:value-of select="concat('text-indent:', ./@indent ,'cm;')"/>-->
					</xsl:if>
					<xsl:if test="./@horizontal">
						<xsl:value-of select="concat('text-align:', ./@horizontal ,';')"/>
					</xsl:if>
					<xsl:if test="./@vertical">
						<xsl:value-of select="concat('vertical-align:', ./@vertical ,';')"/>
					</xsl:if>
					<xsl:if test="./@wrapText='false'">
						<xsl:value-of select="concat('white-space: ', 'nowrap;')"/>
					</xsl:if>
				</xsl:when>
			</xsl:choose>
		</xsl:for-each>
	</xsl:template>

	<!--  ########################################################################################### -->
	<!--  ##  getExternalStyleName																														####### -->
	<!--  ##  erzeugt aus dem uebergebenen Knoten(Identifikationsknoten) einen Namen,         ####### -->
	<!--  ##  welcher im externen StyleTemplate gesucht wird, um den darueber gefundenen      ####### -->
	<!--	##	Style anzuwenden. 																															####### -->
	<!--  ##  node: Ein Element(Identification), von welchem der Stylename generiert wird			####### -->
	<!--  ########################################################################################### -->
	<xsl:template name="getExternalStyleName">
		<xsl:param name="node"/>

		<xsl:value-of select="$node/@type"/>
		<xsl:if test="$node/@level">
			<xsl:value-of select="concat('.',$node/@level)"/>
		</xsl:if>
		<xsl:if test="not($node/@level)">
			<xsl:value-of select="'.1'"/>
		</xsl:if>
		<xsl:if test="$node/@type='user'">
			<xsl:value-of select="'.'"/>
			<xsl:value-of select="$node/@class"/>
		</xsl:if>
	</xsl:template>

	<!--  ########################################################################################### -->
	<!--  ##  makeStyleAttributeForInternalStyle																							####### -->
	<!--  ##  Der uebergebene String wird ein Style gesucht geparst und angewendet.           ####### -->  
	<!--  ##  str: Name des Styles 	          																								####### -->
	<!--  ########################################################################################### -->
	<xsl:template name="makeStyleAttributeForInternalStyle">
		<xsl:param name="str"/>
	
		<xsl:call-template name="parseStyle">
			<xsl:with-param name="style" select="key('key',key('key',$str)/@refStyle)"/>
		</xsl:call-template>
	</xsl:template>
	
	<!--  ########################################################################################### -->
	<!--  ##  makeStyleAttributeForExternalStyle																							####### --> 
	<!--  ##  Der uebergebene String wird ein Style in der externen Datei gesucht geparst und ####### -->  
	<!--  ##  angewendet. 												                                            ####### --> 	
	<!--  ##  str: Eine IDRef zu einem Identification Element																	####### -->
	<!--  ########################################################################################### -->
	<xsl:template name="makeStyleAttributeForExternalStyle">
		<xsl:param name="str"/>

		<xsl:variable name="styleName">
			<xsl:call-template name="getExternalStyleName">
				<xsl:with-param name="node" select="key('key',$str)"/>
			</xsl:call-template>
		</xsl:variable>
		<xsl:if test="$p_userStyleFile='false'">
			<xsl:variable name="style" select="document(string($p_UseExternalStyleTemplate))//stl:Style[@name=string($styleName)]"/>
			<xsl:call-template name="parseStyle">
				<xsl:with-param name="style" select="$style"/>
			</xsl:call-template>
		</xsl:if>
		<xsl:if test="$p_userStyleFile!='false'">
			<xsl:variable name="style" select="document(string($p_userStyleFile))//stl:Style[@name=string($styleName)]"/>
			<xsl:call-template name="parseStyle">
				<xsl:with-param name="style" select="$style"/>
			</xsl:call-template>
		</xsl:if>
	</xsl:template>

	<!--  ########################################################################################### -->
	<!--  ##  idrefSplitter     																															####### -->
	<!--  ##  Splittet die uebergebene ID Liste und fuehrt fuer jede ID die Funktion aus.			####### -->
	<!--  ##  ids_string:           Entaehlt einen String mit einer Liste von IDs							####### -->
	<!--  ##  function:             Enthaelt, welche Funktion fuer jede ID ausgefuehrt wird 	####### -->
	<!--  ##  key:                  Enthaelt, in welchem key aus der ID ein Knoten gemacht    ####### -->
	<!--  ## 												wird. 																										####### -->
	<!--  ##  actOnlyAsStrSplitter: Enthaelt, ob die IDs als Knoten, oder als Text an die     ####### -->
	<!--  ##                        weitergereicht wird.																			####### -->
	<!--  ########################################################################################### -->
	<xsl:template name="idrefSplitter">
		<xsl:param name="ids_string"/>
		<xsl:param name="function"/>
		<xsl:param name="key"/>
		<xsl:param name="actOnlyAsStrSplitter"/>

		<xsl:variable name="id_str" select="normalize-space(substring-before($ids_string, ' '))"/>
		<xsl:variable name="id_rest" select="substring-after($ids_string, ' ')"/>
		<xsl:choose>
			<xsl:when test="string-length($id_str) = 0 and string-length($ids_string) &gt; 0">
				<xsl:if test="$actOnlyAsStrSplitter = 'true'">
					<xsl:call-template name="fooChooser">
						<xsl:with-param name="function" select="$function"/>
						<xsl:with-param name="node" select="key($key,$ids_string)"/>
						<xsl:with-param name="str" select="$ids_string"/>
					</xsl:call-template>
				</xsl:if>
				<xsl:if test="$actOnlyAsStrSplitter != 'true'">
					<xsl:call-template name="fooChooser">
						<xsl:with-param name="function" select="$function"/>
						<xsl:with-param name="node" select="key($key,$ids_string)"/>
					</xsl:call-template>
				</xsl:if>
			</xsl:when>
			<xsl:otherwise>
				<xsl:if test="$actOnlyAsStrSplitter = 'true'">
					<xsl:call-template name="fooChooser">
						<xsl:with-param name="function" select="$function"/>
						<xsl:with-param name="node" select="key($key,$id_str)"/>
						<xsl:with-param name="str" select="$id_str"/>
					</xsl:call-template>
				</xsl:if>
				<xsl:if test="$actOnlyAsStrSplitter != 'true'">
					<xsl:call-template name="fooChooser">
						<xsl:with-param name="function" select="$function"/>
						<xsl:with-param name="node" select="key($key,$id_str)"/>
					</xsl:call-template>
				</xsl:if>
			</xsl:otherwise>
		</xsl:choose>
		<xsl:if test="string-length($id_rest) &gt; 0">
			<xsl:call-template name="idrefSplitter">
				<xsl:with-param name="ids_string" select="$id_rest"/>
				<xsl:with-param name="function" select="$function"/>
				<xsl:with-param name="key" select="$key"/>
				<xsl:with-param name="actOnlyAsStrSplitter" select="$actOnlyAsStrSplitter"/>
			</xsl:call-template>
		</xsl:if>
	</xsl:template>

	<!--  ########################################################################################### -->
	<!--  ##  fooChooser																																			####### -->
	<!--  ##  Fuehrt eine als Text uebergebene Funktion aus. 																	####### -->
	<!--  ##  function: Name der Funktion, welche ausgefuehrt werden soll											####### -->
	<!--  ##  node:     Parameter, welche an die Funktion weitergereicht wird.								####### -->
	<!--  ##  str:      Parameter, welche an die Funktion weitergereicht wird.								####### -->
	<!--  ########################################################################################### -->
	<xsl:template name="fooChooser">
		<xsl:param name="node"/>
		<xsl:param name="function"/>
		<xsl:param name="str"/>

		<xsl:choose>
			<xsl:when test="$function='getAlternativelyTextofMeta'">
				<xsl:call-template name="getAlternativelyTextofMeta">
					<xsl:with-param name="node" select="$node"/>
				</xsl:call-template>
			</xsl:when>
			<xsl:when test="$function='makeStyleAttributeForExternalStyle'">
				<xsl:call-template name="makeStyleAttributeForExternalStyle">
					<xsl:with-param name="str" select="$str"/>
				</xsl:call-template>
			</xsl:when>
			<xsl:when test="$function='makeStyleAttributeForInternalStyle'">
				<xsl:call-template name="makeStyleAttributeForInternalStyle">
					<xsl:with-param name="str" select="$str"/>
				</xsl:call-template>
			</xsl:when>
			<xsl:when test="$function='createLink'">
				<xsl:call-template name="createLink">
					<xsl:with-param name="node" select="$node"/>
					<xsl:with-param name="prefix" select="'#'"/>
				</xsl:call-template>
			</xsl:when>
			<xsl:when test="$function='showMetaElement'">
				<xsl:call-template name="showMetaElement">
					<xsl:with-param name="node" select="$node"/>
				</xsl:call-template>
			</xsl:when>
			<xsl:when test="$function='createRefMetLinkSingle'">
				<xsl:call-template name="createRefMetLinkSingle">
					<xsl:with-param name="meta" select="$node"/>
				</xsl:call-template>
			</xsl:when>
		</xsl:choose>
	</xsl:template>

	<!--  ########################################################################################### -->
	<!--  ##  createLink																																			####### -->
	<!--  ##  Erstellt einen Link zu einem Abschnitt im Informationsblock. Ueblicherweise ein ####### -->
	<!--  ##  Meta Element. Dazu wird ein Link mit der Syntax "#+Knotenid" erstellt.      		####### -->
	<!--  ##  Ein Leerzeichen wird diesem Link vorangestellt.                             		####### -->
	<!--  ##  node: Fuer dieses Element wird der Link erstellt.                  							####### -->
	<!--  ########################################################################################### -->
	<xsl:template name="createLink">
		<xsl:param name="node"/>
		<xsl:param name="prefix"/>
		
		<xsl:value-of select="' '"/>
		<xsl:element name="a">
			<xsl:attribute name="href">
				<xsl:value-of select="$prefix"/>
				<xsl:value-of select="$node/@id"/>
			</xsl:attribute>
			<xsl:if test="string($p_showHotTip)='true'">
				<xsl:attribute name="title">
					<xsl:variable name="asf">
					<xsl:call-template name="getTextOfNodeFullFeature">
						<xsl:with-param name="node" select="$node"/>
						<xsl:with-param name="mode" select="'fullTxt'"/>
					</xsl:call-template>
					</xsl:variable>
					<xsl:value-of select="translate($asf,' 	','')"/>
				</xsl:attribute>
			</xsl:if>
			<xsl:value-of select="$p_txt_Link_Sign"/>
		</xsl:element>
	</xsl:template>

	<!--  ########################################################################################### -->
	<!--  ##  createStyleAttributeForExternStyl																								####### -->
	<!--  ##  Wenn ein externes Styletemplate verwendet wird, dann wird der uebergebene    		####### -->
	<!--  ##  StyleName im externen Template gesucht, geparst und ausgegeben               		####### -->
	<!--  ##  styleName: Name eines externen Styles                              							####### -->
	<!--  ########################################################################################### -->
	<xsl:template name="createStyleAttributeForExternStyle">
		<xsl:param name="styleName"/>
		<xsl:param name="addBorderColor"/>
		<xsl:if test="string($styleFileAdditional)!='false'">
			<xsl:attribute name="style">
				<xsl:call-template name="parseStyle">
					<xsl:with-param name="style" select="$styleFileAdditional//stl:Style[@name=string($styleName)]"/>
				</xsl:call-template>
				<xsl:if test="$addBorderColor='true'">
					<xsl:value-of select="'border-color:black;'"/>
				</xsl:if>
			</xsl:attribute>
		</xsl:if>
	</xsl:template>

	<!--  ########################################################################################### -->
	<!--  ##  showDummyTd              	        																							####### -->
	<!--  ##  Erstellt bis zur uebergebenen nr leere td Element gefuellt mit einem Leerzeichen####### -->
	<!--  ##  nr:        Anzahl der auszugebenden td Elemente																	####### -->
	<!--  ##  styleName: Enthaelt den Namen fuer den externen Style. Dieser wird fuer den     ####### --> 
	<!--  ##             leeren Eintrag ausgegeben																						####### -->
	<!--  ########################################################################################### -->
	<xsl:template name="showDummyTd">
		<xsl:param name="nr"/>
		<xsl:param name="styleName"/>

		<xsl:if test="number($nr) &gt; 0">
			<xsl:element name="td">
			<xsl:attribute name="colspan">3</xsl:attribute>
			<xsl:call-template name="createStyleAttributeForExternStyle">
				<xsl:with-param name="styleName" select="$styleName"/>
			</xsl:call-template>
			  <xsl:text>&#160;</xsl:text>	
			</xsl:element>
			<xsl:call-template name="showDummyTd">
				<xsl:with-param name="nr" select="$nr - 1"/>
				<xsl:with-param name="styleName" select="$styleName"/>
			</xsl:call-template>
		</xsl:if>
	</xsl:template>


	<!--  ########################################################################################### -->
	<!--  ##  showClassLine     																															####### -->
	<!--  ##  Zeigt den Inhalt vom Value Element in einer Zeile an der korrekten Position     ####### -->
	<!--  ##  Wenn notwendig, werden leere td's angefuegt bzw. vorangestellt.                 ####### -->
	<!--  ##  node: 			Ein Classification Element         																	####### -->
	<!--  ##  nr:   			Position innerhalb der Zeile                 												####### -->
	<!--  ##  max:       	maximalen Elemente einer Zeile               												####### -->
	<!--  ##  showDummy:  Zeige dummy TD's				                    												####### -->
	<!--  ########################################################################################### -->
	<xsl:template name="showClassLine">
		<xsl:param name="node"/>
		<xsl:param name="nr"/>
		<xsl:param name="max"/>
		<xsl:param name="showDummy"/>

		<xsl:if test="$showDummy='true'">
			<xsl:call-template name="showDummyTd">
				<xsl:with-param name="nr" select="$nr"/>
				<xsl:with-param name="styleName" select="'S_Class_Table_1'"/>
			</xsl:call-template> 
		</xsl:if>
		<xsl:element name="td">
			<xsl:call-template name="createStyleAttributeForExternStyle">
				<xsl:with-param name="styleName" select="'S_Class_Table_1'"/>
			</xsl:call-template>
			<xsl:value-of select="./@key"/>
			<xsl:text>&#160;</xsl:text>	
		</xsl:element>
		<xsl:element name="td">
			<xsl:call-template name="createStyleAttributeForExternStyle">
				<xsl:with-param name="styleName" select="'S_Class_Table_1'"/>
			</xsl:call-template>
			<xsl:call-template name="getTextOfNodeFullFeature">
					<xsl:with-param name="node" select="$node"/>
					<xsl:with-param name="mode" select="'fullTxt'"/>
			</xsl:call-template>
			<xsl:text>&#160;</xsl:text>	
		</xsl:element>
		<xsl:element name="td">
			<xsl:call-template name="createStyleAttributeForExternStyle">
				<xsl:with-param name="styleName" select="'S_Class_Table_1'"/>
			</xsl:call-template>
			<xsl:value-of select="./@code"/>
			<xsl:text>&#160;</xsl:text>	
		</xsl:element>
	</xsl:template>

	<!--  ########################################################################################### -->
	<!--  ##  showClassValue    																															####### -->
	<!--  ##  Zeigt den Inhalt vom Value Element in einer Zeile an der korrekten Position     ####### -->
	<!--  ##  Wenn notwendig, werden leere td's angefuegt bzw. vorangestellt.                 ####### -->
	<!--  ##  node: Ein Classification Element               																	####### -->
	<!--  ##  nr:   Position innerhalb der Zeile                      												####### -->
	<!--  ##  max:  maximalen Elemente einer Zeile                    												####### -->
	<!--  ########################################################################################### -->
	<xsl:template name="showClassValue">
		<xsl:param name="node"/>
		<xsl:param name="nr"/>
		<xsl:param name="max"/>

		<xsl:for-each select="./stf:Value">
			<xsl:if test="$nr=0 or position()!=1"> 
				<xsl:element name="tr">
					<xsl:call-template name="showClassLine">
						<xsl:with-param name="node" select="."/>
						<xsl:with-param name="nr" select="$nr"/>
						<xsl:with-param name="max" select="$max"/>
						<xsl:with-param name="showDummy" select="'true'"/>
					</xsl:call-template>
					<xsl:call-template name="showClassValue">
						<xsl:with-param name="node" select="."/>
						<xsl:with-param name="nr" select="$nr + 1"/>
						<xsl:with-param name="max" select="$max"/>
					</xsl:call-template>
					<!-- abschliessende dummy td's ausgeben, wenn notwendig -->
					<xsl:if test="count(./stf:Value)=0"> 
						<xsl:variable name="parents" select="count(ancestor::*[local-name()='Value'])"/>
						<xsl:call-template name="showDummyTd">
							<xsl:with-param name="nr" select="$max - $parents"/>
							<xsl:with-param name="styleName" select="'S_Class_Table_1'"/>
						</xsl:call-template> 
					</xsl:if> 
				</xsl:element>
			</xsl:if> 
			<xsl:if test="not($nr=0 or position()!=1)">
				<xsl:call-template name="showClassLine">
					<xsl:with-param name="node" select="."/>
					<xsl:with-param name="nr" select="$nr"/>
					<xsl:with-param name="max" select="$max"/>
				</xsl:call-template>
				<xsl:call-template name="showClassValue">
					<xsl:with-param name="node" select="."/>
					<xsl:with-param name="nr" select="$nr + 1"/>
					<xsl:with-param name="max" select="$max"/>
				</xsl:call-template> 
				<!-- abschliessende dummy td's ausgeben, wenn notwendig -->
				<xsl:if test="count(./stf:Value)=0">
					<xsl:variable name="parents" select="count(ancestor::*[local-name()='Value'])"/>
					<xsl:call-template name="showDummyTd">
						<xsl:with-param name="nr" select="$max - $parents"/>
						<xsl:with-param name="styleName" select="'S_Class_Table_1'"/>
					</xsl:call-template> 
				</xsl:if>
			</xsl:if> 
		</xsl:for-each>
	</xsl:template>

	<!--  ########################################################################################### -->
	<!--  ##  showClassValueXHTML    																															####### -->
	<!--  ##  Zeigt den Inhalt vom Value Element in einer Zeile an der korrekten Position     ####### -->
	<!--  ##  Wenn notwendig, werden leere td's angefuegt bzw. vorangestellt.                 ####### -->
	<!--  ##  node: Ein Classification Element               																	####### -->
	<!--  ##  nr:   Position innerhalb der Zeile                      												####### -->
	<!--  ##  max:  maximalen Elemente einer Zeile                    												####### -->
	<!--  ########################################################################################### -->
	<xsl:template name="showClassValueXHTML">
		<xsl:param name="node"/>
		<xsl:param name="nr"/>
		<xsl:param name="max"/>

		<xsl:for-each select="./stf:Value">
				<xsl:element name="tr">
					<xsl:call-template name="showClassLine">
						<xsl:with-param name="node" select="."/>
						<xsl:with-param name="nr" select="$nr"/>
						<xsl:with-param name="max" select="$max"/>
						<xsl:with-param name="showDummy" select="'true'"/>
					</xsl:call-template>
					<!-- abschliessende dummy td's ausgeben, wenn notwendig -->
					<xsl:variable name="parents" select="count(ancestor::*[local-name()='Value'])"/>
					<xsl:call-template name="showDummyTd">
						<xsl:with-param name="nr" select="$max - $parents"/>
						<xsl:with-param name="styleName" select="'S_Class_Table_1'"/>
					</xsl:call-template> 
				</xsl:element>
				<xsl:call-template name="showClassValueXHTML">
					<xsl:with-param name="node" select="."/>
					<xsl:with-param name="nr" select="$nr + 1"/>
					<xsl:with-param name="max" select="$max"/>
				</xsl:call-template>
		</xsl:for-each>
	</xsl:template>

	<!--  ########################################################################################### -->
	<!--  ##  showClassification																															####### -->
	<!--  ##  Zeigt den Inhalt des Classification Elements																		####### -->
	<!--  ########################################################################################### -->
	<xsl:template name="showClassification">
		<xsl:for-each select="//stf:Classification">
				<xsl:element name="table">
					<xsl:attribute name="cellspacing"><xsl:value-of select="'0'"/></xsl:attribute>
					<xsl:attribute name="cellpadding"><xsl:value-of select="'1'"/></xsl:attribute>
					<!--<xsl:attribute name="bordercolor"><xsl:value-of select="'#000000'"/></xsl:attribute>-->
					<xsl:call-template name="createStyleAttributeForExternStyle">
						<xsl:with-param name="styleName" select="'S_Class_Table'"/>
						<xsl:with-param name="addBorderColor" select="'true'"/>
					</xsl:call-template>
					<xsl:element name="tr">
						<xsl:element name="td">
							<xsl:attribute name="colspan">3</xsl:attribute>
							<xsl:call-template name="createStyleAttributeForExternStyle">
								<xsl:with-param name="styleName" select="'S_Class_Table_Head1'"/>
							</xsl:call-template>
							<xsl:call-template name="getTextOfNodeFullFeature">
								<xsl:with-param name="node" select="./stf:Name"/>
								<xsl:with-param name="mode" select="'fullTxt'"/>
							</xsl:call-template>
						</xsl:element>
						<!--  Zeige ChildClass Elemente -->
						<xsl:for-each select="./stf:ChildClass">
							<xsl:element name="td">
								<xsl:attribute name="colspan">3</xsl:attribute>
								<xsl:call-template name="createStyleAttributeForExternStyle">
									<xsl:with-param name="styleName" select="'S_Class_Table_Head1'"/>
								</xsl:call-template>
								<xsl:call-template name="getTextOfNodeFullFeature">
									<xsl:with-param name="node" select="./stf:Name"/>
									<xsl:with-param name="mode" select="'fullTxt'"/>
								</xsl:call-template>
							</xsl:element>
						</xsl:for-each>
					</xsl:element>
					<!-- Zeige Kopf unterteilung -->
					<xsl:element name="tr">			
						<xsl:element name="td">					
							<xsl:call-template name="createStyleAttributeForExternStyle">
								<xsl:with-param name="styleName" select="'S_Class_Table_Head1'"/>
							</xsl:call-template>
							<xsl:value-of select="$p_txt_Class_Head1"/>
						</xsl:element>
						<xsl:element name="td">					
							<xsl:call-template name="createStyleAttributeForExternStyle">
								<xsl:with-param name="styleName" select="'S_Class_Table_Head1'"/>
							</xsl:call-template>
							<xsl:value-of select="$p_txt_Class_Head2"/>
						</xsl:element>
						<xsl:element name="td">					
							<xsl:call-template name="createStyleAttributeForExternStyle">
								<xsl:with-param name="styleName" select="'S_Class_Table_Head1'"/>
							</xsl:call-template>
							<xsl:value-of select="$p_txt_Class_Head3"/>
						</xsl:element>
						<xsl:for-each select="./stf:ChildClass">
							<xsl:element name="td">					
								<xsl:call-template name="createStyleAttributeForExternStyle">
									<xsl:with-param name="styleName" select="'S_Class_Table_Head1'"/>
								</xsl:call-template>
								<xsl:value-of select="$p_txt_Class_Head1"/>
							</xsl:element>
							<xsl:element name="td">					
								<xsl:call-template name="createStyleAttributeForExternStyle">
									<xsl:with-param name="styleName" select="'S_Class_Table_Head1'"/>
								</xsl:call-template>
								<xsl:value-of select="$p_txt_Class_Head2"/>
							</xsl:element>
							<xsl:element name="td">					
								<xsl:call-template name="createStyleAttributeForExternStyle">
									<xsl:with-param name="styleName" select="'S_Class_Table_Head1'"/>
								</xsl:call-template>
								<xsl:value-of select="$p_txt_Class_Head3"/>
							</xsl:element>
						</xsl:for-each>
					</xsl:element>
					<xsl:if test="string($p_showClassXHTML)='true'">
						<xsl:call-template name="showClassValueXHTML">
							<xsl:with-param name="node" select="."/>
							<xsl:with-param name="nr" select="0"/>
							<xsl:with-param name="max" select="count(./stf:ChildClass)"/>
						</xsl:call-template>
					</xsl:if>
					<xsl:if test="string($p_showClassXHTML)!='true'">
						<xsl:call-template name="showClassValue">
							<xsl:with-param name="node" select="."/>
							<xsl:with-param name="nr" select="0"/>
							<xsl:with-param name="max" select="count(./stf:ChildClass)"/>
						</xsl:call-template>
					</xsl:if>
			</xsl:element>
			<xsl:element name="div">
				<xsl:element name="br"/>
			</xsl:element>
		</xsl:for-each>
	</xsl:template>
	
	<!--  ########################################################################################### -->
	<!--  ##  showMetaElement																																	####### -->
	<!--  ##  Zeigt den Inhalt eines Meta Elementes in einer TabellenZeile      							####### -->
	<!--  ##  Ausser es ist ein Meta Element fuer alternativen Text                           ####### -->
	<!--  ##  node: Ein Element, von welchem der Text ausgegeben wird 												####### -->
	<!--  ########################################################################################### -->
	<xsl:template name="showMetaElement">
		<xsl:param name="meta"/>

		<xsl:if test="not($meta/@type='alternatively')">
			<xsl:element name="tr">
				<xsl:element name="td">
					<xsl:call-template name="createStyleAttributeForExternStyle">
						<xsl:with-param name="styleName" select="'S_Meta_Table_1'"/>
					</xsl:call-template>
					<xsl:element name="a">
						<xsl:attribute name="name"><xsl:value-of select="$meta/@id"/></xsl:attribute>
						<!--<xsl:value-of select="./*[local-name()='CT']/*[local-name()='RefTxt']/text()"/>-->
						<xsl:text>#</xsl:text><xsl:value-of select="$meta/@id"/>
			  		<xsl:text>&#160;</xsl:text>	
					</xsl:element>
				</xsl:element>
				<xsl:element name="td">
					<xsl:call-template name="createStyleAttributeForExternStyle">
						<xsl:with-param name="styleName" select="'S_Meta_Table_2'"/>
					</xsl:call-template>
					<xsl:value-of select="./@type"/>
			  	<xsl:text>&#160;</xsl:text>	
					<xsl:if test="string-length(./@class) != 0">
			  		<xsl:text>-&#160;</xsl:text>	
						<xsl:value-of select="./@class"/>
			  		<xsl:text>&#160;</xsl:text>	
					</xsl:if>
				</xsl:element>
				<xsl:element name="td">
					<xsl:call-template name="createStyleAttributeForExternStyle">
						<xsl:with-param name="styleName" select="'S_Meta_Table_3'"/>
					</xsl:call-template>
					<xsl:call-template name="getTextOfNodeFullFeature">
						<xsl:with-param name="node" select="$meta"/>
						<xsl:with-param name="mode" select="'refTxtAsTxt'"/>
					</xsl:call-template>
			  	<xsl:text>&#160;</xsl:text>	
					<xsl:call-template name="getTextOfNodeFullFeature">
						<xsl:with-param name="node" select="$meta"/>
						<xsl:with-param name="mode" select="'keyTxt'"/>
					</xsl:call-template>
			  	<xsl:text>&#160;</xsl:text>	
				</xsl:element>
				<xsl:element name="td">
					<xsl:call-template name="createStyleAttributeForExternStyle">
						<xsl:with-param name="styleName" select="'S_Meta_Table_4'"/>
					</xsl:call-template>
					<xsl:call-template name="getTextOfNodeFullFeature">
						<xsl:with-param name="node" select="$meta"/>
						<xsl:with-param name="mode" select="'fullTxt'"/>
					</xsl:call-template>
			  	<xsl:text>&#160;</xsl:text>	
				</xsl:element>
			</xsl:element>
		</xsl:if>
	</xsl:template>
	
	<!--  ########################################################################################### -->
	<!--  ##  showMetaInformation																															####### -->
	<!--  ##  Zeigt den Inhalt eines MetaInformation Elements in Form einer Tabelle,	  			####### -->
	<!--  ##  wobei jedes Kindelement(Meta) ausgegeben wird 																	####### -->
	<!--  ##  metainformation: Ein MetaInformation Element            												####### -->
	<!--  ########################################################################################### -->
	<xsl:template name="showMetaInformation">
		<xsl:param name="metaInformation"/>

		<xsl:if test="count($metaInformation//stf:Meta[@type!='alternatively'])>0">
			<!-- zeige Kopf -->
			<xsl:element name="table">
				<xsl:attribute name="cellspacing"><xsl:value-of select="'0'"/></xsl:attribute>
				<xsl:attribute name="cellpadding"><xsl:value-of select="'1'"/></xsl:attribute>
				<!--<xsl:attribute name="bordercolor"><xsl:value-of select="'#000000'"/></xsl:attribute>-->
				<xsl:call-template name="createStyleAttributeForExternStyle">
					<xsl:with-param name="styleName" select="'S_Meta_Table'"/>
					<xsl:with-param name="addBorderColor" select="'true'"/>
				</xsl:call-template>
				<xsl:element name="tr">
					<xsl:element name="td">
						<xsl:call-template name="createStyleAttributeForExternStyle">
							<xsl:with-param name="styleName" select="'S_Meta_Table_Head1'"/>
						</xsl:call-template>
						<xsl:value-of select="$p_txt_Meta_Head1"/>
					</xsl:element>
					<xsl:element name="td">
						<xsl:call-template name="createStyleAttributeForExternStyle">
							<xsl:with-param name="styleName" select="'S_Meta_Table_Head2'"/>
						</xsl:call-template>
						<xsl:value-of select="$p_txt_Meta_Head2"/>
					</xsl:element>
					<xsl:element name="td">
						<xsl:call-template name="createStyleAttributeForExternStyle">
							<xsl:with-param name="styleName" select="'S_Meta_Table_Head3'"/>
						</xsl:call-template>
						<xsl:value-of select="$p_txt_Meta_Head3"/>
					</xsl:element>
					<xsl:element name="td">
						<xsl:call-template name="createStyleAttributeForExternStyle">
							<xsl:with-param name="styleName" select="'S_Meta_Table_Head4'"/>
						</xsl:call-template>
						<xsl:value-of select="$p_txt_Meta_Head4"/>
					</xsl:element>
				</xsl:element>
			<!-- zeige Eintraege -->
				<xsl:for-each select="$metaInformation/stf:Meta">
					<xsl:sort select="./@type"/>
					<xsl:call-template name="showMetaElement">
						<xsl:with-param name="meta" select="."/>
					</xsl:call-template>
				</xsl:for-each>
			</xsl:element>
		</xsl:if>
	</xsl:template>

	<!--  ########################################################################################### -->
	<!--  ##  showUnitElement																																	####### -->
	<!--  ##  Zeigt den Inhalt eines Unit Elementes in einer TabellenZeile      							####### -->
	<!--  ##  node: Ein Element, von welchem der Text ausgegeben wird 												####### -->
	<!--  ########################################################################################### -->
	<xsl:template name="showUnitElement">
		<xsl:param name="unit"/>

			<xsl:element name="tr">
				<xsl:element name="td">
					<xsl:call-template name="createStyleAttributeForExternStyle">
						<xsl:with-param name="styleName" select="'S_Unit_Table_1'"/>
					</xsl:call-template>
					<xsl:element name="a">
						<xsl:attribute name="name"><xsl:value-of select="$unit/@id"/></xsl:attribute><xsl:text>#</xsl:text><xsl:value-of select="$unit/@id"/>
			  		<xsl:text>&#160;</xsl:text>	
					</xsl:element>
				</xsl:element>
				<xsl:element name="td">
					<xsl:call-template name="createStyleAttributeForExternStyle">
						<xsl:with-param name="styleName" select="'S_Unit_Table_2'"/>
					</xsl:call-template>
					<xsl:call-template name="getTextOfNodeFullFeature">
						<xsl:with-param name="node" select="$unit"/>
						<xsl:with-param name="mode" select="'fullTxt'"/>
					</xsl:call-template>
			  	<xsl:text>&#160;</xsl:text>	
				</xsl:element>
			</xsl:element>
	</xsl:template>

	<!--  ########################################################################################### -->
	<!--  ##  showUnitInformation																															####### -->
	<!--  ##  Zeigt den Inhalt eines MetaInformation Elements in Form einer Tabelle,	  			####### -->
	<!--  ##  wobei jedes Kindelement(Unit) ausgegeben wird				  													####### -->
	<!--  ##  metainformation: Ein MetaInformation Element            												####### -->
	<!--  ########################################################################################### -->
	<xsl:template name="showUnitInformation">
		<xsl:param name="metaInformation"/>

		<xsl:if test="count($metaInformation//stf:Units)>0">
			<!-- zeige Kopf -->
			<xsl:element name="table">
				<xsl:attribute name="cellspacing"><xsl:value-of select="'0'"/></xsl:attribute>
				<xsl:attribute name="cellpadding"><xsl:value-of select="'1'"/></xsl:attribute>
				<!--<xsl:attribute name="bordercolor"><xsl:value-of select="'#000000'"/></xsl:attribute>-->
				<xsl:call-template name="createStyleAttributeForExternStyle">
					<xsl:with-param name="styleName" select="'S_Unit_Table'"/>
					<xsl:with-param name="addBorderColor" select="'true'"/>
				</xsl:call-template>
				<xsl:element name="tr">
					<xsl:element name="td">
						<xsl:call-template name="createStyleAttributeForExternStyle">
							<xsl:with-param name="styleName" select="'S_Unit_Table_Head1'"/>
						</xsl:call-template>
						<xsl:value-of select="$p_txt_Unit_Head1"/>
					</xsl:element>
					<xsl:element name="td">
						<xsl:call-template name="createStyleAttributeForExternStyle">
							<xsl:with-param name="styleName" select="'S_Unit_Table_Head2'"/>
						</xsl:call-template>
						<xsl:value-of select="$p_txt_Unit_Head2"/>
					</xsl:element>
				</xsl:element>
			<!-- zeige Eintraege -->
				<xsl:for-each select="$metaInformation/stf:Units">
					<xsl:call-template name="showUnitElement">
						<xsl:with-param name="unit" select="."/>
					</xsl:call-template>
				</xsl:for-each>
			</xsl:element>
		</xsl:if>
	</xsl:template>


	<!--  ########################################################################################### -->
	<!--  ##  showDescriptionElement																													####### -->
	<!--  ##  Zeigt den Inhalt eines Description Elementes in einer TabellenZeile, wenn				####### -->
	<!--  ##  es dieses Element gibt																													####### -->
	<!--  ##  node: Ein Element, von welchem der Text ausgegeben wird 												####### -->
	<!--  ##  text: Ein beschreibender Text fuer dieses Element 															####### -->
	<!--  ########################################################################################### -->
	<xsl:template name="showDescriptionElement">
		<xsl:param name="node"/>
		<xsl:param name="text"/>

		<xsl:if test="local-name($node) != ''">
			<xsl:element name="tr">
				<xsl:element name="td">
					<xsl:call-template name="createStyleAttributeForExternStyle">
						<xsl:with-param name="styleName" select="'S_Dbl_Core_Table_1'"/>
					</xsl:call-template>
					<xsl:value-of select="$text"/>
			  	<xsl:text>&#160;</xsl:text>	
				</xsl:element>
				<xsl:element name="td">
					<xsl:call-template name="createStyleAttributeForExternStyle">
						<xsl:with-param name="styleName" select="'S_Dbl_Core_Table_2'"/>
					</xsl:call-template>
					<xsl:call-template name="getTextOfNodeFullFeature">
							<xsl:with-param name="node" select="$node"/>
							<xsl:with-param name="mode" select="'fullTxt'"/>
					</xsl:call-template>
			  	<xsl:text>&#160;</xsl:text>	
				</xsl:element>
			</xsl:element>
		</xsl:if>
	</xsl:template>
	
	<!--  ########################################################################################### -->
	<!--  ##  showDublinCore																																	####### -->
	<!--  ##  Zeigt den Inhalt des Description Elementes in Form einer Tabelle								####### -->
	<!--  ##  description: Das Element Description																						####### -->
	<!--  ########################################################################################### -->
	<xsl:template name="showDublinCore">
		<xsl:param name="description"/>

			<xsl:if test="count($description//*)>0">
				<xsl:element name="table">
				<xsl:attribute name="cellspacing"><xsl:value-of select="'0'"/></xsl:attribute>
				<xsl:attribute name="cellpadding"><xsl:value-of select="'1'"/></xsl:attribute>
				<!--<xsl:attribute name="bordercolor"><xsl:value-of select="'#000000'"/></xsl:attribute>-->
					<xsl:call-template name="createStyleAttributeForExternStyle">
						<xsl:with-param name="styleName" select="'S_Dbl_Core_Table'"/>
						<xsl:with-param name="addBorderColor" select="'true'"/>
					</xsl:call-template>
					<!-- zeige Kopf -->
					<xsl:element name="tr">
						<xsl:element name="td">
							<xsl:call-template name="createStyleAttributeForExternStyle">
								<xsl:with-param name="styleName" select="'S_Dbl_Core_Table_Head1'"/>
							</xsl:call-template>
							<xsl:value-of select="$p_txt_Dbl_Core_Head1"/>
						</xsl:element>
						<xsl:element name="td">
							<xsl:call-template name="createStyleAttributeForExternStyle">
								<xsl:with-param name="styleName" select="'S_Dbl_Core_Table_Head2'"/>
							</xsl:call-template>
							<xsl:value-of select="$p_txt_Dbl_Core_Head2"/>
						</xsl:element>
					</xsl:element>
					<!-- zeige Eintraege -->
					<xsl:call-template name="showDescriptionElement">
						<xsl:with-param name="node" select="$description/stf:Title"/>
						<xsl:with-param name="text" select="$p_txt_Dbl_Core_Title"/>
					</xsl:call-template>
					<xsl:call-template name="showDescriptionElement">
						<xsl:with-param name="node" select="$description/stf:Creator"/>
						<xsl:with-param name="text" select="$p_txt_Dbl_Core_Creator"/>
					</xsl:call-template>
					<xsl:call-template name="showDescriptionElement">
						<xsl:with-param name="node" select="$description/stf:Subject"/>
						<xsl:with-param name="text" select="$p_txt_Dbl_Core_Subject"/>
					</xsl:call-template>
					<xsl:call-template name="showDescriptionElement">
						<xsl:with-param name="node" select="$description/stf:Description"/>
						<xsl:with-param name="text" select="$p_txt_Dbl_Core_Description"/>
					</xsl:call-template>
					<xsl:call-template name="showDescriptionElement">
						<xsl:with-param name="node" select="$description/stf:Publisher"/>
						<xsl:with-param name="text" select="$p_txt_Dbl_Core_Publisher"/>
					</xsl:call-template>
					<xsl:call-template name="showDescriptionElement">
						<xsl:with-param name="node" select="$description/stf:Contributor"/>
						<xsl:with-param name="text" select="$p_txt_Dbl_Core_Contributor"/>
					</xsl:call-template>
					<xsl:call-template name="showDescriptionElement">
						<xsl:with-param name="node" select="$description/stf:Date"/>
						<xsl:with-param name="text" select="$p_txt_Dbl_Core_Date"/>
					</xsl:call-template>
					<xsl:call-template name="showDescriptionElement">
						<xsl:with-param name="node" select="$description/stf:Type"/>
						<xsl:with-param name="text" select="$p_txt_Dbl_Core_Type"/>
					</xsl:call-template>
					<xsl:call-template name="showDescriptionElement">
						<xsl:with-param name="node" select="$description/stf:Format"/>
						<xsl:with-param name="text" select="$p_txt_Dbl_Core_Format"/>
					</xsl:call-template>
					<xsl:call-template name="showDescriptionElement">
						<xsl:with-param name="node" select="$description/stf:Identifier"/>
						<xsl:with-param name="text" select="$p_txt_Dbl_Core_Identifier"/>
					</xsl:call-template>
					<xsl:call-template name="showDescriptionElement">
						<xsl:with-param name="node" select="$description/stf:Source"/>
						<xsl:with-param name="text" select="$p_txt_Dbl_Core_Source"/>
					</xsl:call-template>
					<xsl:call-template name="showDescriptionElement">
						<xsl:with-param name="node" select="$description/stf:Language"/>
						<xsl:with-param name="text" select="$p_txt_Dbl_Core_Language"/>
					</xsl:call-template>
					<xsl:call-template name="showDescriptionElement">
						<xsl:with-param name="node" select="$description/stf:Relation"/>
						<xsl:with-param name="text" select="$p_txt_Dbl_Core_Relation"/>
					</xsl:call-template>
					<xsl:call-template name="showDescriptionElement">
						<xsl:with-param name="node" select="$description/stf:Coverage"/>
						<xsl:with-param name="text" select="$p_txt_Dbl_Core_Coverage"/>
					</xsl:call-template>
					<xsl:call-template name="showDescriptionElement">
						<xsl:with-param name="node" select="$description/stf:Rights"/>
						<xsl:with-param name="text" select="$p_txt_Dbl_Core_Rights"/>
					</xsl:call-template>
				</xsl:element>
			</xsl:if>
	</xsl:template>

	<!--  ########################################################################################### -->
	<!--  ##  createRefMetLinks																																####### -->
	<!--  ##  Zeigt Verweise zu Metadaten als Link an. Ausgenommen alternativen Text					####### -->
	<!--  ##  node: Ein Element                   																						####### -->
	<!--  ########################################################################################### -->
	<xsl:template name="createRefMetLinks">
		<xsl:param name="node"/>
			<xsl:if test="string($p_showMetaInformationGlobal)='true' or string($p_showMetaInformationTable)='true'">
				<xsl:if test="$node/@refMet">
					<xsl:call-template name="idrefSplitter">
						<xsl:with-param name="function" select="'createRefMetLinkSingle'"/>
						<xsl:with-param name="key" select="'key'"/>
						<xsl:with-param name="ids_string" select="$node/@refMet"/>
					</xsl:call-template>
				</xsl:if>
			</xsl:if>
	</xsl:template>

	<!--  ########################################################################################### -->
	<!--  ##  createRefMetLinkSingle																													####### -->
	<!--  ##  Zeigt ein Meta Element als Link an. Ausgenommen alternativen Text	      				####### -->
	<!--  ##  node: Ein Element (Meta)             																						####### -->
	<!--  ########################################################################################### -->
	<xsl:template name="createRefMetLinkSingle">
		<xsl:param name="meta"/>
			<xsl:if test="$meta/@type != 'alternatively'">
				<xsl:call-template name="createLink">
					<xsl:with-param name="node" select="$meta"/>
					<xsl:with-param name="prefix" select="'#'"/>
				</xsl:call-template>
			</xsl:if>
	</xsl:template>
</xsl:stylesheet>

