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

                xmlns:m="http://docbook2x.sourceforge.net/xmlns/Man-XML"

                exclude-result-prefixes="exsl"

                version='1.0'>

       $Id: man-table.xsl,v 1.2 2006/04/22 19:47:18 stevecheng Exp $

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

       This file came from manpages/table.xsl in

       the XSL DocBook Stylesheet distribution.

       See ../../COPYING for the original copyright information.

       This stylesheet converts DocBook tables to tbl markup.

       The conversion is done in a somewhat roundabout way by 

       going through HTML tables first.

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

  <xsl:include href="man-common-table.xsl" />

  <xsl:include href="man-html-table.xsl" />

  <xsl:template name="dbhtml-attribute">

    <xsl:param name="pis" />

    <xsl:param name="attribute" />

  </xsl:template>

  <xsl:param name="html.cellspacing" select="''" />

  <xsl:param name="html.cellpadding" select="''" />

  <xsl:param name="table.borders.with.css" select="0" />

  <xsl:param name="default.table.width" select="''"/>

  <xsl:param name="use.extensions" select="0" />

  <xsl:param name="entry.propagates.style" select="1" />

  <xsl:param name="show.revisionflag" select="0" />

  <xsl:template name="anchor" />

<xsl:template name="copy-string">

  <xsl:param name="string"/>

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

  <xsl:param name="result"/>

  <xsl:choose>

    <xsl:when test="$count>0">

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

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

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

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

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

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

        </xsl:with-param>

      </xsl:call-template>

    </xsl:when>

    <xsl:otherwise>

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

    </xsl:otherwise>

  </xsl:choose>

</xsl:template>

  <xsl:template name="trim.text">

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

    <xsl:variable name="contents-left-trimmed">

      <xsl:call-template name="trim-left">

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

      </xsl:call-template>

    </xsl:variable>

    <xsl:variable name="contents-trimmed">

      <xsl:call-template name="trim-right">

        <xsl:with-param name="contents" select="$contents-left-trimmed"/>

      </xsl:call-template>

    </xsl:variable>

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

  </xsl:template>

  <xsl:template name="trim-left">

    <xsl:param name="contents"/>

    <xsl:choose>

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

        <xsl:call-template name="trim-left">

          <xsl:with-param name="contents" select="substring($contents, 2)"/>

        </xsl:call-template>

      </xsl:when>

      <xsl:otherwise>

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

      </xsl:otherwise>

    </xsl:choose>

  </xsl:template>

  <xsl:template name="trim-right">

    <xsl:param name="contents"/>

    <xsl:variable name="last-char">

      <xsl:value-of select="substring($contents, string-length($contents), 1)"/>

    </xsl:variable>

    <xsl:choose>

      <xsl:when test="($last-char = '
') or                       ($last-char = '
') or                       ($last-char = ' ') or                       ($last-char = '	')">

        <xsl:call-template name="trim-right">

          <xsl:with-param name="contents" select="substring($contents, 1, string-length($contents) - 1)"/>

        </xsl:call-template>

      </xsl:when>

      <xsl:otherwise>

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

      </xsl:otherwise>

    </xsl:choose>

  </xsl:template>

  <xsl:template match="m:table">

    <xsl:call-template name="block-break" />

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

  </xsl:template>

  <xsl:param name="tbl.running.header.from.thead" select="0"/>

  <xsl:param name="tbl.column.separator.char">:</xsl:param>

  <xsl:param name="tbl.title.font">B</xsl:param>

  <xsl:param name="tbl.headings.font">B</xsl:param>

  <xsl:template match="m:table" mode="to.tbl">

    <xsl:param name="source"/>

    <xsl:param name="title" />

    <xsl:param name="allbox">

    <xsl:if test="not(@frame = 'none') and not(@border = '0')">

      <xsl:text>allbox </xsl:text>

    </xsl:if>

    </xsl:param>

    <xsl:param name="center">

    <xsl:if test="@align = 'center' or m:tgroup/@align = 'center'">

      <xsl:text>center </xsl:text>

    </xsl:if>

    </xsl:param>

    <xsl:param name="expand">

    <xsl:if test="@pgwide = '1' or @width = '100%'">

      <xsl:text>expand </xsl:text>

    </xsl:if>

    </xsl:param>

    <xsl:param name="html-table-output">

      <xsl:choose>

        <xsl:when test=".//tr">

          <xsl:for-each select="descendant-or-self::table|descendant-or-self::informaltable">

            <xsl:element name="{local-name(..)}">

                <xsl:copy-of select="*"/>

            </xsl:element>

          </xsl:for-each>

        </xsl:when>

        <xsl:otherwise>

          <xsl:apply-templates/>

        </xsl:otherwise>

      </xsl:choose>

    </xsl:param>

    <xsl:param name="contents" select="exsl:node-set($html-table-output)"/>

         * templates (further below) to generate the actual tbl(1) markup, -->

    <xsl:for-each select="$contents//table">

      <xsl:if test="$title != '' or parent::td">

        <xsl:text>.PP
</xsl:text>

        <xsl:text>.</xsl:text>

        <xsl:value-of select="$tbl.title.font"/>

        <xsl:text> </xsl:text>

        <xsl:if test="parent::td">

          <xsl:text>*[nested table]</xsl:text>

        </xsl:if>

        <xsl:value-of select="normalize-space($title)"/>

        <xsl:text>
</xsl:text>

        <xsl:text>.sp -1n
</xsl:text>

      </xsl:if>

      <xsl:text>.TS</xsl:text>

      <xsl:if test="thead and $tbl.running.header.from.thead">

        <xsl:text> H</xsl:text>

      </xsl:if>

      <xsl:text>
</xsl:text>

      <xsl:variable name="options-line">

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

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

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

        <xsl:text>tab(</xsl:text>

        <xsl:value-of select="$tbl.column.separator.char"/>

        <xsl:text>)</xsl:text>

      </xsl:variable>

      <xsl:if test="normalize-space($options-line) != ''">

        <xsl:value-of select="normalize-space($options-line)"/>

        <xsl:text>;
</xsl:text>

      </xsl:if>

      <xsl:if test="thead">

        <xsl:call-template name="output.rows">

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

        </xsl:call-template> 

        <xsl:text>
</xsl:text>

        <xsl:choose>

          <xsl:when test="$tbl.running.header.from.thead">

            <xsl:text>.TH
</xsl:text>

          </xsl:when>

          <xsl:otherwise>

            <xsl:text>.T&
</xsl:text>

          </xsl:otherwise>

        </xsl:choose>

      </xsl:if>

      <xsl:variable name="rows-set">

        <xsl:copy-of select="tbody/tr|tr"/>

        <xsl:copy-of select="tfoot/tr"/>

      </xsl:variable>

      <xsl:call-template name="output.rows">

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

        <xsl:with-param name="rows" select="exsl:node-set($rows-set)"/>

      </xsl:call-template>

      <xsl:text>
</xsl:text>

      <xsl:text>.TE
</xsl:text>

      <xsl:text>.sp
</xsl:text>

    </xsl:for-each>

  </xsl:template>

  <xsl:template name="output.rows">

    <xsl:param name="source"/>

    <xsl:param name="rows"/>

    <xsl:variable name="cells-list">

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

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

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

      </xsl:call-template>

    </xsl:variable>

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

    <xsl:call-template name="create.table.format">

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

    </xsl:call-template>

    <xsl:for-each select="$cells/cell">

      <xsl:call-template name="output.cell"/>

    </xsl:for-each>

  </xsl:template>

  <xsl:template name="output.cell">

    <xsl:choose>

                      not(preceding-sibling::cell)">

        <xsl:text>
</xsl:text>

      </xsl:when>

      <xsl:otherwise>

        <xsl:value-of select="$tbl.column.separator.char"/>

      </xsl:otherwise>

    </xsl:choose>

    <xsl:choose>

      <xsl:when test="@type = '^'">

        <xsl:if test="@colspan and @colspan > 1">

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

            <xsl:with-param name="string" select="$tbl.column.separator.char"/>

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

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

            </xsl:with-param>

          </xsl:call-template>

        </xsl:if>

      </xsl:when>

      <xsl:otherwise>

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

        <xsl:copy-of select="."/>

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

      </xsl:otherwise>

    </xsl:choose>

  </xsl:template>

  <xsl:template name="build.cell.list">

    <xsl:param name="source"/>

    <xsl:param name="rows"/>

    <xsl:param  name="cell-data-unsorted">

      <xsl:apply-templates select="$rows" mode="cell.list">

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

      </xsl:apply-templates>

    </xsl:param>

    <xsl:param  name="cell-data-sorted">

      <xsl:for-each select="exsl:node-set($cell-data-unsorted)/cell">

        <xsl:sort select="@row"/>

        <xsl:sort select="@slot"/>

        <xsl:copy-of select="."/>

      </xsl:for-each>

    </xsl:param>

    <xsl:copy-of select="$cell-data-sorted"/>

  </xsl:template>

  <xsl:template match="tr" mode="cell.list">

    <xsl:param name="source"/>

    <xsl:variable name="row">

      <xsl:value-of select="count(preceding-sibling::tr) + 1"/>

    </xsl:variable>

    <xsl:for-each select="td|th">

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

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

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

        <xsl:with-param name="class" select="name(.)"/>

      </xsl:call-template>

    </xsl:for-each>

  </xsl:template>

  <xsl:template name="cell">

    <xsl:param name="source"/>

    <xsl:param name="row"/>

    <xsl:param name="class"/>

    <xsl:param name="slot">

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

    </xsl:param>

          row="{$row}"

          slot="{$slot}"

          class="{$class}"

          colspan="{@colspan}"

          align="{@align}"

          valign="{@valign}"

          >

      <xsl:choose>

        <xsl:when test=".//tr">

          <xsl:call-template name="log.message">

            <xsl:with-param name="level">Warn</xsl:with-param>

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

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

              >tbl convert : Extracted a nested table</xsl:text>

            </xsl:with-param>

          </xsl:call-template>

          <xsl:text>[\fInested table\fR]*
</xsl:text>

        </xsl:when>

        <xsl:otherwise>

          <xsl:variable name="contents">

            <xsl:apply-templates/>

          </xsl:variable>

          <xsl:call-template name="trim.text">

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

          </xsl:call-template>

        </xsl:otherwise>

      </xsl:choose>

    </cell>

    <xsl:if test="@rowspan and @rowspan > 0">

      <xsl:variable name="colspan-offset">

            select="sum(preceding-sibling::td[@colspan != ''

                    and @colspan > 1]/@colspan) -

                    count(preceding-sibling::td[@colspan != ''

                    and @colspan > 1]/@colspan)"/>

      </xsl:variable>

      <xsl:call-template name="create.dummy.cells">

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

        <xsl:with-param name="slot" select="$slot + $colspan-offset"/>

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

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

      </xsl:call-template>

    </xsl:if>

  </xsl:template>

  <xsl:template name="create.dummy.cells">

    <xsl:param name="row"/>

    <xsl:param name="slot"/>

    <xsl:param name="colspan"/>

    <xsl:param name="rowspan"/>

    <xsl:choose>

      <xsl:when test="$rowspan > 1">

        <cell row="{$row}" slot="{$slot}" type="^" colspan="{@colspan}"/>

        <xsl:call-template name="create.dummy.cells">

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

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

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

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

        </xsl:call-template>

      </xsl:when>

    </xsl:choose>

  </xsl:template>

  <xsl:template name="create.table.format">

    <xsl:param name="cells"/>

    <xsl:apply-templates mode="table.format" select="$cells"/>

    <xsl:text>.</xsl:text>

  </xsl:template>

  <xsl:template match="cell" mode="table.format">

    <xsl:choose>

      <xsl:when test="preceding-sibling::cell[1]/@row != @row">

        <xsl:text>
</xsl:text>

      </xsl:when>

      <xsl:otherwise>

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

          <xsl:text> </xsl:text>

        </xsl:if>

      </xsl:otherwise>

    </xsl:choose>

    <xsl:choose>

      <xsl:when test="@type = '^'">

        <xsl:text>^</xsl:text>

      </xsl:when>

      <xsl:when test="@align = 'center'">

        <xsl:text>c</xsl:text>

      </xsl:when>

      <xsl:when test="@align = 'right'">

        <xsl:text>r</xsl:text>

      </xsl:when>

      <xsl:when test="@align = 'char'">

        <xsl:text>n</xsl:text>

      </xsl:when>

      <xsl:otherwise>

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

      </xsl:otherwise>

    </xsl:choose>

    <xsl:if test="@valign = 'top'">

      <xsl:text>t</xsl:text>

    </xsl:if>

    <xsl:if test="@class = 'th'">

      <xsl:value-of select="$tbl.headings.font"/>

    </xsl:if>

    <xsl:if test="@colspan > 1">

      <xsl:call-template name="process.colspan">

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

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

      </xsl:call-template>

    </xsl:if>

  </xsl:template>

  <xsl:template name="process.colspan">

    <xsl:param name="colspan"/>

    <xsl:param name="type"/>

    <xsl:text> </xsl:text>

    <xsl:choose>

      <xsl:when test="$type = '^'">

        <xsl:text>^</xsl:text>

      </xsl:when>

      <xsl:otherwise>

        <xsl:text>s</xsl:text>

      </xsl:otherwise>

    </xsl:choose>

    <xsl:if test="$colspan > 1">

      <xsl:call-template name="process.colspan">

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

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

      </xsl:call-template>

    </xsl:if>

  </xsl:template>

  <xsl:template match="colgroup"/>

  <xsl:template match="col"/>

</xsl:stylesheet>