Showing:

Documentation
Parameters
Used by
References
Overriding
Imported modules
Included modules
Imported from
Source
Stylesheet dita2htmlImpl.xsl
Documentation

Description

 This file is part of the DITA Open Toolkit project hosted on 
     Sourceforge.net. See the accompanying license.txt file for 
     applicable licenses.
 (c) Copyright IBM Corp. 2004, 2005 All Rights Reserved. 
Imported modules
Included modules
Imported from
Template *[contains(@class,' topic/no-topic-nesting ')]
Documentation

Description

 these elements are never processed in a conventional presentation. can be overridden. 
Namespace No namespace
Match *[contains(@class,' topic/no-topic-nesting ')]
Mode #default
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/no-topic-nesting ')]"/>
Template /
Documentation

Description

 =========== ROOT RULE (just fall through; no side effects for new delivery contexts =========== 
Namespace No namespace
Match /
Mode #default
Overriding
Template /
Import precedence 4
Source
<xsl:template match="/">
  <xsl:apply-templates/>
</xsl:template>
Template /dita | *[contains(@class,' topic/topic ')]
Documentation

Description

 =========== NESTED TOPIC RULES =========== 
 This first template rule generates the outer-level shell for a delivery context.
     In an override stylesheet, the same call to "chapter-setup" must be issued to
     maintain the consistency of overall look'n'feel of the output HTML.
     Match on the first DITA element -or- the first root 'topic' element. 
Namespace No namespace
Match /dita | *[contains(@class,' topic/topic ')]
Mode #default
Import precedence 4
Source
<xsl:template match="/dita | *[contains(@class,' topic/topic ')]">
  <xsl:choose>
    <xsl:when test="not(parent::*)">
      <xsl:apply-templates select="." mode="root_element"/>
    </xsl:when>
    <xsl:otherwise>
      <xsl:apply-templates select="." mode="child.topic"/>
    </xsl:otherwise>
  </xsl:choose>
</xsl:template>
Template *root_elementroot_element
Documentation

Description

 Matches /dita or a root topic 
Namespace No namespace
Match *
Mode root_element
References
Template chapter-setup
Import precedence 4
Source
<xsl:template match="*" mode="root_element" name="root_element">
  <xsl:call-template name="chapter-setup"/>
</xsl:template>
Template *[contains(@class,' topic/topic ')]child.topicchild.topic
Documentation

Description

 child topics get a div wrapper and fall through 
Namespace No namespace
Match *[contains(@class,' topic/topic ')]
Mode child.topic
References
Template gen-topic
Variable newline
Parameters
QName Namespace
nestlevel No namespace
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/topic ')]" mode="child.topic" name="child.topic">
  <xsl:param name="nestlevel">
    <xsl:choose>
      <!-- Limit depth for historical reasons, could allow any depth. Previously limit was 5. -->
      <xsl:when test="count(ancestor::*[contains(@class,' topic/topic ')]) > 9">9</xsl:when>
      <xsl:otherwise>
        <xsl:value-of select="count(ancestor::*[contains(@class,' topic/topic ')])"/>
      </xsl:otherwise>
    </xsl:choose>
  </xsl:param>
  <div class="nested{$nestlevel}">
    <xsl:call-template name="gen-topic"/>
  </div>
  <xsl:value-of select="$newline"/>
</xsl:template>
Template gen-topic
Namespace No namespace
Used by
Template child.topic
References
Import precedence 4
Source
<xsl:template name="gen-topic">
  <xsl:variable name="flagrules">
    <xsl:call-template name="getrules"/>
  </xsl:variable>
  <xsl:choose>
    <xsl:when test="parent::dita and not(preceding-sibling::*)">
      <!-- Do not reset xml:lang if it is already set on <html> -->
      <xsl:apply-templates select="." mode="set-output-class"/>
    </xsl:when>
    <xsl:otherwise>
      <xsl:call-template name="commonattributes"/>
    </xsl:otherwise>
  </xsl:choose>
  <xsl:call-template name="gen-toc-id"/>
  <xsl:call-template name="gen-style">
    <xsl:with-param name="flagrules" select="$flagrules"/>
  </xsl:call-template>
  <xsl:call-template name="setidaname"/>
  <xsl:apply-templates select="." mode="outputContentsWithFlags"/>
</xsl:template>
Template *[contains(@class,' topic/topic ')]/*[contains(@class,' topic/title ')]
Documentation

Description

 NESTED TOPIC TITLES (sensitive to nesting depth, but are still processed for contained markup) 
 1st level - topic/title 
 Condensed topic title into single template without priorities; use $headinglevel to set heading.
     If desired, somebody could pass in the value to manually set the heading level 
Namespace No namespace
Match *[contains(@class,' topic/topic ')]/*[contains(@class,' topic/title ')]
Mode #default
References
Template commonattributes
Variable newline
Parameters
QName Namespace
headinglevel No namespace
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/topic ')]/*[contains(@class,' topic/title ')]">
  <xsl:param name="headinglevel">
    <xsl:choose>
      <xsl:when test="count(ancestor::*[contains(@class,' topic/topic ')]) > 6">6</xsl:when>
      <xsl:otherwise>
        <xsl:value-of select="count(ancestor::*[contains(@class,' topic/topic ')])"/>
      </xsl:otherwise>
    </xsl:choose>
  </xsl:param>
  <xsl:element name="h{$headinglevel}">
    <xsl:attribute name="class">topictitle
      <xsl:value-of select="$headinglevel"/>
    </xsl:attribute>
    <xsl:call-template name="commonattributes">
      <xsl:with-param name="default-output-class">topictitle
        <xsl:value-of select="$headinglevel"/>
      </xsl:with-param>
    </xsl:call-template>
    <xsl:apply-templates/>
  </xsl:element>
  <xsl:value-of select="$newline"/>
</xsl:template>
Template *[contains(@class,' topic/titlealts ')]
Documentation

Description

 Hide titlealts - they need to get pulled into the proper places 
Namespace No namespace
Match *[contains(@class,' topic/titlealts ')]
Mode #default
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/titlealts ')]"/>
Template *[contains(@class,' topic/body ')]topic.body
Documentation

Description

 =========== BODY/SECTION (not sensitive to nesting depth) =========== 
Namespace No namespace
Match *[contains(@class,' topic/body ')]
Mode #default
References
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/body ')]" name="topic.body">
  <xsl:variable name="flagrules">
    <xsl:call-template name="getrules"/>
  </xsl:variable>
  <div>
    <xsl:call-template name="commonattributes"/>
    <xsl:call-template name="gen-style">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
    <xsl:call-template name="setidaname"/>
    <xsl:call-template name="start-flagit">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
    <xsl:call-template name="start-revflag">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
    <!-- here, you can generate a toc based on what's a child of body -->
    <!--xsl:call-template name="gen-sect-ptoc"/-->
    <!-- Works; not always wanted, though; could add a param to enable it.-->
    <!-- Insert prev/next links. since they need to be scoped by who they're 'pooled' with, apply-templates in 'hierarchylink' mode to linkpools (or related-links itself) when they have children that have any of the following characteristics:
       - role=ancestor (used for breadcrumb)
       - role=next or role=previous (used for left-arrow and right-arrow before the breadcrumb)
       - importance=required AND no role, or role=sibling or role=friend or role=previous or role=cousin (to generate prerequisite links)
       - we can't just assume that links with importance=required are prerequisites, since a topic with eg role='next' might be required, while at the same time by definition not a prerequisite -->
    <!-- Added for DITA 1.1 "Shortdesc proposal" -->
    <!-- get the abstract para -->
    <xsl:apply-templates select="preceding-sibling::*[contains(@class,' topic/abstract ')]" mode="outofline"/>
    <!-- get the shortdesc para -->
    <xsl:apply-templates select="preceding-sibling::*[contains(@class,' topic/shortdesc ')]" mode="outofline"/>
    <!-- Insert pre-req links - after shortdesc - unless there is a prereq section about -->
    <xsl:apply-templates select="following-sibling::*[contains(@class,' topic/related-links ')]" mode="prereqs"/>
    <xsl:apply-templates/>
    <xsl:call-template name="end-revflag">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
    <xsl:call-template name="end-flagit">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
  </div>
  <xsl:value-of select="$newline"/>
</xsl:template>
Template *[contains(@class,' topic/abstract ')]
Documentation

Description

 Added for DITA 1.1 "Shortdesc proposal" 
Namespace No namespace
Match *[contains(@class,' topic/abstract ')]
Mode #default
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/abstract ')]">
  <xsl:if test="not(following-sibling::*[contains(@class,' topic/body ')])">
    <xsl:apply-templates select="." mode="outofline"/>
    <xsl:apply-templates select="following-sibling::*[contains(@class,' topic/related-links ')]" mode="prereqs"/>
  </xsl:if>
</xsl:template>
Template *[contains(@class,' topic/abstract ')]outofline
Documentation

Description

 Added for DITA 1.1 "Shortdesc proposal" 
 called abstract processing - para at start of topic 
Namespace No namespace
Match *[contains(@class,' topic/abstract ')]
Mode outofline
References
Template commonattributes
Variable newline
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/abstract ')]" mode="outofline">
  <div>
    <xsl:call-template name="commonattributes"/>
    <xsl:apply-templates select="." mode="outputContentsWithFlagsAndStyle"/>
  </div>
  <xsl:value-of select="$newline"/>
</xsl:template>
Template *[contains(@class,' topic/shortdesc ')]
Documentation

Description

 Updated for DITA 1.1 "Shortdesc proposal" 
 Added for SF 1363055: Shortdesc disappears when optional body is removed 
Namespace No namespace
Match *[contains(@class,' topic/shortdesc ')]
Mode #default
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/shortdesc ')]">
  <xsl:choose>
    <xsl:when test="parent::*[contains(@class, ' topic/abstract ')]">
      <xsl:apply-templates select="." mode="outofline.abstract"/>
    </xsl:when>
    <xsl:when test="not(following-sibling::*[contains(@class,' topic/body ')])">
      <xsl:apply-templates select="." mode="outofline"/>
      <xsl:apply-templates select="following-sibling::*[contains(@class,' topic/related-links ')]" mode="prereqs"/>
    </xsl:when>
    <xsl:otherwise/>
  </xsl:choose>
</xsl:template>
Template *[contains(@class,' topic/shortdesc ')]outofline.abstract
Documentation

Description

 called shortdesc processing when it is in abstract 
Namespace No namespace
Match *[contains(@class,' topic/shortdesc ')]
Mode outofline.abstract
References
Template commonattributes
Variable newline
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/shortdesc ')]" mode="outofline.abstract">
  <xsl:choose>
    <xsl:when test="preceding-sibling::*[contains(@class,' topic/p ') or contains(@class,' topic/dl ') or                                          contains(@class,' topic/fig ') or contains(@class,' topic/lines ') or                                          contains(@class,' topic/lq ') or contains(@class,' topic/note ') or                                          contains(@class,' topic/ol ') or contains(@class,' topic/pre ') or                                          contains(@class,' topic/simpletable ') or contains(@class,' topic/sl ') or                                          contains(@class,' topic/table ') or contains(@class,' topic/ul ')]">
      <div>
        <xsl:call-template name="commonattributes"/>
        <xsl:apply-templates select="." mode="outputContentsWithFlagsAndStyle"/>
      </div>
    </xsl:when>
    <xsl:when test="following-sibling::*[contains(@class,' topic/p ') or contains(@class,' topic/dl ') or                                          contains(@class,' topic/fig ') or contains(@class,' topic/lines ') or                                          contains(@class,' topic/lq ') or contains(@class,' topic/note ') or                                          contains(@class,' topic/ol ') or contains(@class,' topic/pre ') or                                          contains(@class,' topic/simpletable ') or contains(@class,' topic/sl ') or                                          contains(@class,' topic/table ') or contains(@class,' topic/ul ')]">
      <div>
        <xsl:call-template name="commonattributes"/>
        <xsl:apply-templates select="." mode="outputContentsWithFlagsAndStyle"/>
      </div>
    </xsl:when>
    <xsl:otherwise>
      <xsl:if test="preceding-sibling::* | preceding-sibling::text()">
        <xsl:text> </xsl:text>
      </xsl:if>
      <span>
        <xsl:call-template name="commonattributes"/>
        <xsl:apply-templates select="." mode="outputContentsWithFlagsAndStyle"/>
      </span>
    </xsl:otherwise>
  </xsl:choose>
  <xsl:value-of select="$newline"/>
</xsl:template>
Template *[contains(@class,' topic/shortdesc ')]outofline
Documentation

Description

 called shortdesc processing - para at start of topic 
Namespace No namespace
Match *[contains(@class,' topic/shortdesc ')]
Mode outofline
References
Template commonattributes
Variable newline
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/shortdesc ')]" mode="outofline">
  <p>
    <xsl:call-template name="commonattributes"/>
    <xsl:apply-templates select="." mode="outputContentsWithFlagsAndStyle"/>
  </p>
  <xsl:value-of select="$newline"/>
</xsl:template>
Template *[contains(@class,' topic/section ')]topic.section
Documentation

Description

 section processor - div with no generated title 
Namespace No namespace
Match *[contains(@class,' topic/section ')]
Mode #default
References
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/section ')]" name="topic.section">
  <xsl:variable name="flagrules">
    <xsl:call-template name="getrules"/>
  </xsl:variable>
  <div class="section">
    <xsl:call-template name="commonattributes"/>
    <xsl:call-template name="gen-style">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
    <xsl:call-template name="gen-toc-id"/>
    <xsl:call-template name="setidaname"/>
    <xsl:call-template name="start-flagit">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
    <xsl:variable name="revtest">
      <xsl:if test="@rev and not($FILTERFILE='') and ($DRAFT='yes')">
        <xsl:call-template name="find-active-rev-flag">
          <xsl:with-param name="allrevs" select="@rev"/>
        </xsl:call-template>
      </xsl:if>
    </xsl:variable>
    <xsl:choose>
      <xsl:when test="$revtest=1">
        <!-- Rev is active - add the DIV -->
        <div class="{@rev}">
          <xsl:apply-templates select="." mode="section-fmt"/>
        </div>
      </xsl:when>
      <xsl:otherwise>
        <!-- Rev wasn't active - process normally -->
        <xsl:apply-templates select="." mode="section-fmt"/>
      </xsl:otherwise>
    </xsl:choose>
    <xsl:call-template name="end-flagit">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
  </div>
  <xsl:value-of select="$newline"/>
</xsl:template>
Template *[contains(@class,' topic/section ')]section-fmt
Namespace No namespace
Match *[contains(@class,' topic/section ')]
Mode section-fmt
References
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/section ')]" mode="section-fmt">
  <xsl:variable name="flagrules">
    <xsl:call-template name="getrules"/>
  </xsl:variable>
  <xsl:call-template name="start-revflag">
    <xsl:with-param name="flagrules" select="$flagrules"/>
  </xsl:call-template>
  <xsl:call-template name="sect-heading"/>
  <xsl:apply-templates select="*[not(contains(@class,' topic/title '))] | text() | comment() | processing-instruction()"/>
  <xsl:call-template name="end-revflag">
    <xsl:with-param name="flagrules" select="$flagrules"/>
  </xsl:call-template>
</xsl:template>
Template *[contains(@class,' topic/example ')]topic.example
Documentation

Description

 example processor - div with no generated title 
Namespace No namespace
Match *[contains(@class,' topic/example ')]
Mode #default
References
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/example ')]" name="topic.example">
  <div class="example">
    <xsl:call-template name="commonattributes"/>
    <xsl:call-template name="gen-toc-id"/>
    <xsl:call-template name="setidaname"/>
    <xsl:variable name="revtest">
      <xsl:if test="@rev and not($FILTERFILE='') and ($DRAFT='yes')">
        <xsl:call-template name="find-active-rev-flag">
          <xsl:with-param name="allrevs" select="@rev"/>
        </xsl:call-template>
      </xsl:if>
    </xsl:variable>
    <xsl:choose>
      <xsl:when test="$revtest=1">
        <!-- Rev is active - add the DIV -->
        <div class="{@rev}">
          <xsl:apply-templates select="." mode="example-fmt"/>
        </div>
      </xsl:when>
      <xsl:otherwise>
        <!-- Rev wasn't active - process normally -->
        <xsl:apply-templates select="." mode="example-fmt"/>
      </xsl:otherwise>
    </xsl:choose>
  </div>
  <xsl:value-of select="$newline"/>
</xsl:template>
Template *[contains(@class,' topic/example ')]example-fmt
Namespace No namespace
Match *[contains(@class,' topic/example ')]
Mode example-fmt
References
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/example ')]" mode="example-fmt">
  <xsl:variable name="flagrules">
    <xsl:call-template name="getrules"/>
  </xsl:variable>
  <xsl:call-template name="gen-style">
    <xsl:with-param name="flagrules" select="$flagrules"/>
  </xsl:call-template>
  <xsl:call-template name="start-flagit">
    <xsl:with-param name="flagrules" select="$flagrules"/>
  </xsl:call-template>
  <xsl:call-template name="start-revflag">
    <xsl:with-param name="flagrules" select="$flagrules"/>
  </xsl:call-template>
  <xsl:call-template name="sect-heading"/>
  <xsl:apply-templates select="*[not(contains(@class,' topic/title '))] | text() | comment() | processing-instruction()"/>
  <xsl:call-template name="end-revflag">
    <xsl:with-param name="flagrules" select="$flagrules"/>
  </xsl:call-template>
  <xsl:call-template name="end-flagit">
    <xsl:with-param name="flagrules" select="$flagrules"/>
  </xsl:call-template>
</xsl:template>
Template *[contains(@class,' topic/p ')]topic.p
Documentation

Description

 ===================================================================== 
 =========== BASIC BODY ELEMENTS =========== 
 paragraphs 
Namespace No namespace
Match *[contains(@class,' topic/p ')]
Mode #default
References
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/p ')]" name="topic.p">
  <xsl:variable name="flagrules">
    <xsl:call-template name="getrules"/>
  </xsl:variable>
  <!-- To ensure XHTML validity, need to determine whether the DITA kids are block elements.
      If so, use div_class="p" instead of p -->
  <xsl:choose>
    <xsl:when test="descendant::*[contains(@class,' topic/pre ')] or        descendant::*[contains(@class,' topic/ul ')] or        descendant::*[contains(@class,' topic/sl ')] or        descendant::*[contains(@class,' topic/ol ')] or        descendant::*[contains(@class,' topic/lq ')] or        descendant::*[contains(@class,' topic/dl ')] or        descendant::*[contains(@class,' topic/note ')] or        descendant::*[contains(@class,' topic/lines ')] or        descendant::*[contains(@class,' topic/fig ')] or        descendant::*[contains(@class,' topic/table ')] or        descendant::*[contains(@class,' topic/simpletable ')]">
      <div class="p">
        <xsl:call-template name="commonattributes"/>
        <xsl:call-template name="gen-style">
          <xsl:with-param name="flagrules" select="$flagrules"/>
        </xsl:call-template>
        <xsl:call-template name="setidaname"/>
        <xsl:call-template name="start-flagit">
          <xsl:with-param name="flagrules" select="$flagrules"/>
        </xsl:call-template>
        <xsl:call-template name="revblock">
          <xsl:with-param name="flagrules" select="$flagrules"/>
        </xsl:call-template>
        <xsl:call-template name="end-flagit">
          <xsl:with-param name="flagrules" select="$flagrules"/>
        </xsl:call-template>
      </div>
    </xsl:when>
    <xsl:otherwise>
      <p>
        <xsl:call-template name="commonattributes"/>
        <xsl:call-template name="gen-style">
          <xsl:with-param name="flagrules" select="$flagrules"/>
        </xsl:call-template>
        <xsl:call-template name="setidaname"/>
        <xsl:call-template name="start-flagit">
          <xsl:with-param name="flagrules" select="$flagrules"/>
        </xsl:call-template>
        <xsl:call-template name="revblock">
          <xsl:with-param name="flagrules" select="$flagrules"/>
        </xsl:call-template>
        <xsl:call-template name="end-flagit">
          <xsl:with-param name="flagrules" select="$flagrules"/>
        </xsl:call-template>
      </p>
    </xsl:otherwise>
  </xsl:choose>
  <xsl:value-of select="$newline"/>
</xsl:template>
Template note
Documentation

Description

 Left for users who call this template in an override 
Namespace No namespace
Import precedence 4
Source
<xsl:template name="note">
  <xsl:apply-templates select="." mode="process.note"/>
</xsl:template>
Template *[contains(@class,' topic/note ')]topic.note
Documentation

Description

 Fixed SF Bug 1405184 "Note template for XHTML should be easier to override" 
Namespace No namespace
Match *[contains(@class,' topic/note ')]
Mode #default
References
Template spec-title
Variable newline
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/note ')]" name="topic.note">
  <xsl:call-template name="spec-title"/>
  <xsl:choose>
    <xsl:when test="@type='note'">
      <xsl:apply-templates select="." mode="process.note"/>
    </xsl:when>
    <xsl:when test="@type='tip'">
      <xsl:apply-templates select="." mode="process.note.tip"/>
    </xsl:when>
    <xsl:when test="@type='fastpath'">
      <xsl:apply-templates select="." mode="process.note.fastpath"/>
    </xsl:when>
    <xsl:when test="@type='important'">
      <xsl:apply-templates select="." mode="process.note.important"/>
    </xsl:when>
    <xsl:when test="@type='remember'">
      <xsl:apply-templates select="." mode="process.note.remember"/>
    </xsl:when>
    <xsl:when test="@type='restriction'">
      <xsl:apply-templates select="." mode="process.note.restriction"/>
    </xsl:when>
    <xsl:when test="@type='attention'">
      <xsl:apply-templates select="." mode="process.note.attention"/>
    </xsl:when>
    <xsl:when test="@type='caution'">
      <xsl:apply-templates select="." mode="process.note.caution"/>
    </xsl:when>
    <xsl:when test="@type='danger'">
      <xsl:apply-templates select="." mode="process.note.danger"/>
    </xsl:when>
    <xsl:when test="@type='other'">
      <xsl:apply-templates select="." mode="process.note.other"/>
    </xsl:when>
    <xsl:otherwise>
      <xsl:apply-templates select="." mode="process.note"/>
    </xsl:otherwise>
  </xsl:choose>
  <xsl:value-of select="$newline"/>
</xsl:template>
Template *process.note
Namespace No namespace
Match *
Mode process.note
References
Import precedence 4
Source
<xsl:template match="*" mode="process.note">
  <xsl:variable name="flagrules">
    <xsl:call-template name="getrules"/>
  </xsl:variable>
  <div class="note">
    <xsl:call-template name="commonattributes">
      <xsl:with-param name="default-output-class" select="'note'"/>
    </xsl:call-template>
    <xsl:call-template name="gen-style">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
    <xsl:call-template name="setidaname"/>
    <span class="notetitle">
      <xsl:call-template name="getString">
        <xsl:with-param name="stringName" select="'Note'"/>
      </xsl:call-template>
      <xsl:call-template name="getString">
        <xsl:with-param name="stringName" select="'ColonSymbol'"/>
      </xsl:call-template>
    </span>
    <xsl:text> </xsl:text>
    <xsl:call-template name="start-flagit">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
    <xsl:call-template name="revblock">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
    <xsl:call-template name="end-flagit">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
  </div>
</xsl:template>
Template *process.note.tip
Namespace No namespace
Match *
Mode process.note.tip
References
Import precedence 4
Source
<xsl:template match="*" mode="process.note.tip">
  <xsl:variable name="flagrules">
    <xsl:call-template name="getrules"/>
  </xsl:variable>
  <div class="tip">
    <xsl:call-template name="commonattributes">
      <xsl:with-param name="default-output-class" select="'tip'"/>
    </xsl:call-template>
    <xsl:call-template name="setidaname"/>
    <xsl:call-template name="gen-style">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
    <span class="tiptitle">
      <xsl:call-template name="getString">
        <xsl:with-param name="stringName" select="'Tip'"/>
      </xsl:call-template>
      <xsl:call-template name="getString">
        <xsl:with-param name="stringName" select="'ColonSymbol'"/>
      </xsl:call-template>
    </span>
    <xsl:text> </xsl:text>
    <xsl:call-template name="start-flagit">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
    <xsl:call-template name="revblock">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
    <xsl:call-template name="end-flagit">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
  </div>
</xsl:template>
Template *process.note.fastpath
Namespace No namespace
Match *
Mode process.note.fastpath
References
Import precedence 4
Source
<xsl:template match="*" mode="process.note.fastpath">
  <xsl:variable name="flagrules">
    <xsl:call-template name="getrules"/>
  </xsl:variable>
  <div class="fastpath">
    <xsl:call-template name="commonattributes">
      <xsl:with-param name="default-output-class" select="'fastpath'"/>
    </xsl:call-template>
    <xsl:call-template name="gen-style">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
    <xsl:call-template name="setidaname"/>
    <span class="fastpathtitle">
      <xsl:call-template name="getString">
        <xsl:with-param name="stringName" select="'Fastpath'"/>
      </xsl:call-template>
      <xsl:call-template name="getString">
        <xsl:with-param name="stringName" select="'ColonSymbol'"/>
      </xsl:call-template>
    </span>
    <xsl:text> </xsl:text>
    <xsl:call-template name="start-flagit">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
    <xsl:call-template name="revblock">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
    <xsl:call-template name="end-flagit">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
  </div>
</xsl:template>
Template *process.note.important
Namespace No namespace
Match *
Mode process.note.important
References
Import precedence 4
Source
<xsl:template match="*" mode="process.note.important">
  <xsl:variable name="flagrules">
    <xsl:call-template name="getrules"/>
  </xsl:variable>
  <div class="important">
    <xsl:call-template name="commonattributes">
      <xsl:with-param name="default-output-class" select="'important'"/>
    </xsl:call-template>
    <xsl:call-template name="gen-style">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
    <xsl:call-template name="setidaname"/>
    <span class="importanttitle">
      <xsl:call-template name="getString">
        <xsl:with-param name="stringName" select="'Important'"/>
      </xsl:call-template>
      <xsl:call-template name="getString">
        <xsl:with-param name="stringName" select="'ColonSymbol'"/>
      </xsl:call-template>
    </span>
    <xsl:text> </xsl:text>
    <xsl:call-template name="start-flagit">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
    <xsl:call-template name="revblock">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
    <xsl:call-template name="end-flagit">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
  </div>
</xsl:template>
Template *process.note.remember
Namespace No namespace
Match *
Mode process.note.remember
References
Import precedence 4
Source
<xsl:template match="*" mode="process.note.remember">
  <xsl:variable name="flagrules">
    <xsl:call-template name="getrules"/>
  </xsl:variable>
  <div class="remember">
    <xsl:call-template name="commonattributes">
      <xsl:with-param name="default-output-class" select="'remember'"/>
    </xsl:call-template>
    <xsl:call-template name="gen-style">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
    <xsl:call-template name="setidaname"/>
    <span class="remembertitle">
      <xsl:call-template name="getString">
        <xsl:with-param name="stringName" select="'Remember'"/>
      </xsl:call-template>
      <xsl:call-template name="getString">
        <xsl:with-param name="stringName" select="'ColonSymbol'"/>
      </xsl:call-template>
    </span>
    <xsl:text> </xsl:text>
    <xsl:call-template name="start-flagit">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
    <xsl:call-template name="revblock">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
    <xsl:call-template name="end-flagit">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
  </div>
</xsl:template>
Template *process.note.restriction
Namespace No namespace
Match *
Mode process.note.restriction
References
Import precedence 4
Source
<xsl:template match="*" mode="process.note.restriction">
  <xsl:variable name="flagrules">
    <xsl:call-template name="getrules"/>
  </xsl:variable>
  <div class="restriction">
    <xsl:call-template name="commonattributes">
      <xsl:with-param name="default-output-class" select="'restriction'"/>
    </xsl:call-template>
    <xsl:call-template name="gen-style">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
    <xsl:call-template name="setidaname"/>
    <span class="restrictiontitle">
      <xsl:call-template name="getString">
        <xsl:with-param name="stringName" select="'Restriction'"/>
      </xsl:call-template>
      <xsl:call-template name="getString">
        <xsl:with-param name="stringName" select="'ColonSymbol'"/>
      </xsl:call-template>
    </span>
    <xsl:text> </xsl:text>
    <xsl:call-template name="start-flagit">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
    <xsl:call-template name="revblock">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
    <xsl:call-template name="end-flagit">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
  </div>
</xsl:template>
Template *process.note.attention
Namespace No namespace
Match *
Mode process.note.attention
References
Import precedence 4
Source
<xsl:template match="*" mode="process.note.attention">
  <xsl:variable name="flagrules">
    <xsl:call-template name="getrules"/>
  </xsl:variable>
  <div class="attention">
    <xsl:call-template name="commonattributes">
      <xsl:with-param name="default-output-class" select="'attention'"/>
    </xsl:call-template>
    <xsl:call-template name="gen-style">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
    <xsl:call-template name="setidaname"/>
    <xsl:call-template name="start-flagit">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
    <span class="attentiontitle">
      <xsl:call-template name="getString">
        <xsl:with-param name="stringName" select="'Attention'"/>
      </xsl:call-template>
      <xsl:call-template name="getString">
        <xsl:with-param name="stringName" select="'ColonSymbol'"/>
      </xsl:call-template>
    </span>
    <xsl:text> </xsl:text>
    <xsl:call-template name="revblock">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
    <xsl:call-template name="end-flagit">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
  </div>
</xsl:template>
Template *process.note.caution
Namespace No namespace
Match *
Mode process.note.caution
References
Import precedence 4
Source
<xsl:template match="*" mode="process.note.caution">
  <xsl:variable name="flagrules">
    <xsl:call-template name="getrules"/>
  </xsl:variable>
  <div class="cautiontitle">
    <xsl:call-template name="commonattributes"/>
    <xsl:attribute name="class">cautiontitle</xsl:attribute>
    <xsl:call-template name="setidaname"/>
    <xsl:call-template name="getString">
      <xsl:with-param name="stringName" select="'Caution'"/>
    </xsl:call-template>
    <xsl:call-template name="getString">
      <xsl:with-param name="stringName" select="'ColonSymbol'"/>
    </xsl:call-template>
  </div>
  <div class="caution">
    <xsl:call-template name="commonattributes">
      <xsl:with-param name="default-output-class" select="'caution'"/>
    </xsl:call-template>
    <xsl:call-template name="gen-style">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
    <xsl:call-template name="start-flagit">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
    <xsl:call-template name="revblock">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
    <xsl:call-template name="end-flagit">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
  </div>
</xsl:template>
Template *process.note.danger
Namespace No namespace
Match *
Mode process.note.danger
References
Import precedence 4
Source
<xsl:template match="*" mode="process.note.danger">
  <xsl:variable name="flagrules">
    <xsl:call-template name="getrules"/>
  </xsl:variable>
  <div class="dangertitle">
    <xsl:call-template name="commonattributes"/>
    <xsl:attribute name="class">dangertitle</xsl:attribute>
    <xsl:call-template name="setidaname"/>
    <xsl:call-template name="getString">
      <xsl:with-param name="stringName" select="'Danger'"/>
    </xsl:call-template>
  </div>
  <div class="danger">
    <xsl:call-template name="commonattributes">
      <xsl:with-param name="default-output-class" select="'danger'"/>
    </xsl:call-template>
    <xsl:call-template name="gen-style">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
    <xsl:call-template name="start-flagit">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
    <xsl:call-template name="revblock">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
    <xsl:call-template name="end-flagit">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
  </div>
</xsl:template>
Template *process.note.other
Namespace No namespace
Match *
Mode process.note.other
References
Import precedence 4
Source
<xsl:template match="*" mode="process.note.other">
  <xsl:variable name="flagrules">
    <xsl:call-template name="getrules"/>
  </xsl:variable>
  <xsl:choose>
    <xsl:when test="@othertype">
      <div class="note">
        <xsl:call-template name="commonattributes">
          <xsl:with-param name="default-output-class" select="'note'"/>
        </xsl:call-template>
        <xsl:call-template name="gen-style">
          <xsl:with-param name="flagrules" select="$flagrules"/>
        </xsl:call-template>
        <xsl:call-template name="setidaname"/>
        <span class="notetitle">
          <xsl:value-of select="@othertype"/>
          <xsl:call-template name="getString">
            <xsl:with-param name="stringName" select="'ColonSymbol'"/>
          </xsl:call-template>
        </span>
        <xsl:text> </xsl:text>
        <xsl:call-template name="start-flagit">
          <xsl:with-param name="flagrules" select="$flagrules"/>
        </xsl:call-template>
        <xsl:call-template name="revblock">
          <xsl:with-param name="flagrules" select="$flagrules"/>
        </xsl:call-template>
        <xsl:call-template name="end-flagit">
          <xsl:with-param name="flagrules" select="$flagrules"/>
        </xsl:call-template>
      </div>
    </xsl:when>
    <xsl:otherwise>
      <xsl:apply-templates select="." mode="process.note"/>
      <!-- otherwise, give them the standard note -->
    </xsl:otherwise>
  </xsl:choose>
</xsl:template>
Template *[contains(@class,' topic/lq ')]topic.lq
Documentation

Description

 long quote (bibliographic association).
     @reftitle contains the citation for the excerpt.
     With a link if @href is used.  
Namespace No namespace
Match *[contains(@class,' topic/lq ')]
Mode #default
References
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/lq ')]" name="topic.lq">
  <xsl:variable name="flagrules">
    <xsl:call-template name="getrules"/>
  </xsl:variable>
  <blockquote>
    <xsl:call-template name="commonattributes"/>
    <xsl:call-template name="gen-style">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
    <xsl:call-template name="setidaname"/>
    <xsl:call-template name="start-flagit">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
    <xsl:variable name="revtest">
      <xsl:if test="@rev and not($FILTERFILE='') and ($DRAFT='yes')">
        <xsl:call-template name="find-active-rev-flag">
          <xsl:with-param name="allrevs" select="@rev"/>
        </xsl:call-template>
      </xsl:if>
    </xsl:variable>
    <xsl:choose>
      <xsl:when test="$revtest=1">
        <!-- Rev is active - add the DIV -->
        <div class="{@rev}">
          <xsl:apply-templates select="." mode="lq-fmt"/>
        </div>
      </xsl:when>
      <xsl:otherwise>
        <!-- Rev wasn't active - process normally -->
        <xsl:apply-templates select="." mode="lq-fmt"/>
      </xsl:otherwise>
    </xsl:choose>
    <xsl:call-template name="end-flagit">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
  </blockquote>
  <xsl:value-of select="$newline"/>
</xsl:template>
Template *[contains(@class,' topic/lq ')]lq-fmt
Namespace No namespace
Match *[contains(@class,' topic/lq ')]
Mode lq-fmt
References
Templates end-revflag; getrules; start-revflag
Parameters DITAEXT; OUTEXT
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/lq ')]" mode="lq-fmt">
  <xsl:variable name="flagrules">
    <xsl:call-template name="getrules"/>
  </xsl:variable>
  <xsl:call-template name="start-revflag">
    <xsl:with-param name="flagrules" select="$flagrules"/>
  </xsl:call-template>
  <xsl:apply-templates/>
  <xsl:choose>
    <xsl:when test="@href">
      <!-- Insert citation as link, use @href as-is -->
      <br/>
      <div style="text-align:right">
        <a>
          <xsl:attribute name="href">
            <xsl:choose>
              <xsl:when test="contains(@href,$DITAEXT)">
                <xsl:value-of select="substring-before(@href,$DITAEXT)"/>
                <xsl:value-of select="$OUTEXT"/>
                <xsl:value-of select="substring-after(@href,$DITAEXT)"/>
              </xsl:when>
              <xsl:otherwise>
                <xsl:value-of select="@href"/>
              </xsl:otherwise>
            </xsl:choose>
          </xsl:attribute>
          <xsl:choose>
            <xsl:when test="@type='external'">
              <xsl:attribute name="target">_blank</xsl:attribute>
            </xsl:when>
            <xsl:otherwise>
              <!--nop - no target needed for internal or biblio types (OR-should internal force DITA xref-like processing? What is intent? @type is only internal/external/bibliographic) -->
            </xsl:otherwise>
          </xsl:choose>
          <cite>
            <xsl:choose>
              <xsl:when test="@reftitle">
                <xsl:value-of select="@reftitle"/>
              </xsl:when>
              <xsl:otherwise>
                <xsl:value-of select="@href"/>
              </xsl:otherwise>
            </xsl:choose>
          </cite>
        </a>
      </div>
    </xsl:when>
    <xsl:when test="@reftitle">
      <!-- Insert citation text -->
      <br/>
      <div style="text-align:right">
        <cite>
          <xsl:value-of select="@reftitle"/>
        </cite>
      </div>
    </xsl:when>
    <xsl:otherwise>
      <!--nop - do nothing-->
    </xsl:otherwise>
  </xsl:choose>
  <xsl:call-template name="end-revflag">
    <xsl:with-param name="flagrules" select="$flagrules"/>
  </xsl:call-template>
</xsl:template>
Template *[contains(@class,' topic/ul ')]topic.ul
Documentation

Description

 =========== SINGLE PART LISTS =========== 
 Unordered List 
 handle all levels thru browser processing 
Namespace No namespace
Match *[contains(@class,' topic/ul ')]
Mode #default
References
Parameters DRAFT; FILTERFILE
Template find-active-rev-flag
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/ul ')]" name="topic.ul">
  <xsl:variable name="revtest">
    <xsl:if test="@rev and not($FILTERFILE='') and ($DRAFT='yes')">
      <xsl:call-template name="find-active-rev-flag">
        <xsl:with-param name="allrevs" select="@rev"/>
      </xsl:call-template>
    </xsl:if>
  </xsl:variable>
  <xsl:choose>
    <xsl:when test="$revtest=1">
      <!-- Rev is active - add the DIV -->
      <div class="{@rev}">
        <xsl:apply-templates select="." mode="ul-fmt"/>
      </div>
    </xsl:when>
    <xsl:otherwise>
      <!-- Rev wasn't active - process normally -->
      <xsl:apply-templates select="." mode="ul-fmt"/>
    </xsl:otherwise>
  </xsl:choose>
</xsl:template>
Template *[contains(@class,' topic/ul ')]ul-fmt
Namespace No namespace
Match *[contains(@class,' topic/ul ')]
Mode ul-fmt
References
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/ul ')]" mode="ul-fmt">
  <xsl:variable name="flagrules">
    <xsl:call-template name="getrules"/>
  </xsl:variable>
  <!-- edited by William on 2009-06-16 for bullet bug:2782503 start-->
  <!--br/-->
  <!-- edited by William on 2009-06-16 for bullet bug:2782503 end-->
  <xsl:call-template name="start-flagit">
    <xsl:with-param name="flagrules" select="$flagrules"/>
  </xsl:call-template>
  <xsl:call-template name="start-revflag">
    <xsl:with-param name="flagrules" select="$flagrules"/>
  </xsl:call-template>
  <xsl:call-template name="setaname"/>
  <ul>
    <xsl:call-template name="commonattributes"/>
    <xsl:call-template name="gen-style">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
    <xsl:apply-templates select="@compact"/>
    <xsl:call-template name="setid"/>
    <xsl:apply-templates/>
  </ul>
  <xsl:call-template name="end-revflag">
    <xsl:with-param name="flagrules" select="$flagrules"/>
  </xsl:call-template>
  <xsl:call-template name="end-flagit">
    <xsl:with-param name="flagrules" select="$flagrules"/>
  </xsl:call-template>
  <xsl:value-of select="$newline"/>
</xsl:template>
Template *[contains(@class,' topic/sl ')]topic.sl
Documentation

Description

 Simple List 
 handle all levels thru browser processing 
Namespace No namespace
Match *[contains(@class,' topic/sl ')]
Mode #default
References
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/sl ')]" name="topic.sl">
  <xsl:variable name="flagrules">
    <xsl:call-template name="getrules"/>
  </xsl:variable>
  <!-- edited by William on 2009-06-16 for bullet bug:2782503 start-->
  <!--br/-->
  <!-- edited by William on 2009-06-16 for bullet bug:2782503 end-->
  <xsl:call-template name="start-flagit">
    <xsl:with-param name="flagrules" select="$flagrules"/>
  </xsl:call-template>
  <xsl:choose>
    <!-- draft rev mode, add div w/ rev attr value -->
    <xsl:when test="@rev and not($FILTERFILE='') and ($DRAFT='yes')">
      <xsl:variable name="revtest">
        <!-- Flag the revision? 1=yes; 0=no -->
        <xsl:call-template name="find-active-rev-flag">
          <xsl:with-param name="allrevs" select="@rev"/>
        </xsl:call-template>
      </xsl:variable>
      <xsl:choose>
        <xsl:when test="$revtest=1">
          <div class="{@rev}">
            <xsl:apply-templates select="." mode="sl-fmt"/>
          </div>
        </xsl:when>
        <xsl:otherwise>
          <xsl:apply-templates select="." mode="sl-fmt"/>
        </xsl:otherwise>
      </xsl:choose>
    </xsl:when>
    <xsl:otherwise>
      <xsl:apply-templates select="." mode="sl-fmt"/>
    </xsl:otherwise>
  </xsl:choose>
</xsl:template>
Template *[contains(@class,' topic/sl ')]sl-fmt
Namespace No namespace
Match *[contains(@class,' topic/sl ')]
Mode sl-fmt
References
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/sl ')]" mode="sl-fmt">
  <xsl:variable name="flagrules">
    <xsl:call-template name="getrules"/>
  </xsl:variable>
  <xsl:call-template name="start-revflag">
    <xsl:with-param name="flagrules" select="$flagrules"/>
  </xsl:call-template>
  <xsl:call-template name="setaname"/>
  <ul class="simple">
    <xsl:call-template name="commonattributes">
      <xsl:with-param name="default-output-class" select="'simple'"/>
    </xsl:call-template>
    <xsl:call-template name="gen-style">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
    <xsl:apply-templates select="@compact"/>
    <xsl:call-template name="setid"/>
    <xsl:apply-templates/>
  </ul>
  <xsl:call-template name="end-revflag">
    <xsl:with-param name="flagrules" select="$flagrules"/>
  </xsl:call-template>
  <xsl:call-template name="end-flagit">
    <xsl:with-param name="flagrules" select="$flagrules"/>
  </xsl:call-template>
  <xsl:value-of select="$newline"/>
</xsl:template>
Template *[contains(@class,' topic/ol ')]topic.ol
Documentation

Description

 Ordered List - 1st level - Handle levels 1 to 9 thru OL-TYPE attribution 
 Updated to use a single template, use count and mod to set the list type 
Namespace No namespace
Match *[contains(@class,' topic/ol ')]
Mode #default
References
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/ol ')]" name="topic.ol">
  <xsl:variable name="flagrules">
    <xsl:call-template name="getrules"/>
  </xsl:variable>
  <xsl:variable name="olcount" select="count(ancestor-or-self::*[contains(@class,' topic/ol ')])"/>
  <!-- edited by William on 2009-06-16 for bullet bug:2782503 start-->
  <!--br/-->
  <!-- edited by William on 2009-06-16 for bullet bug:2782503 end-->
  <xsl:call-template name="start-flagit">
    <xsl:with-param name="flagrules" select="$flagrules"/>
  </xsl:call-template>
  <xsl:call-template name="start-revflag">
    <xsl:with-param name="flagrules" select="$flagrules"/>
  </xsl:call-template>
  <xsl:call-template name="setaname"/>
  <ol>
    <xsl:call-template name="commonattributes"/>
    <xsl:call-template name="gen-style">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
    <xsl:apply-templates select="@compact"/>
    <xsl:choose>
      <xsl:when test="$olcount mod 3 = 1"/>
      <xsl:when test="$olcount mod 3 = 2">
        <xsl:attribute name="type">a</xsl:attribute></xsl:when>
      <xsl:otherwise>
        <xsl:attribute name="type">i</xsl:attribute></xsl:otherwise>
    </xsl:choose>
    <xsl:call-template name="setid"/>
    <xsl:apply-templates/>
  </ol>
  <xsl:call-template name="end-revflag">
    <xsl:with-param name="flagrules" select="$flagrules"/>
  </xsl:call-template>
  <xsl:call-template name="end-flagit">
    <xsl:with-param name="flagrules" select="$flagrules"/>
  </xsl:call-template>
  <xsl:value-of select="$newline"/>
</xsl:template>
Template *[contains(@class,' topic/li ')]topic.li
Documentation

Description

 list item 
Namespace No namespace
Match *[contains(@class,' topic/li ')]
Mode #default
References
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/li ')]" name="topic.li">
  <xsl:variable name="flagrules">
    <xsl:call-template name="getrules"/>
  </xsl:variable>
  <li>
    <!-- handle non-compact list items -->
    <xsl:if test="parent::*/@compact='no'">
      <xsl:attribute name="class">liexpand</xsl:attribute>
    </xsl:if>
    <xsl:call-template name="commonattributes"/>
    <xsl:call-template name="gen-style">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
    <xsl:call-template name="setidaname"/>
    <xsl:call-template name="start-flagit">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
    <xsl:call-template name="revblock">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
    <xsl:call-template name="end-flagit">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
  </li>
  <xsl:value-of select="$newline"/>
</xsl:template>
Template *[contains(@class,' topic/sli ')]topic.sli
Documentation

Description

 simple list item 
Namespace No namespace
Match *[contains(@class,' topic/sli ')]
Mode #default
References
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/sli ')]" name="topic.sli">
  <xsl:variable name="flagrules">
    <xsl:call-template name="getrules"/>
  </xsl:variable>
  <li>
    <xsl:choose>
      <xsl:when test="parent::*/@compact='no'">
        <xsl:attribute name="class">sliexpand</xsl:attribute>
        <!-- handle non-compact list items -->
        <xsl:call-template name="commonattributes">
          <xsl:with-param name="default-output-class" select="'sliexpand'"/>
        </xsl:call-template>
      </xsl:when>
      <xsl:otherwise>
        <xsl:call-template name="commonattributes"/>
      </xsl:otherwise>
    </xsl:choose>
    <xsl:call-template name="commonattributes"/>
    <xsl:call-template name="gen-style">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
    <xsl:call-template name="setidaname"/>
    <xsl:call-template name="start-flagit">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
    <xsl:call-template name="revblock">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
    <xsl:call-template name="end-flagit">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
  </li>
  <xsl:value-of select="$newline"/>
</xsl:template>
Template *[contains(@class,' topic/li ')]xref
Documentation

Description

 special case of getting the number of a list item referenced by xref 
Namespace No namespace
Match *[contains(@class,' topic/li ')]
Mode xref
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/li ')]" mode="xref">
  <xsl:number/>
</xsl:template>
Template *[contains(@class,' topic/itemgroup ')]topic.itemgroup
Documentation

Description

 list item section is like li/lq but without presentation (indent) 
Namespace No namespace
Match *[contains(@class,' topic/itemgroup ')]
Mode #default
References
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/itemgroup ')]" name="topic.itemgroup">
  <!-- insert a space before all but the first itemgroups in a LI -->
  <xsl:variable name="itemgroupcount">
    <xsl:number count="*[contains(@class,' topic/itemgroup ')]"/>
  </xsl:variable>
  <xsl:variable name="flagrules">
    <xsl:call-template name="getrules"/>
  </xsl:variable>
  <xsl:if test="$itemgroupcount>'1'">
    <xsl:text> </xsl:text>
  </xsl:if>
  <xsl:call-template name="start-flagit">
    <xsl:with-param name="flagrules" select="$flagrules"/>
  </xsl:call-template>
  <xsl:call-template name="revtext">
    <xsl:with-param name="flagrules" select="$flagrules"/>
  </xsl:call-template>
  <xsl:call-template name="end-flagit">
    <xsl:with-param name="flagrules" select="$flagrules"/>
  </xsl:call-template>
</xsl:template>
Template *[contains(@class,' topic/dl ')]topic.dl
Documentation

Description

 =========== DEFINITION LIST =========== 
 DL 
Namespace No namespace
Match *[contains(@class,' topic/dl ')]
Mode #default
References
Parameters DRAFT; FILTERFILE
Template find-active-rev-flag
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/dl ')]" name="topic.dl">
  <xsl:variable name="revtest">
    <xsl:if test="@rev and not($FILTERFILE='') and ($DRAFT='yes')">
      <xsl:call-template name="find-active-rev-flag">
        <xsl:with-param name="allrevs" select="@rev"/>
      </xsl:call-template>
    </xsl:if>
  </xsl:variable>
  <xsl:choose>
    <xsl:when test="$revtest=1">
      <!-- Rev is active - add the DIV -->
      <div class="{@rev}">
        <xsl:apply-templates select="." mode="dl-fmt"/>
      </div>
    </xsl:when>
    <xsl:otherwise>
      <!-- Rev wasn't active - process normally -->
      <xsl:apply-templates select="." mode="dl-fmt"/>
    </xsl:otherwise>
  </xsl:choose>
</xsl:template>
Template *[contains(@class,' topic/dl ')]dl-fmt
Namespace No namespace
Match *[contains(@class,' topic/dl ')]
Mode dl-fmt
References
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/dl ')]" mode="dl-fmt">
  <xsl:variable name="flagrules">
    <xsl:call-template name="getrules"/>
  </xsl:variable>
  <xsl:call-template name="start-flagit">
    <xsl:with-param name="flagrules" select="$flagrules"/>
  </xsl:call-template>
  <xsl:call-template name="start-revflag">
    <xsl:with-param name="flagrules" select="$flagrules"/>
  </xsl:call-template>
  <xsl:call-template name="setaname"/>
  <dl>
    <!-- handle DL compacting - default=yes -->
    <xsl:if test="@compact='no'">
      <xsl:attribute name="class">dlexpand</xsl:attribute>
    </xsl:if>
    <xsl:call-template name="commonattributes"/>
    <xsl:call-template name="gen-style">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
    <xsl:apply-templates select="@compact"/>
    <xsl:call-template name="setid"/>
    <xsl:apply-templates/>
  </dl>
  <xsl:call-template name="end-revflag">
    <xsl:with-param name="flagrules" select="$flagrules"/>
  </xsl:call-template>
  <xsl:call-template name="end-flagit">
    <xsl:with-param name="flagrules" select="$flagrules"/>
  </xsl:call-template>
  <xsl:value-of select="$newline"/>
</xsl:template>
Template *[contains(@class,' topic/dlentry ')]topic.dlentry
Documentation

Description

 DL entry 
Namespace No namespace
Match *[contains(@class,' topic/dlentry ')]
Mode #default
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/dlentry ')]" name="topic.dlentry">
  <xsl:apply-templates/>
</xsl:template>
Template *[contains(@class,' topic/dt ')]output-dt
Documentation

Description

 SF Patch 2185423: condensed code so that dt processing is not repeated for keyref or when $dtcount!=1
     Code could be reduced further by compressing the flagging templates. 
Namespace No namespace
Match *[contains(@class,' topic/dt ')]
Mode output-dt
References
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/dt ')]" mode="output-dt">
  <!-- insert a blank line before only the first DT in a DLENTRY; count which DT this is -->
  <xsl:variable name="dtcount">
    <xsl:number count="*[contains(@class,' topic/dt ')]"/>
  </xsl:variable>
  <xsl:variable name="dt-class">
    <xsl:choose>
      <!-- handle non-compact list items -->
      <xsl:when test="$dtcount=1 and ../../@compact='no'">dltermexpand</xsl:when>
      <xsl:otherwise>dlterm</xsl:otherwise>
    </xsl:choose>
  </xsl:variable>
  <xsl:variable name="flagrules">
    <xsl:call-template name="getrules"/>
    <xsl:call-template name="getrules-parent"/>
  </xsl:variable>
  <dt class="{$dt-class}">
    <xsl:apply-templates select="../@xml:lang"/>
    <!-- Get from DLENTRY, then override with local -->
    <xsl:call-template name="commonattributes">
      <xsl:with-param name="default-output-class" select="$dt-class"/>
    </xsl:call-template>
    <xsl:call-template name="gen-style">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
    <xsl:call-template name="setidaname"/>
    <!-- handle ID on a DLENTRY -->
    <xsl:if test="$dtcount=1 and parent::*/@id">
      <xsl:call-template name="parent-id"/>
    </xsl:if>
    <!-- handle non-compact DLs dl/dlentry/dt-->
    <xsl:call-template name="start-flagit">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
    <xsl:call-template name="start-revflag-parent">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
    <xsl:call-template name="revtext">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
    <xsl:call-template name="end-revflag-parent">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
    <xsl:call-template name="end-flagit">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
    <xsl:apply-templates select="." mode="pull-in-title">
      <xsl:with-param name="type" select="' dt '"/>
      <xsl:with-param name="displaytext" select="normalize-space(text())"/>
    </xsl:apply-templates>
  </dt>
</xsl:template>
Template *[contains(@class,' topic/dt ')]topic.dt
Documentation

Description

 DL term 
Namespace No namespace
Match *[contains(@class,' topic/dt ')]
Mode #default
References
Parameters KEYREF-FILE; OUTEXT
Variable newline
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/dt ')]" name="topic.dt">
  <xsl:variable name="keys" select="@keyref"/>
  <xsl:choose>
    <xsl:when test="@keyref and document($KEYREF-FILE)//*[contains(@keys, $keys)]">
      <xsl:variable name="updatedTarget">
        <xsl:apply-templates select="." mode="find-keyref-target"/>
      </xsl:variable>
      <xsl:choose>
        <xsl:when test="normalize-space($updatedTarget)!=$OUTEXT">
          <a href="{$updatedTarget}">
            <xsl:apply-templates select="." mode="output-dt"/>
          </a>
        </xsl:when>
        <xsl:otherwise>
          <xsl:apply-templates select="." mode="output-dt"/>
        </xsl:otherwise>
      </xsl:choose>
    </xsl:when>
    <xsl:otherwise>
      <xsl:apply-templates select="." mode="output-dt"/>
    </xsl:otherwise>
  </xsl:choose>
  <xsl:value-of select="$newline"/>
</xsl:template>
Template *[contains(@class,' topic/dd ')]topic.dd
Documentation

Description

 DL description 
Namespace No namespace
Match *[contains(@class,' topic/dd ')]
Mode #default
References
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/dd ')]" name="topic.dd">
  <!-- insert a blank line before all but the first DD in a DLENTRY; count which DD this is -->
  <!-- SF Patch 2185423: condensed code so that dd processing is not repeated when $ddcount!=1 -->
  <xsl:variable name="ddcount">
    <xsl:number count="*[contains(@class,' topic/dd ')]"/>
  </xsl:variable>
  <xsl:variable name="flagrules">
    <xsl:call-template name="getrules"/>
  </xsl:variable>
  <dd>
    <xsl:if test="$ddcount!=1">
      <!-- para space before 2 thru N -->
      <xsl:attribute name="class">ddexpand</xsl:attribute>
    </xsl:if>
    <xsl:apply-templates select="../@xml:lang"/>
    <!-- Get from DLENTRY, then override with local -->
    <xsl:call-template name="commonattributes"/>
    <xsl:call-template name="gen-style">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
    <xsl:call-template name="setidaname"/>
    <xsl:call-template name="start-flagit">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
    <xsl:call-template name="start-revflag-parent">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
    <xsl:call-template name="revblock">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
    <xsl:call-template name="end-revflag-parent">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
    <xsl:call-template name="end-flagit">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
  </dd>
  <xsl:value-of select="$newline"/>
</xsl:template>
Template *[contains(@class, ' topic/dlhead ')]topic.dlhead
Documentation

Description

 DL heading 
Namespace No namespace
Match *[contains(@class, ' topic/dlhead ')]
Mode #default
Import precedence 4
Source
<xsl:template match="*[contains(@class, ' topic/dlhead ')]" name="topic.dlhead">
  <xsl:apply-templates/>
</xsl:template>
Template *[contains(@class,' topic/dthd ')]topic.dthd
Documentation

Description

 DL heading, term 
Namespace No namespace
Match *[contains(@class,' topic/dthd ')]
Mode #default
References
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/dthd ')]" name="topic.dthd">
  <xsl:variable name="flagrules">
    <xsl:call-template name="getrules"/>
  </xsl:variable>
  <dt>
    <xsl:apply-templates select="../@xml:lang"/>
    <!-- Get from DLHEAD, then override with local -->
    <xsl:call-template name="commonattributes"/>
    <xsl:call-template name="gen-style">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
    <xsl:call-template name="setidaname"/>
    <xsl:call-template name="start-flagit">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
    <xsl:call-template name="start-revflag-parent">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
    <strong>
      <xsl:call-template name="revtext">
        <xsl:with-param name="flagrules" select="$flagrules"/>
      </xsl:call-template>
    </strong>
    <xsl:call-template name="end-revflag-parent">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
    <xsl:call-template name="end-flagit">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
  </dt>
  <xsl:value-of select="$newline"/>
</xsl:template>
Template *[contains(@class,' topic/ddhd ')]topic.ddhd
Documentation

Description

 DL heading, description 
Namespace No namespace
Match *[contains(@class,' topic/ddhd ')]
Mode #default
References
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/ddhd ')]" name="topic.ddhd">
  <xsl:variable name="flagrules">
    <xsl:call-template name="getrules"/>
  </xsl:variable>
  <dd>
    <xsl:apply-templates select="../@xml:lang"/>
    <!-- Get from DLHEAD, then override with local -->
    <xsl:call-template name="commonattributes"/>
    <xsl:call-template name="gen-style">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
    <xsl:call-template name="setidaname"/>
    <xsl:call-template name="start-flagit">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
    <xsl:call-template name="start-revflag-parent">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
    <strong>
      <xsl:call-template name="revblock">
        <xsl:with-param name="flagrules" select="$flagrules"/>
      </xsl:call-template>
    </strong>
    <xsl:call-template name="end-revflag-parent">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
    <xsl:call-template name="end-flagit">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
  </dd>
  <xsl:value-of select="$newline"/>
</xsl:template>
Template *[contains(@class,' topic/ph ')]topic.ph
Documentation

Description

 =========== PHRASES =========== 
 phrase presentational style - have to use a low priority otherwise topic/ph always wins 
 should not need priority, default is low enough 
Namespace No namespace
Match *[contains(@class,' topic/ph ')]
Mode #default
References
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/ph ')]" name="topic.ph">
  <xsl:variable name="flagrules">
    <xsl:call-template name="getrules"/>
  </xsl:variable>
  <xsl:choose>
    <xsl:when test="@keyref">
      <xsl:apply-templates select="." mode="turning-to-link">
        <xsl:with-param name="keys" select="@keyref"/>
        <xsl:with-param name="flagrules" select="$flagrules"/>
        <xsl:with-param name="type" select="'ph'"/>
      </xsl:apply-templates>
    </xsl:when>
    <xsl:otherwise>
      <span>
        <xsl:call-template name="commonattributes"/>
        <xsl:call-template name="gen-style">
          <xsl:with-param name="flagrules" select="$flagrules"/>
        </xsl:call-template>
        <xsl:call-template name="setidaname"/>
        <xsl:call-template name="flagcheck"/>
        <xsl:call-template name="revtext">
          <xsl:with-param name="flagrules" select="$flagrules"/>
        </xsl:call-template>
      </span>
    </xsl:otherwise>
  </xsl:choose>
  <xsl:call-template name="add-br-for-empty-cmd"/>
</xsl:template>
Template add-br-for-empty-cmd
Namespace No namespace
Used by
Template topic.ph
Import precedence 4
Source
<xsl:template name="add-br-for-empty-cmd">
  <xsl:if test="contains(@class,' task/cmd ')">
    <xsl:variable name="text" select="text()"/>
    <xsl:if test="string-length(normalize-space($text))=0">
      <br/>
    </xsl:if>
  </xsl:if>
</xsl:template>
Template *[contains(@class,' topic/keyword ')]topic.keyword
Documentation

Description

 keyword presentational style - have to use priority else topic/keyword always wins 
 should not need priority, default is low enough 
Namespace No namespace
Match *[contains(@class,' topic/keyword ')]
Mode #default
References
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/keyword ')]" name="topic.keyword">
  <xsl:variable name="flagrules">
    <xsl:call-template name="getrules"/>
  </xsl:variable>
  <xsl:choose>
    <xsl:when test="@keyref">
      <xsl:apply-templates select="." mode="turning-to-link">
        <xsl:with-param name="keys" select="@keyref"/>
        <xsl:with-param name="flagrules" select="$flagrules"/>
        <xsl:with-param name="type" select="'keyword'"/>
      </xsl:apply-templates>
    </xsl:when>
    <xsl:otherwise>
      <span class="keyword">
        <xsl:call-template name="commonattributes"/>
        <xsl:call-template name="gen-style">
          <xsl:with-param name="flagrules" select="$flagrules"/>
        </xsl:call-template>
        <xsl:call-template name="setidaname"/>
        <xsl:call-template name="flagcheck"/>
        <xsl:call-template name="revtext">
          <xsl:with-param name="flagrules" select="$flagrules"/>
        </xsl:call-template>
      </span>
    </xsl:otherwise>
  </xsl:choose>
</xsl:template>
Template *[contains(@class,' topic/tm ')]topic.tm
Documentation

Description

 process the TM tag 
 removed priority 1 : should not be needed 
Namespace No namespace
Match *[contains(@class,' topic/tm ')]
Mode #default
References
Templates convert-to-lower; tm-area
Key tm
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/tm ')]" name="topic.tm">
  <xsl:apply-templates/>
  <!-- output the TM content -->
  <xsl:variable name="Ltmclass">
    <xsl:call-template name="convert-to-lower">
      <!-- ensure lowercase for comparisons -->
      <xsl:with-param name="inputval" select="@tmclass"/>
    </xsl:call-template>
  </xsl:variable>
  <!-- If this is a good class, continue... -->
  <xsl:if test="$Ltmclass='ibm' or $Ltmclass='ibmsub' or $Ltmclass='special'">
    <!-- Test for TM area's language -->
    <xsl:variable name="tmtest">
      <xsl:call-template name="tm-area"/>
    </xsl:variable>
    <!-- If this language should get trademark markers, continue... -->
    <xsl:if test="$tmtest='tm'">
      <xsl:variable name="tmvalue">
        <xsl:value-of select="@trademark"/>
      </xsl:variable>
      <!-- Determine if this is in a title, and should be marked -->
      <xsl:variable name="usetitle">
        <xsl:if test="ancestor::*[contains(@class,' topic/title ')]/parent::*[contains(@class,' topic/topic ')]">
          <xsl:choose>
            <!-- Not the first one in a title -->
            <xsl:when test="generate-id(.)!=generate-id(key('tm',.)[1])">skip</xsl:when>
            <!-- First one in the topic, BUT it appears in a shortdesc or body -->
            <xsl:when test="//*[contains(@class,' topic/shortdesc ') or contains(@class,' topic/body ')]//*[contains(@class,' topic/tm ')][@trademark=$tmvalue]">skip</xsl:when>
            <xsl:otherwise>use</xsl:otherwise>
          </xsl:choose>
        </xsl:if>
      </xsl:variable>
      <!-- Determine if this is in a body, and should be marked -->
      <xsl:variable name="usebody">
        <xsl:choose>
          <!-- If in a title or prolog, skip -->
          <xsl:when test="ancestor::*[contains(@class,' topic/title ') or contains(@class,' topic/prolog ')]/parent::*[contains(@class,' topic/topic ')]">skip</xsl:when>
          <!-- If first in the document, use it -->
          <xsl:when test="generate-id(.)=generate-id(key('tm',.)[1])">use</xsl:when>
          <!-- If there is another before this that is in the body or shortdesc, skip -->
          <xsl:when test="preceding::*[contains(@class,' topic/tm ')][@trademark=$tmvalue][ancestor::*[contains(@class,' topic/body ') or contains(@class,' topic/shortdesc ')]]">skip</xsl:when>
          <!-- Otherwise, any before this must be in a title or ignored section -->
          <xsl:otherwise>use</xsl:otherwise>
        </xsl:choose>
      </xsl:variable>
      <!-- If it should be used in a title or used in the body, output your favorite TM marker based on the attributes -->
      <xsl:if test="$usetitle='use' or $usebody='use'">
        <xsl:choose>
          <!-- ignore @tmtype=service or anything else -->
          <xsl:when test="@tmtype='tm'"></xsl:when>
          <xsl:when test="@tmtype='reg'">
            <sup>®</sup>
          </xsl:when>
          <xsl:otherwise/>
        </xsl:choose>
      </xsl:if>
    </xsl:if>
  </xsl:if>
</xsl:template>
Template tm-area
Documentation

Description

 Test for in TM area: returns "tm" when parent's @xml:lang needs a trademark language;
     Otherwise, leave blank.
     Use the TM for US English and the AP languages (Japanese, Korean, and both Chinese).
     Ignore the TM for all other languages. 
Namespace No namespace
Used by
Template topic.tm
References
Template getLowerCaseLang
Import precedence 4
Source
<xsl:template name="tm-area">
  <xsl:variable name="parentlang">
    <xsl:call-template name="getLowerCaseLang"/>
  </xsl:variable>
  <xsl:choose>
    <xsl:when test="$parentlang='en-us' or $parentlang='en'">tm</xsl:when>
    <xsl:when test="$parentlang='ja-jp' or $parentlang='ja'">tm</xsl:when>
    <xsl:when test="$parentlang='ko-kr' or $parentlang='ko'">tm</xsl:when>
    <xsl:when test="$parentlang='zh-cn' or $parentlang='zh'">tm</xsl:when>
    <xsl:when test="$parentlang='zh-tw' or $parentlang='zh'">tm</xsl:when>
    <xsl:otherwise/>
  </xsl:choose>
</xsl:template>
Template *[contains(@class,' topic/cite ')]topic.cite
Documentation

Description

 phrase "semantic" classes 
 citations 
Namespace No namespace
Match *[contains(@class,' topic/cite ')]
Mode #default
References
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/cite ')]" name="topic.cite">
  <xsl:variable name="flagrules">
    <xsl:call-template name="getrules"/>
  </xsl:variable>
  <xsl:choose>
    <xsl:when test="@keyref">
      <xsl:apply-templates select="." mode="turning-to-link">
        <xsl:with-param name="keys" select="@keyref"/>
        <xsl:with-param name="flagrules" select="$flagrules"/>
        <xsl:with-param name="type" select="'cite'"/>
      </xsl:apply-templates>
    </xsl:when>
    <xsl:otherwise>
      <cite>
        <xsl:call-template name="commonattributes"/>
        <xsl:call-template name="gen-style">
          <xsl:with-param name="flagrules" select="$flagrules"/>
        </xsl:call-template>
        <xsl:call-template name="setidaname"/>
        <xsl:call-template name="flagcheck"/>
        <xsl:call-template name="revtext">
          <xsl:with-param name="flagrules" select="$flagrules"/>
        </xsl:call-template>
      </cite>
    </xsl:otherwise>
  </xsl:choose>
</xsl:template>
Template *[contains(@class,' topic/q ')]topic.q
Documentation

Description

 quotes - only do 1 level, no flip-flopping 
Namespace No namespace
Match *[contains(@class,' topic/q ')]
Mode #default
References
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/q ')]" name="topic.q">
  <xsl:variable name="flagrules">
    <xsl:call-template name="getrules"/>
  </xsl:variable>
  <span class="q">
    <xsl:call-template name="commonattributes"/>
    <xsl:call-template name="gen-style">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
    <xsl:call-template name="getString">
      <xsl:with-param name="stringName" select="'OpenQuote'"/>
    </xsl:call-template>
    <xsl:call-template name="flagcheck"/>
    <xsl:call-template name="revtext">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
    <xsl:call-template name="getString">
      <xsl:with-param name="stringName" select="'CloseQuote'"/>
    </xsl:call-template>
  </span>
</xsl:template>
Template *[contains(@class,' topic/term ')]output-term
Namespace No namespace
Match *[contains(@class,' topic/term ')]
Mode output-term
References
Parameters
QName Namespace Select
displaytext No namespace ''
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/term ')]" mode="output-term">
  <xsl:param name="displaytext" select="''"/>
  <xsl:variable name="flagrules">
    <xsl:call-template name="getrules"/>
  </xsl:variable>
  <dfn class="term">
    <xsl:call-template name="commonattributes"/>
    <xsl:call-template name="gen-style">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
    <xsl:call-template name="setidaname"/>
    <xsl:call-template name="flagcheck"/>
    <xsl:call-template name="revtext">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
    <xsl:apply-templates select="." mode="pull-in-title">
      <xsl:with-param name="type" select="' term '"/>
      <xsl:with-param name="displaytext" select="normalize-space($displaytext)"/>
    </xsl:apply-templates>
  </dfn>
</xsl:template>
Template getMatchingTarget
Documentation

Description

 Templates for internal usage in terms/abbreviation resolving 
Namespace No namespace
Used by
Template topic.term
References
Parameter DEFAULTLANG
Parameters
QName Namespace Select
m_entry-file-contents No namespace
m_glossid No namespace ''
m_reflang No namespace en_US
Import precedence 4
Source
<xsl:template name="getMatchingTarget" xmlns:exsl="http://exslt.org/common">
  <xsl:param name="m_glossid" select="''"/>
  <xsl:param name="m_entry-file-contents"/>
  <xsl:param name="m_reflang" select="en_US"/>
  <xsl:choose>
    <xsl:when test="$m_glossid='' and $m_entry-file-contents//*[contains(@class, ' glossentry/glossentry ')][lang($m_reflang)]">
      <xsl:copy-of select="$m_entry-file-contents//*[contains(@class, ' glossentry/glossentry ')][lang($m_reflang)]"/>
    </xsl:when>
    <xsl:when test="not($m_glossid='') and $m_entry-file-contents//*[contains(@class, ' glossentry/glossentry ')][@id=$m_glossid][lang($m_reflang)]">
      <xsl:copy-of select="$m_entry-file-contents//*[contains(@class, ' glossentry/glossentry ')][@id=$m_glossid][lang($m_reflang)]"/>
    </xsl:when>
    <xsl:when test="$m_glossid='' and $m_entry-file-contents//*[contains(@class, ' glossentry/glossentry ')][lang($DEFAULTLANG)]">
      <xsl:copy-of select="$m_entry-file-contents//*[contains(@class, ' glossentry/glossentry ')][lang($DEFAULTLANG)]"/>
    </xsl:when>
    <xsl:when test="not($m_glossid='') and $m_entry-file-contents//*[contains(@class, ' glossentry/glossentry ')][@id=$m_glossid][lang($DEFAULTLANG)]">
      <xsl:copy-of select="$m_entry-file-contents//*[contains(@class, ' glossentry/glossentry ')][@id=$m_glossid][lang($DEFAULTLANG)]"/>
    </xsl:when>
    <xsl:when test="$m_glossid='' and $m_entry-file-contents//*[contains(@class, ' glossentry/glossentry ')][not(@xml:lang) or normalize-space(@xml:lang)='']">
      <xsl:copy-of select="$m_entry-file-contents//*[contains(@class, ' glossentry/glossentry ')][not(@xml:lang) or normalize-space(@xml:lang)=''][1]"/>
    </xsl:when>
    <xsl:when test="not($m_glossid='') and $m_entry-file-contents//*[contains(@class, ' glossentry/glossentry ')][@id=$m_glossid][not(@xml:lang) or normalize-space(@xml:lang)='']">
      <xsl:copy-of select="$m_entry-file-contents//*[contains(@class, ' glossentry/glossentry ')][@id=$m_glossid][not(@xml:lang) or normalize-space(@xml:lang)=''][1]"/>
    </xsl:when>
    <xsl:otherwise>
      <xsl:value-of select="'#none#'"/>
    </xsl:otherwise>
  </xsl:choose>
</xsl:template>
Template *getMatchingSurfaceForm
Namespace No namespace
Match *
Mode getMatchingSurfaceForm
Parameters
QName Namespace
m_keys No namespace
m_matched-target No namespace
Import precedence 4
Source
<xsl:template match="*" mode="getMatchingSurfaceForm" xmlns:exsl="http://exslt.org/common">
  <xsl:param name="m_matched-target"/>
  <xsl:param name="m_keys"/>
  <xsl:choose>
    <xsl:when test="not($m_matched-target='#none#')">
      <xsl:choose>
        <xsl:when test="exsl:node-set($m_matched-target)/*[contains(@class, ' glossentry/glossentry ')][1]//*[contains(@class, ' glossentry/glossSurfaceForm ')][normalize-space(text())!='']">
          <xsl:value-of select="exsl:node-set($m_matched-target)/*[contains(@class, ' glossentry/glossentry ')][1]//*[contains(@class, ' glossentry/glossSurfaceForm ')][normalize-space(text())!='']"/>
        </xsl:when>
        <xsl:otherwise>
          <xsl:value-of select="exsl:node-set($m_matched-target)/*[contains(@class, ' glossentry/glossentry ')][1]//*[contains(@class, ' glossentry/glossterm ')][normalize-space(text())!='']"/>
        </xsl:otherwise>
      </xsl:choose>
    </xsl:when>
    <xsl:otherwise>
      <xsl:apply-templates select="." mode="ditamsg:no-glossentry-for-key">
        <xsl:with-param name="matching-keys" select="$m_keys"/>
      </xsl:apply-templates>
    </xsl:otherwise>
  </xsl:choose>
</xsl:template>
Template *getMatchingAcronym
Namespace No namespace
Match *
Mode getMatchingAcronym
Parameters
QName Namespace
m_keys No namespace
m_matched-target No namespace
Import precedence 4
Source
<xsl:template match="*" mode="getMatchingAcronym" xmlns:exsl="http://exslt.org/common">
  <xsl:param name="m_matched-target"/>
  <xsl:param name="m_keys"/>
  <xsl:choose>
    <xsl:when test="not($m_matched-target='#none#')">
      <xsl:choose>
        <xsl:when test="exsl:node-set($m_matched-target)/*[contains(@class, ' glossentry/glossentry ')][1]//*[contains(@class, ' glossentry/glossStatus ')][@value='preferred'][1]/preceding-sibling::*[contains(@class, ' glossentry/glossAcronym ') or contains(@class, ' glossentry/glossAbbreviation ')][normalize-space(text())!='']">
          <xsl:value-of select="exsl:node-set($m_matched-target)/*[contains(@class, ' glossentry/glossentry ')][1]//*[contains(@class, ' glossentry/glossStatus ')][@value='preferred'][1]/preceding-sibling::*[contains(@class, ' glossentry/glossAcronym ') or contains(@class, ' glossentry/glossAbbreviation ')][normalize-space(text())!='']"/>
        </xsl:when>
        <xsl:when test="exsl:node-set($m_matched-target)/*[contains(@class, ' glossentry/glossentry ')][1]//*[contains(@class, ' glossentry/glossStatus ')][@value!='prohibited'][@value!='obsolete'][1]/preceding-sibling::*[contains(@class, ' glossentry/glossAcronym ') or contains(@class, ' glossentry/glossAbbreviation ')][normalize-space(text())!='']">
          <xsl:value-of select="exsl:node-set($m_matched-target)/*[contains(@class, ' glossentry/glossentry ')][1]//*[contains(@class, ' glossentry/glossStatus ')][@value!='prohibited'][@value!='obsolete'][1]/preceding-sibling::*[contains(@class, ' glossentry/glossAcronym ') or contains(@class, ' glossentry/glossAbbreviation ')][normalize-space(text())!='']"/>
        </xsl:when>
        <xsl:when test="exsl:node-set($m_matched-target)/*[contains(@class, ' glossentry/glossentry ')][1]//*[contains(@class, ' glossentry/glossAlt ')][1]/*[contains(@class, ' glossentry/glossAcronym ') or contains(@class, ' glossentry/glossAbbreviation ')][count(following-sibling::glossStatus)=0][normalize-space(text())!='']">
          <xsl:value-of select="exsl:node-set($m_matched-target)/*[contains(@class, ' glossentry/glossentry ')][1]//*[contains(@class, ' glossentry/glossAlt ')][1]/*[contains(@class, ' glossentry/glossAcronym ') or contains(@class, ' glossentry/glossAbbreviation ')][count(following-sibling::glossStatus)=0][normalize-space(text())!='']"/>
        </xsl:when>
        <xsl:otherwise>
          <xsl:value-of select="exsl:node-set($m_matched-target)/*[contains(@class, ' glossentry/glossentry ')][1]/*[contains(@class, ' glossentry/glossterm ')][normalize-space(text())!='']"/>
        </xsl:otherwise>
      </xsl:choose>
    </xsl:when>
    <xsl:otherwise>
      <!-- No matching entries found with reference language or default language. -->
      <xsl:apply-templates select="." mode="ditamsg:no-glossentry-for-key">
        <xsl:with-param name="matching-keys" select="$m_keys"/>
      </xsl:apply-templates>
    </xsl:otherwise>
  </xsl:choose>
</xsl:template>
Template *[contains(@class,' topic/term ')]topic.term
Documentation

Description

 terms and abbreviated-forms 
Namespace No namespace
Match *[contains(@class,' topic/term ')]
Mode #default
Used by
References
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/term ')]" name="topic.term">
  <xsl:variable name="keys" select="@keyref"/>
  <xsl:choose>
    <xsl:when test="@keyref and document($KEYREF-FILE)//*[@keys=$keys][normalize-space(@href)!='']/@href">
      <xsl:variable name="target">
        <xsl:value-of select="document($KEYREF-FILE)//*[@keys=$keys][normalize-space(@href)!='']/@href"/>
      </xsl:variable>
      <xsl:variable name="updatedTarget">
        <xsl:apply-templates select="." mode="find-keyref-target"/>
      </xsl:variable>
      <xsl:variable name="entry-file" select="concat($WORKDIR, $PATH2PROJ, substring-before($target, '.'), $DITAEXT)"/>
      <!-- Save glossary entry file contents into a variable to workaround the infamous putDocumentCache error in Xalan -->
      <xsl:variable name="entry-file-contents" select="document($entry-file, /)"/>
      <!-- Glossary id defined in <glossentry> -->
      <xsl:variable name="glossid">
        <xsl:value-of select="substring-after($updatedTarget, '#')"/>
      </xsl:variable>
      <!--
          Language preference.
          NOTE: glossid overrides language preference.
      -->
      <xsl:variable name="reflang">
        <xsl:call-template name="getLowerCaseLang"/>
      </xsl:variable>
      <xsl:variable name="matched-target">
        <xsl:call-template name="getMatchingTarget">
          <xsl:with-param name="m_entry-file-contents" select="$entry-file-contents"/>
          <xsl:with-param name="m_glossid" select="$glossid"/>
          <xsl:with-param name="m_reflang" select="$reflang"/>
        </xsl:call-template>
      </xsl:variable>
      <!-- End: Language preference. -->
      <!-- Text should be displayed -->
      <xsl:variable name="displaytext">
        <xsl:choose>
          <xsl:when test="normalize-space(text())!=''">
            <xsl:value-of select="normalize-space(text())"/>
          </xsl:when>
          <xsl:otherwise>
            <xsl:choose>
              <xsl:when test="boolean(ancestor::*[contains(@class,' topic/copyright ')]) or generate-id(.)=generate-id(key('keyref',@keyref)[1])">
                <xsl:apply-templates select="." mode="getMatchingSurfaceForm">
                  <xsl:with-param name="m_matched-target" select="$matched-target"/>
                  <xsl:with-param name="m_keys" select="$keys"/>
                </xsl:apply-templates>
              </xsl:when>
              <xsl:otherwise>
                <xsl:apply-templates select="." mode="getMatchingAcronym">
                  <xsl:with-param name="m_matched-target" select="$matched-target"/>
                  <xsl:with-param name="m_keys" select="$keys"/>
                </xsl:apply-templates>
              </xsl:otherwise>
            </xsl:choose>
          </xsl:otherwise>
        </xsl:choose>
      </xsl:variable>
      <!-- End of displaytext -->
      <!-- hovertip text -->
      <xsl:variable name="hovertext">
        <xsl:apply-templates select="." mode="getMatchingSurfaceForm">
          <xsl:with-param name="m_matched-target" select="$matched-target"/>
          <xsl:with-param name="m_keys" select="$keys"/>
        </xsl:apply-templates>
      </xsl:variable>
      <!-- End of hovertip text -->
      <xsl:choose>
        <xsl:when test="not(normalize-space($updatedTarget)=$OUTEXT)">
          <a href="{$updatedTarget}" title="{$hovertext}">
            <xsl:apply-templates select="." mode="output-term">
              <xsl:with-param name="displaytext" select="normalize-space($displaytext)"/>
            </xsl:apply-templates>
          </a>
        </xsl:when>
        <xsl:otherwise>
          <xsl:apply-templates select="." mode="output-term">
            <xsl:with-param name="displaytext" select="normalize-space($displaytext)"/>
          </xsl:apply-templates>
        </xsl:otherwise>
      </xsl:choose>
    </xsl:when>
    <xsl:otherwise>
      <xsl:apply-templates select="." mode="output-term">
        <xsl:with-param name="displaytext" select="normalize-space(text())"/>
      </xsl:apply-templates>
    </xsl:otherwise>
  </xsl:choose>
</xsl:template>
Template *[contains(@class,' topic/boolean ')]topic.boolean
Documentation

Description

 =========== BOOLEAN-STATE DATA TYPES =========== 
 Use color to indicate these types for now 
 output the tag & it's state 
Namespace No namespace
Match *[contains(@class,' topic/boolean ')]
Mode #default
References
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/boolean ')]" name="topic.boolean">
  <span style="color:green">
    <xsl:call-template name="commonattributes"/>
    <xsl:call-template name="setidaname"/>
    <xsl:value-of select="name()"/>
    <xsl:text>: </xsl:text>
    <xsl:value-of select="@state"/>
  </span>
</xsl:template>
Template *[contains(@class,' topic/state ')]topic.state
Documentation

Description

 output the tag, it's name & value 
Namespace No namespace
Match *[contains(@class,' topic/state ')]
Mode #default
References
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/state ')]" name="topic.state">
  <span style="color:red">
    <xsl:call-template name="commonattributes"/>
    <xsl:call-template name="setidaname"/>
    <xsl:value-of select="name()"/>
    <xsl:text>: </xsl:text>
    <xsl:value-of select="@name"/>
    <xsl:text>=</xsl:text>
    <xsl:value-of select="@value"/>
  </span>
</xsl:template>
Template *[contains(@class,' topic/pre ')]topic.pre
Documentation

Description

 =========== RECORD END RESPECTING DATA =========== 
 PRE 
Namespace No namespace
Match *[contains(@class,' topic/pre ')]
Mode #default
References
Parameters DRAFT; FILTERFILE
Template find-active-rev-flag
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/pre ')]" name="topic.pre">
  <xsl:variable name="revtest">
    <xsl:if test="@rev and not($FILTERFILE='') and ($DRAFT='yes')">
      <xsl:call-template name="find-active-rev-flag">
        <xsl:with-param name="allrevs" select="@rev"/>
      </xsl:call-template>
    </xsl:if>
  </xsl:variable>
  <xsl:choose>
    <xsl:when test="$revtest=1">
      <!-- Rev is active - add the DIV -->
      <div class="{@rev}">
        <xsl:apply-templates select="." mode="pre-fmt"/>
      </div>
    </xsl:when>
    <xsl:otherwise>
      <!-- Rev wasn't active - process normally -->
      <xsl:apply-templates select="." mode="pre-fmt"/>
    </xsl:otherwise>
  </xsl:choose>
</xsl:template>
Template *[contains(@class,' topic/pre ')]pre-fmt
Namespace No namespace
Match *[contains(@class,' topic/pre ')]
Mode pre-fmt
References
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/pre ')]" mode="pre-fmt">
  <xsl:variable name="flagrules">
    <xsl:call-template name="getrules"/>
  </xsl:variable>
  <xsl:if test="contains(@frame,'top')">
    <hr/>
  </xsl:if>
  <xsl:call-template name="start-flagit">
    <xsl:with-param name="flagrules" select="$flagrules"/>
  </xsl:call-template>
  <xsl:call-template name="start-revflag">
    <xsl:with-param name="flagrules" select="$flagrules"/>
  </xsl:call-template>
  <xsl:call-template name="spec-title-nospace"/>
  <pre>
    <xsl:attribute name="class">
      <xsl:value-of select="name()"/>
    </xsl:attribute>
    <xsl:call-template name="commonattributes"/>
    <xsl:call-template name="gen-style">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
    <xsl:call-template name="setscale"/>
    <xsl:call-template name="setidaname"/>
    <xsl:apply-templates/>
  </pre>
  <xsl:call-template name="end-revflag">
    <xsl:with-param name="flagrules" select="$flagrules"/>
  </xsl:call-template>
  <xsl:call-template name="end-flagit">
    <xsl:with-param name="flagrules" select="$flagrules"/>
  </xsl:call-template>
  <xsl:if test="contains(@frame,'bot')">
    <hr/>
  </xsl:if>
  <xsl:value-of select="$newline"/>
</xsl:template>
Template *[contains(@class,' topic/lines ')]topic.lines
Documentation

Description

 lines - body font 
Namespace No namespace
Match *[contains(@class,' topic/lines ')]
Mode #default
References
Parameters DRAFT; FILTERFILE
Template find-active-rev-flag
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/lines ')]" name="topic.lines">
  <xsl:variable name="revtest">
    <xsl:if test="@rev and not($FILTERFILE='') and ($DRAFT='yes')">
      <xsl:call-template name="find-active-rev-flag">
        <xsl:with-param name="allrevs" select="@rev"/>
      </xsl:call-template>
    </xsl:if>
  </xsl:variable>
  <xsl:choose>
    <xsl:when test="$revtest=1">
      <!-- Rev is active - add the DIV -->
      <div class="{@rev}">
        <xsl:apply-templates select="." mode="lines-fmt"/>
      </div>
    </xsl:when>
    <xsl:otherwise>
      <!-- Rev wasn't active - process normally -->
      <xsl:apply-templates select="." mode="lines-fmt"/>
    </xsl:otherwise>
  </xsl:choose>
</xsl:template>
Template *[contains(@class,' topic/lines ')]lines-fmt
Namespace No namespace
Match *[contains(@class,' topic/lines ')]
Mode lines-fmt
References
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/lines ')]" mode="lines-fmt">
  <xsl:variable name="flagrules">
    <xsl:call-template name="getrules"/>
  </xsl:variable>
  <xsl:if test="contains(@frame,'top')">
    <hr/>
  </xsl:if>
  <xsl:call-template name="start-flagit">
    <xsl:with-param name="flagrules" select="$flagrules"/>
  </xsl:call-template>
  <xsl:call-template name="start-revflag">
    <xsl:with-param name="flagrules" select="$flagrules"/>
  </xsl:call-template>
  <xsl:call-template name="spec-title-nospace"/>
  <p>
    <xsl:call-template name="commonattributes"/>
    <xsl:call-template name="gen-style">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
    <xsl:call-template name="setscale"/>
    <xsl:call-template name="setidaname"/>
    <xsl:apply-templates/>
  </p>
  <xsl:call-template name="end-revflag">
    <xsl:with-param name="flagrules" select="$flagrules"/>
  </xsl:call-template>
  <xsl:call-template name="end-flagit">
    <xsl:with-param name="flagrules" select="$flagrules"/>
  </xsl:call-template>
  <xsl:if test="contains(@frame,'bot')">
    <hr/>
  </xsl:if>
  <xsl:value-of select="$newline"/>
</xsl:template>
Template *[contains(@class,' topic/lines ')]//text()
Namespace No namespace
Match *[contains(@class,' topic/lines ')]//text()
Mode #default
References
Templates br-replace; sp-replace
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/lines ')]//text()">
  <xsl:variable name="linetext">
    <xsl:value-of select="."/>
  </xsl:variable>
  <xsl:variable name="linetext2">
    <xsl:call-template name="sp-replace">
      <xsl:with-param name="sptext" select="$linetext"/>
    </xsl:call-template>
  </xsl:variable>
  <xsl:call-template name="br-replace">
    <xsl:with-param name="brtext" select="$linetext2"/>
  </xsl:call-template>
</xsl:template>
Template *[contains(@class,' topic/fig ')]topic.fig
Documentation

Description

 =========== FIGURE =========== 
Namespace No namespace
Match *[contains(@class,' topic/fig ')]
Mode #default
References
Parameters DRAFT; FILTERFILE
Template find-active-rev-flag
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/fig ')]" name="topic.fig">
  <xsl:variable name="revtest">
    <xsl:if test="@rev and not($FILTERFILE='') and ($DRAFT='yes')">
      <xsl:call-template name="find-active-rev-flag">
        <xsl:with-param name="allrevs" select="@rev"/>
      </xsl:call-template>
    </xsl:if>
  </xsl:variable>
  <xsl:choose>
    <xsl:when test="$revtest=1">
      <!-- Rev is active - add the DIV -->
      <div class="{@rev}">
        <xsl:apply-templates select="." mode="fig-fmt"/>
      </div>
    </xsl:when>
    <xsl:otherwise>
      <!-- Rev wasn't active - process normally -->
      <xsl:apply-templates select="." mode="fig-fmt"/>
    </xsl:otherwise>
  </xsl:choose>
</xsl:template>
Template *{http://dita-ot.sourceforge.net/ns/200801/dita2html}get-default-fig-class
Documentation

Description

 Determine the default XHTML class attribute for a figure 
Namespace No namespace
Match *
Mode {http://dita-ot.sourceforge.net/ns/200801/dita2html}get-default-fig-class
Import precedence 4
Source
<xsl:template match="*" mode="dita2html:get-default-fig-class">
  <xsl:choose>
    <xsl:when test="@frame='all'">figborder</xsl:when>
    <xsl:when test="@frame='sides'">figsides</xsl:when>
    <xsl:when test="@frame='top'">figtop</xsl:when>
    <xsl:when test="@frame='bottom'">figbottom</xsl:when>
    <xsl:when test="@frame='topbot'">figtopbot</xsl:when>
    <xsl:otherwise>fignone</xsl:otherwise>
  </xsl:choose>
</xsl:template>
Template *[contains(@class,' topic/fig ')]fig-fmt
Namespace No namespace
Match *[contains(@class,' topic/fig ')]
Mode fig-fmt
References
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/fig ')]" mode="fig-fmt">
  <xsl:variable name="default-fig-class">
    <xsl:apply-templates select="." mode="dita2html:get-default-fig-class"/>
  </xsl:variable>
  <xsl:variable name="flagrules">
    <xsl:call-template name="getrules"/>
  </xsl:variable>
  <xsl:call-template name="start-flagit">
    <xsl:with-param name="flagrules" select="$flagrules"/>
  </xsl:call-template>
  <xsl:call-template name="start-revflag">
    <xsl:with-param name="flagrules" select="$flagrules"/>
  </xsl:call-template>
  <div>
    <xsl:if test="$default-fig-class!=''">
      <xsl:attribute name="class">
        <xsl:value-of select="$default-fig-class"/>
      </xsl:attribute>
    </xsl:if>
    <xsl:call-template name="commonattributes">
      <xsl:with-param name="default-output-class" select="$default-fig-class"/>
    </xsl:call-template>
    <xsl:call-template name="gen-style">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
    <xsl:call-template name="setscale"/>
    <xsl:call-template name="setidaname"/>
    <xsl:call-template name="place-fig-lbl"/>
    <xsl:apply-templates select="*[not(contains(@class,' topic/title '))][not(contains(@class,' topic/desc '))] |text()|comment()|processing-instruction()"/>
  </div>
  <xsl:call-template name="end-revflag">
    <xsl:with-param name="flagrules" select="$flagrules"/>
  </xsl:call-template>
  <xsl:call-template name="end-flagit">
    <xsl:with-param name="flagrules" select="$flagrules"/>
  </xsl:call-template>
  <xsl:value-of select="$newline"/>
</xsl:template>
Template *[contains(@class,' topic/figgroup ')]topic.figgroup
Documentation

Description

 should not need priority, default is low enough; was set to 1 
Namespace No namespace
Match *[contains(@class,' topic/figgroup ')]
Mode #default
References
Parameters DRAFT; FILTERFILE
Template find-active-rev-flag
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/figgroup ')]" name="topic.figgroup">
  <xsl:variable name="revtest">
    <xsl:if test="@rev and not($FILTERFILE='') and ($DRAFT='yes')">
      <xsl:call-template name="find-active-rev-flag">
        <xsl:with-param name="allrevs" select="@rev"/>
      </xsl:call-template>
    </xsl:if>
  </xsl:variable>
  <xsl:choose>
    <xsl:when test="$revtest=1">
      <!-- Rev is active - add the DIV -->
      <div class="{@rev}">
        <xsl:apply-templates select="." mode="figgroup-fmt"/>
      </div>
    </xsl:when>
    <xsl:otherwise>
      <!-- Rev wasn't active - process normally -->
      <xsl:apply-templates select="." mode="figgroup-fmt"/>
    </xsl:otherwise>
  </xsl:choose>
</xsl:template>
Template *[contains(@class,' topic/figgroup ')]figgroup-fmt
Namespace No namespace
Match *[contains(@class,' topic/figgroup ')]
Mode figgroup-fmt
References
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/figgroup ')]" mode="figgroup-fmt">
  <xsl:variable name="flagrules">
    <xsl:call-template name="getrules"/>
  </xsl:variable>
  <xsl:call-template name="start-flagit">
    <xsl:with-param name="flagrules" select="$flagrules"/>
  </xsl:call-template>
  <xsl:call-template name="start-revflag">
    <xsl:with-param name="flagrules" select="$flagrules"/>
  </xsl:call-template>
  <span>
    <xsl:call-template name="commonattributes"/>
    <xsl:call-template name="gen-style">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
    <xsl:call-template name="setidaname"/>
    <!-- Allow title to fallthrough -->
    <xsl:apply-templates/>
  </span>
  <xsl:call-template name="end-revflag">
    <xsl:with-param name="flagrules" select="$flagrules"/>
  </xsl:call-template>
  <xsl:call-template name="end-flagit">
    <xsl:with-param name="flagrules" select="$flagrules"/>
  </xsl:call-template>
</xsl:template>
Template *[contains(@class,' topic/image ')]topic.image
Documentation

Description

 =========== IMAGE/OBJECT =========== 
Namespace No namespace
Match *[contains(@class,' topic/image ')]
Mode #default
References
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/image ')]" name="topic.image">
  <xsl:variable name="flagrules">
    <xsl:call-template name="getrules"/>
  </xsl:variable>
  <!-- build any pre break indicated by style -->
  <xsl:choose>
    <xsl:when test="parent::fig[contains(@frame,'top ')]">
      <!-- NOP if there is already a break implied by a parent property -->
    </xsl:when>
    <xsl:otherwise>
      <xsl:choose>
        <xsl:when test="(@placement='break')">
          <br/>
          <xsl:call-template name="start-flagit">
            <xsl:with-param name="flagrules" select="$flagrules"/>
          </xsl:call-template>
        </xsl:when>
        <xsl:otherwise>
          <xsl:call-template name="flagcheck"/>
        </xsl:otherwise>
      </xsl:choose>
    </xsl:otherwise>
  </xsl:choose>
  <xsl:call-template name="start-revflag">
    <xsl:with-param name="flagrules" select="$flagrules"/>
  </xsl:call-template>
  <xsl:call-template name="setaname"/>
  <xsl:choose>
    <xsl:when test="@placement='break'">
      <!--Align only works for break-->
      <xsl:choose>
        <xsl:when test="@align='left'">
          <div class="imageleft">
            <xsl:call-template name="topic-image"/>
          </div>
        </xsl:when>
        <xsl:when test="@align='right'">
          <div class="imageright">
            <xsl:call-template name="topic-image"/>
          </div>
        </xsl:when>
        <xsl:when test="@align='center'">
          <div class="imagecenter">
            <xsl:call-template name="topic-image"/>
          </div>
        </xsl:when>
        <xsl:otherwise>
          <xsl:call-template name="topic-image"/>
        </xsl:otherwise>
      </xsl:choose>
    </xsl:when>
    <xsl:otherwise>
      <xsl:call-template name="topic-image"/>
    </xsl:otherwise>
  </xsl:choose>
  <xsl:call-template name="end-revflag">
    <xsl:with-param name="flagrules" select="$flagrules"/>
  </xsl:call-template>
  <xsl:call-template name="end-flagit">
    <xsl:with-param name="flagrules" select="$flagrules"/>
  </xsl:call-template>
  <!-- build any post break indicated by style -->
  <xsl:if test="not(@placement='inline')">
    <br/>
  </xsl:if>
  <!-- image name for review -->
  <xsl:if test="$ARTLBL='yes'">[
    <xsl:value-of select="@href"/>]</xsl:if>
</xsl:template>
Template topic-image
Namespace No namespace
Used by
Template topic.image
References
Templates commonattributes; setid
Import precedence 4
Source
<xsl:template name="topic-image">
  <!-- now invoke the actual content and its alt text -->
  <xsl:element name="img">
    <xsl:call-template name="commonattributes">
      <xsl:with-param name="default-output-class">
        <xsl:if test="@placement='break'">
          <!--Align only works for break-->
          <xsl:choose>
            <xsl:when test="@align='left'">imageleft</xsl:when>
            <xsl:when test="@align='right'">imageright</xsl:when>
            <xsl:when test="@align='center'">imagecenter</xsl:when>
          </xsl:choose>
        </xsl:if>
      </xsl:with-param>
    </xsl:call-template>
    <xsl:call-template name="setid"/>
    <xsl:choose>
      <xsl:when test="*[contains(@class, ' topic/longdescref ')]">
        <xsl:apply-templates select="*[contains(@class, ' topic/longdescref ')]"/>
      </xsl:when>
      <xsl:otherwise>
        <xsl:apply-templates select="@longdescref"/>
      </xsl:otherwise>
    </xsl:choose>
    <xsl:apply-templates select="@href|@height|@width"/>
    <xsl:choose>
      <xsl:when test="*[contains(@class,' topic/alt ')]">
        <xsl:variable name="alt-content">
          <xsl:apply-templates select="*[contains(@class,' topic/alt ')]" mode="text-only"/>
        </xsl:variable>
        <xsl:attribute name="alt">
          <xsl:value-of select="normalize-space($alt-content)"/>
        </xsl:attribute>
      </xsl:when>
      <xsl:when test="@alt">
        <xsl:attribute name="alt">
          <xsl:value-of select="@alt"/>
        </xsl:attribute>
      </xsl:when>
    </xsl:choose>
  </xsl:element>
</xsl:template>
Template *[contains(@class,' topic/alt ')]
Namespace No namespace
Match *[contains(@class,' topic/alt ')]
Mode #default
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/alt ')]">
  <xsl:apply-templates select="." mode="text-only"/>
</xsl:template>
Template *[contains(@class,' topic/image ')]/@href
Documentation

Description

 Process image attributes. Using priority, in case default @href is added at some point. 
 20090303: Removed priority; does not appear to be needed. 
Namespace No namespace
Match *[contains(@class,' topic/image ')]/@href
Mode #default
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/image ')]/@href">
  <xsl:attribute name="src">
    <xsl:value-of select="."/>
  </xsl:attribute>
</xsl:template>
Template *[contains(@class,' topic/image ')]/@height
Namespace No namespace
Match *[contains(@class,' topic/image ')]/@height
Mode #default
References
Template length-to-pixels
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/image ')]/@height">
  <xsl:variable name="height-in-pixel">
    <xsl:call-template name="length-to-pixels">
      <xsl:with-param name="dimen" select="."/>
    </xsl:call-template>
  </xsl:variable>
  <xsl:if test="not($height-in-pixel='100%')">
    <xsl:attribute name="height">
      <xsl:choose>
        <xsl:when test="../@scale and string(number(../@scale))!='NaN'">
          <xsl:value-of select="number($height-in-pixel) * number(../@scale)"/>
        </xsl:when>
        <xsl:otherwise>
          <xsl:value-of select="number($height-in-pixel)"/>
        </xsl:otherwise>
      </xsl:choose>
    </xsl:attribute>
  </xsl:if>
</xsl:template>
Template *[contains(@class,' topic/image ')]/@width
Namespace No namespace
Match *[contains(@class,' topic/image ')]/@width
Mode #default
References
Template length-to-pixels
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/image ')]/@width">
  <xsl:variable name="width-in-pixel">
    <xsl:call-template name="length-to-pixels">
      <xsl:with-param name="dimen" select="."/>
    </xsl:call-template>
  </xsl:variable>
  <xsl:if test="not($width-in-pixel = '100%')">
    <xsl:attribute name="width">
      <xsl:choose>
        <xsl:when test="../@scale and string(number(../@scale))!='NaN'">
          <xsl:value-of select="number($width-in-pixel) * number(../@scale)"/>
        </xsl:when>
        <xsl:otherwise>
          <xsl:value-of select="number($width-in-pixel)"/>
        </xsl:otherwise>
      </xsl:choose>
    </xsl:attribute>
  </xsl:if>
</xsl:template>
Template *[contains(@class,' topic/image ')]/@longdescref
Namespace No namespace
Match *[contains(@class,' topic/image ')]/@longdescref
Mode #default
References
Parameters DITAEXT; OUTEXT
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/image ')]/@longdescref">
  <xsl:attribute name="longdesc">
    <xsl:choose>
      <xsl:when test="contains(.,$DITAEXT)">
        <!-- switch extension from .dita -->
        <xsl:value-of select="substring-before(.,$DITAEXT)"/>
        <xsl:value-of select="$OUTEXT"/>
        <xsl:value-of select="substring-after(.,$DITAEXT)"/>
      </xsl:when>
      <xsl:otherwise>
        <xsl:value-of select="."/>
      </xsl:otherwise>
    </xsl:choose>
  </xsl:attribute>
</xsl:template>
Template *[contains(@class, ' topic/image ')]/*[contains(@class, ' topic/longdescref ')]
Namespace No namespace
Match *[contains(@class, ' topic/image ')]/*[contains(@class, ' topic/longdescref ')]
Mode #default
References
Parameters DITAEXT; OUTEXT
Import precedence 4
Source
<xsl:template match="*[contains(@class, ' topic/image ')]/*[contains(@class, ' topic/longdescref ')]">
  <xsl:if test="@href and not (@href='')">
    <xsl:attribute name="longdesc">
      <xsl:choose>
        <xsl:when test="contains(@href,$DITAEXT)">
          <!-- switch extension from .dita -->
          <xsl:value-of select="substring-before(@href,$DITAEXT)"/>
          <xsl:value-of select="$OUTEXT"/>
          <xsl:value-of select="substring-after(@href,$DITAEXT)"/>
        </xsl:when>
        <xsl:otherwise>
          <xsl:value-of select="@href"/>
        </xsl:otherwise>
      </xsl:choose>
    </xsl:attribute>
  </xsl:if>
</xsl:template>
Template *[contains(@class,' topic/object ')]topic.object
Documentation

Description

 object, desc, & param 
Namespace No namespace
Match *[contains(@class,' topic/object ')]
Mode #default
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/object ')]" name="topic.object">
  <xsl:element name="object">
    <xsl:if test="@id">
      <xsl:attribute name="id">
        <xsl:value-of select="@id"/>
      </xsl:attribute>
    </xsl:if>
    <xsl:if test="@declare">
      <xsl:attribute name="declare">
        <xsl:value-of select="@declare"/>
      </xsl:attribute>
    </xsl:if>
    <xsl:if test="@codebase">
      <xsl:attribute name="codebase">
        <xsl:value-of select="@codebase"/>
      </xsl:attribute>
    </xsl:if>
    <xsl:if test="@type">
      <xsl:attribute name="type">
        <xsl:value-of select="@type"/>
      </xsl:attribute>
    </xsl:if>
    <xsl:if test="@archive">
      <xsl:attribute name="archive">
        <xsl:value-of select="@archive"/>
      </xsl:attribute>
    </xsl:if>
    <xsl:if test="@height">
      <xsl:attribute name="height">
        <xsl:value-of select="@height"/>
      </xsl:attribute>
    </xsl:if>
    <xsl:if test="@usemap">
      <xsl:attribute name="usemap">
        <xsl:value-of select="@usemap"/>
      </xsl:attribute>
    </xsl:if>
    <xsl:if test="@tabindex">
      <xsl:attribute name="tabindex">
        <xsl:value-of select="@tabindex"/>
      </xsl:attribute>
    </xsl:if>
    <xsl:if test="@classid">
      <xsl:attribute name="classid">
        <xsl:value-of select="@classid"/>
      </xsl:attribute>
    </xsl:if>
    <xsl:if test="@data">
      <xsl:attribute name="data">
        <xsl:value-of select="@data"/>
      </xsl:attribute>
    </xsl:if>
    <xsl:if test="@codetype">
      <xsl:attribute name="codetype">
        <xsl:value-of select="@codetype"/>
      </xsl:attribute>
    </xsl:if>
    <xsl:if test="@standby">
      <xsl:attribute name="standby">
        <xsl:value-of select="@standby"/>
      </xsl:attribute>
    </xsl:if>
    <xsl:if test="@width">
      <xsl:attribute name="width">
        <xsl:value-of select="@width"/>
      </xsl:attribute>
    </xsl:if>
    <xsl:if test="@name">
      <xsl:attribute name="name">
        <xsl:value-of select="@name"/>
      </xsl:attribute>
    </xsl:if>
    <xsl:if test="@longdescref or *[contains(@class, ' topic/longdescref ')]">
      <xsl:apply-templates select="." mode="ditamsg:longdescref-on-object"/>
    </xsl:if>
    <xsl:apply-templates/>
    <!-- Test for Flash movie; include EMBED statement for non-IE browsers -->
    <xsl:if test="contains(@codebase,'swflash.cab')">
      <xsl:element name="embed">
        <xsl:if test="@id">
          <xsl:attribute name="name">
            <xsl:value-of select="@id"/>
          </xsl:attribute>
        </xsl:if>
        <xsl:if test="@height">
          <xsl:attribute name="height">
            <xsl:value-of select="@height"/>
          </xsl:attribute>
        </xsl:if>
        <xsl:if test="@width">
          <xsl:attribute name="width">
            <xsl:value-of select="@width"/>
          </xsl:attribute>
        </xsl:if>
        <xsl:attribute name="type">
          <xsl:text>application/x-shockwave-flash</xsl:text>
        </xsl:attribute>
        <xsl:attribute name="pluginspage">
          <xsl:text>http://www.macromedia.com/go/getflashplayer</xsl:text>
        </xsl:attribute>
        <xsl:if test="./*[contains(@class,' topic/param ')]/@name='movie'">
          <xsl:attribute name="src">
            <xsl:value-of select="./*[contains(@class,' topic/param ')][@name='movie']/@value"/>
          </xsl:attribute>
        </xsl:if>
        <xsl:if test="./*[contains(@class,' topic/param ')]/@name='quality'">
          <xsl:attribute name="quality">
            <xsl:value-of select="./*[contains(@class,' topic/param ')][@name='quality']/@value"/>
          </xsl:attribute>
        </xsl:if>
        <xsl:if test="./*[contains(@class,' topic/param ')]/@name='bgcolor'">
          <xsl:attribute name="bgcolor">
            <xsl:value-of select="./*[contains(@class,' topic/param ')][@name='bgcolor']/@value"/>
          </xsl:attribute>
        </xsl:if>
      </xsl:element>
    </xsl:if>
  </xsl:element>
</xsl:template>
Template *[contains(@class,' topic/param ')]topic.param
Namespace No namespace
Match *[contains(@class,' topic/param ')]
Mode #default
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/param ')]" name="topic.param">
  <xsl:element name="param">
    <xsl:if test="@name">
      <xsl:attribute name="name">
        <xsl:value-of select="@name"/>
      </xsl:attribute>
    </xsl:if>
    <xsl:if test="@id">
      <xsl:attribute name="id">
        <xsl:value-of select="@id"/>
      </xsl:attribute>
    </xsl:if>
    <xsl:if test="@value">
      <xsl:attribute name="value">
        <xsl:value-of select="@value"/>
      </xsl:attribute>
    </xsl:if>
  </xsl:element>
</xsl:template>
Template *[contains(@class,' topic/object ')]/*[contains(@class,' topic/desc ')]topic.object_desc
Documentation

Description

 need to add test for object/desc to avoid conflicts 
Namespace No namespace
Match *[contains(@class,' topic/object ')]/*[contains(@class,' topic/desc ')]
Mode #default
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/object ')]/*[contains(@class,' topic/desc ')]" name="topic.object_desc">
  <xsl:element name="span">
    <xsl:if test="@name">
      <xsl:attribute name="name">
        <xsl:value-of select="@name"/>
      </xsl:attribute>
    </xsl:if>
    <xsl:if test="@id">
      <xsl:attribute name="id">
        <xsl:value-of select="@id"/>
      </xsl:attribute>
    </xsl:if>
    <xsl:if test="@value">
      <xsl:attribute name="value">
        <xsl:value-of select="@value"/>
      </xsl:attribute>
    </xsl:if>
    <xsl:apply-templates/>
  </xsl:element>
</xsl:template>
Template *[contains(@class,' topic/table ')]topic.table
Documentation

Description

 ===================================================================== 
 =========== CALS (OASIS) TABLE =========== 
Namespace No namespace
Match *[contains(@class,' topic/table ')]
Mode #default
References
Parameters DRAFT; FILTERFILE
Template find-active-rev-flag
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/table ')]" name="topic.table">
  <xsl:variable name="revtest">
    <xsl:if test="@rev and not($FILTERFILE='') and ($DRAFT='yes')">
      <xsl:call-template name="find-active-rev-flag">
        <xsl:with-param name="allrevs" select="@rev"/>
      </xsl:call-template>
    </xsl:if>
  </xsl:variable>
  <xsl:choose>
    <xsl:when test="$revtest=1">
      <!-- Rev is active - add the DIV -->
      <div class="{@rev}">
        <xsl:apply-templates select="." mode="table-fmt"/>
      </div>
    </xsl:when>
    <xsl:otherwise>
      <!-- Rev wasn't active - process normally -->
      <xsl:apply-templates select="." mode="table-fmt"/>
    </xsl:otherwise>
  </xsl:choose>
</xsl:template>
Template *[contains(@class,' topic/table ')]table-fmt
Namespace No namespace
Match *[contains(@class,' topic/table ')]
Mode table-fmt
References
Variable newline
Template dotable
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/table ')]" mode="table-fmt">
  <xsl:value-of select="$newline"/>
  <!-- special case for IE & NS for frame & no rules - needs to be a double table -->
  <xsl:variable name="colsep">
    <xsl:choose>
      <xsl:when test="*[contains(@class,' topic/tgroup ')]/@colsep">
        <xsl:value-of select="*[contains(@class,' topic/tgroup ')]/@colsep"/>
      </xsl:when>
      <xsl:when test="@colsep">
        <xsl:value-of select="@colsep"/>
      </xsl:when>
    </xsl:choose>
  </xsl:variable>
  <xsl:variable name="rowsep">
    <xsl:choose>
      <xsl:when test="*[contains(@class,' topic/tgroup ')]/@rowsep">
        <xsl:value-of select="*[contains(@class,' topic/tgroup ')]/@rowsep"/>
      </xsl:when>
      <xsl:when test="@rowsep">
        <xsl:value-of select="@rowsep"/>
      </xsl:when>
    </xsl:choose>
  </xsl:variable>
  <xsl:choose>
    <xsl:when test="@frame='all' and $colsep='0' and $rowsep='0'">
      <table cellpadding="4" cellspacing="0" border="1" class="tableborder">
        <tr>
          <td>
            <xsl:value-of select="$newline"/>
            <xsl:call-template name="dotable"/>
          </td>
        </tr>
      </table>
    </xsl:when>
    <xsl:when test="@frame='top' and $colsep='0' and $rowsep='0'">
      <hr/>
      <xsl:value-of select="$newline"/>
      <xsl:call-template name="dotable"/>
    </xsl:when>
    <xsl:when test="@frame='bot' and $colsep='0' and $rowsep='0'">
      <xsl:call-template name="dotable"/>
      <hr/>
      <xsl:value-of select="$newline"/>
    </xsl:when>
    <xsl:when test="@frame='topbot' and $colsep='0' and $rowsep='0'">
      <hr/>
      <xsl:value-of select="$newline"/>
      <xsl:call-template name="dotable"/>
      <hr/>
      <xsl:value-of select="$newline"/>
    </xsl:when>
    <xsl:when test="not(@frame) and $colsep='0' and $rowsep='0'">
      <table cellpadding="4" cellspacing="0" border="1" class="tableborder">
        <tr>
          <td>
            <xsl:value-of select="$newline"/>
            <xsl:call-template name="dotable"/>
          </td>
        </tr>
      </table>
    </xsl:when>
    <xsl:otherwise>
      <div class="tablenoborder">
        <xsl:call-template name="dotable"/>
      </div>
    </xsl:otherwise>
  </xsl:choose>
  <xsl:value-of select="$newline"/>
</xsl:template>
Template dotable
Namespace No namespace
Used by
References
Import precedence 4
Source
<xsl:template name="dotable">
  <xsl:variable name="flagrules">
    <xsl:call-template name="getrules"/>
  </xsl:variable>
  <xsl:call-template name="start-flagit">
    <xsl:with-param name="flagrules" select="$flagrules"/>
  </xsl:call-template>
  <xsl:call-template name="start-revflag">
    <xsl:with-param name="flagrules" select="$flagrules"/>
  </xsl:call-template>
  <xsl:call-template name="setaname"/>
  <table cellpadding="4" cellspacing="0" summary="">
    <xsl:variable name="colsep">
      <xsl:choose>
        <xsl:when test="*[contains(@class,' topic/tgroup ')]/@colsep">
          <xsl:value-of select="*[contains(@class,' topic/tgroup ')]/@colsep"/>
        </xsl:when>
        <xsl:when test="@colsep">
          <xsl:value-of select="@colsep"/>
        </xsl:when>
      </xsl:choose>
    </xsl:variable>
    <xsl:variable name="rowsep">
      <xsl:choose>
        <xsl:when test="*[contains(@class,' topic/tgroup ')]/@rowsep">
          <xsl:value-of select="*[contains(@class,' topic/tgroup ')]/@rowsep"/>
        </xsl:when>
        <xsl:when test="@rowsep">
          <xsl:value-of select="@rowsep"/>
        </xsl:when>
      </xsl:choose>
    </xsl:variable>
    <xsl:call-template name="setid"/>
    <xsl:call-template name="commonattributes"/>
    <xsl:call-template name="gen-style">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
    <xsl:call-template name="setscale"/>
    <!-- When a table's width is set to page or column, force it's width to 100%. If it's in a list, use 90%.
       Otherwise, the table flows to the content -->
    <xsl:choose>
      <xsl:when test="(@expanse='page' or @pgwide='1')and (ancestor::*[contains(@class,' topic/li ')] or ancestor::*[contains(@class,' topic/dd ')] )">
        <xsl:attribute name="width">90%</xsl:attribute>
      </xsl:when>
      <xsl:when test="(@expanse='column' or @pgwide='0') and (ancestor::*[contains(@class,' topic/li ')] or ancestor::*[contains(@class,' topic/dd ')] )">
        <xsl:attribute name="width">90%</xsl:attribute>
      </xsl:when>
      <xsl:when test="(@expanse='page' or @pgwide='1')">
        <xsl:attribute name="width">100%</xsl:attribute>
      </xsl:when>
      <xsl:when test="(@expanse='column' or @pgwide='0')">
        <xsl:attribute name="width">100%</xsl:attribute>
      </xsl:when>
    </xsl:choose>
    <xsl:choose>
      <xsl:when test="@frame='all' and $colsep='0' and $rowsep='0'">
        <xsl:attribute name="border">0</xsl:attribute>
      </xsl:when>
      <xsl:when test="not(@frame) and $colsep='0' and $rowsep='0'">
        <xsl:attribute name="border">0</xsl:attribute>
      </xsl:when>
      <xsl:when test="@frame='sides'">
        <xsl:attribute name="frame">vsides</xsl:attribute>
        <xsl:attribute name="border">1</xsl:attribute>
      </xsl:when>
      <xsl:when test="@frame='top'">
        <xsl:attribute name="frame">above</xsl:attribute>
        <xsl:attribute name="border">1</xsl:attribute>
      </xsl:when>
      <xsl:when test="@frame='bottom'">
        <xsl:attribute name="frame">below</xsl:attribute>
        <xsl:attribute name="border">1</xsl:attribute>
      </xsl:when>
      <xsl:when test="@frame='topbot'">
        <xsl:attribute name="frame">hsides</xsl:attribute>
        <xsl:attribute name="border">1</xsl:attribute>
      </xsl:when>
      <xsl:when test="@frame='none'">
        <xsl:attribute name="frame">void</xsl:attribute>
        <xsl:attribute name="border">1</xsl:attribute>
      </xsl:when>
      <xsl:otherwise>
        <xsl:attribute name="frame">border</xsl:attribute>
        <xsl:attribute name="border">1</xsl:attribute>
      </xsl:otherwise>
    </xsl:choose>
    <xsl:choose>
      <xsl:when test="@frame='all' and $colsep='0' and $rowsep='0'">
        <xsl:attribute name="border">0</xsl:attribute>
      </xsl:when>
      <xsl:when test="not(@frame) and $colsep='0' and $rowsep='0'">
        <xsl:attribute name="border">0</xsl:attribute>
      </xsl:when>
      <xsl:when test="$colsep='0' and $rowsep='0'">
        <xsl:attribute name="rules">none</xsl:attribute>
        <xsl:attribute name="border">0</xsl:attribute>
      </xsl:when>
      <xsl:when test="$colsep='0'">
        <xsl:attribute name="rules">rows</xsl:attribute>
      </xsl:when>
      <xsl:when test="$rowsep='0'">
        <xsl:attribute name="rules">cols</xsl:attribute>
      </xsl:when>
      <xsl:otherwise>
        <xsl:attribute name="rules">all</xsl:attribute>
      </xsl:otherwise>
    </xsl:choose>
    <xsl:call-template name="place-tbl-lbl"/>
    <!-- title and desc are processed elsewhere -->
    <xsl:apply-templates select="*[contains(@class,' topic/tgroup ')]"/>
  </table>
  <xsl:value-of select="$newline"/>
  <xsl:call-template name="end-revflag">
    <xsl:with-param name="flagrules" select="$flagrules"/>
  </xsl:call-template>
  <xsl:call-template name="end-flagit">
    <xsl:with-param name="flagrules" select="$flagrules"/>
  </xsl:call-template>
</xsl:template>
Template *[contains(@class,' topic/tgroup ')]topic.tgroup
Namespace No namespace
Match *[contains(@class,' topic/tgroup ')]
Mode #default
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/tgroup ')]" name="topic.tgroup">
  <xsl:apply-templates/>
</xsl:template>
Template *[contains(@class,' topic/colspec ')]
Namespace No namespace
Match *[contains(@class,' topic/colspec ')]
Mode #default
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/colspec ')]"/>
Template *[contains(@class,' topic/spanspec ')]
Namespace No namespace
Match *[contains(@class,' topic/spanspec ')]
Mode #default
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/spanspec ')]"/>
Template *[contains(@class,' topic/thead ')]topic.thead
Namespace No namespace
Match *[contains(@class,' topic/thead ')]
Mode #default
References
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/thead ')]" name="topic.thead">
  <xsl:variable name="flagrules">
    <xsl:call-template name="getrules"/>
  </xsl:variable>
  <thead>
    <xsl:call-template name="commonattributes"/>
    <xsl:call-template name="gen-style">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
    <xsl:choose>
      <xsl:when test="@align">
        <xsl:attribute name="align">
          <xsl:value-of select="@align"/>
        </xsl:attribute>
      </xsl:when>
      <xsl:otherwise>
        <xsl:call-template name="th-align"/>
      </xsl:otherwise>
    </xsl:choose>
    <xsl:if test="@char">
      <xsl:attribute name="char">
        <xsl:value-of select="@char"/>
      </xsl:attribute>
    </xsl:if>
    <xsl:if test="@charoff">
      <xsl:attribute name="charoff">
        <xsl:value-of select="@charoff"/>
      </xsl:attribute>
    </xsl:if>
    <xsl:if test="@valign">
      <xsl:attribute name="valign">
        <xsl:value-of select="@valign"/>
      </xsl:attribute>
    </xsl:if>
    <xsl:apply-templates/>
  </thead>
  <xsl:value-of select="$newline"/>
</xsl:template>
Template *[contains(@class,' topic/tfoot ')]
Documentation

Description

 Table footer processing. Ignore fall-thru tfoot; process them from the table body 
Namespace No namespace
Match *[contains(@class,' topic/tfoot ')]
Mode #default
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/tfoot ')]"/>
Template *[contains(@class,' topic/tbody ')]topic.tbody
Namespace No namespace
Match *[contains(@class,' topic/tbody ')]
Mode #default
References
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/tbody ')]" name="topic.tbody">
  <xsl:variable name="flagrules">
    <xsl:call-template name="getrules"/>
  </xsl:variable>
  <tbody>
    <xsl:call-template name="commonattributes"/>
    <xsl:call-template name="gen-style">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
    <xsl:if test="@align">
      <xsl:attribute name="align">
        <xsl:value-of select="@align"/>
      </xsl:attribute>
    </xsl:if>
    <xsl:if test="@char">
      <xsl:attribute name="char">
        <xsl:value-of select="@char"/>
      </xsl:attribute>
    </xsl:if>
    <xsl:if test="@charoff">
      <xsl:attribute name="charoff">
        <xsl:value-of select="@charoff"/>
      </xsl:attribute>
    </xsl:if>
    <xsl:if test="@valign">
      <xsl:attribute name="valign">
        <xsl:value-of select="@valign"/>
      </xsl:attribute>
    </xsl:if>
    <xsl:apply-templates/>
    <!-- process table footer -->
    <xsl:apply-templates select="../*[contains(@class,' topic/tfoot ')]" mode="gen-tfoot"/>
  </tbody>
  <xsl:value-of select="$newline"/>
</xsl:template>
Template *[contains(@class,' topic/tfoot ')]gen-tfoot
Documentation

Description

 special mode for table footers 
Namespace No namespace
Match *[contains(@class,' topic/tfoot ')]
Mode gen-tfoot
References
Variable newline
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/tfoot ')]" mode="gen-tfoot">
  <xsl:apply-templates/>
  <xsl:value-of select="$newline"/>
</xsl:template>
Template *[contains(@class,' topic/row ')]topic.row
Namespace No namespace
Match *[contains(@class,' topic/row ')]
Mode #default
References
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/row ')]" name="topic.row">
  <xsl:variable name="flagrules">
    <xsl:call-template name="getrules"/>
  </xsl:variable>
  <tr>
    <xsl:call-template name="setid"/>
    <xsl:call-template name="commonattributes"/>
    <xsl:call-template name="gen-style">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
    <xsl:if test="@align">
      <xsl:attribute name="align">
        <xsl:value-of select="@align"/>
      </xsl:attribute>
    </xsl:if>
    <xsl:if test="@char">
      <xsl:attribute name="char">
        <xsl:value-of select="@char"/>
      </xsl:attribute>
    </xsl:if>
    <xsl:if test="@charoff">
      <xsl:attribute name="charoff">
        <xsl:value-of select="@charoff"/>
      </xsl:attribute>
    </xsl:if>
    <xsl:if test="@valign">
      <xsl:attribute name="valign">
        <xsl:value-of select="@valign"/>
      </xsl:attribute>
    </xsl:if>
    <xsl:apply-templates/>
  </tr>
  <xsl:value-of select="$newline"/>
</xsl:template>
Template *[contains(@class,' topic/entry ')]topic.entry
Namespace No namespace
Match *[contains(@class,' topic/entry ')]
Mode #default
References
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/entry ')]" name="topic.entry">
  <xsl:choose>
    <xsl:when test="parent::*/parent::*[contains(@class,' topic/thead ')]">
      <xsl:call-template name="topic.thead_entry"/>
    </xsl:when>
    <xsl:otherwise>
      <xsl:call-template name="topic.tbody_entry"/>
    </xsl:otherwise>
  </xsl:choose>
</xsl:template>
Template topic.thead_entry
Documentation

Description

 do header entries 
Namespace No namespace
Used by
Template topic.entry
References
Template doentry
Variable newline
Import precedence 4
Source
<xsl:template name="topic.thead_entry">
  <th>
    <xsl:call-template name="doentry"/>
  </th>
  <xsl:value-of select="$newline"/>
</xsl:template>
Template topic.tbody_entry
Documentation

Description

 do body entries 
Namespace No namespace
Used by
Template topic.entry
References
Import precedence 4
Source
<xsl:template name="topic.tbody_entry">
  <xsl:variable name="startpos">
    <xsl:if test="../../../../@rowheader='firstcol'">
      <xsl:call-template name="find-entry-start-position"/>
    </xsl:if>
  </xsl:variable>
  <xsl:choose>
    <xsl:when test="$startpos=1">
      <th>
        <xsl:call-template name="doentry"/>
      </th>
    </xsl:when>
    <xsl:otherwise>
      <td>
        <xsl:call-template name="doentry"/>
      </td>
    </xsl:otherwise>
  </xsl:choose>
  <xsl:value-of select="$newline"/>
</xsl:template>
Template doentry
Namespace No namespace
Used by
References
Import precedence 4
Source
<xsl:template name="doentry">
  <xsl:variable name="this-colname">
    <xsl:value-of select="@colname"/>
  </xsl:variable>
  <!-- Rowsep/colsep: Skip if the last row or column. Only check the entry and colsep;
    if set higher, will already apply to the whole table. -->
  <xsl:variable name="flagrules">
    <xsl:call-template name="getrules"/>
    <xsl:call-template name="getrules-parent"/>
  </xsl:variable>
  <xsl:variable name="framevalue">
    <xsl:choose>
      <xsl:when test="ancestor::*[contains(@class,' topic/table ')][1]/@frame and ancestor::*[contains(@class,' topic/table ')][1]/@frame!=''">
        <xsl:value-of select="ancestor::*[contains(@class,' topic/table ')][1]/@frame"/>
      </xsl:when>
      <xsl:otherwise>all</xsl:otherwise>
    </xsl:choose>
  </xsl:variable>
  <xsl:variable name="rowsep">
    <xsl:choose>
      <!-- If there are more rows, keep rows on -->
      <xsl:when test="not(../following-sibling::*)">
        <xsl:choose>
          <xsl:when test="$framevalue='all' or $framevalue='bottom' or $framevalue='topbot'">1</xsl:when>
          <xsl:otherwise>0</xsl:otherwise>
        </xsl:choose>
      </xsl:when>
      <xsl:when test="@rowsep">
        <xsl:value-of select="@rowsep"/>
      </xsl:when>
      <xsl:when test="../@rowsep">
        <xsl:value-of select="../@rowsep"/>
      </xsl:when>
      <xsl:when test="@colname and ../../../*[contains(@class,' topic/colspec ')][@colname=$this-colname]/@rowsep">
        <xsl:value-of select="../../../*[contains(@class,' topic/colspec ')][@colname=$this-colname]/@rowsep"/>
      </xsl:when>
      <xsl:otherwise>1</xsl:otherwise>
    </xsl:choose>
  </xsl:variable>
  <xsl:variable name="colsep">
    <xsl:choose>
      <!-- If there are more columns, keep rows on -->
      <xsl:when test="not(following-sibling::*)">
        <xsl:choose>
          <xsl:when test="$framevalue='all' or $framevalue='sides'">1</xsl:when>
          <xsl:otherwise>0</xsl:otherwise>
        </xsl:choose>
      </xsl:when>
      <xsl:when test="@colsep">
        <xsl:value-of select="@colsep"/>
      </xsl:when>
      <xsl:when test="@colname and ../../../*[contains(@class,' topic/colspec ')][@colname=$this-colname]/@colsep">
        <xsl:value-of select="../../../*[contains(@class,' topic/colspec ')][@colname=$this-colname]/@colsep"/>
      </xsl:when>
      <xsl:otherwise>1</xsl:otherwise>
    </xsl:choose>
  </xsl:variable>
  <xsl:choose>
    <xsl:when test="$rowsep='0' and $colsep='0'">
      <xsl:attribute name="class">nocellnorowborder</xsl:attribute>
    </xsl:when>
    <xsl:when test="$rowsep='1' and $colsep='0'">
      <xsl:attribute name="class">row-nocellborder</xsl:attribute>
    </xsl:when>
    <xsl:when test="$rowsep='0' and $colsep='1'">
      <xsl:attribute name="class">cell-norowborder</xsl:attribute>
    </xsl:when>
    <xsl:when test="$rowsep='1' and $colsep='1'">
      <xsl:attribute name="class">cellrowborder</xsl:attribute>
    </xsl:when>
  </xsl:choose>
  <xsl:call-template name="commonattributes"/>
  <xsl:if test="@morerows">
    <xsl:attribute name="rowspan">
      <!-- set the number of rows to span -->
      <xsl:value-of select="@morerows+1"/>
    </xsl:attribute>
  </xsl:if>
  <xsl:if test="@spanname">
    <xsl:attribute name="colspan">
      <!-- get the number of columns to span from the corresponding spanspec -->
      <xsl:call-template name="find-spanspec-colspan"/>
    </xsl:attribute>
  </xsl:if>
  <xsl:if test="@namest and @nameend">
    <!-- get the number of columns to span from the specified named column values -->
    <xsl:attribute name="colspan">
      <xsl:call-template name="find-colspan"/>
    </xsl:attribute>
  </xsl:if>
  <!-- If align is on the tgroup, use it (parent=row, then tbody|thead|tfoot, then tgroup) -->
  <xsl:if test="../../../@align">
    <xsl:attribute name="align">
      <xsl:value-of select="../../../@align"/>
    </xsl:attribute>
  </xsl:if>
  <!-- If align is specified on a colspec or spanspec, that takes priority over tgroup -->
  <xsl:if test="@colname">
    <!-- Removed $this-colname variable, because it is declared above -->
    <xsl:if test="../../../*[contains(@class,' topic/colspec ')][@colname=$this-colname][@align]">
      <xsl:attribute name="align">
        <xsl:value-of select="../../../*[contains(@class,' topic/colspec ')][@colname=$this-colname]/@align"/>
      </xsl:attribute>
    </xsl:if>
  </xsl:if>
  <xsl:if test="@spanname">
    <xsl:variable name="this-spanname">
      <xsl:value-of select="@spanname"/>
    </xsl:variable>
    <xsl:if test="../../../*[contains(@class,' topic/spanspec ')][@spanname=$this-spanname][@align]">
      <xsl:attribute name="align">
        <xsl:value-of select="../../../*[contains(@class,' topic/spanspec ')][@spanname=$this-spanname]/@align"/>
      </xsl:attribute>
    </xsl:if>
  </xsl:if>
  <!-- If align is locally specified, that takes priority over all -->
  <xsl:if test="@align">
    <xsl:attribute name="align">
      <xsl:value-of select="@align"/>
    </xsl:attribute>
  </xsl:if>
  <xsl:if test="@char">
    <xsl:attribute name="char">
      <xsl:value-of select="@char"/>
    </xsl:attribute>
  </xsl:if>
  <xsl:if test="@charoff">
    <xsl:attribute name="charoff">
      <xsl:value-of select="@charoff"/>
    </xsl:attribute>
  </xsl:if>
  <xsl:choose>
    <xsl:when test="@valign">
      <xsl:attribute name="valign">
        <xsl:value-of select="@valign"/>
      </xsl:attribute>
    </xsl:when>
    <xsl:when test="ancestor::*[contains(@class,' topic/row ')]/@valign">
      <xsl:attribute name="valign">
        <xsl:value-of select="ancestor::*[contains(@class,' topic/row ')]/@valign"/>
      </xsl:attribute>
    </xsl:when>
    <xsl:otherwise>
      <xsl:attribute name="valign">top</xsl:attribute>
    </xsl:otherwise>
  </xsl:choose>
  <xsl:if test="../../../*[contains(@class,' topic/colspec ')]/@colwidth and                 not(@namest) and not(@nameend) and not(@spanspec)">
    <xsl:variable name="entrypos">
      <!-- Current column -->
      <xsl:call-template name="find-entry-start-position"/>
    </xsl:variable>
    <xsl:variable name="totalwidth">
      <!-- Total width of the column, in units -->
      <xsl:apply-templates select="../../../*[contains(@class,' topic/colspec ')][1]" mode="count-colwidth"/>
    </xsl:variable>
    <xsl:variable name="thiswidth">
      <!-- Width of this column, in units -->
      <xsl:choose>
        <xsl:when test="../../../*[contains(@class,' topic/colspec ')][number($entrypos)]/@colwidth">
          <xsl:value-of select="substring-before(../../../*[contains(@class,' topic/colspec ')][number($entrypos)]/@colwidth,'*')"/>
        </xsl:when>
        <xsl:otherwise>1</xsl:otherwise>
      </xsl:choose>
    </xsl:variable>
    <!-- Width = width of this column / width of table, times 100 to make a percent -->
    <xsl:attribute name="width">
      <xsl:value-of select="($thiswidth div $totalwidth) * 100"/>
      <xsl:text>%</xsl:text>
    </xsl:attribute>
  </xsl:if>
  <!-- If @rowheader='firstcol' on table, and this entry is in the first column,
       output an ID and the firstcol class -->
  <xsl:if test="../../../../@rowheader='firstcol'">
    <xsl:variable name="startpos">
      <xsl:call-template name="find-entry-start-position"/>
    </xsl:variable>
    <xsl:if test="number($startpos)=1">
      <xsl:attribute name="class">firstcol</xsl:attribute>
      <xsl:attribute name="id">
        <xsl:value-of select="generate-id(.)"/>
      </xsl:attribute>
    </xsl:if>
  </xsl:if>
  <xsl:choose>
    <!-- When entry is in a thead, output the ID -->
    <xsl:when test="parent::*/parent::*[contains(@class,' topic/thead ')]">
      <xsl:attribute name="id">
        <xsl:value-of select="generate-id(.)"/>
      </xsl:attribute>
    </xsl:when>
    <!-- otherwise, add @headers if needed -->
    <xsl:otherwise>
      <xsl:call-template name="add-headers-attribute"/>
    </xsl:otherwise>
  </xsl:choose>
  <xsl:choose>
    <!-- When entry is empty, output a blank -->
    <xsl:when test="not(*|text()|processing-instruction())">
      <xsl:text disable-output-escaping="yes">&#xA0;</xsl:text>
      <!-- nbsp -->
    </xsl:when>
    <xsl:otherwise>
      <xsl:variable name="revtest">
        <xsl:if test="@rev and not($FILTERFILE='') and ($DRAFT='yes')">
          <xsl:call-template name="find-active-rev-flag">
            <xsl:with-param name="allrevs" select="@rev"/>
          </xsl:call-template>
        </xsl:if>
      </xsl:variable>
      <xsl:variable name="revtest-row">
        <xsl:if test="../@rev and not($FILTERFILE='') and ($DRAFT='yes')">
          <xsl:call-template name="find-active-rev-flag">
            <xsl:with-param name="allrevs" select="../@rev"/>
          </xsl:call-template>
        </xsl:if>
      </xsl:variable>
      <xsl:choose>
        <xsl:when test="$revtest=1">
          <!-- Entry Rev is active - add the span -->
          <span class="{@rev}">
            <xsl:call-template name="start-revflag">
              <xsl:with-param name="flagrules" select="$flagrules"/>
            </xsl:call-template>
            <xsl:apply-templates/>
            <xsl:call-template name="end-revflag">
              <xsl:with-param name="flagrules" select="$flagrules"/>
            </xsl:call-template>
          </span>
        </xsl:when>
        <xsl:when test="$revtest-row=1">
          <!-- Row Rev is active - add the span -->
          <span class="{../@rev}">
            <xsl:call-template name="start-revflag-parent">
              <xsl:with-param name="flagrules" select="$flagrules"/>
            </xsl:call-template>
            <xsl:apply-templates/>
            <xsl:call-template name="end-revflag-parent">
              <xsl:with-param name="flagrules" select="$flagrules"/>
            </xsl:call-template>
          </span>
        </xsl:when>
        <xsl:otherwise>
          <!-- Rev wasn't active - process normally -->
          <xsl:apply-templates/>
        </xsl:otherwise>
      </xsl:choose>
    </xsl:otherwise>
  </xsl:choose>
</xsl:template>
Template *[contains(@class,' topic/colspec ')]count-colwidth
Namespace No namespace
Match *[contains(@class,' topic/colspec ')]
Mode count-colwidth
Parameters
QName Namespace
totalwidth No namespace
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/colspec ')]" mode="count-colwidth">
  <xsl:param name="totalwidth">0</xsl:param>
  <!-- Total counted width so far -->
  <xsl:variable name="thiswidth">
    <!-- Width of this column -->
    <xsl:choose>
      <xsl:when test="@colwidth">
        <xsl:value-of select="substring-before(@colwidth,'*')"/>
      </xsl:when>
      <xsl:otherwise>1</xsl:otherwise>
    </xsl:choose>
  </xsl:variable>
  <!-- If there are more colspecs, continue, otherwise return the current count -->
  <xsl:choose>
    <xsl:when test="following-sibling::*[contains(@class,' topic/colspec ')]">
      <xsl:apply-templates select="following-sibling::*[contains(@class,' topic/colspec ')][1]" mode="count-colwidth">
        <xsl:with-param name="totalwidth" select="$totalwidth + $thiswidth"/>
      </xsl:apply-templates>
    </xsl:when>
    <xsl:otherwise>
      <xsl:value-of select="$totalwidth + $thiswidth"/>
    </xsl:otherwise>
  </xsl:choose>
</xsl:template>
Template find-entry-start-position
Documentation

Description

 Find the starting column of an entry in a row. 
Namespace No namespace
Used by
Templates add-headers-attribute; doentry; find-colspan; topic.tbody_entry; *[contains(@class,' topic/thead ')]/*[contains(@class,' topic/row ')]/*[contains(@class,' topic/entry ')]findmatch
Import precedence 4
Source
<xsl:template name="find-entry-start-position">
  <xsl:choose>
    <!-- if the column number is specified, use it -->
    <xsl:when test="@colnum">
      <xsl:value-of select="@colnum"/>
    </xsl:when>
    <!-- If there is a defined column name, check the colspans to determine position -->
    <xsl:when test="@colname">
      <!-- count the number of colspans before the one this entry references, plus one -->
      <xsl:value-of select="number(count(../../../*[contains(@class,' topic/colspec ')][@colname=current()/@colname]/preceding-sibling::*)+1)"/>
    </xsl:when>
    <!-- If the starting column is defined, check colspans to determine position -->
    <xsl:when test="@namest">
      <xsl:value-of select="number(count(../../../*[contains(@class,' topic/colspec ')][@colname=current()/@namest]/preceding-sibling::*)+1)"/>
    </xsl:when>
    <!-- Need a test for spanspec -->
    <xsl:when test="@spanname">
      <xsl:variable name="startspan">
        <!-- starting column for this span -->
        <xsl:value-of select="../../../*[contains(@class,' topic/spanspec ')][@spanname=current()/@spanname]/@namest"/>
      </xsl:variable>
      <xsl:value-of select="number(count(../../../*[contains(@class,' topic/colspec ')][@colname=$startspan]/preceding-sibling::*)+1)"/>
    </xsl:when>
    <!-- Otherwise, just use the count of cells in this row -->
    <xsl:otherwise>
      <xsl:variable name="prev-sib">
        <xsl:value-of select="count(preceding-sibling::*)"/>
      </xsl:variable>
      <xsl:value-of select="$prev-sib+1"/>
    </xsl:otherwise>
  </xsl:choose>
</xsl:template>
Template find-entry-end-position
Documentation

Description

 Find the end column of a cell. If the cell does not span any columns,
     the end position is the same as the start position. 
Namespace No namespace
Used by
Templates add-headers-attribute; find-colspan; *[contains(@class,' topic/thead ')]/*[contains(@class,' topic/row ')]/*[contains(@class,' topic/entry ')]findmatch
Parameters
QName Namespace Select
startposition No namespace 0
Import precedence 4
Source
<xsl:template name="find-entry-end-position">
  <xsl:param name="startposition" select="0"/>
  <xsl:choose>
    <xsl:when test="@nameend">
      <xsl:value-of select="number(count(../../../*[contains(@class,' topic/colspec ')][@colname=current()/@nameend]/preceding-sibling::*)+1)"/>
    </xsl:when>
    <xsl:when test="@spanname">
      <xsl:variable name="endspan">
        <!-- starting column for this span -->
        <xsl:value-of select="../../../*[contains(@class,' topic/spanspec ')][@spanname=current()/@spanname]/@nameend"/>
      </xsl:variable>
      <xsl:value-of select="number(count(../../../*[contains(@class,' topic/colspec ')][@colname=$endspan]/preceding-sibling::*)+1)"/>
    </xsl:when>
    <xsl:otherwise>
      <xsl:value-of select="$startposition"/>
    </xsl:otherwise>
  </xsl:choose>
</xsl:template>
Template *[contains(@class,' topic/thead ')]/*[contains(@class,' topic/row ')]/*[contains(@class,' topic/entry ')]findmatch
Documentation

Description

 Check <thead> entries, and return IDs for those which match the desired column 
Namespace No namespace
Match *[contains(@class,' topic/thead ')]/*[contains(@class,' topic/row ')]/*[contains(@class,' topic/entry ')]
Mode findmatch
References
Parameters
QName Namespace
endmatch No namespace
startmatch No namespace
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/thead ')]/*[contains(@class,' topic/row ')]/*[contains(@class,' topic/entry ')]" mode="findmatch">
  <xsl:param name="startmatch">1</xsl:param>
  <!-- start column of the tbody cell -->
  <xsl:param name="endmatch">1</xsl:param>
  <!-- end column of the tbody cell -->
  <xsl:variable name="entrystartpos">
    <!-- start column of this thead cell -->
    <xsl:call-template name="find-entry-start-position"/>
  </xsl:variable>
  <xsl:variable name="entryendpos">
    <!-- end column of this thead cell -->
    <xsl:call-template name="find-entry-end-position">
      <xsl:with-param name="startposition" select="$entrystartpos"/>
    </xsl:call-template>
  </xsl:variable>
  <xsl:choose>
    <!-- Ignore this header cell if it  starts after the tbody cell we are testing -->
    <xsl:when test="number($endmatch) < number($entrystartpos)"/>
    <!-- Ignore this header cell if it ends before the tbody cell we are testing -->
    <xsl:when test="number($startmatch) > number($entryendpos)"/>
    <!-- Otherwise, this header lines up with the tbody cell, so use the ID -->
    <xsl:otherwise>
      <xsl:value-of select="generate-id(.)"/>
      <xsl:text> </xsl:text>
    </xsl:otherwise>
  </xsl:choose>
</xsl:template>
Template *[contains(@class,' topic/entry ')]check-first-column
Documentation

Description

 Check the first column for entries that line up with the test row.
     Any entries that line up need to have the header saved. This template is first
     called with the first entry of the first row in <tbody>. It is called from here
     on the next cell in column one.            
Namespace No namespace
Match *[contains(@class,' topic/entry ')]
Mode check-first-column
Parameters
QName Namespace Select
endMatchRow No namespace 1
startCurrentRow No namespace 1
startMatchRow No namespace 1
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/entry ')]" mode="check-first-column">
  <xsl:param name="startMatchRow" select="1"/>
  <!-- First row of the tbody cell we are matching -->
  <xsl:param name="endMatchRow" select="1"/>
  <!-- Last row of the tbody cell we are matching -->
  <xsl:param name="startCurrentRow" select="1"/>
  <!-- First row of the column-1 cell we are testing -->
  <xsl:variable name="endCurrentRow">
    <!-- Last row of the column-1 cell we are testing -->
    <xsl:choose>
      <!-- If @morerows, the cell ends at startCurrentRow + @morerows. Otherise, start=end. -->
      <xsl:when test="@morerows">
        <xsl:value-of select="number($startCurrentRow)+number(@morerows)"/>
      </xsl:when>
      <xsl:otherwise>
        <xsl:value-of select="$startCurrentRow"/>
      </xsl:otherwise>
    </xsl:choose>
  </xsl:variable>
  <xsl:choose>
    <!-- When the current column-1 cell ends before the tbody cell we are matching -->
    <xsl:when test="number($endCurrentRow) < number($startMatchRow)">
      <!-- Call this template again with the next entry in column one -->
      <xsl:if test="parent::*/parent::*/*[number($endCurrentRow)+1]">
        <xsl:apply-templates select="parent::*/parent::*/*[number($endCurrentRow)+1]/*[1]" mode="check-first-column">
          <xsl:with-param name="startMatchRow" select="$startMatchRow"/>
          <xsl:with-param name="endMatchRow" select="$endMatchRow"/>
          <xsl:with-param name="startCurrentRow" select="number($endCurrentRow)+1"/>
        </xsl:apply-templates>
      </xsl:if>
    </xsl:when>
    <!-- If this column-1 cell starts after the tbody cell we are matching, jump out of recursive loop -->
    <xsl:when test="number($startCurrentRow) > number($endMatchRow)"/>
    <!-- Otherwise, the column-1 cell is aligned with the tbody cell, so save the ID and continue -->
    <xsl:otherwise>
      <xsl:value-of select="generate-id(.)"/>
      <xsl:text> </xsl:text>
      <!-- If we are not at the end of the tbody cell, and more rows exist, continue testing column 1 -->
      <xsl:if test="number($endCurrentRow) < number($endMatchRow) and                     parent::*/parent::*/*[number($endCurrentRow)+1]">
        <xsl:apply-templates select="parent::*/parent::*/*[number($endCurrentRow)+1]/*[1]" mode="check-first-column">
          <xsl:with-param name="startMatchRow" select="$startMatchRow"/>
          <xsl:with-param name="endMatchRow" select="$endMatchRow"/>
          <xsl:with-param name="startCurrentRow" select="number($endCurrentRow)+1"/>
        </xsl:apply-templates>
      </xsl:if>
    </xsl:otherwise>
  </xsl:choose>
</xsl:template>
Template add-headers-attribute
Documentation

Description

 Add @headers to cells in the body of a table. 
Namespace No namespace
Used by
Template doentry
References
Import precedence 4
Source
<xsl:template name="add-headers-attribute">
  <!-- Determine the start column for the current cell -->
  <xsl:variable name="entrystartpos">
    <xsl:call-template name="find-entry-start-position"/>
  </xsl:variable>
  <!-- Determine the end column for the current cell -->
  <xsl:variable name="entryendpos">
    <xsl:call-template name="find-entry-end-position">
      <xsl:with-param name="startposition" select="$entrystartpos"/>
    </xsl:call-template>
  </xsl:variable>
  <!-- Find the IDs of headers that are aligned above this cell. This is done by applying
       templates on all headers, using mode=findmatch; matching IDs are returned. -->
  <xsl:variable name="hdrattr">
    <xsl:apply-templates select="../../../*[contains(@class,' topic/thead ')]/*[contains(@class,' topic/row ')]/*" mode="findmatch">
      <xsl:with-param name="startmatch" select="$entrystartpos"/>
      <xsl:with-param name="endmatch" select="$entryendpos"/>
    </xsl:apply-templates>
  </xsl:variable>
  <!-- Find the IDs of headers in the first column, which are aligned with this cell -->
  <xsl:variable name="rowheader">
    <!-- If this entry is not in the first column or in thead, and @rowheader=firstcol on table -->
    <xsl:if test="not(number($entrystartpos)=1) and                   not(parent::*/parent::*[contains(@class,' topic/thead ')]) and                   ../../../../@rowheader='firstcol'">
      <!-- Find the start row for this entry -->
      <xsl:variable name="startrow" select="number(count(parent::*/preceding-sibling::*)+1)"/>
      <!-- Find the end row for this entry -->
      <xsl:variable name="endrow">
        <xsl:if test="@morerows">
          <xsl:value-of select="number($startrow) + number(@morerows)"/>
        </xsl:if>
        <xsl:if test="not(@morerows)">
          <xsl:value-of select="$startrow"/>
        </xsl:if>
      </xsl:variable>
      <!-- Scan first-column entries for ones that align with this cell, starting with
           the first entry in the first row -->
      <xsl:apply-templates select="../../*[contains(@class,' topic/row ')][1]/*[contains(@class,' topic/entry ')][1]" mode="check-first-column">
        <xsl:with-param name="startMatchRow" select="$startrow"/>
        <xsl:with-param name="endMatchRow" select="$endrow"/>
      </xsl:apply-templates>
    </xsl:if>
  </xsl:variable>
  <xsl:if test="string-length($rowheader)>0 or string-length($hdrattr)>0">
    <xsl:attribute name="headers">
      <xsl:value-of select="$rowheader"/>
      <xsl:value-of select="$hdrattr"/>
    </xsl:attribute>
  </xsl:if>
</xsl:template>
Template find-colspan
Documentation

Description

 Find the number of column spans between name-start and name-end attrs 
Namespace No namespace
Used by
Template doentry
References
Import precedence 4
Source
<xsl:template name="find-colspan">
  <xsl:variable name="startpos">
    <xsl:call-template name="find-entry-start-position"/>
  </xsl:variable>
  <xsl:variable name="endpos">
    <xsl:call-template name="find-entry-end-position"/>
  </xsl:variable>
  <xsl:value-of select="$endpos - $startpos + 1"/>
</xsl:template>
Template find-spanspec-colspan
Namespace No namespace
Used by
Template doentry
Import precedence 4
Source
<xsl:template name="find-spanspec-colspan">
  <xsl:variable name="spanname">
    <xsl:value-of select="@spanname"/>
  </xsl:variable>
  <xsl:variable name="startcolname">
    <xsl:value-of select="../../../*[contains(@class,' topic/spanspec ')][@spanname=$spanname][1]/@namest"/>
  </xsl:variable>
  <xsl:variable name="endcolname">
    <xsl:value-of select="../../../*[contains(@class,' topic/spanspec ')][@spanname=$spanname][1]/@nameend"/>
  </xsl:variable>
  <xsl:variable name="startpos">
    <xsl:value-of select="number(count(../../../*[contains(@class,' topic/colspec ')][@colname=$startcolname]/preceding-sibling::*)+1)"/>
  </xsl:variable>
  <xsl:variable name="endpos">
    <xsl:value-of select="number(count(../../../*[contains(@class,' topic/colspec ')][@colname=$endcolname]/preceding-sibling::*)+1)"/>
  </xsl:variable>
  <xsl:value-of select="$endpos - $startpos + 1"/>
</xsl:template>
Template *[contains(@class,' topic/simpletable ')]topic.simpletable
Documentation

Description

 end of table section 
 ===================================================================== 
 =========== SimpleTable - SEMANTIC TABLE =========== 
Namespace No namespace
Match *[contains(@class,' topic/simpletable ')]
Mode #default
References
Parameters DRAFT; FILTERFILE
Template find-active-rev-flag
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/simpletable ')]" name="topic.simpletable">
  <xsl:variable name="revtest">
    <xsl:if test="@rev and not($FILTERFILE='') and ($DRAFT='yes')">
      <xsl:call-template name="find-active-rev-flag">
        <xsl:with-param name="allrevs" select="@rev"/>
      </xsl:call-template>
    </xsl:if>
  </xsl:variable>
  <xsl:choose>
    <xsl:when test="$revtest=1">
      <!-- Rev is active - add the DIV -->
      <div class="{@rev}">
        <xsl:apply-templates select="." mode="simpletable-fmt"/>
      </div>
    </xsl:when>
    <xsl:otherwise>
      <!-- Rev wasn't active - process normally -->
      <xsl:apply-templates select="." mode="simpletable-fmt"/>
    </xsl:otherwise>
  </xsl:choose>
</xsl:template>
Template *[contains(@class,' topic/simpletable ')]simpletable-fmt
Namespace No namespace
Match *[contains(@class,' topic/simpletable ')]
Mode simpletable-fmt
References
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/simpletable ')]" mode="simpletable-fmt">
  <!-- Find the total number of relative units for the table. If @relcolwidth="1* 2* 2*",
       the variable is set to 5. -->
  <xsl:variable name="flagrules">
    <xsl:call-template name="getrules"/>
  </xsl:variable>
  <xsl:variable name="totalwidth">
    <xsl:if test="@relcolwidth">
      <xsl:call-template name="find-total-table-width"/>
    </xsl:if>
  </xsl:variable>
  <!-- Find how much of the table each relative unit represents. If @relcolwidth is 1* 2* 2*,
       there are 5 units. So, each unit takes up 100/5, or 20% of the table. Default to 0,
       which the entries will ignore. -->
  <xsl:variable name="width-multiplier">
    <xsl:choose>
      <xsl:when test="@relcolwidth">
        <xsl:value-of select="100 div $totalwidth"/>
      </xsl:when>
      <xsl:otherwise>0</xsl:otherwise>
    </xsl:choose>
  </xsl:variable>
  <xsl:call-template name="spec-title"/>
  <xsl:call-template name="start-flagit">
    <xsl:with-param name="flagrules" select="$flagrules"/>
  </xsl:call-template>
  <xsl:call-template name="start-revflag">
    <xsl:with-param name="flagrules" select="$flagrules"/>
  </xsl:call-template>
  <xsl:call-template name="setaname"/>
  <table cellpadding="4" cellspacing="0" summary="">
    <xsl:call-template name="setid"/>
    <xsl:choose>
      <xsl:when test="@frame='none'">
        <xsl:attribute name="border">0</xsl:attribute>
        <xsl:attribute name="class">simpletablenoborder</xsl:attribute>
      </xsl:when>
      <xsl:otherwise>
        <xsl:attribute name="border">1</xsl:attribute>
        <xsl:attribute name="class">simpletableborder</xsl:attribute>
      </xsl:otherwise>
    </xsl:choose>
    <xsl:call-template name="commonattributes"/>
    <xsl:call-template name="gen-style">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
    <xsl:call-template name="setscale"/>
    <xsl:apply-templates select="." mode="dita2html:simpletable-heading">
      <xsl:with-param name="width-multiplier">
        <xsl:value-of select="$width-multiplier"/>
      </xsl:with-param>
    </xsl:apply-templates>
    <xsl:apply-templates select="*[contains(@class,' topic/strow ')]|processing-instruction()">
      <!-- width-multiplier will be used in the first row to set widths. -->
      <xsl:with-param name="width-multiplier">
        <xsl:value-of select="$width-multiplier"/>
      </xsl:with-param>
    </xsl:apply-templates>
  </table>
  <xsl:call-template name="end-revflag">
    <xsl:with-param name="flagrules" select="$flagrules"/>
  </xsl:call-template>
  <xsl:call-template name="end-flagit">
    <xsl:with-param name="flagrules" select="$flagrules"/>
  </xsl:call-template>
  <xsl:value-of select="$newline"/>
</xsl:template>
Template *[contains(@class,' topic/strow ')]topic.strow
Namespace No namespace
Match *[contains(@class,' topic/strow ')]
Mode #default
References
Parameters
QName Namespace
width-multiplier No namespace
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/strow ')]" name="topic.strow">
  <xsl:param name="width-multiplier"/>
  <xsl:variable name="flagrules">
    <xsl:call-template name="getrules"/>
  </xsl:variable>
  <tr>
    <xsl:call-template name="setid"/>
    <xsl:call-template name="commonattributes"/>
    <xsl:call-template name="gen-style">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
    <xsl:choose>
      <!-- If there are any rows or headers before this, the width values have already been set. -->
      <xsl:when test="preceding-sibling::*">
        <xsl:apply-templates/>
      </xsl:when>
      <!-- Otherwise, this is the first row. Pass the percentage to all entries in this row. -->
      <xsl:otherwise>
        <xsl:apply-templates>
          <xsl:with-param name="width-multiplier">
            <xsl:value-of select="$width-multiplier"/>
          </xsl:with-param>
        </xsl:apply-templates>
      </xsl:otherwise>
    </xsl:choose>
  </tr>
  <xsl:value-of select="$newline"/>
</xsl:template>
Template *{http://dita-ot.sourceforge.net/ns/200801/dita2html}simpletable-heading
Documentation

Description

 Specialized simpletables may match this rule to create default column 
     headings. By default, process the sthead if available. 
Namespace No namespace
Match *
Mode {http://dita-ot.sourceforge.net/ns/200801/dita2html}simpletable-heading
Parameters
QName Namespace
width-multiplier No namespace
Import precedence 4
Source
<xsl:template match="*" mode="dita2html:simpletable-heading">
  <xsl:param name="width-multiplier"/>
  <xsl:apply-templates select="*[contains(@class,' topic/sthead ')]">
    <xsl:with-param name="width-multiplier">
      <xsl:value-of select="$width-multiplier"/>
    </xsl:with-param>
  </xsl:apply-templates>
</xsl:template>
Template *[contains(@class,' topic/sthead ')]topic.sthead
Namespace No namespace
Match *[contains(@class,' topic/sthead ')]
Mode #default
References
Template commonattributes
Variable newline
Parameters
QName Namespace
width-multiplier No namespace
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/sthead ')]" name="topic.sthead">
  <xsl:param name="width-multiplier"/>
  <tr>
    <xsl:call-template name="commonattributes"/>
    <!-- There is only one sthead, so use the entries in the header to set relative widths. -->
    <xsl:apply-templates>
      <xsl:with-param name="width-multiplier">
        <xsl:value-of select="$width-multiplier"/>
      </xsl:with-param>
    </xsl:apply-templates>
  </tr>
  <xsl:value-of select="$newline"/>
</xsl:template>
Template output-stentry-id
Namespace No namespace
Used by
Import precedence 4
Source
<xsl:template name="output-stentry-id">
  <!-- Find the position in this row -->
  <xsl:variable name="thiscolnum">
    <xsl:number level="single" count="*"/>
  </xsl:variable>
  <xsl:choose>
    <xsl:when test="@id">
      <!-- If ID is specified, always use it -->
      <xsl:attribute name="id">
        <xsl:value-of select="@id"/>
      </xsl:attribute>
    </xsl:when>
    <!-- If no ID is specified, and this is a header cell, generate an ID -->
    <xsl:when test="parent::*[contains(@class,' topic/sthead ')] or                     (parent::*/parent::*/@keycol and number(parent::*/parent::*/@keycol)=number($thiscolnum))">
      <xsl:attribute name="id">
        <xsl:value-of select="generate-id(.)"/>
      </xsl:attribute>
    </xsl:when>
  </xsl:choose>
</xsl:template>
Template set.stentry.headers
Namespace No namespace
Used by
Import precedence 4
Source
<xsl:template name="set.stentry.headers">
  <xsl:if test="parent::*/parent::*/@keycol | parent::*/parent::*/*[contains(@class,' topic/sthead ')]">
    <xsl:variable name="thiscolnum">
      <xsl:number level="single" count="*"/>
    </xsl:variable>
    <!-- If there is a keycol, and this is not the key column, get the ID for the keycol -->
    <xsl:variable name="keycolhead">
      <xsl:if test="parent::*/parent::*/@keycol and $thiscolnum!=number(parent::*/parent::*/@keycol)">
        <xsl:choose>
          <xsl:when test="../*[number(parent::*/parent::*/@keycol)]/@id">
            <xsl:value-of select="../*[number(parent::*/parent::*/@keycol)]/@id"/>
          </xsl:when>
          <xsl:otherwise>
            <xsl:value-of select="generate-id(../*[number(parent::*/parent::*/@keycol)])"/>
          </xsl:otherwise>
        </xsl:choose>
      </xsl:if>
    </xsl:variable>
    <!-- If there is a header, get the ID from the head cell in this column.
           Go up to simpletable, into the row, to the entry at column $thiscolnum -->
    <xsl:variable name="header">
      <xsl:if test="parent::*/parent::*/*[contains(@class,' topic/sthead ')]">
        <xsl:choose>
          <xsl:when test="parent::*/parent::*/*[contains(@class,' topic/sthead ')]/*[number($thiscolnum)]/@id">
            <xsl:value-of select="parent::*/parent::*/*[contains(@class,' topic/sthead ')]/*[number($thiscolnum)]/@id"/>
          </xsl:when>
          <xsl:otherwise>
            <xsl:value-of select="generate-id(parent::*/parent::*/*[contains(@class,' topic/sthead ')]/*[number($thiscolnum)])"/>
          </xsl:otherwise>
        </xsl:choose>
      </xsl:if>
    </xsl:variable>
    <!-- If there is a keycol header or an sthead header, create the attribute -->
    <xsl:if test="string-length($header)>0 or string-length($keycolhead)>0">
      <xsl:attribute name="headers">
        <xsl:value-of select="$header"/>
        <xsl:if test="string-length($header)>0 and string-length($keycolhead)>0">
          <xsl:text> </xsl:text>
        </xsl:if>
        <xsl:value-of select="$keycolhead"/>
      </xsl:attribute>
    </xsl:if>
  </xsl:if>
</xsl:template>
Template *start-stentry-flagging
Documentation

Description

 SF Report 2008294: support flagging in simpletable headers. Use common template to simplify
                        sharing this with all simpletable entries and specializations. 
Namespace No namespace
Match *
Mode start-stentry-flagging
References
Parameters
QName Namespace
flagrules No namespace
Import precedence 4
Source
<xsl:template match="*" mode="start-stentry-flagging">
  <xsl:param name="flagrules">
    <xsl:call-template name="getrules"/>
    <xsl:call-template name="getrules-parent"/>
  </xsl:param>
  <xsl:call-template name="start-flagit">
    <xsl:with-param name="flagrules" select="$flagrules"/>
  </xsl:call-template>
  <xsl:call-template name="start-revflag-parent">
    <xsl:with-param name="flagrules" select="$flagrules"/>
  </xsl:call-template>
  <xsl:call-template name="start-revflag">
    <xsl:with-param name="flagrules" select="$flagrules"/>
  </xsl:call-template>
</xsl:template>
Template *end-stentry-flagging
Namespace No namespace
Match *
Mode end-stentry-flagging
References
Parameters
QName Namespace
flagrules No namespace
Import precedence 4
Source
<xsl:template match="*" mode="end-stentry-flagging">
  <xsl:param name="flagrules">
    <xsl:call-template name="getrules"/>
    <xsl:call-template name="getrules-parent"/>
  </xsl:param>
  <xsl:call-template name="end-revflag">
    <xsl:with-param name="flagrules" select="$flagrules"/>
  </xsl:call-template>
  <xsl:call-template name="end-revflag-parent">
    <xsl:with-param name="flagrules" select="$flagrules"/>
  </xsl:call-template>
  <xsl:call-template name="end-flagit">
    <xsl:with-param name="flagrules" select="$flagrules"/>
  </xsl:call-template>
</xsl:template>
Template *[contains(@class,' topic/stentry ')]topic.stentry
Namespace No namespace
Match *[contains(@class,' topic/stentry ')]
Mode #default
References
Parameters
QName Namespace
width-multiplier No namespace
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/stentry ')]" name="topic.stentry">
  <xsl:param name="width-multiplier">0</xsl:param>
  <xsl:choose>
    <xsl:when test="parent::*[contains(@class,' topic/sthead ')]">
      <xsl:call-template name="topic.sthead_stentry">
        <xsl:with-param name="width-multiplier">
          <xsl:value-of select="$width-multiplier"/>
        </xsl:with-param>
      </xsl:call-template>
    </xsl:when>
    <xsl:otherwise>
      <xsl:call-template name="topic.strow_stentry">
        <xsl:with-param name="width-multiplier">
          <xsl:value-of select="$width-multiplier"/>
        </xsl:with-param>
      </xsl:call-template>
    </xsl:otherwise>
  </xsl:choose>
</xsl:template>
Template topic.sthead_stentry
Documentation

Description

 sthead/stentry - bottom align the header text 
Namespace No namespace
Used by
Template topic.stentry
References
Parameters
QName Namespace
width-multiplier No namespace
Import precedence 4
Source
<xsl:template name="topic.sthead_stentry">
  <xsl:param name="width-multiplier">0</xsl:param>
  <xsl:variable name="flagrules">
    <xsl:call-template name="getrules"/>
    <xsl:call-template name="getrules-parent"/>
  </xsl:variable>
  <th valign="bottom">
    <xsl:call-template name="th-align"/>
    <!-- Determine which column this entry is in. -->
    <xsl:variable name="thiscolnum">
      <xsl:value-of select="number(count(preceding-sibling::*)+1)"/>
    </xsl:variable>
    <!-- If width-multiplier=0, then either @relcolwidth was not specified, or this is not the first
         row, so do not create a width value. Otherwise, find out the relative width of this column. -->
    <xsl:variable name="widthpercent">
      <xsl:if test="$width-multiplier != 0">
        <xsl:call-template name="get-current-entry-percentage">
          <xsl:with-param name="multiplier">
            <xsl:value-of select="$width-multiplier"/>
          </xsl:with-param>
          <xsl:with-param name="entry-num">
            <xsl:value-of select="$thiscolnum"/>
          </xsl:with-param>
        </xsl:call-template>
      </xsl:if>
    </xsl:variable>
    <xsl:call-template name="output-stentry-id"/>
    <xsl:call-template name="commonattributes"/>
    <xsl:call-template name="gen-style">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
    <!-- If we calculated a width, create the width attribute. -->
    <xsl:if test="string-length($widthpercent)>0">
      <xsl:attribute name="width">
        <xsl:value-of select="$widthpercent"/>
        <xsl:text>%</xsl:text>
      </xsl:attribute>
    </xsl:if>
    <xsl:apply-templates select="." mode="start-stentry-flagging">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:apply-templates>
    <xsl:choose>
      <xsl:when test="not(*|text()|processing-instruction()) and @specentry">
        <xsl:value-of select="@specentry"/>
      </xsl:when>
      <xsl:otherwise>
        <xsl:apply-templates/>
      </xsl:otherwise>
    </xsl:choose>
    <xsl:apply-templates select="." mode="end-stentry-flagging">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:apply-templates>
  </th>
  <xsl:value-of select="$newline"/>
</xsl:template>
Template th-align
Documentation

Description

 For simple table headers: <TH> Set align="right" when in a BIDI area 
Namespace No namespace
Used by
References
Template bidi-area
Import precedence 4
Source
<xsl:template name="th-align">
  <xsl:variable name="biditest">
    <xsl:call-template name="bidi-area"/>
  </xsl:variable>
  <xsl:choose>
    <xsl:when test="$biditest='bidi'">
      <xsl:attribute name="align">right</xsl:attribute>
    </xsl:when>
    <xsl:otherwise>
      <xsl:attribute name="align">left</xsl:attribute>
    </xsl:otherwise>
  </xsl:choose>
</xsl:template>
Template topic.strow_stentry
Documentation

Description

 stentry  
 for specentry - if no text in cell, output specentry attr; otherwise output text 
 Bold the @keycol column. Get the column's number. When (Nth stentry = the @keycol value) then bold the stentry 
Namespace No namespace
Used by
Template topic.stentry
References
Parameters
QName Namespace
width-multiplier No namespace
Import precedence 4
Source
<xsl:template name="topic.strow_stentry">
  <xsl:param name="width-multiplier">0</xsl:param>
  <xsl:variable name="flagrules">
    <xsl:call-template name="getrules"/>
    <xsl:call-template name="getrules-parent"/>
  </xsl:variable>
  <td valign="top">
    <xsl:call-template name="output-stentry-id"/>
    <xsl:call-template name="set.stentry.headers"/>
    <xsl:call-template name="commonattributes"/>
    <xsl:call-template name="gen-style">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
    <xsl:variable name="localkeycol">
      <xsl:choose>
        <xsl:when test="ancestor::*[contains(@class,' topic/simpletable ')]/@keycol">
          <xsl:value-of select="ancestor::*[contains(@class,' topic/simpletable ')]/@keycol"/>
        </xsl:when>
        <xsl:otherwise>0</xsl:otherwise>
      </xsl:choose>
    </xsl:variable>
    <!-- Determine which column this entry is in. -->
    <xsl:variable name="thiscolnum">
      <xsl:value-of select="number(count(preceding-sibling::*)+1)"/>
    </xsl:variable>
    <!-- If width-multiplier=0, then either @relcolwidth was not specified, or this is not the first
         row, so do not create a width value. Otherwise, find out the relative width of this column. -->
    <xsl:variable name="widthpercent">
      <xsl:if test="$width-multiplier != 0">
        <xsl:call-template name="get-current-entry-percentage">
          <xsl:with-param name="multiplier">
            <xsl:value-of select="$width-multiplier"/>
          </xsl:with-param>
          <xsl:with-param name="entry-num">
            <xsl:value-of select="$thiscolnum"/>
          </xsl:with-param>
        </xsl:call-template>
      </xsl:if>
    </xsl:variable>
    <!-- If we calculated a width, create the width attribute. -->
    <xsl:if test="string-length($widthpercent)>0">
      <xsl:attribute name="width">
        <xsl:value-of select="$widthpercent"/>
        <xsl:text>%</xsl:text>
      </xsl:attribute>
    </xsl:if>
    <xsl:apply-templates select="." mode="start-stentry-flagging">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:apply-templates>
    <xsl:variable name="revtest">
      <xsl:if test="@rev and not($FILTERFILE='') and ($DRAFT='yes')">
        <!-- revision? -->
        <xsl:call-template name="find-active-rev-flag">
          <!-- active? (revtest will be 1 when active)-->
          <xsl:with-param name="allrevs" select="@rev"/>
        </xsl:call-template>
      </xsl:if>
    </xsl:variable>
    <xsl:variable name="revtest-row">
      <xsl:if test="../@rev and not($FILTERFILE='') and ($DRAFT='yes')">
        <!-- revision? -->
        <xsl:call-template name="find-active-rev-flag">
          <!-- active? (revtest will be 1 when active)-->
          <xsl:with-param name="allrevs" select="../@rev"/>
        </xsl:call-template>
      </xsl:if>
    </xsl:variable>
    <xsl:choose>
      <xsl:when test="$thiscolnum=$localkeycol and $revtest-row=1">
        <strong>
          <span class="{../@rev}">
            <xsl:call-template name="stentry-templates"/>
          </span>
        </strong>
      </xsl:when>
      <xsl:when test="$thiscolnum=$localkeycol and $revtest=1">
        <strong>
          <span class="{@rev}">
            <xsl:call-template name="stentry-templates"/>
          </span>
        </strong>
      </xsl:when>
      <xsl:when test="$thiscolnum=$localkeycol">
        <strong>
          <xsl:call-template name="stentry-templates"/>
        </strong>
      </xsl:when>
      <xsl:when test="$revtest-row=1">
        <span class="{../@rev}">
          <xsl:call-template name="stentry-templates"/>
        </span>
      </xsl:when>
      <xsl:when test="$revtest=1">
        <span class="{@rev}">
          <xsl:call-template name="stentry-templates"/>
        </span>
      </xsl:when>
      <xsl:otherwise>
        <xsl:call-template name="stentry-templates"/>
      </xsl:otherwise>
    </xsl:choose>
    <xsl:apply-templates select="." mode="end-stentry-flagging">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:apply-templates>
  </td>
  <xsl:value-of select="$newline"/>
</xsl:template>
Template stentry-templates
Namespace No namespace
Used by
Import precedence 4
Source
<xsl:template name="stentry-templates">
  <xsl:choose>
    <xsl:when test="not(*|text()|processing-instruction()) and @specentry">
      <xsl:value-of select="@specentry"/>
    </xsl:when>
    <xsl:when test="not(*|text()|processing-instruction())">
      <xsl:text disable-output-escaping="yes">&#xA0;</xsl:text>
      <!-- nbsp -->
    </xsl:when>
    <xsl:otherwise>
      <xsl:apply-templates/>
    </xsl:otherwise>
  </xsl:choose>
</xsl:template>
Template find-total-table-width
Documentation

Description

 Use @relcolwidth to find the total width of the table. That is, if the attribute is set
     to 1* 2* 2* 1*, then the table is 6 units wide. 
Namespace No namespace
Used by
References
Parameters
QName Namespace
relcolwidth No namespace
Import precedence 4
Source
<xsl:template name="find-total-table-width">
  <!-- Start with relcolwidth, and each recursive call will remove the first value -->
  <xsl:param name="relcolwidth">
    <xsl:value-of select="@relcolwidth"/>
  </xsl:param>
  <!-- Determine the first value, which is the value before the first asterisk -->
  <xsl:variable name="firstval">
    <xsl:if test="contains($relcolwidth,'*')">
      <xsl:value-of select="substring-before($relcolwidth,'*')"/>
    </xsl:if>
  </xsl:variable>
  <!-- Begin processing if we were able to find a first value -->
  <xsl:if test="string-length($firstval)>0">
    <!-- Chop off the first value, and set morevals to the remainder -->
    <xsl:variable name="morevals">
      <xsl:value-of select="substring-after($relcolwidth,' ')"/>
    </xsl:variable>
    <xsl:choose>
      <!-- If there are additional values, call this template on the remainder.
           Add the result of that call to the first value. -->
      <xsl:when test="string-length($morevals)>0">
        <xsl:variable name="nextval">
          <!-- The total of the remaining values -->
          <xsl:call-template name="find-total-table-width">
            <xsl:with-param name="relcolwidth">
              <xsl:value-of select="$morevals"/>
            </xsl:with-param>
          </xsl:call-template>
        </xsl:variable>
        <xsl:value-of select="number($firstval)+number($nextval)"/>
      </xsl:when>
      <!-- If there are no more values, return the first (and only) value -->
      <xsl:otherwise>
        <xsl:value-of select="$firstval"/>
      </xsl:otherwise>
    </xsl:choose>
  </xsl:if>
</xsl:template>
Template get-current-entry-percentage
Documentation

Description

 Find the width of the current cell. Multiplier is how much each unit of width is multiplied to total 100.
     Entry-num is the current entry. Current-col is what column we are at when scanning @relcolwidth.
     Relcolvalues is the unscanned part of @relcolwidth. 
Namespace No namespace
Used by
Templates get-current-entry-percentage; topic.sthead_stentry; topic.strow_stentry; topic.task.chdesc; topic.task.choption; *propertiesEntry
References
Template get-current-entry-percentage
Parameters
QName Namespace
current-col No namespace
entry-num No namespace
multiplier No namespace
relcolvalues No namespace
Import precedence 4
Source
<xsl:template name="get-current-entry-percentage">
  <xsl:param name="multiplier">1</xsl:param>
  <!-- Each relative unit is worth this many percentage points -->
  <xsl:param name="entry-num"/>
  <!-- The entry number of the cell we are evaluating now -->
  <xsl:param name="current-col">1</xsl:param>
  <!-- Position within the recursive call to evaluate @relcolwidth -->
  <!-- relcolvalues begins with @relcolwidth. Each call to the template removes the first value. -->
  <xsl:param name="relcolvalues">
    <xsl:value-of select="parent::*/parent::*/@relcolwidth"/>
  </xsl:param>
  <xsl:choose>
    <!-- If the recursion has moved up to the proper cell, multiply $multiplier by the number of
         relative units for this column. -->
    <xsl:when test="$entry-num = $current-col">
      <xsl:variable name="relcol">
        <xsl:value-of select="substring-before($relcolvalues,'*')"/>
      </xsl:variable>
      <xsl:value-of select="$relcol * $multiplier"/>
    </xsl:when>
    <!-- Otherwise, call this template again, removing the first value form @relcolwidth. Also add one
         to $current-col. -->
    <xsl:otherwise>
      <xsl:call-template name="get-current-entry-percentage">
        <xsl:with-param name="multiplier">
          <xsl:value-of select="$multiplier"/>
        </xsl:with-param>
        <xsl:with-param name="entry-num">
          <xsl:value-of select="$entry-num"/>
        </xsl:with-param>
        <xsl:with-param name="current-col">
          <xsl:value-of select="$current-col + 1"/>
        </xsl:with-param>
        <xsl:with-param name="relcolvalues">
          <xsl:value-of select="substring-after($relcolvalues,' ')"/>
        </xsl:with-param>
      </xsl:call-template>
    </xsl:otherwise>
  </xsl:choose>
</xsl:template>
Template *[contains(@class,' topic/fn ')]topic.fn
Documentation

Description

 =========== FOOTNOTE =========== 
Namespace No namespace
Match *[contains(@class,' topic/fn ')]
Mode #default
Parameters
QName Namespace
xref No namespace
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/fn ')]" name="topic.fn">
  <xsl:param name="xref"/>
  <!-- when FN has an ID, it can only be referenced, otherwise, output an a-name & a counter -->
  <xsl:if test="not(@id) or $xref='yes'">
    <xsl:variable name="fnid">
      <xsl:number from="/" level="any"/>
    </xsl:variable>
    <xsl:variable name="callout">
      <xsl:value-of select="@callout"/>
    </xsl:variable>
    <xsl:variable name="convergedcallout">
      <xsl:choose>
        <xsl:when test="string-length($callout)>'0'">
          <xsl:value-of select="$callout"/>
        </xsl:when>
        <xsl:otherwise>
          <xsl:value-of select="$fnid"/>
        </xsl:otherwise>
      </xsl:choose>
    </xsl:variable>
    <a name="fnsrc_{$fnid}" href="#fntarg_{$fnid}">
      <sup>
        <xsl:value-of select="$convergedcallout"/>
      </sup>
    </a>
  </xsl:if>
</xsl:template>
Template *[contains(@class,' topic/required-cleanup ')]topic.required-cleanup
Documentation

Description

 =========== REQUIRED CLEANUP and REVIEW COMMENT =========== 
Namespace No namespace
Match *[contains(@class,' topic/required-cleanup ')]
Mode #default
References
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/required-cleanup ')]" name="topic.required-cleanup">
  <xsl:if test="$DRAFT='yes'">
    <xsl:variable name="flagrules">
      <xsl:call-template name="getrules"/>
    </xsl:variable>
    <xsl:apply-templates select="." mode="ditamsg:required-cleanup-in-content"/>
    <div style="background-color: #FFFF99; color:#CC3333; border: 1pt black solid;">
      <xsl:call-template name="commonattributes"/>
      <xsl:call-template name="gen-style">
        <xsl:with-param name="flagrules" select="$flagrules"/>
      </xsl:call-template>
      <xsl:call-template name="setidaname"/>
      <xsl:call-template name="start-flagit">
        <xsl:with-param name="flagrules" select="$flagrules"/>
      </xsl:call-template>
      <xsl:call-template name="start-revflag">
        <xsl:with-param name="flagrules" select="$flagrules"/>
      </xsl:call-template>
      <strong>
        <xsl:call-template name="getString">
          <xsl:with-param name="stringName" select="'Required cleanup'"/>
        </xsl:call-template>
        <xsl:call-template name="getString">
          <xsl:with-param name="stringName" select="'ColonSymbol'"/>
        </xsl:call-template>
        <xsl:text> </xsl:text>
      </strong>
      <xsl:if test="@remap">[<xsl:value-of select="@remap"/>] </xsl:if>
      <xsl:apply-templates/>
      <xsl:call-template name="end-revflag">
        <xsl:with-param name="flagrules" select="$flagrules"/>
      </xsl:call-template>
      <xsl:call-template name="end-flagit">
        <xsl:with-param name="flagrules" select="$flagrules"/>
      </xsl:call-template>
    </div>
    <xsl:value-of select="$newline"/>
  </xsl:if>
</xsl:template>
Template *[contains(@class,' topic/draft-comment ')]topic.draft-comment
Namespace No namespace
Match *[contains(@class,' topic/draft-comment ')]
Mode #default
References
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/draft-comment ')]" name="topic.draft-comment">
  <xsl:if test="$DRAFT='yes'">
    <xsl:variable name="flagrules">
      <xsl:call-template name="getrules"/>
    </xsl:variable>
    <xsl:apply-templates select="." mode="ditamsg:draft-comment-in-content"/>
    <div style="background-color: #99FF99; border: 1pt black solid;">
      <xsl:call-template name="commonattributes"/>
      <xsl:call-template name="gen-style">
        <xsl:with-param name="flagrules" select="$flagrules"/>
      </xsl:call-template>
      <xsl:call-template name="setidaname"/>
      <xsl:call-template name="start-flagit">
        <xsl:with-param name="flagrules" select="$flagrules"/>
      </xsl:call-template>
      <xsl:call-template name="start-revflag">
        <xsl:with-param name="flagrules" select="$flagrules"/>
      </xsl:call-template>
      <strong>
        <xsl:call-template name="getString">
          <xsl:with-param name="stringName" select="'Draft comment'"/>
        </xsl:call-template>
        <xsl:call-template name="getString">
          <xsl:with-param name="stringName" select="'ColonSymbol'"/>
        </xsl:call-template>
        <xsl:text> </xsl:text>
      </strong>
      <xsl:if test="@author">
        <xsl:value-of select="@author"/>
        <xsl:text> </xsl:text>
      </xsl:if>
      <xsl:if test="@disposition">
        <xsl:value-of select="@disposition"/>
        <xsl:text> </xsl:text>
      </xsl:if>
      <xsl:if test="@time">
        <xsl:value-of select="@time"/>
      </xsl:if>
      <br/>
      <xsl:apply-templates/>
      <xsl:call-template name="end-revflag">
        <xsl:with-param name="flagrules" select="$flagrules"/>
      </xsl:call-template>
      <xsl:call-template name="end-flagit">
        <xsl:with-param name="flagrules" select="$flagrules"/>
      </xsl:call-template>
    </div>
    <xsl:value-of select="$newline"/>
  </xsl:if>
</xsl:template>
Template processing-instruction()
Documentation

Description

Dita comment passthru
Namespace No namespace
Match processing-instruction()
Mode #default
Import precedence 4
Source
<xsl:template match="processing-instruction()">
  <xsl:if test="name()='dita-comment'">
    <xsl:comment>
      <xsl:value-of select="."/>
    </xsl:comment>
  </xsl:if>
</xsl:template>
Template *[contains(@class,' topic/indexterm ')]topic.indexterm
Documentation

Description

 =========== INDEX =========== 
 TBD: this needs practical implementation.  currently the support merely
     echoes the content back, indicating any nesting.  Useful view for authoring!
Namespace No namespace
Match *[contains(@class,' topic/indexterm ')]
Mode #default
References
Parameters INDEXSHOW; KEYREF-FILE
Template commonattributes
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/indexterm ')]" name="topic.indexterm">
  <xsl:if test="$INDEXSHOW='yes'">
    <xsl:variable name="keys">
      <xsl:value-of select="@keyref"/>
    </xsl:variable>
    <xsl:choose>
      <xsl:when test="@keyref and document($KEYREF-FILE)//*[contains(@keys, $keys)]">
        <xsl:variable name="updatedTarget">
          <xsl:apply-templates select="." mode="find-keyref-target"/>
        </xsl:variable>
        <a href="{$updatedTarget}">
          <span style="margin: 1pt; background-color: #ffddff; border: 1pt black solid;">
            <xsl:call-template name="commonattributes"/>
            <xsl:apply-templates/>
          </span>
        </a>
      </xsl:when>
      <xsl:otherwise>
        <span style="margin: 1pt; background-color: #ffddff; border: 1pt black solid;">
          <xsl:call-template name="commonattributes"/>
          <xsl:apply-templates/>
        </span>
      </xsl:otherwise>
    </xsl:choose>
  </xsl:if>
</xsl:template>
Template *[contains(@class,' topic/indexterm ')]text-only
Documentation

Description

 Index terms which may be inside of ph elements should not appear in text-only mode 
Namespace No namespace
Match *[contains(@class,' topic/indexterm ')]
Mode text-only
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/indexterm ')]" mode="text-only"/>
Template *[contains(@class,' topic/indextermref ')]
Namespace No namespace
Match *[contains(@class,' topic/indextermref ')]
Mode #default
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/indextermref ')]"/>
Template *[contains(@class,' topic/prolog ')]
Documentation

Description

 ===================================================================== 
 =========== PROLOG =========== 
 all handled in get-meta.xsl 
Namespace No namespace
Match *[contains(@class,' topic/prolog ')]
Mode #default
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/prolog ')]"/>
Template setidaname
Documentation

Description

 ===================================================================== 
 ================= COMMON ATTRIBUTE PROCESSORS ====================== 
 If the element has an ID, set it as an ID and anchor
 Set ID and output A-name 
Namespace No namespace
Used by
Templates gen-topic; topic.body; topic.boolean; topic.cite; topic.dd; topic.ddhd; topic.draft-comment; topic.dthd; topic.example; topic.hi-d.b; topic.hi-d.i; topic.hi-d.sub; topic.hi-d.sup; topic.hi-d.tt; topic.hi-d.u; topic.keyword; topic.li; topic.lq; topic.p; topic.ph; topic.pr-d.apiname; topic.pr-d.codeph; topic.pr-d.delim; topic.pr-d.kwd; topic.pr-d.oper; topic.pr-d.option; topic.pr-d.parmname; topic.pr-d.repsep; topic.pr-d.sep; topic.pr-d.synph; topic.pr-d.var; topic.required-cleanup; topic.section; topic.sli; topic.state; topic.sw-d.cmdname; topic.sw-d.filepath; topic.sw-d.msgnum; topic.sw-d.msgph; topic.sw-d.systemoutput; topic.sw-d.userinput; topic.sw-d.varname; topic.task.prereq; topic.task.taskbody; topic.ui-d.menucascade; topic.ui-d.shortcut; topic.ui-d.uicontrol; topic.ui-d.wintitle; topic.ut-d.imagemap; *chapterBody; *common-processing-phrase-within-link; *[contains(@class,' topic/fig ')]fig-fmt; *[contains(@class,' topic/figgroup ')]figgroup-fmt; *[contains(@class,' topic/lines ')]lines-fmt; *[contains(@class,' task/step ')]onestep-fmt; *[contains(@class,' topic/dt ')]output-dt; *[contains(@class,' topic/term ')]output-term; *[contains(@class,' topic/pre ')]pre-fmt; *process.note; *process.note.attention; *process.note.caution; *process.note.danger; *process.note.fastpath; *process.note.important; *process.note.other; *process.note.remember; *process.note.restriction; *process.note.tip; *[contains(@class,' ui-d/screen ')]screen-fmt; *[contains(@class,' task/step ')]steps-fmt; *[contains(@class,' task/substep ')]substep-fmt
References
Templates setanametag; setidattr
Import precedence 4
Source
<xsl:template name="setidaname">
  <xsl:if test="@id">
    <xsl:call-template name="setidattr">
      <xsl:with-param name="idvalue" select="@id"/>
    </xsl:call-template>
    <xsl:call-template name="setanametag">
      <xsl:with-param name="idvalue" select="@id"/>
    </xsl:call-template>
  </xsl:if>
</xsl:template>
Template setid
Documentation

Description

 Set ID only 
Namespace No namespace
Used by
References
Template setidattr
Import precedence 4
Source
<xsl:template name="setid">
  <xsl:if test="@id">
    <xsl:call-template name="setidattr">
      <xsl:with-param name="idvalue" select="@id"/>
    </xsl:call-template>
  </xsl:if>
</xsl:template>
Template setaname
Documentation

Description

 Set A-name only 
Namespace No namespace
Used by
References
Template setanametag
Import precedence 4
Source
<xsl:template name="setaname">
  <xsl:if test="@id">
    <xsl:call-template name="setanametag">
      <xsl:with-param name="idvalue" select="@id"/>
    </xsl:call-template>
  </xsl:if>
</xsl:template>
Template setidattr
Documentation

Description

 Set the ID attr for IE 
Namespace No namespace
Used by
Templates setid; setidaname
Parameters
QName Namespace
idvalue No namespace
Import precedence 4
Source
<xsl:template name="setidattr">
  <xsl:param name="idvalue"/>
  <xsl:attribute name="id">
    <!-- If we're in the body, prefix the ID with the topic's ID & two "_" -->
    <xsl:if test="ancestor::*[contains(@class,' topic/body ')]">
      <xsl:value-of select="ancestor::*[contains(@class,' topic/body ')]/parent::*/@id"/>
      <xsl:text>__</xsl:text>
    </xsl:if>
    <xsl:value-of select="$idvalue"/>
  </xsl:attribute>
</xsl:template>
Template setanametag
Documentation

Description

 Set the A-NAME attr for NS 
Namespace No namespace
Used by
Templates setaname; setidaname
References
Variable afill
Parameters
QName Namespace
idvalue No namespace
Import precedence 4
Source
<xsl:template name="setanametag">
  <xsl:param name="idvalue"/>
  <a>
    <xsl:attribute name="name">
      <xsl:if test="ancestor::*[contains(@class,' topic/body ')]">
        <xsl:value-of select="ancestor::*[contains(@class,' topic/body ')]/parent::*/@id"/>
        <xsl:text>__</xsl:text>
      </xsl:if>
      <xsl:value-of select="$idvalue"/>
    </xsl:attribute>
    <xsl:value-of select="$afill"/>
    <xsl:comment>
      <xsl:text> </xsl:text>
    </xsl:comment>
    <!-- fix for home page reader -->
  </a>
</xsl:template>
Template parent-id
Namespace No namespace
Used by
References
Variable afill
Import precedence 4
Source
<xsl:template name="parent-id">
  <!-- if the parent's element has an ID, copy it through as an anchor -->
  <a>
    <xsl:attribute name="name">
      <xsl:if test="ancestor::*[contains(@class,' topic/body ')]">
        <xsl:value-of select="ancestor::*[contains(@class,' topic/body ')]/parent::*/@id"/>
        <xsl:text>__</xsl:text>
      </xsl:if>
      <xsl:value-of select="parent::*/@id"/>
    </xsl:attribute>
    <xsl:value-of select="$afill"/>
    <xsl:comment>
      <xsl:text> </xsl:text>
    </xsl:comment>
    <!-- fix for home page reader -->
  </a>
</xsl:template>
Template gen-toc-id
Documentation

Description

 Create & insert an ID for the generated table of contents 
Namespace No namespace
Used by
Import precedence 4
Source
<xsl:template name="gen-toc-id">
</xsl:template>
Template commonattributes
Documentation

Description

 Process standard attributes that may appear anywhere. Previously this was "setclass" 
Namespace No namespace
Used by
Templates add-linking-attributes; doentry; dotable; gen-topic; makelink; place-fig-lbl; place-tbl-lbl; topic-image; topic.body; topic.boolean; topic.cite; topic.dd; topic.ddhd; topic.draft-comment; topic.dthd; topic.example; topic.hi-d.b; topic.hi-d.i; topic.hi-d.sub; topic.hi-d.sup; topic.hi-d.tt; topic.hi-d.u; topic.indexterm; topic.keyword; topic.li; topic.link_child; topic.link_orderedchild; topic.lq; topic.ol; topic.p; topic.ph; topic.pr-d.apiname; topic.pr-d.codeph; topic.pr-d.delim; topic.pr-d.kwd; topic.pr-d.oper; topic.pr-d.option; topic.pr-d.parmname; topic.pr-d.repsep; topic.pr-d.sep; topic.pr-d.synph; topic.pr-d.var; topic.q; topic.reference.property; topic.reference.prophead; topic.related-links; topic.required-cleanup; topic.row; topic.section; topic.section_title; topic.sli; topic.state; topic.sthead; topic.sthead_stentry; topic.strow; topic.strow_stentry; topic.sw-d.cmdname; topic.sw-d.filepath; topic.sw-d.msgnum; topic.sw-d.msgph; topic.sw-d.systemoutput; topic.sw-d.userinput; topic.sw-d.varname; topic.task.chdesc; topic.task.choption; topic.task.chrow; topic.task.prereq; topic.task.taskbody; topic.tbody; topic.thead; topic.ui-d.menucascade; topic.ui-d.shortcut; topic.ui-d.uicontrol; topic.ui-d.wintitle; topic.ut-d.imagemap; topic.xref; *[contains(@class,' task/stepsection ')]; *[contains(@class,' topic/topic ')]/*[contains(@class,' topic/title ')]; *[contains(@class, ' topic/link ')][@role='next' or @role='previous']breadcrumb; *[contains(@class,' task/choices ')]choices-fmt; *[contains(@class,' task/choicetable ')]choicetable-fmt; *common-processing-phrase-within-link; *[contains(@class,' topic/dl ')]dl-fmt; *[contains(@class,' topic/fig ')]fig-fmt; *[contains(@class,' topic/figgroup ')]figgroup-fmt; *[contains(@class,' topic/fn ')]genEndnote; *[contains(@class,' topic/lines ')]lines-fmt; *[contains(@class,' task/step ')]onestep-fmt; *[contains(@class,' topic/abstract ')]outofline; *[contains(@class,' topic/shortdesc ')]outofline; *[contains(@class,' topic/shortdesc ')]outofline.abstract; *[contains(@class,' topic/dt ')]output-dt; *[contains(@class,' topic/term ')]output-term; *[contains(@class,' topic/pre ')]pre-fmt; *[contains(@class,' pr-d/delim ')]process-syntaxdiagram; *[contains(@class,' pr-d/oper ')]process-syntaxdiagram; *[contains(@class,' pr-d/sep ')]process-syntaxdiagram; *[contains(@class,' pr-d/synblk ')]process-syntaxdiagram; *process.note; *process.note.attention; *process.note.caution; *process.note.danger; *process.note.fastpath; *process.note.important; *process.note.other; *process.note.remember; *process.note.restriction; *process.note.tip; *processlinklist; *propertiesEntry; *[contains(@class,' ui-d/screen ')]screen-fmt; *[contains(@class,' topic/simpletable ')]simpletable-fmt; *[contains(@class,' topic/sl ')]sl-fmt; *step-elements-with-no-stepsection; *[contains(@class,' task/step ')]steps-fmt; *[contains(@class,' task/substep ')]substep-fmt; *[contains(@class,' task/substeps ')]substeps-fmt; *[contains(@class,' topic/ul ')]ul-fmt
Parameters
QName Namespace
default-output-class No namespace
Import precedence 4
Source
<xsl:template name="commonattributes">
  <xsl:param name="default-output-class"/>
  <xsl:apply-templates select="@xml:lang"/>
  <xsl:apply-templates select="@dir"/>
  <xsl:apply-templates select="." mode="set-output-class">
    <xsl:with-param name="default" select="$default-output-class"/>
  </xsl:apply-templates>
</xsl:template>
Template *set-output-class
Documentation

Description

 Set the class attribute on the resulting output element. The default for a class of elements
     may be passed in with $default, but that default can be overridden with mode="get-output-class". 
Namespace No namespace
Match *
Mode set-output-class
References
Parameters
QName Namespace
default No namespace
Import precedence 4
Source
<xsl:template match="*" mode="set-output-class">
  <xsl:param name="default"/>
  <xsl:variable name="output-class">
    <xsl:apply-templates select="." mode="get-output-class"/>
  </xsl:variable>
  <xsl:variable name="using-output-class">
    <xsl:choose>
      <xsl:when test="string-length(normalize-space($output-class)) > 0">
        <xsl:value-of select="$output-class"/>
      </xsl:when>
      <xsl:when test="string-length(normalize-space($default)) > 0">
        <xsl:value-of select="$default"/>
      </xsl:when>
    </xsl:choose>
  </xsl:variable>
  <xsl:variable name="ancestry">
    <xsl:if test="$PRESERVE-DITA-CLASS='yes'">
      <xsl:apply-templates select="." mode="get-element-ancestry"/>
    </xsl:if>
  </xsl:variable>
  <xsl:variable name="outputclass-attribute">
    <xsl:apply-templates select="@outputclass" mode="get-value-for-class"/>
  </xsl:variable>
  <!-- Revised design with DITA-OT 1.5: include class ancestry if requested; 
       combine user output class with element default, giving priority to the user value. -->
  <xsl:if test="string-length(normalize-space(concat($outputclass-attribute,$using-output-class,$ancestry))) > 0">
    <xsl:attribute name="class">
      <xsl:value-of select="$ancestry"/>
      <xsl:if test="string-length(normalize-space($ancestry)) > 0 and                      string-length(normalize-space($using-output-class)) > 0">
        <xsl:text> </xsl:text>
      </xsl:if>
      <xsl:value-of select="$using-output-class"/>
      <xsl:if test="string-length(normalize-space(concat($ancestry,$using-output-class))) > 0 and                     string-length(normalize-space($outputclass-attribute)) > 0">
        <xsl:text> </xsl:text>
      </xsl:if>
      <xsl:value-of select="$outputclass-attribute"/>
    </xsl:attribute>
  </xsl:if>
</xsl:template>
Template @outputclass
Documentation

Description

 If an element has @outputclass, create a class value 
Namespace No namespace
Match @outputclass
Mode #default
Import precedence 4
Source
<xsl:template match="@outputclass">
  <xsl:attribute name="class">
    <xsl:value-of select="."/>
  </xsl:attribute>
</xsl:template>
Template @outputclassget-value-for-class
Documentation

Description

 Determine what @outputclass value goes into XHTML's @class. If the value should
     NOT fall through, override this template to remove it. 
Namespace No namespace
Match @outputclass
Mode get-value-for-class
Import precedence 4
Source
<xsl:template match="@outputclass" mode="get-value-for-class">
  <xsl:value-of select="."/>
</xsl:template>
Template *get-output-class
Documentation

Description

 Most elements don't get a class attribute. 
Namespace No namespace
Match *
Mode get-output-class
Import precedence 4
Source
<xsl:template match="*" mode="get-output-class"/>
Template *get-element-ancestry
Documentation

Description

 Get the ancestry of the current element (name only, not module) 
Namespace No namespace
Match *
Mode get-element-ancestry
References
Parameters
QName Namespace Select
checkclass No namespace @class
Import precedence 4
Source
<xsl:template match="*" mode="get-element-ancestry">
  <xsl:param name="checkclass" select="@class"/>
  <xsl:if test="contains($checkclass,'/')">
    <xsl:variable name="lastpair">
      <xsl:call-template name="get-last-class-pair">
        <xsl:with-param name="checkclass" select="$checkclass"/>
      </xsl:call-template>
    </xsl:variable>
    <!-- If there are any module/element pairs before the last one, process them and add a space -->
    <xsl:if test="contains(substring-before($checkclass,$lastpair),'/')">
      <xsl:apply-templates select="." mode="get-element-ancestry">
        <xsl:with-param name="checkclass" select="substring-before($checkclass,$lastpair)"/>
      </xsl:apply-templates>
      <xsl:text> </xsl:text>
    </xsl:if>
    <xsl:value-of select="substring-after($lastpair,'/')"/>
  </xsl:if>
</xsl:template>
Template get-last-class-pair
Documentation

Description

 Find the last module/element pair in a class string 
Namespace No namespace
Used by
References
Parameters
QName Namespace Select
checkclass No namespace @class
Import precedence 4
Source
<xsl:template name="get-last-class-pair">
  <xsl:param name="checkclass" select="@class"/>
  <xsl:choose>
    <xsl:when test="contains(substring-after($checkclass,' '),'/')">
      <xsl:call-template name="get-last-class-pair">
        <xsl:with-param name="checkclass" select="substring-after($checkclass,' ')"/>
      </xsl:call-template>
    </xsl:when>
    <xsl:when test="contains($checkclass,'/')">
      <xsl:value-of select="normalize-space($checkclass)"/>
    </xsl:when>
    <xsl:otherwise>
      <!-- Error condition -->
    </xsl:otherwise>
  </xsl:choose>
</xsl:template>
Template @xml:lang
Documentation

Description

 If an element has @xml:lang, copy it to the output 
Namespace No namespace
Match @xml:lang
Mode #default
Import precedence 4
Source
<xsl:template match="@xml:lang">
  <xsl:attribute name="xml:lang">
    <xsl:value-of select="."/>
  </xsl:attribute>
</xsl:template>
Template @dir
Documentation

Description

 If an element has @dir, copy it to the output 
Namespace No namespace
Match @dir
Mode #default
Import precedence 4
Source
<xsl:template match="@dir">
  <xsl:attribute name="dir">
    <xsl:value-of select="."/>
  </xsl:attribute>
</xsl:template>
Template @compact
Documentation

Description

 if the element has a compact=yes attribute, assert it in XHTML form 
Namespace No namespace
Match @compact
Mode #default
Import precedence 4
Source
<xsl:template match="@compact">
  <xsl:if test=". = 'yes'">
    <xsl:attribute name="compact">compact</xsl:attribute>
    <!-- assumes that no compaction is default -->
  </xsl:if>
</xsl:template>
Template setscale
Namespace No namespace
Used by
Import precedence 4
Source
<xsl:template name="setscale">
  <xsl:if test="@scale">
    <!--    <xsl:attribute name="style">font-size: <xsl:value-of select="@scale"/>%;</xsl:attribute> -->
  </xsl:if>
</xsl:template>
Template *topic.undefined_element
Documentation

Description

 ===================================================================== 
 ========== GENERAL SUPPORT/DOC CONTENT MANAGEMENT          ========== 
 ===================================================================== 
 =========== CATCH UNDEFINED ELEMENTS (for stylesheet maintainers) =========== 
 (this rule should NOT produce output in production setting) 
Namespace No namespace
Match *
Mode #default
Import precedence 4
Source
<xsl:template match="*" name="topic.undefined_element">
  <span style="background-color: yellow;">
    <span style="font-weight: bold">
      <xsl:text>[</xsl:text>
      <xsl:for-each select="ancestor-or-self::*">
        <xsl:text>/</xsl:text>
        <xsl:value-of select="name()"/>
      </xsl:for-each>
     {"<xsl:value-of select="@class"/>"}<xsl:text>) </xsl:text>
    </span>
    <xsl:apply-templates/>
    <span style="font-weight: bold">
      <xsl:text> (</xsl:text>
      <xsl:value-of select="name()"/>
      <xsl:text>]</xsl:text>
    </span>
  </span>
</xsl:template>
Template script-sample
Documentation

Description

 =========== CONREF (content fetched by id from conrefed element) =========== 
 conref processing is now done in the first stage & conref.xsl 
 ========== JAVASCRIPT SUPPORT ========== 
Namespace No namespace
Import precedence 4
Source
<xsl:template name="script-sample">
  <script language="JavaScript">
    <xsl:comment>
  // define JavaScript within here; use CDATA sections as appropriate
  self.focus();
  function popwin(popupitem)
  {
         var PopUpWin=window.open(popupitem,"PopUpWin","toolbar=no,directories=no,menubar=no,status=no,scrollbars=yes,resizable=yes,width=500,height=200");
         PopUpWin.focus();
  }
//</xsl:comment>
  </script>
</xsl:template>
Template spec-title
Documentation

Description

 ========= NAMED TEMPLATES (call by name, only) ========== 
 named templates that can be used anywhere 
 Process spectitle attribute - if one exists - needs to be called on tags that allow it 
Namespace No namespace
Used by
Import precedence 4
Source
<xsl:template name="spec-title">
  <xsl:if test="@spectitle">
    <div style="margin-top: 1em;">
      <strong>
        <xsl:value-of select="@spectitle"/>
      </strong>
    </div>
  </xsl:if>
</xsl:template>
Template spec-title-nospace
Namespace No namespace
Used by
Import precedence 4
Source
<xsl:template name="spec-title-nospace">
  <xsl:if test="@spectitle">
    <div style="margin-bottom: 0;">
      <strong>
        <xsl:value-of select="@spectitle"/>
      </strong>
    </div>
  </xsl:if>
</xsl:template>
Template spec-title-cell
Namespace No namespace
Import precedence 4
Source
<xsl:template name="spec-title-cell">
  <!-- not used - was a cell 'title' -->
  <xsl:if test="@specentry">
    <xsl:value-of select="@specentry"/>
    <xsl:text> </xsl:text>
  </xsl:if>
</xsl:template>
Template copyright
Namespace No namespace
Used by
Template *chapterHead
Import precedence 4
Source
<xsl:template name="copyright">
</xsl:template>
Template br-replace
Documentation

Description

 Break replace - used for LINES 
 this replaces newlines with the BR element. Forces breaks. 
Namespace No namespace
Used by
References
Template br-replace
Parameters
QName Namespace
brtext No namespace
Import precedence 4
Source
<xsl:template name="br-replace">
  <xsl:param name="brtext"/>
  <!-- capture an actual newline within the xsl:text element -->
  <xsl:variable name="cr">
    <xsl:text>
</xsl:text>
  </xsl:variable>
  <xsl:choose>
    <xsl:when test="contains($brtext,$cr)">
      <xsl:value-of select="substring-before($brtext,$cr)"/>
      <br/>
      <xsl:value-of select="$cr"/>
      <xsl:call-template name="br-replace">
        <!-- call again to get remaining CRs -->
        <xsl:with-param name="brtext" select="substring-after($brtext,$cr)"/>
      </xsl:call-template>
    </xsl:when>
    <xsl:otherwise>
      <xsl:value-of select="$brtext"/>
      <!-- No CRs, just output -->
    </xsl:otherwise>
  </xsl:choose>
</xsl:template>
Template sp-replace
Documentation

Description

 Space replace - used for LINES 
 add checks for repeating leading blanks & converts them to &nbsp;&nbsp; 
 this replaces newlines with the BR element. Forces breaks. 
Namespace No namespace
Used by
References
Template sp-replace
Parameters
QName Namespace
sptext No namespace
Import precedence 4
Source
<xsl:template name="sp-replace">
  <xsl:param name="sptext"/>
  <!-- capture 2 spaces -->
  <xsl:choose>
    <xsl:when test="contains($sptext,'  ')">
      <xsl:value-of select="substring-before($sptext,'  ')"/>
      <xsl:text disable-output-escaping="yes">&nbsp;&nbsp;
      </xsl:text>
      <xsl:call-template name="sp-replace">
        <!-- call again to get remaining spaces -->
        <xsl:with-param name="sptext" select="substring-after($sptext,'  ')"/>
      </xsl:call-template>
    </xsl:when>
    <xsl:otherwise>
      <xsl:value-of select="$sptext"/>
      <!-- No spaces, just output -->
    </xsl:otherwise>
  </xsl:choose>
</xsl:template>
Template breadcrumbs
Documentation

Description

 diagnostic: call this to generate a path-like view of an element's ancestry 
Namespace No namespace
Import precedence 4
Source
<xsl:template name="breadcrumbs">
  <xsl:variable name="full-path">
    <xsl:for-each select="ancestor-or-self::*">
      <xsl:value-of select="concat('/',name())"/>
    </xsl:for-each>
  </xsl:variable>
  <p>
    <strong>
      <xsl:value-of select="$full-path"/>
    </strong>
  </p>
</xsl:template>
Template *text-only
Documentation

Description

 the following named templates generate inline content for the delivery context 
 named templates for labels and titles related to topic structures 
 test processors for HTML title element 
Namespace No namespace
Match *
Mode text-only
Import precedence 4
Source
<xsl:template match="*" mode="text-only">
  <xsl:apply-templates select="text()|*" mode="text-only"/>
</xsl:template>
Template *[contains(@class,' topic/image ')]text-only
Documentation

Description

 for artwork in a title, get the alt text 
Namespace No namespace
Match *[contains(@class,' topic/image ')]
Mode text-only
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/image ')]" mode="text-only">
  <xsl:choose>
    <xsl:when test="*[contains(@class,' topic/alt ')]">
      <xsl:apply-templates mode="text-only"/>
    </xsl:when>
    <xsl:when test="@alt">
      <xsl:value-of select="@alt"/>
    </xsl:when>
  </xsl:choose>
</xsl:template>
Template *[contains(@class,' topic/boolean ')]text-only
Documentation

Description

 for boolean in a title, set the text 
Namespace No namespace
Match *[contains(@class,' topic/boolean ')]
Mode text-only
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/boolean ')]" mode="text-only">
  <xsl:value-of select="name()"/>
  <xsl:text>: </xsl:text>
  <xsl:value-of select="@state"/>
</xsl:template>
Template *[contains(@class,' topic/state ')]text-only
Documentation

Description

 for state in a title, set the text 
Namespace No namespace
Match *[contains(@class,' topic/state ')]
Mode text-only
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/state ')]" mode="text-only">
  <xsl:value-of select="name()"/>
  <xsl:text>: </xsl:text>
  <xsl:value-of select="@name"/>
  <xsl:text>=</xsl:text>
  <xsl:value-of select="@value"/>
</xsl:template>
Template *[contains(@class,' topic/fn ')]text-only
Documentation

Description

 Footnote as text-only should just create the number 
Namespace No namespace
Match *[contains(@class,' topic/fn ')]
Mode text-only
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/fn ')]" mode="text-only">
  <xsl:variable name="fnid">
    <xsl:number from="/" level="any"/>
  </xsl:variable>
  <xsl:choose>
    <xsl:when test="@callout">(
      <xsl:value-of select="@callout"/>)</xsl:when>
    <xsl:otherwise>(
      <xsl:value-of select="$fnid"/>)</xsl:otherwise>
  </xsl:choose>
</xsl:template>
Template sect-heading
Documentation

Description

 Process a section heading - H4 based on: 1) title element 2) @spectitle attr 
 DITA-OT 1.5: Deprecate this template in favor of a moded template, which allows
     easier generated headings for a specific specialized section                 
Namespace No namespace
Used by
Parameters
QName Namespace
defaulttitle No namespace
Import precedence 4
Source
<xsl:template name="sect-heading">
  <xsl:param name="defaulttitle"/>
  <!-- get param by reference -->
  <!-- Deprecated in favor of the mode template -->
  <xsl:apply-templates select="." mode="dita2html:section-heading">
    <xsl:with-param name="defaulttitle" select="$defaulttitle"/>
  </xsl:apply-templates>
</xsl:template>
Template *{http://dita-ot.sourceforge.net/ns/200801/dita2html}section-heading
Namespace No namespace
Match *
Mode {http://dita-ot.sourceforge.net/ns/200801/dita2html}section-heading
Parameters
QName Namespace
defaulttitle No namespace
Import precedence 4
Source
<xsl:template match="*" mode="dita2html:section-heading">
  <xsl:param name="defaulttitle"/>
  <!-- get param by reference -->
  <xsl:variable name="heading">
    <xsl:choose>
      <xsl:when test="*[contains(@class,' topic/title ')]">
        <xsl:apply-templates select="*[contains(@class,' topic/title ')][1]" mode="text-only"/>
        <xsl:if test="*[contains(@class,' topic/title ')][2]">
          <xsl:apply-templates select="." mode="ditamsg:section-with-multiple-titles"/>
        </xsl:if>
      </xsl:when>
      <xsl:when test="@spectitle">
        <xsl:value-of select="@spectitle"/>
      </xsl:when>
      <xsl:otherwise/>
    </xsl:choose>
  </xsl:variable>
  <xsl:variable name="headCount">
    <xsl:value-of select="count(ancestor::*[contains(@class,' topic/topic ')])+1"/>
  </xsl:variable>
  <xsl:variable name="headLevel">
    <xsl:choose>
      <xsl:when test="$headCount > 6">h6</xsl:when>
      <xsl:otherwise>h
        <xsl:value-of select="$headCount"/>
      </xsl:otherwise>
    </xsl:choose>
  </xsl:variable>
  <!-- based on graceful defaults, build an appropriate section-level heading -->
  <xsl:choose>
    <xsl:when test="not($heading='')">
      <xsl:if test="normalize-space($heading)=''">
        <!-- hack: a title with whitespace ALWAYS overrides as null -->
        <xsl:comment>no heading</xsl:comment>
      </xsl:if>
      <xsl:apply-templates select="*[contains(@class,' topic/title ')][1]">
        <xsl:with-param name="headLevel" select="$headLevel"/>
      </xsl:apply-templates>
      <xsl:if test="@spectitle and not(*[contains(@class,' topic/title ')])">
        <xsl:element name="{$headLevel}">
          <xsl:attribute name="class">sectiontitle</xsl:attribute>
          <xsl:value-of select="@spectitle"/>
        </xsl:element>
      </xsl:if>
    </xsl:when>
    <xsl:when test="$defaulttitle">
      <xsl:element name="{$headLevel}">
        <xsl:attribute name="class">sectiontitle</xsl:attribute>
        <xsl:value-of select="$defaulttitle"/>
      </xsl:element>
    </xsl:when>
    <xsl:otherwise/>
  </xsl:choose>
</xsl:template>
Template *[contains(@class,' topic/section ')]/*[contains(@class,' topic/title ')] | *[contains(@class,' topic/example ')]/*[contains(@class,' topic/title ')]topic.section_title
Namespace No namespace
Match *[contains(@class,' topic/section ')]/*[contains(@class,' topic/title ')] | *[contains(@class,' topic/example ')]/*[contains(@class,' topic/title ')]
Mode #default
References
Template commonattributes
Parameters
QName Namespace
headLevel No namespace
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/section ')]/*[contains(@class,' topic/title ')] |   *[contains(@class,' topic/example ')]/*[contains(@class,' topic/title ')]" name="topic.section_title">
  <xsl:param name="headLevel">
    <xsl:variable name="headCount">
      <xsl:value-of select="count(ancestor::*[contains(@class,' topic/topic ')])+1"/>
    </xsl:variable>
    <xsl:choose>
      <xsl:when test="$headCount > 6">h6</xsl:when>
      <xsl:otherwise>h
        <xsl:value-of select="$headCount"/>
      </xsl:otherwise>
    </xsl:choose>
  </xsl:param>
  <xsl:element name="{$headLevel}">
    <xsl:attribute name="class">sectiontitle</xsl:attribute>
    <xsl:call-template name="commonattributes"/>
    <xsl:apply-templates/>
  </xsl:element>
</xsl:template>
Template bidi-area
Documentation

Description

 Test for in BIDI area: returns "bidi" when parent's @xml:lang is a bidi language;
     Otherwise, leave blank 
Namespace No namespace
Used by
References
Template getLowerCaseLang
Parameters
QName Namespace
parentlang No namespace
Import precedence 4
Source
<xsl:template name="bidi-area">
  <xsl:param name="parentlang">
    <xsl:call-template name="getLowerCaseLang"/>
  </xsl:param>
  <xsl:variable name="direction">
    <xsl:apply-templates select="." mode="get-render-direction">
      <xsl:with-param name="lang" select="$parentlang"/>
    </xsl:apply-templates>
  </xsl:variable>
  <xsl:choose>
    <xsl:when test="$direction='rtl'">bidi</xsl:when>
    <xsl:otherwise/>
  </xsl:choose>
</xsl:template>
Template url-string
Documentation

Description

 Test for URL: returns "url" when the content starts with a URL;
     Otherwise, leave blank 
Namespace No namespace
Used by
Template generateCssLinks
Parameters
QName Namespace
urltext No namespace
Import precedence 4
Source
<xsl:template name="url-string">
  <xsl:param name="urltext"/>
  <xsl:choose>
    <xsl:when test="contains($urltext,'http://')">url</xsl:when>
    <xsl:when test="contains($urltext,'https://')">url</xsl:when>
    <xsl:otherwise/>
  </xsl:choose>
</xsl:template>
Template /divadd-HDF
Documentation

Description

 For header file processing, pull out the wrapping DIV if one is there 
Namespace No namespace
Match /div
Mode add-HDF
Import precedence 4
Source
<xsl:template match="/div" mode="add-HDF">
  <xsl:apply-templates select="*|comment()|processing-instruction()|text()" mode="add-HDF"/>
</xsl:template>
Template *|@*|comment()|processing-instruction()|text()add-HDF
Namespace No namespace
Match *|@*|comment()|processing-instruction()|text()
Mode add-HDF
Import precedence 4
Source
<xsl:template match="*|@*|comment()|processing-instruction()|text()" mode="add-HDF">
  <xsl:copy>
    <xsl:apply-templates select="*|@*|comment()|processing-instruction()|text()" mode="add-HDF"/>
  </xsl:copy>
</xsl:template>
Template gen-endnotes
Documentation

Description

 ========== Section-like generated content =========== 
 render any contained footnotes as endnotes.  Links back to reference point 
Namespace No namespace
Used by
Template *chapterBody
References
Parameter DRAFT
Import precedence 4
Source
<xsl:template name="gen-endnotes">
  <!-- Skip any footnotes that are in draft elements when draft = no -->
  <xsl:apply-templates select="//*[contains(@class,' topic/fn ')][not( (ancestor::*[contains(@class,' topic/draft-comment ')] or ancestor::*[contains(@class,' topic/required-cleanup ')]) and $DRAFT='no')]" mode="genEndnote"/>
</xsl:template>
Template *[contains(@class,' topic/fn ')]genEndnote
Documentation

Description

 Catch footnotes that should appear at the end of the topic, and output them. 
Namespace No namespace
Match *[contains(@class,' topic/fn ')]
Mode genEndnote
References
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/fn ')]" mode="genEndnote">
  <xsl:variable name="flagrules">
    <xsl:call-template name="getrules"/>
  </xsl:variable>
  <div class="p">
    <xsl:variable name="fnid">
      <xsl:number from="/" level="any"/>
    </xsl:variable>
    <xsl:variable name="callout">
      <xsl:value-of select="@callout"/>
    </xsl:variable>
    <xsl:variable name="convergedcallout">
      <xsl:choose>
        <xsl:when test="string-length($callout)>'0'">
          <xsl:value-of select="$callout"/>
        </xsl:when>
        <xsl:otherwise>
          <xsl:value-of select="$fnid"/>
        </xsl:otherwise>
      </xsl:choose>
    </xsl:variable>
    <xsl:call-template name="commonattributes"/>
    <xsl:call-template name="gen-style">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
    <xsl:choose>
      <xsl:when test="@id and not(@id='')">
        <xsl:variable name="topicid">
          <xsl:value-of select="ancestor::*[contains(@class,' topic/topic ')][1]/@id"/>
        </xsl:variable>
        <xsl:variable name="refid">
          <xsl:value-of select="$topicid"/>
          <xsl:text>/</xsl:text>
          <xsl:value-of select="@id"/>
        </xsl:variable>
        <xsl:choose>
          <xsl:when test="key('xref',$refid)">
            <a>
              <xsl:call-template name="setid"/>
              <sup>
                <xsl:value-of select="$convergedcallout"/>
              </sup>
            </a>
            <xsl:text>  </xsl:text>
          </xsl:when>
          <xsl:otherwise>
            <sup>
              <xsl:value-of select="$convergedcallout"/>
            </sup>
            <xsl:text>  </xsl:text>
          </xsl:otherwise>
        </xsl:choose>
      </xsl:when>
      <xsl:otherwise>
        <a>
          <xsl:attribute name="name">
            <xsl:text>fntarg_</xsl:text>
            <xsl:value-of select="$fnid"/>
          </xsl:attribute>
          <xsl:attribute name="href">
            <xsl:text>#fnsrc_</xsl:text>
            <xsl:value-of select="$fnid"/>
          </xsl:attribute>
          <sup>
            <xsl:value-of select="$convergedcallout"/>
          </sup>
        </a>
        <xsl:text>  </xsl:text>
      </xsl:otherwise>
    </xsl:choose>
    <xsl:call-template name="start-flagit">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
    <xsl:call-template name="start-revflag">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
    <xsl:apply-templates/>
    <xsl:call-template name="end-revflag">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
    <xsl:call-template name="end-flagit">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
  </div>
</xsl:template>
Template gen-toc
Documentation

Description

 listing of topics from calling context only; can be expanded for nesting 
Namespace No namespace
References
Template getString
Import precedence 4
Source
<xsl:template name="gen-toc">
  <div>
    <h3 class="sectiontitle">
      <xsl:call-template name="getString">
        <xsl:with-param name="stringName" select="'Contents'"/>
      </xsl:call-template>
    </h3>
    <ul>
      <xsl:for-each select="//topic/title">
        <li>
          <!-- this directive provides a "depth" indicator without doing recursive nesting -->
          <xsl:value-of select="substring('------',1,count(ancestor::*))"/>
          <a>
            <xsl:attribute name="href">#<xsl:value-of select="generate-id()"/></xsl:attribute>
            <xsl:value-of select="."/>
          </a>
          <!--recursive call for subtopics here"/-->
        </li>
      </xsl:for-each>
    </ul>
  </div>
</xsl:template>
Template place-tbl-width
Documentation

Description

 values: yes, no (or any not "yes") 
 ========== "FORMAT" MACROS  - Table title, figure title, InfoNavGraphic ========== 
 | These macros support globally-defined formatting constants for
 | document content.  Some elements have attributes that permit local
 | control of formatting; such logic is part of the pertinent template rule.
 +
Namespace No namespace
Import precedence 4
Source
<xsl:template name="place-tbl-width">
  <!-- was 540 now 100% -->
  <xsl:variable name="twidth-fixed">100%</xsl:variable>
  <xsl:if test="$twidth-fixed != ''">
    <xsl:attribute name="width">
      <xsl:value-of select="$twidth-fixed"/>
    </xsl:attribute>
  </xsl:if>
</xsl:template>
Template place-tbl-lbl
Documentation

Description

 table caption 
Namespace No namespace
Used by
Template dotable
References
Parameters
QName Namespace
stringName No namespace
Import precedence 4
Source
<xsl:template name="place-tbl-lbl">
  <xsl:param name="stringName"/>
  <!-- Number of table/title's before this one -->
  <xsl:variable name="tbl-count-actual" select="count(preceding::*[contains(@class,' topic/table ')]/*[contains(@class,' topic/title ')])+1"/>
  <!-- normally: "Table 1. " -->
  <xsl:variable name="ancestorlang">
    <xsl:call-template name="getLowerCaseLang"/>
  </xsl:variable>
  <xsl:choose>
    <!-- title -or- title & desc -->
    <xsl:when test="*[contains(@class,' topic/title ')]">
      <caption>
        <span class="tablecap">
          <xsl:choose>
            <!-- Hungarian: "1. Table " -->
            <xsl:when test="( (string-length($ancestorlang)=5 and contains($ancestorlang,'hu-hu')) or (string-length($ancestorlang)=2 and contains($ancestorlang,'hu')) )">
              <xsl:value-of select="$tbl-count-actual"/>
              <xsl:text>. </xsl:text>
              <xsl:call-template name="getString">
                <xsl:with-param name="stringName" select="'Table'"/>
              </xsl:call-template>
              <xsl:text> </xsl:text>
            </xsl:when>
            <xsl:otherwise>
              <xsl:call-template name="getString">
                <xsl:with-param name="stringName" select="'Table'"/>
              </xsl:call-template>
              <xsl:text> </xsl:text>
              <xsl:value-of select="$tbl-count-actual"/>
              <xsl:text>. </xsl:text>
            </xsl:otherwise>
          </xsl:choose>
          <xsl:apply-templates select="./*[contains(@class,' topic/title ')]" mode="tabletitle"/>
        </span>
        <xsl:if test="*[contains(@class,' topic/desc ')]">
          <xsl:text>. </xsl:text>
          <span class="tabledesc">
            <xsl:for-each select="./*[contains(@class,' topic/desc ')]">
              <xsl:call-template name="commonattributes"/>
            </xsl:for-each>
            <xsl:apply-templates select="./*[contains(@class,' topic/desc ')]" mode="tabledesc"/>
          </span>
        </xsl:if>
      </caption>
    </xsl:when>
    <!-- desc -->
    <xsl:when test="*[contains(@class,' topic/desc ')]">
      <span class="tabledesc">
        <xsl:for-each select="./*[contains(@class,' topic/desc ')]">
          <xsl:call-template name="commonattributes"/>
        </xsl:for-each>
        <xsl:apply-templates select="./*[contains(@class,' topic/desc ')]" mode="tabledesc"/>
      </span>
    </xsl:when>
  </xsl:choose>
</xsl:template>
Template *[contains(@class,' topic/table ')]/*[contains(@class,' topic/title ')]tabletitle
Namespace No namespace
Match *[contains(@class,' topic/table ')]/*[contains(@class,' topic/title ')]
Mode tabletitle
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/table ')]/*[contains(@class,' topic/title ')]" mode="tabletitle">
  <xsl:apply-templates/>
</xsl:template>
Template *[contains(@class,' topic/table ')]/*[contains(@class,' topic/desc ')]tabledesc
Namespace No namespace
Match *[contains(@class,' topic/table ')]/*[contains(@class,' topic/desc ')]
Mode tabledesc
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/table ')]/*[contains(@class,' topic/desc ')]" mode="tabledesc">
  <xsl:apply-templates/>
</xsl:template>
Template *[contains(@class,' topic/table ')]/*[contains(@class,' topic/desc ')]get-output-class
Namespace No namespace
Match *[contains(@class,' topic/table ')]/*[contains(@class,' topic/desc ')]
Mode get-output-class
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/table ')]/*[contains(@class,' topic/desc ')]" mode="get-output-class">tabledesc</xsl:template>
Template *[contains(@class,' topic/table ')]/*[contains(@class,' topic/title ')]topic.table_title
Documentation

Description

 These 2 rules are not actually used, but could be picked up by an override 
Namespace No namespace
Match *[contains(@class,' topic/table ')]/*[contains(@class,' topic/title ')]
Mode #default
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/table ')]/*[contains(@class,' topic/title ')]" name="topic.table_title">
  <span>
    <xsl:apply-templates/>
  </span>
</xsl:template>
Template *[contains(@class,' topic/table ')]/*[contains(@class,' topic/desc ')]topic.table_desc
Documentation

Description

 These rules are not actually used, but could be picked up by an override 
Namespace No namespace
Match *[contains(@class,' topic/table ')]/*[contains(@class,' topic/desc ')]
Mode #default
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/table ')]/*[contains(@class,' topic/desc ')]" name="topic.table_desc">
  <span>
    <xsl:apply-templates/>
  </span>
</xsl:template>
Template place-fig-lbl
Documentation

Description

 Figure caption 
Namespace No namespace
Used by
References
Parameters
QName Namespace
stringName No namespace
Import precedence 4
Source
<xsl:template name="place-fig-lbl">
  <xsl:param name="stringName"/>
  <!-- Number of fig/title's including this one -->
  <xsl:variable name="fig-count-actual" select="count(preceding::*[contains(@class,' topic/fig ')]/*[contains(@class,' topic/title ')])+1"/>
  <xsl:variable name="ancestorlang">
    <xsl:call-template name="getLowerCaseLang"/>
  </xsl:variable>
  <xsl:choose>
    <!-- title -or- title & desc -->
    <xsl:when test="*[contains(@class,' topic/title ')]">
      <span class="figcap">
        <xsl:choose>
          <!-- Hungarian: "1. Figure " -->
          <xsl:when test="( (string-length($ancestorlang)=5 and contains($ancestorlang,'hu-hu')) or (string-length($ancestorlang)=2 and contains($ancestorlang,'hu')) )">
            <xsl:value-of select="$fig-count-actual"/>
            <xsl:text>. </xsl:text>
            <xsl:call-template name="getString">
              <xsl:with-param name="stringName" select="'Figure'"/>
            </xsl:call-template>
            <xsl:text> </xsl:text>
          </xsl:when>
          <xsl:otherwise>
            <xsl:call-template name="getString">
              <xsl:with-param name="stringName" select="'Figure'"/>
            </xsl:call-template>
            <xsl:text> </xsl:text>
            <xsl:value-of select="$fig-count-actual"/>
            <xsl:text>. </xsl:text>
          </xsl:otherwise>
        </xsl:choose>
        <xsl:apply-templates select="./*[contains(@class,' topic/title ')]" mode="figtitle"/>
      </span>
      <xsl:if test="*[contains(@class,' topic/desc ')]">
        <xsl:text>. </xsl:text>
        <span class="figdesc">
          <xsl:for-each select="./*[contains(@class,' topic/desc ')]">
            <xsl:call-template name="commonattributes"/>
          </xsl:for-each>
          <xsl:apply-templates select="./*[contains(@class,' topic/desc ')]" mode="figdesc"/>
        </span>
      </xsl:if>
    </xsl:when>
    <!-- desc -->
    <xsl:when test="*[contains(@class, ' topic/desc ')]">
      <span class="figdesc">
        <xsl:for-each select="./*[contains(@class,' topic/desc ')]">
          <xsl:call-template name="commonattributes"/>
        </xsl:for-each>
        <xsl:apply-templates select="./*[contains(@class,' topic/desc ')]" mode="figdesc"/>
      </span>
    </xsl:when>
  </xsl:choose>
</xsl:template>
Template *[contains(@class,' topic/fig ')]/*[contains(@class,' topic/title ')]figtitle
Namespace No namespace
Match *[contains(@class,' topic/fig ')]/*[contains(@class,' topic/title ')]
Mode figtitle
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/fig ')]/*[contains(@class,' topic/title ')]" mode="figtitle">
  <xsl:apply-templates/>
</xsl:template>
Template *[contains(@class,' topic/fig ')]/*[contains(@class,' topic/desc ')]figdesc
Namespace No namespace
Match *[contains(@class,' topic/fig ')]/*[contains(@class,' topic/desc ')]
Mode figdesc
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/fig ')]/*[contains(@class,' topic/desc ')]" mode="figdesc">
  <xsl:apply-templates/>
</xsl:template>
Template *[contains(@class,' topic/fig ')]/*[contains(@class,' topic/desc ')]get-output-class
Namespace No namespace
Match *[contains(@class,' topic/fig ')]/*[contains(@class,' topic/desc ')]
Mode get-output-class
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/fig ')]/*[contains(@class,' topic/desc ')]" mode="get-output-class">figdesc</xsl:template>
Template *[contains(@class,' topic/fig ')]/*[contains(@class,' topic/title ')]topic.fig_title
Documentation

Description

 These 2 rules are not actually used, but could be picked up by an override 
Namespace No namespace
Match *[contains(@class,' topic/fig ')]/*[contains(@class,' topic/title ')]
Mode #default
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/fig ')]/*[contains(@class,' topic/title ')]" name="topic.fig_title">
  <span>
    <xsl:apply-templates/>
  </span>
</xsl:template>
Template *[contains(@class,' topic/fig ')]/*[contains(@class,' topic/desc ')]topic.fig_desc
Documentation

Description

 These rules are not actually used, but could be picked up by an override 
Namespace No namespace
Match *[contains(@class,' topic/fig ')]/*[contains(@class,' topic/desc ')]
Mode #default
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/fig ')]/*[contains(@class,' topic/desc ')]" name="topic.fig_desc">
  <span>
    <xsl:apply-templates/>
  </span>
</xsl:template>
Template *[contains(@class,' topic/figgroup ')]/*[contains(@class,' topic/title ')]topic.figgroup_title
Namespace No namespace
Match *[contains(@class,' topic/figgroup ')]/*[contains(@class,' topic/title ')]
Mode #default
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/figgroup ')]/*[contains(@class,' topic/title ')]" name="topic.figgroup_title">
  <xsl:apply-templates/>
</xsl:template>
Template proc-ing
Namespace No namespace
References
Variable do-place-ing
Import precedence 4
Source
<xsl:template name="proc-ing">
  <xsl:if test="$do-place-ing = 'yes'">
    <!-- set in a global variable, as with label placement, etc. -->
    <img src="tip-ing.jpg" alt="tip-ing.jpg"/>
    <!-- this should be an xsl:choose with the approved list and a selection method-->
    <!-- add any other required positioning controls, if needed, but must be valid in the location
         from which the call to this template was made -->
    <xsl:text disable-output-escaping="yes">&#xA0;</xsl:text>
  </xsl:if>
</xsl:template>
Template gen-user-head
Documentation

Description

 ===================================================================== 
 ========== STUBS FOR USER PROVIDED OVERRIDE EXTENSIONS ========== 
Namespace No namespace
Used by
Template *chapterHead
Import precedence 4
Source
<xsl:template name="gen-user-head">
  <xsl:apply-templates select="." mode="gen-user-head"/>
</xsl:template>
Template /|node()|@*gen-user-head
Namespace No namespace
Match /|node()|@*
Mode gen-user-head
Import precedence 4
Source
<xsl:template match="/|node()|@*" mode="gen-user-head">
  <!-- to customize: copy this to your override transform, add the content you want. -->
  <!-- it will be placed in the HEAD section of the XHTML. -->
</xsl:template>
Template gen-user-header
Namespace No namespace
Used by
Template *chapterBody
Import precedence 4
Source
<xsl:template name="gen-user-header">
  <xsl:apply-templates select="." mode="gen-user-header"/>
</xsl:template>
Template /|node()|@*gen-user-header
Namespace No namespace
Match /|node()|@*
Mode gen-user-header
Import precedence 4
Source
<xsl:template match="/|node()|@*" mode="gen-user-header">
  <!-- to customize: copy this to your override transform, add the content you want. -->
  <!-- it will be placed in the running heading section of the XHTML. -->
</xsl:template>
Template gen-user-footer
Namespace No namespace
Used by
Template *chapterBody
Import precedence 4
Source
<xsl:template name="gen-user-footer">
  <xsl:apply-templates select="." mode="gen-user-footer"/>
</xsl:template>
Template /|node()|@*gen-user-footer
Namespace No namespace
Match /|node()|@*
Mode gen-user-footer
Import precedence 4
Source
<xsl:template match="/|node()|@*" mode="gen-user-footer">
  <!-- to customize: copy this to your override transform, add the content you want. -->
  <!-- it will be placed in the running footing section of the XHTML. -->
</xsl:template>
Template gen-user-sidetoc
Namespace No namespace
Used by
Template *chapterBody
Import precedence 4
Source
<xsl:template name="gen-user-sidetoc">
  <xsl:apply-templates select="." mode="gen-user-sidetoc"/>
</xsl:template>
Template /|node()|@*gen-user-sidetoc
Namespace No namespace
Match /|node()|@*
Mode gen-user-sidetoc
Import precedence 4
Source
<xsl:template match="/|node()|@*" mode="gen-user-sidetoc">
  <!-- to customize: copy this to your override transform, add the content you want. -->
  <!-- Uncomment the line below to have a "freebie" table of contents on the top-right -->
</xsl:template>
Template gen-user-scripts
Namespace No namespace
Used by
Template *chapterHead
Import precedence 4
Source
<xsl:template name="gen-user-scripts">
  <xsl:apply-templates select="." mode="gen-user-scripts"/>
</xsl:template>
Template /|node()|@*gen-user-scripts
Namespace No namespace
Match /|node()|@*
Mode gen-user-scripts
Import precedence 4
Source
<xsl:template match="/|node()|@*" mode="gen-user-scripts">
  <!-- to customize: copy this to your override transform, add the content you want. -->
  <!-- It will be placed before the ending HEAD tag -->
  <!-- see (or enable) the named template "script-sample" for an example -->
</xsl:template>
Template gen-user-styles
Namespace No namespace
Used by
Template *chapterHead
Import precedence 4
Source
<xsl:template name="gen-user-styles">
  <xsl:apply-templates select="." mode="gen-user-styles"/>
</xsl:template>
Template /|node()|@*gen-user-styles
Namespace No namespace
Match /|node()|@*
Mode gen-user-styles
Import precedence 4
Source
<xsl:template match="/|node()|@*" mode="gen-user-styles">
  <!-- to customize: copy this to your override transform, add the content you want. -->
  <!-- It will be placed before the ending HEAD tag -->
</xsl:template>
Template gen-user-external-link
Namespace No namespace
Import precedence 4
Source
Template /|node()|@*gen-user-external-link
Namespace No namespace
Match /|node()|@*
Mode gen-user-external-link
Import precedence 4
Source
Template gen-user-panel-title-pfx
Namespace No namespace
Used by
Import precedence 4
Source
<xsl:template name="gen-user-panel-title-pfx">
  <xsl:apply-templates select="." mode="gen-user-panel-title-pfx"/>
</xsl:template>
Template /|node()|@*gen-user-panel-title-pfx
Namespace No namespace
Match /|node()|@*
Mode gen-user-panel-title-pfx
Import precedence 4
Source
<xsl:template match="/|node()|@*" mode="gen-user-panel-title-pfx">
  <!-- to customize: copy this to your override transform, add the content you want. -->
  <!-- It will be placed immediately after TITLE tag, in the title -->
</xsl:template>
Template chapter-setup
Documentation

Description

 ===================================================================== 
 ========== DEFAULT PAGE LAYOUT ========== 
Namespace No namespace
Used by
Template root_element
References
Import precedence 4
Source
<xsl:template name="chapter-setup">
  <html>
    <xsl:call-template name="setTopicLanguage"/>
    <xsl:value-of select="$newline"/>
    <xsl:call-template name="chapterHead"/>
    <xsl:call-template name="chapterBody"/>
  </html>
</xsl:template>
Template setTopicLanguage
Namespace No namespace
Used by
Template chapter-setup
References
Template bidi-area
Import precedence 4
Source
<xsl:template name="setTopicLanguage">
  <xsl:variable name="childlang">
    <xsl:apply-templates select="/*" mode="get-first-topic-lang"/>
  </xsl:variable>
  <xsl:variable name="direction">
    <xsl:call-template name="bidi-area">
      <xsl:with-param name="parentlang" select="$childlang"/>
    </xsl:call-template>
  </xsl:variable>
  <xsl:attribute name="lang">
    <xsl:value-of select="$childlang"/>
  </xsl:attribute>
  <xsl:attribute name="xml:lang">
    <xsl:value-of select="$childlang"/>
  </xsl:attribute>
  <xsl:if test="$direction='bidi'">
    <xsl:attribute name="dir">rtl</xsl:attribute>
  </xsl:if>
</xsl:template>
Template chapterHead
Namespace No namespace
Used by
Template chapter-setup
Import precedence 4
Source
<xsl:template name="chapterHead">
  <xsl:apply-templates select="." mode="chapterHead"/>
</xsl:template>
Template *chapterHead
Namespace No namespace
Match *
Mode chapterHead
References
Import precedence 4
Source
<xsl:template match="*" mode="chapterHead">
  <head>
    <xsl:value-of select="$newline"/>
    <!-- initial meta information -->
    <xsl:call-template name="generateCharset"/>
    <!-- Set the character set to UTF-8 -->
    <xsl:call-template name="generateDefaultCopyright"/>
    <!-- Generate a default copyright, if needed -->
    <xsl:call-template name="generateDefaultMeta"/>
    <!-- Standard meta for security, robots, etc -->
    <xsl:call-template name="getMeta"/>
    <!-- Process metadata from topic prolog -->
    <xsl:call-template name="copyright"/>
    <!-- Generate copyright, if specified manually -->
    <xsl:call-template name="generateCssLinks"/>
    <!-- Generate links to CSS files -->
    <xsl:call-template name="generateChapterTitle"/>
    <!-- Generate the <title> element -->
    <xsl:call-template name="gen-user-head"/>
    <!-- include user's XSL HEAD processing here -->
    <xsl:call-template name="gen-user-scripts"/>
    <!-- include user's XSL javascripts here -->
    <xsl:call-template name="gen-user-styles"/>
    <!-- include user's XSL style element and content here -->
    <xsl:call-template name="processHDF"/>
    <!-- Add user HDF file, if specified -->
  </head>
  <xsl:value-of select="$newline"/>
</xsl:template>
Template generateCharset
Namespace No namespace
Used by
Template *chapterHead
References
Variable newline
Import precedence 4
Source
<xsl:template name="generateCharset">
  <meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
  <xsl:value-of select="$newline"/>
</xsl:template>
Template generateDefaultCopyright
Documentation

Description

 If there is no copyright in the document, make the standard one 
Namespace No namespace
Used by
Template *chapterHead
References
Template getString
Parameter YEAR
Variable newline
Import precedence 4
Source
<xsl:template name="generateDefaultCopyright">
  <xsl:if test="not(//*[contains(@class,' topic/copyright ')])">
    <meta name="copyright">
      <xsl:attribute name="content">
        <xsl:text>(C) </xsl:text>
        <xsl:call-template name="getString">
          <xsl:with-param name="stringName" select="'Copyright'"/>
        </xsl:call-template>
        <xsl:text> </xsl:text>
        <xsl:value-of select="$YEAR"/>
      </xsl:attribute>
    </meta>
    <xsl:value-of select="$newline"/>
    <meta name="DC.rights.owner">
      <xsl:attribute name="content">
        <xsl:text>(C) </xsl:text>
        <xsl:call-template name="getString">
          <xsl:with-param name="stringName" select="'Copyright'"/>
        </xsl:call-template>
        <xsl:text> </xsl:text>
        <xsl:value-of select="$YEAR"/>
      </xsl:attribute>
    </meta>
    <xsl:value-of select="$newline"/>
  </xsl:if>
</xsl:template>
Template generateDefaultMeta
Documentation

Description

 Output metadata that should appear in every XHTML topic 
Namespace No namespace
Used by
Template *chapterHead
References
Parameter genDefMeta
Variable newline
Import precedence 4
Source
<xsl:template name="generateDefaultMeta">
  <xsl:if test="$genDefMeta='yes'">
    <meta name="security" content="public"/>
    <xsl:value-of select="$newline"/>
    <meta name="Robots" content="index,follow"/>
    <xsl:value-of select="$newline"/>
    <xsl:text disable-output-escaping="yes"><meta http-equiv="PICS-Label" content='(PICS-1.1 "http://www.icra.org/ratingsv02.html" l gen true r (cz 1 lz 1 nz 1 oz 1 vz 1) "http://www.rsac.org/ratingsv01.html" l gen true r (n 0 s 0 v 0 l 0) "http://www.classify.org/safesurf/" l gen true r (SS~~000 1))' /></xsl:text>
    <xsl:value-of select="$newline"/>
  </xsl:if>
</xsl:template>
Template generateCssLinks
Documentation

Description

 Generate links to CSS files 
Namespace No namespace
Used by
Template *chapterHead
References
Import precedence 4
Source
<xsl:template name="generateCssLinks">
  <xsl:variable name="childlang">
    <xsl:choose>
      <!-- Update with DITA 1.2: /dita can have xml:lang -->
      <xsl:when test="self::dita[not(@xml:lang)]">
        <xsl:for-each select="*[1]">
          <xsl:call-template name="getLowerCaseLang"/>
        </xsl:for-each>
      </xsl:when>
      <xsl:otherwise>
        <xsl:call-template name="getLowerCaseLang"/>
      </xsl:otherwise>
    </xsl:choose>
  </xsl:variable>
  <xsl:variable name="direction">
    <xsl:apply-templates select="." mode="get-render-direction">
      <xsl:with-param name="lang" select="$childlang"/>
    </xsl:apply-templates>
  </xsl:variable>
  <xsl:variable name="urltest">
    <!-- test for URL -->
    <xsl:call-template name="url-string">
      <xsl:with-param name="urltext">
        <xsl:value-of select="concat($CSSPATH,$CSS)"/>
      </xsl:with-param>
    </xsl:call-template>
  </xsl:variable>
  <xsl:choose>
    <xsl:when test="($direction='rtl') and ($urltest='url') ">
      <link rel="stylesheet" type="text/css" href="{$CSSPATH}{$bidi-dita-css}"/>
    </xsl:when>
    <xsl:when test="($direction='rtl') and ($urltest='')">
      <link rel="stylesheet" type="text/css" href="{$PATH2PROJ}{$CSSPATH}{$bidi-dita-css}"/>
    </xsl:when>
    <xsl:when test="($urltest='url')">
      <link rel="stylesheet" type="text/css" href="{$CSSPATH}{$dita-css}"/>
    </xsl:when>
    <xsl:otherwise>
      <link rel="stylesheet" type="text/css" href="{$PATH2PROJ}{$CSSPATH}{$dita-css}"/>
    </xsl:otherwise>
  </xsl:choose>
  <xsl:value-of select="$newline"/>
  <!-- Add user's style sheet if requested to -->
  <xsl:if test="string-length($CSS)>0">
    <xsl:choose>
      <xsl:when test="$urltest='url'">
        <link rel="stylesheet" type="text/css" href="{$CSSPATH}{$CSS}"/>
      </xsl:when>
      <xsl:otherwise>
        <link rel="stylesheet" type="text/css" href="{$PATH2PROJ}{$CSSPATH}{$CSS}"/>
      </xsl:otherwise>
    </xsl:choose>
    <xsl:value-of select="$newline"/>
  </xsl:if>
</xsl:template>
Template generateChapterTitle
Namespace No namespace
Used by
Template *chapterHead
References
Template gen-user-panel-title-pfx
Variable newline
Import precedence 4
Source
<xsl:template name="generateChapterTitle">
  <!-- Title processing - special handling for short descriptions -->
  <title>
    <xsl:call-template name="gen-user-panel-title-pfx"/>
    <!-- hook for a user-XSL title prefix -->
    <!-- use the searchtitle unless there's no value - else use title -->
    <xsl:variable name="schtitle">
      <xsl:value-of select="/*[contains(@class,' topic/topic ')]/*[contains(@class,' topic/titlealts ')]/*[contains(@class,' topic/searchtitle ')]"/>
    </xsl:variable>
    <xsl:variable name="ditaschtitle">
      <xsl:value-of select="/dita/*[contains(@class,' topic/topic ')][1]/*[contains(@class,' topic/titlealts ')]/*[contains(@class,' topic/searchtitle ')]"/>
    </xsl:variable>
    <xsl:variable name="maintitle">
      <xsl:apply-templates select="/*[contains(@class,' topic/topic ')]/*[contains(@class,' topic/title ')]" mode="text-only"/>
    </xsl:variable>
    <xsl:variable name="ditamaintitle">
      <xsl:apply-templates select="/dita/*[contains(@class,' topic/topic ')][1]/*[contains(@class,' topic/title ')]" mode="text-only"/>
    </xsl:variable>
    <!-- edited by William on 2009-05-18 for searchtitle bug start -->
    <xsl:variable name="mapschtitle">
      <xsl:value-of select="/*[contains(@class,' topic/topic ')]/*[contains(@class,' topic/titlealts ')]/*[contains(@class,' map/searchtitle ')]"/>
    </xsl:variable>
    <!-- edited by William on 2009-05-18 for searchtitile bug end -->
    <xsl:choose>
      <xsl:when test="string-length($schtitle)>'0'">
        <xsl:value-of select="normalize-space($schtitle)"/>
      </xsl:when>
      <!-- edited by William on 2009-05-18 for searchtitle bug start -->
      <xsl:when test="string-length($mapschtitle)>'0'">
        <xsl:value-of select="normalize-space($mapschtitle)"/>
      </xsl:when>
      <!-- edited by William on 2009-05-18 for searchtitile bug end -->
      <xsl:when test="string-length($ditaschtitle)>'0'">
        <xsl:value-of select="normalize-space($ditaschtitle)"/>
      </xsl:when>
      <xsl:when test="string-length($maintitle)>'0'">
        <xsl:value-of select="normalize-space($maintitle)"/>
      </xsl:when>
      <xsl:when test="string-length($ditamaintitle)>'0'">
        <xsl:value-of select="normalize-space($ditamaintitle)"/>
      </xsl:when>
      <xsl:otherwise>
        <xsl:text>***</xsl:text>
        <xsl:apply-templates select="." mode="ditamsg:no-title-for-topic"/>
      </xsl:otherwise>
    </xsl:choose>
  </title>
  <xsl:value-of select="$newline"/>
</xsl:template>
Template processHDF
Documentation

Description

 Add user's head XHTML code snippet, if specified 
Namespace No namespace
Used by
Template *chapterHead
References
Variable HDFFILE
Import precedence 4
Source
<xsl:template name="processHDF">
  <xsl:if test="string-length($HDFFILE)>0">
    <xsl:apply-templates select="document($HDFFILE,/)" mode="add-HDF"/>
  </xsl:if>
</xsl:template>
Template chapterBody
Namespace No namespace
Used by
Template chapter-setup
Import precedence 4
Source
<xsl:template name="chapterBody">
  <xsl:apply-templates select="." mode="chapterBody"/>
</xsl:template>
Template *chapterBody
Namespace No namespace
Match *
Mode chapterBody
References
Import precedence 4
Source
<xsl:template match="*" mode="chapterBody">
  <xsl:variable name="flagrules">
    <xsl:call-template name="getrules"/>
  </xsl:variable>
  <body>
    <!-- Already put xml:lang on <html>; do not copy to body with commonattributes -->
    <xsl:call-template name="gen-style">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
    <!--output parent or first "topic" tag's outputclass as class -->
    <xsl:if test="@outputclass">
      <xsl:attribute name="class">
        <xsl:value-of select="@outputclass"/>
      </xsl:attribute>
    </xsl:if>
    <xsl:if test="self::dita">
      <xsl:if test="*[contains(@class,' topic/topic ')][1]/@outputclass">
        <xsl:attribute name="class">
          <xsl:value-of select="*[contains(@class,' topic/topic ')][1]/@outputclass"/>
        </xsl:attribute>
      </xsl:if>
    </xsl:if>
    <xsl:apply-templates select="." mode="addAttributesToBody"/>
    <xsl:call-template name="setidaname"/>
    <xsl:value-of select="$newline"/>
    <xsl:call-template name="start-flagit">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
    <xsl:call-template name="start-revflag">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
    <xsl:call-template name="generateBreadcrumbs"/>
    <xsl:call-template name="gen-user-header"/>
    <!-- include user's XSL running header here -->
    <xsl:call-template name="processHDR"/>
    <!-- Include a user's XSL call here to generate a toc based on what's a child of topic -->
    <xsl:call-template name="gen-user-sidetoc"/>
    <xsl:apply-templates/>
    <!-- this will include all things within topic; therefore, -->
    <!-- title content will appear here by fall-through -->
    <!-- followed by prolog (but no fall-through is permitted for it) -->
    <!-- followed by body content, again by fall-through in document order -->
    <!-- followed by related links -->
    <!-- followed by child topics by fall-through -->
    <xsl:call-template name="gen-endnotes"/>
    <!-- include footnote-endnotes -->
    <xsl:call-template name="gen-user-footer"/>
    <!-- include user's XSL running footer here -->
    <xsl:call-template name="processFTR"/>
    <!-- Include XHTML footer, if specified -->
    <xsl:call-template name="end-revflag">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
    <xsl:call-template name="end-flagit">
      <xsl:with-param name="flagrules" select="$flagrules"/>
    </xsl:call-template>
  </body>
  <xsl:value-of select="$newline"/>
</xsl:template>
Template *addAttributesToBody
Documentation

Description

 Override this template to add any standard attributes to
       the HTML <body> element. Current context is the root
       element of the doc. 
Namespace No namespace
Match *
Mode addAttributesToBody
Import precedence 4
Source
<xsl:template match="*" mode="addAttributesToBody">
</xsl:template>
Template generateBreadcrumbs
Namespace No namespace
Used by
Template *chapterBody
Import precedence 4
Source
<xsl:template name="generateBreadcrumbs">
  <!-- Insert previous/next/ancestor breadcrumbs links at the top of the xhtml. -->
  <xsl:apply-templates select="*[contains(@class,' topic/related-links ')]" mode="breadcrumb"/>
</xsl:template>
Template processHDR
Namespace No namespace
Used by
Template *chapterBody
References
Variables HDRFILE; newline
Import precedence 4
Source
<xsl:template name="processHDR">
  <!-- Add user's running heading XHTML code snippet if requested to -->
  <xsl:if test="string-length($HDRFILE)>0">
    <xsl:copy-of select="document($HDRFILE,/)"/>
  </xsl:if>
  <xsl:value-of select="$newline"/>
</xsl:template>
Template processFTR
Namespace No namespace
Used by
Template *chapterBody
References
Variables FTRFILE; newline
Import precedence 4
Source
<xsl:template name="processFTR">
  <!-- Add user's running footing XHTML code snippet if requested to -->
  <xsl:if test="string-length($FTRFILE)>0">
    <xsl:copy-of select="document($FTRFILE,/)"/>
  </xsl:if>
  <xsl:value-of select="$newline"/>
</xsl:template>
Template processing-instruction('path2project')get-path2project
Namespace No namespace
Match processing-instruction('path2project')
Mode get-path2project
References
Template get-path2project
Import precedence 4
Source
<xsl:template match="processing-instruction('path2project')" mode="get-path2project">
  <xsl:call-template name="get-path2project">
    <xsl:with-param name="s" select="."/>
  </xsl:call-template>
</xsl:template>
Template get-path2project
Namespace No namespace
Used by
References
Template get-path2project
Parameters
QName Namespace
s No namespace
Import precedence 4
Source
<xsl:template name="get-path2project">
  <!-- Deal with being handed a Windows backslashed path by accident. -->
  <!-- This code only changes \ to / and doesn't handle the many other situations
         where a URI differs from a file path.  Hopefully they don't occur in path2proj anyway. -->
  <xsl:param name="s"/>
  <xsl:choose>
    <xsl:when test="contains($s, '\')">
      <xsl:value-of select="substring-before($s, '\')"/>
      <xsl:text>/</xsl:text>
      <xsl:call-template name="get-path2project">
        <xsl:with-param name="s" select="substring-after($s, '\')"/>
      </xsl:call-template>
    </xsl:when>
    <xsl:otherwise>
      <xsl:value-of select="$s"/>
    </xsl:otherwise>
  </xsl:choose>
</xsl:template>
Template get-file-name
Namespace No namespace
Used by
Template get-file-name
References
Template get-file-name
Parameters
QName Namespace
file-path No namespace
Import precedence 4
Source
<xsl:template name="get-file-name">
  <xsl:param name="file-path"/>
  <xsl:choose>
    <xsl:when test="contains($file-path, '\')">
      <xsl:call-template name="get-file-name">
        <xsl:with-param name="file-path" select="substring-after($file-path, '\')"/>
      </xsl:call-template>
    </xsl:when>
    <xsl:when test="contains($file-path, '/')">
      <xsl:call-template name="get-file-name">
        <xsl:with-param name="file-path" select="substring-after($file-path, '/')"/>
      </xsl:call-template>
    </xsl:when>
    <xsl:otherwise>
      <xsl:value-of select="$file-path"/>
    </xsl:otherwise>
  </xsl:choose>
</xsl:template>
Template *[contains(@class,' topic/data ')]
Documentation

Description

 Add for "New <data> element (#9)" in DITA 1.1 
Namespace No namespace
Match *[contains(@class,' topic/data ')]
Mode #default
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/data ')]"/>
Template *[contains(@class,' topic/foreign ') or contains(@class,' topic/unknown ')]
Documentation

Description

 Add for "Support foreign content vocabularies such as 
    MathML and SVG with <unknown> (#35) " in DITA 1.1 
Namespace No namespace
Match *[contains(@class,' topic/foreign ') or contains(@class,' topic/unknown ')]
Mode #default
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/foreign ') or contains(@class,' topic/unknown ')]">
  <xsl:apply-templates select="*[contains(@class,' topic/object ')][@type='DITA-foreign']"/>
</xsl:template>
Template *[contains(@class,' topic/index-base ')]
Documentation

Description

 Add for index-base element. This template is used to prevent
    any processing applied on index-base element 
Namespace No namespace
Match *[contains(@class,' topic/index-base ')]
Mode #default
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/index-base ')]"/>
Template *[contains(@class,' topic/text ')]
Documentation

Description

 Add for text element.  
Namespace No namespace
Match *[contains(@class,' topic/text ')]
Mode #default
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/text ')]">
  <xsl:apply-templates/>
</xsl:template>
Template *[contains(@class,' topic/bodydiv ') or contains(@class, ' topic/sectiondiv ')]
Documentation

Description

 Add for bodydiv  and sectiondiv
Namespace No namespace
Match *[contains(@class,' topic/bodydiv ') or contains(@class, ' topic/sectiondiv ')]
Mode #default
Import precedence 4
Source
<xsl:template match="*[contains(@class,' topic/bodydiv ') or contains(@class, ' topic/sectiondiv ')]">
  <div>
    <xsl:apply-templates/>
  </div>
</xsl:template>
Template *find-keyref-target
Documentation

Description

 Function to look up a target in the keyref file 
Namespace No namespace
Match *
Mode find-keyref-target
References
Parameters KEYREF-FILE; OUTEXT
Variable desDir
Parameters
QName Namespace Select
keys No namespace @keyref
Import precedence 4
Source
<xsl:template match="*" mode="find-keyref-target">
  <xsl:param name="keys" select="@keyref"/>
  <xsl:variable name="target">
    <!--<xsl:value-of select="document($KEYREF-FILE)//*[contains(@keys, $keys)]/@href"/>-->
    <xsl:value-of select="document($KEYREF-FILE)//*[@keys=$keys]/@href"/>
  </xsl:variable>
  <xsl:choose>
    <xsl:when test="contains($target,'://')">
      <xsl:value-of select="$target"/>
    </xsl:when>
    <xsl:when test="contains($target,'#')">
      <xsl:value-of select="concat($desDir, substring-before(substring-before($target,'#'),'.'),$OUTEXT,'#',substring-after($target,'#'))"/>
    </xsl:when>
    <xsl:when test="$target = ''">
      <xsl:value-of select="$OUTEXT"/>
    </xsl:when>
    <xsl:otherwise>
      <xsl:value-of select="concat($desDir, substring-before($target,'.'),$OUTEXT)"/>
    </xsl:otherwise>
  </xsl:choose>
</xsl:template>
Template *pull-in-title
Documentation

Description

 This template pulls in topic/title 
 20090330: Add error checking to ensre $keys is defined, that the key
                 is defined in KEYREF-FILE, and that $target != '' 
Namespace No namespace
Match *
Mode pull-in-title
References
Parameters
QName Namespace Select
displaytext No namespace ''
keys No namespace @keyref
type No namespace
Import precedence 4
Source
<xsl:template match="*" mode="pull-in-title">
  <xsl:param name="type"/>
  <xsl:param name="displaytext" select="''"/>
  <xsl:param name="keys" select="@keyref"/>
  <xsl:variable name="TAGS" select="' keyword term '"/>
  <xsl:choose>
    <xsl:when test="$displaytext='' and $keys!=''">
      <xsl:variable name="target">
        <xsl:if test="document($KEYREF-FILE)//*[@keys=$keys]">
          <xsl:choose>
            <xsl:when test="contains(document($KEYREF-FILE)//*[@keys=$keys]/@href, '#')">
              <xsl:value-of select="concat(substring-before(substring-before(document($KEYREF-FILE)//*[@keys=$keys]/@href, '#'), '.'), $DITAEXT)"/>
            </xsl:when>
            <xsl:when test="document($KEYREF-FILE)//*[@keys=$keys]/@href">
              <xsl:value-of select="concat(substring-before(document($KEYREF-FILE)//*[@keys=$keys]/@href, '.'), $DITAEXT)"/>
            </xsl:when>
          </xsl:choose>
        </xsl:if>
      </xsl:variable>
      <xsl:if test="not($target='' or contains($target, '://'))">
        <xsl:value-of select="document(concat($WORKDIR, $PATH2PROJ, $target))//*[contains(@class, ' topic/title ')][normalize-space(text())!=''][1]"/>
      </xsl:if>
    </xsl:when>
    <xsl:when test="normalize-space(text())=''">
      <xsl:value-of select="$displaytext"/>
    </xsl:when>
  </xsl:choose>
</xsl:template>
Template *turning-to-link
Documentation
Namespace No namespace
Match *
Mode turning-to-link
References
Parameters
Import precedence 4
Source
Template *common-processing-phrase-within-link
Namespace No namespace
Match *
Mode common-processing-phrase-within-link
References
Parameters
Import precedence 4
Source
Template processing-instruction('workdir')get-work-dir
Namespace No namespace
Match processing-instruction('workdir')
Mode get-work-dir
Import precedence 4
Source
<xsl:template match="processing-instruction('workdir')" mode="get-work-dir">
  <xsl:value-of select="."/>
  <xsl:text>/</xsl:text>
</xsl:template>
Template *{http://dita-ot.sourceforge.net/ns/200704/ditamsg}no-glossentry-for-key
Documentation

Description

 MESSAGES: Refactoring places each message in a moded template, so that users
       may more easily override a message for one or all cases. 
Namespace No namespace
Match *
Mode {http://dita-ot.sourceforge.net/ns/200704/ditamsg}no-glossentry-for-key
References
Template output-message
Parameters
QName Namespace
matching-keys No namespace
Import precedence 4
Source
<xsl:template match="*" mode="ditamsg:no-glossentry-for-key">
  <xsl:param name="matching-keys"/>
  <xsl:call-template name="output-message">
    <xsl:with-param name="msgnum">058</xsl:with-param>
    <xsl:with-param name="msgsev">W</xsl:with-param>
    <xsl:with-param name="msgparams">%1=
      <xsl:value-of select="$matching-keys"/>
    </xsl:with-param>
  </xsl:call-template>
</xsl:template>
Template *{http://dita-ot.sourceforge.net/ns/200704/ditamsg}no-title-for-topic
Namespace No namespace
Match *
Mode {http://dita-ot.sourceforge.net/ns/200704/ditamsg}no-title-for-topic
References
Template output-message
Import precedence 4
Source
<xsl:template match="*" mode="ditamsg:no-title-for-topic">
  <xsl:call-template name="output-message">
    <xsl:with-param name="msgnum">037</xsl:with-param>
    <xsl:with-param name="msgsev">W</xsl:with-param>
  </xsl:call-template>
</xsl:template>
Template *{http://dita-ot.sourceforge.net/ns/200704/ditamsg}longdescref-on-object
Namespace No namespace
Match *
Mode {http://dita-ot.sourceforge.net/ns/200704/ditamsg}longdescref-on-object
References
Template output-message
Import precedence 4
Source
<xsl:template match="*" mode="ditamsg:longdescref-on-object">
  <xsl:call-template name="output-message">
    <xsl:with-param name="msgnum">038</xsl:with-param>
    <xsl:with-param name="msgsev">I</xsl:with-param>
    <xsl:with-param name="msgparams">%1=
      <xsl:value-of select="name(.)"/>
    </xsl:with-param>
  </xsl:call-template>
</xsl:template>
Template *{http://dita-ot.sourceforge.net/ns/200704/ditamsg}required-cleanup-in-content
Namespace No namespace
Match *
Mode {http://dita-ot.sourceforge.net/ns/200704/ditamsg}required-cleanup-in-content
References
Template output-message
Import precedence 4
Source
<xsl:template match="*" mode="ditamsg:required-cleanup-in-content">
  <xsl:call-template name="output-message">
    <xsl:with-param name="msgnum">039</xsl:with-param>
    <xsl:with-param name="msgsev">W</xsl:with-param>
  </xsl:call-template>
</xsl:template>
Template *{http://dita-ot.sourceforge.net/ns/200704/ditamsg}draft-comment-in-content
Namespace No namespace
Match *
Mode {http://dita-ot.sourceforge.net/ns/200704/ditamsg}draft-comment-in-content
References
Template output-message
Import precedence 4
Source
<xsl:template match="*" mode="ditamsg:draft-comment-in-content">
  <xsl:call-template name="output-message">
    <xsl:with-param name="msgnum">040</xsl:with-param>
    <xsl:with-param name="msgsev">I</xsl:with-param>
  </xsl:call-template>
</xsl:template>
Template *{http://dita-ot.sourceforge.net/ns/200704/ditamsg}section-with-multiple-titles
Namespace No namespace
Match *
Mode {http://dita-ot.sourceforge.net/ns/200704/ditamsg}section-with-multiple-titles
References
Template output-message
Import precedence 4
Source
<xsl:template match="*" mode="ditamsg:section-with-multiple-titles">
  <xsl:call-template name="output-message">
    <xsl:with-param name="msgnum">041</xsl:with-param>
    <xsl:with-param name="msgsev">W</xsl:with-param>
  </xsl:call-template>
</xsl:template>
Parameter CSS
Documentation

Description

 =========== DEFAULT VALUES FOR EXTERNALLY MODIFIABLE PARAMETERS =========== 
 /CSS = default CSS filename parameter ('')
Namespace No namespace
Used by
Template generateCssLinks
Source
<xsl:param name="CSS"/>
Parameter dita-css
Namespace No namespace
Select 'commonltr.css'
Used by
Template generateCssLinks
Source
<xsl:param name="dita-css" select="'commonltr.css'"/>
Parameter bidi-dita-css
Documentation

Description

 left to right languages 
Namespace No namespace
Select 'commonrtl.css'
Used by
Template generateCssLinks
Source
<xsl:param name="bidi-dita-css" select="'commonrtl.css'"/>
Parameter TRANSTYPE
Documentation

Description

 bidirectional languages 
 Transform type, such as 'xhtml', 'htmlhelp', or 'eclipsehelp' 
Namespace No namespace
Select 'xhtml'
Source
<xsl:param name="TRANSTYPE" select="'xhtml'"/>
Parameter CSSPATH
Documentation

Description

 default CSS path parameter (null)
Namespace No namespace
Used by
Template generateCssLinks
Source
<xsl:param name="CSSPATH"/>
Parameter PRESERVE-DITA-CLASS
Documentation

Description

 Preserve DITA class ancestry in XHTML output; values are 'yes' or 'no' 
Namespace No namespace
Select 'no'
Used by
Source
<xsl:param name="PRESERVE-DITA-CLASS" select="'no'"/>
Parameter HDF
Documentation

Description

 the file name containing XHTML to be placed in the HEAD area
     (file name and extension only - no path). 
Namespace No namespace
Used by
Variable HDFFILE
Source
<xsl:param name="HDF"/>
Parameter HDR
Documentation

Description

 the file name containing XHTML to be placed in the BODY running-heading area
     (file name and extension only - no path). 
Namespace No namespace
Used by
Variable HDRFILE
Source
<xsl:param name="HDR"/>
Parameter FTR
Documentation

Description

 the file name containing XHTML to be placed in the BODY running-footing area
     (file name and extension only - no path). 
Namespace No namespace
Used by
Variable FTRFILE
Source
<xsl:param name="FTR"/>
Parameter ARTLBL
Documentation

Description

 default "output artwork filenames" processing parameter ('no')
Namespace No namespace
Select 'no'
Used by
Template topic.image
Source
<xsl:param name="ARTLBL" select="'no'"/>
Parameter DRAFT
Documentation

Description

 "no" and "yes" are valid values; non-'yes' is ignored 
 default "hide draft & cleanup content" processing parameter ('no' = hide them)
Namespace No namespace
Select 'no'
Used by
Source
<xsl:param name="DRAFT" select="'no'"/>
Parameter INDEXSHOW
Documentation

Description

 "no" and "yes" are valid values; non-'yes' is ignored 
 default "hide index entries" processing parameter ('no' = hide them)
Namespace No namespace
Select 'no'
Used by
Template topic.indexterm
Source
<xsl:param name="INDEXSHOW" select="'no'"/>
Parameter BREADCRUMBS
Documentation

Description

 "no" and "yes" are valid values; non-'yes' is ignored 
 for now, disable breadcrumbs pending link group descision 
Namespace No namespace
Select 'no'
Source
<xsl:param name="BREADCRUMBS" select="'no'"/>
Parameter YEAR
Documentation

Description

 "no" and "yes" are valid values; non-'yes' is ignored 
 the year for the copyright 
Namespace No namespace
Select '2005'
Used by
Source
<xsl:param name="YEAR" select="'2005'"/>
Parameter OUTEXT
Documentation

Description

 default "output extension" processing parameter ('.html')
Namespace No namespace
Select '.html'
Used by
Source
<xsl:param name="OUTEXT" select="'.html'"/>
Parameter WORKDIR
Documentation

Description

 "htm" and "html" are valid values 
 the working directory that contains the document being transformed.
     Needed as a directory prefix for the @conref "document()" function calls.
     default is '../doc/')
Namespace No namespace
Used by
Source
<xsl:param name="WORKDIR">
  <xsl:apply-templates select="/processing-instruction()" mode="get-work-dir"/>
</xsl:param>
Parameter PATH2PROJ
Documentation

Description

 the path back to the project. Used for c.gif, delta.gif, css to allow user's to have
     these files in 1 location. 
Namespace No namespace
Used by
Source
<xsl:param name="PATH2PROJ">
  <xsl:apply-templates select="/processing-instruction('path2project')" mode="get-path2project"/>
</xsl:param>
Parameter FILENAME
Documentation

Description

 the file name (file name and extension only - no path) of the document being transformed.
     Needed to help with debugging.
     default is 'myfile.xml')
Namespace No namespace
Used by
Source
<xsl:param name="FILENAME"/>
Parameter FILTERFILE
Documentation

Description

 the file name containing filter/flagging/revision information
     (file name and extension only - no path).  - testfile: revflag.dita 
Namespace No namespace
Used by
Source
<xsl:param name="FILTERFILE"/>
Parameter DBG
Documentation

Description

 Debug mode - enables XSL debugging xsl-messages.
     Needed to help with debugging.
     default is 'no')
Namespace No namespace
Select 'no'
Used by
Templates flagcheck; flagcheck
Source
<xsl:param name="DBG" select="'no'"/>
Parameter DITAEXT
Documentation

Description

 "no" and "yes" are valid values; non-'yes' is ignored 
 DITAEXT file extension name of dita topic file 
Namespace No namespace
Select '.xml'
Overriding
Parameter DITAEXT
Source
<xsl:param name="DITAEXT" select="'.xml'"/>
Parameter genDefMeta
Documentation

Description

 Switch to enable or disable the generation of default meta message in html header 
Namespace No namespace
Select 'no'
Used by
Source
<xsl:param name="genDefMeta" select="'no'"/>
Parameter KEYREF-FILE
Documentation

Description

 Name of the keyref file that contains key definitions 
Namespace No namespace
Select concat($WORKDIR,$PATH2PROJ,'keydef.xml')
Used by
References
Parameters PATH2PROJ; WORKDIR
Source
<xsl:param name="KEYREF-FILE" select="concat($WORKDIR,$PATH2PROJ,'keydef.xml')"/>
Parameter BASEDIR
Documentation

Description

 added by William on 2009-09-03 for keyref bug:2849078 start
Namespace No namespace
Used by
Variable desDir
Source
<xsl:param name="BASEDIR"/>
Parameter OUTPUTDIR
Namespace No namespace
Used by
Variable desDir
Source
<xsl:param name="OUTPUTDIR"/>
Variable desDir
Documentation

Description

 get destination dir with BASEDIR and OUTPUTDIR
Namespace No namespace
Used by
References
Parameters BASEDIR; OUTPUTDIR
Source
<xsl:variable name="desDir">
  <xsl:choose>
    <xsl:when test="not($BASEDIR)"/>
    <!-- If no filterfile leave empty -->
    <xsl:when test="starts-with($BASEDIR,'file:')">
      <xsl:value-of select="translate(concat($BASEDIR, '/', $OUTPUTDIR, '/'), '\', '/')"/>
    </xsl:when>
    <xsl:otherwise>
      <xsl:choose>
        <xsl:when test="contains($OUTPUTDIR, ':\') or contains($OUTPUTDIR, ':/')">
          <xsl:value-of select="'file:/'"/>
          <xsl:value-of select="concat($OUTPUTDIR, '/')"/>
        </xsl:when>
        <xsl:when test="starts-with($OUTPUTDIR, '/')">
          <xsl:value-of select="'file://'"/>
          <xsl:value-of select="concat($OUTPUTDIR, '/')"/>
        </xsl:when>
        <xsl:when test="starts-with($BASEDIR,'/')">
          <xsl:text>file://</xsl:text>
          <xsl:value-of select="concat($BASEDIR, '/', $OUTPUTDIR, '/')"/>
        </xsl:when>
        <xsl:otherwise>
          <xsl:text>file:/</xsl:text>
          <xsl:value-of select="concat($BASEDIR, '/', $OUTPUTDIR, '/')"/>
        </xsl:otherwise>
      </xsl:choose>
    </xsl:otherwise>
  </xsl:choose>
</xsl:variable>
Variable FILTERFILEURL
Documentation

Description

 added by William on 2009-09-03 for keyref bug:2849078 end
 =========== "GLOBAL" DECLARATIONS (see 35) =========== 
 The document tree of filterfile returned by document($FILTERFILE,/)
Namespace No namespace
Used by
Variable FILTERDOC
References
Parameter FILTERFILE
Source
<xsl:variable name="FILTERFILEURL">
  <xsl:choose>
    <xsl:when test="not($FILTERFILE)"/>
    <!-- If no filterfile leave empty -->
    <xsl:when test="starts-with($FILTERFILE,'file:')">
      <xsl:value-of select="$FILTERFILE"/>
    </xsl:when>
    <xsl:otherwise>
      <xsl:choose>
        <xsl:when test="starts-with($FILTERFILE,'/')">
          <xsl:text>file://</xsl:text>
          <xsl:value-of select="$FILTERFILE"/>
        </xsl:when>
        <xsl:otherwise>
          <xsl:text>file:/</xsl:text>
          <xsl:value-of select="$FILTERFILE"/>
        </xsl:otherwise>
      </xsl:choose>
    </xsl:otherwise>
  </xsl:choose>
</xsl:variable>
Variable FILTERDOC
Namespace No namespace
Select document($FILTERFILEURL,/)
Used by
References
Variable FILTERFILEURL
Source
<xsl:variable name="FILTERDOC" select="document($FILTERFILEURL,/)"/>
Variable newline
Documentation

Description

 Define a newline character 
Namespace No namespace
Used by
Templates chapter-setup; child.topic; concept-links; dotable; generateChapterTitle; generateCharset; generateCssLinks; generateDefaultCopyright; generateDefaultMeta; next-prev-parent-links; ol-child-links; processFTR; processHDR; reference-links; related-links:group-result.; related-links:result.concept; related-links:result.reference; related-links:result.task; relinfo-links; task-links; topic.body; topic.dd; topic.ddhd; topic.draft-comment; topic.dt; topic.dthd; topic.example; topic.li; topic.link; topic.link_child; topic.link_orderedchild; topic.linkinfo; topic.linklist; topic.linklist_desc; topic.linklist_title; topic.lq; topic.note; topic.ol; topic.p; topic.reference.property; topic.reference.prophead; topic.required-cleanup; topic.row; topic.section; topic.sli; topic.sthead; topic.sthead_stentry; topic.strow; topic.strow_stentry; topic.task.chdesc; topic.task.choption; topic.task.chrow; topic.task.prereq; topic.task.taskbody; topic.tbody; topic.tbody_entry; topic.thead; topic.thead_entry; topic.ut-d.imagemap; ul-child-links; *[contains(@class,' topic/topic ')]/*[contains(@class,' topic/title ')]; *[contains(@class,' topic/related-links ')]breadcrumb; *chapterBody; *chapterHead; *[contains(@class,' task/choices ')]choices-fmt; *[contains(@class,' task/choicetable ')]choicetable-fmt; *[contains(@class,' topic/dl ')]dl-fmt; *[contains(@class,' topic/fig ')]fig-fmt; *gen-format-metadata; *gen-keywords-metadata; *[contains(@class,' topic/audience ')]/@experiencelevelgen-metadata; *[contains(@class,' topic/audience ')]/@importancegen-metadata; *[contains(@class,' topic/audience ')]/@jobgen-metadata; *[contains(@class,' topic/audience ')]/@namegen-metadata; *[contains(@class,' topic/audience ')]/@typegen-metadata; *[contains(@class,' topic/author ')]gen-metadata; *[contains(@class,' topic/brand ')]gen-metadata; *[contains(@class,' topic/component ')]gen-metadata; *[contains(@class,' topic/copyright ')]gen-metadata; *[contains(@class,' topic/critdates ')]/*[contains(@class,' topic/created ')]gen-metadata; *[contains(@class,' topic/critdates ')]/*[contains(@class,' topic/revised ')]/@expirygen-metadata; *[contains(@class,' topic/critdates ')]/*[contains(@class,' topic/revised ')]/@golivegen-metadata; *[contains(@class,' topic/critdates ')]/*[contains(@class,' topic/revised ')]/@modifiedgen-metadata; *[contains(@class,' topic/featnum ')]gen-metadata; *[contains(@class,' topic/link ')]/@hrefgen-metadata; *[contains(@class,' topic/metadata ')]/*[contains(@class,' topic/category ')]gen-metadata; *[contains(@class,' topic/othermeta ')]gen-metadata; *[contains(@class,' topic/permissions ')]gen-metadata; *[contains(@class,' topic/platform ')]gen-metadata; *[contains(@class,' topic/prodname ')]gen-metadata; *[contains(@class,' topic/prognum ')]gen-metadata; *[contains(@class,' topic/publisher ')]gen-metadata; *[contains(@class,' topic/series ')]gen-metadata; *[contains(@class,' topic/shortdesc ')]gen-metadata; *[contains(@class,' topic/source ')]/@hrefgen-metadata; *[contains(@class,' topic/title ')]gen-metadata; *[contains(@class,' topic/vrm ')]/@modificationgen-metadata; *[contains(@class,' topic/vrm ')]/@releasegen-metadata; *[contains(@class,' topic/vrm ')]/@versiongen-metadata; @idgen-metadata; @xml:langgen-metadata; *[contains(@class,' topic/tfoot ')]gen-tfoot; *gen-type-metadata; *[contains(@class,' topic/lines ')]lines-fmt; *[contains(@class,' task/step ')]onestep-fmt; *[contains(@class,' topic/abstract ')]outofline; *[contains(@class,' topic/shortdesc ')]outofline; *[contains(@class,' topic/shortdesc ')]outofline.abstract; *[contains(@class,' topic/pre ')]pre-fmt; *[contains(@class, ' topic/link ')]prereqs; *[contains(@class,' topic/related-links ')]prereqs; *processlinklist; *propertiesEntry; *[contains(@class,' ui-d/screen ')]screen-fmt; *[contains(@class,' topic/simpletable ')]simpletable-fmt; *[contains(@class,' topic/sl ')]sl-fmt; *step-elements-with-no-stepsection; *[contains(@class,' task/step ')]steps-fmt; *[contains(@class,' task/substep ')]substep-fmt; *[contains(@class,' task/substeps ')]substeps-fmt; *[contains(@class,' topic/table ')]table-fmt; *[contains(@class,' topic/ul ')]ul-fmt
Source
<xsl:variable name="newline">
  <xsl:text>
</xsl:text>
</xsl:variable>
Variable HDFFILE
Documentation

Description

Check the file Url Definition of HDF HDR FTR
Namespace No namespace
Used by
Template processHDF
References
Parameter HDF
Source
<xsl:variable name="HDFFILE">
  <xsl:choose>
    <xsl:when test="not($HDF)"/>
    <!-- If no filterfile leave empty -->
    <xsl:when test="starts-with($HDF,'file:')">
      <xsl:value-of select="$HDF"/>
    </xsl:when>
    <xsl:otherwise>
      <xsl:choose>
        <xsl:when test="starts-with($HDF,'/')">
          <xsl:text>file://</xsl:text>
          <xsl:value-of select="$HDF"/>
        </xsl:when>
        <xsl:otherwise>
          <xsl:text>file:/</xsl:text>
          <xsl:value-of select="$HDF"/>
        </xsl:otherwise>
      </xsl:choose>
    </xsl:otherwise>
  </xsl:choose>
</xsl:variable>
Variable HDRFILE
Namespace No namespace
Used by
Template processHDR
References
Parameter HDR
Source
<xsl:variable name="HDRFILE">
  <xsl:choose>
    <xsl:when test="not($HDR)"/>
    <!-- If no filterfile leave empty -->
    <xsl:when test="starts-with($HDR,'file:')">
      <xsl:value-of select="$HDR"/>
    </xsl:when>
    <xsl:otherwise>
      <xsl:choose>
        <xsl:when test="starts-with($HDR,'/')">
          <xsl:text>file://</xsl:text>
          <xsl:value-of select="$HDR"/>
        </xsl:when>
        <xsl:otherwise>
          <xsl:text>file:/</xsl:text>
          <xsl:value-of select="$HDR"/>
        </xsl:otherwise>
      </xsl:choose>
    </xsl:otherwise>
  </xsl:choose>
</xsl:variable>
Variable FTRFILE
Namespace No namespace
Used by
Template processFTR
References
Parameter FTR
Source
<xsl:variable name="FTRFILE">
  <xsl:choose>
    <xsl:when test="not($FTR)"/>
    <!-- If no filterfile leave empty -->
    <xsl:when test="starts-with($FTR,'file:')">
      <xsl:value-of select="$FTR"/>
    </xsl:when>
    <xsl:otherwise>
      <xsl:choose>
        <xsl:when test="starts-with($FTR,'/')">
          <xsl:text>file://</xsl:text>
          <xsl:value-of select="$FTR"/>
        </xsl:when>
        <xsl:otherwise>
          <xsl:text>file:/</xsl:text>
          <xsl:value-of select="$FTR"/>
        </xsl:otherwise>
      </xsl:choose>
    </xsl:otherwise>
  </xsl:choose>
</xsl:variable>
Variable msgprefix
Documentation

Description

 Define the error message prefix identifier 
Namespace No namespace
Used by
Template output-message
Source
<xsl:variable name="msgprefix">DOTX</xsl:variable>
Variable afill
Documentation

Description

 Filler for A-name anchors  - was &nbsp;
Namespace No namespace
Used by
Templates parent-id; setanametag
Source
<xsl:variable name="afill"/>
Variable trace
Documentation

Description

 ========== SETTINGS ========== 
Namespace No namespace
Source
<xsl:variable name="trace">no</xsl:variable>
Variable link-top-section
Documentation
Namespace No namespace
Used by
Source
Variable do-place-ing
Documentation

Description

 values: yes, no (or any not "yes") 
Namespace No namespace
Used by
Template proc-ing
Source
<xsl:variable name="do-place-ing">no</xsl:variable>
Output (default)
Documentation

Description

 =========== OUTPUT METHOD =========== 
 XHTML output with XML syntax 
Namespace No namespace
Output properties
method encoding indent
no
Source
<xsl:output method="xml" encoding="utf-8" indent="no"/>
Key tm
Namespace No namespace
Match *[contains(@class,' topic/tm ')]
Use .
Used by
Template topic.tm
Source
<xsl:key name="tm" match="*[contains(@class,' topic/tm ')]" use="."/>
Key keyref
Namespace No namespace
Match *[contains(@class, ' topic/term ')]
Use @keyref
Used by
Template topic.term
Source
<xsl:key name="keyref" match="*[contains(@class, ' topic/term ')]" use="@keyref"/>
Key topic
Namespace No namespace
Match *[contains(@class,' topic/topic ')]
Use @id
Source
<xsl:key name="topic" match="*[contains(@class,' topic/topic ')]" use="@id"/>
Key fig
Namespace No namespace
Match *[contains(@class,' topic/fig ')]
Use @id
Source
<xsl:key name="fig" match="*[contains(@class,' topic/fig ')]" use="@id"/>
Key table
Namespace No namespace
Match *[contains(@class,' topic/table ')]
Use @id
Source
<xsl:key name="table" match="*[contains(@class,' topic/table ')]" use="@id"/>
Key li
Namespace No namespace
Match *[contains(@class,' topic/li ')]
Use @id
Source
<xsl:key name="li" match="*[contains(@class,' topic/li ')]" use="@id"/>
Key fn
Namespace No namespace
Match *[contains(@class,' topic/fn ')]
Use @id
Source
<xsl:key name="fn" match="*[contains(@class,' topic/fn ')]" use="@id"/>
Key xref
Namespace No namespace
Match *[contains(@class,' topic/xref ')]
Use substring-after(@href,'#')
Used by
Source
<xsl:key name="xref" match="*[contains(@class,' topic/xref ')]" use="substring-after(@href,'#')"/>