Merge branch 'org.openembedded.dev' of git@git.openembedded.net:openembedded into...
[openembedded.git] / docs / usermanual / 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 7833 2008-03-04 19:09:35Z nwalsh $
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="function-available('exsl:node-set')">
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 function-available('exsl:node-set')">
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"/>
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"/>
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="left"/>
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:call-template name="href.target.uri">
1094       <xsl:with-param name="object" select="$context"/>
1095     </xsl:call-template>
1096   </xsl:variable>
1097   <!-- * <xsl:message>toc-context: <xsl:value-of select="local-name($toc-context)"/></xsl:message> -->
1098   <!-- * <xsl:message>node: <xsl:value-of select="local-name(.)"/></xsl:message> -->
1099   <!-- * <xsl:message>context: <xsl:value-of select="local-name($context)"/></xsl:message> -->
1100   <!-- * <xsl:message>object: <xsl:value-of select="local-name($object)"/></xsl:message> -->
1101   <!-- * <xsl:message>toc-output-dir: <xsl:value-of select="$toc-output-dir"/></xsl:message> -->
1102   <!-- * <xsl:message>linked-file-output-dir: <xsl:value-of select="$linked-file-output-dir"/></xsl:message> -->
1103   <!-- * <xsl:message>href.to.uri: <xsl:value-of select="$href.to.uri"/></xsl:message> -->
1104   <!-- * <xsl:message>href.from.uri: <xsl:value-of select="$href.from.uri"/></xsl:message> -->
1105   <xsl:variable name="href.to">
1106     <xsl:choose>
1107       <!-- * 2007-07-19, MikeSmith: Added the following conditional to -->
1108       <!-- * deal with a problem case for links in TOCs. It checks to see -->
1109       <!-- * if the output dir that a TOC will get written to is -->
1110       <!-- * different from the output dir of the file being linked to. -->
1111       <!-- * If it is different, we do not call trim.common.uri.paths. -->
1112       <!-- *  -->
1113       <!-- * Reason why I added that conditional is: I ran into a bug for -->
1114       <!-- * this case: -->
1115       <!-- *  -->
1116       <!-- * 1. we are chunking into separate dirs -->
1117       <!-- *  -->
1118       <!-- * 2. output for the TOC is written to current dir, but the file -->
1119       <!-- *    being linked to is written to some subdir "foo". -->
1120       <!-- *  -->
1121       <!-- * For that case, links to that file in that TOC did not show -->
1122       <!-- * the correct path - they omitted the "foo". -->
1123       <!-- *  -->
1124       <!-- * The cause of that problem was that the trim.common.uri.paths -->
1125       <!-- * template[1] was being called under all conditions. But it's -->
1126       <!-- * apparent that we don't want to call trim.common.uri.paths in -->
1127       <!-- * the case where a linked file is being written to a different -->
1128       <!-- * directory than the TOC that contains the link, because doing -->
1129       <!-- * so will cause a necessary (not redundant) directory-name -->
1130       <!-- * part of the link to get inadvertently trimmed, resulting in -->
1131       <!-- * a broken link to that file. Thus, added the conditional. -->
1132       <!-- *  -->
1133       <!-- * [1] The purpose of the trim.common.uri.paths template is to -->
1134       <!-- * prevent cases where, if we didn't call it, we end up with -->
1135       <!-- * unnecessary, redundant directory names getting output; for -->
1136       <!-- * example, "foo/foo/refname.html". -->
1137       <xsl:when test="not($toc-output-dir = $linked-file-output-dir)">
1138         <xsl:value-of select="$href.to.uri"/>
1139       </xsl:when>
1140       <xsl:otherwise>
1141         <xsl:call-template name="trim.common.uri.paths">
1142           <xsl:with-param name="uriA" select="$href.to.uri"/>
1143           <xsl:with-param name="uriB" select="$href.from.uri"/>
1144           <xsl:with-param name="return" select="'A'"/>
1145         </xsl:call-template>
1146       </xsl:otherwise>
1147     </xsl:choose>
1148   </xsl:variable>
1149   <xsl:variable name="href.from">
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="'B'"/>
1154     </xsl:call-template>
1155   </xsl:variable>
1156   <xsl:variable name="depth">
1157     <xsl:call-template name="count.uri.path.depth">
1158       <xsl:with-param name="filename" select="$href.from"/>
1159     </xsl:call-template>
1160   </xsl:variable>
1161   <xsl:variable name="href">
1162     <xsl:call-template name="copy-string">
1163       <xsl:with-param name="string" select="'../'"/>
1164       <xsl:with-param name="count" select="$depth"/>
1165     </xsl:call-template>
1166     <xsl:value-of select="$href.to"/>
1167   </xsl:variable>
1168   <!--
1169   <xsl:message>
1170     <xsl:text>In </xsl:text>
1171     <xsl:value-of select="name(.)"/>
1172     <xsl:text> (</xsl:text>
1173     <xsl:value-of select="$href.from"/>
1174     <xsl:text>,</xsl:text>
1175     <xsl:value-of select="$depth"/>
1176     <xsl:text>) </xsl:text>
1177     <xsl:value-of select="name($object)"/>
1178     <xsl:text> href=</xsl:text>
1179     <xsl:value-of select="$href"/>
1180   </xsl:message>
1181   -->
1182   <xsl:value-of select="$href"/>
1183 </xsl:template>
1184
1185 <!-- Returns the complete olink href value if found -->
1186 <!-- Must take into account any dbhtml dir of the chunk containing the olink -->
1187 <xsl:template name="make.olink.href">
1188   <xsl:param name="olink.key" select="''"/>
1189   <xsl:param name="target.database"/>
1190
1191   <xsl:if test="$olink.key != ''">
1192     <xsl:variable name="target.href" >
1193       <xsl:for-each select="$target.database" >
1194         <xsl:value-of select="key('targetptr-key', $olink.key)/@href" />
1195       </xsl:for-each>
1196     </xsl:variable>
1197   
1198     <!-- an olink starting point may be in a subdirectory, so need
1199          the "from" reference point to compute a relative path -->
1200
1201     <xsl:variable name="from.href">
1202       <xsl:call-template name="olink.from.uri">
1203         <xsl:with-param name="target.database" select="$target.database"/>
1204         <xsl:with-param name="object" select="."/>
1205         <xsl:with-param name="object.targetdoc" select="$current.docid"/>
1206       </xsl:call-template>
1207     </xsl:variable>
1208
1209     <!-- If the from.href has directory path, then must "../" upward
1210          to document level -->
1211     <xsl:variable name="upward.from.path">
1212       <xsl:call-template name="upward.path">
1213         <xsl:with-param name="path" select="$from.href"/>
1214       </xsl:call-template>
1215     </xsl:variable>
1216
1217     <xsl:variable name="targetdoc">
1218       <xsl:value-of select="substring-before($olink.key, '/')"/>
1219     </xsl:variable>
1220   
1221     <!-- Does the target database use a sitemap? -->
1222     <xsl:variable name="use.sitemap">
1223       <xsl:choose>
1224         <xsl:when test="$target.database//sitemap">1</xsl:when>
1225         <xsl:otherwise>0</xsl:otherwise>
1226       </xsl:choose>
1227     </xsl:variable>
1228   
1229   
1230     <!-- Get the baseuri for this targetptr -->
1231     <xsl:variable name="baseuri" >
1232       <xsl:choose>
1233         <!-- Does the database use a sitemap? -->
1234         <xsl:when test="$use.sitemap != 0" >
1235           <xsl:choose>
1236             <!-- Was current.docid parameter set? -->
1237             <xsl:when test="$current.docid != ''">
1238               <!-- Was it found in the database? -->
1239               <xsl:variable name="currentdoc.key" >
1240                 <xsl:for-each select="$target.database" >
1241                   <xsl:value-of select="key('targetdoc-key',
1242                                         $current.docid)/@targetdoc" />
1243                 </xsl:for-each>
1244               </xsl:variable>
1245               <xsl:choose>
1246                 <xsl:when test="$currentdoc.key != ''">
1247                   <xsl:for-each select="$target.database" >
1248                     <xsl:call-template name="targetpath" >
1249                       <xsl:with-param name="dirnode" 
1250                           select="key('targetdoc-key', $current.docid)/parent::dir"/>
1251                       <xsl:with-param name="targetdoc" select="$targetdoc"/>
1252                     </xsl:call-template>
1253                   </xsl:for-each >
1254                 </xsl:when>
1255                 <xsl:otherwise>
1256                   <xsl:message>
1257                     <xsl:text>Olink error: cannot compute relative </xsl:text>
1258                     <xsl:text>sitemap path because $current.docid '</xsl:text>
1259                     <xsl:value-of select="$current.docid"/>
1260                     <xsl:text>' not found in target database.</xsl:text>
1261                   </xsl:message>
1262                 </xsl:otherwise>
1263               </xsl:choose>
1264             </xsl:when>
1265             <xsl:otherwise>
1266               <xsl:message>
1267                 <xsl:text>Olink warning: cannot compute relative </xsl:text>
1268                 <xsl:text>sitemap path without $current.docid parameter</xsl:text>
1269               </xsl:message>
1270             </xsl:otherwise>
1271           </xsl:choose> 
1272           <!-- In either case, add baseuri from its document entry-->
1273           <xsl:variable name="docbaseuri">
1274             <xsl:for-each select="$target.database" >
1275               <xsl:value-of select="key('targetdoc-key', $targetdoc)/@baseuri" />
1276             </xsl:for-each>
1277           </xsl:variable>
1278           <xsl:if test="$docbaseuri != ''" >
1279             <xsl:value-of select="$docbaseuri"/>
1280           </xsl:if>
1281         </xsl:when>
1282         <!-- No database sitemap in use -->
1283         <xsl:otherwise>
1284           <!-- Just use any baseuri from its document entry -->
1285           <xsl:variable name="docbaseuri">
1286             <xsl:for-each select="$target.database" >
1287               <xsl:value-of select="key('targetdoc-key', $targetdoc)/@baseuri" />
1288             </xsl:for-each>
1289           </xsl:variable>
1290           <xsl:if test="$docbaseuri != ''" >
1291             <xsl:value-of select="$docbaseuri"/>
1292           </xsl:if>
1293         </xsl:otherwise>
1294       </xsl:choose>
1295     </xsl:variable>
1296   
1297     <!-- Form the href information -->
1298     <xsl:if test="not(contains($baseuri, ':'))">
1299       <!-- if not an absolute uri, add upward path from olink chunk -->
1300       <xsl:value-of select="$upward.from.path"/>
1301     </xsl:if>
1302
1303     <xsl:if test="$baseuri != ''">
1304       <xsl:value-of select="$baseuri"/>
1305       <xsl:if test="substring($target.href,1,1) != '#'">
1306         <!--xsl:text>/</xsl:text-->
1307       </xsl:if>
1308     </xsl:if>
1309     <!-- optionally turn off frag for PDF references -->
1310     <xsl:if test="not($insert.olink.pdf.frag = 0 and
1311           translate(substring($baseuri, string-length($baseuri) - 3),
1312                     'PDF', 'pdf') = '.pdf'
1313           and starts-with($target.href, '#') )">
1314       <xsl:value-of select="$target.href"/>
1315     </xsl:if>
1316   </xsl:if>
1317 </xsl:template>
1318
1319 <!-- Computes "../" to reach top -->
1320 <xsl:template name="upward.path">
1321   <xsl:param name="path" select="''"/>
1322   <xsl:choose> 
1323     <!-- Don't bother with absolute uris -->
1324     <xsl:when test="contains($path, ':')"/>
1325     <xsl:when test="starts-with($path, '/')"/>
1326     <xsl:when test="contains($path, '/')">
1327       <xsl:text>../</xsl:text>
1328       <xsl:call-template name="upward.path">
1329         <xsl:with-param name="path" select="substring-after($path, '/')"/>
1330       </xsl:call-template>
1331     </xsl:when>
1332   </xsl:choose>
1333
1334 </xsl:template>
1335
1336 <!-- ==================================================================== -->
1337
1338 <xsl:template name="html.head">
1339   <xsl:param name="prev" select="/foo"/>
1340   <xsl:param name="next" select="/foo"/>
1341   <xsl:variable name="this" select="."/>
1342   <xsl:variable name="home" select="/*[1]"/>
1343   <xsl:variable name="up" select="parent::*"/>
1344
1345   <head>
1346     <xsl:call-template name="system.head.content"/>
1347     <xsl:call-template name="head.content"/>
1348
1349     <xsl:if test="$home">
1350       <link rel="home">
1351         <xsl:attribute name="href">
1352           <xsl:call-template name="href.target">
1353             <xsl:with-param name="object" select="$home"/>
1354           </xsl:call-template>
1355         </xsl:attribute>
1356         <xsl:attribute name="title">
1357           <xsl:apply-templates select="$home"
1358                                mode="object.title.markup.textonly"/>
1359         </xsl:attribute>
1360       </link>
1361     </xsl:if>
1362
1363     <xsl:if test="$up">
1364       <link rel="up">
1365         <xsl:attribute name="href">
1366           <xsl:call-template name="href.target">
1367             <xsl:with-param name="object" select="$up"/>
1368           </xsl:call-template>
1369         </xsl:attribute>
1370         <xsl:attribute name="title">
1371           <xsl:apply-templates select="$up" mode="object.title.markup.textonly"/>
1372         </xsl:attribute>
1373       </link>
1374     </xsl:if>
1375
1376     <xsl:if test="$prev">
1377       <link rel="prev">
1378         <xsl:attribute name="href">
1379           <xsl:call-template name="href.target">
1380             <xsl:with-param name="object" select="$prev"/>
1381           </xsl:call-template>
1382         </xsl:attribute>
1383         <xsl:attribute name="title">
1384           <xsl:apply-templates select="$prev" mode="object.title.markup.textonly"/>
1385         </xsl:attribute>
1386       </link>
1387     </xsl:if>
1388
1389     <xsl:if test="$next">
1390       <link rel="next">
1391         <xsl:attribute name="href">
1392           <xsl:call-template name="href.target">
1393             <xsl:with-param name="object" select="$next"/>
1394           </xsl:call-template>
1395         </xsl:attribute>
1396         <xsl:attribute name="title">
1397           <xsl:apply-templates select="$next" mode="object.title.markup.textonly"/>
1398         </xsl:attribute>
1399       </link>
1400     </xsl:if>
1401
1402     <xsl:if test="$html.extra.head.links != 0">
1403       <xsl:for-each select="//part
1404                             |//reference
1405                             |//preface
1406                             |//chapter
1407                             |//article
1408                             |//refentry
1409                             |//appendix[not(parent::article)]|appendix
1410                             |//glossary[not(parent::article)]|glossary
1411                             |//index[not(parent::article)]|index">
1412         <link rel="{local-name(.)}">
1413           <xsl:attribute name="href">
1414             <xsl:call-template name="href.target">
1415               <xsl:with-param name="context" select="$this"/>
1416               <xsl:with-param name="object" select="."/>
1417             </xsl:call-template>
1418           </xsl:attribute>
1419           <xsl:attribute name="title">
1420             <xsl:apply-templates select="." mode="object.title.markup.textonly"/>
1421           </xsl:attribute>
1422         </link>
1423       </xsl:for-each>
1424
1425       <xsl:for-each select="section|sect1|refsection|refsect1">
1426         <link>
1427           <xsl:attribute name="rel">
1428             <xsl:choose>
1429               <xsl:when test="local-name($this) = 'section'
1430                               or local-name($this) = 'refsection'">
1431                 <xsl:value-of select="'subsection'"/>
1432               </xsl:when>
1433               <xsl:otherwise>
1434                 <xsl:value-of select="'section'"/>
1435               </xsl:otherwise>
1436             </xsl:choose>
1437           </xsl:attribute>
1438           <xsl:attribute name="href">
1439             <xsl:call-template name="href.target">
1440               <xsl:with-param name="context" select="$this"/>
1441               <xsl:with-param name="object" select="."/>
1442             </xsl:call-template>
1443           </xsl:attribute>
1444           <xsl:attribute name="title">
1445             <xsl:apply-templates select="." mode="object.title.markup.textonly"/>
1446           </xsl:attribute>
1447         </link>
1448       </xsl:for-each>
1449
1450       <xsl:for-each select="sect2|sect3|sect4|sect5|refsect2|refsect3">
1451         <link rel="subsection">
1452           <xsl:attribute name="href">
1453             <xsl:call-template name="href.target">
1454               <xsl:with-param name="context" select="$this"/>
1455               <xsl:with-param name="object" select="."/>
1456             </xsl:call-template>
1457           </xsl:attribute>
1458           <xsl:attribute name="title">
1459             <xsl:apply-templates select="." mode="object.title.markup.textonly"/>
1460           </xsl:attribute>
1461         </link>
1462       </xsl:for-each>
1463     </xsl:if>
1464
1465     <!-- * if we have a legalnotice and user wants it output as a -->
1466     <!-- * separate page and $html.head.legalnotice.link.types is -->
1467     <!-- * non-empty, we generate a link or links for each value in -->
1468     <!-- * $html.head.legalnotice.link.types -->
1469     <xsl:if test="//legalnotice
1470                   and not($generate.legalnotice.link = 0)
1471                   and not($html.head.legalnotice.link.types = '')">
1472       <xsl:call-template name="make.legalnotice.head.links"/>
1473     </xsl:if>
1474
1475     <xsl:call-template name="user.head.content"/>
1476   </head>
1477 </xsl:template>
1478
1479 <!-- ==================================================================== -->
1480
1481 <xsl:template name="header.navigation">
1482   <xsl:param name="prev" select="/foo"/>
1483   <xsl:param name="next" select="/foo"/>
1484   <xsl:param name="nav.context"/>
1485
1486   <xsl:variable name="home" select="/*[1]"/>
1487   <xsl:variable name="up" select="parent::*"/>
1488
1489   <xsl:variable name="row1" select="$navig.showtitles != 0"/>
1490   <xsl:variable name="row2" select="count($prev) &gt; 0
1491                                     or (count($up) &gt; 0 
1492                                         and generate-id($up) != generate-id($home)
1493                                         and $navig.showtitles != 0)
1494                                     or count($next) &gt; 0"/>
1495
1496   <xsl:if test="$suppress.navigation = '0' and $suppress.header.navigation = '0'">
1497     <div class="navheader">
1498       <xsl:if test="$row1 or $row2">
1499         <table width="100%" summary="Navigation header">
1500           <xsl:if test="$row1">
1501             <tr>
1502               <th colspan="3" align="center">
1503                 <xsl:apply-templates select="." mode="object.title.markup"/>
1504               </th>
1505             </tr>
1506           </xsl:if>
1507
1508           <xsl:if test="$row2">
1509             <tr>
1510               <td width="20%" align="left">
1511                 <xsl:if test="count($prev)>0">
1512                   <a accesskey="p">
1513                     <xsl:attribute name="href">
1514                       <xsl:call-template name="href.target">
1515                         <xsl:with-param name="object" select="$prev"/>
1516                       </xsl:call-template>
1517                     </xsl:attribute>
1518                     <xsl:call-template name="navig.content">
1519                       <xsl:with-param name="direction" select="'prev'"/>
1520                     </xsl:call-template>
1521                   </a>
1522                 </xsl:if>
1523                 <xsl:text>&#160;</xsl:text>
1524               </td>
1525               <th width="60%" align="center">
1526                 <xsl:choose>
1527                   <xsl:when test="count($up) > 0
1528                                   and generate-id($up) != generate-id($home)
1529                                   and $navig.showtitles != 0">
1530                     <xsl:apply-templates select="$up" mode="object.title.markup"/>
1531                   </xsl:when>
1532                   <xsl:otherwise>&#160;</xsl:otherwise>
1533                 </xsl:choose>
1534               </th>
1535               <td width="20%" align="right">
1536                 <xsl:text>&#160;</xsl:text>
1537                 <xsl:if test="count($next)>0">
1538                   <a accesskey="n">
1539                     <xsl:attribute name="href">
1540                       <xsl:call-template name="href.target">
1541                         <xsl:with-param name="object" select="$next"/>
1542                       </xsl:call-template>
1543                     </xsl:attribute>
1544                     <xsl:call-template name="navig.content">
1545                       <xsl:with-param name="direction" select="'next'"/>
1546                     </xsl:call-template>
1547                   </a>
1548                 </xsl:if>
1549               </td>
1550             </tr>
1551           </xsl:if>
1552         </table>
1553       </xsl:if>
1554       <xsl:if test="$header.rule != 0">
1555         <hr/>
1556       </xsl:if>
1557     </div>
1558   </xsl:if>
1559 </xsl:template>
1560
1561 <!-- ==================================================================== -->
1562
1563 <xsl:template name="footer.navigation">
1564   <xsl:param name="prev" select="/foo"/>
1565   <xsl:param name="next" select="/foo"/>
1566   <xsl:param name="nav.context"/>
1567
1568   <xsl:variable name="home" select="/*[1]"/>
1569   <xsl:variable name="up" select="parent::*"/>
1570
1571   <xsl:variable name="row1" select="count($prev) &gt; 0
1572                                     or count($up) &gt; 0
1573                                     or count($next) &gt; 0"/>
1574
1575   <xsl:variable name="row2" select="($prev and $navig.showtitles != 0)
1576                                     or (generate-id($home) != generate-id(.)
1577                                         or $nav.context = 'toc')
1578                                     or ($chunk.tocs.and.lots != 0
1579                                         and $nav.context != 'toc')
1580                                     or ($next and $navig.showtitles != 0)"/>
1581
1582   <xsl:if test="$suppress.navigation = '0' and $suppress.footer.navigation = '0'">
1583     <div class="navfooter">
1584       <xsl:if test="$footer.rule != 0">
1585         <hr/>
1586       </xsl:if>
1587
1588       <xsl:if test="$row1 or $row2">
1589         <table width="100%" summary="Navigation footer">
1590           <xsl:if test="$row1">
1591             <tr>
1592               <td width="40%" align="left">
1593                 <xsl:if test="count($prev)>0">
1594                   <a accesskey="p">
1595                     <xsl:attribute name="href">
1596                       <xsl:call-template name="href.target">
1597                         <xsl:with-param name="object" select="$prev"/>
1598                       </xsl:call-template>
1599                     </xsl:attribute>
1600                     <xsl:call-template name="navig.content">
1601                       <xsl:with-param name="direction" select="'prev'"/>
1602                     </xsl:call-template>
1603                   </a>
1604                 </xsl:if>
1605                 <xsl:text>&#160;</xsl:text>
1606               </td>
1607               <td width="20%" align="center">
1608                 <xsl:choose>
1609                   <xsl:when test="count($up)&gt;0
1610                                   and generate-id($up) != generate-id($home)">
1611                     <a accesskey="u">
1612                       <xsl:attribute name="href">
1613                         <xsl:call-template name="href.target">
1614                           <xsl:with-param name="object" select="$up"/>
1615                         </xsl:call-template>
1616                       </xsl:attribute>
1617                       <xsl:call-template name="navig.content">
1618                         <xsl:with-param name="direction" select="'up'"/>
1619                       </xsl:call-template>
1620                     </a>
1621                   </xsl:when>
1622                   <xsl:otherwise>&#160;</xsl:otherwise>
1623                 </xsl:choose>
1624               </td>
1625               <td width="40%" align="right">
1626                 <xsl:text>&#160;</xsl:text>
1627                 <xsl:if test="count($next)>0">
1628                   <a accesskey="n">
1629                     <xsl:attribute name="href">
1630                       <xsl:call-template name="href.target">
1631                         <xsl:with-param name="object" select="$next"/>
1632                       </xsl:call-template>
1633                     </xsl:attribute>
1634                     <xsl:call-template name="navig.content">
1635                       <xsl:with-param name="direction" select="'next'"/>
1636                     </xsl:call-template>
1637                   </a>
1638                 </xsl:if>
1639               </td>
1640             </tr>
1641           </xsl:if>
1642
1643           <xsl:if test="$row2">
1644             <tr>
1645               <td width="40%" align="left" valign="top">
1646                 <xsl:if test="$navig.showtitles != 0">
1647                   <xsl:apply-templates select="$prev" mode="object.title.markup"/>
1648                 </xsl:if>
1649                 <xsl:text>&#160;</xsl:text>
1650               </td>
1651               <td width="20%" align="center">
1652                 <xsl:choose>
1653                   <xsl:when test="$home != . or $nav.context = 'toc'">
1654                     <a accesskey="h">
1655                       <xsl:attribute name="href">
1656                         <xsl:call-template name="href.target">
1657                           <xsl:with-param name="object" select="$home"/>
1658                         </xsl:call-template>
1659                       </xsl:attribute>
1660                       <xsl:call-template name="navig.content">
1661                         <xsl:with-param name="direction" select="'home'"/>
1662                       </xsl:call-template>
1663                     </a>
1664                     <xsl:if test="$chunk.tocs.and.lots != 0 and $nav.context != 'toc'">
1665                       <xsl:text>&#160;|&#160;</xsl:text>
1666                     </xsl:if>
1667                   </xsl:when>
1668                   <xsl:otherwise>&#160;</xsl:otherwise>
1669                 </xsl:choose>
1670
1671                 <xsl:if test="$chunk.tocs.and.lots != 0 and $nav.context != 'toc'">
1672                   <a accesskey="t">
1673                     <xsl:attribute name="href">
1674                       <xsl:apply-templates select="/*[1]"
1675                                            mode="recursive-chunk-filename">
1676                         <xsl:with-param name="recursive" select="true()"/>
1677                       </xsl:apply-templates>
1678                       <xsl:text>-toc</xsl:text>
1679                       <xsl:value-of select="$html.ext"/>
1680                     </xsl:attribute>
1681                     <xsl:call-template name="gentext">
1682                       <xsl:with-param name="key" select="'nav-toc'"/>
1683                     </xsl:call-template>
1684                   </a>
1685                 </xsl:if>
1686               </td>
1687               <td width="40%" align="right" valign="top">
1688                 <xsl:text>&#160;</xsl:text>
1689                 <xsl:if test="$navig.showtitles != 0">
1690                   <xsl:apply-templates select="$next" mode="object.title.markup"/>
1691                 </xsl:if>
1692               </td>
1693             </tr>
1694           </xsl:if>
1695         </table>
1696       </xsl:if>
1697     </div>
1698   </xsl:if>
1699 </xsl:template>
1700
1701 <!-- ==================================================================== -->
1702
1703 <xsl:template name="navig.content">
1704     <xsl:param name="direction" select="next"/>
1705     <xsl:variable name="navtext">
1706         <xsl:choose>
1707             <xsl:when test="$direction = 'prev'">
1708                 <xsl:call-template name="gentext.nav.prev"/>
1709             </xsl:when>
1710             <xsl:when test="$direction = 'next'">
1711                 <xsl:call-template name="gentext.nav.next"/>
1712             </xsl:when>
1713             <xsl:when test="$direction = 'up'">
1714                 <xsl:call-template name="gentext.nav.up"/>
1715             </xsl:when>
1716             <xsl:when test="$direction = 'home'">
1717                 <xsl:call-template name="gentext.nav.home"/>
1718             </xsl:when>
1719             <xsl:otherwise>
1720                 <xsl:text>xxx</xsl:text>
1721             </xsl:otherwise>
1722         </xsl:choose>
1723     </xsl:variable>
1724
1725     <xsl:choose>
1726         <xsl:when test="$navig.graphics != 0">
1727             <img>
1728                 <xsl:attribute name="src">
1729                     <xsl:value-of select="$navig.graphics.path"/>
1730                     <xsl:value-of select="$direction"/>
1731                     <xsl:value-of select="$navig.graphics.extension"/>
1732                 </xsl:attribute>
1733                 <xsl:attribute name="alt">
1734                     <xsl:value-of select="$navtext"/>
1735                 </xsl:attribute>
1736             </img>
1737         </xsl:when>
1738         <xsl:otherwise>
1739             <xsl:value-of select="$navtext"/>
1740         </xsl:otherwise>
1741     </xsl:choose>
1742 </xsl:template>
1743
1744 <!-- ==================================================================== -->
1745
1746 <!-- * The following template assumes that the first legalnotice -->
1747 <!-- * instance found in a document applies to the contents of the -->
1748 <!-- * entire document. It generates an HTML link in each chunk, back -->
1749 <!-- * to the file containing the contents of the first legalnotice. -->
1750 <!-- * -->
1751 <!-- * Actually, it may generate multiple link instances in each chunk, -->
1752 <!-- * because it walks through the space-separated list of link -->
1753 <!-- * types specified in the $html.head.legalnotice.link.types param, -->
1754 <!-- * popping off link types and generating links for them until it -->
1755 <!-- * depletes the list. -->
1756   
1757 <xsl:template name="make.legalnotice.head.links">
1758   <!-- * the following ID is used as part of the legalnotice filename; -->
1759   <!-- * we need it in order to construct the filename for use in the -->
1760   <!-- * value of the href attribute on the link -->
1761
1762   <xsl:param name="ln-node" select="(//legalnotice)[1]"/>
1763   
1764   <xsl:param name="linktype">
1765     <xsl:choose>
1766       <xsl:when test="contains($html.head.legalnotice.link.types, ' ')">
1767         <xsl:value-of
1768             select="normalize-space(
1769                     substring-before($html.head.legalnotice.link.types, ' '))"/>
1770       </xsl:when>
1771       <xsl:otherwise>
1772         <xsl:value-of select="$html.head.legalnotice.link.types"/>
1773       </xsl:otherwise>
1774     </xsl:choose>
1775   </xsl:param>
1776   <xsl:param
1777       name="remaining.linktypes"
1778       select="concat(
1779               normalize-space(
1780               substring-after($html.head.legalnotice.link.types, ' ')),' ')"/>
1781   <xsl:if test="not($linktype = '')">
1782
1783     <!-- Compute name of legalnotice file (see titlepage.xsl) -->
1784     <xsl:variable name="file">
1785       <xsl:call-template name="ln.or.rh.filename">
1786         <xsl:with-param name="node" select="$ln-node"/>
1787       </xsl:call-template>
1788     </xsl:variable>
1789    
1790     <link rel="{$linktype}">
1791       <xsl:attribute name="href">
1792         <xsl:value-of select="$file"/>
1793       </xsl:attribute>
1794       <xsl:attribute name="title">
1795         <xsl:apply-templates select="(//legalnotice)[1]"
1796                              mode="object.title.markup.textonly"/>
1797       </xsl:attribute>
1798     </link>
1799     <xsl:call-template name="make.legalnotice.head.links">
1800       <!-- * pop the next value off the list of link types -->
1801       <xsl:with-param
1802           name="linktype"
1803           select="substring-before($remaining.linktypes, ' ')"/>
1804       <!-- * remove the link type from the list of remaining link types -->
1805       <xsl:with-param
1806           name="remaining.linktypes"
1807           select="substring-after($remaining.linktypes, ' ')"/>
1808     </xsl:call-template>
1809   </xsl:if>
1810 </xsl:template>
1811
1812 <!-- ==================================================================== -->
1813 <xsl:template name="chunk-element-content">
1814   <xsl:param name="prev"/>
1815   <xsl:param name="next"/>
1816   <xsl:param name="nav.context"/>
1817   <xsl:param name="content">
1818     <xsl:apply-imports/>
1819   </xsl:param>
1820
1821   <xsl:call-template name="user.preroot"/>
1822
1823   <html>
1824     <xsl:call-template name="html.head">
1825       <xsl:with-param name="prev" select="$prev"/>
1826       <xsl:with-param name="next" select="$next"/>
1827     </xsl:call-template>
1828
1829     <body>
1830       <xsl:call-template name="body.attributes"/>
1831       <xsl:call-template name="user.header.navigation"/>
1832
1833       <xsl:call-template name="header.navigation">
1834         <xsl:with-param name="prev" select="$prev"/>
1835         <xsl:with-param name="next" select="$next"/>
1836         <xsl:with-param name="nav.context" select="$nav.context"/>
1837       </xsl:call-template>
1838
1839       <xsl:call-template name="user.header.content"/>
1840
1841       <xsl:copy-of select="$content"/>
1842
1843       <xsl:call-template name="user.footer.content"/>
1844
1845       <xsl:call-template name="footer.navigation">
1846         <xsl:with-param name="prev" select="$prev"/>
1847         <xsl:with-param name="next" select="$next"/>
1848         <xsl:with-param name="nav.context" select="$nav.context"/>
1849       </xsl:call-template>
1850
1851       <xsl:call-template name="user.footer.navigation"/>
1852     </body>
1853   </html>
1854   <xsl:value-of select="$chunk.append"/>
1855 </xsl:template>
1856
1857 <!-- ==================================================================== -->
1858 <xsl:template name="generate.manifest">
1859   <xsl:param name="node" select="/"/>
1860   <xsl:call-template name="write.text.chunk">
1861     <xsl:with-param name="filename">
1862       <xsl:if test="$manifest.in.base.dir != 0">
1863         <xsl:value-of select="$base.dir"/>
1864       </xsl:if>
1865       <xsl:value-of select="$manifest"/>
1866     </xsl:with-param>
1867     <xsl:with-param name="method" select="'text'"/>
1868     <xsl:with-param name="content">
1869       <xsl:apply-templates select="$node" mode="enumerate-files"/>
1870     </xsl:with-param>
1871     <xsl:with-param name="encoding" select="$chunker.output.encoding"/>
1872   </xsl:call-template>
1873 </xsl:template>
1874
1875 <!-- ==================================================================== -->
1876
1877 <xsl:template name="dbhtml-dir">
1878   <xsl:param name="context" select="."/>
1879   <!-- directories are now inherited from previous levels -->
1880   <xsl:variable name="ppath">
1881     <xsl:if test="$context/parent::*">
1882       <xsl:call-template name="dbhtml-dir">
1883         <xsl:with-param name="context" select="$context/parent::*"/>
1884       </xsl:call-template>
1885     </xsl:if>
1886   </xsl:variable>
1887   <xsl:variable name="path">
1888     <xsl:call-template name="pi.dbhtml_dir">
1889       <xsl:with-param name="node" select="$context"/>
1890     </xsl:call-template>
1891   </xsl:variable>
1892   <xsl:choose>
1893     <xsl:when test="$path = ''">
1894       <xsl:if test="$ppath != ''">
1895         <xsl:value-of select="$ppath"/>
1896       </xsl:if>
1897     </xsl:when>
1898     <xsl:otherwise>
1899       <xsl:if test="$ppath != ''">
1900         <xsl:value-of select="$ppath"/>
1901         <xsl:if test="substring($ppath, string-length($ppath), 1) != '/'">
1902           <xsl:text>/</xsl:text>
1903         </xsl:if>
1904       </xsl:if>
1905       <xsl:value-of select="$path"/>
1906       <xsl:text>/</xsl:text>
1907     </xsl:otherwise>
1908   </xsl:choose>
1909 </xsl:template>
1910
1911 </xsl:stylesheet>