Although you can specify a CSS stylesheet by using the html.stylesheet parameter, you may want to supplement it with additional CSS style rules in the head element. To do so, you can output an HTML style element using either the user.head.content template or the system.head.content template. The following example shows how to do it.

<xsl:template name="user.head.content">
  <style type="text/css">
    <xsl:comment>
      @import "stylesheets/override.css"
      body {background: url(graphics/bluesea.png);}
    </xsl:comment>
  </style>
</xsl:template>

This results in the following output in the HTML head element:

<style type="text/css">
  <!--
    @import "stylesheets/override.css"
    body {background: url(graphics/bluesea.png);}
  -->
</style>
 

Using the user.head.content template means these style rules will appear after the CSS stylesheet specified in html.stylesheet, so they will have higher CSS precedence. Using system.head.content instead means these style rules will appear before any other content in head, and so will have lower CSS precendence and can be overriden by rules in the file specified by html.stylesheet.

Instead of referring to an external CSS stylesheet, you may want to embed the CSS styles in your HTML output. That makes the HTML files more portable, since they no longer are dependent on a separate CSS file. You can make use of the placeholder template user.head.content as described in the following steps:

You can add a date-of-processing timestamp in a META tag in your HTML HEAD output. This example uses an EXSLT extension function named date-time() that reads the system clock and generates a date timestamp at the moment the process is run. Not all XSLT processors support EXSLT functions, but Saxon, Xalan, and xsltproc do.

To add a date timestamp to your output, add a call to the extension function to the user.head.content template in your customization layer. You will also have to add a couple of attributes to the xsl:stylesheet element itself in order to identify the namespace used by the extension function. The following annotated example shows what needs to be done.

Example 11.1. Timestamp in meta element

<?xml version="1.0"?>
<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
                xmlns:date="http://exslt.org/dates-and-times"  
                exclude-result-prefixes="date"  
                version='1.0'>

<xsl:import href="../docbook-xsl-1.68.1/html/docbook.xsl"/>

<xsl:template name="user.head.content">  
  <meta name="date">  
    <xsl:attribute name="content">  
      <xsl:call-template name="datetime.format">  
        <xsl:with-param name="date" select="date:date-time()"/>  
        <xsl:with-param name="format" select="'m/d/Y'"/>  
      </xsl:call-template>
    </xsl:attribute>
  </meta>
</xsl:template>

...

	You have to add the xmlns:date namespace declaration to the customization layer's xsl:stylesheet element.
	Also add an exclude-result-prefixes attribute so the namespace doesn't appear in the HTML output.
	The user.head.content template is an empty placeholder template in the stylesheets to be filled in by the customizer.
	Start an HTML META element and give it a name="date" attribute.
	Start the addition of a content attribute on the META element.
	Call the stylesheet template datetime.format to generate the content attribute's value. That template is located in common/pi.xsl.
	Pass the template a date parameter whose value is generated by the EXSLT date-time() function. The date: prefix ensures that this function call is not confused with the built-in XSLT functions.
	Pass the template a format parameter whose value is a string of date and time component letters. The string must be enclosed in single quotes, or it will be misinterpreted as a document node resulting in a blank date output. These component letters are listed in the section “Date and time”. You can use whatever format you desire.

This example customization results in the following HTML output:

<meta name="date" content="03/10/2005">

This customization uses the datetime extension feature that is described in more detail in the section “Date and time”.

In some website setups, such as those that use Java ServerPages, HTML content is stored in modular pieces without HTML HEAD elements. The HTTP server is responsible for assembling a complete HTML file by dynamically adding a HEAD element. That makes it possible for the server to customize the output for each request. In other setups, the content files also have the HTML and BODY tags removed. Such content can be combined from several files by the server, which also dynamically adds the HTML, HEAD, and BODY tags.

If you want to generate such modular output, you will need to customize the template that generates the HTML wrapper elements. If you are using the nonchunking stylesheet, you want to customize the process.root template in html/docbook.xsl. If you are using the chunking stylesheet, you need customize the chunk-element-content template in html/chunk-common.xsl.

In both cases, you want to eliminate all those parts of the template that output the HTML elements you don't want. If you want to eliminate just the HEAD, then remove the literal <head> and </head> tags and their content. If you want completely bare content, then remove the <html>, <head>, and <body> tags, as well as the template calls that fill the <head> element and generate the header and footer. There won't be much left. For example, process.root could end up looking like this:

<xsl:template match="*" mode="process.root">
  <xsl:call-template name="root.messages"/>
  <xsl:apply-templates select="."/>
</xsl:template>