<tags:xhtmlbasic xmlns:tags="urn:jsptagdir:/WEB-INF/tags"
                 xmlns:jsp="http://java.sun.com/JSP/Page"
                 xmlns:fmt="http://java.sun.com/jsp/jstl/fmt"
		 xmlns="http://www.w3.org/1999/xhtml">
  <jsp:directive.page contentType="text/html" />
  <head>
    <title>JSPX - XHTML Basic Example</title>
  </head>
  <body>
    <h1>JSPX - XHTML Basic Example</h1>
    <hr/>
    This example illustrates how to use JSPX to produce an XHTML basic
    document suitable for use with mobile phones, televisions, 
    PDAs, vending machines, pagers, car navigation systems,
    mobile game machines, digital book readers, smart watches, etc.
    <p/>
    JSPX lets you create dynamic documents in a pure XML syntax compatible
    with existing XML tools.  The XML syntax in JSP 1.2 was awkward and
    required &amp;lt;jsp:root&amp;gt; to be the root element of the document.
    This is no longer the case in JSP 2.0.
    <p/>
    This particular example uses a tag file to produce the DOCTYPE and
    namespace declarations to make the output of this page a valid XHTML
    Basic document.
    <p/>
    Just to prove this is live, here's some dynamic content:
    <jsp:useBean id="now" class="java.util.Date" />
    <fmt:formatDate value="${now}" pattern="MMMM d, yyyy, H:mm:ss"/>
  </body>
</tags:xhtmlbasic>
