<?xml version="1.0"?>

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

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

	<xsl:param name="Run"/> 

		<!-- Selects the run mode, by default it will draw the model from the given layout data. The output is an SVG diagram. 

		There are two other options:

				"calc" - Indicates that it should just do all 1st-pass calculations and generate a model with those embedded. The generated XML output is non-standard and has a fragile syntax that cannot be relied upon.

				"draw" - Draw the model from a pre-caculated result. The output is an SVG diagram. This will fail if run on raw layout data.  

			The run mode options are mostly useful for debugging, though they can also be used for drawing a model

			in low-memory or very large model situations. In the normal mode, the 1st pass is saved in memory before drawing. 

			Saving to disk instead could greatly reduce the run-time memory usage.	-->

	<xsl:param name="Use-as-name" select="'name'"/> <!-- The attribute to use as the item name. Falls back to 'name' -->

	  <xsl:key name="lgrp-bottom" match="layer-group" use="@from"/>

	  <xsl:key name="lgrp-top" match="layer-group" use="@to"/>

	<xsl:variable name="large-width" select="500"/> <!-- cutoff width to be considered a wide model and thus need larger title size -->

<xsl:variable name="Versions">

	<xsl:choose>

		<xsl:when test="/SystemDefinition/*/meta[@rel='version-list']">

			<xsl:copy-of select="/SystemDefinition/*/meta[@rel='version-list']"/>

		</xsl:when>

		<xsl:otherwise>

			<v>ER5</v><v>ER5U</v>

			<v>6.0</v> <v>6.1</v> <v>6.2</v>

			 <v>7.0</v> <v>7.0s</v>

			 <v>8.0</v> <v>8.0a 8.0b</v><v>8.1 8.1a 8.1b</v>

			 <v>9.0</v> <v>9.1</v> <v>9.2</v> <v>9.3</v> 

			 <v>9.4 ^1</v><v>tb91 ^2</v> <v>tb92 9.5 ^3</v> <v>tb101 9.6 ^4</v> 

			 <v>^5</v> <v>^6</v> <v>^7</v> <v>^8</v> <v>^9</v> <v>^10</v>

			 <v>Future</v>

		</xsl:otherwise>

	</xsl:choose>

</xsl:variable>

<xsl:template match="/SystemDefinition" priority="2">

	<!-- see above for Run usage -->

	<xsl:choose>

		<xsl:when test="$Run = 'calc' ">

			<!-- just do 1st pass calculations like sizing and legend generation -->

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

		</xsl:when>

		<xsl:when test="$Run = 'draw' ">

			<!-- draw from pre-calculated data -->

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

		</xsl:when>

		<xsl:otherwise> <!-- the normal case, run w/1st pass for sizing, then draw --> 

			<xsl:variable name="sysdef">

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

			</xsl:variable>

			<xsl:apply-templates select="exslt:node-set($sysdef)/SystemDefinition" mode="draw"/>

		</xsl:otherwise>		

	</xsl:choose>

</xsl:template>

<xsl:template match="SystemDefinition" mode="draw">

	<xsl:if test="@resolution"><xsl:processing-instruction name="AdobeSVGViewer">resolution="<xsl:value-of select="@resolution"/>"</xsl:processing-instruction></xsl:if>

	<!-- groupDy padding around whole thing -->

	<svg version="1.1" onload="wrapalltext()" viewBox="{-$groupDy} {-$groupDy} {@width + $groupDy} {@height  + 2* $groupDy}">

		<xsl:attribute name="class">

			<xsl:if test="not(@detail)">component</xsl:if>

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

			<xsl:if test="@detail-type">-<xsl:value-of select="@detail-type"/></xsl:if>

		</xsl:attribute>

		<xsl:copy-of select="@xml:lang"/> <!-- localized language -->

		<xsl:if test="not(@static='true') and (@navctrl or */meta/legend/@float)">

			<xsl:attribute name="onscroll">resized()</xsl:attribute>

			<xsl:attribute name="onzoom">resized()</xsl:attribute>

			<xsl:attribute name="onresize">resized()</xsl:attribute>

		</xsl:if>		

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

	<defs>

    <style type="text/css">

    text.layer, text.package, text.collection, text.component,

    text.cbox, text.lgrp, text.label, text.lgd {

		fill:black;

		font-family: <xsl:call-template name="default-font"/>;

    }

    text.title {

		fill:red;

		font-weight: bold;

		font-size: <xsl:call-template name="title-line-height"/>px;	

		font-family: <xsl:call-template name="default-font"/>;

    }    

    text.component {		

		font-size: 1.940px;  /*  5.5pt  */

		font-weight: bold;

	}

 	text.lgd, 

	text.layer, text.package {

		font-size: 4.233px;  /*  12pt  */

		font-weight: bold;

	}

	text.label {		

		font-size: 1.940px;  /*  5.5pt  */

		font-weight: bold

	}

	 text.level {

		font-style: italic;

		fill: blue;

	}

	g.layer text.level {		

		font-size: 7.055px;  /*  20pt  */

		font-style: italic;

		fill: red;

	}

	g.package text.level {		

		font-size: 4.233px;  /*  12pt  */

	}

	g.nested text.level {		

		font-size: 3.175px;  /*  8pt  */

	}

	text.cbox {		

		font-size: 1.411px;  /*  4pt  */

		font-weight: bold

	}

	text.lgrp {

		font-size: 12.699px;  /*  36pt  */

		font-weight: normal;

	}

<!-- package font sizes: larger if there is no displayed children -->

g.placeholder text.package,

svg.package text.package,

svg.package-fixed text.package {

		font-size: 11.288px;  /*  32pt  */

		font-weight: normal;

	}

<!-- subpackage font sizes -->

	g.nested text.package {

		font-size: 2.822px;  /*  8pt  */

	}

	svg.collection g.nested text.package,

	svg.collection-fixed g.nested text.package  {

		font-size: 4.233px;  /*  12pt  */

	}

	svg.package g.nested text.package,

	svg.package-fixed g.nested text.package  {

		font-size: 7.055px;  /*  20pt  */

	}

<!-- collection font sizes -->

	text.collection {

		font-size: 2.469px;  /*  7pt  */

	}

	g.placeholder text.collection,

	svg.collection text.collection,

	svg.collection-fixed text.collection  {

		font-size: 3.7035px;  /*  10.5pt  */

	} 

<!-- borders -->

	/* thin border */

	rect.legend, rect.collection, rect.cbox {

		stroke-width: 0.0882px;  /*  0.25pt  */

		stroke: black

	}

	/* thick border */

	rect.layer, rect.package  {

		stroke-width: 0.2469px;  /*  0.7pt  */

		stroke: black

	}

	rect.layer {

		fill: #e6e6e6

	}

	rect.package {

		fill: #b3b3b3

	}

	g.nested rect.package {

		fill: #e6e6e6

	}

	rect.collection {

		fill: white

	}

	rect.legend {

		fill: white

	}

	<!-- opera does not support <style media="print">, so must use @media instead -->

	 @media print {

		#Zoom {visibility: hidden}

	  }

 </style>	

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

	</defs>

<script type="text/ecmascript"> 

<!-- for creating / finding elements by namespace -->

var svgns="http://www.w3.org/2000/svg";

<xsl:call-template name="script-wrapping"/>

<xsl:call-template name="script-popups"/> <!-- dependencies use this and they override @static -->

<xsl:if test="not(@static='true')">

	<xsl:if test="@navctrl">

		<xsl:call-template name="script-navcontrol"/>

	</xsl:if>

function resized()

		{

		var viewbox = document.documentElement.getAttribute("viewBox").split(' ');

 		var x = Number(viewbox[0]);

 		var y = Number(viewbox[1]);

 		var width = Number(viewbox[2]);

 		var height = Number(viewbox[3]);

 		if( window.innerWidth==0 || window.innerHeight ==0 || height ==0) {return}

 		var s = width  / window.innerWidth;

 		if ( width / height < window.innerWidth / window.innerHeight)

 			{

			s = height  / window.innerHeight;

			width = window.innerWidth * s;

			}

		else	

			{

 			height = window.innerHeight * s;

 			}

<xsl:if test="@navctrl">

		var e = document.getElementById('Zoom');

		var trans = 'translate(';

		trans+= x - 0.5* (width - viewbox[2]) + ( -document.rootElement.currentTranslate.x ) * s  / document.rootElement.currentScale ;

		trans+=' ';

		trans+= y - 0.5* (height - viewbox[3]) + ( -document.rootElement.currentTranslate.y ) * s  / document.rootElement.currentScale ;

		trans+=') scale(';

		trans+=  (height / window.innerHeight) *3.2 / document.rootElement.currentScale;

		trans+=')';

		e.setAttribute('transform',trans);

</xsl:if>

<xsl:if test="*/meta/legend/@float">

		e = document.getElementById('legend-display');

		var ctrl = document.getElementById('legend-ctrl');

		var wBox = Number(ctrl.getAttribute('width'));

		scale = (width / window.innerWidth)  * (window.innerWidth / ( wBox+3)) / document.rootElement.currentScale;

		trans = 'translate(';

		trans+= x + (1.5 *scale )  -0.5* (width - viewbox[2]) + ( -document.rootElement.currentTranslate.x ) * s  / document.rootElement.currentScale ;

		trans+=' ';

		trans+= y -(14.3 +0.3)* scale - 0.5* (height - viewbox[3] ) + ( -document.rootElement.currentTranslate.y ) * s  / document.rootElement.currentScale 

		+ height   / document.rootElement.currentScale

		trans+=') scale(';

		trans+=  scale;

		trans+=')';

		e.setAttribute('transform',trans);</xsl:if>		

 		}

	<xsl:if test="*/meta/legend/@float">

		<xsl:call-template name="script-float-legend"/>

	</xsl:if>

</xsl:if>

</script>

	<xsl:variable name="model-bottom">

		<!-- The y-location of the bottom of the model itself -->

		<xsl:for-each select="*[1]"> <!-- should only be one child -->

			<xsl:choose>

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

					<xsl:value-of select="../@height - sum (meta[@rel='model-footer' or @rel='model-logo']/@height) "/>

				</xsl:when>

				<xsl:otherwise>

					<xsl:value-of select="../@height - sum (meta[@rel='model-footer' or @rel='model-legend']/@height) "/>

				</xsl:otherwise>

			</xsl:choose>

		</xsl:for-each>

	</xsl:variable>

	<!-- these meta go under the model -->

	<xsl:apply-templates select="*/meta[not(starts-with(@rel,'model-'))]" mode="global"/>

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

	<!-- do these meta last so that it could obscure the model if it needs to -->

	<xsl:apply-templates select="*/meta[starts-with(@rel,'model-')]" mode="global">

		<xsl:sort select="@rel"/>

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

	</xsl:apply-templates>

	<xsl:if test="not(@static='true') and @navctrl">

		<xsl:call-template name="navctrl"/>

	</xsl:if>

<!--

<rect x="0" y="0" width="{@width}" height="{@height}" fill="none" stroke="black" stroke-width="1"/>

<rect x="{@padding-left}" y="0" width="{@model-width}" height="{@model-height}" fill="none" stroke="black" stroke-width="1"/>

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

	<rect x="0" y="{../@height - @height}" width="{../@width}" height="{@height}" fill="none" stroke="green" stroke-width="1"/>

</xsl:for-each>

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

	<rect x="0" y="{$model-bottom}" width="{@width}" height="{@height}" fill="none" stroke="green" stroke-width="1"/>

</xsl:for-each>

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

	<rect x="{../@width - legend/@title-width * @scaled}" y="{$model-bottom}" width="{legend/@title-width * @scaled }" height="{legend/@title-height * @scaled}" fill="none" stroke="green" stroke-width="1"/>

</xsl:for-each>

-->

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

</svg>

</xsl:template>

<xsl:template match="systemModel">

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

</xsl:template>

<xsl:template match="*" mode="filter"/> <!-- filters for all items -->

<xsl:template match="*" mode="text-filter"/> <!-- fitler for just text -->

<!-- scripts -->

<xsl:template name="script-popups">

<!-- for pop-ups which can only appear one at a time. 

In general, one would want to use 

	onmouseover="on('blah') onmouseout="off('blah')"

for stuff which appears and disappears based on the position of the mouse (like dependency arrows)

for stuff which appears based on a mouseover or button press, but does not 

disappear until some other trigger (and only one can appear at a time), use one of:

	onmouseover="on(clear('blah'))"

	onclick="on(clear('blah'))"

-->

var curId = '';

function clear(id) {

	if(curId != '') off(curId);

	return curId=id;

}

<!--  for showing and hiding : 

	not used by default, but used by higher-detailed versions when Static is not set

	also used by post-processed versions for showing pop-up data.-->

function on(id) {

	var cur =document.getElementById(id)

	cur.setAttribute('visibility','visible');

	<xsl:if test="not(@detail='component')"><!-- this is needed to wrap text which is initially hidden -->

	if(!cur.hasAttribute('wrapenated')) {

		cur.setAttribute('wrapenated','true');

		wrapalltext(cur)

	}

	</xsl:if>

	return cur;

}

function off(id) {

	document.getElementById(id).setAttribute('visibility','hidden');

}

</xsl:template>

<xsl:template name="script-wrapping">

<!--  for wrapping: breaks text up into an array of words -->

function splitup(txt) {

	var a = new Array;

	var t = txt;

	var found		<!-- \u4e00-\ufa2 is the unicode range for kanjii, \u3041-\u309 is katakana and e\u30a1-\u30fe is hiragana-->

	while((found = t.match(/(^[\u3041-\u309e\u30a1-\u30fe\u4e00-\ufa2d])([\u3041-\u309e\u30a1-\u30fe\u4e00-\ufa2d].*)$/))|| ( found = t.match(/^([^ \u200b\xad-]+[ \u200b\xad-]+)(.*)$/))) {

			a.push(found[1]);

			t=found[2];

	}

	a.push(t);

	return a;

}

<!--  the remainder of the scripts also are for wrapping 

Note that comments are kept to an absolute minimum inline since it's a waste of 

	space in the generated file to duplicate the unused text 

-->

<![CDATA[

function splitable(node) {

 	return node.firstChild.nodeType == 3 && node.firstChild.data.match(/[\t\n\r \u200b\xad-]/);

}

function crush(node, len) {

	node.setAttribute('letter-spacing','-0.075em');

	if( node.getComputedTextLength() > len) 

		node.setAttribute('letter-spacing','-0.15em');

}

function whatSize(txt) { // convert a length into pixels

	if(txt.match(/^[0-9.-]+$/)) return txt;

	return;

}

function wrapalltext(node) {

    if(!node) node= document;

    var all = node.getElementsByTagNameNS(svgns,'text');

    var i=0;

    for (i=0; i<all.length; i++) {

		var cur = all.item(i);

		var w=0;

		if (cur.hasAttribute('width')) {

			w = whatSize(cur.getAttribute('width'));

		}

	if (w)	wraptext(cur,w)

	}

}

function wraptext(cur,l) {

	if(cur.firstChild.nodeType != 3)  return; // must be just a text node

	if(cur.getBBox().width < l )  {

		cur.firstChild.data = cur.firstChild.data.replace(/[\xad\u200b]/g,"");

		return; // no need -- won't wrap

	}

	var t = cur.firstChild.data.replace(/\s+/," ");  // normalize all spaces

	t = t.replace(/^ +/,"").replace(/ +$/,"");  // trim spaces

	var words =splitup(t); 	// each word ends with the split character (if any)

	if (words.length<2)  {

		crush(cur, l);

		return;

	}

	cur.removeChild(cur.firstChild)

	var tspan = document.createElementNS(svgns,'tspan');

	var first = tspan;	

	cur.appendChild(tspan);

	var txt = document.createTextNode(words[0]);

	tspan.appendChild(txt);

	tspan.setAttribute('x',cur.getAttribute('x'));	// Opera needs this

	var nlines=1;

	var zero =0;

	for (i =1;i< words.length;i++) {

		var was = txt.data;

		txt.data+=words[i];

		if (tspan.getComputedTextLength() -zero > l) { // if the line with this word at the end is bigger than the available space...

			txt.data=was.replace(/ +$/,"").replace(/\xad(.)/,"$1").replace(/\u200b/g,""); // remove zero-width spaces and trailing spaces and soft hyphens

			// if it's still too big then decrease the letter spacing

			if( tspan.getComputedTextLength() > l ) crush(tspan,l);

			tspan = document.createElementNS(svgns,'tspan');

			tspan.setAttribute('dy',"1em");

			nlines++;

			tspan.setAttribute('x',cur.getAttribute('x'));

			cur.appendChild(tspan);

			txt = document.createTextNode('');

			tspan.appendChild(txt);

			zero = tspan.getComputedTextLength();

			txt.data+=words[i];

		}

	}

	txt.data=txt.data.replace(/ +$/,"").replace(/\xad(.)/,"$1").replace(/\u200b/g,""); // remove zero-width spaces and trailing spaces and soft hyphens

	if( tspan.getComputedTextLength() > l ) 	crush(tspan,l);

	var align =cur.getAttribute('dy');

	if(align=='0.375em') {	// middle aligned

		first.setAttribute('dy',((1-nlines ) / 2 + 0.375 )+"em");

	}  else if(align=='0.75em' || align=='1em')  {  // top (or above) aligned

		first.setAttribute('dy',align)	

	}  else  { // bottom aligned (default)

		first.setAttribute('dy',(1-nlines)+"em");

	}

}

]]>

  <!-- 

  dominant-baseline is not widely supported, but should indicate the vertical alignment of the text

  	mathematical = middle-aligned

  	hanging = top-aligned

  	ideographic = bottom aligned

  Since they're not widely supported, using dy is used instead. 

  Ideally we'd have

	  top aligned: dy="1.5ex"

	  middle aligned: dy="0.75ex"

	  bottom aligned: dy="0ex"

	  since in most fonts the top of the captial letters is about 0.5ex higher than the 

	  	top of the lower case letters (1ex), hence 1.5ex for top-algined and half that for middle

  However, you can't add the em-based offset of multiple lines to the ex-based alignment, 

  	so we have to make the reasonably valid assumption that 1em = 2ex

  Which gives us: 

	  top aligned: dy="0.75em"

	  middle aligned: dy="0.375em"

	  bottom aligned: dy="0em"

	Since this is supported is Firefox 3.5, ASV and Opera 9, it's a much better way to handle 

		he alighment than using the dominant-baseline approach

   -->

</xsl:template>

<xsl:template name="script-navcontrol">

<!-- this should only be called on the SystemDefinition element -->

var pandandzoom=null;

function endpanning()

        {

        if(pandandzoom)

	        {

    	    window.clearInterval(pandandzoom)

        	pandandzoom=null

        	}

        }

function repeatpan(x,y)

        {

        endpanning()

        panning(x,y)

        pandandzoom = window.setInterval('panning('+x+','+y+')', 100);

        }

function panning(x,y)

        {

        document.rootElement.currentTranslate.x += x

        document.rootElement.currentTranslate.y += y

        }

function repeatzoom(z)

        {

        endpanning()

        zoom(z)

        pandandzoom = window.setInterval('zoom('+z+')', 100);

        }

<![CDATA[

function zoom(z)

		{

		var viewbox = document.documentElement.getAttribute("viewBox").split(' ');

 		var x = Number(viewbox[0]);

 		var y = Number(viewbox[1]);

 		var width = Number(viewbox[2]);

 		var height = Number(viewbox[3]);

 		if( window.innerWidth==0 || window.innerHeight ==0 || height ==0) {return}

 		var s = width  / window.innerWidth;

 		if ( width / height < window.innerWidth / window.innerHeight)

 			{

			s = height  / window.innerHeight;

			width = window.innerWidth * s;

			}

		else	

			{

 			height = window.innerHeight * s;

 			}

 		x = x - 0.5* (width - viewbox[2]) + ( -document.rootElement.currentTranslate.x ) * s  / document.rootElement.currentScale ;

		y = y - 0.5* (height - viewbox[3]) + ( -document.rootElement.currentTranslate.y ) * s  / document.rootElement.currentScale ;

		width = width / document.rootElement.currentScale;

		height = height / document.rootElement.currentScale;

        document.rootElement.currentTranslate.x=