xmlns:exsl="http://exslt.org/common"

                exclude-result-prefixes="exsl" version='1.0'>

    XSLT Stylesheet DocBook -> LaTeX 

    ############################################################################ -->

<xsl:param name="seg.item.separator">, </xsl:param>

<xsl:param name="variablelist.term.separator">, </xsl:param>

<xsl:param name="term.breakline">0</xsl:param>

<xsl:param name="segmentedlist.as.table" select="0"/>

                     orderedlist/title | itemizedlist/title | simplelist/title">

  <xsl:text>
{\sc </xsl:text>

  <xsl:apply-templates/>

  <xsl:text>}
</xsl:text>

  <xsl:call-template name="label.id">

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

  </xsl:call-template>

  <xsl:text>\nopagebreak
</xsl:text>

</xsl:template>

     order to prevent from compilation crash. If the depth is correct

     the templates that actually do the work are called.

 -->

<xsl:template match="itemizedlist|orderedlist|variablelist">

  <xsl:variable name="ditem" select="count(ancestor-or-self::itemizedlist)"/>

  <xsl:variable name="dorder" select="count(ancestor-or-self::orderedlist)"/>

  <xsl:variable name="dvar" select="count(ancestor-or-self::variablelist)"/>

  <xsl:choose>

  <xsl:when test="$ditem > 4">

    <xsl:message>*** Error: itemizedlist too deeply nested (> 4)</xsl:message>

    <xsl:text>[Error: itemizedlist too deeply nested]</xsl:text>

  </xsl:when>

  <xsl:when test="$dorder > 4">

    <xsl:message>*** Error: orderedlist too deeply nested (> 4)</xsl:message>

    <xsl:text>[Error: orderedlist too deeply nested]</xsl:text>

  </xsl:when>

  <xsl:when test="($ditem+$dorder+$dvar) > 6">

    <xsl:message>*** Error: lists too deeply nested (> 6)</xsl:message>

    <xsl:text>[Error: lists too deeply nested]</xsl:text>

  </xsl:when>

  <xsl:otherwise>

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

  </xsl:otherwise>

  </xsl:choose>

</xsl:template>

<xsl:template match="itemizedlist" mode="print">

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

                                     self::titleabbrev or

                                     self::listitem)]"/>

  <xsl:text>\begin{itemize}</xsl:text>

  <xsl:call-template name="opt.group">

    <xsl:with-param name="opts" select="@spacing"/>

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

  </xsl:call-template>

  <xsl:text>
</xsl:text>

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

  <xsl:text>\end{itemize}
</xsl:text>

</xsl:template>

<xsl:template match="orderedlist" mode="print">

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

                                     self::titleabbrev or

                                     self::listitem)]"/>

  <xsl:text>\begin{enumerate}</xsl:text>

  <xsl:call-template name="opt.group">

    <xsl:with-param name="opts" select="@numeration|@continuation|@spacing"/>

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

  </xsl:call-template>

  <xsl:text>
</xsl:text>

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

  <xsl:text>\end{enumerate}
</xsl:text>

</xsl:template>

<xsl:template match="variablelist" mode="print">

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

                                     self::titleabbrev or

                                     self::varlistentry)]"/>

  <xsl:text>
\noindent
</xsl:text>

  <xsl:text>\begin{description}
</xsl:text>

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

  <xsl:text>\end{description}
</xsl:text>

</xsl:template>

<xsl:template match="listitem">

  <xsl:text>
\item{}</xsl:text>

  <xsl:call-template name="label.id"/>

  <xsl:apply-templates/>

  <xsl:text>
</xsl:text>

</xsl:template>

<xsl:template match="varlistentry">

  <xsl:text>\item[{</xsl:text>

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

  <xsl:text>}] </xsl:text>

  <xsl:call-template name="label.id">

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

  </xsl:call-template>

  <xsl:call-template name="label.id">

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

  </xsl:call-template>

  <xsl:apply-templates select="term" mode="foottext"/>

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

</xsl:template>

<xsl:template match="varlistentry/term">

  <xsl:apply-templates/>

  <xsl:if test="position()!=last()">

    <xsl:value-of select="$variablelist.term.separator"/>

  </xsl:if>

</xsl:template>

<xsl:template match="varlistentry/listitem">

  <xsl:choose>

                              self::orderedlist or

                              self::variablelist][not(child::title)]">

    <xsl:text>~</xsl:text>

  </xsl:when>

  <xsl:when test="child::*[1][self::programlisting][not(child::title)]">

    <xsl:text>~</xsl:text>

  </xsl:when>

  <xsl:when test="child::*[not(self::indexterm)][1][self::figure]">

    <xsl:text>~ </xsl:text>

  </xsl:when>

       with immediate following brackets [...]-->

  <xsl:when test="$term.breakline='1'">

    <xsl:text>\hspace{0em}\\~
</xsl:text>

  </xsl:when>

  </xsl:choose>

  <xsl:apply-templates/>

</xsl:template>

     # List Options #

     ################ -->

<xsl:template name="opt.group">

  <xsl:param name="opts"/>

  <xsl:param name="mode" select="'opt'"/>

  <xsl:param name="left" select="'['"/>

  <xsl:param name="right" select="']'"/>

  <xsl:variable name="result">

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

      <xsl:variable name="str">

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

      </xsl:variable>

      <xsl:if test="$str!='' and position()!=1">

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

      </xsl:if>

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

    </xsl:for-each>

  </xsl:variable>

  <xsl:if test="$result != ''">

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

    <xsl:choose>

      <xsl:when test="starts-with($result, ',')">

        <xsl:value-of select="substring-after($result, ',')"/>

      </xsl:when>

      <xsl:otherwise>

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

      </xsl:otherwise>

    </xsl:choose>

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

  </xsl:if>

</xsl:template>

<xsl:template match="@numeration" mode="enumitem">

  <xsl:text>label=</xsl:text>

  <xsl:choose>

    <xsl:when test=".='arabic'">\arabic*.</xsl:when>

    <xsl:when test=".='upperalpha'">\Alph*.</xsl:when>

    <xsl:when test=".='loweralpha'">\alph*.</xsl:when>

    <xsl:when test=".='upperroman'">\Roman*.</xsl:when>

    <xsl:when test=".='lowerroman'">\roman*.</xsl:when>

    <xsl:otherwise>\arabic*.</xsl:otherwise>

  </xsl:choose>

</xsl:template>

<xsl:template match="@continuation" mode="enumitem">

  <xsl:if test=". = 'continues'">

    <xsl:text>resume</xsl:text>

  </xsl:if>

</xsl:template>

<xsl:template match="@spacing" mode="enumitem">

  <xsl:if test=". = 'compact'">

    <xsl:text>itemsep=0pt</xsl:text>

  </xsl:if>

</xsl:template>

     # Simplelist #

     ############## -->

<xsl:template name="tabular.string">

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

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

  <xsl:if test="$i <= $cols">

    <xsl:text>l</xsl:text>

    <xsl:call-template name="tabular.string">

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

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

    </xsl:call-template>

  </xsl:if>

</xsl:template>

<xsl:template match="member">

  <xsl:text>{</xsl:text>

  <xsl:apply-templates/>

  <xsl:text>}</xsl:text>

</xsl:template>

<xsl:template match="simplelist[@type='inline']">

  <xsl:apply-templates/>

</xsl:template>

<xsl:template match="simplelist[@type='inline']/member">

  <xsl:apply-templates/>

  <xsl:if test="position()!=last()">

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

  </xsl:if>

</xsl:template>

<xsl:template match="simplelist[@type='horiz']">

  <xsl:variable name="cols">

    <xsl:choose>

      <xsl:when test="@columns">

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

      </xsl:when>

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

    </xsl:choose>

  </xsl:variable>

  <xsl:text>
\begin{tabular*}{\linewidth}{</xsl:text>

  <xsl:call-template name="tabular.string">

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

  </xsl:call-template>

  <xsl:text>}
</xsl:text>

  <xsl:for-each select="member">

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

    <xsl:choose>

    <xsl:when test="position()=last()">

      <xsl:text> \\
</xsl:text>

    </xsl:when>

    <xsl:when test="position() mod $cols">

      <xsl:text> & </xsl:text>

    </xsl:when>

    <xsl:otherwise>

      <xsl:text> \\
</xsl:text>

    </xsl:otherwise>

    </xsl:choose>

  </xsl:for-each>

  <xsl:text>
\end{tabular*}
</xsl:text>

</xsl:template>

<xsl:template match="simplelist|simplelist[@type='vert']">

  <xsl:variable name="cols">

    <xsl:choose>

      <xsl:when test="@columns">

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

      </xsl:when>

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

    </xsl:choose>

  </xsl:variable>

  <xsl:text>
\begin{tabular*}{\linewidth}{</xsl:text>

  <xsl:call-template name="tabular.string">

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

  </xsl:call-template>

  <xsl:text>}
</xsl:text>

  <xsl:call-template name="simplelist.vert.row">

    <xsl:with-param name="rows" select="floor((count(member)+$cols - 1) div $cols)"/>

  </xsl:call-template>

  <xsl:text>
\end{tabular*}
</xsl:text>

</xsl:template>

<xsl:template name="simplelist.vert.row">

  <xsl:param name="cell">0</xsl:param>

  <xsl:param name="rows"/>

  <xsl:if test="$cell < $rows">

    <xsl:for-each select="member[((position()-1) mod $rows) = $cell]">

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

      <xsl:if test="position()!=last()">

        <xsl:text> & </xsl:text>

      </xsl:if>

    </xsl:for-each>

    <xsl:text> \\
</xsl:text>

    <xsl:call-template name="simplelist.vert.row">

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

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

    </xsl:call-template>

  </xsl:if>

</xsl:template>

<xsl:template match="segmentedlist">

  <xsl:variable name="presentation">

    <xsl:call-template name="pi.dblatex_list-presentation"/>

  </xsl:variable>

  <xsl:choose>

    <xsl:when test="$presentation = 'table'">

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

    </xsl:when>

    <xsl:when test="$presentation = 'list'">

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

    </xsl:when>

    <xsl:when test="$segmentedlist.as.table != 0">

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

    </xsl:when>

    <xsl:otherwise>

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

    </xsl:otherwise>

  </xsl:choose>

</xsl:template>

<xsl:template match="segmentedlist" mode="seglist-inline">

  <xsl:text>\noindent </xsl:text>

  <xsl:apply-templates/>

  <xsl:text>
</xsl:text>

</xsl:template>

<xsl:template match="segmentedlist/title">

  <xsl:text>{\bf </xsl:text>

  <xsl:apply-templates/>

  <xsl:text>}\\
</xsl:text>

</xsl:template>

<xsl:template match="segtitle">

</xsl:template>

<xsl:template match="segtitle" mode="segtitle-in-seg">

  <xsl:apply-templates/>

</xsl:template>

<xsl:template match="seglistitem">

  <xsl:apply-templates/>

  <xsl:if test="following-sibling::seglistitem">

    <xsl:text> \\</xsl:text>

  </xsl:if>

  <xsl:text>
</xsl:text>

</xsl:template>

<xsl:template match="seg">

  <xsl:variable name="segnum" select="count(preceding-sibling::seg)+1"/>

  <xsl:variable name="seglist" select="ancestor::segmentedlist"/>

  <xsl:variable name="segtitles" select="$seglist/segtitle"/>

     Note: segtitle is only going to be the right thing in a well formed

     SegmentedList.  If there are too many Segs or too few SegTitles,

     you'll get something odd...maybe an error

  -->

  <xsl:text>\emph{</xsl:text>

                       mode="segtitle-in-seg"/>

  <xsl:text>:} </xsl:text>

  <xsl:apply-templates/>

  <xsl:if test="following-sibling::seg">

    <xsl:value-of select="$seg.item.separator"/>

  </xsl:if>

</xsl:template>

      To make a LaTeX table we want to know:

      A) How much overall columnar space there is so we can equally

      apportion any leftover space using the proportional space

      allocator, '*'.

      B) Whether to autosize columns, letting LaTeX base the width on

      content, and B.1) which ones to autosize.

      Unfortunately these 2 types of information may be transmitted to

      us via one value, either the default.table.width param or the

      dblatex table-width PI.  We operate on the principal that the

      dblatex table-width PI completely overrides the

      default.table.width param, so we've really only one value to

      work with at any one time.  Since we get a single value we

      receive only one of A or B and must assume the other.

      We may or may not receive additional information regards A or B

      via the newtbl.autowidth param or the dblatex newtbl-autowidth

      PI or the dblatex colwidth PI.

      This is resolved as follows:

       o When B is specified, assume page width for A.

       o When A is specified, assume every column is equally apportioned.

       o When nothing is specified, assume page width for A and

         autosizing of every column.

      Note that page width is not a universally good default for

      table width.  Proportionally spaced columns will "appropriately"

      fill the page, but adding any fixed width columns or

      autowidth columns will result in a table that's wider than

      a page.

      To gain complete control the user must specify A, the overall

      table width, using param or PI above.  Then specify the width of

      each column, whether fixed, proportional, proportional + fixed,

      or autosized, via other methods.

      This works because the PIs and params that otherwise control

      table layout have precedence over the table width controls.  The

      dblatex colwidth PI only occurs within a lexically "inner"

      portion of the document so it always has priority.

      newtbl.autowidth (and the newtbl-autowidth PI) is defined to

      have priority over table.width (and it's PI).

      -->

<xsl:template name="segtable.table-width">

  <xsl:variable name="table-width">

    <xsl:call-template name="pi.dblatex_table-width"/>

  </xsl:variable>

  <xsl:choose>

    <xsl:when test="$table-width = ''">

      <xsl:value-of select="$default.table.width"/>

    </xsl:when>

    <xsl:otherwise>

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

    </xsl:otherwise>

  </xsl:choose>

</xsl:template>

<xsl:template name="segtable.autocols">

  <xsl:param name="autowidth-pi"/>  

  <xsl:param name="table-width"/>   

  <xsl:choose>

    <xsl:when test="contains($autowidth-pi, 'column:')">

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

    </xsl:when>

                    and contains($table-width, 'column:')">

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

    </xsl:when>

  </xsl:choose>

  <xsl:text> </xsl:text>

</xsl:template>

<xsl:template name="segtable.autowidth">

  <xsl:param name="autowidth.pi"/>  

  <xsl:param name="table-width"/>   

  <xsl:variable name="autowidth">

    <xsl:choose>

      <xsl:when test="$autowidth.pi = ''">

        <xsl:value-of select="$newtbl.autowidth"/>

      </xsl:when>

      <xsl:otherwise>

        <xsl:value-of select="$autowidth.pi"/>

      </xsl:otherwise>

    </xsl:choose>

  </xsl:variable>

  <xsl:choose>

    <xsl:when test="$autowidth = ''">

      <xsl:choose>

        <xsl:when test="$table-width = ''">

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

        </xsl:when>

        <xsl:when test="contains($table-width, 'auto')">

          <xsl:choose>

                            or contains($table-width, 'column:')">

              <xsl:text>none</xsl:text>

            </xsl:when>

            <xsl:otherwise>

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

            </xsl:otherwise>

          </xsl:choose>

        </xsl:when>

        <xsl:otherwise>

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

        </xsl:otherwise>

      </xsl:choose>

    </xsl:when>

    <xsl:otherwise>

      <xsl:choose>

        <xsl:when test="contains($autowidth, 'column:')">

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

        </xsl:when>

        <xsl:otherwise>

          <xsl:choose>

            <xsl:when test="$autowidth = 'none'">

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

            </xsl:when>

            <xsl:otherwise>

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

            </xsl:otherwise>

          </xsl:choose>

        </xsl:otherwise>

      </xsl:choose>

    </xsl:otherwise>

  </xsl:choose>

</xsl:template>

<xsl:template name="proportional.column">

      colwidth="\newtblstarfactor"

      star="1"/>

</xsl:template>

<xsl:template name="autowidth.column">

      autowidth="1"/>

</xsl:template>

<xsl:template name="user.specified.column">

  <xsl:param name="colwidth.pi"/>  

  <xsl:variable name="fixed">

    <xsl:call-template name="colfixed.get">

      <xsl:with-param name="width" select="$colwidth.pi"/>

    </xsl:call-template>

  </xsl:variable>

  <colspec>

    <xsl:if test="$fixed != ''">

      <xsl:attribute name="fixedwidth">

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

      </xsl:attribute>

    </xsl:if>

    <xsl:choose>

      <xsl:when test="contains($colwidth.pi, '*')">

        <xsl:attribute name="colwidth">

          <xsl:call-template name="replace-string">

            <xsl:with-param name="text" select="$colwidth.pi"/>

            <xsl:with-param name="replace">*</xsl:with-param>

            <xsl:with-param name="with">\newtblstarfactor</xsl:with-param>

          </xsl:call-template>

        </xsl:attribute>

        <xsl:attribute name="star">

          <xsl:call-template name="colstar.get">

                name="width"

                select="substring-before($colwidth.pi, '*')"/>

          </xsl:call-template>

        </xsl:attribute>

      </xsl:when>

      <xsl:otherwise>

        <xsl:attribute name="colwidth">

          <xsl:value-of select="$colwidth.pi"/>

        </xsl:attribute>

      </xsl:otherwise>

    </xsl:choose>

  </colspec>

</xsl:template>

   - tbl.sizes wants colspecs so build a set of fake colspec elements.

   -

   - tbl.sizes takes a collection of colspec elements, each having

   - the following (optional) attributes:

   -

   - fixedwidth

   -   String.  The fixed part (from colfixed.get) of a specified

   -   column width.

   -

   - star

   -   String (that we know can be converted to a number).

   -   The "prefix count" of the * (from colstar.get).

   -

   - colwidth

   -   String.  The user-specified column width with * replaced with

   -   "\newtblstarfactor".

   -

   - The code in this file uses the (optional) attributes:

   -   colwidth

   -   autowidth

   -     String (always "1").  When present (regardless of value!)

   -     autowidth means the column is latex spaced.

-->

<xsl:template name="segtable.colspecs">

  <xsl:param name="table-width"/>   

  <xsl:variable name="autowidth.pi">

    <xsl:call-template name="pi.dblatex_autowidth"/>

  </xsl:variable>

  <xsl:variable name="autowidth">

    <xsl:call-template name="segtable.autowidth">

      <xsl:with-param name="autowidth.pi" select="$autowidth.pi"/>

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

    </xsl:call-template>

  </xsl:variable>

  <xsl:variable name="autocols">

    <xsl:call-template name="segtable.autocols">

      <xsl:with-param name="autowidth.pi" select="$autowidth.pi"/>

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

    </xsl:call-template>

  </xsl:variable>

  <xsl:for-each select="segtitle">

    <xsl:variable name="colwidth.pi">

      <xsl:call-template name="pi.dblatex_colwidth"/>

    </xsl:variable>

    <xsl:choose>

      <xsl:when test="$colwidth.pi = ''">

        <xsl:choose>

                                   concat(' ', position(), ' '))

                          or $autowidth = '1'">

            <xsl:call-template name="autowidth.column"/>

          </xsl:when>

          <xsl:otherwise>

            <xsl:call-template name="proportional.column"/>

          </xsl:otherwise>

        </xsl:choose>

      </xsl:when>

                      or $colwidth.pi = 'autowidth.all'">

        <xsl:call-template name="autowidth.column"/>

      </xsl:when>

      <xsl:when test="$colwidth.pi = 'autowidth.none'">

        <xsl:call-template name="proportional.column"/>

      </xsl:when>

      <xsl:otherwise>

        <xsl:call-template name="user.specified.column">

          <xsl:with-param name="colwidth.pi" select="$colwidth.pi"/>

        </xsl:call-template>

      </xsl:otherwise>

    </xsl:choose>

  </xsl:for-each>

</xsl:template>

<xsl:template name="segtable.length.setup">

  <xsl:param name="table-width"/>   

  <xsl:param name="colspecs"/>      

  <xsl:variable name="width">

    <xsl:variable name="fullwidth">\linewidth-2\tabcolsep</xsl:variable>

    <xsl:choose>

                    or contains($table-width, 'auto')">

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

    </xsl:when>

    <xsl:when test="contains($table-width, '%')">

                            div 100"/>

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

    </xsl:when>

    <xsl:otherwise>

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

    </xsl:otherwise>

    </xsl:choose>

  </xsl:variable>

  <xsl:call-template name="tbl.sizes">

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

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

  </xsl:call-template>

</xsl:template>

<xsl:template match="segmentedlist" mode="seglist-table">

  <xsl:variable name="table-width">

    <xsl:call-template name="segtable.table-width"/>

  </xsl:variable>

  <xsl:variable name="colspecs-text">

    <xsl:call-template name="segtable.colspecs">

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

    </xsl:call-template>

  </xsl:variable>

  <xsl:variable name="colspecs" select="exsl:node-set($colspecs-text)"/>

  <xsl:text>

{\raggedright\savetablecounter</xsl:text>

  <xsl:text>\begingroup%
</xsl:text>

  <xsl:call-template name="segtable.length.setup">

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

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

  </xsl:call-template>

  <xsl:text>\setlength{\LTpre}{\parskip}</xsl:text>

  <xsl:text>\setlength{\LTpost}{\parskip-\fontcharht\font`i}%
</xsl:text>

  <xsl:text>\begin{longtable}[l]{</xsl:text>

  <xsl:for-each select="$colspecs/colspec">

    <xsl:text>l</xsl:text>

  </xsl:for-each>

  <xsl:text>}
</xsl:text>

                       select="title|info/title|titleabbrev|info/titleabbrev">

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

  </xsl:apply-templates>

  <xsl:apply-templates mode="seg-table" select="segtitle">

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

  </xsl:apply-templates>

  <xsl:apply-templates mode="seg-table" select="seglistitem">

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

  </xsl:apply-templates>

  <xsl:text>\end{longtable}\endgroup%
</xsl:text>

  <xsl:text>\restoretablecounter%
</xsl:text>

  <xsl:text>}</xsl:text>

</xsl:template>

<xsl:template match="title|titleabbrev" mode="seglist-title">

  <xsl:text>{\bf </xsl:text>

  <xsl:apply-templates/>

  <xsl:text>}</xsl:text>

</xsl:template>

                     | segmentedlist/info/title

                     | segmentedlist/titleabbrev[not(../title)]

                     | segmentedlist/info/titleabbrev[not(../title)]"

              mode="seg-table">

  <xsl:param name="colspecs"/>

  <xsl:text>\multicolumn{</xsl:text>

  <xsl:value-of select="count($colspecs/colspec)"/>

  <xsl:text>}{</xsl:text>

  <xsl:choose>

    <xsl:when test="$colspecs/colspec/@autowidth">

      <xsl:text>l</xsl:text>

    </xsl:when>

    <xsl:otherwise>

      <xsl:text>p{</xsl:text>

      <xsl:for-each select="$colspecs/colspec">

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

        <xsl:if test="following-sibling::colspec">

          <xsl:text>+\tabcolsep+</xsl:text>

        </xsl:if>

      </xsl:for-each>

      <xsl:text>}</xsl:text>

    </xsl:otherwise>

  </xsl:choose>

  <xsl:text>}{\raggedright%
</xsl:text>

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

  <xsl:text>%
}\tabularnewline
</xsl:text>

</xsl:template>

<xsl:template name="segmentedlist.col">

  <xsl:param name="colspecs"/>

  <xsl:param name="format"/>

  <xsl:param name="heading" select="0"/>

  <xsl:variable name="position">

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

  </xsl:variable>

                select="$colspecs/colspec[position()=$position]"/>

  <xsl:variable name="colwidth">

    <xsl:value-of select="$colspec/@colwidth"/>

  </xsl:variable>

       - but we want to know about the _existance_ of the attribute,

       - not it's content, and testing for "" is ugly.

       - So "select=..." in variable. -->

                select="$colspec/@autowidth"/>

  <xsl:text>\multicolumn{1}{</xsl:text>