xsl.xtp

解压在c盘

<xsl:template match='a'>
  <c xsl:use-attribute-sets='font'/>
</xsl:template>
</example>
<results>
&lt;c font-size='12pt' font-weight='bold'/>
</results>
</example>

</defun>

<defun name=pi title='&lt;xsl:processing-instruction&gt;'>
<sum>Creates a new processing instruction.</sum>

<deftable>
<tr><th>Attribute<th>Meaning
<tr><td>name<td>Processing instruction name.
</deftable>

<example>
<example>
&lt;xsl:template match='a'>
  &lt;xsl:processing-instruction name='foo'>
  &lt;xsl:text>Text for the PI&lt;/xsl:text>
  &lt;/xsl:processing-instruction/>
&lt;/xsl:template>
</example>
<results>
&lt;?foo Text for the PI?>
</results>
</example>
</defun>

<defun name=comment title='&lt;xsl:comment&gt;'>
<sum>Creates a new comment.</sum>  The contents of the xsl:comment element
become the contents of the comment.

<example>
<example>
&lt;xsl:template match='a'>
  &lt;xsl:comment>
  &lt;xsl:text>Text for the comment&lt;/xsl:text>
  &lt;/xsl:processing-instruction/>
&lt;/xsl:template>
</example>
<results>
&lt;!--Text for the comment-->
</results>
</example>
</defun>

<defun name=copy title='&lt;xsl:copy&gt;'>
<sum>Copies the current node, but not children or attributes, to the
output.</sum> 

<p>To copy an element, a stylesheet must copy the attributes as well.

<p/>The following example is the identity stylesheet. It copies input
to the output including the attributes.

<example>
<example>
&lt;xsl:template match='@*|node()'>
  &lt;xsl:copy>
    &lt;xsl:apply-templates select='@*|node()'/>
  &lt;/xsl:copy>
&lt;/xsl:template>
</example>
</example>
</defun>

<defun name=copy-of title='&lt;xsl:copy-of .../&gt;'>
<sum>Copies a sub-tree into the output.</sum>  <code/copy-of/> resembles
<code/value-of/>.  <code/value-of/> always converts the value to a
string.  <code/copy-of/> will copy subtrees. 

<deftable>
<tr><th>attribute<th>meaning
<tr><td>select<td>An XPath expression to be copied.
</deftable>
</defun>

<defun name=variable title='&lt;xsl:variable&gt;'>
<sum>Assignes an XSL variable.</sum>  Variables can be retrieved using
the XPath variable syntax.

<deftable>
<tr><th>Attribute<th>Meaning
<tr><td>name<td>variable name
<tr><td>select<td>variable value
</deftable>

<example>
<example>
&lt;xsl:variable name='foo' select='1+1'/>

&lt;xsl:template match='a'>
  &lt;xsl:value-of select='$foo'/>
&lt;/xsl:template>
</example>
<results>
2
</results>
</example>
</defun>

<defun name=call-template title='&lt;xsl:call-template&gt;'>
<sum>Calls a named template with the current node.</sum>
<code/xsl:call-template/> lets stylesheets reuse common code, like
functions.  It works like <code/xsl:apply-templates select='.'/>
except that it calls based on a template name.


<deftable>
<tr><th>Attribute<th>Meaning
<tr><td>name<td>template name to call
<tr><td>mode<td>template mode
</deftable>
</defun>

<defun name=param title='&lt;xsl:param&gt;'>
<sum>Declares an XSL parameter.</sum>  <code/xsl:param/>'s
<code/select/> parameter as a default.  If the variable has been
assigned, it uses the old value.

<deftable>
<tr><th>Attribute<th>Meaning
<tr><td>name<td>variable name
<tr><td>select<td>variable value
</deftable>

<example>
<example>
&lt;xsl:template name='fun'>
  &lt;xsl:param name='foo' select='15'/>
  &lt;xsl:value-of select='$foo'/>
&lt;/xsl:template>

&lt;xsl:template match='a'>
  &lt;xsl:call-template name='foo'>
    &lt;xsl:with-param name='foo' select='1+2'/>
  &lt;/xsl:call-template>
&lt;/xsl:template>
</example>
<results>
3
</results>
</example>
</defun>

<defun name=apply-imports title='&lt;xsl:apply-imports&gt;'>
<sum>Like Java's <code/super/>, calls the overridden template.</sum>
</defun>

<defun name=sort title='&lt;xsl:sort&gt;'>
<sum>Sorts nodes in xsl:apply-templates or
xsl:for-each.</sum>

<deftable>
<tr><th>Attribute<th>Meaning
<tr><td>select<td>value to sort on (default = '.')
<tr><td>order<td>ascending or descending  (default = ascending)
<tr><td>data-type<td>text or number (default = text)
</deftable>

<note>case-order is not implemented</note>
</defun>

<defun name=choose title='&lt;xsl:choose ...&gt; ...'>
<sum>Implements an if-elsif-else block.</sum>  The <code/xsl:when/>
statements are tested in order.  The first matching one is executed.
If none match, the <code/xsl:otherwise/> block is executed.

<deftable>
<tr><th>Attribute<th>Meaning
<tr><td>test<td>XPath expression evaluating to a boolean.
</deftable>

<example>
<example>
&lt;xsl:template match='a'>
  &lt;xsl:choose>
  &lt;xsl:when test='@color="red"'>
    &lt;xsl:text>stop&lt;/xsl:text>
  &lt;/xsl:when>
  &lt;xsl:when test='@color="green"'>
    &lt;xsl:text>go&lt;/xsl:text>
  &lt;/xsl:when>
  &lt;xsl:otherwise>
    &lt;xsl:text>yield&lt;/xsl:text>
  &lt;/xsl:otherwise>
  &lt;/xsl:choose>
&lt;/xsl:template>
</example>
</example>

</defun>
</section>

<section name='xsl' title='Resin extensions'>
<!--
<defun name=copy-element title='&lt;xtp:copy-element&gt;' version='resin1.0'>
<sum>Copies the element to the output.</sum>

<p><code/xtp:copy-element/> is extremely useful as a default rule.
With <code/xtp:copy-element/> as the default, the input gets copied to
the output.  Using the usual default, all tags get stripped.

<p>The standard default rule produces the following,</p>

<example>
<example>
&lt;a&gt;A text&lt;/a&gt;
&lt;b&gt;B text&lt;/b&gt;
</example>
<results>
A text
B text
</results>
</example>

<p>Using <code/xtp:copy-element/>, XSL stylesheets can copy elements
it doesn't understand.</p>

<example>
<example>
&lt;xsl:template match='*'&gt;
  &lt;xtp:copy-element&gt;
    &lt;xsl:apply-templates/&gt;
  &lt;/xtp:copy-element&gt;
&lt;/xsl:template&gt;
</example>

<example>
&lt;a&gt;A text&lt;/a&gt;
&lt;b&gt;B text&lt;/b&gt;
</example>
<results>
&lt;a&gt;A text&lt;/a&gt;
&lt;b&gt;B text&lt;/b&gt;
</results>
</example>


</defun>
-->
<defun name=expression title='&lt;xtp:expression>expression ...'
       version='resin1.0'>
<sum>Executes <var/expression/> and prints it to the output.</sum>
 Stylesheets can use any JavaScript expression.  The following
variables are pre-defined in stylesheets.

<deftable>
<tr><th>Variable<th>Meaning
<tr><td>node<td>The current org.w3c.dom.Node.
<tr><td>out<td>The com.caucho.xsl.XslWriter.
</deftable>

In addition, the <var/out/> variable gives access to the servlet
PageContext with the <var/page/> property.

<example>
&lt;xsl:template match='welcome-user'&gt;
  &lt;xsl:text>Welcome back, &lt;/xsl:text>
  &lt;xtp:expression>
    out.page.session.value.user
  &lt;xtp:expression>
&lt;/xsl:template&gt;
</example>
</defun>
<defun name=scriptlet title='&lt;xtp:scriptlet> statement_list'
       version='resin1.0'>
<sum>Executes the <var/statement_list/> scriptlet.</sum>  The
JavaScript code can be any statement list.  The same implicit
variables are allowed in scriptlets as in expressions.

<p>The following example creates a number of stars:

<example>
<example>
&lt;@# page language='javascript' #>
&lt;xsl:template match='ct:stars'&gt;
  &lt;xtp:scriptlet&gt;
    for (var i = 0; i < node.attribute.count; i++)
      out.write('*');
  &lt;/xtp:scriptlet&gt;
&lt;/xsl:template&gt;
</example>

<example>
1 = &lt;ct:stars count='1'/><br>
9 = &lt;ct:stars count='9'/><br>
</example>
<results>
1 = *
9 = *********
</results>
</example>

</defun>

<defun name=declaration title='&lt;xtp:declaration>'
       index='declaration'>
<sum>Adds declaration code, i.e. code outside of any function.</sum>

<example>
&lt;xtp:declaration>
function dist(x1, y1, x2, y2)
{
  return Math.sqrt((x1 - x2) * (x1 - x2) +
                   (y1 - y2) * (y1 - y2));
}
&lt;/xtp:declaration>

</example>

</defun>

<defun name=page title='&lt;xtp:directive.page attributes />'>
<sum>Sets page directives</sum>
<deftable>
<tr><th>name<th>meaning
<tr><td>language<td>script language, default Java
<tr><td>session<td>use sessions, default false
<tr><td>errorPage<td>page to display for errors
<tr><td>errorPage<td>page to display for errors
<tr><td>import<td>imports Java packages 
<tr><td>contentType<td>content-type of the generated page
</deftable>

</defun>
<!--
<defun name=cache title='&lt;xtp:directive.cache attributes/>'>

<sum>Caches the generated JSP file by default.</sum>

<p>Caching for XSL is more complicated than for JSP because only some
templates may be used in a page.  Caching is based on the generated
page, not simply on the stylesheet.

<p/>A page that just uses static
templates is automatically cached.  Pages that use scripts just for
simple calculation can also be cached.  But pages that use scripts
based on the request cannot be cached.

<deftable>
<tr><th>name<th>meaning
<tr><td>file<td>the JSP file depends on <var/file/>.
<tr><td>no-cache<td>do not cache the generated JSP.
</deftable>

</defun>
-->

</section>