doc/xslt/html/chunk-common.xsl

   1 <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
   2                 xmlns:exsl="http://exslt.org/common"
   3                 xmlns:cf="http://docbook.sourceforge.net/xmlns/chunkfast/1.0"
   4                 xmlns:ng="http://docbook.org/docbook-ng"
   5                 xmlns:db="http://docbook.org/ns/docbook"
   6                 version="1.0"
   7                 exclude-result-prefixes="exsl cf ng db">
   8
   9 <!-- ********************************************************************
  10      $Id: chunk-common.xsl 8551 2009-12-07 06:03:50Z bobstayton $
  11      ********************************************************************
  12
  13      This file is part of the XSL DocBook Stylesheet distribution.
  14      See ../README or http://docbook.sf.net/release/xsl/current/ for
  15      copyright and other information.
  16
  17      ******************************************************************** -->
  18
  19 <!-- ==================================================================== -->
  20
  21 <xsl:param name="onechunk" select="0"/>
  22 <xsl:param name="refentry.separator" select="0"/>
  23 <xsl:param name="chunk.fast" select="0"/>
  24
  25 <xsl:key name="genid" match="*" use="generate-id()"/>
  26
  27 <!-- ==================================================================== -->
  28
  29 <xsl:variable name="chunk.hierarchy">
  30   <xsl:if test="$chunk.fast != 0">
  31     <xsl:choose>
  32       <xsl:when test="$exsl.node.set.available != 0">
  33         <xsl:message>Computing chunks...</xsl:message>
  34         <xsl:apply-templates select="/*" mode="find.chunks"/>
  35       </xsl:when>
  36       <xsl:otherwise>
  37         <xsl:message>
  38           <xsl:text>Fast chunking requires exsl:node-set(). </xsl:text>
  39           <xsl:text>Using "slow" chunking.</xsl:text>
  40         </xsl:message>
  41       </xsl:otherwise>
  42     </xsl:choose>
  43   </xsl:if>
  44 </xsl:variable>
  45
  46 <!-- ==================================================================== -->
  47
  48 <xsl:template name="process-chunk-element">
  49   <xsl:param name="content">
  50     <xsl:apply-imports/>
  51   </xsl:param>
  52
  53   <xsl:choose>
  54     <xsl:when test="$chunk.fast != 0 and $exsl.node.set.available != 0">
  55       <xsl:variable name="chunks" select="exsl:node-set($chunk.hierarchy)//cf:div"/>
  56       <xsl:variable name="genid" select="generate-id()"/>
  57
  58       <xsl:variable name="div" select="$chunks[@id=$genid or @xml:id=$genid]"/>
  59
  60       <xsl:variable name="prevdiv"
  61                     select="($div/preceding-sibling::cf:div|$div/preceding::cf:div|$div/parent::cf:div)[last()]"/>
  62       <xsl:variable name="prev" select="key('genid', ($prevdiv/@id|$prevdiv/@xml:id)[1])"/>
  63
  64       <xsl:variable name="nextdiv"
  65                     select="($div/following-sibling::cf:div|$div/following::cf:div|$div/cf:div)[1]"/>
  66       <xsl:variable name="next" select="key('genid', ($nextdiv/@id|$nextdiv/@xml:id)[1])"/>
  67
  68       <xsl:choose>
  69         <xsl:when test="$onechunk != 0 and parent::*">
  70           <xsl:copy-of select="$content"/>
  71         </xsl:when>
  72         <xsl:otherwise>
  73           <xsl:call-template name="process-chunk">
  74             <xsl:with-param name="prev" select="$prev"/>
  75             <xsl:with-param name="next" select="$next"/>
  76             <xsl:with-param name="content" select="$content"/>
  77           </xsl:call-template>
  78         </xsl:otherwise>
  79       </xsl:choose>
  80     </xsl:when>
  81     <xsl:otherwise>
  82       <xsl:choose>
  83         <xsl:when test="$onechunk != 0 and not(parent::*)">
  84           <xsl:call-template name="chunk-all-sections">
  85             <xsl:with-param name="content" select="$content"/>
  86           </xsl:call-template>
  87         </xsl:when>
  88         <xsl:when test="$onechunk != 0">
  89           <xsl:copy-of select="$content"/>
  90         </xsl:when>
  91         <xsl:when test="$chunk.first.sections = 0">
  92           <xsl:call-template name="chunk-first-section-with-parent">
  93             <xsl:with-param name="content" select="$content"/>
  94           </xsl:call-template>
  95         </xsl:when>
  96         <xsl:otherwise>
  97           <xsl:call-template name="chunk-all-sections">
  98             <xsl:with-param name="content" select="$content"/>
  99           </xsl:call-template>
 100         </xsl:otherwise>
 101       </xsl:choose>
 102     </xsl:otherwise>
 103   </xsl:choose>
 104 </xsl:template>
 105
 106 <xsl:template name="process-chunk">
 107   <xsl:param name="prev" select="."/>
 108   <xsl:param name="next" select="."/>
 109   <xsl:param name="content">
 110     <xsl:apply-imports/>
 111   </xsl:param>
 112
 113   <xsl:variable name="ischunk">
 114     <xsl:call-template name="chunk"/>
 115   </xsl:variable>
 116
 117   <xsl:variable name="chunkfn">
 118     <xsl:if test="$ischunk='1'">
 119       <xsl:apply-templates mode="chunk-filename" select="."/>
 120     </xsl:if>
 121   </xsl:variable>
 122
 123   <xsl:if test="$ischunk='0'">
 124     <xsl:message>
 125       <xsl:text>Error </xsl:text>
 126       <xsl:value-of select="name(.)"/>
 127       <xsl:text> is not a chunk!</xsl:text>
 128     </xsl:message>
 129   </xsl:if>
 130
 131   <xsl:variable name="filename">
 132     <xsl:call-template name="make-relative-filename">
 133       <xsl:with-param name="base.dir" select="$base.dir"/>
 134       <xsl:with-param name="base.name" select="$chunkfn"/>
 135     </xsl:call-template>
 136   </xsl:variable>
 137
 138   <xsl:call-template name="write.chunk">
 139     <xsl:with-param name="filename" select="$filename"/>
 140     <xsl:with-param name="content">
 141       <xsl:call-template name="chunk-element-content">
 142         <xsl:with-param name="prev" select="$prev"/>
 143         <xsl:with-param name="next" select="$next"/>
 144         <xsl:with-param name="content" select="$content"/>
 145       </xsl:call-template>
 146     </xsl:with-param>
 147     <xsl:with-param name="quiet" select="$chunk.quietly"/>
 148   </xsl:call-template>
 149 </xsl:template>
 150
 151 <xsl:template name="chunk-first-section-with-parent">
 152   <xsl:param name="content">
 153     <xsl:apply-imports/>
 154   </xsl:param>
 155
 156   <!-- These xpath expressions are really hairy. The trick is to pick sections -->
 157   <!-- that are not first children and are not the children of first children -->
 158
 159   <!-- Break these variables into pieces to work around
 160        http://nagoya.apache.org/bugzilla/show_bug.cgi?id=6063 -->
 161
 162   <xsl:variable name="prev-v1"
 163      select="(ancestor::sect1[$chunk.section.depth &gt; 0
 164                                    and not(ancestor::*/processing-instruction('dbhtml')[normalize-space(.) ='stop-chunking'])
 165                                and preceding-sibling::sect1][1]
 166
 167              |ancestor::sect2[$chunk.section.depth &gt; 1
 168                                and not(ancestor::*/processing-instruction('dbhtml')[normalize-space(.) ='stop-chunking'])
 169                                and preceding-sibling::sect2
 170                                and parent::sect1[preceding-sibling::sect1]][1]
 171
 172              |ancestor::sect3[$chunk.section.depth &gt; 2
 173                                and not(ancestor::*/processing-instruction('dbhtml')[normalize-space(.) ='stop-chunking'])
 174                                and preceding-sibling::sect3
 175                                and parent::sect2[preceding-sibling::sect2]
 176                                and ancestor::sect1[preceding-sibling::sect1]][1]
 177
 178              |ancestor::sect4[$chunk.section.depth &gt; 3
 179                                and not(ancestor::*/processing-instruction('dbhtml')[normalize-space(.) ='stop-chunking'])
 180                                and preceding-sibling::sect4
 181                                and parent::sect3[preceding-sibling::sect3]
 182                                and ancestor::sect2[preceding-sibling::sect2]
 183                                and ancestor::sect1[preceding-sibling::sect1]][1]
 184
 185              |ancestor::sect5[$chunk.section.depth &gt; 4
 186                                and not(ancestor::*/processing-instruction('dbhtml')[normalize-space(.) ='stop-chunking'])
 187                                and preceding-sibling::sect5
 188                                and parent::sect4[preceding-sibling::sect4]
 189                                and ancestor::sect3[preceding-sibling::sect3]
 190                                and ancestor::sect2[preceding-sibling::sect2]
 191                                and ancestor::sect1[preceding-sibling::sect1]][1]
 192
 193              |ancestor::section[$chunk.section.depth &gt; count(ancestor::section)
 194                                     and not(ancestor::*/processing-instruction('dbhtml')[normalize-space(.) ='stop-chunking'])
 195                                 and not(ancestor::section[not(preceding-sibling::section)])][1])[last()]"/>
 196
 197   <xsl:variable name="prev-v2"
 198      select="(preceding::sect1[$chunk.section.depth &gt; 0
 199                                and not(ancestor::*/processing-instruction('dbhtml')[normalize-space(.) ='stop-chunking'])
 200                                and preceding-sibling::sect1][1]
 201
 202              |preceding::sect2[$chunk.section.depth &gt; 1
 203                                and not(ancestor::*/processing-instruction('dbhtml')[normalize-space(.) ='stop-chunking'])
 204                                and preceding-sibling::sect2
 205                                and parent::sect1[preceding-sibling::sect1]][1]
 206
 207              |preceding::sect3[$chunk.section.depth &gt; 2
 208                                and not(ancestor::*/processing-instruction('dbhtml')[normalize-space(.) ='stop-chunking'])
 209                                and preceding-sibling::sect3
 210                                and parent::sect2[preceding-sibling::sect2]
 211                                and ancestor::sect1[preceding-sibling::sect1]][1]
 212
 213              |preceding::sect4[$chunk.section.depth &gt; 3
 214                                and not(ancestor::*/processing-instruction('dbhtml')[normalize-space(.) ='stop-chunking'])
 215                                and preceding-sibling::sect4
 216                                and parent::sect3[preceding-sibling::sect3]
 217                                and ancestor::sect2[preceding-sibling::sect2]
 218                                and ancestor::sect1[preceding-sibling::sect1]][1]
 219
 220              |preceding::sect5[$chunk.section.depth &gt; 4
 221                                and not(ancestor::*/processing-instruction('dbhtml')[normalize-space(.) ='stop-chunking'])
 222                                and preceding-sibling::sect5
 223                                and parent::sect4[preceding-sibling::sect4]
 224                                and ancestor::sect3[preceding-sibling::sect3]
 225                                and ancestor::sect2[preceding-sibling::sect2]
 226                                and ancestor::sect1[preceding-sibling::sect1]][1]
 227
 228              |preceding::section[$chunk.section.depth &gt; count(ancestor::section)
 229                                      and not(ancestor::*/processing-instruction('dbhtml')[normalize-space(.) ='stop-chunking'])
 230                                  and preceding-sibling::section
 231                                  and not(ancestor::section[not(preceding-sibling::section)])][1])[last()]"/>
 232
 233   <xsl:variable name="prev"
 234     select="(preceding::book[1]
 235              |preceding::preface[1]
 236              |preceding::chapter[1]
 237              |preceding::appendix[1]
 238              |preceding::part[1]
 239              |preceding::reference[1]
 240              |preceding::refentry[1]
 241              |preceding::colophon[1]
 242              |preceding::article[1]
 243              |preceding::bibliography[parent::article or parent::book or parent::part][1]
 244              |preceding::glossary[parent::article or parent::book or parent::part][1]
 245              |preceding::index[$generate.index != 0]
 246                                [parent::article or parent::book or parent::part][1]
 247              |preceding::setindex[$generate.index != 0][1]
 248              |ancestor::set
 249              |ancestor::book[1]
 250              |ancestor::preface[1]
 251              |ancestor::chapter[1]
 252              |ancestor::appendix[1]
 253              |ancestor::part[1]
 254              |ancestor::reference[1]
 255              |ancestor::article[1]
 256              |$prev-v1
 257              |$prev-v2)[last()]"/>
 258
 259   <xsl:variable name="next-v1"
 260     select="(following::sect1[$chunk.section.depth &gt; 0
 261                                    and not(ancestor::*/processing-instruction('dbhtml')[normalize-space(.) ='stop-chunking'])
 262                                and preceding-sibling::sect1][1]
 263
 264              |following::sect2[$chunk.section.depth &gt; 1
 265                                    and not(ancestor::*/processing-instruction('dbhtml')[normalize-space(.) ='stop-chunking'])
 266                                and preceding-sibling::sect2
 267                                and parent::sect1[preceding-sibling::sect1]][1]
 268
 269              |following::sect3[$chunk.section.depth &gt; 2
 270                                    and not(ancestor::*/processing-instruction('dbhtml')[normalize-space(.) ='stop-chunking'])
 271                                and preceding-sibling::sect3
 272                                and parent::sect2[preceding-sibling::sect2]
 273                                and ancestor::sect1[preceding-sibling::sect1]][1]
 274
 275              |following::sect4[$chunk.section.depth &gt; 3
 276                                    and not(ancestor::*/processing-instruction('dbhtml')[normalize-space(.) ='stop-chunking'])
 277                                and preceding-sibling::sect4
 278                                and parent::sect3[preceding-sibling::sect3]
 279                                and ancestor::sect2[preceding-sibling::sect2]
 280                                and ancestor::sect1[preceding-sibling::sect1]][1]
 281
 282              |following::sect5[$chunk.section.depth &gt; 4
 283                                    and not(ancestor::*/processing-instruction('dbhtml')[normalize-space(.) ='stop-chunking'])
 284                                and preceding-sibling::sect5
 285                                and parent::sect4[preceding-sibling::sect4]
 286                                and ancestor::sect3[preceding-sibling::sect3]
 287                                and ancestor::sect2[preceding-sibling::sect2]
 288                                and ancestor::sect1[preceding-sibling::sect1]][1]
 289
 290              |following::section[$chunk.section.depth &gt; count(ancestor::section)
 291                                      and not(ancestor::*/processing-instruction('dbhtml')[normalize-space(.) ='stop-chunking'])
 292                                  and preceding-sibling::section
 293                                  and not(ancestor::section[not(preceding-sibling::section)])][1])[1]"/>
 294
 295   <xsl:variable name="next-v2"
 296     select="(descendant::sect1[$chunk.section.depth &gt; 0
 297                                    and not(ancestor::*/processing-instruction('dbhtml')[normalize-space(.) ='stop-chunking'])
 298                                and preceding-sibling::sect1][1]
 299
 300              |descendant::sect2[$chunk.section.depth &gt; 1
 301                                    and not(ancestor::*/processing-instruction('dbhtml')[normalize-space(.) ='stop-chunking'])
 302                                and preceding-sibling::sect2
 303                                and parent::sect1[preceding-sibling::sect1]][1]
 304
 305              |descendant::sect3[$chunk.section.depth &gt; 2
 306                                    and not(ancestor::*/processing-instruction('dbhtml')[normalize-space(.) ='stop-chunking'])
 307                                and preceding-sibling::sect3
 308                                and parent::sect2[preceding-sibling::sect2]
 309                                and ancestor::sect1[preceding-sibling::sect1]][1]
 310
 311              |descendant::sect4[$chunk.section.depth &gt; 3
 312                                    and not(ancestor::*/processing-instruction('dbhtml')[normalize-space(.) ='stop-chunking'])
 313                                and preceding-sibling::sect4
 314                                and parent::sect3[preceding-sibling::sect3]
 315                                and ancestor::sect2[preceding-sibling::sect2]
 316                                and ancestor::sect1[preceding-sibling::sect1]][1]
 317
 318              |descendant::sect5[$chunk.section.depth &gt; 4
 319                                    and not(ancestor::*/processing-instruction('dbhtml')[normalize-space(.) ='stop-chunking'])
 320                                and preceding-sibling::sect5
 321                                and parent::sect4[preceding-sibling::sect4]
 322                                and ancestor::sect3[preceding-sibling::sect3]
 323                                and ancestor::sect2[preceding-sibling::sect2]
 324                                and ancestor::sect1[preceding-sibling::sect1]][1]
 325
 326              |descendant::section[$chunk.section.depth &gt; count(ancestor::section)
 327                                      and not(ancestor::*/processing-instruction('dbhtml')[normalize-space(.) ='stop-chunking'])
 328                                  and preceding-sibling::section
 329                                  and not(ancestor::section[not(preceding-sibling::section)])])[1]"/>
 330
 331   <xsl:variable name="next"
 332     select="(following::book[1]
 333              |following::preface[1]
 334              |following::chapter[1]
 335              |following::appendix[1]
 336              |following::part[1]
 337              |following::reference[1]
 338              |following::refentry[1]
 339              |following::colophon[1]
 340              |following::bibliography[parent::article or parent::book or parent::part][1]
 341              |following::glossary[parent::article or parent::book or parent::part][1]
 342              |following::index[$generate.index != 0]
 343                                [parent::article or parent::book or parent::part][1]
 344              |following::article[1]
 345              |following::setindex[$generate.index != 0][1]
 346              |descendant::book[1]
 347              |descendant::preface[1]
 348              |descendant::chapter[1]
 349              |descendant::appendix[1]
 350              |descendant::article[1]
 351              |descendant::bibliography[parent::article or parent::book or parent::part][1]
 352              |descendant::glossary[parent::article or parent::book or parent::part][1]
 353              |descendant::index[$generate.index != 0]
 354                                [parent::article or parent::book or parent::part][1]
 355              |descendant::colophon[1]
 356              |descendant::setindex[$generate.index != 0][1]
 357              |descendant::part[1]
 358              |descendant::reference[1]
 359              |descendant::refentry[1]
 360              |$next-v1
 361              |$next-v2)[1]"/>
 362
 363   <xsl:call-template name="process-chunk">
 364     <xsl:with-param name="prev" select="$prev"/>
 365     <xsl:with-param name="next" select="$next"/>
 366     <xsl:with-param name="content" select="$content"/>
 367   </xsl:call-template>
 368 </xsl:template>
 369
 370 <xsl:template name="chunk-all-sections">
 371   <xsl:param name="content">
 372     <xsl:apply-imports/>
 373   </xsl:param>
 374
 375   <xsl:variable name="prev-v1"
 376     select="(preceding::sect1[$chunk.section.depth &gt; 0 and not(ancestor::*/processing-instruction('dbhtml')[normalize-space(.) ='stop-chunking'])][1]
 377              |preceding::sect2[$chunk.section.depth &gt; 1 and not(ancestor::*/processing-instruction('dbhtml')[normalize-space(.) ='stop-chunking'])][1]
 378              |preceding::sect3[$chunk.section.depth &gt; 2 and not(ancestor::*/processing-instruction('dbhtml')[normalize-space(.) ='stop-chunking'])][1]
 379              |preceding::sect4[$chunk.section.depth &gt; 3 and not(ancestor::*/processing-instruction('dbhtml')[normalize-space(.) ='stop-chunking'])][1]
 380              |preceding::sect5[$chunk.section.depth &gt; 4 and not(ancestor::*/processing-instruction('dbhtml')[normalize-space(.) ='stop-chunking'])][1]
 381              |preceding::section[$chunk.section.depth &gt; count(ancestor::section) and not(ancestor::*/processing-instruction('dbhtml')[normalize-space(.) ='stop-chunking'])][1])[last()]"/>
 382
 383   <xsl:variable name="prev-v2"
 384     select="(ancestor::sect1[$chunk.section.depth &gt; 0 and not(ancestor::*/processing-instruction('dbhtml')[normalize-space(.) ='stop-chunking'])][1]
 385              |ancestor::sect2[$chunk.section.depth &gt; 1 and not(ancestor::*/processing-instruction('dbhtml')[normalize-space(.) ='stop-chunking'])][1]
 386              |ancestor::sect3[$chunk.section.depth &gt; 2 and not(ancestor::*/processing-instruction('dbhtml')[normalize-space(.) ='stop-chunking'])][1]
 387              |ancestor::sect4[$chunk.section.depth &gt; 3 and not(ancestor::*/processing-instruction('dbhtml')[normalize-space(.) ='stop-chunking'])][1]
 388              |ancestor::sect5[$chunk.section.depth &gt; 4 and not(ancestor::*/processing-instruction('dbhtml')[normalize-space(.) ='stop-chunking'])][1]
 389              |ancestor::section[$chunk.section.depth &gt; count(ancestor::section) and not(ancestor::*/processing-instruction('dbhtml')[normalize-space(.) ='stop-chunking'])][1])[last()]"/>
 390
 391   <xsl:variable name="prev"
 392     select="(preceding::book[1]
 393              |preceding::preface[1]
 394              |preceding::chapter[1]
 395              |preceding::appendix[1]
 396              |preceding::part[1]
 397              |preceding::reference[1]
 398              |preceding::refentry[1]
 399              |preceding::colophon[1]
 400              |preceding::article[1]
 401              |preceding::bibliography[parent::article or parent::book or parent::part][1]
 402              |preceding::glossary[parent::article or parent::book or parent::part][1]
 403              |preceding::index[$generate.index != 0]
 404                                [parent::article or parent::book or parent::part][1]
 405              |preceding::setindex[$generate.index != 0][1]
 406              |ancestor::set
 407              |ancestor::book[1]
 408              |ancestor::preface[1]
 409              |ancestor::chapter[1]
 410              |ancestor::appendix[1]
 411              |ancestor::part[1]
 412              |ancestor::reference[1]
 413              |ancestor::article[1]
 414              |$prev-v1
 415              |$prev-v2)[last()]"/>
 416
 417   <xsl:variable name="next-v1"
 418     select="(following::sect1[$chunk.section.depth &gt; 0 and not(ancestor::*/processing-instruction('dbhtml')[normalize-space(.) ='stop-chunking'])][1]
 419              |following::sect2[$chunk.section.depth &gt; 1 and not(ancestor::*/processing-instruction('dbhtml')[normalize-space(.) ='stop-chunking'])][1]
 420              |following::sect3[$chunk.section.depth &gt; 2 and not(ancestor::*/processing-instruction('dbhtml')[normalize-space(.) ='stop-chunking'])][1]
 421              |following::sect4[$chunk.section.depth &gt; 3 and not(ancestor::*/processing-instruction('dbhtml')[normalize-space(.) ='stop-chunking'])][1]
 422              |following::sect5[$chunk.section.depth &gt; 4 and not(ancestor::*/processing-instruction('dbhtml')[normalize-space(.) ='stop-chunking'])][1]
 423              |following::section[$chunk.section.depth &gt; count(ancestor::section) and not(ancestor::*/processing-instruction('dbhtml')[normalize-space(.) ='stop-chunking'])][1])[1]"/>
 424
 425   <xsl:variable name="next-v2"
 426     select="(descendant::sect1[$chunk.section.depth &gt; 0 and not(ancestor::*/processing-instruction('dbhtml')[normalize-space(.) ='stop-chunking'])][1]
 427              |descendant::sect2[$chunk.section.depth &gt; 1 and not(ancestor::*/processing-instruction('dbhtml')[normalize-space(.) ='stop-chunking'])][1]
 428              |descendant::sect3[$chunk.section.depth &gt; 2 and not(ancestor::*/processing-instruction('dbhtml')[normalize-space(.) ='stop-chunking'])][1]
 429              |descendant::sect4[$chunk.section.depth &gt; 3 and not(ancestor::*/processing-instruction('dbhtml')[normalize-space(.) ='stop-chunking'])][1]
 430              |descendant::sect5[$chunk.section.depth &gt; 4 and not(ancestor::*/processing-instruction('dbhtml')[normalize-space(.) ='stop-chunking'])][1]
 431              |descendant::section[$chunk.section.depth
 432                                   &gt; count(ancestor::section) and not(ancestor::*/processing-instruction('dbhtml')[normalize-space(.) ='stop-chunking'])][1])[1]"/>
 433
 434   <xsl:variable name="next"
 435     select="(following::book[1]
 436              |following::preface[1]
 437              |following::chapter[1]
 438              |following::appendix[1]
 439              |following::part[1]
 440              |following::reference[1]
 441              |following::refentry[1]
 442              |following::colophon[1]
 443              |following::bibliography[parent::article or parent::book or parent::part][1]
 444              |following::glossary[parent::article or parent::book or parent::part][1]
 445              |following::index[$generate.index != 0]
 446                                [parent::article or parent::book][1]
 447              |following::article[1]
 448              |following::setindex[$generate.index != 0][1]
 449              |descendant::book[1]
 450              |descendant::preface[1]
 451              |descendant::chapter[1]
 452              |descendant::appendix[1]
 453              |descendant::article[1]
 454              |descendant::bibliography[parent::article or parent::book][1]
 455              |descendant::glossary[parent::article or parent::book or parent::part][1]
 456              |descendant::index[$generate.index != 0]
 457                                [parent::article or parent::book][1]
 458              |descendant::colophon[1]
 459              |descendant::setindex[$generate.index != 0][1]
 460              |descendant::part[1]
 461              |descendant::reference[1]
 462              |descendant::refentry[1]
 463              |$next-v1
 464              |$next-v2)[1]"/>
 465
 466   <xsl:call-template name="process-chunk">
 467     <xsl:with-param name="prev" select="$prev"/>
 468     <xsl:with-param name="next" select="$next"/>
 469     <xsl:with-param name="content" select="$content"/>
 470   </xsl:call-template>
 471 </xsl:template>
 472
 473 <!-- ==================================================================== -->
 474
 475 <!-- ==================================================================== -->
 476
 477 <xsl:template name="make.lots">
 478   <xsl:param name="toc.params" select="''"/>
 479   <xsl:param name="toc"/>
 480
 481   <xsl:variable name="lots">
 482     <xsl:if test="contains($toc.params, 'toc')">
 483       <xsl:copy-of select="$toc"/>
 484     </xsl:if>
 485
 486     <xsl:if test="contains($toc.params, 'figure')">
 487       <xsl:choose>
 488         <xsl:when test="$chunk.separate.lots != '0'">
 489           <xsl:call-template name="make.lot.chunk">
 490             <xsl:with-param name="type" select="'figure'"/>
 491             <xsl:with-param name="lot">
 492               <xsl:call-template name="list.of.titles">
 493                 <xsl:with-param name="titles" select="'figure'"/>
 494                 <xsl:with-param name="nodes" select=".//figure"/>
 495               </xsl:call-template>
 496             </xsl:with-param>
 497           </xsl:call-template>
 498         </xsl:when>
 499         <xsl:otherwise>
 500           <xsl:call-template name="list.of.titles">
 501             <xsl:with-param name="titles" select="'figure'"/>
 502             <xsl:with-param name="nodes" select=".//figure"/>
 503           </xsl:call-template>
 504         </xsl:otherwise>
 505       </xsl:choose>
 506     </xsl:if>
 507
 508     <xsl:if test="contains($toc.params, 'table')">
 509       <xsl:choose>
 510         <xsl:when test="$chunk.separate.lots != '0'">
 511           <xsl:call-template name="make.lot.chunk">
 512             <xsl:with-param name="type" select="'table'"/>
 513             <xsl:with-param name="lot">
 514               <xsl:call-template name="list.of.titles">
 515                 <xsl:with-param name="titles" select="'table'"/>
 516                 <xsl:with-param name="nodes" select=".//table"/>
 517               </xsl:call-template>
 518             </xsl:with-param>
 519           </xsl:call-template>
 520         </xsl:when>
 521         <xsl:otherwise>
 522           <xsl:call-template name="list.of.titles">
 523             <xsl:with-param name="titles" select="'table'"/>
 524             <xsl:with-param name="nodes" select=".//table"/>
 525           </xsl:call-template>
 526         </xsl:otherwise>
 527       </xsl:choose>
 528     </xsl:if>
 529
 530     <xsl:if test="contains($toc.params, 'example')">
 531       <xsl:choose>
 532         <xsl:when test="$chunk.separate.lots != '0'">
 533           <xsl:call-template name="make.lot.chunk">
 534             <xsl:with-param name="type" select="'example'"/>
 535             <xsl:with-param name="lot">
 536               <xsl:call-template name="list.of.titles">
 537                 <xsl:with-param name="titles" select="'example'"/>
 538                 <xsl:with-param name="nodes" select=".//example"/>
 539               </xsl:call-template>
 540             </xsl:with-param>
 541           </xsl:call-template>
 542         </xsl:when>
 543         <xsl:otherwise>
 544           <xsl:call-template name="list.of.titles">
 545             <xsl:with-param name="titles" select="'example'"/>
 546             <xsl:with-param name="nodes" select=".//example"/>
 547           </xsl:call-template>
 548         </xsl:otherwise>
 549       </xsl:choose>
 550     </xsl:if>
 551
 552     <xsl:if test="contains($toc.params, 'equation')">
 553       <xsl:choose>
 554         <xsl:when test="$chunk.separate.lots != '0'">
 555           <xsl:call-template name="make.lot.chunk">
 556             <xsl:with-param name="type" select="'equation'"/>
 557             <xsl:with-param name="lot">
 558               <xsl:call-template name="list.of.titles">
 559                 <xsl:with-param name="titles" select="'equation'"/>
 560                 <xsl:with-param name="nodes" select=".//equation[title or info/title]"/>
 561               </xsl:call-template>
 562             </xsl:with-param>
 563           </xsl:call-template>
 564         </xsl:when>
 565         <xsl:otherwise>
 566           <xsl:call-template name="list.of.titles">
 567             <xsl:with-param name="titles" select="'equation'"/>
 568             <xsl:with-param name="nodes" select=".//equation[title or info/title]"/>
 569           </xsl:call-template>
 570         </xsl:otherwise>
 571       </xsl:choose>
 572     </xsl:if>
 573
 574     <xsl:if test="contains($toc.params, 'procedure')">
 575       <xsl:choose>
 576         <xsl:when test="$chunk.separate.lots != '0'">
 577           <xsl:call-template name="make.lot.chunk">
 578             <xsl:with-param name="type" select="'procedure'"/>
 579             <xsl:with-param name="lot">
 580               <xsl:call-template name="list.of.titles">
 581                 <xsl:with-param name="titles" select="'procedure'"/>
 582                 <xsl:with-param name="nodes" select=".//procedure[title]"/>
 583               </xsl:call-template>
 584             </xsl:with-param>
 585           </xsl:call-template>
 586         </xsl:when>
 587         <xsl:otherwise>
 588           <xsl:call-template name="list.of.titles">
 589             <xsl:with-param name="titles" select="'procedure'"/>
 590             <xsl:with-param name="nodes" select=".//procedure[title]"/>
 591           </xsl:call-template>
 592         </xsl:otherwise>
 593       </xsl:choose>
 594     </xsl:if>
 595   </xsl:variable>
 596
 597   <xsl:if test="string($lots) != ''">
 598     <xsl:choose>
 599       <xsl:when test="$chunk.tocs.and.lots != 0 and not(parent::*)">
 600         <xsl:call-template name="write.chunk">
 601           <xsl:with-param name="filename">
 602             <xsl:call-template name="make-relative-filename">
 603               <xsl:with-param name="base.dir" select="$base.dir"/>
 604               <xsl:with-param name="base.name">
 605                 <xsl:call-template name="dbhtml-dir"/>
 606                 <xsl:apply-templates select="." mode="recursive-chunk-filename">
 607                   <xsl:with-param name="recursive" select="true()"/>
 608                 </xsl:apply-templates>
 609                 <xsl:text>-toc</xsl:text>
 610                 <xsl:value-of select="$html.ext"/>
 611               </xsl:with-param>
 612             </xsl:call-template>
 613           </xsl:with-param>
 614           <xsl:with-param name="content">
 615             <xsl:call-template name="chunk-element-content">
 616               <xsl:with-param name="prev" select="/foo"/>
 617               <xsl:with-param name="next" select="/foo"/>
 618               <xsl:with-param name="nav.context" select="'toc'"/>
 619               <xsl:with-param name="content">
 620                 <xsl:if test="$chunk.tocs.and.lots.has.title != 0">
 621                   <h1>
 622                     <xsl:apply-templates select="." mode="object.title.markup"/>
 623                   </h1>
 624                 </xsl:if>
 625                 <xsl:copy-of select="$lots"/>
 626               </xsl:with-param>
 627             </xsl:call-template>
 628           </xsl:with-param>
 629           <xsl:with-param name="quiet" select="$chunk.quietly"/>
 630         </xsl:call-template>
 631       </xsl:when>
 632       <xsl:otherwise>
 633         <xsl:copy-of select="$lots"/>
 634       </xsl:otherwise>
 635     </xsl:choose>
 636   </xsl:if>
 637 </xsl:template>
 638
 639 <xsl:template name="make.lot.chunk">
 640   <xsl:param name="type" select="''"/>
 641   <xsl:param name="lot"/>
 642
 643   <xsl:if test="string($lot) != ''">
 644     <xsl:variable name="filename">
 645       <xsl:call-template name="make-relative-filename">
 646         <xsl:with-param name="base.dir" select="$base.dir"/>
 647         <xsl:with-param name="base.name">
 648           <xsl:call-template name="dbhtml-dir"/>
 649           <xsl:value-of select="$type"/>
 650           <xsl:text>-toc</xsl:text>
 651           <xsl:value-of select="$html.ext"/>
 652         </xsl:with-param>
 653       </xsl:call-template>
 654     </xsl:variable>
 655
 656     <xsl:variable name="href">
 657       <xsl:call-template name="make-relative-filename">
 658         <xsl:with-param name="base.name">
 659           <xsl:call-template name="dbhtml-dir"/>
 660           <xsl:value-of select="$type"/>
 661           <xsl:text>-toc</xsl:text>
 662           <xsl:value-of select="$html.ext"/>
 663         </xsl:with-param>
 664       </xsl:call-template>
 665     </xsl:variable>
 666
 667     <xsl:call-template name="write.chunk">
 668       <xsl:with-param name="filename" select="$filename"/>
 669       <xsl:with-param name="content">
 670         <xsl:call-template name="chunk-element-content">
 671           <xsl:with-param name="prev" select="/foo"/>
 672           <xsl:with-param name="next" select="/foo"/>
 673           <xsl:with-param name="nav.context" select="'toc'"/>
 674           <xsl:with-param name="content">
 675             <xsl:copy-of select="$lot"/>
 676           </xsl:with-param>
 677         </xsl:call-template>
 678       </xsl:with-param>
 679       <xsl:with-param name="quiet" select="$chunk.quietly"/>
 680     </xsl:call-template>
 681     <!-- And output a link to this file -->
 682     <div>
 683       <xsl:attribute name="class">
 684         <xsl:text>ListofTitles</xsl:text>
 685       </xsl:attribute>
 686       <a href="{$href}">
 687         <xsl:call-template name="gentext">
 688           <xsl:with-param name="key">
 689             <xsl:choose>
 690               <xsl:when test="$type='table'">ListofTables</xsl:when>
 691               <xsl:when test="$type='figure'">ListofFigures</xsl:when>
 692               <xsl:when test="$type='equation'">ListofEquations</xsl:when>
 693               <xsl:when test="$type='example'">ListofExamples</xsl:when>
 694               <xsl:when test="$type='procedure'">ListofProcedures</xsl:when>
 695               <xsl:otherwise>ListofUnknown</xsl:otherwise>
 696             </xsl:choose>
 697           </xsl:with-param>
 698         </xsl:call-template>
 699       </a>
 700     </div>
 701   </xsl:if>
 702 </xsl:template>
 703
 704 <!-- ==================================================================== -->
 705
 706 <xsl:template name="in.other.chunk">
 707   <xsl:param name="chunk" select="."/>
 708   <xsl:param name="node" select="."/>
 709
 710   <xsl:variable name="is.chunk">
 711     <xsl:call-template name="chunk">
 712       <xsl:with-param name="node" select="$node"/>
 713     </xsl:call-template>
 714   </xsl:variable>
 715
 716 <!--
 717   <xsl:message>
 718     <xsl:text>in.other.chunk: </xsl:text>
 719     <xsl:value-of select="name($chunk)"/>
 720     <xsl:text> </xsl:text>
 721     <xsl:value-of select="name($node)"/>
 722     <xsl:text> </xsl:text>
 723     <xsl:value-of select="$chunk = $node"/>
 724     <xsl:text> </xsl:text>
 725     <xsl:value-of select="$is.chunk"/>
 726   </xsl:message>
 727 -->
 728
 729   <xsl:choose>
 730     <xsl:when test="$chunk = $node">0</xsl:when>
 731     <xsl:when test="$is.chunk = 1">1</xsl:when>
 732     <xsl:when test="count($node) = 0">0</xsl:when>
 733     <xsl:otherwise>
 734       <xsl:call-template name="in.other.chunk">
 735         <xsl:with-param name="chunk" select="$chunk"/>
 736         <xsl:with-param name="node" select="$node/parent::*"/>
 737       </xsl:call-template>
 738     </xsl:otherwise>
 739   </xsl:choose>
 740 </xsl:template>
 741
 742 <xsl:template name="count.footnotes.in.this.chunk">
 743   <xsl:param name="node" select="."/>
 744   <xsl:param name="footnotes" select="$node//footnote"/>
 745   <xsl:param name="count" select="0"/>
 746
 747 <!--
 748   <xsl:message>
 749     <xsl:text>count.footnotes.in.this.chunk: </xsl:text>
 750     <xsl:value-of select="name($node)"/>
 751   </xsl:message>
 752 -->
 753
 754   <xsl:variable name="in.other.chunk">
 755     <xsl:call-template name="in.other.chunk">
 756       <xsl:with-param name="chunk" select="$node"/>
 757       <xsl:with-param name="node" select="$footnotes[1]"/>
 758     </xsl:call-template>
 759   </xsl:variable>
 760
 761   <xsl:choose>
 762     <xsl:when test="count($footnotes) = 0">
 763       <xsl:value-of select="$count"/>
 764     </xsl:when>
 765     <xsl:otherwise>
 766       <xsl:choose>
 767         <xsl:when test="$in.other.chunk != 0">
 768           <xsl:call-template name="count.footnotes.in.this.chunk">
 769             <xsl:with-param name="node" select="$node"/>
 770             <xsl:with-param name="footnotes"
 771                             select="$footnotes[position() &gt; 1]"/>
 772             <xsl:with-param name="count" select="$count"/>
 773           </xsl:call-template>
 774         </xsl:when>
 775         <xsl:when test="$footnotes[1]/ancestor::table
 776                         |$footnotes[1]/ancestor::informaltable">
 777           <xsl:call-template name="count.footnotes.in.this.chunk">
 778             <xsl:with-param name="node" select="$node"/>
 779             <xsl:with-param name="footnotes"
 780                             select="$footnotes[position() &gt; 1]"/>
 781             <xsl:with-param name="count" select="$count"/>
 782           </xsl:call-template>
 783         </xsl:when>
 784         <xsl:otherwise>
 785           <xsl:call-template name="count.footnotes.in.this.chunk">
 786             <xsl:with-param name="node" select="$node"/>
 787             <xsl:with-param name="footnotes"
 788                             select="$footnotes[position() &gt; 1]"/>
 789             <xsl:with-param name="count" select="$count + 1"/>
 790           </xsl:call-template>
 791         </xsl:otherwise>
 792       </xsl:choose>
 793     </xsl:otherwise>
 794   </xsl:choose>
 795 </xsl:template>
 796
 797 <xsl:template name="process.footnotes.in.this.chunk">
 798   <xsl:param name="node" select="."/>
 799   <xsl:param name="footnotes" select="$node//footnote"/>
 800
 801 <!--
 802   <xsl:message>process.footnotes.in.this.chunk</xsl:message>
 803 -->
 804
 805   <xsl:variable name="in.other.chunk">
 806     <xsl:call-template name="in.other.chunk">
 807       <xsl:with-param name="chunk" select="$node"/>
 808       <xsl:with-param name="node" select="$footnotes[1]"/>
 809     </xsl:call-template>
 810   </xsl:variable>
 811
 812   <xsl:choose>
 813     <xsl:when test="count($footnotes) = 0">
 814       <!-- nop -->
 815     </xsl:when>
 816     <xsl:otherwise>
 817       <xsl:choose>
 818         <xsl:when test="$in.other.chunk != 0">
 819           <xsl:call-template name="process.footnotes.in.this.chunk">
 820             <xsl:with-param name="node" select="$node"/>
 821             <xsl:with-param name="footnotes"
 822                             select="$footnotes[position() &gt; 1]"/>
 823           </xsl:call-template>
 824         </xsl:when>
 825         <xsl:when test="$footnotes[1]/ancestor::table
 826                         |$footnotes[1]/ancestor::informaltable">
 827           <xsl:call-template name="process.footnotes.in.this.chunk">
 828             <xsl:with-param name="node" select="$node"/>
 829             <xsl:with-param name="footnotes"
 830                             select="$footnotes[position() &gt; 1]"/>
 831           </xsl:call-template>
 832         </xsl:when>
 833         <xsl:otherwise>
 834           <xsl:apply-templates select="$footnotes[1]"
 835                                mode="process.footnote.mode"/>
 836           <xsl:call-template name="process.footnotes.in.this.chunk">
 837             <xsl:with-param name="node" select="$node"/>
 838             <xsl:with-param name="footnotes"
 839                             select="$footnotes[position() &gt; 1]"/>
 840           </xsl:call-template>
 841         </xsl:otherwise>
 842       </xsl:choose>
 843     </xsl:otherwise>
 844   </xsl:choose>
 845 </xsl:template>
 846
 847 <xsl:template name="process.footnotes">
 848   <xsl:variable name="footnotes" select=".//footnote"/>
 849   <xsl:variable name="fcount">
 850     <xsl:call-template name="count.footnotes.in.this.chunk">
 851       <xsl:with-param name="node" select="."/>
 852       <xsl:with-param name="footnotes" select="$footnotes"/>
 853     </xsl:call-template>
 854   </xsl:variable>
 855
 856 <!--
 857   <xsl:message>
 858     <xsl:value-of select="name(.)"/>
 859     <xsl:text> fcount: </xsl:text>
 860     <xsl:value-of select="$fcount"/>
 861   </xsl:message>
 862 -->
 863
 864   <!-- Only bother to do this if there's at least one non-table footnote -->
 865   <xsl:if test="$fcount &gt; 0">
 866     <div class="footnotes">
 867       <br/>
 868       <hr width="100" align="{$direction.align.start}"/>
 869       <xsl:call-template name="process.footnotes.in.this.chunk">
 870         <xsl:with-param name="node" select="."/>
 871         <xsl:with-param name="footnotes" select="$footnotes"/>
 872       </xsl:call-template>
 873     </div>
 874   </xsl:if>
 875
 876   <!-- FIXME: When chunking, only the annotations actually used
 877               in this chunk should be referenced. I don't think it
 878               does any harm to reference them all, but it adds
 879               unnecessary bloat to each chunk. -->
 880   <xsl:if test="$annotation.support != 0 and //annotation">
 881     <div class="annotation-list">
 882       <div class="annotation-nocss">
 883         <p>The following annotations are from this essay. You are seeing
 884         them here because your browser doesn’t support the user-interface
 885         techniques used to make them appear as ‘popups’ on modern browsers.</p>
 886       </div>
 887
 888       <xsl:apply-templates select="//annotation"
 889                            mode="annotation-popup"/>
 890     </div>
 891   </xsl:if>
 892 </xsl:template>
 893
 894 <xsl:template name="process.chunk.footnotes">
 895   <xsl:variable name="is.chunk">
 896     <xsl:call-template name="chunk"/>
 897   </xsl:variable>
 898   <xsl:if test="$is.chunk = 1">
 899     <xsl:call-template name="process.footnotes"/>
 900   </xsl:if>
 901 </xsl:template>
 902
 903 <!-- ====================================================================== -->
 904
 905 <xsl:template name="chunk">
 906   <xsl:param name="node" select="."/>
 907   <!-- returns 1 if $node is a chunk -->
 908
 909   <!-- ==================================================================== -->
 910   <!-- What's a chunk?
 911
 912        The root element
 913        appendix
 914        article
 915        bibliography  in article or part or book
 916        book
 917        chapter
 918        colophon
 919        glossary      in article or part or book
 920        index         in article or part or book
 921        part
 922        preface
 923        refentry
 924        reference
 925        sect{1,2,3,4,5}  if position()>1 && depth < chunk.section.depth
 926        section          if position()>1 && depth < chunk.section.depth
 927        set
 928        setindex
 929                                                                             -->
 930   <!-- ==================================================================== -->
 931
 932 <!--
 933   <xsl:message>
 934     <xsl:text>chunk: </xsl:text>
 935     <xsl:value-of select="name($node)"/>
 936     <xsl:text>(</xsl:text>
 937     <xsl:value-of select="$node/@id"/>
 938     <xsl:text>)</xsl:text>
 939     <xsl:text> csd: </xsl:text>
 940     <xsl:value-of select="$chunk.section.depth"/>
 941     <xsl:text> cfs: </xsl:text>
 942     <xsl:value-of select="$chunk.first.sections"/>
 943     <xsl:text> ps: </xsl:text>
 944     <xsl:value-of select="count($node/parent::section)"/>
 945     <xsl:text> prs: </xsl:text>
 946     <xsl:value-of select="count($node/preceding-sibling::section)"/>
 947   </xsl:message>
 948 -->
 949
 950   <xsl:choose>
 951           <xsl:when test="$node/parent::*/processing-instruction('dbhtml')[normalize-space(.) = 'stop-chunking']">0</xsl:when>
 952     <xsl:when test="not($node/parent::*)">1</xsl:when>
 953
 954     <xsl:when test="local-name($node) = 'sect1'
 955                     and $chunk.section.depth &gt;= 1
 956                     and ($chunk.first.sections != 0
 957                          or count($node/preceding-sibling::sect1) &gt; 0)">
 958       <xsl:text>1</xsl:text>
 959     </xsl:when>
 960     <xsl:when test="local-name($node) = 'sect2'
 961                     and $chunk.section.depth &gt;= 2
 962                     and ($chunk.first.sections != 0
 963                          or count($node/preceding-sibling::sect2) &gt; 0)">
 964       <xsl:call-template name="chunk">
 965         <xsl:with-param name="node" select="$node/parent::*"/>
 966       </xsl:call-template>
 967     </xsl:when>
 968     <xsl:when test="local-name($node) = 'sect3'
 969                     and $chunk.section.depth &gt;= 3
 970                     and ($chunk.first.sections != 0
 971                          or count($node/preceding-sibling::sect3) &gt; 0)">
 972       <xsl:call-template name="chunk">
 973         <xsl:with-param name="node" select="$node/parent::*"/>
 974       </xsl:call-template>
 975     </xsl:when>
 976     <xsl:when test="local-name($node) = 'sect4'
 977                     and $chunk.section.depth &gt;= 4
 978                     and ($chunk.first.sections != 0
 979                          or count($node/preceding-sibling::sect4) &gt; 0)">
 980       <xsl:call-template name="chunk">
 981         <xsl:with-param name="node" select="$node/parent::*"/>
 982       </xsl:call-template>
 983     </xsl:when>
 984     <xsl:when test="local-name($node) = 'sect5'
 985                     and $chunk.section.depth &gt;= 5
 986                     and ($chunk.first.sections != 0
 987                          or count($node/preceding-sibling::sect5) &gt; 0)">
 988       <xsl:call-template name="chunk">
 989         <xsl:with-param name="node" select="$node/parent::*"/>
 990       </xsl:call-template>
 991     </xsl:when>
 992     <xsl:when test="local-name($node) = 'section'
 993                     and $chunk.section.depth &gt;= count($node/ancestor::section)+1
 994                     and ($chunk.first.sections != 0
 995                          or count($node/preceding-sibling::section) &gt; 0)">
 996       <xsl:call-template name="chunk">
 997         <xsl:with-param name="node" select="$node/parent::*"/>
 998       </xsl:call-template>
 999     </xsl:when>
1000
1001     <xsl:when test="local-name($node)='preface'">1</xsl:when>
1002     <xsl:when test="local-name($node)='chapter'">1</xsl:when>
1003     <xsl:when test="local-name($node)='appendix'">1</xsl:when>
1004     <xsl:when test="local-name($node)='article'">1</xsl:when>
1005     <xsl:when test="local-name($node)='part'">1</xsl:when>
1006     <xsl:when test="local-name($node)='reference'">1</xsl:when>
1007     <xsl:when test="local-name($node)='refentry'">1</xsl:when>
1008     <xsl:when test="local-name($node)='index' and ($generate.index != 0 or count($node/*) > 0)
1009                     and (local-name($node/parent::*) = 'article'
1010                     or local-name($node/parent::*) = 'book'
1011                     or local-name($node/parent::*) = 'part'
1012                     )">1</xsl:when>
1013     <xsl:when test="local-name($node)='bibliography'
1014                     and (local-name($node/parent::*) = 'article'
1015                     or local-name($node/parent::*) = 'book'
1016                     or local-name($node/parent::*) = 'part'
1017                     )">1</xsl:when>
1018     <xsl:when test="local-name($node)='glossary'
1019                     and (local-name($node/parent::*) = 'article'
1020                     or local-name($node/parent::*) = 'book'
1021                     or local-name($node/parent::*) = 'part'
1022                     )">1</xsl:when>
1023     <xsl:when test="local-name($node)='colophon'">1</xsl:when>
1024     <xsl:when test="local-name($node)='book'">1</xsl:when>
1025     <xsl:when test="local-name($node)='set'">1</xsl:when>
1026     <xsl:when test="local-name($node)='setindex'">1</xsl:when>
1027     <xsl:when test="local-name($node)='legalnotice'
1028                     and $generate.legalnotice.link != 0">1</xsl:when>
1029     <xsl:otherwise>0</xsl:otherwise>
1030   </xsl:choose>
1031 </xsl:template>
1032
1033 <!-- ==================================================================== -->
1034 <xsl:template name="href.target.uri">
1035   <xsl:param name="object" select="."/>
1036   <xsl:variable name="ischunk">
1037     <xsl:call-template name="chunk">
1038       <xsl:with-param name="node" select="$object"/>
1039     </xsl:call-template>
1040   </xsl:variable>
1041
1042   <xsl:apply-templates mode="chunk-filename" select="$object"/>
1043
1044   <xsl:if test="$ischunk='0'">
1045     <xsl:text>#</xsl:text>
1046     <xsl:call-template name="object.id">
1047       <xsl:with-param name="object" select="$object"/>
1048     </xsl:call-template>
1049   </xsl:if>
1050 </xsl:template>
1051
1052 <xsl:template name="href.target">
1053   <xsl:param name="context" select="."/>
1054   <xsl:param name="object" select="."/>
1055   <xsl:param name="toc-context" select="."/>
1056   <!-- * If $toc-context contains some node other than the current node, -->
1057   <!-- * it means we're processing a link in a TOC. In that case, to -->
1058   <!-- * ensure the link will work correctly, we need to take a look at -->
1059   <!-- * where the file containing the TOC will get written, and where -->
1060   <!-- * the file that's being linked to will get written. -->
1061   <xsl:variable name="toc-output-dir">
1062     <xsl:if test="not($toc-context = .)">
1063       <!-- * Get the $toc-context node and all its ancestors, look down -->
1064       <!-- * through them to find the last/closest node to the -->
1065       <!-- * toc-context node that has a "dbhtml dir" PI, and get the -->
1066       <!-- * directory name from that. That's the name of the directory -->
1067       <!-- * to which the current toc output file will get written. -->
1068       <xsl:call-template name="dbhtml-dir">
1069         <xsl:with-param name="context"
1070           select="$toc-context/ancestor-or-self::*[processing-instruction('dbhtml')[contains(.,'dir')]][last()]"/>
1071       </xsl:call-template>
1072     </xsl:if>
1073   </xsl:variable>
1074   <xsl:variable name="linked-file-output-dir">
1075     <xsl:if test="not($toc-context = .)">
1076       <!-- * Get the current node and all its ancestors, look down -->
1077       <!-- * through them to find the last/closest node to the current -->
1078       <!-- * node that has a "dbhtml dir" PI, and get the directory name -->
1079       <!-- * from that.  That's the name of the directory to which the -->
1080       <!-- * file that's being linked to will get written. -->
1081       <xsl:call-template name="dbhtml-dir">
1082         <xsl:with-param name="context"
1083           select="ancestor-or-self::*[processing-instruction('dbhtml')[contains(.,'dir')]][last()]"/>
1084       </xsl:call-template>
1085     </xsl:if>
1086   </xsl:variable>
1087   <xsl:variable name="href.to.uri">
1088     <xsl:call-template name="href.target.uri">
1089       <xsl:with-param name="object" select="$object"/>
1090     </xsl:call-template>
1091   </xsl:variable>
1092   <xsl:variable name="href.from.uri">
1093     <xsl:choose>
1094       <xsl:when test="not($toc-context = .)">
1095         <xsl:call-template name="href.target.uri">
1096           <xsl:with-param name="object" select="$toc-context"/>
1097         </xsl:call-template>
1098       </xsl:when>
1099       <xsl:otherwise>
1100         <xsl:call-template name="href.target.uri">
1101           <xsl:with-param name="object" select="$context"/>
1102         </xsl:call-template>
1103       </xsl:otherwise>
1104     </xsl:choose>
1105   </xsl:variable>
1106   <!-- * <xsl:message>toc-context: <xsl:value-of select="local-name($toc-context)"/></xsl:message> -->
1107   <!-- * <xsl:message>node: <xsl:value-of select="local-name(.)"/></xsl:message> -->
1108   <!-- * <xsl:message>context: <xsl:value-of select="local-name($context)"/></xsl:message> -->
1109   <!-- * <xsl:message>object: <xsl:value-of select="local-name($object)"/></xsl:message> -->
1110   <!-- * <xsl:message>toc-output-dir: <xsl:value-of select="$toc-output-dir"/></xsl:message> -->
1111   <!-- * <xsl:message>linked-file-output-dir: <xsl:value-of select="$linked-file-output-dir"/></xsl:message> -->
1112   <!-- * <xsl:message>href.to.uri: <xsl:value-of select="$href.to.uri"/></xsl:message> -->
1113   <!-- * <xsl:message>href.from.uri: <xsl:value-of select="$href.from.uri"/></xsl:message> -->
1114   <xsl:variable name="href.to">
1115     <xsl:choose>
1116       <!-- * 2007-07-19, MikeSmith: Added the following conditional to -->
1117       <!-- * deal with a problem case for links in TOCs. It checks to see -->
1118       <!-- * if the output dir that a TOC will get written to is -->
1119       <!-- * different from the output dir of the file being linked to. -->
1120       <!-- * If it is different, we do not call trim.common.uri.paths. -->
1121       <!-- *  -->
1122       <!-- * Reason why I added that conditional is: I ran into a bug for -->
1123       <!-- * this case: -->
1124       <!-- *  -->
1125       <!-- * 1. we are chunking into separate dirs -->
1126       <!-- *  -->
1127       <!-- * 2. output for the TOC is written to current dir, but the file -->
1128       <!-- *    being linked to is written to some subdir "foo". -->
1129       <!-- *  -->
1130       <!-- * For that case, links to that file in that TOC did not show -->
1131       <!-- * the correct path - they omitted the "foo". -->
1132       <!-- *  -->
1133       <!-- * The cause of that problem was that the trim.common.uri.paths -->
1134       <!-- * template[1] was being called under all conditions. But it's -->
1135       <!-- * apparent that we don't want to call trim.common.uri.paths in -->
1136       <!-- * the case where a linked file is being written to a different -->
1137       <!-- * directory than the TOC that contains the link, because doing -->
1138       <!-- * so will cause a necessary (not redundant) directory-name -->
1139       <!-- * part of the link to get inadvertently trimmed, resulting in -->
1140       <!-- * a broken link to that file. Thus, added the conditional. -->
1141       <!-- *  -->
1142       <!-- * [1] The purpose of the trim.common.uri.paths template is to -->
1143       <!-- * prevent cases where, if we didn't call it, we end up with -->
1144       <!-- * unnecessary, redundant directory names getting output; for -->
1145       <!-- * example, "foo/foo/refname.html". -->
1146       <xsl:when test="not($toc-output-dir = $linked-file-output-dir)">
1147         <xsl:value-of select="$href.to.uri"/>
1148       </xsl:when>
1149       <xsl:otherwise>
1150         <xsl:call-template name="trim.common.uri.paths">
1151           <xsl:with-param name="uriA" select="$href.to.uri"/>
1152           <xsl:with-param name="uriB" select="$href.from.uri"/>
1153           <xsl:with-param name="return" select="'A'"/>
1154         </xsl:call-template>
1155       </xsl:otherwise>
1156     </xsl:choose>
1157   </xsl:variable>
1158   <xsl:variable name="href.from">
1159     <xsl:call-template name="trim.common.uri.paths">
1160       <xsl:with-param name="uriA" select="$href.to.uri"/>
1161       <xsl:with-param name="uriB" select="$href.from.uri"/>
1162       <xsl:with-param name="return" select="'B'"/>
1163     </xsl:call-template>
1164   </xsl:variable>
1165   <xsl:variable name="depth">
1166     <xsl:call-template name="count.uri.path.depth">
1167       <xsl:with-param name="filename" select="$href.from"/>
1168     </xsl:call-template>
1169   </xsl:variable>
1170   <xsl:variable name="href">
1171     <xsl:call-template name="copy-string">
1172       <xsl:with-param name="string" select="'../'"/>
1173       <xsl:with-param name="count" select="$depth"/>
1174     </xsl:call-template>
1175     <xsl:value-of select="$href.to"/>
1176   </xsl:variable>
1177   <!--
1178   <xsl:message>
1179     <xsl:text>In </xsl:text>
1180     <xsl:value-of select="name(.)"/>
1181     <xsl:text> (</xsl:text>
1182     <xsl:value-of select="$href.from"/>
1183     <xsl:text>,</xsl:text>
1184     <xsl:value-of select="$depth"/>
1185     <xsl:text>) </xsl:text>
1186     <xsl:value-of select="name($object)"/>
1187     <xsl:text> href=</xsl:text>
1188     <xsl:value-of select="$href"/>
1189   </xsl:message>
1190   -->
1191   <xsl:value-of select="$href"/>
1192 </xsl:template>
1193
1194 <!-- Returns the complete olink href value if found -->
1195 <!-- Must take into account any dbhtml dir of the chunk containing the olink -->
1196 <xsl:template name="make.olink.href">
1197   <xsl:param name="olink.key" select="''"/>
1198   <xsl:param name="target.database"/>
1199
1200   <xsl:if test="$olink.key != ''">
1201     <xsl:variable name="target.href" >
1202       <xsl:for-each select="$target.database" >
1203         <xsl:value-of select="key('targetptr-key', $olink.key)[1]/@href" />
1204       </xsl:for-each>
1205     </xsl:variable>
1206
1207     <!-- an olink starting point may be in a subdirectory, so need
1208          the "from" reference point to compute a relative path -->
1209
1210     <xsl:variable name="from.href">
1211       <xsl:call-template name="olink.from.uri">
1212         <xsl:with-param name="target.database" select="$target.database"/>
1213         <xsl:with-param name="object" select="."/>
1214         <xsl:with-param name="object.targetdoc" select="$current.docid"/>
1215       </xsl:call-template>
1216     </xsl:variable>
1217
1218     <!-- If the from.href has directory path, then must "../" upward
1219          to document level -->
1220     <xsl:variable name="upward.from.path">
1221       <xsl:call-template name="upward.path">
1222         <xsl:with-param name="path" select="$from.href"/>
1223       </xsl:call-template>
1224     </xsl:variable>
1225
1226     <xsl:variable name="targetdoc">
1227       <xsl:value-of select="substring-before($olink.key, '/')"/>
1228     </xsl:variable>
1229
1230     <!-- Does the target database use a sitemap? -->
1231     <xsl:variable name="use.sitemap">
1232       <xsl:choose>
1233         <xsl:when test="$target.database//sitemap">1</xsl:when>
1234         <xsl:otherwise>0</xsl:otherwise>
1235       </xsl:choose>
1236     </xsl:variable>
1237
1238
1239     <!-- Get the baseuri for this targetptr -->
1240     <xsl:variable name="baseuri" >
1241       <xsl:choose>
1242         <!-- Does the database use a sitemap? -->
1243         <xsl:when test="$use.sitemap != 0" >
1244           <xsl:choose>
1245             <!-- Was current.docid parameter set? -->
1246             <xsl:when test="$current.docid != ''">
1247               <!-- Was it found in the database? -->
1248               <xsl:variable name="currentdoc.key" >
1249                 <xsl:for-each select="$target.database" >
1250                   <xsl:value-of select="key('targetdoc-key',
1251                                         $current.docid)/@targetdoc" />
1252                 </xsl:for-each>
1253               </xsl:variable>
1254               <xsl:choose>
1255                 <xsl:when test="$currentdoc.key != ''">
1256                   <xsl:for-each select="$target.database" >
1257                     <xsl:call-template name="targetpath" >
1258                       <xsl:with-param name="dirnode"
1259                           select="key('targetdoc-key', $current.docid)/parent::dir"/>
1260                       <xsl:with-param name="targetdoc" select="$targetdoc"/>
1261                     </xsl:call-template>
1262                   </xsl:for-each >
1263                 </xsl:when>
1264                 <xsl:otherwise>
1265                   <xsl:message>
1266                     <xsl:text>Olink error: cannot compute relative </xsl:text>
1267                     <xsl:text>sitemap path because $current.docid '</xsl:text>
1268                     <xsl:value-of select="$current.docid"/>
1269                     <xsl:text>' not found in target database.</xsl:text>
1270                   </xsl:message>
1271                 </xsl:otherwise>
1272               </xsl:choose>
1273             </xsl:when>
1274             <xsl:otherwise>
1275               <xsl:message>
1276                 <xsl:text>Olink warning: cannot compute relative </xsl:text>
1277                 <xsl:text>sitemap path without $current.docid parameter</xsl:text>
1278               </xsl:message>
1279             </xsl:otherwise>
1280           </xsl:choose>
1281           <!-- In either case, add baseuri from its document entry-->
1282           <xsl:variable name="docbaseuri">
1283             <xsl:for-each select="$target.database" >
1284               <xsl:value-of select="key('targetdoc-key', $targetdoc)/@baseuri" />
1285             </xsl:for-each>
1286           </xsl:variable>
1287           <xsl:if test="$docbaseuri != ''" >
1288             <xsl:value-of select="$docbaseuri"/>
1289           </xsl:if>
1290         </xsl:when>
1291         <!-- No database sitemap in use -->
1292         <xsl:otherwise>
1293           <!-- Just use any baseuri from its document entry -->
1294           <xsl:variable name="docbaseuri">
1295             <xsl:for-each select="$target.database" >
1296               <xsl:value-of select="key('targetdoc-key', $targetdoc)/@baseuri" />
1297             </xsl:for-each>
1298           </xsl:variable>
1299           <xsl:if test="$docbaseuri != ''" >
1300             <xsl:value-of select="$docbaseuri"/>
1301           </xsl:if>
1302         </xsl:otherwise>
1303       </xsl:choose>
1304     </xsl:variable>
1305
1306     <!-- Form the href information -->
1307     <xsl:if test="not(contains($baseuri, ':'))">
1308       <!-- if not an absolute uri, add upward path from olink chunk -->
1309       <xsl:value-of select="$upward.from.path"/>
1310     </xsl:if>
1311
1312     <xsl:if test="$baseuri != ''">
1313       <xsl:value-of select="$baseuri"/>
1314       <xsl:if test="substring($target.href,1,1) != '#'">
1315         <!--xsl:text>/</xsl:text-->
1316       </xsl:if>
1317     </xsl:if>
1318     <!-- optionally turn off frag for PDF references -->
1319     <xsl:if test="not($insert.olink.pdf.frag = 0 and
1320           translate(substring($baseuri, string-length($baseuri) - 3),
1321                     'PDF', 'pdf') = '.pdf'
1322           and starts-with($target.href, '#') )">
1323       <xsl:value-of select="$target.href"/>
1324     </xsl:if>
1325   </xsl:if>
1326 </xsl:template>
1327
1328 <!-- Computes "../" to reach top -->
1329 <xsl:template name="upward.path">
1330   <xsl:param name="path" select="''"/>
1331   <xsl:choose>
1332     <!-- Don't bother with absolute uris -->
1333     <xsl:when test="contains($path, ':')"/>
1334     <xsl:when test="starts-with($path, '/')"/>
1335     <xsl:when test="contains($path, '/')">
1336       <xsl:text>../</xsl:text>
1337       <xsl:call-template name="upward.path">
1338         <xsl:with-param name="path" select="substring-after($path, '/')"/>
1339       </xsl:call-template>
1340     </xsl:when>
1341   </xsl:choose>
1342
1343 </xsl:template>
1344
1345 <!-- ==================================================================== -->
1346
1347 <xsl:template name="html.head">
1348   <xsl:param name="prev" select="/foo"/>
1349   <xsl:param name="next" select="/foo"/>
1350   <xsl:variable name="this" select="."/>
1351   <xsl:variable name="home" select="/*[1]"/>
1352   <xsl:variable name="up" select="parent::*"/>
1353
1354   <head>
1355     <xsl:call-template name="system.head.content"/>
1356     <xsl:call-template name="head.content"/>
1357
1358     <xsl:if test="$home">
1359       <link rel="home">
1360         <xsl:attribute name="href">
1361           <xsl:call-template name="href.target">
1362             <xsl:with-param name="object" select="$home"/>
1363           </xsl:call-template>
1364         </xsl:attribute>
1365         <xsl:attribute name="title">
1366           <xsl:apply-templates select="$home"
1367                                mode="object.title.markup.textonly"/>
1368         </xsl:attribute>
1369       </link>
1370     </xsl:if>
1371
1372     <xsl:if test="$up">
1373       <link rel="up">
1374         <xsl:attribute name="href">
1375           <xsl:call-template name="href.target">
1376             <xsl:with-param name="object" select="$up"/>
1377           </xsl:call-template>
1378         </xsl:attribute>
1379         <xsl:attribute name="title">
1380           <xsl:apply-templates select="$up" mode="object.title.markup.textonly"/>
1381         </xsl:attribute>
1382       </link>
1383     </xsl:if>
1384
1385     <xsl:if test="$prev">
1386       <link rel="prev">
1387         <xsl:attribute name="href">
1388           <xsl:call-template name="href.target">
1389             <xsl:with-param name="object" select="$prev"/>
1390           </xsl:call-template>
1391         </xsl:attribute>
1392         <xsl:attribute name="title">
1393           <xsl:apply-templates select="$prev" mode="object.title.markup.textonly"/>
1394         </xsl:attribute>
1395       </link>
1396     </xsl:if>
1397
1398     <xsl:if test="$next">
1399       <link rel="next">
1400         <xsl:attribute name="href">
1401           <xsl:call-template name="href.target">
1402             <xsl:with-param name="object" select="$next"/>
1403           </xsl:call-template>
1404         </xsl:attribute>
1405         <xsl:attribute name="title">
1406           <xsl:apply-templates select="$next" mode="object.title.markup.textonly"/>
1407         </xsl:attribute>
1408       </link>
1409     </xsl:if>
1410
1411     <xsl:if test="$html.extra.head.links != 0">
1412       <xsl:for-each select="//part
1413                             |//reference
1414                             |//preface
1415                             |//chapter
1416                             |//article
1417                             |//refentry
1418                             |//appendix[not(parent::article)]|appendix
1419                             |//glossary[not(parent::article)]|glossary
1420                             |//index[not(parent::article)]|index">
1421         <link rel="{local-name(.)}">
1422           <xsl:attribute name="href">
1423             <xsl:call-template name="href.target">
1424               <xsl:with-param name="context" select="$this"/>
1425               <xsl:with-param name="object" select="."/>
1426             </xsl:call-template>
1427           </xsl:attribute>
1428           <xsl:attribute name="title">
1429             <xsl:apply-templates select="." mode="object.title.markup.textonly"/>
1430           </xsl:attribute>
1431         </link>
1432       </xsl:for-each>
1433
1434       <xsl:for-each select="section|sect1|refsection|refsect1">
1435         <link>
1436           <xsl:attribute name="rel">
1437             <xsl:choose>
1438               <xsl:when test="local-name($this) = 'section'
1439                               or local-name($this) = 'refsection'">
1440                 <xsl:value-of select="'subsection'"/>
1441               </xsl:when>
1442               <xsl:otherwise>
1443                 <xsl:value-of select="'section'"/>
1444               </xsl:otherwise>
1445             </xsl:choose>
1446           </xsl:attribute>
1447           <xsl:attribute name="href">
1448             <xsl:call-template name="href.target">
1449               <xsl:with-param name="context" select="$this"/>
1450               <xsl:with-param name="object" select="."/>
1451             </xsl:call-template>
1452           </xsl:attribute>
1453           <xsl:attribute name="title">
1454             <xsl:apply-templates select="." mode="object.title.markup.textonly"/>
1455           </xsl:attribute>
1456         </link>
1457       </xsl:for-each>
1458
1459       <xsl:for-each select="sect2|sect3|sect4|sect5|refsect2|refsect3">
1460         <link rel="subsection">
1461           <xsl:attribute name="href">
1462             <xsl:call-template name="href.target">
1463               <xsl:with-param name="context" select="$this"/>
1464               <xsl:with-param name="object" select="."/>
1465             </xsl:call-template>
1466           </xsl:attribute>
1467           <xsl:attribute name="title">
1468             <xsl:apply-templates select="." mode="object.title.markup.textonly"/>
1469           </xsl:attribute>
1470         </link>
1471       </xsl:for-each>
1472     </xsl:if>
1473
1474     <!-- * if we have a legalnotice and user wants it output as a -->
1475     <!-- * separate page and $html.head.legalnotice.link.types is -->
1476     <!-- * non-empty, we generate a link or links for each value in -->
1477     <!-- * $html.head.legalnotice.link.types -->
1478     <xsl:if test="//legalnotice
1479                   and not($generate.legalnotice.link = 0)
1480                   and not($html.head.legalnotice.link.types = '')">
1481       <xsl:call-template name="make.legalnotice.head.links"/>
1482     </xsl:if>
1483
1484     <xsl:call-template name="user.head.content"/>
1485   </head>
1486 </xsl:template>
1487
1488 <!-- ==================================================================== -->
1489
1490 <xsl:template name="header.navigation">
1491   <xsl:param name="prev" select="/foo"/>
1492   <xsl:param name="next" select="/foo"/>
1493   <xsl:param name="nav.context"/>
1494
1495   <xsl:variable name="home" select="/*[1]"/>
1496   <xsl:variable name="up" select="parent::*"/>
1497
1498   <xsl:variable name="row1" select="$navig.showtitles != 0"/>
1499   <xsl:variable name="row2" select="count($prev) &gt; 0
1500                                     or (count($up) &gt; 0
1501                                         and generate-id($up) != generate-id($home)
1502                                         and $navig.showtitles != 0)
1503                                     or count($next) &gt; 0"/>
1504
1505   <xsl:if test="$suppress.navigation = '0' and $suppress.header.navigation = '0'">
1506     <div class="navheader">
1507       <xsl:if test="$row1 or $row2">
1508         <table width="100%" summary="Navigation header">
1509           <xsl:if test="$row1">
1510             <tr>
1511               <th colspan="3" align="center">
1512                 <xsl:apply-templates select="." mode="object.title.markup"/>
1513               </th>
1514             </tr>
1515           </xsl:if>
1516
1517           <xsl:if test="$row2">
1518             <tr>
1519               <td width="20%" align="{$direction.align.start}">
1520                 <xsl:if test="count($prev)>0">
1521                   <a accesskey="p">
1522                     <xsl:attribute name="href">
1523                       <xsl:call-template name="href.target">
1524                         <xsl:with-param name="object" select="$prev"/>
1525                       </xsl:call-template>
1526                     </xsl:attribute>
1527                     <xsl:call-template name="navig.content">
1528                       <xsl:with-param name="direction" select="'prev'"/>
1529                     </xsl:call-template>
1530                   </a>
1531                 </xsl:if>
1532                 <xsl:text>&#160;</xsl:text>
1533               </td>
1534               <th width="60%" align="center">
1535                 <xsl:choose>
1536                   <xsl:when test="count($up) > 0
1537                                   and generate-id($up) != generate-id($home)
1538                                   and $navig.showtitles != 0">
1539                     <xsl:apply-templates select="$up" mode="object.title.markup"/>
1540                   </xsl:when>
1541                   <xsl:otherwise>&#160;</xsl:otherwise>
1542                 </xsl:choose>
1543               </th>
1544               <td width="20%" align="{$direction.align.end}">
1545                 <xsl:text>&#160;</xsl:text>
1546                 <xsl:if test="count($next)>0">
1547                   <a accesskey="n">
1548                     <xsl:attribute name="href">
1549                       <xsl:call-template name="href.target">
1550                         <xsl:with-param name="object" select="$next"/>
1551                       </xsl:call-template>
1552                     </xsl:attribute>
1553                     <xsl:call-template name="navig.content">
1554                       <xsl:with-param name="direction" select="'next'"/>
1555                     </xsl:call-template>
1556                   </a>
1557                 </xsl:if>
1558               </td>
1559             </tr>
1560           </xsl:if>
1561         </table>
1562       </xsl:if>
1563       <xsl:if test="$header.rule != 0">
1564         <hr/>
1565       </xsl:if>
1566     </div>
1567   </xsl:if>
1568 </xsl:template>
1569
1570 <!-- ==================================================================== -->
1571
1572 <xsl:template name="footer.navigation">
1573   <xsl:param name="prev" select="/foo"/>
1574   <xsl:param name="next" select="/foo"/>
1575   <xsl:param name="nav.context"/>
1576
1577   <xsl:variable name="home" select="/*[1]"/>
1578   <xsl:variable name="up" select="parent::*"/>
1579
1580   <xsl:variable name="row1" select="count($prev) &gt; 0
1581                                     or count($up) &gt; 0
1582                                     or count($next) &gt; 0"/>
1583
1584   <xsl:variable name="row2" select="($prev and $navig.showtitles != 0)
1585                                     or (generate-id($home) != generate-id(.)
1586                                         or $nav.context = 'toc')
1587                                     or ($chunk.tocs.and.lots != 0
1588                                         and $nav.context != 'toc')
1589                                     or ($next and $navig.showtitles != 0)"/>
1590
1591   <xsl:if test="$suppress.navigation = '0' and $suppress.footer.navigation = '0'">
1592     <div class="navfooter">
1593       <xsl:if test="$footer.rule != 0">
1594         <hr/>
1595       </xsl:if>
1596
1597       <xsl:if test="$row1 or $row2">
1598         <table width="100%" summary="Navigation footer">
1599           <xsl:if test="$row1">
1600             <tr>
1601               <td width="40%" align="{$direction.align.start}">
1602                 <xsl:if test="count($prev)>0">
1603                   <a accesskey="p">
1604                     <xsl:attribute name="href">
1605                       <xsl:call-template name="href.target">
1606                         <xsl:with-param name="object" select="$prev"/>
1607                       </xsl:call-template>
1608                     </xsl:attribute>
1609                     <xsl:call-template name="navig.content">
1610                       <xsl:with-param name="direction" select="'prev'"/>
1611                     </xsl:call-template>
1612                   </a>
1613                 </xsl:if>
1614                 <xsl:text>&#160;</xsl:text>
1615               </td>
1616               <td width="20%" align="center">
1617                 <xsl:choose>
1618                   <xsl:when test="count($up)&gt;0
1619                                   and generate-id($up) != generate-id($home)">
1620                     <a accesskey="u">
1621                       <xsl:attribute name="href">
1622                         <xsl:call-template name="href.target">
1623                           <xsl:with-param name="object" select="$up"/>
1624                         </xsl:call-template>
1625                       </xsl:attribute>
1626                       <xsl:call-template name="navig.content">
1627                         <xsl:with-param name="direction" select="'up'"/>
1628                       </xsl:call-template>
1629                     </a>
1630                   </xsl:when>
1631                   <xsl:otherwise>&#160;</xsl:otherwise>
1632                 </xsl:choose>
1633               </td>
1634               <td width="40%" align="{$direction.align.end}">
1635                 <xsl:text>&#160;</xsl:text>
1636                 <xsl:if test="count($next)>0">
1637                   <a accesskey="n">
1638                     <xsl:attribute name="href">
1639                       <xsl:call-template name="href.target">
1640                         <xsl:with-param name="object" select="$next"/>
1641                       </xsl:call-template>
1642                     </xsl:attribute>
1643                     <xsl:call-template name="navig.content">
1644                       <xsl:with-param name="direction" select="'next'"/>
1645                     </xsl:call-template>
1646                   </a>
1647                 </xsl:if>
1648               </td>
1649             </tr>
1650           </xsl:if>
1651
1652           <xsl:if test="$row2">
1653             <tr>
1654               <td width="40%" align="{$direction.align.start}" valign="top">
1655                 <xsl:if test="$navig.showtitles != 0">
1656                   <xsl:apply-templates select="$prev" mode="object.title.markup"/>
1657                 </xsl:if>
1658                 <xsl:text>&#160;</xsl:text>
1659               </td>
1660               <td width="20%" align="center">
1661                 <xsl:choose>
1662                   <xsl:when test="$home != . or $nav.context = 'toc'">
1663                     <a accesskey="h">
1664                       <xsl:attribute name="href">
1665                         <xsl:call-template name="href.target">
1666                           <xsl:with-param name="object" select="$home"/>
1667                         </xsl:call-template>
1668                       </xsl:attribute>
1669                       <xsl:call-template name="navig.content">
1670                         <xsl:with-param name="direction" select="'home'"/>
1671                       </xsl:call-template>
1672                     </a>
1673                     <xsl:if test="$chunk.tocs.and.lots != 0 and $nav.context != 'toc'">
1674                       <xsl:text>&#160;|&#160;</xsl:text>
1675                     </xsl:if>
1676                   </xsl:when>
1677                   <xsl:otherwise>&#160;</xsl:otherwise>
1678                 </xsl:choose>
1679
1680                 <xsl:if test="$chunk.tocs.and.lots != 0 and $nav.context != 'toc'">
1681                   <a accesskey="t">
1682                     <xsl:attribute name="href">
1683                       <xsl:apply-templates select="/*[1]"
1684                                            mode="recursive-chunk-filename">
1685                         <xsl:with-param name="recursive" select="true()"/>
1686                       </xsl:apply-templates>
1687                       <xsl:text>-toc</xsl:text>
1688                       <xsl:value-of select="$html.ext"/>
1689                     </xsl:attribute>
1690                     <xsl:call-template name="gentext">
1691                       <xsl:with-param name="key" select="'nav-toc'"/>
1692                     </xsl:call-template>
1693                   </a>
1694                 </xsl:if>
1695               </td>
1696               <td width="40%" align="{$direction.align.end}" valign="top">
1697                 <xsl:text>&#160;</xsl:text>
1698                 <xsl:if test="$navig.showtitles != 0">
1699                   <xsl:apply-templates select="$next" mode="object.title.markup"/>
1700                 </xsl:if>
1701               </td>
1702             </tr>
1703           </xsl:if>
1704         </table>
1705       </xsl:if>
1706     </div>
1707   </xsl:if>
1708 </xsl:template>
1709
1710 <!-- ==================================================================== -->
1711
1712 <xsl:template name="navig.content">
1713     <xsl:param name="direction" select="next"/>
1714     <xsl:variable name="navtext">
1715         <xsl:choose>
1716             <xsl:when test="$direction = 'prev'">
1717                 <xsl:call-template name="gentext.nav.prev"/>
1718             </xsl:when>
1719             <xsl:when test="$direction = 'next'">
1720                 <xsl:call-template name="gentext.nav.next"/>
1721             </xsl:when>
1722             <xsl:when test="$direction = 'up'">
1723                 <xsl:call-template name="gentext.nav.up"/>
1724             </xsl:when>
1725             <xsl:when test="$direction = 'home'">
1726                 <xsl:call-template name="gentext.nav.home"/>
1727             </xsl:when>
1728             <xsl:otherwise>
1729                 <xsl:text>xxx</xsl:text>
1730             </xsl:otherwise>
1731         </xsl:choose>
1732     </xsl:variable>
1733
1734     <xsl:choose>
1735         <xsl:when test="$navig.graphics != 0">
1736             <img>
1737                 <xsl:attribute name="src">
1738                     <xsl:value-of select="$navig.graphics.path"/>
1739                     <xsl:value-of select="$direction"/>
1740                     <xsl:value-of select="$navig.graphics.extension"/>
1741                 </xsl:attribute>
1742                 <xsl:attribute name="alt">
1743                     <xsl:value-of select="$navtext"/>
1744                 </xsl:attribute>
1745             </img>
1746         </xsl:when>
1747         <xsl:otherwise>
1748             <xsl:value-of select="$navtext"/>
1749         </xsl:otherwise>
1750     </xsl:choose>
1751 </xsl:template>
1752
1753 <!-- ==================================================================== -->
1754
1755 <!-- * The following template assumes that the first legalnotice -->
1756 <!-- * instance found in a document applies to the contents of the -->
1757 <!-- * entire document. It generates an HTML link in each chunk, back -->
1758 <!-- * to the file containing the contents of the first legalnotice. -->
1759 <!-- * -->
1760 <!-- * Actually, it may generate multiple link instances in each chunk, -->
1761 <!-- * because it walks through the space-separated list of link -->
1762 <!-- * types specified in the $html.head.legalnotice.link.types param, -->
1763 <!-- * popping off link types and generating links for them until it -->
1764 <!-- * depletes the list. -->
1765
1766 <xsl:template name="make.legalnotice.head.links">
1767   <!-- * the following ID is used as part of the legalnotice filename; -->
1768   <!-- * we need it in order to construct the filename for use in the -->
1769   <!-- * value of the href attribute on the link -->
1770
1771   <xsl:param name="ln-node" select="(//legalnotice)[1]"/>
1772
1773   <xsl:param name="linktype">
1774     <xsl:choose>
1775       <xsl:when test="contains($html.head.legalnotice.link.types, ' ')">
1776         <xsl:value-of
1777             select="normalize-space(
1778                     substring-before($html.head.legalnotice.link.types, ' '))"/>
1779       </xsl:when>
1780       <xsl:otherwise>
1781         <xsl:value-of select="$html.head.legalnotice.link.types"/>
1782       </xsl:otherwise>
1783     </xsl:choose>
1784   </xsl:param>
1785   <xsl:param
1786       name="remaining.linktypes"
1787       select="concat(
1788               normalize-space(
1789               substring-after($html.head.legalnotice.link.types, ' ')),' ')"/>
1790   <xsl:if test="not($linktype = '')">
1791
1792     <!-- Compute name of legalnotice file (see titlepage.xsl) -->
1793     <xsl:variable name="file">
1794       <xsl:call-template name="ln.or.rh.filename">
1795         <xsl:with-param name="node" select="$ln-node"/>
1796       </xsl:call-template>
1797     </xsl:variable>
1798
1799     <link rel="{$linktype}">
1800       <xsl:attribute name="href">
1801         <xsl:value-of select="$file"/>
1802       </xsl:attribute>
1803       <xsl:attribute name="title">
1804         <xsl:apply-templates select="(//legalnotice)[1]"
1805                              mode="object.title.markup.textonly"/>
1806       </xsl:attribute>
1807     </link>
1808     <xsl:call-template name="make.legalnotice.head.links">
1809       <!-- * pop the next value off the list of link types -->
1810       <xsl:with-param
1811           name="linktype"
1812           select="substring-before($remaining.linktypes, ' ')"/>
1813       <!-- * remove the link type from the list of remaining link types -->
1814       <xsl:with-param
1815           name="remaining.linktypes"
1816           select="substring-after($remaining.linktypes, ' ')"/>
1817     </xsl:call-template>
1818   </xsl:if>
1819 </xsl:template>
1820
1821 <!-- ==================================================================== -->
1822 <xsl:template name="chunk-element-content">
1823   <xsl:param name="prev"/>
1824   <xsl:param name="next"/>
1825   <xsl:param name="nav.context"/>
1826   <xsl:param name="content">
1827     <xsl:apply-imports/>
1828   </xsl:param>
1829
1830   <xsl:call-template name="user.preroot"/>
1831
1832   <html>
1833     <xsl:call-template name="html.head">
1834       <xsl:with-param name="prev" select="$prev"/>
1835       <xsl:with-param name="next" select="$next"/>
1836     </xsl:call-template>
1837
1838     <body>
1839       <xsl:call-template name="body.attributes"/>
1840       <xsl:call-template name="user.header.navigation"/>
1841
1842       <xsl:call-template name="header.navigation">
1843         <xsl:with-param name="prev" select="$prev"/>
1844         <xsl:with-param name="next" select="$next"/>
1845         <xsl:with-param name="nav.context" select="$nav.context"/>
1846       </xsl:call-template>
1847
1848       <xsl:call-template name="user.header.content"/>
1849
1850       <xsl:copy-of select="$content"/>
1851
1852       <xsl:call-template name="user.footer.content"/>
1853
1854       <xsl:call-template name="footer.navigation">
1855         <xsl:with-param name="prev" select="$prev"/>
1856         <xsl:with-param name="next" select="$next"/>
1857         <xsl:with-param name="nav.context" select="$nav.context"/>
1858       </xsl:call-template>
1859
1860       <xsl:call-template name="user.footer.navigation"/>
1861     </body>
1862   </html>
1863   <xsl:value-of select="$chunk.append"/>
1864 </xsl:template>
1865
1866 <!-- ==================================================================== -->
1867 <xsl:template name="generate.manifest">
1868   <xsl:param name="node" select="/"/>
1869   <xsl:call-template name="write.text.chunk">
1870     <xsl:with-param name="filename">
1871       <xsl:if test="$manifest.in.base.dir != 0">
1872         <xsl:value-of select="$base.dir"/>
1873       </xsl:if>
1874       <xsl:value-of select="$manifest"/>
1875     </xsl:with-param>
1876     <xsl:with-param name="method" select="'text'"/>
1877     <xsl:with-param name="content">
1878       <xsl:apply-templates select="$node" mode="enumerate-files"/>
1879     </xsl:with-param>
1880     <xsl:with-param name="encoding" select="$chunker.output.encoding"/>
1881   </xsl:call-template>
1882 </xsl:template>
1883
1884 <!-- ==================================================================== -->
1885
1886 <xsl:template name="dbhtml-dir">
1887   <xsl:param name="context" select="."/>
1888   <!-- directories are now inherited from previous levels -->
1889   <xsl:variable name="ppath">
1890     <xsl:if test="$context/parent::*">
1891       <xsl:call-template name="dbhtml-dir">
1892         <xsl:with-param name="context" select="$context/parent::*"/>
1893       </xsl:call-template>
1894     </xsl:if>
1895   </xsl:variable>
1896   <xsl:variable name="path">
1897     <xsl:call-template name="pi.dbhtml_dir">
1898       <xsl:with-param name="node" select="$context"/>
1899     </xsl:call-template>
1900   </xsl:variable>
1901   <xsl:choose>
1902     <xsl:when test="$path = ''">
1903       <xsl:if test="$ppath != ''">
1904         <xsl:value-of select="$ppath"/>
1905       </xsl:if>
1906     </xsl:when>
1907     <xsl:otherwise>
1908       <xsl:if test="$ppath != ''">
1909         <xsl:value-of select="$ppath"/>
1910         <xsl:if test="substring($ppath, string-length($ppath), 1) != '/'">
1911           <xsl:text>/</xsl:text>
1912         </xsl:if>
1913       </xsl:if>
1914       <xsl:value-of select="$path"/>
1915       <xsl:text>/</xsl:text>
1916     </xsl:otherwise>
1917   </xsl:choose>
1918 </xsl:template>
1919
1920 </xsl:stylesheet>