<?xml version="1.0"?>

<!--

  Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved.

  CDDL HEADER START

   The contents of this file are subject to the terms of the

   Common Development and Distribution License (the "License").

   You may not use this file except in compliance with the License.

   You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE

   or http://www.opensolaris.org/os/licensing.

   See the License for the specific language governing permissions

   and limitations under the License.

   When distributing Covered Code, include this CDDL HEADER in each

   file and include the License file at usr/src/OPENSOLARIS.LICENSE.

   If applicable, add the following below this CDDL HEADER, with the

   fields enclosed by brackets "[]" replaced with your own identifying

   information: Portions Copyright [yyyy] [name of copyright owner]

  CDDL HEADER END

-->

<!-- Common docbook xsl templates -->

<xsl:stylesheet version="1.0"

  xmlns:adr="http://www.opensolaris.org/ns/adr"

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

  exclude-result-prefixes="adr">

  <!-- l10n routines -->

  <xsl:import href="locale.xsl"/>

  <xsl:variable name="LOCALE_PKG_PREFIX" select="'radadr-'"/>

  <!--

   * Whether to adhere to the docbook schema, at the expense of some elements

   * not rendering as nicely

   -->

  <xsl:param name="transform.adheretoschema" select="0"/>

  <!-- The element name of sections at various depths -->

  <xsl:variable name="element.section1">section</xsl:variable>

  <xsl:variable name="element.section2">section</xsl:variable>

  <xsl:variable name="element.section3">section</xsl:variable>

  <!-- Constants -->

  <xsl:variable name="newline"><xsl:text>&#xA;</xsl:text></xsl:variable>

  <xsl:variable name="nbsp"><xsl:text>&#xA0;</xsl:text></xsl:variable>

  <xsl:template name="header">

    <xsl:param name="node"/>

    <xsl:param name="inline"/>

    <xsl:choose>

      <xsl:when test="boolean($inline)">

        <emphasis role="strong">

          <xsl:copy-of select="$node"/>

        </emphasis>

      </xsl:when>

      <xsl:otherwise>

        <para>

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

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

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

          </xsl:call-template>

        </para>

      </xsl:otherwise>

    </xsl:choose>

  </xsl:template>

  <!-- Indent content -->

  <xsl:template name="indent">

    <xsl:param name="content"/>

    <xsl:choose>

      <xsl:when test="boolean($transform.adheretoschema)">

        <blockquote>

          <xsl:copy-of select="$content"/>

        </blockquote>

      </xsl:when>

      <xsl:otherwise>

        <!--

         * looks better under yelp, and renders consistently for man pages

         * transforms, but is non-compliant

         -->

        <simplelist type="vert">

          <member>

            <xsl:copy-of select="$content"/>

          </member>

        </simplelist>

      </xsl:otherwise>

    </xsl:choose>

  </xsl:template>

  <!-- Indent content -->

  <xsl:template match="*" mode="indent">

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

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

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

      </xsl:with-param>

    </xsl:call-template>

  </xsl:template>

  <!-- Process type/typeref attributes for fields, props, etc. -->

  <xsl:template match="*" mode="type">

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

    <xsl:variable name="type">

      <xsl:choose>

        <xsl:when test="@type">

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

        </xsl:when>

        <xsl:when test="@typeref">

          <xsl:variable name="content">

            <link linkend="{@typeref}">

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

            </link>

          </xsl:variable>

          <xsl:choose>

            <xsl:when test="boolean($transform.adheretoschema)">

              <replaceable>

                <xsl:copy-of select="$content"/>

              </replaceable>

            </xsl:when>

            <xsl:otherwise>

              <!-- looks better under yelp, but is non-compliant -->

              <xsl:copy-of select="$content"/>

            </xsl:otherwise>

          </xsl:choose>

        </xsl:when>

        <xsl:when test="adr:list">

          <xsl:apply-templates select="adr:list" mode="type">

            <xsl:with-param name="enclose" select="0"/>

          </xsl:apply-templates>

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

        </xsl:when>

      </xsl:choose>

    </xsl:variable>

    <xsl:choose>

      <xsl:when test="boolean($enclose)">

        <xsl:choose>

          <xsl:when test="string-length($type) != 0">

            <type>

              <xsl:copy-of select="$type"/>

            </type>

          </xsl:when>

          <xsl:otherwise>

            <emphasis>

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

                <xsl:with-param name="name"

                  select="'docbook.general.voidtype'"/>

              </xsl:call-template>

            </emphasis>

          </xsl:otherwise>

        </xsl:choose>

      </xsl:when>

      <xsl:otherwise>

        <xsl:copy-of select="$type"/>

      </xsl:otherwise>

    </xsl:choose>

  </xsl:template>

  <!-- Process parameter names -->

  <xsl:template match="*" mode="paramname">

    <xsl:param name="strong"/>

    <emphasis>

      <xsl:if test="boolean($strong)">

        <xsl:attribute name="role">strong</xsl:attribute>

      </xsl:if>

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

    </emphasis>

  </xsl:template>

  <!-- Process parameters -->

  <xsl:template match="*" mode="parameter">

    <xsl:param name="strong"/>

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

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

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

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

    </xsl:apply-templates>

  </xsl:template>

  <!-- Process optional attribute for fields, props, etc. -->

  <xsl:template match="*" mode="optional">

    <xsl:if test="@optional = 'true' or @optional = '1'">

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

        <emphasis>

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

            <xsl:with-param name="name" select="'docbook.general.optional'"/>

          </xsl:call-template>

        </emphasis>

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

    </xsl:if>

  </xsl:template>

  <!-- API hierarchy characters -->

  <xsl:variable name="hierarchy.boxdr">.</xsl:variable>

  <xsl:variable name="hierarchy.boxh">-</xsl:variable>

  <xsl:variable name="hierarchy.boxv">|</xsl:variable>

  <xsl:variable name="hierarchy.boxvr">+</xsl:variable>

  <xsl:variable name="hierarchy.rarr">&gt;</xsl:variable>

  <!--

   * Output an inheritance tree for the given api or type.  Since these elements

   * support multiple inheritance, the tree must be drawn slightly differently

   * than, say, a Javadoc class hierarchy.

   *

   *  .-> api threeletterwords

   *  |

   *  |   .-> api familymember

   *  |   |

   *  +-> api pet

   *  |

   *  |       .-> api lifeform

   *  |       |

   *  |   .-> api animal

   *  |   |

   *  +-> api mammal

   *  |

   *  api dog

   -->

  <xsl:template match="adr:api|adr:type" mode="hierarchy">

    <xsl:param name="prefix"/>

    <xsl:param name="position" select='0'/>

    <xsl:variable name="elementname" select="name()"/>

    <xsl:variable name="newprefix">

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

      <xsl:choose>

        <xsl:when test="$position = 0"/>

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

          <xsl:text>    </xsl:text>

        </xsl:when>

        <xsl:otherwise>

          <xsl:value-of select="$hierarchy.boxv"/>

          <xsl:text>   </xsl:text>

        </xsl:otherwise>

      </xsl:choose>

    </xsl:variable>

    <xsl:for-each select="adr:include/@typeref">

      <xsl:apply-templates

        select="//*[name() = $elementname and @name = current()]"

        mode="hierarchy">

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

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

      </xsl:apply-templates>

      <!-- Vertical separator between nodes -->

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

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

      <xsl:value-of select="$hierarchy.boxv"/>

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

    </xsl:for-each>

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

    <xsl:if test="$position != 0">

      <xsl:choose>

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

          <!-- Corner -->

          <xsl:value-of select="$hierarchy.boxdr"/>

        </xsl:when>

        <xsl:otherwise>

          <!-- Tee -->

          <xsl:value-of select="$hierarchy.boxvr"/>

        </xsl:otherwise>

      </xsl:choose>

      <!-- Horizontal line/arrow -->

      <xsl:value-of select="$hierarchy.boxh"/>

      <xsl:value-of select="$hierarchy.rarr"/>

      <xsl:text> </xsl:text>

    </xsl:if>

    <!-- Display node -->

    <xsl:apply-templates select="." mode="hierarchy-node">

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

    </xsl:apply-templates>

  </xsl:template>

  <!-- Default presentation of hierarchy nodes -->

  <xsl:template match="adr:api" mode="hierarchy-node">

    <xsl:param name="position"/>

    <xsl:choose>

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

        <emphasis role="strong">

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

        </emphasis>

      </xsl:when>

      <xsl:otherwise>

        <link linkend="{concat('api.', @name)}">

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

        </link>

      </xsl:otherwise>

    </xsl:choose>

  </xsl:template>

  <!-- Default presentation of hierarchy nodes -->

  <xsl:template match="adr:type" mode="hierarchy-node">

    <xsl:param name="position"/>

    <xsl:variable name="text">

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

        <xsl:with-param name="name" select="'docbook.type.label'"/>

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

          <param>

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

          </param>

        </xsl:with-param>

      </xsl:call-template>

    </xsl:variable>

    <xsl:choose>

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

        <emphasis role="strong">

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

        </emphasis>

      </xsl:when>

      <xsl:otherwise>

        <link linkend="{@name}">

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

        </link>

      </xsl:otherwise>

    </xsl:choose>

  </xsl:template>

  <!--

   * Output sections listing the members (fields of types, properties of

   * apis, methods of apis, etc.) of inherited entities.  Each member is

   * hyperlinked to the actual definition of that member elsewhere in the

   * document.  When no members of the given type are found, the noneRes

   * resource is used to display a "none" label.

   -->

  <xsl:template match="adr:api|adr:type" mode="member-hierarchy">

    <xsl:param name="level" select='0'/>

    <xsl:param name="member"/>

    <xsl:param name="noneRes"/>

    <xsl:variable name="elementname" select="name()"/>

    <xsl:for-each select="adr:include/@typeref">

      <xsl:apply-templates

        select="//*[name() = $elementname and @name = current()]"

        mode="member-hierarchy">

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

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

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

      </xsl:apply-templates>

    </xsl:for-each>

    <xsl:if test="$level != 0">

      <xsl:apply-templates select="." mode="member-hierarchy-header">

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

      </xsl:apply-templates>

      <para>

        <xsl:choose>

          <xsl:when test="*[name() = $member]">

            <simplelist type="inline">

              <xsl:for-each select="*[name() = $member]">

                <member>

                  <xsl:apply-templates select="."

                    mode="member-hierarchy-list-item"/>

                </member>

              </xsl:for-each>

            </simplelist>

          </xsl:when>

          <xsl:otherwise>

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

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

            </xsl:call-template>

          </xsl:otherwise>

        </xsl:choose>

      </para>

    </xsl:if>

  </xsl:template>

  <!-- Present an api header to appear in a member hierarchy section -->

  <xsl:template match="adr:api" mode="member-hierarchy-header">

    <xsl:param name="member"/>

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

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

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

          <xsl:with-param name="name"

            select="concat('docbook.api.', $member, '.inherited.header')"/>

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

            <param>

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

            </param>

          </xsl:with-param>

        </xsl:call-template>

      </xsl:with-param>

    </xsl:call-template>

  </xsl:template>

  <!-- Present a type header to appear in a member hierarchy section -->

  <xsl:template match="adr:type" mode="member-hierarchy-header">

    <xsl:param name="member"/>

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

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

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

          <xsl:with-param name="name"

            select="'docbook.type.field.inherited.header'"/>

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

            <param>

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

            </param>

          </xsl:with-param>

        </xsl:call-template>

      </xsl:with-param>

    </xsl:call-template>

  </xsl:template>

  <!-- Display a member in a member hierarchy section -->

  <xsl:template match="adr:field|adr:property|adr:method"

    mode="member-hierarchy-list-item">

    <link linkend="{concat(../@name, '.', @name)}">

      <emphasis>

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

      </emphasis>

    </link>

  </xsl:template>

  <!-- Process the documentation summary (inline) elements -->

  <xsl:template match="adr:summary" mode="inline">

    <xsl:param name="usehyphen" select='1'/>

    <xsl:if test="$usehyphen">

      <xsl:text> &#x2014; </xsl:text> <!-- &mdash; -->

    </xsl:if>

    <xsl:apply-templates/>

  </xsl:template>

  <!-- Process the documentation summary (block) elements -->

  <xsl:template match="adr:summary" mode="block">

    <para>

      <xsl:apply-templates/>

    </para>

  </xsl:template>

  <!--

   * Process "documentation root" elements, i.e. those that can contain inline

   * children or block children, but not both.  Currently doc and item are the

   * only such elements.

   -->

  <xsl:template match="adr:doc|adr:item" mode="docroot">

    <xsl:choose>

      <xsl:when test="adr:heading or adr:list or adr:para or adr:example">

        <!-- Block children -->

        <xsl:apply-templates/>

      </xsl:when>

      <xsl:otherwise>

        <!-- Inline children, wrap in a para for docbook conformance -->

        <para>

          <xsl:apply-templates/>

        </para>

      </xsl:otherwise>

    </xsl:choose>

  </xsl:template>

  <!-- Process the documentation elements -->

  <xsl:template match="adr:doc">

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

  </xsl:template>

  <!-- Process the (inline) code doc elements -->

  <xsl:template match="adr:summary//adr:code|adr:doc//adr:code">

    <code>

      <xsl:apply-templates/>

    </code>

  </xsl:template>

  <!-- Process the (inline) strong doc elements -->

  <xsl:template match="adr:summary//adr:strong|adr:doc//adr:strong">

    <emphasis role="strong">

      <xsl:apply-templates/>

    </emphasis>

  </xsl:template>

  <!-- Process the (inline) link doc elements -->

  <xsl:template match="adr:summary//adr:link|adr:doc//adr:link">

    <ulink url="{@url}">

      <xsl:apply-templates/>

    </ulink>

  </xsl:template>

  <!-- Process the (inline) br doc elements -->

  <xsl:template match="adr:summary//adr:br|adr:doc//adr:br">

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

  </xsl:template>

  <!-- Process the (block) heading doc elements -->

  <xsl:template match="adr:doc//adr:heading">

    <formalpara>

      <title>

        <xsl:apply-templates/>

      </title>

      <para/>

    </formalpara>

  </xsl:template>

  <!-- Process the (block) para doc elements -->

  <xsl:template match="adr:doc//adr:para">

    <para>

      <xsl:apply-templates/>

    </para>

  </xsl:template>

  <!-- Process the (block) list doc elements -->

  <xsl:template match="adr:doc//adr:list">

    <xsl:choose>

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

        <orderedlist inheritnum="ignore" continuation="restarts">

          <xsl:apply-templates select="adr:item"/>

        </orderedlist>

      </xsl:when>

      <xsl:otherwise> <!-- default: unordered -->

        <itemizedlist>

          <xsl:apply-templates select="adr:item"/>

        </itemizedlist>

      </xsl:otherwise>

    </xsl:choose>

  </xsl:template>

  <!-- Process the (block) list item doc elements -->

  <xsl:template match="adr:doc//adr:list/adr:item">

    <listitem>

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

    </listitem>

  </xsl:template>

  <!-- Process the (block) example doc elements -->

  <xsl:template match="adr:doc//adr:example">

    <example>