analytics/templates/ps/logicsheets/formlogic.xslt

<?xml version="1.0" encoding="UTF-8"?>
<!--
    Licensed Materials - Property of IBM

    IBM Cognos Products: ps

    (C) Copyright IBM Corp. 2005, 2022

    US Government Users Restricted Rights - Use, duplication or disclosure restricted by GSA ADP Schedule Contract with IBM Corp.
-->

<!--
   Copyright (C) 2008 Cognos ULC, an IBM Company. All rights reserved.
   Cognos (R) is a trademark of Cognos ULC, (formerly Cognos Incorporated).
-->
<xsl:stylesheet version="1.0" xmlns:xtsext="xalan://com.cognos.xts.ext.XTSExt" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:out="dummy-uri" xmlns:utml="http://developer.cognos.com/schemas/xts/logicsheet/xslt/formlogic/">
   <xsl:output method="xml" version="1.0" encoding="UTF-8" indent="no"/>
   <xsl:namespace-alias stylesheet-prefix="out" result-prefix="xsl"/>
   <xsl:variable name="utml-namespace-uri" select="'http://developer.cognos.com/schemas/xts/logicsheet/xslt/formlogic/'"/>
   <xsl:template match="/">
      <xsl:apply-templates/>
   </xsl:template>
   <!--
		eXtensible Form Markup Logicsheet 1.0
		Upfront Template Markup Language 3.0
		Copyright (c) 1998 - 2008 Cognos Inc.
			
		utml:form
			utml:input
			utml:textbox
			utml:checkbox
			utml:radio
			utml:password
			utml:hidden
			utml:textarea
			utml:select
			utml:option
	
		attributes
			utml:name
			utml:value
			utml:default-value
			utml:update
			utml:prefix
			utml:generate-cancel-form
			
		helper functions
			utml:subst
			utml:comment
			utml:dump-state

	-->
   <!--
		utml:form
			name
			method
			target
			action
	-->
   <xsl:template match="utml:form[namespace-uri() = $utml-namespace-uri]" priority="1">
      <!-- get the form name... -->
      <out:variable name="utml-form-name">
         <xsl:call-template name="get-utml-name">
            <xsl:with-param name="node" select="."/>
         </xsl:call-template>
      </out:variable>
      <form>
         <!-- copy non-utml attributes... -->
         <xsl:copy-of select="@*[namespace-uri() != $utml-namespace-uri]"/>
         <!-- set the name... -->
         <out:attribute name="name">
            <out:value-of select="$utml-form-name"/>
         </out:attribute>
         <!-- determine if this ontrol needs to be rendered in read-only mode -->
         <out:variable name="form-read-only">
            <xsl:call-template name="get-utml-read-only">
               <xsl:with-param name="node" select="."/>
            </xsl:call-template>
         </out:variable>
         <!-- handle children... -->
         <xsl:apply-templates/>
         <!--  
				the only constraint with prefixes is that if a relative path is given in any XPath expression the value will 
				not be substituted.  we have to define variables here so that they will be generated, and referencable below
				in the generated XSLT...this is necessary b/c the prefix could contain an XPath expression inside an xslt
				element, such as:
				
					<utml:input type="input" value="xxx">
						<utml:prefix>
							<xsl:text/>prefix1<xsl:text/>
							<xsl:value-of select="/root/env/param[@name = 'zzz']"/>
						</utml:prefix>
					</utml:input>
					
				if we don't define a variable and make its contents a copy of the original contents of the utml:prefix information
				will be lost.
			 -->
         <xsl:for-each select="//utml:input[@utml:prefix or utml:prefix] | //utml:textarea[@utml:prefix or utml:prefix] | //utml:select[@utml:prefix or utml:prefix] | //utml:radio-group[@utml:prefix or utml:prefix]">
            <out:variable name="{concat( 'generated-id-', generate-id(.) )}">
               <xsl:call-template name="get-utml-prefix">
                  <xsl:with-param name="node" select="."/>
               </xsl:call-template>
            </out:variable>
         </xsl:for-each>
         <!-- 
				build up the existence test string, this will be used to determine what query-values to create hidden inputs for,
				utml:prefix's take precedence over name, when doing the comparison.  name can only be used when
				it is given as an attribute.
			-->
        <xsl:variable name="is-utml-exclusion-list" select="utml:exclusion-list"/>
		
         <xsl:variable name="existence-test-string">
           
		    <xsl:variable name="test-string">
               <xsl:for-each select="//utml:input[not(@type = 'button' or type = 'button') and not( (@type = 'radio' or type = 'radio') and ancestor::*[name() = 'utml:radio-group'] )] | //utml:textarea | //utml:select | //utml:radio-group | //utml:change">
                  <xsl:if test="position() = 1">
                     <xsl:text>not(</xsl:text>
                  </xsl:if>
                  <xsl:choose>
                     <xsl:when test="./@utml:prefix or ./utml:prefix">
                        <xsl:text/>starts-with(@name, <xsl:value-of select="concat( '$generated-id-', generate-id(.) )"/>) or <xsl:text/>
                     </xsl:when>
                     <xsl:when test="./@name">
                        <xsl:text/>( @name = '<xsl:value-of select="./@name"/>' or @name = '<xsl:value-of select="concat( 'tmp_chkbox_', ./@name )"/>' or @name = '<xsl:value-of select="concat( 'changed_', ./@name )"/>' ) or <xsl:text/>
                     </xsl:when>
                  </xsl:choose>
                  <xsl:if test="position() = last()">
		               <xsl:if test="$is-utml-exclusion-list">
		               	<xsl:text/>contains($utml-exclusion-list, concat(' ', @name, ' ')) or <xsl:text/>
		               </xsl:if>
                     <xsl:text/>starts-with(@name, 'h_CAM'))<xsl:text/>
                  </xsl:if>
               </xsl:for-each>
            </xsl:variable>
			
            <xsl:choose>
               <xsl:when test="$test-string = ''">
                  <xsl:text/>true()<xsl:text/>
               </xsl:when>
               <xsl:otherwise>
                  <xsl:value-of select="$test-string"/>
               </xsl:otherwise>
            </xsl:choose>
			
         </xsl:variable>
		 
         <!-- copy all unused query-values into the form as hidden inputs... -->
         <xsl:if test="utml:exclusion-list">
         	<out:variable name="utml-exclusion-list">
         		<out:value-of select="' '"/>
         		<xsl:copy-of select="utml:exclusion-list/child::node()"/>
         		<out:value-of select="' '"/>
         	</out:variable>
         </xsl:if>
		 
		 <!-- this will allow you to specify other fields to exclude in the automatic building of the hidden inputs -->
		<out:variable name="other-excludes">
			<xsl:for-each select="//utml:form/utml:excludes">
				<xsl:value-of select="concat(' ', normalize-space(.), ' ')"/>
			</xsl:for-each>
		</out:variable>
		  
		<!-- this will allow you to specigy a prefix to exclude hidden inputs for -->
		<out:variable name="exclude-prefix">
			<xsl:choose>
				<xsl:when test="//utml:form/utml:exclude-prefix">
					<xsl:copy-of select="//utml:form/utml:exclude-prefix"/>
				</xsl:when>
				<xsl:otherwise>
					<xsl:value-of select="'do_not_include_this_entry_'"/>
				</xsl:otherwise>	
			</xsl:choose>	
		</out:variable>		
		  
		<out:for-each select="/root/env/param[not(starts-with( @name, $exclude-prefix ))]">
			<out:if test="{$existence-test-string} and not(contains($other-excludes, concat(' ', @name, ' ')))">
             <!-- 
						TODO: if we don't add the space (&#160;) below, the carriage return and tab will be lost...I don't
						think Xalan is handling whitespace correctly when the xsl:output method is 'HTML'.  however, adding 
						the space (which will be rendered as &nbsp; by Xalan may cause some formatting head aches...

No one is quite sure why this was put into the code. We'll comment it out for now, and remove it later.
             <xsl:text/>&#10;&#09;&#160;<xsl:text/>
					-->
             <!-- the default operation (if the control was not explicitly given on the page) is "maintain" -->
					<out:choose>
						<out:when test="@name = 'ps_nav_op'">
							<input type="hidden" name="{'{@name}'}" value="'maintain'"/>
						</out:when>
						<out:otherwise>
							<input type="hidden" name="{'{@name}'}" value="{'{.}'}"/>
						</out:otherwise>
					</out:choose>
			</out:if>
		</out:for-each>
        
		<!-- UTML navigation control fields: Add those to the page if they do not exist already.  -->		
		<!-- Navigation instruction for stacked dialogs. -->
		<xsl:if test="not(//utml:input[@name = 'ps_nav_op' or name = 'ps_nav_op']) ">
			<out:if test="not( /root/env/param[@name = 'ps_nav_op'] )">
				<!--xsl:text/>&#10;&#09;&#160;<xsl:text/-->
				<input type="hidden" name="ps_nav_op" value=""/>
			</out:if>
		</xsl:if>
		<!-- Comma-delimited list of template names representing a set of stacked dialogs resulting from a "push" or a "stack-up" navigation operations. -->
		<xsl:if test="not(//utml:input[@name = 'ps_nav_stack' or name = 'ps_nav_stack']) ">
			<out:if test="not( /root/env/param[@name = 'ps_nav_stack'] )">
				<!--xsl:text/>&#10;&#09;&#160;<xsl:text/-->
				<input type="hidden" name="ps_nav_stack" value=""/>
			</out:if>
		</xsl:if>
		<!-- The name of the current template.  This is used by formlogic-init to determine where we came from to update the navigation stack. -->
		<xsl:if test="not(//utml:input[@name = 'ps_nav_source' or name = 'ps_nav_source']) ">
			<out:if test="not( /root/env/param[@name = 'ps_nav_source'] )">
				<!--xsl:text/>&#10;&#09;&#160;<xsl:text/-->
				<input type="hidden" name="ps_nav_source">
					<xsl:attribute name="value">{/root/env/param[@name = 'm']}</xsl:attribute>		
				</input>
			</out:if>
		</xsl:if>
      </form>
   </xsl:template>
   
   <xsl:template match="utml:a[namespace-uri() = $utml-namespace-uri]" priority="1">
      <!-- Temporary work-around for XSLTC bug #6819 - variable scoping problem with literal result elements -->
      <out:if test="true()">
         <!-- get the href value, it can only contain JS, but we won't check for it... ... -->
         <xsl:variable name="hide-when-read-only">
            <xsl:call-template name="get-utml-hide-when-read-only">
               <xsl:with-param name="node" select="."/>
            </xsl:call-template>
         </xsl:variable>
         <out:variable name="read-only">
            <xsl:call-template name="get-utml-read-only">
               <xsl:with-param name="node" select="."/>
            </xsl:call-template>
         </out:variable>
         <out:variable name="hide">
            <xsl:choose>
               <xsl:when test=" $hide-when-read-only = 'true' ">
               	<out:value-of select="read-only"/>
               </xsl:when>
               <xsl:otherwise>
               	<xsl:value-of select=" 'false' "/>
               </xsl:otherwise>
            </xsl:choose>
         </out:variable>
         <out:variable name="unique-id">
            <xsl:call-template name="get-utml-unique-id">
               <xsl:with-param name="node" select="."/>
            </xsl:call-template>
         </out:variable>
         <out:if test="($hide = 'false') or ($read-only = 'false' and  $form-read-only = 'false')">
	         <out:variable name="href">
	            <xsl:call-template name="get-utml-href">
	               <xsl:with-param name="node" select="."/>
	            </xsl:call-template>
	         </out:variable>
	         <!-- get the utml:target... -->
	         <out:variable name="target">
	            <xsl:call-template name="get-utml-target">
	               <xsl:with-param name="node" select="."/>
	            </xsl:call-template>
	         </out:variable>
	         <out:variable name="defaultKey">
	            <xsl:call-template name="get-utml-defaultKey">
	               <xsl:with-param name="node" select="."/>
	            </xsl:call-template>
	         </out:variable>
	         <out:variable name="defaultAct">
	            <xsl:call-template name="get-utml-defaultAct">
	               <xsl:with-param name="node" select="."/>
	            </xsl:call-template>
	         </out:variable>
	         <!-- get the utml:op value, currently it can only be plain text... -->
	         <xsl:variable name="op">
	            <xsl:choose>
	               <xsl:when test="./@utml:op = 'push' or ./@utml:op = 'stack-up'">
	                  <xsl:value-of select="'push'"/>
	               </xsl:when>
	               <xsl:when test="./@utml:op = 'pop' or ./@utml:op = 'stack-down'">
	                  <xsl:value-of select="'pop'"/>
	               </xsl:when>
	               <xsl:when test="./@utml:op = 'drop' or ./@utml:op = 'stack-down-save'">
	                  <xsl:value-of select="'drop'"/>
	               </xsl:when>
	               <xsl:when test="./@utml:op = 'submit'">
	                  <xsl:value-of select="'submit'"/>
	               </xsl:when>
	               <xsl:otherwise>
	                  <xsl:value-of select="'maintain'"/>
	               </xsl:otherwise>
	            </xsl:choose>
	         </xsl:variable>
	         <!-- get the name of the parent form, necessary for setting form variables via JS -->
	         <out:variable name="parent-form-name">
	            <xsl:choose>
	               <xsl:when test="ancestor::*[name() = 'utml:form' and namespace-uri() = $utml-namespace-uri]">
	                  <xsl:call-template name="get-utml-name">
	                     <xsl:with-param name="node" select="ancestor::*[name() = 'utml:form' and namespace-uri() = $utml-namespace-uri]"/>
	                  </xsl:call-template>
	               </xsl:when>
	               <xsl:otherwise>
	                  <xsl:choose>
	                     <xsl:when test="@utml:formName">
	                        <xsl:value-of select="@utml:formName"/>
	                     </xsl:when>
	                     <xsl:when test="utml:formName">
	                        <xsl:copy-of select="utml:formName/child::node()"/>
	                     </xsl:when>
	                     <xsl:otherwise>
	                     	<out:value-of select="$utml-form-name"/>
	                     </xsl:otherwise>
	                  </xsl:choose>
	               </xsl:otherwise>
	            </xsl:choose>
	         </out:variable>
	         <!-- determine whether we're to call a JS validate function or not. -->
	         <out:variable name="validate">
	            <xsl:call-template name="get-utml-validate">
	               <xsl:with-param name="node" select="."/>
	            </xsl:call-template>
	         </out:variable>
	 		<!-- 
				Use this to delimit template names in the navigation stack.  Use * since it is the least likely char to be used in a folder or file name. 
				This is also defined in formlogic_init.xslt 
			-->
			<out:variable name="nav-stack-delimiter" select="'*'"/>
			 <out:variable name="js-logic">			   
				<!-- propogate the navigation operation...-->
				document.<out:value-of select="$parent-form-name"/>.ps_nav_op.value = '<xsl:value-of select="$op"/>';			
				<!-- calculate the target morphlet... -->                
				<out:choose>				
					<out:when test="$target">
						document.<out:value-of select="$parent-form-name"/>.m.value = '<out:value-of select="$target"/>';
					</out:when>
					<!--  if the user gave one of the operations: stack-up, submit, or no operation, they would have been required to give a target, in which 	case we won't be here, however don't currently have
							the ability to validate(!), so we'll just use a conditional test... 	-->
					<out:otherwise>                       
						<xsl:if test="$op = 'pop' or $op = 'drop'">
							<!-- Determine the new target from the existing stack.  If the current template is A then the current stack could be somthing like 	A,B,C.  we want to extract B. -->
							<out:variable name="new-target">
								<out:choose>
									<out:when test="contains(/root/env/param[@name='ps_nav_stack'], $nav-stack-delimiter)">
										<out:value-of select="substring-before( /root/env/param[@name='ps_nav_stack'], $nav-stack-delimiter )"/>
									</out:when>					
									<out:otherwise>
										<out:value-of select="/root/env/param[@name='ps_nav_stack']"/>
									</out:otherwise>
								</out:choose>							
							</out:variable>
							document.<out:value-of select="$parent-form-name"/>.m.value = "<out:value-of select="xtsext:javascriptencode($new-target)"/>";
						</xsl:if>
					</out:otherwise>
				</out:choose>
				
				<!-- insert any user specified href info... -->
				<out:value-of select="$href"/>
				  
				<!-- form submission... -->
				<out:variable name="submit">
					<xsl:call-template name="get-utml-submit">
						<xsl:with-param name="node" select="."/>
					</xsl:call-template>
				</out:variable>
				  
				<out:if test="$submit != 'false'">
					<script language="JavaScript">
						<![CDATA[
							function needCustomHeader(formName)
							{
								var needed = false;
								var iFrmCmd = formName.ifrmcmd;
								var psNavOp = formName.ps_nav_op;
								var mClass = formName.m_class;
								var psNavSource = formName.ps_nav_source;
								var mNewClass = formName.m_new_class;
								if ( iFrmCmd != undefined && iFrmCmd.value === "create" &&
									 psNavOp != undefined && psNavOp.value === "submit" )
								{
									if ( mClass != undefined && mClass.value === "subscriptionFolder" &&
										 psNavSource != undefined && psNavSource.value.slice(-"new_general.xts".length) === "new_general.xts" ) {
										needed = true;
									}
									else if ( mNewClass != undefined && mNewClass.value === "subscriptionFolder" &&
											  psNavSource != undefined && psNavSource.value.slice(-"new_actions.xts".length) === "new_actions.xts" ) {
										needed = true;
									}
								}
								return needed;
							}
							function getFormDataQueryString(form)
							{
								var keyValuePairs = [];
								for (var i = 0; i < form.elements.length; i++)
								{
									var element = form.elements[i];
									keyValuePairs.push(encodeURIComponent(element.name) + "=" + encodeURIComponent(element.value));
								}
								return queryString = keyValuePairs.join("&");
							}
						]]>
					</script>
					<!-- XSRF-TOKEN cookie is null when disableXSRFCheck=true in bootstrap.properties. -->
					var xsrfTokenCookie = getCookie("XSRF-TOKEN");
					var formName= document.<out:value-of select="$parent-form-name"/>;
					if (xsrfTokenCookie &amp;&amp; needCustomHeader(formName))
					{
						<!-- 
							CAPSIRTS-412 / MANAGECA-9957
							
							Case A:
							1. Go to "Personal menu" > "My Watch Items" and "Rules".
							2. Click "New Folder", enter a name, etc., and click "Finish".
							
							ifrmcmd=create
							ps_nav_op=submit
							m_class=subscriptionFolder
							ps_nav_source=portal/new_general.xts
							
							Case B
							1. Go to "Personal menu" > "My Watch Items" and "Rules".
							2. Click "New Folder" and click "Select another location...".
							3. Click "New Folder...", enter a name, etc., and click "Finish".
							...
							
							ifrmcmd=create
							ps_nav_op=submit
							m_new_class=subscriptionFolder
							ps_nav_source=portal/select/new_actions.xts
						-->
						var xhr = new XMLHttpRequest();
						xhr.onreadystatechange = function()
						{
							if (xhr.readyState === 4)
							{
								document.write(xhr.responseText);
								document.close();
							}
						}
						xhr.open(formName.method, formName.action, false);
						xhr.setRequestHeader("Content-Type", "application/x-www-form-urlencoded");
						xhr.setRequestHeader("X-XSRF-TOKEN", xsrfTokenCookie);
						xhr.send(getFormDataQueryString(formName));
					}
					else
					{
						formName.submit();
					}
				</out:if>
			</out:variable>
			
			<!-- Generate a unique id to use for calling a function. Use the unique-id the caller passed it in if it exists. We need this so that we do not have name collisions when more than one <utml:a> exist 	on a page. -->
			<out:variable name="node_id">
				<out:choose>
					<out:when test="$unique-id!=''"><out:value-of select="$unique-id"/></out:when>
					<out:otherwise><xsl:value-of select="generate-id(.)"/></out:otherwise>
				</out:choose>								
			</out:variable>

			<!-- Output the JS snippet for the anchor -->
			<script language="JavaScript">
				<out:if test="$defaultKey = 'active'">
					function enterdfaultact()
					{
					    var currentFocusEl = document.activeElement;
					    if (currentFocusEl.tagName.toLowerCase() =='a' || currentFocusEl.getAttribute("role") == 'button' || currentFocusEl.getAttribute("role") == 'link'){
  			             return true;
  			            }   
						<out:if test="$defaultAct!=''">
							<out:value-of select="$defaultAct"/>
						</out:if>
						utmlA_<out:value-of select="$node_id"/>();
						return false;
					}
				</out:if>
				function utmlA_<out:value-of select="$node_id"/>()
				{			
		   			<out:choose>
						<!--out:when test="$validate = 'true'" -->
							<!-- If the morphlet writer provided a validate() function on the page then make sure to call it before execution. -->
							<!-- if (window.validate)
							{
								if (validate())
								{
									<out:value-of select="$js-logic"/>
								}
							} -->
							<!-- If the morphlet writer did NOT provide a validate() function then politely execute the command (may be this is bad!!) -->
							<!-- else
							{
								<out:value-of select="$js-logic"/>
							}
						</out:when -->
						<out:when test="$validate != '' and $validate != 'false' ">
							<out:variable name="validateName">
								<out:choose>
									<out:when test="$validate='true'"><out:value-of select="'validate'"/></out:when>
									<out:otherwise><out:value-of select="$validate"/></out:otherwise>
								</out:choose>
							</out:variable>
							<!-- If the morphlet writer provided a validate() function on the page then make sure to call it before execution. -->
							if (window.<out:value-of select="$validateName"/>)
							{
								if (<out:value-of select="$validateName"/>())
								{
									<out:value-of select="$js-logic"/>
								}
							}
							<!-- If the morphlet writer did NOT provide a validate() function then politely execute the command (may be this is bad!!) -->
							else
							{
								<out:value-of select="$js-logic"/>
							}
						</out:when>
						<out:otherwise>
							<out:value-of select="$js-logic"/>
						</out:otherwise>
					</out:choose>  
				}  
			</script>   
			<!-- Output the HTML anchor -->
			<a>
			   	<xsl:if test="count(ancestor::*[@role='tablist'])">
	                    <xsl:attribute name="role">tab</xsl:attribute>
	                    <xsl:attribute name="aria-selected"><out:value-of select="$isTabSelected"/></xsl:attribute>
	            </xsl:if>
			   
			    <!-- copy all non-utml attributes... -->
				<xsl:copy-of select="@*[namespace-uri() != $utml-namespace-uri]"/>
				<out:attribute name="href">javascript:utmlA_<out:value-of select="$node_id"/>()</out:attribute>
				<!-- copy all non-utml child elements... -->
				<xsl:apply-templates/>
			</a>
           </out:if>
      </out:if>
   </xsl:template>
   
   
   <xsl:template match="utml:static[namespace-uri() = $utml-namespace-uri]" priority="1">
      <!-- calculate the control name, this includes all dynamically generated name information... -->
      <out:variable name="control-name">
         <xsl:call-template name="get-utml-prefix">
            <xsl:with-param name="node" select="."/>
         </xsl:call-template>
         <xsl:call-template name="get-utml-name">
            <xsl:with-param name="node" select="."/>
         </xsl:call-template>
      </out:variable>
      <!-- get the value ... -->
      <out:variable name="value">
         <xsl:call-template name="get-utml-value">
            <xsl:with-param name="node" select="."/>
         </xsl:call-template>
      </out:variable>
      <!-- get the update flag, this can only be text... -->
      <xsl:variable name="update">
         <xsl:call-template name="get-utml-update">
            <xsl:with-param name="node" select="."/>
         </xsl:call-template>
      </xsl:variable>
      <!-- update the control value, either from the query value, or the default... -->
      <xsl:choose>
         <xsl:when test="$update = 'false'">
            <out:value-of select="$value"/>
         </xsl:when>
         <xsl:otherwise>
            <out:choose>
               <out:when test="/root/env/param[@name = $control-name]">
                  <!-- TEMPORARY HACK TO DEAL WITH CM ENCODING ISSUES FOR 0.1 RELEASE. -->
                  <xsl:choose>
                     <xsl:when test="@cmdecode = 'true'">
                        <out:value-of select="/root/env/param[@name = $control-name]"/>
                     </xsl:when>
                     <xsl:otherwise>
                        <out:value-of select="/root/env/param[@name = $control-name]"/>
                     </xsl:otherwise>
                  </xsl:choose>
               </out:when>
               <out:otherwise>
                  <out:value-of select="$value"/>
               </out:otherwise>
            </out:choose>
         </xsl:otherwise>
      </xsl:choose>
   </xsl:template>
   
   
	<!-- ============================================================ -->
	<!-- ==	Text Lite - only keeps track of the variable no extras == -->
	<!-- ============================================================ -->	
	<xsl:template match="utml:input[(@type = 'text-lite')]" priority="1">
		<input type="text">
			<xsl:copy-of select="@*[(local-name() != 'type') and (local-name() != 'value')]"/>
			<out:attribute name="value">
				<out:choose>
					<out:when test="/root/env/param[@name = '{@name}']">
						<out:value-of select="/root/env/param[@name = '{@name}']"/>
					</out:when>
					<out:otherwise>
						<xsl:copy-of select="utml:value/child::node()"/>
					</out:otherwise>
				</out:choose>
			</out:attribute>
		</input>
   </xsl:template>
   

   <!-- =====================================================================  -->
   <!-- ==============						Text - Password - Hidden				=================== -->
   <xsl:template match="utml:input[((@type = 'text' or type = 'text') or (@type = 'password' or type = 'password') or (@type = 'hidden' or type = 'hidden')) and (namespace-uri() = $utml-namespace-uri)]" priority="1">
      <out:if test="true()">
         <!-- add this here to define unique context for the variables below -->
         <!-- determine if this ontrol needs to be rendered in read-only mode -->
         <out:variable name="read-only">
            <xsl:call-template name="get-utml-read-only">
               <xsl:with-param name="node" select="."/>
            </xsl:call-template>
         </out:variable>
         <!-- calculate the control name, this includes all dynamically generated name information... -->
         <out:variable name="control-name">
            <xsl:call-template name="get-utml-prefix">
               <xsl:with-param name="node" select="."/>
            </xsl:call-template>
            <xsl:call-template name="get-utml-name">
               <xsl:with-param name="node" select="."/>
            </xsl:call-template>
         </out:variable>
         <!-- get the value ... -->
         <out:variable name="value">
            <xsl:call-template name="get-utml-value">
               <xsl:with-param name="node" select="."/>
            </xsl:call-template>
         </out:variable>
         <!-- get the update flag, this can only be text... -->
         <xsl:variable name="update">
            <xsl:call-template name="get-utml-update">
               <xsl:with-param name="node" select="."/>
            </xsl:call-template>
         </xsl:variable>
         <!-- get the type... -->
         <out:variable name="type">
            <xsl:call-template name="get-utml-type">
               <xsl:with-param name="node" select="."/>
            </xsl:call-template>
         </out:variable>
         <!-- get the state of the tracking feature... -->
         <xsl:variable name="track-changes">
            <xsl:call-template name="get-utml-track">
               <xsl:with-param name="node" select="."/>
            </xsl:call-template>
         </xsl:variable>
         <out:choose>
            <out:when test="($read-only = 'true' or  $form-read-only = 'true') and (not($type = 'hidden'))">
               <out:value-of select = "xtsext:enforceBTD($value, $baseTextDirection, $productLocale, boolean($isBidiEnabled='true'))"/>
            </out:when>
            <out:otherwise>
               <xsl:if test="$track-changes = 'true'">
                  <script language="JavaScript">
			      function on_<out:value-of select="$control-name"/>_changed() {
			         document.<out:value-of select="$utml-form-name"/>.changed_<out:value-of select="$control-name"/>.value=&quot;1&quot;;
			      }			      
			      </script>
                  <out:variable name="hidden-control-name">
                     <out:value-of select="concat( 'changed_', $control-name )"/>
                  </out:variable>
                  <input type="hidden">
                     <out:attribute name="name">
                        <out:value-of select="$hidden-control-name"/>
                     </out:attribute>
                     <out:choose>
                        <out:when test="/root/env/param[@name = $hidden-control-name]">
                           <out:attribute name="value">
                              <out:value-of select="/root/env/param[@name = $hidden-control-name]"/>
                           </out:attribute>
                        </out:when>
                        <out:otherwise>
                           <out:attribute name="value">0</out:attribute>
                        </out:otherwise>
                     </out:choose>
                  </input>
               </xsl:if>
               <input>
                  <!-- copy all non-utml attributes... -->
                  <xsl:copy-of select="@*[namespace-uri() != $utml-namespace-uri]"/>
                  <!-- add the name attribute... -->
                  <out:attribute name="name">
                     <out:value-of select="$control-name"/>
                  </out:attribute>
                  <!-- add the type... -->
                  <out:attribute name="type">
                     <xsl:call-template name="get-utml-type">
                        <xsl:with-param name="node" select="."/>
                     </xsl:call-template>
                  </out:attribute>
                  <!-- add the onchange attribute... -->
                  <xsl:if test="$track-changes = 'true'">
                     <out:attribute name="onchange">
                        <out:text/>if(window.on_<out:value-of select="$control-name"/>_changed)window.on_<out:value-of select="$control-name"/>_changed();<out:text/>
                        <xsl:if test="@onchange">
                           <out:text/>
                           <xsl:value-of select="@onchange"/>
                           <out:text/>
                        </xsl:if>
                     </out:attribute>
                  </xsl:if>
                  <!-- update the control value, either from the query value, or the default... -->
                  <!-- bidi -->
                  <out:variable name="updatedValue">
                     <xsl:choose>
                        <xsl:when test="$update = 'false'"><out:value-of select="$value"/></xsl:when>
                           <xsl:otherwise>
                              <out:choose>
                                 <out:when test="/root/env/param[@name = $control-name]">
                                    <out:value-of select="/root/env/param[@name = $control-name]"/>
                                 </out:when>
                                 <out:otherwise><out:value-of select="$value"/></out:otherwise>
                              </out:choose>
                           </xsl:otherwise>
                     </xsl:choose>
                  </out:variable>
                  <out:attribute name="value">
                     <out:value-of select="$updatedValue"/>
                  </out:attribute>                  
                  <out:variable name="textDirection">
                     <out:choose>
                        <out:when test="$isBidiEnabled != 'true'"></out:when>
                           <out:otherwise>
                              <xsl:choose>
                                 <xsl:when test="@dir"></xsl:when>      	 
                                 <xsl:when test="@stttype">stt</xsl:when>
                                 <xsl:otherwise>
                                    <out:value-of select="xtsext:getBTD(string($updatedValue), $baseTextDirection, $productLocale)"/>
                                 </xsl:otherwise>
                              </xsl:choose>
                           </out:otherwise>
                     </out:choose>
                  </out:variable>         		   
                  <out:if test="$type = 'text' and $textDirection != ''">
                     <out:choose>
                        <out:when test="$textDirection = 'stt'">
                           <out:attribute name="dir">ltr</out:attribute>
                        </out:when>
                        <out:otherwise>
                           <out:attribute name="dir">
                              <out:value-of select="$textDirection"/>
                           </out:attribute>
                        </out:otherwise>
                     </out:choose>
                     <out:if test="$textDirection = 'stt' or $baseTextDirection = 'auto'">
                        <xsl:choose>
                           <xsl:when test="@onfocus">
                              <out:attribute name="onfocus">
                                 <xsl:value-of select="concat('bidi.onfocus(this);',@onfocus)"/> 
                              </out:attribute>
                           </xsl:when>
                           <xsl:otherwise>
                              <out:attribute name="onfocus">
                                 <out:text>bidi.onfocus(this)</out:text>
                              </out:attribute>
                           </xsl:otherwise>
                        </xsl:choose>
                     </out:if>                     
                  </out:if>                  
                  <!-- handle children... -->
                  <xsl:apply-templates/>
               </input>
            </out:otherwise>
         </out:choose>
      </out:if>
   </xsl:template>

   
   <!-- ====================================================================  -->
   <!-- ==============									Checkbox						=================== -->
   <xsl:template match="utml:input[(@type = 'checkbox' or type = 'checkbox') and (namespace-uri() = $utml-namespace-uri)]" priority="1">
      <out:if test="true()">
         <!-- add this here to define unique context for the variables below -->
         <!-- calculate the control name, this includes all dynamically generated name information... -->
         <out:variable name="control-name">
            <xsl:call-template name="get-utml-prefix">
               <xsl:with-param name="node" select="."/>
            </xsl:call-template>
            <xsl:call-template name="get-utml-name">
               <xsl:with-param name="node" select="."/>
            </xsl:call-template>
         </out:variable>
         <!-- determine if this ontrol needs to be rendered in read-only mode -->
         <out:variable name="read-only">
            <xsl:call-template name="get-utml-read-only">
               <xsl:with-param name="node" select="."/>
            </xsl:call-template>
         </out:variable>
         <!-- get the value ... -->
         <out:variable name="value">
            <xsl:call-template name="get-utml-value">
               <xsl:with-param name="node" select="."/>
            </xsl:call-template>
         </out:variable>
         <!-- get the update flag, this can only be text... -->
         <xsl:variable name="update">
            <xsl:call-template name="get-utml-update">
               <xsl:with-param name="node" select="."/>
            </xsl:call-template>
         </xsl:variable>
         <!-- get the default condition that will be evaluated when the queryvalue isn't present... -->
         <xsl:variable name="default-condition">
            <xsl:call-template name="get-utml-default-condition">
               <xsl:with-param name="node" select="."/>
            </xsl:call-template>
         </xsl:variable>
         <!-- get the state of the tracking feature... -->
         <xsl:variable name="track-changes">
            <xsl:call-template name="get-utml-track">
               <xsl:with-param name="node" select="."/>
            </xsl:call-template>
         </xsl:variable>
         <!-- get the state of the unchecked value feature -->
         <xsl:variable name="unchecked-value">
            <xsl:call-template name="get-utml-unchecked-value">
               <xsl:with-param name="node" select="."/>
            </xsl:call-template>
         </xsl:variable>
         <!-- get the default condition that will be evaluated when the queryvalue isn't present... -->
         <out:variable name="checked">
            <xsl:call-template name="get-checked-state">
               <xsl:with-param name="node" select="."/>
            </xsl:call-template>
         </out:variable>
         <out:choose>
            <out:when test="$read-only = 'true' or $form-read-only = 'true'">
               <img role="checkbox" aria-disabled="true">
                  <xsl:copy-of select="@id"/>
                  <out:choose>
                     <out:when test="/root/env/param[@name = $control-name] = $value or $checked = 'true'">
                        <out:attribute name="src"><out:value-of select="$image_root"/>icon_disabled_checkbox_checked.gif</out:attribute>
                        <out:attribute name="aria-checked">true</out:attribute>
                     </out:when>
                     <xsl:if test="$default-condition != ''">
                        <out:when>
                           <xsl:attribute name="test"><xsl:value-of select="$default-condition"/></xsl:attribute>
                           <out:attribute name="src"><out:value-of select="$image_root"/>icon_disabled_checkbox_checked.gif</out:attribute>
                           <out:attribute name="aria-checked">true</out:attribute>
                        </out:when>
                     </xsl:if>
                     <out:otherwise>
                        <out:attribute name="src"><out:value-of select="$image_root"/>icon_disabled_checkbox_unchecked.gif</out:attribute>
                        <out:attribute name="aria-checked">false</out:attribute>
                     </out:otherwise>
                  </out:choose>
               </img>
            </out:when>
            <out:otherwise>
               <xsl:if test="$track-changes = 'true'">
                  <script language="JavaScript">
			      function on_<out:value-of select="$control-name"/>_changed() {
			         document.<out:value-of select="$utml-form-name"/>.changed_<out:value-of select="$control-name"/>.value=&quot;1&quot;;
			      }			      
			      </script>
                  <out:variable name="hidden-control-name">
                     <out:value-of select="concat( 'changed_', $control-name )"/>
                  </out:variable>
                  <input type="hidden">
                     <out:attribute name="name">
                        <out:value-of select="$hidden-control-name"/>
                     </out:attribute>
                     <out:choose>
                        <out:when test="/root/env/param[@name = $hidden-control-name]">
                           <out:attribute name="value">
                              <out:value-of select="/root/env/param[@name = $hidden-control-name]"/>
                           </out:attribute>
                        </out:when>
                        <out:otherwise>
                           <out:attribute name="value">0</out:attribute>
                        </out:otherwise>
                     </out:choose>
                  </input>
               </xsl:if>
               <xsl:if test="$unchecked-value != ''">
                  <input type="hidden">
					  <!-- add the name attribute... -->
					  <out:attribute name="name">
						 <out:value-of select="$control-name"/>
					  </out:attribute>                  
					  
					  <!-- update the control value, either from the query value, or the default... -->
					  <xsl:choose>
						  <xsl:when test="$update != 'false'">
							 <out:choose>
								<!-- take the value from the env -->
								<out:when test="/root/env/param[@name = $control-name]">
								   <out:attribute name="value"><out:value-of select="/root/env/param[@name = $control-name]"/></out:attribute>
								</out:when>
								<xsl:if test="$default-condition != ''">
									<!-- if the default condition is met, then the checkbox is checked -->
								   <out:when>
									  <xsl:attribute name="test"><xsl:value-of select="$default-condition"/></xsl:attribute>
									  <out:attribute name="value"><out:value-of select="$value"/></out:attribute>
								   </out:when>
								</xsl:if>								
								<out:otherwise>
									<out:attribute name="value"><xsl:value-of select="$unchecked-value"/></out:attribute>
								</out:otherwise>
							 </out:choose>						  
						  </xsl:when>
						  <xsl:otherwise>
							  <out:attribute name="value"><out:value-of select="$value"/></out:attribute>
						  </xsl:otherwise>
					  </xsl:choose>					  	  
                  </input>				   
               </xsl:if>
               <input>
                  <!-- copy all non-utml attributes... -->
                  <xsl:copy-of select="@*[namespace-uri() != $utml-namespace-uri]"/>
                  <!-- add the type... -->
                  <out:attribute name="type">
                     <xsl:call-template name="get-utml-type">
                        <xsl:with-param name="node" select="."/>
                     </xsl:call-template>
                  </out:attribute>
                  <!-- add the name attribute... -->
                  <out:attribute name="name">
					  <xsl:if test="$unchecked-value != ''">tmp_chkbox_</xsl:if>
					  <out:value-of select="$control-name"/>
                  </out:attribute>
                  <!-- add the value attribute... -->
                  <out:attribute name="value">
                     <out:value-of select="$value"/>
                  </out:attribute>
                  <!-- update the control value, either from the query value, or the default... -->
                  <xsl:if test="$update != 'false'">
                     <out:choose>
                        <out:when test="/root/env/param[@name = $control-name] = $value">
                           <out:attribute name="checked">checked</out:attribute>
                        </out:when>
                        <xsl:if test="$default-condition != ''">
                           <out:when>
                              <xsl:attribute name="test"><xsl:value-of select="$default-condition"/></xsl:attribute>
                              <out:attribute name="checked">checked</out:attribute>
                           </out:when>
                        </xsl:if>
                     </out:choose>
                  </xsl:if>
                  <!-- add the onchange attribute... -->
                  <xsl:if test="$track-changes = 'true' or $unchecked-value != ''">
                     <out:attribute name="onclick">
                        <xsl:if test="$track-changes = 'true'">
							<out:text/>if(window.on_<out:value-of select="$control-name"/>_changed)window.on_<out:value-of select="$control-name"/>_changed();<out:text/>
                        </xsl:if>
                        <xsl:if test="$unchecked-value != ''">
							<out:text/>if (this.checked) { document.<out:value-of select="$utml-form-name"/>.<out:value-of select="$control-name"/>.value = '<out:value-of select="xtsext:javascriptencode(string($value))"/>'; } <out:text/>
							<out:text/>else { document.<out:value-of select="$utml-form-name"/>.<out:value-of select="$control-name"/>.value = '<xsl:value-of select="xtsext:javascriptencode(string($unchecked-value))"/>'; } <out:text/>
                        </xsl:if>
                        <xsl:if test="@onclick">
                           <out:text/>
                           <xsl:value-of select="@onclick"/>
                           <out:text/>
                          </xsl:if>
                     </out:attribute>
                  </xsl:if>
                  <!-- handle children... -->
                  <xsl:apply-templates/>
               </input>
            </out:otherwise>
         </out:choose>
      </out:if>
   </xsl:template>
   
   
   <!-- =====================================================================  -->
   <!-- ==============									Textarea							=================== -->
   <xsl:template match="utml:textarea[namespace-uri() = $utml-namespace-uri]" priority="1">
      <out:if test="true()">
         <!-- add this here to define unique context for the variables below -->
         <!-- determine if this ontrol needs to be rendered in read-only mode -->
         <out:variable name="read-only">
            <xsl:call-template name="get-utml-read-only">
               <xsl:with-param name="node" select="."/>
            </xsl:call-template>
         </out:variable>
         <!-- calculate the control name, this includes all dynamically generated name information... -->
         <out:variable name="control-name">
            <xsl:call-template name="get-utml-prefix">
               <xsl:with-param name="node" select="."/>
            </xsl:call-template>
            <xsl:call-template name="get-utml-name">
               <xsl:with-param name="node" select="."/>
            </xsl:call-template>
         </out:variable>
         <!-- get the value ... -->
         <out:variable name="value">
            <xsl:call-template name="get-utml-value">
               <xsl:with-param name="node" select="."/>
            </xsl:call-template>
         </out:variable>
         <!-- get the update flag, this can only be text... -->
         <xsl:variable name="update">
            <xsl:call-template name="get-utml-update">
               <xsl:with-param name="node" select="."/>
            </xsl:call-template>
         </xsl:variable>
         <!-- get the state of the tracking feature... -->
         <xsl:variable name="track-changes">
            <xsl:call-template name="get-utml-track">
               <xsl:with-param name="node" select="."/>
            </xsl:call-template>
         </xsl:variable>
         <out:choose>
            <out:when test="$read-only = 'true' or  $form-read-only = 'true'">
               <out:value-of select = "xtsext:enforceBTD($value, $baseTextDirection, $productLocale, boolean($isBidiEnabled='true'))"/>
            </out:when>
            <out:otherwise>
               <xsl:if test="$track-changes = 'true'">
                  <script language="JavaScript">
			      function on_<out:value-of select="$control-name"/>_changed(){
			         document.<out:value-of select="$utml-form-name"/>.changed_<out:value-of select="$control-name"/>.value=&quot;1&quot;;
			      }
			      </script>
                  <out:variable name="hidden-control-name">
                     <out:value-of select="concat( 'changed_', $control-name )"/>
                  </out:variable>
                  <input type="hidden">
                     <out:attribute name="name">
                        <out:value-of select="$hidden-control-name"/>
                     </out:attribute>
                     <out:choose>
                        <out:when test="/root/env/param[@name = $hidden-control-name]">
                           <out:attribute name="value">
                              <out:value-of select="/root/env/param[@name = $hidden-control-name]"/>
                           </out:attribute>
                        </out:when>
                        <out:otherwise>
                           <out:attribute name="value">0</out:attribute>
                        </out:otherwise>
                     </out:choose>
                  </input>
               </xsl:if>
               <textarea>
                  <!-- copy all non-utml attributes... -->
                  <xsl:copy-of select="@*[namespace-uri() != $utml-namespace-uri]"/>
                  <!-- add the type... -->
                  <out:attribute name="type">
                     <xsl:call-template name="get-utml-type">
                        <xsl:with-param name="node" select="."/>
                     </xsl:call-template>
                  </out:attribute>
                  <!-- add the name attribute... -->
                  <out:attribute name="name">
                     <out:value-of select="$control-name"/>
                  </out:attribute>
                  <!-- add the onchange attribute... -->
                  <xsl:if test="$track-changes = 'true'">
                     <out:attribute name="onchange">
                        <out:text/>if(window.on_<out:value-of select="$control-name"/>_changed)window.on_<out:value-of select="$control-name"/>_changed();<out:text/>
                        <xsl:if test="@onchange">
                           <out:text/>
                           <xsl:value-of select="@onchange"/>
                           <out:text/>
                        </xsl:if>
                     </out:attribute>
                  </xsl:if>
                  <!-- bidi -->
                  <out:variable name="updatedValue">
                     <xsl:choose>
                        <xsl:when test="$update = 'false'"><out:value-of select="$value"/></xsl:when>
                        <xsl:otherwise>
                           <out:choose>
                              <out:when test="/root/env/param[@name = $control-name]">
                                 <out:value-of select="/root/env/param[@name = $control-name]"/>
                              </out:when>
                              <out:otherwise><out:value-of select="$value"/></out:otherwise>
                           </out:choose>
                        </xsl:otherwise>
                     </xsl:choose>
                  </out:variable>
                 <out:variable name="textDirection">
                     <out:choose>
                        <out:when test="$isBidiEnabled != 'true'"></out:when>
                        <out:otherwise>
                           <xsl:choose>
                              <xsl:when test="@dir"></xsl:when>      	 
                              <xsl:when test="@stttype">stt</xsl:when>
                              <xsl:otherwise>
                                 <out:value-of select="xtsext:getBTD(string($updatedValue), $baseTextDirection, $productLocale)"/>
                              </xsl:otherwise>
                           </xsl:choose>
                        </out:otherwise>
                     </out:choose>
                  </out:variable>         		   
                  <out:if test="$textDirection != ''">
                     <out:choose>
                        <out:when test="$textDirection = 'stt'">
                           <out:attribute name="dir">ltr</out:attribute>
                        </out:when>
                        <out:otherwise>
                           <out:attribute name="dir">
                              <out:value-of select="$textDirection"/>
                           </out:attribute>
                        </out:otherwise>
                     </out:choose>
                     <out:if test="$textDirection = 'stt' or $baseTextDirection = 'auto'">
                        <xsl:choose>
                           <xsl:when test="@onfocus">
                              <out:attribute name="onfocus">
                                 <xsl:value-of select="concat('bidi.onfocus(this);',@onfocus)"/> 
                              </out:attribute>
                           </xsl:when>
                           <xsl:otherwise>
                              <out:attribute name="onfocus">
                                 <out:text>bidi.onfocus(this)</out:text>
                              </out:attribute>
                           </xsl:otherwise>
                        </xsl:choose>
                     </out:if>                                          
                  </out:if>                                    
                  <!-- handle children... -->
                  <xsl:apply-templates/>
                  <!-- update the control value, either from the query value, or the default... -->
                  <out:value-of select="$updatedValue"/>
               </textarea>
            </out:otherwise>
         </out:choose>
      </out:if>
   </xsl:template>
   
   
   <!-- =====================================================================  -->
   <!-- ==============									Select								=================== -->
   <xsl:template match="utml:select[namespace-uri() = $utml-namespace-uri]" priority="1">
      <out:if test="true()">
         <!-- add this here to define unique context for the variables below -->
         <!-- determine if this ontrol needs to be rendered in read-only mode -->
         <out:variable name="read-only">
            <xsl:call-template name="get-utml-read-only">
               <xsl:with-param name="node" select="."/>
            </xsl:call-template>
         </out:variable>
         <!--  create variables for each default value in the comma delimited list... -->
         <!-- 
			TODO: ADD SUPPORT FOR SUBSTITUTION VARIABLES THAT CONTAIN A COMMA
			DELIMITED LIST, AND LISTS OF COMMA DELIMITED SUBSTITUTION VARIABLES/PLAIN 
			TEXT ???
		-->
         <out:variable name="default-value">
            <xsl:call-template name="get-utml-default-value">
               <xsl:with-param name="node" select="."/>
            </xsl:call-template>
         </out:variable>
         <!-- calculate the control name, this includes all dynamically generated name information... -->
         <out:variable name="control-name">
            <xsl:call-template name="get-utml-prefix">
               <xsl:with-param name="node" select="."/>
            </xsl:call-template>
            <xsl:call-template name="get-utml-name">
               <xsl:with-param name="node" select="."/>
            </xsl:call-template>
         </out:variable>
         <!-- get the state of the tracking feature... -->
         <xsl:variable name="track-changes">
            <xsl:call-template name="get-utml-track">
               <xsl:with-param name="node" select="."/>
            </xsl:call-template>
         </xsl:variable>
         <out:choose>
            <out:when test="$read-only = 'true' or  $form-read-only = 'true'">
				<xsl:apply-templates/>
            </out:when>
            <out:otherwise>
               <xsl:if test="$track-changes = 'true'">
                  <script language="JavaScript">
			      function on_<out:value-of select="$control-name"/>_changed(){
			         document.<out:value-of select="$utml-form-name"/>.changed_<out:value-of select="$control-name"/>.value=&quot;1&quot;;
			      }
			      </script>
                   <out:variable name="hidden-control-name">
                      <out:value-of select="concat( 'changed_', $control-name )"/>
                   </out:variable>
                  <input type="hidden">
                     <out:attribute name="name">
                        <out:value-of select="$hidden-control-name"/>
                     </out:attribute>
                     <out:choose>
                        <out:when test="/root/env/param[@name = $hidden-control-name]">
                           <out:attribute name="value">
                              <out:value-of select="/root/env/param[@name = $hidden-control-name]"/>
                           </out:attribute>
                        </out:when>
                        <out:otherwise>
                           <out:attribute name="value">0</out:attribute>
                        </out:otherwise>
                     </out:choose>
                  </input>
               </xsl:if>
               <select>
                  <!-- copy all non-utml attributes... -->
                  <xsl:copy-of select="@*[namespace-uri() != $utml-namespace-uri]"/>
                  <!-- add the name attribute... -->
                  <out:attribute name="name">
                     <out:value-of select="$control-name"/>
                  </out:attribute>
                  <xsl:if test="$track-changes = 'true'">
                     <out:attribute name="onchange">
                        <out:text/>if(window.on_<out:value-of select="$control-name"/>_changed)window.on_<out:value-of select="$control-name"/>_changed();<out:text/>
                        <xsl:if test="@onchange">
                           <out:text/>
                           <xsl:value-of select="@onchange"/>
                           <out:text/>
                        </xsl:if>
                      </out:attribute>
                  </xsl:if>
                  <xsl:apply-templates/>
               </select>
            </out:otherwise>
         </out:choose>
      </out:if>
   </xsl:template>
   
   
   <!-- =====================================================================  -->
   <!-- ==============									Option								=================== -->
   <xsl:template match="utml:option[namespace-uri() = $utml-namespace-uri]" priority="1">
      <out:if test="true()">
         <!-- get the value ... -->
         <out:variable name="value">
            <xsl:call-template name="get-utml-value">
               <xsl:with-param name="node" select="."/>
            </xsl:call-template>
         </out:variable>
         <!-- get the update flag, this can only be text... -->
         <xsl:variable name="update">
            <xsl:call-template name="get-utml-update">
               <xsl:with-param name="node" select="ancestor::*[name() = 'utml:select' and namespace-uri() = $utml-namespace-uri]"/>
            </xsl:call-template>
         </xsl:variable>
         <out:choose>
            <out:when test="$read-only = 'true' or  $form-read-only = 'true'">
	            <xsl:choose>
	               <xsl:when test="$update != 'false'">
	                  <out:choose>
	                     <out:when test="string(/root/env/param[@name = $control-name]) = $value">
						<xsl:apply-templates/>	                     	
	                     </out:when>
	                     <out:when test="not(/root/env/param[@name = $control-name])">
	                        <out:if test="$value = $default-value">
	                        		<xsl:apply-templates/>	                     	
	                        </out:if>
	                     </out:when>
	                  </out:choose>
	               </xsl:when>
	               <xsl:otherwise>
	                  <out:if test="$value  = $default-value">
						<xsl:apply-templates/>	                     		                  
	                  </out:if>
	               </xsl:otherwise>
	            </xsl:choose>
            </out:when>
            <out:otherwise>
		         <option>
		            <out:attribute name="value">
		               <out:value-of select="$value"/>
		            </out:attribute>
		            <!-- update the control value from the query value... -->
		            <xsl:choose>
		               <xsl:when test="$update != 'false'">
		                  <out:choose>
		                     <out:when test="/root/env/param[@name = $control-name] = string($value)">
		                        <out:attribute name="selected">selected</out:attribute>
		                     </out:when>
		                     <out:when test="not(/root/env/param[@name = $control-name])">
		                        <out:if test="string($value) = string($default-value)">
		                           <out:attribute name="selected">selected</out:attribute>
		                        </out:if>
		                     </out:when>
		                  </out:choose>
		               </xsl:when>
		               <xsl:otherwise>
		                  <out:if test="string($value) = string($default-value)">
		                     <out:attribute name="selected">selected</out:attribute>
		                  </out:if>
		               </xsl:otherwise>
		            </xsl:choose>
		            <!-- handle children... -->
		            <xsl:apply-templates/>
		         </option>
			</out:otherwise>
		</out:choose>		 
      </out:if>
   </xsl:template>
   
   
   <!-- =====================================================================  -->
   <!-- ==============									Radio								=================== -->
   <xsl:template match="utml:input[(@type = 'radio' or type = 'radio') and (namespace-uri() = $utml-namespace-uri)]" priority="1">
      <out:if test="true()">
         <!-- add this here to define unique context for the variables below -->
		 
 		<!-- the button names should match that of the group so all group variables will need this prefix -->
		<xsl:variable name="radio-prefix">
			<xsl:choose>
				<xsl:when test="@name"><xsl:value-of select="concat(@name, '-')"/></xsl:when>
				<xsl:otherwise><xsl:value-of select="concat(ancestor::*[name() = 'utml:radio-group' and namespace-uri() = $utml-namespace-uri]/@name, '-')"/></xsl:otherwise>
			</xsl:choose>
		</xsl:variable>
		 
         <!-- get the value ... -->
         <out:variable name="value">
            <xsl:call-template name="get-utml-value">
               <xsl:with-param name="node" select="."/>
            </xsl:call-template>
         </out:variable>
         <!-- get the default condition that will be evaluated when the queryvalue isn't present... -->
         <out:variable name="checked">
            <xsl:call-template name="get-checked-state">
               <xsl:with-param name="node" select="."/>
            </xsl:call-template>
         </out:variable>
         <xsl:variable name="track-changes">
            <xsl:call-template name="get-utml-track">
               <xsl:with-param name="node" select="ancestor::*[name() = 'utml:radio-group' and namespace-uri() = $utml-namespace-uri] | ."/>
            </xsl:call-template>
         </xsl:variable>
         <out:choose>
            <out:when test="${$radio-prefix}read-only = 'true' or $form-read-only = 'true'">
               <img role="radio" aria-disabled="true">
                  <xsl:copy-of select="@id"/>
                  <out:choose>
                     <out:when test="string(/root/env/param[@name = ${$radio-prefix}control-name])  = $value or $checked = 'true'">
                        <out:attribute name="src"><out:value-of select="$image_root"/>icon_disabled_radio_checked.gif</out:attribute>
                        <out:attribute name="aria-checked">true</out:attribute>
                     </out:when>
                     <xsl:if test="ancestor::*[name() = 'utml:radio-group' and namespace-uri() = $utml-namespace-uri]">
                        <out:when test="($value = ${$radio-prefix}default-value) and not(/root/env/param[@name = ${$radio-prefix}control-name])">
                           <out:attribute name="src"><out:value-of select="$image_root"/>icon_disabled_radio_checked.gif</out:attribute>
                           <out:attribute name="aria-checked">true</out:attribute>
                        </out:when>
                     </xsl:if>
                     <out:otherwise>
                        <out:attribute name="src"><out:value-of select="$image_root"/>icon_disabled_radio_unchecked.gif</out:attribute>
                        <out:attribute name="aria-checked">false</out:attribute>
                     </out:otherwise>
                  </out:choose>
               </img>
            </out:when>
            <out:otherwise>
               <input>
                  <!-- copy all non-utml attributes... -->
                  <xsl:copy-of select="@*[namespace-uri() != $utml-namespace-uri]"/>
                  <!-- calculate the control name, if it this guy isn't contained inside a utml:radio-group... -->
                  <xsl:choose>
                     <xsl:when test="not( ancestor::*[name() = 'utml:radio-group' and namespace-uri() = $utml-namespace-uri] )">
                        <out:variable name="{$radio-prefix}control-name">
                           <xsl:call-template name="get-utml-prefix">
                              <xsl:with-param name="node" select="."/>
                           </xsl:call-template>
                           <xsl:call-template name="get-utml-name">
                              <xsl:with-param name="node" select="."/>
                           </xsl:call-template>
                        </out:variable>
                     </xsl:when>
                     <xsl:otherwise>
                        <xsl:if test="$track-changes = 'true'">
                           <out:attribute name="onclick">
                              <out:text/>if(window.on_<out:value-of select="${$radio-prefix}control-name"/>_changed)window.on_<out:value-of select="${$radio-prefix}control-name"/>_changed();<out:text/>
                              <xsl:if test="@onclick">
                                 <out:text/>
                                 <xsl:value-of select="@onclick"/>
                                 <out:text/>
                              </xsl:if>
                           </out:attribute>
                        </xsl:if>
                     </xsl:otherwise>
                  </xsl:choose>
                  <!-- get the update flag, this can only be text... -->
                  <xsl:variable name="update">
                     <xsl:call-template name="get-utml-update">
                        <xsl:with-param name="node" select="ancestor::*[name() = 'utml:radio-group' and namespace-uri() = $utml-namespace-uri]"/>
                     </xsl:call-template>
                  </xsl:variable>
                  <!-- add the name attribute, $control-name would have been generated by the utml:radio-group... -->
                  <out:attribute name="name">
                     <out:value-of select="${$radio-prefix}control-name"/>
                  </out:attribute>
                  <!-- add the type... -->
                  <out:attribute name="type">
                     <xsl:call-template name="get-utml-type">
                        <xsl:with-param name="node" select="."/>
                     </xsl:call-template>
                  </out:attribute>
                  <!-- add the value attribute... -->
                  <out:attribute name="value">
                     <out:value-of select="$value"/>
                  </out:attribute>
                  <!-- update the control value, either from the query value, or the default... 	-->
                  <xsl:if test="$update != 'false'">
                  <out:choose>
                        <out:when test="string(/root/env/param[@name = ${$radio-prefix}control-name]) = string($value)">
                           <out:attribute name="checked">checked</out:attribute>
                        </out:when>
                        <xsl:if test="ancestor::*[name() = 'utml:radio-group' and namespace-uri() = $utml-namespace-uri]">
                           <out:when test="(string($value) = string(${$radio-prefix}default-value)) and (not(/root/env/param[@name = ${$radio-prefix}control-name]) or string(/root/env/param[@name = ${$radio-prefix}control-name])='')">
                              <out:attribute name="checked">checked</out:attribute>
                           </out:when>
                        </xsl:if>
                     </out:choose>
                  </xsl:if>
                  <!-- handle children... -->
                  <xsl:apply-templates/>
               </input>
            </out:otherwise>
         </out:choose>
      </out:if>
   </xsl:template>
   
   
   <!-- =====================================================================  -->
   <!-- ==============								Radio Group							=================== -->
   <xsl:template match="utml:radio-group[namespace-uri() = $utml-namespace-uri]" priority="1">
      <!-- 
			unlike utml:select utml:radio-group doesn't generate a top level element, so we'll wrap it in an
			xsl:if to deal with any potential scoping issues.
		-->
      <!-- 
			determine if this ontrol needs to be rendered in read-only mode 
			All radio button children of a radio button group will use this to be rendered in read-only mode (disabled).		
		-->
      <out:if test="true()">
		
		<!-- this will prefix all the radio group variable so they have unique names -->
		<xsl:variable name="radio-prefix">
			<xsl:choose>
				<xsl:when test="@name"><xsl:value-of select="concat(@name, '-')"/></xsl:when>
				<xsl:otherwise><xsl:value-of select="''"/></xsl:otherwise>
			</xsl:choose>
		</xsl:variable>
				
         <out:variable name="{$radio-prefix}read-only">
            <xsl:call-template name="get-utml-read-only">
               <xsl:with-param name="node" select="."/>
            </xsl:call-template>
         </out:variable>
         <!-- calculate the control name, this includes all dynamically generated name information... -->
         <out:variable name="{$radio-prefix}control-name">
            <xsl:call-template name="get-utml-prefix">
               <xsl:with-param name="node" select="."/>
            </xsl:call-template>
            <xsl:call-template name="get-utml-name">
               <xsl:with-param name="node" select="."/>
            </xsl:call-template>
         </out:variable>
         <!--  create a variable for the default value... -->
         <out:variable name="{$radio-prefix}default-value">
            <xsl:call-template name="get-utml-default-value">
               <xsl:with-param name="node" select="."/>
            </xsl:call-template>
         </out:variable>
         <!-- get the state of the tracking feature... -->
         <xsl:variable name="track-changes">
            <xsl:call-template name="get-utml-track">
               <xsl:with-param name="node" select="."/>
            </xsl:call-template>
         </xsl:variable>
         <out:if test="${$radio-prefix}read-only != 'true' and $form-read-only != 'true'">
            <xsl:if test="$track-changes = 'true'">
				<script language="JavaScript">
					function on_<out:value-of select="${$radio-prefix}control-name"/>_changed(){
						  document.<out:value-of select="$utml-form-name"/>.changed_<out:value-of select="${$radio-prefix}control-name"/>.value=&quot;1&quot;;
					}
				</script>
              <out:variable name="{$radio-prefix}hidden-control-name">
                 <out:value-of select="concat( 'changed_', ${$radio-prefix}control-name )"/>
              </out:variable>
    		    <input type="hidden">
                  <out:attribute name="name">
                     <out:value-of select="${$radio-prefix}hidden-control-name"/>
                  </out:attribute>
                  <out:choose>
                     <out:when test="/root/env/param[@name = ${$radio-prefix}hidden-control-name]">
                        <out:attribute name="value">
                           <out:value-of select="/root/env/param[@name = ${$radio-prefix}hidden-control-name]"/>
                        </out:attribute>
                     </out:when>
                     <out:otherwise>
                        <out:attribute name="value">0</out:attribute>
                     </out:otherwise>
                  </out:choose>
               </input>
            </xsl:if>
         </out:if>
         <xsl:apply-templates/>
      </out:if>
   </xsl:template>
   
   <!--
   =============================================================================
   Change - a control used to track changes to properties.
   =============================================================================
   -->
   <xsl:template match="utml:change[namespace-uri() = $utml-namespace-uri]" priority="1">
      <!-- Limit the scope of variables declared with <out:variable>. -->
      <out:if test="true()">
         <!-- Get the name of the hidden field. -->
         <out:variable name="hidden-control-name">
            <xsl:call-template name="get-utml-prefix">
               <xsl:with-param name="node" select="."/>
            </xsl:call-template>
            <xsl:call-template name="get-utml-name">
               <xsl:with-param name="node" select="."/>
            </xsl:call-template>
         </out:variable>
         <!-- Get the default value for this flag. -->
         <out:variable name="value">
            <xsl:call-template name="get-utml-value">
               <xsl:with-param name="node" select="."/>
            </xsl:call-template>
         </out:variable>
         <!-- Get the value for the update flag. -->
         <xsl:variable name="update">
            <xsl:call-template name="get-utml-update">
               <xsl:with-param name="node" select="."/>
            </xsl:call-template>
         </xsl:variable>
         <!-- Get the default condition expression. -->
         <xsl:variable name="default-condition">
            <xsl:call-template name="get-utml-default-condition">
               <xsl:with-param name="node" select="."/>
            </xsl:call-template>
         </xsl:variable>
         <!-- Get the override condition. -->
         <xsl:variable name="override-condition">
            <xsl:call-template name="get-utml-condition">
               <xsl:with-param name="node" select="."/>
            </xsl:call-template>
         </xsl:variable>
         <script language="JavaScript">
         function on_<out:value-of select="$hidden-control-name"/>_changed() {
            document.<out:value-of select="$utml-form-name"/>.<out:value-of select="$hidden-control-name"/>.value = &apos;1&apos;;
         }
         </script>
         <input type="hidden">
            <out:attribute name="name"><out:value-of select="$hidden-control-name"/></out:attribute>
            <!-- Update the value attribute, either from the query-values or using the default condition.  -->
            <xsl:choose>
               <xsl:when test="$update = 'false'">
                  <xsl:choose>
                     <xsl:when test="$override-condition != ''">
                        <out:choose>
                           <out:when>
                              <xsl:attribute name="test"><xsl:value-of select="$override-condition"/></xsl:attribute>
                              <out:attribute name="value">1</out:attribute>
                           </out:when>
                           <out:otherwise>
                              <out:attribute name="value">0</out:attribute>
                           </out:otherwise>
                        </out:choose>
                     </xsl:when>
                     <xsl:otherwise>
                        <out:attribute name="value"><out:value-of select="$value"/></out:attribute>
                     </xsl:otherwise>
                  </xsl:choose>
               </xsl:when>
               <xsl:otherwise>
                  <out:choose>
                     <out:when test="/root/env/param[@name = $hidden-control-name]">
                        <out:attribute name="value"><out:value-of select="/root/env/param[@name = $hidden-control-name]"/></out:attribute>
                     </out:when>
                     <xsl:if test="$default-condition != ''">
                        <out:when>
                           <xsl:attribute name="test"><xsl:value-of select="$default-condition"/></xsl:attribute>
                           <out:attribute name="value">1</out:attribute>
                        </out:when>
                     </xsl:if>
                     <out:otherwise>
                        <out:attribute name="value"><out:value-of select="$value"/></out:attribute>
                     </out:otherwise>
                  </out:choose>
               </xsl:otherwise>
            </xsl:choose>
         </input>
      </out:if>
   </xsl:template>
   
   
   
   <xsl:template name="get-utml-condition">
      <xsl:param name="node"/>
      <xsl:choose>
         <xsl:when test="$node/@utml:condition">
            <xsl:value-of select="$node/@utml:condition"/>
         </xsl:when>
         <xsl:when test="$node/utml:condition">
            <xsl:value-of select="$node/utml:condition/child::text()"/>
         </xsl:when>
      </xsl:choose>
   </xsl:template>
   <!-- 
		Description:		Retrieve the utml:prefix attribute or child element from the given node.  
	-->
   <xsl:template name="get-utml-prefix">
      <xsl:param name="node"/>
      <xsl:choose>
         <xsl:when test="$node/@utml:prefix">
            <out:text/>
            <xsl:value-of select="$node/@utml:prefix"/>
            <out:text/>
         </xsl:when>
         <xsl:when test="$node/utml:prefix">
            <out:text/>
            <xsl:copy-of select="$node/utml:prefix/child::node()"/>
            <out:text/>
         </xsl:when>
      </xsl:choose>
   </xsl:template>
   <!-- 
		Description:		Retrieve the type attribute or the utml:type child element from the given node.  Currently type can only be plain 
		text (no substitutions!), any markup given in child utml:type element will be ignored.
	-->
   <xsl:template name="get-utml-type">
      <xsl:param name="node"/>
      <xsl:choose>
         <xsl:when test="$node/@type">
            <out:text/>
            <xsl:value-of select="$node/@type"/>
            <out:text/>
         </xsl:when>
         <xsl:when test="$node/utml:type">
            <out:text/>
            <xsl:copy-of select="$node/utml:type/child::text()"/>
            <out:text/>
         </xsl:when>
      </xsl:choose>
   </xsl:template>
   <!-- 
		Description: 	retrieve the name attribute or child utml:name element from the given node.
	-->
   <xsl:template name="get-utml-name">
      <xsl:param name="node"/>
      <xsl:choose>
         <xsl:when test="$node/@name">
            <out:text/>
            <xsl:value-of select="$node/@name"/>
            <out:text/>
         </xsl:when>
         <xsl:when test="$node/utml:name">
            <out:text/>
            <xsl:copy-of select="$node/utml:name/child::node()"/>
            <out:text/>
         </xsl:when>
      </xsl:choose>
   </xsl:template>
   <!-- 
		Description: 	retrieve the read-only attribute or child utml:read-only element from the given node.
	-->
   <xsl:template name="get-utml-read-only">
      <xsl:param name="node"/>
      <xsl:choose>
         <xsl:when test="$node/@utml:read-only">
            <xsl:value-of select="$node/@utml:read-only"/>
         </xsl:when>
         <xsl:when test="$node/utml:read-only">
            <out:text/>
            <xsl:copy-of select="$node/utml:read-only/child::node()"/>
            <out:text/>
         </xsl:when>
         <xsl:otherwise>
            <out:text/>
            <xsl:value-of select="'false'"/>
            <out:text/>
         </xsl:otherwise>
      </xsl:choose>
   </xsl:template>
   <!-- 
		Description: 	retrieve the hide-when-read-only attribute or child utml:hide-when-read-only element from the given node.
	-->
   <xsl:template name="get-utml-hide-when-read-only">
      <xsl:param name="node"/>
      <xsl:choose>
         <xsl:when test="$node/@utml:hide-when-read-only">
            <xsl:value-of select="$node/@utml:hide-when-read-only"/>
         </xsl:when>
         <xsl:when test="$node/utml:hide-when-read-only">
            <out:text/>
            <xsl:copy-of select="$node/utml:hide-when-read-only/child::node()"/>
            <out:text/>
         </xsl:when>
         <xsl:otherwise>
            <out:text/>
            <xsl:value-of select="'false'"/>
            <out:text/>
         </xsl:otherwise>
      </xsl:choose>
   </xsl:template>
   <!-- 
		Description: 	retrieve the utml:unique-id attribute or child element from the given node.  
	-->
   <xsl:template name="get-utml-unique-id">
      <xsl:param name="node"/>
      <xsl:choose>
         <xsl:when test="$node/@unique-id">
            <out:text/>
            <xsl:value-of select="$node/@unique-id"/>
            <out:text/>
         </xsl:when>
         <xsl:when test="$node/utml:unique-id">
            <out:text/>
            <xsl:copy-of select="$node/utml:unique-id/child::node()"/>
            <out:text/>
         </xsl:when>
      </xsl:choose>
   </xsl:template>
   <!-- 
		Description: 	retrieve the value attribute or the utml:value child element from the given node.
	-->
   <xsl:template name="get-utml-value">
      <xsl:param name="node"/>
      <xsl:choose>
         <xsl:when test="$node/@value">
            <out:text/>
            <xsl:value-of select="$node/@value"/>
            <out:text/>
         </xsl:when>
         <xsl:when test="$node/utml:value">
            <out:text/>
            <xsl:copy-of select="$node/utml:value/child::node()"/>
            <out:text/>
         </xsl:when>
      </xsl:choose>
   </xsl:template>
   <!-- 
		Description: 	retrieve the utml:update attribute or child element from the given node.  Currently update can only be plain 
		text (no substitutions!), any markup given in child utml:update element will be ignored.

	-->
   <xsl:template name="get-utml-update">
      <xsl:param name="node"/>
      <xsl:choose>
         <xsl:when test="$node/@utml:update">
            <out:text/>
            <xsl:value-of select="$node/@utml:update"/>
            <out:text/>
         </xsl:when>
         <xsl:when test="$node/utml:update">
            <out:text/>
            <xsl:copy-of select="$node/utml:update/child::text()"/>
            <out:text/>
         </xsl:when>
      </xsl:choose>
   </xsl:template>
   <!-- 
		Description: 	retrieve the utml:default-value attribute or child element from the given node.

	-->
   <xsl:template name="get-utml-default-value">
      <xsl:param name="node"/>
      <xsl:choose>
         <xsl:when test="$node/@utml:default-value">
            <out:text/>
            <xsl:value-of select="$node/@utml:default-value"/>
            <out:text/>
         </xsl:when>
         <xsl:when test="$node/@default-value">
            <out:text/>
            <xsl:value-of select="$node/@default-value"/>
            <out:text/>
         </xsl:when>
         <xsl:when test="$node/utml:default-value">
            <out:text/>
            <xsl:copy-of select="$node/utml:default-value/child::node()"/>
            <out:text/>
         </xsl:when>
      </xsl:choose>
   </xsl:template>
   <!-- 
		Description: 	retrieve the utml:onclick attribute or child element from the given node.  
	-->
   <xsl:template name="get-utml-onclick">
      <xsl:param name="node"/>
      <xsl:choose>
         <xsl:when test="$node/@onclick">
            <out:text/>
            <xsl:value-of select="$node/@onclick"/>
            <out:text/>
         </xsl:when>
         <xsl:when test="$node/utml:onclick">
            <out:text/>
            <xsl:copy-of select="$node/utml:onclick/child::node()"/>
            <out:text/>
         </xsl:when>
      </xsl:choose>
   </xsl:template>
   <!-- 
		Description: 	retrieve the target attribute or utml:target child element from the given node.  
	-->
   <xsl:template name="get-utml-target">
      <xsl:param name="node"/>
      <xsl:choose>
         <xsl:when test="$node/@utml:target">
            <out:text/>
            <xsl:value-of select="$node/@utml:target"/>
            <out:text/>
         </xsl:when>
         <xsl:when test="$node/utml:target">
            <out:text/>
            <xsl:copy-of select="$node/utml:target/child::node()"/>
            <out:text/>
         </xsl:when>
      </xsl:choose>
   </xsl:template>
   <!-- 
		Description: 	retrieve the target attribute or utml:target child element from the given node.  
	-->
   <xsl:template name="get-target">
      <xsl:param name="node"/>
      <xsl:choose>
         <xsl:when test="$node/@target">
            <out:text/>
            <xsl:value-of select="$node/@target"/>
            <out:text/>
         </xsl:when>
         <xsl:when test="$node/utml:target">
            <out:text/>
            <xsl:copy-of select="$node/utml:target/child::node()"/>
            <out:text/>
         </xsl:when>
      </xsl:choose>
   </xsl:template>
   <!-- 
		Description: 	retrieve the submit attribute or utml:submit child element from the given node.  
	-->
   <xsl:template name="get-utml-submit">
      <xsl:param name="node"/>
      <xsl:choose>
         <xsl:when test="$node/@utml:submit">
            <out:text/>
            <xsl:value-of select="$node/@utml:submit"/>
            <out:text/>
         </xsl:when>
         <xsl:when test="$node/utml:submit">
            <out:text/>
            <xsl:copy-of select="$node/utml:submit/child::node()"/>
            <out:text/>
         </xsl:when>
      </xsl:choose>
   </xsl:template>
   <!-- 
		Description: 	retrieve the utml:validate attribute or utml:validate child element from the given node.  
	-->
   <xsl:template name="get-utml-validate">
      <xsl:param name="node"/>
      <xsl:choose>
         <xsl:when test="$node/@utml:validate">
            <out:text/>
            <xsl:value-of select="$node/@utml:validate"/>
            <out:text/>
         </xsl:when>
         <xsl:when test="$node/utml:validate">
            <out:text/>
            <xsl:copy-of select="$node/utml:validate/child::node()"/>
            <out:text/>
         </xsl:when>
      </xsl:choose>
   </xsl:template>
   <!-- 
		Description: 	retrieve the checked state 
	-->
   <xsl:template name="get-checked-state">
      <xsl:param name="node"/>
      <xsl:choose>
         <xsl:when test="$node/@checked = 'checked' or $node/@checked = 'true'">
            <xsl:text/>true<xsl:text/>
         </xsl:when>
         <xsl:otherwise>
            <xsl:text/>false<xsl:text/>
         </xsl:otherwise>
      </xsl:choose>
   </xsl:template>
   <!-- 
		Description: 	retrieve the default-condition attribute or child utml:default-condition element from the given node.  
	-->
   <xsl:template name="get-utml-default-condition">
      <xsl:param name="node"/>
      <xsl:choose>
         <xsl:when test="$node/@utml:default-condition">
            <out:text/>
            <xsl:value-of select="$node/@utml:default-condition"/>
            <out:text/>
         </xsl:when>
         <xsl:when test="$node/utml:default-condition">
            <out:text/>
            <xsl:copy-of select="$node/utml:default-condition/child::node()"/>
            <out:text/>
         </xsl:when>
      </xsl:choose>
   </xsl:template>
   <!--
	   Description:   retrieves the value of the utml:track attribute or child utml:track element
	                  from the given node.
   -->
   <xsl:template name="get-utml-track">
      <xsl:param name="node"/>
      <xsl:choose>
         <xsl:when test="$node/@utml:track">
            <xsl:text/>
            <xsl:value-of select="$node/@utml:track"/>
            <xsl:text/>
         </xsl:when>
         <xsl:when test="$node/utml:track">
            <xsl:text/>
            <xsl:copy-of select="$node/utml:track/child::node()"/>
            <xsl:text/>
         </xsl:when>
         <xsl:otherwise>
            <!-- By default, this feature is disabled. -->
            <xsl:text>false</xsl:text>
         </xsl:otherwise>
      </xsl:choose>
   </xsl:template>
   <!--
	   Description:		retrieves the value of the utml:uncheckedValue. This is used for checkboxes that need
						to return a value even when the checkbox is unchecked
   -->   
   <xsl:template name="get-utml-unchecked-value">
      <xsl:param name="node"/>
      <xsl:choose>
         <xsl:when test="$node/@utml:uncheckedValue">
            <xsl:value-of select="$node/@utml:uncheckedValue"/>
         </xsl:when>
         <xsl:when test="$node/utml:uncheckedValue">
            <xsl:copy-of select="$node/utml:uncheckedValue/child::node()"/>
         </xsl:when>
      </xsl:choose>   
   </xsl:template>
   
   <!-- 
		Description: 	retrieve the href attribute or child utml:href element from the given node.  
	-->
   <xsl:template name="get-utml-href">
      <xsl:param name="node"/>
      <xsl:choose>
         <xsl:when test="$node/@href">
            <out:text/>
            <xsl:value-of select="$node/@href"/>
            <out:text/>
         </xsl:when>
         <xsl:when test="$node/utml:href">
            <out:text/>
            <xsl:copy-of select="$node/utml:href/child::node()"/>
            <out:text/>
         </xsl:when>
      </xsl:choose>
   </xsl:template>
      <!-- 
		Description: 	retrieve the defaultKey attribute only.  
	-->
   <xsl:template name="get-utml-defaultKey">
      <xsl:param name="node"/>
      <xsl:choose>
         <xsl:when test="$node/@utml:defaultKey">
            <out:text/>
            <xsl:value-of select="$node/@utml:defaultKey"/>
            <out:text/>
         </xsl:when>
         <xsl:when test="$node/utml:defaultKey">
            <out:text/>
            <xsl:copy-of select="$node/utml:defaultKey/child::node()"/>
            <out:text/>
         </xsl:when>
      </xsl:choose>
   </xsl:template>
   <!-- 
		Description: 	retrieve the defaultAct child utml:defaultAct element from the given node.  
	-->
   <xsl:template name="get-utml-defaultAct">
      <xsl:param name="node"/>
      <xsl:choose>
         <xsl:when test="$node/@utml:defaultAct">
            <out:text/>
            <xsl:value-of select="$node/@utml:defaultAct"/>
            <out:text/>
         </xsl:when>
         <xsl:when test="$node/utml:defaultAct">
            <out:text/>
            <xsl:copy-of select="$node/utml:defaultAct/child::node()"/>
            <out:text/>
         </xsl:when>
      </xsl:choose>
   </xsl:template>
   
   <!-- the main engine -->
   <xsl:template match="*[namespace-uri() = $utml-namespace-uri]" priority="0"/>
   
   <xsl:template match="*">
      <xsl:copy>
         <xsl:copy-of select="@*[namespace-uri() != $utml-namespace-uri]"/>
         <xsl:apply-templates/>
      </xsl:copy>
   </xsl:template>
   <!--
		utml:textbox
			type
			name
			value
			utml:default-value
	-->
   <!-- theoretically the simplest template -->
   <xsl:template match="utml:comment"/>
   <!-- debug information -->
   <xsl:template match="utml:dump-state">
      <table cellpadding="2" cellspacing="3" border="0" width="100%" bgcolor="#FFFFFF">
         <tr bgcolor="#3333FF">
            <td colspan="2">
               <font face="arial" size="4" color="#FFFFFF">
						query-values
					</font>
            </td>
         </tr>
         <tr bgcolor="#CCCCFF">
            <td>
               <font face="arial" size="2">
                  <b>name</b>
               </font>
            </td>
            <td>
               <font face="arial" size="2">
                  <b>value</b>
               </font>
            </td>
         </tr>
         <out:for-each select="/root/env/param">
            <out:sort select="@name"/>
            <tr bgcolor="#CCCCCC">
               <td>
                  <font face="arial" size="2">
                     <out:value-of select="@name"/>
                  </font>
               </td>
               <td>
                  <font face="arial" size="2">
                     <out:value-of select="."/>
                  </font>
               </td>
            </tr>
         </out:for-each>
      </table>
   </xsl:template>
</xsl:stylesheet>