D-Net

<?xml version='1.0'?>

<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"

                xmlns:doc="http://nwalsh.com/xsl/documentation/1.0"

                xmlns:dyn="http://exslt.org/dynamic"

                xmlns:saxon="http://icl.com/saxon"

                exclude-result-prefixes="doc dyn saxon"

                version='1.0'>

<!-- ********************************************************************

     $Id: common.xsl 8274 2009-02-27 07:02:45Z bobstayton $

     ********************************************************************

     This file is part of the XSL DocBook Stylesheet distribution.

     See ../README or http://docbook.sf.net/release/xsl/current/ for

     copyright and other information.

     ******************************************************************** -->

<doc:reference xmlns="" xml:id="base">

  <info>

    <title>Common » Base Template Reference</title>

    <releaseinfo role="meta">

      $Id: common.xsl 8274 2009-02-27 07:02:45Z bobstayton $

    </releaseinfo>

  </info>

  <!-- * yes, partintro is a valid child of a reference... -->

  <partintro xml:id="partintro">

    <title>Introduction</title>

    <para>This is technical reference documentation for the “base”

      set of common templates in the DocBook XSL Stylesheets.</para>

    <para>This is not intended to be user documentation. It is

      provided for developers writing customization layers for the

      stylesheets.</para>

  </partintro>

</doc:reference>

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

<!-- Establish strip/preserve whitespace rules -->

<xsl:preserve-space elements="*"/>

<xsl:strip-space elements="

abstract affiliation anchor answer appendix area areaset areaspec

artheader article audiodata audioobject author authorblurb authorgroup

beginpage bibliodiv biblioentry bibliography biblioset blockquote book

bookbiblio bookinfo callout calloutlist caption caution chapter

citerefentry cmdsynopsis co collab colophon colspec confgroup

copyright dedication docinfo editor entrytbl epigraph equation

example figure footnote footnoteref formalpara funcprototype

funcsynopsis glossary glossdef glossdiv glossentry glosslist graphicco

group highlights imagedata imageobject imageobjectco important index

indexdiv indexentry indexterm info informalequation informalexample

informalfigure informaltable inlineequation inlinemediaobject

itemizedlist itermset keycombo keywordset legalnotice listitem lot

mediaobject mediaobjectco menuchoice msg msgentry msgexplan msginfo

msgmain msgrel msgset msgsub msgtext note objectinfo

orderedlist othercredit part partintro preface printhistory procedure

programlistingco publisher qandadiv qandaentry qandaset question

refentry reference refmeta refnamediv refsection refsect1 refsect1info refsect2

refsect2info refsect3 refsect3info refsynopsisdiv refsynopsisdivinfo

revhistory revision row sbr screenco screenshot sect1 sect1info sect2

sect2info sect3 sect3info sect4 sect4info sect5 sect5info section

sectioninfo seglistitem segmentedlist seriesinfo set setindex setinfo

shortcut sidebar simplelist simplesect spanspec step subject

subjectset substeps synopfragment table tbody textobject tfoot tgroup

thead tip toc tocchap toclevel1 toclevel2 toclevel3 toclevel4

toclevel5 tocpart varargs variablelist varlistentry videodata

videoobject void warning subjectset

classsynopsis

constructorsynopsis

destructorsynopsis

fieldsynopsis

methodparam

methodsynopsis

ooclass

ooexception

oointerface

simplemsgentry

manvolnum

"/>

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

<doc:template name="is.component" xmlns="">

<refpurpose>Tests if a given node is a component-level element</refpurpose>

<refdescription id="is.component-desc">

<para>This template returns '1' if the specified node is a component

(Chapter, Appendix, etc.), and '0' otherwise.</para>

</refdescription>

<refparameter id="is.component-params">

<variablelist>

<varlistentry><term>node</term>

<listitem>

<para>The node which is to be tested.</para>

</listitem>

</varlistentry>

</variablelist>

</refparameter>

<refreturn id="is.component-returns">

<para>This template returns '1' if the specified node is a component

(Chapter, Appendix, etc.), and '0' otherwise.</para>

</refreturn>

</doc:template>

<xsl:template name="is.component">

  <xsl:param name="node" select="."/>

  <xsl:choose>

    <xsl:when test="local-name($node) = 'appendix'

                    or local-name($node) = 'article'

                    or local-name($node) = 'chapter'

                    or local-name($node) = 'preface'

                    or local-name($node) = 'bibliography'

                    or local-name($node) = 'glossary'

                    or local-name($node) = 'index'">1</xsl:when>

    <xsl:otherwise>0</xsl:otherwise>

  </xsl:choose>

</xsl:template>

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

<doc:template name="is.section" xmlns="">

<refpurpose>Tests if a given node is a section-level element</refpurpose>

<refdescription id="is.section-desc">

<para>This template returns '1' if the specified node is a section

(Section, Sect1, Sect2, etc.), and '0' otherwise.</para>

</refdescription>

<refparameter id="is.section-params">

<variablelist>

<varlistentry><term>node</term>

<listitem>

<para>The node which is to be tested.</para>

</listitem>

</varlistentry>

</variablelist>

</refparameter>

<refreturn id="is.section-returns">

<para>This template returns '1' if the specified node is a section

(Section, Sect1, Sect2, etc.), and '0' otherwise.</para>

</refreturn>

</doc:template>

<xsl:template name="is.section">

  <xsl:param name="node" select="."/>

  <xsl:choose>

    <xsl:when test="local-name($node) = 'section'

                    or local-name($node) = 'sect1'

                    or local-name($node) = 'sect2'

                    or local-name($node) = 'sect3'

                    or local-name($node) = 'sect4'

                    or local-name($node) = 'sect5'

                    or local-name($node) = 'refsect1'

                    or local-name($node) = 'refsect2'

                    or local-name($node) = 'refsect3'

                    or local-name($node) = 'simplesect'">1</xsl:when>

    <xsl:otherwise>0</xsl:otherwise>

  </xsl:choose>

</xsl:template>

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

<doc:template name="section.level" xmlns="">

<refpurpose>Returns the hierarchical level of a section</refpurpose>

<refdescription id="section.level-desc">

<para>This template calculates the hierarchical level of a section.

The element <tag>sect1</tag> is at level 1, <tag>sect2</tag> is

at level 2, etc.</para>

<para>Recursive sections are calculated down to the fifth level.</para>

</refdescription>

<refparameter id="section.level-params">

<variablelist>

<varlistentry><term>node</term>

<listitem>

<para>The section node for which the level should be calculated.

Defaults to the context node.</para>

</listitem>

</varlistentry>

</variablelist>

</refparameter>

<refreturn id="section.level-returns">

<para>The section level, <quote>1</quote>, <quote>2</quote>, etc.

</para>

</refreturn>

</doc:template>

<xsl:template name="section.level">

  <xsl:param name="node" select="."/>

  <xsl:choose>

    <xsl:when test="local-name($node)='sect1'">1</xsl:when>

    <xsl:when test="local-name($node)='sect2'">2</xsl:when>

    <xsl:when test="local-name($node)='sect3'">3</xsl:when>

    <xsl:when test="local-name($node)='sect4'">4</xsl:when>

    <xsl:when test="local-name($node)='sect5'">5</xsl:when>

    <xsl:when test="local-name($node)='section'">

      <xsl:choose>

        <xsl:when test="$node/../../../../../../section">6</xsl:when>

        <xsl:when test="$node/../../../../../section">5</xsl:when>

        <xsl:when test="$node/../../../../section">4</xsl:when>

        <xsl:when test="$node/../../../section">3</xsl:when>

        <xsl:when test="$node/../../section">2</xsl:when>

        <xsl:otherwise>1</xsl:otherwise>

      </xsl:choose>

    </xsl:when>

    <xsl:when test="local-name($node)='refsect1' or

                    local-name($node)='refsect2' or

                    local-name($node)='refsect3' or

                    local-name($node)='refsection' or

                    local-name($node)='refsynopsisdiv'">

      <xsl:call-template name="refentry.section.level">

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

      </xsl:call-template>

    </xsl:when>

    <xsl:when test="local-name($node)='simplesect'">

      <xsl:choose>

        <xsl:when test="$node/../../sect1">2</xsl:when>

        <xsl:when test="$node/../../sect2">3</xsl:when>

        <xsl:when test="$node/../../sect3">4</xsl:when>

        <xsl:when test="$node/../../sect4">5</xsl:when>

        <xsl:when test="$node/../../sect5">5</xsl:when>

        <xsl:when test="$node/../../section">

          <xsl:choose>

            <xsl:when test="$node/../../../../../section">5</xsl:when>

            <xsl:when test="$node/../../../../section">4</xsl:when>

            <xsl:when test="$node/../../../section">3</xsl:when>

            <xsl:otherwise>2</xsl:otherwise>

          </xsl:choose>

        </xsl:when>

        <xsl:otherwise>1</xsl:otherwise>

      </xsl:choose>

    </xsl:when>

    <xsl:otherwise>1</xsl:otherwise>

  </xsl:choose>

</xsl:template><!-- section.level -->

<doc:template name="qanda.section.level" xmlns="">

<refpurpose>Returns the hierarchical level of a QandASet</refpurpose>

<refdescription id="qanda.section.level-desc">

<para>This template calculates the hierarchical level of a QandASet.

</para>

</refdescription>

<refreturn id="qanda.section.level-returns">

<para>The level, <quote>1</quote>, <quote>2</quote>, etc.

</para>

</refreturn>

</doc:template>

<xsl:template name="qanda.section.level">

  <xsl:variable name="section"

                select="(ancestor::section

                         |ancestor::simplesect

                         |ancestor::sect5

                         |ancestor::sect4

                         |ancestor::sect3

                         |ancestor::sect2

                         |ancestor::sect1

                         |ancestor::refsect3

                         |ancestor::refsect2

                         |ancestor::refsect1)[last()]"/>

  <xsl:choose>

    <xsl:when test="count($section) = '0'">1</xsl:when>

    <xsl:otherwise>

      <xsl:variable name="slevel">

        <xsl:call-template name="section.level">

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

        </xsl:call-template>

      </xsl:variable>

      <xsl:value-of select="$slevel + 1"/>

    </xsl:otherwise>

  </xsl:choose>

</xsl:template>

<!-- Finds the total section depth of a section in a refentry -->

<xsl:template name="refentry.section.level">

  <xsl:param name="node" select="."/>

  <xsl:variable name="RElevel">

    <xsl:call-template name="refentry.level">

      <xsl:with-param name="node" select="$node/ancestor::refentry[1]"/>

    </xsl:call-template>

  </xsl:variable>

  <xsl:variable name="levelinRE">

    <xsl:choose>

      <xsl:when test="local-name($node)='refsynopsisdiv'">1</xsl:when>

      <xsl:when test="local-name($node)='refsect1'">1</xsl:when>

      <xsl:when test="local-name($node)='refsect2'">2</xsl:when>

      <xsl:when test="local-name($node)='refsect3'">3</xsl:when>

      <xsl:when test="local-name($node)='refsection'">

        <xsl:choose>

          <xsl:when test="$node/../../../../../refsection">5</xsl:when>

          <xsl:when test="$node/../../../../refsection">4</xsl:when>

          <xsl:when test="$node/../../../refsection">3</xsl:when>

          <xsl:when test="$node/../../refsection">2</xsl:when>

          <xsl:otherwise>1</xsl:otherwise>

        </xsl:choose>

      </xsl:when>

    </xsl:choose>

  </xsl:variable>

  <xsl:value-of select="$levelinRE + $RElevel"/>

</xsl:template>

<!-- Finds the section depth of a refentry -->

<xsl:template name="refentry.level">

  <xsl:param name="node" select="."/>

  <xsl:variable name="container"

                select="($node/ancestor::section |

                        $node/ancestor::sect1 |

                        $node/ancestor::sect2 |

                        $node/ancestor::sect3 |

                        $node/ancestor::sect4 |

                        $node/ancestor::sect5)[last()]"/>

  <xsl:choose>

    <xsl:when test="$container">

      <xsl:variable name="slevel">

        <xsl:call-template name="section.level">

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

        </xsl:call-template>

      </xsl:variable>

      <xsl:value-of select="$slevel + 1"/>

    </xsl:when>

    <xsl:otherwise>1</xsl:otherwise>

  </xsl:choose>

</xsl:template>

<xsl:template name="qandadiv.section.level">

  <xsl:variable name="section.level">

    <xsl:call-template name="qanda.section.level"/>

  </xsl:variable>

  <xsl:variable name="anc.divs" select="ancestor::qandadiv"/>

  <xsl:value-of select="count($anc.divs) + number($section.level)"/>

</xsl:template>

<xsl:template name="question.answer.label">

  <xsl:variable name="deflabel">

    <xsl:choose>

      <xsl:when test="ancestor-or-self::*[@defaultlabel]">

        <xsl:value-of select="(ancestor-or-self::*[@defaultlabel])[last()]

                              /@defaultlabel"/>

      </xsl:when>

      <xsl:otherwise>

        <xsl:value-of select="$qanda.defaultlabel"/>

      </xsl:otherwise>

    </xsl:choose>

  </xsl:variable>

  <xsl:variable name="label" select="@label"/>

<!--

 (hnr      (hierarchical-number-recursive (normalize "qandadiv") node))

         (parsect  (ancestor-member node (section-element-list)))

         (defnum   (if (and %qanda-inherit-numeration% 

                            %section-autolabel%)

                       (if (node-list-empty? parsect)

                           (section-autolabel-prefix node)

                           (section-autolabel parsect))

                       ""))

         (hnumber  (let loop ((numlist hnr) (number defnum) 

                              (sep (if (equal? defnum "") "" ".")))

                     (if (null? numlist)

                         number

                         (loop (cdr numlist) 

                               (string-append number

                                              sep

                                              (number->string (car numlist)))

                               "."))))

         (cnumber  (child-number (parent node)))

         (number   (string-append hnumber 

                                  (if (equal? hnumber "")

                                      ""

                                      ".")

                                  (number->string cnumber))))

-->

  <xsl:choose>

    <xsl:when test="$deflabel = 'qanda'">

      <xsl:call-template name="gentext">

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

          <xsl:choose>

            <xsl:when test="local-name(.) = 'question'">question</xsl:when>

            <xsl:when test="local-name(.) = 'answer'">answer</xsl:when>

            <xsl:when test="local-name(.) = 'qandadiv'">qandadiv</xsl:when>

            <xsl:otherwise>qandaset</xsl:otherwise>

          </xsl:choose>

        </xsl:with-param>

      </xsl:call-template>

    </xsl:when>

    <xsl:when test="$deflabel = 'label'">

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

    </xsl:when>

    <xsl:when test="$deflabel = 'number'

                    and local-name(.) = 'question'">

      <xsl:apply-templates select="ancestor::qandaset[1]"

                           mode="number"/>

      <xsl:choose>

        <xsl:when test="ancestor::qandadiv">

          <xsl:apply-templates select="ancestor::qandadiv[1]"

                               mode="number"/>

          <xsl:apply-templates select="ancestor::qandaentry"

                               mode="number"/>

        </xsl:when>

        <xsl:otherwise>

          <xsl:apply-templates select="ancestor::qandaentry"

                               mode="number"/>

        </xsl:otherwise>

      </xsl:choose>

    </xsl:when>

    <xsl:otherwise>

      <!-- nothing -->

    </xsl:otherwise>

  </xsl:choose>

</xsl:template>

<xsl:template match="qandaset" mode="number">

  <!-- FIXME: -->

</xsl:template>

<xsl:template match="qandadiv" mode="number">

  <xsl:number level="multiple" from="qandaset" format="1."/>

</xsl:template>

<xsl:template match="qandaentry" mode="number">

  <xsl:choose>

    <xsl:when test="ancestor::qandadiv">

      <xsl:number level="single" from="qandadiv" format="1."/>

    </xsl:when>

    <xsl:otherwise>

      <xsl:number level="single" from="qandaset" format="1."/>

    </xsl:otherwise>

  </xsl:choose>

</xsl:template>

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

<xsl:template name="object.id">

  <xsl:param name="object" select="."/>

  <xsl:choose>

    <xsl:when test="$object/@id">

      <xsl:value-of select="$object/@id"/>

    </xsl:when>

    <xsl:when test="$object/@xml:id">

      <xsl:value-of select="$object/@xml:id"/>

    </xsl:when>

    <xsl:otherwise>

      <xsl:value-of select="generate-id($object)"/>

    </xsl:otherwise>

  </xsl:choose>

</xsl:template>

<xsl:template name="person.name">

  <!-- Formats a personal name. Handles corpauthor as a special case. -->

  <xsl:param name="node" select="."/>

  <xsl:variable name="style">

    <xsl:choose>

      <xsl:when test="$node/@role">

        <xsl:value-of select="$node/@role"/>

      </xsl:when>

      <xsl:otherwise>

        <xsl:call-template name="gentext.template">

          <xsl:with-param name="context" select="'styles'"/>

          <xsl:with-param name="name" select="'person-name'"/>

        </xsl:call-template>

      </xsl:otherwise>

    </xsl:choose>

  </xsl:variable>

  <xsl:choose>

    <!-- the personname element is a specialcase -->

    <xsl:when test="$node/personname">

      <xsl:call-template name="person.name">

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

      </xsl:call-template>

    </xsl:when>

    <!-- handle corpauthor as a special case...-->

    <!-- * MikeSmith 2007-06: I'm wondering if the person.name template -->

    <!-- * actually ever gets called to handle corpauthor.. maybe -->

    <!-- * we don't actually need to check for corpauthor here. -->

    <xsl:when test="local-name($node)='corpauthor'">

      <xsl:apply-templates select="$node"/>

    </xsl:when>

    <xsl:otherwise>

      <xsl:choose>

        <!-- Handle case when personname contains only general markup (DocBook 5.0) -->

        <xsl:when test="$node/self::personname and not($node/firstname or $node/honorific or $node/lineage or $node/othername or $node/surname)">

          <xsl:apply-templates select="$node/node()"/>

        </xsl:when>

        <xsl:when test="$style = 'family-given'">

          <xsl:call-template name="person.name.family-given">

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

          </xsl:call-template>

        </xsl:when>

        <xsl:when test="$style = 'last-first'">

          <xsl:call-template name="person.name.last-first">

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

          </xsl:call-template>

        </xsl:when>

        <xsl:otherwise>

          <xsl:call-template name="person.name.first-last">

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

          </xsl:call-template>

        </xsl:otherwise>

      </xsl:choose>

    </xsl:otherwise>

  </xsl:choose>

</xsl:template>

<xsl:template name="person.name.family-given">

  <xsl:param name="node" select="."/>

  <!-- The family-given style applies a convention for identifying given -->

  <!-- and family names in locales where it may be ambiguous -->

  <xsl:apply-templates select="$node//surname[1]"/>

  <xsl:if test="$node//surname and $node//firstname">

    <xsl:text> </xsl:text>

  </xsl:if>

  <xsl:apply-templates select="$node//firstname[1]"/>

  <xsl:text> [FAMILY Given]</xsl:text>

</xsl:template>

<xsl:template name="person.name.last-first">

  <xsl:param name="node" select="."/>

  <xsl:apply-templates select="$node//surname[1]"/>

  <xsl:if test="$node//surname and $node//firstname">

    <xsl:text>, </xsl:text>

  </xsl:if>

  <xsl:apply-templates select="$node//firstname[1]"/>

</xsl:template>

<xsl:template name="person.name.first-last">

  <xsl:param name="node" select="."/>

  <xsl:if test="$node//honorific">

    <xsl:apply-templates select="$node//honorific[1]"/>

    <xsl:value-of select="$punct.honorific"/>

  </xsl:if>

  <xsl:if test="$node//firstname">

    <xsl:if test="$node//honorific">

      <xsl:text> </xsl:text>

    </xsl:if>

    <xsl:apply-templates select="$node//firstname[1]"/>

  </xsl:if>

  <xsl:if test="$node//othername and $author.othername.in.middle != 0">

    <xsl:if test="$node//honorific or $node//firstname">

      <xsl:text> </xsl:text>

    </xsl:if>

    <xsl:apply-templates select="$node//othername[1]"/>

  </xsl:if>

  <xsl:if test="$node//surname">

    <xsl:if test="$node//honorific or $node//firstname

                  or ($node//othername and $author.othername.in.middle != 0)">

      <xsl:text> </xsl:text>

    </xsl:if>

    <xsl:apply-templates select="$node//surname[1]"/>

  </xsl:if>

  <xsl:if test="$node//lineage">

    <xsl:text>, </xsl:text>

    <xsl:apply-templates select="$node//lineage[1]"/>

  </xsl:if>

</xsl:template>

<xsl:template name="person.name.list">

  <!-- Return a formatted string representation of the contents of

       the current element. The current element must contain one or

       more AUTHORs, CORPAUTHORs, OTHERCREDITs, and/or EDITORs.

       John Doe

     or

       John Doe and Jane Doe

     or

       John Doe, Jane Doe, and A. Nonymous

  -->

  <xsl:param name="person.list"

             select="author|corpauthor|othercredit|editor"/>

  <xsl:param name="person.count" select="count($person.list)"/>

  <xsl:param name="count" select="1"/>

  <xsl:choose>

    <xsl:when test="$count &gt; $person.count"></xsl:when>

    <xsl:otherwise>

      <xsl:call-template name="person.name">

        <xsl:with-param name="node" select="$person.list[position()=$count]"/>

      </xsl:call-template>

      <xsl:choose>

        <xsl:when test="$person.count = 2 and $count = 1">

          <xsl:call-template name="gentext.template">

            <xsl:with-param name="context" select="'authorgroup'"/>

            <xsl:with-param name="name" select="'sep2'"/>

          </xsl:call-template>

        </xsl:when>

        <xsl:when test="$person.count &gt; 2 and $count+1 = $person.count">

          <xsl:call-template name="gentext.template">

            <xsl:with-param name="context" select="'authorgroup'"/>

            <xsl:with-param name="name" select="'seplast'"/>

          </xsl:call-template>

        </xsl:when>

        <xsl:when test="$count &lt; $person.count">

          <xsl:call-template name="gentext.template">

            <xsl:with-param name="context" select="'authorgroup'"/>

            <xsl:with-param name="name" select="'sep'"/>

          </xsl:call-template>

        </xsl:when>

      </xsl:choose>

      <xsl:call-template name="person.name.list">

        <xsl:with-param name="person.list" select="$person.list"/>

        <xsl:with-param name="person.count" select="$person.count"/>

        <xsl:with-param name="count" select="$count+1"/>

      </xsl:call-template>

    </xsl:otherwise>

  </xsl:choose>

</xsl:template><!-- person.name.list -->

<!-- === synopsis ======================================================= -->

<!-- The following definitions match those given in the reference

     documentation for DocBook V3.0

-->

<xsl:variable name="arg.choice.opt.open.str">[</xsl:variable>

<xsl:variable name="arg.choice.opt.close.str">]</xsl:variable>

<xsl:variable name="arg.choice.req.open.str">{</xsl:variable>

<xsl:variable name="arg.choice.req.close.str">}</xsl:variable>

<xsl:variable name="arg.choice.plain.open.str"><xsl:text> </xsl:text></xsl:variable>

<xsl:variable name="arg.choice.plain.close.str"><xsl:text> </xsl:text></xsl:variable>

<xsl:variable name="arg.choice.def.open.str">[</xsl:variable>

<xsl:variable name="arg.choice.def.close.str">]</xsl:variable>

<xsl:variable name="arg.rep.repeat.str">...</xsl:variable>

<xsl:variable name="arg.rep.norepeat.str"></xsl:variable>

<xsl:variable name="arg.rep.def.str"></xsl:variable>

<xsl:variable name="arg.or.sep"> | </xsl:variable>

<xsl:variable name="cmdsynopsis.hanging.indent">4pi</xsl:variable>

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

<!--

<xsl:template name="xref.g.subst">

  <xsl:param name="string"></xsl:param>

  <xsl:param name="target" select="."/>

  <xsl:variable name="subst">%g</xsl:variable>

  <xsl:choose>

    <xsl:when test="contains($string, $subst)">

      <xsl:value-of select="substring-before($string, $subst)"/>

      <xsl:call-template name="gentext.element.name">

        <xsl:with-param name="element.name" select="local-name($target)"/>

      </xsl:call-template>

      <xsl:call-template name="xref.g.subst">

        <xsl:with-param name="string"

                        select="substring-after($string, $subst)"/>

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

      </xsl:call-template>

    </xsl:when>

    <xsl:otherwise>

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

    </xsl:otherwise>

  </xsl:choose>

</xsl:template>

<xsl:template name="xref.t.subst">

  <xsl:param name="string"></xsl:param>

  <xsl:param name="target" select="."/>

  <xsl:variable name="subst">%t</xsl:variable>

  <xsl:choose>

    <xsl:when test="contains($string, $subst)">

      <xsl:call-template name="xref.g.subst">

        <xsl:with-param name="string"

                        select="substring-before($string, $subst)"/>

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

      </xsl:call-template>

      <xsl:call-template name="title.xref">

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

      </xsl:call-template>

      <xsl:call-template name="xref.t.subst">

        <xsl:with-param name="string"

                        select="substring-after($string, $subst)"/>

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

      </xsl:call-template>

    </xsl:when>

    <xsl:otherwise>

      <xsl:call-template name="xref.g.subst">

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

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

      </xsl:call-template>

    </xsl:otherwise>

  </xsl:choose>

</xsl:template>

<xsl:template name="xref.n.subst">

  <xsl:param name="string"></xsl:param>

  <xsl:param name="target" select="."/>

  <xsl:variable name="subst">%n</xsl:variable>

  <xsl:choose>

    <xsl:when test="contains($string, $subst)">

      <xsl:call-template name="xref.t.subst">

        <xsl:with-param name="string"

                        select="substring-before($string, $subst)"/>

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

      </xsl:call-template>

      <xsl:call-template name="number.xref">

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

      </xsl:call-template>

      <xsl:call-template name="xref.t.subst">

        <xsl:with-param name="string"

                        select="substring-after($string, $subst)"/>

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

      </xsl:call-template>

    </xsl:when>

    <xsl:otherwise>

      <xsl:call-template name="xref.t.subst">

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

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

      </xsl:call-template>

    </xsl:otherwise>

  </xsl:choose>

</xsl:template>

<xsl:template name="subst.xref.text">

  <xsl:param name="xref.text"></xsl:param>

  <xsl:param name="target" select="."/>

  <xsl:call-template name="xref.n.subst">

    <xsl:with-param name="string" select="$xref.text"/>

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

  </xsl:call-template>

</xsl:template>

-->

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

<xsl:template name="filename-basename">

  <!-- We assume all filenames are really URIs and use "/" -->

  <xsl:param name="filename"></xsl:param>

  <xsl:param name="recurse" select="false()"/>

  <xsl:choose>

    <xsl:when test="substring-after($filename, '/') != ''">

      <xsl:call-template name="filename-basename">

        <xsl:with-param name="filename"

                        select="substring-after($filename, '/')"/>

        <xsl:with-param name="recurse" select="true()"/>

      </xsl:call-template>

    </xsl:when>

    <xsl:otherwise>

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

    </xsl:otherwise>

  </xsl:choose>

</xsl:template>

<xsl:template name="filename-extension">

  <xsl:param name="filename"></xsl:param>

  <xsl:param name="recurse" select="false()"/>

  <!-- Make sure we only look at the base name... -->

  <xsl:variable name="basefn">

    <xsl:choose>

      <xsl:when test="$recurse">

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

      </xsl:when>

      <xsl:otherwise>

        <xsl:call-template name="filename-basename">

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

        </xsl:call-template>

      </xsl:otherwise>

    </xsl:choose>

  </xsl:variable>

  <xsl:choose>

    <xsl:when test="substring-after($basefn, '.') != ''">

      <xsl:call-template name="filename-extension">

        <xsl:with-param name="filename"

                        select="substring-after($basefn, '.')"/>

        <xsl:with-param name="recurse" select="true()"/>

      </xsl:call-template>

    </xsl:when>

    <xsl:when test="$recurse">

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

    </xsl:when>

    <xsl:otherwise></xsl:otherwise>

  </xsl:choose>

</xsl:template>

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

<doc:template name="select.mediaobject" xmlns="">

<refpurpose>Selects and processes an appropriate media object from a list</refpurpose>

<refdescription id="select.mediaobject-desc">

<para>This template takes a list of media objects (usually the

children of a mediaobject or inlinemediaobject) and processes

the "right" object.</para>

<para>This template relies on a template named 

"select.mediaobject.index" to determine which object

in the list is appropriate.</para>

<para>If no acceptable object is located, nothing happens.</para>

</refdescription>

<refparameter id="select.mediaobject-params">

<variablelist>

<varlistentry><term>olist</term>

<listitem>

<para>The node list of potential objects to examine.</para>

</listitem>

</varlistentry>

</variablelist>

</refparameter>

<refreturn id="select.mediaobject-returns">

<para>Calls &lt;xsl:apply-templates&gt; on the selected object.</para>

</refreturn>

</doc:template>

<xsl:template name="select.mediaobject">

  <xsl:param name="olist"

             select="imageobject|imageobjectco

                     |videoobject|audioobject|textobject"/>

  <xsl:variable name="mediaobject.index">

    <xsl:call-template name="select.mediaobject.index">

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

      <xsl:with-param name="count" select="1"/>

    </xsl:call-template>

  </xsl:variable>

  <xsl:if test="$mediaobject.index != ''">

    <xsl:apply-templates select="$olist[position() = $mediaobject.index]"/>

  </xsl:if>

</xsl:template>

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

<doc:template name="select.mediaobject.index" xmlns="">

<refpurpose>Selects the position of the appropriate media object from a list</refpurpose>

<refdescription id="select.mediaobject.index-desc">

<para>This template takes a list of media objects (usually the

children of a mediaobject or inlinemediaobject) and determines

the "right" object. It returns the position of that object

to be used by the calling template.</para>

<para>If the parameter <parameter>use.role.for.mediaobject</parameter>

is nonzero, then it first checks for an object with

a role attribute of the appropriate value.  It takes the first

of those.  Otherwise, it takes the first acceptable object

through a recursive pass through the list.</para>

<para>This template relies on a template named "is.acceptable.mediaobject"

to determine if a given object is an acceptable graphic. The semantics

of media objects is that the first acceptable graphic should be used.

</para>

<para>If no acceptable object is located, no index is returned.</para>

</refdescription>

<refparameter id="select.mediaobject.index-params">

<variablelist>

<varlistentry><term>olist</term>

<listitem>

<para>The node list of potential objects to examine.</para>

</listitem>

</varlistentry>

<varlistentry><term>count</term>

<listitem>

<para>The position in the list currently being considered by the 

recursive process.</para>

</listitem>

</varlistentry>

</variablelist>

</refparameter>

<refreturn id="select.mediaobject.index-returns">

<para>Returns the position in the original list of the selected object.</para>

</refreturn>

</doc:template>

<xsl:template name="select.mediaobject.index">

  <xsl:param name="olist"

             select="imageobject|imageobjectco

                     |videoobject|audioobject|textobject"/>

  <xsl:param name="count">1</xsl:param>

  <xsl:choose>

    <!-- Test for objects preferred by role -->

    <xsl:when test="$use.role.for.mediaobject != 0 

               and $preferred.mediaobject.role != ''

               and $olist[@role = $preferred.mediaobject.role]"> 

      <!-- Get the first hit's position index -->

      <xsl:for-each select="$olist">

        <xsl:if test="@role = $preferred.mediaobject.role and

             not(preceding-sibling::*[@role = $preferred.mediaobject.role])"> 

          <xsl:value-of select="position()"/> 

        </xsl:if>

      </xsl:for-each>

    </xsl:when>

    <xsl:when test="$use.role.for.mediaobject != 0 

               and $olist[@role = $stylesheet.result.type]">

      <!-- Get the first hit's position index -->

      <xsl:for-each select="$olist">

        <xsl:if test="@role = $stylesheet.result.type and 

              not(preceding-sibling::*[@role = $stylesheet.result.type])"> 

          <xsl:value-of select="position()"/> 

        </xsl:if>

      </xsl:for-each>

    </xsl:when>

    <!-- Accept 'html' for $stylesheet.result.type = 'xhtml' -->

    <xsl:when test="$use.role.for.mediaobject != 0 

               and $stylesheet.result.type = 'xhtml'

               and $olist[@role = 'html']">

      <!-- Get the first hit's position index -->

      <xsl:for-each select="$olist">

        <xsl:if test="@role = 'html' and 

              not(preceding-sibling::*[@role = 'html'])"> 

          <xsl:value-of select="position()"/> 

        </xsl:if>

      </xsl:for-each>

    </xsl:when>

    <!-- If no selection by role, and there is only one object, use it -->

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

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

    </xsl:when>

    <xsl:otherwise>

      <!-- Otherwise select first acceptable object -->

      <xsl:if test="$count &lt;= count($olist)">

        <xsl:variable name="object" select="$olist[position()=$count]"/>

        <xsl:variable name="useobject">

          <xsl:choose>

            <!-- The phrase is used only when contains TeX Math and output is FO -->

            <xsl:when test="local-name($object)='textobject' and $object/phrase

                            and $object/@role='tex' and $stylesheet.result.type = 'fo'

                            and $tex.math.in.alt != ''">

              <xsl:text>1</xsl:text> 

            </xsl:when>

            <!-- The phrase is never used -->

            <xsl:when test="local-name($object)='textobject' and $object/phrase">

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

            </xsl:when>

            <xsl:when test="local-name($object)='textobject'

                            and $object/ancestor::equation ">

            <!-- The first textobject is not a reasonable fallback

                 for equation image -->

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

            </xsl:when>

            <!-- The first textobject is a reasonable fallback -->

            <xsl:when test="local-name($object)='textobject'

                            and $object[not(@role) or @role!='tex']">

              <xsl:text>1</xsl:text>

            </xsl:when>

            <!-- don't use graphic when output is FO, TeX Math is used 

                 and there is math in alt element -->

            <xsl:when test="$object/ancestor::equation and 

                            $object/ancestor::equation/alt[@role='tex']

                            and $stylesheet.result.type = 'fo'

                            and $tex.math.in.alt != ''">

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

            </xsl:when>

            <!-- If there's only one object, use it -->

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

               <xsl:text>1</xsl:text>

            </xsl:when>

            <!-- Otherwise, see if this one is a useable graphic -->

            <xsl:otherwise>

              <xsl:choose>

                <!-- peek inside imageobjectco to simplify the test -->

                <xsl:when test="local-name($object) = 'imageobjectco'">

                  <xsl:call-template name="is.acceptable.mediaobject">

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

                  </xsl:call-template>

                </xsl:when>

                <xsl:otherwise>

                  <xsl:call-template name="is.acceptable.mediaobject">

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

                  </xsl:call-template>

                </xsl:otherwise>

              </xsl:choose>

            </xsl:otherwise>

          </xsl:choose>

        </xsl:variable>

        <xsl:choose>

          <xsl:when test="$useobject='1'">

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

          </xsl:when>

          <xsl:otherwise>

            <xsl:call-template name="select.mediaobject.index">

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

              <xsl:with-param name="count" select="$count + 1"/>

            </xsl:call-template>

          </xsl:otherwise>

        </xsl:choose>

      </xsl:if>

    </xsl:otherwise>

  </xsl:choose>

</xsl:template>

<doc:template name="is.acceptable.mediaobject" xmlns="">

<refpurpose>Returns '1' if the specified media object is recognized</refpurpose>

<refdescription id="is.acceptable.mediaobject-desc">

<para>This template examines a media object and returns '1' if the

object is recognized as a graphic.</para>

</refdescription>

<refparameter id="is.acceptable.mediaobject-params">

<variablelist>

<varlistentry><term>object</term>

<listitem>

<para>The media object to consider.</para>

</listitem>

</varlistentry>

</variablelist>

</refparameter>

<refreturn id="is.acceptable.mediaobject-returns">

<para>0 or 1</para>

</refreturn>

</doc:template>

<xsl:template name="is.acceptable.mediaobject">

  <xsl:param name="object"></xsl:param>

  <xsl:variable name="filename">

    <xsl:call-template name="mediaobject.filename">

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

    </xsl:call-template>

  </xsl:variable>

  <xsl:variable name="ext">

    <xsl:call-template name="filename-extension">

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

    </xsl:call-template>

  </xsl:variable>

  <!-- there will only be one -->

  <xsl:variable name="data" select="$object/videodata

                                    |$object/imagedata

                                    |$object/audiodata"/>

  <xsl:variable name="format" select="$data/@format"/>

  <xsl:variable name="graphic.format">

    <xsl:if test="$format">

      <xsl:call-template name="is.graphic.format">

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

      </xsl:call-template>

    </xsl:if>

  </xsl:variable>

  <xsl:variable name="graphic.ext">

    <xsl:if test="$ext">

      <xsl:call-template name="is.graphic.extension">

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

      </xsl:call-template>

    </xsl:if>

  </xsl:variable>

  <xsl:choose>

    <xsl:when test="$use.svg = 0 and $format = 'SVG'">0</xsl:when>

    <xsl:when xmlns:svg="http://www.w3.org/2000/svg"

              test="$use.svg != 0 and $object/svg:*">1</xsl:when>

    <xsl:when test="$graphic.format = '1'">1</xsl:when>

    <xsl:when test="$graphic.ext = '1'">1</xsl:when>

    <xsl:otherwise>0</xsl:otherwise>

  </xsl:choose>

</xsl:template>

<xsl:template name="mediaobject.filename">

  <xsl:param name="object"></xsl:param>

  <xsl:variable name="data" select="$object/videodata

                                    |$object/imagedata

                                    |$object/audiodata

                                    |$object"/>

  <xsl:variable name="filename">

    <xsl:choose>

      <xsl:when test="$data[@fileref]">

        <xsl:apply-templates select="$data/@fileref"/>

      </xsl:when>

      <xsl:when test="$data[@entityref]">

        <xsl:value-of select="unparsed-entity-uri($data/@entityref)"/>

      </xsl:when>

      <xsl:otherwise></xsl:otherwise>

    </xsl:choose>

  </xsl:variable>

  <xsl:variable name="real.ext">

    <xsl:call-template name="filename-extension">

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

    </xsl:call-template>

  </xsl:variable>

  <xsl:variable name="ext">

    <xsl:choose>

      <xsl:when test="$real.ext != ''">

        <xsl:value-of select="$real.ext"/>