<?xml version="1.0"?>

 <xsl:stylesheet  xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0"   xmlns:s="http://www.w3.org/2000/svg" xmlns:exslt="http://exslt.org/common" xmlns:m="http://exslt.org/math" exclude-result-prefixes="s m exslt" >

<!--Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

	All rights reserved.

	This component and the accompanying materials are made available

	under the terms of the License "Eclipse Public License v1.0"

	which accompanies this distribution, and is available

	at the URL "http://www.eclipse.org/legal/epl-v10.html".

	Initial Contributors:

	Nokia Corporation - initial contribution.

	Contributors:

	Description:

	Create a stand-alone sysdef from a linked set of fragments

-->

	  <xsl:key name="color" match="legend/cbox" use="@value"/>

	<xsl:output method="xml" cdata-section-elements="script s:script" indent="yes"/>

<xsl:param name="pkgLabelSize" select="4.23"/> <!-- the height needed at the bottom of a package for the label (mm) -->

<!-- /SystemDefinition/@detail  = The level of detail to show in the diagram. 

	The value is the name of the lowest element to show. If @static  is set to false, mousing-over an item will show its detailed content. 

	By default this is equivalent to 'component' -->

<!-- ====== Constants ============= -->

<xsl:param name="groupDx" select="2.1"/> <!-- the horizontal distance between groups (mm) -->

<xsl:param name="groupDy" select="3.2"/> <!-- the vertical distance between groups (mm) -->

<xsl:param name="cSize" select="9.3"/> <!-- the width and height of a component (mm) -->

<xsl:param name="mHeight" select="15.6"/> <!-- the height of a collection (mm) -->

<xsl:param name="mMinWidth" select="15.6"/> <!-- the minimum width of a collection (mm) -->

<xsl:param name="lyrFixedWidth" select="$mMinWidth * 6"/><!-- fixed width of a layer (mm)-->

<xsl:param name="pkgMinWidth" select="$cSize * 3"/><!-- small pkg, use min width of 2 * smallest possible collection -->

<xsl:param name="subpkgMinWidth" select="$cSize * 3"/> <!-- small nested pkg, use min width of  3 components -->

<xsl:param name="pkgFixedWidth" select="$mMinWidth * 5"/><!-- fixed width of a  pacakge (mm) -->

<xsl:param name="subpkgFixedWidth" select="$mMinWidth * 3"/> <!-- fixed width nested pkg (mm) -->

<xsl:variable name="inlineLabel" select="3 * $cSize"/> <!-- the max width of an inline label. 3 times the width of a collection by default 

	I don't like this. Should compute somehow and make local variable. -->

<xsl:variable name="detail-block-space" select="6"/>

<xsl:param name="lyrTitleBox" select="9.3"/> <!-- the width of the layer's title box (mm) -->

<xsl:variable name="lgrpDx" select="5"/> <!-- the width of a layer group border (mm)-->

<xsl:variable name="lgrpLabelDx" select="$lyrTitleBox + 5.7"/> <!-- the width of a layer group title (mm) -->

<xsl:variable name="levelExpandName" select="$cSize"/> <!-- the height of the name when levels are being shown inline (mm) -->

<xsl:param name="Verbose" select="0"/> <!-- Verbosity level of messages. Set to 1 (or higher) to get runtime comments  -->

<!-- ====== Computed values ============= -->

<xsl:template name="Caller-Debug"><xsl:param name="text"/>

	<xsl:if test="$Verbose &gt; 4"><xsl:message>&#xa;Note: <xsl:value-of select="$text"/></xsl:message></xsl:if>

</xsl:template>

<xsl:template name="Caller-Note"><xsl:param name="text"/>

	<xsl:message>&#xa;Note: <xsl:value-of select="$text"/></xsl:message>

</xsl:template>

<xsl:template name="Caller-Warning"><xsl:param name="text"/>

	<xsl:message>&#xa;Warning: <xsl:value-of select="$text"/></xsl:message>

</xsl:template>

<xsl:template name="Caller-Error"><xsl:param name="text"/>

	<xsl:message>&#xa;Error: <xsl:value-of select="$text"/></xsl:message>

</xsl:template>

<xsl:template name="Critical-Error"><xsl:param name="text"/>

	<xsl:message terminate="yes">&#xa;Error: <xsl:value-of select="$text"/></xsl:message>

</xsl:template>

<xsl:template match="/SystemDefinition">

		<xsl:apply-templates select="." mode="sizing"/>

</xsl:template>

<xsl:template match="node()" mode="sizing"><xsl:copy-of select="."/></xsl:template>

<xsl:template match="systemModel" mode="sizing">

	<!-- 1st pass to compute the sizes of everything -->

	<xsl:copy><xsl:apply-templates mode="copy-attr" select="@*"/>

		<xsl:apply-templates select="*" mode="sizing"/>

	</xsl:copy>

</xsl:template>

<xsl:template match="meta" mode="sizing">

	<xsl:copy><xsl:apply-templates mode="copy-attr" select="@*"/>

		<xsl:attribute name="width">0</xsl:attribute>

		<xsl:attribute name="height">0</xsl:attribute>

		<xsl:copy-of select="node()"/>

	</xsl:copy>

</xsl:template>

<xsl:template name="full-width">

	<xsl:param name="w0" select="@width"/>

	<xsl:param name="lscale"/>

	<!-- call from item which contains the global metas -->

	<xsl:variable name="logo-w" select="sum(meta[@rel='model-logo']/@width) + $groupDx * count(meta[@rel='model-logo'])"/>

	<xsl:choose>

		<xsl:when test="not(meta[@rel='model-legend']) and meta[@rel='model-logo'] and meta[@rel='model-logo']/@width &gt; $w0 ">

			<!-- no legend, but a logo that's wider than the model, use logo width -->

			<xsl:value-of select="meta[@rel='model-logo']/@width"/>

		</xsl:when>

		<xsl:when test="not(meta[@rel='model-legend']/legend)">

			<!-- no legend, and if there is a logo it's narrower than the model, use model width -->

			<xsl:value-of select="$w0"/>

		</xsl:when>

		<xsl:when test="meta[@rel='model-legend']/legend/@percent-width and meta[@rel='model-legend']/legend/@percent-width &lt;= 100">

			<!-- legend takes up less than the full width of the model, so it can be ignored -->

			<xsl:value-of select="$w0"/>

		</xsl:when>

		<xsl:when test="meta[@rel='model-legend']/@width * $lscale + $logo-w &gt; $w0">

			<!-- if the legend is scaled so that it's wider than the model, then use that width -->

			<xsl:value-of select="meta[@rel='model-legend']/@width * $lscale + $logo-w"/>

		</xsl:when>

		<xsl:otherwise> <!-- legend scaling is smaller than the width, so use model width-->

			<xsl:value-of select="$w0"/>

		</xsl:otherwise>

	</xsl:choose>

</xsl:template>

<xsl:template name="full-height"><xsl:param name="lscale"/>

<!--

 HEIGHT:

 if there is no scaling, add max(legend height , logo height) to the page height

 if there is scaling use max(legend height * scale , logo height) 

-->

	<xsl:call-template name="sum-list">

		<xsl:with-param name="list">

			<xsl:value-of select="concat($groupDy,' ')"/>

			<xsl:choose>

				<xsl:when test="not(meta[@rel='model-legend']/legend) and meta[@rel='model-logo'] ">

					<!-- no legend, but there's a logo, so add that height -->

					<xsl:value-of select="meta[@rel='model-logo']/@height"/>

				</xsl:when>

				<xsl:when test="not(meta[@rel='model-legend']/legend)">0</xsl:when>			<!-- no legend and no logo -->

				<xsl:when test="meta[@rel='model-legend']/@height * $lscale &gt; sum(meta[@rel='model-logo']/@height)">

					<!-- legend is taller than the logo, use legend -->

					<xsl:value-of select="meta[@rel='model-legend']/@height * $lscale"/>

				</xsl:when>

				<xsl:otherwise> <!-- legend is not at tall as the logo, use logo -->

					<xsl:value-of select="meta[@rel='model-logo']/@height"/>

				</xsl:otherwise>

			</xsl:choose><xsl:text> </xsl:text>

			<xsl:if test="meta[@rel='model-footer']">

				<xsl:value-of select="concat(meta[@rel='model-footer']/@height,' ')"/>

			</xsl:if>

			<xsl:if test="not(layer)">  <!-- not a full model, just use this one item -->

				<xsl:value-of select="@height"/> 

			</xsl:if>

			<!-- padding + extra padding from layer groups for full model-->

			<xsl:if test="layer"> 

				<xsl:value-of select="concat(sum(layer[not(@span) or @span=0]/@height), ' ')"/>

				<xsl:value-of select="count(layer[not(@span) or @span=0]) * $groupDy + sum(layer[not(@span) or @span=0]/@*[name()='padding-bottom' or name()='padding-top'])"/>

			</xsl:if>

			<xsl:text> </xsl:text>

		</xsl:with-param>

	</xsl:call-template>

</xsl:template>			

<xsl:template match="/SystemDefinition" mode="sizing">

	<!-- not full model, just one item  -->

	<!-- 1st pass to compute the sizes of everything -->

	<xsl:variable name="content">

		<xsl:apply-templates mode="sizing"/>

	</xsl:variable>

	<xsl:copy><xsl:apply-templates mode="copy-attr" select="@*"/>

		<xsl:attribute name="padding-left">0</xsl:attribute>

		<xsl:attribute name="padding-right">0</xsl:attribute>

		<xsl:for-each select="exslt:node-set($content)/*">

			<xsl:attribute name="model-width"><xsl:value-of select="@width"/></xsl:attribute>

			<xsl:attribute name="model-height"><xsl:value-of select="@height"/></xsl:attribute>

			<!-- the width without taking the legend into account -->

			<xsl:variable name="lscale"> <!-- legend scaling --> 

				<xsl:apply-templates select="meta[@rel='model-legend']/legend" mode="scale-factor">

					<xsl:with-param name="full-width" select="current()/@width + $groupDy"/>

				</xsl:apply-templates>

			</xsl:variable>

			<xsl:attribute name="width">

				<xsl:call-template name="full-width">

					<xsl:with-param name="w0" select="current()/@width + $groupDy"/>

					<xsl:with-param name="lscale" select="$lscale"/>

				</xsl:call-template>

			</xsl:attribute>

			<xsl:attribute name="height">

				<xsl:call-template name="full-height">

					<xsl:with-param name="lscale" select="$lscale"/>

				</xsl:call-template>

			</xsl:attribute>

			<xsl:copy><xsl:copy-of select="@*"/> 	<!--  the root item  -->

				<xsl:for-each select="meta[@rel='model-legend']">

					<!-- copy legend 1st and add scaling -->

					<xsl:copy>

						<xsl:copy-of select="@*[name()!='width' and name()!='height']"/>

						<xsl:attribute name="width"><xsl:value-of select="@width * $lscale"/></xsl:attribute>

						<xsl:attribute name="height"><xsl:value-of select="@height * $lscale"/></xsl:attribute>

						<xsl:attribute name="scaled"><xsl:value-of select="$lscale"/></xsl:attribute>

						<xsl:copy-of select="node()"/>

					</xsl:copy>

				</xsl:for-each>

				<!-- copy everything else -->

				<xsl:copy-of select="*[not(self::meta and @rel='model-legend')]"/>

			</xsl:copy>

		</xsl:for-each>

	</xsl:copy>

</xsl:template>

<xsl:template match="/SystemDefinition[systemModel]" mode="sizing">

	<!-- 1st pass to compute the sizes of everything -->

	<xsl:variable name="content0">

		<xsl:apply-templates mode="sizing"/>

	</xsl:variable>

	<xsl:variable name="heights">

		<xsl:call-template name="layer-height">

			<xsl:with-param name="layers">

				<xsl:for-each select="exslt:node-set($content0)/systemModel/layer">

					<xsl:copy><xsl:copy-of select="@id|@height|@span"/></xsl:copy>

				</xsl:for-each>

			</xsl:with-param>

			<xsl:with-param name="spans" select="exslt:node-set($content0)/systemModel/layer[@span and @span!=0]"/>

		</xsl:call-template>

	</xsl:variable>

	<xsl:variable name="content">

		<xsl:apply-templates select="exslt:node-set($content0)/*" mode="adjust-layer-height">

			<xsl:with-param name="new-layers" select="exslt:node-set($heights)/layer"/>

		</xsl:apply-templates>

	</xsl:variable>	 

	<xsl:copy><xsl:apply-templates mode="copy-attr" select="@*"/>

		<xsl:for-each select="exslt:node-set($content)/systemModel">

			<xsl:variable name="m-width">

				<xsl:call-template name="max-from-list">

					<xsl:with-param name="list">		

						<xsl:for-each select="layer[not(@span) or @span=0]">

							<xsl:value-of select="concat(sum(@width | following-sibling::layer[@span and position() - @span &lt;= 0]/@width) + $groupDx * (count(@width | following-sibling::layer[@span and position() - @span &lt;= 0]/@width)  - 1), ' ')"/>					

						</xsl:for-each>

					</xsl:with-param> 

				</xsl:call-template>

			</xsl:variable>

			<xsl:attribute name="model-width"><xsl:value-of select="$m-width"/></xsl:attribute>

			<xsl:variable name="right-borders">

				<xsl:call-template name="max-from-list">

					<xsl:with-param name="list">

						<xsl:text>0 </xsl:text>

						<xsl:for-each select="meta[@rel='layer-group']/layer-group">

							<xsl:apply-templates select="." mode="right-border"/><xsl:text> </xsl:text>

						</xsl:for-each>

					</xsl:with-param>

				</xsl:call-template>

			</xsl:variable>

			<xsl:variable name="left-borders">

				<xsl:call-template name="max-from-list">

					<xsl:with-param name="list">

						<xsl:text>0 </xsl:text>

						<xsl:for-each select="meta[@rel='layer-group']/layer-group">

							<xsl:apply-templates select="." mode="left-border"/><xsl:text> </xsl:text>

						</xsl:for-each>

					</xsl:with-param>

				</xsl:call-template>

			</xsl:variable>

			<xsl:attribute name="padding-left"><xsl:value-of select="$left-borders + $lyrTitleBox + 3.5 + $groupDy"/></xsl:attribute>

			<xsl:attribute name="padding-right"><xsl:value-of select="$right-borders + $groupDy"/></xsl:attribute>

			<!-- the width without taking the legend into account -->

			<xsl:variable name="w0"  select="$m-width+ $lyrTitleBox + 3.5 +  2 * $groupDy + $left-borders + $right-borders"/>

			<!--

			Options for scaling the legend:

			WIDTH: 

			if the legend has @percent-width, then don't count the legend width in the list

			if @percent-width < 100 ignore entirely

			if @percent-width > 100 then width = (full width - logo width) * @percent-width % + logo width 

			@maxscale is set, then clamp scale to that and recalc width if scale > 1

			if there is no legend scaling

			take into account legend width + logo width +padding

			-->

			<xsl:variable name="lscale"> <!-- legend scaling --> 

				<xsl:apply-templates select="meta[@rel='model-legend']/legend" mode="scale-factor">

					<xsl:with-param name="full-width" select="$w0"/>

				</xsl:apply-templates>

			</xsl:variable>

<!--

 HEIGHT:

 if there is no scaling, add max(legend height , logo height) to the page height

 if there is scaling use max(legend height * scale , logo height) 

-->

		<xsl:attribute name="model-height">

			<xsl:value-of select="count(layer[not(@span) or @span=0]) * $groupDy + sum(layer[not(@span) or @span=0]/@*[name()='height'  or name()='padding-bottom' or name()='padding-top'])"/>

		</xsl:attribute>

		<xsl:attribute name="width">

				<xsl:call-template name="full-width">

					<xsl:with-param name="w0" select="$w0"/>

					<xsl:with-param name="lscale" select="$lscale"/>

				</xsl:call-template>

		</xsl:attribute>

		<xsl:attribute name="height">

			<xsl:call-template name="full-height">

				<xsl:with-param name="lscale" select="$lscale"/>

			</xsl:call-template>

		</xsl:attribute>

		<xsl:copy><xsl:copy-of select="@*"/>

			<xsl:for-each select="meta[@rel='model-legend']">

				<!-- copy legend 1st and add scaling -->

				<xsl:copy>

					<xsl:copy-of select="@*[name()!='width' and name()!='height']"/>

					<xsl:attribute name="width"><xsl:value-of select="@width * $lscale"/></xsl:attribute>

					<xsl:attribute name="height"><xsl:value-of select="@height * $lscale"/></xsl:attribute>

					<xsl:attribute name="scaled"><xsl:value-of select="$lscale"/></xsl:attribute>

					<xsl:copy-of select="node()"/>

				</xsl:copy>

			</xsl:for-each>

			<!-- copy everything else -->

			<xsl:copy-of select="*[not(self::meta and @rel='model-legend')]"/>

		</xsl:copy>

	</xsl:for-each>

	</xsl:copy>

</xsl:template>

<xsl:template name="layer-height-step">

	<xsl:param name="layers"/>

	<xsl:param name="span"/>

	<xsl:variable name="spanning" select="$span/preceding-sibling::layer[position() &lt;= $span/@span]"/>

	<xsl:variable name="h" select="sum($spanning/@height) + (count($spanning) - 1) * $groupDy"/>

	<xsl:variable name="even" select="($span/@height - $h) div count($spanning)"/>

	<xsl:for-each select="exslt:node-set($layers)/layer">

		<xsl:copy><xsl:copy-of select="@id|@span"/>

			<xsl:choose>

				<xsl:otherwise> <!-- layers smaller than spanned -->

					<xsl:choose>

						<xsl:when test="$spanning[@id=current()/@id] and $span/@height &gt; $h">

							<!-- layers are smaller than spanned layer -->

							<xsl:attribute name="height"><xsl:value-of select="@height + $even"/></xsl:attribute>

						</xsl:when>

						<xsl:when test="@id=$span/@id and $span/@height &lt; $h">

							<!-- layers are bigger than spanned layer -->

							<xsl:attribute name="height"><xsl:value-of select="$h"/></xsl:attribute>

						</xsl:when>

						<xsl:otherwise><xsl:copy-of select="@height"/></xsl:otherwise>

					</xsl:choose>

				</xsl:otherwise>

			</xsl:choose>

		</xsl:copy>

	</xsl:for-each>

</xsl:template>

<xsl:template name="layer-height">

	<xsl:param name="layers"/>

	<xsl:param name="spans"/>

	<xsl:choose>

		<xsl:when test="not($spans)">

			<!-- layers are bigger than spanned layer -->

			<xsl:copy-of select="$layers"/>

		</xsl:when>

		<xsl:when test="count($spans)=1">

			<xsl:call-template name="layer-height-step">

				<xsl:with-param name="layers" select="$layers"/>

				<xsl:with-param name="span" select="$spans[1]"/>

			</xsl:call-template>

		</xsl:when>

		<xsl:otherwise>

			<xsl:call-template name="layer-height">

				<xsl:with-param name="layers">

					<xsl:call-template name="layer-height-step">

						<xsl:with-param name="layers" select="$layers"/>

						<xsl:with-param name="span" select="$spans[1]"/>

					</xsl:call-template>

				</xsl:with-param>

				<xsl:with-param name="spans" select="$spans[position() &gt; 1]"/>

			</xsl:call-template>

		</xsl:otherwise>

	</xsl:choose>

</xsl:template>

<xsl:template match="legend" mode="scale-factor">

	<!--

	Options for scaling the legend:

	WIDTH: 

	if the legend has @percent-width, then don't count the legend width in the list

	if @percent-width < 100 ignore entirely

	if @percent-width > 100 then width = (full width - logo width) * @percent-width % + logo width 

	@maxscale is set, then clamp scale to that and recalc width if scale > 1

	if there is no legend scaling

	take into account legend width + logo width +padding

	-->

	<xsl:param name="full-width"/>

	<!-- the space avialble for the legend -->

	<xsl:variable name="available-width" select="$full-width - sum(../../meta[@rel='model-logo']/@width) - $groupDx * count(../../meta[@rel='model-logo'])"/>

	<!-- the space the legend wants to take up -->

	<xsl:variable name="want-width">

		<xsl:choose>

			<xsl:when test="@percent-width"><xsl:value-of select="0.01* @percent-width * $available-width"/></xsl:when>

			<xsl:otherwise><xsl:value-of select="$available-width"/></xsl:otherwise> <!-- assume 100% in relevent cases where % not set -->

		</xsl:choose>

	</xsl:variable>	

	<xsl:choose>

		<xsl:when test="@maxscale and ($want-width &gt; ../@width * @maxscale)"><xsl:value-of select="@maxscale"/></xsl:when> <!-- desired space requires too much scaling, so limit the scale to maxscale -->

		<xsl:when test="@maxscale or @percent-width"><xsl:value-of select="$want-width div ../@width"/></xsl:when> <!-- scaling = desired size / available size -->

		<xsl:otherwise>1</xsl:otherwise> <!-- don't scale unless asked to -->

	</xsl:choose>

</xsl:template>

<xsl:template match="node()" mode="adjust-layer-height">

	<xsl:copy-of select="."/>

</xsl:template>

<xsl:template match="systemModel" mode="adjust-layer-height">	<xsl:param name="new-layers"/>

	<xsl:copy><xsl:copy-of select="@*"/>

		<xsl:apply-templates select="*" mode="adjust-layer-height">

			<xsl:with-param name="new-layers" select="$new-layers"/>

		</xsl:apply-templates>		

	</xsl:copy>

</xsl:template>

<xsl:template match="layer" mode="adjust-layer-height">	<xsl:param name="new-layers"/>

	<xsl:copy><xsl:copy-of select="@*[name()!='height']"/>

		<xsl:choose>

			<xsl:when test="$new-layers[@id=current()/@id]/@height">

				<xsl:copy-of select="$new-layers[@id=current()/@id]/@height"/>

			</xsl:when>

			<xsl:otherwise>

				<xsl:copy-of select="@height"/>

			</xsl:otherwise>

		</xsl:choose>

		<xsl:copy-of select="node()"/>

	</xsl:copy>

</xsl:template>

<xsl:template match="layer" mode="sizing">

	<!-- 1st pass to compute the sizes of everything -->

	<xsl:variable name="content">

		<xsl:apply-templates mode="sizing"/>

	</xsl:variable>	 

	<!-- if there's no content, only show if forced to by placeholder-detail -->

	<xsl:if test="/SystemDefinition[@placeholder-detail]	or exslt:node-set($content)/*[self::package]">  	

		<xsl:copy><xsl:apply-templates mode="copy-attr" select="@*"/>

			<xsl:if test="not(@span) or @span=0  or count(exslt:node-set($content)/package)!=1">

				<xsl:attribute name="ipad"><xsl:value-of select="2* $groupDy"/></xsl:attribute>

			</xsl:if>		

			<xsl:attribute name="width">

						<xsl:value-of select="sum(exslt:node-set($content)/*/@width) + $groupDx * ( count(exslt:node-set($content)/*/@width)  - 1 )"/>

			</xsl:attribute>

			<xsl:attribute name="height">

				<xsl:for-each select="exslt:node-set($content)/*">

					<xsl:sort select="@height" order="descending" data-type="number"/>

					<xsl:if test="position()=1"><xsl:value-of select="@height"/></xsl:if>

				</xsl:for-each>

			</xsl:attribute>

			<xsl:call-template name="layer-padding"/>

			<xsl:copy-of select="$content"/>

		</xsl:copy>

	</xsl:if>

</xsl:template>

<xsl:template name="layer-padding">

	<xsl:variable name="top" select="count(../meta[@rel='layer-group']/descendant::layer-group[@to=current()/@id])"/>

	<xsl:variable name="bottom" select="count(../meta[@rel='layer-group']/descendant::layer-group[@from=current()/@id])"/>

	<xsl:if test="$top!=0">

		<xsl:attribute name="padding-top">

			<xsl:value-of select="$top * $lgrpDx"/>

		</xsl:attribute>

	</xsl:if>

	<xsl:if test="$bottom!=0">

		<xsl:attribute name="padding-bottom">

			<xsl:value-of select="$bottom * $lgrpDx"/>

		</xsl:attribute>

	</xsl:if>

</xsl:template>

<xsl:template name="spanned-levels-step">

	<xsl:param name="pkg"/>

	<xsl:param name="levels"/>

	<xsl:variable name="named" select="exslt:node-set($levels)/level[@name=$pkg/@level] or not($pkg/@level)"/>

	<!-- it's this level, or it spans all by not having any level defined, or by being in the span range for level  or it's the unnamed error level-->

	<xsl:variable name="match" select="exslt:node-set($levels)/level[

		@name=$pkg/@level  or 

		not($pkg/@level)  or 

		($pkg/@span and following-sibling::level[position() < $pkg/@span][@name=$pkg/@level or (not(@name) and not($named))]) or 

		(not($named) and not(@name))

		]"/>

	<xsl:variable name="h" select="(sum($match/@height) + $groupDy * (count($match) - 1))"/> <!--height of all levels spanned by this -->

	<xsl:variable name="even" select="($pkg/@height - $groupDy * (count($match) - 1) - sum($match/@min-height)) div count($match)"/>

	<xsl:for-each select="exslt:node-set($levels)/level">

		<xsl:choose>

			<xsl:when test="$even &lt;= 0">

				<!-- this is too small to have an impact, ignore this -->

				<xsl:copy-of select="."/>

			</xsl:when>

			<xsl:when test="$match[@name=current()/@name or (not(@name) and not(current()/@name))]">

				<xsl:choose>

					<xsl:when test="$h &gt;= $pkg/@height">

							<xsl:copy-of select="."/> <!-- no change -->

					</xsl:when>

						<xsl:otherwise>

							<xsl:copy><xsl:copy-of select="@*[name()!='height']"/>

								<xsl:attribute name="height">

									<xsl:value-of select="sum(@min-height) + $even"/>

								</xsl:attribute>

								<xsl:copy-of select="*"/>

							</xsl:copy>

						</xsl:otherwise>

				</xsl:choose>