1 <?xml version="1.0" encoding="UTF-8" ?>

     2 <!--

     3  (C) Copyright Nokia Corporation and/or its subsidiary(-ies) 2009 - 2010. All rights reserved.

     4 -->

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

     6                 xmlns:dita2html="http://dita-ot.sourceforge.net/ns/200801/dita2html"

     7                 version="1.0"

     8                 exclude-result-prefixes="dita2html">

     9 

    10   <xsl:include href="utilities.xsl"/>

    11 

    12   <xsl:strip-space elements="cxxFunctionParameterDeclaredType"/>

    13   

    14   <!-- Styling -->

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

    16 

    17   <xsl:template match="*[contains(@class, ' topic/topic ')]" mode="gen-user-styles">

    18     <link rel="stylesheet" type="text/css" href="{$PATH2PROJ}{$CSSPATH}nokiacxxref.css"/>

    19   </xsl:template>

    20   

    21   <xsl:template match="*[contains(@class, ' apiRef/apiRef ')]" mode="gen-user-head">

    22     <meta name="keywords" content="api"/>

    23   </xsl:template>

    24   

    25   <xsl:template match="*[contains(@class,' cxxClass/cxxClass ') or

    26                           contains(@class, ' cxxStruct/cxxStruct ') or

    27                           contains(@class, ' cxxUnion/cxxUnion ')]//

    28                           *[contains(@class, ' topic/link ')][@role='parent']" priority="2000"/>

    29   <xsl:template match="*[contains(@class,' cxxClass/cxxClass ') or

    30                           contains(@class, ' cxxStruct/cxxStruct ') or

    31                           contains(@class, ' cxxUnion/cxxUnion ')]//

    32                           *[contains(@class, ' topic/link ')]

    33                            [@role='child' or @role='descendant']" priority="2000"/>

    34 

    35   <!-- Common API reference overrides -->

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

    37 

    38   <!-- Remove title from apiDesc -->

    39   <xsl:template match="*[contains(@class,' apiRef/apiDesc ')]" mode="section-fmt">

    40     <xsl:if test="node()">

    41       <div>

    42         <xsl:call-template name="start-revflag"/>

    43         <!--

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

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

    46         </xsl:apply-templates>

    47         -->

    48         <xsl:apply-templates select="node()[not(contains(@class,' topic/title '))]"/>

    49         <xsl:call-template name="end-revflag"/>

    50       </div>

    51     </xsl:if>

    52   </xsl:template>

    53 

    54   <!-- Override to support "cxxapiref.title-fmt" mode. -->

    55   <xsl:template match="*[contains(@class, ' apiRef/apiRef ')]/*[contains(@class, ' topic/title ')]">

    56     <xsl:param name="headinglevel">

    57       <xsl:choose>

    58         <xsl:when test="count(ancestor::*[contains(@class,' topic/topic ')]) > 6">6</xsl:when>

    59         <xsl:otherwise><xsl:value-of select="count(ancestor::*[contains(@class,' topic/topic ')])"/></xsl:otherwise>

    60       </xsl:choose>

    61     </xsl:param>

    62     <xsl:element name="h{$headinglevel}">

    63       <xsl:attribute name="class">topictitle<xsl:value-of select="$headinglevel"/></xsl:attribute>

    64       <xsl:call-template name="commonattributes">

    65         <xsl:with-param name="default-output-class">topictitle<xsl:value-of select="$headinglevel"/></xsl:with-param>

    66       </xsl:call-template>

    67       <xsl:apply-templates select="." mode="cxxapiref.title-fmt"/>

    68     </xsl:element>

    69   </xsl:template>

    70   

    71   <!-- API Reference topic title content -->

    72   <xsl:template match="*[contains(@class,' topic/title ')]" mode="cxxapiref.title-fmt" priority="0">

    73     <xsl:apply-templates/>

    74   </xsl:template>

    75 

    76   <!-- Disable API reference body processing that adds a horizontal rule --> 

    77   <xsl:template match="*[contains(@class,' apiRef/apiDetail ')]" priority="0">

    78     <xsl:call-template name="topic.body"/>

    79   </xsl:template>

    80 

    81   <!-- File -->

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

    83   

    84   <!-- File title content -->

    85   <xsl:template match="*[contains(@class, ' cxxFile/cxxFile ')]/*[contains(@class,' topic/title ')]" mode="cxxapiref.title-fmt">

    86     <xsl:apply-templates/>

    87     <xsl:text> </xsl:text>

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

    89       <xsl:with-param name="stringName" select="'File Reference'"/>

    90     </xsl:call-template>

    91   </xsl:template>

    92   

    93   <xsl:template match="*[contains(@class, ' cxxFile/cxxFileAPIItemLocation ')]"/>

    94 

    95   <!-- Struct -->

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

    97   

    98   <!-- Struct title content -->

    99   <xsl:template match="*[contains(@class, ' cxxStruct/cxxStruct ')]/*[contains(@class,' topic/title ')]" mode="cxxapiref.title-fmt">

   100     <xsl:apply-templates/>

   101     <xsl:call-template name="cxxapiref.title-fmt.suffix">

   102       <xsl:with-param name="type" select="'Struct'"/>

   103     </xsl:call-template>

   104   </xsl:template>

   105 

   106   <!-- Union -->

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

   108 

   109   <!-- Class or union title content -->

   110   <xsl:template match="*[contains(@class, ' cxxUnion/cxxUnion ')]/

   111                          *[contains(@class,' topic/title ')]" mode="cxxapiref.title-fmt">

   112     <xsl:apply-templates/>

   113     <xsl:call-template name="cxxapiref.title-fmt.suffix">

   114       <xsl:with-param name="type" select="'Union'"/>

   115     </xsl:call-template>

   116   </xsl:template>

   117 

   118   <!-- Class -->

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

   120   

   121   <!-- Override API reference with base processing -->

   122   <xsl:template match="/*[contains(@class,' cxxClass/cxxClass ') or

   123                           contains(@class, ' cxxStruct/cxxStruct ') or

   124                           contains(@class, ' cxxFile/cxxFile ') or

   125                           contains(@class, ' cxxUnion/cxxUnion ')]">

   126     <xsl:call-template name="chapter-setup"/>

   127   </xsl:template>

   128   

   129   <!-- Class or union title content -->

   130   <xsl:template match="*[contains(@class, ' cxxClass/cxxClass ')]/

   131                          *[contains(@class,' topic/title ')]" mode="cxxapiref.title-fmt">

   132     <xsl:apply-templates/>

   133     <xsl:call-template name="cxxapiref.title-fmt.suffix">

   134       <xsl:with-param name="type" select="'Class'"/>

   135     </xsl:call-template>

   136   </xsl:template>

   137   

   138   <xsl:template name="cxxapiref.title-fmt.suffix">

   139     <xsl:param name="type"/>

   140     

   141     <xsl:variable name="templates"

   142                   select="../*[contains(@class, ' cxxClass/cxxClassDetail ') or

   143                                contains(@class, ' cxxStruct/cxxStructDetail ') or

   144                                contains(@class, ' cxxUnion/cxxUnionDetail ')]/

   145                                *[contains(@class, ' cxxClass/cxxClassDefinition ') or

   146                                  contains(@class, ' cxxStruct/cxxStructDefinition ') or

   147                                  contains(@class, ' cxxUnion/cxxUnionDefinition ')]/

   148                                  *[contains(@class, ' cxxClass/cxxClassTemplateParamList ') or

   149                                    contains(@class, ' cxxStruct/cxxStructTemplateParamList ') or

   150                                    contains(@class, ' cxxUnion/cxxUnionTemplateParamList ')]"/>

   151     <xsl:for-each select="$templates">

   152       <xsl:text>&lt; </xsl:text>

   153         <xsl:for-each select="*[contains(@class, ' cxxClass/cxxClassTemplateParameter ') or

   154                                 contains(@class, ' cxxStruct/cxxStructTemplateParameter ') or

   155                                 contains(@class, ' cxxUnion/cxxUnionTemplateParameter ')]">

   156           <xsl:if test="not(position() = 1)">, </xsl:if>

   157           <xsl:value-of select="*[contains(@class, ' cxxClass/cxxClassTemplateParamDeclarationName ') or

   158                                   contains(@class, ' cxxStruct/cxxStructTemplateParamDeclarationName ') or

   159                                   contains(@class, ' cxxUnion/cxxUnionTemplateParamDeclarationName ')]"/>

   160         </xsl:for-each>

   161         <xsl:text> &gt;</xsl:text>

   162     </xsl:for-each>

   163     <xsl:text> </xsl:text>

   164     <xsl:choose>

   165       <xsl:when test="contains(., '&lt;') or $templates">

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

   167           <xsl:with-param name="stringName" select="concat($type, ' Template Reference')"/>

   168         </xsl:call-template>

   169       </xsl:when>

   170       <xsl:otherwise>

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

   172           <xsl:with-param name="stringName" select="concat($type, ' Reference')"/>

   173         </xsl:call-template>

   174       </xsl:otherwise>

   175     </xsl:choose>

   176   </xsl:template>

   177 

   178   <!-- Class and struct derivation section -->

   179   <xsl:template match="*[contains(@class, ' cxxClass/cxxClassDerivations ') or

   180                          contains(@class, ' cxxStruct/cxxStructDerivations ')]">

   181     <xsl:call-template name="topic.section"/>

   182   </xsl:template>

   183   <xsl:template match="*[contains(@class, ' cxxClass/cxxClassDerivations ') or

   184                          contains(@class, ' cxxStruct/cxxStructDerivations ')]" mode="get-output-class">

   185     <xsl:text>section derivation</xsl:text>

   186   </xsl:template>

   187   <xsl:template match="*[contains(@class, ' cxxClass/cxxClassDerivations ') or

   188                          contains(@class, ' cxxStruct/cxxStructDerivations ')]" mode="section-fmt">

   189     <xsl:variable name="flagrules">

   190       <xsl:call-template name="getrules"/>

   191     </xsl:variable>

   192     <xsl:call-template name="start-revflag">

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

   194     </xsl:call-template>

   195     <xsl:call-template name="sect-heading">

   196       <xsl:with-param name="defaulttitle">

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

   198           <xsl:with-param name="stringName" select="'cxxBaseClass'"/>

   199         </xsl:call-template>

   200       </xsl:with-param>

   201     </xsl:call-template>

   202     <ul class="derivation derivation-root">

   203       <xsl:apply-templates select="ancestor::*[contains(@class, ' cxxClass/cxxClass ') or

   204                                                contains(@class, ' cxxStruct/cxxStruct ')][1]" mode="derivation"/>

   205     </ul>

   206     <!--

   207     <xsl:call-template name="sect-heading">

   208       <xsl:with-param name="defaulttitle">Reverse inheritance path</xsl:with-param>

   209     </xsl:call-template>

   210     <xsl:apply-templates select="ancestor::*[contains(@class, ' cxxClass/cxxClass ') or

   211                                              contains(@class, ' cxxStruct/cxxStruct ')][1]" mode="derivation.reverse"/>

   212     -->

   213     <xsl:call-template name="end-revflag">

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

   215     </xsl:call-template>

   216   </xsl:template>

   217   

   218   <!-- Class and struct derivation walker -->

   219   <xsl:template match="*[contains(@class, ' cxxClass/cxxClass ') or

   220                          contains(@class, ' cxxStruct/cxxStruct ')]"

   221                 mode="derivation">

   222     <xsl:param name="link" select="/.."/>

   223     <xsl:param name="depth" select="0"/>

   224     <xsl:param name="class"/>

   225     <li class="derivation-depth-{$depth} {$class}">

   226       <xsl:choose>

   227         <xsl:when test="$link">

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

   229         </xsl:when>

   230         <xsl:otherwise>

   231           <xsl:value-of select="*[contains(@class, ' topic/title ')]"/>

   232         </xsl:otherwise>

   233       </xsl:choose>

   234       <xsl:variable name="derivation"

   235                     select="*[contains(@class, ' topic/body ')]/

   236                               *[contains(@class, ' apiRef/apiDef ')]/

   237                                 *[contains(@class, ' cxxClass/cxxClassDerivations ') or

   238                                   contains(@class, ' cxxStruct/cxxStructDerivations ')]/

   239                                   *[contains(@class, ' cxxClass/cxxClassDerivation ') or

   240                                     contains(@class, ' cxxStruct/cxxStructDerivation ')]"/>

   241       <xsl:if test="$derivation">

   242         <ul class="derivation">

   243          <xsl:for-each select="$derivation">

   244           <xsl:variable name="cls">

   245             <xsl:if test="not(position() = last())">derivation-has-next</xsl:if>

   246           </xsl:variable>

   247           <xsl:variable name="base" select="*[contains(@class, ' cxxClass/cxxClassBaseClass ') or

   248                                               contains(@class, ' cxxClass/cxxClassBaseStruct ') or

   249                                               contains(@class, ' cxxClass/cxxClassBaseUnion ') or

   250                                               contains(@class, ' cxxStruct/cxxStructBaseClass ') or

   251                                               contains(@class, ' cxxStruct/cxxStructBaseStruct ') or

   252                                               contains(@class, ' cxxStruct/cxxStructBaseUnion ')]"/>

   253           <xsl:variable name="url"> 

   254             <xsl:call-template name="strip-url-fragment">

   255               <xsl:with-param name="url" select="$base/@href"/>

   256             </xsl:call-template>

   257           </xsl:variable>

   258           <xsl:if test="normalize-space($url)"><!-- infinite loop guard -->

   259             <xsl:variable name="doc" select="document($url, .)"/>

   260             <xsl:apply-templates select="$doc/*[contains(@class, ' cxxClass/cxxClass ') or

   261                                                 contains(@class, ' cxxStruct/cxxStruct ')]"

   262                                  mode="derivation">

   263                <xsl:with-param name="link" select="$base"/>

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

   265                <xsl:with-param name="class" select="$cls"/>

   266              </xsl:apply-templates>

   267            </xsl:if>

   268          </xsl:for-each>

   269         </ul>

   270       </xsl:if>

   271     </li>

   272   </xsl:template>

   273   

   274   <!-- Class and struct derivation walker. The walker inverts the tree. -->

   275   <!--

   276   <xsl:template match="*[contains(@class, ' cxxClass/cxxClass ') or

   277                          contains(@class, ' cxxStruct/cxxStruct ')]"

   278                 mode="derivation.reverse">

   279     <xsl:param name="link" select="/.."/>

   280     <xsl:param name="contents"/>

   281     

   282     <xsl:variable name="title">

   283       <xsl:choose>

   284         <xsl:when test="$link">

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

   286         </xsl:when>

   287         <xsl:otherwise>

   288           <xsl:value-of select="*[contains(@class, ' topic/title ')]"/>

   289         </xsl:otherwise>

   290       </xsl:choose>

   291     </xsl:variable>

   292     <xsl:variable name="derivation"

   293                   select="*[contains(@class, ' topic/body ')]/

   294                             *[contains(@class, ' apiRef/apiDef ')]/

   295                               *[contains(@class, ' cxxClass/cxxClassDerivations ') or

   296                                 contains(@class, ' cxxStruct/cxxStructDerivations ')]/

   297                                 *[contains(@class, ' cxxClass/cxxClassDerivation ') or

   298                                   contains(@class, ' cxxStruct/cxxStructDerivation ')]"/>

   299     <xsl:choose>

   300       <xsl:when test="$derivation">

   301        <xsl:for-each select="$derivation">

   302          <xsl:variable name="base" select="*[contains(@class, ' cxxClass/cxxClassBaseClass ') or

   303                                              contains(@class, ' cxxClass/cxxClassBaseStruct ') or

   304                                              contains(@class, ' cxxClass/cxxClassBaseUnion ') or

   305                                              contains(@class, ' cxxStruct/cxxStructBaseClass ') or

   306                                              contains(@class, ' cxxStruct/cxxStructBaseStruct ') or

   307                                              contains(@class, ' cxxStruct/cxxStructBaseUnion ')]"/>

   308          <xsl:variable name="url"> 

   309            <xsl:call-template name="strip-url-fragment">

   310              <xsl:with-param name="url" select="$base/@href"/>

   311            </xsl:call-template>

   312          </xsl:variable>

   313          <xsl:if test="normalize-space($url)">

   314            <xsl:variable name="doc" select="document($url, .)"/>

   315 

   316            <xsl:apply-templates select="$doc/*[contains(@class, ' cxxClass/cxxClass ') or

   317                                                contains(@class, ' cxxStruct/cxxStruct ')]"

   318                                 mode="derivation.reverse">

   319              <xsl:with-param name="contents">

   320                <li>

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

   322                  <xsl:if test="normalize-space($contents)">

   323                    <ul>

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

   325                    </ul>  

   326                  </xsl:if>

   327                </li>

   328              </xsl:with-param>

   329              <xsl:with-param name="link" select="$base"/>

   330            </xsl:apply-templates>

   331          </xsl:if>

   332        </xsl:for-each>

   333       </xsl:when>

   334       <xsl:otherwise>

   335         <ul class="derivation-root">

   336           <li>

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

   338             <ul>

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

   340             </ul>

   341           </li>

   342         </ul>

   343       </xsl:otherwise>

   344     </xsl:choose>

   345   </xsl:template>

   346   -->

   347 

   348   <!-- Class, struct, or union body -->

   349   <xsl:template match="*[contains(@class, ' cxxClass/cxxClassDetail ') or

   350                          contains(@class, ' cxxStruct/cxxStructDetail ') or

   351                          contains(@class, ' cxxUnion/cxxUnionDetail ')]">

   352     <xsl:apply-templates select="*[contains(@class, ' cxxClass/cxxClassDefinition ') or

   353                                    contains(@class, ' cxxStruct/cxxStructDefinition ') or

   354                                    contains(@class, ' cxxUnion/cxxUnionDefinition ')]" mode="signature"/>

   355     <xsl:apply-templates select="*[(contains(@class, ' topic/section ') or

   356                                     contains(@class, ' topic/example ')) and

   357                                    not(contains(@class, ' apiRef/apiDef '))]"/>

   358     <xsl:apply-templates select="*[contains(@class, ' cxxClass/cxxClassDefinition ') or

   359                                    contains(@class, ' cxxStruct/cxxStructDefinition ')]/

   360                                    *[contains(@class, ' cxxClass/cxxClassDerivations ') or

   361                                      contains(@class, ' cxxStruct/cxxStructDerivations ')]"/>

   362     <xsl:apply-templates select="../*[contains(@class, ' cxxClass/cxxClassNested ') or

   363                                       contains(@class, ' cxxStruct/cxxStructNested ') or

   364                                       contains(@class, ' cxxUnion/cxxUnionNested ')]/

   365                                       *[contains(@class, ' cxxClass/cxxClassNestedDetail ') or

   366                                         contains(@class, ' cxxStruct/cxxStructNestedDetail ') or

   367                                         contains(@class, ' cxxUnion/cxxUnionNestedDetail ')]"/>

   368     <div class="section member-index">

   369       <xsl:for-each select="..">

   370         <xsl:variable name="inherited" select="*[contains(@class, ' cxxClass/cxxClassInherits ') or

   371                                                  contains(@class, ' cxxStruct/cxxStructInherits ')]/

   372                                                  *[contains(@class, ' cxxClass/cxxClassInheritsDetail ') or

   373                                                    contains(@class, ' cxxStruct/cxxStructInheritsDetail ')]"/>

   374 <!--

   375         <xsl:call-template name="member-index-block">

   376           <xsl:with-param name="title" select="'Member Nested Classes'"/>

   377           <xsl:with-param name="nodes" select="*[contains(@class, ' cxxClass/cxxClassNested ')]"/>

   378         </xsl:call-template>

   379 -->      

   380         <xsl:call-template name="member-index-group">

   381           <xsl:with-param name="title" select="'Member Functions'"/>

   382           <xsl:with-param name="nodes" select="*[contains(@class, ' cxxFunction/cxxFunction ')]"/>

   383         </xsl:call-template>

   384         <xsl:call-template name="member-index-block">

   385           <xsl:with-param name="title" select="'Inherited Functions'"/>

   386           <xsl:with-param name="nodes" select="$inherited/*[contains(@class, ' cxxClass/cxxClassFunctionInherited ') or

   387                                                             contains(@class, ' cxxStruct/cxxStructFunctionInherited ')]"/>

   388         </xsl:call-template>

   389         <xsl:call-template name="member-index-group">

   390           <xsl:with-param name="title" select="'Member Enumerations'"/>

   391           <xsl:with-param name="nodes" select="*[contains(@class, ' cxxEnumeration/cxxEnumeration ')]"/>

   392         </xsl:call-template>

   393         <xsl:call-template name="member-index-block">

   394           <xsl:with-param name="title" select="'Inherited Enumerations'"/>

   395           <xsl:with-param name="nodes" select="$inherited/*[contains(@class, ' cxxClass/cxxClassEnumerationInherited ') or

   396                                                             contains(@class, ' cxxStruct/cxxStructEnumerationInherited ')]"/>

   397         </xsl:call-template>

   398         <xsl:call-template name="member-index-group">

   399           <xsl:with-param name="title" select="'Member Type Definitions'"/>

   400           <xsl:with-param name="nodes" select="*[contains(@class, ' cxxTypedef/cxxTypedef ')]"/>

   401         </xsl:call-template>

   402         <xsl:call-template name="member-index-group">

   403           <xsl:with-param name="title" select="'Attributes'"/>

   404           <xsl:with-param name="nodes" select="*[contains(@class, ' cxxVariable/cxxVariable ')]"/>

   405         </xsl:call-template>

   406         <xsl:call-template name="member-index-block">

   407           <xsl:with-param name="title" select="'Inherited Attributes'"/>

   408           <xsl:with-param name="nodes" select="$inherited/*[contains(@class, ' cxxClass/cxxClassVariableInherited ') or

   409                                                             contains(@class, ' cxxStruct/cxxStructVariableInherited ')]"/>

   410         </xsl:call-template>

   411       </xsl:for-each>

   412     </div>

   413     <xsl:for-each select="..">

   414       <xsl:for-each select="*[contains(@class, ' topic/related-links ')]">

   415         <xsl:call-template name="topic.related-links"/>

   416       </xsl:for-each>

   417     </xsl:for-each>

   418 

   419     <!-- Pull nested topics into groups, normal fall-through is disabled -->

   420     <xsl:variable name="all-functions" select="../*[contains(@class, ' cxxFunction/cxxFunction ')]"/>

   421     <xsl:variable name="constructor" select="$all-functions[*[contains(@class, ' apiRef/apiDetail ')]/*[contains(@class, ' apiRef/apiDef ')]/*[contains(@class, ' apiRef/apiQualifier ')][@name = 'constructor']]"/>      	

   422     <xsl:variable name="destructor" select="$all-functions[*[contains(@class, ' apiRef/apiDetail ')]/*[contains(@class, ' apiRef/apiDef ')]/*[contains(@class, ' apiRef/apiQualifier ')][@name = 'destructor']]"/>

   423     <xsl:if test="$constructor | $destructor">

   424       <h1 class="pageHeading topictitle1">Constructor &amp; Destructor Documentation</h1>

   425       <xsl:apply-templates select="$constructor" mode="child.topic">

   426         <xsl:sort select="*[contains(@class, ' topic/title ')]"/>

   427       </xsl:apply-templates>

   428       <xsl:apply-templates select="$destructor" mode="child.topic">

   429         <xsl:sort select="*[contains(@class, ' topic/title ')]"/>

   430       </xsl:apply-templates>

   431     </xsl:if>

   432     <xsl:variable name="functions" select="$all-functions[not(count($constructor | $destructor) = count(. | $constructor | $destructor))]"/>

   433     <xsl:if test="$functions">

   434       <h1 class="pageHeading topictitle1">Member Functions Documentation</h1>

   435       <xsl:apply-templates select="$functions" mode="child.topic">

   436         <xsl:sort select="*[contains(@class, ' topic/title ')]"/>

   437       </xsl:apply-templates>

   438     </xsl:if>

   439     <xsl:variable name="structures" select="../*[contains(@class, ' cxxStruct/cxxStruct ')]"/>

   440     <xsl:if test="$structures">

   441       <h1 class="pageHeading topictitle1">Member Structures Documentation</h1>

   442       <xsl:apply-templates select="$structures" mode="child.topic">

   443         <xsl:sort select="*[contains(@class, ' topic/title ')]"/>

   444       </xsl:apply-templates>

   445     </xsl:if>

   446     <xsl:variable name="enums" select="../*[contains(@class, ' cxxEnumeration/cxxEnumeration ')]"/>

   447     <xsl:if test="$enums">

   448       <h1 class="pageHeading topictitle1">Member Enumerations Documentation</h1>

   449       <xsl:apply-templates select="$enums" mode="child.topic">

   450         <xsl:sort select="*[contains(@class, ' topic/title ')]"/>

   451       </xsl:apply-templates>

   452     </xsl:if>

   453     <xsl:variable name="typedefs" select="../*[contains(@class, ' cxxTypedef/cxxTypedef ')]"/>

   454     <xsl:if test="$typedefs">

   455      <h1 class="pageHeading topictitle1">Member Type Definitions Documentation</h1>

   456      <xsl:apply-templates select="$typedefs" mode="child.topic">

   457        <xsl:sort select="*[contains(@class, ' topic/title ')]"/>

   458      </xsl:apply-templates>

   459     </xsl:if>

   460     <xsl:variable name="variables" select="../*[contains(@class, ' cxxVariable/cxxVariable ')]"/>

   461     <xsl:if test="$variables">

   462       <h1 class="pageHeading topictitle1">Member Data Documentation</h1>

   463       <xsl:apply-templates select="$variables" mode="child.topic">

   464         <xsl:sort select="*[contains(@class, ' topic/title ')]"/>

   465       </xsl:apply-templates>

   466     </xsl:if>

   467   </xsl:template>

   468   

   469   <!-- Omit, pulled by class/struct body -->

   470   <xsl:template match="*[contains(@class, ' cxxClass/cxxClass ') or

   471                          contains(@class, ' cxxStruct/cxxStruct ') or

   472                          contains(@class, ' cxxUnion/cxxUnion ')]/

   473                          *[contains(@class, ' topic/topic ') or

   474                            contains(@class, ' topic/related-links ')]"/>

   475 

   476   <!-- Class and struct body class -->

   477   <xsl:template match="*[contains(@class,' cxxClass/cxxClass ') or

   478                          contains(@class, ' cxxStruct/cxxStruct ') or

   479                          contains(@class, ' cxxUnion/cxxUnion ')]/

   480                          *[contains(@class,' topic/topic ')]/

   481                            *[contains(@class,' topic/body ')]"

   482                 mode="get-output-class">

   483     <xsl:text>topicbody</xsl:text>

   484     <xsl:value-of select="count(ancestor-or-self::*[contains(@class,' topic/topic ')])"/> 

   485   </xsl:template>  

   486 

   487   <!-- Member index group -->

   488   <xsl:template name="member-index-group">

   489     <xsl:param name="title"/>

   490     <xsl:param name="nodes"/>

   491     <xsl:call-template name="member-index-block">

   492       <xsl:with-param name="nodes"

   493                       select="$nodes[*[contains(@class, ' apiRef/apiDetail ')]/*[contains(@class, ' apiRef/apiDef ')]/

   494                                        *[contains(@class, ' apiRef/apiQualifier ')][@name = 'access' and @value = 'public']]"/>

   495       <xsl:with-param name="title" select="concat('Public ', $title)"/>

   496     </xsl:call-template>

   497     <xsl:call-template name="member-index-block">

   498       <xsl:with-param name="nodes"

   499                       select="$nodes[*[contains(@class, ' apiRef/apiDetail ')]/*[contains(@class, ' apiRef/apiDef ')]/

   500                                        *[contains(@class, ' apiRef/apiQualifier ')][@name = 'access' and @value = 'protected']]"/>

   501       <xsl:with-param name="title" select="concat('Protected ', $title)"/>

   502     </xsl:call-template>

   503     <xsl:call-template name="member-index-block">

   504       <xsl:with-param name="nodes"

   505                       select="$nodes[*[contains(@class, ' apiRef/apiDetail ')]/*[contains(@class, ' apiRef/apiDef ')]/

   506                                        *[contains(@class, ' apiRef/apiQualifier ')][@name = 'access' and @value = 'private']]"/>

   507       <xsl:with-param name="title" select="concat('Private ', $title)"/>

   508     </xsl:call-template>

   509   </xsl:template>

   510   

   511   <!-- Member index table -->

   512   <xsl:template name="member-index-block">

   513     <xsl:param name="nodes" select="/.."/>

   514     <xsl:param name="title"/>

   515     <xsl:if test="$nodes">

   516       <table border="1" class="member-index">

   517         <thead>

   518           <tr>

   519             <th colspan="2">

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

   521             </th>

   522           </tr>

   523         </thead>

   524         <tbody>

   525           <xsl:apply-templates select="$nodes" mode="class-members">

   526             <xsl:sort select="number(boolean(*[contains(@class, ' apiRef/apiDetail ')]/

   527                                                *[contains(@class, ' apiRef/apiDef ')]/

   528                                                  *[contains(@class, ' apiRef/apiQualifier ')]

   529                                                   [@name = 'constructor' or @name = 'destructor']))"

   530                       data-type="number" order="descending"/>

   531             <xsl:sort select="*[contains(@class, ' topic/title ')]"/>

   532           </xsl:apply-templates>

   533         </tbody>

   534       </table>

   535     </xsl:if>

   536   </xsl:template>

   537 

   538   <xsl:template match="*[contains(@class, ' cxxClass/cxxClassFunctionInherited ') or 

   539                          contains(@class, ' cxxClass/cxxClassVariableInherited ') or 

   540                          contains(@class, ' cxxClass/cxxClassEnumerationInherited ') or 

   541                          contains(@class, ' cxxClass/cxxClassEnumeratorInherited ')]"

   542                 mode="class-members">

   543     <tr>

   544       <xsl:if test="position() mod 2 = 0">

   545         <xsl:attribute name="class">bg</xsl:attribute>  

   546       </xsl:if>

   547       <td><xsl:text> </xsl:text></td>

   548       <td>

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

   550       </td>

   551     </tr>

   552   </xsl:template>

   553   

   554   <!--

   555   <xsl:template match="*[contains(@class, ' cxxClass/cxxClassFunctionInherited ') or 

   556                          contains(@class, ' cxxClass/cxxClassVariableInherited ') or 

   557                          contains(@class, ' cxxClass/cxxClassEnumerationInherited ') or 

   558                          contains(@class, ' cxxClass/cxxClassEnumeratorInherited ')]/text()">

   559     <xsl:variable name="t" select="substring-after(., '::')"/>

   560     <xsl:choose>

   561       <xsl:when test="contains($t, '(')">

   562         <xsl:value-of select="substring-before($t, '(')"/>

   563       </xsl:when>

   564       <xsl:otherwise>

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

   566       </xsl:otherwise>

   567     </xsl:choose>

   568   </xsl:template>

   569   -->

   570 

   571   <!-- Default member index row -->

   572   <xsl:template match="*" mode="class-members" priority="0">

   573     <tr>

   574       <xsl:if test="position() mod 2 = 0">

   575         <xsl:attribute name="class">bg</xsl:attribute>  

   576       </xsl:if>

   577       <td><xsl:text> </xsl:text></td>

   578       <td>

   579         <a href="#{@id}">

   580           <xsl:apply-templates select="*[contains(@class, ' topic/title ')]" mode="cxxapiref.title-fmt"/>

   581          </a>

   582       </td>

   583     </tr>

   584   </xsl:template>

   585   

   586   <!-- Class or struct signature --> 

   587   <xsl:template match="*[contains(@class, ' cxxClass/cxxClassDefinition ') or

   588                          contains(@class, ' cxxStruct/cxxStructDefinition ') or

   589                          contains(@class, ' cxxUnion/cxxUnionDefinition ')]"

   590                  mode="signature">

   591     <xsl:variable name="templates"

   592                   select="*[contains(@class, ' cxxClass/cxxClassTemplateParamList ') or

   593                             contains(@class, ' cxxStruct/cxxStructTemplateParamList ') or

   594                             contains(@class, ' cxxUnion/cxxUnionTemplateParamList ')]/

   595                             *[contains(@class, ' cxxClass/cxxClassTemplateParameter ') or

   596                               contains(@class, ' cxxStruct/cxxStructTemplateParameter ') or

   597                               contains(@class, ' cxxUnion/cxxUnionTemplateParameter ')]"/>

   598     <xsl:variable name="title">

   599       <xsl:value-of select="ancestor::*[contains(@class, ' topic/topic ')]/*[contains(@class, ' topic/title ')]"/>

   600     </xsl:variable>

   601     <table class="signature">

   602       <xsl:if test="contains($title, '&lt;') or $templates">

   603         <tr>

   604           <td>

   605             <xsl:text>template &lt;</xsl:text>

   606             <xsl:for-each select="$templates">

   607               <xsl:if test="not(position() = 1)">, </xsl:if>

   608               <xsl:value-of select="*[contains(@class, ' cxxClass/cxxClassTemplateParamType ') or

   609                                       contains(@class, ' cxxStruct/cxxStructTemplateParamType ') or

   610                                       contains(@class, ' cxxUnion/cxxUnionTemplateParamType ')]"/>

   611               

   612               <xsl:text> </xsl:text>

   613               <xsl:value-of select="*[contains(@class, ' cxxClass/cxxClassTemplateParamDeclarationName ') or

   614                                       contains(@class, ' cxxStruct/cxxStructTemplateParamDeclarationName ') or

   615                                       contains(@class, ' cxxUnion/cxxUnionTemplateParamDeclarationName ')]"/>

   616             </xsl:for-each>

   617             <xsl:text>&gt;</xsl:text>

   618           </td>

   619         </tr>

   620       </xsl:if>

   621       <tr>

   622         <td>

   623           <xsl:choose>

   624             <xsl:when test="self::*[contains(@class, ' cxxClass/cxxClassDefinition ')]">class</xsl:when>

   625             <xsl:when test="self::*[contains(@class, ' cxxStruct/cxxStructDefinition ')]">struct</xsl:when>

   626             <xsl:when test="self::*[contains(@class, ' cxxUnion/cxxUnionDefinition ')]">union</xsl:when>

   627           </xsl:choose>

   628           <xsl:text> </xsl:text>

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

   630           <xsl:variable name="derivation"

   631                         select="*[contains(@class, ' cxxClass/cxxClassDerivations ') or

   632                                   contains(@class, ' cxxStruct/cxxStructDerivations ')]/

   633                                   *[contains(@class, ' cxxClass/cxxClassDerivation ') or

   634                                     contains(@class, ' cxxStruct/cxxStructDerivation ')]"/>

   635           <xsl:if test="$derivation">

   636             <xsl:text> : </xsl:text>

   637             <xsl:for-each select="$derivation">

   638               <xsl:if test="not(position() = 1)">, </xsl:if>

   639               <xsl:value-of select="*[contains(@class, ' apiRef/apiQualifier ')][@name = 'access']/@value"/>

   640               <xsl:text> </xsl:text>

   641               <xsl:value-of select="*[contains(@class, ' cxxClass/cxxClassBaseClass ') or

   642                                       contains(@class, ' cxxClass/cxxClassBaseStruct ') or

   643                                       contains(@class, ' cxxClass/cxxClassBaseUnion ') or

   644                                       contains(@class, ' cxxStruct/cxxStructBaseClass ') or

   645                                       contains(@class, ' cxxStruct/cxxStructBaseStruct ') or

   646                                       contains(@class, ' cxxStruct/cxxStructBaseUnion ')]"/>

   647             </xsl:for-each>

   648           </xsl:if>

   649         </td>

   650       </tr>

   651     </table>

   652   </xsl:template>  

   653   

   654   <!-- Nested class -->

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

   656   

   657   <xsl:template match="*[contains(@class, ' cxxClass/cxxClassNestedDetail ') or

   658                          contains(@class, ' cxxStruct/cxxStructNestedDetail ') or

   659                          contains(@class, ' cxxUnion/cxxUnionNestedDetail ')]" priority="10">

   660     <xsl:call-template name="topic.section"/>

   661   </xsl:template>

   662   <xsl:template match="*[contains(@class, ' cxxClass/cxxClassNestedDetail ') or

   663                          contains(@class, ' cxxStruct/cxxStructNestedDetail ') or

   664                          contains(@class, ' cxxUnion/cxxUnionNestedDetail ')]" mode="get-output-class" priority="10">

   665     <xsl:text>section nested</xsl:text>

   666   </xsl:template>

   667   <xsl:template match="*[contains(@class, ' cxxClass/cxxClassNestedDetail ') or

   668                          contains(@class, ' cxxStruct/cxxStructNestedDetail ') or

   669                          contains(@class, ' cxxUnion/cxxUnionNestedDetail ')]" mode="section-fmt">

   670     <xsl:variable name="flagrules">

   671       <xsl:call-template name="getrules"/>

   672     </xsl:variable>

   673     <xsl:call-template name="start-revflag">

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

   675     </xsl:call-template>

   676     <!-- default will output h3 instead of h2

   677     <xsl:call-template name="sect-heading">

   678       <xsl:with-param name="defaulttitle">

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

   680           <xsl:with-param name="stringName" select="'cxxBaseClass'"/>

   681         </xsl:call-template>

   682       </xsl:with-param>

   683     </xsl:call-template>

   684     -->    

   685     <h2 class="sectiontitle">

   686       <xsl:text>Nested Classes and Structures</xsl:text>

   687     </h2>

   688     <ul>

   689       <xsl:for-each select="*[contains(@class, ' cxxClass/cxxClassNestedClass ') or

   690                               contains(@class, ' cxxClass/cxxClassNestedStruct ') or

   691                               contains(@class, ' cxxClass/cxxClassNestedUnion ') or

   692                               contains(@class, ' cxxStruct/cxxStructNestedClass ') or

   693                               contains(@class, ' cxxStruct/cxxStructNestedStruct ') or

   694                               contains(@class, ' cxxStruct/cxxStructNestedUnion ') or

   695                               contains(@class, ' cxxUnion/cxxUnionNestedClass ') or

   696                               contains(@class, ' cxxUnion/cxxUnionNestedStruct ') or

   697                               contains(@class, ' cxxUnion/cxxUnionNestedUnion ')]">

   698         <xsl:sort select="."/>

   699         <li>

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

   701         </li>

   702       </xsl:for-each>

   703     </ul>

   704     <xsl:call-template name="end-revflag">

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

   706     </xsl:call-template>

   707   </xsl:template>

   708 

   709   <!-- Function -->

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

   711   

   712   <xsl:template name="is-constructor">    

   713     <xsl:value-of select="boolean(*[contains(@class, ' apiRef/apiDetail ')]/

   714                                     *[contains(@class, ' apiRef/apiDef ')]/

   715                                       *[contains(@class, ' apiRef/apiQualifier ')]

   716                                        [@name = 'constructor' or @name = 'destructor'])"/>

   717   </xsl:template>

   718   

   719   <xsl:template match="*[contains(@class, ' cxxFunction/cxxFunction ')]" mode="class-members">

   720     <xsl:variable name="is-constructor">

   721       <xsl:call-template name="is-constructor"/>

   722     </xsl:variable>

   723     <tr>

   724       <xsl:if test="position() mod 2 = 0">

   725         <xsl:attribute name="class">bg</xsl:attribute>  

   726       </xsl:if>

   727       <td align="right" class="code">

   728         <xsl:if test="not($is-constructor = 'true')">

   729           <xsl:apply-templates select="*[contains(@class, ' cxxFunction/cxxFunctionDetail ')]/

   730                                          *[contains(@class, ' cxxFunction/cxxFunctionDefinition ')]/

   731                                            *[contains(@class, ' cxxFunction/cxxFunctionDeclaredType ')]/node()"/>

   732         </xsl:if>

   733       </td>

   734       <td>

   735         <a href="#{@id}">

   736           <xsl:apply-templates select="*[contains(@class, ' topic/title ')]/node()"/><!--mode="cxxapiref.title-fmt"-->

   737         </a>

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

   739         <xsl:for-each select="*[contains(@class, ' cxxFunction/cxxFunctionDetail ')]/

   740                                 *[contains(@class, ' cxxFunction/cxxFunctionDefinition ')]/

   741                                   *[contains(@class, ' cxxFunction/cxxFunctionParameters ')]/

   742                                     *[contains(@class, ' cxxFunction/cxxFunctionParameter ')]">

   743           <xsl:if test="not(position() = 1)">, </xsl:if>

   744           <xsl:apply-templates select="*[contains(@class, ' cxxFunction/cxxFunctionParameterDeclaredType ')]/node()"/>

   745         </xsl:for-each>

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

   747       </td>

   748     </tr>

   749   </xsl:template>

   750   

   751   <!--

   752   <xsl:template match="*[contains(@class, ' cxxFunction/cxxFunction ')]/*[contains(@class, ' topic/title ')]" mode="class-members">

   753     <xsl:apply-templates select="../*[contains(@class, ' cxxFunction/cxxFunctionDetail ')]/

   754                                       *[contains(@class, ' cxxFunction/cxxFunctionDefinition ')]/

   755                                         *[contains(@class, ' cxxFunction/cxxFunctionPrototype ')]/

   756                                           node()"/>

   757   </xsl:template>

   758   -->

   759   

   760   <!-- Function title -->

   761   <xsl:template match="*[contains(@class, ' cxxFunction/cxxFunction ')]/*[contains(@class, ' topic/title ')]" mode="cxxapiref.title-fmt">

   762     <xsl:apply-templates/>

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

   764     <xsl:for-each select="../*[contains(@class, ' cxxFunction/cxxFunctionDetail ')]/

   765                               *[contains(@class, ' cxxFunction/cxxFunctionDefinition ')]/

   766                                 *[contains(@class, ' cxxFunction/cxxFunctionParameters ')]/

   767                                   *[contains(@class, ' cxxFunction/cxxFunctionParameter ')]">

   768       <xsl:if test="not(position() = 1)">,<!--&#x200B;--> </xsl:if>

   769       <xsl:value-of select="normalize-space(*[contains(@class, ' cxxFunction/cxxFunctionParameterDeclaredType ')])"/>

   770     </xsl:for-each>

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

   772   </xsl:template>

   773   

   774   <!-- Function body -->

   775   <xsl:template match="*[contains(@class, ' cxxFunction/cxxFunctionDetail ')]">

   776     <xsl:apply-templates select="*[contains(@class, ' cxxFunction/cxxFunctionDefinition ')]" mode="signature"/>

   777     <xsl:apply-templates select="*[(contains(@class, ' topic/section ') or

   778                                     contains(@class, ' topic/example ')) and

   779                                    not(contains(@class, ' apiRef/apiDef '))]"/>

   780     <xsl:apply-templates select="*[contains(@class, ' cxxFunction/cxxFunctionDefinition ')]/*[contains(@class, ' cxxFunction/cxxFunctionParameters ')]"/>

   781   </xsl:template>

   782   

   783   <xsl:template match="*[contains(@class, ' cxxFunction/cxxFunctionPrototype ')]">

   784     <pre>

   785       <xsl:for-each select="../*[contains(@class, ' apiRef/apiQualifier ')][@name = 'access']">

   786         <!--xsl:if test="@value = 'private' or @value = 'protected'"-->

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

   788           <xsl:text>: </xsl:text>

   789         <!--/xsl:if-->  

   790       </xsl:for-each>

   791       <xsl:apply-templates/>

   792     </pre>

   793   </xsl:template>

   794   

   795   <!-- common meta -->

   796   <xsl:template name="meta-signature">

   797     <xsl:variable name="m">

   798       <xsl:for-each select="*[contains(@class, ' apiRef/apiQualifier ')][@name = 'access'][not(@value = 'public')]">

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

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

   801       </xsl:for-each>

   802       <xsl:for-each select="*[contains(@class, ' apiRef/apiQualifier ')][@name = 'static']">

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

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

   805       </xsl:for-each>

   806       <xsl:for-each select="*[contains(@class, ' apiRef/apiQualifier ')][@name = 'inline']">

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

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

   809       </xsl:for-each>

   810       <xsl:for-each select="*[contains(@class, ' apiRef/apiQualifier ')][@name = 'pure virtual']">

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

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

   813       </xsl:for-each>

   814       <xsl:for-each select="*[contains(@class, ' apiRef/apiQualifier ')][@name = 'virtual']">

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

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

   817       </xsl:for-each>

   818       <xsl:for-each select="*[contains(@class, ' apiRef/apiQualifier ')][@name = 'explicit']">

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

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

   821       </xsl:for-each>

   822     </xsl:variable>

   823     <xsl:if test="normalize-space($m)">

   824       <xsl:text>[</xsl:text>

   825       <xsl:value-of select="normalize-space(substring($m, 2))"/>

   826       <xsl:text>]</xsl:text>  

   827     </xsl:if>

   828   </xsl:template>

   829   

   830   <!-- Method signature -->

   831   <xsl:template match="*[contains(@class, ' cxxFunction/cxxFunctionDefinition ')]" mode="signature">

   832     <xsl:variable name="parameters" select="*[contains(@class, ' cxxFunction/cxxFunctionParameters ')]/*[contains(@class, ' cxxFunction/cxxFunctionParameter ')]"/>

   833     <xsl:variable name="meta">

   834       <xsl:for-each select="*[contains(@class, ' apiRef/apiQualifier ')][@name = 'const']">

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

   836         <xsl:text> </xsl:text>

   837       </xsl:for-each>

   838       <xsl:call-template name="meta-signature"/>

   839     </xsl:variable>

   840     <xsl:variable name="has-type" select="boolean(*[contains(@class, ' cxxFunction/cxxFunctionDeclaredType ')]/node())"/>

   841     <table class="signature">

   842       <tr>

   843         <xsl:if test="$has-type">

   844           <td>

   845             <!--

   846             <xsl:value-of select="*[contains(@class, ' cxxFunction/cxxFunctionStorageClassSpecifierStatic ')]/@value"/>

   847             <xsl:text> </xsl:text>

   848             <xsl:value-of select="*[contains(@class, ' cxxFunction/cxxFunctionInline ')]/@value"/>

   849             <xsl:text> </xsl:text>

   850             -->

   851             <xsl:apply-templates select="*[contains(@class, ' cxxFunction/cxxFunctionDeclaredType ')]/node()"/>

   852           </td>

   853         </xsl:if>

   854         <td>

   855           <xsl:apply-templates select="../../*[contains(@class, ' apiRef/apiName ')]/node()"/>

   856         </td>

   857         <td>(</td>

   858         <xsl:apply-templates select="$parameters[1]" mode="signature">

   859           <xsl:with-param name="hasNext" select="count($parameters) > 1"/>

   860         </xsl:apply-templates>

   861         <xsl:if test="count($parameters) &lt;= 1">

   862           <td>

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

   864           </td>

   865           <td>

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

   867           </td>

   868         </xsl:if>        

   869       </tr>

   870       <xsl:for-each select="$parameters[not(position() = 1)]">

   871         <tr>

   872           <!--xsl:if test="$has-type">

   873             <td><xsl:text> </xsl:text></td>

   874           </xsl:if>

   875           <td><xsl:text> </xsl:text></td-->

   876           <td colspan="{2 + number($has-type)}"><xsl:text> </xsl:text></td>

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

   878             <xsl:with-param name="hasNext" select="not(position() = count($parameters) - 1)"/>

   879           </xsl:apply-templates>

   880         </tr>

   881       </xsl:for-each>

   882       <xsl:if test="count($parameters) > 1">

   883         <tr>

   884           <!--xsl:if test="$has-type">

   885             <td><xsl:text> </xsl:text></td>

   886           </xsl:if-->

   887           <td colspan="{1 + number($has-type)}"><xsl:text> </xsl:text></td>

   888           <td>)</td>

   889           <td colspan="2">

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

   891           </td>

   892           <!--td><xsl:text> </xsl:text></td-->

   893         </tr>

   894       </xsl:if>

   895     </table>

   896   </xsl:template>

   897   <xsl:template match="*[contains(@class, ' cxxFunction/cxxFunctionParameter ')]" mode="signature">

   898     <xsl:param name="hasNext" select="false"/>

   899     <td>

   900       <xsl:apply-templates select="*[contains(@class, ' cxxFunction/cxxFunctionParameterDeclaredType ')]/node()"/>

   901     </td>

   902     <td>

   903       <xsl:apply-templates select="*[contains(@class, ' cxxFunction/cxxFunctionParameterDeclarationName ')]/node()"/>

   904       <xsl:if test="*[contains(@class, ' cxxFunction/cxxFunctionParameterDefaultValue ')]">

   905         <xsl:text>&#xA0;=&#xA0;</xsl:text>

   906         <xsl:apply-templates select="*[contains(@class, ' cxxFunction/cxxFunctionParameterDefaultValue ')]/node()"/>

   907       </xsl:if>

   908       <xsl:if test="$hasNext">,</xsl:if>

   909     </td>

   910   </xsl:template>

   911 

   912   <!-- Return type -->

   913   <xsl:template match="*[contains(@class, ' cxxFunction/cxxFunctionDeclaredType ')]">

   914     <xsl:call-template name="topic.section"/>

   915   </xsl:template>

   916   <xsl:template match="*[contains(@class, ' cxxFunction/cxxFunctionDeclaredType ')]" mode="get-output-class">

   917     <xsl:text>section return</xsl:text>

   918   </xsl:template>

   919   <xsl:template match="*[contains(@class, ' cxxFunction/cxxFunctionDeclaredType ')]" mode="section-fmt">

   920     <xsl:variable name="flagrules">

   921       <xsl:call-template name="getrules"/>

   922     </xsl:variable>

   923     <xsl:call-template name="start-revflag">

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

   925     </xsl:call-template>

   926     <xsl:call-template name="sect-heading">

   927       <xsl:with-param name="defaulttitle">Returns</xsl:with-param>

   928     </xsl:call-template>

   929     <xsl:apply-templates/>

   930     <xsl:call-template name="end-revflag">

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

   932     </xsl:call-template>

   933   </xsl:template>

   934   

   935   <!-- Parameters -->

   936   <xsl:template match="*[contains(@class, ' cxxFunction/cxxFunctionParameters ')]">

   937     <xsl:if test="*[contains(@class, ' cxxFunction/cxxFunctionParameter ')]">

   938       <xsl:call-template name="topic.section"/>

   939     </xsl:if>

   940   </xsl:template>

   941   <xsl:template match="*[contains(@class, ' cxxFunction/cxxFunctionParameters ')]" mode="get-output-class">

   942     <xsl:text>section parameters</xsl:text>

   943   </xsl:template>

   944   <xsl:template match="*[contains(@class, ' cxxFunction/cxxFunctionParameters ')]" mode="section-fmt">

   945     <xsl:variable name="flagrules">

   946       <xsl:call-template name="getrules"/>

   947     </xsl:variable>

   948     <xsl:call-template name="start-revflag">

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

   950     </xsl:call-template>

   951     <xsl:call-template name="sect-heading">

   952       <xsl:with-param name="defaulttitle">

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

   954           <xsl:with-param name="stringName" select="'cxxParameters'"/>

   955         </xsl:call-template>

   956       </xsl:with-param>

   957     </xsl:call-template>

   958     <table border="1" class="parameters">

   959       <xsl:for-each select="*[contains(@class, ' cxxFunction/cxxFunctionParameter ')]">

   960         <tr>

   961           <xsl:if test="position() mod 2 = 0">

   962             <xsl:attribute name="class">bg</xsl:attribute>  

   963           </xsl:if>          

   964           <td class="parameter">

   965             <xsl:apply-templates select="*[contains(@class, ' cxxFunction/cxxFunctionParameterDeclaredType ')]/node()"/>

   966             <xsl:text> </xsl:text>

   967             <xsl:apply-templates select="*[contains(@class, ' cxxFunction/cxxFunctionParameterDeclarationName ')]/node()"/>

   968             <xsl:if test="*[contains(@class, ' cxxFunction/cxxFunctionParameterDefaultValue ')]">

   969               <xsl:text>&#xA0;=&#xA0;</xsl:text>

   970               <xsl:apply-templates select="*[contains(@class, ' cxxFunction/cxxFunctionParameterDefaultValue ')]/node()"/>

   971             </xsl:if>

   972           </td>

   973           <td>

   974             <xsl:apply-templates select="*[contains(@class, ' apiRef/apiDefNote ')]/node()"/>

   975             <xsl:text> </xsl:text>

   976           </td>

   977         </tr>

   978       </xsl:for-each>

   979     </table>

   980     <xsl:call-template name="end-revflag">

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

   982     </xsl:call-template>

   983   </xsl:template>

   984   

   985   <!-- Variable -->

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

   987   

   988   <!-- Variable title -->

   989   <xsl:template match="*[contains(@class, ' cxxVariable/cxxVariable ')]/*[contains(@class, ' topic/title ')]" mode="cxxapiref.title-fmt">

   990     <xsl:value-of select="../*[contains(@class, ' cxxVariable/cxxVariableDetail ')]/*[contains(@class, ' cxxVariable/cxxVariableDefinition ')]/*[contains(@class, ' cxxVariable/cxxVariableDeclaredType ')]"/>

   991     <xsl:text> </xsl:text>    

   992     <xsl:apply-templates/>

   993   </xsl:template>

   994   

   995   <!-- Variable member index row -->

   996   <xsl:template match="*[contains(@class, ' cxxVariable/cxxVariable ')]" mode="class-members">

   997     <tr>

   998       <xsl:if test="position() mod 2 = 0">

   999         <xsl:attribute name="class">bg</xsl:attribute>  

  1000       </xsl:if>

  1001       <td align="right" valign="top">

  1002         <xsl:apply-templates select="*[contains(@class, ' cxxVariable/cxxVariableDetail ')]/*[contains(@class, ' cxxVariable/cxxVariableDefinition ')]/*[contains(@class, ' cxxVariable/cxxVariableDeclaredType ')]/node()"/>

  1003       </td>

  1004       <td>

  1005         <a href="#{@id}">

  1006           <xsl:apply-templates select="*[contains(@class, ' topic/title ')]/node()"/>

  1007         </a>

  1008       </td>

  1009     </tr>

  1010   </xsl:template>

  1011   

  1012   <!-- Variable body -->

  1013   <xsl:template match="*[contains(@class, ' cxxVariable/cxxVariableDetail ')]">

  1014     <xsl:apply-templates select="*[contains(@class, ' cxxVariable/cxxVariableDefinition ')]" mode="signature"/>

  1015     <xsl:apply-templates select="*[(contains(@class, ' topic/section ') or

  1016                                     contains(@class, ' topic/example ')) and

  1017                                    not(contains(@class, ' apiRef/apiDef '))]"/>

  1018   </xsl:template>

  1019   

  1020   <!-- Variable signature -->

  1021   <xsl:template match="*[contains(@class, ' cxxVariable/cxxVariableDefinition ')]" mode="signature">

  1022     <xsl:variable name="meta">

  1023       <xsl:call-template name="meta-signature"/>

  1024     </xsl:variable>

  1025     <table class="signature">

  1026       <tr>

  1027         <td>

  1028           <xsl:apply-templates select="*[contains(@class, ' cxxVariable/cxxVariableDeclaredType ')]/node()"/>

  1029         </td>

  1030         <td>

  1031           <xsl:apply-templates select="ancestor::*[contains(@class, ' cxxVariable/cxxVariable ')][1]/*[contains(@class, ' topic/title ')]/node()"/>

  1032         </td>

  1033         <xsl:if test="normalize-space($meta)">

  1034           <td>

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

  1036           </td>

  1037         </xsl:if>

  1038       </tr>

  1039     </table>

  1040   </xsl:template>

  1041   

  1042   <!-- Enumeration -->

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

  1044   

  1045   <!-- Enumeration title -->

  1046   <xsl:template match="*[contains(@class, ' cxxEnumeration/cxxEnumeration ')]/*[contains(@class, ' topic/title ')]" mode="cxxapiref.title-fmt">

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

  1048       <xsl:with-param name="stringName" select="'Enum'"/>

  1049     </xsl:call-template>

  1050     <xsl:text> </xsl:text>

  1051     <xsl:choose>

  1052       <xsl:when test="starts-with(., '@')">

  1053         <xsl:text>anonymous</xsl:text>

  1054       </xsl:when>

  1055       <xsl:otherwise>

  1056         <xsl:apply-templates/>

  1057       </xsl:otherwise>

  1058     </xsl:choose>

  1059   </xsl:template>

  1060   

  1061   <!-- Enumeration member index row -->

  1062   <xsl:template match="*[contains(@class, ' cxxEnumeration/cxxEnumeration ')]" mode="class-members">

  1063     <tr>

  1064       <xsl:if test="position() mod 2 = 0">

  1065         <xsl:attribute name="class">bg</xsl:attribute>  

  1066       </xsl:if>

  1067       <td align="right" valign="top">

  1068         <xsl:text>enum</xsl:text>

  1069       </td>

  1070       <td>

  1071         <a href="#{@id}">

  1072           <xsl:choose>

  1073            <xsl:when test="starts-with(*[contains(@class, ' topic/title ')], '@')">

  1074              <xsl:text>anonymous</xsl:text>

  1075            </xsl:when>

  1076            <xsl:otherwise>

  1077              <xsl:apply-templates select="*[contains(@class, ' topic/title ')]/node()"/>

  1078            </xsl:otherwise>

  1079          </xsl:choose>

  1080         </a>

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

  1082         <xsl:variable name="enumerators"

  1083                       select="*[contains(@class, ' cxxEnumeration/cxxEnumerationDetail ')]/

  1084                                 *[contains(@class, ' cxxEnumeration/cxxEnumerationDefinition ')]/

  1085                                   *[contains(@class, ' cxxEnumeration/cxxEnumerators ')]/

  1086                                     *[contains(@class, ' cxxEnumeration/cxxEnumerator ')]"/>

  1087         <xsl:if test="count($enumerators) > 5">

  1088           <br/>

  1089         </xsl:if>

  1090         <xsl:for-each select="*[contains(@class, ' cxxEnumeration/cxxEnumerationDetail ')]/

  1091                                 *[contains(@class, ' cxxEnumeration/cxxEnumerationDefinition ')]/

  1092                                   *[contains(@class, ' cxxEnumeration/cxxEnumerators ')]/

  1093                                     *[contains(@class, ' cxxEnumeration/cxxEnumerator ')]">

  1094           <xsl:if test="not(position() = 1)">, </xsl:if>

  1095           <a href="#{@id}">

  1096             <xsl:apply-templates select="*[contains(@class, ' apiRef/apiName ')]/node()"/>  

  1097           </a>

  1098           <xsl:for-each select="*[contains(@class, ' cxxEnumeration/cxxEnumeratorInitialiser ')] ">

  1099             <xsl:text>&#xA0;=&#xA0;</xsl:text>

  1100             <xsl:apply-templates select="@value"/>

  1101           </xsl:for-each>

  1102         </xsl:for-each>

  1103         <xsl:if test="count($enumerators) > 5">

  1104           <br/>

  1105         </xsl:if>

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

  1107       </td>

  1108     </tr>

  1109   </xsl:template>

  1110   

  1111   <!-- Enumeration body -->

  1112   <xsl:template match="*[contains(@class, ' cxxEnumeration/cxxEnumerationDetail ')]">

  1113     <!--xsl:apply-templates select="*[contains(@class, ' cxxEnumeration/cxxEnumerationDefinition ')]" mode="signature"/-->

  1114     <xsl:apply-templates select="*[(contains(@class, ' topic/section ') or

  1115                                     contains(@class, ' topic/example ')) and

  1116                                    not(contains(@class, ' apiRef/apiDef '))]"/>

  1117     <xsl:apply-templates select="*[contains(@class, ' cxxEnumeration/cxxEnumerationDefinition ')]/*[contains(@class, ' cxxEnumeration/cxxEnumerators ')]"/>

  1118   </xsl:template>  

  1119   

  1120   <xsl:template match="*[contains(@class, ' cxxEnumeration/cxxEnumerators ')]">

  1121     <xsl:call-template name="topic.section"/>

  1122   </xsl:template>

  1123   <xsl:template match="*[contains(@class, ' cxxEnumeration/cxxEnumerators ')]" mode="get-output-class">

  1124     <xsl:text>section enumerators</xsl:text>

  1125   </xsl:template>

  1126   <xsl:template match="*[contains(@class, ' cxxEnumeration/cxxEnumerators ')]" mode="section-fmt">

  1127     <xsl:variable name="flagrules">

  1128       <xsl:call-template name="getrules"/>

  1129     </xsl:variable>

  1130     <xsl:call-template name="start-revflag">

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

  1132     </xsl:call-template>

  1133     <xsl:call-template name="sect-heading">

  1134       <xsl:with-param name="defaulttitle">Enumerators</xsl:with-param>

  1135     </xsl:call-template>